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