Update from Alberica. Addition of VZERO equalized signals and ZNC.
[u/mrichter/AliRoot.git] / MUON / MUONTRGda.cxx
1 /*
2 MTR DA for online
3
4 Contact: Franck Manso <manso@clermont.in2p3.fr>
5 Link: http://aliceinfo.cern.ch/static/Offline/dimuon/muon_html/README_mtrda.html
6 Reference run: 61898
7 Run Type:  PHYSICS
8 DA Type: MON
9 Number of events needed: 1000 events
10 Input files: MtgGlobalCrate.dat MtgRegionalCrate.dat MtgLocalMask.dat MtgLocalLut.dat MtgCurrent.dat DAConfig.dat
11 Output Files: ExportedFiles.dat MtgGlobalCrate.dat
12 Trigger types used: PHYSICS_EVENT CALIBRATION_EVENT
13 */
14
15 //////////////////////////////////////////////////////////////////////////////
16 // Detector Algorithm for the MUON trigger configuration.                   //
17 //                                                                          //
18 // Calculates masks for the global trigger input, by looking at dead        //
19 // channels in calibration events and at noisy channels in physics events.  //
20 // Transfers trigger configuration files to the File Exchange Server and    //
21 // writes them (if modified) into the trigger configuration data base.      //
22 //                                                                          //
23 // Authors:                                                                 //
24 // Christian Fink (formerly at Subatech, Nantes)                            //
25 // Franck Manso (LPC Clermont-Ferrand, manso@clermont.in2p3.fr)             //
26 // Bogdan Vulpescu (LPC Clermont-Ferrand, vulpescu@clermont.in2p3.fr)       //
27 //                                                                          //
28 //////////////////////////////////////////////////////////////////////////////
29
30 //#define OFFLINE
31
32 extern "C" {
33 #include <daqDA.h>
34 }
35
36 #include "event.h"
37 #include "monitor.h"
38
39 #include <Riostream.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42
43 #include "AliRawReaderDate.h"
44
45 #include "AliMpConstants.h"
46 #include "AliMUONRawStreamTrigger.h"
47 #include "AliMUONRawStreamTriggerHP.h"
48 #include "AliMUONDarcHeader.h"
49 #include "AliMUONRegHeader.h"
50 #include "AliMUONDDLTrigger.h"
51 #include "AliMUONVStore.h"
52 #include "AliMUON1DArray.h"
53 #include "AliMUONTriggerIO.h"
54 #include "AliMUONRegionalTriggerConfig.h"
55 #include "AliMUONGlobalCrateConfig.h"
56 #include "AliMUONVCalibParam.h"
57 #include "AliMUONCalibParamND.h"
58 #include "AliMUONCalibParamNI.h"
59 #include "AliMUONLocalStruct.h"
60
61 #include "TString.h"
62 #include "TSystem.h"
63 #include "TStopwatch.h"
64 #include "TROOT.h"
65 #include "TPluginManager.h"
66 #include "TArrayS.h"
67
68 /// class for DA run parameters and DA working space
69 class AliDAConfig : TObject {
70
71 public:
72
73   AliDAConfig() : 
74     fDAConfigFileName("DAConfig.dat"),
75     fCurrentFileName("MtgCurrent.dat"), 
76     fLastCurrentFileName("MtgLastCurrent.dat"), 
77     fSodName(""),
78     fSodFlag(0),
79     fDAName(""),
80     fDAFlag(0),
81     fDAMode(1),
82     fGlobalFileName(""),
83     fRegionalFileName(""),
84     fLocalMaskFileName(""),
85     fLocalLutFileName(""),
86     fSignatureFileName(""),
87     fGlobalFileVersion(0),
88     fRegionalFileVersion(0),
89     fLocalMaskFileVersion(0),
90     fLocalLutFileVersion(0),
91     fSignatureFileVersion(0),
92     fGlobalFileLastVersion(0),
93     fRegionalFileLastVersion(0),
94     fLocalMaskFileLastVersion(0),
95     fLocalLutFileLastVersion(0),
96     fEventsN(0),
97     fEventsD(0),
98     fPrintLevel(0),
99     fLocalMasks(0x0),
100     fLocalMasksDA(0x0),
101     fRegionalMasks(0x0),
102     fGlobalMasks(0x0),
103     fTriggerIO(new AliMUONTriggerIO),
104     fAlgoNoisyInput(kFALSE),
105     fAlgoDeadcInput(kFALSE),
106     fThrN(0.1),
107     fThrD(0.9),
108     fThrLocN(0.1),
109     fThrLocD(0.9),
110     fMinEvents(10),
111     fSkipEvents(0),
112     fMaxEvents(65535),
113     fWithWarnings(kFALSE),
114     fUseFastDecoder(kFALSE),
115     fNLocalBoard(AliMpConstants::TotalNofLocalBoards()+1),
116     fPatternStoreN(0x0),
117     fPatternStoreD(0x0)
118   {
119     /// default constructor
120     for (Int_t ii = 0; ii < kGlobalInputs; ii++) {
121       for (Int_t il = 0; il < kGlobalInputLength; il++) {
122         fAccGlobalInputN[ii][il] = 0;
123         fAccGlobalInputD[ii][il] = 0;
124       }
125     }
126     fLocalMasks    = new AliMUON1DArray(fNLocalBoard);
127     fLocalMasksDA  = new AliMUON1DArray(fNLocalBoard);
128     fRegionalMasks = new AliMUONRegionalTriggerConfig();
129     fGlobalMasks   = new AliMUONGlobalCrateConfig();
130     fPatternStoreN = new AliMUON1DArray(fNLocalBoard);
131     fPatternStoreD = new AliMUON1DArray(fNLocalBoard);
132
133     // Generate local trigger masks store. All masks are set to FFFF
134     for (Int_t i = 1; i <= AliMpConstants::TotalNofLocalBoards(); i++) {
135       AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8,i,0,0);
136       for (Int_t x = 0; x < 2; x++) {
137         for (Int_t y = 0; y < 4; y++) {
138           Int_t index = x*4+y;
139           localBoard->SetValueAsInt(index,0,0xFFFF);
140         }
141       }
142       fLocalMasksDA->Add(localBoard);
143     }
144     
145     // Create a default pattern store
146     for (Int_t i = 1; i <= AliMpConstants::TotalNofLocalBoards(); i++) {
147       AliMUONVCalibParam *patN = new AliMUONCalibParamND(2, 64, i, 0, 0.);
148       AliMUONVCalibParam *patD = new AliMUONCalibParamND(2, 64, i, 0, 0.);
149       fPatternStoreN->Add(patN);        
150       fPatternStoreD->Add(patD);        
151     }
152
153   }
154
155   virtual ~AliDAConfig()
156   {
157     /// destructor
158     delete fLocalMasks;
159     delete fLocalMasksDA;
160     delete fRegionalMasks;
161     delete fGlobalMasks; 
162     delete fPatternStoreN;
163     delete fPatternStoreD;
164     delete fTriggerIO;
165   }
166   void PrintConfig()
167   {
168     /// print DA parameters
169     printf("DA config file name: %s \n",GetDAConfigFileName());
170     printf("Current file name: %s \n",GetCurrentFileName());
171     printf("Last current file name: %s \n",GetLastCurrentFileName());
172     printf("Global file name: %s (%d %d)\n",GetGlobalFileName(),GetGlobalFileVersion(),GetGlobalFileLastVersion());
173     printf("Regional file name: %s (%d %d)\n",GetRegionalFileName(),GetRegionalFileVersion(),GetRegionalFileLastVersion());
174     printf("Local mask file name: %s (%d %d)\n",GetLocalMaskFileName(),GetLocalMaskFileVersion(),GetLocalMaskFileLastVersion());
175     printf("Local LUT file name: %s (%d %d)\n",GetLocalLutFileName(),GetLocalLutFileVersion(),GetLocalLutFileLastVersion());
176     printf("Signature file name: %s (%d)\n",GetSignatureFileName(),GetSignatureFileVersion());
177   }
178
179      /// name of the DA configuration file from detector DB
180   const Char_t* GetDAConfigFileName()    { return fDAConfigFileName.Data(); }
181      /// file with current versions of the configuration files, usually MtgCurrent.dat
182   const Char_t* GetCurrentFileName()     { return fCurrentFileName.Data(); }
183      /// last known versions of the configuration files, usually MtgLastCurrent.dat
184   const Char_t* GetLastCurrentFileName() { return fLastCurrentFileName.Data(); }
185
186      /// name of the Start-of-data field in MtgCurrent.dat
187   const Char_t* GetSodName() { return fSodName.Data(); }
188      /// flag value of the Start-of-data field in MtgCurrent.dat
189   Int_t GetSodFlag() const { return fSodFlag; }
190
191      /// name of the Detector Algorithm field in MtgCurrent.dat
192   const Char_t* GetDAName() { return fDAName.Data(); }
193      /// flag value of the Detector Algorithm field in MtgCurrent.dat
194   Int_t GetDAFlag() const { return fDAFlag; }
195      /// DA active mode (GLOBAL or GLOBAL+LOCAL)
196   Int_t GetDAMode() const { return fDAMode; }
197
198      /// global crate configuration file name
199   const Char_t* GetGlobalFileName()    { return fGlobalFileName.Data(); }
200      /// regional crate configuration file name
201   const Char_t* GetRegionalFileName()  { return fRegionalFileName.Data(); }
202      /// masks for the local cards, file name
203   const Char_t* GetLocalMaskFileName() { return fLocalMaskFileName.Data(); }
204      /// transverse momentum Look-Up-Table, file name
205   const Char_t* GetLocalLutFileName()  { return fLocalLutFileName.Data(); }
206      /// signature file name
207   const Char_t* GetSignatureFileName() { return fSignatureFileName.Data(); }
208
209      /// version of the global crate configuration in the detector DB
210   Int_t GetGlobalFileVersion()    const { return fGlobalFileVersion; }
211      /// version of the regional crate configuration in the detector DB
212   Int_t GetRegionalFileVersion()  const { return fRegionalFileVersion; }
213      /// version of the masks for the local cards in the detector DB
214   Int_t GetLocalMaskFileVersion() const { return fLocalMaskFileVersion; }
215      /// version of the transverse momentum Look-Up-Table in the detector DB
216   Int_t GetLocalLutFileVersion()  const { return fLocalLutFileVersion; }
217      /// version of the signature file in the detector DB
218   Int_t GetSignatureFileVersion() const { return fSignatureFileVersion; }
219
220      /// last known version of the global crate configuration
221   Int_t GetGlobalFileLastVersion()    const { return fGlobalFileLastVersion; }
222      /// last known version of the regional crate configuration
223   Int_t GetRegionalFileLastVersion()  const { return fRegionalFileLastVersion; }
224      /// last known version of the masks for the local cards
225   Int_t GetLocalMaskFileLastVersion() const { return fLocalMaskFileLastVersion; }
226      /// last known version of the transverse momentum Look-Up-Table
227   Int_t GetLocalLutFileLastVersion()  const { return fLocalLutFileLastVersion; }
228
229      /// store for the masks for the local cards (own)
230   AliMUONVStore*                GetLocalMasks()    const { return fLocalMasks; }
231      /// store for the DA-calculated masks for the local cards (own)
232   AliMUONVStore*                GetLocalMasksDA()  const { return fLocalMasksDA; }
233      /// configuration object for the regional crate (own)
234   AliMUONRegionalTriggerConfig* GetRegionalMasks() const { return fRegionalMasks; }
235      /// configuration object for the global crate (own)
236   AliMUONGlobalCrateConfig*     GetGlobalMasks()   const { return fGlobalMasks; }
237
238      /// read/write configurations, masks and LUT to/from online files (own)
239   AliMUONTriggerIO* GetTriggerIO() const { return fTriggerIO; }
240
241      /// store for local strips patterns (noisy strips)
242   AliMUONVStore* GetPatternStoreN() const { return fPatternStoreN; }
243      /// store for local strips patterns (dead strips)
244   AliMUONVStore* GetPatternStoreD() const { return fPatternStoreD; }
245
246      /// number of accumulated PHYSICS events for noisy channels analysis
247   Int_t GetEventsN() const { return fEventsN; }
248      /// number of accumulated CALIBRATION events for dead channels analysis
249   Int_t GetEventsD() const { return fEventsD; }
250
251      /// print verbosity of the DA
252   Int_t GetPrintLevel() const { return fPrintLevel; }
253
254      /// select PHYSICS events for noisy channels analysis
255   Bool_t GetAlgoNoisyInput() const { return fAlgoNoisyInput; }
256      /// select CALIBRATION events for dead channels analysis
257   Bool_t GetAlgoDeadcInput() const { return fAlgoDeadcInput; }
258
259      /// threshold for noisy global inputs (fraction of events)
260   Float_t GetThrN() const { return fThrN; }
261      /// threshold for dead global inputs (fraction of events)
262   Float_t GetThrD() const { return fThrD; }
263      /// threshold for noisy local strips (fraction of events)
264   Float_t GetThrLocN() const { return fThrLocN; }
265      /// threshold for dead local strips (fraction of events)
266   Float_t GetThrLocD() const { return fThrLocD; }
267
268      /// minumum nr of events for rate calculation
269   Int_t GetMinEvents()  const { return fMinEvents; }
270      /// maximum number of events to analyze
271   Int_t GetMaxEvents()  const { return fMaxEvents; }
272      /// number of events to skip from start
273   Int_t GetSkipEvents() const { return fSkipEvents; }
274
275      /// show warnings from the raw data decoder
276   Bool_t WithWarnings() const { return fWithWarnings; }
277      /// use the high-performance (HP) decoder
278   Bool_t UseFastDecoder() const { return fUseFastDecoder; }
279
280      /// number of global input words
281   Int_t GetGlobalInputs()      const { return kGlobalInputs; }
282     /// length in bits of a global input word
283   Int_t GetGlobalInputLength() const { return kGlobalInputLength; }
284
285      /// get accumulated values for bit "ib" from global input word "ii", PHYSICS events
286   Int_t GetAccGlobalInputN(Int_t ii, Int_t ib) const { return fAccGlobalInputN[ii][ib]; }
287      /// get accumulated values for bit "ib" from global input word "ii", CALIBRATION events
288   Int_t GetAccGlobalInputD(Int_t ii, Int_t ib) const { return fAccGlobalInputD[ii][ib]; }
289
290      /// set the name of the Start-of-data field in MtgCurrent.dat
291   void SetSodName(Char_t *name) { fSodName = TString(name); }
292      /// set the flag value of the Start-of-data field in MtgCurrent.dat
293   void SetSodFlag(Int_t flag)   { fSodFlag = flag; }
294
295      /// set the name of the Detector Algorithm field in MtgCurrent.dat
296   void SetDAName(Char_t *name) { fDAName = TString(name); }
297      /// set the flag value of the Detector Algorithm field in MtgCurrent.dat
298   void SetDAFlag(Int_t flag)   { fDAFlag = flag; }
299      /// set DA active mode, 1 = GLOBAL (default), 2 = GLOBAL and LOCAL
300   void SetDAMode(Int_t mode)   { fDAMode = mode; }
301
302      /// set the global crate configuration file name
303   void SetGlobalFileName(const Char_t *name)    { fGlobalFileName = TString(name); }
304      /// set the regional crate configuration file name
305   void SetRegionalFileName(const Char_t *name)  { fRegionalFileName = TString(name); }
306      /// set the masks for the local cards, file name
307   void SetLocalMaskFileName(const Char_t *name) { fLocalMaskFileName = TString(name); }
308      /// set the transverse momentum Look-Up-Table, file name
309   void SetLocalLutFileName(const Char_t *name)  { fLocalLutFileName = TString(name); }
310      /// set the signature file name
311   void SetSignatureFileName(const Char_t *name) { fSignatureFileName = TString(name); }
312
313      /// set the version of the global crate configuration in the detector DB
314   void SetGlobalFileVersion(Int_t ver)    { fGlobalFileVersion = ver; }
315      /// set the version of the regional crate configuration in the detector DB
316   void SetRegionalFileVersion(Int_t ver)  { fRegionalFileVersion = ver; }
317      /// set the version of the masks for the local cards in the detector DB
318   void SetLocalMaskFileVersion(Int_t ver) { fLocalMaskFileVersion = ver; }
319      /// set the version of the transverse momentum Look-Up-Table in the detector DB
320   void SetLocalLutFileVersion(Int_t ver)  { fLocalLutFileVersion = ver; }
321      /// set the version of the signature file in the detector DB
322   void SetSignatureFileVersion(Int_t ver) { fSignatureFileVersion = ver; }
323
324      /// set the last known version of the global crate configuration
325   void SetGlobalFileLastVersion(Int_t ver)    { fGlobalFileLastVersion = ver; }
326      /// set the last known version of the regional crate configuration
327   void SetRegionalFileLastVersion(Int_t ver)  { fRegionalFileLastVersion = ver; }
328      /// set the last known version of the masks for the local cards
329   void SetLocalMaskFileLastVersion(Int_t ver) { fLocalMaskFileLastVersion = ver; }
330      /// set the last known version of the transverse momentum Look-Up-Table
331   void SetLocalLutFileLastVersion(Int_t ver)  { fLocalLutFileLastVersion = ver; }
332
333      /// increment the number of selected PHYSICS events
334   void IncNoiseEvent() { fEventsN++; }
335      /// increment the number of selected CALIBRATION events
336   void IncDeadcEvent() { fEventsD++; }
337
338      /// count the value of the bit "ib" of global input word "ii" (PHYSICS events)
339   void AddAccGlobalInputN(Int_t ii, Int_t ib, Int_t val) { fAccGlobalInputN[ii][ib] += val; }
340      /// count the value of the bit "ib" of global input word "ii" (CALIBRATION events)
341   void AddAccGlobalInputD(Int_t ii, Int_t ib, Int_t val) { fAccGlobalInputD[ii][ib] += val; }
342
343      /// set the print verbosity level of the DA
344   void SetPrintLevel(Int_t level) { fPrintLevel = level; }
345
346      /// select PHYSICS events for noisy channels analysis
347   void SetAlgoNoisyInput(Bool_t val) { fAlgoNoisyInput = val; }
348      /// select CALIBRATION events for dead channels analysis
349   void SetAlgoDeadcInput(Bool_t val) { fAlgoDeadcInput = val; }
350
351      /// set the threshold for noisy global inputs (fraction of events)
352   void SetThrN(Float_t val) { fThrN = val; }
353      /// set the threshold for dead global inputs (fraction of events)
354   void SetThrD(Float_t val) { fThrD = val; }
355      /// set the threshold for noisy local strips (fraction of events)
356   void SetThrLocN(Float_t val) { fThrLocN = val; }
357      /// set the threshold for dead local strips (fraction of events)
358   void SetThrLocD(Float_t val) { fThrLocD = val; }
359
360      /// set the minumum nr of events for rate calculation
361   void SetMinEvents(Int_t val)  { fMinEvents = val; }
362      /// set the maximum number of events to analyze
363   void SetMaxEvents(Int_t val)  { fMaxEvents = val; }
364      /// set the number of events to skip from start
365   void SetSkipEvents(Int_t val) { fSkipEvents = val; }
366
367      /// set/unset to show warnings from the raw data decoder
368   void SetWithWarnings() { fWithWarnings = kTRUE; }
369      /// set/unset the use of the high-performance (HP) decoder
370   void SetUseFastDecoder() { fUseFastDecoder = kTRUE; }
371
372     /// increment version of the global crate configuration file
373   void IncGlobalFileVersion() { fGlobalFileVersion++; }
374     /// increment version of the local mask configuration file
375   void IncLocalMaskFileVersion() { fLocalMaskFileVersion++; }
376     /// count skipped events
377   void DecSkipEvents() { fSkipEvents--; }
378
379 private:
380
381   /// copy constructor, not implemented
382   AliDAConfig (const AliDAConfig& cfg);
383   /// assignment operator, not implemented
384   AliDAConfig& operator=(const AliDAConfig& cfg);
385
386   const TString fDAConfigFileName;    //!< name of the DA configuration file from detector DB
387   const TString fCurrentFileName;     //!< usually MtgCurrent.dat
388   const TString fLastCurrentFileName; //!< usually MtgLastCurrent.dat
389
390   TString fSodName; //!< name of the Start-of-data field in MtgCurrent.dat
391   Int_t   fSodFlag; //!< flag value of the Start-of-data field in MtgCurrent.dat
392
393   TString fDAName;  //!< name of the Detector Algorithm field in MtgCurrent.dat 
394   Int_t   fDAFlag;  //!< flag value of the Detector Algorithm field in MtgCurrent.dat (enabled/disabled)
395   Int_t   fDAMode;  //!< DA active mode, GLOBAL or GLOBAL+LOCAL
396
397   TString fGlobalFileName;      //!< global crate configuration, file name
398   TString fRegionalFileName;    //!< regional crate configuration, file name
399   TString fLocalMaskFileName;   //!< masks for the local cards, file name
400   TString fLocalLutFileName;    //!< transverse momentum Look-Up-Table, file name
401   TString fSignatureFileName;   //!< signature file name
402
403   Int_t   fGlobalFileVersion;    //!< version of the global crate configuration in the detector DB
404   Int_t   fRegionalFileVersion;  //!< version of the regional crate configuration in the detector DB
405   Int_t   fLocalMaskFileVersion; //!< version of the masks for the local cards in the detector DB
406   Int_t   fLocalLutFileVersion;  //!< version of the transverse momentum Look-Up-Table in the detector DB
407   Int_t   fSignatureFileVersion; //!< version of the signature file in the detector DB
408   
409   Int_t   fGlobalFileLastVersion;    //!< last known version of the global crate configuration
410   Int_t   fRegionalFileLastVersion;  //!< last known version of the regional crate configuration
411   Int_t   fLocalMaskFileLastVersion; //!< last known version of the masks for the local cards
412   Int_t   fLocalLutFileLastVersion;  //!< last known version of the transverse momentum Look-Up-Table
413
414   Int_t   fEventsN; //!< number of accumulated PHYSICS events
415   Int_t   fEventsD; //!< number of accumulated CALIBRATION events
416
417   Int_t   fPrintLevel;  //!< print verbosity of the DA
418
419   AliMUONVStore*                fLocalMasks;    //!< store for the masks for the local cards
420   AliMUONVStore*                fLocalMasksDA;  //!< store for the DA-calculated masks for the local cards
421   AliMUONRegionalTriggerConfig* fRegionalMasks; //!< configuration object for the regional crate
422   AliMUONGlobalCrateConfig*     fGlobalMasks;   //!< configuration object for the global crate
423
424   AliMUONTriggerIO *fTriggerIO;  //!< read/write masks and LUT to/from online files
425
426   Bool_t fAlgoNoisyInput; //!< select PHYSICS events for noisy channels analysis
427   Bool_t fAlgoDeadcInput; //!< select CALIBRATION events for dead channels analysis
428
429   Float_t fThrN;           //!< threshold for noisy global inputs (fraction of events)
430   Float_t fThrD;           //!< threshold for dead global inputs (fraction of events)
431   Float_t fThrLocN;        //!< threshold for noisy local strips (fraction of events)
432   Float_t fThrLocD;        //!< threshold for dead local strips (fraction of events)
433   Int_t   fMinEvents;      //!< minumum nr of events for rate calculation
434   Int_t   fSkipEvents;     //!< number of events to skip from start
435   Int_t   fMaxEvents;      //!< maximum number of events to analyze
436   Bool_t  fWithWarnings;   //!< show warnings from the raw data decoder
437   Bool_t  fUseFastDecoder; //!< use the high-performance (HP) decoder
438
439   const Int_t fNLocalBoard; //!< number of local boards
440
441   enum { kGlobalInputs = 4,         //!< number of global input words
442          kGlobalInputLength = 32    //!< length in bits of a global input word
443   };
444
445   AliMUONVStore *fPatternStoreN; //! store for local strips patterns
446   AliMUONVStore *fPatternStoreD; //! store for local strips patterns
447
448   Int_t fAccGlobalInputN[kGlobalInputs][kGlobalInputLength]; //!< storage for global input (PHYSICS events)
449   Int_t fAccGlobalInputD[kGlobalInputs][kGlobalInputLength]; //!< storage for global input (CALIBRATION events)
450
451 };
452
453 //__________________________________________________________________
454 Bool_t ReadDAConfig(AliDAConfig& cfg)
455 {
456     /// read run parameters for the DA
457
458     char line[80];
459
460     TString file;
461     file = cfg.GetDAConfigFileName();
462     std::ifstream in(gSystem->ExpandPathName(file.Data()));
463     if (!in.good()) {
464       printf("Cannot open DA configuration file %s ; use default values.\n",file.Data());
465       return kTRUE;
466     }
467
468     TString tmp;
469     Int_t pos;
470     
471     in.getline(line,80);  
472     tmp = line;
473     pos = tmp.First(" ");
474     tmp = tmp(0,pos);
475     cfg.SetPrintLevel(tmp.Atoi());
476     
477     in.getline(line,80);  
478     tmp = line;
479     pos = tmp.First(" ");
480     tmp = tmp(0,pos);
481     cfg.SetThrN(tmp.Atof());
482
483     in.getline(line,80);  
484     tmp = line;
485     pos = tmp.First(" ");
486     tmp = tmp(0,pos);
487     cfg.SetThrD(tmp.Atof());
488
489     in.getline(line,80);  
490     tmp = line;
491     pos = tmp.First(" ");
492     tmp = tmp(0,pos);
493     cfg.SetMinEvents(tmp.Atoi());
494
495     in.getline(line,80);  
496     tmp = line;
497     pos = tmp.First(" ");
498     tmp = tmp(0,pos);
499     cfg.SetSkipEvents(tmp.Atoi());
500
501     in.getline(line,80);  
502     tmp = line;
503     pos = tmp.First(" ");
504     tmp = tmp(0,pos);
505     cfg.SetMaxEvents(tmp.Atoi());
506
507     in.getline(line,80);  
508     tmp = line;
509     pos = tmp.First(" ");
510     tmp = tmp(0,pos);
511     if (tmp.Atoi() != 0) cfg.SetWithWarnings();
512     
513     in.getline(line,80);  
514     tmp = line;
515     pos = tmp.First(" ");
516     tmp = tmp(0,pos);
517     if (tmp.Atoi() != 0) cfg.SetUseFastDecoder();
518     
519     in.getline(line,80);  
520     tmp = line;
521     pos = tmp.First(" ");
522     tmp = tmp(0,pos);
523     cfg.SetThrLocN(tmp.Atof());
524
525     in.getline(line,80);  
526     tmp = line;
527     pos = tmp.First(" ");
528     tmp = tmp(0,pos);
529     cfg.SetThrLocD(tmp.Atof());
530
531     in.getline(line,80);  
532     tmp = line;
533     pos = tmp.First(" ");
534     tmp = tmp(0,pos);
535     cfg.SetDAMode(tmp.Atoi());
536
537     return kTRUE;
538
539 }
540
541 //__________________________________________________________________
542 void WriteLastCurrentFile(AliDAConfig& cfg, TString currentFile)
543 {
544     /// write last current file
545
546     ofstream out;
547     TString file;
548     file = currentFile;
549     out.open(file.Data());
550     out << cfg.GetSodName() << " " << cfg.GetSodFlag() << endl;
551     out << cfg.GetDAName()  << " " << cfg.GetDAFlag()  << endl;
552
553     out << cfg.GetGlobalFileName()    << " " << cfg.GetGlobalFileVersion()    << endl;
554     out << cfg.GetRegionalFileName()  << " " << cfg.GetRegionalFileVersion()  << endl;
555     out << cfg.GetLocalMaskFileName() << " " << cfg.GetLocalMaskFileVersion() << endl;
556     out << cfg.GetLocalLutFileName()  << " " << cfg.GetLocalLutFileVersion()  << endl;
557     out << cfg.GetSignatureFileName() << " " << cfg.GetSignatureFileVersion() << endl;
558
559     out.close();
560 }
561
562 //___________________________________________________________________________________________
563 Bool_t ReadCurrentFile(AliDAConfig& cfg, TString currentFile, Bool_t lastCurrentFlag = kFALSE)
564 {
565     /// read last current file name and version
566
567     char line[80];
568     char name[80];
569     Int_t flag;
570
571     TString file;
572     file = currentFile;
573     std::ifstream in(gSystem->ExpandPathName(file.Data()));
574     if (!in.good()) {
575       printf("Cannot open last current file %s\n",currentFile.Data());
576       return kFALSE;
577     }
578     
579     // read SOD 
580     in.getline(line,80);  
581     sscanf(line, "%s %d", name, &flag);
582     cfg.SetSodName(name);
583     cfg.SetSodFlag(flag);
584     if (cfg.GetPrintLevel()) printf("Sod Flag %d\n", cfg.GetSodFlag());
585
586     //read DA
587     in.getline(line,80);    
588     sscanf(line, "%s %d", name, &flag);
589     cfg.SetDAName(name);
590     cfg.SetDAFlag(flag);
591     if (cfg.GetPrintLevel()) printf("DA Flag: %d\n", cfg.GetDAFlag());
592
593     // read global
594     in.getline(line,80);    
595     TString tmp(line);
596     Int_t pos =  tmp.First(" ");
597     TString tmp1 = tmp(0, pos);
598     cfg.SetGlobalFileName(tmp1.Data());
599     
600     if (!lastCurrentFlag) {
601       cfg.SetGlobalFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
602       if (cfg.GetPrintLevel()) printf("Global File Name: %s version: %d\n", 
603                                       cfg.GetGlobalFileName(), cfg.GetGlobalFileVersion());
604     } else {
605       cfg.SetGlobalFileLastVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
606       if (cfg.GetPrintLevel()) printf("Global File Name: %s last version: %d\n", 
607                                       cfg.GetGlobalFileName(), cfg.GetGlobalFileLastVersion());
608     }
609
610     // read regional
611     in.getline(line,80);
612     tmp = line;
613     pos = tmp.First(" ");
614     tmp1 = tmp(0, pos);
615     cfg.SetRegionalFileName(tmp1.Data());
616
617     if (!lastCurrentFlag) {
618       cfg.SetRegionalFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
619       if (cfg.GetPrintLevel()) printf("Regional File Name: %s version: %d\n", 
620                                       cfg.GetRegionalFileName(), cfg.GetRegionalFileVersion());
621
622     } else {
623       cfg.SetRegionalFileLastVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
624       if (cfg.GetPrintLevel()) printf("Regional File Name: %s last version: %d\n", 
625                                       cfg.GetRegionalFileName(), cfg.GetRegionalFileLastVersion());
626     }
627
628     // read mask
629     in.getline(line,80);    
630     tmp = line;
631     pos = tmp.First(" ");
632     tmp1 = tmp(0, pos);
633     cfg.SetLocalMaskFileName(tmp1.Data());
634
635     if (!lastCurrentFlag) {
636       cfg.SetLocalMaskFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
637       if (cfg.GetPrintLevel()) printf("Mask File Name: %s version: %d\n", 
638                                       cfg.GetLocalMaskFileName(), cfg.GetLocalMaskFileVersion());
639     } else {
640       cfg.SetLocalMaskFileLastVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
641       if (cfg.GetPrintLevel()) printf("Mask File Name: %s last version: %d\n", 
642                                       cfg.GetLocalMaskFileName(), cfg.GetLocalMaskFileLastVersion());
643     }
644     // read Lut
645     in.getline(line,80);    
646     tmp = line;
647     pos = tmp.First(" ");
648     tmp1 = tmp(0, pos);
649     cfg.SetLocalLutFileName(tmp1.Data());
650
651     if (!lastCurrentFlag) {
652       cfg.SetLocalLutFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
653       if (cfg.GetPrintLevel()) printf("Lut File Name: %s version: %d\n", 
654                                       cfg.GetLocalLutFileName(), cfg.GetLocalLutFileVersion());
655     } else {
656       cfg.SetLocalLutFileLastVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
657       if (cfg.GetPrintLevel()) printf("Lut File Name: %s last version: %d\n", 
658                                       cfg.GetLocalLutFileName(), cfg.GetLocalLutFileLastVersion());
659     }
660
661     in.getline(line,80);    
662     tmp = line;
663     pos = tmp.First(" ");
664     tmp1 = tmp(0, pos);
665     cfg.SetSignatureFileName(tmp1.Data());
666     cfg.SetSignatureFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
667     if (cfg.GetPrintLevel()) printf("Lut File Name: %s version: %d\n", 
668                                     cfg.GetSignatureFileName(), cfg.GetSignatureFileVersion());
669
670     return kTRUE;
671 }
672
673 //_____________
674 void ReadFileNames(AliDAConfig& cfg)
675 {
676   /// if last current file does not exist than read current file
677
678   if (!ReadCurrentFile(cfg,cfg.GetLastCurrentFileName(), kTRUE)) 
679     {
680       ReadCurrentFile(cfg,cfg.GetCurrentFileName(), kTRUE);
681     } 
682   
683   // any case read current file
684   ReadCurrentFile(cfg,cfg.GetCurrentFileName());
685   
686 }
687
688 //__________________
689 Bool_t ExportFiles(AliDAConfig& cfg)
690 {
691     /// Export files to FES
692
693     // env variables have to be set (suppose by ECS ?)
694     // setenv DATE_FES_PATH
695     // setenv DATE_RUN_NUMBER
696     // setenv DATE_ROLE_NAME
697     // setenv DATE_DETECTOR_CODE
698
699 #ifdef OFFLINE
700     gSystem->Setenv("DAQDALIB_PATH", "$DATE_SITE/infoLogger");
701     gSystem->Setenv("DAQDA_TEST_DIR", "/alisoft/FES");
702 #endif
703
704     // update files
705     Int_t status = 0;
706
707     Bool_t modified = kFALSE;
708     Bool_t globalExported = kFALSE;
709
710     ofstream out;
711     TString fileExp("ExportedFiles.dat");
712     TString file;
713
714     out.open(fileExp.Data());
715     if (!out.good()) {
716         printf("Failed to create file: %s\n",file.Data());
717         return kFALSE;
718     }      
719
720     // check if MtgLastCurrent.dat exists
721     // if not, do initial export of all files
722     Bool_t initFES = kFALSE;
723     if (gSystem->AccessPathName("MtgLastCurrent.dat"))
724       initFES = kTRUE;
725     if (initFES) printf("Copy all configuration files to the FES.\n");
726
727     file = cfg.GetLocalMaskFileName();  
728     if ((cfg.GetLocalMaskFileLastVersion() != cfg.GetLocalMaskFileVersion()) || initFES) {
729       modified = kTRUE;
730       status = daqDA_FES_storeFile(file.Data(), "LOCAL");
731       if (status) {
732         printf("Failed to export file: %s\n",cfg.GetLocalMaskFileName());
733         return kFALSE;
734       }
735       if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetLocalMaskFileName());
736       out << cfg.GetLocalMaskFileName() << endl;
737     }
738
739     file = cfg.GetLocalLutFileName();
740     if ((cfg.GetLocalLutFileLastVersion() != cfg.GetLocalLutFileVersion()) || initFES) {
741       modified = kTRUE;
742       status = daqDA_FES_storeFile(file.Data(), "LUT");
743       if (status) {
744         printf("Failed to export file: %s\n",cfg.GetLocalLutFileName());
745         return kFALSE;
746       }
747       if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetLocalLutFileName());
748       out << cfg.GetLocalLutFileName() << endl;
749
750     }
751
752     file = cfg.GetGlobalFileName();
753     if ((cfg.GetGlobalFileLastVersion() != cfg.GetGlobalFileVersion()) || modified || initFES) {
754       modified = kTRUE;
755       globalExported = kTRUE;
756       status = daqDA_FES_storeFile(file.Data(), "GLOBAL");
757       if (status) {
758         printf("Failed to export file: %s\n",cfg.GetGlobalFileName());
759         return kFALSE;
760       }
761       if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetGlobalFileName());
762       out << cfg.GetGlobalFileName() << endl;
763     }
764
765     file = cfg.GetRegionalFileName();
766     if ( (cfg.GetRegionalFileLastVersion() != cfg.GetRegionalFileVersion()) || modified || initFES) {
767       status = daqDA_FES_storeFile(file.Data(), "REGIONAL");
768       if (status) {
769         printf("Failed to export file: %s\n",cfg.GetRegionalFileName());
770         return kFALSE;
771       }
772       if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetRegionalFileName());
773       out << cfg.GetRegionalFileName() << endl;
774
775       // needed for the initialisation of the mapping
776       if (!globalExported) {
777         file = cfg.GetGlobalFileName();
778         status = daqDA_FES_storeFile(file.Data(), "GLOBAL");
779         if (status) {
780           printf("Failed to export file: %s\n",cfg.GetGlobalFileName());
781           return kFALSE;
782         }
783         if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetGlobalFileName());
784         out << cfg.GetGlobalFileName() << endl;
785       }
786
787     }
788
789     out.close();
790
791     // export Exported file to FES anyway
792     status = daqDA_FES_storeFile(fileExp.Data(), "EXPORTED");
793     if (status) {
794       printf("Failed to export file: %s\n", fileExp.Data());
795       return kFALSE;
796     }
797     if(cfg.GetPrintLevel()) printf("Export file: %s\n",fileExp.Data());
798
799     // write last current file
800     WriteLastCurrentFile(cfg,cfg.GetLastCurrentFileName());
801
802     return kTRUE;
803 }
804
805 //__________________
806 Bool_t ImportFiles(AliDAConfig& cfg)
807 {
808     /// copy locally a file from daq detector config db 
809     /// The current detector is identified by detector code in variable
810     /// DATE_DETECTOR_CODE. It must be defined.
811     /// If environment variable DAQDA_TEST_DIR is defined, files are copied from 
812     /// DAQDA_TEST_DIR instead of the database. 
813     /// The usual environment variables are not needed.
814
815     Int_t status = 0;
816
817 #ifdef OFFLINE
818     gSystem->Setenv("DAQDALIB_PATH", "$DATE_SITE/db");
819 #endif
820
821     status = daqDA_DB_getFile(cfg.GetDAConfigFileName(), cfg.GetDAConfigFileName());
822     if (status) {
823       printf("Failed to get DA config file from DB: %s\n",cfg.GetDAConfigFileName());
824       return kFALSE;
825     }
826  
827     ReadDAConfig(cfg);
828     
829     status = daqDA_DB_getFile(cfg.GetCurrentFileName(), cfg.GetCurrentFileName());
830     if (status) {
831       printf("Failed to get current config file from DB: %s\n",cfg.GetCurrentFileName());
832       return kFALSE;
833     }
834     
835     ReadFileNames(cfg);
836
837     status = daqDA_DB_getFile(cfg.GetGlobalFileName(), cfg.GetGlobalFileName());
838     if (status) {
839       printf("Failed to get current config file from DB: %s\n", cfg.GetGlobalFileName());
840       return kFALSE;
841     }
842
843     status = daqDA_DB_getFile(cfg.GetRegionalFileName(), cfg.GetRegionalFileName());
844     if (status) {
845       printf("Failed to get current config file from DB: %s\n",cfg.GetRegionalFileName());
846       return kFALSE;
847     }
848
849     status = daqDA_DB_getFile(cfg.GetLocalMaskFileName(), cfg.GetLocalMaskFileName());
850     if (status) {
851       printf("Failed to get current config file from DB: %s\n",cfg.GetLocalMaskFileName());
852       return kFALSE;
853     }
854
855     status = daqDA_DB_getFile(cfg.GetLocalLutFileName(), cfg.GetLocalLutFileName());
856     if (status) {
857       printf("Failed to get current config file from DB: %s\n",cfg.GetLocalLutFileName());
858       return kFALSE;
859     }
860  
861     return kTRUE;
862 }
863
864 //_____________
865 void ReadMaskFiles(AliDAConfig& cfg)
866 {
867     /// read mask files
868
869     const Char_t* localFile    = cfg.GetLocalMaskFileName();
870     const Char_t* regionalFile = cfg.GetRegionalFileName();
871     const Char_t* globalFile   = cfg.GetGlobalFileName();
872
873     cfg.GetTriggerIO()->ReadConfig(localFile, regionalFile, globalFile, cfg.GetLocalMasks(), cfg.GetRegionalMasks(), cfg.GetGlobalMasks());                     
874 }
875
876 //______________________________________________________________
877 UInt_t GetFetMode(const AliDAConfig & cfg)
878 {
879   /// FET mode = 3 to run algorithm for dead global inputs
880   /// 0x3 prepulse
881   /// 0x0 internal
882
883   return cfg.GetGlobalMasks()->GetFetRegister(3);
884
885 }
886
887 //______________________________________________________________
888 void StoreGlobalInput(AliDAConfig& cfg, const UInt_t * const globalInput) 
889 {
890   /// accumulate and build statistics of global input values
891   
892   for (Int_t ii = 0; ii < cfg.GetGlobalInputs(); ii++) {
893     for (Int_t ib = 0; ib < cfg.GetGlobalInputLength(); ib++) {
894       // lsb -> msb
895       if (cfg.GetAlgoNoisyInput())
896         cfg.AddAccGlobalInputN(ii,ib,((globalInput[ii] >> ib) & 0x1));
897       if (cfg.GetAlgoDeadcInput())
898         cfg.AddAccGlobalInputD(ii,ib,((globalInput[ii] >> ib) & 0x1));
899     }
900   }
901
902 }
903
904 //______________________________________________________________
905 void UpdateGlobalMasks(AliDAConfig& cfg) 
906 {
907   /// update the global masks
908   
909 #ifdef OFFLINE
910   gSystem->Setenv("DAQDALIB_PATH", "$DATE_SITE/db");
911 #endif
912
913   Float_t rateN = 0.0, rateD = 0.0;
914   UInt_t gmask[4], omask;
915   Bool_t noise, deadc, withEvN, withEvD, updated = kFALSE;
916
917   for (Int_t ii = 0; ii < cfg.GetGlobalInputs(); ii++) {
918     gmask[ii] = 0;
919
920     for (Int_t ib = 0; ib < cfg.GetGlobalInputLength(); ib++) {
921       // lsb -> msb
922       noise = kFALSE;
923       deadc = kFALSE;
924       withEvN = kFALSE;
925       withEvD = kFALSE;
926       if (cfg.GetEventsN() > cfg.GetMinEvents()) {
927         rateN = (Float_t)cfg.GetAccGlobalInputN(ii,ib)/(Float_t)cfg.GetEventsN();
928         noise = (rateN > cfg.GetThrN());        
929         withEvN = kTRUE;
930       }
931       if (cfg.GetEventsD() > cfg.GetMinEvents()) {
932         rateD = (Float_t)cfg.GetAccGlobalInputD(ii,ib)/(Float_t)cfg.GetEventsD();
933         deadc = (rateD < cfg.GetThrD());
934         withEvD = kTRUE;
935       }
936       if (!withEvN && !withEvD) {
937         // - copy the bit from the old mask
938         gmask[ii] |= ((cfg.GetGlobalMasks()->GetGlobalMask(ii) >> ib) & 0x1) << ib;
939         if (cfg.GetPrintLevel()) 
940           printf("Mask not changed (just copy the old values)\n");
941       }
942       if (!withEvN && withEvD) {
943         if (!deadc) {
944           // - create a new mask, set the bit to 1
945           //   not allowed!
946           //gmask[ii] |= 0x1 << ib;
947           // - copy the bit from the old mask
948           gmask[ii] |= ((cfg.GetGlobalMasks()->GetGlobalMask(ii) >> ib) & 0x1) << ib;
949         } else {
950           // - create a new mask, set the bit to 0
951           gmask[ii] |= 0x0 << ib;
952           if (cfg.GetPrintLevel()) 
953             printf("Found dead  channel %1d:%02d (%4.2f) \n",ii,ib,rateD);
954         }
955       }
956       if (withEvN && !withEvD) {
957         if (!noise) {
958           // - create a new mask, set the bit to 1
959           //   not allowed!
960           //gmask[ii] |= 0x1 << ib;
961           // - copy the bit from the old mask
962           gmask[ii] |= ((cfg.GetGlobalMasks()->GetGlobalMask(ii) >> ib) & 0x1) << ib;
963         } else {
964           // - create a new mask, set the bit to 0
965           gmask[ii] |= 0x0 << ib;
966           if (cfg.GetPrintLevel()) 
967             printf("Found noisy channel %1d:%02d (%4.2f) \n",ii,ib,rateN);
968         }
969       }
970       if (withEvN && withEvD) {
971         if (!noise && !deadc) {
972           // - create a new mask, set the bit to 1
973           //   not allowed!
974           //gmask[ii] |= 0x1 << ib;
975           // - copy the bit from the old mask
976           gmask[ii] |= ((cfg.GetGlobalMasks()->GetGlobalMask(ii) >> ib) & 0x1) << ib;
977         } else {
978           // - create a new mask, set the bit to 0
979           gmask[ii] |= 0x0 << ib;
980           if (cfg.GetPrintLevel()) {
981             if (noise)
982               printf("Found noisy channel %1d:%02d (%4.2f) \n",ii,ib,rateN);
983             if (deadc)
984               printf("Found dead  channel %1d:%02d (%4.2f) \n",ii,ib,rateD);
985           }
986         }
987       }
988     }
989   }
990
991   // check if at least one mask value has been changed from previous version
992   for (Int_t ii = 0; ii < cfg.GetGlobalInputs(); ii++) {
993     printf("Global mask [%1d] %08x \n",ii,gmask[ii]);
994     omask = cfg.GetGlobalMasks()->GetGlobalMask(ii);
995     if (gmask[ii] != omask) {
996       updated = kTRUE;
997       cfg.GetGlobalMasks()->SetGlobalMask(ii,gmask[ii]);
998     }
999   }
1000
1001   Int_t status = 0;
1002   if (updated) {
1003     
1004     // update version
1005     cfg.IncGlobalFileVersion();
1006     
1007     // don't change the file version ("-x.dat")
1008     
1009     cfg.GetTriggerIO()->WriteGlobalConfig(cfg.GetGlobalFileName(),cfg.GetGlobalMasks());
1010     
1011     // write last current file
1012     WriteLastCurrentFile(cfg,cfg.GetCurrentFileName());
1013
1014     status = daqDA_DB_storeFile(cfg.GetGlobalFileName(), cfg.GetGlobalFileName());
1015     if (status) {
1016       printf("Failed to export file to DB: %s\n",cfg.GetGlobalFileName());
1017       return;
1018     }
1019     
1020     status = daqDA_DB_storeFile(cfg.GetCurrentFileName(), cfg.GetCurrentFileName());
1021     if (status) {
1022       printf("Failed to export file to DB: %s\n",cfg.GetCurrentFileName());
1023       return;
1024     }
1025
1026   }
1027   
1028 }
1029
1030 //______________________________________________________________
1031 void UpdateLocalMask(AliDAConfig& cfg, Int_t localBoardId, Int_t connector, Int_t strip) 
1032 {
1033
1034   /// update local strip mask
1035
1036   AliMUONVCalibParam* localMask = 
1037     static_cast<AliMUONVCalibParam*>(cfg.GetLocalMasksDA()->FindObject(localBoardId));
1038   
1039   UShort_t mask = static_cast<UShort_t>(localMask->ValueAsInt(connector,0)); 
1040   
1041   mask &= ~(0x1 << strip); // set strip mask to zero
1042   
1043   localMask->SetValueAsInt(connector, 0, mask);  
1044
1045 }
1046
1047 //______________________________________________________________
1048 void MakePattern(AliDAConfig& cfg, Int_t localBoardId, const TArrayS& xPattern, const TArrayS& yPattern) 
1049 {
1050   /// calculate the hit map for each strip in x and y direction
1051   
1052   AliMUONVCalibParam* pat = 0x0;
1053
1054   if (cfg.GetAlgoNoisyInput())
1055     pat = static_cast<AliMUONVCalibParam*>(cfg.GetPatternStoreN()->FindObject(localBoardId));
1056   if (cfg.GetAlgoDeadcInput())
1057     pat = static_cast<AliMUONVCalibParam*>(cfg.GetPatternStoreD()->FindObject(localBoardId));
1058
1059   if (!pat) {
1060     pat = new AliMUONCalibParamND(2, 64, localBoardId, 0, 0.);
1061     if (cfg.GetAlgoNoisyInput())
1062       cfg.GetPatternStoreN()->Add(pat); 
1063     if (cfg.GetAlgoDeadcInput())
1064       cfg.GetPatternStoreD()->Add(pat); 
1065   }
1066
1067   for (Int_t i = 0; i < 4; ++i) {
1068     for (Int_t j = 0; j < 16; ++j) {
1069         
1070       Int_t xMask = xPattern[i];
1071       Int_t yMask = yPattern[i];
1072       
1073       Int_t index = 16*i + j;
1074       Double_t patOcc = 0.;
1075       
1076       if ( (xMask >> j ) & 0x1 ) {
1077         patOcc  = pat->ValueAsDouble(index, 0) + 1.;
1078         pat->SetValueAsDouble(index, 0, patOcc);
1079       }
1080       if ( (yMask >> j ) & 0x1 ) {
1081         patOcc  = pat->ValueAsDouble(index, 1) + 1.;
1082         pat->SetValueAsDouble(index, 1, patOcc);
1083       }
1084     }
1085   }
1086
1087 }
1088
1089 //______________________________________________________________
1090 void MakePatternStore(AliDAConfig& cfg) 
1091 {
1092   /// analyse patterns for local strips (calculate occupancy)
1093   
1094 #ifdef OFFLINE
1095   gSystem->Setenv("DAQDALIB_PATH", "$DATE_SITE/db");
1096 #endif
1097
1098   AliMUONVCalibParam* pat;
1099   Int_t localBoardId = 0;
1100   Int_t nEventsN = 0, nEventsD = 0;  
1101   UShort_t strip = 0;
1102   Int_t connector = 0;
1103   Bool_t updated = kFALSE;
1104   
1105   if (cfg.GetEventsN() > cfg.GetMinEvents()) {
1106     nEventsN = cfg.GetEventsN();
1107   }
1108   if (cfg.GetEventsD() > cfg.GetMinEvents()) {
1109     nEventsD = cfg.GetEventsD();
1110   }
1111
1112   // noisy strips
1113   if (nEventsN > 0) {
1114
1115     TIter next(cfg.GetPatternStoreN()->CreateIterator());
1116
1117     while ( ( pat = dynamic_cast<AliMUONVCalibParam*>(next() ) ) ) {
1118       
1119       localBoardId  = pat->ID0();
1120       
1121       for (Int_t index = 0; index < pat->Size(); index++) {
1122         
1123         Double_t patXOcc  = pat->ValueAsDouble(index, 0)/(Double_t)nEventsN;
1124         Double_t patYOcc  = pat->ValueAsDouble(index, 1)/(Double_t)nEventsN;
1125         
1126         pat->SetValueAsDouble(index, 0, patXOcc);
1127         pat->SetValueAsDouble(index, 1, patYOcc);
1128         
1129         // check for x strip
1130         if (patXOcc > cfg.GetThrLocN()) {
1131           strip  = index % 16;
1132           connector = index/16;
1133           UpdateLocalMask(cfg, localBoardId, connector, strip);
1134         }
1135         // check for y strip
1136         if (patYOcc > cfg.GetThrLocN()) {
1137           strip  = index % 16;
1138           connector = index/16 + 4;
1139           UpdateLocalMask(cfg, localBoardId, connector, strip);
1140         }
1141         
1142       }
1143     }
1144     
1145   }
1146   
1147   // dead strips
1148   if (nEventsD > 0) {
1149
1150     TIter next(cfg.GetPatternStoreD()->CreateIterator());
1151
1152     while ( ( pat = dynamic_cast<AliMUONVCalibParam*>(next() ) ) ) {
1153       
1154       localBoardId  = pat->ID0();
1155       
1156       for (Int_t index = 0; index < pat->Size(); index++) {
1157         
1158         Double_t patXOcc  = pat->ValueAsDouble(index, 0)/(Double_t)nEventsD;
1159         Double_t patYOcc  = pat->ValueAsDouble(index, 1)/(Double_t)nEventsD;
1160         
1161         pat->SetValueAsDouble(index, 0, patXOcc);
1162         pat->SetValueAsDouble(index, 1, patYOcc);
1163         
1164         // check for x strip
1165         if (patXOcc < cfg.GetThrLocD()) {
1166           strip  = index % 16;
1167           connector = index/16;
1168           UpdateLocalMask(cfg, localBoardId, connector, strip);
1169         }
1170         // check for y strip
1171         if (patYOcc < cfg.GetThrLocD()) {
1172           strip  = index % 16;
1173           connector = index/16 + 4;
1174           UpdateLocalMask(cfg, localBoardId, connector, strip);
1175         }
1176         
1177       }
1178     }
1179     
1180   }
1181   
1182   // make and AND with the previous version of the mask and
1183   // check if the mask has changed
1184   UShort_t maskDA, mask;
1185   Int_t nMaskBits = AliMpConstants::TotalNofLocalBoards()*8*16;
1186   Int_t nMaskBitsChanged = 0;
1187   for (localBoardId = 1; localBoardId <= AliMpConstants::TotalNofLocalBoards(); localBoardId++) {
1188     AliMUONVCalibParam* localMaskDA = static_cast<AliMUONVCalibParam*>(cfg.GetLocalMasksDA()->FindObject(localBoardId));
1189     AliMUONVCalibParam* localMask = static_cast<AliMUONVCalibParam*>(cfg.GetLocalMasks()->FindObject(localBoardId));
1190     for (connector = 0; connector < 8; connector++) {
1191       maskDA = static_cast<UShort_t>(localMaskDA->ValueAsInt(connector,0)); 
1192       mask = static_cast<UShort_t>(localMask->ValueAsInt(connector,0));
1193       maskDA &= mask; 
1194       localMaskDA->SetValueAsInt(connector, 0, maskDA);  
1195       if (maskDA != mask) {
1196         updated = kTRUE;
1197         // calculated percentage of mask bits changed
1198         for (Int_t iBit = 0; iBit < 16; iBit++) {
1199           if (((maskDA >> iBit) & 0x1) != ((mask >> iBit) &0x1)) {
1200             nMaskBitsChanged++;
1201           }
1202         }
1203       }
1204     }
1205   }
1206
1207   printf("LOCAL mask bits changed = %5d (%7.3f %%) \n",nMaskBitsChanged,100*(Float_t)nMaskBitsChanged/(Float_t)nMaskBits);
1208
1209   Int_t status = 0;
1210   if (updated) {
1211
1212     // update version
1213     cfg.IncLocalMaskFileVersion();
1214     
1215     // don't change the file version ("-x.dat")
1216     
1217     cfg.GetTriggerIO()->WriteLocalMasks(cfg.GetLocalMaskFileName(),*cfg.GetLocalMasksDA());
1218
1219     // write last current file
1220     WriteLastCurrentFile(cfg,cfg.GetCurrentFileName());
1221
1222     status = daqDA_DB_storeFile(cfg.GetLocalMaskFileName(), cfg.GetLocalMaskFileName());
1223     if (status) {
1224       printf("Failed to export file to DB: %s\n",cfg.GetLocalMaskFileName());
1225       return;
1226     }
1227     
1228     status = daqDA_DB_storeFile(cfg.GetCurrentFileName(), cfg.GetCurrentFileName());
1229     if (status) {
1230       printf("Failed to export file to DB: %s\n",cfg.GetCurrentFileName());
1231       return;
1232     }
1233
1234   }
1235
1236 }
1237
1238 //*************************************************************//
1239 int main(Int_t argc, Char_t **argv) 
1240 {
1241     /// main routine
1242   
1243     // needed for streamer application
1244     gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo", "*", "TStreamerInfo", "RIO", "TStreamerInfo()"); 
1245
1246     /* check that we got some arguments = list of files */
1247     if (argc<2) {
1248       printf("Wrong number of arguments\n");
1249       return -1;
1250     }
1251
1252     AliDAConfig cfg;
1253
1254     Char_t inputFile[256] = "";
1255     inputFile[0] = 0;
1256     if (argc > 1)
1257       if (argv[1] != NULL)
1258         strncpy(inputFile, argv[1], 256);
1259       else {
1260         printf("MUONTRGda : No input File !\n");
1261         return -1;
1262       }
1263
1264     // decoding the events
1265   
1266     Int_t status = 0;
1267     Int_t nDateEvents = 0;
1268
1269     void* event;
1270
1271     // containers
1272     // old decoder
1273     AliMUONDDLTrigger*       ddlTrigger     = 0x0;
1274     AliMUONDarcHeader*       darcHeader     = 0x0;
1275     AliMUONRegHeader*        regHeader   = 0x0;
1276     AliMUONLocalStruct*      localStruct = 0x0;
1277     // new (fast) decoder
1278     const AliMUONRawStreamTriggerHP::AliHeader*      darcHeaderHP  = 0x0;
1279     const AliMUONRawStreamTriggerHP::AliLocalStruct* localStructHP = 0x0;
1280
1281     TArrayS xPattern(4);
1282     TArrayS yPattern(4);
1283     Int_t localBoardId = 0;
1284
1285     TStopwatch timers;
1286
1287     timers.Start(kTRUE); 
1288
1289     // comment out, since we do not retrieve files from database
1290     if (!ImportFiles(cfg)) {
1291       printf("Import from DB failed\n");
1292       printf("For local test set DAQDA_TEST_DIR to the local directory where the Mtg files are located \n");
1293       return -1;
1294     }
1295     
1296     ReadMaskFiles(cfg);
1297
1298 #ifdef OFFLINE
1299     // the run number extracted from the file name
1300     TString tmp(inputFile);
1301     Int_t pos1 = tmp.First('d');
1302     Int_t pos2 = tmp.Last('.');
1303     Int_t len  = pos2 - (pos1+3);
1304     tmp = tmp(pos1+3,len);
1305     gSystem->Setenv("DATE_RUN_NUMBER",tmp.Data());
1306     gSystem->Exec("echo \"DATE_RUN_NUMBER = \" $DATE_RUN_NUMBER");
1307 #endif
1308
1309     if(!ExportFiles(cfg)) {
1310       printf("ExportFiles failed\n");
1311       return -1;
1312     }
1313
1314     if (!cfg.GetDAFlag()) {
1315
1316       cout << "MUONTRGda: DA enable: " << cfg.GetDAFlag() << endl;
1317       cout << "MUONTRGda: Print level: " << cfg.GetPrintLevel() << endl;
1318       
1319       printf("MUONTRGda: Execution time : R:%7.2fs C:%7.2fs\n", timers.RealTime(), timers.CpuTime());
1320
1321       return status;
1322
1323     }
1324
1325     // FET is triggered by CTP
1326     Bool_t modeFET3 = kTRUE;
1327     if (GetFetMode(cfg) != 3) {
1328       printf("FET is not in mode 3. Only PHYSICS events will be analysed (noisy channels)\n");
1329       modeFET3 = kFALSE;
1330     }
1331
1332     // All 5 global cards are controlled by the Mts proxy
1333     if (cfg.GetGlobalMasks()->GetGlobalCrateEnable() != 0x1F) {
1334       printf("The MTS proxy does not control all global cards\n");
1335       return -1;
1336     }
1337
1338     // The global cards are ON (active on the global inputs)
1339     if (!cfg.GetGlobalMasks()->GetMasksOn()) {
1340       printf("Global masks are not ON\n");
1341       return -1;
1342     }
1343   
1344     // make sure to catch the "rare" calib events (1 every 50s in physics)
1345     const Char_t* tableSOD[]  = {"ALL", "yes", "CAL", "all", NULL, NULL};
1346     monitorDeclareTable(const_cast<char**>(tableSOD));
1347
1348     status = monitorSetDataSource(inputFile);
1349     if (status) {
1350       cerr << "ERROR : monitorSetDataSource status (hex) = " << hex << status
1351            << " " << monitorDecodeError(status) << endl;
1352       return -1;
1353     }
1354     status = monitorDeclareMp("MUON Trigger monitoring");
1355     if (status) {
1356       cerr << "ERROR : monitorDeclareMp status (hex) = " << hex << status
1357            << " " << monitorDecodeError(status) << endl;
1358       return -1;
1359     }
1360
1361     /* define wait event timeout - 1s max */
1362     monitorSetNowait();
1363     monitorSetNoWaitNetworkTimeout(1000);
1364
1365     cout << "MUONTRGda : Reading data from file " << inputFile <<endl;
1366
1367     UInt_t *globalInput = new UInt_t[4];
1368     Bool_t doUpdate = kFALSE;
1369     Int_t runNumber = 0;
1370     Int_t nEvents = 0;
1371
1372     while(1) 
1373     {
1374       if (nEvents >= cfg.GetMaxEvents()) break;
1375       if (cfg.GetPrintLevel()) {
1376         if (nEvents && nEvents % 1000 == 0)     
1377           cout<<"Cumulated events " << nEvents << endl;
1378       }
1379       // check shutdown condition 
1380       if (daqDA_checkShutdown()) 
1381           break;
1382
1383       // Skip Events if needed
1384       while (cfg.GetSkipEvents()) {
1385         status = monitorGetEventDynamic(&event);
1386         cfg.DecSkipEvents();
1387       }
1388
1389       // starts reading
1390       status = monitorGetEventDynamic(&event);
1391       if (status < 0)  {
1392         cout << "MUONTRGda : EOF found" << endl;
1393         break;
1394       }
1395
1396       nDateEvents++;
1397
1398       // decoding rawdata headers
1399       AliRawReader *rawReader = new AliRawReaderDate(event);
1400  
1401       Int_t eventType = rawReader->GetType();
1402       runNumber = rawReader->GetRunNumber();
1403     
1404       // L1Swc1
1405       // CALIBRATION_EVENT 
1406       // SYSTEM_SOFTWARE_TRIGGER_EVENT
1407       // DETECTOR_SOFTWARE_TRIGGER_EVENT
1408       cfg.SetAlgoNoisyInput(kFALSE);
1409       cfg.SetAlgoDeadcInput(kFALSE);
1410       if (eventType == PHYSICS_EVENT) {
1411         cfg.SetAlgoNoisyInput(kTRUE);
1412         doUpdate = kTRUE;
1413         cfg.IncNoiseEvent();
1414       } else if (modeFET3 && eventType == CALIBRATION_EVENT) {
1415         cfg.SetAlgoDeadcInput(kTRUE);
1416         doUpdate = kTRUE;
1417         cfg.IncDeadcEvent();
1418       } else {
1419         continue;
1420       }
1421       
1422       nEvents++;
1423       if (cfg.GetPrintLevel() == 2) printf("\nEvent # %d\n",nEvents);
1424
1425       // decoding MUON payload
1426       AliMUONVRawStreamTrigger   *rawStream   = 0x0;
1427       if (cfg.UseFastDecoder()) {
1428         rawStream = new AliMUONRawStreamTriggerHP(rawReader);
1429       } else {
1430         rawStream = new AliMUONRawStreamTrigger(rawReader);
1431       }
1432
1433       // ... without warnings from the decoder !!!
1434       if (!cfg.WithWarnings())
1435         rawStream->DisableWarnings();
1436
1437       // loops over DDL 
1438       while((status = rawStream->NextDDL())) {
1439
1440         if (cfg.GetPrintLevel() == 2) printf("iDDL %d\n", rawStream->GetDDL());
1441
1442         if (cfg.UseFastDecoder()) {
1443           darcHeaderHP = static_cast<AliMUONRawStreamTriggerHP*>(rawStream)->GetHeaders();
1444           if (cfg.GetPrintLevel() == 2) printf("Global output (fast decoder) %x\n", (Int_t)darcHeaderHP->GetGlobalOutput());
1445           for (Int_t ig = 0; ig < cfg.GetGlobalInputs(); ig++) {
1446             globalInput[ig] = darcHeaderHP->GetGlobalInput(ig);
1447           }
1448           // loop over regional structure
1449           Int_t nReg = (Int_t)static_cast<AliMUONRawStreamTriggerHP*>(rawStream)->GetRegionalHeaderCount();
1450           for(Int_t iReg = 0; iReg < nReg; iReg++) {
1451             // loop over local structures
1452             Int_t nLoc = (Int_t)static_cast<AliMUONRawStreamTriggerHP*>(rawStream)->GetLocalStructCount(iReg);
1453             for(Int_t iLoc = 0; iLoc < nLoc; iLoc++) {
1454               localStructHP = static_cast<AliMUONRawStreamTriggerHP*>(rawStream)->GetLocalStruct(iReg, iLoc);
1455               localBoardId = cfg.GetTriggerIO()->LocalBoardId(rawStream->GetDDL(),iReg,localStructHP->GetId());
1456               if (localBoardId > 0) {
1457                 localStructHP->GetXPattern(xPattern);
1458                 localStructHP->GetYPattern(yPattern);
1459                 MakePattern(cfg,localBoardId,xPattern,yPattern);
1460               }
1461             }
1462           }
1463         } else {
1464           ddlTrigger = rawStream->GetDDLTrigger();
1465           darcHeader = ddlTrigger->GetDarcHeader();
1466           if (cfg.GetPrintLevel() == 2) printf("Global output %x\n", (Int_t)darcHeader->GetGlobalOutput());
1467           globalInput = darcHeader->GetGlobalInput();
1468           // loop over regional structure
1469           Int_t nReg = darcHeader->GetRegHeaderEntries();
1470           for(Int_t iReg = 0; iReg < nReg; iReg++) {
1471             regHeader = darcHeader->GetRegHeaderEntry(iReg);
1472             // loop over local structures
1473             Int_t nLoc = regHeader->GetLocalEntries();
1474             for(Int_t iLoc = 0; iLoc < nLoc; iLoc++) {  
1475               localStruct = regHeader->GetLocalEntry(iLoc);
1476               localBoardId = cfg.GetTriggerIO()->LocalBoardId(rawStream->GetDDL(),iReg,localStruct->GetId());
1477               if (localBoardId > 0) {
1478                 localStruct->GetXPattern(xPattern);
1479                 localStruct->GetYPattern(yPattern);
1480                 MakePattern(cfg,localBoardId,xPattern,yPattern);
1481               }
1482             }
1483           }
1484         }
1485         if (rawStream->GetDDL() == 0) {
1486           StoreGlobalInput(cfg,globalInput);
1487         }
1488         
1489       } // NextDDL
1490
1491       delete rawReader;
1492       delete rawStream;
1493
1494     } // while (1)
1495
1496     // update configuration files ifrequested event types were found
1497     if (doUpdate) {
1498       if (cfg.GetDAMode() > 0) UpdateGlobalMasks(cfg);
1499       if (cfg.GetDAMode() > 1) MakePatternStore(cfg);
1500     }
1501
1502     timers.Stop();
1503
1504     cout << "MUONTRGda: DA enable: " << cfg.GetDAFlag() << endl;
1505     cout << "MUONTRGda: Run number: " << runNumber << endl;
1506     cout << "MUONTRGda: Nb of DATE events: " << nDateEvents << endl;
1507     cout << "MUONTRGda: Nb of events used: " << nEvents << endl;
1508     cout << "MUONTRGda: Nb of events used (noise): " << cfg.GetEventsN() << endl;
1509     cout << "MUONTRGda: Nb of events used (deadc): " << cfg.GetEventsD() << endl;
1510     cout << "MUONTRGda: Minumum nr of events for rate calculation: " << cfg.GetMinEvents() << endl;
1511     cout << "MUONTRGda: Maximum nr of analyzed events: " << cfg.GetMaxEvents() << endl;
1512     cout << "MUONTRGda: Skip events from start: " << cfg.GetSkipEvents() << endl;
1513     cout << "MUONTRGda: Threshold for global noisy inputs: " << 100*cfg.GetThrN() << "%" << endl;
1514     cout << "MUONTRGda: Threshold for global dead inputs: " << 100*cfg.GetThrD() << "%" << endl;
1515     cout << "MUONTRGda: Threshold for local noisy inputs: " << 100*cfg.GetThrLocN() << "%" << endl;
1516     cout << "MUONTRGda: Threshold for local dead inputs: " << 100*cfg.GetThrLocD() << "%" << endl;
1517     cout << "MUONTRGda: Print level: " << cfg.GetPrintLevel() << endl;
1518     cout << "MUONTRGda: Show decoder warnings: " << cfg.WithWarnings() << endl;
1519     cout << "MUONTRGda: Use the fast decoder: " << cfg.UseFastDecoder() << endl;
1520     cout << "MUONTRGda: DA mode (1=GLOBAL, 2=GLOBAL+LOCAL): " << cfg.GetDAMode() << endl;
1521
1522     printf("MUONTRGda: Execution time : R:%7.2fs C:%7.2fs\n", timers.RealTime(), timers.CpuTime());
1523
1524     return status;
1525
1526 }
1527