]>
Commit | Line | Data |
---|---|---|
1 | /************************************************************************** | |
2 | * Copyright(c) 2007-2009, 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 | /* $Id$ */ | |
16 | // ************************************************************* | |
17 | // Checks the quality assurance | |
18 | // by comparing with reference data | |
19 | // contained in a DB | |
20 | // ------------------------------------------------------------- | |
21 | // W. Ferrarese + P. Cerello Feb 2008 | |
22 | // INFN Torino | |
23 | // M. Nicassio D. Elia INFN Bari March 2008 | |
24 | // maria.nicassio@ba.infn.it | |
25 | ||
26 | ||
27 | // --- ROOT system --- | |
28 | #include <TTree.h> | |
29 | #include <TH1I.h> | |
30 | #include <TH1F.h> | |
31 | #include <TH2F.h> | |
32 | #include <TMath.h> | |
33 | // --- Standard library --- | |
34 | ||
35 | // --- AliRoot header files --- | |
36 | #include "AliITSQADataMakerRec.h" | |
37 | #include "AliITSQASPDDataMakerRec.h" | |
38 | #include "AliLog.h" | |
39 | #include "AliQAv1.h" | |
40 | #include "AliRawReader.h" | |
41 | #include "AliITSRawStreamSPD.h" | |
42 | #include "AliITSRawStreamSPDErrorLog.h" | |
43 | #include "AliITSdigitSPD.h" | |
44 | #include "AliITSRecPoint.h" | |
45 | #include "AliITSRecPointContainer.h" | |
46 | ||
47 | ClassImp(AliITSQASPDDataMakerRec) | |
48 | ||
49 | //____________________________________________________________________________ | |
50 | AliITSQASPDDataMakerRec::AliITSQASPDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Short_t ldc, AliITSRawStreamSPDErrorLog *aliITSRawStreamSPDErrorLog) : | |
51 | TObject(), | |
52 | fAliITSQADataMakerRec(aliITSQADataMakerRec), | |
53 | fkOnline(kMode), | |
54 | fLDC(ldc), | |
55 | fSPDhRawsTask(0), | |
56 | fSPDhDigitsTask(0), | |
57 | fSPDhRecPointsTask(0), | |
58 | fGenRawsOffset(0), | |
59 | fGenDigitsOffset(0), | |
60 | fGenRecPointsOffset(0), | |
61 | fAdvLogger(aliITSRawStreamSPDErrorLog) | |
62 | { | |
63 | //ctor used to discriminate OnLine-Offline analysis | |
64 | //AliInfo(Form("AliRecoParam::kNSpecies %d\n",AliRecoParam::kNSpecies)); | |
65 | fGenRawsOffset = new Int_t[AliRecoParam::kNSpecies]; | |
66 | fGenRecPointsOffset = new Int_t[AliRecoParam::kNSpecies]; | |
67 | fGenDigitsOffset = new Int_t[AliRecoParam::kNSpecies]; | |
68 | for(Int_t i=0; i<AliRecoParam::kNSpecies;i++) { | |
69 | fGenRawsOffset[i] = 0; | |
70 | fGenRecPointsOffset[i] = 0; | |
71 | fGenDigitsOffset[i]=0; | |
72 | } | |
73 | } | |
74 | ||
75 | //____________________________________________________________________________ | |
76 | AliITSQASPDDataMakerRec::AliITSQASPDDataMakerRec(const AliITSQASPDDataMakerRec& qadm) : | |
77 | TObject(), | |
78 | fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec), | |
79 | fkOnline(qadm.fkOnline), | |
80 | fLDC(qadm.fLDC), | |
81 | fSPDhRawsTask(qadm.fSPDhRawsTask), | |
82 | fSPDhDigitsTask(qadm.fSPDhDigitsTask), | |
83 | fSPDhRecPointsTask(qadm.fSPDhRecPointsTask), | |
84 | fGenRawsOffset(qadm.fGenRawsOffset), | |
85 | fGenDigitsOffset(qadm.fGenDigitsOffset), | |
86 | fGenRecPointsOffset(qadm.fGenRecPointsOffset), | |
87 | fAdvLogger(qadm.fAdvLogger) | |
88 | { | |
89 | //copy ctor | |
90 | fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ; | |
91 | fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle()); | |
92 | } | |
93 | ||
94 | //__________________________________________________________________ | |
95 | AliITSQASPDDataMakerRec::~AliITSQASPDDataMakerRec(){ | |
96 | // destructor | |
97 | delete fAdvLogger; | |
98 | } | |
99 | //__________________________________________________________________ | |
100 | ||
101 | AliITSQASPDDataMakerRec& AliITSQASPDDataMakerRec::operator = (const AliITSQASPDDataMakerRec& qac ) | |
102 | { | |
103 | // Equal operator. | |
104 | this->~AliITSQASPDDataMakerRec(); | |
105 | new(this) AliITSQASPDDataMakerRec(qac); | |
106 | return *this; | |
107 | } | |
108 | ||
109 | //____________________________________________________________________________ | |
110 | void AliITSQASPDDataMakerRec::StartOfDetectorCycle() | |
111 | { | |
112 | //Detector specific actions at start of cycle | |
113 | AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SPD Cycle\n"); | |
114 | } | |
115 | ||
116 | //____________________________________________________________________________ | |
117 | void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list) | |
118 | { | |
119 | // launch the QA checking | |
120 | // | |
121 | AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); | |
122 | if(!list){ | |
123 | AliError(" Histogram list is NULL"); | |
124 | return; | |
125 | } | |
126 | // | |
127 | Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]; | |
128 | for (int trCl=-1;trCl<fAliITSQADataMakerRec->GetNTrigClasses();trCl++) { // RS Loop over all trigger classes (+ global counter, -1) | |
129 | if(task == AliQAv1::kRAWS) { | |
130 | TObjArray &harr = *fAliITSQADataMakerRec->GetRawsDataOfTrigClass(trCl); // extract the clones for given trigger class | |
131 | // | |
132 | if (harr[5+shift]) ((TH1*)harr[5+shift])->Reset(); // clean up MEB histo (needed at the first cycle for small statistics) | |
133 | if (harr[7+shift]&&harr[1+shift]&&harr[0+shift]) ((TH1*)harr[7+shift])->Divide((TH1*)harr[1+shift],(TH1*)harr[0+shift]); | |
134 | if (harr[8+shift]&&harr[2+shift]&&harr[0+shift]) ((TH1*)harr[8+shift])->Divide((TH1*)harr[2+shift],(TH1*)harr[0+shift]); // missing FO ratio (per event) | |
135 | if (harr[9+shift]&&harr[3+shift]&&harr[4+shift]) ((TH1*)harr[9+shift])->Divide((TH1*)harr[3+shift],(TH1*)harr[4+shift]); // noisy FO ratio (per event) | |
136 | // | |
137 | TH1 *h0 = (TH1*)harr[0+shift]; | |
138 | TH1 *h4 = (TH1*)harr[4+shift]; | |
139 | TH2 *h5 = (TH2*)harr[5+shift]; | |
140 | TH1 *h8 = (TH1*)harr[8+shift]; | |
141 | TH1 *h9 = (TH1*)harr[9+shift]; | |
142 | // | |
143 | if (h0 && h4 && h5 && h8 && h9) { | |
144 | for(Int_t i=0; i<1200; i++) { | |
145 | // threshold for protection in case of technical runs (->few entries per chip) | |
146 | Short_t thre=20; // 20 is ok in run 104792 (where the problem occured). | |
147 | if (h0->GetBinContent(i+1)<thre) continue; // expected FO yield | |
148 | if (h4->GetBinContent(i+1)<thre) continue; // the total FO yield. | |
149 | // | |
150 | if(h8->GetBinContent(i+1)>0.5 && h9->GetBinContent(i+1)>0.5) { | |
151 | Int_t eq=i/60; | |
152 | Int_t hs=(i%60)/10; | |
153 | Int_t chip = (i%60)%10; | |
154 | Int_t sect = 999; Int_t chipbin = 999; | |
155 | if(eq<10) {sect = eq; chipbin = 19-chip;} | |
156 | else {sect = eq-10; chipbin = chip;} | |
157 | h5->Fill(sect*6+hs,chipbin); | |
158 | } | |
159 | } | |
160 | } | |
161 | } // QA Task Index == RAWS | |
162 | } // RS: loop over trigger classes | |
163 | } | |
164 | ||
165 | //____________________________________________________________________________ | |
166 | Int_t AliITSQASPDDataMakerRec::InitRaws() | |
167 | { | |
168 | ||
169 | // Initialization for RAW data - SPD - | |
170 | const Bool_t expert = kTRUE ; | |
171 | const Bool_t saveCorr = kTRUE ; | |
172 | const Bool_t image = kTRUE ; | |
173 | Int_t rv = 0 ; | |
174 | ||
175 | if(!fAdvLogger) fAdvLogger = new AliITSRawStreamSPDErrorLog(); | |
176 | AliDebug(AliQAv1::GetQADebugLevel(), "Book Offline Histograms for SPD\n "); | |
177 | ||
178 | Char_t name[50]; | |
179 | Char_t title[50]; | |
180 | // offset for online histogram numbering | |
181 | Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]; | |
182 | ||
183 | ||
184 | Float_t range[2] = {-0.5,1199.5}; | |
185 | ||
186 | // ********** online histo booking (shift is added) ********************* | |
187 | ||
188 | //0 | |
189 | TH1F *hFiredChips = new TH1F("SPDFiredChips_OnlineSPD","FiredChips - SPD",fgkSPDchips,range[0],range[1]); | |
190 | hFiredChips->GetXaxis()->SetTitle("chip index (eq*60 + hs*10 + chip)"); | |
191 | hFiredChips->GetYaxis()->SetTitle("Fired Chip yield"); | |
192 | rv = fAliITSQADataMakerRec->Add2RawsList(hFiredChips, 0+shift, expert, !image, !saveCorr); | |
193 | fSPDhRawsTask++; | |
194 | // 1 | |
195 | TH1F *hFastOrFiredChips = new TH1F("SPDFastOrFiredChips_OnlineSPD","FastOr-Fired Chips (if pixel hit present) - SPD",fgkSPDchips,range[0],range[1]); | |
196 | hFastOrFiredChips->GetXaxis()->SetTitle("chip index (eq*60 + hs*10 + chip)"); | |
197 | hFastOrFiredChips->GetYaxis()->SetTitle("FastOr-Fired Chip yield (per event)"); | |
198 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrFiredChips, 1+shift, expert, !image, !saveCorr); | |
199 | fSPDhRawsTask++; | |
200 | // 2 | |
201 | TH1F *hFastOrMissing = new TH1F("SPDFastOrMissing_OnlineSPD","Missing FastOr signal - SPD",fgkSPDchips,range[0],range[1]); | |
202 | hFastOrMissing->GetXaxis()->SetTitle("chip index (eq*60 + hs*10 + chip)"); | |
203 | hFastOrMissing->GetYaxis()->SetTitle("Missing Fast Or yield"); | |
204 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrMissing, 2+shift, expert, !image, !saveCorr); | |
205 | fSPDhRawsTask++; | |
206 | // 3 | |
207 | TH1F *hFastOrNoisy = new TH1F("SPDFastOrNoisy_OnlineSPD","Noisy (no pixel hit present) FastOr signal - SPD",fgkSPDchips,range[0],range[1]); | |
208 | hFastOrNoisy->GetXaxis()->SetTitle("chipkey"); | |
209 | hFastOrNoisy->GetYaxis()->SetTitle("Noisy Fast Or"); | |
210 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrNoisy, 3+shift, expert, !image, !saveCorr); | |
211 | fSPDhRawsTask++; | |
212 | // 4 | |
213 | TH1F *hFastOrCumulative = new TH1F("SPDFastOrCumulative_OnlineSPD","Cumulative FastOr signal - SPD",fgkSPDchips,range[0],range[1]); | |
214 | hFastOrCumulative->GetXaxis()->SetTitle("chipkey"); | |
215 | hFastOrCumulative->GetYaxis()->SetTitle("Cumulative Fast Or yield"); | |
216 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrCumulative, 4+shift, expert, !image, !saveCorr); | |
217 | fSPDhRawsTask++; | |
218 | // 5 | |
219 | ||
220 | TH2I *hSPDChipsMEB = new TH2I("SPDChipsMEB_OnlineSPD","Chips with MEB problem - SPD",60,0,60,20,0,20); | |
221 | // hSPDChipsMEB->GetXaxis()->SetTitle("Stave"); | |
222 | hSPDChipsMEB->GetXaxis()->SetNdivisions(60,kFALSE); | |
223 | hSPDChipsMEB->GetYaxis()->SetTitle("SIDE C -> SIDE A Chip"); | |
224 | hSPDChipsMEB->GetYaxis()->SetNdivisions(20,kFALSE); | |
225 | //hSPDChipsMEB->SetOption("COLZ"); | |
226 | hSPDChipsMEB->SetOption("text"); | |
227 | hSPDChipsMEB->UseCurrentStyle(); | |
228 | for(Int_t ibinx =0; ibinx< hSPDChipsMEB->GetNbinsX(); ibinx++){ | |
229 | if(ibinx%6==0) hSPDChipsMEB->GetXaxis()->SetBinLabel(ibinx+1,Form("Sector %i__%i",ibinx/6,ibinx%6)); | |
230 | else hSPDChipsMEB->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx%6)); | |
231 | } | |
232 | for(Int_t ibiny =0; ibiny< hSPDChipsMEB->GetNbinsY(); ibiny++){ | |
233 | if(ibiny < 10) hSPDChipsMEB->GetYaxis()->SetBinLabel(ibiny+1,Form("%i",ibiny)); | |
234 | else hSPDChipsMEB->GetYaxis()->SetBinLabel(ibiny+1,Form("%i",19-ibiny)); | |
235 | } | |
236 | rv = fAliITSQADataMakerRec->Add2RawsList(hSPDChipsMEB, 5+shift, !expert, image, !saveCorr); | |
237 | fSPDhRawsTask++; | |
238 | // 6 | |
239 | TH2F *hFastOrCorrelation = new TH2F("SPDFastOrCorrelation_OnlineSPD","Fast Or multiplicity correlation - SPD",350,0,350,700,0,700); | |
240 | hFastOrCorrelation->GetXaxis()->SetTitle("Layer 1"); | |
241 | hFastOrCorrelation->GetYaxis()->SetTitle("Layer 2"); | |
242 | hFastOrCorrelation->SetOption("COLZ"); | |
243 | hFastOrCorrelation->UseCurrentStyle(); | |
244 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrCorrelation, 6+shift, !expert, image, !saveCorr); | |
245 | fSPDhRawsTask++; | |
246 | // 7 | |
247 | TH1F *hFastOrEfficiency, *hFastOrMissingRatio, *hFastOrNoisyRatio; | |
248 | ||
249 | hFastOrEfficiency = new TH1F("SPDFastOrEfficiency_OnlineSPD","FastOr Efficiency : FastOr / fired chips (per event) - SPD",fgkSPDchips,range[0],range[1]); | |
250 | hFastOrEfficiency->SetFillColor(kBlue); | |
251 | hFastOrEfficiency->SetMaximum(1.05); | |
252 | hFastOrEfficiency->GetXaxis()->SetTitle("chip index [eq*60+hs*10+chip]"); | |
253 | hFastOrEfficiency->GetYaxis()->SetTitle("FastOr Efficiency (per event)"); | |
254 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrEfficiency, 7+shift, expert, !image, !saveCorr); | |
255 | fSPDhRawsTask++; | |
256 | // 8 | |
257 | hFastOrMissingRatio = new TH1F("SPDFastOrMissingRatio_OnlineSPD"," Missing FastOr / fired chips (per event) - SPD)",fgkSPDchips,range[0],range[1]); | |
258 | hFastOrMissingRatio->SetFillColor(kBlue); | |
259 | hFastOrMissingRatio->SetMaximum(1.05); | |
260 | hFastOrMissingRatio->GetXaxis()->SetTitle("chip index [eq*60+hs*10+chip]"); | |
261 | hFastOrMissingRatio->GetYaxis()->SetTitle("ratio of Missing FastOr (per event)"); | |
262 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrMissingRatio, 8+shift, expert, !image, !saveCorr); | |
263 | fSPDhRawsTask++; | |
264 | // 9 | |
265 | hFastOrNoisyRatio = new TH1F("SPDFastOrNoisyRatio_OnlineSPD","Noisy Fast Or / fired chips (per event) - SPD",fgkSPDchips,range[0],range[1]); | |
266 | hFastOrNoisyRatio->SetFillColor(kBlue); | |
267 | hFastOrNoisyRatio->SetMaximum(1.05); | |
268 | hFastOrNoisyRatio->GetXaxis()->SetTitle("chip index [eq*60+hs*10+chip]"); | |
269 | hFastOrNoisyRatio->GetYaxis()->SetTitle("ratio of Noisy FastOr (per event)"); | |
270 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrNoisyRatio, 9+shift, expert, !image, !saveCorr); | |
271 | fSPDhRawsTask++; | |
272 | // 10 | |
273 | TH2F *herrorsAll = new TH2F("SPDErrorsAll_OnlineSPD","Error codes - SPD",20,-0.5,19.5,22,-0.5,21.5); | |
274 | herrorsAll->GetXaxis()->SetTitle("DDL"); | |
275 | herrorsAll->GetYaxis()->SetTitle("Error Type"); | |
276 | // herrorsAll->SetOption("COLZ"); | |
277 | herrorsAll->SetOption("text"); | |
278 | herrorsAll->UseCurrentStyle(); | |
279 | rv = fAliITSQADataMakerRec->Add2RawsList(herrorsAll, kAmoreFoOffset+shift, !expert, image, !saveCorr); | |
280 | fSPDhRawsTask++; | |
281 | //11-30 | |
282 | TH1F * herrors[20]; | |
283 | for (Int_t iEq=0; iEq<20; iEq++) { | |
284 | snprintf(name,49,"SPDErrors_Eq%d_OnlineSPD",iEq+1); | |
285 | snprintf(title,49,"Error codes - SPD Eq %d",iEq+1); | |
286 | herrors[iEq] = new TH1F (name,title,fAdvLogger->GetNrErrorCodes(),0,fAdvLogger->GetNrErrorCodes()); | |
287 | herrors[iEq]->SetXTitle("Error Code"); | |
288 | herrors[iEq]->SetYTitle("Nr of errors"); | |
289 | rv = fAliITSQADataMakerRec->Add2RawsList(herrors[iEq], 11+shift+iEq, expert, !image, !saveCorr); | |
290 | fSPDhRawsTask++; | |
291 | } | |
292 | // ********* offline histo booking (offset is added) **************************** | |
293 | ||
294 | // offset for offline histogram numbering | |
295 | Int_t offset = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + kAmoreFoOffset + kAmoreErrorsOffset; | |
296 | ||
297 | // printf("now booking offline raw data : genrawoffset %i, kAmoreOffset %i , kAmoreErrorsOffset %i -> total %i , list numbering %i\n",fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()],(Int_t)kAmoreFoOffset,(Int_t)kAmoreErrorsOffset, offset,fSPDhRawsTask); | |
298 | // 0 | |
299 | TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.); | |
300 | hlayer->GetXaxis()->SetTitle("Layer number"); | |
301 | hlayer->GetYaxis()->SetTitle("Entries"); | |
302 | rv = fAliITSQADataMakerRec->Add2RawsList(hlayer, 0+offset, expert, !image, !saveCorr); | |
303 | fSPDhRawsTask++; | |
304 | ||
305 | TH1F * hmod[2]; | |
306 | TH2F * hhitMap[20]; | |
307 | ||
308 | ||
309 | // 1-2 | |
310 | for (Int_t iLay=0; iLay<2; iLay++) { | |
311 | snprintf(name,50,"SPDModPattern_SPD%d",iLay+1); | |
312 | snprintf(title,50,"Module map - SPD Layer %d",iLay+1); | |
313 | hmod[iLay]=new TH1F(name,title,fgknSPDmodules,0,fgknSPDmodules); | |
314 | hmod[iLay]->GetXaxis()->SetTitle("Module number"); | |
315 | hmod[iLay]->GetYaxis()->SetTitle("Entries"); | |
316 | rv = fAliITSQADataMakerRec->Add2RawsList(hmod[iLay], 1+iLay+offset, expert, !image, !saveCorr); | |
317 | fSPDhRawsTask++; | |
318 | } | |
319 | // 3 | |
320 | TH2F *hHitMapHalfStaveChipSideA | |
321 | = new TH2F("SPDHitMapHalfStaveChipSideA_SPD","Hit map per HalfStave per Chip Side A - SPD",60,0.,60.,10,0.,10.); | |
322 | hHitMapHalfStaveChipSideA->GetXaxis()->SetTitle("HalfStave"); | |
323 | hHitMapHalfStaveChipSideA->GetYaxis()->SetTitle("Chip"); | |
324 | rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapHalfStaveChipSideA, 3+offset, expert, !image, !saveCorr); | |
325 | fSPDhRawsTask++; | |
326 | // 4 | |
327 | TH2F *hHitMapHalfStaveChipSideC | |
328 | = new TH2F("SPDHitMapHalfStaveChipSideC_SPD","Hit map per HalfStave per Chip Side C - SPD",60,0.,60.,10,0.,10.); | |
329 | hHitMapHalfStaveChipSideC->GetXaxis()->SetTitle("HalfStave"); | |
330 | hHitMapHalfStaveChipSideC->GetYaxis()->SetTitle("Chip"); | |
331 | rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapHalfStaveChipSideC, 4+offset, expert, !image, !saveCorr); | |
332 | fSPDhRawsTask++; | |
333 | //5-24 | |
334 | for (Int_t iDDL=0; iDDL<20; iDDL++) { | |
335 | snprintf(name,49,"SPDHitMap_SPD_DDL%d",iDDL+1); | |
336 | snprintf(title,49,"Hit map - SPD DDL %d",iDDL+1); | |
337 | hhitMap[iDDL]=new TH2F(name,title,320,0,10*32,1536,0,6*256); | |
338 | hhitMap[iDDL]->GetXaxis()->SetTitle("Column"); | |
339 | hhitMap[iDDL]->GetYaxis()->SetTitle("Row"); | |
340 | rv = fAliITSQADataMakerRec->Add2RawsList(hhitMap[iDDL], 5+iDDL+offset, expert, !image, !saveCorr); | |
341 | fSPDhRawsTask++; | |
342 | } | |
343 | // 25-26 | |
344 | TH1F * hMultSPDhits[2]; | |
345 | for (Int_t iLay=0; iLay<2; iLay++) { | |
346 | snprintf(name,49,"SPDHitsMultiplicity_SPD%d",iLay+1); | |
347 | snprintf(title,49,"Hit multiplicity - SPD Layer %d",iLay+1); | |
348 | hMultSPDhits[iLay]=new TH1F(name,title,200,0.,200.); | |
349 | hMultSPDhits[iLay]->GetXaxis()->SetTitle("Hit multiplicity"); | |
350 | hMultSPDhits[iLay]->GetYaxis()->SetTitle("Entries"); | |
351 | rv = fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits[iLay], 25+iLay+offset, expert, !image, !saveCorr); | |
352 | fSPDhRawsTask++; | |
353 | } | |
354 | // 27 | |
355 | TH2F *hMultSPDhits2MultSPDhits1 | |
356 | = new TH2F("SPDHitMultCorrelation_SPD","Hit multiplicity correlation - SPD",200,0.,200.,200,0.,200.); | |
357 | hMultSPDhits2MultSPDhits1->GetXaxis()->SetTitle("Hit multiplicity (Layer 1)"); | |
358 | hMultSPDhits2MultSPDhits1->GetYaxis()->SetTitle("Hit multiplicity (Layer 2)"); | |
359 | rv = fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits2MultSPDhits1, 27+offset, expert, !image, !saveCorr); | |
360 | fSPDhRawsTask++; | |
361 | // 28 | |
362 | TH2F *hFastOrMapStaveChip | |
363 | = new TH2F("SPDFastOrMapStaveChip_SPD","FastOr map per Stave per Chip - SPD",60,0.,60,20,0,20); | |
364 | // hFastOrMapStaveChip->GetXaxis()->SetTitle("Stave"); | |
365 | hFastOrMapStaveChip->GetYaxis()->SetTitle("SIDE C -> SIDE A Chip"); | |
366 | for(Int_t ibinx =0; ibinx< hFastOrMapStaveChip->GetNbinsX(); ibinx++){ | |
367 | if(ibinx%6==0) hFastOrMapStaveChip->GetXaxis()->SetBinLabel(ibinx+1,Form("Sector %i__%i",ibinx/6,ibinx%6)); | |
368 | else hFastOrMapStaveChip->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx%6)); | |
369 | } | |
370 | for(Int_t ibiny =0; ibiny< hFastOrMapStaveChip->GetNbinsY(); ibiny++){ | |
371 | if(ibiny < 10) hFastOrMapStaveChip->GetYaxis()->SetBinLabel(ibiny+1,Form("%i",ibiny)); | |
372 | else hFastOrMapStaveChip->GetYaxis()->SetBinLabel(ibiny+1,Form("%i",19-ibiny)); | |
373 | } | |
374 | hFastOrMapStaveChip->SetOption("COLZ"); | |
375 | hFastOrMapStaveChip->UseCurrentStyle(); | |
376 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrMapStaveChip, 28+offset, !expert, image, !saveCorr); | |
377 | fSPDhRawsTask++; | |
378 | // 29 | |
379 | TH1F *hFastOrFiredMap = new TH1F("SPDFastOrPattern_SPD","FastOrFiredChip map - SPD",1200,0.,1200.); | |
380 | hFastOrFiredMap->GetXaxis()->SetTitle("Chip number"); | |
381 | hFastOrFiredMap->GetYaxis()->SetTitle("Entries"); | |
382 | rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrFiredMap, 29+offset, expert, !image, !saveCorr); | |
383 | fSPDhRawsTask++; | |
384 | // 30 | |
385 | TH2F *hHitMapHalfStaveChipInner | |
386 | = new TH2F("SPDHitMapStaveChipInner_SPD","Hit map per Stave per Chip Inner Layer- SPD",20,0.,20.,20,0.,20.); | |
387 | hHitMapHalfStaveChipInner->GetXaxis()->SetTitle("SIDE C SIDE A Chip"); | |
388 | //hHitMapHalfStaveChipInner->GetYaxis()->SetTitle("Stave in Sector S"); | |
389 | for(Int_t ibinx =0; ibinx< hHitMapHalfStaveChipInner->GetNbinsX(); ibinx++){ | |
390 | if(ibinx < 10) hHitMapHalfStaveChipInner->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx)); | |
391 | else hHitMapHalfStaveChipInner->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",20-(ibinx+1))); | |
392 | } | |
393 | for(Int_t ibiny =0; ibiny< hHitMapHalfStaveChipInner->GetNbinsY(); ibiny++){ | |
394 | if(ibiny%2==1) hHitMapHalfStaveChipInner->GetYaxis()->SetBinLabel(ibiny+1,Form(" S %i - %i",ibiny/2,ibiny%2)); | |
395 | else hHitMapHalfStaveChipInner->GetYaxis()->SetBinLabel(ibiny+1,Form("%i",ibiny%2)); | |
396 | hHitMapHalfStaveChipInner->GetYaxis()->SetTitleOffset(1.4); | |
397 | } | |
398 | hHitMapHalfStaveChipInner->SetOption("COLZ"); | |
399 | hHitMapHalfStaveChipInner->UseCurrentStyle(); | |
400 | rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapHalfStaveChipInner, 30+offset, !expert, image, !saveCorr); | |
401 | fSPDhRawsTask++; | |
402 | // 31 | |
403 | TH2F *hHitMapHalfStaveChipOuter | |
404 | = new TH2F("SPDHitMapStaveChipOuter_SPD","Hit map per Stave per Chip Outer Layer - SPD",20,0.,20.,40,0.,40.); | |
405 | hHitMapHalfStaveChipOuter->GetXaxis()->SetTitle("SIDE C SIDE A Chip"); | |
406 | //hHitMapHalfStaveChipOuter->GetYaxis()->SetTitle("Stave in Sector S"); | |
407 | for(Int_t ibinx =0; ibinx< hHitMapHalfStaveChipOuter->GetNbinsX(); ibinx++){ | |
408 | if(ibinx < 10) hHitMapHalfStaveChipOuter->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx)); | |
409 | else hHitMapHalfStaveChipOuter->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",20-(ibinx+1))); | |
410 | } | |
411 | for(Int_t ibiny =0; ibiny< hHitMapHalfStaveChipOuter->GetNbinsY(); ibiny++){ | |
412 | if(ibiny%4==3) hHitMapHalfStaveChipOuter->GetYaxis()->SetBinLabel(ibiny+1,Form(" S %i - %i",ibiny/4,ibiny%4+2)); | |
413 | else hHitMapHalfStaveChipOuter->GetYaxis()->SetBinLabel(ibiny+1,Form("%i",ibiny%4+2)); | |
414 | hHitMapHalfStaveChipOuter->GetYaxis()->SetTitleOffset(1.4); | |
415 | } | |
416 | hHitMapHalfStaveChipOuter->SetOption("COLZ"); | |
417 | hHitMapHalfStaveChipOuter->UseCurrentStyle(); | |
418 | rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapHalfStaveChipOuter, 31+offset, !expert, image, !saveCorr); | |
419 | fSPDhRawsTask++; | |
420 | // 32 | |
421 | TH1F *hHitMapChipInnerZ = new TH1F("SPDHitMapChipInnerZ_SPD","Hit map per ChipZ Inner - SPD",20,0.,20.); | |
422 | hHitMapChipInnerZ->GetXaxis()->SetTitle("Chip"); | |
423 | hHitMapChipInnerZ->GetYaxis()->SetTitle("Entries"); | |
424 | rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapChipInnerZ, 32+offset, expert, !image, !saveCorr); | |
425 | fSPDhRawsTask++; | |
426 | // 33 | |
427 | TH1F *hHitMapChipOuterZ = new TH1F("SPDHitMapChipOuterZ_SPD","Hit map per ChipZ Outer - SPD",20,0.,20.); | |
428 | hHitMapChipOuterZ->GetXaxis()->SetTitle("Chip"); | |
429 | hHitMapChipOuterZ->GetYaxis()->SetTitle("Entries"); | |
430 | rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapChipOuterZ, 33+offset, expert, !image, !saveCorr); | |
431 | fSPDhRawsTask++; | |
432 | // 34 | |
433 | TH1F *hHitMapStaveInnerPhi = new TH1F("SPDHitMapChipInnerPhi_SPD","Hit map per Stave in Phi Inner - SPD",20,0.,20.); | |
434 | //hHitMapStaveInnerPhi->GetXaxis()->SetTitle("Stave"); | |
435 | hHitMapStaveInnerPhi->GetYaxis()->SetTitle("Entries"); | |
436 | for(Int_t ibinx =0; ibinx< hHitMapStaveInnerPhi->GetNbinsX(); ibinx++){ | |
437 | if(ibinx%2==0) hHitMapStaveInnerPhi->GetXaxis()->SetBinLabel(ibinx+1,Form("%i___Sector %i",ibinx%2,ibinx/2)); | |
438 | else hHitMapStaveInnerPhi->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx%2)); | |
439 | } | |
440 | rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapStaveInnerPhi, 34+offset, expert, !image, !saveCorr); | |
441 | fSPDhRawsTask++; | |
442 | // 35 | |
443 | TH1F *hHitMapStaveOuterPhi = new TH1F("SPDHitMapChipOuterPhi_SPD","Hit map per Stave in Phi Outer - SPD",40,0.,40.); | |
444 | //hHitMapStaveOuterPhi->GetXaxis()->SetTitle("Stave"); | |
445 | hHitMapStaveOuterPhi->GetYaxis()->SetTitle("Entries"); | |
446 | for(Int_t ibinx =0; ibinx< hHitMapStaveOuterPhi->GetNbinsX(); ibinx++){ | |
447 | if(ibinx%4==0) hHitMapStaveOuterPhi->GetXaxis()->SetBinLabel(ibinx+1,Form("%i___Sector %i ",ibinx%4+2,ibinx/4)); | |
448 | else hHitMapStaveOuterPhi->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx%4+2)); | |
449 | } | |
450 | rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapStaveOuterPhi, 35+offset, expert, !image, !saveCorr); | |
451 | fSPDhRawsTask++; | |
452 | ||
453 | //AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Raws histograms booked\n",fSPDhRawsTask)); | |
454 | //printf("------------------ %d SPD Raws histograms booked \n",fSPDhRawsTask); | |
455 | return rv ; | |
456 | } | |
457 | ||
458 | //____________________________________________________________________________ | |
459 | Int_t AliITSQASPDDataMakerRec::MakeRaws(AliRawReader* rawReader) | |
460 | { | |
461 | // Fill QA for RAW - SPD - | |
462 | Int_t rv = 0 ; | |
463 | if(!rawReader) { | |
464 | AliError("rawReader is NULL"); | |
465 | return -1; | |
466 | } | |
467 | rawReader->Reset(); | |
468 | AliITSRawStreamSPD rawStreamSPD(rawReader); | |
469 | rawStreamSPD.ActivateAdvancedErrorLog(kTRUE,fAdvLogger); | |
470 | // shift for online histos | |
471 | Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]; | |
472 | ||
473 | // shift for offline histos | |
474 | Int_t offset = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + kAmoreFoOffset+kAmoreErrorsOffset; | |
475 | ||
476 | Int_t nDigitsL1 = 0; | |
477 | Int_t nDigitsL2 = 0; | |
478 | Int_t iEq; | |
479 | Int_t iLayer; | |
480 | Int_t iHalfStave, iChip; | |
481 | Int_t chipKey; | |
482 | Int_t col, row; | |
483 | UInt_t module, colM, rowM; | |
484 | Bool_t isFiredChip[1200]; | |
485 | for(Int_t ichK=0; ichK<1200; ichK++) isFiredChip[ichK] = kFALSE; | |
486 | Bool_t isOnlineFiredChip[1200]; | |
487 | for(Int_t iOnlineKey=0; iOnlineKey<1200; iOnlineKey++) isOnlineFiredChip[iOnlineKey] = kFALSE; | |
488 | UInt_t nFastOr[2]={0,0}; | |
489 | ||
490 | while(rawStreamSPD.Next()) { | |
491 | ||
492 | iEq = rawReader->GetDDLID(); | |
493 | if (iEq>=0 && iEq<20) { | |
494 | iHalfStave = rawStreamSPD.GetHalfStaveNr(); | |
495 | iChip = rawStreamSPD.GetChipAddr(); | |
496 | col = rawStreamSPD.GetChipCol(); | |
497 | row = rawStreamSPD.GetChipRow(); | |
498 | isOnlineFiredChip[iEq*60+iHalfStave*10+iChip] = kTRUE; | |
499 | chipKey = rawStreamSPD.GetOfflineChipKeyFromOnline(iEq,iHalfStave,iChip); | |
500 | isFiredChip[chipKey] = kTRUE; | |
501 | ||
502 | rawStreamSPD.OnlineToOffline(iEq, iHalfStave, iChip, col, row, module, colM, rowM); | |
503 | ||
504 | if (iHalfStave>=0 && iHalfStave<2) iLayer=0; | |
505 | else iLayer=1; | |
506 | ||
507 | fAliITSQADataMakerRec->FillRawsData(0+offset,iLayer); | |
508 | if (iLayer==0) { | |
509 | fAliITSQADataMakerRec->FillRawsData(1+offset,module); | |
510 | nDigitsL1++; | |
511 | } else { | |
512 | fAliITSQADataMakerRec->FillRawsData(2+offset,module); | |
513 | nDigitsL2++; | |
514 | } | |
515 | ||
516 | if(iEq<10) { | |
517 | fAliITSQADataMakerRec->FillRawsData(3+offset,iHalfStave+iEq*6,iChip); | |
518 | } | |
519 | else { | |
520 | fAliITSQADataMakerRec->FillRawsData(4+offset,iHalfStave+(iEq-10)*6,iChip); | |
521 | } | |
522 | ||
523 | if(iLayer==0) { | |
524 | if(iEq<10) { | |
525 | fAliITSQADataMakerRec->FillRawsData(30+offset,19-iChip,iHalfStave+iEq*2); | |
526 | fAliITSQADataMakerRec->FillRawsData(32+offset,19-iChip); | |
527 | fAliITSQADataMakerRec->FillRawsData(34+offset,iHalfStave+iEq*2); | |
528 | } | |
529 | else { | |
530 | fAliITSQADataMakerRec->FillRawsData(30+offset,iChip,iHalfStave+(iEq-10)*2); | |
531 | fAliITSQADataMakerRec->FillRawsData(32+offset,iChip); | |
532 | fAliITSQADataMakerRec->FillRawsData(34+offset,iHalfStave+(iEq-10)*2); | |
533 | } | |
534 | } | |
535 | else { | |
536 | if(iEq<10) { | |
537 | fAliITSQADataMakerRec->FillRawsData(31+offset,19-iChip,iHalfStave-2+iEq*4); | |
538 | fAliITSQADataMakerRec->FillRawsData(33+offset,19-iChip); | |
539 | fAliITSQADataMakerRec->FillRawsData(35+offset,iHalfStave-2+iEq*4); | |
540 | } | |
541 | else { | |
542 | fAliITSQADataMakerRec->FillRawsData(31+offset,iChip,iHalfStave-2+(iEq-10)*4); | |
543 | fAliITSQADataMakerRec->FillRawsData(33+offset,iChip); | |
544 | fAliITSQADataMakerRec->FillRawsData(35+offset,iHalfStave-2+(iEq-10)*4); | |
545 | } | |
546 | } | |
547 | fAliITSQADataMakerRec->FillRawsData(5+iEq+offset,colM+(module%2)*160,rowM+iHalfStave*256); | |
548 | } | |
549 | } | |
550 | ||
551 | UInt_t nErrorsDDL[20]; | |
552 | for (Int_t ieq=0; ieq<20; ieq++) { | |
553 | nErrorsDDL[ieq] = 0; | |
554 | if (!fAdvLogger) continue; | |
555 | for (UInt_t ierr=0; ierr<fAdvLogger->GetNrErrorCodes(); ierr++) { | |
556 | fAliITSQADataMakerRec->FillRawsData(ieq+(kAmoreFoOffset+1)+shift,ierr,fAdvLogger->GetNrErrors(ierr,ieq)); | |
557 | if(ierr>0) { | |
558 | nErrorsDDL[ieq] = nErrorsDDL[ieq] + fAdvLogger->GetNrErrors(ierr,ieq); | |
559 | } | |
560 | fAliITSQADataMakerRec->FillRawsData(kAmoreFoOffset+shift,ieq,ierr,fAdvLogger->GetNrErrors(ierr,ieq)); | |
561 | } | |
562 | for (Int_t ihs=0; ihs<6; ihs++) { | |
563 | for (Int_t ichip=0; ichip<10; ichip++) { | |
564 | if(isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->FillRawsData(0+shift,ieq*60+ihs*10+ichip); // online | |
565 | if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip)) fAliITSQADataMakerRec->FillRawsData(4+shift,ieq*60+ihs*10+ichip); // online | |
566 | // now filling the 3 possibile combinations | |
567 | if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->FillRawsData(1+shift,ieq*60+ihs*10+ichip); // online | |
568 | if(!rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->FillRawsData(2+shift,ieq*60+ihs*10+ichip); // online | |
569 | if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && !isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->FillRawsData(3+shift,ieq*60+ihs*10+ichip); // online | |
570 | ||
571 | chipKey = rawStreamSPD.GetOfflineChipKeyFromOnline(ieq,ihs,ichip); | |
572 | Int_t sect = 999; | |
573 | Int_t chipbin = 999; | |
574 | ||
575 | if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip)) { | |
576 | if(ihs <2) nFastOr[0]++; // online | |
577 | else nFastOr[1]++; // online | |
578 | if(ieq<10) {sect = ieq; chipbin = 19-ichip;} | |
579 | else {sect = ieq-10; chipbin = ichip;} | |
580 | ||
581 | fAliITSQADataMakerRec->FillRawsData(28+offset,sect*6+ihs,chipbin); | |
582 | fAliITSQADataMakerRec->FillRawsData(29+offset,chipKey); | |
583 | } | |
584 | } | |
585 | } | |
586 | ||
587 | ||
588 | } | |
589 | fAliITSQADataMakerRec->FillRawsData(6+shift,nFastOr[0],nFastOr[1]); // online | |
590 | ||
591 | fAdvLogger->Reset(); | |
592 | fAliITSQADataMakerRec->FillRawsData(25+offset,nDigitsL1); | |
593 | fAliITSQADataMakerRec->FillRawsData(26+offset,nDigitsL2); | |
594 | fAliITSQADataMakerRec->FillRawsData(27+offset,nDigitsL1,nDigitsL2); | |
595 | // | |
596 | AliDebug(AliQAv1::GetQADebugLevel(),Form("Event completed, %d raw digits read",nDigitsL1+nDigitsL2)); | |
597 | return rv ; | |
598 | } | |
599 | ||
600 | //____________________________________________________________________________ | |
601 | Int_t AliITSQASPDDataMakerRec::InitDigits() | |
602 | { | |
603 | // Initialization for DIGIT data - SPD - | |
604 | const Bool_t expert = kTRUE ; | |
605 | const Bool_t image = kTRUE ; | |
606 | Int_t rv = 0 ; | |
607 | // fGenDigitsOffset = (fAliITSQADataMakerRec->fDigitsQAList[AliRecoParam::kDefault])->GetEntries(); | |
608 | //fSPDhDigitsTask must be incremented by one unit every time a histogram is ADDED to the QA List | |
609 | ||
610 | Char_t name[50]; | |
611 | Char_t title[50]; | |
612 | ||
613 | TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.); | |
614 | hlayer->GetXaxis()->SetTitle("Layer number"); | |
615 | hlayer->GetYaxis()->SetTitle("Entries"); | |
616 | rv = fAliITSQADataMakerRec->Add2DigitsList(hlayer,fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
617 | fSPDhDigitsTask++; | |
618 | ||
619 | TH1F * hmod[2]; | |
620 | for (Int_t iLay=0; iLay<2; iLay++) { | |
621 | snprintf(name,49,"SPDModPattern_SPD%d",iLay+1); | |
622 | snprintf(title,49,"Module map - SPD Layer %d",iLay+1); | |
623 | hmod[iLay]=new TH1F(name,title,240,0,240); | |
624 | hmod[iLay]->GetXaxis()->SetTitle("Module number"); | |
625 | hmod[iLay]->GetYaxis()->SetTitle("Entries"); | |
626 | rv = fAliITSQADataMakerRec->Add2DigitsList(hmod[iLay],1+iLay+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image); | |
627 | fSPDhDigitsTask++; | |
628 | } | |
629 | ||
630 | TH1F *hcolumns = new TH1F("SPDColumns_SPD","Columns - SPD",160,0.,160.); | |
631 | hcolumns->GetXaxis()->SetTitle("Column number"); | |
632 | hcolumns->GetYaxis()->SetTitle("Entries"); | |
633 | rv = fAliITSQADataMakerRec->Add2DigitsList(hcolumns,3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
634 | fSPDhDigitsTask++; | |
635 | ||
636 | TH1F *hrows = new TH1F("SPDRows_SPD","Rows - SPD",256,0.,256.); | |
637 | hrows->GetXaxis()->SetTitle("Row number"); | |
638 | hrows->GetYaxis()->SetTitle("Entries"); | |
639 | rv = fAliITSQADataMakerRec->Add2DigitsList(hrows,4+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
640 | fSPDhDigitsTask++; | |
641 | ||
642 | TH1F * hMultSPDdigits[2]; | |
643 | for (Int_t iLay=0; iLay<2; ++iLay) { | |
644 | snprintf(name,49,"SPDDigitMultiplicity_SPD%d",iLay+1); | |
645 | snprintf(title,49,"Digit multiplicity - SPD Layer %d",iLay+1); | |
646 | hMultSPDdigits[iLay]=new TH1F(name,title,200,0.,200.); | |
647 | hMultSPDdigits[iLay]->GetXaxis()->SetTitle("Digit multiplicity"); | |
648 | hMultSPDdigits[iLay]->GetYaxis()->SetTitle("Entries"); | |
649 | rv = fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image); | |
650 | fSPDhDigitsTask++; | |
651 | } | |
652 | ||
653 | TH2F *hMultSPDdig2MultSPDdig1 | |
654 | = new TH2F("SPDDigitMultCorrelation_SPD","Digit multiplicity correlation - SPD",200,0.,200.,200,0.,200.); | |
655 | hMultSPDdig2MultSPDdig1->GetXaxis()->SetTitle("Digit multiplicity (Layer 1)"); | |
656 | hMultSPDdig2MultSPDdig1->GetYaxis()->SetTitle("Digit multiplicity (Layer 2)"); | |
657 | rv = fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image); | |
658 | fSPDhDigitsTask++; | |
659 | ||
660 | AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Digits histograms booked\n",fSPDhDigitsTask)); | |
661 | return rv ; | |
662 | } | |
663 | ||
664 | //____________________________________________________________________________ | |
665 | Int_t AliITSQASPDDataMakerRec::MakeDigits(TTree *digits) | |
666 | { | |
667 | // Fill QA for DIGIT - SPD - | |
668 | ||
669 | Int_t rv = 0 ; | |
670 | // AliITS *fITS = (AliITS*)gAlice->GetModule("ITS"); | |
671 | // fITS->SetTreeAddress(); | |
672 | // TClonesArray *iITSdigits = fITS->DigitsAddress(0); // 0->SPD | |
673 | TBranch *branchD = digits->GetBranch("ITSDigitsSPD"); | |
674 | if (!branchD) { | |
675 | AliError("can't get the branch with the SPD ITS digits !"); | |
676 | return rv; | |
677 | } | |
678 | static TClonesArray statDigits("AliITSdigitSPD"); | |
679 | TClonesArray *iITSdigits = &statDigits; | |
680 | branchD->SetAddress(&iITSdigits); | |
681 | Int_t nDigitsL1=0; | |
682 | Int_t nDigitsL2=0; | |
683 | ||
684 | for (Int_t imod=0; imod<240; ++imod){ | |
685 | digits->GetEvent(imod); | |
686 | Int_t ndigits = iITSdigits->GetEntries(); | |
687 | if (imod<80) { | |
688 | fAliITSQADataMakerRec->FillDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],0.5,ndigits); | |
689 | fAliITSQADataMakerRec->FillDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],imod,ndigits); | |
690 | nDigitsL1+=ndigits; | |
691 | } | |
692 | else { | |
693 | fAliITSQADataMakerRec->FillDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],1,ndigits); | |
694 | fAliITSQADataMakerRec->FillDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],imod,ndigits); | |
695 | nDigitsL2+=ndigits; | |
696 | } | |
697 | for (Int_t idig=0; idig<ndigits; ++idig) { | |
698 | AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig); | |
699 | Int_t col=dig->GetCoord1(); // cell number z | |
700 | Int_t row=dig->GetCoord2(); // cell number x | |
701 | fAliITSQADataMakerRec->FillDigitsData(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],col); | |
702 | fAliITSQADataMakerRec->FillDigitsData(4+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],row); | |
703 | } | |
704 | } | |
705 | fAliITSQADataMakerRec->FillDigitsData(5+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nDigitsL1); | |
706 | fAliITSQADataMakerRec->FillDigitsData(6+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nDigitsL2); | |
707 | fAliITSQADataMakerRec->FillDigitsData(7+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nDigitsL1,nDigitsL2); | |
708 | // | |
709 | return rv ; | |
710 | } | |
711 | ||
712 | //____________________________________________________________________________ | |
713 | Int_t AliITSQASPDDataMakerRec::InitRecPoints() | |
714 | { | |
715 | // Initialization for RECPOINTS - SPD - | |
716 | const Bool_t expert = kTRUE ; | |
717 | const Bool_t image = kTRUE ; | |
718 | Int_t rv = 0 ; | |
719 | //AliInfo(Form("fAliITSQADataMakerRec->GetEventSpecie() %d\n",fAliITSQADataMakerRec->GetEventSpecie())); | |
720 | //AliInfo(Form("fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] %d\n",fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])); | |
721 | // fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries(); | |
722 | TH1F* hlayer= new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.); | |
723 | hlayer->GetXaxis()->SetTitle("Layer number"); | |
724 | hlayer->GetYaxis()->SetTitle("Entries"); | |
725 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hlayer, 0+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
726 | fSPDhRecPointsTask++; | |
727 | ||
728 | TH1F * hmod[2]; | |
729 | TH1F * hxl[2]; | |
730 | TH1F * hzl[2]; | |
731 | TH1F * hxg[2]; | |
732 | TH1F * hyg[2]; | |
733 | TH1F * hzg[2]; | |
734 | TH1F * hr[2]; | |
735 | TH1F * hphi[2]; | |
736 | TH1F * hMultSPDcl[2]; | |
737 | TH2F * hNyNz[2]; // y and z cluster length | |
738 | TH1F * hNpixels[2]; // cluster size in number of pixels | |
739 | TH1F * hType[2]; // cluster type according to conventional table | |
740 | TH2F * hPhiZ[2]; | |
741 | ||
742 | Float_t xlim[2]={4.5,8.}; | |
743 | Float_t zlim[2]={15.,15.}; | |
744 | ||
745 | Char_t name[50]; | |
746 | Char_t title[50]; | |
747 | for (Int_t iLay=0;iLay<2;iLay++) { | |
748 | snprintf(name,49,"SPDModPattern_SPD%d",iLay+1); | |
749 | snprintf(title,49,"Module map - SPD Layer %d",iLay+1); | |
750 | hmod[iLay]=new TH1F(name,title,fgknSPDmodules,0,fgknSPDmodules); | |
751 | hmod[iLay]->GetXaxis()->SetTitle("Module number"); | |
752 | hmod[iLay]->GetYaxis()->SetTitle("Entries"); | |
753 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hmod[iLay], 1+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
754 | fSPDhRecPointsTask++; | |
755 | ||
756 | snprintf(name,49,"SPDxLoc_SPD%d",iLay+1); | |
757 | snprintf(title,49,"Local x coordinate - SPD Layer %d",iLay+1); | |
758 | hxl[iLay]=new TH1F(name,title,100,-4.,4.); | |
759 | hxl[iLay]->GetXaxis()->SetTitle("Local x [cm]"); | |
760 | hxl[iLay]->GetYaxis()->SetTitle("Entries"); | |
761 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hxl[iLay], 2+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
762 | fSPDhRecPointsTask++; | |
763 | ||
764 | snprintf(name,49,"SPDzLoc_SPD%d",iLay+1); | |
765 | snprintf(title,49,"Local z coordinate - SPD Layer %d",iLay+1); | |
766 | hzl[iLay]=new TH1F(name,title,100,-4.,4.); | |
767 | hzl[iLay]->GetXaxis()->SetTitle("Local z [cm]"); | |
768 | hzl[iLay]->GetYaxis()->SetTitle("Entries"); | |
769 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hzl[iLay], 3+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
770 | fSPDhRecPointsTask++; | |
771 | ||
772 | snprintf(name,49,"SPDxGlob_SPD%d",iLay+1); | |
773 | snprintf(title,49,"Global x coordinate - SPD Layer %d",iLay+1); | |
774 | hxg[iLay]=new TH1F(name,title,100,-xlim[iLay],xlim[iLay]); | |
775 | hxg[iLay]->GetXaxis()->SetTitle("Global x [cm]"); | |
776 | hxg[iLay]->GetYaxis()->SetTitle("Entries"); | |
777 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hxg[iLay],4+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
778 | fSPDhRecPointsTask++; | |
779 | ||
780 | snprintf(name,49,"SPDyGlob_SPD%d",iLay+1); | |
781 | snprintf(title,49,"Global y coordinate - SPD Layer %d",iLay+1); | |
782 | hyg[iLay]=new TH1F(name,title,100,-xlim[iLay],xlim[iLay]); | |
783 | hyg[iLay]->GetXaxis()->SetTitle("Global y [cm]"); | |
784 | hyg[iLay]->GetYaxis()->SetTitle("Entries"); | |
785 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hyg[iLay], 5+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
786 | fSPDhRecPointsTask++; | |
787 | ||
788 | snprintf(name,49,"SPDzGlob_SPD%d",iLay+1); | |
789 | snprintf(title,49,"Global z coordinate - SPD Layer %d",iLay+1); | |
790 | hzg[iLay]=new TH1F(name,title,150,-zlim[iLay],zlim[iLay]); | |
791 | hzg[iLay]->GetXaxis()->SetTitle("Global z [cm]"); | |
792 | hzg[iLay]->GetYaxis()->SetTitle("Entries"); | |
793 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hzg[iLay], 6+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
794 | fSPDhRecPointsTask++; | |
795 | ||
796 | snprintf(name,49,"SPDr_SPD%d",iLay+1); | |
797 | snprintf(title,49,"Radius - SPD Layer %d",iLay+1); | |
798 | hr[iLay]=new TH1F(name,title,100,0.,10.); | |
799 | hr[iLay]->GetXaxis()->SetTitle("r [cm]"); | |
800 | hr[iLay]->GetYaxis()->SetTitle("Entries"); | |
801 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hr[iLay], 7+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
802 | fSPDhRecPointsTask++; | |
803 | ||
804 | snprintf(name,49,"SPDphi_SPD%d",iLay+1); | |
805 | snprintf(title,49,"#varphi - SPD Layer %d",iLay+1); | |
806 | hphi[iLay]=new TH1F(name,title,1000,0.,2*TMath::Pi()); | |
807 | hphi[iLay]->GetXaxis()->SetTitle("#varphi [rad]"); | |
808 | hphi[iLay]->GetYaxis()->SetTitle("Entries"); | |
809 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hphi[iLay], 8+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
810 | fSPDhRecPointsTask++; | |
811 | ||
812 | snprintf(name,49,"SPDSizeYvsZ_SPD%d",iLay+1); | |
813 | snprintf(title,49,"Cluster dimension - SPD Layer %d",iLay+1); | |
814 | hNyNz[iLay]=new TH2F(name,title,100,0.,100.,100,0.,100.); | |
815 | hNyNz[iLay]->GetXaxis()->SetTitle("z length"); | |
816 | hNyNz[iLay]->GetYaxis()->SetTitle("y length"); | |
817 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hNyNz[iLay], 9+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
818 | fSPDhRecPointsTask++; | |
819 | ||
820 | snprintf(name,49,"SPDSizeTot_SPD%d",iLay+1); | |
821 | snprintf(title,49,"Cluster size - SPD Layer %d",iLay+1); | |
822 | hNpixels[iLay]=new TH1F(name,title,100,0.,100.); | |
823 | hNpixels[iLay]->GetXaxis()->SetTitle("Cluster size"); | |
824 | hNpixels[iLay]->GetYaxis()->SetTitle("Entries"); | |
825 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hNpixels[iLay], 10+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
826 | fSPDhRecPointsTask++; | |
827 | ||
828 | snprintf(name,49,"SPDType_SPD%d",iLay+1); | |
829 | snprintf(title,49,"Cluster type - SPD Layer %d",iLay+1); | |
830 | hType[iLay]=new TH1F(name,title,20,0.,20.); | |
831 | hType[iLay]->GetXaxis()->SetTitle("Cluster type"); | |
832 | hType[iLay]->GetYaxis()->SetTitle("Entries"); | |
833 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hType[iLay], 11+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image); | |
834 | fSPDhRecPointsTask++; | |
835 | ||
836 | snprintf(name,49,"SPDphi_z_SPD%d",iLay+1); | |
837 | snprintf(title,49,"#varphi vs z - SPD Layer %d",iLay+1); | |
838 | hPhiZ[iLay]=new TH2F(name,title,150,-zlim[iLay],zlim[iLay],200,0.,2*TMath::Pi()); | |
839 | hPhiZ[iLay]->GetXaxis()->SetTitle("Global z [cm]"); | |
840 | hPhiZ[iLay]->GetYaxis()->SetTitle("#varphi [rad]"); | |
841 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hPhiZ[iLay], 12+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image); | |
842 | fSPDhRecPointsTask++; | |
843 | ||
844 | } | |
845 | ||
846 | TH2F *hrPhi=new TH2F("SPDr_phi_SPD","#varphi vs r - SPD",100,0.,10.,100,0.,2*TMath::Pi()); | |
847 | hrPhi->GetXaxis()->SetTitle("r [cm]"); | |
848 | hrPhi->GetYaxis()->SetTitle("#varphi [rad]"); | |
849 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hrPhi, 25+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); | |
850 | fSPDhRecPointsTask++; | |
851 | ||
852 | TH2F *hxy=new TH2F("SPDx_y_SPD","Global y vs x - SPD",200,-10.,10.,200,-10.,10.); | |
853 | hxy->GetXaxis()->SetTitle("Global x [cm]"); | |
854 | hxy->GetYaxis()->SetTitle("Global y [cm]"); | |
855 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hxy, 26+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image); | |
856 | fSPDhRecPointsTask++; | |
857 | ||
858 | for (Int_t iLay=0;iLay<2;iLay++) { | |
859 | snprintf(name,49,"SPDMultiplicity_SPD%d",iLay+1); | |
860 | snprintf(title,49,"Cluster multiplicity - SPD Layer %d",iLay+1); | |
861 | hMultSPDcl[iLay]=new TH1F(name,title,200,0.,200.); | |
862 | hMultSPDcl[iLay]->GetXaxis()->SetTitle("Cluster multiplicity"); | |
863 | hMultSPDcl[iLay]->GetYaxis()->SetTitle("Entries"); | |
864 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl[iLay], 27+iLay+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image); | |
865 | fSPDhRecPointsTask++; | |
866 | } | |
867 | ||
868 | TH2F *hMultSPDcl2MultSPDcl1 = | |
869 | new TH2F("SPDMultCorrelation_SPD","Cluster multiplicity correlation - SPD",200,0.,200.,200,0.,200.); | |
870 | hMultSPDcl2MultSPDcl1->GetXaxis()->SetTitle("Clusters multiplicity (Layer 1)"); | |
871 | hMultSPDcl2MultSPDcl1->GetYaxis()->SetTitle("Clusters multiplicity (Layer 2)"); | |
872 | rv = fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl2MultSPDcl1, 29+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image); | |
873 | fSPDhRecPointsTask++; | |
874 | ||
875 | AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Recs histograms booked\n",fSPDhRecPointsTask)); | |
876 | ||
877 | return rv ; | |
878 | } | |
879 | ||
880 | //____________________________________________________________________________ | |
881 | Int_t AliITSQASPDDataMakerRec::MakeRecPoints(TTree * clusterTree) | |
882 | { | |
883 | // Fill QA for RecPoints - SPD - | |
884 | ||
885 | Int_t rv = 0 ; | |
886 | AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance(); | |
887 | TClonesArray *recpoints = NULL; | |
888 | rpcont->FetchClusters(0,clusterTree); | |
889 | if(!rpcont->GetStatusOK() || !rpcont->IsSPDActive()){ | |
890 | AliError("can't get SPD clusters !"); | |
891 | return rv; | |
892 | } | |
893 | ||
894 | //AliInfo(Form("fAliITSQADataMakerRec->GetEventSpecie() %d\n",fAliITSQADataMakerRec->GetEventSpecie())); | |
895 | //AliInfo(Form("fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] %d\n",fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])); | |
896 | Int_t nSPDmod = AliITSgeomTGeo::GetModuleIndex(3,1,1); | |
897 | ||
898 | Float_t cluGlo[3] = {0.,0.,0.}; | |
899 | Int_t nClusters[2] = {0,0}; | |
900 | ||
901 | for (Int_t iIts=0; iIts < nSPDmod; iIts++) { | |
902 | recpoints = rpcont->UncheckedGetClusters(iIts); | |
903 | Int_t nCluster = recpoints->GetEntriesFast(); | |
904 | if(nCluster == 0)continue; | |
905 | // loop over clusters | |
906 | while(nCluster--) { | |
907 | AliITSRecPoint* cluster = | |
908 | (AliITSRecPoint*)recpoints->UncheckedAt(nCluster); | |
909 | if (cluster->GetLayer()>1)continue; | |
910 | Int_t lay=cluster->GetLayer(); | |
911 | fAliITSQADataMakerRec->FillRecPointsData(0 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],lay); | |
912 | cluster->GetGlobalXYZ(cluGlo); | |
913 | Float_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]); | |
914 | Float_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]); | |
915 | if (lay==0) { | |
916 | fAliITSQADataMakerRec->FillRecPointsData(1 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],iIts); | |
917 | fAliITSQADataMakerRec->FillRecPointsData(2 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetDetLocalX()); | |
918 | fAliITSQADataMakerRec->FillRecPointsData(3 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetDetLocalZ()); | |
919 | fAliITSQADataMakerRec->FillRecPointsData(4 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[0]); | |
920 | fAliITSQADataMakerRec->FillRecPointsData(5 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[1]); | |
921 | fAliITSQADataMakerRec->FillRecPointsData(6 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[2]); | |
922 | fAliITSQADataMakerRec->FillRecPointsData(7 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],rad); | |
923 | fAliITSQADataMakerRec->FillRecPointsData(8 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],phi); | |
924 | fAliITSQADataMakerRec->FillRecPointsData(9 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetNz(),cluster->GetNy()); | |
925 | fAliITSQADataMakerRec->FillRecPointsData(10 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetNpixels()); | |
926 | fAliITSQADataMakerRec->FillRecPointsData(11 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetSPDclusterType()); | |
927 | fAliITSQADataMakerRec->FillRecPointsData(12 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[2],phi); | |
928 | } else { | |
929 | fAliITSQADataMakerRec->FillRecPointsData(13 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],iIts); | |
930 | fAliITSQADataMakerRec->FillRecPointsData(14 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetDetLocalX()); | |
931 | fAliITSQADataMakerRec->FillRecPointsData(15 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetDetLocalZ()); | |
932 | fAliITSQADataMakerRec->FillRecPointsData(16 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[0]); | |
933 | fAliITSQADataMakerRec->FillRecPointsData(17 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[1]); | |
934 | fAliITSQADataMakerRec->FillRecPointsData(18 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[2]); | |
935 | fAliITSQADataMakerRec->FillRecPointsData(19 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],rad); | |
936 | fAliITSQADataMakerRec->FillRecPointsData(20 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],phi); | |
937 | fAliITSQADataMakerRec->FillRecPointsData(21 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetNz(),cluster->GetNy()); | |
938 | fAliITSQADataMakerRec->FillRecPointsData(22 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetNpixels()); | |
939 | fAliITSQADataMakerRec->FillRecPointsData(23 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetSPDclusterType()); | |
940 | fAliITSQADataMakerRec->FillRecPointsData(24 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[2],phi); | |
941 | } | |
942 | fAliITSQADataMakerRec->FillRecPointsData(25 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],rad,phi); | |
943 | fAliITSQADataMakerRec->FillRecPointsData(26 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[0],cluGlo[1]); | |
944 | ||
945 | nClusters[lay]++; | |
946 | } // end of cluster loop | |
947 | } // end of its "subdetector" loop | |
948 | ||
949 | for (Int_t iLay=0; iLay<2; iLay++) | |
950 | fAliITSQADataMakerRec->FillRecPointsData(27 +iLay +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nClusters[iLay]); | |
951 | ||
952 | fAliITSQADataMakerRec->FillRecPointsData(29 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nClusters[0],nClusters[1]); | |
953 | // | |
954 | return rv ; | |
955 | } | |
956 | ||
957 | ||
958 | ||
959 | //_______________________________________________________________ | |
960 | ||
961 | Int_t AliITSQASPDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task,Int_t specie) const { | |
962 | // Returns offset number according to the specified task | |
963 | Int_t offset=0; | |
964 | if( task == AliQAv1::kRAWS ) { | |
965 | offset=fGenRawsOffset[specie]; | |
966 | } | |
967 | else if( task == AliQAv1::kDIGITSR ) { | |
968 | offset=fGenDigitsOffset[specie]; | |
969 | } | |
970 | else if( task == AliQAv1::kRECPOINTS ) { | |
971 | offset=fGenRecPointsOffset[specie]; | |
972 | } | |
973 | ||
974 | return offset; | |
975 | } | |
976 | ||
977 | //_______________________________________________________________ | |
978 | ||
979 | void AliITSQASPDDataMakerRec::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset, Int_t specie) { | |
980 | // Returns offset number according to the specified task | |
981 | if( task == AliQAv1::kRAWS ) { | |
982 | fGenRawsOffset[specie]=offset; | |
983 | } | |
984 | else if( task == AliQAv1::kDIGITSR ) { | |
985 | fGenDigitsOffset[specie]=offset; | |
986 | } | |
987 | else if( task == AliQAv1::kRECPOINTS ) { | |
988 | fGenRecPointsOffset[specie]=offset; | |
989 | } | |
990 | } | |
991 | ||
992 | //_______________________________________________________________ | |
993 | ||
994 | Int_t AliITSQASPDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task) const { | |
995 | // Returns the number of histograms associated to the specified task | |
996 | ||
997 | Int_t histotot=0; | |
998 | ||
999 | if( task == AliQAv1::kRAWS ) { | |
1000 | histotot=fSPDhRawsTask; | |
1001 | } | |
1002 | else if( task == AliQAv1::kDIGITSR ) { | |
1003 | histotot=fSPDhDigitsTask; | |
1004 | } | |
1005 | else if( task == AliQAv1::kRECPOINTS ){ | |
1006 | histotot=fSPDhRecPointsTask; | |
1007 | } | |
1008 | ||
1009 | return histotot; | |
1010 | } | |
1011 |