]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TPC/AliTPCMonitorBack.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Coding violation fixies (Jens Viechula)
[u/mrichter/AliRoot.git] / TPC / AliTPCMonitorBack.cxx
CommitLineData
48265b32 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$Log$
18*/
19
20#include "AliTPCMonitor.h"
21ClassImp(AliTPCMonitor)
22
23//____________________________________________________________________________
24AliTPCMonitor::AliTPCMonitor(char* name, char* title) : AliTPCMonitorConfig(name,title)
25{
26 // Constructor
27
28 fPad = new Int_t*[GetMaxHwAddr()];
29 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPad[i] = new Int_t[GetTimeBins()];}
30
31 fPadMapRCU = new Int_t*[GetMaxHwAddr()];
32 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { fPadMapRCU[i] = new Int_t[6];}
33
34 fPadMapHw = new Float_t[GetMaxHwAddr()];
35
36
37
38 fReaderROOT = 0;
39 fReaderDATE = 0;
40 fReaderDATEMon = 0;
41
42 // row and pad settings
43 kNRowsIroc = 63;
44 kNRowsOroc = 96;
45
46 kNPadsIroc = 110;
47 kNPadsOroc = 140;
48 kNPadMinIroc = -55;
49 kNPadMaxIroc = 55;
50
51 kNPadMinOroc = -70;
52 kNPadMaxOroc = 70;
53
54
55
56 // histograms to be used ////////////////////////////////////////////////////////////////
57 fHistIROC =0;
58 fHistOROC =0;
59 fHistIROCIndex =0;
60 fHistOROCIndex =0;
61 fHistIROCTime =0;
62 fHistOROCTime =0;
63 fHistIROCClone =0;
64 fHistOROCClone =0;
65
66 fHistIROCRMS =0;
67 fHistOROCRMS =0;
68
69 fHistIROCBASE =0;
70 fHistOROCBASE =0;
71
72 fHistIROCSUM =0;
73 fHistOROCSUM =0;
74
75 fHistChannelTime =0;
76 fHistAddrMapIndex =0;
77 fHistAddrMaxAdc =0;
78 fHistAddrBaseMean =0;
79 fHistAddrMaxAdcX =0;
80 fHistAddrAdcSum =0;
81 fHistAddrBaseRms =0;
82
83 fHistDistrSumIROC =0;
84 fHistDistrMaxIROC =0;
85
86 fHistDistrSumOROC =0;
87 fHistDistrMaxOROC =0;
88
89 fHistDistrBase2dIROC =0;
90 fHistDistrBase2dOROC =0;
91
92 fHistDistrBaseRmsIROC =0;
93 fHistDistrBaseMeanIROC =0;
94
95 fHistDistrBaseRmsOROC =0;
96 fHistDistrBaseMeanOROC =0;
97
98 fHistGlobalMaxA =0;
99 fHistGlobalMaxC =0;
100
101
102 // some error flags //////////////////////////////////////////////////////////////////////////////
103 fVerb =0;
104 fMapHand =0;
105
106
107 fLastEv =0;
108 fEventNumber =0;
109 fEventNumberOld =0;
110
111 fDisableFit =0;
112
113 fExecGlob =0;
114 fExecPlaneMax =0;
115 fExecPadIrocRms =0;
116 fExecPadOrocRms =0;
117
118 fRunId =0;
119 fEqId =0;
120
121 fPadUsedRoc =-1;
122 fPadUsedHwAddr =-1;
123
124 fMirror = 1;
125
126 fChannelIter = 0;
127
128
129
130 fMapEqidsRcu = new Int_t[1000];
131 fMapEqidsSec = new Int_t*[36];
132 for(Int_t i = 0; i<36; i++) { fMapEqidsSec[i] = new Int_t[6];}
133
134
135 if (gDirectory)
136 {
137 if (!gDirectory->GetList())
138 {
139 Warning("Build","Current directory is not a valid directory");
140 return;
141 }
142 AliTPCMonitor *hold = (AliTPCMonitor*)gDirectory->GetList()->FindObject(GetName());
143 if(hold)
144 {
145 Warning("Build","Replacing existing histogram: %s (Potential memory leak).",GetName());
146 gDirectory->GetList()->Remove(hold);
147 }
148 gDirectory->Append(this);
149 }
150
151 fHistList = new TObjArray();
152
153 fGdcId = 0;
154 fLdcId = 0;
155 fLdcIdOld = -1;
156
157 CreateHistos();
158 SetEqIds();
159
160}
161//____________________________________________________________________________
162AliTPCMonitor::~AliTPCMonitor()
163{
164 // destructor
165 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPad[i] ;}
166 for(Int_t i = 0; i<GetMaxHwAddr(); i++) { delete[] fPadMapRCU[i];}
167 delete[] fPadMapHw ;
168 DeleteHistos();
169}
170
171//____________________________________________________________________________
172void AliTPCMonitor::CreateHistos()
173{
174
175 // Create histograms to be displayed
176
177 if(fVerb) cout << " create new ones " << endl;
178 fHistIROC = new TH2F("fHistIROC" ,"fHistIROC" ,kNRowsIroc,0,kNRowsIroc,kNPadsIroc, kNPadMinIroc, kNPadMaxIroc); fHistList->Add(fHistIROC);
179 fHistOROC = new TH2F("fHistOROC" ,"fHistOROC" ,kNRowsOroc,0,kNRowsOroc,kNPadsOroc, kNPadMinOroc, kNPadMaxOroc); fHistList->Add(fHistOROC);
180
181 fHistIROCIndex = new TH2S("fHistIROCIndex" ,"fHistIROCIndex" ,kNRowsIroc,0,kNRowsIroc,kNPadsIroc, kNPadMinIroc, kNPadMaxIroc); fHistList->Add(fHistIROCIndex);
182 fHistOROCIndex = new TH2S("fHistOROCIndex" ,"fHistOROCIndex" ,kNRowsOroc,0,kNRowsOroc,kNPadsOroc, kNPadMinOroc, kNPadMaxOroc); fHistList->Add(fHistOROCIndex);
183
184 fHistIROCTime = new TH2F("fHistIROCTime" ,"fHistIROCTime" ,kNRowsIroc,0,kNRowsIroc,kNPadsIroc, kNPadMinIroc, kNPadMaxIroc); fHistList->Add(fHistIROCTime);
185 fHistOROCTime = new TH2F("fHistOROCTime" ,"fHistOROCTime" ,kNRowsOroc,0,kNRowsOroc,kNPadsOroc, kNPadMinOroc, kNPadMaxOroc); fHistList->Add(fHistOROCTime);
186
187 fHistIROCRMS = new TH2F("fHistIROCRMS" ,"fHistIROCRMS" ,kNRowsIroc,0,kNRowsIroc,kNPadsIroc, kNPadMinIroc, kNPadMaxIroc); fHistList->Add(fHistIROCRMS);
188 fHistOROCRMS = new TH2F("fHistOROCRMS" ,"fHistOROCRMS" ,kNRowsOroc,0,kNRowsOroc,kNPadsOroc, kNPadMinOroc, kNPadMaxOroc); fHistList->Add(fHistOROCRMS);
189
190 fHistIROCSUM = new TH2F("fHistIROCSUM" ,"fHistIROCSUM" ,kNRowsIroc,0,kNRowsIroc,kNPadsIroc, kNPadMinIroc, kNPadMaxIroc); fHistList->Add(fHistIROCSUM);
191 fHistOROCSUM = new TH2F("fHistOROCSUM" ,"fHistOROCSUM" ,kNRowsOroc,0,kNRowsOroc,kNPadsOroc, kNPadMinOroc, kNPadMaxOroc); fHistList->Add(fHistOROCSUM);
192
193 fHistIROCBASE = new TH2F("fHistIROCBASE" ,"fHistIROCBASE" ,kNRowsIroc,0,kNRowsIroc,kNPadsIroc, kNPadMinIroc, kNPadMaxIroc); fHistList->Add(fHistIROCBASE);
194 fHistOROCBASE = new TH2F("fHistOROCBASE" ,"fHistOROCBASE" ,kNRowsOroc,0,kNRowsOroc,kNPadsOroc, kNPadMinOroc, kNPadMaxOroc); fHistList->Add(fHistOROCBASE);
195
196
197 fHistChannelTime = new TH2F("fHistChannelTime" ,"fHistChannelTime" ,GetNumOfChannels(),0,GetNumOfChannels(),GetTimeBins(),0,GetTimeBins());fHistList->Add(fHistChannelTime);
198 fHistAddrMapIndex = new TH1F("fHistAddrMapIndex" ,"fHistAddrMapIndex" ,GetMaxHwAddr() ,0,GetMaxHwAddr()); fHistList->Add(fHistAddrMapIndex);
199 fHistAddrMaxAdc = new TH1F("fHistAddrMaxAdc" ,"fHistAddrMaxAdc" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrMaxAdc);
200 fHistAddrMaxAdcX = new TH1F("fHistAddrMaxAdcX" ,"fHistAddrMaxAdcX" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrMaxAdcX);
201 fHistAddrBaseMean = new TH1F("fHistAddrBaseMean" ,"fHistAddrBaseMean" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrBaseMean);
202 fHistAddrAdcSum = new TH1F("fHistAddrAdcSum" ,"fHistAddrAdcSum" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrAdcSum);
203 fHistAddrBaseRms = new TH1F("fHistAddrBaseRms" ,"fHistAddrBaseRms" ,GetMaxHwAddr(),0,GetMaxHwAddr()); fHistList->Add(fHistAddrBaseRms);
204 fHistDistrSumIROC = new TH1F("fHistDistrSumIROC" ,"fHistDistrSumIROC" ,400,0.0,4000.0); fHistList->Add(fHistDistrSumIROC);
205 fHistDistrMaxIROC = new TH1F("fHistDistrMaxIROC" ,"fHistDistrMaxIROC" ,500,0.0,1000.0); fHistList->Add(fHistDistrMaxIROC);
206 fHistDistrSumOROC = new TH1F("fHistDistrSumOROC" ,"fHistDistrSumOROC" ,400,0.0,4000.0); fHistList->Add(fHistDistrSumOROC);
207 fHistDistrMaxOROC = new TH1F("fHistDistrMaxOROC" ,"fHistDistrMaxOROC" ,500,0.0,1000.0); fHistList->Add(fHistDistrMaxOROC);
208
209 fHistDistrBase2dIROC = new TH2F("fHistDistrBase2dIROC" ,"fHistDistrBase2dIROC",100,0.0,100.0,100,0.0,10.0); fHistList->Add(fHistDistrBase2dIROC);
210 fHistDistrBase2dOROC = new TH2F("fHistDistrBase2dOROC" ,"fHistDistrBase2dOROC",100,0.0,100.0,100,0.0,10.0); fHistList->Add(fHistDistrBase2dOROC);
211
212 fHistGlobalMaxA = new TH2S("SIDE A" ,"SIDE A" ,500,-3000,3000,500,-3000,3000); fHistList->Add(fHistGlobalMaxA);
213 fHistGlobalMaxC = new TH2S("SIDE C" ,"SIDE C" ,500,-3000,3000,500,-3000,3000); fHistList->Add(fHistGlobalMaxC);
214
215 ResetArrays();
216}
217//____________________________________________________________________________
218Int_t AliTPCMonitor::ProcessEvent()
219{
220 // Process Event
221 // Depending on the value of the sector id all sectors (sectorid == -1) are processed.
222 //
223 // In this case only the maximum values are calculated per pad and filled to the global histograms
224 // In a second loop the last processed(displayed) sector will be processed (sectorid!=-1)
225 // again and the baseline rms and further quantities are calculated
226 //
227 // If only one sector should be processed SetProcOneSector(1) should be set.
228 // In this case only the specified (last/last displayed) sector will be processed.
229 //
230 // If GetProcNextEvent()==0 the same event will be processed again
231
232
233 Int_t sectorid = 0;
234 Int_t retflag = 0; // id of last sector + 1000, or error flag
235 if(GetProcNextEvent()==1 && fLastEv) { AliInfo("Last event already processed"); }
236 if(GetProcNextEvent()==1) ResetSectorArray();
237
238
239 if(GetProcNextEvent()==0 || GetProcOneSector()==1 ) sectorid = GetLastSector();
240 else sectorid = -1;
241
242 // first iteration
243 retflag = ReadData(sectorid);
244
245 SetLastProcFile(GetFile());
246
247 if(retflag>=10 && retflag<1000){ AliError("Could not read event properly: Check file name and format or try next event"); return 0 ;}
248
249 DrawHists(3);
250
251 // second iteration
252 if(sectorid==-1 && retflag >1000)
253 {
254 AliInfo("Second read cycle");
255 SetProcNextEvent(0);
256 if(GetLastSectorDisplayed()==-1) {sectorid = GetLastSector() ; }
257 else {sectorid = GetLastSectorDisplayed(); SetLastSector(sectorid) ; }
258 retflag = ReadData(sectorid);
259 }
260
261 SetLastSectorDisplayed(sectorid) ;
262 fMapHand->ReadfecHwMap(GetLastSector());
263 FillHistsPadPlane();
264 DrawHists(1);
265 SetEventProcessed(1);
266 return retflag;
267}
268
269//__________________________________________________________________
270Int_t AliTPCMonitor::ReadData(Int_t secid)
271{
272
273 // Read Data File/Stream for specified Format
274 // Payload will be extracted from either ROOT or DATE format
275 // and passed to FillHistsDecode for decoding of the adc information
276
277 Int_t format = GetFormat();
278
279
280 //if(format==2 && !gSystem->Getenv("DATE_ROOT")) { AliError("DATE not initialized on this system"); return 11;}
281
282 if(format==0){return ReadDataROOT(secid);}
283 else {return ReadDataDATE(secid,format);}
284}
285//__________________________________________________________________
286Int_t AliTPCMonitor::ReadDataDATE(Int_t secid, Int_t format )
287{
288 // Read Data in Date format
289 // Date file and monitor will be handled in this function
290 Int_t MON = 0;
291 if(format==1) MON =0;
292 else MON =1;
293 cout << " Monitor " << MON << endl;
294
295 if(fReaderROOT) { delete fReaderROOT ; fReaderROOT=0;}
296 if(MON) { if(fReaderDATE) { delete fReaderDATE ; fReaderDATE =0; }}
297 else { if(fReaderDATEMon) { delete fReaderDATEMon ; fReaderDATEMon=0; }}
298
299 fChannelIter =0;
300 Int_t last_eq = 0;
301 Int_t last_rcu_id = 0;
302 Int_t rcu_patch = 0;
303 Char_t* eventPtr = 0;
304 UInt_t* eventPtrUI = 0;
305 Bool_t exitSubEventLoop = false;
306 AliTPCMonitorDateFormat* DateForm =0 ;
307
308 // Create objects ///
309 if( !MON && (fReaderDATE==0 || ( fReaderDATE!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) )) )
310 {
311 cout << " Create new DATE file "<< endl;
312 if(fReaderDATE) { delete fReaderDATE ; fReaderDATE=0; }
313 fReaderDATE = new AliTPCMonitorDateFile() ;
314 fReaderDATE->SetName("fReaderDATE") ;
315 fReaderDATE->OpenDateFile(GetFile()) ;
316 fEventNumber =0;
317 }
318 else if(MON && (fReaderDATEMon==0 || ( fReaderDATEMon!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) )))
319 {
320 if(fReaderDATEMon!=0)
321 {
322 fReaderDATEMon->Logout();
323 delete fReaderDATEMon;
324 }
325 cout << " Creating new Date monitoring Object "<< endl;
326 fReaderDATEMon = new AliTPCMonitorDateMonitor();
327 fReaderDATEMon->SetName("DMon");
328 Int_t status = fReaderDATEMon->OpenMonitoring(GetFile());
329 if(status) { AliError(Form("Could not read event online: Error: %s",fReaderDATEMon->DecodeError(status))); return 11; }
330 }
331 // Get Event pointer ///
332 if(!MON)
333 {
334 if(fReaderDATE->IsDateFileOpen() ==false ) { AliError("Could not open Date File"); return 11 ; }
335 // Rewind event if new event number is smaller than old one
336 if(fEventNumberOld>fEventNumber) { fReaderDATE->ResetFilePos(); }
337 while(GetProcNextEvent() || fEventNumber==0)
338 {
339 fReaderDATE->ReadEvent();
340 eventPtr = fReaderDATE->GetMemoryPointer();
341 DateForm = new AliTPCMonitorDateFormat(eventPtr);
342 Int_t current_ev = DateForm->GetEventID();
343 if(fEventNumber <= current_ev ){ break; }
344 }
345 }
346 else if(GetProcNextEvent())
347 {
348 fReaderDATEMon->Free();
349 Int_t status = fReaderDATEMon->GetEvent();
350 if(status) { AliError(Form("Could not read event online: Error: %s",fReaderDATEMon->DecodeError(status))); return 11 ;}
351 //fReaderDATEMon->Logout();
352 }
353
354 if(!MON) { eventPtr = fReaderDATE->GetMemoryPointer(); }
355 else { eventPtr = fReaderDATEMon->GetEventPointerasChar(); }
356
357 if(DateForm==0) DateForm = new AliTPCMonitorDateFormat(eventPtr);
358 fEventNumber = DateForm->GetEventID();
359 fEventNumberOld = DateForm->GetEventID();
360
361 if(!MON && fReaderDATE->IsLastEvent()) fLastEv =1;
362 if(DateForm->IsEventEndOfRun()) { AliInfo("Event is end of run: eventType END_OF_RUN "); }
363
364 if( !MON && fReaderDATE->IsEventValid() == false ) {AliInfo("Skipping Event because invalid"); return 10; }
365 if(DateForm->IsEventPhysicsEvent() == false ) {AliInfo("Skipping Header/event because not Physics event"); return 12; }
366
367 ResetHistos() ;
368
369 Int_t start =1;
370 while(exitSubEventLoop == false)
371 {
372 if(start==1) { DateForm->GotoSubEventHeader() ; start=0;}
373 else { DateForm->GotoNextSubEventHeader(); }
374 if(DateForm->IsLastSubEventHeader()) exitSubEventLoop = true;
375
376 if(fVerb) cout << " next subevent LDC " << (Int_t)DateForm->GetSubEventLDC() << endl;
377
378 last_eq = 0 ;
379 Int_t neq = 0 ;
380
381 while(last_eq==0)
382 {
383 if(neq ==0){ DateForm->GotoFirstEquipment();}
384 else { DateForm->GotoNextEquipment();}
385
386 fGdcId = DateForm->GetSubEventGDC() ;
387 fLdcId = DateForm->GetSubEventLDC();
388 fRunId = DateForm->GetEventRunID();
389 fEqId = DateForm->GetEquipmentID();
390 rcu_patch = GetRCUPatch(fRunId, fEqId);
391 last_rcu_id = (rcu_patch+1000);
392 neq++;
393
394 if(fLdcIdOld!=fLdcId && fChannelIter!=0) {
395 if(secid==-1)
396 {
397 FillGlobal(GetLastSector());
398 ResetArrays();
399 fChannelIter =0;
400 }
401 else
402 {
403 return last_rcu_id;
404 }
405 }
406 fLdcIdOld = fLdcId ;
407
408
409 if(DateForm->IsLastEquipment() != false ) last_eq = 1;
410
411 eventPtr = DateForm->GetFirstDataPointer();
412 eventPtrUI = (UInt_t *) eventPtr;
413 Int_t payload = DateForm->GetPayloadSize();
414
415 if(fVerb)DumpHeader(DateForm);
416 if(fVerb) cout << "Check sector and fEqId " << endl;
417
418 if(fVerb && secid >0 )
419 {
420 cout << "secid : "<< secid << " fEqId "<< fEqId << " equipment 0 form map " << endl;
421 cout << fMapEqidsSec[secid][0] << endl;
422 cout << " showed map_eqids " << endl;
423 }
424
425 if(CheckEqId(secid,fEqId))
426 {
427 if(fVerb) cout << " init altro " << endl;
428 AliTPCMonitorAltro* altro = new AliTPCMonitorAltro((UInt_t *)eventPtrUI,(payload/4),1);
429 altro->SetWrite10Bit(GetWrite10Bit());
430 altro->SetActFilename(GetFile());
431 if(fVerb) cout << " allocated 10bit " << endl;
432 altro->Allocate10BitArray();
433 altro->Decodeto10Bit(fEqId);
434 AliInfo(Form("Process eqid %i , patch %i ",fEqId,rcu_patch%6));
435 FillHistsDecode(altro,(rcu_patch%6),secid);
436 if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcu_patch/6);
437 delete altro;
438 }// if(CheckID)
439 }// while last eq
440 AliInfo(Form("Process sector %i eqid %i , patch %i ",rcu_patch/6,fEqId,rcu_patch%6));
441 SetLastSector(rcu_patch/6);
442 }// getSubEventLDC
443 if(fChannelIter!=0 && secid==-1){ FillGlobal(GetLastSector()); }
444 delete DateForm;
445 if(fVerb) cout << " last rcu " << last_rcu_id << endl;
446 return last_rcu_id;
447}
448
449//__________________________________________________________________
450Int_t AliTPCMonitor::ReadDataROOT(Int_t secid)
451{
452 // Read in data in ROOT format
453 if(fReaderDATE){ delete fReaderDATE ; fReaderDATE=0;}
454 fChannelIter =0;
455 Int_t last_rcu_id = 0;
456 Int_t rcu_patch = 0;
457 Int_t equipmentSize = 0;
458 UChar_t* eventPtr = 0 ;
459 UInt_t* eventPtrUI = 0 ;
460 Int_t evtype = 0;
461
462 if(fReaderROOT==0 || ( fReaderROOT!=0 && (strcmp(GetLastProcFile(),GetFile())!=0) ) )
463 {
464 if(fVerb) cout << "AliTPCMonitor::ReadDataROOT create new reader " << endl;
465 if(fReaderROOT) { delete fReaderROOT ; fReaderROOT=0; }
466 fReaderROOT = new AliRawReaderRoot(GetFile());
467 if(!fReaderROOT) { AliError("Could not initiate AliRawReaderRoo "); return 10;}
468 fEventNumber=0;
469 }
470
471 // reset to beginning of the event
472 fReaderROOT->Reset();
473
474 // Rewind event if new event number is smaller than old one
475 if(fEventNumberOld>fEventNumber) fReaderROOT->RewindEvents();
476
477 while(GetProcNextEvent() || fEventNumber==0)
478 {
479 if(fVerb) cout << "AliTPCMonitor::ReadDataROOT get event " << endl;
480 if(!fReaderROOT->NextEvent()) { AliError("Could not get next Event"); return 11 ;}
481 Int_t current_ev = *(fReaderROOT->GetEventId());
482
483 if(fEventNumber <= current_ev ){ break; }
484 }
485
486 fEventNumber = *(fReaderROOT->GetEventId());
487 fEventNumberOld = *(fReaderROOT->GetEventId());
488
489 ResetHistos() ;
490
491 while(fReaderROOT->ReadHeader())
492 {
493 if(fVerb) cout << "AliTPCMonitor::ReadDataROOT read header " << endl;
494 fGdcId = fReaderROOT->GetGDCId() ;
495 fLdcId = fReaderROOT->GetLDCId() ;
496 fRunId = fReaderROOT->GetRunNumber() ;
497 equipmentSize = fReaderROOT->GetEquipmentSize();
498 fEqId = fReaderROOT->GetEquipmentId();
499 evtype = fReaderROOT->GetType();
500 rcu_patch = GetRCUPatch(fRunId, fEqId);
501 last_rcu_id = (rcu_patch+1000);
502
503 if(evtype==1) { AliWarning(Form("EventType==1 in event %i ",fEventNumber)); return 10; }
504 if(equipmentSize==0) { AliWarning(Form("Equipmentsize ==0 in event %i ",fEventNumber)); return 10; }
505
506 if(fVerb) DumpHeader(fReaderROOT);
507
508 if(fLdcIdOld!=fLdcId && fChannelIter!=0) {
509 if(secid==-1)
510 {
511 FillGlobal(GetLastSector());
512 ResetArrays();
513 fChannelIter =0;
514 }
515 else
516 {
517 return last_rcu_id;
518 }
519 }
520 fLdcIdOld = fLdcId ;
521
522 if(CheckEqId(secid,fEqId))
523 {
524 fReaderROOT->ReadNextData(eventPtr);
525 eventPtrUI = (UInt_t *) eventPtr;
526 Int_t offset = 16;
527 Int_t fsize = (Int_t)((equipmentSize/4) -offset) +1;
528 AliTPCMonitorAltro* altro = new AliTPCMonitorAltro((UInt_t *)eventPtrUI,fsize,2);
529 altro->SetWrite10Bit(GetWrite10Bit());
530 if(fVerb) cout << "AliTPCMonitor::ReadDataROOT Set Write10bit to " << GetWrite10Bit() << endl;
531 altro->SetActFilename(GetFile());
532 altro->Allocate10BitArray();
533 altro->Decodeto10Bit(fEqId);
534 AliInfo(Form("Process sector %i eqid %i , patch %i ",rcu_patch/6,fEqId,rcu_patch%6));
535 FillHistsDecode(altro,(rcu_patch%6),secid);
536 if(fChannelIter!=0 && secid==-1 ) SetSectorFilled(rcu_patch/6);
537 delete altro;
538 }
539 SetLastSector(rcu_patch/6);
540 }
541 if(fChannelIter!=0 && secid==-1) { FillGlobal(GetLastSector()); }
542 return last_rcu_id;
543}
544
545
546//____________________________________________________________________________
547void AliTPCMonitor::FillHistsDecode(AliTPCMonitorAltro* altro ,Int_t rcu_patch, Int_t secid)
548{
549 // Decode Channels, calculate base mean and rms depending on the
550 // value of secid (see ProcessEvent) and fill histograms
551
552
553 if(fVerb) cout << "FillHistsDecode : rcu_patch " << rcu_patch << " id " << secid << endl;
554 Int_t time_stamp = 0;
555 Int_t sample_iter = 0;
556 Int_t sample_length = 0;
557 Int_t sample_bins = 0;
558 Float_t max = 0;
559 Float_t max_x = 0;
560 Float_t sum = 0.0;
561 Int_t sumn = 0;
562 Int_t block_pos = 0;
563 Int_t hw = 0;
564 Int_t nwords = 0;
565 Int_t nextHwAddress = 0;
566 Int_t ntime = 0;
567 Int_t adc = 0;
568 Int_t nextpos = 0;
569 Int_t lastpos = altro->Get10BitArraySize()-1;
570 Short_t* entries = altro->Get10BitArray();
571 Double_t h_rms = 0.0;
572 Double_t h_mean = 0.0;
573 Int_t supnextpos = 0;
574 TH1D* hbase = new TH1D("hbase","hbase",GetTimeBins(),0.5,(GetTimeBins()+0.5));
575
576 while(lastpos>0)
577 {
578 nextpos = altro->DecodeTrailer(lastpos);
579 supnextpos = altro->GetNextTrailerPos();
580 if(nextpos==-1) { break; }
581
582 lastpos = nextpos;
583 block_pos = altro->GetTrailerBlockPos();
584 hw = altro->GetTrailerHwAddress();
585 nwords = altro->GetTrailerNWords();
586 nextHwAddress = ( hw + (rcu_patch<<12) );
587 fPad[fChannelIter][0] = nextHwAddress ;
588
589 if(fPadMapHw[nextHwAddress]!=-1 )
590 {
591 //Int_t hw_before1 = fPad[fChannelIter-2][0];
592 //Int_t hw_before2 = fPad[fChannelIter-3][0];
593
594 if(fVerb){ cout <<"\n //// Ambiguous hwaddress " << nextHwAddress << " write 10bit files and check file for eqid : " << fEqId << " /////// " << endl;}
595
596 if( TMath::Abs(fPadMapRCU[nextHwAddress][4] - fChannelIter)==1)
597 {
598 if(fVerb) cout << "//// Difference to previous channel==1 : reset branch bit of hw from last channel to 1 " << endl;
599 Int_t hwreset = (nextHwAddress + (1<<11));
600 fPad[fChannelIter-1][0] = hwreset;
601
602 fPadMapHw[hwreset] = fChannelIter-1 ;
603 fPadMapRCU[hwreset][0]= rcu_patch ;
604 fPadMapRCU[hwreset][1]= ((hwreset & AliTPCMonitorAltro::GetHwMaskBranch()) >> 11);
605 fPadMapRCU[hwreset][2]= ((hwreset & AliTPCMonitorAltro::GetHwMaskFEC()) >>7 );
606 fPadMapRCU[hwreset][3]= ( hwreset & AliTPCMonitorAltro::GetHwMaskFECChannel() );
607 fPadMapRCU[hwreset][4]= fChannelIter-1;
608 fPadMapRCU[hwreset][5]= altro->GetTrailerPos();
609 }
610 }
611
612 fPadMapHw[nextHwAddress] = fChannelIter ;
613 fPadMapRCU[nextHwAddress][0]= rcu_patch ;
614 fPadMapRCU[nextHwAddress][1]= ((nextHwAddress & AliTPCMonitorAltro::GetHwMaskBranch())>> 11) ;
615 fPadMapRCU[nextHwAddress][2]= ((nextHwAddress & AliTPCMonitorAltro::GetHwMaskFEC()) >>7);
616 fPadMapRCU[nextHwAddress][3]= (nextHwAddress & AliTPCMonitorAltro::GetHwMaskFECChannel());
617 fPadMapRCU[nextHwAddress][4]= fChannelIter;
618 fPadMapRCU[nextHwAddress][5]= altro->GetTrailerPos();
619
620 time_stamp = 0;
621 sample_iter = 0;
622 sample_length = 0;
623 sample_bins = 0;
624
625 max = 0.0;
626 max_x = 0.0;
627 sum = 0.0;
628 sumn = 0;
629
630 hbase->Reset();
631
632 for(Int_t iter_words = 0 ; iter_words< nwords ; iter_words++)
633 {
634 if(entries[block_pos-iter_words]==682) { continue; }
635 if(entries[block_pos-iter_words]!=682 && sample_iter==0)
636 {
637 sample_length = entries[block_pos-iter_words];
638 sample_iter = sample_length;
639 sample_bins = 0;
640 time_stamp = entries[block_pos-iter_words-1];
641 iter_words++;
642 }
643 else
644 {
645 ntime = time_stamp-sample_bins;
646 adc = entries[block_pos-iter_words];
647 fPad[fChannelIter][ntime] = adc;
648 if( (adc!=0) && (ntime>=GetRangeBaseMin() ) && (ntime<GetRangeBaseMax() )) {hbase->Fill(adc) ;}
649 if( (adc>max) && (ntime>=GetRangeMaxAdcMin()) && (ntime<GetRangeMaxAdcMax() )) {max = adc;max_x = ntime ;}
650 if( (ntime>=GetRangeSumMin()) && (ntime<GetRangeSumMax() )) {sum+=adc; sumn++;}
651 sample_bins++;
652 }
653 }
654
655 h_mean = hbase->GetMean();
656 hbase->GetXaxis()->SetRangeUser(h_mean- h_mean/3 , h_mean + h_mean/3);
657 h_mean = hbase->GetMean();
658 h_rms = hbase->GetRMS();
659
660 if( GetPedestals()==1) fHistAddrMaxAdc->SetBinContent( nextHwAddress,max- h_mean);
661 else fHistAddrMaxAdc->SetBinContent( nextHwAddress,max );
662
663 if(secid!=-1)
664 {
665 if(rcu_patch<2)
666 {
667 fHistDistrBase2dIROC->Fill(h_mean,h_rms);
668 fHistDistrSumIROC->Fill(sum);
669 if( GetPedestals()==1 ) { fHistDistrMaxIROC->Fill(max-h_mean); fHistDistrSumIROC->Fill(sum -sumn*h_mean);}
670 else { fHistDistrMaxIROC->Fill(max); fHistDistrSumIROC->Fill(sum );}
671 }
672 else
673 {
674 fHistDistrBase2dOROC->Fill(h_mean,h_rms);
675 fHistDistrSumOROC->Fill(sum);
676 if( GetPedestals()==1 ){ fHistDistrMaxOROC->Fill(max-h_mean); fHistDistrSumOROC->Fill(sum -sumn*h_mean);}
677 else { fHistDistrMaxOROC->Fill(max); fHistDistrSumOROC->Fill(sum) ;}
678 }
679
680 fHistAddrAdcSum->SetBinContent( nextHwAddress,sum);
681 fHistAddrMapIndex->SetBinContent(nextHwAddress,fChannelIter);
682 fHistAddrBaseMean->SetBinContent(nextHwAddress,h_mean);
683 fHistAddrMaxAdcX->SetBinContent( nextHwAddress,max_x);
684 fHistAddrBaseRms->SetBinContent( nextHwAddress,h_rms);
685 }
686 fChannelIter++;
687 if(nextpos<0) { AliError("Error : next pos < 0 "); break ;}
688 }
689 delete hbase;
690 return ;
691}
692
693
694//____________________________________________________________________________
695void AliTPCMonitor::FillHistsPadPlane()
696{
697 // Fill 2Dim histograms for IROC and OROC (max , rms and sum)
698
699 if(fVerb)cout << "AliTPCMonitor::FillHistsPadPlane() Start " << endl;
700 if(fVerb)PrintConfig();
701
702 Int_t pad = 0;
703 Int_t row = 0;
704 Int_t padmax = 0;
705 Int_t hwadd = 0;
706
707 for(Int_t ch = 0; ch<fChannelIter; ch++)
708 {
709 hwadd= fPad[ch][0];
710 fHistChannelTime->SetCellContent(ch,0,hwadd);
711
712 for(Int_t bin = 1; bin <GetTimeBins(); bin++)
713 {
714 if( fHistChannelTime->GetCellContent(ch,bin)!=0) cout << " cellcontent already set " << endl;
715 if( GetPedestals()==1 ) fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]- fHistAddrBaseMean->GetBinContent(hwadd)));
716 else fHistChannelTime->SetCellContent(ch,bin,(fPad[ch][bin]));
717 }
718
719 pad = fMapHand->GetPad( hwadd);
720 row = fMapHand->GetPadRow(hwadd);
721 padmax = fMapHand->GetNumofPads(row);
722
723 if(row<63)
724 {
725 fHistIROC->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent( hwadd));
726 fHistIROCIndex->SetCellContent(row +1 ,pad +55 -padmax/2 +1,ch);
727 fHistIROCRMS->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
728 fHistIROCBASE->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
729 fHistIROCSUM->SetCellContent( row +1 ,pad +55 -padmax/2 +1,fHistAddrAdcSum->GetBinContent( hwadd));
730 }
731 else
732 {
733 fHistOROC->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrMaxAdc->GetBinContent( hwadd));
734 fHistOROCIndex->SetCellContent(row-63 +1 ,pad +70 -padmax/2 +1,ch);
735 fHistOROCRMS->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseRms->GetBinContent( hwadd));
736 fHistOROCBASE->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrBaseMean->GetBinContent(hwadd));
737 fHistOROCSUM->SetCellContent( row-63 +1 ,pad +70 -padmax/2 +1,fHistAddrAdcSum->GetBinContent( hwadd));
738 }
739 }
740
741 fHistChannelTime->GetXaxis()->SetRange(0,fChannelIter);
742 fHistChannelTime->GetYaxis()->SetRange(0,GetTimeBins());
743}
744
745
746
747//____________________________________________________________________________
748void AliTPCMonitor::ResetArrays()
749{
750 // Reset data arrays
751 for(Int_t row = 0 ; row < kNRowsIroc; row++)
752 {
753 for(Int_t pad = 0 ; pad < kNPadsIroc ; pad++)
754 {
755 fHistIROCIndex->SetCellContent(row+1,pad+1,-1);
756 }
757 }
758 for(Int_t row = 0 ; row < kNRowsOroc; row++)
759 {
760 for(Int_t pad = 0 ; pad < kNPadsOroc ; pad++)
761 {
762 fHistOROCIndex->SetCellContent(row+1,pad+1,-1);
763 }
764 }
765
766 for(Int_t ch= 0; ch<GetMaxHwAddr(); ch++)
767 {
768 fHistAddrMaxAdcX->SetBinContent(ch,-1);
769 fHistAddrMapIndex->SetBinContent(ch,-1);
770 fHistAddrMaxAdc->SetBinContent( ch, 0);
771 fHistAddrBaseMean->SetBinContent( ch, 0);
772 fHistAddrAdcSum->SetBinContent( ch, 0);
773 fHistAddrBaseRms->SetBinContent(ch, 0);
774 }
775
776 for(Int_t ch = 0; ch< GetNumOfChannels(); ch++)
777 {
778 for(Int_t bin = 0; bin< GetTimeBins(); bin++)
779 {
780 fPad[ch][bin] = 0;
781 }
782 }
783 for(Int_t ch = 0; ch< GetMaxHwAddr(); ch++)
784 {
785 fPadMapHw[ch]=-1;
786 fPadMapRCU[ch][0]=-1;
787 fPadMapRCU[ch][1]=-1;
788 fPadMapRCU[ch][2]=-1;
789 fPadMapRCU[ch][3]=-1;
790 fPadMapRCU[ch][4]=-1;
791 fPadMapRCU[ch][5]=-1;
792 }
793 fPadUsedHwAddr=-1;
794}
795
796
797//____________________________________________________________________________
798void AliTPCMonitor::ResetHistos()
799{
800 // Reset all but
801 for(Int_t i =0; i<fHistList->GetEntries(); i++)
802 {
803 if(GetProcNextEvent()==0 && strcmp(((TH1*)fHistList->At(i))->GetName(),"SIDE A")==0) continue;
804 if(GetProcNextEvent()==0 && strcmp(((TH1*)fHistList->At(i))->GetName(),"SIDE C")==0) continue;
805 ((TH1*)fHistList->At(i))->Reset();
806 }
807 ResetArrays();
808}
809
810//____________________________________________________________________________
811void AliTPCMonitor::DeleteHistos()
812{
813 // Delete histograms
814 for(Int_t i =0; i<fHistList->GetEntries(); i++)
815 {
816 delete (TH1*)fHistList->At(i);
817 }
818}
819
820
821//__________________________________________________________________
822Int_t AliTPCMonitor::CheckEqId(Int_t secid,Int_t eqid)
823{
824 // Check if equipment id corresponds to any rcu patch in sector
825 // Equipment ids changed during commisioning in 2006 (starting from run 704)
826 // However Runids started from 0 again in 2007
827 // Now only runids from commissioning in 2006 after runid 704 and all new ones are supported.
828 // Comment in equipment check for runids < 704 if old runs should be processed
829
830 if(fVerb) cout << "AliTPCMonitor::CheckEqId : SectorId " << secid << " EquipmentId " << eqid << " runid " << fRunId << endl;
831 Int_t passed =1;
832 if(fRunId<704 && 0) // commented out --> runs with runid < 704 in 2006 are not recognized anymore
833 {
834 if( (secid>-1) && (secid<36) ) // if ( secid is in range) { take only specific eqids} else { take all }
835 {
836 if( (secid==13) && ( eqid!=408 && eqid!=409 && eqid!=509 && eqid!=512 && eqid!=513 && eqid!=517 )) {passed=0;}
837 else if( (secid==4) && ( eqid!=404 && eqid!=504 && eqid!=407 && eqid!=503 && eqid!=508 && eqid!=506 )) {passed=0;}
838 }
839 else {if(fVerb) cout << "passed check "<< endl; }
840 }
841 else
842 {
843 if( (secid>-1) && (secid<36) ) // if ( secid is in range) { take only specific eqids} else { take all }
844 {
845 if(eqid!=fMapEqidsSec[secid][0] && eqid!= fMapEqidsSec[secid][1] && eqid!=fMapEqidsSec[secid][2] &&
846 eqid!=fMapEqidsSec[secid][3] && eqid!= fMapEqidsSec[secid][4] && eqid!=fMapEqidsSec[secid][5] ) {passed=0;}
847 }
848 else {if(fVerb) cout << "passed check "<< endl;}
849 }
850 return passed;
851}
852
853//__________________________________________________________________
854void AliTPCMonitor::SetEqIds()
855{
856 // Set mapping for equipment ids
857 for(Int_t i = 0; i<36 ; i++)
858 {
859 for(Int_t j = 0; j<6; j++)
860 {
861 if(j<2) fMapEqidsSec[i][j]= 768+i*2+j;
862 else fMapEqidsSec[i][j]= 840+i*4+j-2;
863 }
864 }
865
866 for(Int_t i = 0; i<36 ; i++)
867 {
868 for(Int_t j = 0; j<6; j++)
869 {
870 if(j<2) fMapEqidsRcu[768+i*2+j] = i*6 +j;
871 else fMapEqidsRcu[840+i*4+j-2] = i*6 +j;
872 }
873 }
874}
875
876//__________________________________________________________________
877void AliTPCMonitor::FillGlobal(Int_t sector)
878{
879
880 // Fill global histograms with max adc for each channel
881
882 TH2S* hglob =0;
883 if((sector/18) ==0) hglob = fHistGlobalMaxA;
884 else hglob = fHistGlobalMaxC;
885
886 Float_t rotsec = (2*TMath::Pi()/18.0);
887 Float_t rot = (-rotsec*(sector%18) +4*rotsec);
888
889 Float_t m11 = TMath::Cos(rot);
890 Float_t m12 = TMath::Sin(rot);
891 Float_t m21 = -1*TMath::Sin(rot);
892 Float_t m22 = TMath::Cos(rot);
893
894 Int_t max = 0; // use integer for global view
895
896 Double_t xval = 0.0;
897 Double_t yval = 0.0;
898
899 Int_t pad = 0;
900 Int_t row = 0;
901 Int_t padmax = 0;
902
903 Float_t xdr = 0;
904 Float_t ydr = 0;
905
906 for(Int_t hw = 0; hw<fHistAddrMaxAdc->GetNbinsX(); hw++)
907 {
908 max = (Int_t)fHistAddrMaxAdc->GetBinContent(hw);
909 if(max!=-1)
910 {
911 pad = fMapHand->GetPad( hw);
912 row = fMapHand->GetPadRow(hw);
913 padmax = fMapHand->GetNumofPads(row);
914 GetXY(xval ,yval , padmax,row ,pad);
915 xdr = xval*m11 +yval*m12;
916 ydr = xval*m21 +yval*m22;
917 if(hglob->GetBinContent(hglob->GetXaxis()->FindBin(xdr),hglob->GetYaxis()->FindBin(ydr))==0) hglob->Fill(xdr,ydr,(Int_t)max);
918 }
919 }
920}
921
922
923//__________________________________________________________________
924void AliTPCMonitor::GetXY( Double_t& xval , Double_t& yval , Int_t padmax, Int_t row , Int_t pad)
925{
926 // Get x and y position of pad
927
928 if(row<63)
929 {
930 xval = fMirror*( 2*padmax -4*pad -2);
931 yval = 852.25 +7.5*row;
932 }
933 else
934 {
935 xval = fMirror*( 3*padmax -6*pad -3);
936 if((row-63)<63) { yval = 10*(row-63) +1351; }
937 else { yval = 15*(row-63-64)+1993.5; }
938 }
939
940}
941
942//__________________________________________________________________
943Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row, Int_t padmax)
944{
945 // Get pad number at given position in x
946 Int_t pad = 0;
947
948 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
949 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
950
951 if(pad>=padmax) return -1;
952 else return pad ;
953
954}
955
956//__________________________________________________________________
957Int_t AliTPCMonitor::GetPadAtX(Float_t xval, Int_t row)
958{
959
960 // Get pad number at given position in x
961
962 Int_t padmax = fMapHand->GetNumofPads(row);
963 Int_t pad = 0;
964
965 if(row<63) {pad = (Int_t)( ( (xval/fMirror) +2 -2*padmax)/-4);}
966 else {pad = (Int_t)( ( (xval/fMirror) +3 -3*padmax)/-6);}
967
968 if(pad>=padmax) return -1;
969 else return pad ;
970
971}
972
973//__________________________________________________________________
974void AliTPCMonitor::DrawHists(Int_t histos)
975{
976
977 // Draw sets of histograms
978 // histos==1 : 2Dim histos for MAX adc and add executables
979 // histos==2 : distributions max/rms/sum
980 // histos==3 : global max adc for specified SideA/C
981
982
983 if(fVerb) cout << " Draw histos " << endl;
984 Char_t cside[10];
985 if(GetLastSector()/18==0 ) sprintf(cside,"A");
986 else sprintf(cside,"C");
987
988 Char_t titleSEC[256]; sprintf(titleSEC ,"Sector %i Side %s Run : %05i EventID %i " ,GetLastSector()%18,cside,fRunId, fEventNumber);
989 Char_t titleEvent[256]; sprintf(titleEvent ,"Time <-> Channles %s" ,titleSEC);
990 Char_t titleIROC[256]; sprintf(titleIROC ,"IROC %s" ,titleSEC);
991 Char_t titleOROC[256]; sprintf(titleOROC ,"OROC %s" ,titleSEC);
992
993 Char_t titleMAX[256]; sprintf(titleMAX ,"Max (timebin: %i,%i) %s" ,GetRangeMaxAdcMin(),GetRangeMaxAdcMax(),titleSEC);
994 Char_t titleSUM[256]; sprintf(titleSUM ,"Sum (timebin: %i,%i) %s" ,GetRangeSumMin() ,GetRangeSumMax() ,titleSEC);
995 Char_t titleBASE[256]; sprintf(titleBASE ,"Baseline RMS<->Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
996 Char_t titleMEAN[256]; sprintf(titleMEAN ,"Baseline Mean (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
997 Char_t titleRMS[256] ; sprintf(titleRMS ,"Baseline RMS (timebin: %i-%i) %s" ,GetRangeBaseMin() ,GetRangeBaseMax() ,titleSEC);
998
999 if(histos==1)
1000 {
1001 // IROC _______________________________________________________________
1002 TCanvas* ciroc = 0;
1003 ciroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1004 if(!ciroc)
1005 {
1006 ciroc = CreateCanvas("ciroc");
1007 fExecPlaneMax=0;
1008 }
1009 ciroc->cd();
1010
1011 fHistIROC->SetXTitle("row");
1012 fHistIROC->SetYTitle("pad");
1013 if(GetPedestals()) fHistIROC->SetZTitle("max ADC (baseline sub)");
1014 else fHistIROC->SetZTitle("max ADC ");
1015 fHistIROC->SetTitle(titleIROC);
1016 fHistIROC->SetMinimum(0.01);
1017 fHistIROC->Draw("COLZ");
1018 ciroc->UseCurrentStyle();
1019
1020
1021 fHistIROCTime->SetXTitle("row"); fHistIROCTime->SetZTitle("peak time (fit)"); fHistIROCTime->SetYTitle("pad"); fHistIROCTime->SetTitle(titleIROC);
1022 fHistIROCRMS->SetXTitle("row"); fHistIROCRMS->SetZTitle( "baseline rms (ADC)"); fHistIROCRMS->SetYTitle("pad"); fHistIROCRMS->SetTitle(titleIROC);
1023
1024 // OROC
1025 TCanvas* coroc = 0;
1026 coroc =(TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1027 if(!coroc) {
1028 coroc = CreateCanvas("coroc");
1029 fExecPlaneMax=0;
1030 }
1031 coroc->cd();
1032
1033 fHistOROC->SetXTitle("row");
1034 fHistOROC->SetYTitle("pad");
1035 if(GetPedestals()) fHistOROC->SetZTitle("max ADC (baseline sub)");
1036 else fHistOROC->SetZTitle("max ADC ");
1037 fHistOROC->SetTitle(titleOROC);
1038 fHistOROC->SetMinimum(0.01);
1039 fHistOROC->Draw("COLZ");
1040 coroc->UseCurrentStyle();
1041
1042
1043 fHistOROCTime->SetXTitle("row"); fHistOROCTime->SetZTitle("peak time (fit) (timebins)"); fHistOROCTime->SetYTitle("pad"); fHistOROCTime->SetTitle(titleOROC);
1044 fHistOROCRMS->SetXTitle("row"); fHistOROCRMS->SetZTitle("baseline rms (ADC)"); fHistOROCRMS->SetYTitle("pad"); fHistOROCRMS->SetTitle(titleOROC);
1045
1046 // SUM
1047 Char_t name_sum[256] ; sprintf(name_sum,"ADC sum (bins: %i, %i)",GetRangeSumMin() ,GetRangeSumMax() );
1048 fHistIROCSUM->SetXTitle("row"); fHistIROCSUM->SetZTitle(name_sum); fHistIROCSUM->SetYTitle("pad"); fHistIROCSUM->SetTitle(titleIROC);
1049 fHistOROCSUM->SetXTitle("row"); fHistOROCSUM->SetZTitle(name_sum); fHistOROCSUM->SetYTitle("pad"); fHistOROCSUM->SetTitle(titleOROC);
1050
1051 // BASE
1052 Char_t name_base[256] ; sprintf(name_base ,"base mean (timbebin: %i, %i )",GetRangeBaseMin(),GetRangeBaseMax());
1053 fHistIROCBASE->SetXTitle("row"); fHistIROCBASE->SetZTitle(name_base); fHistIROCBASE->SetYTitle("pad"); fHistIROCBASE->SetTitle(titleIROC);
1054 fHistOROCBASE->SetXTitle("row"); fHistOROCBASE->SetZTitle(name_base); fHistOROCBASE->SetYTitle("pad"); fHistOROCBASE->SetTitle(titleOROC);
1055
1056 if(fHistIROCClone) fHistIROCClone->Delete();
1057 if(fHistOROCClone) fHistOROCClone->Delete();
1058 fHistIROCClone = (TH2F*)fHistIROC->Clone("fHistIROCClone");
1059 fHistOROCClone = (TH2F*)fHistOROC->Clone("fHistOROCClone");
1060
1061 // Executables
1062 if(fExecPlaneMax==0)
1063 {
1064 Char_t carry1[100];
1065 sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1066 ciroc->AddExec("pad",carry1);
1067 coroc->AddExec("pad",carry1);
1068
1069 Char_t carry2[100];
1070 sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1071 ciroc->AddExec("row",carry2);
1072 coroc->AddExec("row",carry2);
1073 fExecPlaneMax=1;
1074 }
1075 coroc->Update();
1076 ciroc->Update();
1077 }
1078 else if(histos==2)
1079 {
1080 // MAX ADC distribution ____________________________________________
1081 TCanvas* cmax = 0;
1082 cmax = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cmax");
1083 if(!cmax) cmax = CreateCanvas("cmax");
1084
1085 cmax->cd();
1086 fHistDistrMaxIROC->GetXaxis()->SetRangeUser(0.0,1000.0);
1087 fHistDistrMaxIROC->SetXTitle("max ADC (ADC)");
1088 fHistDistrMaxIROC->SetYTitle("counts");
1089 fHistDistrMaxIROC->SetTitle(titleMAX);
1090 fHistDistrMaxIROC->Draw("");
1091 fHistDistrMaxOROC->SetLineColor(2);
1092 fHistDistrMaxOROC->Draw("same");
1093
1094 if(fHistDistrMaxOROC->GetMaximum()> fHistDistrMaxIROC->GetMaximum()) fHistDistrMaxIROC->SetMaximum(fHistDistrMaxOROC->GetMaximum()*1.1);
1095
1096 TLegend* legio = new TLegend(0.6,0.6,0.8,0.8);
1097 legio->SetFillColor(0);
1098 legio->AddEntry(fHistDistrMaxIROC,"IROC","l");
1099 legio->AddEntry(fHistDistrMaxOROC,"OROC","l");
1100 legio->Draw("same");
1101
1102 // ADC sum distribution
1103 TCanvas* csum = 0;
1104 csum = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("csum");
1105 if(!csum) csum = CreateCanvas("csum") ;
1106 csum->cd();
1107
1108 fHistDistrSumIROC->SetXTitle("sum ADC (ADC)");
1109 fHistDistrSumIROC->SetYTitle("counts");
1110 fHistDistrSumIROC->SetTitle(titleSUM);
1111 fHistDistrSumIROC->Draw("");
1112 fHistDistrSumOROC->SetLineColor(2);
1113 fHistDistrSumOROC->Draw("same");
1114 if(fHistDistrSumOROC->GetMaximum()> fHistDistrSumIROC->GetMaximum()) fHistDistrSumIROC->SetMaximum(fHistDistrSumOROC->GetMaximum()*1.1);
1115 legio->Draw("same");
1116
1117 // BASELINE MEAN distribution
1118 TCanvas* cbasemean = 0;
1119 cbasemean = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbasemean");
1120 if(!cbasemean) cbasemean = CreateCanvas("cbasemean");
1121 cbasemean->cd();
1122
1123 fHistDistrBaseMeanIROC = fHistDistrBase2dIROC->ProjectionX("fHistDistrBaseMeanIROC");
1124 fHistDistrBaseMeanIROC->SetXTitle("base mean (ADC)");
1125 fHistDistrBaseMeanIROC->SetYTitle("counts");
1126 fHistDistrBaseMeanIROC->SetTitle(titleMEAN);
1127 fHistDistrBaseMeanIROC->Draw("");
1128
1129 fHistDistrBaseMeanOROC = fHistDistrBase2dOROC->ProjectionX("fHistDistrBaseMeanOROC");
1130 fHistDistrBaseMeanOROC->SetLineColor(2);
1131 fHistDistrBaseMeanOROC->Draw("same");
1132 if(fHistDistrBaseMeanOROC->GetMaximum()>fHistDistrBaseMeanIROC->GetMaximum()) fHistDistrBaseMeanIROC->SetMaximum(fHistDistrBaseMeanOROC->GetMaximum()*1.1);
1133 legio->Draw("same");
1134
1135 TCanvas* cbaserms = 0;
1136 cbaserms = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cbaserms");
1137 if(!cbaserms) cbaserms = CreateCanvas("cbaserms") ;
1138 cbaserms->cd();
1139
1140 // BASELINE RMS distribution
1141 fHistDistrBaseRmsIROC = fHistDistrBase2dIROC->ProjectionY("fHistDistrBaseRmsIROC");
1142 fHistDistrBaseRmsIROC->SetXTitle("base rms (ADC)");
1143 fHistDistrBaseRmsIROC->SetYTitle("counts");
1144 fHistDistrBaseRmsIROC->SetTitle(titleRMS);
1145 fHistDistrBaseRmsIROC->Draw("");
1146
1147 fHistDistrBaseRmsOROC = fHistDistrBase2dOROC->ProjectionY("fHistDistrBaseRmsOROC");
1148 fHistDistrBaseRmsOROC->SetLineColor(2);
1149 fHistDistrBaseRmsOROC->Draw("same");
1150 if(fHistDistrBaseRmsOROC->GetMaximum()>fHistDistrBaseRmsIROC->GetMaximum()) fHistDistrBaseRmsIROC->SetMaximum(fHistDistrBaseRmsOROC->GetMaximum()*1.1);
1151 legio->Draw("same");
1152
1153 cmax->Update();
1154 csum->Update();
1155 cbasemean->Update();
1156 cbaserms->Update();
1157 }
1158 else if(histos==3)
1159 {
1160 // GLOBAL MAX ADC _________________________________
1161 if(GetProcNextEvent()==1)
1162 {
1163 TCanvas* cglobA =0;
1164 TCanvas* cglobC =0;
1165
1166 if(!(cglobC=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE C all"))) cglobC = CreateCanvas("SIDE C all");
1167 if(!(cglobA=(TCanvas*)gROOT->GetListOfCanvases()->FindObject("SIDE A all"))) cglobA = CreateCanvas("SIDE A all");
1168
1169 Char_t gl_title1[256]; sprintf(gl_title1,"SIDE A Run %05i (EventID %i)",fRunId,fEventNumber);
1170 Char_t gl_title2[256]; sprintf(gl_title2,"SIDE C Run %05i (EventID %i)",fRunId,fEventNumber);
1171
1172 fHistGlobalMaxA->SetTitle(gl_title1);
1173 fHistGlobalMaxC->SetTitle(gl_title2);
1174 fHistGlobalMaxA->SetXTitle("x/mm");
1175 fHistGlobalMaxA->SetYTitle("y/mm");
1176 fHistGlobalMaxC->SetXTitle("x/mm");
1177 fHistGlobalMaxC->SetYTitle("y/mm");
1178
1179 if(GetPedestals()==0) { fHistGlobalMaxA->SetZTitle("max adc (not baseline sub)"); fHistGlobalMaxC->SetZTitle("max adc (not baseline sub)"); }
1180 else { fHistGlobalMaxA->SetZTitle("max adc "); fHistGlobalMaxC->SetZTitle("max adc "); }
1181
1182 fHistGlobalMaxA->SetMinimum(0.01);
1183 fHistGlobalMaxC->SetMinimum(0.01);
1184
1185 cglobC->cd() ; fHistGlobalMaxC->Draw("COLZ");
1186 cglobA->cd() ; fHistGlobalMaxA->Draw("COLZ");
1187
1188 Char_t name_om[256];
1189 sprintf(name_om,".x %s/TPC/AliTPCMonitorExec.C(3)",gSystem->Getenv("ALICE_ROOT"));
1190
1191 if(fExecGlob==0)
1192 {
1193 if(fVerb)cout << " set exec " << name_om << endl;
1194 cglobC->AddExec("glob",name_om);
1195 cglobA->AddExec("glob",name_om);
1196 fExecGlob = 1;
1197 }
1198 else
1199 {
1200 cglobC->DeleteExec("glob");
1201 cglobA->DeleteExec("glob");
1202
1203 if(fVerb) cout << " set exec " << name_om << endl;
1204 cglobC->AddExec("glob",name_om);
1205 cglobA->AddExec("glob",name_om);
1206
1207 }
1208 cglobC->Update();
1209 cglobA->Update();
1210 }
1211
1212 }
1213}
1214
1215
1216
1217//__________________________________________________________________
1218void AliTPCMonitor::DrawRMSMap()
1219{
1220 // Draw 2Dim rms histos for IROC and OROC
1221 // and set executables for canvases
1222
1223 TCanvas* crmsoroc =0;
1224 TCanvas* crmsiroc =0;
1225 if(!(crmsoroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsoroc"))) crmsoroc = CreateCanvas("crmsoroc");
1226 if(!(crmsiroc = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crmsiroc"))) crmsiroc = CreateCanvas("crmsiroc");
1227
1228 crmsiroc->cd(); fHistIROCRMS->Draw("COLZ");
1229 crmsoroc->cd(); fHistOROCRMS->Draw("COLZ");
1230
1231 Char_t carry1[100]; sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1232 Char_t carry2[100]; sprintf(carry2,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1233
1234 if(fExecPadIrocRms==0)
1235 {
1236 crmsiroc->AddExec("pad",carry1);
1237 crmsiroc->AddExec("row",carry2);
1238 fExecPadIrocRms=1;
1239 }
1240
1241 if(fExecPadOrocRms==0)
1242 {
1243 crmsoroc->AddExec("pad",carry1);
1244 crmsoroc->AddExec("row",carry2);
1245 fExecPadOrocRms=1;
1246 }
1247
1248 crmsiroc->Update();
1249 crmsoroc->Update();
1250
1251 DrawHists(2);
1252
1253}
1254
1255//__________________________________________________________________
1256void AliTPCMonitor::ExecPad()
1257{
1258
1259 // Executable for Pad
1260 // Show time profile for channel the mouse is pointing at
1261
1262 Int_t event = gPad->GetEvent();
1263 if (event != 51) return;
1264
1265 TObject *select = gPad->GetSelected();
1266 if(!select) return;
1267 if(!select->InheritsFrom("TH2")) { return; }
1268 gPad->GetCanvas()->FeedbackMode(kTRUE);
1269
1270 // get position
1271 Int_t px = gPad->GetEventX();
1272 Int_t py = gPad->GetEventY();
1273 Float_t upy = gPad->AbsPixeltoY(py);
1274 Float_t upx = gPad->AbsPixeltoX(px);
1275 Float_t y = gPad->PadtoY(upy);
1276 Float_t x = gPad->PadtoX(upx);
1277
1278 Int_t setrange = 0;
1279
1280 TCanvas* cpad = 0;
1281 // Char_t namehist[50];
1282 Char_t projhist[60];
1283 Char_t namesel[256];
1284 Char_t namecanv[256];
1285
1286 Int_t xbin_min = 0;
1287 Int_t xbin_max = 0;
1288 Float_t ybin_min = 0;
1289 Float_t ybin_max = 0;
1290 Int_t ROC = 0;
1291
1292 // Check wich Canvas executed the event
1293 TH2S* fHistIndex=0;
1294 sprintf(namesel,select->GetName());
1295 if(strcmp(namesel,"fHistOROC")==0 || strcmp(namesel,"fHistOROCRMS")==0 || strcmp(namesel,"fHistOROCTime")==0 )
1296 {
1297 ROC = 1;
1298 fPadUsedRoc =1;
1299 sprintf(projhist,"ProjectionOROC");
1300 sprintf(namecanv,"coroc_ch");
1301 fHistIndex = fHistOROCIndex;
1302 }
1303 if(strcmp(namesel,"fHistIROC")==0 || strcmp(namesel,"fHistIROCRMS")==0 || strcmp(namesel,"fHistIROCTime")==0 )
1304 {
1305 ROC = 0;
1306 fPadUsedRoc=0;
1307 sprintf(projhist,"ProjectionIROC");
1308 sprintf(namecanv,"ciroc_ch");
1309 fHistIndex = fHistIROCIndex;
1310 }
1311
1312 // Check if Canvas already existed and get Ranges from former Prjection histogram
1313 if(cpad=(TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv))
1314 {
1315 cpad->cd();
1316 if(gROOT->Get(projhist))
1317 {
1318 setrange = 1;
1319 xbin_min = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetFirst();
1320 xbin_max = ((TH1D*)gROOT->Get(projhist))->GetXaxis()->GetLast();
1321 ybin_min = ((TH1D*)gROOT->Get(projhist))->GetMinimum();
1322 ybin_max = ((TH1D*)gROOT->Get(projhist))->GetMaximum();
1323 delete gROOT->Get("legfit");
1324 delete gROOT->Get("fg");
1325 }
1326 }
1327 else
1328 {
1329 cpad = CreateCanvas(namecanv); cpad->cd();
1330 }
1331
1332 // Get Bin
1333 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1334 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1335 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1336 if(binchannel>30000 || binchannel<0) return;
1337
1338 if(gROOT->Get(projhist)) delete gROOT->Get(projhist);
1339 // Get Projection
1340 TH1D *hp = (TH1D*)(((TH1D*)fHistChannelTime->ProjectionY("hp",binchannel,binchannel))->Clone(projhist));
1341
1342 // Make title and Pave for channel Info
1343 Char_t title[256];
1344 Int_t npadRow , npad , nhw , nmax , hwadd;
1345
1346 hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1347 fPadUsedHwAddr = hwadd;
1348
1349 if(ROC==0) npadRow = fMapHand->GetPadRow(hwadd);
1350 else npadRow = fMapHand->GetPadRow(hwadd)-63;
1351 npad = fMapHand->GetPad(hwadd);
1352 nhw = hwadd;
1353 nmax = (Int_t)hp->GetMaximum();
1354
1355
1356 TPaveText* legstat = new TPaveText(0.18,0.65,0.3,0.8,"NDC");
1357
1358 Int_t connector = fMapHand->GetFECconnector(hwadd);
1359 Int_t FECnr = fMapHand->GetFECfromHw(hwadd);
1360 Int_t FECch = fMapHand->GetFECchannel(hwadd);
1361 Int_t Altro = fMapHand->GetAltro(hwadd);
1362 Int_t AltroCh = (fMapHand->GetAltroChannel(hwadd))%16;
1363 Int_t FECloc = fMapHand->U2fGetFECinRCU(FECnr) ;
1364 Int_t FEClocbran = fMapHand->U2fGetFECinBranch(FECnr);
1365 Int_t branch = fMapHand->U2fGetBranch(FECnr);
1366
1367
1368 Short_t fecget = (hwadd & AliTPCMonitorAltro::GetHwMaskFEC()) >> 7;
1369 Short_t branchget = (hwadd & AliTPCMonitorAltro::GetHwMaskBranch())>> 11;
1370
1371
1372 Char_t nstat1[100]; Char_t nstat2[100]; Char_t nstat3[100]; Char_t nstat4[100];
1373 Char_t nstat5[100]; Char_t nstat6[100]; Char_t nstat7[100]; Char_t nstat8[100];
1374
1375 sprintf(nstat1,"Branch (map) \t %i (%i) \n",branchget,branch);
1376 sprintf(nstat2,"Fec in patch \t %i \n",FECloc);
1377 sprintf(nstat8,"Fec in branch (map)\t %i (%i)\n",fecget,FEClocbran);
1378 sprintf(nstat7,"Connector \t %i \n",connector);
1379 sprintf(nstat3,"Fec No. \t %i \n",FECnr);
1380 sprintf(nstat4,"Fec chan \t %i \n",FECch);
1381 sprintf(nstat5,"Altro chip\t %i \n",Altro);
1382 sprintf(nstat6,"Altro chan\t %i \n",AltroCh);
1383
1384 legstat->AddText(nstat1); legstat->AddText(nstat2); legstat->AddText(nstat8); legstat->AddText(nstat7);
1385 legstat->AddText(nstat3); legstat->AddText(nstat4); legstat->AddText(nstat5); legstat->AddText(nstat6);
1386
1387 sprintf(title,"Row=%d Pad=%d Hw =%d maxADC =%d count =%d",npadRow,npad,nhw,nmax,binchannel);
1388
1389 hp->SetName(projhist);
1390 hp->SetTitleSize(0.04);
1391 hp->SetTitle(title);
1392 hp->SetYTitle("ADC");
1393 hp->SetXTitle("Timebin");
1394 hp->GetXaxis()->SetTitleColor(1);
1395
1396 if(setrange)
1397 {
1398 hp->GetXaxis()->SetRange(xbin_min,xbin_max);
1399 hp->SetMinimum(ybin_min);
1400 hp->SetMaximum(ybin_max);
1401 }
1402 else
1403 {
1404 hp->SetMinimum(0.0);
1405 hp->SetMaximum(1000.0);
1406 }
1407
1408 cpad->cd();
1409 hp->Draw();
1410
1411 // Make Fit to peak
1412 if(GetPedestals() && fDisableFit==0)
1413 {
1414 Int_t max_x = (Int_t)fHistAddrMaxAdcX->GetBinContent(hwadd);
1415 Float_t max = (Float_t)fHistAddrMaxAdc->GetBinContent(hwadd);
1416 Float_t base = (Float_t)fHistAddrBaseMean->GetBinContent(hwadd);
1417 if(base!=0)
1418 {
1419 if( ((max+base)/base)>1.2)
1420 {
1421 TF1* fg = new TF1("fg",AliTPCMonitor::Gamma4,max_x-5,max_x+5,4);
1422 fg->SetParName(0,"Normalisation");
1423 fg->SetParName(1,"Minimum");
1424 fg->SetParName(2,"Width");
1425 fg->SetParName(3,"Base");
1426 fg->SetParameter(0,max);
1427 fg->SetParameter(1,max_x-2);
1428 fg->SetParameter(2,1.5);
1429 fg->FixParameter(3,0);
1430 fg->SetLineColor(4);
1431 fg->SetLineWidth(1);
1432 hp->Fit("fg","RQ");
1433
1434 TLegend* legfit = new TLegend(0.6,0.7,0.7,0.8);
1435 legfit->AddEntry("fg","#Gamma 4 fit","l");
1436 legfit->SetFillColor(0);
1437 legfit->SetName("legfit");
1438 legfit->Draw("same");
1439 }
1440 }
1441 }
1442 legstat->SetFillColor(0);
1443 legstat->Draw("same");
1444 cpad->Update();
1445 return;
1446}
1447
1448//__________________________________________________________________
1449void AliTPCMonitor::ExecRow()
1450{
1451
1452 // Executable for Pad
1453 // Show profile of max adc over given pad row
1454 // and 2dim histo adc(pad-in-row,time bin)
1455
1456 Int_t event = gPad->GetEvent();
1457 if (event != 61) return;
1458 gPad->cd();
1459 TObject *select = gPad->GetSelected();
1460 if(!select) return;
1461 if(!select->InheritsFrom("TH2")) { return; }
1462
1463 Int_t ROC = 0;
1464 // Char_t namehist[50];
1465 Char_t rowhist[60];
1466 Char_t rowhist_sum[60];
1467 Char_t rowhist_max[60];
1468 Char_t rowhist_xmax[60];
1469
1470 sprintf(rowhist, "hrow_time");
1471 sprintf(rowhist_xmax ,"hx_max");
1472 sprintf(rowhist_max , "hrow_max");
1473
1474 // get position
1475 Int_t px = gPad->GetEventX();
1476 Int_t py = gPad->GetEventY();
1477 Float_t upy = gPad->AbsPixeltoY(py);
1478 Float_t upx = gPad->AbsPixeltoX(px);
1479 Float_t y = gPad->PadtoY(upy);
1480 Float_t x = gPad->PadtoX(upx);
1481
1482 TCanvas*crow_time = 0;
1483 TCanvas*crow_max = 0;
1484 TCanvas*cx_max = 0;
1485
1486 TH2S* fHistIndex = 0;
1487
1488 // ranges from already existing histos
1489 Int_t row_time_xmin = 0;
1490 Int_t row_time_xmax = 0;
1491 Int_t row_time_ymin = 0;
1492 Int_t row_time_ymax = 0;
1493 Float_t row_time_zmin = 0;
1494 Float_t row_time_zmax = 0;
1495
1496 Int_t prof_row_xmin = 0;
1497 Int_t prof_row_xmax = 0;
1498 Double_t prof_row_ymin = 0;
1499 Double_t prof_row_ymax = 0;
1500
1501 Int_t prof_x_xmin = 0;
1502 Int_t prof_x_xmax = 0;
1503 Double_t prof_x_ymin = 0;
1504 Double_t prof_x_ymax = 0;
1505
1506
1507 Int_t setrange = 0;
1508
1509
1510 if( strcmp(select->GetName(),"fHistIROC")==0 || strcmp(select->GetName(),"fHistIROCRMS")==0 ) { fHistIndex = fHistIROCIndex; ROC =1; }
1511 else if(strcmp(select->GetName(),"fHistOROC")==0 || strcmp(select->GetName(),"fHistOROCRMS")==0 ) { fHistIndex = fHistOROCIndex; ROC =2; }
1512 else { cout << " not implemented for this histo " << endl; return; }
1513
1514 gPad->GetCanvas()->FeedbackMode(kTRUE);
1515
1516
1517
1518 // check if canvases exist //
1519 crow_time = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crow_time");
1520 crow_max = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("crow_max");
1521 cx_max = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("cx_max");
1522
1523 if(!crow_time) crow_time = CreateCanvas("crow_time") ;
1524 if(!crow_max) crow_max = CreateCanvas("crow_max") ;
1525 if(!cx_max ) cx_max = CreateCanvas("cx_max") ;
1526
1527 // check ranges of already existing histos
1528 if(gROOT->Get(rowhist))
1529 {
1530 row_time_xmin = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetFirst();
1531 row_time_xmax = ((TH2F*)gROOT->Get(rowhist))->GetXaxis()->GetLast();
1532 row_time_ymin = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetFirst();
1533 row_time_ymax = ((TH2F*)gROOT->Get(rowhist))->GetYaxis()->GetLast();
1534 row_time_zmin = ((TH2F*)gROOT->Get(rowhist))->GetMinimum();
1535 row_time_zmax = ((TH2F*)gROOT->Get(rowhist))->GetMaximum();
1536
1537 prof_row_xmin = ((TH1F*)gROOT->Get(rowhist_max))->GetXaxis()->GetFirst();
1538 prof_row_xmax = ((TH1F*)gROOT->Get(rowhist_max))->GetXaxis()->GetLast();
1539 prof_row_ymin = ((TH1F*)gROOT->Get(rowhist_max))->GetMinimum();
1540 prof_row_ymax = ((TH1F*)gROOT->Get(rowhist_max))->GetMaximum();
1541
1542 prof_x_xmin = ((TH1F*)gROOT->Get(rowhist_xmax))->GetXaxis()->GetFirst();
1543 prof_x_xmax = ((TH1F*)gROOT->Get(rowhist_xmax))->GetXaxis()->GetLast();
1544 prof_x_ymin = ((TH1F*)gROOT->Get(rowhist_xmax))->GetMinimum();
1545 prof_x_ymax = ((TH1F*)gROOT->Get(rowhist_xmax))->GetMaximum();
1546
1547 setrange =1;
1548
1549 delete gROOT->Get(rowhist);
1550 delete gROOT->Get(rowhist_max);
1551 delete gROOT->Get(rowhist_sum);
1552 delete gROOT->Get("hx_max");
1553 delete gROOT->Get("legrow");
1554 }
1555
1556 // get channel for xy bin -> getRow -> getNrows -> getHw for each Pad in Row -> get channel for each hw -> make proj
1557 Int_t testy = fHistIndex->GetYaxis()->FindBin(y);
1558 Int_t testx = fHistIndex->GetXaxis()->FindBin(x);
1559 Int_t binchannel = (Int_t)fHistIndex->GetCellContent(testx,testy);
1560
1561 if(binchannel>30000) return;
1562 if(binchannel<=0 ) { crow_time->Update() ; crow_max->Update() ; return ; }
1563
1564 // get hwaddress
1565 Int_t hwadd = (Int_t)fHistChannelTime->GetCellContent(binchannel,0);
1566 Int_t row = fMapHand->GetPadRow(hwadd);
1567 Int_t pad = fMapHand->GetPad(hwadd) ;
1568 Int_t numofpads = fMapHand->GetNumofPads(row);
1569
1570 // create histos
1571 TH2F *hrow_time = new TH2F(rowhist , "" ,numofpads,0,numofpads,GetTimeBins(),0.0,GetTimeBins());
1572 TH1F *hrow_max = new TH1F(rowhist_max , "" ,numofpads,0,numofpads);
1573 TH1F *hx_max = new TH1F(rowhist_xmax, "" ,159,0,159 );
1574
1575 // Row profile ///////////
1576 if(fVerb) cout << " Number of pads " << numofpads << endl;
1577 for(Int_t padnr = 0; padnr<numofpads;padnr++)
1578 {
1579 Int_t addrinrow = fMapHand->GetPadAddInRow(row,padnr );
1580 Int_t channel = (Int_t)fHistAddrMapIndex->GetBinContent(addrinrow);
1581 if(channel==-1) continue;
1582
1583 hrow_max->SetBinContent(padnr+1,fHistAddrMaxAdc->GetBinContent(addrinrow));
1584 TH1D *hp = fHistChannelTime->ProjectionY("hp",channel,channel);
1585 for(Int_t time = 0;time<GetTimeBins();time++) {
1586
1587 Float_t val = hp->GetBinContent(time);
1588 hrow_time->SetCellContent(padnr+1,time+1,val);
1589 }
1590 }
1591
1592 // X profile /////////////
1593 Double_t xval = 0.0;
1594 Double_t yval = 0.0;
1595 GetXY(xval,yval,numofpads,row,pad);
1596
1597 Int_t padnr = 0;
1598 Int_t hw = 0;
1599 for(Int_t nrow = 0; nrow<159; nrow++)
1600 {
1601 padnr = GetPadAtX(xval,nrow);
1602 if(padnr>=0)
1603 {
1604 hw = fMapHand->GetPadAddInRow(nrow,padnr);
1605 if(fPadMapHw[hw]==-1){ continue ; }
1606 else { hx_max->SetBinContent(nrow+1,fHistAddrMaxAdc->GetBinContent(hw)) ; }
1607 }
1608 }
1609
1610 cx_max->cd();
1611 Char_t hx_titl[50] ; sprintf(hx_titl,"max adc in pads at x=%5.1f mm",xval);
1612 hx_max->SetTitle(hx_titl);
1613 hx_max->SetXTitle("row");
1614 if(!GetPedestals()) hx_max->SetYTitle("max adc (baseline sub.)");
1615 else hx_max->SetYTitle("max adc ");
1616 hx_max->SetMinimum(0.01);
1617 hx_max->Draw("l");
1618
1619 if(setrange)
1620 {
1621 hx_max->GetXaxis()->SetRange(prof_x_xmin,prof_x_xmax);
1622 hx_max->SetMinimum(prof_x_ymin);
1623 hx_max->SetMaximum(prof_x_ymax);
1624 }
1625
1626 cx_max->Update();
1627
1628 crow_time->cd();
1629 Char_t title[256];
1630 Char_t title_max[256];
1631 if(ROC==1) {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row) ; sprintf(title_max,"IROC max/sum Row=%d",row );}
1632 else {sprintf(title,"%s Row=%d",((TH2*)select)->GetTitle(),row-63); sprintf(title_max,"OROC max/sum Row=%d",row-63);}
1633 if(fVerb) cout << " set name " << endl;
1634
1635
1636 // row vs time
1637 crow_time->cd();
1638 hrow_time->SetTitleSize(0.04);
1639 hrow_time->SetTitle(title);
1640 hrow_time->SetYTitle("timbin");
1641 hrow_time->SetXTitle("pad in row");
1642 hrow_time->SetZTitle("signal (ADC)");
1643
1644 hrow_time->GetXaxis()->SetTitleColor(1);
1645 hrow_time->SetMaximum(1000.0);
1646 hrow_time->SetMinimum(0.0);
1647
1648 if(setrange)
1649 {
1650 hrow_time->GetXaxis()->SetRange(row_time_xmin,row_time_xmax);
1651 hrow_time->GetYaxis()->SetRange(row_time_ymin,row_time_ymax);
1652 hrow_time->SetMinimum(row_time_zmin);
1653 hrow_time->SetMaximum(row_time_zmax);
1654 }
1655
1656 hrow_time->Draw("COLZ");
1657 crow_time->UseCurrentStyle();
1658 crow_time->Update();
1659
1660 // max and sum /////////////////////////
1661 crow_max->cd();
1662 if(setrange) {
1663 hrow_max->GetXaxis()->SetRange(prof_row_xmin,prof_row_xmax);
1664 hrow_max->SetMinimum(prof_row_ymin);
1665 hrow_max->SetMaximum(prof_row_ymax);
1666 }
1667 hrow_max->SetTitleSize(0.04);
1668 hrow_max->SetTitle(title);
1669 hrow_max->SetYTitle("max adc");
1670 hrow_max->SetXTitle("pad in row");
1671 hrow_max->GetXaxis()->SetTitleColor(1);
1672
1673 hrow_max->SetLineColor(2);
1674 hrow_max->Draw("l");
1675 crow_max->Update();
1676
1677 return;
1678}
1679
1680//__________________________________________________________________
1681void AliTPCMonitor::Write10bitChannel()
1682{
1683
1684 // Write 10 bit words form histogram for active(last pointed) channel
1685
1686 if(fPadUsedHwAddr==-1){ AliWarning(" No active pad "); return ;}
1687
1688 Int_t pad = (Int_t)fMapHand->GetPad( fPadUsedHwAddr);
1689 Int_t row = (Int_t)fMapHand->GetPadRow(fPadUsedHwAddr);
1690 Int_t channel = (Int_t)fPadMapHw[fPadUsedHwAddr];
1691
1692 Char_t filename_root[256];
1693 Char_t filename_dat[256];
1694 Char_t projhist[256];
1695
1696 if(fPadUsedRoc==1) { sprintf(projhist,"ProjectionOROC"); }
1697 if(fPadUsedRoc==0) { sprintf(projhist,"ProjectionIROC"); }
1698
1699 sprintf(filename_dat, "Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.dat" ,fRunId,fEventNumber,pad,row);
1700 sprintf(filename_root,"Channel_Run%05i_EventID_%i_Pad_%i_Row_%i.root" ,fRunId,fEventNumber,pad,row);
1701
1702 TH1D* hpr = 0;
1703 if(hpr=(TH1D*)gROOT->Get(projhist))
1704 {
1705 // root histo
1706 TFile f(filename_root,"recreate");
1707 hpr->Write();
1708 f.Close();
1709
1710 // raw singal
1711 ofstream datout(filename_dat,ios::out);
1712 datout <<"Timebin \t ADC value " << endl;
1713 for(Int_t i = 1; i <GetTimeBins(); i++)
1714 {
1715 datout << i << " \t \t " << fPad[channel][i] << endl;
1716 }
1717 datout.close();
1718 }
1719 else
1720 {
1721 AliWarning("No projection histo found ");
1722 }
1723}
1724
1725//__________________________________________________________________
1726void AliTPCMonitor::ExecTransform()
1727{
1728
1729 // Make Fast Fourier Transformation for active pad
1730 // fft is only performed for a data sample of size 2^n
1731 // reduce window according to largest power of 2 which is smaller than the viewing range
1732
1733 Char_t namecanv[256];
1734 Char_t projhist[256];
1735 Char_t name_htr_imag[256];
1736 Char_t name_htr_real[256];
1737
1738 if(fPadUsedRoc==1) { sprintf(namecanv,"coroc_ch_trans") ; sprintf(projhist,"ProjectionOROC"); }
1739 if(fPadUsedRoc==0) { sprintf(namecanv,"ciroc_ch_trans") ; sprintf(projhist,"ProjectionIROC"); }
1740
1741 TH1D* hproj = 0;
1742
1743 if((TH1D*)gROOT->Get(projhist)==0){AliWarning("Proj histo does not exist \n Move mouse over 2d histo choose channel \n and drag mouse form histo again!"); return ;}
1744 else hproj = (TH1D*)gROOT->Get(projhist) ;
1745
1746
1747 if(fPadUsedRoc==1) { sprintf(name_htr_imag,"htrans_imag_freq_oroc"); sprintf(name_htr_real,"htrans_real_freq_oroc"); }
1748 else { sprintf(name_htr_imag,"htrans_imag_freq_iroc"); sprintf(name_htr_real,"htrans_real_freq_iroc"); }
1749
1750 if( gROOT->Get(name_htr_imag)) delete gROOT->Get(name_htr_imag);
1751 if( gROOT->Get(name_htr_real)) delete gROOT->Get(name_htr_real);
1752
1753 TCanvas *ctrans = 0;
1754 if(!(ctrans = (TCanvas*)gROOT->GetListOfCanvases()->FindObject(namecanv)))
1755 {
1756 ctrans = CreateCanvas(namecanv);
1757 ctrans->Divide(1,2);
1758 }
1759
1760 Int_t bin_first = hproj->GetXaxis()->GetFirst();
1761 Int_t bin_last = hproj->GetXaxis()->GetLast();
1762 Int_t bins = bin_last -bin_first +1;
1763
1764 Int_t power = 0;
1765 for(Int_t pot = 0; pot<=10 ; pot++)
1766 {
1767 Int_t comp = (Int_t)TMath::Power(2,pot);
1768 if(bins>=comp)power = pot;
1769 }
1770
1771 bins = (Int_t)TMath::Power(2,power);
1772
1773 // sampling frequency ;
1774 Double_t delta_t = 1.0/(Float_t)GetSamplingFrequency();
1775
1776 // output histo
1777 TH1D* htrans_real_freq = new TH1D(name_htr_real,name_htr_real,10000,-1/(2*delta_t),1/(2*delta_t));
1778 TH1D* htrans_imag_freq = new TH1D(name_htr_imag,name_htr_imag,10000,-1/(2*delta_t),1/(2*delta_t));
1779
1780
1781 Char_t title_real[256];
1782 Char_t title_imag[256];
1783 if(fPadUsedRoc==1) { sprintf(title_real,"OROC DFT real part"); sprintf(title_imag,"OROC DFT imag part"); }
1784 else { sprintf(title_real,"IROC DFT real part"); sprintf(title_imag,"IROC DFT imag part"); }
1785
1786 htrans_real_freq->SetTitle(title_real); htrans_real_freq->SetXTitle("f/hz"); htrans_real_freq->SetYTitle("z_{real}(f)");
1787 htrans_imag_freq->SetTitle(title_imag); htrans_imag_freq->SetXTitle("f/hz"); htrans_imag_freq->SetYTitle("z_{imag}(f)");
1788
1789
1790 // create complex packed data array
1791 const Int_t datasiz = 2*bins;
1792 Double_t* data = new Double_t[datasiz];
1793 for(Int_t i=0;i<2*bins;i++) { data[i] = 0.0;}
1794 for(Int_t i=0;i<bins;i++) { data[2*i] = (Double_t)hproj->GetBinContent(bin_first+i); }
1795
1796 // make fourier transformation
1797 AliTPCMonitorFFT* four = new AliTPCMonitorFFT();
1798 four->ComplexRadix2ForwardWrap(data,1,bins);
1799
1800 // write output and fill histos forward
1801 Double_t freq = 0.0;
1802 for(Int_t i=0;i<2*bins;i++)
1803 {
1804 if(i<bins)
1805 {
1806 if(i<(bins/2)) { freq = i/(bins*delta_t) ; }
1807 else { freq = -1*((bins-i)/(bins*delta_t)); }
1808 htrans_real_freq->Fill( freq,data[2*i] );
1809 htrans_imag_freq->Fill( freq,data[2*i+1]);
1810
1811
1812 }
1813 }
1814
1815 ctrans->cd(1);
1816 htrans_real_freq->Draw();
1817 ctrans->cd(2);
1818 htrans_imag_freq->Draw();
1819 ctrans->Update();
1820 delete four;
1821 delete data;
1822}
1823
1824//__________________________________________________________________
1825void AliTPCMonitor::ShowSel(Int_t* comp_val)
1826{
1827
1828 // Show only selected components
1829 // First restore original histogram from clone
1830 // Than remove all not matching pads form histos
1831
1832 Int_t connector = 0;
1833 Int_t FECnr = 0;
1834 Int_t Altro = 0;
1835 Int_t FEClocbran = 0;
1836 Int_t branch = 0;
1837 Short_t rcuget = 0;
1838 Int_t emptyI = 1;
1839 Int_t index = -1;
1840 Int_t hwadd = 0;
1841
1842 Float_t maxiroc = fHistIROCClone->GetMaximum();
1843 Float_t maxoroc = fHistOROCClone->GetMaximum();
1844
1845
1846 // restore original histos
1847 for(Int_t row = 0; row<kNRowsIroc; row++)
1848 {
1849 for(Int_t pad = 0; pad<kNPadsIroc; pad++)
1850 {
1851 index = (Int_t)fHistIROCIndex->GetCellContent(row+1,pad+1);
1852 if(index==-1)continue;
1853 else fHistIROC->SetCellContent(row+1,pad+1,fHistIROCClone->GetCellContent(row+1,pad+1));
1854 }
1855 }
1856 for(Int_t row = 0; row<kNRowsOroc; row++)
1857 {
1858 for(Int_t pad = 0; pad<kNPadsOroc; pad++)
1859 {
1860 index = (Int_t)fHistOROCIndex->GetCellContent(row+1,pad+1);
1861 if(index==-1)continue;
1862 else fHistOROC->SetCellContent(row+1,pad+1,fHistOROCClone->GetCellContent(row+1,pad+1));
1863 }
1864 }
1865
1866
1867 // remove not matching entries from fHistIROC/fHistOROC
1868
1869 TH2F* fHist =0;
1870 TH2S* fHistIndex =0;
1871 Int_t npads =0;
1872 Int_t subrows =0;
1873
1874 for(Int_t row = 0; row< (kNRowsIroc + kNRowsOroc); row++)
1875 {
1876 if(row<kNRowsIroc) { fHist=fHistIROC ; fHistIndex = fHistIROCIndex; npads = kNPadsIroc; subrows =0 ;}
1877 else { fHist=fHistOROC ; fHistIndex = fHistOROCIndex; npads = kNPadsOroc; subrows =kNRowsIroc;}
1878
1879 for(Int_t pad = 0; pad<npads; pad++)
1880 {
1881 index = (Int_t)fHistIndex->GetCellContent(row -subrows +1,pad+1);
1882 if(index==-1) continue ;
1883 hwadd = (Int_t)fHistChannelTime->GetCellContent(index,0);
1884
1885 // global fecnr
1886 FECnr = fMapHand->GetFECfromHw(hwadd);
1887 if(comp_val[0]!=-1 && FECnr!=comp_val[0]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1888
1889 // rcu
1890 rcuget = (hwadd & AliTPCMonitorAltro::GetHwMaskRCU())>> 12;
1891 if(comp_val[1]!=-1 && rcuget!=comp_val[1]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1892
1893 // branch
1894 branch = fMapHand->U2fGetBranch(FECnr) ;
1895 if(comp_val[2]!=-1 && branch!=comp_val[2]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1896
1897 // local fec
1898 FEClocbran= fMapHand->U2fGetFECinBranch(FECnr) ;
1899 if(comp_val[3]!=-1 && FEClocbran!=comp_val[3]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1900
1901 // connector
1902 connector = fMapHand->GetFECconnector(hwadd);
1903 if(comp_val[4]!=-1 && connector!=comp_val[4]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1904
1905 // Altro chip
1906 Altro = fMapHand->GetAltro(hwadd);
1907 if(comp_val[5]!=-1 && Altro!=comp_val[5]) { fHist->SetCellContent(row-subrows+1,pad+1,0); continue; }
1908 emptyI =0;
1909 }
1910 }
1911
1912 TCanvas* c1 =0;
1913 TCanvas* c2 =0;
1914 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
1915 {
1916 c1 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("ciroc");
1917 c1->cd() ;
1918 fHistIROC->Draw("COLZ");
1919 fHistIROC->SetMaximum(maxiroc);
1920 fHistIROC->SetMinimum(0.0);
1921 c1->Update();
1922 }
1923 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
1924 {
1925 c2 = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("coroc");
1926 c2->cd() ;
1927 fHistOROC->Draw("COLZ");
1928 fHistOROC->SetMaximum(maxoroc);
1929 fHistOROC->SetMinimum(0.0);
1930 c2->Update();
1931 }
1932 return ;
1933}
1934
1935//__________________________________________________________________
1936void AliTPCMonitor::ResizeCanv()
1937{
1938 // Resize canvases and delete some of them
1939
1940 Char_t carry1[100];
1941 sprintf(carry1,".x %s/TPC/AliTPCMonitorExec.C(1)",gSystem->Getenv("ALICE_ROOT"));
1942 Char_t carry3[100];
1943 sprintf(carry3,".x %s/TPC/AliTPCMonitorExec.C(2)",gSystem->Getenv("ALICE_ROOT"));
1944 if(fVerb) cout << " canv 1 " << endl;
1945
1946 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch") ; }
1947 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch") ; }
1948
1949 // for 2dim plots delete create and draw again
1950 if(gROOT->GetListOfCanvases()->FindObject("ciroc"))
1951 {
1952 delete gROOT->GetListOfCanvases()->FindObject("ciroc");
1953 TCanvas* ciroc = CreateCanvas("ciroc");
1954 ciroc->cd();
1955 fHistIROC->Draw("COLZ");
1956 ciroc->AddExec("pad",carry1);
1957 ciroc->AddExec("row",carry3);
1958 fExecPlaneMax=1;
1959 ciroc->Update();
1960 }
1961 // for 2dim plots delete create and draw again
1962 if(gROOT->GetListOfCanvases()->FindObject("coroc"))
1963 {
1964 delete gROOT->GetListOfCanvases()->FindObject("coroc");
1965 TCanvas* coroc = CreateCanvas("coroc");
1966 coroc->cd();
1967 fHistOROC->Draw("COLZ");
1968
1969 coroc->AddExec("pad",carry1);
1970 coroc->AddExec("row",carry3);
1971 coroc->Update();
1972 fExecPlaneMax=1;
1973 }
1974
1975 if(gROOT->GetListOfCanvases()->FindObject( "cbasemean")) { delete gROOT->GetListOfCanvases()->FindObject("cbasemean"); }
1976 if(gROOT->GetListOfCanvases()->FindObject( "cbase")) { delete gROOT->GetListOfCanvases()->FindObject("cbase");}
1977 if(gROOT->GetListOfCanvases()->FindObject( "cbaserms")) { delete gROOT->GetListOfCanvases()->FindObject("cbaserms"); }
1978 if(gROOT->GetListOfCanvases()->FindObject( "cmax")) { delete gROOT->GetListOfCanvases()->FindObject("cmax"); }
1979 if(gROOT->GetListOfCanvases()->FindObject( "csum")) { delete gROOT->GetListOfCanvases()->FindObject("csum"); }
1980 if(gROOT->GetListOfCanvases()->FindObject( "ciroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("ciroc_ch_trans");}
1981 if(gROOT->GetListOfCanvases()->FindObject( "coroc_ch_trans")) { delete gROOT->GetListOfCanvases()->FindObject("coroc_ch_trans");}
1982 if(gROOT->GetListOfCanvases()->FindObject( "crow_time")) { delete gROOT->GetListOfCanvases()->FindObject("crow_time"); }
1983 if(gROOT->GetListOfCanvases()->FindObject( "crow_max")) { delete gROOT->GetListOfCanvases()->FindObject("crow_max"); }
1984 if(gROOT->GetListOfCanvases()->FindObject( "cx_max")) { delete gROOT->GetListOfCanvases()->FindObject("cx_max"); }
1985 if(gROOT->GetListOfCanvases()->FindObject( "crmsoroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsoroc"); fExecPadOrocRms = 0; }
1986 if(gROOT->GetListOfCanvases()->FindObject( "crmsiroc")) { delete gROOT->GetListOfCanvases()->FindObject("crmsiroc"); fExecPadIrocRms = 0; }
1987 if(gROOT->GetListOfCanvases()->FindObject( "crow_max")) { delete gROOT->GetListOfCanvases()->FindObject("crow_max"); }
1988 if(gROOT->GetListOfCanvases()->FindObject( "crow_max")) { delete gROOT->GetListOfCanvases()->FindObject("crow_max"); }
1989
1990}
1991
1992
1993
1994
1995//__________________________________________________________________
1996Int_t AliTPCMonitor::ExecProcess()
1997{
1998 // Executable for global Histogram
1999 // Will be called from /TPC/AliTPCMonitorExec.C(3)
2000 // Call ProcessEvent for same event and sector pointed at
2001
2002 Int_t side = 0;
2003 Int_t sector = 0;
2004
2005 Int_t event = gPad->GetEvent();
2006 if(event != 61) return -1;
2007
2008 TObject *select = gPad->GetSelected();
2009 if(!select) return -1;
2010 if(!select->InheritsFrom("TH2")) {gPad->SetUniqueID(0); return -1; }
2011 if( strcmp(select->GetName(),"hglobal" )==0 || ( strcmp(select->GetName(),"SIDE A" )==0) ) side = 0;
2012 else if( strcmp(select->GetName(),"hglobal2")==0 || ( strcmp(select->GetName(),"SIDE C" )==0) ) side = 1;
2013
2014 // get position
2015 Int_t px = gPad->GetEventX();
2016 Int_t py = gPad->GetEventY();
2017 Float_t upy = gPad->AbsPixeltoY(py);
2018 Float_t upx = gPad->AbsPixeltoX(px);
2019 Float_t y = gPad->PadtoY(upy);
2020 Float_t x = gPad->PadtoX(upx);
2021
2022 Int_t testy = ((TH2*)select)->GetYaxis()->FindBin(y);
2023 Int_t testx = ((TH2*)select)->GetXaxis()->FindBin(x);
2024 if(((TH2*)select)->GetCellContent(testx,testy)==0) return -1 ;
2025
2026 Float_t alpha = 0.0;
2027 if(x>0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2028 if(x>0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2029 if(x<0.0 && y < 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(x/y)));
2030 if(x<0.0 && y > 0.0) alpha = TMath::Abs(TMath::ATan(TMath::Abs(y/x)));
2031
2032 if(x>0.0 && y < 0.0) alpha += ( TMath::Pi()/2);
2033 if(x<0.0 && y < 0.0) alpha += ( TMath::Pi());
2034 if(x<0.0 && y > 0.0) alpha += (1.5*TMath::Pi());
2035
2036 sector = (Int_t)(alpha/(2*TMath::Pi()/18.0));
2037 if(alpha> (sector+0.5)*(2*TMath::Pi()/18.0)) sector+=1;
2038
2039 if(sector==18 && side ==0 ) {
2040 AliWarning("There was a wromg assignment of sector 0 with sector 18. Check sectors");
2041 sector =0;
2042 }
2043
2044 sector = (18-sector +4)%18;
2045 SetLastSector(sector+ side*18);
2046 SetProcNextEvent(0);
2047
2048 if(fVerb) cout << "AliTPCMonitor::ExecProcess() next side " << side << " next sector " << sector << endl;
2049
2050 return (Int_t)ProcessEvent();
2051
2052}
2053
2054//__________________________________________________________________
2055Int_t AliTPCMonitor::GetRCUPatch(Int_t runid, Int_t eqid)
2056{
2057
2058 // Return RCU patch index for given equipment id eqid
2059 Int_t patch = 0;
2060 //if(runid>=704)
2061 if(runid>=0)
2062 {
2063 if(eqid>=1000) return 0;
2064 patch = fMapEqidsRcu[eqid] ;
2065 }
2066 else
2067 {
2068 if(eqid==408) {patch = 13*6+4 +0; }
2069 if(eqid==409) {patch = 13*6+5 +0; }
2070 if(eqid==509) {patch = 13*6+0 +0; }
2071 if(eqid==512) {patch = 13*6+3 +0; }
2072 if(eqid==513) {patch = 13*6+1 +0; }
2073 if(eqid==517) {patch = 13*6+2 +0; }
2074
2075 if(eqid==404) {patch = 4*6+5 +0; }
2076 if(eqid==504) {patch = 4*6+4 +0; }
2077 if(eqid==407) {patch = 4*6+3 +0; }
2078 if(eqid==503) {patch = 4*6+2 +0; }
2079 if(eqid==508) {patch = 4*6+1 +0; }
2080 if(eqid==506) {patch = 4*6+0 +0; }
2081 }
2082 return patch;
2083}
2084
2085//__________________________________________________________________
2086void AliTPCMonitor::DumpHeader(AliRawReaderRoot * fReaderROOT)
2087{
2088 // Dump Event header for ROOT format
2089
2090 cout << "EventHeader : fReaderROOT->GetEquipmentSize() :" << fReaderROOT->GetEquipmentSize() << endl;
2091 cout << "EventHeader : fReaderROOT->GetType() :" << fReaderROOT->GetType() << endl;
2092 cout << "EventHeader : fReaderROOT->GetRunNumber() :" << fReaderROOT->GetRunNumber() << endl;
2093 cout << "EventHeader : fReaderROOT->GetEventId() :" << *(fReaderROOT->GetEventId()) << endl;
2094 cout << "EventHeader : fReaderROOT->GetLDCId() :" << fReaderROOT->GetLDCId() << endl;
2095 cout << "EventHeader : fReaderROOT->GetGDCId() :" << fReaderROOT->GetGDCId() << endl;
2096}
2097
2098//__________________________________________________________________
2099void AliTPCMonitor::DumpHeader(AliTPCMonitorDateFormat* DateForm)
2100{
2101 // Dump Event header for DATE format
2102
2103 cout << "EquipmentHeader : DateForm->GetEquipmentSize() :" << DateForm->GetEquipmentSize() << endl;
2104 cout << "EquipmentHeader : DateForm->GetEquipmentType() :" << DateForm->GetEquipmentType() << endl;
2105 cout << "EquipmentHeader : DateForm->GetEquipmentID() :" << DateForm->GetEquipmentID() << endl;
2106 cout << "EquipmentHeader : DateForm->GetEquipmentTypeAttribute() :" << DateForm->GetEquipmentTypeAttribute() << endl;
2107 cout << "EquipmentHeader : DateForm->GetEquipmentBasicSize() :" << DateForm->GetEquipmentBasicSize() << endl;
2108 cout << "EquipmentHeader : DateForm->GetEquipmentHeaderSize() :" << DateForm->GetEquipmentHeaderSize() << endl;
2109 cout << "EquipmentHeader : DateForm->IsLastSubEventHeader() :" << DateForm->IsLastSubEventHeader() << endl;
2110}
2111
2112//__________________________________________________________________
2113Double_t AliTPCMonitor::Gamma4(Double_t* x, Double_t* par) {
2114
2115 // Gamma4 function used to fit signals
2116 // Defined in sections: diverging branch set to 0
2117
2118 Double_t val = 0.0;
2119 if(x[0] > par[1])
2120 val = par[0]*exp(4.0)* pow((x[0]-par[1])/par[2],4)*exp(-4.0*(x[0]-par[1])/par[2])+ par[3];
2121 else
2122 val = 0;
2123 return val;
2124}
2125
2126//__________________________________________________________________
2127TCanvas* AliTPCMonitor::CreateCanvas(Char_t* name)
2128{
2129 // Create Canvases
2130
2131 TCanvas* canv =0;
2132
2133 Int_t xoffset = GetCanvasXOffset();
2134 Int_t xsize = GetCanvasXSize();
2135 Int_t ysize = GetCanvasYSize();
2136 Int_t xspace = GetCanvasXSpace();
2137 Int_t yspace = GetCanvasYSpace();
2138
2139 // ROC 2dim max distribution
2140 if( strcmp(name,"coroc" )==0) { canv = new TCanvas("coroc" ,"coroc" , -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2141 else if(strcmp(name,"ciroc" )==0) { canv = new TCanvas("ciroc" ,"ciroc" , -1+xoffset, 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2142 // ROC 2dim rms distribution
2143 else if(strcmp(name,"crmsoroc" )==0) { canv = new TCanvas("crmsoroc" ,"crmsoroc" , -1+xoffset,(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2144 else if(strcmp(name,"crmsiroc" )==0) { canv = new TCanvas("crmsiroc" ,"crmsiroc" , -1+xoffset, 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2145 // Global ADC max Histos
2146 else if(strcmp(name,"SIDE C all" )==0) { canv = new TCanvas("SIDE C all" ,"SIDE C all" , (Int_t)(3*xspace+ xoffset),(Int_t)(yspace+0.5*ysize) ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2147 else if(strcmp(name,"SIDE A all" )==0) { canv = new TCanvas("SIDE A all" ,"SIDE A all" , (Int_t)(3*xspace+ xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2148 // 1 dim max sum basekine distribution
2149 else if(strcmp(name,"cmax" )==0) { canv = new TCanvas("cmax" ,"cmax" , -1+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2150 else if(strcmp(name,"csum" )==0) { canv = new TCanvas("csum" ,"csum" , xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2151 else if(strcmp(name,"cbasemean" )==0) { canv = new TCanvas("cbasemean" ,"cbasemean" , 2*xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2152 else if(strcmp(name,"cbaserms" )==0) { canv = new TCanvas("cbaserms" ,"cbaserms" , 3*xspace+xoffset, 3*yspace ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2153 // Projections of single channel
2154 else if(strcmp(name,"coroc_ch" )==0) { canv = new TCanvas("coroc_ch" ,"coroc_ch" , (Int_t)(1.5*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2155 else if(strcmp(name,"ciroc_ch" )==0) { canv = new TCanvas("ciroc_ch" ,"ciroc_ch" , (Int_t)(1.5*xspace+xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2156 // FFT for single channel
2157 else if(strcmp(name,"coroc_ch_trans")==0) { canv = new TCanvas("coroc_ch_trans","coroc_ch_trans",(Int_t)(3.0*xspace+xoffset),(Int_t)(yspace+0.5*ysize),(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2158 else if(strcmp(name,"ciroc_ch_trans")==0) { canv = new TCanvas("ciroc_ch_trans","ciroc_ch_trans",(Int_t)(3.0*xspace+xoffset), 0 ,(Int_t)(1.5*xsize),(Int_t)(1.5*ysize)); return canv; }
2159 // row profile histograms
2160 else if(strcmp(name,"crow_time" )==0) { canv = new TCanvas("crow_time" ,"crow_time" , 1*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2161 else if(strcmp(name,"crow_max" )==0) { canv = new TCanvas("crow_max" ,"crow_max" , 2*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2162 else if(strcmp(name,"cx_max" )==0) { canv = new TCanvas("cx_max" ,"cx_max" , 3*xspace+xoffset, 2*yspace +ysize ,(Int_t)(1.0*xsize),(Int_t)(1.0*ysize)); return canv; }
2163 else { cout << " Warning Canvas name unknown " << endl; return 0 ; }
2164}
2165
2166//__________________________________________________________________
2167void AliTPCMonitor::WriteHistos()
2168{
2169 // Writes all available histograms to a file in current directory
2170 // File name will be specified by : sector, side, runid and eventnumber
2171
2172 if(GetEventProcessed())
2173 {
2174 AliInfo("Write histos to file");
2175 Char_t name[256];
2176 sprintf(name,"SIDE_%i_SECTOR_%02i_RUN_%05i_EventID_%06i.root",(GetLastSector()/18),(GetLastSector()%18),fRunId,fEventNumber);
2177 TFile* f = new TFile(name,"recreate");
2178 for(Int_t i =0; i<fHistList->GetEntries(); i++)
2179 {
2180 if(((TH1*)fHistList->At(i))!=0)
2181 {
2182 ((TH1*)fHistList->At(i))->Write();
2183 }
2184 }
2185 f->ls();
2186 f->Close();
2187 }
2188 else
2189 {
2190 AliError("No Event Processed : Chose Format , File and push 'Next Event' ");
2191 }
2192}
2193
2194
2195//__________________________________________________________________
2196TH1* AliTPCMonitor::GetHisto(char* histname)
2197{
2198
2199 // Returns histogram specified by histname
2200 // check available names for histos in CreateHistos()
2201
2202 TH1* hist = 0;
2203 if((TH1*)fHistList->FindObject(histname))
2204 {
2205 hist = (TH1*)fHistList->FindObject(histname);
2206 }
2207 else
2208 {
2209 cout << " AliTPCMonitor::GetHisto :: Can not find histo with name " << histname << endl;
2210 }
2211 return hist ;
2212}