| fa97374c |
1 | /************************************************************************** |
| 2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * |
| 3 | * * |
| 4 | * Author: The ALICE Off-line Project. * |
| 5 | * Contributors are mentioned in the code where appropriate. * |
| 6 | * * |
| 7 | * Permission to use, copy, modify and distribute this software and its * |
| 8 | * documentation strictly for non-commercial purposes is hereby granted * |
| 9 | * without fee, provided that the above copyright notice appears in all * |
| 10 | * copies and that both the copyright notice and this permission notice * |
| 11 | * appear in the supporting documentation. The authors make no claims * |
| 12 | * about the suitability of this software for any purpose. It is * |
| 13 | * provided "as is" without express or implied warranty. * |
| 14 | **************************************************************************/ |
| 15 | |
| 27de2dfb |
16 | /* $Id$ */ |
| 17 | |
| fa97374c |
18 | // ROOT includes |
| 19 | #include <TObjArray.h> |
| 20 | #include <TClonesArray.h> |
| 21 | #include <TH1F.h> |
| 22 | #include <TH2F.h> |
| 23 | #include <TCanvas.h> |
| 24 | |
| 25 | // STEER includes |
| 26 | #include "AliLog.h" |
| 27 | #include "AliESDEvent.h" |
| 28 | #include "AliESDMuonTrack.h" |
| 29 | #include "AliESDInputHandler.h" |
| 30 | #include "AliMCEventHandler.h" |
| 31 | |
| 32 | // ANALYSIS includes |
| c121b0eb |
33 | #include "AliAnalysisDataSlot.h" |
| 34 | #include "AliAnalysisDataContainer.h" |
| fa97374c |
35 | #include "AliAnalysisManager.h" |
| 36 | #include "AliCDBManager.h" |
| 37 | |
| 38 | // MUON includes |
| 39 | #include "AliMUONCDB.h" |
| 40 | #include "AliMUONRecoParam.h" |
| 41 | #include "AliMUONRecoCheck.h" |
| 42 | #include "AliMUONVCluster.h" |
| 43 | #include "AliMUONVTrackStore.h" |
| c121b0eb |
44 | #include "AliMUONVTriggerTrackStore.h" |
| fa97374c |
45 | #include "AliMUONTrack.h" |
| 46 | #include "AliMUONTrackParam.h" |
| 47 | #include "AliMUONESDInterface.h" |
| 48 | |
| 49 | #include "AliAnalysisTaskMuonFakes.h" |
| 50 | #include "AliCounterCollection.h" |
| 51 | |
| 52 | ClassImp(AliAnalysisTaskMuonFakes) |
| 53 | |
| 54 | //________________________________________________________________________ |
| 55 | AliAnalysisTaskMuonFakes::AliAnalysisTaskMuonFakes() : |
| 56 | AliAnalysisTaskSE(), |
| 57 | fList(0x0), |
| 58 | fCanvases(0x0), |
| 59 | fTrackCounters(0x0), |
| 60 | fFakeTrackCounters(0x0), |
| 61 | fMatchedTrackCounters(0x0), |
| 62 | fEventCounters(0x0), |
| 63 | fCurrentFileName(""), |
| 64 | fRequestedStationMask(0), |
| 65 | fRequest2ChInSameSt45(kFALSE), |
| 66 | fSigmaCut(-1.), |
| 67 | fUseLabel(kFALSE), |
| 68 | fRecoParamLocation("alien://folder=/alice/simulation/2008/v4-15-Release/Full") |
| 69 | { |
| 70 | /// Default constructor. |
| 71 | } |
| 72 | |
| 73 | //________________________________________________________________________ |
| 74 | AliAnalysisTaskMuonFakes::AliAnalysisTaskMuonFakes(const char *name) : |
| 75 | AliAnalysisTaskSE(name), |
| 76 | fList(0x0), |
| 77 | fCanvases(0x0), |
| 78 | fTrackCounters(0x0), |
| 79 | fFakeTrackCounters(0x0), |
| 80 | fMatchedTrackCounters(0x0), |
| 81 | fEventCounters(0x0), |
| 82 | fCurrentFileName(""), |
| 83 | fRequestedStationMask(0), |
| 84 | fRequest2ChInSameSt45(kFALSE), |
| 85 | fSigmaCut(-1.), |
| 86 | fUseLabel(kFALSE), |
| 87 | fRecoParamLocation("alien://folder=/alice/simulation/2008/v4-15-Release/Full") |
| 88 | { |
| 89 | /// Constructor. |
| 90 | // Output slot #1 writes into a TObjArray container |
| 91 | DefineOutput(1,TObjArray::Class()); |
| 92 | // Output slot #2 writes into an AliCounterCollection container |
| 93 | DefineOutput(2,AliCounterCollection::Class()); |
| 94 | // Output slot #3 writes into an AliCounterCollection container |
| 95 | DefineOutput(3,AliCounterCollection::Class()); |
| 96 | // Output slot #4 writes into an AliCounterCollection container |
| 97 | DefineOutput(4,AliCounterCollection::Class()); |
| 98 | // Output slot #5 writes into an AliCounterCollection container |
| 99 | DefineOutput(5,AliCounterCollection::Class()); |
| 100 | } |
| 101 | |
| 102 | //________________________________________________________________________ |
| 103 | AliAnalysisTaskMuonFakes::~AliAnalysisTaskMuonFakes() |
| 104 | { |
| 105 | /// Destructor. |
| 106 | if (!AliAnalysisManager::GetAnalysisManager()->IsProofMode()) { |
| 107 | delete fList; |
| 108 | delete fTrackCounters; |
| 109 | delete fFakeTrackCounters; |
| 110 | delete fMatchedTrackCounters; |
| 111 | delete fEventCounters; |
| 112 | } |
| 113 | delete fCanvases; |
| 114 | } |
| 115 | |
| 116 | //___________________________________________________________________________ |
| 117 | void AliAnalysisTaskMuonFakes::UserCreateOutputObjects() |
| 118 | { |
| 119 | /// Create histograms and counters. |
| 120 | |
| 121 | fList = new TObjArray(100); |
| 122 | fList->SetOwner(); |
| 123 | |
| 124 | // number of tracks |
| 125 | TH1F *hNumberOfTracks = new TH1F("hNumberOfTracks", "nb of tracks /evt", 21, -0.5, 20.5); |
| 126 | fList->AddAtAndExpand(hNumberOfTracks, kNumberOfTracks); |
| 127 | TH1F *hNumberOfAdditionalTracks = new TH1F("hNumberOfAdditionalTracks", "nb of fake - nb of missing track", 21, -0.5, 20.5); |
| 128 | fList->AddAtAndExpand(hNumberOfAdditionalTracks, kNumberOfAdditionalTracks); |
| 129 | |
| 130 | // number of clusters |
| 131 | TH1F *hNumberOfClusters = new TH1F("hNumberOfClusters", "nb of clusters /track", 21, -0.5, 20.5); |
| 132 | fList->AddAtAndExpand(hNumberOfClusters, kNumberOfClusters); |
| 133 | TH1F *hNumberOfClustersM = new TH1F("hNumberOfClustersM", "nb of clusters /matched track", 21, -0.5, 20.5); |
| 134 | fList->AddAtAndExpand(hNumberOfClustersM, kNumberOfClustersM); |
| 135 | TH1F *hNumberOfClustersF = new TH1F("hNumberOfClustersF", "nb of clusters /fake track", 21, -0.5, 20.5); |
| 136 | fList->AddAtAndExpand(hNumberOfClustersF, kNumberOfClustersF); |
| 137 | TH1F *hNumberOfClustersMC = new TH1F("hNumberOfClustersMC", "nb of clusters /MC track", 21, -0.5, 20.5); |
| 138 | fList->AddAtAndExpand(hNumberOfClustersMC, kNumberOfClustersMC); |
| 139 | TH1F *hFractionOfMatchedClusters = new TH1F("hFractionOfMatchedClusters", "nb of matched clusters / nb of clusters", 110, 0., 1.1); |
| 140 | fList->AddAtAndExpand(hFractionOfMatchedClusters, kFractionOfMatchedClusters); |
| 141 | TH1F *hFractionOfConnectedClusters = new TH1F("hFractionOfConnectedClusters", "nb of connected clusters / nb of clusters in fake tracks", 110, 0., 1.1); |
| 142 | fList->AddAtAndExpand(hFractionOfConnectedClusters, kFractionOfConnectedClusters); |
| 143 | |
| 144 | // number of fired chambers |
| 145 | TH1F *hNumberOfChamberHit = new TH1F("hNumberOfChamberHit", "nb of chambers hit /track", 16, -0.5, 15.5); |
| 146 | fList->AddAtAndExpand(hNumberOfChamberHit, kNumberOfChamberHit); |
| 147 | TH1F *hNumberOfChamberHitM = new TH1F("hNumberOfChamberHitM", "nb of chambers hit /matched track", 16, -0.5, 15.5); |
| 148 | fList->AddAtAndExpand(hNumberOfChamberHitM, kNumberOfChamberHitM); |
| 149 | TH1F *hNumberOfChamberHitF = new TH1F("hNumberOfChamberHitF", "nb of chambers hit /fake track", 16, -0.5, 15.5); |
| 150 | fList->AddAtAndExpand(hNumberOfChamberHitF, kNumberOfChamberHitF); |
| 151 | |
| 152 | // chi2 |
| 153 | TH1F *hChi2PerDof = new TH1F("hChi2PerDof", "track chi2/d.o.f.", 100, 0., 20.); |
| 154 | fList->AddAtAndExpand(hChi2PerDof, kChi2PerDof); |
| 155 | TH1F *hChi2PerDofM = new TH1F("hChi2PerDofM", "matched track chi2/d.o.f.", 100, 0., 20.); |
| 156 | fList->AddAtAndExpand(hChi2PerDofM, kChi2PerDofM); |
| 157 | TH1F *hChi2PerDofF = new TH1F("hChi2PerDofF", "fake track chi2/d.o.f.", 100, 0., 20.); |
| 158 | fList->AddAtAndExpand(hChi2PerDofF, kChi2PerDofF); |
| 159 | |
| 160 | // chi2 versus number of clusters |
| 161 | TH2F *hChi2PerDofVsNClusters = new TH2F("hChi2PerDofVsNClusters", "track chi2/d.o.f. versus nb of clusters", 21, -0.5, 20.5, 100, 0., 20.); |
| 162 | fList->AddAtAndExpand(hChi2PerDofVsNClusters, kChi2PerDofVsNClusters); |
| 163 | TH2F *hChi2PerDofVsNClustersM = new TH2F("hChi2PerDofVsNClustersM", "matched track chi2/d.o.f. versus nb of clusters", 21, -0.5, 20.5, 100, 0., 20.); |
| 164 | fList->AddAtAndExpand(hChi2PerDofVsNClustersM, kChi2PerDofVsNClustersM); |
| 165 | TH2F *hChi2PerDofVsNClustersF = new TH2F("hChi2PerDofVsNClustersF", "fake track chi2/d.o.f. versus nb of clusters", 21, -0.5, 20.5, 100, 0., 20.); |
| 166 | fList->AddAtAndExpand(hChi2PerDofVsNClustersF, kChi2PerDofVsNClustersF); |
| 167 | |
| 168 | // chi2 versus number of fired chambers |
| 169 | TH2F *hChi2PerDofVsNChamberHit = new TH2F("hChi2PerDofVsNChamberHit", "track chi2/d.o.f. versus nb of fired chambers", 16, -0.5, 15.5, 100, 0., 20.); |
| 170 | fList->AddAtAndExpand(hChi2PerDofVsNChamberHit, kChi2PerDofVsNChamberHit); |
| 171 | TH2F *hChi2PerDofVsNChamberHitM = new TH2F("hChi2PerDofVsNChamberHitM", "matched track chi2/d.o.f. versus nb of fired chambers", 16, -0.5, 15.5, 100, 0., 20.); |
| 172 | fList->AddAtAndExpand(hChi2PerDofVsNChamberHitM, kChi2PerDofVsNChamberHitM); |
| 173 | TH2F *hChi2PerDofVsNChamberHitF = new TH2F("hChi2PerDofVsNChamberHitF", "fake track chi2/d.o.f. versus nb of fired chambers", 16, -0.5, 15.5, 100, 0., 20.); |
| 174 | fList->AddAtAndExpand(hChi2PerDofVsNChamberHitF, kChi2PerDofVsNChamberHitF); |
| 175 | |
| 176 | // physics quantities |
| 177 | TH1F *hP = new TH1F("hP", "Muon P distribution (GeV/c)", 100, 0., 200.); |
| 178 | fList->AddAtAndExpand(hP, kP); |
| 179 | TH1F *hPM = new TH1F("hPM", "matched track P distribution (GeV/c)", 100, 0., 200.); |
| 180 | fList->AddAtAndExpand(hPM, kPM); |
| 181 | TH1F *hPF = new TH1F("hPF", "fake track P distribution (GeV/c)", 100, 0., 200.); |
| 182 | fList->AddAtAndExpand(hPF, kPF); |
| 183 | TH1F *hPt = new TH1F("hPt", "Muon Pt distribution (GeV/c)", 100, 0., 20.); |
| 184 | fList->AddAtAndExpand(hPt, kPt); |
| 185 | TH1F *hPtM = new TH1F("hPtM", "matched track Pt distribution (GeV/c)", 100, 0., 20.); |
| 186 | fList->AddAtAndExpand(hPtM, kPtM); |
| 187 | TH1F *hPtF = new TH1F("hPtF", "fake track Pt distribution (GeV/c)", 100, 0., 20.); |
| 188 | fList->AddAtAndExpand(hPtF, kPtF); |
| 189 | TH1F *hEta = new TH1F("hEta", "Muon pseudo-rapidity distribution", 100, -10., 0.); |
| 190 | fList->AddAtAndExpand(hEta , kEta ); |
| 191 | TH1F *hEtaM = new TH1F("hEtaM", "matched track pseudo-rapidity distribution", 100, -10., 0.); |
| 192 | fList->AddAtAndExpand(hEtaM, kEtaM); |
| 193 | TH1F *hEtaF = new TH1F("hEtaF", "fake track pseudo-rapidity distribution", 100, -10., 0.); |
| 194 | fList->AddAtAndExpand(hEtaF, kEtaF); |
| 195 | TH1F *hPhi = new TH1F("hPhi", "Muon phi distribution", 100, -1., 9.); |
| 196 | fList->AddAtAndExpand(hPhi, kPhi); |
| 197 | TH1F *hPhiM = new TH1F("hPhiM", "matched track phi distribution", 100, -1., 9.); |
| 198 | fList->AddAtAndExpand(hPhiM, kPhiM); |
| 199 | TH1F *hPhiF = new TH1F("hPhiF", "fake track phi distribution", 100, -1., 9.); |
| 200 | fList->AddAtAndExpand(hPhiF, kPhiF); |
| 201 | TH1F *hDCA = new TH1F("hDCA", "Muon DCA distribution", 125, 0., 500.); |
| 202 | fList->AddAtAndExpand(hDCA, kDCA); |
| 203 | TH1F *hDCAM = new TH1F("hDCAM", "matched track DCA distribution", 125, 0., 500.); |
| 204 | fList->AddAtAndExpand(hDCAM, kDCAM); |
| 205 | TH1F *hDCAF = new TH1F("hDCAF", "fake track DCA distribution", 125, 0., 500.); |
| 206 | fList->AddAtAndExpand(hDCAF, kDCAF); |
| 207 | |
| 208 | // global counters of tracks: |
| 209 | // - reconstructible = number of reconstructible tracks |
| 210 | // - reconstructed = number of reconstructed tracks |
| 211 | // - matched = number of reconstructed tracks matched with a simulated one (reconstructible or not) |
| 212 | // - matchedyet = number of reconstructed tracks matched with a simulated one that is not reconstructible |
| 213 | // - fake = number of fake tracks |
| 214 | // - connected = number of fake tracks connected to a reconstructible simulated track |
| 215 | // - additional = number of additional (fake) tracks compared to the number of reconstructible ones |
| c121b0eb |
216 | fTrackCounters = new AliCounterCollection(GetOutputSlot(2)->GetContainer()->GetName()); |
| fa97374c |
217 | fTrackCounters->AddRubric("track", "reconstructible/reconstructed/matched/matchedyet/fake/connected/additional"); |
| 218 | fTrackCounters->AddRubric("run", 1000000); |
| 219 | fTrackCounters->AddRubric("trig", "yes/no/unknown"); |
| 220 | fTrackCounters->AddRubric("selected", "yes/no"); |
| 221 | fTrackCounters->AddRubric("acc", "in/out/unknown"); |
| 222 | fTrackCounters->Init(); |
| 223 | |
| 224 | // detailled counters of fake tracks: |
| c121b0eb |
225 | fFakeTrackCounters = new AliCounterCollection(GetOutputSlot(3)->GetContainer()->GetName()); |
| fa97374c |
226 | fFakeTrackCounters->AddRubric("track", "fake/connected/additional/matchedyet/fake?"); |
| 227 | fFakeTrackCounters->AddRubric("run", 1000000); |
| 228 | fFakeTrackCounters->AddRubric("file", 1000000); |
| 229 | fFakeTrackCounters->AddRubric("event", 1000000); |
| 230 | fFakeTrackCounters->AddRubric("trig", "yes/no/unknown"); |
| 231 | fFakeTrackCounters->AddRubric("selected", "yes/no"); |
| 232 | fFakeTrackCounters->AddRubric("acc", "in/out/unknown"); |
| 233 | fFakeTrackCounters->Init(); |
| 234 | |
| 235 | // counters of tracks matched by position or by using MC labels |
| c121b0eb |
236 | fMatchedTrackCounters = new AliCounterCollection(GetOutputSlot(4)->GetContainer()->GetName()); |
| fa97374c |
237 | fMatchedTrackCounters->AddRubric("position", "match/not match"); |
| 238 | fMatchedTrackCounters->AddRubric("label", "match/not match/match other"); |
| 239 | fMatchedTrackCounters->AddRubric("run", 1000000); |
| 240 | fMatchedTrackCounters->AddRubric("trig", "yes/no"); |
| 241 | fMatchedTrackCounters->AddRubric("selected", "yes/no"); |
| 242 | fMatchedTrackCounters->AddRubric("acc", "in/out"); |
| 243 | fMatchedTrackCounters->Init(); |
| 244 | |
| 245 | // global counters of events |
| 246 | // - any = total number of events with reconstructed tracks |
| 247 | // - fake = number of events with fake track(s) |
| 248 | // - notconnected = number of events with fake tracks that are not connected to a reconstructible simulated track |
| 249 | // - additional = number of events with additional (fake) tracks compared to the number of reconstructible ones |
| 250 | // - matchedyet = number of events with reconstructed tracks matched with a simulated one that is not reconstructible |
| 251 | // if trig = yes: only the tracks matched with the trigger are considered in the above logic |
| c121b0eb |
252 | fEventCounters = new AliCounterCollection(GetOutputSlot(5)->GetContainer()->GetName()); |
| fa97374c |
253 | fEventCounters->AddRubric("event", "any/fake/notconnected/additional/matchedyet"); |
| 254 | fEventCounters->AddRubric("run", 1000000); |
| 255 | fEventCounters->AddRubric("trig", "any/yes"); |
| 256 | fEventCounters->AddRubric("selected", "yes/no"); |
| 257 | fEventCounters->Init(); |
| 258 | |
| 259 | // Disable printout of AliMCEvent |
| 260 | AliLog::SetClassDebugLevel("AliMCEvent",-1); |
| 261 | |
| 262 | // Post data at least once per task to ensure data synchronisation (required for merging) |
| 263 | PostData(1, fList); |
| 264 | PostData(2, fTrackCounters); |
| 265 | PostData(3, fFakeTrackCounters); |
| 266 | PostData(4, fMatchedTrackCounters); |
| 267 | PostData(5, fEventCounters); |
| 268 | } |
| 269 | |
| 270 | //________________________________________________________________________ |
| 271 | void AliAnalysisTaskMuonFakes::UserExec(Option_t *) |
| 272 | { |
| 273 | /// Process event: looks for fakes... |
| 274 | |
| 275 | // check that reconstructions parameters for that run have been properly set |
| 276 | if (fSigmaCut < 0) return; |
| 277 | |
| 278 | // check physics selection |
| 279 | TString selected = (fInputHandler && fInputHandler->IsEventSelected() != 0) ? "selected:yes" : "selected:no"; |
| 280 | |
| 281 | // current file name |
| 282 | fCurrentFileName = CurrentFileName(); |
| 283 | fCurrentFileName.ReplaceAll("alien://",""); |
| 284 | fCurrentFileName.ReplaceAll("/","\\"); |
| 285 | fCurrentFileName.ReplaceAll(":",";"); |
| 286 | |
| 287 | // Load ESD event |
| 288 | AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent()); |
| 289 | |
| 290 | // Load MC event |
| 291 | AliMCEventHandler *mcH = 0; |
| 292 | if(MCEvent()) mcH = static_cast<AliMCEventHandler*>((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler()); |
| 293 | |
| 294 | // get reconstructed and simulated tracks |
| 295 | AliMUONRecoCheck rc(esd,mcH); |
| 296 | AliMUONVTrackStore* muonTrackStore = rc.ReconstructedTracks(-1, kFALSE); |
| 297 | AliMUONVTrackStore* trackRefStore = rc.TrackRefs(-1); |
| c121b0eb |
298 | AliMUONVTriggerTrackStore* triggerTrackRefStore = rc.TriggerableTracks(-1); |
| fa97374c |
299 | if (!muonTrackStore || !trackRefStore) return; |
| 300 | |
| 301 | // count the number of reconstructible tracks |
| 302 | TIter next(trackRefStore->CreateIterator()); |
| 303 | AliMUONTrack* trackRef; |
| 304 | while ( ( trackRef = static_cast<AliMUONTrack*>(next()) ) ) { |
| c121b0eb |
305 | if (trackRef->IsValid(fRequestedStationMask, fRequest2ChInSameSt45)) { |
| 306 | TString trig = (triggerTrackRefStore->FindObject(trackRef->GetUniqueID())) ? "trig:yes" : "trig:no"; |
| 307 | fTrackCounters->Count(Form("track:reconstructible/run:%d/%s/%s/acc:unknown", fCurrentRunNumber, trig.Data(), selected.Data())); |
| 308 | } |
| fa97374c |
309 | } |
| 310 | |
| 311 | // loop over ESD tracks |
| 312 | Int_t nTrackerTracks = 0; |
| 313 | Bool_t containTrack[2] = {kFALSE, kFALSE}; |
| 314 | Bool_t containFakeTrack[2] = {kFALSE, kFALSE}; |
| 315 | Bool_t containMatchedYetTrack[2] = {kFALSE, kFALSE}; |
| 316 | AliMUONVTrackStore *fakeTrackStore = AliMUONESDInterface::NewTrackStore(); |
| 317 | Int_t nTracks = (Int_t)esd->GetNumberOfMuonTracks() ; |
| 318 | for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) { |
| 319 | |
| 320 | AliESDMuonTrack* esdTrack = esd->GetMuonTrack(iTrack); |
| 321 | |
| 322 | // skip ghosts |
| 323 | if (!esdTrack->ContainTrackerData()) continue; |
| 324 | nTrackerTracks++; |
| 325 | containTrack[0] = kTRUE; |
| 326 | |
| 327 | // trigger condition |
| 328 | Bool_t trigger = esdTrack->ContainTriggerData(); |
| 329 | TString trig = "trig:"; |
| 330 | if (trigger) { |
| 331 | trig += "yes"; |
| 332 | containTrack[1] = kTRUE; |
| 333 | } else trig += "no"; |
| 334 | |
| 335 | // acceptance condition |
| 336 | TString acc = "acc:"; |
| 337 | Double_t thetaTrackAbsEnd = TMath::ATan(esdTrack->GetRAtAbsorberEnd()/505.) * TMath::RadToDeg(); |
| 338 | Double_t eta = esdTrack->Eta(); |
| 339 | if (thetaTrackAbsEnd >= 2. && thetaTrackAbsEnd <= 9. && eta >= -4. && eta <= -2.5) acc += "in"; |
| 340 | else acc += "out"; |
| 341 | |
| 342 | // fill global counters |
| 343 | fTrackCounters->Count(Form("track:reconstructed/run:%d/%s/%s/%s", fCurrentRunNumber, trig.Data(), selected.Data(), acc.Data())); |
| 344 | |
| 345 | // find the corresponding MUON track |
| 346 | AliMUONTrack* muonTrack = static_cast<AliMUONTrack*>(muonTrackStore->FindObject(esdTrack->GetUniqueID())); |
| 347 | |
| 348 | // get track info |
| 349 | Int_t nClusters = esdTrack->GetNClusters(); |
| 350 | Int_t nChamberHit = 0; |
| 351 | for (Int_t ich=0; ich<10; ich++) if (esdTrack->IsInMuonClusterMap(ich)) nChamberHit++; |
| 352 | Double_t normalizedChi2 = esdTrack->GetChi2() / (2. * esdTrack->GetNHit() - 5); |
| 353 | Double_t p = esdTrack->P(); |
| 354 | Double_t pT = esdTrack->Pt(); |
| 355 | Double_t phi = esdTrack->Phi(); |
| 356 | Double_t dca = esdTrack->GetDCA(); |
| 357 | |
| 358 | // fill global histograms |
| 359 | ((TH1F*)fList->UncheckedAt(kNumberOfClusters))->Fill(nClusters); |
| 360 | ((TH1F*)fList->UncheckedAt(kNumberOfChamberHit))->Fill(nChamberHit); |
| 361 | ((TH1F*)fList->UncheckedAt(kChi2PerDof))->Fill(normalizedChi2); |
| 362 | ((TH1F*)fList->UncheckedAt(kP))->Fill(p); |
| 363 | ((TH1F*)fList->UncheckedAt(kPt))->Fill(pT); |
| 364 | ((TH1F*)fList->UncheckedAt(kEta))->Fill(eta); |
| 365 | ((TH1F*)fList->UncheckedAt(kPhi))->Fill(phi); |
| 366 | ((TH1F*)fList->UncheckedAt(kDCA))->Fill(dca); |
| 367 | ((TH1F*)fList->UncheckedAt(kChi2PerDofVsNClusters))->Fill(nClusters,normalizedChi2); |
| 368 | ((TH1F*)fList->UncheckedAt(kChi2PerDofVsNChamberHit))->Fill(nChamberHit,normalizedChi2); |
| 369 | |
| 370 | // try to match, by position, the reconstructed track with a simulated one |
| 371 | Int_t nMatchClustersByPosition = 0; |
| 372 | AliMUONTrack* matchedTrackRefByPosition = rc.FindCompatibleTrack(*muonTrack, *trackRefStore, nMatchClustersByPosition, kFALSE, fSigmaCut); |
| 8b855522 |
373 | Int_t MCLabelByPosition = (matchedTrackRefByPosition) ? static_cast<Int_t>(matchedTrackRefByPosition->GetUniqueID()) : -1; |
| fa97374c |
374 | |
| 375 | // try to match, by using MC labels, the reconstructed track with a simulated one |
| 376 | Int_t nMatchClustersByLabel = 0; |
| 377 | AliMUONTrack* matchedTrackRefByLabel = rc.FindCompatibleTrack(*muonTrack, *trackRefStore, nMatchClustersByLabel, kTRUE, fSigmaCut); |
| 8b855522 |
378 | Int_t MCLabelByLabel = (matchedTrackRefByLabel) ? static_cast<Int_t>(matchedTrackRefByLabel->GetUniqueID()) : -1; |
| fa97374c |
379 | |
| 380 | // fill global counters |
| 381 | TString positionCase = (MCLabelByPosition >= 0) ? "position:match" : "position:not match"; |
| 382 | TString labelCase = "label:"; |
| 383 | if (MCLabelByLabel >= 0 && MCLabelByPosition >= 0 && MCLabelByLabel != MCLabelByPosition) labelCase += "match other"; |
| 384 | else if (MCLabelByLabel >= 0) labelCase += "match"; |
| 385 | else labelCase += "not match"; |
| 386 | fMatchedTrackCounters->Count(Form("%s/%s/run:%d/%s/%s/%s", positionCase.Data(), labelCase.Data(), fCurrentRunNumber, trig.Data(), selected.Data(), acc.Data())); |
| 387 | if ((MCLabelByLabel >= 0 && MCLabelByPosition < 0) || (MCLabelByLabel < 0 && MCLabelByPosition >= 0)) |
| 388 | fFakeTrackCounters->Count(Form("track:fake?/run:%d/file:%s/event:%d/%s/%s/%s", fCurrentRunNumber, fCurrentFileName.Data(), |
| 389 | esd->GetEventNumberInFile(), trig.Data(), selected.Data(), acc.Data())); |
| 390 | |
| 391 | // take actions according to the matching result we are interested in |
| 392 | Int_t nMatchClusters = (fUseLabel) ? nMatchClustersByLabel : nMatchClustersByPosition; |
| 393 | AliMUONTrack* matchedTrackRef = (fUseLabel) ? matchedTrackRefByLabel : matchedTrackRefByPosition; |
| 394 | if (matchedTrackRef) { |
| 395 | |
| 396 | // fill global counters |
| 397 | fTrackCounters->Count(Form("track:matched/run:%d/%s/%s/%s", fCurrentRunNumber, trig.Data(), selected.Data(), acc.Data())); |
| 398 | |
| 399 | // track matched with a trackRef that is not reconstructible |
| 400 | if (!matchedTrackRef->IsValid(fRequestedStationMask, fRequest2ChInSameSt45)) { |
| 401 | |
| 402 | containMatchedYetTrack[0] = kTRUE; |
| 403 | if (trigger) containMatchedYetTrack[1] = kTRUE; |
| 404 | |
| 405 | // fill global counters |
| 406 | fTrackCounters->Count(Form("track:matchedyet/run:%d/%s/%s/%s", fCurrentRunNumber, trig.Data(), selected.Data(), acc.Data())); |
| 407 | fFakeTrackCounters->Count(Form("track:matchedyet/run:%d/file:%s/event:%d/%s/%s/%s", fCurrentRunNumber, fCurrentFileName.Data(), |
| 408 | esd->GetEventNumberInFile(), trig.Data(), selected.Data(), acc.Data())); |
| 409 | } |
| 410 | |
| 411 | // fill histograms |
| 412 | ((TH1F*)fList->UncheckedAt(kFractionOfMatchedClusters))->Fill(((Float_t) nMatchClusters) / ((Float_t) nClusters)); |
| 413 | ((TH1F*)fList->UncheckedAt(kNumberOfClustersMC))->Fill(matchedTrackRef->GetNClusters()); |
| 414 | ((TH1F*)fList->UncheckedAt(kNumberOfClustersM))->Fill(nClusters); |
| 415 | ((TH1F*)fList->UncheckedAt(kNumberOfChamberHitM))->Fill(nChamberHit); |
| 416 | ((TH1F*)fList->UncheckedAt(kChi2PerDofM))->Fill(normalizedChi2); |
| 417 | ((TH1F*)fList->UncheckedAt(kPM))->Fill(p); |
| 418 | ((TH1F*)fList->UncheckedAt(kPtM))->Fill(pT); |
| 419 | ((TH1F*)fList->UncheckedAt(kEtaM))->Fill(eta); |
| 420 | ((TH1F*)fList->UncheckedAt(kPhiM))->Fill(phi); |
| 421 | ((TH1F*)fList->UncheckedAt(kDCAM))->Fill(dca); |
| 422 | ((TH1F*)fList->UncheckedAt(kChi2PerDofVsNClustersM))->Fill(nClusters,normalizedChi2); |
| 423 | ((TH1F*)fList->UncheckedAt(kChi2PerDofVsNChamberHitM))->Fill(nChamberHit,normalizedChi2); |
| 424 | |
| 425 | // remove already matched trackRefs |
| 426 | trackRefStore->Remove(*matchedTrackRef); |
| 427 | |
| 428 | } else { |
| 429 | |
| 430 | containFakeTrack[0] = kTRUE; |
| 431 | if (trigger) containFakeTrack[1] = kTRUE; |
| 432 | |
| 433 | // fill global counters |
| 434 | fTrackCounters->Count(Form("track:fake/run:%d/%s/%s/%s", fCurrentRunNumber, trig.Data(), selected.Data(), acc.Data())); |
| 435 | fFakeTrackCounters->Count(Form("track:fake/run:%d/file:%s/event:%d/%s/%s/%s", fCurrentRunNumber, fCurrentFileName.Data(), |
| 436 | esd->GetEventNumberInFile(), trig.Data(), selected.Data(), acc.Data())); |
| 437 | |
| 438 | // fill histograms |
| 439 | ((TH1F*)fList->UncheckedAt(kNumberOfClustersF))->Fill(nClusters); |
| 440 | ((TH1F*)fList->UncheckedAt(kNumberOfChamberHitF))->Fill(nChamberHit); |
| 441 | ((TH1F*)fList->UncheckedAt(kChi2PerDofF))->Fill(normalizedChi2); |
| 442 | ((TH1F*)fList->UncheckedAt(kPF))->Fill(p); |
| 443 | ((TH1F*)fList->UncheckedAt(kPtF))->Fill(pT); |
| 444 | ((TH1F*)fList->UncheckedAt(kEtaF))->Fill(eta); |
| 445 | ((TH1F*)fList->UncheckedAt(kPhiF))->Fill(phi); |
| 446 | ((TH1F*)fList->UncheckedAt(kDCAF))->Fill(dca); |
| 447 | ((TH1F*)fList->UncheckedAt(kChi2PerDofVsNClustersF))->Fill(nClusters,normalizedChi2); |
| 448 | ((TH1F*)fList->UncheckedAt(kChi2PerDofVsNChamberHitF))->Fill(nChamberHit,normalizedChi2); |
| 449 | |
| 450 | // store fake tracks |
| 451 | fakeTrackStore->Add(*muonTrack); |
| 452 | |
| 453 | } |
| 454 | |
| 455 | } // end of loop over ESD tracks |
| 456 | |
| 457 | // fill histogram and global counters |
| 458 | ((TH1F*)fList->UncheckedAt(kNumberOfTracks))->Fill(nTrackerTracks); |
| 459 | if (containTrack[0]) fEventCounters->Count(Form("event:any/run:%d/trig:any/%s", fCurrentRunNumber, selected.Data())); |
| 460 | if (containTrack[1]) fEventCounters->Count(Form("event:any/run:%d/trig:yes/%s", fCurrentRunNumber, selected.Data())); |
| 461 | if (containFakeTrack[0]) fEventCounters->Count(Form("event:fake/run:%d/trig:any/%s", fCurrentRunNumber, selected.Data())); |
| 462 | if (containFakeTrack[1]) fEventCounters->Count(Form("event:fake/run:%d/trig:yes/%s", fCurrentRunNumber, selected.Data())); |
| 463 | if (containMatchedYetTrack[0]) fEventCounters->Count(Form("event:matchedyet/run:%d/trig:any/%s", fCurrentRunNumber, selected.Data())); |
| 464 | if (containMatchedYetTrack[1]) fEventCounters->Count(Form("event:matchedyet/run:%d/trig:yes/%s", fCurrentRunNumber, selected.Data())); |
| 465 | |
| 466 | // count the number of not connected and additional fake tracks |
| 467 | if (fakeTrackStore->GetSize() > 0) { |
| 468 | |
| 469 | // remove the most connected fake tracks |
| 470 | Int_t nFreeMissingTracks = RemoveConnectedFakes(*fakeTrackStore, *trackRefStore); |
| 471 | |
| 472 | if (fakeTrackStore->GetSize() > 0) { |
| 473 | |
| 474 | // fill global counters |
| 475 | fEventCounters->Count(Form("event:notconnected/run:%d/trig:any/%s", fCurrentRunNumber, selected.Data())); |
| 476 | |
| 477 | // check status of remaining fakes with respect to the matching with trigger |
| 478 | Bool_t containMatchedFake = kFALSE; |
| 479 | Bool_t containUnmatchedFake = kFALSE; |
| 480 | AliMUONTrack* fakeTrack = 0x0; |
| 481 | TIter next3(fakeTrackStore->CreateIterator()); |
| 482 | while ( ( fakeTrack = static_cast<AliMUONTrack*>(next3()) ) ) { |
| 483 | if (fakeTrack->GetMatchTrigger() > 0) containMatchedFake = kTRUE; |
| 484 | else containUnmatchedFake = kTRUE; |
| 485 | } |
| 486 | |
| 487 | // fill global counters |
| 488 | if (containMatchedFake) fEventCounters->Count(Form("event:notconnected/run:%d/trig:yes/%s", fCurrentRunNumber, selected.Data())); |
| 489 | |
| 490 | // remove the remaining free reconstructible tracks |
| 491 | Int_t nAdditionalTracks = fakeTrackStore->GetSize() - nFreeMissingTracks; |
| 492 | |
| 493 | if (nAdditionalTracks > 0) { |
| 494 | |
| 495 | // fill histogram and global counters |
| 496 | ((TH1F*)fList->UncheckedAt(kNumberOfAdditionalTracks))->Fill(nAdditionalTracks); |
| 497 | fEventCounters->Count(Form("event:additional/run:%d/trig:any/%s", fCurrentRunNumber, selected.Data())); |
| 498 | if (!containUnmatchedFake) { // all matched |
| 499 | fTrackCounters->Count(Form("track:additional/run:%d/trig:yes/%s/acc:unknown", fCurrentRunNumber, selected.Data()), nAdditionalTracks); |
| 500 | fFakeTrackCounters->Count(Form("track:additional/run:%d/file:%s/event:%d/trig:yes/%s/acc:unknown", fCurrentRunNumber, fCurrentFileName.Data(), esd->GetEventNumberInFile(), selected.Data()), nAdditionalTracks); |
| 501 | fEventCounters->Count(Form("event:additional/run:%d/trig:yes/%s", fCurrentRunNumber, selected.Data())); |
| 502 | } else if (!containMatchedFake) { // none matched |
| 503 | fTrackCounters->Count(Form("track:additional/run:%d/trig:no/%s/acc:unknown", fCurrentRunNumber, selected.Data()), nAdditionalTracks); |
| 504 | fFakeTrackCounters->Count(Form("track:additional/run:%d/file:%s/event:%d/trig:no/%s/acc:unknown", fCurrentRunNumber, fCurrentFileName.Data(), esd->GetEventNumberInFile(), selected.Data()), nAdditionalTracks); |
| 505 | } else { // mixed |
| 506 | fTrackCounters->Count(Form("track:additional/run:%d/trig:unknown/%s/acc:unknown", fCurrentRunNumber, selected.Data()), nAdditionalTracks); |
| 507 | fFakeTrackCounters->Count(Form("track:additional/run:%d/file:%s/event:%d/trig:unknown/%s/acc:unknown", fCurrentRunNumber, fCurrentFileName.Data(), esd->GetEventNumberInFile(), selected.Data()), nAdditionalTracks); |
| 508 | fEventCounters->Count(Form("event:additional/run:%d/trig:yes/%s", fCurrentRunNumber, selected.Data())); |
| 509 | } |
| 510 | |
| 511 | } |
| 512 | |
| 513 | } |
| 514 | |
| 515 | } |
| 516 | |
| 517 | delete fakeTrackStore; |
| 518 | |
| 519 | // Post final data |
| 520 | PostData(1, fList); |
| 521 | PostData(2, fTrackCounters); |
| 522 | PostData(3, fFakeTrackCounters); |
| 523 | PostData(4, fMatchedTrackCounters); |
| 524 | PostData(5, fEventCounters); |
| 525 | } |
| 526 | |
| 527 | //________________________________________________________________________ |
| 528 | void AliAnalysisTaskMuonFakes::NotifyRun() |
| 529 | { |
| 530 | /// Prepare processing of new run: load corresponding OCDB objects... |
| 531 | |
| 532 | // load necessary data from OCDB |
| 533 | AliCDBManager::Instance()->SetDefaultStorage(fRecoParamLocation.Data()); |
| 534 | AliCDBManager::Instance()->SetRun(fCurrentRunNumber); |
| 535 | AliMUONRecoParam* recoParam = AliMUONCDB::LoadRecoParam(); |
| 536 | if (!recoParam) { |
| 537 | fRequestedStationMask = 0; |
| 538 | fRequest2ChInSameSt45 = kFALSE; |
| 539 | fSigmaCut = -1.; |
| 540 | AliError("--> skip this run"); |
| 541 | return; |
| 542 | } |
| 543 | |
| 544 | // compute the mask of requested stations from recoParam |
| 545 | fRequestedStationMask = 0; |
| 546 | for (Int_t i = 0; i < 5; i++) if (recoParam->RequestStation(i)) fRequestedStationMask |= ( 1 << i ); |
| 547 | |
| 548 | // get from recoParam whether a track need 2 chambers hit in the same station (4 or 5) or not to be reconstructible |
| 549 | fRequest2ChInSameSt45 = !recoParam->MakeMoreTrackCandidates(); |
| 550 | |
| 551 | // get sigma cut from recoParam to associate clusters with TrackRefs in case the labels are not used |
| 552 | fSigmaCut = (recoParam->ImproveTracks()) ? recoParam->GetSigmaCutForImprovement() : recoParam->GetSigmaCutForTracking(); |
| 553 | } |
| 554 | |
| 555 | //________________________________________________________________________ |
| 556 | void AliAnalysisTaskMuonFakes::Terminate(Option_t *) |
| 557 | { |
| 558 | /// Draw results to the screen and print statistics. |
| 559 | |
| 560 | // recover output objects |
| 561 | fList = static_cast<TObjArray*> (GetOutputData(1)); |
| 562 | if (!fList) return; |
| 563 | fTrackCounters = static_cast<AliCounterCollection*> (GetOutputData(2)); |
| 564 | fFakeTrackCounters = static_cast<AliCounterCollection*> (GetOutputData(3)); |
| 565 | fMatchedTrackCounters = static_cast<AliCounterCollection*> (GetOutputData(4)); |
| 566 | fEventCounters = static_cast<AliCounterCollection*> (GetOutputData(5)); |
| 567 | |
| 568 | // add canvas to compare histograms |
| 569 | fCanvases = new TObjArray(1000); |
| 570 | fCanvases->SetOwner(); |
| 571 | TCanvas *cFakesSummary1 = new TCanvas("cFakesSummary1","cFakesSummary1",1200,600); |
| 572 | fCanvases->AddAtAndExpand(cFakesSummary1, 0); |
| 573 | TCanvas *cFakesSummary2 = new TCanvas("cFakesSummary2","cFakesSummary2",1200,600); |
| 574 | fCanvases->AddAtAndExpand(cFakesSummary2, 1); |
| 575 | |
| 576 | // display |
| 577 | Int_t iHist1[8] = {kNumberOfClusters, kChi2PerDof, kP, kEta, kNumberOfChamberHit, kDCA, kPt, kPhi}; |
| 578 | cFakesSummary1->Divide(4,2); |
| 579 | for (Int_t i=0; i<8; i++) { |
| 580 | cFakesSummary1->cd(i+1); |
| 581 | cFakesSummary1->GetPad(i+1)->SetLogy(); |
| 582 | ((TH1F*)fList->UncheckedAt(iHist1[i]))->SetMinimum(0.5); |
| 583 | ((TH1F*)fList->UncheckedAt(iHist1[i]))->DrawCopy(); |
| 584 | ((TH1F*)fList->UncheckedAt(iHist1[i]+1))->SetLineColor(4); |
| 585 | ((TH1F*)fList->UncheckedAt(iHist1[i]+1))->DrawCopy("sames"); |
| 586 | ((TH1F*)fList->UncheckedAt(iHist1[i]+2))->SetLineColor(2); |
| 587 | ((TH1F*)fList->UncheckedAt(iHist1[i]+2))->SetFillColor(2); |
| 588 | ((TH1F*)fList->UncheckedAt(iHist1[i]+2))->SetFillStyle(3017); |
| 589 | ((TH1F*)fList->UncheckedAt(iHist1[i]+2))->DrawCopy("sames"); |
| 590 | } |
| 591 | |
| 592 | Int_t iHist2[2] = {kChi2PerDofVsNClusters, kChi2PerDofVsNChamberHit}; |
| 593 | cFakesSummary2->Divide(2); |
| 594 | for (Int_t i=0; i<2; i++) { |
| 595 | cFakesSummary2->cd(i+1); |
| 596 | ((TH2F*)fList->UncheckedAt(iHist2[i]+1))->SetMarkerColor(4); |
| 597 | ((TH2F*)fList->UncheckedAt(iHist2[i]+1))->DrawCopy(); |
| 598 | ((TH2F*)fList->UncheckedAt(iHist2[i]+2))->SetMarkerColor(2); |
| 599 | ((TH2F*)fList->UncheckedAt(iHist2[i]+2))->SetMarkerStyle(7); |
| 600 | ((TH2F*)fList->UncheckedAt(iHist2[i]+2))->DrawCopy("sames"); |
| 601 | } |
| 602 | |
| 603 | // print |
| 604 | if (fTrackCounters && fFakeTrackCounters && fMatchedTrackCounters && fEventCounters) { |
| 605 | printf("\nGlobal statistics of reconstructed tracks matched or not with the trigger:\n"); |
| 606 | fTrackCounters->Print("track/trig"); |
| 607 | printf("\nGlobal statistics of pathological tracks matched or not with the trigger:\n"); |
| 608 | fFakeTrackCounters->Print("track/trig"); |
| 609 | printf("\nDetailled statistics of tracks matched per label vs position:\n"); |
| 610 | fMatchedTrackCounters->Print("label/position"); |
| 611 | printf("\nGlobal statistics of events containing pathological tracks:\n"); |
| 612 | fEventCounters->Print("event/trig"); |
| 613 | } |
| 614 | |
| 615 | printf("\nREMINDER: results are relevent provided that you use the same recoParams as for the reconstruction\n"); |
| 616 | } |
| 617 | |
| 618 | //________________________________________________________________________ |
| 619 | Int_t AliAnalysisTaskMuonFakes::RemoveConnectedFakes(AliMUONVTrackStore &fakeTrackStore, AliMUONVTrackStore &trackRefStore) |
| 620 | { |
| 621 | /// loop over reconstructible TrackRef not associated with reconstructed track: |
| 622 | /// for each of them, find and remove the most connected the fake track, if any, |
| 623 | /// and fill the histograms with the fraction of connected clusters. |
| 624 | /// Return the number of reconstructible track not connected to any fake |
| 625 | |
| 626 | Int_t nFreeMissingTracks = 0; |
| 627 | |
| 628 | // loop over trackRefs |
| 629 | TIter next(trackRefStore.CreateIterator()); |
| 630 | AliMUONTrack* trackRef; |
| 631 | while ( ( trackRef = static_cast<AliMUONTrack*>(next()) ) ) { |
| 632 | |
| 633 | // skip not reconstructible trackRefs |
| 634 | if (!trackRef->IsValid(fRequestedStationMask, fRequest2ChInSameSt45)) continue; |
| 635 | |
| 636 | Int_t label = trackRef->GetUniqueID(); |
| 637 | |
| 638 | // look for the most connected fake track |
| 639 | AliMUONTrack *connectedFake = 0x0; |
| 640 | Double_t fractionOfConnectedClusters = 0.; |
| 641 | TIter next2(fakeTrackStore.CreateIterator()); |
| 642 | AliMUONTrack* fakeTrack; |
| 643 | while ( ( fakeTrack = static_cast<AliMUONTrack*>(next2()) ) ) { |
| 644 | |
| 645 | // get the number of connected clusters |
| 646 | Int_t nConnectedClusters = 0; |
| 647 | if (fUseLabel) { // by using the MC label |
| 648 | for (Int_t iCl = 0; iCl < fakeTrack->GetNClusters(); iCl++) |
| 649 | if (((AliMUONTrackParam*) fakeTrack->GetTrackParamAtCluster()->UncheckedAt(iCl))->GetClusterPtr()->GetMCLabel() == label) |
| 650 | nConnectedClusters++; |
| 651 | } else { // by comparing cluster/TrackRef positions |
| 652 | Bool_t compTrack[10]; |
| 653 | nConnectedClusters = fakeTrack->FindCompatibleClusters(*trackRef, fSigmaCut, compTrack); |
| 654 | } |
| 655 | |
| 656 | // skip non-connected fake tracks |
| 657 | if (nConnectedClusters == 0) continue; |
| 658 | |
| 659 | // check if it is the most connected fake track |
| 660 | Double_t f = ((Double_t)nConnectedClusters) / ((Double_t)fakeTrack->GetNClusters()); |
| 661 | if (f > fractionOfConnectedClusters) { |
| 662 | connectedFake = fakeTrack; |
| 663 | fractionOfConnectedClusters = f; |
| 664 | } |
| 665 | |
| 666 | } |
| 667 | |
| 668 | if (connectedFake) { |
| 669 | |
| 670 | // find the corresponding ESD MUON track |
| 671 | AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent()); |
| 672 | TIter next3(static_cast<TClonesArray*>(esd->FindListObject("MuonTracks"))); |
| 673 | AliESDMuonTrack* esdTrack = 0x0; |
| 674 | while ((esdTrack = static_cast<AliESDMuonTrack*>(next3())) && esdTrack->GetUniqueID() != connectedFake->GetUniqueID()) {} |
| 675 | if (!esdTrack) { |
| 676 | AliError("unable to find the corresponding ESD track???"); |
| 677 | continue; |
| 678 | } |
| 679 | |
| 680 | // trigger condition |
| 681 | TString trig = (esdTrack->ContainTriggerData()) ? "trig:yes" : "trig:no"; |
| 682 | |
| 683 | // acceptance condition |
| 684 | Double_t thetaTrackAbsEnd = TMath::ATan(esdTrack->GetRAtAbsorberEnd()/505.) * TMath::RadToDeg(); |
| 685 | Double_t eta = esdTrack->Eta(); |
| 686 | TString acc = (thetaTrackAbsEnd >= 2. && thetaTrackAbsEnd <= 9. && eta >= -4. && eta <= -2.5) ? "acc:in" : "acc:out"; |
| 687 | |
| 688 | // check physics selection |
| 689 | TString selected = (fInputHandler && fInputHandler->IsEventSelected()) ? "selected:yes" : "selected:no"; |
| 690 | |
| 691 | // fill histogram and counters |
| 692 | ((TH1F*)fList->UncheckedAt(kFractionOfConnectedClusters))->Fill(fractionOfConnectedClusters); |
| 693 | fTrackCounters->Count(Form("track:connected/run:%d/%s/%s/%s", fCurrentRunNumber, trig.Data(), selected.Data(), acc.Data())); |
| 694 | fFakeTrackCounters->Count(Form("track:connected/run:%d/file:%s/event:%d/%s/%s/%s", fCurrentRunNumber, fCurrentFileName.Data(), |
| 695 | esd->GetEventNumberInFile(), trig.Data(), selected.Data(), acc.Data())); |
| 696 | |
| 697 | // remove the most connected fake track |
| 698 | fakeTrackStore.Remove(*connectedFake); |
| 699 | |
| 700 | } else nFreeMissingTracks++; |
| 701 | |
| 702 | } |
| 703 | |
| 704 | return nFreeMissingTracks; |
| 705 | |
| 706 | } |
| 707 | |
git://git.uio.no / u / mrichter / AliRoot.git / blame