X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;ds=sidebyside;f=MUON%2FAliMUONTracker.cxx;h=8f833d5b993301df10194122454e600249df7e21;hb=f5a4613950af693fe3394e3ec84b32a2d4e47260;hp=0ea93743c357831e7aa4ebf264aa33c81c021c3f;hpb=32ab62c9364d23f845ff3bd58f186946a9f4f381;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUONTracker.cxx b/MUON/AliMUONTracker.cxx index 0ea93743c35..8f833d5b993 100644 --- a/MUON/AliMUONTracker.cxx +++ b/MUON/AliMUONTracker.cxx @@ -13,21 +13,34 @@ * provided "as is" without express or implied warranty. * **************************************************************************/ +/* $Id$ */ + +//----------------------------------------------------------------------------- /// \class AliMUONTracker /// /// Steering class for use in global tracking framework; /// reconstruct tracks from recpoints /// /// Actual tracking is performed by some AliMUONVTrackReconstructor children +/// Tracking modes (ORIGINAL, KALMAN) and associated options and parameters can be changed +/// through the AliMUONRecoParam object set in the reconstruction macro or read from the CDB +/// (see methods in AliMUONRecoParam.h file for details) /// /// \author Christian Finck and Laurent Aphecetche, SUBATECH Nantes +//----------------------------------------------------------------------------- #include "AliMUONTracker.h" -#include "AliESD.h" +#include "AliCodeTimer.h" +#include "AliESDEvent.h" #include "AliESDMuonTrack.h" #include "AliESDVertex.h" -#include "AliLoader.h" +#include "AliLog.h" +#include "AliMUONClusterStoreV2.h" +#include "AliMUONESDInterface.h" +#include "AliMUONLegacyClusterServer.h" +#include "AliMUONRecoParam.h" +#include "AliMUONReconstructor.h" #include "AliMUONTrack.h" #include "AliMUONTrackExtrap.h" #include "AliMUONTrackHitPattern.h" @@ -36,31 +49,58 @@ #include "AliMUONTrackReconstructorK.h" #include "AliMUONTrackStoreV1.h" #include "AliMUONTriggerTrackStoreV1.h" -#include "AliMUONVClusterStore.h" +#include "AliMUONTriggerTrack.h" +#include "AliMUONLocalTrigger.h" +#include "AliMUONVClusterServer.h" +#include "AliMUONVDigitStore.h" #include "AliMUONVTriggerStore.h" +#include "AliMUONDigitMaker.h" #include +#include #include -#include "AliLog.h" + +/// \cond CLASSIMP +ClassImp(AliMUONTracker) +/// \endcond + //_____________________________________________________________________________ -AliMUONTracker::AliMUONTracker(AliLoader* loader, +AliMUONTracker::AliMUONTracker(const AliMUONRecoParam* recoParam, + AliMUONVClusterServer* clusterServer, + AliMUONVDigitStore& digitStore, const AliMUONDigitMaker* digitMaker, const AliMUONGeometryTransformer* transformer, const AliMUONTriggerCircuit* triggerCircuit) : AliTracker(), - fLoader(loader), - fDigitMaker(digitMaker), // not owner - fTransformer(transformer), // not owner - fTriggerCircuit(triggerCircuit), // not owner - fTrackHitPatternMaker(0x0), - fTrackReco(0x0), - fClusterStore(0x0), - fTriggerStore(0x0) +fkDigitMaker(digitMaker), // not owner +fkTransformer(transformer), // not owner +fkTriggerCircuit(triggerCircuit), // not owner +fTrackHitPatternMaker(0x0), +fTrackReco(0x0), +fClusterStore(0x0), +fTriggerStore(0x0), +fClusterServer(clusterServer), +fIsOwnerOfClusterServer(kFALSE), +fkDigitStore(digitStore), // not owner +fInputClusterStore(0x0), +fTriggerTrackStore(0x0), +fkRecoParam(recoParam) { /// constructor - if (fTransformer && fDigitMaker) + if (fkTransformer && fkDigitMaker) + fTrackHitPatternMaker = new AliMUONTrackHitPattern(recoParam,*fkTransformer,*fkDigitMaker); + + if (!fClusterServer) { - fTrackHitPatternMaker = new AliMUONTrackHitPattern(*fTransformer,*fDigitMaker); + AliDebug(1,"No cluster server given. Will use AliMUONLegacyClusterServer"); + fIsOwnerOfClusterServer = kTRUE; + } + else + { + TIter next(fkDigitStore.CreateIterator()); + fClusterServer->UseDigits(next,&digitStore); + + SetupClusterServer(*fClusterServer); } } @@ -72,31 +112,73 @@ AliMUONTracker::~AliMUONTracker() delete fTrackHitPatternMaker; delete fClusterStore; delete fTriggerStore; + if ( fIsOwnerOfClusterServer ) delete fClusterServer; + delete fInputClusterStore; + delete fTriggerTrackStore; } //_____________________________________________________________________________ -Int_t -AliMUONTracker::LoadClusters(TTree* clustersTree) +AliMUONVClusterStore* +AliMUONTracker::ClusterStore() const { - /// Load clusterStore and triggerStore from clustersTree - delete fClusterStore; - delete fTriggerStore; + /// Return (and create if necessary) the cluster container + if (!fClusterStore) + { + fClusterStore = new AliMUONClusterStoreV2; + } + return fClusterStore; +} - fClusterStore = AliMUONVClusterStore::Create(*clustersTree); - fTriggerStore = AliMUONVTriggerStore::Create(*clustersTree); - - if (!fClusterStore) +//_____________________________________________________________________________ +AliMUONVTriggerTrackStore* +AliMUONTracker::TriggerTrackStore() const +{ + /// Return (and create if necessary) the trigger track container + if (!fTriggerTrackStore) { - AliError("Could not get clusterStore"); + fTriggerTrackStore = new AliMUONTriggerTrackStoreV1; + } + return fTriggerTrackStore; +} + +//_____________________________________________________________________________ +Int_t AliMUONTracker::LoadClusters(TTree* clustersTree) +{ + /// Load triggerStore from clustersTree + + delete fTriggerStore; + delete fInputClusterStore; + fInputClusterStore=0x0; + + if ( ! clustersTree ) { + AliFatal("No clustersTree"); return 1; } + + fTriggerStore = AliMUONVTriggerStore::Create(*clustersTree); + if (!fTriggerStore) { AliError("Could not get triggerStore"); return 2; } - fClusterStore->Connect(*clustersTree,kFALSE); + if ( fIsOwnerOfClusterServer ) + { + fInputClusterStore = AliMUONVClusterStore::Create(*clustersTree); + if ( fInputClusterStore ) + { + AliDebug(1,Form("Created %s from cluster tree",fInputClusterStore->ClassName())); + fInputClusterStore->Clear(); + fInputClusterStore->Connect(*clustersTree,kFALSE); + } + delete fClusterServer; + fClusterServer = new AliMUONLegacyClusterServer(*fkTransformer,fInputClusterStore, + GetRecoParam()->BypassSt4(), + GetRecoParam()->BypassSt5()); + SetupClusterServer(*fClusterServer); + } + fTriggerStore->Connect(*clustersTree,kFALSE); clustersTree->GetEvent(0); @@ -105,167 +187,220 @@ AliMUONTracker::LoadClusters(TTree* clustersTree) } //_____________________________________________________________________________ -Int_t -AliMUONTracker::Clusters2Tracks(AliESD* esd) +Int_t AliMUONTracker::Clusters2Tracks(AliESDEvent* esd) { - /// Performs the tracking and store the resulting tracks in both - /// the TreeT and the ESD - - Int_t rv(0); - - TTree* tracksTree = fLoader->TreeT(); + /// Performs the tracking and store the resulting tracks in the ESD + AliDebug(1,""); + AliCodeTimerAuto("",0) - if (!tracksTree) + if (!fTrackReco) { - AliError("Cannot get TreeT"); - rv=1; + fTrackReco = CreateTrackReconstructor(GetRecoParam(),fClusterServer); } - if (!fClusterStore) + + // if the required tracking mode does not exist + if (!fTrackReco) return 1; + + if ( ! ClusterStore() ) { AliError("ClusterStore is NULL"); - rv=2; + return 2; } - if (!fTriggerStore) - { + + if (!fTriggerStore) { AliError("TriggerStore is NULL"); - rv=3; - } - if (!rv) - { - rv = Clusters2Tracks(*tracksTree,esd); + return 3; } - return rv; -} -//_____________________________________________________________________________ -Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESD* esd) -{ - /// Performs the tracking - - AliDebug(1,""); - - AliMUONVTrackStore* trackStore(0x0); - AliMUONVTriggerTrackStore* triggerTrackStore(0x0); - - // Make tracker tracks - if ( fClusterStore ) + // Make trigger tracks + if ( fkTriggerCircuit ) { - trackStore = new AliMUONTrackStoreV1; - Bool_t alone = ( ( fTriggerStore && fTriggerCircuit ) ? kFALSE : kTRUE ); - trackStore->Connect(tracksTree,alone); - fTrackReco->EventReconstruct(*fClusterStore,*trackStore); + TriggerTrackStore()->Clear(); + fTrackReco->EventReconstructTrigger(*fkTriggerCircuit,*fTriggerStore,*(TriggerTrackStore())); } - if ( fTriggerStore && fTriggerCircuit ) + if ( TriggerTrackStore()->GetSize() > GetRecoParam()->GetMaxTriggerTracks() ) { - // Make trigger tracks - triggerTrackStore = new AliMUONTriggerTrackStoreV1; - Bool_t alone = ( fClusterStore ? kFALSE : kTRUE ); - triggerTrackStore->Connect(tracksTree,alone); - fTrackReco->EventReconstructTrigger(*fTriggerCircuit,*fTriggerStore,*triggerTrackStore); - } + // cut to reject shower events + + AliCodeTimerAuto("MUON Shower events",1); - if ( trackStore && triggerTrackStore && fTriggerStore && fTrackHitPatternMaker ) + AliWarning(Form("Probably got a shower event (%d trigger tracks). Will not reconstruct tracks.", + TriggerTrackStore()->GetSize())); + + return 0; + } + + // Make tracker tracks + AliMUONVTrackStore* trackStore = new AliMUONTrackStoreV1; + fTrackReco->EventReconstruct(*(ClusterStore()),*trackStore); + + // Match tracker/trigger tracks + if ( fTrackHitPatternMaker ) { - fTrackReco->ValidateTracksWithTrigger(*trackStore,*triggerTrackStore,*fTriggerStore,*fTrackHitPatternMaker); + fTrackReco->ValidateTracksWithTrigger(*trackStore,*(TriggerTrackStore()),*fTriggerStore,*fTrackHitPatternMaker); } - // Fills output TreeT - tracksTree.Fill(); - + // Fill ESD FillESD(*trackStore,esd); // cleanup delete trackStore; - delete triggerTrackStore; return 0; } //_____________________________________________________________________________ -void -AliMUONTracker::FillESD(AliMUONVTrackStore& trackStore, AliESD* esd) const +void AliMUONTracker::FillESD(const AliMUONVTrackStore& trackStore, AliESDEvent* esd) const { /// Fill the ESD from the trackStore - AliDebug(1,""); + AliCodeTimerAuto("",0) - // Get vertex - Double_t vertex[3] = {0}; + // get ITS vertex + Double_t vertex[3] = {0., 0., 0.}; const AliESDVertex* esdVert = esd->GetVertex(); - if (esdVert->GetNContributors()) - { + if (esdVert->GetNContributors()) { esdVert->GetXYZ(vertex); AliDebug(1,Form("found vertex (%e,%e,%e)",vertex[0],vertex[1],vertex[2])); } - // setting ESD MUON class - AliESDMuonTrack esdTrack; - + // fill ESD event including all info in ESD cluster if required and only for the given fraction of events AliMUONTrack* track; + AliMUONLocalTrigger* locTrg; + AliESDMuonTrack esdTrack; TIter next(trackStore.CreateIterator()); - - while ( ( track = static_cast(next()) ) ) - { - AliMUONTrackParam* trackParam = static_cast((track->GetTrackParamAtHit())->First()); - AliMUONTrackParam trackParamAtVtx(*trackParam); + if (GetRecoParam()->SaveFullClusterInESD() && + gRandom->Uniform(100.) <= GetRecoParam()->GetPercentOfFullClusterInESD()) { + + while ( ( track = static_cast(next()) ) ) { + + if (track->GetMatchTrigger() > 0) { + locTrg = static_cast(fTriggerStore->FindLocal(track->LoCircuit())); + AliMUONESDInterface::MUONToESD(*track, esdTrack, vertex, &fkDigitStore, locTrg); + } else AliMUONESDInterface::MUONToESD(*track, esdTrack, vertex, &fkDigitStore); + + esd->AddMuonTrack(&esdTrack); + } + + } else { - /// Extrapolate to vertex (which is set to (0,0,0) if not available, see above) - AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, vertex[0],vertex[1],vertex[2]); + while ( ( track = static_cast(next()) ) ) { + + if (track->GetMatchTrigger() > 0) { + locTrg = static_cast(fTriggerStore->FindLocal(track->LoCircuit())); + AliMUONESDInterface::MUONToESD(*track, esdTrack, vertex, 0x0, locTrg); + } else AliMUONESDInterface::MUONToESD(*track, esdTrack, vertex); + + esd->AddMuonTrack(&esdTrack); + } - // setting data member of ESD MUON + } + + // fill the local trigger decisions not matched with tracks (associate them to "ghost" tracks) + UInt_t ghostId = 0xFFFFFFFF - 1; + Bool_t matched = kFALSE; + AliMUONTriggerTrack *triggerTrack; + TIter itTriggerTrack(fTriggerTrackStore->CreateIterator()); + while ( ( triggerTrack = static_cast(itTriggerTrack()) ) ) { + + locTrg = static_cast(fTriggerStore->FindLocal(triggerTrack->GetLoTrgNum())); - // at first station - esdTrack.SetInverseBendingMomentumUncorrected(trackParam->GetInverseBendingMomentum()); - esdTrack.SetThetaXUncorrected(TMath::ATan(trackParam->GetNonBendingSlope())); - esdTrack.SetThetaYUncorrected(TMath::ATan(trackParam->GetBendingSlope())); - esdTrack.SetZUncorrected(trackParam->GetZ()); - esdTrack.SetBendingCoorUncorrected(trackParam->GetBendingCoor()); - esdTrack.SetNonBendingCoorUncorrected(trackParam->GetNonBendingCoor()); - // at vertex - esdTrack.SetInverseBendingMomentum(trackParamAtVtx.GetInverseBendingMomentum()); - esdTrack.SetThetaX(TMath::ATan(trackParamAtVtx.GetNonBendingSlope())); - esdTrack.SetThetaY(TMath::ATan(trackParamAtVtx.GetBendingSlope())); - esdTrack.SetZ(trackParamAtVtx.GetZ()); - esdTrack.SetBendingCoor(trackParamAtVtx.GetBendingCoor()); - esdTrack.SetNonBendingCoor(trackParamAtVtx.GetNonBendingCoor()); - // global info - esdTrack.SetChi2(track->GetFitFMin()); - esdTrack.SetNHit(track->GetNTrackHits()); - esdTrack.SetLocalTrigger(track->GetLocalTrigger()); - esdTrack.SetChi2MatchTrigger(track->GetChi2MatchTrigger()); - esdTrack.SetHitsPatternInTrigCh(track->GetHitsPatternInTrigCh()); + // check if this local trigger has already been matched + TIter itTrack(trackStore.CreateIterator()); + while ( ( track = static_cast(itTrack()) ) ) { + matched = (track->LoCircuit() == locTrg->LoCircuit()); + if (matched) break; + } + if (matched) continue; + + AliMUONESDInterface::MUONToESD(*locTrg, esdTrack, ghostId, triggerTrack); - // storing ESD MUON Track into ESD Event esd->AddMuonTrack(&esdTrack); - } // end of loop on tracks + ghostId -= 1; + } + } //_____________________________________________________________________________ -void AliMUONTracker::SetOption(Option_t* option) +AliMUONVTrackReconstructor* AliMUONTracker::CreateTrackReconstructor(const AliMUONRecoParam* recoParam, AliMUONVClusterServer* clusterServer) { - /// set reconstructor class + /// Create track reconstructor, depending on tracking mode set in RecoParam - if (strstr(option,"Original")) + AliMUONVTrackReconstructor* trackReco(0x0); + + TString opt(recoParam->GetTrackingMode()); + opt.ToUpper(); + + if (strstr(opt,"ORIGINAL")) { - fTrackReco = new AliMUONTrackReconstructor; + trackReco = new AliMUONTrackReconstructor(recoParam,clusterServer); } - else if (strstr(option,"Combi")) + else if (strstr(opt,"KALMAN")) { - fTrackReco = new AliMUONTrackReconstructorK("Combi"); + trackReco = new AliMUONTrackReconstructorK(recoParam,clusterServer); } - else + else { - fTrackReco = new AliMUONTrackReconstructorK("Kalman"); + AliErrorClass(Form("tracking mode \"%s\" does not exist",opt.Data())); + return 0x0; } + + AliDebugClass(1,Form("Will use %s for tracking",trackReco->ClassName())); + + return trackReco; } //_____________________________________________________________________________ -void -AliMUONTracker::UnloadClusters() +void AliMUONTracker::UnloadClusters() { - /// Delete internal clusterStore - delete fClusterStore; - fClusterStore = 0x0; + /// Clear internal clusterStore + + delete fInputClusterStore; + fInputClusterStore = 0x0; } + +//_____________________________________________________________________________ +void +AliMUONTracker::SetupClusterServer(AliMUONVClusterServer& clusterServer) +{ + /// Setup the cluster server + + if ( GetRecoParam()->BypassSt4() || + GetRecoParam()->BypassSt5() ) + { + Bool_t ok = clusterServer.UseTriggerTrackStore(TriggerTrackStore()); + + TString msg1; + TString msg2; + + if ( GetRecoParam()->BypassSt45() ) + { + msg1 = "STATIONS 4 AND 5"; + msg2 = "THOSE TWO STATIONS"; + } + else if ( GetRecoParam()->BypassSt4() ) + { + msg1 = "STATION 4"; + msg2 = "THAT STATION"; + } + else if ( GetRecoParam()->BypassSt5() ) + { + msg1 = "STATION 5"; + msg2 = "THAT STATION"; + } + + if ( ok ) + { + AliWarning(Form("WILL USE TRIGGER TRACKS TO GENERATE CLUSTERS IN %s, " + "THUS BYPASSING REAL CLUSTERS IN %s!!!",msg1.Data(),msg2.Data())); + } + else + { + AliWarning("BYPASSING OF ST4 AND/OR 5 REQUESTED, BUT CLUSTERSERVER DOES NOT SEEM TO SUPPORT IT !!!"); + } + } +} + +