MTRda.cxx

Go to the documentation of this file.

/*
MTR DA for online

Contact: Franck Manso <manso@clermont.in2p3.fr>
Link: http://aliceinfo.cern.ch/static/Offline/dimuon/muon_html/README_mtrda.html
Reference run: 61898
Run Type:  PHYSICS
DA Type: MON
Number of events needed: 1000 events
Input files: MtgGlobalCrate.dat MtgRegionalCrate.dat MtgLocalMask.dat MtgLocalLut.dat MtgCurrent.dat DAConfig.dat
Output Files: ExportedFiles.dat MtgGlobalCrate.dat
Trigger types used: PHYSICS_EVENT CALIBRATION_EVENT
*/

// Detector Algorithm for the MUON trigger configuration.                   //
//                                                                          //
// Calculates masks for the global trigger input, by looking at dead        //
// channels in calibration events and at noisy channels in physics events.  //
// Transfers trigger configuration files to the File Exchange Server and    //
// writes them (if modified) into the trigger configuration data base.      //
//                                                                          //
// Authors:                                                                 //
// Christian Fink (formerly at Subatech, Nantes)                            //
// Franck Manso (LPC Clermont-Ferrand, manso@clermont.in2p3.fr)             //
// Bogdan Vulpescu (LPC Clermont-Ferrand, vulpescu@clermont.in2p3.fr)       //
//                                                                          //

//#define OFFLINE

extern "C" {
#include <daqDA.h>
}

#include "event.h"
#include "monitor.h"

#include <Riostream.h>
#include <stdio.h>
#include <stdlib.h>

#include "AliRawReaderDate.h"

#include "AliMpConstants.h"
#include "AliMUONRawStreamTrigger.h"
#include "AliMUONRawStreamTriggerHP.h"
#include "AliMUONDarcHeader.h"
#include "AliMUONRegHeader.h"
#include "AliMUONDDLTrigger.h"
#include "AliMUONVStore.h"
#include "AliMUON1DArray.h"
#include "AliMUONTriggerIO.h"
#include "AliMUONRegionalTriggerConfig.h"
#include "AliMUONGlobalCrateConfig.h"
#include "AliMUONVCalibParam.h"
#include "AliMUONCalibParamND.h"
#include "AliMUONCalibParamNI.h"
#include "AliMUONLocalStruct.h"

#include "TString.h"
#include "TSystem.h"
#include "TStopwatch.h"
#include "TROOT.h"
#include "TPluginManager.h"
#include "TArrayS.h"

static const TString fileExp("ExportedFiles.dat");

class AliDAConfig : TObject {

public:

  AliDAConfig() : 
    fDAConfigFileName("DAConfig.dat"),
    fCurrentFileName("MtgCurrent.dat"), 
    fLastCurrentFileName("MtgLastCurrent.dat"), 
    fSodName(""),
    fSodFlag(0),
    fDAName(""),
    fDAFlag(0),
    fDAMode(1),
    fGlobalFileName(""),
    fRegionalFileName(""),
    fLocalMaskFileName(""),
    fLocalLutFileName(""),
    fSignatureFileName(""),
    fTrigScalFileName("MtgTrigScalers.dat"),
    fGlobalFileVersion(0),
    fRegionalFileVersion(0),
    fLocalMaskFileVersion(0),
    fLocalLutFileVersion(0),
    fSignatureFileVersion(0),
    fGlobalFileLastVersion(0),
    fRegionalFileLastVersion(0),
    fLocalMaskFileLastVersion(0),
    fLocalLutFileLastVersion(0),
    fEventsN(0),
    fEventsD(0),
    fPrintLevel(0),
    fLocalMasks(0x0),
    fLocalMasksDA(0x0),
    fRegionalMasks(0x0),
    fGlobalMasks(0x0),
    fTriggerIO(new AliMUONTriggerIO),
    fAlgoNoisyInput(kFALSE),
    fAlgoDeadcInput(kFALSE),
    fThrN(0.1),
    fThrD(0.9),
    fThrLocN(0.1),
    fThrLocD(0.9),
    fMinEvents(10),
    fSkipEvents(0),
    fMaxEvents(65535),
    fWithWarnings(kFALSE),
    fUseFastDecoder(kFALSE),
    fNLocalBoard(AliMpConstants::TotalNofLocalBoards()+1),
    fPatternStoreN(0x0),
    fPatternStoreD(0x0),
    fSaveScalers(kFALSE),
    fScalerRecTime(600)
  {
    for (Int_t ii = 0; ii < kGlobalInputs; ii++) {
      for (Int_t il = 0; il < kGlobalInputLength; il++) {
  fAccGlobalInputN[ii][il] = 0;
  fAccGlobalInputD[ii][il] = 0;
      }
    }
    fLocalMasks    = new AliMUON1DArray(fNLocalBoard);
    fLocalMasksDA  = new AliMUON1DArray(fNLocalBoard);
    fRegionalMasks = new AliMUONRegionalTriggerConfig();
    fGlobalMasks   = new AliMUONGlobalCrateConfig();
    fPatternStoreN = new AliMUON1DArray(fNLocalBoard);
    fPatternStoreD = new AliMUON1DArray(fNLocalBoard);

    // Generate local trigger masks store. All masks are set to FFFF
    for (Int_t i = 1; i <= AliMpConstants::TotalNofLocalBoards(); i++) {
      AliMUONVCalibParam* localBoard = new AliMUONCalibParamNI(1,8,i,0,0);
      for (Int_t x = 0; x < 2; x++) {
  for (Int_t y = 0; y < 4; y++) {
    Int_t index = x*4+y;
    localBoard->SetValueAsInt(index,0,0xFFFF);
  }
      }
      fLocalMasksDA->Add(localBoard);
    }
    
    // Create a default pattern store
    for (Int_t i = 1; i <= AliMpConstants::TotalNofLocalBoards(); i++) {
      AliMUONVCalibParam *patN = new AliMUONCalibParamND(2, 64, i, 0, 0.);
      AliMUONVCalibParam *patD = new AliMUONCalibParamND(2, 64, i, 0, 0.);
      fPatternStoreN->Add(patN);  
      fPatternStoreD->Add(patD);  
    }

  }

  virtual ~AliDAConfig()
  {
    delete fLocalMasks;
    delete fLocalMasksDA;
    delete fRegionalMasks;
    delete fGlobalMasks; 
    delete fPatternStoreN;
    delete fPatternStoreD;
    delete fTriggerIO;
  }
  void PrintConfig()
  {
    printf("DA config file name: %s \n",GetDAConfigFileName());
    printf("Current file name: %s \n",GetCurrentFileName());
    printf("Last current file name: %s \n",GetLastCurrentFileName());
    printf("Global file name: %s (%d %d)\n",GetGlobalFileName(),GetGlobalFileVersion(),GetGlobalFileLastVersion());
    printf("Regional file name: %s (%d %d)\n",GetRegionalFileName(),GetRegionalFileVersion(),GetRegionalFileLastVersion());
    printf("Local mask file name: %s (%d %d)\n",GetLocalMaskFileName(),GetLocalMaskFileVersion(),GetLocalMaskFileLastVersion());
    printf("Local LUT file name: %s (%d %d)\n",GetLocalLutFileName(),GetLocalLutFileVersion(),GetLocalLutFileLastVersion());
    printf("Signature file name: %s (%d)\n",GetSignatureFileName(),GetSignatureFileVersion());
  }

  const Char_t* GetDAConfigFileName()    { return fDAConfigFileName.Data(); }
  const Char_t* GetCurrentFileName()     { return fCurrentFileName.Data(); }
  const Char_t* GetLastCurrentFileName() { return fLastCurrentFileName.Data(); }

  const Char_t* GetSodName() { return fSodName.Data(); }
  Int_t GetSodFlag() const { return fSodFlag; }

  const Char_t* GetDAName() { return fDAName.Data(); }
  Int_t GetDAFlag() const { return fDAFlag; }
  Int_t GetDAMode() const { return fDAMode; }

  const Char_t* GetGlobalFileName()    { return fGlobalFileName.Data(); }
  const Char_t* GetRegionalFileName()  { return fRegionalFileName.Data(); }
  const Char_t* GetLocalMaskFileName() { return fLocalMaskFileName.Data(); }
  const Char_t* GetLocalLutFileName()  { return fLocalLutFileName.Data(); }
  const Char_t* GetSignatureFileName() { return fSignatureFileName.Data(); }
  const Char_t* GetTrigScalFileName() { return fTrigScalFileName.Data(); }

  Int_t GetGlobalFileVersion()    const { return fGlobalFileVersion; }
  Int_t GetRegionalFileVersion()  const { return fRegionalFileVersion; }
  Int_t GetLocalMaskFileVersion() const { return fLocalMaskFileVersion; }
  Int_t GetLocalLutFileVersion()  const { return fLocalLutFileVersion; }
  Int_t GetSignatureFileVersion() const { return fSignatureFileVersion; }

  Int_t GetGlobalFileLastVersion()    const { return fGlobalFileLastVersion; }
  Int_t GetRegionalFileLastVersion()  const { return fRegionalFileLastVersion; }
  Int_t GetLocalMaskFileLastVersion() const { return fLocalMaskFileLastVersion; }
  Int_t GetLocalLutFileLastVersion()  const { return fLocalLutFileLastVersion; }

  AliMUONVStore*                GetLocalMasks()    const { return fLocalMasks; }
  AliMUONVStore*                GetLocalMasksDA()  const { return fLocalMasksDA; }
  AliMUONRegionalTriggerConfig* GetRegionalMasks() const { return fRegionalMasks; }
  AliMUONGlobalCrateConfig*     GetGlobalMasks()   const { return fGlobalMasks; }

  AliMUONTriggerIO* GetTriggerIO() const { return fTriggerIO; }

  AliMUONVStore* GetPatternStoreN() const { return fPatternStoreN; }
  AliMUONVStore* GetPatternStoreD() const { return fPatternStoreD; }

  Int_t GetEventsN() const { return fEventsN; }
  Int_t GetEventsD() const { return fEventsD; }

  Int_t GetPrintLevel() const { return fPrintLevel; }

  Bool_t GetAlgoNoisyInput() const { return fAlgoNoisyInput; }
  Bool_t GetAlgoDeadcInput() const { return fAlgoDeadcInput; }

  Float_t GetThrN() const { return fThrN; }
  Float_t GetThrD() const { return fThrD; }
  Float_t GetThrLocN() const { return fThrLocN; }
  Float_t GetThrLocD() const { return fThrLocD; }

  Int_t GetMinEvents()  const { return fMinEvents; }
  Int_t GetMaxEvents()  const { return fMaxEvents; }
  Int_t GetSkipEvents() const { return fSkipEvents; }

  Bool_t WithWarnings() const { return fWithWarnings; }
  Bool_t UseFastDecoder() const { return fUseFastDecoder; }

  Bool_t SaveScalers() const { return fSaveScalers; }
  UInt_t GetScalerRecTime() const { return fScalerRecTime; }


  Int_t GetGlobalInputs()      const { return kGlobalInputs; }
  Int_t GetGlobalInputLength() const { return kGlobalInputLength; }

  Int_t GetAccGlobalInputN(Int_t ii, Int_t ib) const { return fAccGlobalInputN[ii][ib]; }
  Int_t GetAccGlobalInputD(Int_t ii, Int_t ib) const { return fAccGlobalInputD[ii][ib]; }

  void SetSodName(Char_t *name) { fSodName = TString(name); }
  void SetSodFlag(Int_t flag)   { fSodFlag = flag; }

  void SetDAName(Char_t *name) { fDAName = TString(name); }
  void SetDAFlag(Int_t flag)   { fDAFlag = flag; }
  void SetDAMode(Int_t mode)   { fDAMode = mode; }

  void SetGlobalFileName(const Char_t *name)    { fGlobalFileName = TString(name); }
  void SetRegionalFileName(const Char_t *name)  { fRegionalFileName = TString(name); }
  void SetLocalMaskFileName(const Char_t *name) { fLocalMaskFileName = TString(name); }
  void SetLocalLutFileName(const Char_t *name)  { fLocalLutFileName = TString(name); }
  void SetSignatureFileName(const Char_t *name) { fSignatureFileName = TString(name); }
  void SetTrigScalFileName(const Char_t *name) { fTrigScalFileName = TString(name); }

  void SetGlobalFileVersion(Int_t ver)    { fGlobalFileVersion = ver; }
  void SetRegionalFileVersion(Int_t ver)  { fRegionalFileVersion = ver; }
  void SetLocalMaskFileVersion(Int_t ver) { fLocalMaskFileVersion = ver; }
  void SetLocalLutFileVersion(Int_t ver)  { fLocalLutFileVersion = ver; }
  void SetSignatureFileVersion(Int_t ver) { fSignatureFileVersion = ver; }

  void SetGlobalFileLastVersion(Int_t ver)    { fGlobalFileLastVersion = ver; }
  void SetRegionalFileLastVersion(Int_t ver)  { fRegionalFileLastVersion = ver; }
  void SetLocalMaskFileLastVersion(Int_t ver) { fLocalMaskFileLastVersion = ver; }
  void SetLocalLutFileLastVersion(Int_t ver)  { fLocalLutFileLastVersion = ver; }

  void IncNoiseEvent() { fEventsN++; }
  void IncDeadcEvent() { fEventsD++; }

  void AddAccGlobalInputN(Int_t ii, Int_t ib, Int_t val) { fAccGlobalInputN[ii][ib] += val; }
  void AddAccGlobalInputD(Int_t ii, Int_t ib, Int_t val) { fAccGlobalInputD[ii][ib] += val; }

  void SetPrintLevel(Int_t level) { fPrintLevel = level; }

  void SetAlgoNoisyInput(Bool_t val) { fAlgoNoisyInput = val; }
  void SetAlgoDeadcInput(Bool_t val) { fAlgoDeadcInput = val; }

  void SetThrN(Float_t val) { fThrN = val; }
  void SetThrD(Float_t val) { fThrD = val; }
  void SetThrLocN(Float_t val) { fThrLocN = val; }
  void SetThrLocD(Float_t val) { fThrLocD = val; }

  void SetMinEvents(Int_t val)  { fMinEvents = val; }
  void SetMaxEvents(Int_t val)  { fMaxEvents = val; }
  void SetSkipEvents(Int_t val) { fSkipEvents = val; }

  void SetWithWarnings() { fWithWarnings = kTRUE; }
  void SetUseFastDecoder() { fUseFastDecoder = kTRUE; }
  void SetSaveScalers(Bool_t val) { fSaveScalers = val; }
  void SetScalerRecTime(Int_t trec) { fScalerRecTime = (UInt_t)trec; }

  void IncGlobalFileVersion() { fGlobalFileVersion++; }
  void IncLocalMaskFileVersion() { fLocalMaskFileVersion++; }
  void DecSkipEvents() { fSkipEvents--; }

private:

  AliDAConfig (const AliDAConfig& cfg);
  AliDAConfig& operator=(const AliDAConfig& cfg);

  const TString fDAConfigFileName;    
  const TString fCurrentFileName;     
  const TString fLastCurrentFileName; 

  TString fSodName; 
  Int_t   fSodFlag; 

  TString fDAName;  
  Int_t   fDAFlag;  
  Int_t   fDAMode;  

  TString fGlobalFileName;      
  TString fRegionalFileName;    
  TString fLocalMaskFileName;   
  TString fLocalLutFileName;    
  TString fSignatureFileName;   
  TString fTrigScalFileName;    

  Int_t   fGlobalFileVersion;    
  Int_t   fRegionalFileVersion;  
  Int_t   fLocalMaskFileVersion; 
  Int_t   fLocalLutFileVersion;  
  Int_t   fSignatureFileVersion; 
  
  Int_t   fGlobalFileLastVersion;    
  Int_t   fRegionalFileLastVersion;  
  Int_t   fLocalMaskFileLastVersion; 
  Int_t   fLocalLutFileLastVersion;  

  Int_t   fEventsN; 
  Int_t   fEventsD; 

  Int_t   fPrintLevel;  

  AliMUONVStore*                fLocalMasks;    
  AliMUONVStore*                fLocalMasksDA;  
  AliMUONRegionalTriggerConfig* fRegionalMasks; 
  AliMUONGlobalCrateConfig*     fGlobalMasks;   

  AliMUONTriggerIO *fTriggerIO;  

  Bool_t fAlgoNoisyInput; 
  Bool_t fAlgoDeadcInput; 

  Float_t fThrN;           
  Float_t fThrD;           
  Float_t fThrLocN;        
  Float_t fThrLocD;        
  Int_t   fMinEvents;      
  Int_t   fSkipEvents;     
  Int_t   fMaxEvents;      
  Bool_t  fWithWarnings;   
  Bool_t  fUseFastDecoder; 

  const Int_t fNLocalBoard; 

  enum { kGlobalInputs = 4,         
   kGlobalInputLength = 32    
  };

  AliMUONVStore *fPatternStoreN; 
  AliMUONVStore *fPatternStoreD; 

  Int_t fAccGlobalInputN[kGlobalInputs][kGlobalInputLength]; 
  Int_t fAccGlobalInputD[kGlobalInputs][kGlobalInputLength]; 

  Bool_t fSaveScalers;   
  Int_t  fScalerRecTime; 

};

//__________________________________________________________________
Bool_t ReadDAConfig(AliDAConfig& cfg)
{

    char line[80];

    TString file;
    file = cfg.GetDAConfigFileName();
    std::ifstream in(gSystem->ExpandPathName(file.Data()));
    if (!in.good()) {
      printf("Cannot open DA configuration file %s ; use default values.\n",file.Data());
      return kTRUE;
    }

    TString tmp;
    Int_t pos;
    
    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetPrintLevel(tmp.Atoi());
    
    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetThrN(tmp.Atof());

    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetThrD(tmp.Atof());

    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetMinEvents(tmp.Atoi());

    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetSkipEvents(tmp.Atoi());

    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetMaxEvents(tmp.Atoi());

    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    if (tmp.Atoi() != 0) cfg.SetWithWarnings();
    
    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    if (tmp.Atoi() != 0) cfg.SetUseFastDecoder();
    
    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetThrLocN(tmp.Atof());

    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetThrLocD(tmp.Atof());

    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetDAMode(tmp.Atoi());

    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    tmp.Atoi() == 0 ? cfg.SetSaveScalers(kFALSE) : cfg.SetSaveScalers(kTRUE);
    
    in.getline(line,80);  
    tmp = line;
    pos = tmp.First(" ");
    tmp = tmp(0,pos);
    cfg.SetScalerRecTime(tmp.Atoi());
    
    return kTRUE;

}

//__________________________________________________________________
void WriteLastCurrentFile(AliDAConfig& cfg, TString currentFile)
{

    ofstream out;
    TString file;
    file = currentFile;
    out.open(file.Data(), std::ofstream::out);
    out << cfg.GetSodName() << " " << cfg.GetSodFlag() << endl;
    out << cfg.GetDAName()  << " " << cfg.GetDAFlag()  << endl;

    out << cfg.GetGlobalFileName()    << " " << cfg.GetGlobalFileVersion()    << endl;
    out << cfg.GetRegionalFileName()  << " " << cfg.GetRegionalFileVersion()  << endl;
    out << cfg.GetLocalMaskFileName() << " " << cfg.GetLocalMaskFileVersion() << endl;
    out << cfg.GetLocalLutFileName()  << " " << cfg.GetLocalLutFileVersion()  << endl;
    out << cfg.GetSignatureFileName() << " " << cfg.GetSignatureFileVersion() << endl;

    out.close();
}

//___________________________________________________________________________________________
Bool_t ReadCurrentFile(AliDAConfig& cfg, TString currentFile, Bool_t lastCurrentFlag = kFALSE)
{

    char line[80];
    char name[80];
    Int_t flag;

    TString file;
    file = currentFile;
    std::ifstream in(gSystem->ExpandPathName(file.Data()));
    if (!in.good()) {
      printf("Cannot open last current file %s\n",currentFile.Data());
      return kFALSE;
    }
    
    // read SOD 
    in.getline(line,80);  
    sscanf(line, "%s %d", name, &flag);
    cfg.SetSodName(name);
    cfg.SetSodFlag(flag);
    if (cfg.GetPrintLevel()) printf("Sod Flag %d\n", cfg.GetSodFlag());

    //read DA
    in.getline(line,80);    
    sscanf(line, "%s %d", name, &flag);
    cfg.SetDAName(name);
    cfg.SetDAFlag(flag);
    if (cfg.GetPrintLevel()) printf("DA Flag: %d\n", cfg.GetDAFlag());

    // read global
    in.getline(line,80);    
    TString tmp(line);
    Int_t pos =  tmp.First(" ");
    TString tmp1 = tmp(0, pos);
    cfg.SetGlobalFileName(tmp1.Data());
    
    if (!lastCurrentFlag) {
      cfg.SetGlobalFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
      if (cfg.GetPrintLevel()) printf("Global File Name: %s version: %d\n", 
              cfg.GetGlobalFileName(), cfg.GetGlobalFileVersion());
    } else {
      cfg.SetGlobalFileLastVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
      if (cfg.GetPrintLevel()) printf("Global File Name: %s last version: %d\n", 
              cfg.GetGlobalFileName(), cfg.GetGlobalFileLastVersion());
    }

    // read regional
    in.getline(line,80);
    tmp = line;
    pos = tmp.First(" ");
    tmp1 = tmp(0, pos);
    cfg.SetRegionalFileName(tmp1.Data());

    if (!lastCurrentFlag) {
      cfg.SetRegionalFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
      if (cfg.GetPrintLevel()) printf("Regional File Name: %s version: %d\n", 
              cfg.GetRegionalFileName(), cfg.GetRegionalFileVersion());

    } else {
      cfg.SetRegionalFileLastVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
      if (cfg.GetPrintLevel()) printf("Regional File Name: %s last version: %d\n", 
              cfg.GetRegionalFileName(), cfg.GetRegionalFileLastVersion());
    }

    // read mask
    in.getline(line,80);    
    tmp = line;
    pos = tmp.First(" ");
    tmp1 = tmp(0, pos);
    cfg.SetLocalMaskFileName(tmp1.Data());

    if (!lastCurrentFlag) {
      cfg.SetLocalMaskFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
      if (cfg.GetPrintLevel()) printf("Mask File Name: %s version: %d\n", 
              cfg.GetLocalMaskFileName(), cfg.GetLocalMaskFileVersion());
    } else {
      cfg.SetLocalMaskFileLastVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
      if (cfg.GetPrintLevel()) printf("Mask File Name: %s last version: %d\n", 
              cfg.GetLocalMaskFileName(), cfg.GetLocalMaskFileLastVersion());
    }
    // read Lut
    in.getline(line,80);    
    tmp = line;
    pos = tmp.First(" ");
    tmp1 = tmp(0, pos);
    cfg.SetLocalLutFileName(tmp1.Data());

    if (!lastCurrentFlag) {
      cfg.SetLocalLutFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
      if (cfg.GetPrintLevel()) printf("Lut File Name: %s version: %d\n", 
              cfg.GetLocalLutFileName(), cfg.GetLocalLutFileVersion());
    } else {
      cfg.SetLocalLutFileLastVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
      if (cfg.GetPrintLevel()) printf("Lut File Name: %s last version: %d\n", 
              cfg.GetLocalLutFileName(), cfg.GetLocalLutFileLastVersion());
    }

    in.getline(line,80);    
    tmp = line;
    pos = tmp.First(" ");
    tmp1 = tmp(0, pos);
    cfg.SetSignatureFileName(tmp1.Data());
    cfg.SetSignatureFileVersion(atoi(tmp(pos+1, tmp.Length()-pos).Data()));
    if (cfg.GetPrintLevel()) printf("Lut File Name: %s version: %d\n", 
            cfg.GetSignatureFileName(), cfg.GetSignatureFileVersion());

    return kTRUE;
}

//_____________
void ReadFileNames(AliDAConfig& cfg)
{

  if (!ReadCurrentFile(cfg,cfg.GetLastCurrentFileName(), kTRUE)) 
    {
      ReadCurrentFile(cfg,cfg.GetCurrentFileName(), kTRUE);
    } 
  
  // any case read current file
  ReadCurrentFile(cfg,cfg.GetCurrentFileName());
  
}

//__________________
Bool_t ExportFiles(AliDAConfig& cfg)
{

    // env variables have to be set (suppose by ECS ?)
    // setenv DATE_FES_PATH
    // setenv DATE_RUN_NUMBER
    // setenv DATE_ROLE_NAME
    // setenv DATE_DETECTOR_CODE

#ifdef OFFLINE
    gSystem->Setenv("DAQDALIB_PATH", "$DATE_ROOT/infoLogger");
    gSystem->Setenv("DAQDA_TEST_DIR", "/users_local1/Software/ALICE/AMORE/FES");
#endif

    // update files
    Int_t status = 0;

    Bool_t modified = kFALSE;
    Bool_t globalExported = kFALSE;

    ofstream out;
    TString file;

    out.open(fileExp.Data(), std::ofstream::out);
    if (!out.good()) {
  printf("Failed to create file: %s\n",fileExp.Data());
  return kFALSE;
    }      

    // check if MtgLastCurrent.dat exists
    // if not, do initial export of all files
    Bool_t initFES = kFALSE;
    if (gSystem->AccessPathName("MtgLastCurrent.dat"))
      initFES = kTRUE;
    if (initFES) printf("Copy all configuration files to the FES.\n");

    file = cfg.GetLocalMaskFileName();  
    if ((cfg.GetLocalMaskFileLastVersion() != cfg.GetLocalMaskFileVersion()) || initFES) {
      modified = kTRUE;
      status = 0;
      status = daqDA_FES_storeFile(file.Data(), "LOCAL");
      if (status) {
  printf("Failed to export file: %s\n",cfg.GetLocalMaskFileName());
  return kFALSE;
      }
      if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetLocalMaskFileName());
      out << cfg.GetLocalMaskFileName() << endl;
    }

    file = cfg.GetLocalLutFileName();
    if ((cfg.GetLocalLutFileLastVersion() != cfg.GetLocalLutFileVersion()) || initFES) {
      modified = kTRUE;
      status = 0;
      status = daqDA_FES_storeFile(file.Data(), "LUT");
      if (status) {
  printf("Failed to export file: %s\n",cfg.GetLocalLutFileName());
  return kFALSE;
      }
      if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetLocalLutFileName());
      out << cfg.GetLocalLutFileName() << endl;

    }

    file = cfg.GetGlobalFileName();
    if ((cfg.GetGlobalFileLastVersion() != cfg.GetGlobalFileVersion()) || modified || initFES) {
      modified = kTRUE;
      globalExported = kTRUE;
      status = 0;
      status = daqDA_FES_storeFile(file.Data(), "GLOBAL");
      if (status) {
  printf("Failed to export file: %s\n",cfg.GetGlobalFileName());
  return kFALSE;
      }
      if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetGlobalFileName());
      out << cfg.GetGlobalFileName() << endl;
    }

    file = cfg.GetRegionalFileName();
    if ( (cfg.GetRegionalFileLastVersion() != cfg.GetRegionalFileVersion()) || modified || initFES) {
      status = 0;
      status = daqDA_FES_storeFile(file.Data(), "REGIONAL");
      if (status) {
  printf("Failed to export file: %s\n",cfg.GetRegionalFileName());
  return kFALSE;
      }
      if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetRegionalFileName());
      out << cfg.GetRegionalFileName() << endl;

      // needed for the initialisation of the mapping
      if (!globalExported) {
  file = cfg.GetGlobalFileName();
  status = 0;
  status = daqDA_FES_storeFile(file.Data(), "GLOBAL");
  if (status) {
    printf("Failed to export file: %s\n",cfg.GetGlobalFileName());
    return kFALSE;
  }
  if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetGlobalFileName());
  out << cfg.GetGlobalFileName() << endl;
      }

    }

    out.close();

    // write last current file
    WriteLastCurrentFile(cfg,cfg.GetLastCurrentFileName());

    return kTRUE;
}

//__________________
Bool_t ExportTRIGSCAL(AliDAConfig& cfg)
{


  TString file;
  Int_t status = 0;

  ofstream out;
  out.open(fileExp.Data(), std::ofstream::app);
  if (!out.good()) {
    printf("Failed to open file in append mode: %s\n",fileExp.Data());
    return kFALSE;
  }

  // global config
  file = cfg.GetGlobalFileName();
  status = 0;
  status = daqDA_FES_storeFile(file.Data(), "GLOBAL");
  if (status) {
    printf("Failed to export file: %s\n",cfg.GetGlobalFileName());
    return kFALSE;
  }
  if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetGlobalFileName());
  out << cfg.GetGlobalFileName() << endl;

  // regional config
  file = cfg.GetRegionalFileName();
  status = 0;
  status = daqDA_FES_storeFile(file.Data(), "REGIONAL");
  if (status) {
    printf("Failed to export file: %s\n",cfg.GetRegionalFileName());
    return kFALSE;
  }
  if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetRegionalFileName());
  out << cfg.GetRegionalFileName() << endl;

  // trigger scalers
  file = cfg.GetTrigScalFileName();  
  status = 0;
  status = daqDA_FES_storeFile(file.Data(), "TRIGSCAL");
  if (status) {
    printf("Failed to export file: %s\n",cfg.GetTrigScalFileName());
    return status;
  }
  if(cfg.GetPrintLevel()) printf("Export file: %s\n",cfg.GetTrigScalFileName());
  out << cfg.GetTrigScalFileName() << endl;

  out.close();

  return kTRUE;

}

//__________________
Bool_t ImportFiles(AliDAConfig& cfg)
{

    Int_t status = 0;

#ifdef OFFLINE
    gSystem->Setenv("DAQDALIB_PATH", "$DATE_ROOT/db");
#endif

    status = 0;
    status = daqDA_DB_getFile(cfg.GetDAConfigFileName(), cfg.GetDAConfigFileName());
    if (status) {
      printf("Failed to get DA config file from DB: %s\n",cfg.GetDAConfigFileName());
      return kFALSE;
    }
 
    ReadDAConfig(cfg);
    
    status = 0;
    status = daqDA_DB_getFile(cfg.GetCurrentFileName(), cfg.GetCurrentFileName());
    if (status) {
      printf("Failed to get current config file from DB: %s\n",cfg.GetCurrentFileName());
      return kFALSE;
    }
    
    ReadFileNames(cfg);

    status = 0;
    status = daqDA_DB_getFile(cfg.GetGlobalFileName(), cfg.GetGlobalFileName());
    if (status) {
      printf("Failed to get current config file from DB: %s\n", cfg.GetGlobalFileName());
      return kFALSE;
    }

    status = 0;
    status = daqDA_DB_getFile(cfg.GetRegionalFileName(), cfg.GetRegionalFileName());
    if (status) {
      printf("Failed to get current config file from DB: %s\n",cfg.GetRegionalFileName());
      return kFALSE;
    }

    status = 0;
    status = daqDA_DB_getFile(cfg.GetLocalMaskFileName(), cfg.GetLocalMaskFileName());
    if (status) {
      printf("Failed to get current config file from DB: %s\n",cfg.GetLocalMaskFileName());
      return kFALSE;
    }

    status = 0;
    status = daqDA_DB_getFile(cfg.GetLocalLutFileName(), cfg.GetLocalLutFileName());
    if (status) {
      printf("Failed to get current config file from DB: %s\n",cfg.GetLocalLutFileName());
      return kFALSE;
    }
 
    return kTRUE;
}

//_____________
void ReadMaskFiles(AliDAConfig& cfg)
{

    const Char_t* localFile    = cfg.GetLocalMaskFileName();
    const Char_t* regionalFile = cfg.GetRegionalFileName();
    const Char_t* globalFile   = cfg.GetGlobalFileName();

    cfg.GetTriggerIO()->ReadConfig(localFile, regionalFile, globalFile, cfg.GetLocalMasks(), cfg.GetRegionalMasks(), cfg.GetGlobalMasks());     
}

//______________________________________________________________
UInt_t GetFetMode(const AliDAConfig & cfg)
{

  return cfg.GetGlobalMasks()->GetFetRegister(3);

}

//______________________________________________________________
void StoreGlobalInput(AliDAConfig& cfg, const UInt_t * const globalInput) 
{
  
  for (Int_t ii = 0; ii < cfg.GetGlobalInputs(); ii++) {
    for (Int_t ib = 0; ib < cfg.GetGlobalInputLength(); ib++) {
      // lsb -> msb
      if (cfg.GetAlgoNoisyInput())
  cfg.AddAccGlobalInputN(ii,ib,((globalInput[ii] >> ib) & 0x1));
      if (cfg.GetAlgoDeadcInput())
  cfg.AddAccGlobalInputD(ii,ib,((globalInput[ii] >> ib) & 0x1));
    }
  }

}

//______________________________________________________________
void UpdateGlobalMasks(AliDAConfig& cfg) 
{
  
#ifdef OFFLINE
  gSystem->Setenv("DAQDALIB_PATH", "$DATE_ROOT/db");
#endif

  Float_t rateN = 0.0, rateD = 0.0;
  UInt_t gmask[4], omask;
  Bool_t noise, deadc, withEvN, withEvD, updated = kFALSE;

  for (Int_t ii = 0; ii < cfg.GetGlobalInputs(); ii++) {
    gmask[ii] = 0;

    for (Int_t ib = 0; ib < cfg.GetGlobalInputLength(); ib++) {
      // lsb -> msb
      noise = kFALSE;
      deadc = kFALSE;
      withEvN = kFALSE;
      withEvD = kFALSE;
      if (cfg.GetEventsN() > cfg.GetMinEvents()) {
  rateN = (Float_t)cfg.GetAccGlobalInputN(ii,ib)/(Float_t)cfg.GetEventsN();
  noise = (rateN > cfg.GetThrN());  
  withEvN = kTRUE;
      }
      if (cfg.GetEventsD() > cfg.GetMinEvents()) {
  rateD = (Float_t)cfg.GetAccGlobalInputD(ii,ib)/(Float_t)cfg.GetEventsD();
  deadc = (rateD < cfg.GetThrD());
  withEvD = kTRUE;
      }
      if (!withEvN && !withEvD) {
  // - copy the bit from the old mask
  gmask[ii] |= ((cfg.GetGlobalMasks()->GetGlobalMask(ii) >> ib) & 0x1) << ib;
  if (cfg.GetPrintLevel()) 
    printf("Mask not changed (just copy the old values)\n");
      }
      if (!withEvN && withEvD) {
  if (!deadc) {
    // - create a new mask, set the bit to 1
    //   not allowed!
    //gmask[ii] |= 0x1 << ib;
    // - copy the bit from the old mask
    gmask[ii] |= ((cfg.GetGlobalMasks()->GetGlobalMask(ii) >> ib) & 0x1) << ib;
  } else {
    // - create a new mask, set the bit to 0
    gmask[ii] |= 0x0 << ib;
    if (cfg.GetPrintLevel()) 
      printf("Found dead  channel %1d:%02d (%4.2f) \n",ii,ib,rateD);
  }
      }
      if (withEvN && !withEvD) {
  if (!noise) {
    // - create a new mask, set the bit to 1
    //   not allowed!
    //gmask[ii] |= 0x1 << ib;
    // - copy the bit from the old mask
    gmask[ii] |= ((cfg.GetGlobalMasks()->GetGlobalMask(ii) >> ib) & 0x1) << ib;
  } else {
    // - create a new mask, set the bit to 0
    gmask[ii] |= 0x0 << ib;
    if (cfg.GetPrintLevel()) 
      printf("Found noisy channel %1d:%02d (%4.2f) \n",ii,ib,rateN);
  }
      }
      if (withEvN && withEvD) {
  if (!noise && !deadc) {
    // - create a new mask, set the bit to 1
    //   not allowed!
    //gmask[ii] |= 0x1 << ib;
    // - copy the bit from the old mask
    gmask[ii] |= ((cfg.GetGlobalMasks()->GetGlobalMask(ii) >> ib) & 0x1) << ib;
  } else {
    // - create a new mask, set the bit to 0
    gmask[ii] |= 0x0 << ib;
    if (cfg.GetPrintLevel()) {
      if (noise)
        printf("Found noisy channel %1d:%02d (%4.2f) \n",ii,ib,rateN);
      if (deadc)
        printf("Found dead  channel %1d:%02d (%4.2f) \n",ii,ib,rateD);
    }
  }
      }
    }
  }

  // check if at least one mask value has been changed from previous version
  for (Int_t ii = 0; ii < cfg.GetGlobalInputs(); ii++) {
    printf("Global mask [%1d] %08x \n",ii,gmask[ii]);
    omask = cfg.GetGlobalMasks()->GetGlobalMask(ii);
    if (gmask[ii] != omask) {
      updated = kTRUE;
      cfg.GetGlobalMasks()->SetGlobalMask(ii,gmask[ii]);
    }
  }

  Int_t status = 0;
  if (updated) {
    
    // update version
    cfg.IncGlobalFileVersion();
    
    // don't change the file version ("-x.dat")
    
    cfg.GetTriggerIO()->WriteGlobalConfig(cfg.GetGlobalFileName(),cfg.GetGlobalMasks());
    
    // write last current file
    WriteLastCurrentFile(cfg,cfg.GetCurrentFileName());

    status = 0;
    status = daqDA_DB_storeFile(cfg.GetGlobalFileName(), cfg.GetGlobalFileName());
    if (status) {
      printf("Failed to export file to DB: %s\n",cfg.GetGlobalFileName());
      return;
    }
    
    status = 0;
    status = daqDA_DB_storeFile(cfg.GetCurrentFileName(), cfg.GetCurrentFileName());
    if (status) {
      printf("Failed to export file to DB: %s\n",cfg.GetCurrentFileName());
      return;
    }

  }
  
}

//______________________________________________________________
void UpdateLocalMask(AliDAConfig& cfg, Int_t localBoardId, Int_t connector, Int_t strip) 
{


  AliMUONVCalibParam* localMask = 
    static_cast<AliMUONVCalibParam*>(cfg.GetLocalMasksDA()->FindObject(localBoardId));
  
  UShort_t mask = static_cast<UShort_t>(localMask->ValueAsInt(connector,0)); 
  
  mask &= ~(0x1 << strip); // set strip mask to zero
  
  localMask->SetValueAsInt(connector, 0, mask);  

}

//______________________________________________________________
void MakePattern(AliDAConfig& cfg, Int_t localBoardId, const TArrayS& xPattern, const TArrayS& yPattern) 
{
  
  AliMUONVCalibParam* pat = 0x0;

  if (cfg.GetAlgoNoisyInput())
    pat = static_cast<AliMUONVCalibParam*>(cfg.GetPatternStoreN()->FindObject(localBoardId));
  if (cfg.GetAlgoDeadcInput())
    pat = static_cast<AliMUONVCalibParam*>(cfg.GetPatternStoreD()->FindObject(localBoardId));

  if (!pat) {
    pat = new AliMUONCalibParamND(2, 64, localBoardId, 0, 0.);
    if (cfg.GetAlgoNoisyInput())
      cfg.GetPatternStoreN()->Add(pat); 
    if (cfg.GetAlgoDeadcInput())
      cfg.GetPatternStoreD()->Add(pat); 
  }

  for (Int_t i = 0; i < 4; ++i) {
    for (Int_t j = 0; j < 16; ++j) {
  
      Int_t xMask = xPattern[i];
      Int_t yMask = yPattern[i];
      
      Int_t index = 16*i + j;
      Double_t patOcc = 0.;
      
      if ( (xMask >> j ) & 0x1 ) {
  patOcc  = pat->ValueAsDouble(index, 0) + 1.;
  pat->SetValueAsDouble(index, 0, patOcc);
      }
      if ( (yMask >> j ) & 0x1 ) {
  patOcc  = pat->ValueAsDouble(index, 1) + 1.;
  pat->SetValueAsDouble(index, 1, patOcc);
      }
    }
  }

}

//______________________________________________________________
void MakePatternStore(AliDAConfig& cfg) 
{
  
#ifdef OFFLINE
  gSystem->Setenv("DAQDALIB_PATH", "$DATE_ROOT/db");
#endif

  AliMUONVCalibParam* pat;
  Int_t localBoardId = 0;
  Int_t nEventsN = 0, nEventsD = 0;  
  UShort_t strip = 0;
  Int_t connector = 0;
  Bool_t updated = kFALSE;
  
  if (cfg.GetEventsN() > cfg.GetMinEvents()) {
    nEventsN = cfg.GetEventsN();
  }
  if (cfg.GetEventsD() > cfg.GetMinEvents()) {
    nEventsD = cfg.GetEventsD();
  }

  // noisy strips
  if (nEventsN > 0) {

    TIter next(cfg.GetPatternStoreN()->CreateIterator());

    while ( ( pat = dynamic_cast<AliMUONVCalibParam*>(next() ) ) ) {
      
      localBoardId  = pat->ID0();
      
      for (Int_t index = 0; index < pat->Size(); index++) {
  
  Double_t patXOcc  = pat->ValueAsDouble(index, 0)/(Double_t)nEventsN;
  Double_t patYOcc  = pat->ValueAsDouble(index, 1)/(Double_t)nEventsN;
  
  pat->SetValueAsDouble(index, 0, patXOcc);
  pat->SetValueAsDouble(index, 1, patYOcc);
  
  // check for x strip
  if (patXOcc > cfg.GetThrLocN()) {
    strip  = index % 16;
    connector = index/16;
    UpdateLocalMask(cfg, localBoardId, connector, strip);
  }
  // check for y strip
  if (patYOcc > cfg.GetThrLocN()) {
    strip  = index % 16;
    connector = index/16 + 4;
    UpdateLocalMask(cfg, localBoardId, connector, strip);
  }
  
      }
    }
    
  }
  
  // dead strips
  if (nEventsD > 0) {

    TIter next(cfg.GetPatternStoreD()->CreateIterator());

    while ( ( pat = dynamic_cast<AliMUONVCalibParam*>(next() ) ) ) {
      
      localBoardId  = pat->ID0();
      
      for (Int_t index = 0; index < pat->Size(); index++) {
  
  Double_t patXOcc  = pat->ValueAsDouble(index, 0)/(Double_t)nEventsD;
  Double_t patYOcc  = pat->ValueAsDouble(index, 1)/(Double_t)nEventsD;
  
  pat->SetValueAsDouble(index, 0, patXOcc);
  pat->SetValueAsDouble(index, 1, patYOcc);
  
  // check for x strip
  if (patXOcc < cfg.GetThrLocD()) {
    strip  = index % 16;
    connector = index/16;
    UpdateLocalMask(cfg, localBoardId, connector, strip);
  }
  // check for y strip
  if (patYOcc < cfg.GetThrLocD()) {
    strip  = index % 16;
    connector = index/16 + 4;
    UpdateLocalMask(cfg, localBoardId, connector, strip);
  }
  
      }
    }
    
  }
  
  // make and AND with the previous version of the mask and
  // check if the mask has changed
  UShort_t maskDA, mask;
  Int_t nMaskBits = AliMpConstants::TotalNofLocalBoards()*8*16;
  Int_t nMaskBitsChanged = 0;
  for (localBoardId = 1; localBoardId <= AliMpConstants::TotalNofLocalBoards(); localBoardId++) {
    AliMUONVCalibParam* localMaskDA = static_cast<AliMUONVCalibParam*>(cfg.GetLocalMasksDA()->FindObject(localBoardId));
    AliMUONVCalibParam* localMask = static_cast<AliMUONVCalibParam*>(cfg.GetLocalMasks()->FindObject(localBoardId));
    for (connector = 0; connector < 8; connector++) {
      maskDA = static_cast<UShort_t>(localMaskDA->ValueAsInt(connector,0)); 
      mask = static_cast<UShort_t>(localMask->ValueAsInt(connector,0));
      maskDA &= mask; 
      localMaskDA->SetValueAsInt(connector, 0, maskDA);  
      if (maskDA != mask) {
  updated = kTRUE;
  // calculated percentage of mask bits changed
  for (Int_t iBit = 0; iBit < 16; iBit++) {
    if (((maskDA >> iBit) & 0x1) != ((mask >> iBit) &0x1)) {
      nMaskBitsChanged++;
    }
  }
      }
    }
  }

  printf("LOCAL mask bits changed = %5d (%7.3f %%) \n",nMaskBitsChanged,100*(Float_t)nMaskBitsChanged/(Float_t)nMaskBits);

  Int_t status = 0;
  if (updated) {

    // update version
    cfg.IncLocalMaskFileVersion();
    
    // don't change the file version ("-x.dat")
    
    cfg.GetTriggerIO()->WriteLocalMasks(cfg.GetLocalMaskFileName(),*cfg.GetLocalMasksDA());

    // write last current file
    WriteLastCurrentFile(cfg,cfg.GetCurrentFileName());

    status = 0;
    status = daqDA_DB_storeFile(cfg.GetLocalMaskFileName(), cfg.GetLocalMaskFileName());
    if (status) {
      printf("Failed to export file to DB: %s\n",cfg.GetLocalMaskFileName());
      return;
    }
    
    status = 0;
    status = daqDA_DB_storeFile(cfg.GetCurrentFileName(), cfg.GetCurrentFileName());
    if (status) {
      printf("Failed to export file to DB: %s\n",cfg.GetCurrentFileName());
      return;
    }

  }

}

//*************************************************************//
int main(Int_t argc, Char_t **argv) 
{
  
    // needed for streamer application
    gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo", "*", "TStreamerInfo", "RIO", "TStreamerInfo()"); 

    /* check that we got some arguments = list of files */
    if (argc<2) {
      printf("Wrong number of arguments\n");
      return -1;
    }

    AliDAConfig cfg;

    Char_t inputFile[256] = "";
    inputFile[0] = 0;
    if (argc > 1)
      if (argv[1] != NULL)
        strncpy(inputFile, argv[1], 256);
      else {
        printf("MUONTRGda : No input File !\n");
        return -1;
      }

    // decoding the events
  
    Int_t status = 0;
    Int_t nDateEvents = 0;

    // containers
    // old decoder
    AliMUONDDLTrigger*       ddlTrigger     = 0x0;
    AliMUONDarcHeader*       darcHeader     = 0x0;
    AliMUONRegHeader*        regHeader   = 0x0;
    AliMUONLocalStruct*      localStruct = 0x0;
    // new (fast) decoder
    const AliMUONRawStreamTriggerHP::AliHeader*      darcHeaderHP  = 0x0;
    const AliMUONRawStreamTriggerHP::AliLocalStruct* localStructHP = 0x0;

    TArrayS xPattern(4);
    TArrayS yPattern(4);
    Int_t localBoardId = 0;

    TStopwatch timers;

    timers.Start(kTRUE); 

    // comment out, since we do not retrieve files from database
    if (!ImportFiles(cfg)) {
      printf("Import from DB failed\n");
      printf("For local test set DAQDA_TEST_DIR to the local directory where the Mtg files are located \n");
      return -1;
    }
    
    ReadMaskFiles(cfg);

#ifdef OFFLINE
    // the run number extracted from the file name
    TString tmp(inputFile);
    Int_t pos1 = tmp.First('d');
    Int_t pos2 = tmp.Last('.');
    Int_t len  = pos2 - (pos1+3);
    tmp = tmp(pos1+3,len);
    gSystem->Setenv("DATE_RUN_NUMBER",tmp.Data());
    gSystem->Exec("echo \"DATE_RUN_NUMBER = \" $DATE_RUN_NUMBER");
#endif

    if(!ExportFiles(cfg)) {
      printf("ExportFiles failed\n");
      return -1;
    }

    // FET is triggered by CTP
    Bool_t modeFET3 = kTRUE;
    if (GetFetMode(cfg) != 3) {
      printf("FET is not in mode 3. Only PHYSICS events will be analysed (noisy channels)\n");
      modeFET3 = kFALSE;
    }
      
    // All 5 global cards are controlled by the Mts proxy
    // sans carte JTAG 0x1F ---> 0x0F (!)
    if (cfg.GetGlobalMasks()->GetGlobalCrateEnable() != 0x1F) {
      printf("The MTS proxy does not control all global cards\n");
      return -1;
    }
    
    // The global cards are ON (active on the global inputs)
    if (!cfg.GetGlobalMasks()->GetMasksOn()) {
      printf("Global masks are not ON\n");
      return -1;
    }
      
    // make sure to catch the "rare" calib events (1 every 50s in physics)
    const Char_t* tableSOD[]  = {"ALL", "yes", "CAL", "all", NULL, NULL};
    monitorDeclareTable(const_cast<char**>(tableSOD));

    status = 0;
    status = monitorSetDataSource(inputFile);
    if (status) {
      cerr << "ERROR : monitorSetDataSource status (hex) = " << hex << status
     << " " << monitorDecodeError(status) << endl;
      return -1;
    }
    status = 0;
    status = monitorDeclareMp("MUON Trigger monitoring");
    if (status) {
      cerr << "ERROR : monitorDeclareMp status (hex) = " << hex << status
     << " " << monitorDecodeError(status) << endl;
      return -1;
    }

    /* define wait event timeout - 1s max */
    monitorSetNowait();
    monitorSetNoWaitNetworkTimeout(1000);

    cout << "MUONTRGda : Reading data from file " << inputFile <<endl;

    UInt_t nCalibEvents;
    UInt_t elapsT;
    UInt_t deltaT;
    UInt_t glSc[6];
    Bool_t overFlow, firstCalibEvent = kTRUE;
    const Int_t nTriChambers = AliMpConstants::NofTriggerChambers();
    const Int_t nLocBoards = AliMpConstants::NofLocalBoards();
    const Int_t nCathodes = 2;
    UInt_t locLptScaler[nLocBoards];
    ULong64_t locStripScaler[nTriChambers][nLocBoards][nCathodes];
    UInt_t locStripOver[nTriChambers][nLocBoards][nCathodes];

    const Int_t bufflen = 
      8*sizeof(UInt_t)+
      nLocBoards*sizeof(UInt_t)+
      nLocBoards*nCathodes*nTriChambers*(sizeof(UInt_t)+sizeof(ULong64_t));
    UChar_t buffer[bufflen];
    //printf("Buffer length = %d bytes \n",bufflen);

    // reset scalers
    deltaT = 0.;
    nCalibEvents = 0;
    for (Int_t bit = 0; bit < 6; bit++) {
      glSc[bit] = 0;
    }
    for (Int_t iLoc = 0; iLoc < nLocBoards; iLoc++) {
      locLptScaler[iLoc] = 0;
      for (Int_t iCath = 0; iCath < nCathodes; iCath++) {
  for (Int_t iCha = 0; iCha < nTriChambers; iCha++) {
    locStripScaler[iCha][iLoc][iCath] = 0;
    locStripOver[iCha][iLoc][iCath] = 0;
  }
      }
    }

    FILE* fsc = fopen(cfg.GetTrigScalFileName(),"wb");
    Bool_t writeScalers = kFALSE;

    UInt_t *globalInput = new UInt_t[4];
    Bool_t doUpdate = kFALSE;
    Int_t runNumber = 0;
    Int_t nEvents = 0;

    // event loop
    while(1) 
    {

      void *event;
      
      if (cfg.GetPrintLevel()) {
  if (nEvents && nEvents % 1000 == 0)   
    cout<<"Cumulated events " << nEvents << endl;
      }
      // check shutdown condition 
      if (daqDA_checkShutdown()) 
    break;

      // Skip Events if needed
      while (cfg.GetSkipEvents()) {
  status = 0;
  status = monitorGetEventDynamic(&event);
  cfg.DecSkipEvents();
      }

      // starts reading
      status = 0;
      status = monitorGetEventDynamic(&event);
      if (status < 0)  {
  cout << "MUONTRGda : EOF found" << endl;
  break;
      }

      nDateEvents++;

      // decoding rawdata headers
      AliRawReader *rawReader = new AliRawReaderDate(event);
 
      Int_t eventType = rawReader->GetType();
      runNumber = rawReader->GetRunNumber();
    
      if (cfg.GetDAFlag() && (nEvents < cfg.GetMaxEvents())) {
  // L1Swc1
  // CALIBRATION_EVENT 
  // SYSTEM_SOFTWARE_TRIGGER_EVENT
  // DETECTOR_SOFTWARE_TRIGGER_EVENT
  cfg.SetAlgoNoisyInput(kFALSE);
  cfg.SetAlgoDeadcInput(kFALSE);
  if (eventType == PHYSICS_EVENT) {
    cfg.SetAlgoNoisyInput(kTRUE);
    doUpdate = kTRUE;
    cfg.IncNoiseEvent();
  } else if (modeFET3 && eventType == CALIBRATION_EVENT) {
    cfg.SetAlgoDeadcInput(kTRUE);
    doUpdate = kTRUE;
    cfg.IncDeadcEvent();
  } else {
    continue;
  }
      }
      /*      
      if (eventType == PHYSICS_EVENT) {
  printf("DBG: PHYSICS_EVENT\n");
      } else if (modeFET3 && eventType == CALIBRATION_EVENT) {
  printf("DBG: CALIBRATION_EVENT\n");
      } else {
  printf("DBG: OTHER (%d)\n",eventType);
      }
      */
      nEvents++;
      if (cfg.GetPrintLevel() == 2) printf("\nEvent # %d\n",nEvents);

      // decoding MUON payload
      AliMUONVRawStreamTrigger   *rawStream   = 0x0;
      if (cfg.UseFastDecoder()) {
  rawStream = new AliMUONRawStreamTriggerHP(rawReader);
      } else {
  rawStream = new AliMUONRawStreamTrigger(rawReader);
      }

      // ... without warnings from the decoder !!!
      if (!cfg.WithWarnings())
  rawStream->DisableWarnings();

      // if there is global clock overflow
      overFlow = kFALSE;
      // loops over DDL 
      while((status = rawStream->NextDDL())) {

  if (cfg.GetPrintLevel() == 2) printf("iDDL %d\n", rawStream->GetDDL());

  if (cfg.UseFastDecoder()) {
    darcHeaderHP = static_cast<AliMUONRawStreamTriggerHP*>(rawStream)->GetHeaders();
    if (cfg.GetPrintLevel() == 2) printf("Global output (fast decoder) %x\n", (Int_t)darcHeaderHP->GetGlobalOutput());
    for (Int_t ig = 0; ig < cfg.GetGlobalInputs(); ig++) {
      globalInput[ig] = darcHeaderHP->GetGlobalInput(ig);
    }
    // global scalers
    if (cfg.SaveScalers() && (eventType == CALIBRATION_EVENT)) {
      if (darcHeaderHP->GetGlobalFlag()) {
        if (firstCalibEvent) {
    //printf("Skip first calib event: %x \n",darcHeaderHP->GetGlobalClock());
    overFlow = kTRUE;
    firstCalibEvent = kFALSE;
        } else {
    elapsT = darcHeaderHP->GetGlobalClock()/40e6; // [s]
    if (elapsT > 50) {
      //printf("Possible overflow: %x \n",darcHeaderHP->GetGlobalClock());
      overFlow = kTRUE;
    } else {
      deltaT += elapsT;
      nCalibEvents++;
      const UInt_t* globScaler = darcHeaderHP->GetGlobalScaler();
      for (Int_t bit = 0; bit < 6; bit++) {
        glSc[bit] += (double)(*(globScaler+bit));
      }
    } // end check overflow
        } // end first calib event
      } // end global flag
    } // end scalers calib event
    // loop over regional structure
    Int_t nReg = (Int_t)static_cast<AliMUONRawStreamTriggerHP*>(rawStream)->GetRegionalHeaderCount();
    for(Int_t iReg = 0; iReg < nReg; iReg++) {
      // loop over local structures
      Int_t nLoc = (Int_t)static_cast<AliMUONRawStreamTriggerHP*>(rawStream)->GetLocalStructCount(iReg);
      for(Int_t iLoc = 0; iLoc < nLoc; iLoc++) {
        localStructHP = static_cast<AliMUONRawStreamTriggerHP*>(rawStream)->GetLocalStruct(iReg, iLoc);
        localBoardId = cfg.GetTriggerIO()->LocalBoardId(rawStream->GetDDL(),iReg,localStructHP->GetId());
        if (localBoardId > 0) {
    localStructHP->GetXPattern(xPattern);
    localStructHP->GetYPattern(yPattern);
    if (cfg.GetDAFlag() && (nEvents < cfg.GetMaxEvents())) {
      MakePattern(cfg,localBoardId,xPattern,yPattern);
    }
    // local scalers
    if (cfg.SaveScalers() && (eventType == CALIBRATION_EVENT)) {
      if (!overFlow) {
        // skip dead and copy cards
        if(localBoardId <= nLocBoards) {
          locLptScaler[localBoardId-1] += 
      localStructHP->GetScalars()->fLPtRTrig +
      localStructHP->GetScalars()->fLPtLTrig +
      localStructHP->GetScalars()->fLPtSTrig;
          Int_t cathode = localStructHP->GetComptXY();
          for (Int_t ibitxy = 0; ibitxy < 16; ++ibitxy) {   
      UInt_t scalerVal[4] = {
        localStructHP->GetXY1(ibitxy),
        localStructHP->GetXY2(ibitxy),
        localStructHP->GetXY3(ibitxy),
        localStructHP->GetXY4(ibitxy)
      };

      for(Int_t ich = 0; ich < nTriChambers; ich++) {
        // sum over all strips
        if (scalerVal[ich] < 0xffff/2) {
          locStripScaler[ich][localBoardId-1][cathode] += 2*scalerVal[ich];
        } else {
          locStripOver[ich][localBoardId-1][cathode]++;
        }
      } // end chamber loop
      
          } // end strip loop
        } // end skip copy cards
      } // env check overflow
    } // end scalers calib event
        } // end valid local
      } // end loc loop
    } // end reg loop
  } else {
    ddlTrigger = rawStream->GetDDLTrigger();
    darcHeader = ddlTrigger->GetDarcHeader();
    if (cfg.GetPrintLevel() == 2) printf("Global output %x\n", (Int_t)darcHeader->GetGlobalOutput());
    globalInput = darcHeader->GetGlobalInput();
    // loop over regional structure
    Int_t nReg = darcHeader->GetRegHeaderEntries();
    for(Int_t iReg = 0; iReg < nReg; iReg++) {
      regHeader = darcHeader->GetRegHeaderEntry(iReg);
      // loop over local structures
      Int_t nLoc = regHeader->GetLocalEntries();
      for(Int_t iLoc = 0; iLoc < nLoc; iLoc++) {  
        localStruct = regHeader->GetLocalEntry(iLoc);
        localBoardId = cfg.GetTriggerIO()->LocalBoardId(rawStream->GetDDL(),iReg,localStruct->GetId());
        if (localBoardId > 0) {
    localStruct->GetXPattern(xPattern);
    localStruct->GetYPattern(yPattern);
    if (cfg.GetDAFlag() && (nEvents < cfg.GetMaxEvents())) {
      MakePattern(cfg,localBoardId,xPattern,yPattern);
    }
        }
      }
    }
  }
  if (cfg.GetDAFlag() && (nEvents < cfg.GetMaxEvents())) {
    if (rawStream->GetDDL() == 0) {
      StoreGlobalInput(cfg,globalInput);
    }
  }
  
      } // NextDDL

      if (cfg.SaveScalers()) {
  if (!overFlow && (deltaT > cfg.GetScalerRecTime())) {
    //printf("Write scalers after %d events\n",nEvents);
    writeScalers = kTRUE;
    Int_t ibw = 0;
    // global
    buffer[ibw++] = (nCalibEvents >> 24) & 0xff;
    buffer[ibw++] = (nCalibEvents >> 16) & 0xff;
    buffer[ibw++] = (nCalibEvents >>  8) & 0xff;
    buffer[ibw++] = (nCalibEvents >>  0) & 0xff;
    buffer[ibw++] = (deltaT >> 24) & 0xff;
    buffer[ibw++] = (deltaT >> 16) & 0xff;
    buffer[ibw++] = (deltaT >>  8) & 0xff;
    buffer[ibw++] = (deltaT >>  0) & 0xff;
    //printf("nev %u time %u \n",nCalibEvents,deltaT);
    for (Int_t bit = 0; bit < 6; bit++) {
      buffer[ibw++] = (glSc[bit] >> 24) & 0xff;
      buffer[ibw++] = (glSc[bit] >> 16) & 0xff;
      buffer[ibw++] = (glSc[bit] >>  8) & 0xff;
      buffer[ibw++] = (glSc[bit] >>  0) & 0xff;
      //printf("glSc %u \n",glSc[bit]);
    }
    // local
    for (Int_t iLoc = 0; iLoc < nLocBoards; iLoc++) {
      buffer[ibw++] = (locLptScaler[iLoc] >> 24) & 0xff;
      buffer[ibw++] = (locLptScaler[iLoc] >> 16) & 0xff;
      buffer[ibw++] = (locLptScaler[iLoc] >>  8) & 0xff;
      buffer[ibw++] = (locLptScaler[iLoc] >>  0) & 0xff;
      for (Int_t iCath = 0; iCath < nCathodes; iCath++) {
        for (Int_t iCha = 0; iCha < nTriChambers; iCha++) {
    //printf("Ch%1dCath%1dLoc%03d  %u  %u \n",iCha,iCath,iLoc+1,locStripScaler[iCha][iLoc][iCath],locStripOver[iCha][iLoc][iCath]);
    // strip scalers
    buffer[ibw++] = (locStripScaler[iCha][iLoc][iCath] >> 56) & 0xff;
    buffer[ibw++] = (locStripScaler[iCha][iLoc][iCath] >> 48) & 0xff;
    buffer[ibw++] = (locStripScaler[iCha][iLoc][iCath] >> 40) & 0xff;
    buffer[ibw++] = (locStripScaler[iCha][iLoc][iCath] >> 32) & 0xff;
    buffer[ibw++] = (locStripScaler[iCha][iLoc][iCath] >> 24) & 0xff;
    buffer[ibw++] = (locStripScaler[iCha][iLoc][iCath] >> 16) & 0xff;
    buffer[ibw++] = (locStripScaler[iCha][iLoc][iCath] >>  8) & 0xff;
    buffer[ibw++] = (locStripScaler[iCha][iLoc][iCath] >>  0) & 0xff;
    // number of strips in overflow
    buffer[ibw++] = (locStripOver[iCha][iLoc][iCath] >> 24) & 0xff;
    buffer[ibw++] = (locStripOver[iCha][iLoc][iCath] >> 16) & 0xff;
    buffer[ibw++] = (locStripOver[iCha][iLoc][iCath] >>  8) & 0xff;
    buffer[ibw++] = (locStripOver[iCha][iLoc][iCath] >>  0) & 0xff;
        }
      }
    }
    //printf("Write to buffer %d bytes.\n",ibw);
    fwrite(&buffer,ibw,1,fsc);
    // reset
    deltaT = 0.;
    nCalibEvents = 0;
    for (Int_t bit = 0; bit < 6; bit++) {
      glSc[bit] = 0;
    }
    for (Int_t iLoc = 0; iLoc < nLocBoards; iLoc++) {
      locLptScaler[iLoc] = 0;
      for (Int_t iCath = 0; iCath < nCathodes; iCath++) {
        for (Int_t iCha = 0; iCha < nTriChambers; iCha++) {
    locStripScaler[iCha][iLoc][iCath] = 0;
    locStripOver[iCha][iLoc][iCath] = 0;
        }
      }
    }
  }
      } // end write scalers

      delete event;

      delete rawReader;
      delete rawStream;

    } // while (1)

    if (cfg.GetDAFlag() && (nEvents < cfg.GetMaxEvents())) {
      // update configuration files ifrequested event types were found
      if (doUpdate) {
  if (cfg.GetDAMode() > 0) UpdateGlobalMasks(cfg);
  if (cfg.GetDAMode() > 1) MakePatternStore(cfg);
      }
    }

    fclose(fsc);

    if (cfg.SaveScalers()) {
      if (writeScalers) {
  //printf("Store scalers to FES, DATE_RUN_NUMBER %s \n",gSystem->Getenv("DATE_RUN_NUMBER"));
  if(!ExportTRIGSCAL(cfg)) {
    printf("ExportTRIGSCAL failed\n");
  }
      } else {
  printf("Run too short ( < %d sec ), no scalers calculated! \n",cfg.GetScalerRecTime());
      }
    }
    
    // export Exported file to FES
    status = 0;
    status = daqDA_FES_storeFile(fileExp.Data(), "EXPORTED");
    if (status) {
      printf("Failed to export file: %s\n", fileExp.Data());
      return kFALSE;
    }
    if(cfg.GetPrintLevel()) printf("Export file: %s\n",fileExp.Data());

    timers.Stop();

    cout << "MUONTRGda: DA enable: " << cfg.GetDAFlag() << endl;
    cout << "MUONTRGda: Run number: " << runNumber << endl;
    cout << "MUONTRGda: Nb of DATE events: " << nDateEvents << endl;
    cout << "MUONTRGda: Nb of events used: " << nEvents << endl;
    cout << "MUONTRGda: Nb of events used (noise): " << cfg.GetEventsN() << endl;
    cout << "MUONTRGda: Nb of events used (deadc): " << cfg.GetEventsD() << endl;
    cout << "MUONTRGda: Minumum nr of events for rate calculation: " << cfg.GetMinEvents() << endl;
    cout << "MUONTRGda: Maximum nr of analyzed events: " << cfg.GetMaxEvents() << endl;
    cout << "MUONTRGda: Skip events from start: " << cfg.GetSkipEvents() << endl;
    cout << "MUONTRGda: Threshold for global noisy inputs: " << 100*cfg.GetThrN() << "%" << endl;
    cout << "MUONTRGda: Threshold for global dead inputs: " << 100*cfg.GetThrD() << "%" << endl;
    cout << "MUONTRGda: Threshold for local noisy inputs: " << 100*cfg.GetThrLocN() << "%" << endl;
    cout << "MUONTRGda: Threshold for local dead inputs: " << 100*cfg.GetThrLocD() << "%" << endl;
    cout << "MUONTRGda: Print level: " << cfg.GetPrintLevel() << endl;
    cout << "MUONTRGda: Show decoder warnings: " << cfg.WithWarnings() << endl;
    cout << "MUONTRGda: Use the fast decoder: " << cfg.UseFastDecoder() << endl;
    cout << "MUONTRGda: DA mode (1=GLOBAL, 2=GLOBAL+LOCAL): " << cfg.GetDAMode() << endl;
    cout << "MUONTRGda: Save scalers: " << cfg.SaveScalers() << endl;
    if (cfg.SaveScalers()) {
      cout << "MUONTRGda: Time to record scalers: " << cfg.GetScalerRecTime() << " seconds" << endl;
    }

    printf("MUONTRGda: Execution time : R:%7.2fs C:%7.2fs\n", timers.RealTime(), timers.CpuTime());

    return status;

}