X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONRecoCheck.cxx;h=68e51e182989eed6b0bf10b96fa37e8f09993a13;hb=fc179f1702342af92f3d93cc28e46ed9a44bc67e;hp=91f40ff8e254058c7369ce3aecddd85a0a4eaec9;hpb=c59f70b9ad722c1e7bd4fa9b2162928808e6cd96;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUONRecoCheck.cxx b/MUON/AliMUONRecoCheck.cxx index 91f40ff8e25..68e51e18298 100644 --- a/MUON/AliMUONRecoCheck.cxx +++ b/MUON/AliMUONRecoCheck.cxx @@ -31,6 +31,7 @@ // 25 Jan 2008: // Use the new ESDInterface to create MUON objects from ESD data // - Philippe Pillot +// #include "AliMUONRecoCheck.h" #include "AliMUONTrack.h" @@ -39,6 +40,9 @@ #include "AliMUONVClusterStore.h" #include "AliMUONConstants.h" #include "AliMUONESDInterface.h" +#include "AliMUONTrackParam.h" +#include "AliMUONTriggerTrack.h" +#include "AliMUONVTriggerTrackStore.h" #include "AliMCEventHandler.h" #include "AliMCEvent.h" #include "AliStack.h" @@ -47,18 +51,31 @@ #include "AliESDEvent.h" #include "AliESDMuonTrack.h" +#include "AliGeomManager.h" +#include "AliMpCDB.h" +#include "AliMpDDLStore.h" +#include "AliMUONCDB.h" +#include "AliMUONGeometryTransformer.h" +#include "AliMUONTriggerCircuit.h" +#include "AliMUONVTrackReconstructor.h" +#include "AliMUONVTriggerStore.h" + +#include "TGeoManager.h" + #include #include #include #include #include +#include "AliMUONRecoCheck.h" + /// \cond CLASSIMP ClassImp(AliMUONRecoCheck) /// \endcond //_____________________________________________________________________________ -AliMUONRecoCheck::AliMUONRecoCheck(Char_t *esdFileName, Char_t *pathSim) +AliMUONRecoCheck::AliMUONRecoCheck(const Char_t *esdFileName, const Char_t *pathSim) : TObject(), fMCEventHandler(new AliMCEventHandler()), fESDEvent(new AliESDEvent()), @@ -67,7 +84,12 @@ fESDFile (0x0), fCurrentEvent(0), fTrackRefStore(0x0), fRecoTrackRefStore(0x0), -fRecoTrackStore(0x0) +fRecoTriggerRefStore(0x0), +fRecoTrackStore(0x0), +fRecoTriggerTrackStore(0x0), +fGeometryTransformer(0x0), +fTriggerCircuit(0x0), +fESDEventOwner(kTRUE) { /// Normal ctor @@ -92,14 +114,44 @@ fRecoTrackStore(0x0) fESDEvent->ReadFromTree(fESDTree); // link fESDEvent to the tree } +//_____________________________________________________________________________ +AliMUONRecoCheck::AliMUONRecoCheck(AliESDEvent *esdEvent, AliMCEventHandler *mcEventHandler) +: TObject(), +fMCEventHandler(0), +fESDEvent(0), +fESDTree (0x0), +fESDFile (0x0), +fCurrentEvent(0), +fTrackRefStore(0x0), +fRecoTrackRefStore(0x0), +fRecoTriggerRefStore(0x0), +fRecoTrackStore(0x0), +fRecoTriggerTrackStore(0x0), +fGeometryTransformer(0x0), +fTriggerCircuit(0x0), +fESDEventOwner(kFALSE) +{ + /// Normal ctor + + // TrackRefs and Particules + fMCEventHandler = mcEventHandler; + + // ESD MUON Tracks + fESDEvent = esdEvent; +} + //_____________________________________________________________________________ AliMUONRecoCheck::~AliMUONRecoCheck() { /// Destructor - delete fMCEventHandler; - delete fESDEvent; - if (fESDFile) fESDFile->Close(); + if (fESDEventOwner) { + delete fMCEventHandler; + delete fESDEvent; + if (fESDFile) fESDFile->Close(); + } ResetStores(); + delete fGeometryTransformer; + delete fTriggerCircuit; } //_____________________________________________________________________________ @@ -108,22 +160,74 @@ void AliMUONRecoCheck::ResetStores() /// Deletes all the store objects that have been created and resets the pointers to 0x0 delete fTrackRefStore; fTrackRefStore = 0x0; delete fRecoTrackRefStore; fRecoTrackRefStore = 0x0; + delete fRecoTriggerRefStore; fRecoTriggerRefStore = 0x0; delete fRecoTrackStore; fRecoTrackStore = 0x0; + delete fRecoTriggerTrackStore; fRecoTriggerTrackStore = 0x0; +} + +//_____________________________________________________________________________ +Bool_t AliMUONRecoCheck::InitCircuit() +{ + + if ( fTriggerCircuit ) return kTRUE; + + if ( !AliMUONCDB::CheckOCDB() ) return kFALSE; + + if ( !AliGeomManager::GetGeometry() ) + AliGeomManager::LoadGeometry(); + + if ( !AliMpDDLStore::Instance(false) ) + AliMpCDB::LoadDDLStore(); + + fGeometryTransformer = new AliMUONGeometryTransformer(); + fGeometryTransformer->LoadGeometryData(); + + fTriggerCircuit = new AliMUONTriggerCircuit(fGeometryTransformer); + + // reset tracker for local trigger to trigger track conversion + if ( ! AliMUONESDInterface::GetTracker() ) + AliMUONESDInterface::ResetTracker(); + + return kTRUE; +} + + +//_____________________________________________________________________________ +Int_t AliMUONRecoCheck::GetRunNumber() +{ + /// Return the run number of the current ESD event + + if (fESDEventOwner && fRecoTrackStore == 0x0 && fRecoTriggerTrackStore == 0x0) { + if (!fESDTree || fESDTree->GetEvent(fCurrentEvent) <= 0) { + AliError(Form("fails to read ESD object for event %d: cannot get the run number",fCurrentEvent)); + return -1; + } + } + + return fESDEvent->GetRunNumber(); } //_____________________________________________________________________________ Int_t AliMUONRecoCheck::NumberOfEvents() const { /// Return the number of events - if (fESDTree) return fESDTree->GetEntries(); + if (fESDEventOwner && fESDTree) return fESDTree->GetEntries(); return 0; } //_____________________________________________________________________________ -AliMUONVTrackStore* AliMUONRecoCheck::ReconstructedTracks(Int_t event) +AliMUONVTrackStore* AliMUONRecoCheck::ReconstructedTracks(Int_t event, Bool_t refit) { /// Return a track store containing the reconstructed tracks (converted into - /// MUONTrack objects) for a given event + /// MUONTrack objects) for a given event. + /// Track parameters at each clusters are computed or not depending on the flag "refit". + /// If not, only the track parameters at first cluster are valid. + + if (!fESDEventOwner) { + if (fRecoTrackStore == 0x0) MakeReconstructedTracks(refit); + return fRecoTrackStore; + } + if (event != fCurrentEvent) { ResetStores(); fCurrentEvent = event; @@ -136,16 +240,52 @@ AliMUONVTrackStore* AliMUONRecoCheck::ReconstructedTracks(Int_t event) AliError(Form("fails to read ESD object for event %d", event)); return 0x0; } - MakeReconstructedTracks(); + MakeReconstructedTracks(refit); return fRecoTrackStore; } } + +//_____________________________________________________________________________ +AliMUONVTriggerTrackStore* AliMUONRecoCheck::TriggeredTracks(Int_t event) +{ + /// Return a track store containing the reconstructed trigger tracks (converted into + /// MUONTriggerTrack objects) for a given event. + + if (!fESDEventOwner) { + if (fRecoTriggerTrackStore == 0x0) MakeTriggeredTracks(); + return fRecoTriggerTrackStore; + } + + if (event != fCurrentEvent) { + ResetStores(); + fCurrentEvent = event; + } + + if (fRecoTriggerTrackStore != 0x0) return fRecoTriggerTrackStore; + else { + if (!fESDTree) return 0x0; + if (fESDTree->GetEvent(event) <= 0) { + AliError(Form("fails to read ESD object for event %d", event)); + return 0x0; + } + MakeTriggeredTracks(); + return fRecoTriggerTrackStore; + } +} + + //_____________________________________________________________________________ AliMUONVTrackStore* AliMUONRecoCheck::TrackRefs(Int_t event) { /// Return a track store containing the track references (converted into /// MUONTrack objects) for a given event + + if (!fESDEventOwner) { + if (fTrackRefStore == 0x0) MakeTrackRefs(); + return fTrackRefStore; + } + if (event != fCurrentEvent) { ResetStores(); fCurrentEvent = event; @@ -153,7 +293,7 @@ AliMUONVTrackStore* AliMUONRecoCheck::TrackRefs(Int_t event) if (fTrackRefStore != 0x0) return fTrackRefStore; else { - if (!fMCEventHandler->GetEvent(event)) { + if (!fMCEventHandler->LoadEvent(event)) { AliError(Form("fails to read MC objects for event %d", event)); return 0x0; } @@ -163,9 +303,47 @@ AliMUONVTrackStore* AliMUONRecoCheck::TrackRefs(Int_t event) } //_____________________________________________________________________________ -AliMUONVTrackStore* AliMUONRecoCheck::ReconstructibleTracks(Int_t event) +AliMUONVTriggerTrackStore* AliMUONRecoCheck::TriggerableTracks(Int_t event) +{ + /// Return a trigger track store containing the triggerable track references (converted into + /// AliMUONTriggerTrack objects) for a given event + + if (!fESDEventOwner) { + if (fRecoTriggerRefStore == 0x0) MakeTriggerableTracks(); + return fRecoTriggerRefStore; + } + + if (event != fCurrentEvent) { + ResetStores(); + fCurrentEvent = event; + } + + if (fRecoTriggerRefStore != 0x0) return fRecoTriggerRefStore; + else { + if (!fMCEventHandler->LoadEvent(event)) { + AliError(Form("fails to read MC objects for event %d", event)); + return 0x0; + } + MakeTriggerableTracks(); + return fRecoTriggerRefStore; + } +} + + +//_____________________________________________________________________________ +AliMUONVTrackStore* AliMUONRecoCheck::ReconstructibleTracks(Int_t event, UInt_t requestedStationMask, Bool_t request2ChInSameSt45) { - /// Return a track store containing the reconstructible tracks for a given event + /// Return a track store containing the reconstructible tracks for a given event, + /// according to the mask of requested stations and the minimum number of chambers hit in stations 4 & 5. + + if (!fESDEventOwner) { + if (fRecoTrackRefStore == 0x0) { + if (TrackRefs(event) == 0x0) return 0x0; + MakeReconstructibleTracks(requestedStationMask, request2ChInSameSt45); + } + return fRecoTrackRefStore; + } + if (event != fCurrentEvent) { ResetStores(); fCurrentEvent = event; @@ -174,13 +352,14 @@ AliMUONVTrackStore* AliMUONRecoCheck::ReconstructibleTracks(Int_t event) if (fRecoTrackRefStore != 0x0) return fRecoTrackRefStore; else { if (TrackRefs(event) == 0x0) return 0x0; - MakeReconstructibleTracks(); + MakeReconstructibleTracks(requestedStationMask, request2ChInSameSt45); return fRecoTrackRefStore; } } + //_____________________________________________________________________________ -void AliMUONRecoCheck::MakeReconstructedTracks() +void AliMUONRecoCheck::MakeReconstructedTracks(Bool_t refit) { /// Make reconstructed tracks if (!(fRecoTrackStore = AliMUONESDInterface::NewTrackStore())) return; @@ -189,11 +368,46 @@ void AliMUONRecoCheck::MakeReconstructedTracks() Int_t nTracks = (Int_t) fESDEvent->GetNumberOfMuonTracks(); for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) { AliESDMuonTrack* esdTrack = fESDEvent->GetMuonTrack(iTrack); - if (esdTrack->ContainTrackerData()) AliMUONESDInterface::Add(*esdTrack, *fRecoTrackStore); + if (esdTrack->ContainTrackerData()) AliMUONESDInterface::Add(*esdTrack, *fRecoTrackStore, refit); } } + +//_____________________________________________________________________________ +void AliMUONRecoCheck::MakeTriggeredTracks() +{ + /// Make reconstructed trigger tracks + if (!(fRecoTriggerTrackStore = AliMUONESDInterface::NewTriggerTrackStore())) return; + + AliMUONVTriggerStore* tmpTriggerStore = AliMUONESDInterface::NewTriggerStore(); + if ( ! tmpTriggerStore ) return; + + // loop over all reconstructed tracks and add them to the store (include ghosts) + Int_t nTracks = (Int_t) fESDEvent->GetNumberOfMuonTracks(); + for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) { + AliESDMuonTrack* esdTrack = fESDEvent->GetMuonTrack(iTrack); + if (esdTrack->ContainTriggerData()) AliMUONESDInterface::Add(*esdTrack, *tmpTriggerStore); + } + + if ( ! InitCircuit() ) return; + + AliMUONVTrackReconstructor* tracker = AliMUONESDInterface::GetTracker(); + tracker->EventReconstructTrigger(*fTriggerCircuit, *tmpTriggerStore, *fRecoTriggerTrackStore); + + delete tmpTriggerStore; +} + +//_____________________________________________________________________________ +void AliMUONRecoCheck::TriggerToTrack(const AliMUONLocalTrigger& locTrg, AliMUONTriggerTrack& triggerTrack) +{ + /// Make trigger track from local trigger info + if ( ! InitCircuit() ) return; + AliMUONVTrackReconstructor* tracker = AliMUONESDInterface::GetTracker(); + tracker->TriggerToTrack(*fTriggerCircuit, locTrg, triggerTrack); +} + + //_____________________________________________________________________________ void AliMUONRecoCheck::MakeTrackRefs() { @@ -308,7 +522,7 @@ void AliMUONRecoCheck::MakeTrackRefs() track.SetTrackParamAtVertex(&trackParamAtVertex); // store the track - track.SetTrackID(iTrackRef); + track.SetUniqueID(iTrackRef); tmpTrackRefStore->Add(track); } @@ -319,6 +533,74 @@ void AliMUONRecoCheck::MakeTrackRefs() delete tmpTrackRefStore; } +//_____________________________________________________________________________ +void AliMUONRecoCheck::MakeTriggerableTracks() +{ + /// Make triggerable tracks + if (!(fRecoTriggerRefStore = AliMUONESDInterface::NewTriggerTrackStore())) + return; + + Double_t x, y, z, slopeX, slopeY, pZ; + TParticle* particle; + TClonesArray* trackRefs; + Int_t nTrackRef = fMCEventHandler->MCEvent()->GetNumberOfTracks(); + + // loop over simulated tracks + for (Int_t iTrackRef = 0; iTrackRef < nTrackRef; ++iTrackRef) { + Int_t nHits = fMCEventHandler->GetParticleAndTR(iTrackRef, particle, trackRefs); + + // skip empty trackRefs + if (nHits < 1) continue; + + AliMUONTriggerTrack track; + Int_t hitsOnTrigger = 0; + Int_t currCh = -1; + + // loop over simulated track hits + for (Int_t iHit = 0; iHit < nHits; ++iHit) { + AliTrackReference* trackReference = static_cast(trackRefs->UncheckedAt(iHit)); + + // skip trackRefs not in MUON + if (trackReference->DetectorId() != AliTrackReference::kMUON) continue; + + // check chamberId of current trackReference + Int_t detElemId = trackReference->UserId(); + Int_t chamberId = detElemId / 100 - 1; + if (chamberId < AliMUONConstants::NTrackingCh() || chamberId >= AliMUONConstants::NCh() ) continue; + + + if ( hitsOnTrigger == 0 ) { + // Get track parameters of current hit + x = trackReference->X(); + y = trackReference->Y(); + z = trackReference->Z(); + pZ = trackReference->Pz(); + slopeX = ( pZ == 0. ) ? 99999. : trackReference->Px() / pZ; + slopeY = ( pZ == 0. ) ? 99999. : trackReference->Py() / pZ; + + track.SetX11(x); + track.SetY11(y); + track.SetZ11(z); + track.SetSlopeX(slopeX); + track.SetSlopeY(slopeY); + } + + if ( currCh != chamberId ) { + hitsOnTrigger++; + currCh = chamberId; + } + + } // loop on hits + + if ( hitsOnTrigger >= 3 ){ + // store the track + track.SetUniqueID(iTrackRef); + fRecoTriggerRefStore->Add(track); + } + } +} + + //_____________________________________________________________________________ void AliMUONRecoCheck::CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefStore) { @@ -425,7 +707,7 @@ void AliMUONRecoCheck::CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefSt iHit1++; } - newTrack.SetTrackID(track->GetTrackID()); + newTrack.SetUniqueID(track->GetUniqueID()); newTrack.SetTrackParamAtVertex(track->GetTrackParamAtVertex()); fTrackRefStore->Add(newTrack); @@ -436,7 +718,7 @@ void AliMUONRecoCheck::CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefSt } //_____________________________________________________________________________ -void AliMUONRecoCheck::MakeReconstructibleTracks() +void AliMUONRecoCheck::MakeReconstructibleTracks(UInt_t requestedStationMask, Bool_t request2ChInSameSt45) { /// Isolate the reconstructible tracks if (!(fRecoTrackRefStore = AliMUONESDInterface::NewTrackStore())) return; @@ -444,36 +726,85 @@ void AliMUONRecoCheck::MakeReconstructibleTracks() // create iterator on trackRef TIter next(fTrackRefStore->CreateIterator()); - // loop over trackRef + // loop over trackRef and add reconstructible tracks to fRecoTrackRefStore AliMUONTrack* track; while ( ( track = static_cast(next()) ) ) { + if (track->IsValid(requestedStationMask, request2ChInSameSt45)) fRecoTrackRefStore->Add(*track); + } + +} + +//_____________________________________________________________________________ +AliMUONTrack* AliMUONRecoCheck::FindCompatibleTrack(AliMUONTrack &track, AliMUONVTrackStore &trackStore, + Int_t &nMatchClusters, Bool_t useLabel, Double_t sigmaCut) +{ + /// Return the track from the store matched with the given track (or 0x0) and the number of matched clusters. + /// Matching is done by using the MC label of by comparing cluster/TrackRef positions according to the flag "useLabel". + /// WARNING: Who match who matters since the matching algorithm uses the *fraction* of matched clusters of the given track + + AliMUONTrack *matchedTrack = 0x0; + nMatchClusters = 0; + + if (useLabel) { // by using the MC label - Bool_t* chamberInTrack = new Bool_t(AliMUONConstants::NTrackingCh()); - for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) chamberInTrack[iCh] = kFALSE; + // get the corresponding simulated track if any + Int_t label = track.GetMCLabel(); + matchedTrack = (AliMUONTrack*) trackStore.FindObject(label); - // loop over trackRef's hits to get hit chambers - Int_t nTrackHits = track->GetNClusters(); - for (Int_t iHit = 0; iHit < nTrackHits; iHit++) { - AliMUONVCluster* hit = ((AliMUONTrackParam*) track->GetTrackParamAtCluster()->UncheckedAt(iHit))->GetClusterPtr(); - chamberInTrack[hit->GetChamberId()] = kTRUE; - } + // get the fraction of matched clusters + if (matchedTrack) { + Int_t nClusters = track.GetNClusters(); + for (Int_t iCl = 0; iCl < nClusters; iCl++) + if (((AliMUONTrackParam*) track.GetTrackParamAtCluster()->UncheckedAt(iCl))->GetClusterPtr()->GetMCLabel() == label) + nMatchClusters++; + } - // track is reconstructible if the particle is depositing a hit - // in the following chamber combinations: - Bool_t trackOK = kTRUE; - if (!chamberInTrack[0] && !chamberInTrack[1]) trackOK = kFALSE; - if (!chamberInTrack[2] && !chamberInTrack[3]) trackOK = kFALSE; - if (!chamberInTrack[4] && !chamberInTrack[5]) trackOK = kFALSE; - Int_t nHitsInLastStations = 0; - for (Int_t iCh = 6; iCh < AliMUONConstants::NTrackingCh(); iCh++) - if (chamberInTrack[iCh]) nHitsInLastStations++; - if(nHitsInLastStations < 3) trackOK = kFALSE; + } else { // by comparing cluster/TrackRef positions - // Add reconstructible tracks to fRecoTrackRefStore - if (trackOK) fRecoTrackRefStore->Add(*track); + // look for the corresponding simulated track if any + TIter next(trackStore.CreateIterator()); + AliMUONTrack* track2; + while ( ( track2 = static_cast(next()) ) ) { + + // check compatibility + Int_t n = 0; + if (track.Match(*track2, sigmaCut, n)) { + matchedTrack = track2; + nMatchClusters = n; + break; + } + + } - delete [] chamberInTrack; } + + return matchedTrack; + +} + +//_____________________________________________________________________________ +AliMUONTriggerTrack* AliMUONRecoCheck::FindCompatibleTrack(AliMUONTriggerTrack &track, const AliMUONVTriggerTrackStore &triggerTrackStore, + Double_t sigmaCut) +{ + /// Return the trigger track from the store matched with the given track (or 0x0). + /// Matching is done by comparing cluster/TrackRef positions. + + AliMUONTriggerTrack *matchedTrack = 0x0; + + // look for the corresponding simulated track if any + TIter next(triggerTrackStore.CreateIterator()); + AliMUONTriggerTrack* track2; + while ( ( track2 = static_cast(next()) ) ) { + + // check compatibility + if (track.Match(*track2, sigmaCut)) { + matchedTrack = track2; + break; + } + } + + return matchedTrack; + }