]>
Commit | Line | Data |
---|---|---|
6c1053a8 | 1 | /************************************************************************** |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | //////////////////////////////////////////////////////////////////////////// | |
17 | // // | |
18 | // AliTRDCalibChamberStatus: to determine which half chambers are off // | |
19 | // Produce a AliTRDCalChamberStatus calibration object // | |
d6a1ec13 | 20 | // Check with the AliTRDCalDCSFEEv2 info // |
6c1053a8 | 21 | // // |
22 | // // | |
23 | // Authors: // | |
24 | // J. Book (jbook@ikf.uni-frankfurt.de) // | |
25 | // R. Bailhache (rbailhache@ikf.uni-frankfurt.de) // | |
26 | // // | |
27 | //////////////////////////////////////////////////////////////////////////// | |
28 | ||
29 | ||
30 | //Root includes | |
31 | #include <THnSparse.h> | |
32 | ||
33 | #include <TDirectory.h> | |
34 | #include <TFile.h> | |
fd50bb14 | 35 | #include <TAxis.h> |
36 | #include <TH2F.h> | |
37 | #include <TStyle.h> | |
38 | #include <TCanvas.h> | |
6c1053a8 | 39 | |
40 | //AliRoot includes | |
41 | #include "AliRawReader.h" | |
42 | ||
43 | //header file | |
44 | #include "AliLog.h" | |
45 | #include "AliTRDCalibChamberStatus.h" | |
46 | #include "AliTRDgeometry.h" | |
fd50bb14 | 47 | #include "AliTRDfeeParam.h" |
6c1053a8 | 48 | #include "AliTRDdigitsManager.h" |
49 | #include "AliTRDSignalIndex.h" | |
fd50bb14 | 50 | #include "AliTRDpadPlane.h" |
6c1053a8 | 51 | #include "./Cal/AliTRDCalChamberStatus.h" |
d6a1ec13 | 52 | #include "./Cal/AliTRDCalDCSv2.h" |
53 | #include "./Cal/AliTRDCalDCSFEEv2.h" | |
6c1053a8 | 54 | |
fd50bb14 | 55 | #include "AliTRDrawStream.h" |
b2277aa2 | 56 | #include "AliTRDseedV1.h" |
57 | #include "AliTRDcluster.h" | |
fd50bb14 | 58 | |
6c1053a8 | 59 | #ifdef ALI_DATE |
60 | #include "event.h" | |
61 | #endif | |
62 | ||
63 | ClassImp(AliTRDCalibChamberStatus) /*FOLD00*/ | |
64 | ||
65 | //_____________________________________________________________________ | |
66 | AliTRDCalibChamberStatus::AliTRDCalibChamberStatus() : /*FOLD00*/ | |
67 | TObject(), | |
68 | fDetector(-1), | |
69 | fNumberOfTimeBins(0), | |
70 | fCounterEventNotEmpty(0), | |
71 | fCalChamberStatus(0x0), | |
72 | fHnSparseI(0x0), | |
73 | fHnSparseHCM(0x0), | |
74 | fHnSparseEvtDet(0x0), | |
75 | fHnSparseDebug(0x0), | |
76 | fHnSparseMCM(0x0), | |
fd50bb14 | 77 | fC1(0x0), |
6c1053a8 | 78 | fDebugLevel(0) |
79 | { | |
80 | // | |
81 | // default constructor | |
82 | // | |
83 | ||
84 | } | |
85 | //_____________________________________________________________________ | |
86 | AliTRDCalibChamberStatus::AliTRDCalibChamberStatus(const AliTRDCalibChamberStatus &ped) : /*FOLD00*/ | |
87 | TObject(ped), | |
88 | fDetector(ped.fDetector), | |
89 | fNumberOfTimeBins(ped.fNumberOfTimeBins), | |
90 | fCounterEventNotEmpty(ped.fCounterEventNotEmpty), | |
91 | fCalChamberStatus(ped.fCalChamberStatus), | |
92 | fHnSparseI(ped.fHnSparseI), | |
93 | fHnSparseHCM(ped.fHnSparseHCM), | |
94 | fHnSparseEvtDet(ped.fHnSparseEvtDet), | |
95 | fHnSparseDebug(ped.fHnSparseDebug), | |
96 | fHnSparseMCM(ped.fHnSparseMCM), | |
fd50bb14 | 97 | fC1(ped.fC1), |
6c1053a8 | 98 | fDebugLevel(ped.fDebugLevel) |
99 | { | |
100 | // | |
101 | // copy constructor | |
102 | // | |
103 | ||
104 | } | |
105 | //_____________________________________________________________________ | |
106 | AliTRDCalibChamberStatus& AliTRDCalibChamberStatus::operator = (const AliTRDCalibChamberStatus &source) | |
107 | { | |
108 | // | |
109 | // assignment operator | |
110 | // | |
111 | if (&source == this) return *this; | |
112 | new (this) AliTRDCalibChamberStatus(source); | |
113 | ||
114 | return *this; | |
115 | } | |
116 | //_____________________________________________________________________ | |
117 | AliTRDCalibChamberStatus::~AliTRDCalibChamberStatus() /*FOLD00*/ | |
118 | { | |
119 | // | |
120 | // destructor | |
121 | // | |
122 | if(fCalChamberStatus){ | |
123 | delete fCalChamberStatus; | |
124 | } | |
125 | if(fHnSparseI) { | |
126 | delete fHnSparseI; | |
127 | } | |
128 | if(fHnSparseHCM) { | |
129 | delete fHnSparseHCM; | |
130 | } | |
131 | if(fHnSparseEvtDet) { | |
132 | delete fHnSparseEvtDet; | |
133 | } | |
134 | if(fHnSparseDebug) { | |
135 | delete fHnSparseDebug; | |
136 | } | |
137 | if(fHnSparseMCM) { | |
138 | delete fHnSparseMCM; | |
fd50bb14 | 139 | } |
140 | if(fC1) { | |
141 | delete fC1; | |
142 | } | |
6c1053a8 | 143 | } |
144 | ||
145 | //_____________________________________________________________________ | |
146 | void AliTRDCalibChamberStatus::Init() | |
147 | { | |
148 | // | |
149 | // Init the different THnSparse | |
150 | // | |
151 | // | |
152 | ||
153 | // | |
154 | // Init the fHnSparseI | |
155 | // | |
156 | ||
157 | //create the map | |
158 | Int_t thnDimEvt[4]; // sm, layer, stack, halfchamber | |
159 | thnDimEvt[0] = 18; | |
160 | thnDimEvt[1] = 6; | |
161 | thnDimEvt[2] = 5; | |
162 | thnDimEvt[3] = 2; | |
163 | //arrays for lower bounds : | |
164 | Double_t* binEdgesEvt[4]; | |
165 | for(Int_t ivar = 0; ivar < 4; ivar++) | |
166 | binEdgesEvt[ivar] = new Double_t[thnDimEvt[ivar] + 1]; | |
167 | //values for bin lower bounds | |
168 | for(Int_t i=0; i<=thnDimEvt[0]; i++) binEdgesEvt[0][i]= 0.0 + (18.0)/thnDimEvt[0]*(Double_t)i; | |
169 | for(Int_t i=0; i<=thnDimEvt[1]; i++) binEdgesEvt[1][i]= 0.0 + (6.0)/thnDimEvt[1]*(Double_t)i; | |
170 | for(Int_t i=0; i<=thnDimEvt[2]; i++) binEdgesEvt[2][i]= 0.0 + (5.0)/thnDimEvt[2]*(Double_t)i; | |
171 | for(Int_t i=0; i<=thnDimEvt[3]; i++) binEdgesEvt[3][i]= 0.0 + (2.0)/thnDimEvt[3]*(Double_t)i; | |
172 | ||
173 | //create the THnSparse | |
174 | fHnSparseI = new THnSparseI("NumberOfEntries","NumberOfEntries",4,thnDimEvt); | |
175 | for (int k=0; k<4; k++) { | |
176 | fHnSparseI->SetBinEdges(k,binEdgesEvt[k]); | |
177 | } | |
178 | fHnSparseI->Sumw2(); | |
179 | ||
180 | // | |
181 | // Init the fHnSparseHCM (THnSparseI) | |
182 | // | |
183 | ||
184 | //create the THnSparse | |
185 | fHnSparseHCM = new THnSparseI("HCMerrors","HCMerrors",4,thnDimEvt); | |
186 | for (int k=0; k<4; k++) { | |
187 | fHnSparseHCM->SetBinEdges(k,binEdgesEvt[k]); | |
188 | } | |
189 | fHnSparseHCM->Sumw2(); | |
190 | ||
191 | ||
192 | //---------// | |
193 | // Debug // | |
194 | if(fDebugLevel > 0) { | |
195 | ||
196 | // | |
197 | // Init the fHnSparseEvtDet (THnSparseI) | |
198 | // | |
199 | ||
200 | //create the map | |
201 | Int_t thnDimEvts[3]; // event, detector, halfchamber | |
202 | thnDimEvts[0] = 10000; | |
203 | thnDimEvts[1] = 540; | |
204 | thnDimEvts[2] = 2; | |
205 | //arrays for lower bounds : | |
206 | Double_t* binEdgesEvts[3]; | |
207 | for(Int_t ivar = 0; ivar < 3; ivar++) | |
208 | binEdgesEvts[ivar] = new Double_t[thnDimEvts[ivar] + 1]; | |
209 | //values for bin lower bounds | |
210 | for(Int_t i=0; i<=thnDimEvts[0]; i++) binEdgesEvts[0][i]= 0.0 + (10000.0)/thnDimEvts[0]*(Double_t)i; | |
211 | for(Int_t i=0; i<=thnDimEvts[1]; i++) binEdgesEvts[1][i]= 0.0 + (540.0)/thnDimEvts[1]*(Double_t)i; | |
212 | for(Int_t i=0; i<=thnDimEvts[2]; i++) binEdgesEvts[2][i]= 0.0 + (2.0)/thnDimEvts[2]*(Double_t)i; | |
213 | ||
214 | //create the THnSparse | |
215 | fHnSparseEvtDet = new THnSparseI("NumberOfEntriesPerEvent","NumberOfEntriesPerEvent",3,thnDimEvts); | |
216 | for (int k=0; k<3; k++) { | |
217 | fHnSparseEvtDet->SetBinEdges(k,binEdgesEvts[k]); | |
218 | } | |
219 | fHnSparseEvtDet->Sumw2(); | |
220 | ||
221 | // | |
222 | // Init the fHnSparseDebug (THnSparseI) | |
223 | // | |
224 | ||
225 | //create the THnSparse | |
226 | fHnSparseDebug = new THnSparseI("NumberOfDifferentDecisions","NumberOfDifferentDecisions",4,thnDimEvt); | |
227 | for (int k=0; k<4; k++) { | |
228 | fHnSparseDebug->SetBinEdges(k,binEdgesEvt[k]); | |
229 | } | |
230 | fHnSparseDebug->Sumw2(); | |
231 | ||
232 | // | |
233 | // Init the fHnSparseMCM (THnSparseI) | |
234 | // | |
235 | ||
236 | //create the map | |
237 | Int_t thnDimEvtt[6]; // sm, layer, stack, ROB, MCM | |
238 | thnDimEvtt[0] = 18; | |
239 | thnDimEvtt[1] = 6; | |
240 | thnDimEvtt[2] = 5; | |
241 | thnDimEvtt[3] = 8; | |
fd50bb14 | 242 | thnDimEvtt[4] = 18; |
243 | thnDimEvtt[5] = 18; | |
6c1053a8 | 244 | //arrays for lower bounds : |
245 | Double_t* binEdgesEvtt[6]; | |
246 | for(Int_t ivar = 0; ivar < 6; ivar++) | |
247 | binEdgesEvtt[ivar] = new Double_t[thnDimEvtt[ivar] + 1]; | |
248 | //values for bin lower bounds | |
249 | for(Int_t i=0; i<=thnDimEvtt[0]; i++) binEdgesEvtt[0][i]= 0.0 + (18.0)/thnDimEvtt[0]*(Double_t)i; | |
250 | for(Int_t i=0; i<=thnDimEvtt[1]; i++) binEdgesEvtt[1][i]= 0.0 + (6.0)/thnDimEvtt[1]*(Double_t)i; | |
251 | for(Int_t i=0; i<=thnDimEvtt[2]; i++) binEdgesEvtt[2][i]= 0.0 + (5.0)/thnDimEvtt[2]*(Double_t)i; | |
252 | for(Int_t i=0; i<=thnDimEvtt[3]; i++) binEdgesEvtt[3][i]= 0.0 + (8.0)/thnDimEvtt[3]*(Double_t)i; | |
fd50bb14 | 253 | for(Int_t i=0; i<=thnDimEvtt[4]; i++) binEdgesEvtt[4][i]= 0.0 + (18.0)/thnDimEvtt[4]*(Double_t)i; |
254 | for(Int_t i=0; i<=thnDimEvtt[5]; i++) binEdgesEvtt[5][i]= 0.0 + (18.0)/thnDimEvtt[5]*(Double_t)i; | |
6c1053a8 | 255 | |
256 | //create the THnSparse | |
257 | fHnSparseMCM = new THnSparseI("MCMerrorDCS","MCMerrorDCS",6,thnDimEvtt); | |
258 | for (int k=0; k<6; k++) { | |
259 | fHnSparseMCM->SetBinEdges(k,binEdgesEvtt[k]); | |
260 | } | |
261 | fHnSparseMCM->Sumw2(); | |
262 | ||
263 | } | |
264 | // Debug // | |
265 | //---------// | |
266 | ||
b2277aa2 | 267 | } |
268 | //_____________________________________________________________________ | |
92df0132 | 269 | void AliTRDCalibChamberStatus::ProcessTrack(const AliTRDtrackV1 * trdTrack) |
b2277aa2 | 270 | { |
271 | // | |
272 | // Track Processing to get half chamber status | |
273 | // | |
274 | // | |
275 | ||
276 | ||
277 | const AliTRDseedV1 *tracklet = 0x0; | |
278 | AliTRDcluster *cluster; | |
279 | ////////////////////////////////////// | |
280 | // Loop tracklets | |
281 | ///////////////////////////////////// | |
282 | for(Int_t itr = 0; itr < 6; ++itr){ | |
283 | ||
284 | if(!(tracklet = trdTrack->GetTracklet(itr))) continue; | |
285 | if(!tracklet->IsOK()) continue; | |
286 | ||
287 | // Loop on clusters | |
288 | for(int ic=0; ic<AliTRDseedV1::kNtb; ++ic){ | |
289 | if((cluster = tracklet->GetClusters(ic))) { | |
290 | //printf("ic %d\n",ic); | |
291 | break; | |
292 | } | |
293 | } | |
294 | if(!cluster) continue; | |
295 | ||
296 | Int_t det = cluster->GetDetector(); | |
297 | Int_t layer = AliTRDgeometry::GetLayer(det); | |
298 | Int_t sm = AliTRDgeometry::GetSector(det); | |
299 | Int_t stac = AliTRDgeometry::GetStack(det); | |
300 | ||
301 | Int_t col = cluster->GetPadCol(); | |
302 | Int_t iMcm = (Int_t)(col/18); // current group of 18 col pads | |
303 | Double_t rphi = 0.5; | |
304 | if(iMcm > 3) rphi = 1.5; | |
305 | ||
306 | Double_t val[4] = {sm,layer,stac,rphi}; | |
307 | if(fHnSparseI->GetBinContent((const Int_t*)val)<2147483646) fHnSparseI->Fill(&val[0]); | |
308 | } | |
309 | ||
6c1053a8 | 310 | } |
311 | //_____________________________________________________________________ | |
312 | void AliTRDCalibChamberStatus::ProcessEvent(AliRawReader * rawReader, Int_t nevents_physics) | |
fd50bb14 | 313 | { |
314 | // | |
315 | // Event Processing loop with AliTRDrawStream | |
316 | // | |
317 | // | |
318 | ||
319 | Bool_t notEmpty = kFALSE; | |
320 | ||
321 | AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager(kTRUE); | |
322 | digitsManager->CreateArrays(); | |
323 | ||
324 | AliTRDrawStream *rawStream = new AliTRDrawStream(rawReader); | |
325 | rawStream->SetDigitsManager(digitsManager); | |
326 | // rawStream->SetNoErrorWarning(); | |
327 | // rawStream->SetSharedPadReadout(kFALSE); | |
328 | ||
329 | ||
6c1053a8 | 330 | Int_t det = 0; |
331 | while ((det = rawStream->NextChamber(digitsManager, NULL, NULL)) >= 0) { | |
332 | ||
333 | //nextchamber loop | |
334 | ||
335 | // do the QA analysis | |
336 | if (digitsManager->GetIndexes(det)->HasEntry()) {//QA | |
337 | // printf("there is ADC data on this chamber!\n"); | |
338 | ||
339 | AliTRDSignalIndex *indexes = digitsManager->GetIndexes(det); | |
340 | if (indexes->IsAllocated() == kFALSE) { | |
341 | // AliError("Indexes do not exist!"); | |
342 | break; | |
343 | } | |
344 | ||
345 | Int_t iRow = 0; | |
346 | Int_t iCol = 0; | |
347 | indexes->ResetCounters(); | |
348 | ||
349 | while (indexes->NextRCIndex(iRow, iCol)){ | |
350 | Int_t iMcm = (Int_t)(iCol/18); // current group of 18 col pads | |
351 | ||
352 | Int_t layer = AliTRDgeometry::GetLayer(det); | |
353 | Int_t sm = AliTRDgeometry::GetSector(det); | |
354 | Int_t stac = AliTRDgeometry::GetStack(det); | |
355 | Double_t rphi = 0.5; | |
356 | if(iMcm > 3) rphi = 1.5; | |
357 | ||
358 | Double_t val[4] = {sm,layer,stac,rphi}; | |
359 | fHnSparseI->Fill(&val[0]); | |
360 | notEmpty = kTRUE; | |
361 | ||
362 | //---------// | |
363 | // Debug // | |
364 | if(fDebugLevel > 0) { | |
365 | Int_t detector = AliTRDgeometry::GetDetector(layer,stac,sm); | |
366 | Double_t valu[3] = {nevents_physics,detector,rphi}; | |
367 | fHnSparseEvtDet->Fill(&valu[0]); | |
368 | } | |
369 | // Debug // | |
370 | //---------// | |
371 | } | |
372 | ||
373 | } | |
374 | digitsManager->ClearArrays(det); | |
375 | } | |
376 | ||
377 | if(notEmpty) fCounterEventNotEmpty++; | |
378 | ||
a987273c | 379 | delete digitsManager; |
fdc15553 | 380 | delete rawStream; |
6c1053a8 | 381 | |
382 | } | |
383 | //_____________________________________________________________________ | |
384 | Bool_t AliTRDCalibChamberStatus::TestEventHisto(Int_t nevent) /*FOLD00*/ | |
385 | { | |
386 | // | |
387 | // Test event loop | |
388 | // fill the fHnSparseI with entries | |
389 | // | |
390 | ||
391 | AliTRDgeometry geo; | |
392 | ||
393 | ||
394 | for(Int_t ievent=0; ievent<nevent; ievent++){ | |
395 | for (Int_t ism=0; ism<18; ism++){ | |
396 | for (Int_t istack=0; istack<5; istack++){ | |
397 | for (Int_t ipl=0; ipl<6; ipl++){ | |
398 | for (Int_t icol=0; icol<geo.GetColMax(ipl); icol++){ | |
399 | Int_t side = 0; | |
400 | if(icol > 72) side = 1; | |
401 | Double_t val[4] = {ism,ipl,istack,side}; | |
402 | fHnSparseI->Fill(&val[0]); | |
403 | } | |
404 | } | |
405 | } | |
406 | } | |
407 | } | |
408 | ||
409 | return kTRUE; | |
410 | ||
411 | } | |
412 | //_____________________________________________________________________ | |
17aa2935 | 413 | void AliTRDCalibChamberStatus::AnalyseHisto(Int_t limit, Double_t chamberlimit) /*FOLD00*/ |
6c1053a8 | 414 | { |
fd50bb14 | 415 | // |
416 | // Create the AliTRDCalChamberStatus according to the fHnSparseI | |
417 | // | |
418 | ||
6c1053a8 | 419 | if(fCalChamberStatus) delete fCalChamberStatus; |
420 | fCalChamberStatus = new AliTRDCalChamberStatus(); | |
421 | ||
7e302ca9 | 422 | //printf("test0\n"); |
423 | ||
b2277aa2 | 424 | // Check if enough events/tracklets per halfchamber to say something |
425 | Double_t mean=0.0; //number of tracklets per HCS | |
426 | Int_t coord2[4]; | |
427 | for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) { | |
428 | //if(fHnSparseI->GetBinContent(bin,coord2)==0.0) printf(" bin shouldnt be empty!!\n"); | |
429 | mean+=fHnSparseI->GetBinContent(bin,coord2); | |
430 | } | |
7e302ca9 | 431 | if(fHnSparseI->GetNbins() > 0.0) mean/=fHnSparseI->GetNbins(); |
17aa2935 | 432 | //printf(" mean tracklets per halfchamber %.3e \n",mean); |
b2277aa2 | 433 | if((fCounterEventNotEmpty < limit) && (mean < limit)) { |
434 | // Say all good | |
435 | for (Int_t idet=0; idet<540; idet++) { | |
436 | fCalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kGood); | |
6c1053a8 | 437 | } |
438 | return; | |
439 | } | |
440 | ||
7e302ca9 | 441 | //printf("test1\n"); |
442 | ||
b2277aa2 | 443 | // set all chambers to NoData |
444 | for (Int_t idet=0; idet<540; idet++) { | |
445 | fCalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kNoData); | |
6c1053a8 | 446 | } |
447 | ||
b2277aa2 | 448 | // set status according to fHnSparseI |
6c1053a8 | 449 | Int_t coord[4]; |
450 | for(Int_t bin = 0; bin < fHnSparseI->GetNbins(); bin++) { | |
451 | ||
17aa2935 | 452 | Double_t content = fHnSparseI->GetBinContent(bin,coord); |
453 | ||
454 | // layer, stack, sector | |
6c1053a8 | 455 | Int_t detector = AliTRDgeometry::GetDetector(coord[1]-1,coord[2]-1,coord[0]-1); |
17aa2935 | 456 | |
457 | if(content<chamberlimit*mean) { | |
458 | //printf("Number of entries for detector %03d-%s: %.3e -> %.3f \n",detector,(coord[3]-1==0?"A":"B"),content,content/mean); | |
459 | continue; | |
460 | } | |
6c1053a8 | 461 | // |
462 | // Check which halfchamber side corresponds to the bin number (0=A, 1=B) | |
463 | // Change the status accordingly | |
464 | // | |
b2277aa2 | 465 | if(coord[3]-1==0) { // HCS-A |
466 | fCalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood); | |
467 | fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoDataHalfChamberSideA); // A has data | |
468 | //fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoData); | |
469 | } | |
470 | else { //HCS-B | |
471 | fCalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kGood); | |
472 | fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoDataHalfChamberSideB); // B has data | |
473 | //fCalChamberStatus->UnsetStatusBit(detector,AliTRDCalChamberStatus::kNoData); | |
474 | } | |
6c1053a8 | 475 | } |
476 | ||
b2277aa2 | 477 | // printf |
478 | //for (Int_t idet=0; idet<540; idet++) { | |
479 | // if(fCalChamberStatus->IsNoData(idet)) printf("No Data: chamber %d\n",idet); | |
480 | //} | |
481 | ||
6c1053a8 | 482 | |
483 | } | |
484 | //_____________________________________________________________________ | |
92df0132 | 485 | void AliTRDCalibChamberStatus::CheckEORStatus(const AliTRDCalDCSv2 *calDCS) /*FOLD00*/ |
6c1053a8 | 486 | { |
487 | // | |
d6a1ec13 | 488 | // Correct the AliTRDCalChamberStatus according to the AliTRDCalDCSv2 |
6c1053a8 | 489 | // Using globale state of the HalfChamberMerger (HCM) |
490 | // | |
6c1053a8 | 491 | for(Int_t det = 0; det < 540; det++) { |
d6a1ec13 | 492 | AliTRDCalDCSFEEv2* calDCSFEEEOR = calDCS->GetCalDCSFEEObj(det); |
fd50bb14 | 493 | |
494 | if(!calDCSFEEEOR) continue; | |
6c1053a8 | 495 | |
496 | // MCM Global State Machine State Definitions | |
497 | // low_power = 0, | |
498 | // test = 1, | |
499 | // wait_pre = 3, | |
500 | // preproc = 7, | |
501 | // zero_sp = 8, | |
502 | // full_rd = 9, | |
503 | // clear_st = 11, | |
504 | // wait_L1 = 12, | |
505 | // tr_send = 14, | |
506 | // tr_proc = 15 | |
507 | ||
508 | Int_t sm = AliTRDgeometry::GetSector(det); | |
509 | Int_t lay = AliTRDgeometry::GetLayer(det); | |
510 | Int_t stac = AliTRDgeometry::GetStack(det); | |
511 | ||
fd50bb14 | 512 | Int_t stateA = 0; // 0=bad, 1=good state |
513 | Int_t stateB = 0; | |
514 | ||
515 | // loop over all mcm to define DCS-HCS | |
516 | for(Int_t ii = 0; ii < 8; ii++) { //ROB loop | |
517 | for(Int_t i = 0; i < 18; i++) { //MCM loop | |
518 | ||
519 | Int_t side = ii%2; // 0=sideA, 1=sideB | |
520 | Int_t cstate = calDCSFEEEOR->GetMCMGlobalState(ii,i); //current mcm state | |
521 | ||
522 | if(cstate==3) { | |
523 | switch(side) { | |
524 | case 0: stateA=1; break; | |
525 | case 1: stateB=1; break; | |
526 | } | |
527 | } | |
528 | } | |
529 | } | |
1a278748 | 530 | |
6c1053a8 | 531 | //---------// |
532 | // Debug // | |
533 | if(fDebugLevel > 0) { | |
fd50bb14 | 534 | if( ((fCalChamberStatus->GetStatus(det) <= 1) && (stateA==0 || stateB==0)) || |
535 | ((fCalChamberStatus->GetStatus(det) == 2) && (stateA==1 || stateB==1)) || | |
536 | ((fCalChamberStatus->GetStatus(det) == 3) && (stateA==1 || stateB==0)) || | |
537 | ((fCalChamberStatus->GetStatus(det) == 4) && (stateB==0 || stateB==1)) ) | |
6c1053a8 | 538 | { |
539 | //printf(" Different half chamber status in DCS and DATA!!\n"); | |
540 | Double_t val[4] = {sm,lay,stac,1}; | |
541 | fHnSparseDebug->Fill(&val[0]); | |
542 | ||
fd50bb14 | 543 | // Fill MCM status map |
544 | for(Int_t ii = 0; ii < 8; ii++) { //ROB loop | |
545 | for(Int_t i = 0; i < 18; i++) { //MCM loop | |
546 | Double_t valss[6] = {sm,lay,stac,ii,i | |
547 | ,calDCSFEEEOR->GetMCMGlobalState(ii,i)}; | |
548 | fHnSparseMCM->Fill(&valss[0]); | |
549 | ||
6c1053a8 | 550 | } |
551 | } | |
552 | } | |
553 | } | |
554 | //---------// | |
555 | // Debug // | |
1a278748 | 556 | |
fd50bb14 | 557 | //--------------------------------------- |
1a278748 | 558 | // Change the status according to DCS |
fd50bb14 | 559 | //--------------------------------------- |
92df0132 | 560 | Int_t statusData = fCalChamberStatus->GetStatus(det); |
561 | switch(statusData) | |
fd50bb14 | 562 | { |
563 | case 1: | |
564 | if(stateA==0 && stateB==0) fCalChamberStatus->SetStatus(det,2); // completely masked from DCS | |
565 | if(stateA==1 && stateB==0) fCalChamberStatus->SetStatus(det,4); // Only B side masked from DCS | |
566 | if(stateA==0 && stateB==1) fCalChamberStatus->SetStatus(det,3); // Only A side masked from DCS | |
567 | if(stateA==1 && stateB==1) fCalChamberStatus->SetStatus(det,1); | |
568 | break; | |
569 | case 2: // completely masked from DATA | |
570 | if(stateA==0 && stateB==0) fCalChamberStatus->SetStatus(det,2); // completely masked from DCS | |
571 | break; | |
572 | case 3: // Only A side masked from DATA | |
573 | if(stateA==0 && stateB==0) fCalChamberStatus->SetStatus(det,2); // completely masked from DCS | |
574 | if(stateA==1 && stateB==0) fCalChamberStatus->SetStatus(det,2); // Only B side masked from DCS | |
575 | if(stateA==0 && stateB==1) fCalChamberStatus->SetStatus(det,3); // Only A side masked from DCS | |
576 | if(stateA==1 && stateB==1) fCalChamberStatus->SetStatus(det,3); | |
577 | break; | |
578 | case 4: // Only B side masked from DATA | |
579 | if(stateA==0 && stateB==0) fCalChamberStatus->SetStatus(det,2); // completely masked from DCS | |
580 | if(stateA==1 && stateB==0) fCalChamberStatus->SetStatus(det,4); // Only B side masked from DCS | |
581 | if(stateA==0 && stateB==1) fCalChamberStatus->SetStatus(det,2); // Only A side masked from DCS | |
582 | if(stateA==1 && stateB==1) fCalChamberStatus->SetStatus(det,4); | |
583 | break; | |
1a278748 | 584 | } |
1a278748 | 585 | |
6c1053a8 | 586 | } |
587 | ||
588 | } | |
589 | ||
590 | //_____________________________________________________________________________________ | |
92df0132 | 591 | void AliTRDCalibChamberStatus::Add(const AliTRDCalibChamberStatus *calibChamberStatus) /*FOLD00*/ |
6c1053a8 | 592 | { |
593 | // | |
594 | // Add the THnSparseI of this calibChamberStatus | |
595 | // | |
596 | ||
597 | fCounterEventNotEmpty += calibChamberStatus->GetNumberEventNotEmpty(); | |
598 | ||
599 | THnSparseI *hnSparseI = calibChamberStatus->GetSparseI(); | |
600 | if(!hnSparseI) return; | |
601 | ||
602 | if(!fHnSparseI) { | |
603 | fHnSparseI = (THnSparseI *) hnSparseI->Clone(); | |
604 | } | |
605 | else { | |
606 | fHnSparseI->Add(hnSparseI); | |
607 | } | |
608 | ||
609 | ||
610 | } | |
611 | //_____________________________________________________________________ | |
612 | void AliTRDCalibChamberStatus::DumpToFile(const Char_t *filename, const Char_t *dir, Bool_t append) /*FOLD00*/ | |
613 | { | |
614 | // | |
615 | // Write class to file | |
616 | // | |
617 | ||
618 | TString sDir(dir); | |
619 | TString option; | |
620 | ||
621 | if ( append ) | |
622 | option = "update"; | |
623 | else | |
624 | option = "recreate"; | |
625 | ||
626 | TDirectory *backup = gDirectory; | |
627 | TFile f(filename,option.Data()); | |
628 | f.cd(); | |
629 | if ( !sDir.IsNull() ){ | |
630 | f.mkdir(sDir.Data()); | |
631 | f.cd(sDir); | |
632 | } | |
633 | this->Write(); | |
634 | f.Close(); | |
635 | ||
636 | if ( backup ) backup->cd(); | |
637 | } | |
fd50bb14 | 638 | //_____________________________________________________________________________ |
639 | TH2D* AliTRDCalibChamberStatus::PlotSparseI(Int_t sm,Int_t side) | |
640 | { | |
641 | // | |
642 | // Plot number of entries for supermodule sm | |
643 | // as a function of layer and stack | |
644 | // | |
645 | ||
646 | if(!fHnSparseI) return 0x0; | |
647 | ||
648 | fHnSparseI->GetAxis(0)->SetRange(sm+1,sm+1); | |
649 | fHnSparseI->GetAxis(3)->SetRange(side+1,side+1); | |
650 | TH2D *h2 = fHnSparseI->Projection(1,2); | |
651 | ||
652 | ||
653 | return h2; | |
654 | ||
655 | } | |
656 | //_____________________________________________________________________ | |
92df0132 | 657 | TH2F *AliTRDCalibChamberStatus::MakeHisto2DSmPlEORStatus(const AliTRDCalDCSv2 *calDCS, Int_t sm, Int_t pl) /*FOLD00*/ |
fd50bb14 | 658 | { |
659 | // | |
660 | // Plot globale state of the HalfChamberMerger (HCM) | |
661 | // | |
662 | AliTRDfeeParam *paramfee = AliTRDfeeParam::Instance(); | |
663 | ||
664 | AliTRDgeometry *trdGeo = new AliTRDgeometry(); | |
665 | AliTRDpadPlane *padPlane0 = trdGeo->GetPadPlane(pl,0); // layer,stack | |
666 | Double_t row0 = padPlane0->GetRow0(); | |
667 | Double_t col0 = padPlane0->GetCol0(); | |
6c1053a8 | 668 | |
fd50bb14 | 669 | char name[1000]; |
3b0c1edc | 670 | snprintf(name,1000,"%s DCS status sm %d pl %d",GetTitle(),sm,pl); |
fd50bb14 | 671 | TH2F * his = new TH2F( name, name, 88,-TMath::Abs(row0),TMath::Abs(row0) |
672 | ,148,-TMath::Abs(col0),TMath::Abs(col0)); | |
673 | ||
674 | ||
675 | // Where we begin | |
676 | Int_t offsetsmpl = 30*sm+pl; | |
677 | Int_t nstack = 5; | |
678 | Int_t ncols = 144; | |
679 | ||
680 | for (Int_t k = 0; k < nstack; k++){ | |
681 | Int_t det = offsetsmpl+k*6; | |
682 | Int_t stac = AliTRDgeometry::GetStack(det); | |
d6a1ec13 | 683 | AliTRDCalDCSFEEv2* calDCSFEEEOR = calDCS->GetCalDCSFEEObj(det); |
fd50bb14 | 684 | if(!calDCSFEEEOR) { continue;} |
685 | for (Int_t icol=0; icol<ncols; icol++){ | |
686 | Int_t nrows = 16; | |
687 | if(stac==2) nrows = 12; | |
688 | for (Int_t irow=0; irow<nrows; irow++){ | |
689 | Int_t binz = 0; | |
690 | Int_t kb = 5-1-k; | |
691 | Int_t krow = nrows-1-irow; | |
692 | Int_t kcol = ncols-1-icol; | |
693 | if(kb > 2) binz = 16*(kb-1)+12+krow+1+2*(kb+1); | |
694 | else binz = 16*kb+krow+1+2*(kb+1); | |
695 | Int_t biny = kcol+1+2; | |
696 | // Take the value | |
697 | Int_t mcm = paramfee->GetMCMfromPad(irow,icol); | |
698 | Int_t rob = paramfee->GetROBfromPad(irow,icol); | |
3b0c1edc | 699 | if(mcm < 0) AliWarning("Problem with mcm number"); |
700 | Int_t state = calDCSFEEEOR->GetMCMGlobalState(rob,TMath::Abs(mcm)); | |
fd50bb14 | 701 | his->SetBinContent(binz,biny,state); |
702 | } | |
703 | } | |
704 | for(Int_t icol = 1; icol < 147; icol++){ | |
705 | for(Int_t l = 0; l < 2; l++){ | |
706 | Int_t binz = 0; | |
707 | Int_t kb = 5-1-k; | |
708 | if(kb > 2) binz = 16*(kb-1)+12+1+2*(kb+1)-(l+1); | |
709 | else binz = 16*kb+1+2*(kb+1)-(l+1); | |
710 | his->SetBinContent(binz,icol,16.0); | |
711 | } | |
712 | } | |
713 | } | |
714 | ||
715 | for(Int_t icol = 1; icol < 147; icol++){ | |
716 | his->SetBinContent(88,icol,16.0); | |
717 | his->SetBinContent(87,icol,16.0); | |
718 | } | |
719 | for(Int_t irow = 1; irow < 89; irow++){ | |
720 | his->SetBinContent(irow,1,16.0); | |
721 | his->SetBinContent(irow,2,16.0); | |
722 | his->SetBinContent(irow,147,16.0); | |
723 | his->SetBinContent(irow,148,16.0); | |
724 | } | |
725 | ||
726 | his->SetXTitle("z (cm)"); | |
727 | his->SetYTitle("y (cm)"); | |
728 | his->SetMaximum(12); | |
729 | his->SetMinimum(0.0); | |
730 | his->SetStats(0); | |
731 | ||
732 | return his; | |
733 | ||
734 | } | |
735 | //_____________________________________________________________________________ | |
d6a1ec13 | 736 | TCanvas* AliTRDCalibChamberStatus::PlotHistos2DSmEORStatus(AliTRDCalDCSv2 *calDCS, Int_t sm, const Char_t *name) |
fd50bb14 | 737 | { |
738 | // | |
739 | // Make 2D graph | |
740 | // | |
741 | ||
742 | gStyle->SetPalette(1); | |
743 | fC1 = new TCanvas(name,name,50,50,600,800); | |
744 | fC1->Divide(3,2); | |
745 | fC1->cd(1); | |
746 | MakeHisto2DSmPlEORStatus(calDCS,sm,0)->Draw("colz"); | |
747 | fC1->cd(2); | |
748 | MakeHisto2DSmPlEORStatus(calDCS,sm,1)->Draw("colz"); | |
749 | fC1->cd(3); | |
750 | MakeHisto2DSmPlEORStatus(calDCS,sm,2)->Draw("colz"); | |
751 | fC1->cd(4); | |
752 | MakeHisto2DSmPlEORStatus(calDCS,sm,3)->Draw("colz"); | |
753 | fC1->cd(5); | |
754 | MakeHisto2DSmPlEORStatus(calDCS,sm,4)->Draw("colz"); | |
755 | fC1->cd(6); | |
756 | MakeHisto2DSmPlEORStatus(calDCS,sm,5)->Draw("colz"); | |
757 | ||
758 | return fC1; | |
759 | ||
760 | } | |
dc67f7d2 | 761 | |
762 | ||
3b0c1edc | 763 |