First version of the SPD online calibration detector algorithm (Henrik)
[u/mrichter/AliRoot.git] / ITS / ITSSPDda.cxx
CommitLineData
3ec5024c 1//////////////////////////////////////////////////////////////////////////////
2// This program can be run in two modes. //
3// //
4// 1. With the DAQ DA framework on. In Makefile: -DDA_OFF flag outcommented.//
5// Call this program with the name of the executable followed by the //
6// data files to process. //
7// //
8// 2. Without the DAQ DA framework on. In Makefile: with -DDA_OFF flag. //
9// Call this program with the name of the executable followed by the //
10// runNr and the data files to process. //
11// //
12//////////////////////////////////////////////////////////////////////////////
13
14extern "C" {
15#include "daqDA.h"
16}
17#include "event.h"
18#include "monitor.h"
19#include "AliRawReaderDate.h"
20#include "AliITSRawStreamSPD.h"
21#include "AliITSOnlineSPDscan.h"
22#include "AliITSOnlineSPDscanSingle.h"
23#include "AliITSOnlineSPDscanMultiple.h"
24#include "AliITSOnlineSPDscanMeanTh.h"
25#include "AliITSOnlineSPDscanAnalyzer.h"
26#include "AliLog.h"
27#include <iostream>
28#include <fstream>
29#include <TROOT.h>
30#include <TPluginManager.h>
31
32
33int main(int argc, char **argv) {
34 if (argc<2) {
35 printf("Wrong number of arguments\n");
36 return -1;
37 }
38
39 char *saveDirNoisy = "./calibResults/Noisy"; // hard wired for now!!!
40#ifndef DA_OFF
41 char *saveDirNoisyToFXS = "./calibResults/NoisyToFXS"; // hard wired for now!!!
42#endif
43 char *saveDirParameters = "./calibResults/Parameters"; // hard wired for now!!!
44 char *saveDirRef = "./calibResults/Reference"; // hard wired for now!!!
45
46 // This line is needed in case of a stand-alone application w/o
47 // $ROOTSYS/etc/system.rootrc file
48 gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo",
49 "*",
50 "TStreamerInfo",
51 "RIO",
52 "TStreamerInfo()");
53
54 // turn off annoying warning messages
55 new AliLog;
56 AliLog::Instance()->SetModuleDebugLevel("ROOT", -2);
57
58 // calib scan types
59 enum calib_types{MINTH,MEANTH,DAC,UNIMA,NOISE,DELAY};
60
61
62 // ********* STEP 1: Produce scan container files. ***********************************
63 int startSeg = 1;
64
65#ifndef DA_OFF
66 int runNr = atoi(getenv("DATE_RUN_NUMBER"));
67#else
68 int runNr = atoi(argv[1]);
69 startSeg = 2;
70#endif
71
72 // container objects
73 AliITSOnlineSPDscan *scanObj[20];
74 Bool_t bScanInit[20];
75 for (UInt_t eqId=0; eqId<20; eqId++) {
76 scanObj[eqId]=NULL;
77 bScanInit[eqId]=kFALSE;
78 }
79 // header data variables
80 UInt_t routerNr[20];
81 Bool_t halfStaveScanned[20][6];
82 UInt_t type[20];
83 Bool_t dataFormat[20];
84 UInt_t triggers[20];
85 Bool_t chipPresent[20][6][10];
86 UInt_t dacStart[20];
87 UInt_t dacEnd[20];
88 UInt_t dacStep[20];
89 UInt_t dacId[20];
90 UInt_t rowStart[20];
91 UInt_t rowEnd[20];
92 UInt_t rowValue[20];
93 UInt_t dacValue[20];
94 UInt_t dacHigh[20][6];
95 UInt_t dacLow[20][6];
96 UInt_t TPAmp[20][6];
97 // current scan step flag
98 Int_t currentStep[20];
99 for (UInt_t eqId=0; eqId<20; eqId++) currentStep[eqId] = 9999;
100
101 // loop over run segments
102 for (int segNr=startSeg; segNr<argc; segNr++) {
103
104
105 int status;
106
107 /* define data source : this is argument 1 */
108 status=monitorSetDataSource( argv[segNr] );
109 if (status!=0) {
110 printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
111 return -1;
112 }
113 /* declare monitoring program */
114 status=monitorDeclareMp("ITS_SPD_CAL");
115 if (status!=0) {
116 printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
117 return -1;
118 }
119 /* define wait event timeout - 1s max */
120 monitorSetNowait();
121 monitorSetNoWaitNetworkTimeout(1000);
122
123
124 struct eventHeaderStruct *event;
125 eventTypeType eventT;
126 UInt_t eventNr=0;
127
128
129 /* main loop (infinite) */
130 for(;;) {
131
132 /* check shutdown condition */
133 if (daqDA_checkShutdown()) {break;}
134 /* get next event (blocking call until timeout) */
135 status=monitorGetEventDynamic((void **)&event);
136 if (status==MON_ERR_EOF) {
137 printf ("End of File detected\n");
138 break; /* end of monitoring file has been reached */
139 }
140 if (status!=0) {
141 printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
142 break;
143 }
144 /* retry if got no event */
145 if (event==NULL) {
146 printf("event==NULL\n");
147 continue;
148 }
149
150 eventT=event->eventType;
151 if (event->eventType == PHYSICS_EVENT){
152
153
154 eventNr++;
155 // printf("eventNr %d\n",eventNr);
156
157 AliRawReader *reader = new AliRawReaderDate((void*)event);
158 AliITSRawStreamSPD *str = new AliITSRawStreamSPD(reader);
159
160
161 for (UInt_t eqId=0; eqId<20; eqId++) {
162
163 reader->Reset();
164 reader->Select("ITSSPD",eqId,eqId);
165
166 // Hit Event flags, specific for one event
167 Bool_t hitEventHSIncremented[6];
168 Bool_t hitEventChipIncremented[6][10];
169 for (UInt_t hs=0; hs<6; hs++) {
170 hitEventHSIncremented[hs] = kFALSE;
171 for (UInt_t chip=0; chip<10; chip++) {
172 hitEventChipIncremented[hs][chip] = kFALSE;
173 }
174 }
175
176 if (str->ReadCalibHeader()) {
177 // first check the type:
178 if (bScanInit[eqId] && type[eqId]!=str->GetHtype()) {
179 printf("Calib header problem. Type changed (%d -> %d)!\n",type[eqId],str->GetHtype());
180 }
181
182 // read calib values
183 routerNr[eqId] = str->GetHrouterNr();
184 type[eqId] = str->GetHtype();
185 dataFormat[eqId] = str->GetHdataFormat();
186 triggers[eqId] = str->GetHtriggers();
187 dacStart[eqId] = str->GetHdacStart();
188 dacEnd[eqId] = str->GetHdacEnd();
189 dacStep[eqId] = str->GetHdacStep();
190 dacId[eqId] = str->GetHdacId();
191 rowStart[eqId] = str->GetHrowStart();
192 rowEnd[eqId] = str->GetHrowEnd();
193 rowValue[eqId] = str->GetHrowValue();
194 dacValue[eqId] = str->GetHdacValue();
195 for (UInt_t hs=0; hs<6; hs++) {
196 halfStaveScanned[eqId][hs]=str->GetHhalfStaveScanned(hs);
197 dacHigh[eqId][hs] = str->GetHdacHigh(hs);
198 dacLow[eqId][hs] = str->GetHdacLow(hs);
199 TPAmp[eqId][hs] = str->GetHTPAmp(hs);
200 for (UInt_t chip=0; chip<10; chip++) {
201 chipPresent[eqId][hs][chip] = str->GetHchipPresent(hs,chip);
202 }
203 }
204
205 currentStep[eqId] = (dacValue[eqId]-dacStart[eqId])/dacStep[eqId];
206 if (type[eqId]==DELAY) {
207 currentStep[eqId]=currentStep[eqId]*2;
208 dacValue[eqId]=dacValue[eqId]*2;
209 if (dacHigh[eqId][0]==128) { // misc_ctrl value
210 currentStep[eqId]=currentStep[eqId]+1;
211 dacValue[eqId]=dacValue[eqId]+1;
212 }
213 }
214
215 // router nr check:
216 if (routerNr[eqId]!=eqId) {
217 printf("Router nr problem? Router nr %d != EqID %d\n",routerNr[eqId],eqId);
218 }
219
220 if (!bScanInit[eqId]) {
221 // initialize container object
222 Char_t fileName[200];
223 sprintf(fileName,"%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
224 switch (type[eqId]) {
225 case NOISE:
226 case UNIMA:
227 scanObj[eqId] = new AliITSOnlineSPDscanSingle(fileName);
228 ((AliITSOnlineSPDscanSingle*)scanObj[eqId])->ClearThis();
229 bScanInit[eqId]=kTRUE;
230 break;
231 case MINTH:
232 case DAC:
233 case DELAY:
234 scanObj[eqId] = new AliITSOnlineSPDscanMultiple(fileName);
235 scanObj[eqId]->ClearThis();
236 bScanInit[eqId]=kTRUE;
237 break;
238 case MEANTH:
239 scanObj[eqId] = new AliITSOnlineSPDscanMeanTh(fileName);
240 scanObj[eqId]->ClearThis();
241 bScanInit[eqId]=kTRUE;
242 break;
243 default:
244 printf("Unknown scan type: %d.\n",type[eqId]);
245 }
246 // some multiple scan data
247 if (type[eqId]==MINTH || type[eqId]==MEANTH || type[eqId]==DAC || type[eqId]==DELAY) {
248 ((AliITSOnlineSPDscanMultiple*)scanObj[eqId])->SetDacId(dacId[eqId]);
249 }
250 // some common data
251 scanObj[eqId]->SetRunNr((UInt_t)runNr);
252 scanObj[eqId]->SetRouterNr(routerNr[eqId]);
253 for (UInt_t hs=0; hs<6; hs++) {
254 scanObj[eqId]->SetHalfStaveScanned(hs,halfStaveScanned[eqId][hs]);
255 }
256 scanObj[eqId]->SetType(type[eqId]);
257 scanObj[eqId]->SetDataFormat(dataFormat[eqId]);
258 for (Int_t hs=0; hs<6; hs++) {
259
260 // remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
261 Bool_t halfStavePresent = str->GetHalfStavePresent(hs);
262 // remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
263
264 for (UInt_t chip=0; chip<10; chip++) {
265 scanObj[eqId]->SetChipPresent(hs,chip,chipPresent[eqId][hs][chip]);
266
267 // remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
268 if (halfStavePresent) scanObj[eqId]->SetChipPresent(hs,chip,kTRUE);
269 // remove later when the chip present is set correctly !!!!!!!!!!!!!!!!!!!!!!!!!!!
270
271 }
272 }
273 scanObj[eqId]->SetRowStart(rowStart[eqId]);
274 scanObj[eqId]->SetRowEnd(rowEnd[eqId]);
275 scanObj[eqId]->SetDacStart(dacStart[eqId]);
276 scanObj[eqId]->SetDacEnd(dacEnd[eqId]);
277 scanObj[eqId]->SetDacStep(dacStep[eqId]);
278 }
279
280 if (type[eqId]==MINTH) {
281 scanObj[eqId]->SetTriggers(currentStep[eqId],triggers[eqId]);
282 }
283 if (type[eqId]==UNIMA || type[eqId]==NOISE) {
284 if (currentStep[eqId]==9999) printf("SPDcalibratorStep1 (eq %d): single step\n",eqId);
285 currentStep[eqId]=0;
286 }
287 if (type[eqId]==MINTH || type[eqId]==MEANTH || type[eqId]==DAC || type[eqId]==DELAY) {
288 ((AliITSOnlineSPDscanMultiple*)scanObj[eqId])->SetDacValue(currentStep[eqId],dacValue[eqId]);
289 if (type[eqId]==DELAY) {
290 printf("SPDcalibratorStep1 (eq %d): DAC %d/%d , step %d\n",eqId,dacValue[eqId]/2,dacHigh[eqId][0],currentStep[eqId]);
291 }
292 else {
293 printf("SPDcalibratorStep1 (eq %d): DAC %d , step %d\n",eqId,dacValue[eqId],currentStep[eqId]);
294 }
295 }
296 if (type[eqId]==MEANTH) {
297 for (Int_t hs=0; hs<6; hs++) {
298 ((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetDacLow(currentStep[eqId],hs,dacLow[eqId][hs]);
299 ((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetDacHigh(currentStep[eqId],hs,dacHigh[eqId][hs]);
300 ((AliITSOnlineSPDscanMeanTh*)scanObj[eqId])->SetTPAmp(currentStep[eqId],hs,TPAmp[eqId][hs]);
301 }
302 }
303
304
305 }
306
307 if (bScanInit[eqId]) {
308 while (str->Next()) {
309 UInt_t hs = str->GetHalfStaveNr();
310 UInt_t chip = str->GetChipAddr();
311
312 if (type[eqId]!=MINTH || dacHigh[eqId][0]==chip) { // dachigh[0] holds chip scanned for minth
313
314 scanObj[eqId]->IncrementHits(currentStep[eqId],hs,chip,str->GetChipCol(),str->GetChipRow());
315
316 if (!hitEventHSIncremented[hs]) {
317 scanObj[eqId]->IncrementHitEventsTot(currentStep[eqId],hs);
318 hitEventHSIncremented[hs]=kTRUE;
319 }
320
321 if (!hitEventChipIncremented[hs][chip]) {
322 scanObj[eqId]->IncrementHitEvents(currentStep[eqId],hs,chip);
323 hitEventChipIncremented[hs][chip]=kTRUE;
324 }
325 }
326
327 }
328
329 if (type[eqId]!=MINTH) { // for minth, triggers are set from header info
330 scanObj[eqId]->IncrementTriggers(currentStep[eqId]);
331 }
332
333 }
334
335 }
336
337 delete str;
338 delete reader;
339
340 }
341
342 /* free resources */
343 free(event);
344
345 }
346
347 status = monitorLogout();
348 if (status != 0) {
349 printf("monitorLogout() failed : %s\n",monitorDecodeError(status));
350 return -1;
351 }
352
353#ifndef DA_OFF
354 daqDA_progressReport((unsigned int)( ((Float_t)(segNr-startSeg+1))/(argc-startSeg)*50 ));
355#else
356 printf("progress: %d\n",(unsigned int)( ((Float_t)(segNr-startSeg+1))/(argc-startSeg)*50 ));
357#endif
358
359 }
360
361 // clean up scan objects
362 for (UInt_t eqId=0; eqId<20; eqId++) {
363 if (scanObj[eqId]!=NULL) delete scanObj[eqId];
364 }
365
366
367
368
369
370 // ********* STEP 2: Analyze scan container files. ***********************************
371#ifndef DA_OFF
372 // clear noisyToFXS dir:
373 Char_t command[200];
374 sprintf(command,"cd %s; rm -f *",saveDirNoisyToFXS);
375 system(command);
376#endif
377
378 AliITSOnlineSPDscanAnalyzer *analyzer;
379
380 // *** *** *** start loop over equipments (eq_id)
381 for (int eqId=0; eqId<20; eqId++) {
382
383 Char_t fileName[200];
384 sprintf(fileName,"%s/SPDcal_run_%d_eq_%d.root",saveDirRef,runNr,eqId);
385 analyzer = new AliITSOnlineSPDscanAnalyzer(fileName);
386
387 Int_t type = analyzer->GetType();
388 Int_t dacId = analyzer->GetDacId();
389 if (type!=99) {
390 if (type==DAC) {
391 printf("SPD calibrator Step2: eqId %d, type %d, dacId %d\n",eqId,type,dacId);
392 }
393 else printf("SPD calibrator Step2: eqId %d type %d\n",eqId,type);
394 }
395
396
397
398
399 if (type==UNIMA) {
400 }
401 else if (type==NOISE) {
402 if (analyzer->ProcessNoisyPixels(saveDirNoisy)) {
403 for (UInt_t module=0; module<240; module++) {
404 if (analyzer->SaveDeadNoisyPixels(module,saveDirNoisy)) {
405#ifndef DA_OFF
406 Char_t command[100];
407 sprintf(command,"cp %s/SPD_DeadNoisy_%d.root %s/.",saveDirNoisy,module,saveDirNoisyToFXS);
408 system(command);
409#endif
410 }
411 }
412 }
413 }
414// else if (type==DAC && dacId==42) {
415// Char_t ofileName[100];
416// sprintf(ofileName,"%s/delay_eq_%d.txt",saveDirParameters,eqId);
417// ofstream ofile;
418// ofile.open (ofileName);
419// for (UInt_t hs=0; hs<6; hs++) {
420// for (UInt_t chipNr=0; chipNr<10; chipNr++) {
421// ofile << analyzer->GetDelay(hs,chipNr);
422// ofile << "\t";
423// }
424// ofile << "\n";
425// }
426// ofile.close();
427//#ifndef DA_OFF
428// Char_t id[20];
429// sprintf(id,"SPD_delay_%d",eqId);
430// Int_t status = daqDA_FES_storeFile(ofileName,id);
431// if (status) {
432// printf("Failed to export file %s , status %d\n",ofileName,status);
433// }
434//#endif
435// }
436 else if (type==MINTH || (type==DAC && dacId==39)) {
437 Char_t ofileName[100];
438 sprintf(ofileName,"%s/minth_eq_%d.txt",saveDirParameters,eqId);
439 ofstream ofile;
440 ofile.open (ofileName);
441 for (UInt_t hs=0; hs<6; hs++) {
442 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
443 ofile << analyzer->GetMinTh(hs,chipNr);
444 ofile << "\t";
445 }
446 ofile << "\n";
447 }
448 ofile.close();
449#ifndef DA_OFF
450 Char_t id[20];
451 sprintf(id,"SPD_minth_%d",eqId);
452 Int_t status = daqDA_FES_storeFile(ofileName,id);
453 if (status) {
454 printf("Failed to export file %s , status %d\n",ofileName,status);
455 }
456#endif
457 }
458 else if (type==DELAY) {
459 Char_t ofileName[100];
460 sprintf(ofileName,"%s/delay_eq_%d.txt",saveDirParameters,eqId);
461 ofstream ofile;
462 ofile.open (ofileName);
463 for (UInt_t hs=0; hs<6; hs++) {
464 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
465 UInt_t clockCycle = analyzer->GetDelay(hs,chipNr);
466 UInt_t delayCtrl = clockCycle/2;
467 UInt_t miscCtrl = 192;
468 if (clockCycle%2==1) miscCtrl = 128;
469 ofile << delayCtrl << "/" << miscCtrl;
470 ofile << "\t";
471 }
472 ofile << "\n";
473 }
474 ofile.close();
475#ifndef DA_OFF
476 Char_t id[20];
477 sprintf(id,"SPD_delay_%d",eqId);
478 Int_t status = daqDA_FES_storeFile(ofileName,id);
479 if (status) {
480 printf("Failed to export file %s , status %d\n",ofileName,status);
481 }
482#endif
483 }
484
485
486 delete analyzer;
487
488#ifndef DA_OFF
489 daqDA_progressReport((unsigned int)(50+(eqId+1)*2.5));
490#else
491 printf("progress: %d\n",(unsigned int)(50+(eqId+1)*2.5));
492#endif
493
494 }
495 // *** *** *** end loop over equipments (eq_id)
496
497
498#ifndef DA_OFF
499 // send a tared file of all new noisy maps
500 sprintf(command,"cd %s; tar -cf noisy.tar *",saveDirNoisyToFXS);
501 printf("\n\n%s\n\n",command);
502 system(command);
503 Char_t fileName[200];
504 sprintf(fileName,"%s/noisy.tar",saveDirNoisyToFXS);
505 Char_t id[20];
506 sprintf(id,"SPD_noisy");
507 Int_t status = daqDA_FES_storeFile(fileName,id);
508 if (status) {
509 printf("Failed to export file %s , status %d\n",fileName,status);
510 }
511#endif
512
513
514 return 0;
515}