| 9310e980 |
1 | /* created by fbellini@cern.ch on 29/04/2013 */ |
| 2 | /* last modified by fbellini on 19/08/2013 */ |
| 3 | |
| 4 | |
| 5 | #ifndef ALIANALYSISTASKTOFQAID_CXX |
| 6 | #define ALIANALYSISTASKTOFQAID_CXX |
| 7 | |
| 8 | #include "TChain.h" |
| 9 | #include "TTree.h" |
| 10 | #include "TH1F.h" |
| 11 | #include "TH2F.h" |
| 12 | #include "TProfile.h" |
| 13 | #include "TCanvas.h" |
| 14 | #include "AliAnalysisTaskSE.h" |
| 15 | #include "AliAnalysisManager.h" |
| 16 | #include "AliVEvent.h" |
| 17 | #include "AliVTrack.h" |
| 18 | #include "AliESDEvent.h" |
| 19 | #include "AliMCEvent.h" |
| 20 | #include "AliMCParticle.h" |
| 21 | #include "AliESDInputHandler.h" |
| 22 | #include "AliMCEventHandler.h" |
| 23 | #include "AliESDpid.h" |
| b0471367 |
24 | #include "AliTOFPIDParams.h" |
| 9310e980 |
25 | #include "AliCDBManager.h" |
| 26 | #include "AliTOFcalib.h" |
| 27 | #include "AliTOFT0maker.h" |
| 28 | #include "AliTOFT0v1.h" |
| 29 | #include "AliAnalysisTaskTOFqaID.h" |
| 30 | #include "AliAnalysisFilter.h" |
| 31 | #include "AliESDtrackCuts.h" |
| 32 | #include "AliLog.h" |
| 33 | #include "AliTOFRawStream.h" |
| 34 | #include "AliTOFGeometry.h" |
| 35 | |
| 36 | ClassImp(AliAnalysisTaskTOFqaID) |
| 37 | |
| 38 | //________________________________________________________________________ |
| 39 | AliAnalysisTaskTOFqaID::AliAnalysisTaskTOFqaID() : |
| 40 | fRunNumber(0), |
| 41 | fESD(0x0), |
| 42 | fMCevent(0x0), |
| 43 | fTrackFilter(0x0), |
| 44 | fVertex(0x0), |
| 45 | fESDpid(new AliESDpid()), |
| 9310e980 |
46 | fTOFHeader(0x0), |
| 47 | fEnableAdvancedCheck(kFALSE), |
| 48 | fExpTimeBinWidth(24.4), |
| 49 | fExpTimeRangeMin(-25010.), |
| 50 | fExpTimeRangeMax(25010.), |
| 51 | fExpTimeSmallRangeMin(-5002.), |
| 52 | fExpTimeSmallRangeMax(5002.), |
| 53 | fnExpTimeBins(1), |
| 54 | fnExpTimeSmallBins(1), |
| 55 | fMyTimeZeroTOF(1e20), |
| 56 | fMyTimeZeroTOFsigma(1e20), |
| 57 | fMyTimeZeroTOFtracks(-1), |
| 58 | fIsMC(kFALSE), |
| 59 | fSelectedPdg(0), |
| 60 | fP(1e10), |
| 61 | fPt(1e10), |
| 62 | fEta(1e10), |
| 63 | fPhi(1e10), |
| 64 | fTPCOuterPhi(1e10), |
| 65 | fL(1e10), |
| 66 | fMatchingMomCut(1e10), |
| 67 | fTof(1e10), |
| 68 | fHlist(0x0), |
| 69 | fHlistTimeZero(0x0), |
| 70 | fHlistPID(0x0), |
| 71 | fHlistTRD(0x0), |
| 72 | fHlistTrigger(0x0) |
| 73 | { |
| 74 | // Default constructor |
| 75 | |
| 76 | for (Int_t j=0;j<3;j++ ) { |
| 77 | if (j<3) { |
| 78 | fT0[j]=0.0; |
| 79 | fNTOFtracks[j]=0; |
| 80 | } |
| 81 | fSigmaSpecie[j]=0.0; |
| 82 | fTrkExpTimes[j]=0.0; |
| 83 | fThExpTimes[j]=0.0; |
| 84 | } |
| 85 | } |
| 86 | //________________________________________________________________________ |
| 87 | AliAnalysisTaskTOFqaID::AliAnalysisTaskTOFqaID(const char *name) : |
| 88 | AliAnalysisTaskSE(name), |
| 89 | fRunNumber(0), |
| 90 | fESD(0x0), |
| 91 | fMCevent(0x0), |
| 92 | fTrackFilter(0x0), |
| 93 | fVertex(0x0), |
| 94 | fESDpid(new AliESDpid()), |
| 9310e980 |
95 | fTOFHeader(0x0), |
| 96 | fEnableAdvancedCheck(kFALSE), |
| 97 | fExpTimeBinWidth(24.4), |
| 98 | fExpTimeRangeMin(-25010.), |
| 99 | fExpTimeRangeMax(25010.), |
| 100 | fExpTimeSmallRangeMin(-5002.), |
| 101 | fExpTimeSmallRangeMax(5002.), |
| 102 | fnExpTimeBins(1), |
| 103 | fnExpTimeSmallBins(1), |
| 104 | fMyTimeZeroTOF(1e20), |
| 105 | fMyTimeZeroTOFsigma(1e20), |
| 106 | fMyTimeZeroTOFtracks(-1), |
| 107 | fIsMC(kFALSE), |
| 108 | fSelectedPdg(0), |
| 109 | fP(1e10), |
| 110 | fPt(1e10), |
| 111 | fEta(1e10), |
| 112 | fPhi(1e10), |
| 113 | fTPCOuterPhi(1e10), |
| 114 | fL(1e10), |
| 115 | fMatchingMomCut(1.0), |
| 116 | fTof(1e10), |
| 117 | fHlist(0x0), |
| 118 | fHlistTimeZero(0x0), |
| 119 | fHlistPID(0x0), |
| 120 | fHlistTRD(0x0), |
| 121 | fHlistTrigger(0x0) |
| 122 | { |
| 123 | // Constructor |
| 124 | // Define input and output slots here |
| 125 | Info("AliAnalysisTaskTOFqaID","Calling Constructor"); |
| 126 | |
| 127 | for (Int_t j=0;j<5;j++ ) { |
| 128 | if (j<3){ |
| 129 | fT0[j]=0.0; |
| 130 | fNTOFtracks[j]=0; |
| 131 | } |
| 132 | fSigmaSpecie[j]=0.0; |
| 133 | fTrkExpTimes[j]=0.0; |
| 134 | fThExpTimes[j]=0.0; |
| 135 | } |
| 136 | // Input slot #0 works with a TChain |
| 137 | DefineInput(0, TChain::Class()); |
| 138 | |
| 139 | // Output slot #0 writes into a TH1 container |
| 140 | // Output slot #1 writes into a user defined container |
| 141 | DefineOutput(1, TList::Class()); |
| 142 | DefineOutput(2, TList::Class()); |
| 143 | DefineOutput(3, TList::Class()); |
| 144 | DefineOutput(4, TList::Class()); |
| 145 | DefineOutput(5, TList::Class()); |
| 146 | |
| 147 | } |
| 148 | |
| 149 | //________________________________________________________________________ |
| 150 | AliAnalysisTaskTOFqaID::AliAnalysisTaskTOFqaID(const AliAnalysisTaskTOFqaID& copy) |
| 151 | : AliAnalysisTaskSE(), |
| 152 | fRunNumber(copy.fRunNumber), |
| 153 | fESD(copy.fESD), |
| 154 | fMCevent(copy.fMCevent), |
| 155 | fTrackFilter(copy.fTrackFilter), |
| 156 | fVertex(copy.fVertex), |
| 157 | fESDpid(copy.fESDpid), |
| 9310e980 |
158 | fTOFHeader(copy.fTOFHeader), |
| 159 | fEnableAdvancedCheck(copy.fEnableAdvancedCheck), |
| 160 | fExpTimeBinWidth(copy.fExpTimeBinWidth), |
| 161 | fExpTimeRangeMin(copy.fExpTimeRangeMin), |
| 162 | fExpTimeRangeMax(copy.fExpTimeRangeMax), |
| 163 | fExpTimeSmallRangeMin(copy.fExpTimeSmallRangeMin), |
| 164 | fExpTimeSmallRangeMax(copy.fExpTimeSmallRangeMax), |
| 165 | fnExpTimeBins(copy.fnExpTimeBins), |
| 166 | fnExpTimeSmallBins(copy.fnExpTimeSmallBins), |
| 167 | fMyTimeZeroTOF(copy.fMyTimeZeroTOF), |
| 168 | fMyTimeZeroTOFsigma(copy.fMyTimeZeroTOFsigma), |
| 169 | fMyTimeZeroTOFtracks(copy.fMyTimeZeroTOFtracks), |
| 170 | fIsMC(copy.fIsMC), |
| 171 | fSelectedPdg(copy.fSelectedPdg), |
| 172 | fP(copy.fP), |
| 173 | fPt(copy.fPt), |
| 174 | fEta(copy.fEta), |
| 175 | fPhi(copy.fPhi), |
| 176 | fTPCOuterPhi(copy.fTPCOuterPhi), |
| 177 | fL(copy.fL), |
| 178 | fMatchingMomCut(copy.fMatchingMomCut), |
| 179 | fTof(copy.fTof), |
| 180 | fHlist(copy.fHlist), |
| 181 | fHlistTimeZero(copy.fHlistTimeZero), |
| 182 | fHlistPID(copy.fHlistPID), |
| 183 | fHlistTRD(copy.fHlistTRD), |
| 184 | fHlistTrigger(copy.fHlistTrigger) |
| 185 | { |
| 186 | // Copy constructor |
| 187 | for (Int_t j=0;j<5;j++ ) { |
| 188 | if (j<3) { |
| 189 | fT0[j]=copy.fT0[j]; |
| 190 | fNTOFtracks[j]=copy.fNTOFtracks[j]; |
| 191 | } |
| 192 | fSigmaSpecie[j]=copy.fSigmaSpecie[j]; |
| 193 | fTrkExpTimes[j]=copy.fTrkExpTimes[j]; |
| 194 | fThExpTimes[j]=copy.fThExpTimes[j]; |
| 195 | } |
| 196 | |
| 197 | |
| 198 | } |
| 199 | |
| 200 | //___________________________________________________________________________ |
| 201 | AliAnalysisTaskTOFqaID& AliAnalysisTaskTOFqaID::operator=(const AliAnalysisTaskTOFqaID& copy) |
| 202 | { |
| 203 | // |
| 204 | // Assignment operator |
| 205 | // |
| 206 | if (this!=©) { |
| 207 | AliAnalysisTaskSE::operator=(copy) ; |
| 208 | fRunNumber=copy.fRunNumber; |
| 209 | fESD=copy.fESD; |
| 210 | fMCevent=copy.fMCevent; |
| 211 | fTrackFilter=copy.fTrackFilter; |
| 212 | fVertex=copy.fVertex; |
| 213 | fESDpid=copy.fESDpid; |
| 9310e980 |
214 | fTOFHeader=copy.fTOFHeader; |
| 215 | fEnableAdvancedCheck=copy.fEnableAdvancedCheck; |
| 216 | fExpTimeBinWidth=copy.fExpTimeBinWidth; |
| 217 | fExpTimeRangeMin=copy.fExpTimeRangeMin; |
| 218 | fExpTimeRangeMax=copy.fExpTimeRangeMax; |
| 219 | fExpTimeSmallRangeMin=copy.fExpTimeSmallRangeMin; |
| 220 | fExpTimeSmallRangeMax=copy.fExpTimeSmallRangeMax; |
| 221 | fnExpTimeBins=copy.fnExpTimeBins; |
| 222 | fnExpTimeSmallBins=copy.fnExpTimeSmallBins; |
| 223 | fMyTimeZeroTOF=copy.fMyTimeZeroTOF; |
| 224 | fMyTimeZeroTOFsigma=copy.fMyTimeZeroTOFsigma; |
| 225 | fMyTimeZeroTOFtracks=copy.fMyTimeZeroTOFtracks; |
| 226 | for (Int_t j=0;j<5;j++ ) { |
| 227 | if (j<3) { |
| 228 | fT0[j]=copy.fT0[j]; |
| 229 | fNTOFtracks[j]=copy.fNTOFtracks[j]; |
| 230 | } |
| 231 | fSigmaSpecie[j]=copy.fSigmaSpecie[j]; |
| 232 | fTrkExpTimes[j]=copy.fTrkExpTimes[j]; |
| 233 | fThExpTimes[j]=copy.fThExpTimes[j]; |
| 234 | } |
| 235 | fIsMC=copy.fIsMC; |
| 236 | fSelectedPdg=copy.fSelectedPdg; |
| 237 | fP=copy.fP; |
| 238 | fPt=copy.fPt; |
| 239 | fEta=copy.fEta; |
| 240 | fPhi=copy.fPhi; |
| 241 | fTPCOuterPhi=copy.fTPCOuterPhi; |
| 242 | fL=copy.fL; |
| 243 | fMatchingMomCut=copy.fMatchingMomCut; |
| 244 | fTof=copy.fTof; |
| 245 | fHlist=copy.fHlist; |
| 246 | fHlistTimeZero=copy.fHlistTimeZero; |
| 247 | fHlistPID=copy.fHlistPID; |
| 248 | fHlistTRD=copy.fHlistTRD; |
| 249 | fHlistTrigger=copy.fHlistTrigger; |
| 250 | } |
| 251 | return *this; |
| 252 | } |
| 253 | |
| 254 | //___________________________________________________________________________ |
| 255 | AliAnalysisTaskTOFqaID::~AliAnalysisTaskTOFqaID() { |
| 256 | // |
| 257 | //destructor |
| 258 | // |
| 259 | |
| 260 | Info("~AliAnalysisTaskTOFqaID","Calling Destructor"); |
| 261 | if (fESDpid) delete fESDpid; |
| 262 | if (fTOFHeader) delete fTOFHeader; |
| 9310e980 |
263 | if (fVertex) delete fVertex; |
| 264 | if (fTrackFilter) delete fTrackFilter; |
| 265 | if (AliAnalysisManager::GetAnalysisManager()->IsProofMode()) return; |
| 266 | |
| 267 | if (fHlist) { |
| 268 | delete fHlist; |
| 269 | fHlist = 0; |
| 270 | } |
| 271 | if (fHlistTimeZero) { |
| 272 | delete fHlistTimeZero; |
| 273 | fHlistTimeZero = 0; |
| 274 | } |
| 275 | if (fHlistPID){ |
| 276 | delete fHlistPID; |
| 277 | fHlistPID = 0; |
| 278 | } |
| 279 | if (fHlistTRD){ |
| 280 | delete fHlistTRD; |
| 281 | fHlistTRD = 0; |
| 282 | } |
| 283 | if (fHlistTrigger){ |
| 284 | delete fHlistTrigger; |
| 285 | fHlistTrigger = 0; |
| 286 | } |
| 287 | } |
| 288 | |
| 289 | //________________________________________________________________________ |
| 290 | void AliAnalysisTaskTOFqaID::UserCreateOutputObjects() |
| 291 | { |
| b0471367 |
292 | // |
| 293 | //Define output objects and histograms |
| 294 | // |
| 295 | |
| 296 | //retrieve PID response object |
| 297 | AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager(); |
| 298 | if (!man) AliFatal("Analysis manager needed"); |
| 299 | AliInputEventHandler *inputHandler=dynamic_cast<AliInputEventHandler*>(man->GetInputEventHandler()); |
| 300 | if (!inputHandler) AliFatal("Input handler needed"); |
| 301 | //pid response object |
| 302 | fESDpid=(AliESDpid*)inputHandler->GetPIDResponse(); |
| 303 | if (!fESDpid) AliError("PIDResponse object was not created"); |
| 304 | // fESDpid->SetOADBPath("$ALICE_ROOT/OADB"); |
| 305 | |
| 9310e980 |
306 | Info("CreateOutputObjects","CreateOutputObjects (TList) of task %s", GetName()); |
| 307 | OpenFile(1); |
| 4241f42c |
308 | |
| 9310e980 |
309 | if (!fHlist) fHlist = new TList(); |
| 310 | fHlist->SetOwner(kTRUE); |
| 4241f42c |
311 | fHlist->SetName("base"); |
| 312 | |
| 9310e980 |
313 | if (!fHlistTimeZero) fHlistTimeZero = new TList(); |
| 314 | fHlistTimeZero->SetOwner(kTRUE); |
| 4241f42c |
315 | fHlistTimeZero->SetName("startTime"); |
| 316 | |
| 9310e980 |
317 | if (!fHlistPID) fHlistPID = new TList(); |
| 318 | fHlistPID->SetOwner(kTRUE); |
| 4241f42c |
319 | fHlistPID->SetName("pid"); |
| 320 | |
| 9310e980 |
321 | if (!fHlistTRD) fHlistTRD = new TList(); |
| 322 | fHlistTRD->SetOwner(kTRUE); |
| 4241f42c |
323 | fHlistTRD->SetName("TRD"); |
| 324 | |
| 9310e980 |
325 | if (!fHlistTrigger) fHlistTrigger = new TList(); |
| 326 | fHlistTrigger->SetOwner(kTRUE); |
| 4241f42c |
327 | fHlistTrigger->SetName("trigger"); |
| 9310e980 |
328 | |
| 329 | if (fExpTimeRangeMax<fExpTimeRangeMin) { |
| 330 | SetExpTimeHistoRange(-25010.,25010.); |
| 331 | } |
| 332 | fnExpTimeBins = TMath::Nint((fExpTimeRangeMax - fExpTimeRangeMin)/fExpTimeBinWidth);//ps |
| 333 | fExpTimeRangeMax=fExpTimeRangeMin+fnExpTimeBins*fExpTimeBinWidth;//ps |
| 334 | |
| 335 | if (fExpTimeSmallRangeMax<fExpTimeSmallRangeMin) { |
| 336 | SetExpTimeHistoSmallRange(-5002.,5002.); |
| 337 | } |
| 338 | fnExpTimeSmallBins = TMath::Nint((fExpTimeSmallRangeMax - fExpTimeSmallRangeMin)/fExpTimeBinWidth);//ps |
| 339 | fExpTimeSmallRangeMax=fExpTimeSmallRangeMin+fnExpTimeSmallBins*fExpTimeBinWidth;//ps |
| 340 | |
| 341 | //add plots for start time QA |
| 342 | AddStartTimeHisto(fHlistTimeZero,""); |
| 343 | |
| b0471367 |
344 | //add plots for base TO quantities |
| 9310e980 |
345 | AddTofBaseHisto(fHlist, 1, ""); |
| 346 | AddTofBaseHisto(fHlist, -1, ""); |
| 347 | |
| 348 | //add plots for matching efficiency |
| 349 | AddMatchingEffHisto(fHlist, 1, ""); |
| 350 | AddMatchingEffHisto(fHlist, -1, ""); |
| 351 | |
| 352 | //add plots for PID checks |
| 353 | AddPidHisto(fHlistPID, 1, ""); |
| 354 | AddPidHisto(fHlistPID, -1, ""); |
| 355 | |
| 356 | //add trd plots |
| 357 | if (fEnableAdvancedCheck) { |
| 358 | AddTrdHisto(); |
| 359 | AddTofTrgHisto(""); |
| 360 | } |
| 361 | PostData(1, fHlist); |
| 362 | PostData(2, fHlistTimeZero); |
| 363 | PostData(3, fHlistPID); |
| 364 | PostData(4, fHlistTRD); |
| 365 | PostData(5, fHlistTrigger); |
| 366 | } |
| 367 | //________________________________________________________________________ |
| 368 | void AliAnalysisTaskTOFqaID::UserExec(Option_t *) |
| 369 | { |
| 370 | /* Main - executed for each event. |
| 371 | It extracts event information and track information after selecting |
| 372 | primary tracks via standard cuts. */ |
| b0471367 |
373 | /* |
| 9310e980 |
374 | AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()); |
| 375 | if (!esdH) { |
| 376 | AliError("ERROR: Could not get ESDInputHandler"); |
| 377 | return; |
| 378 | } else { |
| 379 | fESD = (AliESDEvent*) esdH->GetEvent(); |
| 380 | } |
| 381 | |
| b0471367 |
382 | */ |
| b0471367 |
383 | fESD=(AliESDEvent*)InputEvent(); |
| 9310e980 |
384 | if (!fESD) { |
| b32dee71 |
385 | Printf("ERROR: fESD not available"); |
| 386 | return; |
| 387 | } |
| 388 | |
| 389 | if (!fESDpid) { |
| 390 | Printf("ERROR: fESDpid not available"); |
| 9310e980 |
391 | return; |
| 392 | } |
| b32dee71 |
393 | |
| b0471367 |
394 | //retrieve default start time type from PIDresponse |
| 395 | AliPIDResponse::EStartTimeType_t startTimeMethodDefault = AliPIDResponse::kBest_T0; |
| 396 | if (fESDpid->GetTOFPIDParams()) { // during reconstruction OADB not yet available |
| 397 | startTimeMethodDefault = ((AliTOFPIDParams *)fESDpid->GetTOFPIDParams())->GetStartTimeMethod(); |
| b0471367 |
398 | } |
| 399 | |
| 9310e980 |
400 | //access MC event handler for MC truth information |
| 401 | if (fIsMC) { |
| 402 | AliMCEventHandler *mcH = dynamic_cast<AliMCEventHandler*> (AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler()); |
| 403 | if (!mcH) { |
| 404 | AliError("ERROR: Could not get MCeventHandler"); |
| 405 | return; |
| 406 | } else { |
| 407 | fMCevent = (AliMCEvent *) mcH->MCEvent(); |
| 408 | if (!fMCevent) { |
| 409 | AliError("Trying to retrieve an invalid MC event."); |
| 410 | return; |
| 411 | } |
| 412 | } |
| 413 | } |
| 414 | |
| 415 | // get run number |
| 416 | Int_t runNb = fESD->GetRunNumber(); |
| b32dee71 |
417 | if (runNb>0) fRunNumber = runNb; |
| b0471367 |
418 | |
| 9310e980 |
419 | //reset matched track counters |
| 420 | for (Int_t j=0;j<3;j++){fNTOFtracks[j]=0;} |
| b0471367 |
421 | |
| 9310e980 |
422 | //Get vertex info and apply vertex cut |
| 423 | if (!IsEventSelected(fESD)) return; |
| 424 | |
| 425 | //set response tof_t0 for all other checks |
| 426 | fESDpid->SetTOFResponse(fESD,AliESDpid::kTOF_T0);//(fill_t0, tof_t0, t0_t0, best_t0) |
| 427 | |
| 428 | Printf("Momentum cut for eta and phi distributions set: Pt>%3.2f", fMatchingMomCut); |
| 429 | |
| 430 | // loop over ESD tracks |
| 431 | for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) { |
| 432 | AliESDtrack* track = fESD->GetTrack(iTracks); |
| 433 | if (!track) { |
| 434 | Printf("ERROR: Could not receive track %d", iTracks); |
| 435 | continue; |
| 436 | } |
| 437 | |
| 438 | //primary tracks selection: kTPCrefit and std cuts |
| 439 | if (fTrackFilter){ |
| 440 | if(!fTrackFilter->IsSelected(track)) continue; |
| 441 | } else { |
| 442 | Printf("No track filter found, skipping the track loop"); |
| 443 | return; |
| 444 | } |
| 445 | |
| 446 | //select specie if MC |
| 447 | if ( fIsMC && |
| 448 | (!SelectMCspecies(fMCevent, track))) { |
| 449 | AliDebug(4, Form("MC tracks selection: Track=%i label=%i Not Accepted", iTracks, track->GetLabel())); |
| 450 | continue; |
| 451 | } |
| 452 | |
| 453 | //apply cut for eta acceptance |
| 454 | fEta=track->Eta(); |
| 455 | if (TMath::Abs(fEta)>0.8) continue; |
| 456 | |
| 457 | //get other track variables |
| 458 | fP = track->P(); |
| 459 | fPt = track->Pt(); |
| 460 | fPhi = track->Phi()*TMath::RadToDeg(); |
| 461 | fTPCOuterPhi = GetPhiAtTPCouterRadius(track); |
| 462 | fL = track->GetIntegratedLength(); |
| 463 | track->GetIntegratedTimes(fTrkExpTimes); |
| 464 | |
| 465 | Int_t charge = track->Charge(); |
| 466 | |
| 467 | FillPrimaryTrkHisto(charge,""); |
| 468 | if (IsTPCTOFMatched(track)) { |
| 469 | fTof=track->GetTOFsignal()*1E-3;//in ps |
| 470 | //increment track counters |
| 471 | fNTOFtracks[0]++; |
| 472 | if (charge>0) fNTOFtracks[1]++; |
| 473 | if (charge<0) fNTOFtracks[2]++; |
| 474 | //fill histos |
| 475 | FillTofBaseHisto(track, charge,""); |
| 476 | FillMatchedTrkHisto(charge,""); |
| 477 | FillPidHisto(track, charge, ""); |
| 478 | } |
| 479 | if (fEnableAdvancedCheck) FillTrdHisto(track, charge); |
| 480 | }//end loop on tracks |
| 481 | |
| 482 | //fill time zero histos |
| 483 | FillStartTimeHisto(""); |
| 484 | ((TH1F*)fHlist->FindObject("hTOFmulti_pos"))->Fill(fNTOFtracks[1]); |
| 485 | ((TH1F*)fHlist->FindObject("hTOFmulti_neg"))->Fill(fNTOFtracks[2]); |
| 486 | |
| 487 | //fill TOF trg histos from infos in TOF header |
| 488 | fTOFHeader=(AliTOFHeader*)fESD->GetTOFHeader(); |
| 489 | if (!fTOFHeader) { |
| 490 | AliWarning("Cannot get TOF header: no TOF trigger info available"); |
| 491 | } else { |
| 492 | FillTofTrgHisto(""); |
| 493 | } |
| 494 | |
| b0471367 |
495 | //restore value set by AliPIDResponseTask for subsequent wagons |
| 496 | fESDpid->SetTOFResponse(fESD,startTimeMethodDefault); |
| 497 | |
| 9310e980 |
498 | PostData(1, fHlist); |
| 499 | PostData(2, fHlistTimeZero); |
| 500 | PostData(3, fHlistPID); |
| 501 | PostData(4, fHlistTRD); |
| 502 | PostData(5, fHlistTrigger); |
| 503 | |
| 504 | } |
| 505 | |
| 506 | //________________________________________________________________________ |
| 507 | void AliAnalysisTaskTOFqaID::Terminate(Option_t *) |
| 508 | { |
| 509 | //check on output validity |
| 510 | fHlist = dynamic_cast<TList*> (GetOutputData(1)); |
| 511 | if (!fHlist) { |
| 512 | Printf("ERROR: lists not available"); |
| 513 | return; |
| 514 | } |
| 515 | |
| 516 | // TH1D*hDummy = ((TH1D*)fHlist->FindObject("hTOFmatchedESDPt")); |
| 517 | // TH1D*hMatchingEff = (TH1D*) hDummy->Clone("hMatchingEff"); |
| 518 | // hMatchingEff->SetTitle("Matching efficiency"); |
| 519 | // hMatchingEff->Divide((TH1F*) fHlist->FindObject("hESDprimaryTrackPt")); |
| 520 | // TCanvas *c1 = new TCanvas("AliAnalysisTaskTOFqaID","Matching vs Pt",10,10,510,510); |
| 521 | // c1->cd(1)->SetLogy(); |
| 522 | // hMatchingEff->DrawCopy("E"); |
| 523 | // fHlist->AddLast(hMatchingEff); |
| 524 | ComputeMatchingEfficiency(fHlist, "pt"); |
| 525 | ComputeMatchingEfficiency(fHlist, "eta"); |
| 526 | ComputeMatchingEfficiency(fHlist, "phi"); |
| 527 | |
| 528 | PostData(1, fHlist); |
| 529 | } |
| 530 | |
| 531 | //--------------------------------------------------------------- |
| 20b640b9 |
532 | Int_t AliAnalysisTaskTOFqaID::GetStripIndex(const Int_t * in) |
| 9310e980 |
533 | { |
| 534 | /* return tof strip index between 0 and 91 */ |
| 535 | |
| 536 | Int_t nStripA = AliTOFGeometry::NStripA(); |
| 537 | Int_t nStripB = AliTOFGeometry::NStripB(); |
| 538 | Int_t nStripC = AliTOFGeometry::NStripC(); |
| 539 | |
| 540 | Int_t iplate = in[1]; |
| 541 | Int_t istrip = in[2]; |
| 542 | |
| 543 | Int_t stripOffset = 0; |
| 544 | switch (iplate) { |
| 545 | case 0: |
| 546 | stripOffset = 0; |
| 547 | break; |
| 548 | case 1: |
| 549 | stripOffset = nStripC; |
| 550 | break; |
| 551 | case 2: |
| 552 | stripOffset = nStripC+nStripB; |
| 553 | break; |
| 554 | case 3: |
| 555 | stripOffset = nStripC+nStripB+nStripA; |
| 556 | break; |
| 557 | case 4: |
| 558 | stripOffset = nStripC+nStripB+nStripA+nStripB; |
| 559 | break; |
| 560 | default: |
| 561 | stripOffset=-1; |
| 562 | break; |
| 563 | }; |
| 564 | |
| 565 | if (stripOffset<0 || stripOffset>92) return -1; |
| 566 | else |
| 567 | return (stripOffset+istrip); |
| 568 | } |
| 569 | |
| 570 | //----------------------------------------------------------------- |
| 571 | Double_t AliAnalysisTaskTOFqaID::GetPhiAtTPCouterRadius(AliESDtrack * track) |
| 572 | { |
| 573 | //get track phi at TPC outer radius |
| 574 | if (!track) return 1e10; |
| 575 | Double_t tpcoutcoord[3]={0.,0.,0.}; |
| 576 | track->GetOuterXYZ(tpcoutcoord); |
| 577 | Double_t phiOuterTPC=TMath::ATan2(tpcoutcoord[1],tpcoutcoord[0])*TMath::RadToDeg(); |
| 578 | if (phiOuterTPC<0) |
| 579 | phiOuterTPC+= (2*TMath::Pi()*TMath::RadToDeg()); |
| 580 | return phiOuterTPC; |
| 581 | } |
| 582 | //----------------------------------------------------------------- |
| 583 | Bool_t AliAnalysisTaskTOFqaID::IsEventSelected(AliESDEvent * event) |
| 584 | { |
| 585 | //select event based on primary vertex |
| 586 | if (!event) { |
| 587 | AliError("Invalid ESD event"); |
| 588 | return kFALSE; |
| 589 | } |
| 590 | fVertex = (AliESDVertex*) event->GetPrimaryVertexTracks(); |
| 591 | if(fVertex->GetNContributors()<1) { |
| 592 | // SPD vertex |
| 593 | fVertex = (AliESDVertex*) event->GetPrimaryVertexSPD(); |
| 594 | if(fVertex->GetNContributors()<1) fVertex = 0x0; |
| 595 | } |
| 596 | if (!fVertex) return kFALSE; |
| 597 | if (TMath::Abs(fVertex->GetZv())<10.0) return kTRUE; |
| 598 | else return kFALSE; |
| 599 | } |
| 600 | |
| 601 | //----------------------------------------------------------------- |
| 602 | Bool_t AliAnalysisTaskTOFqaID::IsTPCTOFMatched(AliESDtrack * track) |
| 603 | { |
| 604 | //defines TOF matching |
| 605 | if (!track){ |
| 606 | AliWarning("Invalid track object"); |
| 607 | return kFALSE; |
| 608 | } |
| 609 | |
| 610 | if ( (track->IsOn(AliESDtrack::kTOFout)) && |
| 611 | (track->IsOn(AliESDtrack::kTIME)) && |
| 612 | (track->IsOn(AliESDtrack::kTPCout)) ) |
| 613 | return kTRUE; |
| 614 | else |
| 615 | return kFALSE; |
| 616 | } |
| 617 | //----------------------------------------------------------------- |
| 618 | Bool_t AliAnalysisTaskTOFqaID::IsInTRD(AliESDtrack * track) |
| 619 | { |
| 620 | //defines cut to select particles in/out TRD |
| 621 | if (!track){ |
| 622 | AliWarning("Invalid track object"); |
| 623 | return kFALSE; |
| 624 | } |
| 625 | |
| 626 | if ( track->IsOn(AliESDtrack::kTPCout) |
| 627 | && track->IsOn(AliESDtrack::kTRDout) ) |
| 628 | return kTRUE; |
| 629 | else |
| 630 | return kFALSE; |
| 631 | } |
| 632 | //----------------------------------------------------------------- |
| 633 | void AliAnalysisTaskTOFqaID::FillStartTimeMaskHisto(TString suffix) |
| 634 | { |
| 635 | /* set pid response to use best_T0 and for each |
| 636 | accepted track fills the histogram with the |
| 637 | used start time |
| 638 | */ |
| 639 | |
| 640 | //set response best_t0 |
| 641 | //fESDpid->SetTOFResponse(fESD,AliESDpid::kBest_T0); |
| 642 | |
| 643 | for (Int_t iTracks = 0; iTracks < fESD->GetNumberOfTracks(); iTracks++) { |
| 644 | AliESDtrack* track = fESD->GetTrack(iTracks); |
| 645 | if (!track) { |
| 646 | Printf("ERROR: Could not receive track %d", iTracks); |
| 647 | continue; |
| 648 | } |
| 649 | //primary tracks selection: kTPCrefit and std cuts |
| 650 | if (fTrackFilter){ |
| 651 | if(!fTrackFilter->IsSelected(track)) continue; |
| 652 | } |
| 653 | else{ |
| 654 | Printf("No track filter found, skipping the track loop"); |
| 655 | break; |
| 656 | } |
| 657 | if (TMath::Abs(track->Eta())>0.8) continue; //cut for acceptance |
| 658 | |
| 659 | Int_t StartTimeBit = fESDpid->GetTOFResponse().GetStartTimeMask(track->P()); |
| 660 | ((TH2F*)fHlistTimeZero->FindObject(Form("hStartTimeMask%s",suffix.Data())))->Fill(track->P(),StartTimeBit); |
| 661 | |
| 662 | //matched tracks selection: kTOFout and kTIME |
| 663 | if ( (track->IsOn(AliESDtrack::kTOFout)) && |
| 664 | (track->IsOn(AliESDtrack::kTIME)) && |
| 665 | (track->IsOn(AliESDtrack::kTPCout)) ) { |
| 666 | ((TH2F*)fHlistTimeZero->FindObject(Form("hStartTimeMaskMatched%s",suffix.Data())))->Fill(track->P(),StartTimeBit); |
| 667 | } |
| 668 | } |
| 669 | return; |
| 670 | } |
| 671 | |
| 672 | //---------------------------------------------------- |
| 673 | Bool_t AliAnalysisTaskTOFqaID::ComputeTimeZeroByTOF1GeV() |
| 674 | { |
| 675 | /* compute T0-TOF for tracks within momentum range [0.95, 1.05] */ |
| 676 | /* init T0-TOF */ |
| b0471367 |
677 | AliTOFT0v1 *fTOFT0v1 = new AliTOFT0v1(fESDpid); // TOF-T0 v1 |
| 9310e980 |
678 | fTOFT0v1->Init(fESD); |
| 9310e980 |
679 | fTOFT0v1->DefineT0("all", 0.95, 1.05); |
| 680 | fMyTimeZeroTOF = -1000. * fTOFT0v1->GetResult(0); |
| 681 | fMyTimeZeroTOFsigma = 1000. * fTOFT0v1->GetResult(1); |
| 682 | fMyTimeZeroTOFtracks = fTOFT0v1->GetResult(3); |
| 683 | Bool_t hasTimeZeroTOF = kFALSE; |
| 684 | /* check T0-TOF sigma */ |
| 685 | if (fMyTimeZeroTOFsigma < 250.) |
| 686 | hasTimeZeroTOF = kTRUE; |
| 687 | return hasTimeZeroTOF; |
| 688 | } |
| 689 | |
| 690 | //------------------------------------------------------ |
| 691 | TString AliAnalysisTaskTOFqaID::GetSpeciesName(Int_t absPdgCode) |
| 692 | { |
| 693 | //returns name of selected specie |
| 694 | TString name; |
| 695 | switch (absPdgCode){ |
| 696 | case 11: |
| 697 | name = "electron"; |
| 698 | break; |
| 699 | case 13: |
| 700 | name = "muon"; |
| 701 | break; |
| 702 | case 211: |
| 703 | name = "pion"; |
| 704 | break; |
| 705 | case 321: |
| 706 | name = "kaon"; |
| 707 | break; |
| 708 | case 2212: |
| 709 | name = "proton"; |
| 710 | break; |
| 711 | default: |
| 712 | name = "noPID"; |
| 713 | break; |
| 714 | } |
| 715 | return name.Data(); |
| 716 | } |
| 717 | |
| 718 | //----------------------------------------------- |
| 719 | Bool_t AliAnalysisTaskTOFqaID::SelectMCspecies(AliMCEvent * ev, AliESDtrack * track) |
| 720 | { |
| 721 | // |
| 722 | //Retrieves particle true ID from MC and selects the desired species |
| 723 | // |
| 724 | if ((!ev) || (!track)) { |
| 725 | AliError("SelectMCspecies - Invalid object set as argument"); |
| 726 | return kFALSE; |
| 727 | } |
| 728 | |
| 729 | if (fSelectedPdg==0) return kTRUE; //if fSelectedPdg==0, no species selection is applied |
| 730 | |
| 731 | Long_t label = track->GetLabel(); |
| 732 | if (label<0) return kFALSE; |
| 733 | |
| 734 | // get number of particles |
| 735 | Long_t nMC = ev->GetNumberOfTracks(); |
| 736 | // if label too large --> failed |
| 737 | if (label>= nMC) { |
| 738 | AliWarning(Form("Stack overflow: track label = %li -- stack maximum = %li", label, nMC)); |
| 739 | return kFALSE; |
| 740 | } |
| 741 | // retrieve particle |
| 742 | AliMCParticle *mcPart = (AliMCParticle *)ev->GetTrack(label); |
| 743 | if (!mcPart) {// if particle = NULL --> failed |
| 744 | AliWarning(Form("Stack discontinuity: label %li refers to a NULL object", label)); |
| 745 | return kFALSE; |
| 746 | } |
| 747 | |
| 748 | Int_t pdgCode = mcPart->PdgCode(); |
| 749 | if (!(TMath::Abs(pdgCode)==fSelectedPdg)) |
| 750 | return kFALSE; |
| 751 | else //Printf("Found particle with selected pdg code = %i", pdgCode); |
| 752 | return kTRUE; |
| 753 | } |
| 754 | |
| 755 | //---------------------------------------------------------------------------------- |
| 756 | Bool_t AliAnalysisTaskTOFqaID::ComputeMatchingEfficiency(TList* list, TString variable) |
| 757 | { |
| 758 | //computes matching efficiency from previously filled histos |
| 759 | // to be called in terminate function |
| 760 | if (!list) return kFALSE; |
| 761 | |
| 762 | TString matchedName, primaryName, xAxisTitle; |
| 763 | if (variable.Contains("pt")) { |
| 764 | matchedName = "hTOFmatchedESDPt"; |
| 765 | primaryName = "hESDprimaryTrackPt"; |
| 766 | xAxisTitle = "p_{T} (GeV/c)"; |
| 767 | } |
| 768 | if (variable.Contains("eta")) { |
| 769 | matchedName = "hTOFmatchedESDeta"; |
| 770 | primaryName = "hTOFprimaryESDeta"; |
| 771 | xAxisTitle = "#eta"; |
| 772 | } |
| 773 | if (variable.Contains("phi")) { |
| 774 | matchedName = "hTOFmatchedESDphi"; |
| 775 | primaryName = "hTOFprimaryESDphi"; |
| 776 | xAxisTitle = "#phi_vtx (deg)"; |
| 777 | } |
| 9310e980 |
778 | |
| 779 | TH1D*hDummy = ((TH1D*)list->FindObject(matchedName.Data())); |
| 780 | if (!hDummy) return 0; |
| 4241f42c |
781 | |
| 9310e980 |
782 | TH1D*hMatchingEff = (TH1D*) hDummy->Clone("hMatchingEff"); |
| 783 | hMatchingEff->SetNameTitle(Form("hMatchingEff_%s", variable.Data()),Form("Matching efficiency vs %s", variable.Data())); |
| 784 | hMatchingEff->Divide((TH1F*) list->FindObject(primaryName.Data())); |
| 785 | hMatchingEff->GetXaxis()->SetTitle(xAxisTitle.Data()); |
| 786 | hMatchingEff->GetYaxis()->SetRangeUser(0.0,1.0); |
| 787 | hMatchingEff->GetYaxis()->SetTitle("#epsilon_{match}"); |
| 788 | list->AddLast(hMatchingEff); |
| 789 | return 1; |
| 790 | } |
| 791 | //---------------------------------------------------------------------------------- |
| 792 | void AliAnalysisTaskTOFqaID::HistogramMakeUp(TH1* hist, Color_t color, Int_t markerStyle, TString drawOpt, TString newName, TString newTitle, TString xTitle, TString yTitle) |
| 793 | { |
| 794 | //set histogram style and axes style at once |
| 795 | if (!hist) return; |
| 796 | if (!newName.IsNull()) hist->SetName(newName.Data()); |
| 797 | if (!newTitle.IsNull()) hist->SetTitle(newTitle.Data()); |
| 798 | if (!xTitle.IsNull()) hist->GetXaxis()->SetTitle(xTitle.Data()); |
| 799 | if (!yTitle.IsNull()) hist->GetYaxis()->SetTitle(yTitle.Data()); |
| 800 | hist->SetLineColor(color); |
| 801 | hist->SetMarkerColor(color); |
| 802 | hist->SetMarkerStyle(markerStyle); |
| 803 | hist->SetMarkerSize(0.7); |
| 804 | hist->SetDrawOption(drawOpt.Data()); |
| 805 | hist->Sumw2(); |
| 806 | return; |
| 807 | } |
| 808 | |
| 809 | //---------------------------------------------------------------------------------- |
| 810 | void AliAnalysisTaskTOFqaID::AddTofBaseHisto(TList *list, Int_t charge, TString suffix) |
| 811 | { |
| 812 | //Creates histograms for monitoring TOF signal, time alignement and matching-related quantities |
| 813 | if (!list){ |
| 814 | AliError("Invalid list passed as argument."); |
| 815 | return; |
| 816 | } |
| 817 | |
| 818 | TString cLabel; |
| 819 | if (charge<0) cLabel.Form("neg"); |
| 820 | else |
| 821 | if (charge>0) cLabel.Form("pos"); |
| 822 | else cLabel.Form("all"); |
| 823 | |
| 824 | TH1I* hTOFmulti = new TH1I(Form("hTOFmulti%s_%s",suffix.Data(), cLabel.Data()), Form("%s matched trk per event (|#eta|#leq0.8, p_{T}#geq0.3 GeV/c)", cLabel.Data()), 100, 0, 100); |
| 825 | HistogramMakeUp(hTOFmulti, ((charge>0)? kRed : kBlue+2), 1, "E1", "","", "N","events"); |
| 826 | list->AddLast(hTOFmulti); |
| 827 | |
| 828 | TH1F* hTOFtime = new TH1F(Form("hTime%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk TOF signal", cLabel.Data()), 250, 0., 610. ) ; |
| 829 | HistogramMakeUp(hTOFtime,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "t (ns)","tracks"); |
| 830 | list->AddLast(hTOFtime); |
| 831 | |
| 832 | TH1F* hTOFrawTime = new TH1F(Form("hRawTime%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk TOF raw signal", cLabel.Data()), 250, 0., 610. ) ; |
| 833 | HistogramMakeUp(hTOFrawTime,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "t_{raw} (ns)","tracks"); |
| 834 | list->AddLast(hTOFrawTime); |
| 835 | |
| 836 | TH1F* hTOFtot = new TH1F(Form("hTot%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk ToT", cLabel.Data()), 50, 0., 50. ) ; |
| 837 | HistogramMakeUp(hTOFtot,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "ToT (ns)","tracks"); |
| 838 | list->AddLast(hTOFtot); |
| 839 | |
| 840 | TH1F* hMatchedL = new TH1F(Form("hMatchedL%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk lenght", cLabel.Data()), 1200, -400., 800) ; |
| 841 | HistogramMakeUp(hMatchedL,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "L (cm)","tracks"); |
| 842 | list->AddLast(hMatchedL); |
| 843 | |
| 844 | TH2F* hMatchedDxVsPt = new TH2F(Form("hMatchedDxVsPt%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk dx vs.p_{T}", cLabel.Data()), 1000,0.,10.,200, -10., 10.) ; |
| 845 | HistogramMakeUp(hMatchedDxVsPt,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "GeV/c (p_{T})","dx (cm)"); |
| 846 | list->AddLast(hMatchedDxVsPt); |
| 847 | |
| 848 | TH2F* hMatchedDzVsStrip = new TH2F(Form("hMatchedDzVsStrip%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk dz vs. strip (#eta)", cLabel.Data()), 92,0.,92.,200, -10., 10.) ; |
| 849 | HistogramMakeUp(hMatchedDzVsStrip,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "strip","dz (cm)"); |
| 850 | list->AddLast(hMatchedDzVsStrip) ; |
| 851 | |
| 852 | TProfile *hMatchedDxVsCh = new TProfile(Form("hMatchedDxVsCh%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk dx vs. channel", cLabel.Data()), 157248., 0.,157248.); |
| 853 | HistogramMakeUp(hMatchedDxVsCh,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "channel","dx (cm)"); |
| 854 | list->AddLast(hMatchedDxVsCh); |
| 855 | |
| 856 | TProfile *hMatchedDzVsCh = new TProfile(Form("hMatchedDzVsCh%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk dz vs. channel", cLabel.Data()), 157248., 0.,157248.); |
| 857 | HistogramMakeUp(hMatchedDzVsCh,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "channel","dz (cm)"); |
| 858 | list->AddLast(hMatchedDzVsCh); |
| 859 | |
| 860 | return; |
| 861 | } |
| 862 | |
| 863 | //---------------------------------------------------------------------------------- |
| 864 | void AliAnalysisTaskTOFqaID::AddMatchingEffHisto(TList *list, Int_t charge, TString suffix) |
| 865 | { |
| 866 | if (!list){ |
| 867 | AliError("Invalid list passed as argument."); |
| 868 | return; |
| 869 | } |
| 870 | TString cLabel; |
| 871 | if (charge<0) cLabel.Form("neg"); else if (charge>0) cLabel.Form("pos"); else cLabel.Form("all"); |
| 872 | |
| 873 | TH1F* hMatchedP = new TH1F(Form("hMatchedP%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p", cLabel.Data()), 1000,0.,10.) ; |
| 874 | HistogramMakeUp(hMatchedP,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "L (cm)","tracks"); |
| 875 | list->AddLast(hMatchedP) ; |
| 876 | |
| 877 | TH1F* hMatchedPt = new TH1F(Form("hMatchedPt%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p_{T}", cLabel.Data()), 1000,0.,10.) ; |
| 878 | HistogramMakeUp(hMatchedPt,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "p_{T} (GeV/c)","tracks"); |
| 879 | list->AddLast(hMatchedPt) ; |
| 880 | |
| 881 | TH1F* hMatchedEta = new TH1F(Form("hMatchedEta%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #eta", cLabel.Data()), 200, -1., 1.) ; |
| 882 | HistogramMakeUp(hMatchedEta,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "#eta","tracks"); |
| 883 | list->AddLast(hMatchedEta) ; |
| 884 | |
| 885 | TH1F* hMatchedPhi = new TH1F(Form("hMatchedPhi%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #phi_{vtx}", cLabel.Data()), 72, 0., 360.) ; |
| 886 | HistogramMakeUp(hMatchedPhi,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "#phi_{vtx} (deg)","tracks"); |
| 887 | list->AddLast(hMatchedPhi) ; |
| 888 | |
| 889 | TH2F* hMatchedPtVsOutPhi = new TH2F(Form("hMatchedPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p_{T} vs. #phi_{TPC out}", cLabel.Data()), 72, 0.0, 360.0, 1000,0.,10.) ; |
| 890 | HistogramMakeUp(hMatchedPtVsOutPhi,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "#phi_{TPC out} (deg)","p_{T} (GeV/c)"); |
| 891 | list->AddLast(hMatchedPtVsOutPhi) ; |
| 892 | |
| 893 | TH1F* hPrimaryP = new TH1F(Form("hPrimaryP%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p", cLabel.Data()), 1000,0.,10.) ; |
| 894 | HistogramMakeUp(hPrimaryP,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "L (cm)","tracks"); |
| 895 | list->AddLast(hPrimaryP) ; |
| 896 | |
| 897 | TH1F* hPrimaryPt = new TH1F(Form("hPrimaryPt%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p_{T}", cLabel.Data()), 1000,0.,10.) ; |
| 898 | HistogramMakeUp(hPrimaryPt,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "p_{T} (GeV/c)","tracks"); |
| 899 | list->AddLast(hPrimaryPt) ; |
| 900 | |
| 901 | TH1F* hPrimaryEta = new TH1F(Form("hPrimaryEta%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #eta", cLabel.Data()), 200, -1., 1.) ; |
| 902 | HistogramMakeUp(hPrimaryEta,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "#eta","tracks"); |
| 903 | list->AddLast(hPrimaryEta) ; |
| 904 | |
| 905 | TH1F* hPrimaryPhi = new TH1F(Form("hPrimaryPhi%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #phi_{vtx}", cLabel.Data()), 72, 0., 360.) ; |
| 906 | HistogramMakeUp(hPrimaryPhi,((charge>0)? kRed+2 : kBlue+2), 1, "E1", "","", "#phi_{vtx} (deg)","tracks"); |
| 907 | list->AddLast(hPrimaryPhi) ; |
| 908 | |
| 909 | TH2F* hPrimaryPtVsOutPhi = new TH2F(Form("hPrimaryPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk p_{T} vs. #phi_{TPC out}", cLabel.Data()), 72, 0.0, 360.0, 1000,0.,10.) ; |
| 910 | HistogramMakeUp(hPrimaryPtVsOutPhi,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "#phi_{TPC out} (deg)","p_{T} (GeV/c)"); |
| 911 | list->AddLast(hPrimaryPtVsOutPhi) ; |
| 912 | return; |
| 913 | } |
| 914 | |
| 915 | //---------------------------------------------------------------------------------- |
| 916 | void AliAnalysisTaskTOFqaID::AddPidHisto(TList *list, Int_t charge, TString suffix) |
| 917 | { |
| 918 | //Creates histograms for monitoring TOF PID |
| 919 | if (!list){ |
| 920 | AliError("Invalid list passed as argument."); |
| 921 | return; |
| 922 | } |
| 923 | TString cLabel; |
| 924 | if (charge<0) cLabel.Form("neg"); else if (charge>0) cLabel.Form("pos"); else cLabel.Form("all"); |
| 925 | |
| 926 | TH2F* hMatchedBetaVsP = new TH2F(Form("hMatchedBetaVsP%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched trk #beta vs. p", cLabel.Data()), 1000, 0.0, 10.0, 150, 0., 1.5) ; |
| 927 | HistogramMakeUp(hMatchedBetaVsP,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","", "p (GeV/c)","#beta"); |
| 928 | list->AddLast(hMatchedBetaVsP); |
| 929 | |
| 930 | TH1F* hMatchedMass= new TH1F(Form("hMatchedMass%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched p.le M", cLabel.Data()), 500, 0., 5. ); |
| 931 | HistogramMakeUp(hMatchedMass,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "M (GeV/c^{2})","entries"); |
| 932 | list->AddLast(hMatchedMass); |
| 933 | |
| 934 | TH1F* hMatchedMass2= new TH1F(Form("hMatchedMass2%s_%s",suffix.Data(),cLabel.Data()), Form("%s matched p.le M^{2}", cLabel.Data()), 500, 0., 10. ); |
| 935 | HistogramMakeUp(hMatchedMass2,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "M^{2} (GeV^{2}/c^{4})","entries"); |
| 936 | list->AddLast(hMatchedMass2); |
| 937 | |
| 938 | TH2F* hExpTimePiVsStrip = new TH2F(Form("hExpTimePiVsStrip%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{#pi,exp} vs strip",cLabel.Data()), 92, 0, 92, fnExpTimeSmallBins, fExpTimeSmallRangeMin, fExpTimeSmallRangeMax) ; |
| 939 | HistogramMakeUp(hExpTimePiVsStrip,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "strip (#eta)","t_{TOF}-t_{#pi,exp} [ps]"); |
| 940 | list->AddLast(hExpTimePiVsStrip); |
| 941 | |
| 942 | TH2F* hExpTimePiT0Sub1GeV = new TH2F(Form("hExpTimePiT0Sub1GeV%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk (0.95#leq p_{T}#leq 1.05 GeV/c) t_{TOF}-t_{#pi,exp}-t_{0}^{TOF}",cLabel.Data()), 500, 0., 500., fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 943 | HistogramMakeUp(hExpTimePiT0Sub1GeV,((charge>0)? kRed+2 : kBlue+2), 1, "colz", "","","n. tracks used for t_{0}^{TOF}","t_{TOF}-t_{#pi,exp}-t_{0}^{TOF}"); |
| 944 | list->AddLast(hExpTimePiT0Sub1GeV) ; |
| b32dee71 |
945 | |
| 946 | TH1F* hExpTimePiFillSub = new TH1F(Form("hExpTimePiFillSub%s_%s",suffix.Data(),cLabel.Data()), "%s trk t_{TOF}-t_{#pi,exp}-t_{0,fill}; t_{TOF}-t_{#pi,exp} -_{0,fill} [ps];entries", fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 947 | list->AddLast(hExpTimePiFillSub) ; |
| 948 | |
| 9310e980 |
949 | TH1F* hExpTimePi = new TH1F(Form("hExpTimePi%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{#pi,exp}",cLabel.Data()), fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 950 | HistogramMakeUp(hExpTimePi,((charge>0)? kRed+2 : kBlue+2), 1, "", "","", "t_{TOF}-t_{#pi,exp} [ps]","tracks"); |
| 951 | list->AddLast(hExpTimePi); |
| 952 | |
| 953 | TH2F* hExpTimePiVsP = new TH2F(Form("hExpTimePiVsP%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{#pi,exp}",cLabel.Data()), 1000, 0.0, 10.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 954 | HistogramMakeUp(hExpTimePiVsP,kRed+2, 1, "colz", "","", "p (GeV/c)","t_{TOF}-t_{#pi,exp} [ps]"); |
| 955 | list->AddLast(hExpTimePiVsP); |
| 956 | |
| 957 | TH2F* hExpTimeKaVsP = new TH2F(Form("hExpTimeKaVsP%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{K,exp}",cLabel.Data()), 1000, 0.0, 10.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 958 | HistogramMakeUp(hExpTimeKaVsP,kBlue+2, 1, "colz", "","", "p (GeV/c)","t_{TOF}-t_{K,exp} [ps]"); |
| 959 | list->AddLast(hExpTimeKaVsP); |
| 960 | |
| 961 | TH2F* hExpTimeProVsP = new TH2F(Form("hExpTimeProVsP%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{p,exp}",cLabel.Data()),1000, 0.0, 10.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 962 | HistogramMakeUp(hExpTimeProVsP,kGreen+2, 1, "colz", "","", "p (GeV/c)","t_{TOF}-t_{p,exp} [ps]"); |
| 963 | list->AddLast(hExpTimeProVsP); |
| 964 | |
| 965 | TH2F* hTOFpidSigmaPi = new TH2F(Form("hTOFpidSigmaPi%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk n#sigma^{TOF}_{#pi} vs p_{T}",cLabel.Data()), 500,0.,5.,200, -10., 10. ) ; |
| 966 | HistogramMakeUp(hTOFpidSigmaPi,kRed+2, 1, "colz", "","", "p (GeV/c)","n#sigma_{#pi,exp} [ps]"); |
| 967 | list->AddLast(hTOFpidSigmaPi) ; |
| 968 | |
| 969 | TH2F* hTOFpidSigmaKa = new TH2F(Form("hTOFpidSigmaKa%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk n#sigma^{TOF}_{K} vs p_{T}",cLabel.Data()), 500, 0.,5.,200, -10., 10. ) ; |
| 970 | HistogramMakeUp(hTOFpidSigmaKa,kBlue+2, 1, "colz", "","", "p (GeV/c)","n#sigma_{K,exp} [ps]"); |
| 971 | list->AddLast(hTOFpidSigmaKa) ; |
| 972 | |
| 973 | TH2F* hTOFpidSigmaPro = new TH2F(Form("hTOFpidSigmaPro%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk TOF n#sigma^{TOF}_{p} vs p_{T}",cLabel.Data()), 500, 0.,5.,200, -10., 10. ) ; |
| 974 | HistogramMakeUp(hTOFpidSigmaPro,kGreen+2, 1, "colz", "","","p (GeV/c)","n#sigma_{p,exp} [ps]"); |
| 975 | list->AddLast(hTOFpidSigmaPro); |
| 976 | |
| 977 | TH2F* hExpTimePiT0SubVsP = new TH2F(Form("hExpTimePiT0SubVsP%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk t_{TOF}-t_{#pi,exp}-t_{0}^{TOF}",cLabel.Data()), 1000, 0.,10., fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 978 | HistogramMakeUp(hExpTimePiT0SubVsP,kRed+2, 1, "colz", "","","p (GeV/c)","t_{TOF}-t_{#pi,exp}-t_{0}^{TOF}"); |
| 979 | list->AddLast(hExpTimePiT0SubVsP) ; |
| 980 | |
| 981 | TH2F* hExpTimeKaT0SubVsP = new TH2F(Form("hExpTimeKaT0SubVsP%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk t_{TOF}-t_{K,exp}-t_{0}^{TOF}",cLabel.Data()), 1000, 0.,10., fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 982 | HistogramMakeUp(hExpTimeKaT0SubVsP,kBlue+2, 1, "colz", "","","p (GeV/c)","t_{TOF}-t_{K,exp}-t_{0}^{TOF}"); |
| 983 | list->AddLast(hExpTimeKaT0SubVsP) ; |
| 984 | |
| 985 | TH2F* hExpTimeProT0SubVsP = new TH2F(Form("hExpTimeProT0SubVsP%s_%s",suffix.Data(),cLabel.Data()), Form("%s trk t_{TOF}-t_{p,exp}-t_{0}^{TOF}",cLabel.Data()), 1000, 0.,10., fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 986 | HistogramMakeUp(hExpTimeProT0SubVsP,kGreen+2, 1, "colz", "","","p (GeV/c)","t_{TOF}-t_{p,exp}-t_{0}^{TOF}"); |
| 987 | list->AddLast(hExpTimeProT0SubVsP) ; |
| 988 | |
| 989 | TH2F* hExpTimePiVsOutPhi = new TH2F(Form("hExpTimePiVsOutPhi%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{#pi,exp} vs #phi_{TPC out}",cLabel.Data()), 72, 0.0, 360.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 990 | HistogramMakeUp(hExpTimePiVsOutPhi,kRed+2, 1, "colz", "","", "#phi_{TPC out} (deg)","t_{TOF}-t_{#pi,exp} [ps]"); |
| 991 | list->AddLast(hExpTimePiVsOutPhi); |
| 992 | |
| 993 | TH2F* hExpTimeKaVsOutPhi = new TH2F(Form("hExpTimeKaVsOutPhi%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{K,exp} vs #phi_{TPC out}",cLabel.Data()), 72, 0.0, 360.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 994 | HistogramMakeUp(hExpTimeKaVsOutPhi,kBlue+2, 1, "colz", "","", "#phi_{TPC out} (deg)","t_{TOF}-t_{K,exp} [ps]"); |
| 995 | list->AddLast(hExpTimeKaVsOutPhi); |
| 996 | |
| 997 | TH2F* hExpTimeProVsOutPhi = new TH2F(Form("hExpTimeProVsOutPhi%s_%s",suffix.Data(),cLabel.Data()),Form("%s matched trk t_{TOF}-t_{p,exp} vs #phi_{TPC out}",cLabel.Data()), 72, 0.0, 360.0, fnExpTimeBins, fExpTimeRangeMin, fExpTimeRangeMax) ; |
| 998 | HistogramMakeUp(hExpTimeProVsOutPhi,kGreen+2, 1, "colz", "","", "#phi_{TPC out} (deg)","t_{TOF}-t_{p,exp} [ps]"); |
| 999 | list->AddLast(hExpTimeProVsOutPhi); |
| 1000 | |
| 1001 | return; |
| 1002 | } |
| 1003 | //---------------------------------------------------------------------------------- |
| 1004 | void AliAnalysisTaskTOFqaID::AddStartTimeHisto(TList *list, TString suffix) |
| 1005 | { |
| 1006 | //Creates histograms for monitoring T0 signal and start-time related quantities |
| 1007 | if (!list){ |
| 1008 | AliError("Invalid list passed as argument."); |
| 1009 | return; |
| 1010 | } |
| 1011 | TH1D* hT0AC = new TH1D(Form("hT0AC%s",suffix.Data()), "Event timeZero from T0A&C; t_{0,AC} [ps]; events", 1000, -25000., 25000. ) ; |
| 1012 | HistogramMakeUp(hT0AC, kRed+2, 20, "", "","","",""); |
| 1013 | list->AddLast(hT0AC); |
| 1014 | |
| 1015 | TH1D* hT0A = new TH1D(Form("hT0A%s",suffix.Data()), "Event timeZero from T0A; t_{0,A} [ps]; events", 1000, -25000., 25000. ) ; |
| 1016 | HistogramMakeUp(hT0A, kBlue+2, 25, "", "","","",""); |
| 1017 | list->AddLast(hT0A); |
| 1018 | |
| 1019 | TH1D* hT0C = new TH1D(Form("hT0C%s",suffix.Data()), "Event timeZero from T0C; t_{0,C} [ps]; events", 1000, -25000., 25000. ) ; |
| 1020 | HistogramMakeUp(hT0C, kGreen+2, 28, "", "","","",""); |
| 1021 | list->AddLast(hT0C); |
| 1022 | |
| 1023 | TH1D* hT0DetRes = new TH1D(Form("hT0DetRes%s",suffix.Data()), "T0 detector (T0A-T0C)/2; (T0A-T0C)/2 [ps]; events", 200, -500.,500. ) ; |
| 1024 | HistogramMakeUp(hT0DetRes, kMagenta+1, 1, "", "","","",""); |
| 1025 | list->AddLast(hT0DetRes) ; |
| 1026 | |
| 1027 | TH1F* hT0fill = new TH1F(Form("hT0fill%s",suffix.Data()), "Event timeZero of fill; t_{0,fill} [ps]; events", 1000, -25000., 25000. ) ; |
| 1028 | HistogramMakeUp(hT0fill, kOrange+1, 25, "", "","","",""); |
| 1029 | list->AddLast(hT0fill) ; |
| 1030 | |
| 1031 | TH1F* hT0TOF = new TH1F(Form("hT0TOF%s",suffix.Data()), "Event timeZero estimated by TOF; t0 [ps]; events", 1000, -25000., 25000. ) ; |
| 1032 | HistogramMakeUp(hT0TOF, kTeal-5, 21, "", "","","",""); |
| 1033 | list->AddLast(hT0TOF) ; |
| 1034 | |
| 1035 | TH1F* hT0T0 = new TH1F(Form("hT0T0%s",suffix.Data()), "Best timeZero between AC, A, C; t_{0} [ps]; events", 1000, -25000.,25000. ) ; |
| 1036 | HistogramMakeUp(hT0T0, kAzure+7, 26, "", "","","",""); |
| 1037 | list->AddLast(hT0T0) ; |
| 1038 | |
| 1039 | TH1F* hT0best = new TH1F(Form("hT0best%s",suffix.Data()), "Event timeZero estimated as T0best; t0 [ps]; events", 1000, -25000.,25000. ) ; |
| 1040 | HistogramMakeUp(hT0best, kBlack, 20, "", "","","",""); |
| 1041 | list->AddLast(hT0best) ; |
| 1042 | |
| 1043 | TH1F* hT0fillRes = new TH1F(Form("hT0fillRes%s",suffix.Data()), "Resolution of fillT0; #sigma_{fillT0} [ps];events", 250, 0.,250. ) ; |
| 1044 | HistogramMakeUp(hT0fillRes, kOrange+1, 25, "", "","","",""); |
| 1045 | list->AddLast(hT0fillRes) ; |
| 1046 | |
| 1047 | TH1F* hT0TOFRes = new TH1F(Form("hT0TOFRes%s",suffix.Data()), "Resolution of timeZero from TOF; #sigma_{TOFT0} [ps];events", 250, 0.,250. ) ; |
| 1048 | HistogramMakeUp(hT0TOFRes, kTeal-5, 21, "", "","","",""); |
| 1049 | list->AddLast(hT0TOFRes) ; |
| 1050 | |
| 1051 | TH1F* hT0T0Res = new TH1F(Form("hT0T0Res%s",suffix.Data()), "Resolution of timeZero from T0;#sigma_{T0T0} [ps];events", 250, -0., 250. ) ; |
| 1052 | HistogramMakeUp(hT0T0Res, kAzure+7, 26, "", "","","",""); |
| 1053 | list->AddLast(hT0T0Res) ; |
| 1054 | |
| 1055 | TH1F* hT0bestRes = new TH1F(Form("hT0bestRes%s",suffix.Data()), "Resolution of bestT0; #sigma_{bestT0} [ps];events", 250, 0.,250. ) ; |
| 1056 | HistogramMakeUp(hT0bestRes, kBlack, 20, "", "","","",""); |
| 1057 | list->AddLast(hT0bestRes) ; |
| 1058 | |
| 1059 | TH2F* hT0TOFvsNtrk = new TH2F(Form("hT0TOFvsNtrk%s",suffix.Data()), "Event timeZero estimated by TOF vs. number of tracks in event;TOF-matching tracks; t0 [ps]", 100, 0., 100.,1000,-25000.,25000. ) ; |
| 1060 | HistogramMakeUp(hT0TOFvsNtrk, kTeal-5, 1, "colz", "","","",""); |
| 1061 | list->AddLast(hT0TOFvsNtrk) ; |
| 1062 | |
| 1063 | TH2F* hEventT0MeanVsVtx = new TH2F(Form("hEventT0MeanVsVtx%s",suffix.Data()), "T0 detector: mean vs vertex ; (t0_{A}-t0_{C})/2 [ns]; (t0_{A}+t0_{C})/2 [ns]; events", 500, -25., 25., 500, -25., 25. ) ; |
| 1064 | HistogramMakeUp(hEventT0MeanVsVtx, kBlue+2, 1, "colz", "","","",""); |
| 1065 | list->AddLast(hEventT0MeanVsVtx) ; |
| 1066 | |
| 1067 | TH2F* hEventV0MeanVsVtx = new TH2F(Form("hEventV0MeanVsVtx%s",suffix.Data()), "V0 detector: mean vs vertex ; (V0_{A}-V0_{C})/2 [ns]; (V0_{A}+V0_{C})/2 [ns]; events", 500, -50., 50., 500, -50., 50. ) ; |
| 1068 | HistogramMakeUp(hEventV0MeanVsVtx, kBlack, 1, "colz", "","","",""); |
| 1069 | list->AddLast(hEventV0MeanVsVtx) ; |
| 1070 | |
| 1071 | const Double_t startTimeMomBins[13]={ 0.0, 0.3, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.2, 1.5, 2., 3., 10.}; |
| 1072 | |
| 1073 | TH2F* hStartTimeMaskMatched = new TH2F(Form("hStartTimeMaskMatched%s",suffix.Data()),"Start Time Mask vs p bin for matched tracks; p(GeV/c);", 12, startTimeMomBins, 8,0.,8.); |
| 1074 | hStartTimeMaskMatched->GetYaxis()->SetBinLabel(1,"fill_t0"); |
| 1075 | hStartTimeMaskMatched->GetYaxis()->SetBinLabel(2,"tof_t0"); |
| 1076 | hStartTimeMaskMatched->GetYaxis()->SetBinLabel(3,"T0AC"); |
| 1077 | hStartTimeMaskMatched->GetYaxis()->SetBinLabel(4,"T0AC & tof_t0"); |
| 1078 | hStartTimeMaskMatched->GetYaxis()->SetBinLabel(5,"T0A"); |
| 1079 | hStartTimeMaskMatched->GetYaxis()->SetBinLabel(6,"T0A & tof_t0"); |
| 1080 | hStartTimeMaskMatched->GetYaxis()->SetBinLabel(7,"T0C"); |
| 1081 | hStartTimeMaskMatched->GetYaxis()->SetBinLabel(8,"T0C & tof_t0"); |
| 1082 | HistogramMakeUp(hStartTimeMaskMatched, kRed+2, 1, "colz", "","","",""); |
| 1083 | list->AddLast(hStartTimeMaskMatched); |
| 1084 | |
| 1085 | TH2F* hStartTimeMask = new TH2F(Form("hStartTimeMask%s",suffix.Data()),"Start Time Mask vs p bin for primary tracks; p(GeV/c);", 12, startTimeMomBins, 8,0.,8.); |
| 1086 | hStartTimeMask->GetYaxis()->SetBinLabel(1,"fill_t0"); |
| 1087 | hStartTimeMask->GetYaxis()->SetBinLabel(2,"tof_t0"); |
| 1088 | hStartTimeMask->GetYaxis()->SetBinLabel(3,"T0AC"); |
| 1089 | hStartTimeMask->GetYaxis()->SetBinLabel(4,"T0AC & tof_t0"); |
| 1090 | hStartTimeMask->GetYaxis()->SetBinLabel(5,"T0A"); |
| 1091 | hStartTimeMask->GetYaxis()->SetBinLabel(6,"T0A & tof_t0"); |
| 1092 | hStartTimeMask->GetYaxis()->SetBinLabel(7,"T0C"); |
| 1093 | hStartTimeMask->GetYaxis()->SetBinLabel(8,"T0C & tof_t0"); |
| 1094 | HistogramMakeUp(hStartTimeMask, kRed+2, 1, "colz", "","","",""); |
| 1095 | list->AddLast(hStartTimeMask); |
| 1096 | |
| 1097 | return; |
| 1098 | } |
| 1099 | //---------------------------------------------------------------------------------- |
| 1100 | void AliAnalysisTaskTOFqaID::AddTrdHisto() |
| 1101 | { |
| 1102 | //Creates histograms for monitoring TOF base quantities wrt TRD/no TRD selection |
| 1103 | if (!fHlistTRD){ |
| 1104 | AliError("Invalid TRD list"); |
| 1105 | return; |
| 1106 | } |
| 1107 | |
| 1108 | AddMatchingEffHisto(fHlistTRD, 1, "_noTrd"); |
| 1109 | AddMatchingEffHisto(fHlistTRD, -1, "_noTrd"); |
| 1110 | AddMatchingEffHisto(fHlistTRD, 1, "_Trd"); |
| 1111 | AddMatchingEffHisto(fHlistTRD, -1, "_Trd"); |
| 1112 | |
| 1113 | AddPidHisto(fHlistTRD, 1, "_noTrd"); |
| 1114 | AddPidHisto(fHlistTRD, -1, "_noTrd"); |
| 1115 | AddPidHisto(fHlistTRD, 1, "_Trd"); |
| 1116 | AddPidHisto(fHlistTRD, -1, "_Trd"); |
| 1117 | return; |
| 1118 | } |
| 1119 | |
| 1120 | |
| 1121 | //---------------------------------------------------------------------------------- |
| 1122 | void AliAnalysisTaskTOFqaID::AddTofTrgHisto(TString suffix) |
| 1123 | { |
| 1124 | //defines histo with trigger info |
| 1125 | if (!fHlistTrigger){ |
| 1126 | AliError("Invalid TOF trigger list"); |
| 1127 | return; |
| 1128 | } |
| 1129 | |
| 1130 | TH1I* hFiredMaxipad = new TH1I(Form("hFiredMaxipad%s",suffix.Data()), Form("Fired maxipad per event"), 1584, 0, 1584); |
| 1131 | HistogramMakeUp(hFiredMaxipad, kBlue+2, 1, "E1", "","", "N_{maxipad}","events"); |
| 1132 | fHlistTrigger->AddLast(hFiredMaxipad); |
| 1133 | |
| 1134 | TH1I* hFiredReadoutPad = new TH1I(Form("hFiredReadoutPad%s",suffix.Data()), Form("Fired readout pad per event"), 153000, 0, 153000); |
| 1135 | HistogramMakeUp(hFiredReadoutPad, kRed+2, 1, "E1", "","", "N_{pad}","events"); |
| 1136 | fHlistTrigger->AddLast(hFiredReadoutPad); |
| 1137 | |
| 1138 | TH1I* hFiredReadoutTrgPad = new TH1I(Form("hFiredReadoutTrgPad%s",suffix.Data()), Form("Fired readout pad in trg window"), 153000, 0, 153000); |
| 1139 | HistogramMakeUp(hFiredReadoutTrgPad, kBlack, 1, "E1", "","", "N_{pad} in trg window","events"); |
| 1140 | fHlistTrigger->AddLast(hFiredReadoutTrgPad); |
| 1141 | |
| 1142 | TH2I* hFiredMaxipadVsTrgPad = new TH2I(Form("hFiredMaxipadVsTrgPad%s",suffix.Data()), Form("Fired maxipad vs pads in trg window per event"), 100, 0, 100, 100, 0, 100); |
| 1143 | HistogramMakeUp(hFiredMaxipadVsTrgPad, kBlue+2, 1, "colz", "","", "N_{pad} in trg window","N_{maxipad}"); |
| 1144 | fHlistTrigger->AddLast(hFiredMaxipadVsTrgPad); |
| 1145 | |
| 1146 | TH2I* hTrgMap = new TH2I(Form("hTrgMap%s",suffix.Data()), Form("Map of fired maxipads"), 72, 0, 72, 22, 0, 22); |
| 1147 | HistogramMakeUp(hTrgMap, kBlue+2, 1, "colz", "","", "LTM","maxipad"); |
| 1148 | fHlistTrigger->AddLast(hTrgMap); |
| 1149 | |
| 1150 | return; |
| 1151 | } |
| 1152 | |
| 1153 | //---------------------------------------------------------------------------------- |
| 1154 | void AliAnalysisTaskTOFqaID::FillTofBaseHisto(AliESDtrack * track, Int_t charge, TString suffix) |
| 1155 | { |
| 1156 | //fill histo with TOF base quantities |
| 1157 | if (!track) return; |
| 1158 | |
| 1159 | // Double_t tofTime=track->GetTOFsignal();//in ps |
| 1160 | Double_t tofTimeRaw=track->GetTOFsignalRaw();//in ps |
| 1161 | Double_t tofToT=track->GetTOFsignalToT(); //in ps |
| 1162 | Int_t channel=track->GetTOFCalChannel(); |
| 1163 | Int_t volId[5]; //(sector, plate,strip,padZ,padX) |
| 1164 | AliTOFGeometry::GetVolumeIndices(channel,volId); |
| 1165 | TString cLabel; if (charge<0) cLabel.Form("neg"); else if (charge>0) cLabel.Form("pos"); else cLabel.Form("all"); |
| 1166 | |
| 1167 | ((TH1F*)fHlist->FindObject(Form("hTime%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTof); //ns |
| 1168 | ((TH1F*)fHlist->FindObject(Form("hRawTime%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofTimeRaw*1E-3); //ns |
| 1169 | ((TH1F*)fHlist->FindObject(Form("hTot%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofToT); |
| 1170 | ((TH1F*)fHlist->FindObject(Form("hMatchedL%s_%s", suffix.Data(), cLabel.Data())))->Fill(fL); |
| 1171 | ((TH2F*)fHlist->FindObject(Form("hMatchedDxVsPt%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt,track->GetTOFsignalDx()); |
| 1172 | ((TH2F*)fHlist->FindObject(Form("hMatchedDzVsStrip%s_%s",suffix.Data(),cLabel.Data())))->Fill((Int_t)GetStripIndex(volId),track->GetTOFsignalDz()); |
| 1173 | ((TProfile*)fHlist->FindObject(Form("hMatchedDxVsCh%s_%s",suffix.Data(),cLabel.Data())))->Fill(channel,track->GetTOFsignalDx()); |
| 1174 | ((TProfile*)fHlist->FindObject(Form("hMatchedDzVsCh%s_%s",suffix.Data(),cLabel.Data())))->Fill(channel,track->GetTOFsignalDz()); |
| 1175 | |
| 1176 | return; |
| 1177 | } |
| 1178 | //---------------------------------------------------------------------------------- |
| 1179 | void AliAnalysisTaskTOFqaID::FillPrimaryTrkHisto(Int_t charge, TString suffix) |
| 1180 | { |
| 1181 | // fill histos with primary tracks info |
| 1182 | // => denominator for matching efficiency |
| 1183 | TString cLabel; |
| 1184 | |
| 9310e980 |
1185 | if (charge<0) cLabel.Form("neg"); else if (charge>0) cLabel.Form("pos"); else cLabel.Form("all"); |
| 4241f42c |
1186 | if (suffix.Contains("Trd")) { |
| 1187 | ((TH1F*)fHlistTRD->FindObject(Form("hPrimaryP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP); |
| 1188 | ((TH1F*)fHlistTRD->FindObject(Form("hPrimaryPt%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt); |
| 1189 | if (fPt>=fMatchingMomCut) { |
| 1190 | ((TH1F*)fHlistTRD->FindObject(Form("hPrimaryEta%s_%s",suffix.Data(),cLabel.Data())))->Fill(fEta); |
| 1191 | ((TH1F*)fHlistTRD->FindObject(Form("hPrimaryPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPhi); |
| 1192 | ((TH2F*)fHlistTRD->FindObject(Form("hPrimaryPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,fPt); |
| 1193 | } |
| 1194 | } else { |
| 1195 | ((TH1F*)fHlist->FindObject(Form("hPrimaryP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP); |
| 1196 | ((TH1F*)fHlist->FindObject(Form("hPrimaryPt%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt); |
| 1197 | if (fPt>=fMatchingMomCut) { |
| 1198 | ((TH1F*)fHlist->FindObject(Form("hPrimaryEta%s_%s",suffix.Data(),cLabel.Data())))->Fill(fEta); |
| 1199 | ((TH1F*)fHlist->FindObject(Form("hPrimaryPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPhi); |
| 1200 | ((TH2F*)fHlist->FindObject(Form("hPrimaryPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,fPt); |
| 1201 | } |
| 9310e980 |
1202 | } |
| 1203 | return; |
| 1204 | } |
| 1205 | //---------------------------------------------------------------------------------- |
| 1206 | void AliAnalysisTaskTOFqaID::FillMatchedTrkHisto(Int_t charge, TString suffix) |
| 1207 | { |
| 1208 | //get matched tracks variables (matching cut to be applied externally) |
| 1209 | //=> numerator for matching efficiency |
| 1210 | TString cLabel; |
| 1211 | |
| 9310e980 |
1212 | if (charge<0) cLabel.Form("neg"); |
| 1213 | else |
| 1214 | if (charge>0) cLabel.Form("pos"); |
| 1215 | else cLabel.Form("all"); |
| 4241f42c |
1216 | |
| 1217 | if (suffix.Contains("Trd")) { |
| 1218 | ((TH1F*)fHlistTRD->FindObject(Form("hMatchedP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP); |
| 1219 | ((TH1F*)fHlistTRD->FindObject(Form("hMatchedPt%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt); |
| 1220 | if (fPt>=fMatchingMomCut) { |
| 1221 | ((TH1F*)fHlistTRD->FindObject(Form("hMatchedEta%s_%s",suffix.Data(),cLabel.Data())))->Fill(fEta); |
| 1222 | ((TH1F*)fHlistTRD->FindObject(Form("hMatchedPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPhi); |
| 1223 | ((TH2F*)fHlistTRD->FindObject(Form("hMatchedPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,fPt); |
| 1224 | } |
| 1225 | } else { |
| 1226 | ((TH1F*)fHlist->FindObject(Form("hMatchedP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP); |
| 1227 | ((TH1F*)fHlist->FindObject(Form("hMatchedPt%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPt); |
| 1228 | if (fPt>=fMatchingMomCut) { |
| 1229 | ((TH1F*)fHlist->FindObject(Form("hMatchedEta%s_%s",suffix.Data(),cLabel.Data())))->Fill(fEta); |
| 1230 | ((TH1F*)fHlist->FindObject(Form("hMatchedPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fPhi); |
| 1231 | ((TH2F*)fHlist->FindObject(Form("hMatchedPtVsOutPhi%s_%s",suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,fPt); |
| 1232 | } |
| 9310e980 |
1233 | } |
| 1234 | return; |
| 1235 | } |
| 1236 | |
| 1237 | //---------------------------------------------------------------------------------- |
| 1238 | void AliAnalysisTaskTOFqaID::FillPidHisto(AliESDtrack * track, Int_t charge, TString suffix) |
| 1239 | { |
| 1240 | //basic PID performance check |
| 1241 | if (fTof<=0) { |
| 1242 | printf("WARNING: track with negative TOF time found! Skipping this track for PID checks\n"); |
| 1243 | return; |
| 1244 | } |
| 1245 | if (fL<=0){ |
| 1246 | printf("WARNING: track with negative length found!Skipping this track for PID checks\n"); |
| 1247 | return; |
| 1248 | } |
| 1249 | if (!track) return; |
| 1250 | |
| 9310e980 |
1251 | TString cLabel; |
| 1252 | if (charge<0) cLabel.Form("neg"); |
| 1253 | else |
| 1254 | if (charge>0) cLabel.Form("pos"); |
| 1255 | else cLabel.Form("all"); |
| 1256 | |
| 1257 | //calculate beta |
| 1258 | Double_t c=TMath::C()*1.E-9;// m/ns |
| 1259 | Double_t mass=0.; //GeV |
| 1260 | Double_t length=fL*0.01; // in meters |
| 1261 | Double_t tof=fTof*c; |
| 1262 | Double_t beta=length/tof; |
| 1263 | Double_t fact= (tof/length)*(tof/length) -1.; |
| 1264 | Double_t fP2 = fP*fP; |
| 1265 | |
| 1266 | if(fact<=0) { |
| 1267 | mass = -fP*TMath::Sqrt(-fact); |
| 1268 | } else { |
| 1269 | mass = fP*TMath::Sqrt(fact); |
| 1270 | } |
| 1271 | |
| 4241f42c |
1272 | if (suffix.Contains("Trd")) { |
| 1273 | ((TH2F*) fHlistTRD->FindObject(Form("hMatchedBetaVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP,beta); |
| 1274 | ((TH1F*) fHlistTRD->FindObject(Form("hMatchedMass%s_%s",suffix.Data(),cLabel.Data())))->Fill(mass); |
| 1275 | ((TH1F*) fHlistTRD->FindObject(Form("hMatchedMass2%s_%s",suffix.Data(),cLabel.Data())))->Fill(mass*mass); |
| 1276 | } else { |
| b32dee71 |
1277 | ((TH2F*) fHlistPID->FindObject(Form("hMatchedBetaVsP%s_%s",suffix.Data(),cLabel.Data())))->Fill(fP,beta); |
| 1278 | ((TH1F*) fHlistPID->FindObject(Form("hMatchedMass%s_%s",suffix.Data(),cLabel.Data())))->Fill(mass); |
| 1279 | ((TH1F*) fHlistPID->FindObject(Form("hMatchedMass2%s_%s",suffix.Data(),cLabel.Data())))->Fill(mass*mass); |
| 4241f42c |
1280 | } |
| 9310e980 |
1281 | |
| 1282 | //PID sigmas |
| 1283 | Bool_t isValidBeta[AliPID::kSPECIES]={0,0,0,0,0}; |
| 1284 | for (Int_t specie = 0; specie < AliPID::kSPECIES; specie++){ |
| 1285 | fSigmaSpecie[specie] = fESDpid->GetTOFResponse().GetExpectedSigma(fP, fTrkExpTimes[specie], AliPID::ParticleMass(specie)); |
| 1286 | beta=1/TMath::Sqrt(1+AliPID::ParticleMass(specie)*AliPID::ParticleMass(specie)/(fP2)); |
| 1287 | if (beta>0) { |
| 1288 | fThExpTimes[specie]=length*1.E3/(beta*c);//ps |
| 1289 | isValidBeta[specie]=kTRUE; |
| 1290 | } else { |
| 1291 | fThExpTimes[specie]=1E-10; |
| 1292 | isValidBeta[specie]=kFALSE; |
| 1293 | } |
| 1294 | } |
| 1295 | Float_t timeZeroTOF = (Float_t) fESDpid->GetTOFResponse().GetStartTime(fPt); |
| 1296 | Double_t tofps=fTof*1E3;//ps for t-texp |
| 1297 | Int_t channel=track->GetTOFCalChannel(); |
| 1298 | Int_t volId[5]; //(sector, plate,strip,padZ,padX) |
| 1299 | AliTOFGeometry::GetVolumeIndices(channel,volId); |
| b32dee71 |
1300 | Char_t partName[3][4] = {"Pi","Ka","Pro"}; |
| 9310e980 |
1301 | |
| b0471367 |
1302 | if (suffix.Contains("Trd")) { |
| b32dee71 |
1303 | //fill histos for pion only |
| 1304 | ((TH2F*)fHlistTRD->FindObject(Form("hExpTimePiVsStrip%s_%s",suffix.Data(),cLabel.Data())))->Fill((Int_t)GetStripIndex(volId),tofps-fTrkExpTimes[AliPID::kPion]);//ps |
| 1305 | ((TH1F*)fHlistTRD->FindObject(Form("hExpTimePi%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofps-fTrkExpTimes[AliPID::kPion]);//ps |
| 1306 | if (ComputeTimeZeroByTOF1GeV() && (fPt>0.95) && (fPt<1.05) ){ |
| 1307 | ((TH2F*)fHlistTRD->FindObject(Form("hExpTimePiT0Sub1GeV%s_%s",suffix.Data(),cLabel.Data())))->Fill(fMyTimeZeroTOFtracks,tofps-fMyTimeZeroTOF-fTrkExpTimes[AliPID::kPion]); |
| 1308 | } |
| 1309 | //fill sigmas and deltas for each specie |
| b0471367 |
1310 | for (Int_t specie = AliPID::kPion; specie <= AliPID::kProton; specie++){ |
| 1311 | if (isValidBeta[specie]){ |
| b32dee71 |
1312 | ((TH2F*)fHlistTRD->FindObject(Form("hExpTime%sVsP%s_%s",partName[specie-2], suffix.Data(),cLabel.Data())))->Fill(fP, tofps-fTrkExpTimes[specie]); |
| 1313 | ((TH2F*)fHlistTRD->FindObject(Form("hTOFpidSigma%s%s_%s",partName[specie-2], suffix.Data(),cLabel.Data())))->Fill(fPt, (tofps-fTrkExpTimes[specie])/fSigmaSpecie[specie]); |
| 1314 | ((TH2F*)fHlistTRD->FindObject(Form("hExpTime%sT0SubVsP%s_%s",partName[specie-2], suffix.Data(),cLabel.Data())))->Fill(fP,tofps-fTrkExpTimes[specie]-timeZeroTOF); |
| 1315 | ((TH2F*)fHlistTRD->FindObject(Form("hExpTime%sVsOutPhi%s_%s",partName[specie-2], suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,tofps-fTrkExpTimes[specie]-timeZeroTOF); |
| b0471367 |
1316 | |
| b0471367 |
1317 | }// end check on beta |
| 1318 | } |
| b0471367 |
1319 | } else { |
| b32dee71 |
1320 | |
| 1321 | //fill histos for pion only |
| 1322 | ((TH2F*)fHlistPID->FindObject(Form("hExpTimePiVsStrip%s_%s",suffix.Data(),cLabel.Data())))->Fill((Int_t)GetStripIndex(volId),tofps-fTrkExpTimes[AliPID::kPion]);//ps |
| 1323 | ((TH1F*)fHlistPID->FindObject(Form("hExpTimePi%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofps-fTrkExpTimes[AliPID::kPion]);//ps |
| 1324 | if (ComputeTimeZeroByTOF1GeV() && (fPt>0.95) && (fPt<1.05) ){ |
| 1325 | ((TH2F*)fHlistPID->FindObject(Form("hExpTimePiT0Sub1GeV%s_%s",suffix.Data(),cLabel.Data())))->Fill(fMyTimeZeroTOFtracks,tofps-fMyTimeZeroTOF-fTrkExpTimes[AliPID::kPion]); |
| 1326 | } |
| 1327 | //fill sigmas and deltas for each specie |
| b0471367 |
1328 | for (Int_t specie = AliPID::kPion; specie <= AliPID::kProton; specie++){ |
| 1329 | if (isValidBeta[specie]){ |
| b32dee71 |
1330 | ((TH2F*)fHlistPID->FindObject(Form("hExpTime%sVsP%s_%s",partName[specie-2], suffix.Data(),cLabel.Data())))->Fill(fP, tofps-fTrkExpTimes[specie]); |
| 1331 | ((TH2F*)fHlistPID->FindObject(Form("hTOFpidSigma%s%s_%s",partName[specie-2], suffix.Data(),cLabel.Data())))->Fill(fPt, (tofps-fTrkExpTimes[specie])/fSigmaSpecie[specie]); |
| 1332 | ((TH2F*)fHlistPID->FindObject(Form("hExpTime%sT0SubVsP%s_%s",partName[specie-2], suffix.Data(),cLabel.Data())))->Fill(fP,tofps-fTrkExpTimes[specie]-timeZeroTOF); |
| 1333 | ((TH2F*)fHlistPID->FindObject(Form("hExpTime%sVsOutPhi%s_%s",partName[specie-2], suffix.Data(),cLabel.Data())))->Fill(fTPCOuterPhi,tofps-fTrkExpTimes[specie]-timeZeroTOF); |
| b0471367 |
1334 | }// end check on beta |
| b32dee71 |
1335 | } |
| 1336 | |
| b0471367 |
1337 | } |
| 1338 | |
| 1339 | //re-set response kFILL_T0 to check post-alignment wih OADB |
| 1340 | fESDpid->SetTOFResponse(fESD,AliESDpid::kFILL_T0);//(fill_t0, tof_t0, t0_t0, best_t0) |
| 1341 | Float_t startTimeFill=fESDpid->GetTOFResponse().GetStartTime(fP); //timeZero for bin pT>10GeV/c |
| b32dee71 |
1342 | if (suffix.Contains("Trd")) |
| 1343 | ((TH1F*)fHlistTRD->FindObject(Form("hExpTimePiFillSub%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofps-fTrkExpTimes[AliPID::kPion]-startTimeFill);//ps |
| 1344 | else |
| 1345 | ((TH1F*)fHlistPID->FindObject(Form("hExpTimePiFillSub%s_%s",suffix.Data(),cLabel.Data())))->Fill(tofps-fTrkExpTimes[AliPID::kPion]-startTimeFill);//ps |
| 1346 | |
| 9310e980 |
1347 | // if (fEnableAdvancedCheck && (fPt<1.)) { |
| 1348 | // Double_t pos[3]={0.,0.,0.}; |
| 1349 | // track->GetXYZAt(378.,5.,pos); |
| 1350 | // if ((pos[0]==0.)&&(pos[1]==0.)&&(pos[2]==0.))continue; |
| 1351 | |
| 1352 | // Double_t phiTOF=TMath::ATan2(pos[1],pos[0])*TMath::RadToDeg(); |
| 1353 | // if (phiTOF<0) phiTOF+= (2*TMath::Pi()*TMath::RadToDeg()); |
| 1354 | |
| 1355 | // //fill t-texp vs phi@TOF |
| 1356 | // if ((phiOuterTPC<=75) || ((phiOuterTPC>=125)&&(phiOuterTPC<=235)) || (phiOuterTPC>=305) ) { //TRD sectors 2012 |
| 1357 | // if ( ((phiOuterTPC>=85)&&(phiOuterTPC<=115)) || ((phiOuterTPC>=245)&&(phiOuterTPC<=295)) ) {//no TRD sectors 2012 |
| 1358 | // } |
| 1359 | return; |
| 1360 | } |
| 1361 | //---------------------------------------------------------------------------------- |
| 1362 | void AliAnalysisTaskTOFqaID::FillStartTimeHisto(TString suffix) |
| 1363 | { |
| 1364 | //fill start time histo |
| 1365 | if (!fESD) { |
| 1366 | AliError("Invalid event object"); |
| 1367 | return; |
| 1368 | } |
| 1369 | // info from V0 detector QA |
| 1370 | AliESDVZERO * vzero = fESD->GetVZEROData(); |
| 1371 | Float_t V0Atime = vzero->GetV0ATime(); |
| 1372 | Float_t V0Ctime = vzero->GetV0CTime(); |
| 1373 | ((TH2F*)fHlistTimeZero->FindObject(Form("hEventV0MeanVsVtx%s",suffix.Data())))->Fill((V0Atime-V0Ctime)*0.5,(V0Atime+V0Ctime)*0.5); |
| 1374 | |
| 1375 | // info from T0 detector QA |
| 1376 | for (Int_t j=0;j<3;j++){ |
| 1377 | fT0[j]= (Float_t) fESD->GetT0TOF(j);//ps |
| 1378 | if (fT0[j]>90000.) fT0[j]=99999.;//fix old default values to the new one |
| 1379 | } |
| 1380 | |
| 1381 | Float_t t0cut = 90000.; |
| 1382 | //Float_t t0cut =3 * t0spread; //use this cut to check t0 used in tof response |
| 1383 | // if(t0cut < 500) t0cut = 500; |
| 1384 | |
| 1385 | if(TMath::Abs(fT0[1]) < t0cut && TMath::Abs(fT0[2]) < t0cut ) { |
| 1386 | //&& TMath::Abs(fT0[2]-fT0[1]) < 500) //add this condition to check t0 used in tof response |
| 1387 | ((TH1F*)fHlistTimeZero->FindObject(Form("hT0DetRes%s",suffix.Data())))->Fill((fT0[2]-fT0[1])*0.5); |
| 1388 | ((TH1F*)fHlistTimeZero->FindObject(Form("hT0AC%s",suffix.Data())))->Fill(fT0[0]); |
| 1389 | ((TH2F*)fHlistTimeZero->FindObject(Form("hEventT0MeanVsVtx%s",suffix.Data())))->Fill((fT0[2]-fT0[1])*0.5,(fT0[2]+fT0[1])*0.5); |
| 1390 | } |
| 1391 | if(TMath::Abs(fT0[1]) < t0cut){ |
| 1392 | ((TH1F*)fHlistTimeZero->FindObject(Form("hT0A%s",suffix.Data())))->Fill(fT0[1]); |
| 1393 | } |
| 1394 | if(TMath::Abs(fT0[2]) < t0cut){ |
| 1395 | ((TH1F*)fHlistTimeZero->FindObject(Form("hT0C%s",suffix.Data())))->Fill(fT0[2]); |
| 1396 | } |
| 1397 | |
| 1398 | // event timeZero QA via AliESDpid::SetTOFResponse() |
| 1399 | Double_t timeZero[4]={99999.,99999.,99999.,99999.}; |
| 1400 | Double_t timeZeroRes[4]={99999.,99999.,99999.,99999.}; |
| 1401 | |
| 1402 | TString timeZeroHisto[4]={"hT0fill","hT0TOF","hT0T0","hT0best"}; |
| 1403 | TString timeZeroHistoRes[4]={"hT0fillRes","hT0TOFRes","hT0T0Res","hT0bestRes"}; |
| 1404 | for (Int_t j=0;j<4;j++){ |
| 1405 | timeZeroHisto[j].Append(suffix.Data()); |
| 1406 | timeZeroHistoRes[j].Append(suffix.Data()); |
| 1407 | fESDpid->SetTOFResponse(fESD, (AliESDpid::EStartTimeType_t) j);//(fill_t0, tof_t0, t0_t0, best_t0) |
| 1408 | timeZero[j]=fESDpid->GetTOFResponse().GetStartTime(10.); //timeZero for bin pT>10GeV/c |
| 1409 | timeZeroRes[j]=fESDpid->GetTOFResponse().GetStartTimeRes(10.); //timeZero for bin pT>10GeV/c |
| 1410 | ((TH1D*)(fHlistTimeZero->FindObject(timeZeroHisto[j].Data())))->Fill(timeZero[j]); |
| 1411 | ((TH1D*)(fHlistTimeZero->FindObject(timeZeroHistoRes[j].Data())))->Fill(timeZeroRes[j]); |
| 1412 | } |
| 1413 | ((TH2F*)fHlistTimeZero->FindObject("hT0TOFvsNtrk"))->Fill(fNTOFtracks[0],timeZero[AliESDpid::kTOF_T0]); |
| b0471367 |
1414 | |
| 9310e980 |
1415 | //response set to best_t0 by previous loop |
| 1416 | FillStartTimeMaskHisto(suffix.Data()); |
| 1417 | |
| 1418 | return; |
| 1419 | } |
| 1420 | //---------------------------------------------------------------------------------- |
| 1421 | void AliAnalysisTaskTOFqaID::FillTrdHisto(AliESDtrack * track, Int_t charge) |
| 1422 | { |
| 1423 | //fill histograms for TRD/noTRD |
| 1424 | if (!track){ |
| 1425 | AliError("Invalid track object"); |
| 1426 | return; |
| 1427 | } |
| 1428 | |
| 1429 | if (IsInTRD(track)){ |
| 1430 | FillPrimaryTrkHisto(charge,"_Trd"); |
| 1431 | if (IsTPCTOFMatched(track)) { |
| 1432 | FillMatchedTrkHisto(charge,"_Trd"); |
| b32dee71 |
1433 | FillPidHisto(track,charge, "_Trd"); |
| 9310e980 |
1434 | } |
| 1435 | } else { |
| 1436 | FillPrimaryTrkHisto(charge,"_noTrd"); |
| 1437 | if (IsTPCTOFMatched(track)) { |
| 1438 | FillMatchedTrkHisto(charge,"_noTrd"); |
| 1439 | FillPidHisto(track, charge, "_noTrd"); |
| 1440 | } |
| 1441 | } |
| 1442 | return; |
| 1443 | } |
| 1444 | //---------------------------------------------------------------------------------- |
| 1445 | void AliAnalysisTaskTOFqaID::FillTofTrgHisto(TString suffix) |
| 1446 | { |
| 1447 | //fills histo with trigger info |
| 1448 | if (!fHlistTrigger){ |
| 1449 | AliError("Invalid TOF trigger list"); |
| 1450 | return; |
| 1451 | } |
| 1452 | if (!fTOFHeader) { |
| 1453 | AliWarning("Invalid AliTOFHeader object - cannot fill trg histo"); |
| 1454 | return; |
| 1455 | } |
| 1456 | |
| b0471367 |
1457 | Int_t nPad = fTOFHeader->GetNumberOfTOFclusters(); //all fired readout pads |
| 1458 | Int_t nTrgPad = fTOFHeader->GetNumberOfTOFtrgPads();// fired readout pads in the trigger window |
| 1459 | Int_t nMaxiPad = fTOFHeader->GetNumberOfTOFmaxipad(); //fired maxipads |
| 9310e980 |
1460 | |
| b0471367 |
1461 | // update histo with fired macropads |
| 9310e980 |
1462 | AliTOFTriggerMask *trgMask = fTOFHeader->GetTriggerMask(); |
| 1463 | for(Int_t j=0;j<72;j++){ |
| 1464 | for(Int_t i=22;i>=0;i--){ |
| 1465 | if(trgMask->IsON(j,i)) |
| 1466 | ((TH1I*)fHlistTrigger->FindObject(Form("hTrgMap%s",suffix.Data())))->Fill(j+1,i+1); |
| 1467 | } |
| 1468 | } |
| 1469 | ((TH1I*)fHlistTrigger->FindObject(Form("hFiredMaxipad%s",suffix.Data())))->Fill(nMaxiPad); |
| 1470 | ((TH1I*)fHlistTrigger->FindObject(Form("hFiredReadoutPad%s",suffix.Data())))->Fill(nPad); |
| 1471 | ((TH1I*)fHlistTrigger->FindObject(Form("hFiredReadoutTrgPad%s",suffix.Data())))->Fill(nTrgPad); |
| 1472 | ((TH2I*)fHlistTrigger->FindObject(Form("hFiredMaxipadVsTrgPad%s",suffix.Data())))->Fill(nTrgPad,nMaxiPad); |
| 1473 | |
| 1474 | return; |
| 1475 | } |
| 1476 | |
| 1477 | #endif |
git://git.uio.no / u / mrichter / AliRoot.git / blame