]>
Commit | Line | Data |
---|---|---|
0730893d | 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 | ||
24 | // --- ROOT system --- | |
25 | #include <TH2D.h> | |
26 | #include <TTree.h> | |
27 | #include <TMath.h> | |
28 | #include <TString.h> | |
29 | #include <TSystem.h> | |
30 | ||
31 | // --- Standard library --- | |
32 | ||
33 | // --- AliRoot header files --- | |
34 | #include "AliITSQASSDDataMakerRec.h" | |
35 | #include "AliQADataMakerRec.h" | |
36 | #include "AliLog.h" | |
37 | #include "AliQA.h" | |
38 | #include "AliQAChecker.h" | |
39 | #include "AliRawReader.h" | |
40 | #include "AliRawReaderRoot.h" | |
41 | #include "AliITSRawStreamSSD.h" | |
42 | #include "AliITSgeomTGeo.h" | |
43 | #include "AliRawEventHeaderBase.h" | |
44 | #include "AliITSRecPoint.h" | |
45 | #include "AliITSBadChannelsSSDv2.h" | |
46 | ||
47 | #include "AliCDBManager.h" | |
48 | #include "AliCDBEntry.h" | |
49 | ||
50 | ClassImp(AliITSQASSDDataMakerRec) | |
51 | ||
52 | AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Int_t ldc) : | |
53 | TObject(), | |
54 | fAliITSQADataMakerRec(aliITSQADataMakerRec), | |
55 | fSSDEvent(0), | |
56 | fSSDEventPerCycle(0), | |
57 | fkOnline(kMode), | |
58 | fLDC(ldc), | |
59 | fSSDRawsOffset(0), fSSDRawsDAOffset(0), | |
60 | fSSDRawsCommonLevelOffset(0), | |
61 | fSSDhTask(0), | |
62 | fGenOffset(0), | |
63 | fCDBManager(0) { | |
64 | // Default constructor | |
65 | //initilize the raw signal vs strip number histograms | |
66 | if(fkOnline) { | |
67 | fCDBManager = AliCDBManager::Instance(); | |
68 | //fCDBManager->SetDefaultStorage("local://$ALICE_ROOT"); | |
69 | fCDBManager->SetDefaultStorage(gSystem->Getenv("AMORE_CDB_URI")); | |
70 | Int_t runNumber = atoi(gSystem->Getenv("DATE_RUN_NUMBER")); | |
71 | if(!runNumber) | |
72 | AliInfo("DATE_RUN_NUMBER not defined!!!\n"); | |
73 | ||
74 | fCDBManager->SetRun(runNumber); | |
75 | AliCDBEntry *geomGRP = fCDBManager->Get("GRP/Geometry/Data"); | |
76 | if(!geomGRP) AliInfo("GRP geometry not found!!!\n"); | |
77 | ||
78 | Int_t gLayer = 0,gLadder = 0, gModule = 0; | |
79 | Int_t gHistCounter = 0; | |
80 | TString gTitle; | |
81 | ||
82 | for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) { | |
83 | AliITSgeomTGeo::GetModuleId(iModule,gLayer,gLadder,gModule); | |
84 | gTitle = "SSD_RawSignal_Layer"; gTitle += gLayer; | |
85 | gTitle += "_Ladder"; gTitle += gLadder; | |
86 | gTitle += "_Module"; gTitle += gModule; | |
87 | fHistSSDRawSignalModule[gHistCounter] = new TH1D(gTitle.Data(),gTitle.Data(), | |
88 | 2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips); | |
89 | gHistCounter += 1; | |
90 | ||
91 | for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++) | |
92 | fOccupancyMatrix[iModule-500][iStrip] = 0; | |
93 | }//module loop | |
94 | }//online flag | |
95 | else { | |
96 | for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) | |
97 | fHistSSDRawSignalModule[iModule]=NULL; | |
98 | fCDBManager = NULL; | |
99 | } | |
100 | } | |
101 | ||
102 | //____________________________________________________________________________ | |
103 | AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(const AliITSQASSDDataMakerRec& qadm) : | |
104 | TObject(), | |
105 | fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec), | |
106 | fSSDEvent(qadm.fSSDEvent), | |
107 | fSSDEventPerCycle(qadm.fSSDEventPerCycle), | |
108 | fkOnline(qadm.fkOnline), | |
109 | fLDC(qadm.fLDC), | |
110 | fSSDRawsOffset(qadm.fSSDRawsOffset), fSSDRawsDAOffset(qadm.fSSDRawsDAOffset), | |
111 | fSSDRawsCommonLevelOffset(qadm.fSSDRawsCommonLevelOffset), | |
112 | fSSDhTask(qadm.fSSDhTask), | |
113 | fGenOffset(qadm.fGenOffset), | |
114 | fCDBManager(qadm.fCDBManager) { | |
115 | //copy ctor | |
116 | fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ; | |
117 | fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle()); | |
118 | } | |
119 | ||
120 | //__________________________________________________________________ | |
121 | AliITSQASSDDataMakerRec& AliITSQASSDDataMakerRec::operator = (const AliITSQASSDDataMakerRec& qac ) | |
122 | { | |
123 | // Equal operator. | |
124 | this->~AliITSQASSDDataMakerRec(); | |
125 | new(this) AliITSQASSDDataMakerRec(qac); | |
126 | return *this; | |
127 | } | |
128 | ||
129 | //__________________________________________________________________ | |
130 | AliITSQASSDDataMakerRec::~AliITSQASSDDataMakerRec() { | |
131 | // destructor | |
132 | for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) | |
133 | if(fHistSSDRawSignalModule[iModule]) delete fHistSSDRawSignalModule[iModule]; | |
134 | if(fCDBManager) delete fCDBManager; | |
135 | } | |
136 | ||
137 | //____________________________________________________________________________ | |
138 | void AliITSQASSDDataMakerRec::StartOfDetectorCycle() | |
139 | { | |
140 | if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined | |
141 | return ; | |
142 | ||
143 | //Detector specific actions at start of cycle | |
144 | AliDebug(1,"AliITSQADM::Start of SSD Cycle\n"); | |
145 | ||
146 | //Data size per DDL | |
147 | ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4)))->Reset(); | |
148 | //Data size per LDC | |
149 | ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22)))->Reset(); | |
150 | ||
151 | //online part | |
152 | if(fkOnline) { | |
153 | for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) { | |
154 | for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++) | |
155 | fOccupancyMatrix[iModule-500][iStrip] = 0; | |
156 | }//module loop | |
157 | ||
158 | Int_t gHistPositionOccupancyPerLadder = 0; | |
159 | Int_t gLayer = 0, gLadder = 0, gModule = 0; | |
160 | for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) { | |
161 | AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule); | |
162 | ||
163 | gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5); | |
164 | ||
165 | //P-SIDE OCCUPANCY | |
166 | fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Reset(); | |
167 | //N-SIDE OCCUPANCY | |
168 | fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Reset(); | |
169 | ||
170 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->Reset(); | |
171 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->Reset(); | |
172 | }//module loop | |
173 | }//online flag | |
174 | } | |
175 | ||
176 | //____________________________________________________________________________ | |
177 | void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray* list) | |
178 | { | |
179 | // launch the QA checking | |
180 | if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined | |
181 | return ; | |
182 | ||
183 | // launch the QA checking | |
184 | AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); | |
185 | //Data size per DDL | |
186 | for(Int_t i = 0; i < fgkNumOfDDLs; i++) { | |
187 | Double_t gSizePerDDL = TMath::Power(10,(fAliITSQADataMakerRec->GetRawsData(fGenOffset+5+i))->GetMean())/1e+06; | |
188 | ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4)))->SetBinContent(i+2,gSizePerDDL); | |
189 | } | |
190 | ||
191 | //Data size per LDC | |
192 | for(Int_t i = 0; i < fgkNumOfLDCs; i++) { | |
193 | Double_t gSizePerLDC = TMath::Power(10,(fAliITSQADataMakerRec->GetRawsData(fGenOffset+23+i))->GetMean())/1e+06; | |
194 | ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22)))->SetBinContent(i+6,gSizePerLDC); | |
195 | } | |
196 | ||
197 | //online part | |
198 | if(fkOnline) { | |
199 | //Output of the DA | |
200 | MonitorOCDBObjects(); | |
201 | ||
202 | Int_t gHistPositionOccupancyPerModule = 0; | |
203 | Int_t gLayer = 0, gLadder = 0, gModule = 0; | |
204 | //occupancy per module | |
205 | for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) { | |
206 | AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule); | |
207 | ||
208 | gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1); | |
209 | for(Int_t iBins = 1; iBins < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBins++) | |
210 | fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)->SetBinContent(iBins,fOccupancyMatrix[iModule][iBins-1]); | |
211 | ||
212 | if(fSSDEventPerCycle != 0) | |
213 | ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)))->Scale(100./fSSDEventPerCycle); | |
214 | }//module loop | |
215 | ||
216 | //occupancy per ladder | |
217 | Int_t gHistPositionOccupancyPerLadder = 0; | |
218 | Int_t lLadderLocationY = 0; | |
219 | Double_t occupancy = 0.0, occupancyThreshold = 0.0, occupancyAverage = 0.0; | |
220 | for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) { | |
221 | AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule); | |
222 | ||
223 | gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1); | |
224 | gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5); | |
225 | ||
226 | //P-SIDE OCCUPANCY | |
227 | occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,0,0); | |
228 | occupancyThreshold = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,1,3); | |
229 | occupancyAverage = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,2,0); | |
230 | ||
231 | fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Fill(gModule,occupancy); | |
232 | lLadderLocationY = 3*gLadder; // sideP=1 sideN=0 | |
233 | if(gLayer == 5) { | |
234 | //occupancy per module - no threshold | |
235 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->SetBinContent(gModule,lLadderLocationY,occupancy); | |
236 | //occupancy per module - threshold @ 3% | |
237 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+2))->SetBinContent(gModule,lLadderLocationY,occupancyThreshold); | |
238 | //average occupancy per module | |
239 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4))->SetBinContent(gModule,lLadderLocationY,occupancyAverage); | |
240 | } | |
241 | else if(gLayer == 6) { | |
242 | //occupancy per module - no threshold | |
243 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY,occupancy); | |
244 | //occupancy per module - threshold @ 3% | |
245 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3))->SetBinContent(gModule,lLadderLocationY,occupancyThreshold); | |
246 | //average occupancy per module | |
247 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+5))->SetBinContent(gModule,lLadderLocationY,occupancyAverage); | |
248 | } | |
249 | ||
250 | //N-SIDE OCCUPANCY | |
251 | occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,0,0); | |
252 | occupancyThreshold = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,1,3); | |
253 | occupancyAverage = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,2,0); | |
254 | ||
255 | fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Fill(gModule,occupancy); | |
256 | if(gLayer == 5) { | |
257 | //occupancy per module - no threshold | |
258 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->SetBinContent(gModule,lLadderLocationY-1,occupancy); | |
259 | //occupancy per module - threshold @ 3% | |
260 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+2))->SetBinContent(gModule,lLadderLocationY-1,occupancyThreshold); | |
261 | //average occupancy per module | |
262 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4))->SetBinContent(gModule,lLadderLocationY-1,occupancyAverage); | |
263 | } | |
264 | else if(gLayer == 6) { | |
265 | //occupancy per module - no threshold | |
266 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY-1,occupancy); | |
267 | //occupancy per module - threshold @ 3% | |
268 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3))->SetBinContent(gModule,lLadderLocationY-1,occupancyThreshold); | |
269 | //average occupancy per module | |
270 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+5))->SetBinContent(gModule,lLadderLocationY-1,occupancyAverage); | |
271 | } | |
272 | }//module loop | |
273 | }//online flag for SSD | |
274 | ||
275 | fSSDEventPerCycle = 0; | |
276 | ||
277 | AliQAChecker::Instance()->Run( AliQA::kITS , task, list); | |
278 | } | |
279 | ||
280 | //____________________________________________________________________________ | |
281 | void AliITSQASSDDataMakerRec::InitRaws() { | |
282 | // Initialization for RAW data - SSD - | |
283 | fGenOffset = (fAliITSQADataMakerRec->fRawsQAList)->GetEntries(); | |
284 | ||
285 | if(fkOnline) { | |
286 | AliInfo("Book Online Histograms for SSD\n"); | |
287 | } | |
288 | else { | |
289 | AliInfo("Book Offline Histograms for SSD\n "); | |
290 | } | |
291 | AliInfo(Form("Number of histograms (SPD+SDD): %d\n",fGenOffset)); | |
292 | TString gTitle = 0; | |
293 | //book online-offline QA histos | |
294 | TH1F *fHistSSDEventType = new TH1F("fHistSSDEventType", | |
295 | ";Event type;Events", | |
296 | 31,-1,30); | |
297 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDEventType, | |
298 | fGenOffset+fSSDRawsOffset); | |
299 | fSSDRawsOffset += 1; | |
300 | TH1F *fHistSSDDataSize = new TH1F("fHistSSDDataSize", | |
301 | ";log(SSD data size) [Bytes];Events", | |
302 | 100,3,8); | |
303 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSize, | |
304 | fGenOffset+fSSDRawsOffset); | |
305 | fSSDRawsOffset += 1; | |
306 | TH1F *fHistSSDDataSizePercentage = new TH1F("fHistSSDDataSizePercentage", | |
307 | ";SSD data size [%];Events", | |
308 | 100,0,100); | |
309 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePercentage, | |
310 | fGenOffset+fSSDRawsOffset); | |
311 | fSSDRawsOffset += 1; | |
312 | TH1F *fHistSSDDDLId = new TH1F("fHistSSDDDLId", | |
313 | ";DDL id;Events",20,510.5,530.5); | |
314 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDDDLId, | |
315 | fGenOffset+fSSDRawsOffset); | |
316 | fSSDRawsOffset += 1; | |
317 | TH1F *fHistSSDDataSizePerDDL = new TH1F("fHistSSDDataSizePerDDL", | |
318 | ";DDL id;<SSD data size> [MB]", | |
319 | 20,510.5,530.5); | |
320 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerDDL, | |
321 | fGenOffset+fSSDRawsOffset); | |
322 | fSSDRawsOffset += 1; | |
323 | TH1F *fHistSSDDataSizeDDL[fgkNumOfDDLs]; | |
324 | for(Int_t i = 1; i < fgkNumOfDDLs+1; i++) { | |
325 | gTitle = "fHistSSDDataSizeDDL"; gTitle += i+511; | |
326 | fHistSSDDataSizeDDL[i-1] = new TH1F(gTitle.Data(), | |
327 | ";log(SSD data size) [Bytes];Events", | |
328 | 100,1,8); | |
329 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeDDL[i-1], | |
330 | fGenOffset+fSSDRawsOffset); | |
331 | fSSDRawsOffset += 1; | |
332 | } | |
333 | ||
334 | TH1F *fHistSSDLDCId = new TH1F("fHistSSDLDCId",";LDC id;Events",10,0.5,10.5); | |
335 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDLDCId, | |
336 | fGenOffset+fSSDRawsOffset); | |
337 | fSSDRawsOffset += 1; | |
338 | TH1F *fHistSSDDataSizePerLDC = new TH1F("fHistSSDDataSizePerLDC", | |
339 | ";LDC id;<SSD data size> [MB]", | |
340 | 20,0.5,20.5); | |
341 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerLDC, | |
342 | fGenOffset+fSSDRawsOffset); | |
343 | fSSDRawsOffset += 1; | |
344 | TH1F *fHistSSDDataSizeLDC[fgkNumOfLDCs]; | |
345 | for(Int_t i = 1; i < fgkNumOfLDCs+1; i++) { | |
346 | gTitle = "fHistSSDDataSizeLDC"; | |
347 | if(i == 1) gTitle += "082"; | |
348 | if(i == 2) gTitle += "086"; | |
349 | if(i == 3) gTitle += "085"; | |
350 | fHistSSDDataSizeLDC[i-1] = new TH1F(gTitle.Data(), | |
351 | ";log(SSD data size) [Bytes];Events", | |
352 | 100,1,8); | |
353 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeLDC[i-1], | |
354 | fGenOffset+fSSDRawsOffset); | |
355 | fSSDRawsOffset += 1; | |
356 | } | |
357 | fSSDRawsCommonLevelOffset = fSSDRawsOffset; | |
358 | ||
359 | if(fkOnline) { | |
360 | Int_t gLayer = 0, gLadder = 0, gModule = 0; | |
361 | //occupancy per SSD module | |
362 | TH1D *fHistSSDOccupancyModule[fgkSSDMODULES]; | |
363 | for(Int_t i = 500; i < fgkSSDMODULES + 500; i++) { | |
364 | AliITSgeomTGeo::GetModuleId(i,gLayer,gLadder,gModule); | |
365 | gTitle = "fHistSSD_Occupancy_Layer"; gTitle += gLayer; | |
366 | gTitle += "_Ladder"; | |
367 | if(gLayer == 5) | |
368 | gTitle += 499+gLadder; | |
369 | if(gLayer == 6) | |
370 | gTitle += 599+gLadder; | |
371 | gTitle += "_Module"; gTitle += gModule; | |
372 | fHistSSDOccupancyModule[i-500] = new TH1D(gTitle.Data(),gTitle.Data(), | |
373 | 2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips); | |
374 | fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitleColor(1); | |
375 | fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitle("N_{strip}"); | |
376 | fHistSSDOccupancyModule[i-500]->GetYaxis()->SetTitle("Occupancy [%]"); | |
377 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyModule[i-500], fGenOffset+fSSDRawsOffset); | |
378 | fSSDRawsOffset += 1; | |
379 | } | |
380 | ||
381 | //Occupancy per SSD ladder | |
382 | Int_t occupancyCounter = 0; | |
383 | TH1D *fHistSSDOccupancyLadder[2*(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)]; | |
384 | for(Int_t iLayer = 5; iLayer < 7; iLayer++) { | |
385 | for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) { | |
386 | //P-side occupancy plots | |
387 | gTitle = "fHistSSD_Occupancy_Layer"; gTitle += iLayer; | |
388 | gTitle += "_Ladder"; | |
389 | if(iLayer == 5) | |
390 | gTitle += 499+iLadder; | |
391 | if(iLayer == 6) | |
392 | gTitle += 599+iLadder; | |
393 | gTitle += "_PSide"; | |
394 | fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(), | |
395 | gTitle.Data(), | |
396 | AliITSgeomTGeo::GetNDetectors(iLayer), | |
397 | 0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5); | |
398 | fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1); | |
399 | fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number"); | |
400 | fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]"); | |
401 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter], | |
402 | fGenOffset+fSSDRawsOffset); | |
403 | occupancyCounter += 1; fSSDRawsOffset += 1; | |
404 | //N-side occupancy plots | |
405 | gTitle = "fHistSSD_Occupancy_Layer"; gTitle += iLayer; | |
406 | gTitle += "_Ladder"; | |
407 | if(iLayer == 5) | |
408 | gTitle += 499+iLadder; | |
409 | if(iLayer == 6) | |
410 | gTitle += 599+iLadder; | |
411 | gTitle += "_NSide"; | |
412 | fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(), | |
413 | gTitle.Data(), | |
414 | AliITSgeomTGeo::GetNDetectors(iLayer), | |
415 | 0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5); | |
416 | fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1); | |
417 | fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number"); | |
418 | fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]"); | |
419 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter], | |
420 | fGenOffset+fSSDRawsOffset); | |
421 | occupancyCounter += 1; fSSDRawsOffset += 1; | |
422 | }//ladder loop | |
423 | }//layer loop | |
424 | ||
425 | //top level occupancy plots | |
426 | //occupancy per module - no threshold | |
427 | TH2D *fHistSSDOccupancyLayer5 = new TH2D("fHistSSDOccupancyLayer5", | |
428 | ";N_{modules};N_{Ladders}", | |
429 | fgkSSDMODULESPERLADDERLAYER5, | |
430 | 0,fgkSSDMODULESPERLADDERLAYER5, | |
431 | 3*fgkSSDLADDERSLAYER5, | |
432 | 0,fgkSSDLADDERSLAYER5); | |
433 | fHistSSDOccupancyLayer5->SetTitle("Occupancy per module (Layer 5) - No threshold"); | |
434 | Char_t fLabel[3]; | |
435 | for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){ | |
436 | sprintf(fLabel,"%d",iBin); | |
437 | fHistSSDOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel); | |
438 | } | |
439 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer5, fGenOffset+fSSDRawsOffset); | |
440 | fSSDRawsOffset += 1; | |
441 | TH2D *fHistSSDOccupancyLayer6 = new TH2D("fHistSSDOccupancyLayer6", | |
442 | ";N_{modules};N_{Ladders}", | |
443 | fgkSSDMODULESPERLADDERLAYER6, | |
444 | 0,fgkSSDMODULESPERLADDERLAYER6, | |
445 | 3*fgkSSDLADDERSLAYER6, | |
446 | 0,fgkSSDLADDERSLAYER6); | |
447 | fHistSSDOccupancyLayer6->SetTitle("Occupancy per module (Layer 6) - No threshold"); | |
448 | for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){ | |
449 | sprintf(fLabel,"%d",iBin); | |
450 | fHistSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel); | |
451 | } | |
452 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6, fGenOffset+fSSDRawsOffset); | |
453 | fSSDRawsOffset += 1; | |
454 | ||
455 | //occupancy per module - threshold @ 3% | |
456 | TH2D *fHistSSDOccupancyThresholdLayer5 = new TH2D("fHistSSDOccupancyThresholdLayer5", | |
457 | ";N_{modules};N_{Ladders}", | |
458 | fgkSSDMODULESPERLADDERLAYER5, | |
459 | 0,fgkSSDMODULESPERLADDERLAYER5, | |
460 | 3*fgkSSDLADDERSLAYER5, | |
461 | 0,fgkSSDLADDERSLAYER5); | |
462 | fHistSSDOccupancyThresholdLayer5->SetTitle("Occupancy per module (Layer 5) - Threshold 3%"); | |
463 | for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){ | |
464 | sprintf(fLabel,"%d",iBin); | |
465 | fHistSSDOccupancyThresholdLayer5->GetXaxis()->SetBinLabel(iBin,fLabel); | |
466 | } | |
467 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer5, fGenOffset+fSSDRawsOffset); | |
468 | fSSDRawsOffset += 1; | |
469 | TH2D *fHistSSDOccupancyThresholdLayer6 = new TH2D("fHistSSDOccupancyThresholdLayer6", | |
470 | ";N_{modules};N_{Ladders}", | |
471 | fgkSSDMODULESPERLADDERLAYER6, | |
472 | 0,fgkSSDMODULESPERLADDERLAYER6, | |
473 | 3*fgkSSDLADDERSLAYER6, | |
474 | 0,fgkSSDLADDERSLAYER6); | |
475 | fHistSSDOccupancyThresholdLayer6->SetTitle("Occupancy per module (Layer 6) - Threshold 3%"); | |
476 | for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){ | |
477 | sprintf(fLabel,"%d",iBin); | |
478 | fHistSSDOccupancyThresholdLayer6->GetXaxis()->SetBinLabel(iBin,fLabel); | |
479 | } | |
480 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer6, fGenOffset+fSSDRawsOffset); | |
481 | fSSDRawsOffset += 1; | |
482 | ||
483 | //Average occupancy per module | |
484 | TH2D *fHistSSDAverageOccupancyLayer5 = new TH2D("fHistSSDAverageOccupancyLayer5", | |
485 | ";N_{modules};N_{Ladders}", | |
486 | fgkSSDMODULESPERLADDERLAYER5, | |
487 | 0,fgkSSDMODULESPERLADDERLAYER5, | |
488 | 3*fgkSSDLADDERSLAYER5, | |
489 | 0,fgkSSDLADDERSLAYER5); | |
490 | fHistSSDAverageOccupancyLayer5->SetTitle("Average occupancy per module (Layer 5)"); | |
491 | for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){ | |
492 | sprintf(fLabel,"%d",iBin); | |
493 | fHistSSDAverageOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel); | |
494 | } | |
495 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer5, fGenOffset+fSSDRawsOffset); | |
496 | fSSDRawsOffset += 1; | |
497 | TH2D *fHistSSDAverageOccupancyLayer6 = new TH2D("fHistSSDAverageOccupancyLayer6", | |
498 | ";N_{modules};N_{Ladders}", | |
499 | fgkSSDMODULESPERLADDERLAYER6, | |
500 | 0,fgkSSDMODULESPERLADDERLAYER6, | |
501 | 3*fgkSSDLADDERSLAYER6, | |
502 | 0,fgkSSDLADDERSLAYER6); | |
503 | fHistSSDAverageOccupancyLayer6->SetTitle("Average occupancy per module (Layer 6)"); | |
504 | for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){ | |
505 | sprintf(fLabel,"%d",iBin); | |
506 | fHistSSDAverageOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel); | |
507 | } | |
508 | fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer6, fGenOffset+fSSDRawsOffset); | |
509 | fSSDRawsOffset += 1; | |
510 | ||
511 | //Output of the DA | |
512 | TH2D *fHistPSideBadChannelMapLayer5 = new TH2D("fHistPSideBadChannelMapLayer5", | |
513 | "Layer 5;N_{module};N_{ladder}", | |
514 | 22,1,23, | |
515 | 34,500,534); | |
516 | fHistPSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1); | |
517 | fHistPSideBadChannelMapLayer5->SetStats(kFALSE); | |
518 | fHistPSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8); | |
519 | fHistPSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22); | |
520 | fHistPSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34); | |
521 | fHistPSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03); | |
522 | fHistPSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03); | |
523 | fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6); | |
524 | fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]"); | |
525 | fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer5, fGenOffset+fSSDRawsOffset); | |
526 | fSSDRawsOffset += 1; fSSDRawsDAOffset += 1; | |
527 | ||
528 | TH2D *fHistNSideBadChannelMapLayer5 = new TH2D("fHistNSideBadChannelMapLayer5", | |
529 | "Layer 5;N_{module};N_{ladder}", | |
530 | 22,1,23, | |
531 | 34,500,534); | |
532 | fHistNSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1); | |
533 | fHistNSideBadChannelMapLayer5->SetStats(kFALSE); | |
534 | fHistNSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8); | |
535 | fHistNSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22); | |
536 | fHistNSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34); | |
537 | fHistNSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03); | |
538 | fHistNSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03); | |
539 | fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6); | |
540 | fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]"); | |
541 | fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer5, fGenOffset+fSSDRawsOffset); | |
542 | fSSDRawsOffset += 1; fSSDRawsDAOffset += 1; | |
543 | ||
544 | TH2D *fHistPSideBadChannelMapLayer6 = new TH2D("fHistPSideBadChannelMapLayer6", | |
545 | "Layer 6;N_{module};N_{ladder}", | |
546 | 25,1,26, | |
547 | 38,600,638); | |
548 | fHistPSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1); | |
549 | fHistPSideBadChannelMapLayer6->SetStats(kFALSE); | |
550 | fHistPSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8); | |
551 | fHistPSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25); | |
552 | fHistPSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38); | |
553 | fHistPSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03); | |
554 | fHistPSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03); | |
555 | fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6); | |
556 | fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]"); | |
557 | fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer6, fGenOffset+fSSDRawsOffset); | |
558 | fSSDRawsOffset += 1; fSSDRawsDAOffset += 1; | |
559 | ||
560 | TH2D *fHistNSideBadChannelMapLayer6 = new TH2D("fHistNSideBadChannelMapLayer6", | |
561 | "Layer 6;N_{module};N_{ladder}", | |
562 | 25,1,26, | |
563 | 38,600,638); | |
564 | fHistNSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1); | |
565 | fHistNSideBadChannelMapLayer6->SetStats(kFALSE); | |
566 | fHistNSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8); | |
567 | fHistNSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25); | |
568 | fHistNSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38); | |
569 | fHistNSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03); | |
570 | fHistNSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03); | |
571 | fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6); | |
572 | fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]"); | |
573 | fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer6, fGenOffset+fSSDRawsOffset); | |
574 | fSSDRawsOffset += 1; fSSDRawsDAOffset += 1; | |
575 | }//online flag | |
576 | fSSDhTask = fSSDRawsOffset; | |
577 | AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhTask)); | |
578 | AliInfo(Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenOffset+fSSDhTask)); | |
579 | AliDebug(1,Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenOffset+fSSDRawsOffset)); | |
580 | } | |
581 | ||
582 | //____________________________________________________________________________ | |
583 | void AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) { | |
584 | // Fill QA for RAW - SSD - | |
585 | Int_t gStripNumber; | |
586 | Int_t gHistPosition; | |
587 | Int_t gLayer = 0,gLadder = 0, gModule = 0; | |
588 | ||
589 | Double_t gSizePerDDL[fgkNumOfDDLs] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.}; | |
590 | Double_t gSizePerLDC[fgkNumOfLDCs] = {0.,0.,0.}; | |
591 | Double_t sumSSDDataSize = 0.0; | |
592 | Double_t eventSize = -1.0; | |
593 | ||
594 | if(fkOnline) { | |
595 | //reset the signal vs strip number histograms | |
596 | for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) | |
597 | fHistSSDRawSignalModule[iModule]->Reset(); | |
598 | }//online flag | |
599 | ||
600 | rawReader->Select("ITSSSD",-1,-1); | |
601 | rawReader->Reset(); //rawReader->NextEvent(); | |
602 | (fAliITSQADataMakerRec->GetRawsData(fGenOffset))->Fill(rawReader->GetType()); | |
603 | if(rawReader->GetType() == 7) { | |
604 | fSSDEvent += 1; | |
605 | fSSDEventPerCycle += 1; | |
606 | } | |
607 | ||
608 | AliITSRawStreamSSD gSSDStream(rawReader); | |
609 | AliRawReaderRoot *rootReader = (AliRawReaderRoot *)rawReader; | |
610 | if(rootReader) { | |
611 | const AliRawEventHeaderBase *header = rootReader->GetEventHeader(); | |
612 | if(header) | |
613 | eventSize = header->GetEventSize(); | |
614 | } | |
615 | while (gSSDStream.Next()) { | |
616 | if(gSSDStream.GetModuleID() < 0) continue; | |
617 | /*cout<<"DDL: "<<rawReader->GetDDLID()<< | |
618 | " - LDC: "<<rawReader->GetLDCId()<< | |
619 | " - Size: "<<rawReader->GetDataSize()<< | |
620 | " - Equipment size: "<<rawReader->GetEquipmentSize()<<endl;*/ | |
621 | gSizePerDDL[rawReader->GetDDLID()] = rawReader->GetDataSize(); | |
622 | gSizePerLDC[rawReader->GetLDCId()-6] = rawReader->GetDataSize(); | |
623 | AliITSgeomTGeo::GetModuleId(gSSDStream.GetModuleID(),gLayer,gLadder,gModule); | |
624 | if(gSSDStream.GetStrip() < 0) continue; | |
625 | gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips; | |
626 | gHistPosition = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1); | |
627 | //AliInfo(Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",gHistPosition,gLayer,gLadder,gModule)); | |
628 | if(fkOnline) | |
629 | fHistSSDRawSignalModule[gHistPosition]->Fill(gStripNumber,gSSDStream.GetSignal()); | |
630 | //fAliITSQADataMakerRec->GetRawsData(fGenOffset+gHistPosition+fSSDRawsCommonLevelOffset)->Fill(gStripNumber,gSSDStream.GetSignal()); | |
631 | }//streamer loop | |
632 | ||
633 | //event size calculation and filling info | |
634 | for(Int_t i = 0; i < fgkNumOfDDLs; i++) { | |
635 | sumSSDDataSize += gSizePerDDL[i]; | |
636 | if(gSizePerDDL[i] > 0) { | |
637 | (fAliITSQADataMakerRec->GetRawsData(fGenOffset+3))->Fill(i+512); | |
638 | (fAliITSQADataMakerRec->GetRawsData(fGenOffset+5+i))->Fill(TMath::Log10(gSizePerDDL[i])); | |
639 | } | |
640 | //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4))->Fill(i+512,gSizePerDDL[i]/1e+06); | |
641 | } | |
642 | for(Int_t i = 0; i < fgkNumOfLDCs; i++) { | |
643 | if(gSizePerLDC[i] > 0) { | |
644 | (fAliITSQADataMakerRec->GetRawsData(fGenOffset+21))->Fill(i+6); | |
645 | //LDC 082 | |
646 | if(i == 0) | |
647 | gSizePerLDC[i] = gSizePerDDL[8] + gSizePerDDL[9] + gSizePerDDL[10] + | |
648 | gSizePerDDL[11] + gSizePerDDL[12] + gSizePerDDL[13]; | |
649 | //LDC 086 | |
650 | if(i == 1) | |
651 | gSizePerLDC[i] = gSizePerDDL[3] + gSizePerDDL[4] + gSizePerDDL[5] + | |
652 | gSizePerDDL[6] + gSizePerDDL[7]; | |
653 | //LDC 085 | |
654 | if(i == 2) | |
655 | gSizePerLDC[i] = gSizePerDDL[0] + gSizePerDDL[1] + gSizePerDDL[2] + | |
656 | gSizePerDDL[14] + gSizePerDDL[15]; | |
657 | (fAliITSQADataMakerRec->GetRawsData(fGenOffset+23+i))->Fill(TMath::Log10(gSizePerLDC[i])); | |
658 | //cout<<"Event: "<<fSSDEventPerCycle<<" - LDC: "<<i+6<< | |
659 | //" - Data size: "<<gSizePerLDC[i]<<endl; | |
660 | } | |
661 | //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22))->Fill(i+6,gSizePerLDC[i]/1e+06); | |
662 | } | |
663 | if(sumSSDDataSize) | |
664 | (fAliITSQADataMakerRec->GetRawsData(fGenOffset+1))->Fill(TMath::Log10(sumSSDDataSize)); | |
665 | if(eventSize) | |
666 | (fAliITSQADataMakerRec->GetRawsData(fGenOffset+2))->Fill(100.*sumSSDDataSize/eventSize); | |
667 | ||
668 | //Occupancy calculation | |
669 | if(fkOnline) { | |
670 | for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) { | |
671 | GetOccupancyStrip(fHistSSDRawSignalModule[iModule],fOccupancyMatrix[iModule]); | |
672 | //if(iModule == 156) { | |
673 | //cout<<"========================================"<<endl; | |
674 | //AliITSgeomTGeo::GetModuleId(656,gLayer,gLadder,gModule); | |
675 | /*for(Int_t iBin = 1; iBin < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBin++) { | |
676 | if((iBin >= 750)&&(iBin <= 780)) | |
677 | cout<<"Event: "<<fSSDEventPerCycle<<" - Ladder: "<<gLadder+499<< | |
678 | " - Module: "<<gModule<<" - Strip: "<<iBin<< | |
679 | " - Signal: "<<fHistSSDRawSignalModule[iModule]->GetBinContent(iBin)<<endl; | |
680 | }*///strip loop --> to be removed | |
681 | //}//module cut --> to be removed | |
682 | }//module loop | |
683 | }//online flag for SSD | |
684 | } | |
685 | ||
686 | //____________________________________________________________________________ // | |
687 | void AliITSQASSDDataMakerRec::GetOccupancyStrip(TH1 *lHisto, Int_t *occupancyMatrix) { | |
688 | //Increments the entries in the occupancy matrix based | |
689 | //on whether the signal for each strip is larger than the cutoff | |
690 | //Currently the cutoff is at 0 which means that if ZS | |
691 | //works, whatever comes from the FEROM is considered as "signal" | |
692 | //Double_t cutoff = 0.0; | |
693 | TString histname = lHisto->GetName(); | |
694 | //cout<<histname.Data()<<endl; | |
695 | //if(histname.Contains("Layer5_Ladder8_Module3")) { | |
696 | for(Int_t iBin = 1; iBin < lHisto->GetXaxis()->GetNbins(); iBin++) { | |
697 | Double_t y = lHisto->GetBinContent(iBin); | |
698 | if(y) { | |
699 | occupancyMatrix[iBin-1] += 1; | |
700 | } | |
701 | //if((iBin >= 750)&&(iBin <= 780)) | |
702 | //cout<<"Strip: "<<iBin<< | |
703 | //" - Signal: "<<y<< | |
704 | //" - Occupancy: "<<occupancyMatrix[iBin-1]<<endl; | |
705 | ||
706 | } | |
707 | //} | |
708 | } | |
709 | ||
710 | //____________________________________________________________________________ | |
711 | Double_t AliITSQASSDDataMakerRec::GetOccupancyModule(TH1 *lHisto, | |
712 | Int_t stripside, | |
713 | Int_t mode, | |
714 | Double_t threshold) { | |
715 | //Mode 0: calculates the occupancy of a module | |
716 | // without a threshold in the strip occupancy | |
717 | //Mode 1: calculates the occupancy of a module | |
718 | // with the set threshold in the strip occupancy | |
719 | //Mode 2: calculates the average occupancy of a module | |
720 | ||
721 | // bo: TDC >0 or # of sigmas wrt noise ? | |
722 | //stripside == 0 --> P-side | |
723 | //stripside == 1 --> N-side | |
724 | Int_t lNumFiredBins = 0; | |
725 | Double_t sumOccupancy = 0.0; | |
726 | TString histname = lHisto->GetName(); | |
727 | for(Int_t iBin = 1 + stripside*fgkNumberOfPSideStrips; iBin < fgkNumberOfPSideStrips*(1 + stripside); iBin++){ | |
728 | /*if(histname.Contains("Layer5_Ladder507_Module3")) { | |
729 | cout<<lHisto->GetName()<< | |
730 | " - Strip: "<<iBin<< | |
731 | " - Bin content: "<<lHisto->GetBinContent(iBin)<<endl; | |
732 | }*/ | |
733 | if (lHisto->GetBinContent(iBin) > threshold) { | |
734 | lNumFiredBins++; | |
735 | sumOccupancy = lHisto->GetBinContent(iBin); | |
736 | } | |
737 | } | |
738 | ||
739 | Double_t lOccupancy = 0.0; | |
740 | if((mode == 0)||(mode == 1)) | |
741 | lOccupancy = (100.*lNumFiredBins)/fgkNumberOfPSideStrips; // percentage | |
742 | else if(mode == 2) | |
743 | lOccupancy = 100.*sumOccupancy/fgkNumberOfPSideStrips; | |
744 | ||
745 | /*if(histname.Contains("Layer5_Ladder507_Module3")) | |
746 | cout<<"Fired strips: "<<lNumFiredBins<< | |
747 | " - Occupancy: "<<lOccupancy<<endl;*/ | |
748 | //AliInfo(Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy)); | |
749 | ||
750 | return lOccupancy; | |
751 | } | |
752 | ||
753 | //____________________________________________________________________________ | |
754 | void AliITSQASSDDataMakerRec::MonitorOCDBObjects() { | |
755 | //Monitor in AMORE the output of the DA | |
756 | //Currently only the bad channel list is monitored | |
757 | //Todo: Noise - Pedestal | |
758 | AliCDBEntry *entryBadChannelsSSD = fCDBManager->Get("ITS/Calib/BadChannelsSSD"); | |
759 | if(!entryBadChannelsSSD) | |
760 | AliError("OCDB entry for the bad channel list is not valid!"); | |
761 | AliITSBadChannelsSSDv2 *badchannelsSSD = (AliITSBadChannelsSSDv2 *)entryBadChannelsSSD->GetObject(); | |
762 | if(!badchannelsSSD) | |
763 | AliError("Bad channel list object is not a valid AliITSBadChannelsSSD object!"); | |
764 | ||
765 | //_____________________________________________________________________________// | |
766 | Int_t nBadPSideChannels = 0, nBadNSideChannels = 0; | |
767 | Int_t layer = 0, ladder = 0, module = 0; | |
768 | Int_t nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0; | |
769 | Int_t nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0; | |
770 | //_____________________________________________________________________________// | |
771 | ||
772 | for(Int_t i = 0; i < fgkSSDMODULES; i++) { | |
773 | AliITSgeomTGeo::GetModuleId(i+500,layer,ladder,module); | |
774 | nBadPSideChannels = 0, nBadNSideChannels = 0; | |
775 | nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0; | |
776 | nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0; | |
777 | ||
778 | Int_t badChannel = 0; | |
779 | for(Int_t j = 0; j < fgkNumberOfPSideStrips; j++) { | |
780 | badChannel = (Int_t)(badchannelsSSD->GetBadChannelP(i,j)); | |
781 | if(badChannel != 0) { | |
782 | if(layer == 5) | |
783 | nPSideChannelsLayer5 += 1; | |
784 | if(layer == 6) | |
785 | nPSideChannelsLayer6 += 1; | |
786 | nBadPSideChannels += 1; | |
787 | }//badchannel flag != 0 | |
788 | badChannel = (Int_t)(badchannelsSSD->GetBadChannelN(i,j)); | |
789 | if(badChannel != 0) { | |
790 | if(layer == 5) | |
791 | nNSideChannelsLayer5 += 1; | |
792 | if(layer == 6) | |
793 | nNSideChannelsLayer6 += 1; | |
794 | nBadNSideChannels += 1; | |
795 | }//badchannel flag != 0 | |
796 | }//loop over strips | |
797 | if(layer == 5) { | |
798 | if(nPSideChannelsLayer5 > 0) | |
799 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder, | |
800 | 100.*nPSideChannelsLayer5/fgkNumberOfPSideStrips); | |
801 | else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder,0.0001); | |
802 | if(nNSideChannelsLayer5 > 0) | |
803 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder, | |
804 | 100.*nNSideChannelsLayer5/fgkNumberOfPSideStrips); | |
805 | else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder,0.0001); | |
806 | }//layer 5 | |
807 | if(layer == 6) { | |
808 | if(nPSideChannelsLayer6 > 0) | |
809 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder, | |
810 | 100.*nPSideChannelsLayer6/fgkNumberOfPSideStrips); | |
811 | else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder,0.0001); | |
812 | if(nNSideChannelsLayer6 > 0) | |
813 | ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder, | |
814 | 100.*nNSideChannelsLayer6/fgkNumberOfPSideStrips); | |
815 | else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder,0.0001); | |
816 | }//layer 6 | |
817 | }//module loop | |
818 | } | |
819 | ||
820 | //____________________________________________________________________________ | |
821 | void AliITSQASSDDataMakerRec::InitRecPoints() | |
822 | { | |
823 | // Initialization for RECPOINTS - SSD - | |
824 | ||
825 | fGenOffset = (fAliITSQADataMakerRec->fRecPointsQAList)->GetEntries(); | |
826 | Int_t nModuleOffset = 500; | |
827 | Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules(); | |
828 | ||
829 | TH1F *fHistModuleIdLayer5 = new TH1F("fHistModuleIdLayer5", | |
830 | "Module Id - Layer 5;Module Id;Entries", | |
831 | fgkSSDMODULESLAYER5, | |
832 | nModuleOffset - 0.5, | |
833 | nITSTotalModules-fgkSSDMODULESLAYER6+0.5); | |
834 | fAliITSQADataMakerRec->Add2RecPointsList(fHistModuleIdLayer5, | |
835 | fGenOffset + 0); | |
836 | fSSDhTask += 1; | |
837 | TH1F *fHistModuleIdLayer6 = new TH1F("fHistModuleIdLayer6", | |
838 | "Module Id - Layer 6;Module Id;Entries", | |
839 | fgkSSDMODULESLAYER6, | |
840 | nModuleOffset+fgkSSDMODULESLAYER5 - 0.5, | |
841 | nITSTotalModules + 0.5); | |
842 | fAliITSQADataMakerRec->Add2RecPointsList(fHistModuleIdLayer6, | |
843 | fGenOffset + 1); | |
844 | fSSDhTask += 1; | |
845 | TH1F *fHistClusterPerEventLayer5 = new TH1F("fHistClusterPerEventLayer5", | |
846 | "N_{clusters} - Layer 5;N_{clusters};Entries;", | |
847 | 100,0.1,5000); | |
848 | fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterPerEventLayer5, | |
849 | fGenOffset + 2); | |
850 | fSSDhTask += 1; | |
851 | TH1F *fHistClusterPerEventLayer6 = new TH1F("fHistClusterPerEventLayer6", | |
852 | "N_{clusters} - Layer 6;N_{clusters};Entries;", | |
853 | 100,0.1,5000); | |
854 | fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterPerEventLayer6, | |
855 | fGenOffset + 3); | |
856 | fSSDhTask += 1; | |
857 | TH1F *fHistLocalXLayer5 = new TH1F("fHistLocalXLayer5", | |
858 | "Local x coord.- Layer 5;x [cm];Entries;", | |
859 | 100,-4.,4.); | |
860 | fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalXLayer5, | |
861 | fGenOffset + 4); | |
862 | fSSDhTask += 1; | |
863 | TH1F *fHistLocalXLayer6 = new TH1F("fHistLocalXLayer6", | |
864 | "Local x coord.- Layer 6;x [cm];Entries;", | |
865 | 100,-4.,4.); | |
866 | fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalXLayer6, | |
867 | fGenOffset + 5); | |
868 | fSSDhTask += 1; | |
869 | TH1F *fHistLocalZLayer5 = new TH1F("fHistLocalZLayer5", | |
870 | "Local z coord.- Layer 5;z [cm];Entries;", | |
871 | 100,-4.,4.); | |
872 | fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalZLayer5, | |
873 | fGenOffset + 6); | |
874 | fSSDhTask += 1; | |
875 | TH1F *fHistLocalZLayer6 = new TH1F("fHistLocalZLayer6", | |
876 | "Local z coord.- Layer 6;z [cm];Entries;", | |
877 | 100,-4.,4.); | |
878 | fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalZLayer6, | |
879 | fGenOffset + 7); | |
880 | fSSDhTask += 1; | |
881 | TH1F *fHistGlobalXLayer5 = new TH1F("fHistGlobalXLayer5", | |
882 | "Global x - Layer 5;x [cm];Entries;", | |
883 | 100,-40.,40.); | |
884 | fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalXLayer5, | |
885 | fGenOffset + 8); | |
886 | fSSDhTask += 1; | |
887 | TH1F *fHistGlobalXLayer6 = new TH1F("fHistGlobalXLayer6", | |
888 | "Global x - Layer 6;x [cm];Entries;", | |
889 | 100,-45.,45.); | |
890 | fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalXLayer6, | |
891 | fGenOffset + 9); | |
892 | fSSDhTask += 1; | |
893 | TH1F *fHistGlobalYLayer5 = new TH1F("fHistGlobalYLayer5", | |
894 | "Global y - Layer 5;y [cm];Entries;", | |
895 | 100,-40.,40); | |
896 | fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalYLayer5, | |
897 | fGenOffset + 10); | |
898 | fSSDhTask += 1; | |
899 | TH1F *fHistGlobalYLayer6 = new TH1F("fHistGlobalYLayer6", | |
900 | "Global y - Layer 6;y [cm];Entries;", | |
901 | 100,-45.,45.); | |
902 | fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalYLayer6, | |
903 | fGenOffset + 11); | |
904 | fSSDhTask += 1; | |
905 | TH1F *fHistGlobalZLayer5 = new TH1F("fHistGlobalZLayer5", | |
906 | "Global z - Layer 5;z [cm];Entries;", | |
907 | 100,-45.,45); | |
908 | fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalZLayer5, | |
909 | fGenOffset + 12); | |
910 | fSSDhTask += 1; | |
911 | TH1F *fHistGlobalZLayer6 = new TH1F("fHistGlobalZLayer6", | |
912 | "Global z - Layer 6;z [cm];Entries;", | |
913 | 100,-55.,55.); | |
914 | fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalZLayer6, | |
915 | fGenOffset + 13); | |
916 | fSSDhTask += 1; | |
917 | TH1F *fHistPhiLayer5 = new TH1F("fHistPhiLayer5", | |
918 | "#phi - Layer 5;#phi [rad];Entries;", | |
919 | 100,-TMath::Pi(),TMath::Pi()); | |
920 | fAliITSQADataMakerRec->Add2RecPointsList(fHistPhiLayer5, | |
921 | fGenOffset + 14); | |
922 | fSSDhTask += 1; | |
923 | TH1F *fHistPhiLayer6 = new TH1F("fHistPhiLayer6", | |
924 | "#phi - Layer 6;#phi [rad];Entries;", | |
925 | 100,-TMath::Pi(),TMath::Pi()); | |
926 | fAliITSQADataMakerRec->Add2RecPointsList(fHistPhiLayer6, | |
927 | fGenOffset + 15); | |
928 | fSSDhTask += 1; | |
929 | TH1F *fHistThetaLayer5 = new TH1F("fHistThetaLayer5", | |
930 | "#theta - Layer 5;#theta [rad];Entries;", | |
931 | 100,-TMath::Pi(),TMath::Pi()); | |
932 | fAliITSQADataMakerRec->Add2RecPointsList(fHistThetaLayer5, | |
933 | fGenOffset + 16); | |
934 | fSSDhTask += 1; | |
935 | TH1F *fHistThetaLayer6 = new TH1F("fHistThetaLayer6", | |
936 | "#theta - Layer 6;#theta [rad];Entries;", | |
937 | 100,-TMath::Pi(),TMath::Pi()); | |
938 | fAliITSQADataMakerRec->Add2RecPointsList(fHistThetaLayer6, | |
939 | fGenOffset + 17); | |
940 | fSSDhTask += 1; | |
941 | TH1F *fHistRadiusLayer5 = new TH1F("fHistRadiusLayer5", | |
942 | "r - Layer 5;r [cm];Entries;", | |
943 | 100,35.,50.); | |
944 | fAliITSQADataMakerRec->Add2RecPointsList(fHistRadiusLayer5, | |
945 | fGenOffset + 18); | |
946 | fSSDhTask += 1; | |
947 | TH1F *fHistRadiusLayer6 = new TH1F("fHistRadiusLayer6", | |
948 | "r - Layer 6;r [cm];Entries;", | |
949 | 100,35.,50.); | |
950 | fAliITSQADataMakerRec->Add2RecPointsList(fHistRadiusLayer6, | |
951 | fGenOffset + 19); | |
952 | fSSDhTask += 1; | |
953 | TH1F *fHistClusterTypeLayer5 = new TH1F("fHistClusterTypeLayer5", | |
954 | "CL type - Layer 5;Cluster type;Entries;", | |
955 | 150,0,150); | |
956 | fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterTypeLayer5, | |
957 | fGenOffset + 20); | |
958 | fSSDhTask += 1; | |
959 | TH1F *fHistClusterTypeLayer6 = new TH1F("fHistClusterTypeLayer6", | |
960 | "CL type - Layer 6;Cluster type;Entries;", | |
961 | 150,0,150); | |
962 | fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterTypeLayer6, | |
963 | fGenOffset + 21); | |
964 | fSSDhTask += 1; | |
965 | TH1F *fHistChargeRatioLayer5 = new TH1F("fHistChargeRatioLayer5", | |
966 | "Charge ratio - Layer 5;q_{ratio};Entries;", | |
967 | 100,-2.0,2.0); | |
968 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatioLayer5, | |
969 | fGenOffset + 22); | |
970 | fSSDhTask += 1; | |
971 | TH1F *fHistChargeRatioLayer6 = new TH1F("fHistChargeRatioLayer6", | |
972 | "Charge ratio - Layer 6;q_{ratio};Entries;", | |
973 | 100,-2.0,2.0); | |
974 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatioLayer6, | |
975 | fGenOffset + 23); | |
976 | fSSDhTask += 1; | |
977 | TH1F *fHistChargekeVLayer5 = new TH1F("fHistChargekeVLayer5", | |
978 | "Charge - Layer 5;q [keV];Entries;", | |
979 | 100,0.,300.); | |
980 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargekeVLayer5, | |
981 | fGenOffset + 24); | |
982 | fSSDhTask += 1; | |
983 | TH1F *fHistChargekeVLayer6 = new TH1F("fHistChargekeVLayer6", | |
984 | "Charge - Layer 6;q [keV];Entries;", | |
985 | 100,0.,300.); | |
986 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargekeVLayer6, | |
987 | fGenOffset + 25); | |
988 | fSSDhTask += 1; | |
989 | TH1F *fHistChargePSideLayer5 = new TH1F("fHistChargePSideLayer5", | |
990 | "Charge P- Layer 5;q_{P} [keV];Entries;", | |
991 | 100,0.,300.); | |
992 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePSideLayer5, | |
993 | fGenOffset + 26); | |
994 | fSSDhTask += 1; | |
995 | TH1F *fHistChargePSideLayer6 = new TH1F("fHistChargePSideLayer6", | |
996 | "Charge P- Layer 6;q_{P} [keV];Entries;", | |
997 | 100,0.,300.); | |
998 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePSideLayer6, | |
999 | fGenOffset + 27); | |
1000 | fSSDhTask += 1; | |
1001 | TH1F *fHistChargeNSideLayer5 = new TH1F("fHistChargeNSideLayer5", | |
1002 | "Charge N- Layer 5;q_{N} [keV];Entries;", | |
1003 | 100,0.,300.); | |
1004 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeNSideLayer5, | |
1005 | fGenOffset + 28); | |
1006 | fSSDhTask += 1; | |
1007 | TH1F *fHistChargeNSideLayer6 = new TH1F("fHistChargeNSideLayer6", | |
1008 | "Charge N- Layer 6;q_{N} [keV];Entries;", | |
1009 | 100,0.,300.); | |
1010 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeNSideLayer6, | |
1011 | fGenOffset + 29); | |
1012 | fSSDhTask += 1; | |
1013 | TH1F *fHistChargeRatio2Layer5 = new TH1F("fHistChargeRatio2Layer5", | |
1014 | "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;", | |
1015 | 100,0,2); | |
1016 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatio2Layer5, | |
1017 | fGenOffset + 30); | |
1018 | fSSDhTask += 1; | |
1019 | TH1F *fHistChargeRatio2Layer6 = new TH1F("fHistChargeRatio2Layer6", | |
1020 | "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;", | |
1021 | 100,0,2); | |
1022 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatio2Layer6, | |
1023 | fGenOffset + 31); | |
1024 | fSSDhTask += 1; | |
1025 | TH2F *fHistChargePNSideLayer5 = new TH2F("fHistChargePNSideLayer5", | |
1026 | "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]", | |
1027 | 100,0.,300., | |
1028 | 100,0.,300.); | |
1029 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePNSideLayer5, | |
1030 | fGenOffset + 32); | |
1031 | fSSDhTask += 1; | |
1032 | TH2F *fHistChargePNSideLayer6 = new TH2F("fHistChargePNSideLayer6", | |
1033 | "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]", | |
1034 | 100,0.,300., | |
1035 | 100,0.,300.); | |
1036 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePNSideLayer6, | |
1037 | fGenOffset + 33); | |
1038 | fSSDhTask += 1; | |
1039 | TH2F *fHistChargeMapLayer5 = new TH2F("fHistChargeMapLayer5", | |
1040 | "Charge map;N_{modules};N_{Ladders}", | |
1041 | fgkSSDMODULESPERLADDERLAYER5, | |
1042 | -0.5,fgkSSDMODULESPERLADDERLAYER5+0.5, | |
1043 | 3*fgkSSDLADDERSLAYER5, | |
1044 | -0.5,fgkSSDLADDERSLAYER5+0.5); | |
1045 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeMapLayer5, | |
1046 | fGenOffset + 34); | |
1047 | fSSDhTask += 1; | |
1048 | TH2F *fHistChargeMapLayer6 = new TH2F("fHistChargeMapLayer6", | |
1049 | "Charge map;N_{modules};N_{Ladders}", | |
1050 | fgkSSDMODULESPERLADDERLAYER6, | |
1051 | -0.5,fgkSSDMODULESPERLADDERLAYER6+0.5, | |
1052 | 3*fgkSSDLADDERSLAYER6, | |
1053 | -0.5,fgkSSDLADDERSLAYER6+0.5); | |
1054 | fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeMapLayer6, | |
1055 | fGenOffset + 35); | |
1056 | fSSDhTask += 1; | |
1057 | ||
1058 | AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhTask)); | |
1059 | } | |
1060 | ||
1061 | //____________________________________________________________________________ | |
1062 | void AliITSQASSDDataMakerRec::MakeRecPoints(TTree *clustersTree) | |
1063 | { | |
1064 | // Fill QA for recpoints - SSD - | |
1065 | ||
1066 | Int_t gLayer = 0, gLadder = 0, gModule = 0; | |
1067 | Int_t lLadderLocationY = 0; | |
1068 | TBranch *branchRecP = clustersTree->GetBranch("ITSRecPoints"); | |
1069 | if (!branchRecP) { | |
1070 | AliError("can't get the branch with the ITS clusters !"); | |
1071 | return; | |
1072 | } | |
1073 | static TClonesArray statRecpoints("AliITSRecPoint"); | |
1074 | TClonesArray *recpoints = &statRecpoints; | |
1075 | branchRecP->SetAddress(&recpoints); | |
1076 | Int_t nClustersLayer5 = 0, nClustersLayer6 = 0; | |
1077 | Int_t npoints = 0; | |
1078 | Float_t cluglo[3]={0.,0.,0.}; | |
1079 | for(Int_t module = 0; module < clustersTree->GetEntries(); module++){ | |
1080 | branchRecP->GetEvent(module); | |
1081 | npoints += recpoints->GetEntries(); | |
1082 | AliITSgeomTGeo::GetModuleId(module,gLayer,gLadder,gModule); | |
1083 | lLadderLocationY = 3*gLadder; | |
1084 | ||
1085 | for(Int_t j = 0;j < recpoints->GetEntries(); j++){ | |
1086 | AliITSRecPoint *recp = (AliITSRecPoint*)recpoints->At(j); | |
1087 | Int_t layer = recp->GetLayer(); | |
1088 | recp->GetGlobalXYZ(cluglo); | |
1089 | Float_t radius = TMath::Sqrt(cluglo[0]*cluglo[0]+cluglo[1]*cluglo[1]); | |
1090 | Float_t phi = TMath::ATan2(cluglo[1],cluglo[0]); | |
1091 | Float_t theta = TMath::ATan2(radius,cluglo[2]); | |
1092 | Double_t chargeRatio = recp->GetChargeRatio(); | |
1093 | Double_t clusterCharge = recp->GetQ(); | |
1094 | Double_t chargePSide = clusterCharge*(1. + chargeRatio); | |
1095 | Double_t chargeNSide = clusterCharge*(1. - chargeRatio); | |
1096 | if(layer == 4) { | |
1097 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 0)->Fill(module); | |
1098 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 4)->Fill(recp->GetDetLocalX()); | |
1099 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 6)->Fill(recp->GetDetLocalZ()); | |
1100 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 8)->Fill(cluglo[0]); | |
1101 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 10)->Fill(cluglo[1]); | |
1102 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 12)->Fill(cluglo[2]); | |
1103 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 14)->Fill(phi); | |
1104 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 16)->Fill(theta); | |
1105 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 18)->Fill(radius); | |
1106 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 20)->Fill(recp->GetType()); | |
1107 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 22)->Fill(recp->GetChargeRatio()); | |
1108 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 24)->Fill(recp->GetQ()); | |
1109 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 26)->Fill(chargePSide); | |
1110 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 28)->Fill(chargeNSide); | |
1111 | if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 30)->Fill(chargeNSide/chargePSide); | |
1112 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 32)->Fill(chargePSide,chargeNSide); | |
1113 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 34)->SetBinContent(gModule,lLadderLocationY,recp->GetQ()); | |
1114 | nClustersLayer5 += 1; | |
1115 | }//layer 5 histograms | |
1116 | if(layer == 5) { | |
1117 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 1)->Fill(module); | |
1118 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 5)->Fill(recp->GetDetLocalX()); | |
1119 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 7)->Fill(recp->GetDetLocalZ()); | |
1120 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 9)->Fill(cluglo[0]); | |
1121 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 11)->Fill(cluglo[1]); | |
1122 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 13)->Fill(cluglo[2]); | |
1123 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 15)->Fill(phi); | |
1124 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 17)->Fill(theta); | |
1125 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 19)->Fill(radius); | |
1126 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 21)->Fill(recp->GetType()); | |
1127 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 23)->Fill(recp->GetChargeRatio()); | |
1128 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 25)->Fill(recp->GetQ()); | |
1129 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 27)->Fill(chargePSide); | |
1130 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 29)->Fill(chargeNSide); | |
1131 | if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 31)->Fill(chargeNSide/chargePSide); | |
1132 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 33)->Fill(chargePSide,chargeNSide); | |
1133 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 35)->SetBinContent(gModule,lLadderLocationY,recp->GetQ()); | |
1134 | nClustersLayer6 += 1; | |
1135 | }//layer 6 histograms | |
1136 | }//rec. points loop | |
1137 | }//module loop | |
1138 | ||
1139 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 2)->Fill(nClustersLayer5); | |
1140 | fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 3)->Fill(nClustersLayer6); | |
1141 | ||
1142 | statRecpoints.Clear(); | |
1143 | } | |
1144 |