9788bb4d37572ca8e5711bc9839b024cb41f9d13
[u/mrichter/AliRoot.git] / HLT / MUON / OnlineAnalysis / AliHLTMUONTriggerCalibratorComponent.cxx
1 /**************************************************************************
2  * This file is property of and copyright by the ALICE HLT Project        * 
3  * All rights reserved.                                                   *
4  *                                                                        *
5  * Primary Authors:                                                       *
6  *   Artur Szostak <artursz@iafrica.com>                                  *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          * 
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 /* $Id$ */
18
19 ///
20 ///  @file   AliHLTMUONTriggerCalibratorComponent.cxx
21 ///  @author Artur Szostak <artursz@iafrica.com>
22 ///  @date   
23 ///  @brief  Implementation of the AliHLTMUONTriggerCalibratorComponent class.
24 ///
25
26 #include "AliHLTMUONTriggerCalibratorComponent.h"
27 #include "AliHLTMUONConstants.h"
28 #include "AliHLTMUONUtils.h"
29
30 ClassImp(AliHLTMUONTriggerCalibratorComponent);
31
32 ///////////////////////////////////////////////////////////////////////////////
33 // The code from here on was copied from MUONTRGda.cxx and addapted to the
34 // HLT framework.
35 //TODO: test that any of this actually works and clean up the code.
36 ///////////////////////////////////////////////////////////////////////////////
37
38 #include <iostream>
39 #include <fstream>
40 using namespace std;
41
42 #include <cstdio>
43 #include <cstdlib>
44
45 //AliRoot
46 #include "AliRawDataHeader.h"
47 #include "AliRawReaderMemory.h"
48 #include "AliMpConstants.h"
49 #include "AliMUONRawStreamTrigger.h"
50 #include "AliMUONDarcHeader.h"
51 #include "AliMUONRegHeader.h"
52 #include "AliMUONLocalStruct.h"
53 #include "AliMUONDDLTrigger.h"
54 #include "AliMUONVCalibParam.h"
55 #include "AliMUONVStore.h"
56 #include "AliMUONCalibParamND.h"
57 #include "AliMUONCalibParamNI.h"
58 #include "AliMUON1DArray.h"
59 #include "AliMUONTriggerIO.h"
60
61 //ROOT
62 #include "TString.h"
63 #include "TSystem.h"
64 #include "TStopwatch.h"
65 #include "TMath.h"
66 #include "TTimeStamp.h"
67 #include "TROOT.h"
68 #include "TPluginManager.h"
69 #include "TFile.h"
70 #include "TH1F.h"
71 #include "TArrayI.h"
72 #include "TArrayS.h"
73
74 namespace
75 {
76
77 // global variables
78 const Int_t gkNLocalBoard = AliMpConstants::NofLocalBoards();
79
80 TString gCommand("ped");
81
82 TString gCurrentFileName("MtgCurrent.dat");
83 TString gLastCurrentFileName("MtgLastCurrent.dat");
84
85 TString gSodName;
86 Int_t   gSodFlag = 0;
87
88 TString gDAName;
89 Int_t   gDAFlag = 0;
90
91 TString gGlobalFileName;
92 TString gRegionalFileName;
93 TString gLocalMaskFileName;
94 TString gLocalLutFileName;
95 TString gSignatureFileName;
96
97 Int_t gGlobalFileVersion;
98 Int_t gRegionalFileVersion;
99 Int_t gLocalMaskFileVersion;
100 Int_t gLocalLutFileVersion;
101 Int_t gSignatureFileVersion;
102
103 Int_t gGlobalFileLastVersion;
104 Int_t gRegionalFileLastVersion;
105 Int_t gLocalMaskFileLastVersion;
106 Int_t gLocalLutFileLastVersion;
107
108 UInt_t gRunNumber = 0;
109 Int_t  gNEvents = 0;
110
111 Int_t gPrintLevel = 0;
112
113 AliMUONVStore* gLocalMasks    = NULL;
114 AliMUONVStore* gRegionalMasks = NULL;
115 AliMUONVCalibParam* gGlobalMasks = NULL;
116
117 AliMUONTriggerIO gTriggerIO;
118
119 AliMUONVStore* gPatternStore = NULL;
120
121 TString gHistoFileName = "";
122
123 Float_t gkThreshold = 0.2;
124
125 }; // end of namespace
126
127 //__________________________________________________________________
128 void UpdateLocalMask(Int_t localBoardId, Int_t connector, Int_t strip)
129 {
130
131     // update local mask
132     AliMUONVCalibParam* localMask = 
133         static_cast<AliMUONVCalibParam*>(gLocalMasks->FindObject(localBoardId));
134
135     UShort_t mask = localMask->ValueAsInt(connector,0); 
136
137     mask ^= (0x1 << strip); // set strip mask to zero
138
139     localMask->SetValueAsInt(connector,0, mask);  
140 }
141
142 //__________________________________________________________________
143 void WriteLastCurrentFile(TString currentFile = gLastCurrentFileName)
144 {
145         if (gSodName.IsNull()) gSodName = "SOD";
146         if (gDAName.IsNull()) gDAName = "MTG";
147         if (gGlobalFileName.IsNull()) gGlobalFileName = "global.dat";
148         if (gRegionalFileName.IsNull()) gRegionalFileName = "regional.dat";
149         if (gLocalMaskFileName.IsNull()) gLocalMaskFileName = "localMask.dat";
150         if (gLocalLutFileName.IsNull()) gLocalLutFileName = "localLut.dat";
151         if (gSignatureFileName.IsNull()) gSignatureFileName = "signature.dat";
152
153     // write last current file
154     ofstream out;
155     TString file;
156     file = currentFile;
157     out.open(file.Data());
158     out << gSodName << " " << gSodFlag << endl;
159     out << gDAName  << " " << gDAFlag  << endl;
160
161     out << gGlobalFileName    << " " << gGlobalFileVersion    << endl;
162     out << gRegionalFileName  << " " << gRegionalFileVersion  << endl;
163     out << gLocalMaskFileName << " " << gLocalMaskFileVersion << endl;
164     out << gLocalLutFileName  << " " << gLocalLutFileVersion  << endl;
165     out << gSignatureFileName << " " << gSignatureFileVersion << endl;
166
167     out.close();
168 }
169
170 //___________________________________________________________________________________________
171 Bool_t ReadCurrentFile(TString currentFile = gCurrentFileName, Bool_t lastCurrentFlag = false)
172 {
173
174     // read last current file name and version
175     char line[80];
176     char name[80];
177
178     TString file;
179     file = currentFile;
180     std::ifstream in(gSystem->ExpandPathName(file.Data()));
181     if (!in.good()) {
182       printf("Cannot open last current file %s\n",currentFile.Data());
183       return false;
184     }
185     
186
187     // read SOD 
188     in.getline(line,80);  
189     sscanf(line, "%s %d", name, &gSodFlag);
190     gSodName = name;
191     if (gPrintLevel) printf("Sod Flag %d\n", gSodFlag);
192
193     //read DA
194     in.getline(line,80);    
195     sscanf(line, "%s %d", name, &gDAFlag);
196     gDAName = name;
197     if (gPrintLevel) printf("DA Flag: %d\n", gDAFlag);
198
199
200     // read global
201     in.getline(line,80);    
202     TString tmp(line);
203     Int_t pos =  tmp.First(" ");
204     gGlobalFileName = tmp(0, pos);
205     
206     if (!lastCurrentFlag) {
207         gGlobalFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
208         if (gPrintLevel) printf("Global File Name: %s version: %d\n", 
209                             gGlobalFileName.Data(), gGlobalFileVersion);
210     } else {
211         gGlobalFileLastVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
212         if (gPrintLevel) printf("Global File Name: %s last version: %d\n", 
213                                 gGlobalFileName.Data(), gGlobalFileLastVersion);
214     }
215
216     // read regional
217     in.getline(line,80);
218     tmp = line;
219     pos = tmp.First(" ");
220     gRegionalFileName = tmp(0, pos);
221
222     if (!lastCurrentFlag) {
223         gRegionalFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
224         if (gPrintLevel) printf("Regional File Name: %s version: %d\n", 
225                                 gRegionalFileName.Data(), gRegionalFileVersion);
226
227     } else {
228         gRegionalFileLastVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
229         if (gPrintLevel) printf("Regional File Name: %s last version: %d\n", 
230                                 gRegionalFileName.Data(), gRegionalFileLastVersion);
231     }
232
233     // read mask
234     in.getline(line,80);    
235     tmp = line;
236     pos = tmp.First(" ");
237     gLocalMaskFileName = tmp(0, pos);
238
239     if (!lastCurrentFlag) {
240       gLocalMaskFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
241       if (gPrintLevel) printf("Mask File Name: %s version: %d\n", 
242                             gLocalMaskFileName.Data(), gLocalMaskFileVersion);
243     } else {
244       gLocalMaskFileLastVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
245       if (gPrintLevel) printf("Mask File Name: %s last version: %d\n", 
246                             gLocalMaskFileName.Data(), gLocalMaskFileLastVersion);
247     }
248     // read Lut
249     in.getline(line,80);    
250     tmp = line;
251     pos = tmp.First(" ");
252     gLocalLutFileName = tmp(0, pos);
253
254     if (!lastCurrentFlag) {
255         gLocalLutFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
256         if (gPrintLevel) printf("Lut File Name: %s version: %d\n", 
257                                 gLocalLutFileName.Data(), gLocalLutFileVersion);
258     } else {
259         gLocalLutFileLastVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
260         if (gPrintLevel) printf("Lut File Name: %s last version: %d\n", 
261                                 gLocalLutFileName.Data(), gLocalLutFileLastVersion);
262     }
263
264     in.getline(line,80);    
265     tmp = line;
266     pos = tmp.First(" ");
267     gSignatureFileName = tmp(0, pos);
268     gSignatureFileVersion = atoi(tmp(pos+1, tmp.Length()-pos).Data());
269     if (gPrintLevel) printf("Lut File Name: %s version: %d\n", 
270                             gSignatureFileName.Data(), gSignatureFileVersion);
271
272     return true;
273 }
274
275 //_____________
276 void ReadFileNames()
277 {
278     // if last current file does not exist than read current file
279     if (!ReadCurrentFile(gLastCurrentFileName, true)) 
280     {
281       ReadCurrentFile(gCurrentFileName, true);
282       WriteLastCurrentFile();
283     } 
284
285     // any case read current file
286     ReadCurrentFile();
287
288 }
289
290 //__________________
291 Bool_t ExportFiles()
292 {
293
294     // Export files to FES
295     // Export files to DB not yet done, waiting for a version > 1.2 of daqDAlib
296     // env variables have to be set (suppose by ECS ?)
297     // setenv DATE_FES_PATH
298     // setenv DATE_RUN_NUMBER
299     // setenv DATE_ROLE_NAME
300     // setenv DATE_DETECTOR_CODE
301
302     // to be sure that env variable is set
303     gSystem->Setenv("DAQDALIB_PATH", "$DATE_SITE/infoLogger");
304
305     // update files
306     Int_t status = 0;
307
308     Bool_t modified = false;
309
310     ofstream out;
311     TString fileExp("ExportedFiles.dat");
312     TString file;
313
314     out.open(fileExp.Data());
315     if (!out.good()) {
316         printf("Failed to create file: %s\n",file.Data());
317         return false;
318     }
319
320     if (gGlobalFileLastVersion != gGlobalFileVersion) {
321       file = gGlobalFileName.Data();
322 //      status = daqDA_FES_storeFile(file.Data(), file.Data());
323       status = 0;
324       if (status) {
325         printf("Failed to export file: %s\n",gGlobalFileName.Data());
326         return false;
327       }
328       out << gGlobalFileName.Data() << endl;
329       if(gPrintLevel) printf("Export file: %s\n",gGlobalFileName.Data());
330     }
331
332     if (gLocalMaskFileLastVersion != gLocalMaskFileVersion) {
333       modified = true;
334       file = gLocalMaskFileName;
335 //      status = daqDA_FES_storeFile(file.Data(), file.Data());
336       status = 0;
337       if (status) {
338         printf("Failed to export file: %s\n",gLocalMaskFileName.Data());
339         return false;
340       }
341       if(gPrintLevel) printf("Export file: %s\n",gLocalMaskFileName.Data());
342       out << gLocalMaskFileName.Data() << endl;
343     }
344
345     if (gLocalLutFileLastVersion != gLocalLutFileVersion) {
346       file = gLocalLutFileName;
347       modified = true;
348 //      status = daqDA_FES_storeFile(file.Data(), file.Data());
349       status = 0;
350       if (status) {
351         printf("Failed to export file: %s\n",gLocalLutFileName.Data());
352         return false;
353       }
354       if(gPrintLevel) printf("Export file: %s\n",gLocalLutFileName.Data());
355       out << gLocalLutFileName.Data() << endl;
356
357     }
358
359     // exported regional file whenever mask or/and Lut are modified
360     if ( (gRegionalFileLastVersion != gRegionalFileVersion) || modified) {
361       file = gRegionalFileName;
362 //      status = daqDA_FES_storeFile(file.Data(), file.Data());
363       status = 0;
364       if (status) {
365         printf("Failed to export file: %s\n",gRegionalFileName.Data());
366         return false;
367       }
368       if(gPrintLevel) printf("Export file: %s\n",gRegionalFileName.Data());
369       out << gRegionalFileName.Data() << endl;
370     }
371
372     out.close();
373
374     // export Exported file to FES anyway
375 //    status = daqDA_FES_storeFile(fileExp.Data(), fileExp.Data());
376     status = 0;
377     if (status) {
378       printf("Failed to export file: %s\n", fileExp.Data());
379       return false;
380     }
381     if(gPrintLevel) printf("Export file: %s\n",fileExp.Data());
382
383     return true;
384 }
385
386 //__________________
387 Bool_t ImportFiles()
388 {
389     // copy locally a file from daq detector config db 
390     // The current detector is identified by detector code in variable
391     // DATE_DETECTOR_CODE. It must be defined.
392     // If environment variable DAQDA_TEST_DIR is defined, files are copied from DAQDA_TEST_DIR
393     // instead of the database. The usual environment variables are not needed.
394
395     // to be sure that env variable is set
396     gSystem->Setenv("DAQDALIB_PATH", "$DATE_SITE/db");
397
398     Int_t status = 0;
399
400 //    status = daqDA_DB_getFile(gCurrentFileName.Data(), gCurrentFileName.Data());
401     status = 0;
402     if (status) {
403       printf("Failed to get current config file from DB: %s\n",gCurrentFileName.Data());
404       return false;
405     }
406  
407     ReadFileNames();
408
409 //    status = daqDA_DB_getFile(gGlobalFileName.Data(), gGlobalFileName.Data());
410     status = 0;
411     if (status) {
412       printf("Failed to get current config file from DB: %s\n", gGlobalFileName.Data());
413       return false;
414     }
415
416 //    status = daqDA_DB_getFile(gRegionalFileName.Data(), gRegionalFileName.Data());
417     status = 0;
418     if (status) {
419       printf("Failed to get current config file from DB: %s\n",gRegionalFileName.Data());
420       return false;
421     }
422
423 //    status = daqDA_DB_getFile(gLocalMaskFileName.Data(), gLocalMaskFileName.Data());
424     status = 0;
425     if (status) {
426       printf("Failed to get current config file from DB: %s\n",gLocalMaskFileName.Data());
427       return false;
428     }
429
430 //    status = daqDA_DB_getFile(gLocalLutFileName.Data(), gLocalLutFileName.Data());
431     status = 0;
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 //__________
441 void MakePattern(Int_t localBoardId, TArrayS& xPattern,  TArrayS& yPattern)
442 {
443
444     // calculate the hit map for each strip in x and y direction
445     AliMUONVCalibParam* pat = 
446         static_cast<AliMUONVCalibParam*>(gPatternStore->FindObject(localBoardId));
447
448     if (!pat) {
449       pat = new AliMUONCalibParamND(2, 64, localBoardId, 0,0.); // put default wise 0.
450       gPatternStore->Add(pat);  
451     }
452
453     for (Int_t i = 0; i < 4; ++i) {
454       for (Int_t j = 0; j < 16; ++j) {
455         
456         Int_t xMask = xPattern[i];
457         Int_t yMask = yPattern[i];
458
459         Int_t index = 16*i + j;
460         Double_t patOcc = 0.;
461
462         if ( (xMask >> j ) & 0x1 ) {
463             patOcc  = pat->ValueAsDouble(index, 0) + 1.;
464             pat->SetValueAsDouble(index, 0, patOcc);
465         }
466         if ( (yMask >> j ) & 0x1 ) {
467             patOcc  = pat->ValueAsDouble(index, 0) + 1.;
468             pat->SetValueAsDouble(index, 0, patOcc);
469         }
470       }
471     }
472
473 }
474
475 //__________
476 void MakePatternStore(Bool_t pedestal = true)
477 {
478
479     // calculates the occupancy (option: store in a root file)
480     // check noisy strip (pedestal true, software trigger)
481     // check dead channel (pesdetal false, FET trigger)
482
483     Int_t localBoardId = 0;
484     Bool_t updated = false;
485
486     // histo
487
488     Char_t name[255];
489     Char_t title[255];
490
491     TH1F*  xOccHisto[243];
492     TH1F*  yOccHisto[243];
493     TH1F*  xPatOccHisto = 0x0;
494     TH1F*  yPatOccHisto = 0x0;
495
496     TFile*  histoFile = 0x0;
497
498     if (gHistoFileName[0] != 0) {
499       histoFile = new TFile(gHistoFileName,"RECREATE","MUON Tracking pedestals");
500
501       sprintf(name,"pat_x");
502       sprintf(title,"Occupancy for x strip");
503       Int_t nx = 200;
504       Float_t xmin = -0.2;
505       Float_t xmax = 1.2; 
506       xPatOccHisto = new TH1F(name,title,nx,xmin,xmax);
507       xPatOccHisto ->SetDirectory(histoFile);
508
509       sprintf(name,"pat_y");
510       sprintf(title,"Occupancy for y strip");
511       yPatOccHisto = new TH1F(name,title,nx,xmin,xmax);
512       yPatOccHisto->SetDirectory(histoFile);
513     
514     }
515
516     // iterator over pedestal
517     TIter next(gPatternStore->CreateIterator());
518     AliMUONVCalibParam* pat;
519   
520     while ( ( pat = dynamic_cast<AliMUONVCalibParam*>(next() ) ) )
521     {
522       localBoardId  = pat->ID0();
523
524       if (gHistoFileName[0] != 0) {
525
526         Int_t nx = 64;
527         Float_t xmin = 0;
528         Float_t xmax = 64;
529
530         sprintf(name,"pat_x_%d",localBoardId);
531         sprintf(title,"Occupancy for x strip, board %d",localBoardId);
532         xOccHisto[localBoardId] = new TH1F(name,title,nx,xmin,xmax);
533
534         sprintf(name,"pat_y_%d",localBoardId);
535         sprintf(title,"Occupancy for y strip, board %d",localBoardId);
536         yOccHisto[localBoardId] = new TH1F(name,title,nx,xmin,xmax);
537
538       }
539
540       for (Int_t index = 0; index < pat->Size() ; ++index) {// 64 bits for X and 64 bits for Y strips
541
542         Double_t patXOcc  = pat->ValueAsDouble(index, 0)/(Double_t)gNEvents;
543         Double_t patYOcc  = pat->ValueAsDouble(index, 1)/(Double_t)gNEvents;
544
545         pat->SetValueAsDouble(index, 0, patXOcc);
546         pat->SetValueAsDouble(index, 1, patYOcc);
547
548
549         // check for x strip
550         if ( (patXOcc > gkThreshold && pedestal) || (patXOcc < 1.- gkThreshold && !pedestal) ) {
551           UShort_t strip  = index % 16;
552           Int_t connector = index/16;
553           UpdateLocalMask(localBoardId, connector, strip); 
554           updated = true;
555         }
556
557         // check for y strip
558         if ( (patYOcc > gkThreshold && pedestal) || (patYOcc < 1.- gkThreshold && !pedestal) ) {
559           UShort_t strip  = index % 16;
560           Int_t connector = index/16 + 4;
561           UpdateLocalMask(localBoardId, connector, strip);
562           updated = true;
563
564         }
565
566         if (gHistoFileName[0] != 0)  {
567           xPatOccHisto->Fill(patXOcc);
568           yPatOccHisto->Fill(patYOcc);
569           xOccHisto[localBoardId]->Fill(index, patXOcc);
570           yOccHisto[localBoardId]->Fill(index, patYOcc);
571
572         }       
573       }
574     }
575
576     if (gHistoFileName[0] != 0) {
577       histoFile->Write();
578       histoFile->Close();
579     }
580
581     if (updated) {
582
583       // update version
584       gLocalMaskFileVersion++;
585
586       TString tmp(gLocalMaskFileName);
587       Int_t pos = tmp.First("-");
588       gLocalMaskFileName = tmp(0,pos+1) + Form("%d",gLocalMaskFileVersion) + ".dat"; 
589
590       // write last current file
591       WriteLastCurrentFile();
592
593       gTriggerIO.WriteMasks(gLocalMaskFileName, gRegionalFileName, gGlobalFileName, gLocalMasks, gRegionalMasks, gGlobalMasks);
594     }
595 }
596
597
598 AliHLTMUONTriggerCalibratorComponent::AliHLTMUONTriggerCalibratorComponent() :
599         AliHLTCalibrationProcessor(),
600         fSkipEvents(0),
601         fMaxEvents(1000000)
602 {
603         /// Default contructor.
604 }
605
606
607 AliHLTMUONTriggerCalibratorComponent::~AliHLTMUONTriggerCalibratorComponent()
608 {
609         /// Default destructor.
610 }
611
612
613 const char* AliHLTMUONTriggerCalibratorComponent::GetComponentID()
614 {
615         /// Inherited from AliHLTComponent.
616         /// Returns the component ID string for this component type.
617         
618         return AliHLTMUONConstants::TriggerCalibratorId();
619 }
620
621
622 void AliHLTMUONTriggerCalibratorComponent::GetInputDataTypes(
623                 vector<AliHLTComponentDataType>& list
624         )
625 {
626         /// Inherited from AliHLTComponent.
627         /// Returns the list of input block types expected by this component.
628
629         list.clear();
630         list.push_back( AliHLTMUONConstants::TriggerDDLRawDataType() );
631 }
632
633
634 AliHLTComponentDataType AliHLTMUONTriggerCalibratorComponent::GetOutputDataType()
635 {
636         /// Inherited from AliHLTComponent.
637         /// Returns the type of output block generated by this component.
638
639         //TODO: fix.
640         return AliHLTMUONConstants::TriggerDDLRawDataType();
641 }
642
643
644 void AliHLTMUONTriggerCalibratorComponent::GetOutputDataSize(
645                 unsigned long& constBase, double& inputMultiplier
646         )
647 {
648         /// Inherited from AliHLTComponent.
649         /// Returns an estimate of the expected output data size.
650
651         constBase = 0;
652         inputMultiplier = 2.;  //TODO: is this the correct estimate.
653 }
654
655
656 AliHLTComponent* AliHLTMUONTriggerCalibratorComponent::Spawn()
657 {
658         /// Inherited from AliHLTComponent.
659         /// Creates a new instance of AliHLTMUONTriggerCalibratorComponent.
660
661         return new AliHLTMUONTriggerCalibratorComponent();
662 }
663
664
665 Int_t AliHLTMUONTriggerCalibratorComponent::ScanArgument(int argc, const char** argv)
666 {
667         /// Inherited from AliHLTCalibrationProcessor.
668         /// Parses the command line parameters.
669         
670         TString arg = argv[0];
671         
672         if (arg.CompareTo("-h") == 0)
673         {
674                 HLTInfo("******************* usage **********************");
675                 HLTInfo("The available options are :");
676                 HLTInfo("-h help                   (this screen)");
677                 HLTInfo("");
678                 HLTInfo(" Output");
679                 HLTInfo("-r <root file>            (default = %s)", gHistoFileName.Data());
680                 HLTInfo("");
681                 HLTInfo(" Options");
682                 HLTInfo("-t <threshold values>     (default = %3.1f)", gkThreshold);
683                 HLTInfo("-d <print level>          (default = %d)", gPrintLevel);
684                 HLTInfo("-s <skip events>          (default = %d)", fSkipEvents);
685                 HLTInfo("-n <max events>           (default = %d)", fMaxEvents);
686                 HLTInfo("-e <execute ped/calib>    (default = %s)", gCommand.Data());
687                 return 0;  // Zero parameters parsed.
688         }
689         
690         if (arg.CompareTo("-t") == 0)
691         {
692                 if (argc < 2) return -EPROTO;
693                 gkThreshold = atof(argv[1]);
694                 return 1;  // 1 parameter parsed.
695         }
696         if (arg.CompareTo("-e") == 0)
697         {
698                 if (argc < 2) return -EPROTO;
699                 gCommand = argv[1];
700                 gCommand.ToLower();  // set command to lower case
701                 return 1;  // 1 parameter parsed.
702         }
703         if (arg.CompareTo("-d") == 0)
704         {
705                 if (argc < 2) return -EPROTO;
706                 gPrintLevel = atoi(argv[1]);
707                 return 1;  // 1 parameter parsed.
708         }
709         if (arg.CompareTo("-s") == 0)
710         {
711                 if (argc < 2) return -EPROTO;
712                 fSkipEvents = atoi(argv[1]);
713                 return 1;  // 1 parameter parsed.
714         }
715         if (arg.CompareTo("-n") == 0)
716         {
717                 if (argc < 2) return -EPROTO;
718                 fMaxEvents = atoi(argv[1]);
719                 return 1;  // 1 parameter parsed.
720         }
721         if (arg.CompareTo("-r") == 0)
722         {
723                 if (argc < 2) return -EPROTO;
724                 gHistoFileName = argv[1];
725                 return 1;  // 1 parameter parsed.
726         }
727         
728         // Do not know what this argument is so return an error code.
729         HLTError("Bad argument %s (please check with -h)", arg.Data());
730         return -EINVAL;
731 }
732
733
734 Int_t AliHLTMUONTriggerCalibratorComponent::InitCalibration()
735 {
736         /// Inherited from AliHLTCalibrationProcessor.
737         /// Initialise the calibration component.
738         
739         // comment out, since we do not retrieve files from database
740         if (!ImportFiles())
741         {
742                 HLTError("Import from DB failed");
743                 HLTError("For local test set DAQDA_TEST_DIR to the local directory where the Mtg files are located.");
744                 return -1;
745         }
746         /*
747         if (!gDAFlag)
748         {
749                 if(!ExportFiles()) return -1;
750                 return 0;
751         }
752         */
753
754         // read mask files
755         gLocalMasks    = new AliMUON1DArray(gkNLocalBoard+9);
756         gRegionalMasks = new AliMUON1DArray(16);
757         gGlobalMasks   = new AliMUONCalibParamNI(1,2,1,0,0);
758         gPatternStore  = new AliMUON1DArray(gkNLocalBoard+9);
759         
760         TString localFile    = gLocalMaskFileName;
761         TString regionalFile = gRegionalFileName;
762         TString globalFile   = gGlobalFileName;
763         
764         gTriggerIO.ReadMasks(localFile.Data(), regionalFile.Data(), globalFile.Data(),
765                                 gLocalMasks, gRegionalMasks, gGlobalMasks, false);
766
767         return 0;
768 }
769
770
771 Int_t AliHLTMUONTriggerCalibratorComponent::DeinitCalibration()
772 {
773         /// Inherited from AliHLTCalibrationProcessor.
774         /// Cleanup the calibration component releasing allocated memory.
775         
776         delete gLocalMasks;
777         delete gRegionalMasks;
778         delete gGlobalMasks; // in case
779         delete gPatternStore;
780         gLocalMasks = NULL;
781         gRegionalMasks = NULL;
782         gGlobalMasks = NULL;
783         gPatternStore = NULL;
784         
785         return 0;
786 }
787
788
789 Int_t AliHLTMUONTriggerCalibratorComponent::ProcessCalibration(
790                 const AliHLTComponentEventData& /*evtData*/,
791                 AliHLTComponentTriggerData& /*trigData*/
792         )
793 {
794         /// Inherited from AliHLTCalibrationProcessor.
795         /// Perform a calibration procedure on the new event.
796         
797         // Skip Events if needed
798         if (fSkipEvents > 0)
799         {
800                 fSkipEvents--;
801                 return 0;
802         }
803         
804         // Do not process more than fMaxEvents.
805         if (gNEvents >= fMaxEvents) return 0;
806         if (gNEvents && gNEvents % 100 == 0)
807                 HLTInfo("Cumulated events %d", gNEvents);
808         
809         gNEvents++;
810         
811         gRunNumber = GetRunNo();
812         
813         /*
814         Int_t eventType = GetRunType();
815         if (eventType != 7)  // PHYSICS_EVENT - from event.h (DATE software)
816         {
817                 HLTWarning("This event is not a physics event");
818                 return 0;
819         }
820         */
821         
822         Int_t status;
823         
824         // containers
825         AliMUONDDLTrigger*       ddlTrigger  = 0x0;
826         AliMUONDarcHeader*       darcHeader  = 0x0;
827         AliMUONRegHeader*        regHeader   = 0x0;
828         AliMUONLocalStruct*      localStruct = 0x0;
829
830         const AliHLTComponentBlockData* iter = NULL;
831         
832         // Loop over all DDL raw data input blocks and decode the event.
833         iter = GetFirstInputBlock( AliHLTMUONConstants::TriggerDDLRawDataType() );
834         while (iter != NULL)
835         {
836                 
837                 // decoding rawdata headers
838                 AliRawReaderMemory* rawReader = new AliRawReaderMemory(
839                                 reinterpret_cast<UChar_t*>(iter->fPtr), iter->fSize
840                         );
841                 rawReader->SetEquipmentID(AliHLTMUONUtils::SpecToEquipId(iter->fSpecification));
842                 
843                 // decoding MUON payload
844                 AliMUONRawStreamTrigger* rawStream  = new AliMUONRawStreamTrigger(rawReader);
845                 //rawStream->SetMaxReg(1);
846                 
847                 Int_t index = 0;
848                 // loops over DDL 
849                 while((status = rawStream->NextDDL()))
850                 {
851                         if (gPrintLevel) HLTInfo("iDDL %d", rawStream->GetDDL());
852                 
853                         ddlTrigger = rawStream->GetDDLTrigger();
854                         darcHeader = ddlTrigger->GetDarcHeader();
855                 
856                         if (gPrintLevel) HLTInfo("Global output %x", (Int_t)darcHeader->GetGlobalOutput());
857                 
858                         // loop over regional structures
859                         Int_t nReg = darcHeader->GetRegHeaderEntries();
860                         for(Int_t iReg = 0; iReg < nReg; ++iReg)
861                         {   //REG loop
862                                 if (gPrintLevel) HLTInfo("RegionalId %d", iReg);
863                         
864                                 regHeader =  darcHeader->GetRegHeaderEntry(iReg);
865                         
866                                 // loop over local structures
867                                 Int_t nLocal = regHeader->GetLocalEntries();
868                                 for(Int_t iLocal = 0; iLocal < nLocal; ++iLocal)
869                                 {
870                                         localStruct = regHeader->GetLocalEntry(iLocal);
871                                 
872                                         Int_t localBoardId = gTriggerIO.LocalBoardId(index++);
873                                         if (gPrintLevel) HLTInfo("local %d",  localBoardId );
874                                 
875                                         TArrayS xPattern(4);
876                                         TArrayS yPattern(4);
877                                         localStruct->GetXPattern(xPattern);
878                                         localStruct->GetYPattern(yPattern);
879                                         MakePattern(localBoardId, xPattern, yPattern);
880                                 
881                                         if (gPrintLevel)
882                                         {
883                                                 HLTInfo("X pattern %x %x %x %x, Y pattern %x %x %x %x",
884                                                         localStruct->GetX1(), localStruct->GetX2(),localStruct->GetX3(),localStruct->GetX4(),
885                                                         localStruct->GetY1(), localStruct->GetY2(),localStruct->GetY3(),localStruct->GetY4()
886                                                 );
887                                         }
888                                 } // iLocal
889                         } // iReg
890                 } // NextDDL
891                 
892                 delete rawReader;
893                 delete rawStream;
894         
895                 // Get next DDL raw data input block, with the same specification as defined in GetFirstInputBlock().
896                 iter = GetNextInputBlock();
897         }
898         
899         if (gCommand.Contains("ped")) 
900                 MakePatternStore();
901         
902         if (gCommand.Contains("cal"))
903                 HLTWarning("Options %s disabled", gCommand.Data());
904         //      MakePatternStore(false);
905         
906         if (!ExportFiles())
907                 return -1;
908         
909         HLTInfo("MUONTRKda : Run number                    : %d", gRunNumber);
910         HLTInfo("MUONTRKda : Histo file generated          : %s", gHistoFileName.Data());
911         HLTInfo("MUONTRKda : Nb of events used     = %d", gNEvents);
912         
913         //TODO:
914         // PushBack data to shared memory ...
915         //PushBack(.....);
916
917         return 0;
918 }
919
920
921 Int_t AliHLTMUONTriggerCalibratorComponent::ShipDataToFXS(
922                 const AliHLTComponentEventData& /*evtData*/,
923                 AliHLTComponentTriggerData& /*trigData*/
924         )
925 {
926         /// Inherited from AliHLTCalibrationProcessor.
927         /// Push the data to the FXS to ship off to the offline CDB.
928         
929         //TODO:
930         // PushBack data to FXS ...
931         //PushToFXS( ..... ) ;
932         
933         return 0;
934 }