1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 // --- MUON header files ---
19 #include "AliMUONQADataMakerRec.h"
21 #include "AliMUON2DMap.h"
22 #include "AliMUONCluster.h"
23 #include "AliMUONConstants.h"
24 #include "AliMUONDDLTrigger.h"
25 #include "AliMUONDarcHeader.h"
26 #include "AliMUONDigitMaker.h"
27 #include "AliMUONLocalStruct.h"
28 #include "AliMUONLocalTrigger.h"
29 #include "AliMUONRawStreamTracker.h"
30 #include "AliMUONRawStreamTrigger.h"
31 #include "AliMUONRegHeader.h"
32 #include "AliMUONTrackerCalibratedDataMaker.h"
33 #include "AliMUONTriggerDisplay.h"
34 #include "AliMUONVCluster.h"
35 #include "AliMUONVClusterStore.h"
36 #include "AliMUONVDigit.h"
37 #include "AliMUONVDigitStore.h"
38 #include "AliMUONVTrackerData.h"
39 #include "AliMUONVTriggerStore.h"
40 #include "AliMUONTrack.h"
41 #include "AliMUONTrackParam.h"
42 #include "AliMUONESDInterface.h"
43 #include "AliMUONCalibrationData.h"
44 #include "AliMpBusPatch.h"
46 #include "AliMpConstants.h"
47 #include "AliMpDDLStore.h"
48 #include "AliMpDEIterator.h"
49 #include "AliMpDEManager.h"
50 #include "AliMpLocalBoard.h"
51 #include "AliMpStationType.h"
52 #include "AliMpTriggerCrate.h"
53 #include "AliMpDCSNamer.h"
54 #include "AliRawEventHeaderBase.h"
56 // --- AliRoot header files ---
57 #include "AliCDBManager.h"
58 #include "AliCDBStorage.h"
59 #include "AliESDEvent.h"
60 #include "AliESDMuonTrack.h"
61 #include "AliESDMuonCluster.h"
63 #include "AliRawReader.h"
64 #include "AliQAChecker.h"
65 #include "AliCodeTimer.h"
66 #include "AliDCSValue.h"
68 // --- ROOT system ---
69 #include <TClonesArray.h>
75 #include <Riostream.h>
77 //-----------------------------------------------------------------------------
78 /// \class AliMUONQADataMakerRec
80 /// MUON base class for quality assurance data (histo) maker
82 /// \author C. Finck, D. Stocco, L. Aphecetche
85 ClassImp(AliMUONQADataMakerRec)
88 //____________________________________________________________________________
89 AliMUONQADataMakerRec::AliMUONQADataMakerRec() :
90 AliQADataMakerRec(AliQA::GetDetName(AliQA::kMUON), "MUON Quality Assurance Data Maker"),
92 fIsInitRecPointsTracker(kFALSE),
93 fIsInitRecPointsTrigger(kFALSE),
99 fTrackerDataMaker(0x0),
100 fhESDnTotClustersPerCh(0x0),
101 fhESDnTotClustersPerDE(0x0),
102 fhESDnTotFullClustersPerDE(0x0),
103 fhESDSumClusterChargePerDE(0x0),
104 fhESDSumClusterSizePerDE(0x0),
105 fhESDSumResidualXPerDE(0x0),
106 fhESDSumResidualYPerDE(0x0),
107 fhESDSumResidualX2PerDE(0x0),
108 fhESDSumResidualY2PerDE(0x0),
109 fhESDSumLocalChi2XPerDE(0x0),
110 fhESDSumLocalChi2YPerDE(0x0)
119 //____________________________________________________________________________
121 AliMUONQADataMakerRec::Ctor()
123 /// Init some members
124 fDigitStore = AliMUONVDigitStore::Create("AliMUONDigitStoreV1");
125 fDigitMaker = new AliMUONDigitMaker(kTRUE);
128 //____________________________________________________________________________
129 AliMUONQADataMakerRec::AliMUONQADataMakerRec(const AliMUONQADataMakerRec& qadm) :
130 AliQADataMakerRec(qadm),
132 fIsInitRecPointsTracker(kFALSE),
133 fIsInitRecPointsTrigger(kFALSE),
139 fTrackerDataMaker(0x0),
140 fhESDnTotClustersPerCh(0x0),
141 fhESDnTotClustersPerDE(0x0),
142 fhESDnTotFullClustersPerDE(0x0),
143 fhESDSumClusterChargePerDE(0x0),
144 fhESDSumClusterSizePerDE(0x0),
145 fhESDSumResidualXPerDE(0x0),
146 fhESDSumResidualYPerDE(0x0),
147 fhESDSumResidualX2PerDE(0x0),
148 fhESDSumResidualY2PerDE(0x0),
149 fhESDSumLocalChi2XPerDE(0x0),
150 fhESDSumLocalChi2YPerDE(0x0)
157 SetName((const char*)qadm.GetName()) ;
158 SetTitle((const char*)qadm.GetTitle());
160 // Do not copy the digit store and digit maker, but create its own ones
166 //__________________________________________________________________
167 AliMUONQADataMakerRec& AliMUONQADataMakerRec::operator = (const AliMUONQADataMakerRec& qadm )
169 /// Assignment operator
173 // check assignment to self
174 if (this == &qadm) return *this;
176 this->~AliMUONQADataMakerRec();
177 new(this) AliMUONQADataMakerRec(qadm);
181 //__________________________________________________________________
182 AliMUONQADataMakerRec::~AliMUONQADataMakerRec()
188 AliCodeTimerAuto("");
191 delete fTriggerStore;
193 delete fClusterStore;
194 delete fTrackerDataMaker;
195 delete fhESDnTotClustersPerCh;
196 delete fhESDnTotClustersPerDE;
197 delete fhESDnTotFullClustersPerDE;
198 delete fhESDSumClusterChargePerDE;
199 delete fhESDSumClusterSizePerDE;
200 delete fhESDSumResidualXPerDE;
201 delete fhESDSumResidualYPerDE;
202 delete fhESDSumResidualX2PerDE;
203 delete fhESDSumResidualY2PerDE;
204 delete fhESDSumLocalChi2XPerDE;
205 delete fhESDSumLocalChi2YPerDE;
208 //____________________________________________________________________________
209 void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray** list)
211 ///Detector specific actions at end of cycle
213 AliCodeTimerAuto("");
215 // Display trigger histos in a more user friendly way
216 DisplayTriggerInfo(task);
218 for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
219 SetEventSpecie(specie) ;
220 if ( task == AliQA::kRAWS && fTrackerDataMaker )
222 TIter next(list[specie]);
224 Bool_t alreadyThere(kFALSE);
225 while ( ( o = next() ) && !alreadyThere )
227 TString classname(o->ClassName());
228 if ( classname.Contains("TrackerData") ) alreadyThere = kTRUE;
230 if (!alreadyThere && fTrackerDataMaker)
232 AliInfo("Adding fTrackerDataMaker to the list of qa objects");
233 list[specie]->AddAt(fTrackerDataMaker->Data(),(Int_t)kTrackerData);
235 if ( fTrackerDataMaker )
237 TH1* hbp = GetRawsData(kTrackerBusPatchOccupancy);
239 TIter nextBP(AliMpDDLStore::Instance()->CreateBusPatchIterator());
240 AliMpBusPatch* bp(0x0);
241 AliMUONVTrackerData* data = fTrackerDataMaker->Data();
244 while ( ( bp = static_cast<AliMpBusPatch*>(nextBP())) )
246 Int_t busPatchId = bp->GetId();
247 Int_t bin = hbp->FindBin(busPatchId);
248 hbp->SetBinContent(bin,data->BusPatch(busPatchId,occDim));
253 // Normalize ESD histos
254 if ( task == AliQA::kESDS ) {
256 Double_t nTracks = GetESDsData(kESDnClustersPerTrack)->GetEntries();
257 if (nTracks <= 0) continue;
259 TH1* hESDnClustersPerCh = GetESDsData(kESDnClustersPerCh);
260 TH1* hESDnClustersPerDE = GetESDsData(kESDnClustersPerDE);
261 TH1* hESDClusterChargePerChMean = GetESDsData(kESDClusterChargePerChMean);
262 TH1* hESDClusterChargePerChSigma = GetESDsData(kESDClusterChargePerChSigma);
263 TH1* hESDClusterSizePerChMean = GetESDsData(kESDClusterSizePerChMean);
264 TH1* hESDClusterSizePerChSigma = GetESDsData(kESDClusterSizePerChSigma);
265 TH1* hESDResidualXPerChMean = GetESDsData(kESDResidualXPerChMean);
266 TH1* hESDResidualXPerChSigma = GetESDsData(kESDResidualXPerChSigma);
267 TH1* hESDResidualYPerChMean = GetESDsData(kESDResidualYPerChMean);
268 TH1* hESDResidualYPerChSigma = GetESDsData(kESDResidualYPerChSigma);
269 TH1* hESDLocalChi2XPerChMean = GetESDsData(kESDLocalChi2XPerChMean);
270 TH1* hESDLocalChi2YPerChMean = GetESDsData(kESDLocalChi2YPerChMean);
271 TH1* hESDClusterChargePerDE = GetESDsData(kESDClusterChargePerDE);
272 TH1* hESDClusterSizePerDE = GetESDsData(kESDClusterSizePerDE);
273 TH1* hESDResidualXPerDEMean = GetESDsData(kESDResidualXPerDEMean);
274 TH1* hESDResidualXPerDESigma = GetESDsData(kESDResidualXPerDESigma);
275 TH1* hESDResidualYPerDEMean = GetESDsData(kESDResidualYPerDEMean);
276 TH1* hESDResidualYPerDESigma = GetESDsData(kESDResidualYPerDESigma);
277 TH1* hESDLocalChi2XPerDEMean = GetESDsData(kESDLocalChi2XPerDEMean);
278 TH1* hESDLocalChi2YPerDEMean = GetESDsData(kESDLocalChi2YPerDEMean);
280 hESDnClustersPerCh->Reset();
281 hESDnClustersPerDE->Reset();
282 hESDnClustersPerCh->Add(fhESDnTotClustersPerCh, 1./nTracks);
283 hESDnClustersPerDE->Add(fhESDnTotClustersPerDE, 1./nTracks);
285 // loop over chambers
286 for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
288 TH1* hESDClusterChargeInCh = GetESDsData(kESDClusterChargeInCh+iCh);
289 Double_t sigmaCharge = hESDClusterChargeInCh->GetRMS();
290 hESDClusterChargePerChMean->SetBinContent(iCh+1, hESDClusterChargeInCh->GetMean());
291 hESDClusterChargePerChMean->SetBinError(iCh+1, hESDClusterChargeInCh->GetMeanError());
292 hESDClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge);
293 hESDClusterChargePerChSigma->SetBinError(iCh+1, hESDClusterChargeInCh->GetRMSError());
295 TH1* hESDClusterSizeInCh = GetESDsData(kESDClusterSizeInCh+iCh);
296 Double_t sigmaSize = hESDClusterSizeInCh->GetRMS();
297 hESDClusterSizePerChMean->SetBinContent(iCh+1, hESDClusterSizeInCh->GetMean());
298 hESDClusterSizePerChMean->SetBinError(iCh+1, hESDClusterSizeInCh->GetMeanError());
299 hESDClusterSizePerChSigma->SetBinContent(iCh+1, sigmaSize);
300 hESDClusterSizePerChSigma->SetBinError(iCh+1, hESDClusterSizeInCh->GetRMSError());
302 TH1* hESDResidualXInCh = GetESDsData(kESDResidualXInCh+iCh);
303 Double_t sigmaResidualX = hESDResidualXInCh->GetRMS();
304 hESDResidualXPerChMean->SetBinContent(iCh+1, hESDResidualXInCh->GetMean());
305 hESDResidualXPerChMean->SetBinError(iCh+1, hESDResidualXInCh->GetMeanError());
306 hESDResidualXPerChSigma->SetBinContent(iCh+1, sigmaResidualX);
307 hESDResidualXPerChSigma->SetBinError(iCh+1, hESDResidualXInCh->GetRMSError());
309 TH1* hESDResidualYInCh = GetESDsData(kESDResidualYInCh+iCh);
310 Double_t sigmaResidualY = hESDResidualYInCh->GetRMS();
311 hESDResidualYPerChMean->SetBinContent(iCh+1, hESDResidualYInCh->GetMean());
312 hESDResidualYPerChMean->SetBinError(iCh+1, hESDResidualYInCh->GetMeanError());
313 hESDResidualYPerChSigma->SetBinContent(iCh+1, sigmaResidualY);
314 hESDResidualYPerChSigma->SetBinError(iCh+1, hESDResidualYInCh->GetRMSError());
316 TH1* hESDLocalChi2XInCh = GetESDsData(kESDLocalChi2XInCh+iCh);
317 Double_t sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS();
318 hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean());
319 hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError());
321 TH1* hESDLocalChi2YInCh = GetESDsData(kESDLocalChi2YInCh+iCh);
322 Double_t sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS();
323 hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean());
324 hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->GetMeanError());
326 // loop over DE into chamber iCh
329 while ( !it.IsDone()) {
331 Int_t iDE = it.CurrentDEId();
333 Double_t nClusters = fhESDnTotClustersPerDE->GetBinContent(iDE+1);
336 hESDClusterChargePerDE->SetBinContent(iDE+1, fhESDSumClusterChargePerDE->GetBinContent(iDE+1)/nClusters);
337 hESDClusterChargePerDE->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters));
339 Double_t meanResX = fhESDSumResidualXPerDE->GetBinContent(iDE+1)/nClusters;
340 hESDResidualXPerDEMean->SetBinContent(iDE+1, meanResX);
341 hESDResidualXPerDEMean->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(nClusters));
342 hESDResidualXPerDESigma->SetBinContent(iDE+1, TMath::Sqrt(fhESDSumResidualX2PerDE->GetBinContent(iDE+1)/nClusters - meanResX*meanResX));
343 hESDResidualXPerDESigma->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(2.*nClusters));
345 Double_t meanResY = fhESDSumResidualYPerDE->GetBinContent(iDE+1)/nClusters;
346 hESDResidualYPerDEMean->SetBinContent(iDE+1, meanResY);
347 hESDResidualYPerDEMean->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(nClusters));
348 hESDResidualYPerDESigma->SetBinContent(iDE+1, TMath::Sqrt(fhESDSumResidualY2PerDE->GetBinContent(iDE+1)/nClusters - meanResY*meanResY));
349 hESDResidualYPerDESigma->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(2.*nClusters));
351 hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, fhESDSumLocalChi2XPerDE->GetBinContent(iDE+1)/nClusters);
352 hESDLocalChi2XPerDEMean->SetBinError(iDE+1, sigmaLocalChi2X/TMath::Sqrt(nClusters));
354 hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, fhESDSumLocalChi2YPerDE->GetBinContent(iDE+1)/nClusters);
355 hESDLocalChi2YPerDEMean->SetBinError(iDE+1, sigmaLocalChi2Y/TMath::Sqrt(nClusters));
359 hESDClusterChargePerDE->SetBinContent(iDE+1, fhESDSumClusterChargePerDE->GetBinContent(iDE+1));
360 hESDClusterChargePerDE->SetBinError(iDE+1, hESDClusterChargeInCh->GetXaxis()->GetXmax());
362 hESDResidualXPerDEMean->SetBinContent(iDE+1, fhESDSumResidualXPerDE->GetBinContent(iDE+1));
363 hESDResidualXPerDEMean->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
364 hESDResidualXPerDESigma->SetBinContent(iDE+1, 0.);
365 hESDResidualXPerDESigma->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
367 hESDResidualYPerDEMean->SetBinContent(iDE+1, fhESDSumResidualYPerDE->GetBinContent(iDE+1));
368 hESDResidualYPerDEMean->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
369 hESDResidualYPerDESigma->SetBinContent(iDE+1, 0.);
370 hESDResidualYPerDESigma->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
372 hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, fhESDSumLocalChi2XPerDE->GetBinContent(iDE+1));
373 hESDLocalChi2XPerDEMean->SetBinError(iDE+1, hESDLocalChi2XInCh->GetXaxis()->GetXmax());
375 hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, fhESDSumLocalChi2YPerDE->GetBinContent(iDE+1));
376 hESDLocalChi2YPerDEMean->SetBinError(iDE+1, hESDLocalChi2YInCh->GetXaxis()->GetXmax());
380 Double_t nFullClusters = fhESDnTotFullClustersPerDE->GetBinContent(iDE+1);
381 if (nFullClusters > 1) {
383 hESDClusterSizePerDE->SetBinContent(iDE+1, fhESDSumClusterSizePerDE->GetBinContent(iDE+1)/nFullClusters);
384 hESDClusterSizePerDE->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nFullClusters));
388 hESDClusterSizePerDE->SetBinContent(iDE+1, fhESDSumClusterSizePerDE->GetBinContent(iDE+1));
389 hESDClusterSizePerDE->SetBinError(iDE+1, hESDClusterSizeInCh->GetXaxis()->GetXmax());
402 // do the QA checking
403 AliQAChecker::Instance()->Run(AliQA::kMUON, task, list) ;
406 //____________________________________________________________________________
407 void AliMUONQADataMakerRec::InitRaws()
409 /// create Raws histograms in Raws subdir
411 AliCodeTimerAuto("");
413 Bool_t forExpert(kTRUE);
415 if ( ! AliCDBManager::Instance()->GetDefaultStorage() )
417 AliError("CDB default storage not set. Cannot work.");
421 TH3F* h3 = new TH3F("hTriggerScalersBendPlane", "Trigger scalers in bending plane",
425 h3->GetXaxis()->SetTitle("Chamber");
426 h3->GetYaxis()->SetTitle("Board");
427 h3->GetZaxis()->SetTitle("Strip");
428 Add2RawsList(h3, kTriggerScalersBP,forExpert);
430 TH3F* h4 = new TH3F("hTriggerScalersNonBendPlane", "Trigger scalers in non-bending plane",
434 h4->GetXaxis()->SetTitle("Chamber");
435 h4->GetYaxis()->SetTitle("Board");
436 h4->GetZaxis()->SetTitle("Strip");
437 Add2RawsList(h4, kTriggerScalersNBP,forExpert);
439 AliMUONTriggerDisplay triggerDisplay;
440 TString histoName, histoTitle;
441 for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
442 TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
443 for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
444 histoName = Form("hScalers%sChamber%i", cathName.Data(), 11+iChamber);
445 histoTitle = Form("Chamber %i: Scalers %s", 11+iChamber, cathName.Data());
446 TH2F* h5 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips,
447 iCath, iChamber, histoTitle);
448 Add2RawsList(h5, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,!forExpert);
452 TH2F* h6 = new TH2F("hTriggerRPCI", "Trigger RPC currents",
455 h6->GetXaxis()->SetTitle("Chamber");
456 h6->GetYaxis()->SetTitle("RPC");
457 Add2RawsList(h6, kTriggerRPCi, forExpert);
459 TH2F* h7 = new TH2F("hTriggerRPCHV", "Trigger RPC HV",
462 h7->GetXaxis()->SetTitle("Chamber");
463 h7->GetYaxis()->SetTitle("RPC");
464 Add2RawsList(h7, kTriggerRPChv, forExpert);
466 for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
467 histoName = Form("hRPCIChamber%i", 11+iChamber);
468 histoTitle = Form("Chamber %i: RPC Currents (#muA)", 11+iChamber);
469 TH2F* h8 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplaySlats,
470 0, iChamber, histoTitle);
471 Add2RawsList(h8, kTriggerIDisplay + iChamber, !forExpert);
474 for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
475 histoName = Form("hRPCHVChamber%i", 11+iChamber);
476 histoTitle = Form("Chamber %i: RPC HV (V)", 11+iChamber);
477 TH2F* h9 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplaySlats,
478 0, iChamber, histoTitle);
479 Add2RawsList(h9, kTriggerHVDisplay + iChamber, !forExpert);
484 TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator());
490 TH1* hbp = new TH1F("hTrackerBusPatchOccupancy","Occupancy of bus patches",
493 Add2RawsList(hbp,kTrackerBusPatchOccupancy,!forExpert);
495 const Bool_t histogram(kFALSE);
496 const Bool_t fastDecoder(kTRUE);
498 fTrackerDataMaker = new AliMUONTrackerCalibratedDataMaker(GetRecoParam(),
499 AliCDBManager::Instance()->GetRun(),
501 AliCDBManager::Instance()->GetDefaultStorage()->GetURI(),
507 fTrackerDataMaker->Data()->DisableChannelLevel(); // to save up disk space, we only store starting at the manu level
509 fTrackerDataMaker->SetRunning(kTRUE);
514 //____________________________________________________________________________
515 void AliMUONQADataMakerRec::InitRecPoints()
517 /// create Reconstructed Points histograms in RecPoints subdir
519 AliCodeTimerAuto("");
521 InitRecPointsTrigger();
522 InitRecPointsTracker();
525 //____________________________________________________________________________
526 void AliMUONQADataMakerRec::InitRecPointsTracker()
528 /// create Reconstructed Points histograms in RecPoints subdir for the
529 /// MUON tracker subsystem.
531 AliCodeTimerAuto("");
533 Bool_t forExpert(kTRUE);
541 while ( !it.IsDone())
543 Int_t detElemId = it.CurrentDEId();
547 if ( AliMpDEManager::GetStationType(detElemId) != AliMp::kStationTrigger )
549 ndes = TMath::Max(ndes,detElemId);
551 TH1* h = new TH1I(Form("hTrackerClusterMultiplicityForDE%04d",detElemId),
552 Form("Multiplicity of the clusters in detection element %d",detElemId),
555 h->GetXaxis()->SetTitle("Detection Element Id");
557 Add2RecPointsList(h,kTrackerClusterMultiplicityPerDE+detElemId,forExpert);
559 h = new TH1I(Form("hTrackerClusterChargeForDE%04d",detElemId),
560 Form("Charge of the clusters in detection element %d",detElemId),
563 h->GetXaxis()->SetTitle("Detection Element Id");
565 Add2RecPointsList(h,kTrackerClusterChargePerDE+detElemId,forExpert);
571 TH1* h = new TH1I("hTrackerNumberOfClustersPerDE","Number of clusters per detection element",
572 ndes, 0.5, ndes + 0.5);
574 h->GetXaxis()->SetTitle("Detection Element Id");
576 Add2RecPointsList(h, kTrackerNumberOfClustersPerDE,!forExpert);
578 for ( Int_t i = 0; i < AliMpConstants::NofTrackingChambers(); ++i )
580 TH1* h1 = new TH1I("hTrackerNumberOfClustersPerChamber","Number of clusters per chamber",
581 AliMpConstants::NofTrackingChambers(),-0.5,AliMpConstants::NofTrackingChambers()-0.5);
582 Add2RecPointsList(h1,kTrackerNumberOfClustersPerChamber,forExpert);
583 h1 = new TH1I(Form("hTrackerClusterMultiplicityForChamber%d",i),
584 Form("Cluster multiplicity for chamber %d",i),
586 Add2RecPointsList(h1,kTrackerClusterMultiplicityPerChamber+i,forExpert);
587 h1 = new TH1I(Form("hTrackerClusterChargeForChamber%d",i),
588 Form("Cluster charge for chamber %d",i),
590 Add2RecPointsList(h1,kTrackerClusterChargePerChamber+i,forExpert);
593 fIsInitRecPointsTracker=kTRUE;
596 //____________________________________________________________________________
597 void AliMUONQADataMakerRec::InitRecPointsTrigger()
599 /// create Reconstructed Points histograms in RecPoints subdir for the
600 /// MUON Trigger subsystem.
602 Bool_t forExpert(kTRUE);
604 TH3F* h0 = new TH3F("hTriggerDigitsBendPlane", "Trigger digits in bending plane",
608 h0->GetXaxis()->SetTitle("Chamber");
609 h0->GetYaxis()->SetTitle("Board");
610 h0->GetZaxis()->SetTitle("Strip");
611 Add2RecPointsList(h0, kTriggerDigitsBendPlane,forExpert);
613 TH3F* h1 = new TH3F("hTriggerDigitsNonBendPlane", "Trigger digits in non-bending plane",
617 h1->GetXaxis()->SetTitle("Chamber");
618 h1->GetYaxis()->SetTitle("Board");
619 h1->GetZaxis()->SetTitle("Strip");
620 Add2RecPointsList(h1, kTriggerDigitsNonBendPlane,forExpert);
622 TH1F* h2 = new TH1F("hTriggeredBoards", "Triggered boards", 234, 0.5, 234.5);
623 Add2RecPointsList(h2, kTriggeredBoards,forExpert);
625 AliMUONTriggerDisplay triggerDisplay;
626 TString histoName, histoTitle;
627 for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
628 TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
629 for(Int_t iChamber=0; iChamber<AliMpConstants::NofTriggerChambers(); iChamber++){
630 histoName = Form("hTriggerDigits%sChamber%i", cathName.Data(), 11+iChamber);
631 histoTitle = Form("Chamber %i: Fired pads %s", 11+iChamber, cathName.Data());
632 TH2F* h3 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips,
633 iCath, iChamber, histoTitle);
634 Add2RecPointsList(h3, kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,!forExpert);
638 TH2F* h4 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto("hFiredBoardsDisplay", AliMUONTriggerDisplay::kDisplayBoards,
639 0, 0, "Fired boards");
640 Add2RecPointsList(h4, kTriggerBoardsDisplay,!forExpert);
642 fIsInitRecPointsTrigger = kTRUE;
646 //____________________________________________________________________________
647 void AliMUONQADataMakerRec::InitESDs()
649 ///create ESDs histograms in ESDs subdir
651 Bool_t forExpert(kTRUE);
653 Int_t nCh = AliMUONConstants::NTrackingCh();
657 TH1F* hESDnTracks = new TH1F("hESDnTracks", "number of tracks;n_{tracks}", 20, 0., 20.);
658 Add2ESDsList(hESDnTracks, kESDnTracks,!forExpert);
660 TH1F* hESDMatchTrig = new TH1F("hESDMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.);
661 Add2ESDsList(hESDMatchTrig, kESDMatchTrig,!forExpert);
663 TH1F* hESDMomentum = new TH1F("hESDMomentum", "momentum distribution;p (GeV/c)", 300, 0., 300);
664 Add2ESDsList(hESDMomentum, kESDMomentum,forExpert);
666 TH1F* hESDPt = new TH1F("hESDPt", "transverse momentum distribution;p_{t} (GeV/c)", 200, 0., 50);
667 Add2ESDsList(hESDPt, kESDPt,forExpert);
669 TH1F* hESDRapidity = new TH1F("hESDRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.);
670 Add2ESDsList(hESDRapidity, kESDRapidity,forExpert);
672 TH1F* hESDChi2 = new TH1F("hESDChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.);
673 Add2ESDsList(hESDChi2, kESDChi2,forExpert);
675 TH1F* hESDProbChi2 = new TH1F("hESDProbChi2", "distribution of probability of #chi^{2};prob(#chi^{2})", 100, 0., 1.);
676 Add2ESDsList(hESDProbChi2, kESDProbChi2,forExpert);
679 for (Int_t i = 0; i < nCh; i++) {
680 Float_t rMax = AliMUONConstants::Rmax(i/2);
681 TH2F* hESDClusterHitMap = new TH2F(Form("hESDClusterHitMap%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1),
682 100, -rMax, rMax, 100, -rMax, rMax);
683 Add2ESDsList(hESDClusterHitMap, kESDClusterHitMap+i,forExpert);
686 TH1F* hESDnClustersPerTrack = new TH1F("hESDnClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.);
687 Add2ESDsList(hESDnClustersPerTrack, kESDnClustersPerTrack,!forExpert);
689 TH1F* hESDnClustersPerCh = new TH1F("hESDnClustersPerCh", "averaged number of clusters per chamber per track;chamber ID;<n_{clusters}>", nCh, 0, nCh);
690 hESDnClustersPerCh->SetFillColor(kRed);
691 Add2ESDsList(hESDnClustersPerCh, kESDnClustersPerCh,forExpert);
693 TH1F* hESDnClustersPerDE = new TH1F("hESDnClustersPerDE", "averaged number of clusters per DE per track;DetElem ID;<n_{clusters}>", nDE, 0, nDE);
694 hESDnClustersPerDE->SetFillColor(kRed);
695 Add2ESDsList(hESDnClustersPerDE, kESDnClustersPerDE,forExpert);
697 for (Int_t i = 0; i < nCh; i++) {
698 TH1F* hESDClusterChargeInCh = new TH1F(Form("hESDClusterChargeInCh%d",i+1), Form("cluster charge distribution in chamber %d;charge (ADC counts)",i+1), 500, 0., 5000.);
699 Add2ESDsList(hESDClusterChargeInCh, kESDClusterChargeInCh+i,forExpert);
702 TH1F* hESDClusterChargePerChMean = new TH1F("hESDClusterChargePerChMean", "cluster mean charge per chamber;chamber ID;<charge> (ADC counts)", nCh, 0, nCh);
703 hESDClusterChargePerChMean->SetOption("P");
704 hESDClusterChargePerChMean->SetMarkerStyle(kFullDotMedium);
705 hESDClusterChargePerChMean->SetMarkerColor(kRed);
706 Add2ESDsList(hESDClusterChargePerChMean, kESDClusterChargePerChMean,forExpert);
708 TH1F* hESDClusterChargePerChSigma = new TH1F("hESDClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (ADC counts)", nCh, 0, nCh);
709 hESDClusterChargePerChSigma->SetOption("P");
710 hESDClusterChargePerChSigma->SetMarkerStyle(kFullDotMedium);
711 hESDClusterChargePerChSigma->SetMarkerColor(kRed);
712 Add2ESDsList(hESDClusterChargePerChSigma, kESDClusterChargePerChSigma,forExpert);
714 TH1F* hESDClusterChargePerDE = new TH1F("hESDClusterChargePerDE", "cluster mean charge per DE;DetElem ID;<charge> (ADC counts)", nDE, 0, nDE);
715 hESDClusterChargePerDE->SetOption("P");
716 hESDClusterChargePerDE->SetMarkerStyle(kFullDotMedium);
717 hESDClusterChargePerDE->SetMarkerColor(kRed);
718 Add2ESDsList(hESDClusterChargePerDE, kESDClusterChargePerDE,forExpert);
720 for (Int_t i = 0; i < nCh; i++) {
721 TH1F* hESDClusterSizeInCh = new TH1F(Form("hESDClusterSizeInCh%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 200, 0., 200.);
722 Add2ESDsList(hESDClusterSizeInCh, kESDClusterSizeInCh+i,forExpert);
725 TH1F* hESDClusterSizePerChMean = new TH1F("hESDClusterSizePerChMean", "cluster mean size per chamber;chamber ID;<size> (n_{pads})", nCh, 0, nCh);
726 hESDClusterSizePerChMean->SetOption("P");
727 hESDClusterSizePerChMean->SetMarkerStyle(kFullDotMedium);
728 hESDClusterSizePerChMean->SetMarkerColor(kRed);
729 Add2ESDsList(hESDClusterSizePerChMean, kESDClusterSizePerChMean,forExpert);
731 TH1F* hESDClusterSizePerChSigma = new TH1F("hESDClusterSizePerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh, 0, nCh);
732 hESDClusterSizePerChSigma->SetOption("P");
733 hESDClusterSizePerChSigma->SetMarkerStyle(kFullDotMedium);
734 hESDClusterSizePerChSigma->SetMarkerColor(kRed);
735 Add2ESDsList(hESDClusterSizePerChSigma, kESDClusterSizePerChSigma,forExpert);
737 TH1F* hESDClusterSizePerDE = new TH1F("hESDClusterSizePerDE", "cluster mean size per DE;DetElem ID;<size> (n_{pads})", nDE, 0, nDE);
738 hESDClusterSizePerDE->SetOption("P");
739 hESDClusterSizePerDE->SetMarkerStyle(kFullDotMedium);
740 hESDClusterSizePerDE->SetMarkerColor(kRed);
741 Add2ESDsList(hESDClusterSizePerDE, kESDClusterSizePerDE,forExpert);
743 // cluster - track info
744 for (Int_t i = 0; i < nCh; i++) {
745 TH1F* hESDResidualXInCh = new TH1F(Form("hESDResidualXInCh%d",i+1), Form("cluster-track residual-X distribution in chamber %d;#Delta_{X} (cm)",i+1), 1000, -5., 5.);
746 Add2ESDsList(hESDResidualXInCh, kESDResidualXInCh+i,forExpert);
748 TH1F* hESDResidualYInCh = new TH1F(Form("hESDResidualYInCh%d",i+1), Form("cluster-track residual-Y distribution in chamber %d;#Delta_{Y} (cm)",i+1), 1000, -1., 1.);
749 Add2ESDsList(hESDResidualYInCh, kESDResidualYInCh+i,forExpert);
751 TH1F* hESDLocalChi2XInCh = new TH1F(Form("hESDLocalChi2XInCh%d",i+1), Form("local chi2-X distribution in chamber %d;local #chi^{2}_{X}",i+1), 1000, 0., 25);
752 Add2ESDsList(hESDLocalChi2XInCh, kESDLocalChi2XInCh+i,forExpert);
754 TH1F* hESDLocalChi2YInCh = new TH1F(Form("hESDLocalChi2YInCh%d",i+1), Form("local chi2-Y distribution in chamber %d;local #chi^{2}_{Y}",i+1), 1000, 0., 25);
755 Add2ESDsList(hESDLocalChi2YInCh, kESDLocalChi2YInCh+i,forExpert);
758 TH1F* hESDResidualXPerChMean = new TH1F("hESDResidualXPerChMean", "cluster-track residual-X per Ch: mean;chamber ID;<#Delta_{X}> (cm)", nCh, 0, nCh);
759 hESDResidualXPerChMean->SetOption("P");
760 hESDResidualXPerChMean->SetMarkerStyle(kFullDotMedium);
761 hESDResidualXPerChMean->SetMarkerColor(kRed);
762 Add2ESDsList(hESDResidualXPerChMean, kESDResidualXPerChMean,forExpert);
764 TH1F* hESDResidualYPerChMean = new TH1F("hESDResidualYPerChMean", "cluster-track residual-Y per Ch: mean;chamber ID;<#Delta_{Y}> (cm)", nCh, 0, nCh);
765 hESDResidualYPerChMean->SetOption("P");
766 hESDResidualYPerChMean->SetMarkerStyle(kFullDotMedium);
767 hESDResidualYPerChMean->SetMarkerColor(kRed);
768 Add2ESDsList(hESDResidualYPerChMean, kESDResidualYPerChMean,forExpert);
770 TH1F* hESDResidualXPerChSigma = new TH1F("hESDResidualXPerChSigma", "cluster-track residual-X per Ch: sigma;chamber ID;#sigma_{X} (cm)", nCh, 0, nCh);
771 hESDResidualXPerChSigma->SetOption("P");
772 hESDResidualXPerChSigma->SetMarkerStyle(kFullDotMedium);
773 hESDResidualXPerChSigma->SetMarkerColor(kRed);
774 Add2ESDsList(hESDResidualXPerChSigma, kESDResidualXPerChSigma,forExpert);
776 TH1F* hESDResidualYPerChSigma = new TH1F("hESDResidualYPerChSigma", "cluster-track residual-Y per Ch: sigma;chamber ID;#sigma_{Y} (cm)", nCh, 0, nCh);
777 hESDResidualYPerChSigma->SetOption("P");
778 hESDResidualYPerChSigma->SetMarkerStyle(kFullDotMedium);
779 hESDResidualYPerChSigma->SetMarkerColor(kRed);
780 Add2ESDsList(hESDResidualYPerChSigma, kESDResidualYPerChSigma,forExpert);
782 TH1F* hESDLocalChi2XPerChMean = new TH1F("hESDLocalChi2XPerChMean", "local chi2-X per Ch: mean;chamber ID;<local #chi^{2}_{X}>", nCh, 0, nCh);
783 hESDLocalChi2XPerChMean->SetOption("P");
784 hESDLocalChi2XPerChMean->SetMarkerStyle(kFullDotMedium);
785 hESDLocalChi2XPerChMean->SetMarkerColor(kRed);
786 Add2ESDsList(hESDLocalChi2XPerChMean, kESDLocalChi2XPerChMean,forExpert);
788 TH1F* hESDLocalChi2YPerChMean = new TH1F("hESDLocalChi2YPerChMean", "local chi2-Y per Ch: mean;chamber ID;<local #chi^{2}_{Y}>", nCh, 0, nCh);
789 hESDLocalChi2YPerChMean->SetOption("P");
790 hESDLocalChi2YPerChMean->SetMarkerStyle(kFullDotMedium);
791 hESDLocalChi2YPerChMean->SetMarkerColor(kRed);
792 Add2ESDsList(hESDLocalChi2YPerChMean, kESDLocalChi2YPerChMean,forExpert);
794 TH1F* hESDResidualXPerDEMean = new TH1F("hESDResidualXPerDEMean", "cluster-track residual-X per DE: mean;DetElem ID;<#Delta_{X}> (cm)", nDE, 0, nDE);
795 hESDResidualXPerDEMean->SetOption("P");
796 hESDResidualXPerDEMean->SetMarkerStyle(kFullDotMedium);
797 hESDResidualXPerDEMean->SetMarkerColor(kRed);
798 Add2ESDsList(hESDResidualXPerDEMean, kESDResidualXPerDEMean,forExpert);
800 TH1F* hESDResidualYPerDEMean = new TH1F("hESDResidualYPerDEMean", "cluster-track residual-Y per DE: mean;DetElem ID;<#Delta_{Y}> (cm)", nDE, 0, nDE);
801 hESDResidualYPerDEMean->SetOption("P");
802 hESDResidualYPerDEMean->SetMarkerStyle(kFullDotMedium);
803 hESDResidualYPerDEMean->SetMarkerColor(kRed);
804 Add2ESDsList(hESDResidualYPerDEMean, kESDResidualYPerDEMean,forExpert);
806 TH1F* hESDResidualXPerDESigma = new TH1F("hESDResidualXPerDESigma", "cluster-track residual-X per DE: sigma;DetElem ID;#sigma_{X} (cm)", nDE, 0, nDE);
807 hESDResidualXPerDESigma->SetOption("P");
808 hESDResidualXPerDESigma->SetMarkerStyle(kFullDotMedium);
809 hESDResidualXPerDESigma->SetMarkerColor(kRed);
810 Add2ESDsList(hESDResidualXPerDESigma, kESDResidualXPerDESigma,forExpert);
812 TH1F* hESDResidualYPerDESigma = new TH1F("hESDResidualYPerDESigma", "cluster-track residual-Y per DE: sigma;DetElem ID;#sigma_{Y} (cm)", nDE, 0, nDE);
813 hESDResidualYPerDESigma->SetOption("P");
814 hESDResidualYPerDESigma->SetMarkerStyle(kFullDotMedium);
815 hESDResidualYPerDESigma->SetMarkerColor(kRed);
816 Add2ESDsList(hESDResidualYPerDESigma, kESDResidualYPerDESigma,forExpert);
818 TH1F* hESDLocalChi2XPerDEMean = new TH1F("hESDLocalChi2XPerDEMean", "local chi2-X per DE: mean;DetElem ID;<local #chi^{2}_{X}>", nDE, 0, nDE);
819 hESDLocalChi2XPerDEMean->SetOption("P");
820 hESDLocalChi2XPerDEMean->SetMarkerStyle(kFullDotMedium);
821 hESDLocalChi2XPerDEMean->SetMarkerColor(kRed);
822 Add2ESDsList(hESDLocalChi2XPerDEMean, kESDLocalChi2XPerDEMean,forExpert);
824 TH1F* hESDLocalChi2YPerDEMean = new TH1F("hESDLocalChi2YPerDEMean", "local chi2-Y per DE: mean;DetElem ID;<local #chi^{2}_{Y}>", nDE, 0, nDE);
825 hESDLocalChi2YPerDEMean->SetOption("P");
826 hESDLocalChi2YPerDEMean->SetMarkerStyle(kFullDotMedium);
827 hESDLocalChi2YPerDEMean->SetMarkerColor(kRed);
828 Add2ESDsList(hESDLocalChi2YPerDEMean, kESDLocalChi2YPerDEMean,forExpert);
830 // temporary histograms
831 fhESDnTotClustersPerCh = new TH1F("fhESDnTotClustersPerCh", "total number of associated clusters per chamber;chamber ID", nCh, 0, nCh);
832 fhESDnTotClustersPerCh->SetDirectory(0);
833 fhESDnTotClustersPerDE = new TH1F("fhESDnTotClustersPerDE", "total number of associated clusters per DE;DetElem ID", nDE, 0, nDE);
834 fhESDnTotClustersPerDE->SetDirectory(0);
835 fhESDnTotFullClustersPerDE = new TH1F("fhESDnTotFullClustersPerDE", "total number of associated clusters containing pad info per DE;DetElem ID", nDE, 0, nDE);
836 fhESDnTotFullClustersPerDE->SetDirectory(0);
837 fhESDSumClusterChargePerDE = new TH1F("fhESDSumClusterChargePerDE", "sum of cluster charge per DE;DetElem ID;ADC counts", nDE, 0, nDE);
838 fhESDSumClusterChargePerDE->SetDirectory(0);
839 fhESDSumClusterSizePerDE = new TH1F("fhESDSumClusterSizePerDE", "sum of cluster size per DE;DetElem ID;averaged number of associated pads", nDE, 0, nDE);
840 fhESDSumClusterSizePerDE->SetDirectory(0);
841 fhESDSumResidualXPerDE = new TH1F("fhESDSumResidualXPerDE", "sum of cluster-track residual-X per DE;DetElem ID", nDE, 0, nDE);
842 fhESDSumResidualXPerDE->SetDirectory(0);
843 fhESDSumResidualYPerDE = new TH1F("fhESDSumResidualYPerDE", "sum of cluster-track residual-Y per DE;DetElem ID", nDE, 0, nDE);
844 fhESDSumResidualYPerDE->SetDirectory(0);
845 fhESDSumResidualX2PerDE = new TH1F("fhESDSumResidualX2PerDE", "sum of cluster-track residual-X**2 per DE;DetElem ID", nDE, 0, nDE);
846 fhESDSumResidualX2PerDE->SetDirectory(0);
847 fhESDSumResidualY2PerDE = new TH1F("fhESDSumResidualY2PerDE", "sum of cluster-track residual-Y**2 per DE;DetElem ID", nDE, 0, nDE);
848 fhESDSumResidualY2PerDE->SetDirectory(0);
849 fhESDSumLocalChi2XPerDE = new TH1F("fhESDSumLocalChi2XPerDE", "sum of local chi2-X per DE;DetElem ID", nDE, 0, nDE);
850 fhESDSumLocalChi2XPerDE->SetDirectory(0);
851 fhESDSumLocalChi2YPerDE = new TH1F("fhESDSumLocalChi2YPerDE", "sum of local chi2-Y per DE;DetElem ID", nDE, 0, nDE);
852 fhESDSumLocalChi2YPerDE->SetDirectory(0);
857 //____________________________________________________________________________
858 void AliMUONQADataMakerRec::MakeRaws(AliRawReader* rawReader)
860 /// make QA for rawdata
862 if ( ! fIsInitRaws ) {
864 << "Skipping function due to a failure in Init" << endl;
868 if ( rawReader->GetType() == AliRawEventHeaderBase::kPhysicsEvent )
871 MakeRawsTracker(rawReader);
875 MakeRawsTrigger(rawReader);
878 //____________________________________________________________________________
879 void AliMUONQADataMakerRec::MakeRawsTracker(AliRawReader* rawReader)
881 /// make QA for rawdata tracker
883 ((AliMUONTrackerCalibratedDataMaker*)fTrackerDataMaker)->SetRawReader(rawReader);
885 fTrackerDataMaker->ProcessEvent();
888 //____________________________________________________________________________
889 void AliMUONQADataMakerRec::MakeRawsTrigger(AliRawReader* rawReader)
891 /// make QA for rawdata trigger
893 // Get trigger scalers
896 AliMpCDB::LoadDDLStore();
898 AliMUONRawStreamTrigger rawStreamTrig(rawReader);
899 while (rawStreamTrig.NextDDL())
901 // If not a scaler event, do nothing
902 Bool_t scalerEvent = rawReader->GetDataHeader()->GetL1TriggerMessage() & 0x1;
903 if(!scalerEvent) break;
905 AliMUONDDLTrigger* ddlTrigger = rawStreamTrig.GetDDLTrigger();
906 AliMUONDarcHeader* darcHeader = ddlTrigger->GetDarcHeader();
908 Int_t nReg = darcHeader->GetRegHeaderEntries();
910 for(Int_t iReg = 0; iReg < nReg ;iReg++)
914 AliMpTriggerCrate* crate = AliMpDDLStore::Instance()->
915 GetTriggerCrate(rawStreamTrig.GetDDL(), iReg);
917 AliMUONRegHeader* regHeader = darcHeader->GetRegHeaderEntry(iReg);
919 // loop over local structures
920 Int_t nLocal = regHeader->GetLocalEntries();
921 for(Int_t iLocal = 0; iLocal < nLocal; iLocal++)
923 AliMUONLocalStruct* localStruct = regHeader->GetLocalEntry(iLocal);
926 if (!localStruct) continue;
928 loCircuit = crate->GetLocalBoardId(localStruct->GetId());
930 if ( !loCircuit ) continue; // empty slot
932 AliMpLocalBoard* localBoard = AliMpDDLStore::Instance()->GetLocalBoard(loCircuit, false);
935 if( !localBoard->IsNotified())
938 Int_t cathode = localStruct->GetComptXY()%2;
940 ERaw hindex = (cathode==0) ? kTriggerScalersBP : kTriggerScalersNBP;
943 for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {
944 if(localStruct->GetXY1(ibitxy) > 0)
945 ((TH3F*)GetRawsData(hindex))->Fill(11+0, loCircuit, ibitxy, 2*localStruct->GetXY1(ibitxy));
946 if(localStruct->GetXY2(ibitxy) > 0)
947 ((TH3F*)GetRawsData(hindex))->Fill(11+1, loCircuit, ibitxy, 2*localStruct->GetXY2(ibitxy));
948 if(localStruct->GetXY3(ibitxy) > 0)
949 ((TH3F*)GetRawsData(hindex))->Fill(11+2, loCircuit, ibitxy, 2*localStruct->GetXY3(ibitxy));
950 if(localStruct->GetXY4(ibitxy) > 0)
951 ((TH3F*)GetRawsData(hindex))->Fill(11+3, loCircuit, ibitxy, 2*localStruct->GetXY4(ibitxy));
958 //____________________________________________________________________________
959 void AliMUONQADataMakerRec::MakeRecPoints(TTree* clustersTree)
961 /// Fill histograms from treeR
963 if (fIsInitRecPointsTracker) MakeRecPointsTracker(clustersTree);
964 if (fIsInitRecPointsTrigger) MakeRecPointsTrigger(clustersTree);
967 //____________________________________________________________________________
968 void AliMUONQADataMakerRec::MakeRecPointsTracker(TTree* clustersTree)
970 /// Fill histograms related to tracker clusters
972 // First things first : do we have clusters in the TreeR ?
973 // In "normal" production mode, it should be perfectly normal
974 // *not* to have them.
975 // But if for some reason we de-activated the combined tracking,
976 // then we have clusters in TreeR, so let's take that opportunity
981 AliCodeTimerAuto("ClusterStore creation");
982 fClusterStore = AliMUONVClusterStore::Create(*clustersTree);
985 fIsInitRecPointsTracker = kFALSE;
990 AliCodeTimerAuto("");
992 fClusterStore->Connect(*clustersTree,kFALSE);
993 clustersTree->GetEvent(0);
995 TIter next(fClusterStore->CreateIterator());
996 AliMUONVCluster* cluster;
998 while ( ( cluster = static_cast<AliMUONVCluster*>(next()) ) )
1000 Int_t detElemId = cluster->GetDetElemId();
1001 Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
1003 GetRecPointsData(kTrackerNumberOfClustersPerDE)->Fill(detElemId);
1004 GetRecPointsData(kTrackerClusterChargePerDE+detElemId)->Fill(cluster->GetCharge());
1005 GetRecPointsData(kTrackerClusterMultiplicityPerDE+detElemId)->Fill(cluster->GetNDigits());
1007 GetRecPointsData(kTrackerNumberOfClustersPerChamber)->Fill(chamberId);
1008 GetRecPointsData(kTrackerClusterChargePerChamber+chamberId)->Fill(cluster->GetCharge());
1009 GetRecPointsData(kTrackerClusterMultiplicityPerChamber+chamberId)->Fill(cluster->GetNDigits());
1013 fClusterStore->Clear();
1016 //____________________________________________________________________________
1017 void AliMUONQADataMakerRec::MakeRecPointsTrigger(TTree* clustersTree)
1019 /// makes data from trigger response
1022 fDigitStore->Clear();
1024 if (!fTriggerStore) fTriggerStore = AliMUONVTriggerStore::Create(*clustersTree);
1025 fTriggerStore->Clear();
1026 fTriggerStore->Connect(*clustersTree, false);
1027 clustersTree->GetEvent(0);
1029 AliMUONLocalTrigger* locTrg;
1030 TIter nextLoc(fTriggerStore->CreateLocalIterator());
1032 while ( ( locTrg = static_cast<AliMUONLocalTrigger*>(nextLoc()) ) )
1034 if (locTrg->IsNull()) continue;
1036 TArrayS xyPattern[2];
1037 locTrg->GetXPattern(xyPattern[0]);
1038 locTrg->GetYPattern(xyPattern[1]);
1040 Int_t nBoard = locTrg->LoCircuit();
1042 Bool_t xTrig=locTrg->IsTrigX();
1043 Bool_t yTrig=locTrg->IsTrigY();
1046 ((TH1F*)GetRecPointsData(kTriggeredBoards))->Fill(nBoard);
1048 fDigitMaker->TriggerDigits(nBoard, xyPattern, *fDigitStore);
1051 TIter nextDigit(fDigitStore->CreateIterator());
1052 AliMUONVDigit* mDigit;
1053 while ( ( mDigit = static_cast<AliMUONVDigit*>(nextDigit()) ) )
1055 Int_t detElemId = mDigit->DetElemId();
1056 Int_t ch = detElemId/100;
1057 Int_t localBoard = mDigit->ManuId();
1058 Int_t channel = mDigit->ManuChannel();
1059 Int_t cathode = mDigit->Cathode();
1061 = ( cathode == 0 ) ? kTriggerDigitsBendPlane : kTriggerDigitsNonBendPlane;
1063 ((TH3F*)GetRecPointsData(hindex))->Fill(ch, localBoard, channel);
1067 //____________________________________________________________________________
1068 void AliMUONQADataMakerRec::MakeESDs(AliESDEvent* esd)
1070 /// make QA data from ESDs
1072 if ( ! fIsInitESDs ) {
1074 << "Skipping function due to a failure in Init" << endl;
1078 // use event specie from RecoParam
1079 AliRecoParam::EventSpecie_t savedEventSpecie = fEventSpecie;
1080 if (GetRecoParam()) SetEventSpecie(static_cast<AliRecoParam::EventSpecie_t>(GetRecoParam()->GetEventSpecie()));
1082 // load ESD event in the interface
1083 AliMUONESDInterface esdInterface;
1084 if (GetRecoParam()) AliMUONESDInterface::ResetTracker(GetRecoParam());
1085 else AliError("Unable to get recoParam: use default ones for residual calculation");
1086 esdInterface.LoadEvent(*esd);
1088 GetESDsData(kESDnTracks)->Fill(esdInterface.GetNTracks());
1090 Int_t nTrackMatchTrig = 0;
1093 Int_t nTracks = (Int_t) esd->GetNumberOfMuonTracks();
1094 for (Int_t iTrack = 0; iTrack < nTracks; ++iTrack) {
1096 // get the ESD track and skip "ghosts"
1097 AliESDMuonTrack* esdTrack = esd->GetMuonTrack(iTrack);
1098 if (!esdTrack->ContainTrackerData()) continue;
1100 // get corresponding MUON track
1101 AliMUONTrack* track = esdInterface.FindTrack(esdTrack->GetUniqueID());
1103 if (esdTrack->ContainTriggerData()) nTrackMatchTrig++;
1105 GetESDsData(kESDMomentum)->Fill(esdTrack->P());
1106 GetESDsData(kESDPt)->Fill(esdTrack->Pt());
1107 GetESDsData(kESDRapidity)->Fill(esdTrack->Y());
1108 GetESDsData(kESDChi2)->Fill(track->GetNormalizedChi2());
1109 GetESDsData(kESDProbChi2)->Fill(TMath::Prob(track->GetGlobalChi2(),track->GetNDF()));
1110 GetESDsData(kESDnClustersPerTrack)->Fill(track->GetNClusters());
1112 // loop over clusters
1113 AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->First());
1114 while (trackParam) {
1116 AliMUONVCluster* cluster = trackParam->GetClusterPtr();
1117 Int_t chId = cluster->GetChamberId();
1118 Int_t deID = cluster->GetDetElemId();
1119 Double_t residualX = cluster->GetX() - trackParam->GetNonBendingCoor();
1120 Double_t residualY = cluster->GetY() - trackParam->GetBendingCoor();
1121 Double_t localChi2X = (cluster->GetErrX2() > 0.) ? residualX*residualX/cluster->GetErrX2() : 0.;
1122 Double_t localChi2Y = (cluster->GetErrY2() > 0.) ? residualY*residualY/cluster->GetErrY2() : 0.;
1124 GetESDsData(kESDClusterHitMap+chId)->Fill(cluster->GetX(), cluster->GetY());
1126 fhESDnTotClustersPerCh->Fill(chId);
1127 fhESDnTotClustersPerDE->Fill(deID);
1129 GetESDsData(kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge());
1130 fhESDSumClusterChargePerDE->Fill(deID, cluster->GetCharge());
1132 if (cluster->GetNDigits() > 0) { // discard clusters with pad not stored in ESD
1133 fhESDnTotFullClustersPerDE->Fill(deID);
1134 GetESDsData(kESDClusterSizeInCh+chId)->Fill(cluster->GetNDigits());
1135 fhESDSumClusterSizePerDE->Fill(deID, cluster->GetNDigits());
1138 GetESDsData(kESDResidualXInCh+chId)->Fill(residualX);
1139 GetESDsData(kESDResidualYInCh+chId)->Fill(residualY);
1140 fhESDSumResidualXPerDE->Fill(deID, residualX);
1141 fhESDSumResidualYPerDE->Fill(deID, residualY);
1142 fhESDSumResidualX2PerDE->Fill(deID, residualX*residualX);
1143 fhESDSumResidualY2PerDE->Fill(deID, residualY*residualY);
1145 GetESDsData(kESDLocalChi2XInCh+chId)->Fill(localChi2X);
1146 GetESDsData(kESDLocalChi2YInCh+chId)->Fill(localChi2Y);
1147 fhESDSumLocalChi2XPerDE->Fill(deID, localChi2X);
1148 fhESDSumLocalChi2YPerDE->Fill(deID, localChi2Y);
1150 trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->After(trackParam));
1155 GetESDsData(kESDMatchTrig)->Fill(nTrackMatchTrig);
1157 // restore event specie
1158 SetEventSpecie(savedEventSpecie);
1162 //____________________________________________________________________________
1163 void AliMUONQADataMakerRec::StartOfDetectorCycle()
1165 /// Detector specific actions at start of cycle
1169 //____________________________________________________________________________
1170 void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task)
1173 /// Display trigger information in a user-friendly way:
1174 /// from local board and strip numbers to their position on chambers
1177 if(task!=AliQA::kRECPOINTS && task!=AliQA::kRAWS) return;
1179 AliMUONTriggerDisplay triggerDisplay;
1181 TH3F* histoStrips=0x0;
1182 TH2F* histoDisplayStrips=0x0;
1184 for (Int_t iCath = 0; iCath < AliMpConstants::NofCathodes(); iCath++)
1186 if(task==AliQA::kRECPOINTS){
1188 = ( iCath == 0 ) ? kTriggerDigitsBendPlane : kTriggerDigitsNonBendPlane;
1189 histoStrips = (TH3F*)GetRecPointsData(hindex);
1191 else if(task==AliQA::kRAWS){
1193 = ( iCath == 0 ) ? kTriggerScalersBP : kTriggerScalersNBP;
1194 histoStrips = (TH3F*)GetRawsData(hindex);
1195 if(histoStrips->GetEntries()==0) continue; // No scalers found
1198 for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++)
1200 if(task==AliQA::kRECPOINTS){
1201 histoDisplayStrips = (TH2F*)GetRecPointsData(kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
1203 else if(task==AliQA::kRAWS){
1204 histoDisplayStrips = (TH2F*)GetRawsData(kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
1206 Int_t bin = histoStrips->GetXaxis()->FindBin(11+iChamber);
1207 histoStrips->GetXaxis()->SetRange(bin,bin);
1208 TH2F* inputHisto = (TH2F*)histoStrips->Project3D("zy");
1209 triggerDisplay.FillDisplayHistogram(inputHisto, histoDisplayStrips, AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber);
1213 if(task==AliQA::kRAWS){
1214 TH2F* histoI = (TH2F*) GetRawsData(kTriggerRPCi);
1215 TH2F* histoHV = (TH2F*) GetRawsData(kTriggerRPChv);
1216 FillTriggerDCSHistos();
1217 for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++) {
1218 Int_t bin = histoI->GetXaxis()->FindBin(11+iChamber);
1219 TH2F* histoDisplayI = (TH2F*)GetRawsData(kTriggerIDisplay + iChamber);
1220 triggerDisplay.FillDisplayHistogram(histoI->ProjectionY("_px", bin, bin), histoDisplayI, AliMUONTriggerDisplay::kDisplaySlats, 0, iChamber);
1221 TH2F* histoDisplayHV = (TH2F*)GetRawsData(kTriggerHVDisplay + iChamber);
1222 bin = histoHV->GetXaxis()->FindBin(11+iChamber);
1223 triggerDisplay.FillDisplayHistogram(histoHV->ProjectionY("_px", bin, bin), histoDisplayHV, AliMUONTriggerDisplay::kDisplaySlats, 0, iChamber);
1227 if(task==AliQA::kRECPOINTS){
1228 TH1F* histoBoards = (TH1F*)GetRecPointsData(kTriggeredBoards);
1229 TH2F* histoDisplayBoards = (TH2F*)GetRecPointsData(kTriggerBoardsDisplay);
1230 triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0);
1235 //_____________________________________________________________________________
1237 AliMUONQADataMakerRec::FillTriggerDCSHistos()
1239 /// Get HV and currents values for one trigger chamber
1241 AliCodeTimerAuto("");
1243 AliMpDEIterator deIt;
1247 AliMUONCalibrationData calibrationData(AliCDBManager::Instance()->GetRun());
1249 TMap* triggerDcsMap = calibrationData.TriggerDCS();
1251 AliMpDCSNamer triggerDcsNamer("TRIGGER");
1253 TH2* currHisto = 0x0;
1255 Bool_t error = kFALSE;
1257 while ( !deIt.IsDone() )
1259 Int_t detElemId = deIt.CurrentDEId();
1261 if ( AliMpDEManager::GetStationType(detElemId) == AliMp::kStationTrigger) {
1263 Int_t iChamber = AliMpDEManager::GetChamberId(detElemId);
1264 Int_t slat = detElemId%100;
1266 for(Int_t iMeas=0; iMeas<AliMpDCSNamer::kNDCSMeas; iMeas++){
1267 TString currAlias = triggerDcsNamer.DCSChannelName(detElemId, 0, iMeas);
1269 AliDebug(2, Form("\nDetElemId %i dcsAlias %s", detElemId, currAlias.Data()));
1271 TPair* triggerDcsPair = static_cast<TPair*>(triggerDcsMap->FindObject(currAlias.Data()));
1273 if (!triggerDcsPair)
1275 AliError(Form("Did not find expected alias (%s) for DE %d",
1276 currAlias.Data(),detElemId));
1281 TObjArray* values = static_cast<TObjArray*>(triggerDcsPair->Value());
1284 AliError(Form("Could not get values for alias %s",currAlias.Data()));
1292 while ( ( val = static_cast<AliDCSValue*>(next()) ) )
1294 Float_t hvi = val->GetFloat();
1296 AliDebug(2, Form("Value %f", hvi));
1299 case AliMpDCSNamer::kDCSI:
1300 currHisto = (TH2F*) GetRawsData(kTriggerRPCi);
1302 case AliMpDCSNamer::kDCSHV:
1303 currHisto = (TH2F*) GetRawsData(kTriggerRPChv);
1306 Int_t binX = currHisto->GetXaxis()->FindBin(iChamber+1);
1307 Int_t binY = currHisto->GetYaxis()->FindBin(slat);
1308 currHisto->SetBinContent(binX, binY, hvi);
1311 } // if (!triggerDcsPair)
1312 } // loop on measured types (HV and currents)
1313 } // if (stationType == kStationTrigger)
1320 //____________________________________________________________________________
1321 AliMUONVTrackerData* AliMUONQADataMakerRec::GetTrackerData() const
1324 return fTrackerDataMaker->Data();