Suppressed FTOS/frame overlap (A.Morsch)
[u/mrichter/AliRoot.git] / MUON / MUONTRGda.cxx
CommitLineData
9f5fafa6 1/*
2
4fd5ed63 3Version 2 for MUONTRGda MUON trigger
4Working version for:
5
6 reading back raw data
7
8 Versionning of the Mtg file
9
10 DA for ELECTRONICS_CALIBRATION_RUN (calib)
11 checking dead channels
12
13 DA for DETECTOR_CALIBRATION_RUN (ped)
14 checking the noisy channels
15
16 Interfaced with online database and file exchange server
17
18November 2007
19Ch. Finck
20
21To be done:
22 Writing into the online database (need update of daqDAlib)
23 Looking at scalers outputs
24
9f5fafa6 25
26*/
27extern "C" {
28#include <daqDA.h>
29}
30
31#include "event.h"
32#include "monitor.h"
33
34#include <Riostream.h>
35#include <stdio.h>
36#include <stdlib.h>
37
38//AliRoot
4fd5ed63 39#include "AliRawReaderDate.h"
40
41#include "AliMpConstants.h"
9f5fafa6 42#include "AliMUONRawStreamTrigger.h"
43#include "AliMUONDarcHeader.h"
44#include "AliMUONRegHeader.h"
45#include "AliMUONLocalStruct.h"
46#include "AliMUONDDLTrigger.h"
4fd5ed63 47#include "AliMUONVCalibParam.h"
48#include "AliMUONVStore.h"
49#include "AliMUONCalibParamND.h"
74e61e0d 50#include "AliMUONCalibParamNI.h"
4fd5ed63 51#include "AliMUON1DArray.h"
52#include "AliMUONTriggerIO.h"
92c23b09 53#include "AliMUONRegionalTriggerConfig.h"
54#include "AliMUONGlobalCrateConfig.h"
55#include "AliMUONTriggerCrateConfig.h"
9f5fafa6 56
57//ROOT
9f5fafa6 58#include "TString.h"
4fd5ed63 59#include "TSystem.h"
9f5fafa6 60#include "TStopwatch.h"
61#include "TMath.h"
62#include "TTimeStamp.h"
63#include "TROOT.h"
64#include "TPluginManager.h"
4fd5ed63 65#include "TFile.h"
66#include "TH1F.h"
67#include "TArrayI.h"
68#include "TArrayS.h"
9f5fafa6 69
70// global variables
92c23b09 71const Int_t gkNLocalBoard = AliMpConstants::TotalNofLocalBoards();
4fd5ed63 72
92c23b09 73TString gCommand("");
4fd5ed63 74
75TString gCurrentFileName("MtgCurrent.dat");
76TString gLastCurrentFileName("MtgLastCurrent.dat");
77
78TString gSodName;
79Int_t gSodFlag = 0;
80
81TString gDAName;
82Int_t gDAFlag = 0;
83
84TString gGlobalFileName;
85TString gRegionalFileName;
86TString gLocalMaskFileName;
87TString gLocalLutFileName;
88TString gSignatureFileName;
89
90Int_t gGlobalFileVersion;
91Int_t gRegionalFileVersion;
92Int_t gLocalMaskFileVersion;
93Int_t gLocalLutFileVersion;
94Int_t gSignatureFileVersion;
95
96Int_t gGlobalFileLastVersion;
97Int_t gRegionalFileLastVersion;
98Int_t gLocalMaskFileLastVersion;
99Int_t gLocalLutFileLastVersion;
100
101UInt_t gRunNumber = 0;
102Int_t gNEvents = 0;
103
104Int_t gPrintLevel = 0;
105
106AliMUONVStore* gLocalMasks = 0x0;
92c23b09 107AliMUONRegionalTriggerConfig* gRegionalMasks = 0x0;
108AliMUONGlobalCrateConfig* gGlobalMasks = 0x0;
4fd5ed63 109
4fd5ed63 110
92c23b09 111 AliMUONTriggerIO gTriggerIO;
112
113AliMUONVStore* gPatternStore = new AliMUON1DArray(gkNLocalBoard);
4fd5ed63 114
115Char_t gHistoFileName[256];
116
74e61e0d 117Float_t gkThreshold = 0.2;
4fd5ed63 118
119//__________________________________________________________________
120void UpdateLocalMask(Int_t localBoardId, Int_t connector, Int_t strip)
121{
122
123 // update local mask
124 AliMUONVCalibParam* localMask =
125 static_cast<AliMUONVCalibParam*>(gLocalMasks->FindObject(localBoardId));
126
127 UShort_t mask = localMask->ValueAsInt(connector,0);
128
129 mask ^= (0x1 << strip); // set strip mask to zero
130
131 localMask->SetValueAsInt(connector,0, mask);
132}
133
134//__________________________________________________________________
135void WriteLastCurrentFile(TString currentFile = gLastCurrentFileName)
136{
137
138 // write last current file
139 ofstream out;
140 TString file;
141 file = currentFile;
142 out.open(file.Data());
143 out << gSodName << " " << gSodFlag << endl;
144 out << gDAName << " " << gDAFlag << endl;
145
146 out << gGlobalFileName << " " << gGlobalFileVersion << endl;
147 out << gRegionalFileName << " " << gRegionalFileVersion << endl;
148 out << gLocalMaskFileName << " " << gLocalMaskFileVersion << endl;
149 out << gLocalLutFileName << " " << gLocalLutFileVersion << endl;
150 out << gSignatureFileName << " " << gSignatureFileVersion << endl;
151
152 out.close();
153}
154
155//___________________________________________________________________________________________
156Bool_t ReadCurrentFile(TString currentFile = gCurrentFileName, Bool_t lastCurrentFlag = false)
157{
158
159 // read last current file name and version
160 char line[80];
161 char name[80];
162
163 TString file;
164 file = currentFile;
165 std::ifstream in(gSystem->ExpandPathName(file.Data()));
166 if (!in.good()) {
167 printf("Cannot open last current file %s\n",currentFile.Data());
168 return false;
169 }
170
171
172 // read SOD
173 in.getline(line,80);
174 sscanf(line, "%s %d", name, &gSodFlag);
175 gSodName = name;
176 if (gPrintLevel) printf("Sod Flag %d\n", gSodFlag);
177
178 //read DA
179 in.getline(line,80);
180 sscanf(line, "%s %d", name, &gDAFlag);
181 gDAName = name;
182 if (gPrintLevel) printf("DA Flag: %d\n", gDAFlag);
183
184
185 // read global
186 in.getline(line,80);
187 TString tmp(line);
188 Int_t pos = tmp.First(" ");
189 gGlobalFileName = tmp(0, pos);
190
191 if (!lastCurrentFlag) {
192 gGlobalFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
193 if (gPrintLevel) printf("Global File Name: %s version: %d\n",
194 gGlobalFileName.Data(), gGlobalFileVersion);
195 } else {
196 gGlobalFileLastVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
197 if (gPrintLevel) printf("Global File Name: %s last version: %d\n",
198 gGlobalFileName.Data(), gGlobalFileLastVersion);
199 }
200
201 // read regional
202 in.getline(line,80);
203 tmp = line;
204 pos = tmp.First(" ");
205 gRegionalFileName = tmp(0, pos);
206
207 if (!lastCurrentFlag) {
208 gRegionalFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
209 if (gPrintLevel) printf("Regional File Name: %s version: %d\n",
210 gRegionalFileName.Data(), gRegionalFileVersion);
211
212 } else {
213 gRegionalFileLastVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
214 if (gPrintLevel) printf("Regional File Name: %s last version: %d\n",
215 gRegionalFileName.Data(), gRegionalFileLastVersion);
216 }
217
218
219
220 // read mask
221 in.getline(line,80);
222 tmp = line;
223 pos = tmp.First(" ");
224 gLocalMaskFileName = tmp(0, pos);
225
226 if (!lastCurrentFlag) {
227 gLocalMaskFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
228 if (gPrintLevel) printf("Mask File Name: %s version: %d\n",
229 gLocalMaskFileName.Data(), gLocalMaskFileVersion);
230 } else {
231 gLocalMaskFileLastVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
232 if (gPrintLevel) printf("Mask File Name: %s last version: %d\n",
233 gLocalMaskFileName.Data(), gLocalMaskFileLastVersion);
234 }
235 // read Lut
236 in.getline(line,80);
237 tmp = line;
238 pos = tmp.First(" ");
239 gLocalLutFileName = tmp(0, pos);
240
241 if (!lastCurrentFlag) {
242 gLocalLutFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
243 if (gPrintLevel) printf("Lut File Name: %s version: %d\n",
244 gLocalLutFileName.Data(), gLocalLutFileVersion);
245 } else {
246 gLocalLutFileLastVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
247 if (gPrintLevel) printf("Lut File Name: %s last version: %d\n",
248 gLocalLutFileName.Data(), gLocalLutFileLastVersion);
249 }
250
251 in.getline(line,80);
252 tmp = line;
253 pos = tmp.First(" ");
254 gSignatureFileName = tmp(0, pos);
255 gSignatureFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
256 if (gPrintLevel) printf("Lut File Name: %s version: %d\n",
257 gSignatureFileName.Data(), gSignatureFileVersion);
258
259 return true;
260}
261
262//_____________
263void ReadFileNames()
264{
265 // if last current file does not exist than read current file
266 if (!ReadCurrentFile(gLastCurrentFileName, true))
267 {
268 ReadCurrentFile(gCurrentFileName, true);
269 WriteLastCurrentFile();
270 }
271
272 // any case read current file
273 ReadCurrentFile();
274
275}
276
277//__________________
278Bool_t ExportFiles()
279{
280
281 // Export files to FES
4fd5ed63 282 // env variables have to be set (suppose by ECS ?)
283 // setenv DATE_FES_PATH
284 // setenv DATE_RUN_NUMBER
285 // setenv DATE_ROLE_NAME
286 // setenv DATE_DETECTOR_CODE
287
92c23b09 288 // Export files into the database
289 // setenv DATE_DETECTOR_CODE MTR
290 // setenv DAQDALIB_PATH $ALICE/daqDAlib
291 // setenv DATE_DB_MYSQL_USER det_MTR
292 // setenv DATE_DB_MYSQL_PWD MTR123
293 // setenv DATE_DB_MYSQL_HOST aldaqdb.cern.ch
294 // setenv DATE_DB_MYSQL_DB $DATE_CONFIG
295 // set PATH=$PATH:${DAQDALIB_PATH}
296
297
4fd5ed63 298 // to be sure that env variable is set
92c23b09 299 // gSystem->Setenv("DAQDALIB_PATH", "$DATE_SITE/infoLogger");
300 gSystem->Setenv("DAQDALIB_PATH", "$ALICE/daqDAlib");
301 gSystem->Setenv("DATE_DETECTOR_CODE", "MTR");
302 gSystem->Setenv("DATE_DB_MYSQL_USER", "det_MTR");
303 gSystem->Setenv("DATE_DB_MYSQL_PWD", "MTR123");
304 gSystem->Setenv("DATE_DB_MYSQL_HOST", "aldaqdb.cern.ch");
305 gSystem->Setenv("DATE_DB_MYSQL_DB", "$DATE_CONFIG");
306
4fd5ed63 307 // update files
308 Int_t status = 0;
309
310 Bool_t modified = false;
311
312 ofstream out;
313 TString fileExp("ExportedFiles.dat");
314 TString file;
315
316 out.open(fileExp.Data());
317 if (!out.good()) {
318 printf("Failed to create file: %s\n",file.Data());
319 return false;
92c23b09 320 } file = gGlobalFileName.Data();
4fd5ed63 321
322 if (gGlobalFileLastVersion != gGlobalFileVersion) {
92c23b09 323
4fd5ed63 324 status = daqDA_FES_storeFile(file.Data(), file.Data());
325 if (status) {
326 printf("Failed to export file: %s\n",gGlobalFileName.Data());
327 return false;
328 }
329 out << gGlobalFileName.Data() << endl;
330 if(gPrintLevel) printf("Export file: %s\n",gGlobalFileName.Data());
331 }
332
333 if (gLocalMaskFileLastVersion != gLocalMaskFileVersion) {
334 modified = true;
335 file = gLocalMaskFileName;
92c23b09 336 // export to FES
4fd5ed63 337 status = daqDA_FES_storeFile(file.Data(), file.Data());
338 if (status) {
339 printf("Failed to export file: %s\n",gLocalMaskFileName.Data());
340 return false;
341 }
92c23b09 342 // export to DB
343 status = daqDA_DB_storeFile(file.Data(), file.Data());
344 if (status) {
345 printf("Failed to export file to DB: %s\n",gLocalMaskFileName.Data());
346 return false;
347 }
348
4fd5ed63 349 if(gPrintLevel) printf("Export file: %s\n",gLocalMaskFileName.Data());
350 out << gLocalMaskFileName.Data() << endl;
351 }
352
353 if (gLocalLutFileLastVersion != gLocalLutFileVersion) {
354 file = gLocalLutFileName;
355 modified = true;
356 status = daqDA_FES_storeFile(file.Data(), file.Data());
357 if (status) {
358 printf("Failed to export file: %s\n",gLocalLutFileName.Data());
359 return false;
360 }
361 if(gPrintLevel) printf("Export file: %s\n",gLocalLutFileName.Data());
362 out << gLocalLutFileName.Data() << endl;
363
364 }
365
366 // exported regional file whenever mask or/and Lut are modified
367 if ( (gRegionalFileLastVersion != gRegionalFileVersion) || modified) {
368 file = gRegionalFileName;
369 status = daqDA_FES_storeFile(file.Data(), file.Data());
370 if (status) {
371 printf("Failed to export file: %s\n",gRegionalFileName.Data());
372 return false;
373 }
374 if(gPrintLevel) printf("Export file: %s\n",gRegionalFileName.Data());
375 out << gRegionalFileName.Data() << endl;
376 }
377
378 out.close();
379
380 // export Exported file to FES anyway
381 status = daqDA_FES_storeFile(fileExp.Data(), fileExp.Data());
382 if (status) {
383 printf("Failed to export file: %s\n", fileExp.Data());
384 return false;
385 }
386 if(gPrintLevel) printf("Export file: %s\n",fileExp.Data());
387
388 return true;
389}
390//__________________
391Bool_t ImportFiles()
392{
393 // copy locally a file from daq detector config db
394 // The current detector is identified by detector code in variable
395 // DATE_DETECTOR_CODE. It must be defined.
396 // If environment variable DAQDA_TEST_DIR is defined, files are copied from DAQDA_TEST_DIR
397 // instead of the database. The usual environment variables are not needed.
398
399 // to be sure that env variable is set
92c23b09 400 // gSystem->Setenv("DAQDALIB_PATH", "$DATE_SITE/db");
401 gSystem->Setenv("DAQDALIB_PATH", "$ALICE/daqDAlib");
402
4fd5ed63 403 Int_t status = 0;
404
405 status = daqDA_DB_getFile(gCurrentFileName.Data(), gCurrentFileName.Data());
406 if (status) {
407 printf("Failed to get current config file from DB: %s\n",gCurrentFileName.Data());
408 return false;
409 }
410
411 ReadFileNames();
412
413 status = daqDA_DB_getFile(gGlobalFileName.Data(), gGlobalFileName.Data());
414 if (status) {
415 printf("Failed to get current config file from DB: %s\n", gGlobalFileName.Data());
416 return false;
417 }
418
419 status = daqDA_DB_getFile(gRegionalFileName.Data(), gRegionalFileName.Data());
420 if (status) {
421 printf("Failed to get current config file from DB: %s\n",gRegionalFileName.Data());
422 return false;
423 }
424
425 status = daqDA_DB_getFile(gLocalMaskFileName.Data(), gLocalMaskFileName.Data());
426 if (status) {
427 printf("Failed to get current config file from DB: %s\n",gLocalMaskFileName.Data());
428 return false;
429 }
430
431 status = daqDA_DB_getFile(gLocalLutFileName.Data(), gLocalLutFileName.Data());
432 if (status) {
433 printf("Failed to get current config file from DB: %s\n",gLocalLutFileName.Data());
434 return false;
435 }
436
437 return true;
438}
439
440//_____________
441void ReadMaskFiles()
442{
443 // read mask files
444 gLocalMasks = new AliMUON1DArray(gkNLocalBoard+9);
92c23b09 445 gRegionalMasks = new AliMUONRegionalTriggerConfig();
446 gGlobalMasks = new AliMUONGlobalCrateConfig();
4fd5ed63 447
448 TString localFile = gLocalMaskFileName;
449 TString regionalFile = gRegionalFileName;
450 TString globalFile = gGlobalFileName;
451
92c23b09 452 gTriggerIO.ReadConfig(localFile.Data(), regionalFile.Data(), globalFile.Data(),
453 gLocalMasks, gRegionalMasks, gGlobalMasks);
4fd5ed63 454}
455//__________
456void MakePattern(Int_t localBoardId, TArrayS& xPattern, TArrayS& yPattern)
457{
458
459 // calculate the hit map for each strip in x and y direction
460 AliMUONVCalibParam* pat =
461 static_cast<AliMUONVCalibParam*>(gPatternStore->FindObject(localBoardId));
462
463 if (!pat) {
464 pat = new AliMUONCalibParamND(2, 64, localBoardId, 0,0.); // put default wise 0.
465 gPatternStore->Add(pat);
466 }
467
468 for (Int_t i = 0; i < 4; ++i) {
469 for (Int_t j = 0; j < 16; ++j) {
470
471 Int_t xMask = xPattern[i];
472 Int_t yMask = yPattern[i];
473
474 Int_t index = 16*i + j;
475 Double_t patOcc = 0.;
476
477 if ( (xMask >> j ) & 0x1 ) {
478 patOcc = pat->ValueAsDouble(index, 0) + 1.;
479 pat->SetValueAsDouble(index, 0, patOcc);
480 }
481 if ( (yMask >> j ) & 0x1 ) {
482 patOcc = pat->ValueAsDouble(index, 0) + 1.;
483 pat->SetValueAsDouble(index, 0, patOcc);
484 }
485 }
486 }
487
488}
489
490//__________
491void MakePatternStore(Bool_t pedestal = true)
492{
493
494 // calculates the occupancy (option: store in a root file)
495 // check noisy strip (pedestal true, software trigger)
496 // check dead channel (pesdetal false, FET trigger)
497
498 Int_t localBoardId = 0;
499 Bool_t updated = false;
500
501 // histo
502
503 Char_t name[255];
504 Char_t title[255];
505
506 TH1F* xOccHisto[243];
507 TH1F* yOccHisto[243];
508 TH1F* xPatOccHisto = 0x0;
509 TH1F* yPatOccHisto = 0x0;
510
511 TFile* histoFile = 0x0;
512
513 if (gHistoFileName[0] != 0) {
514 histoFile = new TFile(gHistoFileName,"RECREATE","MUON Tracking pedestals");
515
516 sprintf(name,"pat_x");
517 sprintf(title,"Occupancy for x strip");
518 Int_t nx = 200;
519 Float_t xmin = -0.2;
520 Float_t xmax = 1.2;
521 xPatOccHisto = new TH1F(name,title,nx,xmin,xmax);
522 xPatOccHisto ->SetDirectory(histoFile);
523
524 sprintf(name,"pat_y");
525 sprintf(title,"Occupancy for y strip");
526 yPatOccHisto = new TH1F(name,title,nx,xmin,xmax);
527 yPatOccHisto->SetDirectory(histoFile);
528
529 }
530
531 // iterator over pedestal
532 TIter next(gPatternStore->CreateIterator());
533 AliMUONVCalibParam* pat;
534
535 while ( ( pat = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
536 {
537 localBoardId = pat->ID0();
538
539 if (gHistoFileName[0] != 0) {
540
541 Int_t nx = 64;
542 Float_t xmin = 0;
543 Float_t xmax = 64;
544
545 sprintf(name,"pat_x_%d",localBoardId);
546 sprintf(title,"Occupancy for x strip, board %d",localBoardId);
547 xOccHisto[localBoardId] = new TH1F(name,title,nx,xmin,xmax);
548
549 sprintf(name,"pat_y_%d",localBoardId);
550 sprintf(title,"Occupancy for y strip, board %d",localBoardId);
551 yOccHisto[localBoardId] = new TH1F(name,title,nx,xmin,xmax);
9f5fafa6 552
4fd5ed63 553 }
554
555 for (Int_t index = 0; index < pat->Size() ; ++index) {// 64 bits for X and 64 bits for Y strips
556
557 Double_t patXOcc = pat->ValueAsDouble(index, 0)/(Double_t)gNEvents;
558 Double_t patYOcc = pat->ValueAsDouble(index, 1)/(Double_t)gNEvents;
559
560 pat->SetValueAsDouble(index, 0, patXOcc);
561 pat->SetValueAsDouble(index, 1, patYOcc);
562
563
564 // check for x strip
565 if ( (patXOcc > gkThreshold && pedestal) || (patXOcc < 1.- gkThreshold && !pedestal) ) {
566 UShort_t strip = index % 16;
567 Int_t connector = index/16;
568 UpdateLocalMask(localBoardId, connector, strip);
569 updated = true;
570 }
571
572 // check for y strip
573 if ( (patYOcc > gkThreshold && pedestal) || (patYOcc < 1.- gkThreshold && !pedestal) ) {
574 UShort_t strip = index % 16;
575 Int_t connector = index/16 + 4;
576 UpdateLocalMask(localBoardId, connector, strip);
577 updated = true;
578
579 }
580
581 if (gHistoFileName[0] != 0) {
582 xPatOccHisto->Fill(patXOcc);
583 yPatOccHisto->Fill(patYOcc);
584 xOccHisto[localBoardId]->Fill(index, patXOcc);
585 yOccHisto[localBoardId]->Fill(index, patYOcc);
586
587 }
588 }
589 }
590
591 if (gHistoFileName[0] != 0) {
592 histoFile->Write();
593 histoFile->Close();
594 }
595
596
597 if (updated) {
598
599 // update version
600 gLocalMaskFileVersion++;
601
602 TString tmp(gLocalMaskFileName);
603 Int_t pos = tmp.First("-");
604 gLocalMaskFileName = tmp(0,pos+1) + Form("%d",gLocalMaskFileVersion) + ".dat";
605
606 // write last current file
607 WriteLastCurrentFile();
608
92c23b09 609 gTriggerIO.WriteConfig(gLocalMaskFileName, gRegionalFileName, gGlobalFileName, gLocalMasks, gRegionalMasks, gGlobalMasks);
4fd5ed63 610 }
611}
9f5fafa6 612
613//*************************************************************//
614
4fd5ed63 615 // main routine
9f5fafa6 616int main(Int_t argc, Char_t **argv)
617{
618
619 // needed for streamer application
4fd5ed63 620 gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo", "*", "TStreamerInfo",
621 "RIO", "TStreamerInfo()");
9f5fafa6 622
9f5fafa6 623 Int_t skipEvents = 0;
624 Int_t maxEvents = 1000000;
625 Char_t inputFile[256];
92c23b09 626 strcpy(inputFile, "");
9f5fafa6 627 TString flatOutputFile;
9f5fafa6 628
629// option handler
630
4fd5ed63 631 // decode the input line
632 for (Int_t i = 1; i < argc; i++) // argument 0 is the executable name
633 {
9f5fafa6 634 Char_t* arg;
635
636 arg = argv[i];
637 if (arg[0] != '-') continue;
638 switch (arg[1])
4fd5ed63 639 {
640 case 'f' :
9f5fafa6 641 i++;
642 sprintf(inputFile,argv[i]);
643 break;
74e61e0d 644 case 't' :
9f5fafa6 645 i++;
74e61e0d 646 gkThreshold = atof(argv[i]);
9f5fafa6 647 break;
4fd5ed63 648 case 'e' :
9f5fafa6 649 i++;
4fd5ed63 650 gCommand = argv[i];
9f5fafa6 651 break;
4fd5ed63 652 case 'd' :
9f5fafa6 653 i++;
4fd5ed63 654 gPrintLevel=atoi(argv[i]);
9f5fafa6 655 break;
4fd5ed63 656 case 's' :
9f5fafa6 657 i++;
658 skipEvents=atoi(argv[i]);
659 break;
4fd5ed63 660 case 'n' :
9f5fafa6 661 i++;
662 sscanf(argv[i],"%d",&maxEvents);
663 break;
4fd5ed63 664 case 'r' :
665 i++;
666 sscanf(argv[i],"%s",gHistoFileName);
667 break;
668 case 'h' :
9f5fafa6 669 i++;
670 printf("\n******************* %s usage **********************",argv[0]);
671 printf("\n%s -options, the available options are :",argv[0]);
672 printf("\n-h help (this screen)");
673 printf("\n");
674 printf("\n Input");
675 printf("\n-f <raw data file> (default = %s)",inputFile);
676 printf("\n");
4fd5ed63 677 printf("\n output");
678 printf("\n-r <root file> (default = %s)",gHistoFileName);
9f5fafa6 679 printf("\n");
680 printf("\n Options");
74e61e0d 681 printf("\n-t <threshold values> (default = %3.1f)",gkThreshold);
4fd5ed63 682 printf("\n-d <print level> (default = %d)",gPrintLevel);
9f5fafa6 683 printf("\n-s <skip events> (default = %d)",skipEvents);
684 printf("\n-n <max events> (default = %d)",maxEvents);
4fd5ed63 685 printf("\n-e <execute ped/calib> (default = %s)",gCommand.Data());
9f5fafa6 686
687 printf("\n\n");
688 exit(-1);
4fd5ed63 689 default :
9f5fafa6 690 printf("%s : bad argument %s (please check %s -h)\n",argv[0],argv[i],argv[0]);
691 argc = 2; exit(-1); // exit if error
4fd5ed63 692 } // end of switch
9f5fafa6 693 } // end of for i
694
4fd5ed63 695 // set command to lower case
696 gCommand.ToLower();
9f5fafa6 697
4fd5ed63 698 // decoding the events
9f5fafa6 699
4fd5ed63 700 Int_t status;
701 Int_t nDateEvents = 0;
9f5fafa6 702
4fd5ed63 703 void* event;
9f5fafa6 704
4fd5ed63 705 // containers
706 AliMUONDDLTrigger* ddlTrigger = 0x0;
707 AliMUONDarcHeader* darcHeader = 0x0;
708 AliMUONRegHeader* regHeader = 0x0;
709 AliMUONLocalStruct* localStruct = 0x0;
9f5fafa6 710
4fd5ed63 711 TStopwatch timers;
9f5fafa6 712
4fd5ed63 713 timers.Start(kTRUE);
9f5fafa6 714
4fd5ed63 715 // comment out, since we do not retrieve files from database
716 if (!ImportFiles()) {
717 printf("Import from DB failed\n");
718 printf("For local test set DAQDA_TEST_DIR to the local directory where the Mtg files are located \n");
9f5fafa6 719 return -1;
720 }
9f5fafa6 721
4fd5ed63 722 if (!gDAFlag) {
723 if(!ExportFiles()) return -1;
724 return 0;
9f5fafa6 725 }
726
4fd5ed63 727 ReadMaskFiles();
728
729 status = monitorSetDataSource(inputFile);
730 if (status) {
731 cerr << "ERROR : monitorSetDataSource status (hex) = " << hex << status
732 << " " << monitorDecodeError(status) << endl;
733 return -1;
734 }
735 status = monitorDeclareMp("MUON Trigger monitoring");
736 if (status) {
737 cerr << "ERROR : monitorDeclareMp status (hex) = " << hex << status
738 << " " << monitorDecodeError(status) << endl;
739 return -1;
9f5fafa6 740 }
741
4fd5ed63 742 cout << "MUONTRKda : Reading data from file " << inputFile <<endl;
743
744 while(1)
745 {
746 if (gNEvents >= maxEvents) break;
747 if (gNEvents && gNEvents % 100 == 0)
748 cout<<"Cumulated events " << gNEvents << endl;
9f5fafa6 749
4fd5ed63 750 // check shutdown condition
751 if (daqDA_checkShutdown())
752 break;
753
754 // Skip Events if needed
755 while (skipEvents) {
756 status = monitorGetEventDynamic(&event);
757 skipEvents--;
758 }
759
760 // starts reading
761 status = monitorGetEventDynamic(&event);
762 if (status < 0) {
763 cout<<"EOF found"<<endl;
764 break;
765 }
766
767 nDateEvents++;
768
769 // decoding rawdata headers
770 AliRawReader *rawReader = new AliRawReaderDate(event);
9f5fafa6 771
4fd5ed63 772 Int_t eventType = rawReader->GetType();
773 gRunNumber = rawReader->GetRunNumber();
9f5fafa6 774
775
4fd5ed63 776 if (eventType != PHYSICS_EVENT)
777 continue; // for the moment
9f5fafa6 778
4fd5ed63 779 gNEvents++;
780 if (gPrintLevel) printf("\nEvent # %d\n",gNEvents);
9f5fafa6 781
4fd5ed63 782 // decoding MUON payload
783 AliMUONRawStreamTrigger* rawStream = new AliMUONRawStreamTrigger(rawReader);
784 //rawStream->SetMaxReg(1);
9f5fafa6 785
4fd5ed63 786 Int_t index = 0;
787 // loops over DDL
788 while((status = rawStream->NextDDL())) {
9f5fafa6 789
4fd5ed63 790 if (gPrintLevel) printf("iDDL %d\n", rawStream->GetDDL());
9f5fafa6 791
4fd5ed63 792 ddlTrigger = rawStream->GetDDLTrigger();
793 darcHeader = ddlTrigger->GetDarcHeader();
9f5fafa6 794
4fd5ed63 795 if (gPrintLevel) printf("Global output %x\n", (Int_t)darcHeader->GetGlobalOutput());
9f5fafa6 796
4fd5ed63 797 // loop over regional structures
798 Int_t nReg = darcHeader->GetRegHeaderEntries();
799 for(Int_t iReg = 0; iReg < nReg; ++iReg){ //REG loop
9f5fafa6 800
4fd5ed63 801 if (gPrintLevel) printf("RegionalId %d\n", iReg);
9f5fafa6 802
4fd5ed63 803 regHeader = darcHeader->GetRegHeaderEntry(iReg);
9f5fafa6 804
4fd5ed63 805 // loop over local structures
806 Int_t nLocal = regHeader->GetLocalEntries();
807 for(Int_t iLocal = 0; iLocal < nLocal; ++iLocal) {
9f5fafa6 808
4fd5ed63 809 localStruct = regHeader->GetLocalEntry(iLocal);
9f5fafa6 810
4fd5ed63 811 Int_t localBoardId = gTriggerIO.LocalBoardId(index++);
812 if (gPrintLevel) printf("local %d\n", localBoardId );
813
814 TArrayS xPattern(4);
815 TArrayS yPattern(4);
816 localStruct->GetXPattern(xPattern);
817 localStruct->GetYPattern(yPattern);
818 MakePattern(localBoardId, xPattern, yPattern);
9f5fafa6 819
4fd5ed63 820 if (gPrintLevel) printf("X pattern %x %x %x %x, Y pattern %x %x %x %x\n",
821 localStruct->GetX1(), localStruct->GetX2(),localStruct->GetX3(),localStruct->GetX4(),
822 localStruct->GetY1(), localStruct->GetY2(),localStruct->GetY3(),localStruct->GetY4());
9f5fafa6 823
4fd5ed63 824 } // iLocal
825 } // iReg
826 } // NextDDL
827
828 delete rawReader;
829 delete rawStream;
830
831 } // while (1)
832
833 if (gCommand.Contains("ped"))
834 MakePatternStore();
9f5fafa6 835
74e61e0d 836 if (gCommand.Contains("cal"))
92c23b09 837 MakePatternStore(false);
9f5fafa6 838
4fd5ed63 839 if (!ExportFiles())
840 return -1;
9f5fafa6 841
4fd5ed63 842 timers.Stop();
9f5fafa6 843
92c23b09 844 cout << "MUONTRGda : Run number : " << gRunNumber << endl;
845 cout << "MUONTRGda : Histo file generated : " << gHistoFileName << endl;
846 cout << "MUONTRGda : Nb of DATE events = " << nDateEvents << endl;
847 cout << "MUONTRGda : Nb of events used = " << gNEvents << endl;
9f5fafa6 848
4fd5ed63 849 printf("Execution time : R:%7.2fs C:%7.2fs\n", timers.RealTime(), timers.CpuTime());
9f5fafa6 850
4fd5ed63 851 delete gLocalMasks;
852 delete gRegionalMasks;
74e61e0d 853 delete gGlobalMasks; // in case
4fd5ed63 854 delete gPatternStore;
9f5fafa6 855
4fd5ed63 856 return status;
9f5fafa6 857}
92c23b09 858