]> git.uio.no Git - u/mrichter/AliRoot.git/blame - EMCAL/AliEMCALQADataMakerRec.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
adding a comment on the event-by-event eta-phi histogram for general use
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALQADataMakerRec.cxx
CommitLineData
9e47432c 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15/*
16Based on the QA code for PHOS written by Yves Schutz July 2007
17
18Authors: J.Klay (Cal Poly) May 2008
19 S. Salur LBL April 2008
20
38986b78 21Created one histogram for QA shifter;-- Yaxian Mao: 11/2009
9e47432c 22The idea:average counts for all the towers should be flat
23Change all existing histograms as experts
9e47432c 24
38986b78 25Change histograms for DQM shifter: -- Yaxian Mao 04/2010
26Calcuate the amplitude ratio from current run and the LED reference, for QAChecker use
27Also calculate the ratio of amplitude from LED Monitor system (current/Reference), to check LED system
28
9e47432c 29*/
30
31// --- ROOT system ---
32#include <TClonesArray.h>
33#include <TFile.h>
34#include <TH1F.h>
35#include <TH1I.h>
36#include <TH2F.h>
38986b78 37#include <TLine.h>
38#include <TText.h>
9e47432c 39#include <TProfile.h>
38986b78 40#include <TStyle.h>
9e47432c 41// --- Standard library ---
42
43
44// --- AliRoot header files ---
e03bcdd4 45#include "AliDAQ.h"
9e47432c 46#include "AliESDCaloCluster.h"
47#include "AliESDCaloCells.h"
48#include "AliESDEvent.h"
49#include "AliLog.h"
50#include "AliEMCALQADataMakerRec.h"
51#include "AliQAChecker.h"
52#include "AliEMCALDigit.h"
53#include "AliEMCALRecPoint.h"
54#include "AliEMCALRawUtils.h"
55#include "AliEMCALReconstructor.h"
56#include "AliEMCALRecParam.h"
57#include "AliRawReader.h"
58#include "AliCaloRawStreamV3.h"
59#include "AliEMCALGeoParams.h"
def665cb 60#include "AliRawEventHeaderBase.h"
38986b78 61#include "AliQAManager.h"
62#include "AliCDBEntry.h"
def665cb 63
64#include "AliCaloBunchInfo.h"
65#include "AliCaloFitResults.h"
66#include "AliCaloRawAnalyzerFastFit.h"
67#include "AliCaloRawAnalyzerNN.h"
68#include "AliCaloRawAnalyzerLMS.h"
69#include "AliCaloRawAnalyzerPeakFinder.h"
70#include "AliCaloRawAnalyzerCrude.h"
9e47432c 71
ce95bae9 72using namespace std;
73
9e47432c 74ClassImp(AliEMCALQADataMakerRec)
75
76//____________________________________________________________________________
def665cb 77AliEMCALQADataMakerRec::AliEMCALQADataMakerRec(fitAlgorithm fitAlgo) :
78 AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kEMCAL), "EMCAL Quality Assurance Data Maker"),
79 fFittingAlgorithm(0),
80 fRawAnalyzer(0),
81 fRawAnalyzerTRU(0),
82 fSuperModules(4), // FIXME!!! number of SuperModules; 4 for 2009; update default to 12 for later runs..
83 fFirstPedestalSample(0),
84 fLastPedestalSample(3),
85 fFirstPedestalSampleTRU(0),
86 fLastPedestalSampleTRU(3),
87 fMinSignalLG(0),
88 fMaxSignalLG(AliEMCALGeoParams::fgkSampleMax),
89 fMinSignalHG(0),
90 fMaxSignalHG(AliEMCALGeoParams::fgkSampleMax),
91 fMinSignalTRU(0),
92 fMaxSignalTRU(AliEMCALGeoParams::fgkSampleMax),
93 fMinSignalLGLEDMon(0),
94 fMaxSignalLGLEDMon(AliEMCALGeoParams::fgkSampleMax),
95 fMinSignalHGLEDMon(0),
38986b78 96 fMaxSignalHGLEDMon(AliEMCALGeoParams::fgkSampleMax),
97 fCalibRefHistoPro(NULL),
98 fCalibRefHistoH2F(NULL),
99 fLEDMonRefHistoPro(NULL),
100 fHighEmcHistoH2F(NULL)
101// fTextSM(new TText*[fSuperModules]) ,
102// fLineCol(NULL),
103// fLineRow(NULL)
104
def665cb 105{
9e47432c 106 // ctor
def665cb 107 SetFittingAlgorithm(fitAlgo);
108 fRawAnalyzerTRU = new AliCaloRawAnalyzerLMS();
109 fRawAnalyzerTRU->SetFixTau(kTRUE);
110 fRawAnalyzerTRU->SetTau(2.5); // default for TRU shaper
38986b78 111// for (Int_t sm = 0 ; sm < fSuperModules ; sm++){
112// fTextSM[sm] = NULL ;
113// }
9e47432c 114}
115
116//____________________________________________________________________________
117AliEMCALQADataMakerRec::AliEMCALQADataMakerRec(const AliEMCALQADataMakerRec& qadm) :
118 AliQADataMakerRec(),
def665cb 119 fFittingAlgorithm(0),
120 fRawAnalyzer(0),
121 fRawAnalyzerTRU(0),
9e47432c 122 fSuperModules(qadm.GetSuperModules()),
123 fFirstPedestalSample(qadm.GetFirstPedestalSample()),
124 fLastPedestalSample(qadm.GetLastPedestalSample()),
def665cb 125 fFirstPedestalSampleTRU(qadm.GetFirstPedestalSampleTRU()),
126 fLastPedestalSampleTRU(qadm.GetLastPedestalSampleTRU()),
127 fMinSignalLG(qadm.GetMinSignalLG()),
128 fMaxSignalLG(qadm.GetMaxSignalLG()),
9e47432c 129 fMinSignalHG(qadm.GetMinSignalHG()),
def665cb 130 fMaxSignalHG(qadm.GetMaxSignalHG()),
131 fMinSignalTRU(qadm.GetMinSignalTRU()),
132 fMaxSignalTRU(qadm.GetMaxSignalTRU()),
133 fMinSignalLGLEDMon(qadm.GetMinSignalLGLEDMon()),
134 fMaxSignalLGLEDMon(qadm.GetMaxSignalLGLEDMon()),
135 fMinSignalHGLEDMon(qadm.GetMinSignalHGLEDMon()),
38986b78 136 fMaxSignalHGLEDMon(qadm.GetMaxSignalHGLEDMon()),
137 fCalibRefHistoPro(NULL),
138 fCalibRefHistoH2F(NULL),
139 fLEDMonRefHistoPro(NULL),
140 fHighEmcHistoH2F(NULL)
141// fTextSM(new TText*[fSuperModules]) ,
142// fLineCol(NULL),
143// fLineRow(NULL)
9e47432c 144{
145 //copy ctor
146 SetName((const char*)qadm.GetName()) ;
147 SetTitle((const char*)qadm.GetTitle());
def665cb 148 SetFittingAlgorithm(qadm.GetFittingAlgorithm());
149 fRawAnalyzerTRU = new AliCaloRawAnalyzerLMS();
150 fRawAnalyzerTRU->SetFixTau(kTRUE);
151 fRawAnalyzerTRU->SetTau(2.5); // default for TRU shaper
38986b78 152// for (Int_t sm = 0 ; sm < fSuperModules ; sm++){
153// fTextSM[sm] = qadm.fTextSM[sm] ;
154// }
9e47432c 155}
156
157//__________________________________________________________________
158AliEMCALQADataMakerRec& AliEMCALQADataMakerRec::operator = (const AliEMCALQADataMakerRec& qadm )
159{
160 // Equal operator.
161 this->~AliEMCALQADataMakerRec();
162 new(this) AliEMCALQADataMakerRec(qadm);
38986b78 163// fLineCol = NULL;
164// fLineRow = NULL;
165// for (Int_t sm = 0 ; sm < fSuperModules ; sm++){
166// fTextSM[sm] = qadm.fTextSM[sm] ;
167// }
9e47432c 168 return *this;
169}
170
171//____________________________________________________________________________
172void AliEMCALQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
173{
174 //Detector specific actions at end of cycle
175
176// if(fCycleCounter)
177// GetRawsData(kNEventsPerTower)->Scale(1./fCycleCounter);
178
179 // do the QA checking
180 AliQAChecker::Instance()->Run(AliQAv1::kEMCAL, task, list) ;
181}
182
38986b78 183//____________________________________________________________________________
184void AliEMCALQADataMakerRec::GetCalibRefFromOCDB()
185{
186 //Get the reference histogram from OCDB
187 TString sName1("hHighEmcalRawMaxMinusMin") ;
188 TString sName2("hLowLEDMonEmcalRawMaxMinusMin") ;
189 sName1.Prepend(Form("%s_", AliRecoParam::GetEventSpecieName(AliRecoParam::kCalib))) ;
190 sName2.Prepend(Form("%s_", AliRecoParam::GetEventSpecieName(AliRecoParam::kCalib))) ;
191
192 TString refStorage(AliQAv1::GetQARefStorage()) ;
193 if (!refStorage.Contains(AliQAv1::GetLabLocalOCDB()) && !refStorage.Contains(AliQAv1::GetLabAliEnOCDB())) {
194 AliFatal(Form("%s is not a valid location for reference data", refStorage.Data())) ;
195 } else {
196 AliQAManager* manQA = AliQAManager::QAManager(AliQAv1::kRAWS) ;
197 AliQAv1::SetQARefDataDirName(AliRecoParam::kCalib) ;
198 if ( ! manQA->GetLock() ) {
199 manQA->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
200 manQA->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
201 manQA->SetRun(AliCDBManager::Instance()->GetRun()) ;
202 manQA->SetLock() ;
203 }
204 char * detOCDBDir = Form("%s/%s/%s", GetName(), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName()) ;
205 AliCDBEntry * entry = manQA->Get(detOCDBDir, manQA->GetRun()) ;
206 if (entry) {
207 TList * listDetQAD =static_cast<TList *>(entry->GetObject()) ;
208 if ( strcmp(listDetQAD->ClassName(), "TList") != 0 ) {
209 AliError(Form("Expected a Tlist and found a %s for detector %s", listDetQAD->ClassName(), GetName())) ;
210 listDetQAD = NULL ;
211 }
212 TObjArray * dirOCDB= NULL ;
213 if ( listDetQAD )
214 dirOCDB = static_cast<TObjArray *>(listDetQAD->FindObject(Form("%s/%s", AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), AliRecoParam::GetEventSpecieName(AliRecoParam::kCalib)))) ;
215 if (dirOCDB){
216 fCalibRefHistoPro = dynamic_cast<TProfile *>(dirOCDB->FindObject(sName1.Data())) ;
217 fLEDMonRefHistoPro = dynamic_cast<TProfile *>(dirOCDB->FindObject(sName2.Data())) ;
218 }
219 }
220 }
221
222 if(fCalibRefHistoPro && fLEDMonRefHistoPro){
223
224 //Defining histograms binning, each 2D histogram covers all SMs
225 Int_t nSMSectors = fSuperModules / 2; // 2 SMs per sector
226 Int_t nbinsZ = 2*AliEMCALGeoParams::fgkEMCALCols;
227 Int_t nbinsPhi = nSMSectors * AliEMCALGeoParams::fgkEMCALRows;
228
229 if(!fCalibRefHistoH2F)
230 fCalibRefHistoH2F = new TH2F("hCalibRefHisto", "hCalibRefHisto", nbinsZ, -0.5, nbinsZ - 0.5, nbinsPhi, -0.5, nbinsPhi -0.5);
231 ConvertProfile2H(fCalibRefHistoPro,fCalibRefHistoH2F) ;
232 } else {
233 AliFatal(Form("No reference object with name %s or %s found", sName1.Data(), sName2.Data())) ;
234 }
235}
9e47432c 236//____________________________________________________________________________
237void AliEMCALQADataMakerRec::InitESDs()
238{
239 //Create histograms to controll ESD
240 const Bool_t expert = kTRUE ;
241 const Bool_t image = kTRUE ;
242
243 TH1F * h1 = new TH1F("hESDCaloClusterE", "ESDs CaloCluster energy in EMCAL;Energy [GeV];Counts", 200, 0., 100.) ;
244 h1->Sumw2() ;
245 Add2ESDsList(h1, kESDCaloClusE, !expert, image) ;
246
247 TH1I * h2 = new TH1I("hESDCaloClusterM", "ESDs CaloCluster multiplicity in EMCAL;# of Clusters;Entries", 100, 0, 100) ;
248 h2->Sumw2() ;
249 Add2ESDsList(h2, kESDCaloClusM, !expert, image) ;
250
251 TH1F * h3 = new TH1F("hESDCaloCellA", "ESDs CaloCell amplitude in EMCAL;Energy [GeV];Counts", 500, 0., 50.) ;
252 h3->Sumw2() ;
253 Add2ESDsList(h3, kESDCaloCellA, !expert, image) ;
254
255 TH1I * h4 = new TH1I("hESDCaloCellM", "ESDs CaloCell multiplicity in EMCAL;# of Clusters;Entries", 200, 0, 1000) ;
256 h4->Sumw2() ;
257 Add2ESDsList(h4, kESDCaloCellM, !expert, image) ;
258
259}
260
261//____________________________________________________________________________
262void AliEMCALQADataMakerRec::InitDigits()
263{
264 // create Digits histograms in Digits subdir
265 const Bool_t expert = kTRUE ;
266 const Bool_t image = kTRUE ;
267
268 TH1I * h0 = new TH1I("hEmcalDigits", "Digits amplitude distribution in EMCAL;Amplitude [ADC counts];Counts", 500, 0, 500) ;
269 h0->Sumw2() ;
270 Add2DigitsList(h0, 0, !expert, image) ;
271 TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL;# of Digits;Entries", 200, 0, 2000) ;
272 h1->Sumw2() ;
273 Add2DigitsList(h1, 1, !expert, image) ;
274}
275
276//____________________________________________________________________________
277void AliEMCALQADataMakerRec::InitRecPoints()
278{
38986b78 279 // create Reconstructed PoInt_ts histograms in RecPoints subdir
9e47432c 280 const Bool_t expert = kTRUE ;
281 const Bool_t image = kTRUE ;
282
283 TH1F* h0 = new TH1F("hEMCALRpE","EMCAL RecPoint energies;Energy [GeV];Counts",200, 0.,20.); //GeV
284 h0->Sumw2();
285 Add2RecPointsList(h0,kRecPE, !expert, image);
286
287 TH1I* h1 = new TH1I("hEMCALRpM","EMCAL RecPoint multiplicities;# of Clusters;Entries",100,0,100);
288 h1->Sumw2();
289 Add2RecPointsList(h1,kRecPM, !expert, image);
290
291 TH1I* h2 = new TH1I("hEMCALRpDigM","EMCAL RecPoint Digit Multiplicities;# of Digits;Entries",20,0,20);
292 h2->Sumw2();
293 Add2RecPointsList(h2,kRecPDigM, !expert, image);
294
295}
296
297//____________________________________________________________________________
298void AliEMCALQADataMakerRec::InitRaws()
299{
300 // create Raws histograms in Raws subdir
301 const Bool_t expert = kTRUE ;
302 const Bool_t saveCorr = kTRUE ;
303 const Bool_t image = kTRUE ;
304
38986b78 305 Int_t nTowersPerSM = AliEMCALGeoParams::fgkEMCALRows * AliEMCALGeoParams::fgkEMCALCols; // number of towers in a SuperModule; 24x48
306 Int_t nTot = fSuperModules * nTowersPerSM; // max number of towers in all SuperModules
307
308
309 //Defining histograms binning, each 2D histogram covers all SMs
310 Int_t nSMSectors = fSuperModules / 2; // 2 SMs per sector
311 Int_t nbinsZ = 2*AliEMCALGeoParams::fgkEMCALCols;
312 Int_t nbinsPhi = nSMSectors * AliEMCALGeoParams::fgkEMCALRows;
313
314 // counter info: number of channels per event (bins are SM index)
9e47432c 315 TProfile * h0 = new TProfile("hLowEmcalSupermodules", "Low Gain EMC: # of towers vs SuperMod;SM Id;# of towers",
316 fSuperModules, -0.5, fSuperModules-0.5) ;
317 Add2RawsList(h0, kNsmodLG, expert, image, !saveCorr) ;
318 TProfile * h1 = new TProfile("hHighEmcalSupermodules", "High Gain EMC: # of towers vs SuperMod;SM Id;# of towers",
319 fSuperModules, -0.5, fSuperModules-0.5) ;
320 Add2RawsList(h1, kNsmodHG, expert, image, !saveCorr) ;
321
322 // where did max sample occur? (bins are towers)
323 TProfile * h2 = new TProfile("hLowEmcalRawtime", "Low Gain EMC: Time at Max vs towerId;Tower Id;Time [ticks]",
324 nTot, -0.5, nTot-0.5) ;
325 Add2RawsList(h2, kTimeLG, expert, image, !saveCorr) ;
326 TProfile * h3 = new TProfile("hHighEmcalRawtime", "High Gain EMC: Time at Max vs towerId;Tower Id;Time [ticks]",
327 nTot, -0.5, nTot-0.5) ;
328 Add2RawsList(h3, kTimeHG, expert, image, !saveCorr) ;
329
330 // how much above pedestal was the max sample? (bins are towers)
331 TProfile * h4 = new TProfile("hLowEmcalRawMaxMinusMin", "Low Gain EMC: Max - Min vs towerId;Tower Id;Max-Min [ADC counts]",
332 nTot, -0.5, nTot-0.5) ;
333 Add2RawsList(h4, kSigLG, expert, image, !saveCorr) ;
334 TProfile * h5 = new TProfile("hHighEmcalRawMaxMinusMin", "High Gain EMC: Max - Min vs towerId;Tower Id;Max-Min [ADC counts]",
335 nTot, -0.5, nTot-0.5) ;
336 Add2RawsList(h5, kSigHG, expert, image, !saveCorr) ;
337
338 // total counter: channels per event
339 TH1I * h6 = new TH1I("hLowNtot", "Low Gain EMC: Total Number of found towers;# of Towers;Counts", 200, 0, nTot) ;
340 h6->Sumw2() ;
341 Add2RawsList(h6, kNtotLG, expert, image, !saveCorr) ;
342 TH1I * h7 = new TH1I("hHighNtot", "High Gain EMC: Total Number of found towers;# of Towers;Counts", 200,0, nTot) ;
343 h7->Sumw2() ;
344 Add2RawsList(h7, kNtotHG, expert, image, !saveCorr) ;
345
346 // pedestal (bins are towers)
347 TProfile * h8 = new TProfile("hLowEmcalRawPed", "Low Gain EMC: Pedestal vs towerId;Tower Id;Pedestal [ADC counts]",
348 nTot, -0.5, nTot-0.5) ;
349 Add2RawsList(h8, kPedLG, expert, image, !saveCorr) ;
350 TProfile * h9 = new TProfile("hHighEmcalRawPed", "High Gain EMC: Pedestal vs towerId;Tower Id;Pedestal [ADC counts]",
351 nTot, -0.5, nTot-0.5) ;
352 Add2RawsList(h9, kPedHG, expert, image, !saveCorr) ;
9e47432c 353
354 //number of events per tower, for shifter fast check
355 TH1I * h12 = new TH1I("hTowerHG", "High Gains on the Tower;Tower", nTot,0, nTot) ;
356 h12->Sumw2() ;
357 Add2RawsList(h12, kTowerHG, !expert, image, !saveCorr) ;
358 TH1I * h13 = new TH1I("hTowerLG", "Low Gains on the Tower;Tower", nTot,0, nTot) ;
359 h13->Sumw2() ;
360 Add2RawsList(h13, kTowerLG, !expert, image, !saveCorr) ;
38986b78 361
362 //temp 2D amplitude histogram for the current run
363 fHighEmcHistoH2F = new TH2F("h2DHighEC2", "High Gain EMC:Max - Min [ADC counts]", nbinsZ, -0.5 , nbinsZ-0.5, nbinsPhi, -0.5, nbinsPhi-0.5);
f05c8877 364 fHighEmcHistoH2F->SetDirectory(0) ; // this histo must be memory resident
38986b78 365 //add ratio histograms: to comapre the current run with the reference data
366 TH2F * h15 = new TH2F("h2DRatioAmp", "High Gain Ratio to Reference:Amplitude_{current run}/Amplitude_{reference run}", nbinsZ, -0.5 , nbinsZ-0.5,
367 nbinsPhi, -0.5, nbinsPhi-0.5);
368 //settings for display in amore
369 h15->SetTitle("Amplitude_{current run}/Amplitude_{reference run}");
370 h15->SetMaximum(1.6);
371 h15->SetMinimum(0.4);
372 h15->SetOption("COLZ");
373 gStyle->SetOptStat(0);
374 Int_t color[] = {4,3,2} ;
375 gStyle->SetPalette(3,color);
376 h15->GetZaxis()->SetNdivisions(3);
377 h15->UseCurrentStyle();
f05c8877 378 h15->SetDirectory(0);
38986b78 379 Add2RawsList(h15, k2DRatioAmp, !expert, image, !saveCorr) ;
380
381 TH1F * h16 = new TH1F("hRatioDist", "Amplitude_{current run}/Amplitude_{reference run} ratio distribution", nTot, 0., 2.);
382 h16->SetMinimum(1.);
f05c8877 383 h16->SetDirectory(0);
38986b78 384 Add2RawsList(h16, kRatioDist, !expert, image, !saveCorr) ;
385
9e47432c 386 // now repeat the same for TRU and LEDMon data
38986b78 387 Int_t nTot2x2 = fSuperModules * AliEMCALGeoParams::fgkEMCALTRUsPerSM * AliEMCALGeoParams::fgkEMCAL2x2PerTRU; // max number of TRU channels for all SuperModules
9e47432c 388
389 // counter info: number of channels per event (bins are SM index)
390 TProfile * hT0 = new TProfile("hTRUEmcalSupermodules", "TRU EMC: # of TRU channels vs SuperMod;SM Id;# of TRU channels",
391 fSuperModules, -0.5, fSuperModules-0.5) ;
392 Add2RawsList(hT0, kNsmodTRU, expert, image, !saveCorr) ;
393
394 // where did max sample occur? (bins are TRU channels)
395 TProfile * hT1 = new TProfile("hTRUEmcalRawtime", "TRU EMC: Time at Max vs 2x2Id;2x2 Id;Time [ticks]",
396 nTot2x2, -0.5, nTot2x2-0.5) ;
397 Add2RawsList(hT1, kTimeTRU, expert, image, !saveCorr) ;
398
399 // how much above pedestal was the max sample? (bins are TRU channels)
400 TProfile * hT2 = new TProfile("hTRUEmcalRawMaxMinusMin", "TRU EMC: Max - Min vs 2x2Id;2x2 Id;Max-Min [ADC counts]",
401 nTot2x2, -0.5, nTot2x2-0.5) ;
402 Add2RawsList(hT2, kSigTRU, expert, image, !saveCorr) ;
403
404 // total counter: channels per event
405 TH1I * hT3 = new TH1I("hTRUNtot", "TRU EMC: Total Number of found TRU channels;# of TRU Channels;Counts", 200, 0, nTot2x2) ;
406 hT3->Sumw2() ;
407 Add2RawsList(hT3, kNtotTRU, expert, image, !saveCorr) ;
408
409 // pedestal (bins are TRU channels)
410 TProfile * hT4 = new TProfile("hTRUEmcalRawPed", "TRU EMC: Pedestal vs 2x2Id;2x2 Id;Pedestal [ADC counts]",
411 nTot2x2, -0.5, nTot2x2-0.5) ;
412 Add2RawsList(hT4, kPedTRU, expert, image, !saveCorr) ;
413
5c6517c3 414 // L0 trigger hits: # of hits (bins are TRU channels)
415 TH1I * hT5 = new TH1I("hTRUEmcalL0hits", "L0 trigger hits: Total number of 2x2 L0 generated", nTot2x2, -0.5, nTot2x2);
416 hT5->Sumw2();
417 Add2RawsList(hT5, kNL0TRU, expert, image, !saveCorr);
418
419 // L0 trigger hits: average time (bins are TRU channels)
420 TProfile * hT6 = new TProfile("hTRUEmcalL0hitsAvgTime", "L0 trigger hits: average time bin", nTot2x2, -0.5, nTot2x2);
421 Add2RawsList(hT6, kTimeL0TRU, expert, image, !saveCorr);
422
9e47432c 423 // and also LED Mon..
424 // LEDMon has both high and low gain channels, just as regular FEE/towers
38986b78 425 Int_t nTotLEDMon = fSuperModules * AliEMCALGeoParams::fgkEMCALLEDRefs; // max number of LEDMon channels for all SuperModules
9e47432c 426
427 // counter info: number of channels per event (bins are SM index)
428 TProfile * hL0 = new TProfile("hLowLEDMonEmcalSupermodules", "LowLEDMon Gain EMC: # of strips vs SuperMod;SM Id;# of strips",
429 fSuperModules, -0.5, fSuperModules-0.5) ;
430 Add2RawsList(hL0, kNsmodLGLEDMon, expert, image, !saveCorr) ;
431 TProfile * hL1 = new TProfile("hHighLEDMonEmcalSupermodules", "HighLEDMon Gain EMC: # of strips vs SuperMod;SM Id;# of strips",
432 fSuperModules, -0.5, fSuperModules-0.5) ;
433 Add2RawsList(hL1, kNsmodHGLEDMon, expert, image, !saveCorr) ;
434
435 // where did max sample occur? (bins are strips)
436 TProfile * hL2 = new TProfile("hLowLEDMonEmcalRawtime", "LowLEDMon Gain EMC: Time at Max vs stripId;Strip Id;Time [ticks]",
437 nTotLEDMon, -0.5, nTotLEDMon-0.5) ;
438 Add2RawsList(hL2, kTimeLGLEDMon, expert, image, !saveCorr) ;
439 TProfile * hL3 = new TProfile("hHighLEDMonEmcalRawtime", "HighLEDMon Gain EMC: Time at Max vs stripId;Strip Id;Time [ticks]",
440 nTotLEDMon, -0.5, nTotLEDMon-0.5) ;
441 Add2RawsList(hL3, kTimeHGLEDMon, expert, image, !saveCorr) ;
442
443 // how much above pedestal was the max sample? (bins are strips)
444 TProfile * hL4 = new TProfile("hLowLEDMonEmcalRawMaxMinusMin", "LowLEDMon Gain EMC: Max - Min vs stripId;Strip Id;Max-Min [ADC counts]",
445 nTotLEDMon, -0.5, nTotLEDMon-0.5) ;
446 Add2RawsList(hL4, kSigLGLEDMon, expert, image, !saveCorr) ;
447 TProfile * hL5 = new TProfile("hHighLEDMonEmcalRawMaxMinusMin", "HighLEDMon Gain EMC: Max - Min vs stripId;Strip Id;Max-Min [ADC counts]",
448 nTotLEDMon, -0.5, nTotLEDMon-0.5) ;
449 Add2RawsList(hL5, kSigHGLEDMon, expert, image, !saveCorr) ;
38986b78 450
451 // total counter: channels per event
9e47432c 452 TH1I * hL6 = new TH1I("hLowLEDMonNtot", "LowLEDMon Gain EMC: Total Number of found strips;# of Strips;Counts", 200, 0, nTotLEDMon) ;
453 hL6->Sumw2() ;
454 Add2RawsList(hL6, kNtotLGLEDMon, expert, image, !saveCorr) ;
455 TH1I * hL7 = new TH1I("hHighLEDMonNtot", "HighLEDMon Gain EMC: Total Number of found strips;# of Strips;Counts", 200,0, nTotLEDMon) ;
456 hL7->Sumw2() ;
457 Add2RawsList(hL7, kNtotHGLEDMon, expert, image, !saveCorr) ;
458
459 // pedestal (bins are strips)
460 TProfile * hL8 = new TProfile("hLowLEDMonEmcalRawPed", "LowLEDMon Gain EMC: Pedestal vs stripId;Strip Id;Pedestal [ADC counts]",
461 nTotLEDMon, -0.5, nTotLEDMon-0.5) ;
462 Add2RawsList(hL8, kPedLGLEDMon, expert, image, !saveCorr) ;
463 TProfile * hL9 = new TProfile("hHighLEDMonEmcalRawPed", "HighLEDMon Gain EMC: Pedestal vs stripId;Strip Id;Pedestal [ADC counts]",
464 nTotLEDMon, -0.5, nTotLEDMon-0.5) ;
465 Add2RawsList(hL9, kPedHGLEDMon, expert, image, !saveCorr) ;
38986b78 466
467 //add two histograms for shifter from the LED monitor system: comapre LED monitor with the reference run
468 //to be used for decision whether we need to change reference data
469 TH1F * hL10 = new TH1F("hMaxMinusMinLEDMonRatio", "LEDMon amplitude, Ratio to reference run", nTotLEDMon, -0.5, nTotLEDMon-0.5) ;
470 Add2RawsList(hL10, kLEDMonRatio, !expert, image, !saveCorr) ;
471 //settings for display in amore
472 hL10->SetTitle("Amplitude_{LEDMon current}/Amplitude_{LEDMon reference}");
473 hL10->SetMaximum(1.6);
474 hL10->SetMinimum(0.4);
475// hL10->SetOption("E");
476 TH1F * hL11 = new TH1F("hMaxMinusMinLEDMonRatioDist", "LEDMon amplitude, Ratio distribution", nTot, 0, 2);
477 hL11->SetMinimum(1.) ;
478 Add2RawsList(hL11, kLEDMonRatioDist, !expert, image, !saveCorr) ;
479
480 GetCalibRefFromOCDB() ;
481 GetCalibRefFromOCDB() ;
9e47432c 482}
483
484//____________________________________________________________________________
485void AliEMCALQADataMakerRec::MakeESDs(AliESDEvent * esd)
486{
487 // make QA data from ESDs
488
489 Int_t nTot = 0 ;
490 for ( Int_t index = 0; index < esd->GetNumberOfCaloClusters() ; index++ ) {
491 AliESDCaloCluster * clu = esd->GetCaloCluster(index) ;
492 if( clu->IsEMCAL() ) {
493 GetESDsData(kESDCaloClusE)->Fill(clu->E()) ;
494 nTot++ ;
495 }
496 }
497 GetESDsData(kESDCaloClusM)->Fill(nTot) ;
498
499 //fill calo cells
500 AliESDCaloCells* cells = esd->GetEMCALCells();
501 GetESDsData(kESDCaloCellM)->Fill(cells->GetNumberOfCells()) ;
502
503 for ( Int_t index = 0; index < cells->GetNumberOfCells() ; index++ ) {
504 GetESDsData(kESDCaloCellA)->Fill(cells->GetAmplitude(index)) ;
505 }
506
507}
508
509//____________________________________________________________________________
510void AliEMCALQADataMakerRec::MakeRaws(AliRawReader* rawReader)
511{
512 //Fill prepared histograms with Raw digit properties
e03bcdd4 513
514 // make sure EMCal was readout during the event
515 Int_t emcID = AliDAQ::DetectorID("EMCAL"); // bit 18..
7b2c20bb 516 const UInt_t *detPattern = rawReader->GetDetectorPattern();
e03bcdd4 517 UInt_t emcInReadout = ( ((1 << emcID) & detPattern[0]) >> emcID);
38986b78 518 if (! emcInReadout) return; // no poInt_t in looking at this event, if no EMCal data
e03bcdd4 519
def665cb 520 // setup
9e47432c 521 rawReader->Reset() ;
522 AliCaloRawStreamV3 in(rawReader,"EMCAL");
30aa89b0 523 rawReader->Select("EMCAL", 0, AliEMCALGeoParams::fgkLastAltroDDL) ; //select EMCAL DDL's
9e47432c 524
5c6517c3 525 AliRecoParam::EventSpecie_t saveSpecie = fEventSpecie ;
526
def665cb 527 if (rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent) {
528 SetEventSpecie(AliRecoParam::kCalib) ;
529 }
38986b78 530
38986b78 531 const Int_t nTowersPerSM = AliEMCALGeoParams::fgkEMCALRows * AliEMCALGeoParams::fgkEMCALCols; // number of towers in a SuperModule; 24x48
532 const Int_t nRows = AliEMCALGeoParams::fgkEMCALRows; // number of rows per SuperModule
533 const Int_t nStripsPerSM = AliEMCALGeoParams::fgkEMCALLEDRefs; // number of strips per SuperModule
534 const Int_t n2x2PerSM = AliEMCALGeoParams::fgkEMCALTRUsPerSM * AliEMCALGeoParams::fgkEMCAL2x2PerTRU; // number of TRU 2x2's per SuperModule
535 const Int_t n2x2PerTRU = AliEMCALGeoParams::fgkEMCAL2x2PerTRU;
9e47432c 536
9e47432c 537 // SM counters; decl. should be safe, assuming we don't get more than expected SuperModules..
38986b78 538 Int_t nTotalSMLG[AliEMCALGeoParams::fgkEMCALModules] = {0};
539 Int_t nTotalSMHG[AliEMCALGeoParams::fgkEMCALModules] = {0};
540 Int_t nTotalSMTRU[AliEMCALGeoParams::fgkEMCALModules] = {0};
541 Int_t nTotalSMLGLEDMon[AliEMCALGeoParams::fgkEMCALModules] = {0};
542 Int_t nTotalSMHGLEDMon[AliEMCALGeoParams::fgkEMCALModules] = {0};
543
544 const Int_t nTRUL0ChannelBits = 10; // used for L0 trigger bits checks
545 Int_t iSM = 0; // SuperModule index
def665cb 546 // start loop over input stream
def665cb 547 while (in.NextDDL()) {
38986b78 548 Int_t iRCU = in.GetDDLNumber() % 2; // RCU0 or RCU1, within SuperModule
dc16c015 549 fRawAnalyzer->SetIsZeroSuppressed( in.GetZeroSupp() );
9e47432c 550
98d6fe2e 551 while (in.NextChannel()) {
552 iSM = in.GetModule(); // SuperModule
38986b78 553 //prInt_tf("iSM %d DDL %d", iSM, in.GetDDLNumber());
98d6fe2e 554 if (iSM>=0 && iSM<fSuperModules) { // valid module reading
9e47432c 555
38986b78 556 Int_t nsamples = 0;
def665cb 557 vector<AliCaloBunchInfo> bunchlist;
558 while (in.NextBunch()) {
559 nsamples += in.GetBunchLength();
560 bunchlist.push_back( AliCaloBunchInfo(in.GetStartTimeBin(), in.GetBunchLength(), in.GetSignals() ) );
561 }
562
563 if (nsamples > 0) { // this check is needed for when we have zero-supp. on, but not sparse readout
38986b78 564 Float_t time = 0.;
565 Float_t amp = 0.;
def665cb 566 // indices for pedestal calc.
38986b78 567 Int_t firstPedSample = 0;
568 Int_t lastPedSample = 0;
569 bool isTRUL0IdData = false;
def665cb 570
571 if (! in.IsTRUData() ) { // high gain, low gain, LED Mon data - all have the same shaper/sampling
572 AliCaloFitResults fitResults = fRawAnalyzer->Evaluate( bunchlist, in.GetAltroCFG1(), in.GetAltroCFG2());
38986b78 573 amp = fitResults.GetAmp();
def665cb 574 time = fitResults.GetTof();
575 firstPedSample = fFirstPedestalSample;
38986b78 576 lastPedSample = fLastPedestalSample;
9e47432c 577 }
def665cb 578 else { // TRU data is special, needs its own analyzer
579 AliCaloFitResults fitResults = fRawAnalyzerTRU->Evaluate( bunchlist, in.GetAltroCFG1(), in.GetAltroCFG2());
38986b78 580 amp = fitResults.GetAmp();
def665cb 581 time = fitResults.GetTof();
582 firstPedSample = fFirstPedestalSampleTRU;
38986b78 583 lastPedSample = fLastPedestalSampleTRU;
5c6517c3 584 if (in.GetColumn() > n2x2PerTRU) {
585 isTRUL0IdData = true;
586 }
def665cb 587 }
588
589 // pedestal samples
38986b78 590 Int_t nPed = 0;
591 vector<Int_t> pedSamples;
9e47432c 592
def665cb 593 // select earliest bunch
594 unsigned int bunchIndex = 0;
595 unsigned int startBin = bunchlist.at(0).GetStartBin();
596 if (bunchlist.size() > 0) {
597 for(unsigned int ui=1; ui < bunchlist.size(); ui++ ) {
598 if (startBin > bunchlist.at(ui).GetStartBin() ) {
599 startBin = bunchlist.at(ui).GetStartBin();
600 bunchIndex = ui;
601 }
9e47432c 602 }
603 }
def665cb 604
605 // check bunch for entries in the pedestal sample range
38986b78 606 Int_t bunchLength = bunchlist.at(bunchIndex).GetLength();
def665cb 607 const UShort_t *sig = bunchlist.at(bunchIndex).GetData();
38986b78 608 Int_t timebin = 0;
5c6517c3 609
610 if (! isTRUL0IdData) { // regular data, can look at pedestals
38986b78 611 for (Int_t i = 0; i<bunchLength; i++) {
5c6517c3 612 timebin = startBin--;
613 if ( firstPedSample<=timebin && timebin<=lastPedSample ) {
614 pedSamples.push_back( sig[i] );
615 nPed++;
616 }
617 } // i
5c6517c3 618 }
619 else { // TRU L0 Id Data
620 // which TRU the channel belongs to?
38986b78 621 Int_t iTRUId = in.GetModule()*3 + (iRCU*in.GetBranch() + iRCU);
5c6517c3 622
38986b78 623 for (Int_t i = 0; i< bunchLength; i++) {
624 for( Int_t j = 0; j < nTRUL0ChannelBits; j++ ){
5c6517c3 625 // check if the bit j is 1
626 if( (sig[i] & ( 1 << j )) > 0 ){
38986b78 627 Int_t iTRUIdInSM = (in.GetColumn() - n2x2PerTRU)*nTRUL0ChannelBits+j;
ce95bae9 628 if(iTRUIdInSM < n2x2PerTRU) {
38986b78 629 Int_t iTRUAbsId = iTRUIdInSM + n2x2PerTRU * iTRUId;
5c6517c3 630 // Fill the histograms
ce95bae9 631 GetRawsData(kNL0TRU)->Fill(iTRUAbsId);
632 GetRawsData(kTimeL0TRU)->Fill(iTRUAbsId, startBin);
5c6517c3 633 }
634 }
635 }
636 startBin--;
637 } // i
638 } // TRU L0 Id data
def665cb 639
640 // fill histograms
641 if ( in.IsLowGain() || in.IsHighGain() ) { // regular towers
38986b78 642 Int_t towerId = iSM*nTowersPerSM + in.GetColumn()*nRows + in.GetRow();
def665cb 643 if ( in.IsLowGain() ) {
644 nTotalSMLG[iSM]++;
645 GetRawsData(kTowerLG)->Fill(towerId);
646 if ( (amp > fMinSignalLG) && (amp < fMaxSignalLG) ) {
647 GetRawsData(kSigLG)->Fill(towerId, amp);
648 GetRawsData(kTimeLG)->Fill(towerId, time);
649 }
650 if (nPed > 0) {
38986b78 651 for (Int_t i=0; i<nPed; i++) {
def665cb 652 GetRawsData(kPedLG)->Fill(towerId, pedSamples[i]);
653 }
654 }
655 } // gain==0
656 else if ( in.IsHighGain() ) {
657 nTotalSMHG[iSM]++;
658 GetRawsData(kTowerHG)->Fill(towerId);
659 if ( (amp > fMinSignalHG) && (amp < fMaxSignalHG) ) {
660 GetRawsData(kSigHG)->Fill(towerId, amp);
661 GetRawsData(kTimeHG)->Fill(towerId, time);
662 }
663 if (nPed > 0) {
38986b78 664 for (Int_t i=0; i<nPed; i++) {
def665cb 665 GetRawsData(kPedHG)->Fill(towerId, pedSamples[i]);
666 }
667 }
668 } // gain==1
669 } // low or high gain
38986b78 670 // TRU
def665cb 671 else if ( in.IsTRUData() && in.GetColumn()<AliEMCALGeoParams::fgkEMCAL2x2PerTRU) {
38986b78 672 // for TRU data, the mapping class holds the TRU Int_ternal 2x2 number (0..95) in the Column var..
673 Int_t iTRU = (iRCU*in.GetBranch() + iRCU); //TRU0 is from RCU0, TRU1 from RCU1, TRU2 is from branch B on RCU1
674 Int_t iTRU2x2Id = iSM*n2x2PerSM + iTRU*AliEMCALGeoParams::fgkEMCAL2x2PerTRU
def665cb 675 + in.GetColumn();
def665cb 676 nTotalSMTRU[iSM]++;
677 if ( (amp > fMinSignalTRU) && (amp < fMaxSignalTRU) ) {
678 GetRawsData(kSigTRU)->Fill(iTRU2x2Id, amp);
679 GetRawsData(kTimeTRU)->Fill(iTRU2x2Id, time);
9e47432c 680 }
def665cb 681 if (nPed > 0) {
38986b78 682 for (Int_t i=0; i<nPed; i++) {
def665cb 683 GetRawsData(kPedTRU)->Fill(iTRU2x2Id, pedSamples[i]);
684 }
9e47432c 685 }
def665cb 686 }
687 // LED Mon
688 else if ( in.IsLEDMonData() ) {
689 // for LED Mon data, the mapping class holds the gain info in the Row variable
690 // and the Strip number in the Column..
38986b78 691 Int_t gain = in.GetRow();
692 Int_t stripId = iSM*nStripsPerSM + in.GetColumn();
def665cb 693
694 if ( gain == 0 ) {
695 nTotalSMLGLEDMon[iSM]++;
696 if ( (amp > fMinSignalLGLEDMon) && (amp < fMaxSignalLGLEDMon) ) {
697 GetRawsData(kSigLGLEDMon)->Fill(stripId, amp);
698 GetRawsData(kTimeLGLEDMon)->Fill(stripId, time);
699 }
700 if (nPed > 0) {
38986b78 701 for (Int_t i=0; i<nPed; i++) {
def665cb 702 GetRawsData(kPedLGLEDMon)->Fill(stripId, pedSamples[i]);
703 }
704 }
705 } // gain==0
706 else if ( gain == 1 ) {
707 nTotalSMHGLEDMon[iSM]++;
708 if ( (amp > fMinSignalHGLEDMon) && (amp < fMaxSignalHGLEDMon) ) {
709 GetRawsData(kSigHGLEDMon)->Fill(stripId, amp);
710 GetRawsData(kTimeHGLEDMon)->Fill(stripId, time);
711 }
712 if (nPed > 0) {
38986b78 713 for (Int_t i=0; i<nPed; i++) {
def665cb 714 GetRawsData(kPedHGLEDMon)->Fill(stripId, pedSamples[i]);
715 }
716 }
717 } // low or high gain
718 } // LEDMon
719
720 } // SM index OK
9e47432c 721
722 } // nsamples>0 check, some data found for this channel; not only trailer/header
723 }// end while over channel
724
725 }//end while over DDL's, of input stream
726
38986b78 727 // TProfile * p = dynamic_cast<TProfile *>(GetRawsData(kSigHG)) ;
728 ConvertProfile2H(dynamic_cast<TProfile *>(GetRawsData(kSigHG)), fHighEmcHistoH2F) ;
729 Double_t binContent = 0. ;
730 //calculate the ratio of the amplitude and fill the histograms, only if the events type is Calib
731 if (rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent) {
f05c8877 732 if(GetRawsData(k2DRatioAmp)->GetEntries())
733 GetRawsData(k2DRatioAmp)->Reset("ICE");
734 if(GetRawsData(kRatioDist)->GetEntries())
735 GetRawsData(kRatioDist)->Reset("ICE");
38986b78 736 for(Int_t ix = 1; ix <= fHighEmcHistoH2F->GetNbinsX(); ix++) {
737 for(Int_t iy = 1; iy <= fHighEmcHistoH2F->GetNbinsY(); iy++) {
738 if(fCalibRefHistoH2F->GetBinContent(ix, iy))binContent = fHighEmcHistoH2F->GetBinContent(ix, iy)/fCalibRefHistoH2F->GetBinContent(ix, iy) ;
739 GetRawsData(k2DRatioAmp)->SetBinContent(ix, iy, binContent);
740 GetRawsData(kRatioDist)->Fill(GetRawsData(k2DRatioAmp)->GetBinContent(ix, iy));
741 }
742 }
743 }
744 //Now for LED monitor system, to calculate the ratio as well
745 if(fLEDMonRefHistoPro){
33ea9527 746 GetRawsData(kLEDMonRatio)->Reset("ICE");
747 GetRawsData(kLEDMonRatioDist)->Reset("ICE");
38986b78 748
f05c8877 749 Double_t binError = 0. ;
38986b78 750
751 for(int ib = 1; ib <= fLEDMonRefHistoPro->GetNbinsX(); ib++) {
752
753 if(fLEDMonRefHistoPro->GetBinContent(ib) != 0) binContent = GetRawsData(kSigLGLEDMon)->GetBinContent(ib) / fLEDMonRefHistoPro->GetBinContent(ib);
754 else binContent = 0;
755 GetRawsData(kLEDMonRatio)->SetBinContent(ib, binContent);
756
757 binError = GetRawsData(kSigLGLEDMon)->GetBinError(ib)/fLEDMonRefHistoPro->GetBinContent(ib) +
758 GetRawsData(kSigLGLEDMon)->GetBinContent(ib)/TMath::Power(fLEDMonRefHistoPro->GetBinContent(ib), 2)*fLEDMonRefHistoPro->GetBinError(ib);
759 GetRawsData(kLEDMonRatio)->SetBinError(ib, binError);
760 GetRawsData(kLEDMonRatioDist)->Fill(GetRawsData(kLEDMonRatio)->GetBinContent(ib));
761 }
762 }
763
764
765
9e47432c 766 // let's also fill the SM and event counter histograms
38986b78 767 Int_t nTotalHG = 0;
768 Int_t nTotalLG = 0;
769 Int_t nTotalTRU = 0;
770 Int_t nTotalHGLEDMon = 0;
771 Int_t nTotalLGLEDMon = 0;
1a78a765 772 for (iSM=0; iSM<fSuperModules; iSM++) {
9e47432c 773 nTotalLG += nTotalSMLG[iSM];
774 nTotalHG += nTotalSMHG[iSM];
775 nTotalTRU += nTotalSMTRU[iSM];
98d6fe2e 776 nTotalLGLEDMon += nTotalSMLGLEDMon[iSM];
777 nTotalHGLEDMon += nTotalSMHGLEDMon[iSM];
9e47432c 778 GetRawsData(kNsmodLG)->Fill(iSM, nTotalSMLG[iSM]);
779 GetRawsData(kNsmodHG)->Fill(iSM, nTotalSMHG[iSM]);
780 GetRawsData(kNsmodTRU)->Fill(iSM, nTotalSMTRU[iSM]);
781 GetRawsData(kNsmodLGLEDMon)->Fill(iSM, nTotalSMLGLEDMon[iSM]);
782 GetRawsData(kNsmodHGLEDMon)->Fill(iSM, nTotalSMHGLEDMon[iSM]);
783 }
def665cb 784
9e47432c 785 GetRawsData(kNtotLG)->Fill(nTotalLG);
786 GetRawsData(kNtotHG)->Fill(nTotalHG);
787 GetRawsData(kNtotTRU)->Fill(nTotalTRU);
788 GetRawsData(kNtotLGLEDMon)->Fill(nTotalLGLEDMon);
789 GetRawsData(kNtotHGLEDMon)->Fill(nTotalHGLEDMon);
5c6517c3 790
791
def665cb 792 SetEventSpecie(saveSpecie) ;
9e47432c 793 // just in case the next rawreader consumer forgets to reset; let's do it here again..
794 rawReader->Reset() ;
795
796 return;
797}
798
799//____________________________________________________________________________
800void AliEMCALQADataMakerRec::MakeDigits()
801{
802 // makes data from Digits
803
804 GetDigitsData(1)->Fill(fDigitsArray->GetEntriesFast()) ;
805 TIter next(fDigitsArray) ;
806 AliEMCALDigit * digit ;
807 while ( (digit = dynamic_cast<AliEMCALDigit *>(next())) ) {
829ba234 808 GetDigitsData(0)->Fill( digit->GetAmplitude()) ;
9e47432c 809 }
810
811}
812
813//____________________________________________________________________________
814void AliEMCALQADataMakerRec::MakeDigits(TTree * digitTree)
815{
816 // makes data from Digit Tree
817 if (fDigitsArray)
818 fDigitsArray->Clear() ;
819 else
820 fDigitsArray = new TClonesArray("AliEMCALDigit", 1000) ;
821
822 TBranch * branch = digitTree->GetBranch("EMCAL") ;
823 if ( ! branch ) {
824 AliWarning("EMCAL branch in Digit Tree not found") ;
825 } else {
826 branch->SetAddress(&fDigitsArray) ;
827 branch->GetEntry(0) ;
828 MakeDigits() ;
829 }
830
831}
832
833//____________________________________________________________________________
834void AliEMCALQADataMakerRec::MakeRecPoints(TTree * clustersTree)
835{
836 // makes data from RecPoints
837 TBranch *emcbranch = clustersTree->GetBranch("EMCALECARP");
838 if (!emcbranch) {
839 AliError("can't get the branch with the EMCAL clusters !");
840 return;
841 }
842
38986b78 843 TObjArray * emcRecPoints = new TObjArray(100) ;
844 emcbranch->SetAddress(&emcRecPoints);
9e47432c 845 emcbranch->GetEntry(0);
846
38986b78 847 GetRecPointsData(kRecPM)->Fill(emcRecPoints->GetEntriesFast()) ;
848 TIter next(emcRecPoints) ;
9e47432c 849 AliEMCALRecPoint * rp ;
850 while ( (rp = dynamic_cast<AliEMCALRecPoint *>(next())) ) {
38986b78 851 GetRecPointsData(kRecPE)->Fill(rp->GetEnergy()) ;
9e47432c 852 GetRecPointsData(kRecPDigM)->Fill(rp->GetMultiplicity());
853 }
38986b78 854 emcRecPoints->Delete();
855 delete emcRecPoints;
9e47432c 856
857}
858
859//____________________________________________________________________________
860void AliEMCALQADataMakerRec::StartOfDetectorCycle()
861{
862 //Detector specific actions at start of cycle
863
864}
865
def665cb 866//____________________________________________________________________________
867void AliEMCALQADataMakerRec::SetFittingAlgorithm(Int_t fitAlgo)
868{
869 //Set fitting algorithm and initialize it if this same algorithm was not set before.
870 //printf("**** Set Algorithm , number %d ****\n",fitAlgo);
871
872 if(fitAlgo == fFittingAlgorithm && fRawAnalyzer) {
873 //Do nothing, this same algorithm already set before.
874 //printf("**** Algorithm already set before, number %d, %s ****\n",fitAlgo, fRawAnalyzer->GetName());
875 return;
876 }
877 //Initialize the requested algorithm
878 if(fitAlgo != fFittingAlgorithm || !fRawAnalyzer) {
879 //printf("**** Init Algorithm , number %d ****\n",fitAlgo);
880
881 fFittingAlgorithm = fitAlgo;
882 if (fRawAnalyzer) delete fRawAnalyzer; // delete prev. analyzer if existed.
883
884 if (fitAlgo == kFastFit) {
885 fRawAnalyzer = new AliCaloRawAnalyzerFastFit();
886 }
887 else if (fitAlgo == kNeuralNet) {
888 fRawAnalyzer = new AliCaloRawAnalyzerNN();
889 }
890 else if (fitAlgo == kLMS) {
891 fRawAnalyzer = new AliCaloRawAnalyzerLMS();
892 }
893 else if (fitAlgo == kPeakFinder) {
894 fRawAnalyzer = new AliCaloRawAnalyzerPeakFinder();
895 }
896 else if (fitAlgo == kCrude) {
897 fRawAnalyzer = new AliCaloRawAnalyzerCrude();
898 }
899 else {
900 AliWarning("EMCAL QA invalid fit algorithm choice") ;
901 }
902
903 }
904 return;
905}
906
38986b78 907//_____________________________________________________________________________________
908void AliEMCALQADataMakerRec::ConvertProfile2H(TProfile * p, TH2 * histo)
909{
910 // set some histogram defaults
911 //histo->Reset() ;
912 //histo->SetStats(kFALSE); // no statistics box shown
913 Int_t nbinsProf = p->GetNbinsX();
914
915 // loop through the TProfile p and fill the TH2F histo
916 Int_t row = 0;
917 Int_t col = 0;
918 Double_t binContent = 0;
919 Int_t towerNum = 0; // global tower Id
920 // i = 0; // tower Id within SuperModule
921 Int_t iSM = 0; // SuperModule index
922 Int_t iSMSide = 0; // 0=A, 1=C side
923 Int_t iSMSector = 0; // 2 SM's per sector
924
925 // indices for 2D plots
926 Int_t col2d = 0;
927 Int_t row2d = 0;
928
929 for (Int_t ibin = 1; ibin <= nbinsProf; ibin++) {
930 towerNum = (Int_t) p->GetBinCenter(ibin);
931 binContent = p->GetBinContent(ibin);
932
933 // figure out what the tower indices are: col, row within a SuperModule
934 iSM = towerNum/(AliEMCALGeoParams::fgkEMCALRows * AliEMCALGeoParams::fgkEMCALCols);
935 col = (towerNum/AliEMCALGeoParams::fgkEMCALRows) % (AliEMCALGeoParams::fgkEMCALCols);
936 row = towerNum % (AliEMCALGeoParams::fgkEMCALRows);
937
938 //DecodeTowerNum(towerNum, &SM, &col, &row);
939 // then we calculate what the global 2D coord are, based on which SM
940 // we are in
941 iSMSector = iSM / 2;
942 iSMSide = iSM % 2;
943
944 if (iSMSide == 1) { // C side, shown to the right
945 col2d = col + AliEMCALGeoParams::fgkEMCALCols;
946 }
947 else { // A side, shown to the left
948 col2d = col;
949 }
950
951 row2d = row + iSMSector * AliEMCALGeoParams::fgkEMCALRows;
952
953 histo->SetBinContent(col2d+1, row2d+1, binContent);
954 }
955}