Coverity fix
[u/mrichter/AliRoot.git] / TRD / TRDbase / AliTRDCalibChamberStatus.cxx
CommitLineData
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"
464611d8 51#include "AliTRDCalChamberStatus.h"
52#include "AliTRDCalDCSv2.h"
53#include "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
63ClassImp(AliTRDCalibChamberStatus) /*FOLD00*/
64
65//_____________________________________________________________________
66AliTRDCalibChamberStatus::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//_____________________________________________________________________
86AliTRDCalibChamberStatus::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//_____________________________________________________________________
106AliTRDCalibChamberStatus& 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//_____________________________________________________________________
117AliTRDCalibChamberStatus::~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//_____________________________________________________________________
146void 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
267}
268//_____________________________________________________________________
92df0132 269void 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
2942f542 306 Double_t val[4] = {static_cast<Double_t>(sm),static_cast<Double_t>(layer),static_cast<Double_t>(stac),static_cast<Double_t>(rphi)};
b2277aa2 307 if(fHnSparseI->GetBinContent((const Int_t*)val)<2147483646) fHnSparseI->Fill(&val[0]);
308 }
309
310}
311//_____________________________________________________________________
6c1053a8 312void AliTRDCalibChamberStatus::ProcessEvent(AliRawReader * rawReader, Int_t nevents_physics)
313{
314 //
fd50bb14 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
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
2942f542 358 Double_t val[4] = {static_cast<Double_t>(sm),static_cast<Double_t>(layer),static_cast<Double_t>(stac),static_cast<Double_t>(rphi)};
fd50bb14 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);
2942f542 366 Double_t valu[3] = {static_cast<Double_t>(nevents_physics),static_cast<Double_t>(detector),rphi};
fd50bb14 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;
fd50bb14 381
6c1053a8 382}
383//_____________________________________________________________________
384Bool_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;
2942f542 401 Double_t val[4] = {static_cast<Double_t>(ism),static_cast<Double_t>(ipl),static_cast<Double_t>(istack),static_cast<Double_t>(side)};
6c1053a8 402 fHnSparseI->Fill(&val[0]);
403 }
404 }
405 }
406 }
407 }
408
409 return kTRUE;
410
411}
412//_____________________________________________________________________
17aa2935 413void 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 485void 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");
2942f542 540 Double_t val[4] = {static_cast<Double_t>(sm),static_cast<Double_t>(lay),static_cast<Double_t>(stac),1};
6c1053a8 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
2942f542 546 Double_t valss[6] = {static_cast<Double_t>(sm),static_cast<Double_t>(lay),static_cast<Double_t>(stac),static_cast<Double_t>(ii),static_cast<Double_t>(i)
547 ,static_cast<Double_t>(calDCSFEEEOR->GetMCMGlobalState(ii,i))};
fd50bb14 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 591void 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//_____________________________________________________________________
612void 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//_____________________________________________________________________________
639TH2D* 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 657TH2F *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 736TCanvas* 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