beamtime/tof-tdctest/go4/GET4V10/TGet4v1Proc.cxx (r4864/r4862)

Go to the documentation of this file.

#include "TGet4v1Proc.h"

#include "TGo4Version.h"
#if __GO4BUILDVERSION__ > 40502
#include "go4iostream.h"
#else
#include "Riostream.h"
#endif

#include "TH1.h"
#include "TH2.h"
#include "TTimeStamp.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TLatex.h"

#include "TGet4v1Param.h"
#include "TGo4MbsEvent.h"
#include "TGo4WinCond.h"
#include "TGo4Log.h"
#include "TGo4Version.h"

#include "roc/Message.h"
#include "roc/Board.h"

#include <algorithm>

// enable this define for "online" mode with only one aux trigger per input buffer analyzed
// if disabled, may process up to TGet4v1Param::maxBufferTriggers per buffer (only offline mode with no lost samples!)
#define ROC_SINGLETRIGGERMODE 1

TGet4v1Proc::TGet4v1Proc() :
   TCBMBeamtimeProc(),
   fOutputEvent(0),
   fIsTimeSorted(kFALSE),
   fHasNewGlobalTrigger(kFALSE)
{
}

//***********************************************************
TGet4v1Proc::~TGet4v1Proc()
{
   TGo4Log::Info("TGet4v1Proc: Test ");
   ROC.clear();
   TGo4Log::Info("TGet4v1Proc: Delete instance ");
}

//***********************************************************
// this one is used in standard factory
TGet4v1Proc::TGet4v1Proc(const char* name) :
   TCBMBeamtimeProc(name),
   fOutputEvent(0),
   fIsTimeSorted(kFALSE),
   fHasNewGlobalTrigger(kFALSE)
{
   TGo4Log::Info("TGet4v1Proc: Create instance %s", name);

   // SL TODO: after next go4 release change uncomment usage of setup macro
   fParam = (TGet4v1Param *) MakeParameter("Get4v1Par", "TGet4v1Param" /*, "set_RocPar.C" */);

   fLastRateTm = TTimeStamp().AsDouble();
   fTotaldatasize = 0;
   fRate = 0.;

   // here we optionally override parameter values with setup macro, if existing:
   TString setupmacro = "set_Get4v1Par.C";
   if (!gSystem->AccessPathName(setupmacro.Data())) {
      TGo4Log::Info("Executing ROC parameter setup script %s", setupmacro.Data());
      gROOT->ProcessLine(Form(".x %s", setupmacro.Data()));
      // need to copy parameter setup to static event array,
      // when restored from Autosave file, executed in UpdateFrom method
      fParam->SetConfigRocs();
   } else {
      TGo4Log::Info("NO ROC parameter setup script %s. Use previous values!", setupmacro.Data());
   }

   fParam->PrintGet4Options();
   if (fParam->numRocs > MAX_ROC) fParam->numRocs = MAX_ROC;
   if (fParam->uNbGet4 > MAX_GET4) fParam->uNbGet4 = MAX_GET4;

   for (unsigned n=0; n < fParam->numRocs;n++) {
      ROC.push_back(TGet4v1Rec());
      ROC[n].fRocId = n;
   }
   fEvntSize = MakeTH1('I', "ROCs/EvntSize", "Number of messages in event",
         250, 1., 2000.);

   fEvtPerProc= MakeTH1('I', "SubEventsPerProc", "Number of subevents per Proc index",
         64, 0., 64);

   fMsgsPerRoc = MakeTH1('I', "ROCs/MsgsPerRoc", "Number of messages per ROC",
         fParam->numRocs, 0., fParam->numRocs);

   fTriggerPerRoc = MakeTH1('I', "ROCs/TriggersPerRoc", "Number of Trigger messages per ROC",
         fParam->numRocs, 0., fParam->numRocs);

   fDeltaTriggerTime = MakeTH1('I', "ROCs/TriggerDeltaTime", "Corrected hits time difference of all ROCs",
         5000, -5000., 5000., "Delta t");

   for( UInt_t  uRoc =0; uRoc<fParam->numRocs; uRoc++ )
   {
      // do not build histograms for non-used ROC
      if (!fParam->IsActiveRoc(uRoc)) continue;

      char folder[30];
      sprintf(folder,"ROC%u/",uRoc);

      ROC[uRoc].fMsgTypes = MakeTH1('I', Form("%sMsgTypes%u", folder, uRoc),
            Form("ROC%u Distribution of messages types", uRoc),
            8, 0., 8.);

      if (IsObjMade()) {
         ROC[uRoc].fMsgTypes->GetXaxis()->SetBinLabel(1 + roc::MSG_NOP, "NOP");
         ROC[uRoc].fMsgTypes->GetXaxis()->SetBinLabel(1 + roc::MSG_HIT, "HIT");
         ROC[uRoc].fMsgTypes->GetXaxis()->SetBinLabel(1 + roc::MSG_EPOCH, "EPOCH");
         ROC[uRoc].fMsgTypes->GetXaxis()->SetBinLabel(1 + roc::MSG_SYNC, "SYNC");
         ROC[uRoc].fMsgTypes->GetXaxis()->SetBinLabel(1 + roc::MSG_AUX, "AUX");
         ROC[uRoc].fMsgTypes->GetXaxis()->SetBinLabel(1 + roc::MSG_EPOCH2, "EPOCH2");
         ROC[uRoc].fMsgTypes->GetXaxis()->SetBinLabel(1 + roc::MSG_GET4, "GET4");
         ROC[uRoc].fMsgTypes->GetXaxis()->SetBinLabel(1 + roc::MSG_SYS, "SYS");
      }

      ROC[uRoc].fSysTypes = MakeTH1('I', Form("%sSysTypes%u", folder, uRoc),
            Form("ROC%u Distribution of system messages", uRoc),
            roc::SYSMSG_GET4_EVENT+1, 0., roc::SYSMSG_GET4_EVENT+1);

      if (IsObjMade()) {
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_DAQ_START,  "DAQ_START");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_DAQ_FINISH, "DAQ_FINISH");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_NX_PARITY,  "NX_PARITY");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_SYNC_PARITY,"SYNC_PARITY");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_DAQ_RESUME, "DAQ_RESUME");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_FIFO_RESET, "FIFO_RESET");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_USER,       "USER_MSG");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_PCTIME,     "PCTIME");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_ADC,        "ADC");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_PACKETLOST, "PACKETLOST");
         ROC[uRoc].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_GET4_EVENT, "GET4_EVENT");
      }

      ROC[uRoc].fSysUserTypes = MakeTH1('I', Form("%sSysUserTypes%u", folder, uRoc),
            Form("ROC%u Distribution of user messages", uRoc),
            8, 7., 15.);
      if (IsObjMade()) {
         ROC[uRoc].fSysUserTypes->GetXaxis()->SetBinLabel(roc::SYSMSG_USER_CALIBR_ON - 6, "CALIBR_ON");
         ROC[uRoc].fSysUserTypes->GetXaxis()->SetBinLabel(roc::SYSMSG_USER_CALIBR_OFF - 6, "CALIBR_OFF");
         ROC[uRoc].fSysUserTypes->GetXaxis()->SetBinLabel(roc::SYSMSG_USER_RECONFIGURE - 6, "RECONFIGURE");
      }

      ROC[uRoc].fAUXch = MakeTH1('I', Form("%sRoc%u_aux_chs", folder, uRoc),
            "Number events per aux channel",
            8, 0., 8.);

      ROC[uRoc].fTrigger_All = MakeTH1('I', Form("%sRoc%u_Trigger", folder, uRoc),
            Form("Time difference between all hits and last trigger signal on ROC%u", uRoc),
            5000, -1000., 4000.);
      ROC[uRoc].fTrigger_All_100 = MakeTH1('I', Form("%sRoc%u_Trigger_100", folder, uRoc),
            Form("Time difference between all hits and last trigger signal on ROC%u", uRoc),
            50005, -100000., 1e6);
      ROC[uRoc].fTrigger_All_us = MakeTH1('I', Form("%sRoc%u_Trigger_us", folder, uRoc),
            Form("Time difference between all hits and last trigger signal on ROC%u", uRoc),
            1000, -1000., 999.*1e3);
      ROC[uRoc].fTrigger_All_ms = MakeTH1('I', Form("%sRoc%u_Trigger_ms", folder, uRoc),
            Form("Time difference between all hits and last trigger signal on ROC%u", uRoc),
            1000, -1e6, 999*1e6);
      ROC[uRoc].fTrigger_All_s = MakeTH1('I', Form("%sRoc%u_Trigger_s", folder, uRoc),
            Form("Time difference between all hits and last trigger signal on ROC%u", uRoc),
            1000, -1e9, 999*1e9);

      ROC[uRoc].fTrigger_AUX = MakeTH1('I', Form("%sRoc%u_Trigger_AUX", folder, uRoc),
            Form("Time difference between all AUXs and last trigger signal on ROC%u", uRoc),
            5000, -5000., 5000.);

      ROC[uRoc].fEvntMultipl = MakeTH1('I', Form("%sRoc%u_Multiplicity", folder, uRoc),
            Form("Event multiplicity for ROC%u in time window", uRoc),
            16, 0., 16.);

      ROC[uRoc].fALLt = MakeTH1('I', Form("%sRoc%u_ALL_t", folder,uRoc), Form("Time distribution of ALL signals on ROC%u", uRoc),
            36000, 0., 3600.,"s");

      ROC[uRoc].fDATAt = MakeTH1('I', Form("%sRoc%u_DATA_t", folder,uRoc), Form("Time distribution of DATA hits on ROC%u", uRoc),
            36000, 0., 3600.,"s");

      ROC[uRoc].fERRORt = MakeTH1('I', Form("%sRoc%u_ERROR_t", folder,uRoc), Form("Time distribution of ERROR signals on ROC%u", uRoc),
            36000, 0., 3600.,"s");

      ROC[uRoc].fSLOWCt = MakeTH1('I', Form("%sRoc%u_SLOWC_t", folder,uRoc), Form("Time distribution of SLOW CONTROL signals on ROC%u", uRoc),
            36000, 0., 3600.,"s");

      ROC[uRoc].fSelfTriggT = MakeTH1('I', Form("%sRoc%u_SelfTrigg_t", folder,uRoc), Form("Time distribution of self triggers on ROC%u", uRoc),
            36000, 0., 3600.,"s");

      ROC[uRoc].fEPOCHt = MakeTH1('I', Form("%sRoc%u_EPOCH_t", folder,uRoc), Form("Time distribution of Epochs on ROC%u", uRoc),
            36000, 0., 3600.,"s");

      ROC[uRoc].fAllSelectedT = MakeTH1('I', Form("%sRoc%u_AllSel_t", folder,uRoc), Form("Time distribution of all selected hits on ROC%u", uRoc),
            36000, 0., 3600.,"s");

      for (unsigned nsync=0; nsync<MAX_SYNC; nsync++)
         ROC[uRoc].fSYNCt[nsync] = MakeTH1('I', Form("%sRoc%u_Sync%u_t", folder, uRoc, nsync),
               Form("Time distribution of SYNC%u signal on ROC%u", nsync, uRoc),
               36000, 0., 3600.,"s");

      for (unsigned naux=0; naux<MAX_AUX; naux++)
         ROC[uRoc].fAUXt[naux] = MakeTH1('I', Form("%sRoc%u_Aux%u_t", folder, uRoc, naux),
               Form("Time distribution of AUX%u signal on ROC%u", naux, uRoc),
               36000, 0., 3600.,"s");

      // Long duration time distribution (1 min. bin, 10 days length)
      if( kTRUE == fParam->bLongTimeHistos )
      {
         ROC[uRoc].fAllLongT = MakeTH1('I', Form("%sLong/Roc%u_All_lt", folder,uRoc), Form("Time distribution of ALL signals on ROC%u", uRoc),
               14400, 0., 240.,"t [h]");

         ROC[uRoc].fDataLongT = MakeTH1('I', Form("%sLong/Roc%u_Data_lt", folder,uRoc), Form("Time distribution of DATA hits on ROC%u", uRoc),
               14400, 0., 240.,"t [h]");

         ROC[uRoc].fErrorLongT = MakeTH1('I', Form("%sLong/Roc%u_Error_lt", folder,uRoc), Form("Time distribution of ERROR signals on ROC%u", uRoc),
               14400, 0., 240.,"t [h]");

         ROC[uRoc].fSlowCLongT = MakeTH1('I', Form("%sLong/Roc%u_Slowc_lt", folder,uRoc), Form("Time distribution of SLOW CONTROL signals on ROC%u", uRoc),
               14400, 0., 240.,"t [h]");

         ROC[uRoc].fSelfTriggLongT = MakeTH1('I', Form("%sLong/Roc%u_SelfTrigg_lt", folder,uRoc), Form("Time distribution of self triggers on ROC%u", uRoc),
               14400, 0., 240.,"t [h]");

         ROC[uRoc].fEpochLongT = MakeTH1('I', Form("%sLong/Roc%u_Epoch_lt", folder,uRoc), Form("Time distribution of Epochs on ROC%u", uRoc),
               14400, 0., 240.,"t [h]");

         ROC[uRoc].fAllEpoch2LongT = MakeTH1('I', Form("%sLong/Roc%u_AllEp2_lt", folder,uRoc), Form("Time distribution of all epoch2 on ROC%u", uRoc),
               14400, 0., 240.,"t [h]");

         ROC[uRoc].fAllSelLongT = MakeTH1('I', Form("%sLong/Roc%u_AllSel_lt", folder,uRoc), Form("Time distribution of all selected hits on ROC%u", uRoc),
               14400, 0., 240.,"t [h]");

         for (unsigned nsync=0; nsync<MAX_SYNC; nsync++)
            ROC[uRoc].fSyncLongT[nsync] = MakeTH1('I', Form("%sLong/Roc%u_Sync%u_lt", folder, uRoc, nsync),
                  Form("Time distribution of SYNC%u signal on ROC%u", nsync, uRoc),
                  14400, 0., 240.,"t [h]");
      } // if( kTRUE == fParam->bLongTimeHistos )

      uNbEvents[uRoc]        = 0;
      uFirstEventIndex[uRoc] = 0;
      uPrevEventIndex[uRoc]  = 0;

      // Real events counters
      uEventInsideMbsEvtCount[uRoc] = 0;
      uRealEventsCount[uRoc] = 0;
      uNotEmptyEventInsideMbsEvtCount[uRoc] = 0;
      uNotEmptyRealEventsCount[uRoc] = 0;

      ROC[uRoc].fTriggerWind = MakeWinCond(Form("Roc%u_EventWindow",uRoc),
            485., 885., ROC[uRoc].fTrigger_All->GetName());

      ROC[uRoc].fAUXWind = MakeWinCond(Form("Roc%u_AUXWindow",uRoc),
            -100., 100., ROC[uRoc].fTrigger_AUX->GetName());

      for( Int_t iGet4 = 0; iGet4 < MAX_GET4_PER_ROC; iGet4++)
      {
         char folderGet4[30];
         sprintf(folderGet4,"%sGet4_%u/",folder, iGet4);
         UInt_t uRemappedGet4Index = fParam->RemapGet4Chip(uRoc, iGet4);
         if( kTRUE == fParam->IsValidGet4Chip(uRemappedGet4Index) &&
             kTRUE == fParam->IsActiveGet4Chip(uRemappedGet4Index) )
         {
            ROC[uRoc].fEPOCH2t[iGet4] = MakeTH1('I', Form("%sRoc%u_EPOCH2_t_%d", folder,uRoc, iGet4),
                  Form("Time distribution of GET4 Epochs on ROC%u Get4 %d", uRoc, iGet4),
                  36000, 0., 3600.,"s");
            for( Int_t iGet4Chan = 0; iGet4Chan < NB_CHAN_GET4; iGet4Chan++)
            {
               ROC[uRoc].fSelectedT[iGet4][iGet4Chan] = MakeTH1('I', Form("%sRoc%u_Selected_t_%d_Ch%d", folderGet4,uRoc, iGet4, iGet4Chan),
                     Form("Time distribution of selected hits on ROC%u Get4 %d Channel %d", uRoc, iGet4, iGet4Chan),
                     36000, 0., 3600.,"s");
            
               ROC[uRoc].fTrigger_Get4Channel[iGet4][iGet4Chan] =
                     MakeTH1('I', Form("%sRoc%u_Get%d_Ch%d_Trigger",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("Time difference between all hits on GET4 %d Channel %d and last trigger signal on ROC%u; [ns]",
                                    iGet4, iGet4Chan, uRoc),
                              10000, -5000., 5000.);
               ROC[uRoc].fTriggerMs_Get4Channel[iGet4][iGet4Chan] =
                     MakeTH1('I', Form("%sRoc%u_Get%d_Ch%d_TriggerMs",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("Time difference between all hits on GET4 %d Channel %d and last trigger signal on ROC%u; [ns]",
                                    iGet4, iGet4Chan, uRoc),
                              20000, -100*1e3, 100*1e3);
               ROC[uRoc].fTriggerS_Get4Channel[iGet4][iGet4Chan] =
                     MakeTH1('I', Form("%sRoc%u_Get%d_Ch%d_TriggerS",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("Time difference between all hits on GET4 %d Channel %d and last trigger signal on ROC%u; [ns]",
                                    iGet4, iGet4Chan, uRoc),
                              20000, -100*1e9, 1900*1e9);

               /*
                * Debug Histograms for GET4 v1.x
                */
               if( 1 == fParam->bTotHistoEnable )
                  ROC[uRoc].fTot[iGet4][iGet4Chan] =
                        MakeTH1('I', Form("%sTot/Roc%u_Get%d_Ch%d_Tot",
                              folderGet4, uRoc, iGet4, iGet4Chan),
                        Form("Tot for channel %d in chip %d on ROC %d", iGet4Chan, iGet4, uRoc),
                        1200, -25, 59975, "Tot [ps]", "Counts [1]" );
               if( 1 == fParam->bDebugHistoEnable )
               {
                  ROC[uRoc].fLeadingFTS[iGet4][iGet4Chan] =
                        MakeTH1('I',
                              Form("%sFTS_L/Roc%u_Get%d_Ch%d_FTS_Leading",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("FTS of Leading edge of channel %d in chip %d on ROC %d",
                                    iGet4Chan, iGet4, uRoc),
                              NB_BIN_GET4_FTS, 0., NB_BIN_GET4_FTS);
                  ROC[uRoc].fTrailingFTS[iGet4][iGet4Chan] =
                        MakeTH1('I',
                              Form("%sFTS_T/Roc%u_Get%d_Ch%d_FTS_Trailing",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("FTS of Trailing edge of channel %d in chip %d on ROC %d",
                                    iGet4Chan, iGet4, uRoc),
                              NB_BIN_GET4_FTS, 0., NB_BIN_GET4_FTS);
                  ROC[uRoc].fLeadingDnl[iGet4][iGet4Chan] =
                        MakeTH1('D',
                              Form("%sDnl_L/Roc%u_Get%d_Ch%d_Dnl_Leading",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("DNL of Leading edge of channel %d in chip %d on ROC %d",
                                    iGet4Chan, iGet4, uRoc),
                              NB_BIN_GET4_FTS, -0.5, NB_BIN_GET4_FTS-0.5);
                  ROC[uRoc].fLeadingDnlSum[iGet4][iGet4Chan] =
                        MakeTH1('D',
                              Form("%sDnlInt_L/Roc%u_Get%d_Ch%d_DnlSum_Leading",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("DNL Integral of Leading edge of channel %d in chip %d on ROC %d",
                                    iGet4Chan, iGet4, uRoc),
                              NB_BIN_GET4_FTS, -0.5, NB_BIN_GET4_FTS-0.5);
                  ROC[uRoc].fTrailingDnl[iGet4][iGet4Chan] =
                        MakeTH1('D',
                              Form("%sDnl_T/Roc%u_Get%d_Ch%d_Dnl_Trailing",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("DNL of Trailing edge of channel %d in chip %d on ROC %d",
                                    iGet4Chan, iGet4, uRoc),
                              NB_BIN_GET4_FTS, -0.5, NB_BIN_GET4_FTS-0.5);
                  ROC[uRoc].fTrailingDnlSum[iGet4][iGet4Chan] =
                        MakeTH1('D',
                              Form("%sDnlInt_T/Roc%u_Get%d_Ch%d_DnlSum_Trailing",
                                    folderGet4, uRoc, iGet4, iGet4Chan),
                              Form("DNL Integral of Trailing edge of channel %d in chip %d on ROC %d",
                                    iGet4Chan, iGet4, uRoc),
                              NB_BIN_GET4_FTS, -0.5, NB_BIN_GET4_FTS-0.5);
               } // if( 1 == fParam->bDebugHistoEnable )

               // Event statistics
               if( kTRUE == fParam->bChannelRateHistoEnable )
                  ROC[uRoc].fChannelRateEvolution[iGet4][iGet4Chan] = MakeTH1('I',
                        Form("%sRateCh/Roc%u_Get%d_Ch%d_RateEvolution",
                              folderGet4, uRoc, iGet4, iGet4Chan),
                        Form("Time distribution of hits of channel %d in chip %d on ROC %d",
                              iGet4Chan, iGet4, uRoc),
                        36000, 0., 7200.,"Time [s]", "(Nb hits)/(bin size in s) []");

            } // for( Int_t iGet4Chan = 0; iGet4Chan < NB_CHAN_GET4; iGet4Chan++)

            // Event statistics
            if( kTRUE == fParam->bChipRateHistoEnable )
            {
               ROC[uRoc].fChipRateEvolution[iGet4] = MakeTH1('I',
                     Form("%sRoc%u_Get%d_RateEvolution",
                           folderGet4, uRoc, iGet4 ),
                     Form("Time distribution of hits for all channels of chip %d on ROC %d",
                           iGet4, uRoc),
                     36000, 0., 7200.,"Time [s]", "(Nb hits)/(bin size in s) []");
               ROC[uRoc].fdRateEvolutionBinSize = ROC[uRoc].fChipRateEvolution[iGet4]->GetBinWidth( 1 );
            } // if( kTRUE == fParam->bChipRateHistoEnable )
            ROC[uRoc].fuNbHitsChipEpoch[iGet4] = 0;

            // Epochs
            ROC[uRoc].fEpochShiftsDuration[iGet4] = MakeTH2('I',
                  Form("%sRoc%u_Get%d_EpochShiftsDuration",
                        folderGet4, uRoc, iGet4 ),
                  Form("Time distribution of hits for all channels of chip %d on ROC %d",
                        iGet4, uRoc),
                  52, -26., 26.,
                  5000, 0., 5000.,
                  "Shift [GET4 epochs]", "Duration [GET4 epochs]");
         } // if remapped chip is valid and active
      } // for( Int_t iGet4 = 0; iGet4 < MAX_GET4_PER_ROC; iGet4++)
      ROC[uRoc].fDistribEpochs = MakeTH1( 'I', Form("%sRoc%u_DistribEpochs", folder, uRoc),
            "Distribution of epoch counter value for 250MHz epoch messages",
            MAIN_EPOCH_CYCLE_SIZE/100000, 0, MAIN_EPOCH_CYCLE_SIZE,
            "Value of Local Epoch Cnt []", "Counts []" );
      ROC[uRoc].fDistribEpochs2 = MakeTH2( 'I', Form("%sRoc%u_DistribEpochs2", folder, uRoc),
            "Distribution of epoch counter value for Roc epoch messages",
            MAX_GET4_PER_ROC, -0.5, MAX_GET4_PER_ROC -0.5,
            GET4_EPOCH_CYCLE_SIZE/100000, 0, GET4_EPOCH_CYCLE_SIZE,
            "chip []", "Value of Roc Epoch Cnt []", "Counts []" );
      ROC[uRoc].fEpochShiftsPerChip = MakeTH2( 'I', Form("%sRoc%u_EpochShiftsPerChip", folder, uRoc),
            "Value of shift in Epochs when non consecutive epoch index are detected, per chip",
            MAX_GET4_PER_ROC, -0.5, MAX_GET4_PER_ROC -0.5,
            512, -256, 256,
            "chip []", "Epoch indec Shift in GET4 epochs []", "Counts []" );
      ROC[uRoc].fEpochShiftsDurationPerChip = MakeTH2('I',
            Form("%sRoc%u_EpochShiftsDurationPerChip", folder, uRoc ),
            Form("Duration of epoch shifts for all chips on ROC %d", uRoc),
            MAX_GET4_PER_ROC, -0.5, MAX_GET4_PER_ROC -0.5,
            5000, 0., 5000.,
            "chip []", "Duration [GET4 epochs]");

      ROC[uRoc].fNbEventsPerMbsEvent = MakeTH1( 'I', Form("%sRoc%u_EventsCount", folder, uRoc),
            "Nb of detected events per Mbs event",
            50, 0, 50 ,
            "# Events []", "Counts []" );
      ROC[uRoc].fNbNotEmptyEventsPerMbsEvent = MakeTH1( 'I', Form("%sRoc%u_NotEmptyEvtCount", folder, uRoc),
            "Nb of detected events per Mbs event",
            50, 0, 50 ,
            "# Events []", "Counts []" );
      ROC[uRoc].fChannelsMapping = MakeTH2( 'I', Form("%sRoc%u_ChanMap", folder, uRoc),
            "Events with both channels present",
            NB_CHAN_GET4*MAX_GET4_PER_ROC, 0, MAX_GET4_PER_ROC ,
            NB_CHAN_GET4*MAX_GET4_PER_ROC, 0, MAX_GET4_PER_ROC ,
            "1st channel []", "2nd channel []", "Counts []" );
      ROC[uRoc].fChannelMultiplicity = MakeTH2( 'I', Form("%sRoc%u_ChanMul", folder, uRoc),
            "Channel multiplicity per event",
            NB_CHAN_GET4*MAX_GET4_PER_ROC, 0, MAX_GET4_PER_ROC ,
            20, 0, 20,
            "Channel []", "# Hits []", "events []" );

      if( kTRUE ==  fParam->bFreeStreaming && 0 < fParam->uNbTriggers )
      {
         ROC[uRoc].fDataSelfTriggerPerEvent = MakeTH2( 'I', Form("%sRoc%u_DataSelfTrigg", folder, uRoc),
               "Channel multiplicity per event",
               50, 0, 50 ,
               fParam->uNbTriggers, 0, fParam->uNbTriggers,
               "# Triggers/event []", "Trigger index[]", "events []" );

         ROC[uRoc].fDataSelfTrigDistanceNs  = MakeTH2('I', Form("%sRoc%u_DataTrigDistanceNs", folder, uRoc),
               "Time difference since last trigger from data ROC",
               1002, -2., 1000.,
               fParam->uNbTriggers, 0, fParam->uNbTriggers,
               " [ns]", "Trigger index[]", "events []" );
         ROC[uRoc].fDataSelfTrigDistanceUs   = MakeTH2('I', Form("%sRoc%u_DataTrigDistanceUs", folder, uRoc),
               "Time difference since last trigger from data ROC",
               999, 1., 1000.,
               fParam->uNbTriggers, 0, fParam->uNbTriggers,
               " [us]", "Trigger index[]", "events []" );
         ROC[uRoc].fDataSelfTrigDistanceMs   = MakeTH2('I', Form("%sRoc%u_DataTrigDistanceMs", folder, uRoc),
               "Time difference since last trigger from data ROC",
               999, 1., 1000.,
               fParam->uNbTriggers, 0, fParam->uNbTriggers,
               " [ms]", "Trigger index[]", "events []" );
         ROC[uRoc].fDataSelfTrigDistanceS    = MakeTH2('I', Form("%sRoc%u_DataTrigDistanceS", folder, uRoc),
               "Time difference since last trigger from data ROC",
               999, 1., 1000.,
               fParam->uNbTriggers, 0, fParam->uNbTriggers,
               " [s]", "Trigger index[]", "events []" );
      }

      // Error messages
      ROC[uRoc].fGet4ErrorChip = MakeTH1('I', Form("%sRoc%u_Get4ErrorChip", folder, uRoc),
                              "Get4 chip sending Error message",
                              fParam->uNbGet4, -0.5, fParam->uNbGet4 -0.5, "Error Chip","Entries [1]");
      ROC[uRoc].fGet4ErrorChan = MakeTH2('I', Form("%sRoc%u_Get4ErrorChan", folder, uRoc),
                              "Get4 channel/edge sending Error message",
                              2*(fParam->uNbGet4)*NB_CHAN_GET4, 0., (fParam->uNbGet4)*NB_CHAN_GET4, 6, 0, 6,
                              "Error chan","","Entries [1]");

      ROC[uRoc].fGet4ErrorChan->GetYaxis()->SetBinLabel(1, "0x04: FIFO Write      ");
      ROC[uRoc].fGet4ErrorChan->GetYaxis()->SetBinLabel(2, "0x05: Lost event      ");
      ROC[uRoc].fGet4ErrorChan->GetYaxis()->SetBinLabel(3, "0x06: Channel state   ");
      ROC[uRoc].fGet4ErrorChan->GetYaxis()->SetBinLabel(4, "0x11: Overwrite       ");
      ROC[uRoc].fGet4ErrorChan->GetYaxis()->SetBinLabel(5, "0x12: ToT out of range");

      ROC[uRoc].fGet4ErrorPatt = MakeTH2('I', Form("%sRoc%u_Get4ErrorPatt", folder, uRoc),
                              "Pattern of Get4 Error message",
                              fParam->uNbGet4, -0.5, fParam->uNbGet4 -0.5, 128, 0., 128,
                              "Error chip","","Entries [1]");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(1,  "0x00: Readout Init    ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(2,  "0x01: Sync            ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(3,  "0x02: Epoch count sync");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(4,  "0x03: Epoch           ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(5,  "0x04: FIFO Write      ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(6,  "0x05: Lost event      ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(7,  "0x06: Channel state   ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(8,  "0x07: Token Ring state");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(9,  "0x08: Token           ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(10, "0x09: Error Readout   ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(11, "0x0a: SPI             ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(12, "0x0b: DLL Lock error  "); // <- From GET4 v1.2
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(13, "0x0c: DLL Reset invok."); // <- From GET4 v1.2
//      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(14, "0x0d:                 ");
//      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(15, "0x0e:                 ");
//      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(16, "0x0f:                 ");
//      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(17, "0x10:                 ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(18, "0x11: Overwrite       ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(19, "0x12: ToT out of range");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(20, "0x13: Event Discarded ");
      ROC[uRoc].fGet4ErrorPatt->GetYaxis()->SetBinLabel(128, "0x7f: Unknown         ");

      /*
       * Debug Histograms for GET4 v1.x
       */
      if( 1 == fParam->bDebugHistoEnable )
      {
         UInt_t uHistosIndexSingleChip = 0;
         UInt_t uHistosIndexChipVsChip = 0;
         for(UInt_t uFirstGet4Channel = 0; uFirstGet4Channel < NB_CHAN_GET4; uFirstGet4Channel++)
         {
            for(UInt_t uSecondGet4Channel = 0; uSecondGet4Channel < NB_CHAN_GET4; uSecondGet4Channel++)
            {
               if( uFirstGet4Channel < uSecondGet4Channel )
               {
                  ROC[uRoc].fTimeDiffInsideChip[0][uHistosIndexSingleChip] =
                        MakeTH1('I',
                              Form("%sDebug/Chip1/Roc%d_TimeDiff1_%d_%d",
                                    folder, uRoc, uFirstGet4Channel, uSecondGet4Channel),
                              Form("Time difference between channel %d and %d in chip %d ROC %d",
                                    uFirstGet4Channel, uSecondGet4Channel, fParam->uGet4TimeDiffChip1, uRoc),
                              601, -15025, 15025, "dT [ps]", "Counts [1]" );
                  ROC[uRoc].fTimeDiffInsideChip[1][uHistosIndexSingleChip] =
                        MakeTH1('I', Form("%sDebug/Chip2/Roc%d_TimeDiff2_%d_%d",
                              folder, uRoc, uFirstGet4Channel, uSecondGet4Channel),
                        Form("Time difference between channel %d and %d in chip %d ROC %d",
                              uFirstGet4Channel, uSecondGet4Channel, fParam->uGet4TimeDiffChip2, uRoc),
                        601, -15025, 15025, "dT [ps]", "Counts [1]" );

                  // 1D FineTime correlation
                  ROC[uRoc].fFTCorrel[0][uHistosIndexSingleChip] =
                        MakeTH1('I',
                              Form("%sDebug/Chip1/Roc%d_FTCorrel1_%d_%d",
                                    folder, uRoc, uFirstGet4Channel, uSecondGet4Channel),
                              Form("FTS Correlation between channels %d and %d in chip %d ROC %d",
                                    uFirstGet4Channel, uSecondGet4Channel, fParam->uGet4TimeDiffChip1, uRoc),
                              2*NB_BIN_GET4_FTS + 1, -NB_BIN_GET4_FTS-0.5, NB_BIN_GET4_FTS+0.5);
                  ROC[uRoc].fFTCorrel[1][uHistosIndexSingleChip] =
                        MakeTH1('I',
                              Form("%sDebug/Chip2/Roc%d_FTCorrel2_%d_%d",
                                    folder, uRoc, uFirstGet4Channel, uSecondGet4Channel),
                              Form("FTS Correlation between channels %d and %d in chip %d ROC %d",
                                    uFirstGet4Channel, uSecondGet4Channel, fParam->uGet4TimeDiffChip2, uRoc),
                              2*NB_BIN_GET4_FTS + 1, -NB_BIN_GET4_FTS-0.5, NB_BIN_GET4_FTS+0.5);

                  // 2D FineTime correlation
                  ROC[uRoc].fFTCorrel2D[0][uHistosIndexSingleChip] =
                        MakeTH2('I',
                              Form("%sDebug/Chip1/Roc%d_2dFTCorr1_%d_%d",
                                    folder, uRoc, uFirstGet4Channel, uSecondGet4Channel),
                              Form("FTS Correlation between channels %d and %d in chip %d ROC %d",
                                    uFirstGet4Channel, uSecondGet4Channel, fParam->uGet4TimeDiffChip1, uRoc),
                              NB_BIN_GET4_FTS, -0.5, NB_BIN_GET4_FTS-0.5,
                              NB_BIN_GET4_FTS, -0.5, NB_BIN_GET4_FTS-0.5);
                  ROC[uRoc].fFTCorrel2D[1][uHistosIndexSingleChip] =
                        MakeTH2('I',
                              Form("%sDebug/Chip2/Roc%d_2dFTCorr2_%d_%d",
                                    folder, uRoc, uFirstGet4Channel, uSecondGet4Channel),
                              Form("FTS Correlation between channels %d and %d in chip %d ROC %d",
                                    uFirstGet4Channel, uSecondGet4Channel, fParam->uGet4TimeDiffChip2, uRoc),
                              NB_BIN_GET4_FTS, -0.5, NB_BIN_GET4_FTS-0.5,
                              NB_BIN_GET4_FTS, -0.5, NB_BIN_GET4_FTS-0.5);

                  uHistosIndexSingleChip++;
               } // if( uFirstGet4Channel < uSecondGet4Channel )
               ROC[uRoc].fTimeDiffBetweenChips[uHistosIndexChipVsChip] =
                     MakeTH1('I',
                           Form("%sDebug/ChipVsChip/Roc%d_dT_%d_%d_Vs_%d_%d",
                                 folder, uRoc,
                                 fParam->uGet4TimeDiffChip1, uFirstGet4Channel,
                                 fParam->uGet4TimeDiffChip2, uSecondGet4Channel),
                           Form("Time difference between channel %d in chip %d and channel %d in chip %d",
                                 uFirstGet4Channel, fParam->uGet4TimeDiffChip1, uSecondGet4Channel, fParam->uGet4TimeDiffChip2),
                           961, -24025, 24025, "dT [ps]", "Counts [1]" );
               ROC[uRoc].fFTCorrelChipToChip[uHistosIndexChipVsChip] =
                     MakeTH1('I',
                           Form("%sDebug/ChipVsChip/Roc%d_FTCorrel_%d_%d_Vs_%d_%d",
                                 folder, uRoc,
                                 fParam->uGet4TimeDiffChip1, uFirstGet4Channel,
                                 fParam->uGet4TimeDiffChip2, uSecondGet4Channel),
                           Form("FTS Correlation between channel %d in chip %d and channel %d in chip %d",
                                 uFirstGet4Channel, fParam->uGet4TimeDiffChip1, uSecondGet4Channel, fParam->uGet4TimeDiffChip2),
                           2*NB_BIN_GET4_FTS + 1, -NB_BIN_GET4_FTS-0.5, NB_BIN_GET4_FTS+0.5);
               uHistosIndexChipVsChip++;
            } // for(UInt_t uSecondGet4Channel = 0; uSecondGet4Channel < MAX_GET4_CH; uSecondGet4Channel++)
         } // for(UInt_t uFirstGet4Channel = 0; uFirstGet4Channel < MAX_GET4_CH; uFirstGet4Channel++)
      } // if( 1 == fParam->bDebugHistoEnable )
   } // for( UInt_t  uRoc =0; uRoc<fParam->numRocs; uRoc++ )
   printData = 0;
   fCurrentGet4Event.Clear();

   /* TODO FILL ME
    * Histos and inner variables initialization for Get4 monitoring
    */

   fGlobalTriggerWind = MakeWinCond("TriggerWindow", -100, 2000., fDeltaTriggerTime->GetName());
   fGlobalAUXWind     = MakeWinCond("AUXWindow",     -100, 100.,  fDeltaTriggerTime->GetName());

   setupmacro = "set_Get4v1Cond.C";
   if (!gSystem->AccessPathName(setupmacro.Data())) {
      TGo4Log::Info("Executing ROC condition setup script %s", setupmacro.Data());
      gROOT->ProcessLine(Form(".x %s", setupmacro.Data()));
   } else {
      TGo4Log::Info("NO ROC condition setup script %s. Use previous values!", setupmacro.Data());
   }

   ResetEndOfBuffer();

/*
   fEvtIndexRoc = MakeTH2('I', "EvtIndexRoc", "Event count vs Event index - Initial event inedx for ROC",
         600, 0., 600, 600, 0., 600 );
   fEvtIndexTrig= MakeTH2('I', "EvtIndexTrig", "Event count vs Event index - Initial event inedx for VME",
         600, 0., 600, 600, 0., 600 );
         */
   uInitialEvent = 0;
   uEventCountsRoc = 0;
   uEventCountsTrig = 0;
   uEventCountsVme = 0;
}


void TGet4v1Proc::InitEvent(TGo4EventElement* outevnt)
{
   // since output event object is never discarded within processor lifetime,
   // we just search for subevent by name once to speed up processing
   if(fOutputEvent==0)
   {
      // test if we are in beamtime or standalone mode:
      TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(outevnt);
      if(btevent)
      {

         fOutputEvent = dynamic_cast<TGet4v1Event*>(btevent->GetSubEvent("ROCGET4V10"));
      }
      else
      {

         fOutputEvent= dynamic_cast<TGet4v1Event*>(outevnt);
      }
      if(fOutputEvent==0)
      {
         GO4_STOP_ANALYSIS_MESSAGE("**** TGet4v1Proc: Fatal error: output event is not a TGet4v1Event!!! STOP GO4");
      }
   } // IF OUTPUTEVENT

   fFirstSubEvent = true;

//   printf("Start event\n");
}



//-----------------------------------------------------------
// event function
void TGet4v1Proc::ProcessSubevent(TGo4MbsSubEvent* psubevt)
{
   uint32_t g4id(0), auxid(0), syncid(0);
   uint64_t fulltm(0);
   uint32_t typ(0), rocid(0), lastevrocid(0);
   static int cnt=0;
   unsigned msgcount=0;

   //cout << "#################### ProcessSubevent Start" << endl;
   bool is_dabc_evt = (psubevt->GetProcid() == roc::proc_RocEvent) ||
                      (psubevt->GetProcid() == roc::proc_ErrEvent) ||
                      (psubevt->GetProcid() == roc::proc_MergedEvent);
   bool is_raw_evt = (psubevt->GetProcid() == roc::proc_RawData);
   bool is_vme_evt = (psubevt->GetProcid() == roc::proc_Triglog) ||
                      (psubevt->GetProcid() == roc::proc_COSY_Nov11);

   fEvtPerProc->Fill( psubevt->GetProcid() );
   if( 0 == uEventCountsRoc && 0 == uEventCountsTrig)
      uInitialEvent = GetEventNumber();

   if( is_vme_evt && psubevt->GetProcid() == roc::proc_Triglog )
   {
      if( 0 == uEventCountsTrig )
         fEvtIndexTrig= MakeTH1('I', "EvtIndexTrig", "Event count vs Event index - Initial event index for VME",
               600, 0., 600 );
//      fEvtIndexTrig->Fill( uEventCountsTrig, GetEventNumber() - uInitialEvent);
      fEvtIndexTrig->Fill( GetEventNumber() - uInitialEvent, uEventCountsTrig);
      uEventCountsTrig++;
   }
      else if( is_vme_evt && psubevt->GetProcid() == roc::proc_COSY_Nov11 )
      {
         if( 0 == uEventCountsVme )
            fEvtIndexVme= MakeTH1('I', "EvtIndexVme", "Event count vs Event index - Initial event index for VME",
                  600, 0., 600 );
         fEvtIndexVme->Fill( GetEventNumber() - uInitialEvent, uEventCountsVme );
         uEventCountsVme++;
      }
         else
         {
            if( 0 == uEventCountsRoc )
            {
               fEvtIndexRoc = MakeTH1('I', "EvtIndexRoc", "Event count vs Event index - Initial event index for ROC",
                     600, 0., 600 );
               fTriggerNumber = MakeTH1('I', "TriggerNumber", "Event count per trigger for ROC",
                     16, 0., 16 );
            }
            fEvtIndexRoc->Fill( GetEventNumber() - uInitialEvent, uEventCountsRoc );
            uEventCountsRoc++;
            fTriggerNumber->Fill( GetTriggerNumber() );
         }

   if (!is_dabc_evt && !is_raw_evt)
   {
      // No printout when VME part of merged data
      if( !is_vme_evt )
         cout << "Oups: Not DABC or RAW event"<< endl;
      return;
   }

   if( 1 == is_raw_evt && kFALSE == fParam->bRawDataMode )
   {
      fParam->bRawDataMode = kTRUE;
      cout<<" Found a RAW DATA event => switch RAW DATA mode ON"<<endl;
   }

   unsigned rid = psubevt->GetSubcrate();

// BEGIN INITIAL EVENT PART
   int datasize = (psubevt->GetDlen() - 2) * 2;
   int msg_fmt = psubevt->GetControl();
   ROC[rid].fIter.setFormat(msg_fmt);
   ROC[rid].fIter.setRocNumber(rid);

   if( -1 != fParam->FindGet4RocId( psubevt->GetSubcrate() ) )
   {
      Int_t iFeetRocIndex = fParam->FindGet4RocId( psubevt->GetSubcrate() );
      if(uNbEvents[iFeetRocIndex] == 0) {
         uFirstEventIndex[iFeetRocIndex] = GetEventNumber();
         TGo4Log::Info("***** First event on Get4 roc %d: %d ", iFeetRocIndex, uFirstEventIndex[iFeetRocIndex]);
      } // if(uNbEvents[iFeetRocIndex] == 0)
      else {
         if( 0 < fParam->iEventNbGap &&
             (Int_t)uPrevEventIndex[iFeetRocIndex] + fParam->iEventNbGap != GetEventNumber() &&
             ( uPrevEventIndex[iFeetRocIndex] !=  fParam->uEventNbCycle || 0 != GetEventNumber() ) ) {
            TGo4Log::Error("***** Missing event in file for Get4 roc %d: Event %d, Previous event index %d, Current event Index %d, expected %d",
                  iFeetRocIndex, uNbEvents[iFeetRocIndex], uPrevEventIndex[iFeetRocIndex], GetEventNumber(),
                  (Int_t)uPrevEventIndex[iFeetRocIndex] + fParam->iEventNbGap);
         } // if not matching expected event gap
      } // else of if(uNbEvents[iFeetRocIndex] == 0)
      uPrevEventIndex[iFeetRocIndex]  = GetEventNumber();
      uNbEvents[iFeetRocIndex]++;
   } // if( -1 != fParam->FindGet4RocId( psubevt->GetSubcrate() ) )
   /*************************************/

   // we can exclude messages (SYNC and may be EPOCH) which are added by DABC at the end of subevent
   if (is_dabc_evt)
   {
      // ignore all irrelevant events
      if (GetTriggerNumber()>11)
      {
         cout<<"OUPS, trigger too high: "<<GetTriggerNumber()<<endl;
         return;
      }

      roc::Message msg1, msg2;
      roc::Message msgA, msgB;

      char* ptr = (char*) psubevt->GetDataField();
      int msglen = roc::Message::RawSize(msg_fmt);

      if (ROC[rid].fIter.assign(ptr + datasize - msglen, msglen)) {
         if (ROC[rid].fIter.next()) msg1.assign(ROC[rid].fIter.msg());
      }

      if (!msg1.isSyncMsg()) {
         TGo4Log::Error("Non-SYNC message at the end of DABC-produced subevent");
      } else {
         rocid = msg1.getRocNumber();
         /*
          * TODO: Option to choose between removing final epoch+SYNC or initial epoch+SYNC
          */
         UInt_t uSyncId    = msg1.getSyncChNum();
         UInt_t uSyncTs    = msg1.getSyncTs();
         UInt_t uSyncEpLsb = msg1.getSyncEpochLSB();
         UInt_t uSyncData  = msg1.getSyncData();
         UInt_t uSyncFlag  = msg1.getSyncStFlag();
         ULong64_t ulFulltime = msg1.getMsgFullTime( ROC[rocid].GetFullEpochNumber( ) );
         ulFulltime += ROC[rocid].GetSuperCycleEpOffset();
/*
         cout<<"End Event "<<GetEventNumber()<<" Sync Id "<<uSyncId<<" Ts "<<uSyncTs;
         cout<<" EpLsb "<<uSyncEpLsb<<" Data "<<uSyncData<<" Flag "<<uSyncFlag;
         cout<<" FullT "<<ulFulltime<<endl;
         */
         /*
          *
          */

         // kFALSE = SYNC arriving before the event data, kTRUE = after
         // => if kTRUE, keep last 2 message and throw 2 first!
         if( kFALSE == fParam->bTriggerAfterData )
            datasize -= msglen;
         int shift = msglen;
         while (shift<=datasize) {

            if (ROC[rid].fIter.assign(ptr + datasize - shift, msglen)) {
               if (ROC[rid].fIter.next())
                  msg2.assign(ROC[rid].fIter.msg());
               else
                  break;

               if (msg2.isEpochMsg())
               {
                  /*
                  cout<<"End Event "<<GetEventNumber()<<" Epoch "<<msg2.getEpochNumber()<<endl;
                  */
                  break;
               }
            }
            shift+=msglen;
         }
         // exclude special epoch message for sync only
         // kFALSE = SYNC arriving before the event data, kTRUE = after
         // => if kTRUE, keep last 2 message and throw 2 first!
         if( kFALSE == fParam->bTriggerAfterData )
            if ((shift==msglen) && msg2.isEpochMsg()) datasize -= msglen;
      } // else of if (!msg1.isSyncMsg())
   } // if (is_dabc_evt)

   fTotaldatasize += datasize;

   if (!ROC[rid].fIter.assign(psubevt->GetDataField(), datasize))
   {
      cout<<"OUPS, probblem: "<<psubevt->GetDataField()<<" "<<datasize<<endl;
      return;
   } // if (!ROC[rid].fIter.assign(psubevt->GetDataField(), datasize))

   fEvntSize->Fill(datasize);

   //cout << "AnlProc: found subevent subcrate="<<(int) psubevt->GetSubcrate()<<", procid=";
   //cout<<(int)psubevt->GetProcid()<<", control="<<(int) psubevt->GetControl()<< endl;
// END INITIAL EVENT PART

   /* TODO FILL ME
    * Buffer processing
    */

   roc::Message* data = & ROC[rid].fIter.msg();
   while (ROC[rid].fIter.next()) {
      msgcount++;

      rocid = data->getRocNumber();
      fMsgsPerRoc->Fill(rocid);

      // Process data only from active ROCs
      if( kFALSE == fParam->IsActiveRoc(rocid) )
         continue;

      typ = data->getMessageType();
      if(typ==roc::MSG_GET4)
      {
         fulltm = data->getMsgFullTime(
               ROC[rocid].GetFullEpoch2Number(
                     fParam->RemapGet4Chip( data->getGet4Number() ) ));
         fulltm +=  ROC[rocid].GetSuperCycleEp2Offset(
                     fParam->RemapGet4Chip( data->getGet4Number() ) );
      }
      else
      {
         fulltm = data->getMsgFullTime(
               ROC[rocid].GetFullEpochNumber() );
         fulltm +=  ROC[rocid].GetSuperCycleEpOffset( );

      }

      ROC[rocid].fMsgTypes->Fill(typ);

      ULong64_t  ulMsgTm = fulltm / 100000000L;
      ROC[rocid].fALLt->Fill( (ulMsgTm % 36000) * 0.1 );

      // Long duration time distribution (1 min. bin, 10 days length)
      if( kTRUE == fParam->bLongTimeHistos )
         ROC[rocid].fAllLongT->Fill( ( ulMsgTm * 0.1 ) /3600);

      TGet4v1MessageExtended exmess(*data,fulltm);

      switch (typ)
      {
         case roc::MSG_NOP:
         {
            break;
         } // case roc::MSG_NOP:
         case roc::MSG_HIT:
         {
            break;
         } // case roc::MSG_HIT:
         case roc::MSG_GET4:
         {
            Double_t dFullTimeD = data->getMsgFullTimeD(
                                    ROC[rocid].GetFullEpoch2Number(
                                             fParam->RemapGet4Chip( data->getGet4Number() ) ) );
            dFullTimeD += ROC[rocid].GetSuperCycleEp2OffsetD( fParam->RemapGet4Chip( data->getGet4Number() ) );
            exmess.SetFullTimeD( dFullTimeD );
            // In case of suppressed epochs, we will have no epoch2 message for all empty epochs
            // However, when a chip has data, its next epoch message should be present!!!
            // => Specific function to wait for next epoch2
            if( kTRUE == fParam->bSuppressedEpochs)
               ProcessGet4SuppDataMessage(rocid, exmess);
            else if( kTRUE == ProcessGet4DataMessage(rocid, exmess) )
               ProcessExtendedMessage(rocid, exmess);
            break;
         } // case roc::MSG_GET4:
         case roc::MSG_EPOCH:
         {
            /*
            if((msgcount<3) && !is_raw_evt)
            {
               cout<<"Beg Event "<<GetEventNumber()<<" Epoch "<<data->getEpochNumber()<<endl;
            }
            */
            if( !is_dabc_evt || kFALSE == fParam->bTriggerAfterData ||
                 2 < msgcount)
               ProcessRocEpochMessage(rocid, exmess);
            break;
         } // case roc::MSG_EPOCH:
         case roc::MSG_EPOCH2:
         {
            if( kTRUE == fParam->bSuppressedEpochs)
               ProcessGet4SuppEpochMessage(rocid, exmess);
               else ProcessGet4EpochMessage(rocid, exmess);
            break;
         } // case roc::MSG_EPOCH2:
         case roc::MSG_SYNC:
         {
            UInt_t uSyncId    = data->getSyncChNum();
            UInt_t uSyncTs    = data->getSyncTs();
            UInt_t uSyncEpLsb = data->getSyncEpochLSB();
            UInt_t uSyncData  = data->getSyncData();
            UInt_t uSyncFlag  = data->getSyncStFlag();
            ULong64_t ulFulltime = data->getMsgFullTime( ROC[rocid].GetFullEpochNumber( ) );
            ulFulltime += ROC[rocid].GetSuperCycleEpOffset();

            if( kFALSE == fParam->bTriggerAfterData )
            {
               if((msgcount<3) && !is_raw_evt)
               {
                  ROC[rocid].fDabcSeparator = data->getSyncChNum()+10;
               }
               ProcessRocSyncMessage(rocid, exmess);
            } // if( kFALSE == fParam->bTriggerAfterData )
               else if( (2 < msgcount ) || !is_dabc_evt)
               {
                  if( ( (datasize - 3 ) < (Int_t)msgcount) && !is_raw_evt)
                  {
                     ROC[rocid].fDabcSeparator = data->getSyncChNum()+10;
                  }
                  ProcessRocSyncMessage(rocid, exmess);
               } // else if( (2 < msgcount ) || !is_dabc_evt) of if( kFALSE == fParam->bTriggerAfterData )
            break;
         } // case roc::MSG_SYNC:
         case roc::MSG_AUX:
         {
            auxid = data->getAuxChNum();
            ROC[rocid].fAUXch->Fill(auxid);
            if (auxid < MAX_AUX)
            {
               ROC[rocid].fLastAuxTm[auxid] = fulltm;

               // Recalculate the full Time to take into account also the epoch cycles
               ULong64_t ulFulltime ;
               ulFulltime  = (exmess.GetRocMessage()).getMsgFullTime(
                                   ROC[rocid].GetFullEpochNumber( ));
               ulFulltime += ROC[rocid].GetSuperCycleEpOffset();
               exmess.SetFullTime(ulFulltime);

               ULong64_t auxtm = fulltm / 100000000L;
               ROC[rocid].fAUXt[auxid]->Fill((auxtm % 10000) * 0.1);

               if( kFALSE ==  fParam->bFreeStreaming || 0 == fParam->uNbTriggers )
                  if (fParam->triggerSignal == (Int_t) auxid)
                  {
                     ProcessTriggerMessage(rocid, exmess);
                  }
            } // if (auxid < MAX_AUX)

            break;
         } // case roc::MSG_AUX:
         case roc::MSG_SYS:
         {
            ROC[rocid].fSysTypes->Fill(data->getSysMesType());

            if (data->getSysMesType() == roc::SYSMSG_USER)
            {
               ROC[rocid].fSysUserTypes->Fill(data->getSysMesData());

               switch (data->getSysMesData())
               {
                  case roc::SYSMSG_USER_CALIBR_ON:
                     ROC[rocid].bIgnoreData = kFALSE;
                     break;
                  case roc::SYSMSG_USER_CALIBR_OFF:
                     ROC[rocid].bIgnoreData = kFALSE;
                     break;
                  case roc::SYSMSG_USER_RECONFIGURE:
                     ROC[rocid].bIgnoreData = kTRUE;
                     ROC[rocid].fIgnoreCnt = 0;
                     ROC[rocid].fIgnoreTime = fulltm;
                     break;
                  default:
                     break;
               } // switch (data->getSysMesData())
            } // if (data->getSysMesType() == roc::SYSMSG_USER)
            else if( data->getSysMesType() == roc::SYSMSG_GET4_EVENT )
            {
               UInt_t uGet4SysMessType = (data->getSysMesData()>>6) & 0x1;

               // Get4 system message types histogram
               /*
               if (ROC[rocid].fGet4SysTypes)
                  ROC[rocid].fGet4SysTypes->Fill(uGet4SysMessType);
                  */

               UInt_t uGet4IndexOffset = fParam->DefineGet4IndexOffset(rocid);
               // Remap the Get4 chip index
               UInt_t uChip = data->getField(40, 8) + uGet4IndexOffset;
               uChip = fParam->RemapGet4Chip(uChip);
               // Set Remapped Get4 index
               data->setField(40, 8, uChip);

               // Get4 system message type = Error
               if (!fParam->IsValidGet4Chip(uChip)) {
                   cout << "Error: Bad chip nb in Error message = " << uChip << endl;
                   cout << " => This message will be skipped!!!! "<<endl;
                   continue;
               }
/*
               fGet4ErrorChip->Fill( uChip );
               fGet4ErrorPatt->Fill( uChip, (data->getSysMesData()) & 0x7f);
               if( 3 < ( (data->getSysMesData()) & 0x7f ) && ( (data->getSysMesData()) & 0x7f ) < 7 )
                  fGet4ErrorChan->Fill( (((data->getSysMesData()) & 0x300)>>16) + 0.5*(((data->getSysMesData()) & 0x80)>>15),
                       ((data->getSysMesData()) & 0x7f )>>2 );
*/
               UInt_t get4_24b_er_code = exmess.getGet4V10R32ErrorData();
               UInt_t get4_24b_er_chan = exmess.getGet4V10R32ErrorChan();
               UInt_t get4_24b_er_edge = exmess.getGet4V10R32ErrorEdge();

               ROC[rocid].fGet4ErrorChip->Fill( uChip );
               ROC[rocid].fGet4ErrorPatt->Fill( uChip, get4_24b_er_code);
               if( (0x03 < get4_24b_er_code && get4_24b_er_code < 0x07) )
                  ROC[rocid].fGet4ErrorChan->Fill(
                        NB_CHAN_GET4*uChip + get4_24b_er_chan + 0.5*get4_24b_er_edge,
                        get4_24b_er_code - 0x04 );

               ULong64_t uFullTimeBins = ((ULong64_t)  ROC[rocid].GetFullEpoch2Number( uChip )) << 19;
               uFullTimeBins /= 20; // now in ns
               uFullTimeBins += 512; // 250MHz offset
               uFullTimeBins /= 100000000L;
               ROC[rocid].fERRORt->Fill( (uFullTimeBins % 36000) * 0.1 );

               // Long duration time distribution (1 min. bin, 10 days length)
               if( kTRUE == fParam->bLongTimeHistos )
                  ROC[rocid].fErrorLongT->Fill( (uFullTimeBins * 0.1 ) / 3600 );

            } // if( data->getSysMesType() == roc::SYSMSG_GET4_EVENT )
            else if( get4v10::SYSMSG_GET4V1_32BIT_0 <= data->getSysMesType()   &&
                      data->getSysMesType() <= get4v10::SYSMSG_GET4V1_32BIT_15 )
            {
               if( 3 == Process32BitGet4Message(rocid, exmess) )
                  ProcessExtendedMessage(rocid, exmess);
            } // if GET4 32 bits message
            break;
         } //  case roc::MSG_SYS:
         default:
            break;
      } // switch (typ)
     
      if(printData<fParam->uGet4Print  )
      {
         exmess.Print(roc::msg_print_Human);
         printData++;
      }
   } // while (ROC[rid].fIter.next()) {
   /*
    * Buffer processing End
    */

   fFirstSubEvent = kFALSE;
}



void TGet4v1Proc::FinalizeEvent()
{
   fOutputEvent->fMbsEventNumber = GetEventNumber();
   /* TODO FILL ME
    * Final histo filling
    * Event validation
    */

   // For now stop current event there: no event spread over MBS event in future
   /*
   if( kFALSE == fCurrentGet4Event.IsEmpty() )
      (fOutputEvent->fEvents).push_back( fCurrentGet4Event );
   fCurrentGet4Event.Clear();
   */

   for( UInt_t  uRocTempId =0; uRocTempId < fParam->numRocs; uRocTempId++ )
   {
      ROC[uRocTempId].fNbEventsPerMbsEvent->Fill(uEventInsideMbsEvtCount[uRocTempId]);
      ROC[uRocTempId].fNbNotEmptyEventsPerMbsEvent->Fill(uNotEmptyEventInsideMbsEvtCount[uRocTempId]);
      uEventInsideMbsEvtCount[uRocTempId] = 0;
      uNotEmptyEventInsideMbsEvtCount[uRocTempId] = 0;

      if( kTRUE ==  fParam->bFreeStreaming && 0 < fParam->uNbTriggers )
         for( UInt_t uTrigger = 0; uTrigger < fParam->uNbTriggers; uTrigger++)
         {
            ROC[uRocTempId].fDataSelfTriggerPerEvent->Fill( ROC[uRocTempId].fuDataSelfTriggerCount[uTrigger],
                  uTrigger );
            ROC[uRocTempId].fuDataSelfTriggerCount[uTrigger] = 0;
         }
   }
   //printf(" =============== TGet4v1Proc::FinalizeEvent ===================\n ");
}


void TGet4v1Proc::ProcessTriggerMessage(UInt_t uRocId, TGet4v1MessageExtended& extMess,
                                            Int_t iTriggerIndex)
{
   /* TODO FILL ME
    * Trigger processing
    */

   /*
    * Check if current event already got a trigger
    */
   if( kTRUE == fCurrentGet4Event.HasTrigger() )
   {
      Double_t dLastTriggerDistance =
              extMess.GetFullTimeD()
            - fCurrentGet4Event.fdTriggerFullTime[uRocId] ;

      /*
       * If incoming trigger has lower priority than current trigger or if
       * current trigger was a SYNC trigger and a data trigger comes
       * And it is inside the deatime window
       * => Ignore incoming trigger
       */
      if( dLastTriggerDistance <= fParam->dDeadTime  &&
          iTriggerIndex < (Int_t)(fCurrentGet4Event.fuTriggerIndex)  )
         return;
      /*
       * If incoming trigger has higher priority than current trigger or if
       * current trigger was a SYNC trigger and a data trigger comes
       * And it is inside the deatime window
       * => erase current event, start new event using incoming trigger
       */
      else if( dLastTriggerDistance <= fParam->dDeadTime  &&
                iTriggerIndex > (Int_t)(fCurrentGet4Event.fuTriggerIndex) )
      {
         fCurrentGet4Event.Clear();

      } // else if( iTriggerIndex > (Int_t)(fCurrentGet4Event.fuTriggerIndex) )
      /*
       * If incoming trigger has same priority than current trigger or if
       * current trigger was a SYNC trigger and a SYNC trigger comes
       * => depend on bAllowEventMixing flag and distance
       * kTRUE  = save the partially filled old one, start the new one => TODO MIXING!!!
       * kFALSE = ignore incoming trigger
       * Distance between them bigger than trigger window size => save the partially filled old one, start the new one
       */
      else
      {
         if( fParam->dDeadTime < dLastTriggerDistance || kTRUE == fParam->bAllowEventMixing)
         {
            /*
             * TODO real event mixing or parallel buffers
             */
            
            // Check flag indicating the extra epoch after trigger is passed
            for( UInt_t  uRocTempId =0; uRocTempId<fParam->numRocs; uRocTempId++ )
            {
               // do not check for non-used ROC
               if (!fParam->IsActiveRoc(uRocTempId)) continue;
               
               for( UInt_t uGet4 = 0; uGet4 < MAX_GET4_PER_ROC; uGet4++)
               {
                  UInt_t uRemappedGet4Index = fParam->RemapGet4Chip(uRocTempId, uGet4);
                  if( kFALSE == fParam->IsValidGet4Chip(uRemappedGet4Index) ||
                      kFALSE == fParam->IsActiveGet4Chip(uRemappedGet4Index) )
                      continue;
                      
                  // Finish previous event
//                  BuildHitsAfterTrigg( uRocTempId,  uRemappedGet4Index);

                  // If chip not finished to process this event, build hits from current
                  // buffer (safe as we anyway build hits on epoch end when necessary)
                  if( kFALSE == ROC[uRocTempId].fbSelectionDone[uRemappedGet4Index]  )
                  {
                     // If This is the first epoch after the trigger and 
                     // we did not process the epoch before the one where the 
                     // trigger came, we need to initialize the 24 bit temp hits
                     if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uRemappedGet4Index] && 
                         kFALSE == ROC[uRocId].bLookInPreviousEpoch[uRemappedGet4Index] )
                        for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                              (ROC[uRocId].fHitTemp24[uRemappedGet4Index][uChan]).Clear();
                                 
                     BuildHits(uRocTempId, uRemappedGet4Index, ROC[uRocTempId].fbBufferWithLastFullEpoch2[uRemappedGet4Index]);
                     ROC[uRocTempId].fbSelectionDone[uRemappedGet4Index] = kTRUE;
                  }
               } // for( UInt_t uGet4 = 0; uGet4 < MAX_GET4_PER_ROC; uGet4++)
            } // for( UInt_t  uRocId =0; uRocId<fParam->numRocs; uRocId++ )

            // Save previous event if not empty
            if( kFALSE == fCurrentGet4Event.IsEmpty() )
            {
               AnalyzeAllGet4Channels( fCurrentGet4Event );
               (fOutputEvent->fEvents).push_back( fCurrentGet4Event );
               
               for( UInt_t  uRocTempId =0; uRocTempId<fParam->numRocs; uRocTempId++ )
               {
                  // do not check for non-used ROC
                  if (!fParam->IsActiveRoc(uRocTempId)) continue;
                  
                  uNotEmptyEventInsideMbsEvtCount[uRocTempId]++;
                  uNotEmptyRealEventsCount[uRocTempId]++;
               } // for( UInt_t  uRocTempId =0; uRocTempId<fParam->numRocs; uRocTempId++ )
            } // if( kFALSE == fCurrentGet4Event.IsEmpty() )
         } // if( kTRUE == fParam->bAllowEventMixing)
            else return;
      } // else of else if( trigger > currentTrig) of if( trigger < currentTrig)
   } // if( kTRUE == fCurrentGet4Event.HasTrigger() )

   // anyway clear again for safety
   fCurrentGet4Event.Clear();

   // Assign new trigger time to current event holder
   fCurrentGet4Event.fdTriggerFullTime[uRocId] = extMess.GetFullTimeD();
   if( fCurrentGet4Event.fdTriggerFullTime[uRocId] <= 0.0)
      TGo4Log::Error("Assigning 0 time as trigger time? event %d time %d", GetEventNumber(), extMess.GetFullTimeD());

   // Event number of the corresponding MBS event
   fCurrentGet4Event.fuMbsEventNumber      = GetEventNumber();
   // Index of the real event inside MBS event
   fCurrentGet4Event.fuEventNbInsideMbsEvt = uEventInsideMbsEvtCount[uRocId];
   // Total event number
   fCurrentGet4Event.fuGlobalEventNumber   = uRealEventsCount[uRocId];
   if( roc::MSG_SYNC == extMess.GetMessageType() )
   {
      // Flag indicating that this real event is the one synchronized to MBS
      fCurrentGet4Event.fbMbsSyncedEvent = kTRUE;
      // Event Nmber from the sync message
      fCurrentGet4Event.fuSyncEventNumber = (extMess.GetRocMessage()).getSyncData();
   } // if( roc::MSG_SYNC == extMess.GetMessageType() )
      else if( -1 < iTriggerIndex )
      {
         // Flag indicating that this real event was made after finding coincidence in data
         fCurrentGet4Event.fbDataTriggered = kTRUE;
         // Index of the Data trigger making this event
         fCurrentGet4Event.fuTriggerIndex = (UInt_t)iTriggerIndex;
      } // else if( -1 < iTriggerIndex ) of if( roc::MSG_SYNC == extMess.GetMessageType() )
   uEventInsideMbsEvtCount[uRocId]++;
   uRealEventsCount[uRocId]++;

   /*
    * TODO: ROC self (NX/SYNC/AUX) messages bulding/checking
    */
   ROC[uRocId].fbSelectionRocDone = kFALSE;
   ROC[uRocId].fbEpochSinceTrigger = kFALSE;
    
   // Good solution is following:
   // When trigger: Process PrevBuffer Epoch -1 and remove older data if no event mixing
   // When current epoch finishes or when new trigger out of deadtime => process current epoch and remove older data if no event mixing
   // When future epoch finishes or when new trigger out of deadtime => process future epoch (which is stored in current buffer)
   for( UInt_t uGet4Index = 0; uGet4Index < fParam->uNbGet4; uGet4Index++)
      if( fParam->IsActiveGet4Chip( uGet4Index ) )
      {
         // Check if necessary to build hits from buffer of previous epoch
         // Is the case if the trigger window begins before beginning of current epoch
         Double_t dFullTimeCurrentEpoch = (((ULong64_t)ROC[uRocId].GetFullEpoch2Number(uGet4Index)) << 19);
         dFullTimeCurrentEpoch = dFullTimeCurrentEpoch / 20. + 512.;

         if( extMess.GetFullTimeD() + fParam->dCoincidenceWindowStart[iTriggerIndex] < dFullTimeCurrentEpoch)
         {
            ROC[uRocId].bLookInPreviousEpoch[uGet4Index] = kTRUE;
            for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                  (ROC[uRocId].fHitTemp24[uGet4Index][uChan]).Clear();
            Bool_t bOlderBuffer = ( kTRUE == ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Index] ? 0 : 1 );
            BuildHits(uRocId, uGet4Index, bOlderBuffer);
         } // if( extMess.GetFullTimeD() + fParam->dCoincidenceWindowStart[iTriggerIndex] < dFullTimeCurrentEpoch)
            else ROC[uRocId].bLookInPreviousEpoch[uGet4Index] = kFALSE;
            
         // Check if necessary to build hits from buffer of epoch after current one
         // Is the case if the trigger window ends after the end of current epoch
//         Double_t dFullTimeNextEpoch    = (Double_t)GET4_EPOCH_IN_PS*(Double_t)( 1.0 + ROC[uRocId].GetFullEpoch2Number(uGet4Index) )/ 1000.0;
         Double_t dFullTimeNextEpoch = 1.0 + (((ULong64_t)ROC[uRocId].GetFullEpoch2Number(uGet4Index)) << 19);
         dFullTimeNextEpoch = dFullTimeCurrentEpoch / 20. + 512.;
         if( dFullTimeNextEpoch < extMess.GetFullTimeD() + fParam->dCoincidenceWindowStop[iTriggerIndex] )
            ROC[uRocId].bLookInNextEpoch[uGet4Index] = kTRUE;
            else ROC[uRocId].bLookInNextEpoch[uGet4Index] = kFALSE;
            
         // Initialize the flag indicating how many epoch2 finished since this trigger came
         ROC[uRocId].fbEpoch2SinceTrigger[uGet4Index] = kFALSE;
         ROC[uRocId].fbSelectionDone[uGet4Index]   = kFALSE;
            
         for(UInt_t uChanTest = 0; uChanTest < NB_CHAN_GET4; uChanTest ++)
         {
            ROC[uRocId].fbDataTimeOut[uGet4Index][uChanTest] = kFALSE;
            ROC[uRocId].fbDataFallingOut[uGet4Index][uChanTest] = kFALSE;
         }
      }
   return;
}

void TGet4v1Proc::ProcessExtendedMessage(UInt_t uRocId, TGet4v1MessageExtended& extMess)
{
   /* TODO FILL ME
    * Generic Extended message processing
    * If Previous trigger done => just put in buffer
    * If not done => put in buffer, build hit if possible and
    * check if it does not match current trigger
    */
   UInt_t uType = extMess.GetMessageType();

   // 24 Bits data message => need to be built
   if( roc::MSG_GET4 == uType )
   {
      UInt_t uGet4Id =  extMess.GetGet4Number() ;

      // Check if chip is activated
      if( fParam->IsActiveGet4Chip(uGet4Id) )
      {
         // Save message anyway in previous epochs buffer in case two triggers come close
         ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][
             ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]].push_back(extMess);
      } // if( fParam->IsActiveGet4Chip(uChip) )
   }
   // 32 Bits data message => already contains a full hit!
   else if( roc::MSG_SYS == uType &&
       get4v10::SYSMSG_GET4V1_32BIT_0 <= extMess.GetSysMesType()   &&
       extMess.GetSysMesType() <= get4v10::SYSMSG_GET4V1_32BIT_15 )
   {
      UInt_t uGet4Id =  extMess.getGet4V10R32ChipId() ;
      uGet4Id = fParam->RemapGet4Chip( uRocId, uGet4Id);

      // Check if chip is activated
      if( fParam->IsActiveGet4Chip(uGet4Id) )
      {
         // Save message anyway in previous epochs buffer in case two triggers come close
         ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][
             ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]].push_back(extMess);
      } // if( fParam->IsActiveGet4Chip(uChip) )
   } // else if( Get4 32 bits) of if( Get4 24 bits )
   // Other ROC data messages => Saved in their own vector for each event if needed
   else
   {
      cout<<"Rejected message because type not recognised in ProcessExtendedMessage"<<endl;
   }// else of else if( Get4 32 bits) of if( Get4 24 bits )
}
/**********************************************************************/
Bool_t TGet4v1Proc::BuildHits(UInt_t uRocId, UInt_t uGet4Id, Bool_t bBufferToBuild)
{
   /*
    * 32 bit hit building from all raw message => easy => done
    * 24bit hit building from all raw edges messages
    * -> Check edges order? => ordering messages should solve
    * -> Check multiple rising edges case  => Histos?
    * -> Check multiple falling edges case => Histos?
    */
   UInt_t uLastAcceptedMessageIndex = 0;

   std::sort( ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild].begin(),
              ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild].end() );
   for( UInt_t uMessageIndex = 0;
         uMessageIndex < ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild].size();
         uMessageIndex ++)
   {
      if( kTRUE == (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild])[uMessageIndex].Is32Bit() )
      {
         // 32 Bits data message => already contains a full hit!
         fHitTemp.Clear();
         fHitTemp.SetFullHit32Bits( (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild])[uMessageIndex] );
         if( kTRUE == CheckHit( uRocId, uGet4Id, fHitTemp ) )
            uLastAcceptedMessageIndex = uMessageIndex;

      } // if( kTRUE == (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild])[uMessageIndex].Is32Bit() )
         else
         {
            UChar_t ucChan = (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild])[uMessageIndex].GetGet4ChNum();

            // 24 Bits data message => Rising and falling edge need to be associated to get a hit
            if( 1 == (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild])[uMessageIndex].IsRisingGet4Edge() )
            {
               // Trailing Edge
               // If no leading edge there, as messages are time ordered, means that
               // the leading edge of this hit is missing => no need to save it
               if( kTRUE == (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).IsTimeSet() )
               {
                  (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).SetTot24Bits(
                        (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild])[uMessageIndex] );

                  // Check if hit is not too big
                  // If it is we can clear this one as anyway messages are time ordered!
                  if( (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).GetTot() < 0)
                  {
                     cout<<"Negative 24b ToT in Build Older: Mess "<<uMessageIndex;
                     cout<<" Tot "<<(ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).GetTot();
                     cout<<" Test "<<( ((ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).GetTimeMessage()) < ((ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).GetTotMessage()) )<<endl;
                     ((ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).GetTimeMessage()).Print(roc::msg_print_Human);
                     ((ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).GetTotMessage()).Print(roc::msg_print_Human);
                     cout<<endl;
                     if( kTRUE == CheckHit( uRocId, uGet4Id, (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]) ) )
                        uLastAcceptedMessageIndex = uMessageIndex;
                  }
                     else if( (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).GetTot() < fParam->dMaxTot )
                     {
                        if( kTRUE == CheckHit( uRocId, uGet4Id, (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]) ) )
                           uLastAcceptedMessageIndex = uMessageIndex;
                     }
                     else (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).Clear();
               } // if( kTRUE == fHitTemp.IsTimeSet() )
            }
               else
               {
                  // Leading edge
                  // clear anyway as time ordered, worst case there was another leading edge
                  // whose trailing edge is missing
                  (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).Clear();
                  (ROC[uRocId].fHitTemp24[uGet4Id][ucChan]).SetTime24Bits(
                        (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild])[uMessageIndex] );
               }
         } // else of if( kTRUE == (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bOlderBuffer])[uMessageIndex].Is32Bit() )
   } // for loop over older buffer = full epoch one
   
   // Erase all messages until last accepted one
   // This can be done only if we don't mix event (always strictly consecutive events)
   
   if( kFALSE == fParam->bAllowEventMixing)
      (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild]).erase(
         (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild]).begin(),
         (ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild]).begin() + uLastAcceptedMessageIndex );
         
   /*
   cout<<"Building hits, size old = "<<(ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bBufferToBuild]).size()<<" (buffer "<<bBufferToBuild<<" )";
   cout<<" size new = "<<(ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][bCurrentBuffer]).size()<<" (buffer "<<bCurrentBuffer<<" )"<<endl;
   */

   return kTRUE;
}


Bool_t TGet4v1Proc::CheckHit(UInt_t uRocId, UInt_t uGet4Id, Get4v1Hit& hit)
{
   /* TODO FILL ME
    * Check if Get4 Hit matches the current trigger and
    * if yes save it in output event
    */
   Double_t dTimeToTrigger = 0.0;
   Bool_t bSelectedHit = kFALSE;

   if ( 0.0 < fCurrentGet4Event.fdTriggerFullTime[uRocId] )
   {
      dTimeToTrigger = hit.GetHitFullTimeD() - fCurrentGet4Event.fdTriggerFullTime[uRocId];

      fDeltaTriggerTime->Fill( dTimeToTrigger );
      ROC[uRocId].fTrigger_All->Fill( dTimeToTrigger );
      ROC[uRocId].fTrigger_All_100->Fill( dTimeToTrigger );
      ROC[uRocId].fTrigger_All_us->Fill( dTimeToTrigger );
      ROC[uRocId].fTrigger_All_ms->Fill( dTimeToTrigger );
      ROC[uRocId].fTrigger_All_s->Fill( dTimeToTrigger );

      UChar_t uGet4Chan = hit.GetChan();
      ROC[uRocId].fTrigger_Get4Channel[uGet4Id][uGet4Chan]->Fill( dTimeToTrigger );
      ROC[uRocId].fTriggerMs_Get4Channel[uGet4Id][uGet4Chan]->Fill( dTimeToTrigger );
      ROC[uRocId].fTriggerS_Get4Channel[uGet4Id][uGet4Chan]->Fill( dTimeToTrigger );
         

      if( kTRUE == ROC[uRocId].fTriggerWind->Test( dTimeToTrigger) )
      {
         bSelectedHit =kTRUE;
         // Hit is in trigger selection window => add it to the event
         ( ( fCurrentGet4Event.fGet4Boards[uGet4Id] ).fHits[ hit.GetChan() ]).push_back( hit );

         // Count per global time unit in s
         Double_t dSyncTm = hit.GetHitFullTimeD() / 100000000.0;
         ROC[uRocId].fSelectedT[uGet4Id][uGet4Chan]->Fill(( dSyncTm ) * 0.1);

         ROC[uRocId].fAllSelectedT->Fill(( dSyncTm ) * 0.1 );
         // Long duration time distribution (1 min. bin, 10 days length)
         if( kTRUE == fParam->bLongTimeHistos )
            ROC[uRocId].fAllSelLongT->Fill( (dSyncTm * 0.1 ) / 3600 );

         // Filling histos:
         if( 1 == fParam->bTotHistoEnable )
         {
            ROC[uRocId].fTot[uGet4Id][hit.GetChan()]->Fill( hit.GetTot() );
            if( hit.GetTot() < 0)
            {
               cout<<"Negative 24b ToT in Check: "<<hit.GetTot()<<endl;
               (hit.GetTimeMessage()).Print(roc::msg_print_Human);
               (hit.GetTotMessage()).Print(roc::msg_print_Human);
               cout<<endl;
            }
         }
         if( 1 == fParam->bDebugHistoEnable )
         {
            ROC[uRocId].fLeadingFTS[uGet4Id][hit.GetChan()]->Fill( hit.GetHitLeadingFTS() );
            if( kFALSE == hit.Is32Bit() )
               ROC[uRocId].fTrailingFTS[uGet4Id][hit.GetChan()]->Fill( hit.GetHitTrailingFTS() );
         } // if( 1 == fParam->bDebugHistoEnable )
      }
   } // if ( 0.0 < fCurrentGet4Event.fdTriggerFullTime[uRocId])
      else TGo4Log::Error("Trying to check a hit validity while no trigger found for current event");
      
   return bSelectedHit;
}
void TGet4v1Proc::CheckEventClosure()
{
   /* TODO FILL ME
    * Checking if event finiched for all ROCs/GET4s
    * saving it
    */

   // If not trigger yet => no need to check!
   if( kFALSE == fCurrentGet4Event.HasTrigger() )
      return;

   Bool_t bAllFutureEpochsFinished = kTRUE;
   // Check flag indicating the extra epoch after trigger is passed
   for( UInt_t  uRocId =0; uRocId<fParam->numRocs; uRocId++ )
   {
      // do not check for non-used ROC
      if (!fParam->IsActiveRoc(uRocId)) continue;

      if( kFALSE == ROC[uRocId].fbSelectionRocDone )
         bAllFutureEpochsFinished = kFALSE;

      for( UInt_t uGet4 = 0; uGet4 < MAX_GET4_PER_ROC; uGet4++)
      {
         UInt_t uRemappedGet4Index = fParam->RemapGet4Chip(uRocId, uGet4);
         if( kTRUE == fParam->IsValidGet4Chip(uRemappedGet4Index) &&
             kTRUE == fParam->IsActiveGet4Chip(uRemappedGet4Index) )
            if( kFALSE == ROC[uRocId].fbSelectionDone[uGet4] )
               bAllFutureEpochsFinished = kFALSE;
      }
   }

   // extra epoch passed for all => save event
   if( kTRUE == bAllFutureEpochsFinished )
   {
      if( kFALSE == fCurrentGet4Event.IsEmpty() )
      {
         AnalyzeAllGet4Channels( fCurrentGet4Event );
         (fOutputEvent->fEvents).push_back( fCurrentGet4Event );
         for( UInt_t  uRocId =0; uRocId<fParam->numRocs; uRocId++ )
         {
            uNotEmptyEventInsideMbsEvtCount[uRocId]++;
            uNotEmptyRealEventsCount[uRocId]++;
         }
      } // if( kFALSE == fCurrentGet4Event.IsEmpty() )

      fCurrentGet4Event.Clear();
   } // if( kTRUE == bAllFutureEpochsFinished )
}

void TGet4v1Proc::ResetTrigger()
{
   /* TODO FILL ME
    * Trigger resetting => Needed?
    */
}


void TGet4v1Proc::ResetEndOfBuffer()
{
   /* TODO FILL ME
    * Buffer resetting => Needed?
    */
}

/**********************************************************************/
/*
 * This function process the data message when it is a ROC Sync message
 */
Bool_t TGet4v1Proc::ProcessRocSyncMessage( UInt_t uRocId, TGet4v1MessageExtended& extMess )
{
   /*
    * ROC Sync message specific processing
    * TODO: Check on Sync number from current event to avoid
    * multiple events created for same sync when using more than 1 ROC
    */
   UInt_t uSyncId = (extMess.GetRocMessage()).getSyncChNum();
   ULong64_t ulFulltime = extMess.GetFullTime();

   // Recalculate the full Time to take into account also the epoch cycles
   ulFulltime  = (extMess.GetRocMessage()).getMsgFullTime(
                       ROC[uRocId].GetFullEpochNumber( ));
   ulFulltime += ROC[uRocId].GetSuperCycleEpOffset();
   extMess.SetFullTime(ulFulltime);

   if( uSyncId < MAX_SYNC )
   {
      ROC[uRocId].fLastSyncTm[uSyncId] = ulFulltime;
      ROC[uRocId].fLastSyncId[uSyncId] = (extMess.GetRocMessage()).getSyncData();
      /* TODO ?
      if (rocevent)
         rocevent->fLastSyncTm[uSyncId] = ulFulltime;
         */

      // Count per global time unit in s
      ULong64_t ulSyncTm = ulFulltime / 100000000L;
      ROC[uRocId].fSYNCt[uSyncId]->Fill((ulSyncTm % 36000) * 0.1);

      // Long duration time distribution (1 min. bin, 10 days length)
      if( kTRUE == fParam->bLongTimeHistos )
         ROC[uRocId].fSyncLongT[uSyncId]->Fill( (ulSyncTm * 0.1 ) / 3600 );

      if( kFALSE ==  fParam->bFreeStreaming || 0 == fParam->uNbTriggers )
         if( fParam->triggerSignal == (Int_t) (uSyncId + 10) ) // then may use it for new trigger
            ProcessTriggerMessage( uRocId, extMess );
   } // if( uSyncId < MAX_SYNC )
   return kTRUE;
}
/**********************************************************************/
/*
 * This function process the data message when it is a ROC epoch message
 */
Bool_t TGet4v1Proc::ProcessRocEpochMessage( UInt_t uRocId, TGet4v1MessageExtended& extMess )
{
   /*
    * Roc epoch message specific processing
    */
   if( ROC[uRocId].fuCurrEpoch > (extMess.GetRocMessage()).getEpochNumber() )
   {
      ROC[uRocId].fuEpochCycle++;
      TGo4Log::Info("Roc Epoch cycle change: %u", ROC[uRocId].fuEpochCycle);
   }
   ROC[uRocId].fuCurrEpoch = (extMess.GetRocMessage()).getEpochNumber();

   // Recalculate the full Time to take into account also the epoch cycles
   ULong64_t ulFulltime = ((ULong64_t)  ROC[uRocId].GetFullEpochNumber() ) << 14;
   extMess.SetFullTime(ulFulltime);

   // Count per global time unit in s
   ULong64_t ulEpochTm = ulFulltime / 100000000L;
   ROC[uRocId].fEPOCHt->Fill((ulEpochTm % 36000) * 0.1);

   // Long duration time distribution (1 min. bin, 10 days length)
   if( kTRUE == fParam->bLongTimeHistos )
      ROC[uRocId].fEpochLongT->Fill( (ulEpochTm * 0.1 ) / 3600 );

   ROC[uRocId].fDistribEpochs->Fill( ROC[uRocId].fuCurrEpoch );

   if(  kTRUE == fCurrentGet4Event.HasTrigger() && 
       kFALSE == ROC[uRocId].fbSelectionRocDone  )
   {
      Double_t dTimeToTrigger = 0.0;
      dTimeToTrigger = extMess.GetFullTimeD() - fCurrentGet4Event.fdTriggerFullTime[uRocId];
      // If flag is kTRUE: we are at the second epoch since trigger
      // => rest of trigger epoch + 1 full epoch elapsed, enough for ordering issues
      // => close hit selection checks for ROC self message
      // If Epoch is out of the trigger window started on trigger
      // => all hits always contained inside epoch even if not time ordered
      // => No need to look at the next epoch!!!
      if( kTRUE == ROC[uRocId].fbEpochSinceTrigger ||
          kFALSE == ROC[uRocId].fTriggerWind->Test( dTimeToTrigger)  )
      {
         ROC[uRocId].fbSelectionRocDone  = kTRUE;
         ROC[uRocId].fbEpochSinceTrigger = kFALSE;
         CheckEventClosure();
      }
      else ROC[uRocId].fbEpochSinceTrigger = kTRUE;
   } // If selection of hits after trigger detection not over
/*
   // TODO: Maybe necessary?
   // As no empty epoch there after data anymore, try to use ROC epoch as
   // empty epochs... unsafe because of ordering, but epochs with data
   // should anyway have the flag ON and an epoch2 message coming after,
   // thus keeping the ordering containment
   if( kTRUE == fParam->bSuppressedEpochs && kTRUE == fCurrentGet4Event.HasTrigger())
      for( UInt_t uGet4Id = 0; uGet4Id < MAX_GET4_PER_ROC; uGet4Id ++)
         if( kTRUE == fParam->IsActiveGet4Chip(uGet4Id) &&
              0 == ROC[uRocId].fuEpochWithData[uGet4Id] &&
              kFALSE == ROC[uRocId].fbSelectionDone[uGet4Id]  )
         {
            // A trigger is ongoing on this chip!
            if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] )
            {
               // This is the first epoch after the trigger
               // => time to look for the data in the epoch which was
               // ongoing when the trigger was found

               // If we did not process the epoch before the one where the
               // trigger came, we need to initialize the 24 bit temp hits
               if( kFALSE == ROC[uRocId].bLookInPreviousEpoch[uGet4Id] )
                  for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                        (ROC[uRocId].fHitTemp24[uGet4Id][uChan]).Clear();

               BuildHits(uRocId, uGet4Id, ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]);
               if( kFALSE == ROC[uRocId].bLookInNextEpoch[uGet4Id] )
               {
                  ROC[uRocId].fbSelectionDone[uGet4Id] = kTRUE;
                  CheckEventClosure();
               }
               ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] = kTRUE;
            } // if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] )
            else if( kTRUE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] &&
                      kTRUE == ROC[uRocId].bLookInNextEpoch[uGet4Id])
            {
               // This is the second epoch after the trigger and we detected on trigger
               // that the trigger window extend in epoch after the one where trigger
               // was found => time to look for the data in the epoch which just finished
               // and was the one just after the trigger epoch
               BuildHits(uRocId, uGet4Id, ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]);
               ROC[uRocId].fbSelectionDone[uGet4Id] = kTRUE;
               CheckEventClosure();
            } // else if( kTRUE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] && kFALSE == ROC[uRocId].bLookInNextEpoch[uGet4Id])
         } // if chip active and not over
*/
   // Swap the flag indicating which buffer contains currently happening epoch
   ROC[uRocId].fbBufferWithLastFullEpoch = ( kTRUE == ROC[uRocId].fbBufferWithLastFullEpoch ? kFALSE: kTRUE );
   // Clear this buffer (Data more than 1 full epoch old => either already selected or junk)
   ROC[uRocId].fPrevEpochsBuffer[ ROC[uRocId].fbBufferWithLastFullEpoch ].clear();

   return kTRUE;
}
/**********************************************************************/
/*
 * This function process the data message when it is a GET4 epoch message
 */
Bool_t TGet4v1Proc::ProcessGet4EpochMessage( UInt_t uRocId, TGet4v1MessageExtended& extMess )
{
   /*
    * 24bit Get4 epoch message specific processing
    */

   UInt_t uGet4Id(0);

   // Remap the Get4 chip index => Go in Get4 indexing common to all ROCs
   uGet4Id = (extMess.GetRocMessage()).getEpoch2ChipNumber();
   uGet4Id = fParam->RemapGet4Chip( fParam->DefineGet4IndexOffset(uRocId) +  uGet4Id);
   extMess.SetEpoch2ChipNumber(uGet4Id);

   // Check if active chip
   if( kFALSE == fParam->IsValidGet4Chip(uGet4Id) )
   {
       cout << "Error: Bad chip nb in Epoch message = " << uGet4Id << endl;
       cout << " => This message will be skipped!!!! "<<endl;
       return kFALSE;
   }
   if( kFALSE == fParam->IsActiveGet4Chip(uGet4Id) )
   {
      // Masked chip, hopefully on purpose, don't complain & return
      return kFALSE;
   }
   
   if( kTRUE == fCurrentGet4Event.HasTrigger() && kFALSE == ROC[uRocId].fbSelectionDone[uGet4Id]  )
   {
      // A trigger is ongoing on this chip!
      if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] )
      {
         // This is the first epoch after the trigger
         // => time to look for the data in the epoch which was
         // ongoing when the trigger was found
         
         // If we did not process the epoch before the one where the 
         // trigger came, we need to initialize the 24 bit temp hits
         if( kFALSE == ROC[uRocId].bLookInPreviousEpoch[uGet4Id] )
            for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                  (ROC[uRocId].fHitTemp24[uGet4Id][uChan]).Clear();
                  
         BuildHits(uRocId, uGet4Id, ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]);
         if( kFALSE == ROC[uRocId].bLookInNextEpoch[uGet4Id] )
         {
            ROC[uRocId].fbSelectionDone[uGet4Id] = kTRUE;
            CheckEventClosure();
         }
         ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] = kTRUE;
      } // if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] )
      else if( kTRUE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] && 
                kTRUE == ROC[uRocId].bLookInNextEpoch[uGet4Id])
      {
         // This is the second epoch after the trigger and we detected on trigger
         // that the trigger window extend in epoch after the one where trigger
         // was found => time to look for the data in the epoch which just finished
         // and was the one just after the trigger epoch
         BuildHits(uRocId, uGet4Id, ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]);
         ROC[uRocId].fbSelectionDone[uGet4Id] = kTRUE;
         CheckEventClosure();
      } // else if( kTRUE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] && kFALSE == ROC[uRocId].bLookInNextEpoch[uGet4Id])
   } // if( kTRUE == fCurrentGet4Event.HasTrigger() && kFALSE == ROC[uRocId].fbSelectionDone[uGet4Id]  )

   UInt_t get4_24b_ep_epoch = (extMess.GetRocMessage()).getEpoch2Number();
   if( ROC[uRocId].fuCurrEpoch2[uGet4Id] + 1 != get4_24b_ep_epoch &&
       ( 0 < ROC[uRocId].fuCurrEpoch2[uGet4Id] || 0 < ROC[uRocId].fuEpoch2Cycle[uGet4Id] ) &&
       !( GET4_EPOCH_CYCLE_SIZE == ROC[uRocId].fuCurrEpoch2[uGet4Id]  && 0 == get4_24b_ep_epoch ) )
   {
      TGo4Log::Info("Roc Get4 Epoch2 error in 24b mode");
      ROC[uRocId].fEpochShiftsPerChip->Fill( uGet4Id, (Int_t)get4_24b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[uGet4Id]+1) );

      // Correction attempt: just calculating, not using it
      if( (Int_t)get4_24b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[uGet4Id]+1) < 10 )
      {
         // close epochs ( < 250us) => probable not a full event missing
         if( 0 != ROC[uRocId].fiEpochShift[uGet4Id])
            ROC[uRocId].fEpochShiftsDuration[uGet4Id]->Fill(ROC[uRocId].fiEpochShift[uGet4Id],
                  ROC[uRocId].fuNbShiftedEpochs[uGet4Id] );
         ROC[uRocId].fiEpochShift[uGet4Id] += (Int_t)get4_24b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[uGet4Id]+1) ;
         ROC[uRocId].fuNbShiftedEpochs[uGet4Id] = 0;
      }
         else
         {
            // far epochs ( > 250us) => probable a full event is missing
            if( 0 != ROC[uRocId].fiEpochShift[uGet4Id])
               ROC[uRocId].fEpochShiftsDuration[uGet4Id]->Fill(ROC[uRocId].fiEpochShift[uGet4Id],
                     ROC[uRocId].fuNbShiftedEpochs[uGet4Id] );
            ROC[uRocId].fiEpochShift[uGet4Id]      = 0 ;
            ROC[uRocId].fuNbShiftedEpochs[uGet4Id] = 0;
         }
   } // if non consecutive epoch indexes
      else
      {
         if( 0 != ROC[uRocId].fiEpochShift[uGet4Id] )
            ROC[uRocId].fuNbShiftedEpochs[uGet4Id]++;
      } // else of if non consecutive epoch indexes

   // Event statistics
   ROC[uRocId].fuNbHitsChipEpoch[uGet4Id] = 0;

   if( ROC[uRocId].fuCurrEpoch2[uGet4Id] > get4_24b_ep_epoch )
   {
      TGo4Log::Info("Roc Epoch2 cycle (24b mode) change: %u", ROC[uRocId].fuEpoch2Cycle);
      ROC[uRocId].fuEpoch2Cycle[uGet4Id]++;
   }
   ROC[uRocId].fuCurrEpoch2[uGet4Id] = get4_24b_ep_epoch;

   // In case of suppressed epochs, we will have only chip 0 epochs for all empty epochs
   // We then use these epochs for all other active chips
   // However, when a chip has data, its next epoch message should be present!!!
   if( kTRUE == fParam->bSuppressedEpochs )
   {
      // Assume Chip 0 are always there, even if disabled
      // TODO: test this and at some other behavior if needed
      if( 0 == uGet4Id )
         for( UInt_t uGet4IdBis = uGet4Id + 1; uGet4IdBis < MAX_GET4_PER_ROC; uGet4IdBis ++)
            if( kTRUE == fParam->IsActiveGet4Chip(uGet4IdBis) )
            {
               // In case no data was found in previous epoch for this chip, we use the epoch info
               // from chip 0
               if( 0 == ROC[uRocId].fuEpochWithData[uGet4IdBis])
               {
                  if( ROC[uRocId].fuCurrEpoch2[uGet4IdBis] + 1 != get4_24b_ep_epoch &&
                      ( 0 < ROC[uRocId].fuCurrEpoch2[uGet4IdBis] || 0 < ROC[uRocId].fuEpoch2Cycle[uGet4IdBis] ) &&
                      !( GET4_EPOCH_CYCLE_SIZE == ROC[uRocId].fuCurrEpoch2[uGet4IdBis]  && 0 == get4_24b_ep_epoch ) )
                  {
                     TGo4Log::Info("Roc Get4 Epoch2 error in 24b mode");
                     ROC[uRocId].fEpochShiftsPerChip->Fill( uGet4IdBis, (Int_t)get4_24b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[uGet4IdBis]+1) );

                     // Correction attempt: just calculating, not using it
                     if( (Int_t)get4_24b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[uGet4IdBis]+1) < 10 )
                     {
                        // close epochs ( < 250us) => probable not a full event missing
                        if( 0 != ROC[uRocId].fiEpochShift[uGet4IdBis])
                           ROC[uRocId].fEpochShiftsDuration[uGet4IdBis]->Fill(ROC[uRocId].fiEpochShift[uGet4IdBis],
                                 ROC[uRocId].fuNbShiftedEpochs[uGet4IdBis] );
                        ROC[uRocId].fiEpochShift[uGet4IdBis] += (Int_t)get4_24b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[uGet4IdBis]+1) ;
                        ROC[uRocId].fuNbShiftedEpochs[uGet4IdBis] = 0;
                     }
                        else
                        {
                           // far epochs ( > 250us) => probable a full event is missing
                           if( 0 != ROC[uRocId].fiEpochShift[uGet4IdBis])
                              ROC[uRocId].fEpochShiftsDuration[uGet4IdBis]->Fill(ROC[uRocId].fiEpochShift[uGet4IdBis],
                                    ROC[uRocId].fuNbShiftedEpochs[uGet4IdBis] );
                           ROC[uRocId].fiEpochShift[uGet4IdBis]      = 0 ;
                           ROC[uRocId].fuNbShiftedEpochs[uGet4IdBis] = 0;
                        }
                  } // if non consecutive epoch indexes
                     else
                     {
                        if( 0 != ROC[uRocId].fiEpochShift[uGet4IdBis] )
                           ROC[uRocId].fuNbShiftedEpochs[uGet4IdBis]++;
                     } // else of if non consecutive epoch indexes

                  // Event statistics
                  ROC[uRocId].fuNbHitsChipEpoch[uGet4IdBis] = 0;

                  if( ROC[uRocId].fuCurrEpoch2[uGet4IdBis] > get4_24b_ep_epoch )
                  {
                     TGo4Log::Info("Roc Epoch2 cycle (24b mode) change: %u", ROC[uRocId].fuEpoch2Cycle);
                     ROC[uRocId].fuEpoch2Cycle[uGet4IdBis]++;
                  }
                  ROC[uRocId].fuCurrEpoch2[uGet4IdBis] = get4_24b_ep_epoch;
               } // if( 0 == ROC[uRocId].fuEpochWithData[uGet4IdBis])
                  // If data just increase the flag, should not hurt,
                  // just in case the epoch messages are not always coming ordered the way I expect
                  else ROC[uRocId].fuEpochWithData[uGet4IdBis]++;
            } // if( kTRUE == fParam->IsActiveGet4Chip(uGet4IdBis) )

      ROC[uRocId].fuEpochWithData[uGet4Id] = 0;
   } // if( kTRUE == fParam->bSuppressedEpochs)

   // Recalculate the full Time to take into account also the epoch2 cycles
   ULong64_t uFullTimeBins = ((ULong64_t)  ROC[uRocId].GetFullEpoch2Number( uGet4Id )) << 19;
   ULong64_t uFullTime = uFullTimeBins/ 20 + 512;
   Double_t  dFullTime = uFullTimeBins / 20. + 512.;
   extMess.SetFullTime(  uFullTime );
   extMess.SetFullTimeD( dFullTime );
   
   // Set The ROC epoch2 counter and cycle counter
   extMess.SetRocEpoch( ROC[uRocId].fuCurrEpoch2[uGet4Id] );
   extMess.SetRocCycle( ROC[uRocId].fuEpoch2Cycle[uGet4Id] );

   // Count per global time unit in s
   ULong64_t ulEpochTm = uFullTime / 100000000L;
   ROC[uRocId].fEPOCH2t[uGet4Id]->Fill((ulEpochTm % 36000) * 0.1);

   // Long duration time distribution (1 min. bin, 10 days length)
   if( kTRUE == fParam->bLongTimeHistos )
      ROC[uRocId].fAllEpoch2LongT->Fill( (ulEpochTm * 0.1 ) / 3600 );

   ROC[uRocId].fDistribEpochs2->Fill(uGet4Id, ROC[uRocId].fuCurrEpoch2[uGet4Id]);
   
   // Swap the flag indicating which buffer contains currently happening epoch
   ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id] = ( kTRUE == ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id] ? kFALSE: kTRUE );
   // Clear this buffer (Data more than 1 full epoch old => either already selected or junk)
   ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][ ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id] ].clear();

   return kTRUE;
}
/**********************************************************************/
/*
 * This function process the data message when it is a GET4 data message
 */
Bool_t TGet4v1Proc::ProcessGet4DataMessage( UInt_t uRocId, TGet4v1MessageExtended& extMess )
{
   /*
    * 24bit Get4 hit message specific processing
    *
    * TODO
    * Make the get4_index consistent everywhere between global get4 index and inside roc get4 index
    */

   if (ROC[uRocId].bIgnoreData) return kFALSE;

   if( kFALSE == ROC[uRocId].fb24bitsReadoutDetected )
   {
      ROC[uRocId].fb24bitsReadoutDetected = kTRUE;
      fb24bitsReadoutDetected = kTRUE;
      // As it is first 24bit message, let's create
      // 24bit specific histograms
      char folder[30];
      sprintf(folder,"ROC%u/",uRocId);

      /*
       * 24 bits specific histograms
       */
      ROC[uRocId].fChannelInputMessCount = MakeTH1( 'I', Form("%sRoc%u_ChanCounts", folder, uRocId),
            "Channel multiplicity per event",
            2*NB_CHAN_GET4*MAX_GET4_PER_ROC, 0, MAX_GET4_PER_ROC ,
            "Channel []", "# Mess []" );
      ROC[uRocId].fb24bitsReadoutDetected = kTRUE;
   } // if( kFALSE == ROC[uRocId].fb24bitsReadoutDetected )

   UInt_t    uGet4Id(0), uGet4Ch(0), uGet4Edge(0);
   uGet4Id   = (extMess.GetRocMessage()).getGet4Number();
   uGet4Ch   = (extMess.GetRocMessage()).getGet4ChNum();
   uGet4Edge = (extMess.GetRocMessage()).getGet4Edge();

   // Remap the Get4 chip index
   uGet4Id = (extMess.GetRocMessage()).getGet4Number();
   uGet4Id = fParam->RemapGet4Chip( fParam->DefineGet4IndexOffset(uRocId) + uGet4Id);
   extMess.SetGet4Number(uGet4Id);

   // Check if valid chip
   if( kFALSE == fParam->IsValidGet4Chip(uGet4Id) )
   {
       cout << "Error: Bad chip nb in Data message = " << uGet4Id << endl;
       cout << " => This message will be skipped!!!! "<<endl;
       return kFALSE;
   }
   if( kFALSE == fParam->IsActiveGet4Chip(uGet4Id) )
   {
      // Masked chip, hopefully on purpose, don't complain & return
      return kFALSE;
   }

   // Recalculate the full Time to take into account also the epoch2 cycles
   ULong64_t uFullTimeBins = ((ULong64_t)  ROC[uRocId].GetFullEpoch2Number( uGet4Id ) << 19) |
                              (ULong64_t)extMess.GetGet4Ts();
   ULong64_t uFullTime = uFullTimeBins/ 20 + 512;
   Double_t  dFullTime = ((Double_t)uFullTimeBins)*0.05 + 512.;
   extMess.SetFullTime(  uFullTime );
   extMess.SetFullTimeD( dFullTime );
   
   // Set The ROC epoch2 counter and cycle counter
   extMess.SetRocEpoch( ROC[uRocId].fuCurrEpoch2[uGet4Id] );
   extMess.SetRocCycle( ROC[uRocId].fuEpoch2Cycle[uGet4Id] );
   

   // Count per global time unit in s
   ULong64_t ulDataTm = uFullTime / 100000000L;
   ROC[uRocId].fDATAt->Fill((ulDataTm % 36000) * 0.1);

   // Long duration time distribution (1 min. bin, 10 days length)
   if( kTRUE == fParam->bLongTimeHistos )
      ROC[uRocId].fDataLongT->Fill( (ulDataTm * 0.1 ) / 3600 );

   // Event statistics
   ROC[uRocId].fChannelInputMessCount->Fill( uGet4Id + (Double_t)uGet4Ch/(Double_t)NB_CHAN_GET4
                                                     + (Double_t)uGet4Edge/(Double_t)(2*NB_CHAN_GET4)  );
   if( kTRUE == fParam->bChipRateHistoEnable )
      ROC[uRocId].fChipRateEvolution[uGet4Id]->Fill(
            (uFullTimeBins ) * 0.1, 1.0/ROC[uRocId].fdRateEvolutionBinSize );
   if( kTRUE == fParam->bChannelRateHistoEnable )
      ROC[uRocId].fChannelRateEvolution[uGet4Id][uGet4Ch]->Fill(
            (uFullTimeBins ) * 0.1, 1.0/ROC[uRocId].fdRateEvolutionBinSize );
   ROC[uRocId].fuNbHitsChipEpoch[uGet4Id] ++;

   // Early event closure check
   if( kTRUE == fCurrentGet4Event.HasTrigger() &&
       kFALSE == ROC[uRocId].fbSelectionDone[uGet4Id]  )
   {
      Double_t dTimeToTrigger = 0.0;
      dTimeToTrigger = extMess.GetFullTimeD() - fCurrentGet4Event.fdTriggerFullTime[uRocId];
      if( kFALSE == ROC[uRocId].fTriggerWind->Test( dTimeToTrigger) )
      {
         // Message after the end of trigger window!!
         Bool_t bAllChanInChipOver = kTRUE;

         // If there was already a message from the same channel & edge out of the trigger
         //  window, then the token ring made at least one full turn => ok for all
         // Otherwise: need to check other channels/edge status
         if( (kFALSE == ROC[uRocId].fbDataTimeOut[uGet4Id][uGet4Ch] && 0 == uGet4Edge ) ||
             (kFALSE == ROC[uRocId].fbDataFallingOut[uGet4Id][uGet4Ch] && 1 == uGet4Edge ) )
         {
            // 24b = always a edge not a hit => need to check both !
            if( 0 == uGet4Edge )
               ROC[uRocId].fbDataTimeOut[uGet4Id][uGet4Ch] = kTRUE;
               else ROC[uRocId].fbDataFallingOut[uGet4Id][uGet4Ch] = kTRUE;
            // Check if chip fully finished
            for(UInt_t uChanTest = 0; uChanTest < NB_CHAN_GET4; uChanTest ++)
            {
               if( kFALSE ==  ROC[uRocId].fbDataTimeOut[uGet4Id][uChanTest] )
                  bAllChanInChipOver = kFALSE;
               if( kFALSE ==  ROC[uRocId].fbDataFallingOut[uGet4Id][uChanTest] )
                  bAllChanInChipOver = kFALSE;
            }
         } // if same edge not already out of trigger once

         // If chip fully finished: don't wait for the next epoch to close future buffer
         // of current event for this chip
         if( kTRUE == bAllChanInChipOver)
         {
            // If This is the first epoch after the trigger and 
            // we did not process the epoch before the one where the 
            // trigger came, we need to initialize the 24 bit temp hits
            if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] && 
                kFALSE == ROC[uRocId].bLookInPreviousEpoch[uGet4Id] )
               for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                     (ROC[uRocId].fHitTemp24[uGet4Id][uChan]).Clear();
                     
            BuildHits(uRocId, uGet4Id, ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]);
            ROC[uRocId].fbSelectionDone[uGet4Id] = kTRUE;
            CheckEventClosure();
            
            for(UInt_t uChanTest = 0; uChanTest < NB_CHAN_GET4; uChanTest ++)
            {
               ROC[uRocId].fbDataTimeOut[uGet4Id][uChanTest] = kFALSE;
               ROC[uRocId].fbDataFallingOut[uGet4Id][uChanTest] = kFALSE;
            }
         } // if( kTRUE == bAllChanInChipOver)
      } // if( kFALSE == ROC[uRocId].fTriggerWind->Test( dTimeToTrigger) )
   } // Event ongoing with a detected trigger and chip did not finished all its buffers

   if( kTRUE ==  fParam->bFreeStreaming && 0 < fParam->uNbTriggers )
   {
      if( 0 == uGet4Edge )
      {
         for( Int_t iMainTriggerIndex = 0; iMainTriggerIndex < (Int_t)(fParam->uNbTriggers); iMainTriggerIndex++ )
            if( kTRUE == fParam->IsMainOfThisTrigger( iMainTriggerIndex, uGet4Id, uGet4Ch ) )
         {
            ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex] = extMess;
            /*
             * TODO: call to ProcessTrigger
             * TEMP: histo Filling + counting
             */
            Bool_t bAllInCoinc = kTRUE;
            for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)
            {
               Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iMainTriggerIndex][uSecChannel]
                                        - extMess.GetFullTimeD();
               if( dDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                     fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dDistanceToMain      )
               {
                  bAllInCoinc = kFALSE;
                  break;
               } // if out of coincidence window
               Double_t dTotDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannelTot[iMainTriggerIndex][uSecChannel]
                                        - extMess.GetFullTimeD();
               if( dTotDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                     fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dTotDistanceToMain      )
               {
                  bAllInCoinc = kFALSE;
                  break;
               } // if out of coincidence window
            } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)
            
            // Check if tot edge of the main channel is in trigger window
            Double_t dTotMainDistanceToMain = ROC[uRocId].fdLastFullTimeMainChannelTot[iMainTriggerIndex]
                              - ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();
            if( dTotMainDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                  fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dTotMainDistanceToMain      )
            {
               bAllInCoinc = kFALSE;
            } // if out of coincidence window
            
            if( kTRUE == bAllInCoinc )
            {
               Double_t dSameTriggerDistance =
                       ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD()
                     - ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] ;

               ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iMainTriggerIndex );
               ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iMainTriggerIndex );
               ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iMainTriggerIndex );
               ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iMainTriggerIndex );

               if( fParam->dDeadTime <= dSameTriggerDistance )
               {
                  // Here we have a DATA self-trigger!!!!!!
                  ROC[uRocId].fuDataSelfTriggerCount[iMainTriggerIndex] ++;

                  ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] =
                        ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();

                  ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTime();
                  uFullTimeSelfTrigBins /= 100000000L;
                  ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );
                  
                  // Long duration time distribution (1 min. bin, 10 days length)
                  if( kTRUE == fParam->bLongTimeHistos )
                     ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                  ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex], iMainTriggerIndex);
               } // if( fParam->dDeadTime <= dSameTriggerDistance )
            } // if( kTRUE == bAllInCoinc )
         } // if( -1 < iMainTriggerIndex )

         for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
         {
            if( kTRUE == fParam->IsSecOfThisTrigger( iSecTriggerIndex, uGet4Id, uGet4Ch ) )
            {
               Int_t iSecondaryIndex = fParam->GetSecChannelIndex(iSecTriggerIndex, uGet4Id, uGet4Ch);
               if( -1 < iSecondaryIndex )
               {
                  ROC[uRocId].fdLastFullTimeSecChannel[iSecTriggerIndex][iSecondaryIndex] = extMess.GetFullTimeD();

                  /*
                   * TODO: call to ProcessTrigger
                   * TEMP: histo Filling + counting
                   */
                  Bool_t bAllInCoinc = kTRUE;
                  for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)
                  {
                     Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iSecTriggerIndex][uSecChannel]
                                       - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                     if( dDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                           fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dDistanceToMain      )
                     {
                        bAllInCoinc = kFALSE;
                        break;
                     } // if out of coincidence window
                        
                     // Check if tot edge is in trigger window, only needed in 24b mode
                     Double_t dTotDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannelTot[iSecTriggerIndex][uSecChannel]
                                       - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                     if( dTotDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                           fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dTotDistanceToMain      )
                     {
                        bAllInCoinc = kFALSE;
                        break;
                     } // if out of coincidence window
                  } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)
                     
                  // Check if tot edge of the main channel is in trigger window, only needed in 24b mode
                  Double_t dTotMainDistanceToMain = ROC[uRocId].fdLastFullTimeMainChannelTot[iSecTriggerIndex]
                                    - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                  if( dTotMainDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                        fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dTotMainDistanceToMain      )
                  {
                     bAllInCoinc = kFALSE;
                  } // if out of coincidence window
                     
                  if( kTRUE == bAllInCoinc  )
                  {
                     Double_t dSameTriggerDistance =
                             ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD()
                           - ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] ;

                     ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iSecTriggerIndex );
                     ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iSecTriggerIndex );
                     ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iSecTriggerIndex );
                     ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iSecTriggerIndex );

                     if( fParam->dDeadTime <= dSameTriggerDistance )
                     {
                        // Here we have a DATA self-trigger!!!!!!
                        ROC[uRocId].fuDataSelfTriggerCount[iSecTriggerIndex] ++;

                        ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] =
                              ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();

                        ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTime();
                        uFullTimeSelfTrigBins /= 100000000L;
                        ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                        // Long duration time distribution (1 min. bin, 10 days length)
                        if( kTRUE == fParam->bLongTimeHistos )
                           ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                        ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex], iSecTriggerIndex);
                     } // if( fParam->dDeadTime <= dSameTriggerDistance )
                  } // if( kTRUE == bAllInCoinc  )
               } // if( -1 < iSecondaryIndex )
            } //  if( -1 < iSecTriggerIndex )
         } // for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
      }// if( 0 == uGet4Edge )
         else
         {
            // Falling edge
            for( Int_t iMainTriggerIndex = 0; iMainTriggerIndex < (Int_t)(fParam->uNbTriggers); iMainTriggerIndex++ )
               if( kTRUE == fParam->IsMainOfThisTrigger( iMainTriggerIndex, uGet4Id, uGet4Ch ) )
            {
               ROC[uRocId].fdLastFullTimeMainChannelTot[iMainTriggerIndex] = extMess.GetFullTimeD();
                     
               Bool_t bAllInCoinc = kTRUE;
               for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)
               {
                  // Check if time edge is in trigger window
                  Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iMainTriggerIndex][uSecChannel]
                                    - ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();
                  if( dDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                        fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dDistanceToMain      )
                  {
                     bAllInCoinc = kFALSE;
                     break;
                  } // if out of coincidence window
                  
                  // Check if tot edge is in trigger window, only needed in 24b mode
                  Double_t dTotDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannelTot[iMainTriggerIndex][uSecChannel]
                                    - ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();
                  if( dTotDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                        fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dTotDistanceToMain      )
                  {
                     bAllInCoinc = kFALSE;
                     break;
                  } // if out of coincidence window
               } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)
               
               // Check if tot edge of the main channel is in trigger window, only needed in 24b mode
               Double_t dTotMainDistanceToMain = ROC[uRocId].fdLastFullTimeMainChannelTot[iMainTriggerIndex]
                                 - ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();
               if( dTotMainDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                     fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dTotMainDistanceToMain      )
               {
                  bAllInCoinc = kFALSE;
               } // if out of coincidence window
               
               if( kTRUE == bAllInCoinc  )
               {
                  Double_t dSameTriggerDistance =
                          ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD()
                        - ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] ;

                  ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iMainTriggerIndex );

                  if( fParam->dDeadTime <= dSameTriggerDistance )
                  {
                     // Here we have a DATA self-trigger!!!!!!
                     ROC[uRocId].fuDataSelfTriggerCount[iMainTriggerIndex] ++;

                     ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] =
                           ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();

                     ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTime();
                     uFullTimeSelfTrigBins /= 100000000L;
                     ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                     // Long duration time distribution (1 min. bin, 10 days length)
                     if( kTRUE == fParam->bLongTimeHistos )
                        ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                     ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex], iMainTriggerIndex);
                  } // if( fParam->dDeadTime <= dSameTriggerDistance )
               } // if( kTRUE == bAllInCoinc  )
            } // if( kTRUE == fParam->IsMainOfThisTrigger( iMainTriggerIndex, uGet4Id, uGet4Ch ) )
            
            for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
            {
               if( kTRUE == fParam->IsSecOfThisTrigger( iSecTriggerIndex, uGet4Id, uGet4Ch ) )
               {
                  Int_t iSecondaryIndex = fParam->GetSecChannelIndex(iSecTriggerIndex, uGet4Id, uGet4Ch);
                  if( -1 < iSecondaryIndex )
                  {
                     ROC[uRocId].fdLastFullTimeSecChannelTot[iSecTriggerIndex][iSecondaryIndex] = extMess.GetFullTimeD();
                     
                     Bool_t bAllInCoinc = kTRUE;
                     for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)
                     {
                        // Check if time edge is in trigger window
                        Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iSecTriggerIndex][uSecChannel]
                                          - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                        if( dDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                              fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dDistanceToMain      )
                        {
                           bAllInCoinc = kFALSE;
                           break;
                        } // if out of coincidence window
                        
                        // Check if tot edge is in trigger window
                        Double_t dTotDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannelTot[iSecTriggerIndex][uSecChannel]
                                          - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                        if( dTotDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                              fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dTotDistanceToMain      )
                        {
                           bAllInCoinc = kFALSE;
                           break;
                        } // if out of coincidence window
                     } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)
                     
                     // Check if tot edge of the main channel is in trigger window
                     Double_t dTotMainDistanceToMain = ROC[uRocId].fdLastFullTimeMainChannelTot[iSecTriggerIndex]
                                       - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                     if( dTotMainDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                           fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dTotMainDistanceToMain      )
                     {
                        bAllInCoinc = kFALSE;
                     } // if out of coincidence window
                     
                     if( kTRUE == bAllInCoinc  )
                     {
                        Double_t dSameTriggerDistance =
                                ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD()
                              - ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] ;

                        ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iSecTriggerIndex );
                        ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iSecTriggerIndex );
                        ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iSecTriggerIndex );
                        ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iSecTriggerIndex );

                        if( fParam->dDeadTime <= dSameTriggerDistance )
                        {
                           // Here we have a DATA self-trigger!!!!!!
                           ROC[uRocId].fuDataSelfTriggerCount[iSecTriggerIndex] ++;

                           ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] =
                                 ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();

                           ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTime();
                           uFullTimeSelfTrigBins /= 100000000L;
                           ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                           // Long duration time distribution (1 min. bin, 10 days length)
                           if( kTRUE == fParam->bLongTimeHistos )
                              ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                           ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex], iSecTriggerIndex);
                        } // if( fParam->dDeadTime <= dSameTriggerDistance )
                     } // if( kTRUE == bAllInCoinc  )
                  } // if( -1 < iSecondaryIndex )
               } // if( kTRUE == fParam->IsSecOfThisTrigger( iSecTriggerIndex, uGet4Id, uGet4Ch ) )
            } // for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
         } // else if( 0 == uGet4Edge )
   } // if( kTRUE ==  fParam->bFreeStreaming && 0 < fParam->uNbTriggers && 0 == uGet4Edge )

   return kTRUE;
}
/**********************************************************************/
/*
 * This function process the data message when it is a GET4 External Synch
 */
Bool_t TGet4v1Proc::ProcessGet4ExtSyncMessage( UInt_t uRocId, TGet4v1MessageExtended& extMess )
{
   /* TODO FILL ME
    * 24bit Get4 external sync message specific processing
    */
   return kTRUE;
}
/**********************************************************************/
/*
 * This function process the data message when it is a GET4 epoch message
 * In suppressed empty epochs 2 mode
 */
Bool_t TGet4v1Proc::ProcessGet4SuppEpochMessage( UInt_t uRocId, TGet4v1MessageExtended& extMess )
{
   /*
    * 24bit Get4 epoch message specific processing
    */

   UInt_t uGet4Id(0);

   // Remap the Get4 chip index => Go in Get4 indexing common to all ROCs
   uGet4Id = (extMess.GetRocMessage()).getEpoch2ChipNumber();
   uGet4Id = fParam->RemapGet4Chip( fParam->DefineGet4IndexOffset(uRocId) +  uGet4Id);
   extMess.SetEpoch2ChipNumber(uGet4Id);

   // Check if active chip
   if( kFALSE == fParam->IsValidGet4Chip(uGet4Id) )
   {
       cout << "Error: Bad chip nb in Epoch message = " << uGet4Id << endl;
       cout << " => This message will be skipped!!!! "<<endl;
       return kFALSE;
   }
   if( kFALSE == fParam->IsActiveGet4Chip(uGet4Id) )
   {
      // Masked chip, hopefully on purpose, don't complain & return
      return kFALSE;
   }

   UInt_t get4_24b_ep_epoch = (extMess.GetRocMessage()).getEpoch2Number();
   // No "non-consecutive epoch check" as in this mode they are by definition non consecutive

   // Event statistics
   ROC[uRocId].fuNbHitsChipEpoch[uGet4Id] = 0;

   if( ROC[uRocId].fuCurrEpoch2[uGet4Id] > get4_24b_ep_epoch )
   {
      TGo4Log::Info("Roc Epoch2 cycle (24b mode) change: %u", ROC[uRocId].fuEpoch2Cycle);
      ROC[uRocId].fuEpoch2Cycle[uGet4Id]++;
   }
   ROC[uRocId].fuCurrEpoch2[uGet4Id] = get4_24b_ep_epoch;

   // Reprocess all data messages which where waiting for their epoch
   if( 1 == ROC[uRocId].fuEpochWithData[uGet4Id] )
   {
      ProcessGet4ReprocessSuppData( uRocId, uGet4Id );
      ROC[uRocId].fuEpochWithData[uGet4Id] = 0;
   }

   // Self triggering
   if( kTRUE == fCurrentGet4Event.HasTrigger() && kFALSE == ROC[uRocId].fbSelectionDone[uGet4Id]  )
   {
      // A trigger is ongoing on this chip!
      if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] )
      {
         // This is the first epoch after the trigger
         // => time to look for the data in the epoch which was
         // ongoing when the trigger was found

         // If we did not process the epoch before the one where the
         // trigger came, we need to initialize the 24 bit temp hits
         if( kFALSE == ROC[uRocId].bLookInPreviousEpoch[uGet4Id] )
            for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                  (ROC[uRocId].fHitTemp24[uGet4Id][uChan]).Clear();

         BuildHits(uRocId, uGet4Id, ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]);
         if( kFALSE == ROC[uRocId].bLookInNextEpoch[uGet4Id] )
         {
            ROC[uRocId].fbSelectionDone[uGet4Id] = kTRUE;
            CheckEventClosure();
         }
         ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] = kTRUE;
      } // if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] )
      else if( kTRUE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] &&
                kTRUE == ROC[uRocId].bLookInNextEpoch[uGet4Id])
      {
         // This is the second epoch after the trigger and we detected on trigger
         // that the trigger window extend in epoch after the one where trigger
         // was found => time to look for the data in the epoch which just finished
         // and was the one just after the trigger epoch
         BuildHits(uRocId, uGet4Id, ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]);
         ROC[uRocId].fbSelectionDone[uGet4Id] = kTRUE;
         CheckEventClosure();
      } // else if( kTRUE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] && kFALSE == ROC[uRocId].bLookInNextEpoch[uGet4Id])
   } // if( kTRUE == fCurrentGet4Event.HasTrigger() && kFALSE == ROC[uRocId].fbSelectionDone[uGet4Id]  )

   // Recalculate the full Time to take into account also the epoch2 cycles
   ULong64_t uFullTimeBins = ((ULong64_t)  ROC[uRocId].GetFullEpoch2Number( uGet4Id )) << 19;
   ULong64_t uFullTime = uFullTimeBins/ 20 + 512;
   Double_t  dFullTime = uFullTimeBins / 20. + 512.;
   extMess.SetFullTime(  uFullTime );
   extMess.SetFullTimeD( dFullTime );

   // Set The ROC epoch2 counter and cycle counter
   extMess.SetRocEpoch( ROC[uRocId].fuCurrEpoch2[uGet4Id] );
   extMess.SetRocCycle( ROC[uRocId].fuEpoch2Cycle[uGet4Id] );

   // Count per global time unit in s
   ULong64_t ulEpochTm = uFullTime / 100000000L;
   ROC[uRocId].fEPOCH2t[uGet4Id]->Fill((ulEpochTm % 36000) * 0.1);

   // Long duration time distribution (1 min. bin, 10 days length)
   if( kTRUE == fParam->bLongTimeHistos )
      ROC[uRocId].fAllEpoch2LongT->Fill( (ulEpochTm * 0.1 ) / 3600 );

   ROC[uRocId].fDistribEpochs2->Fill(uGet4Id, ROC[uRocId].fuCurrEpoch2[uGet4Id]);

   // Swap the flag indicating which buffer contains currently happening epoch
   ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id] = ( kTRUE == ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id] ? kFALSE: kTRUE );
   // Clear this buffer (Data more than 1 full epoch old => either already selected or junk)
   ROC[uRocId].fPrevEpochs2Buffer[uGet4Id][ ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id] ].clear();

   return kTRUE;
}
/**********************************************************************/
/*
 * This function process the data message when it is a GET4 data message
 */
Bool_t TGet4v1Proc::ProcessGet4SuppDataMessage( UInt_t uRocId, TGet4v1MessageExtended& extMess )
{
   /*
    * 24bit Get4 hit message specific processing
    * In case of suppressed epochs, we will have no epoch2 message for all empty epochs
    * However, when a chip has data, its next epoch message should be present!!!
    * => need a flag to use the proper epoch message when its the case
    *
    * TODO
    * Make the get4_index consistent everywhere between global get4 index and inside roc get4 index
    */

   if (ROC[uRocId].bIgnoreData) return kFALSE;

   if( kFALSE == ROC[uRocId].fb24bitsReadoutDetected )
   {
      ROC[uRocId].fb24bitsReadoutDetected = kTRUE;
      fb24bitsReadoutDetected = kTRUE;
      // As it is first 24bit message, let's create
      // 24bit specific histograms
      char folder[30];
      sprintf(folder,"ROC%u/",uRocId);

      /*
       * 24 bits specific histograms
       */
      ROC[uRocId].fChannelInputMessCount = MakeTH1( 'I', Form("%sRoc%u_ChanCounts", folder, uRocId),
            "Channel multiplicity per event",
            2*NB_CHAN_GET4*MAX_GET4_PER_ROC, 0, MAX_GET4_PER_ROC ,
            "Channel []", "# Mess []" );
      ROC[uRocId].fb24bitsReadoutDetected = kTRUE;
   } // if( kFALSE == ROC[uRocId].fb24bitsReadoutDetected )

   UInt_t    uGet4Id(0), uGet4Ch(0), uGet4Edge(0);
   uGet4Id   = (extMess.GetRocMessage()).getGet4Number();
   uGet4Ch   = (extMess.GetRocMessage()).getGet4ChNum();
   uGet4Edge = (extMess.GetRocMessage()).getGet4Edge();

   // Remap the Get4 chip index
   uGet4Id = (extMess.GetRocMessage()).getGet4Number();
   uGet4Id = fParam->RemapGet4Chip( fParam->DefineGet4IndexOffset(uRocId) + uGet4Id);
   extMess.SetGet4Number(uGet4Id);

   // Check if valid chip
   if( kFALSE == fParam->IsValidGet4Chip(uGet4Id) )
   {
       cout << "Error: Bad chip nb in Data message = " << uGet4Id << endl;
       cout << " => This message will be skipped!!!! "<<endl;
       return kFALSE;
   }
   if( kFALSE == fParam->IsActiveGet4Chip(uGet4Id) )
   {
      // Masked chip, hopefully on purpose, don't complain & return
      return kFALSE;
   }

   // => need a flag to use the proper epoch message when its the case
   ROC[uRocId].fuEpochWithData[uGet4Id] = 1;

   // Store data message in temporary buffer to wait for the next epoch message
   ROC[uRocId].fEpSuppBuffer[uGet4Id].push_back( extMess );

   return kTRUE;
}

/**********************************************************************/
/*
 * This function reprocess the data message from a GET4 in empty epoch suppression
 * mode once its next epoch message is found
 */
Bool_t TGet4v1Proc::ProcessGet4ReprocessSuppData( UInt_t uRocId, UInt_t uGet4Id )
{
   /*
    * 24bit Get4 hit message specific processing
    * In case of suppressed epochs, we will have no epoch2 message for all empty epochs
    * However, when a chip has data, its next epoch message should be present just after all data!!!
    * => there should not be more than 1 epoch waiting time before reprocessing
    *
    * TODO
    * Make the get4_index consistent everywhere between global get4 index and inside roc get4 index
    */
   // Loop over the temporary buffer
   for( Int_t iDataIndex = 0; iDataIndex < ROC[uRocId].fEpSuppBuffer[uGet4Id].size(); iDataIndex++ )
   {
      TGet4v1MessageExtended extMess = ROC[uRocId].fEpSuppBuffer[uGet4Id][iDataIndex];
      UInt_t   uGet4Ch(0), uGet4Edge(0);
      uGet4Ch   = (extMess.GetRocMessage()).getGet4ChNum();
      uGet4Edge = (extMess.GetRocMessage()).getGet4Edge();

      // Recalculate the full Time to take into account also the epoch2 cycles
      ULong64_t uFullTimeBins = ((ULong64_t)  ( ROC[uRocId].GetFullEpoch2Number( uGet4Id ) - 1 ) << 19) |
                                 (ULong64_t)extMess.GetGet4Ts();
      ULong64_t uFullTime = uFullTimeBins/ 20 + 512;
      Double_t  dFullTime = ((Double_t)uFullTimeBins)*0.05 + 512.;
      extMess.SetFullTime(  uFullTime );
      extMess.SetFullTimeD( dFullTime );

      // Set The ROC epoch2 counter and cycle counter
      extMess.SetRocEpoch( ROC[uRocId].fuCurrEpoch2[uGet4Id] );
      extMess.SetRocCycle( ROC[uRocId].fuEpoch2Cycle[uGet4Id] );


      // Count per global time unit in s
      ULong64_t ulDataTm = uFullTime / 100000000L;
      ROC[uRocId].fDATAt->Fill((ulDataTm % 36000) * 0.1);

      // Long duration time distribution (1 min. bin, 10 days length)
      if( kTRUE == fParam->bLongTimeHistos )
         ROC[uRocId].fDataLongT->Fill( (ulDataTm * 0.1 ) / 3600 );

      // Event statistics
      ROC[uRocId].fChannelInputMessCount->Fill( uGet4Id + (Double_t)uGet4Ch/(Double_t)NB_CHAN_GET4
                                                        + (Double_t)uGet4Edge/(Double_t)(2*NB_CHAN_GET4)  );
      if( kTRUE == fParam->bChipRateHistoEnable )
         ROC[uRocId].fChipRateEvolution[uGet4Id]->Fill(
               (uFullTimeBins ) * 0.1, 1.0/ROC[uRocId].fdRateEvolutionBinSize );
      if( kTRUE == fParam->bChannelRateHistoEnable )
         ROC[uRocId].fChannelRateEvolution[uGet4Id][uGet4Ch]->Fill(
               (uFullTimeBins ) * 0.1, 1.0/ROC[uRocId].fdRateEvolutionBinSize );
      ROC[uRocId].fuNbHitsChipEpoch[uGet4Id] ++;

      // Early event closure check
      if( kTRUE == fCurrentGet4Event.HasTrigger() &&
          kFALSE == ROC[uRocId].fbSelectionDone[uGet4Id]  )
      {
         Double_t dTimeToTrigger = 0.0;
         dTimeToTrigger = extMess.GetFullTimeD() - fCurrentGet4Event.fdTriggerFullTime[uRocId];
         if( kFALSE == ROC[uRocId].fTriggerWind->Test( dTimeToTrigger) )
         {
            // Message after the end of trigger window!!
            Bool_t bAllChanInChipOver = kTRUE;

            // If there was already a message from the same channel & edge out of the trigger
            //  window, then the token ring made at least one full turn => ok for all
            // Otherwise: need to check other channels/edge status
            if( (kFALSE == ROC[uRocId].fbDataTimeOut[uGet4Id][uGet4Ch] && 0 == uGet4Edge ) ||
                (kFALSE == ROC[uRocId].fbDataFallingOut[uGet4Id][uGet4Ch] && 1 == uGet4Edge ) )
            {
               // 24b = always a edge not a hit => need to check both !
               if( 0 == uGet4Edge )
                  ROC[uRocId].fbDataTimeOut[uGet4Id][uGet4Ch] = kTRUE;
                  else ROC[uRocId].fbDataFallingOut[uGet4Id][uGet4Ch] = kTRUE;
               // Check if chip fully finished
               for(UInt_t uChanTest = 0; uChanTest < NB_CHAN_GET4; uChanTest ++)
               {
                  if( kFALSE ==  ROC[uRocId].fbDataTimeOut[uGet4Id][uChanTest] )
                     bAllChanInChipOver = kFALSE;
                  if( kFALSE ==  ROC[uRocId].fbDataFallingOut[uGet4Id][uChanTest] )
                     bAllChanInChipOver = kFALSE;
               }
            } // if same edge not already out of trigger once

            // If chip fully finished: don't wait for the next epoch to close future buffer
            // of current event for this chip
            if( kTRUE == bAllChanInChipOver)
            {
               // If This is the first epoch after the trigger and
               // we did not process the epoch before the one where the
               // trigger came, we need to initialize the 24 bit temp hits
               if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[uGet4Id] &&
                   kFALSE == ROC[uRocId].bLookInPreviousEpoch[uGet4Id] )
                  for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                        (ROC[uRocId].fHitTemp24[uGet4Id][uChan]).Clear();

               BuildHits(uRocId, uGet4Id, ROC[uRocId].fbBufferWithLastFullEpoch2[uGet4Id]);
               ROC[uRocId].fbSelectionDone[uGet4Id] = kTRUE;
               CheckEventClosure();

               for(UInt_t uChanTest = 0; uChanTest < NB_CHAN_GET4; uChanTest ++)
               {
                  ROC[uRocId].fbDataTimeOut[uGet4Id][uChanTest] = kFALSE;
                  ROC[uRocId].fbDataFallingOut[uGet4Id][uChanTest] = kFALSE;
               }
            } // if( kTRUE == bAllChanInChipOver)
         } // if( kFALSE == ROC[uRocId].fTriggerWind->Test( dTimeToTrigger) )
      } // Event ongoing with a detected trigger and chip did not finished all its buffers

      if( kTRUE ==  fParam->bFreeStreaming && 0 < fParam->uNbTriggers )
      {
         if( 0 == uGet4Edge )
         {
            for( Int_t iMainTriggerIndex = 0; iMainTriggerIndex < (Int_t)(fParam->uNbTriggers); iMainTriggerIndex++ )
               if( kTRUE == fParam->IsMainOfThisTrigger( iMainTriggerIndex, uGet4Id, uGet4Ch ) )
            {
               ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex] = extMess;
               /*
                * TODO: call to ProcessTrigger
                * TEMP: histo Filling + counting
                */
               Bool_t bAllInCoinc = kTRUE;
               for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)
               {
                  Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iMainTriggerIndex][uSecChannel]
                                           - extMess.GetFullTimeD();
                  if( dDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                        fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dDistanceToMain      )
                  {
                     bAllInCoinc = kFALSE;
                     break;
                  } // if out of coincidence window
                  Double_t dTotDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannelTot[iMainTriggerIndex][uSecChannel]
                                           - extMess.GetFullTimeD();
                  if( dTotDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                        fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dTotDistanceToMain      )
                  {
                     bAllInCoinc = kFALSE;
                     break;
                  } // if out of coincidence window
               } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)

               // Check if tot edge of the main channel is in trigger window
               Double_t dTotMainDistanceToMain = ROC[uRocId].fdLastFullTimeMainChannelTot[iMainTriggerIndex]
                                 - ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();
               if( dTotMainDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                     fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dTotMainDistanceToMain      )
               {
                  bAllInCoinc = kFALSE;
               } // if out of coincidence window

               if( kTRUE == bAllInCoinc )
               {
                  Double_t dSameTriggerDistance =
                          ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD()
                        - ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] ;

                  ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iMainTriggerIndex );

                  if( fParam->dDeadTime <= dSameTriggerDistance )
                  {
                     // Here we have a DATA self-trigger!!!!!!
                     ROC[uRocId].fuDataSelfTriggerCount[iMainTriggerIndex] ++;

                     ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] =
                           ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();

                     ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTime();
                     uFullTimeSelfTrigBins /= 100000000L;
                     ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                     // Long duration time distribution (1 min. bin, 10 days length)
                     if( kTRUE == fParam->bLongTimeHistos )
                        ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                     ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex], iMainTriggerIndex);
                  } // if( fParam->dDeadTime <= dSameTriggerDistance )
               } // if( kTRUE == bAllInCoinc )
            } // if( -1 < iMainTriggerIndex )

            for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
            {
               if( kTRUE == fParam->IsSecOfThisTrigger( iSecTriggerIndex, uGet4Id, uGet4Ch ) )
               {
                  Int_t iSecondaryIndex = fParam->GetSecChannelIndex(iSecTriggerIndex, uGet4Id, uGet4Ch);
                  if( -1 < iSecondaryIndex )
                  {
                     ROC[uRocId].fdLastFullTimeSecChannel[iSecTriggerIndex][iSecondaryIndex] = extMess.GetFullTimeD();

                     /*
                      * TODO: call to ProcessTrigger
                      * TEMP: histo Filling + counting
                      */
                     Bool_t bAllInCoinc = kTRUE;
                     for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)
                     {
                        Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iSecTriggerIndex][uSecChannel]
                                          - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                        if( dDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                              fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dDistanceToMain      )
                        {
                           bAllInCoinc = kFALSE;
                           break;
                        } // if out of coincidence window

                        // Check if tot edge is in trigger window, only needed in 24b mode
                        Double_t dTotDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannelTot[iSecTriggerIndex][uSecChannel]
                                          - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                        if( dTotDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                              fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dTotDistanceToMain      )
                        {
                           bAllInCoinc = kFALSE;
                           break;
                        } // if out of coincidence window
                     } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)

                     // Check if tot edge of the main channel is in trigger window, only needed in 24b mode
                     Double_t dTotMainDistanceToMain = ROC[uRocId].fdLastFullTimeMainChannelTot[iSecTriggerIndex]
                                       - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                     if( dTotMainDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                           fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dTotMainDistanceToMain      )
                     {
                        bAllInCoinc = kFALSE;
                     } // if out of coincidence window

                     if( kTRUE == bAllInCoinc  )
                     {
                        Double_t dSameTriggerDistance =
                                ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD()
                              - ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] ;

                        ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iSecTriggerIndex );
                        ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iSecTriggerIndex );
                        ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iSecTriggerIndex );
                        ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iSecTriggerIndex );

                        if( fParam->dDeadTime <= dSameTriggerDistance )
                        {
                           // Here we have a DATA self-trigger!!!!!!
                           ROC[uRocId].fuDataSelfTriggerCount[iSecTriggerIndex] ++;

                           ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] =
                                 ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();

                           ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTime();
                           uFullTimeSelfTrigBins /= 100000000L;
                           ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                           // Long duration time distribution (1 min. bin, 10 days length)
                           if( kTRUE == fParam->bLongTimeHistos )
                              ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                           ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex], iSecTriggerIndex);
                        } // if( fParam->dDeadTime <= dSameTriggerDistance )
                     } // if( kTRUE == bAllInCoinc  )
                  } // if( -1 < iSecondaryIndex )
               } //  if( -1 < iSecTriggerIndex )
            } // for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
         }// if( 0 == uGet4Edge )
            else
            {
               // Falling edge
               for( Int_t iMainTriggerIndex = 0; iMainTriggerIndex < (Int_t)(fParam->uNbTriggers); iMainTriggerIndex++ )
                  if( kTRUE == fParam->IsMainOfThisTrigger( iMainTriggerIndex, uGet4Id, uGet4Ch ) )
               {
                  ROC[uRocId].fdLastFullTimeMainChannelTot[iMainTriggerIndex] = extMess.GetFullTimeD();

                  Bool_t bAllInCoinc = kTRUE;
                  for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)
                  {
                     // Check if time edge is in trigger window
                     Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iMainTriggerIndex][uSecChannel]
                                       - ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();
                     if( dDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                           fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dDistanceToMain      )
                     {
                        bAllInCoinc = kFALSE;
                        break;
                     } // if out of coincidence window

                     // Check if tot edge is in trigger window, only needed in 24b mode
                     Double_t dTotDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannelTot[iMainTriggerIndex][uSecChannel]
                                       - ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();
                     if( dTotDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                           fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dTotDistanceToMain      )
                     {
                        bAllInCoinc = kFALSE;
                        break;
                     } // if out of coincidence window
                  } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)

                  // Check if tot edge of the main channel is in trigger window, only needed in 24b mode
                  Double_t dTotMainDistanceToMain = ROC[uRocId].fdLastFullTimeMainChannelTot[iMainTriggerIndex]
                                    - ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();
                  if( dTotMainDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                        fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dTotMainDistanceToMain      )
                  {
                     bAllInCoinc = kFALSE;
                  } // if out of coincidence window

                  if( kTRUE == bAllInCoinc  )
                  {
                     Double_t dSameTriggerDistance =
                             ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD()
                           - ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] ;

                     ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iMainTriggerIndex );
                     ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iMainTriggerIndex );
                     ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iMainTriggerIndex );
                     ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iMainTriggerIndex );

                     if( fParam->dDeadTime <= dSameTriggerDistance )
                     {
                        // Here we have a DATA self-trigger!!!!!!
                        ROC[uRocId].fuDataSelfTriggerCount[iMainTriggerIndex] ++;

                        ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] =
                              ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();

                        ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTime();
                        uFullTimeSelfTrigBins /= 100000000L;
                        ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                        // Long duration time distribution (1 min. bin, 10 days length)
                        if( kTRUE == fParam->bLongTimeHistos )
                           ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                        ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex], iMainTriggerIndex);
                     } // if( fParam->dDeadTime <= dSameTriggerDistance )
                  } // if( kTRUE == bAllInCoinc  )
               } // if( kTRUE == fParam->IsMainOfThisTrigger( iMainTriggerIndex, uGet4Id, uGet4Ch ) )

               for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
               {
                  if( kTRUE == fParam->IsSecOfThisTrigger( iSecTriggerIndex, uGet4Id, uGet4Ch ) )
                  {
                     Int_t iSecondaryIndex = fParam->GetSecChannelIndex(iSecTriggerIndex, uGet4Id, uGet4Ch);
                     if( -1 < iSecondaryIndex )
                     {
                        ROC[uRocId].fdLastFullTimeSecChannelTot[iSecTriggerIndex][iSecondaryIndex] = extMess.GetFullTimeD();

                        Bool_t bAllInCoinc = kTRUE;
                        for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)
                        {
                           // Check if time edge is in trigger window
                           Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iSecTriggerIndex][uSecChannel]
                                             - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                           if( dDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                                 fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dDistanceToMain      )
                           {
                              bAllInCoinc = kFALSE;
                              break;
                           } // if out of coincidence window

                           // Check if tot edge is in trigger window
                           Double_t dTotDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannelTot[iSecTriggerIndex][uSecChannel]
                                             - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                           if( dTotDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                                 fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dTotDistanceToMain      )
                           {
                              bAllInCoinc = kFALSE;
                              break;
                           } // if out of coincidence window
                        } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)

                        // Check if tot edge of the main channel is in trigger window
                        Double_t dTotMainDistanceToMain = ROC[uRocId].fdLastFullTimeMainChannelTot[iSecTriggerIndex]
                                          - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                        if( dTotMainDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                              fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dTotMainDistanceToMain      )
                        {
                           bAllInCoinc = kFALSE;
                        } // if out of coincidence window

                        if( kTRUE == bAllInCoinc  )
                        {
                           Double_t dSameTriggerDistance =
                                   ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD()
                                 - ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] ;

                           ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iSecTriggerIndex );
                           ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iSecTriggerIndex );
                           ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iSecTriggerIndex );
                           ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iSecTriggerIndex );

                           if( fParam->dDeadTime <= dSameTriggerDistance )
                           {
                              // Here we have a DATA self-trigger!!!!!!
                              ROC[uRocId].fuDataSelfTriggerCount[iSecTriggerIndex] ++;

                              ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] =
                                    ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();

                              ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTime();
                              uFullTimeSelfTrigBins /= 100000000L;
                              ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                              // Long duration time distribution (1 min. bin, 10 days length)
                              if( kTRUE == fParam->bLongTimeHistos )
                                 ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                              ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex], iSecTriggerIndex);
                           } // if( fParam->dDeadTime <= dSameTriggerDistance )
                        } // if( kTRUE == bAllInCoinc  )
                     } // if( -1 < iSecondaryIndex )
                  } // if( kTRUE == fParam->IsSecOfThisTrigger( iSecTriggerIndex, uGet4Id, uGet4Ch ) )
               } // for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
            } // else if( 0 == uGet4Edge )
      } // if( kTRUE ==  fParam->bFreeStreaming && 0 < fParam->uNbTriggers && 0 == uGet4Edge )

      ProcessExtendedMessage(uRocId, extMess);
   } // for( Int_t iDataIndex = 0; iDataIndex < ROC[uRocId].fEpSuppBuffer[uGet4Id].size(); iDataIndex++ )
   ROC[uRocId].fEpSuppBuffer[uGet4Id].clear();

   return kTRUE;
}
/**********************************************************************/
Int_t TGet4v1Proc::Process32BitGet4Message( UInt_t uRocId, TGet4v1MessageExtended& extMess )
{
   /*
    * 32bit Get4 hit message specific processing
    * TODO FILL ME
    * Make the get4_index consistent everywhere between global get4 index and inside roc get4 index
    */

   UInt_t get4_index = extMess.getGet4V10R32ChipId() ;
   get4_index = fParam->RemapGet4Chip(get4_index);

   // Check if valid chip
   if( kFALSE == fParam->IsValidGet4Chip(get4_index) )
   {
       cout << "Error: Bad chip nb in 32b Data message = " << get4_index <<" < "<<fParam->uNbGet4<< endl;
       cout << " => This message will be skipped!!!! "<<endl;
       return -1;
   }
   if( kFALSE == fParam->IsActiveGet4Chip(get4_index) )
   {
      // Masked chip, hopefully on purpose, don't complain & return
      return -1;
   }

   // If 1 message is 32bits, all are!
   if( kFALSE == ROC[uRocId].fb32bitsReadoutDetected )
   {
      ROC[uRocId].fb32bitsReadoutDetected = kTRUE;
      fb32bitsReadoutDetected = kTRUE;
      // As it is first 32bit message, let's create
      // 32bit specific histograms
      char folder[30];
      sprintf(folder,"ROC%u/",uRocId);

      /*
       * 32 bits specific histograms
       */
      ROC[uRocId].fChannelInputMessCount = MakeTH1( 'I', Form("%sRoc%u_ChanCounts", folder, uRocId),
            "Channel multiplicity per event",
            NB_CHAN_GET4*MAX_GET4_PER_ROC, 0, MAX_GET4_PER_ROC ,
            "Channel []", "# Mess []" );

         // Slow control messages
      ROC[uRocId].fGet4V1SlowControlType = MakeTH2('I', Form("%sRoc%u_Get4SlowControl", folder, uRocId),
            "SlowControl message type per Get4",
            fParam->uNbGet4, -0.5, fParam->uNbGet4 -0.5, 5, 0., 5,
            "Chip","","Entries [1]");
      ROC[uRocId].fGet4V1SlowControlType->GetYaxis()->SetBinLabel(1, "Scaler");
      ROC[uRocId].fGet4V1SlowControlType->GetYaxis()->SetBinLabel(2, "Dead time");
      ROC[uRocId].fGet4V1SlowControlType->GetYaxis()->SetBinLabel(3, "SPI");
      ROC[uRocId].fGet4V1SlowControlType->GetYaxis()->SetBinLabel(4, "Start");
      ROC[uRocId].fGet4V1SlowControlType->GetYaxis()->SetBinLabel(5, "Hamming");
      ROC[uRocId].fGet4V1SlowControlScaler = MakeTH2('I', Form("%sRoc%u_Get4SlScaler", folder, uRocId),
                              "Scaler in Get4 slow control message",
                              2*(fParam->uNbGet4)*NB_CHAN_GET4, 0., (fParam->uNbGet4)*NB_CHAN_GET4, 820, 0, 8200,
                              "Channel","Scaler [hits]","Entries [1]");
      ROC[uRocId].fGet4V1SlowControlDeadTime = MakeTH2('I', Form("%sRoc%u_Get4SlDeadTime", folder, uRocId),
                              "Dead time in Get4 slow control message",
                              2*(fParam->uNbGet4)*NB_CHAN_GET4, 0., (fParam->uNbGet4)*NB_CHAN_GET4, 410, 0, 4100,
                              "Channel","Dead Time [Clk cycle]","Entries [1]");
      ROC[uRocId].fGet4V1SlowControlHamming = MakeTH2('I', Form("%sRoc%u_Get4SlSeu", folder, uRocId),
            "Hamming error counter for SEU in Get4 slow control message",
            fParam->uNbGet4, 0., fParam->uNbGet4, 512, 0, 512,
            "Chip","Scaler [hits]","Entries [1]");
      ROC[uRocId].fGet4V1SlowControlSeuEvo = MakeTH2('I', Form("%sRoc%u_Get4SlSeuEvo", folder, uRocId),
            "Hamming error counter for SEU in Get4 slow control message",
            3600, 0, 3600, fParam->uNbGet4, 0., fParam->uNbGet4,
            "Time [s]", "Chip","Scaler [hits]");
         // Data messages
      ROC[uRocId].fGet4V1DllLockBit =
            MakeTH2('I', Form("%sRoc%u_Get4V1DllLockBit", folder, uRocId),
            "Dll lock bit status per channel",
            fParam->uNbGet4*NB_CHAN_GET4, -0.5 , fParam->uNbGet4*NB_CHAN_GET4 -0.5,
            2, -0.5, 1.5,
            "Channel []", "Dll lock bit []", "Counts [1]" );

      for( Int_t iGet4 = 0; iGet4 < MAX_GET4_PER_ROC; iGet4++)
      {
         char folderGet4[30];
         sprintf(folderGet4,"%sGet4_%u/",folder, iGet4);
         UInt_t uRemappedGet4Index = fParam->RemapGet4Chip(uRocId, iGet4);
         if( kTRUE == fParam->IsValidGet4Chip(uRemappedGet4Index) &&
             kTRUE == fParam->IsActiveGet4Chip(uRemappedGet4Index) )
         {
            ROC[uRocId].fGet4V1HitsDistanceNs[iGet4] =
                  MakeTH2('I', Form("%sRoc%u_Get%d_HitDistNs",
                                 folderGet4, uRocId, iGet4),
                           Form("Time difference since last hit on same channel in GET4 %d Channels on ROC%u; [ns]",
                                 iGet4, uRocId),
                           1002, -2., 1000.,
                           NB_CHAN_GET4, 0, NB_CHAN_GET4 );
            ROC[uRocId].fGet4V1HitsDistanceUs[iGet4] =
                  MakeTH2('I', Form("%sRoc%u_Get%d_HitDistUs",
                                 folderGet4, uRocId, iGet4),
                           Form("Time difference since last hit on same channel in GET4 %d Channels on ROC%u; [us]",
                                 iGet4, uRocId),
                           999, 1., 1000.,
                           NB_CHAN_GET4, 0, NB_CHAN_GET4 );
            ROC[uRocId].fGet4V1HitsDistanceMs[iGet4] =
                  MakeTH2('I', Form("%sRoc%u_Get%d_HitDistMs",
                                 folderGet4, uRocId, iGet4),
                           Form("Time difference since last hit on same channel in GET4 %d Channels on ROC%u; [ms]",
                                 iGet4, uRocId),
                           999, 1., 1000.,
                           NB_CHAN_GET4, 0, NB_CHAN_GET4 );
            ROC[uRocId].fGet4V1HitsDistanceS[iGet4]  =
                  MakeTH2('I', Form("%sRoc%u_Get%d_HitDistS",
                                 folderGet4, uRocId, iGet4),
                           Form("Time difference since last hit on same channel in GET4 %d Channels on ROC%u; [s]",
                                 iGet4, uRocId),
                           999, 1., 1000.,
                           NB_CHAN_GET4, 0, NB_CHAN_GET4 );

            if( 1 == fParam->bTotHistoEnable )
               for( Int_t iGet4Chan = 0; iGet4Chan < NB_CHAN_GET4; iGet4Chan++)
                  ROC[uRocId].fRawTot[iGet4][iGet4Chan] =
                        MakeTH1('I', Form("%sTot/RawTot_Ch%d_Get%d_Roc%u",
                              folderGet4, iGet4Chan, iGet4, uRocId ),
                        Form("Tot for channel %d in chip %d on ROC %d", iGet4Chan, iGet4, uRocId),
                        1200, -25, 59975, "Tot [ps]", "Counts [1]" );
         }
      } // for( Int_t iGet4 = 0; iGet4 < MAX_GET4_PER_ROC; iGet4++)
   } // if( kFALSE == fb32bitsReadoutDetected )
   extMess.Set32BitFlag();

   UInt_t get4_32b_type  = extMess.getGet4V10R32MessageType();
   switch(get4_32b_type)
   {
      case 0: // epoch message
      {
         UInt_t get4_32b_ep_epoch = extMess.getGet4V10R32EpochNumber();
         UInt_t get4_32b_ep_sync  = extMess.getGet4V10R32SyncFlag();

         if( kTRUE == fCurrentGet4Event.HasTrigger() && kFALSE == ROC[uRocId].fbSelectionDone[get4_index]  )
         {
            // A trigger is ongoing on this chip!
            if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[get4_index] )
            {
               // This is the first epoch after the trigger
               // => time to look for the data in the epoch which was
               // ongoing when the trigger was found
               
               // If we did not process the epoch before the one where the 
               // trigger came, we need to initialize the 24 bit temp hits
               if( kFALSE == ROC[uRocId].bLookInPreviousEpoch[get4_index] )
                  for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                        (ROC[uRocId].fHitTemp24[get4_index][uChan]).Clear();
                        
               BuildHits(uRocId, get4_index, ROC[uRocId].fbBufferWithLastFullEpoch2[get4_index]);
               if( kFALSE == ROC[uRocId].bLookInNextEpoch[get4_index] )
               {
                  ROC[uRocId].fbSelectionDone[get4_index] = kTRUE;
                  CheckEventClosure();
               }
            } // if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[get4_index] )
            else if( kTRUE == ROC[uRocId].fbEpoch2SinceTrigger[get4_index] && 
                      kTRUE == ROC[uRocId].bLookInNextEpoch[get4_index])
            {
               // This is the second epoch after the trigger and we detected on trigger
               // that the trigger window extend in epoch after the one where trigger
               // was found => time to look for the data in the epoch which just finished
               // and was the one just after the trigger epoch
               BuildHits(uRocId, get4_index, ROC[uRocId].fbBufferWithLastFullEpoch2[get4_index]);
               ROC[uRocId].fbSelectionDone[get4_index] = kTRUE;
               CheckEventClosure();
            } // else if( kTRUE == ROC[uRocId].fbEpoch2SinceTrigger[get4_index] && kFALSE == ROC[uRocId].bLookInNextEpoch[get4_index])
         } // if( kTRUE == fCurrentGet4Event.HasTrigger() && kFALSE == ROC[uRocId].fbSelectionDone[get4_index]  )

         if( ROC[uRocId].fuCurrEpoch2[get4_index] + 1 != get4_32b_ep_epoch &&
               ( 0 < ROC[uRocId].fuCurrEpoch2[get4_index] || 0 < ROC[uRocId].fuEpoch2Cycle[get4_index] ) &&
               !( GET4_EPOCH_CYCLE_SIZE == ROC[uRocId].fuCurrEpoch2[get4_index]  && 0 == get4_32b_ep_epoch ) )
         {

            // Count per global time unit in s for previous epoch as should not be too far away
            // anyway this is just for selection, not actual display
            ULong64_t ulPrevEpochTm = ((ULong64_t)  ROC[uRocId].GetFullEpoch2Number( get4_index )) << 19;
            ulPrevEpochTm = ulPrevEpochTm/ 20 + 512;
            ulPrevEpochTm = ulPrevEpochTm / 100000000L;
         
            if( 311 < (ulPrevEpochTm % 36000) * 0.1 &&
              (ulPrevEpochTm % 36000) * 0.1 < 312 )
            {
               cout<<(ulPrevEpochTm % 36000) * 0.1<<" Non consecutive epoch message for chip "<<get4_index<<" Roc Epoch "<<ROC[uRocId].fuCurrEpoch<<" : ";
               cout<<ROC[uRocId].fuCurrEpoch2[get4_index]<<" "<<get4_32b_ep_epoch<<" ";
               cout<<(Int_t)get4_32b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[get4_index]+1) <<" ";
               cout<<ROC[uRocId].fiEpochShift[get4_index]<<" ";
               cout<<ROC[uRocId].fuNbShiftedEpochs[get4_index]<<endl;
            }
                       
            ROC[uRocId].fEpochShiftsPerChip->Fill( get4_index, (Int_t)get4_32b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[get4_index]+1) );

            if( ROC[uRocId].fuCurrEpoch2[get4_index] > get4_32b_ep_epoch &&
                GET4_EPOCH_CYCLE_SIZE < ROC[uRocId].fuCurrEpoch2[get4_index] + 100 &&
                100 < get4_32b_ep_epoch )
               // Epoch close to a cycle change on both sides
               ROC[uRocId].fuEpoch2Cycle[get4_index]++;

            // Correction attempt:
            if( (Int_t)get4_32b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[get4_index]+1) < 10 )
            {
               // close epochs ( < 250us) => probable not a full event missing
               if( 0 != ROC[uRocId].fiEpochShift[get4_index])
               {
                  ROC[uRocId].fEpochShiftsDuration[get4_index]->Fill(ROC[uRocId].fiEpochShift[get4_index],
                        ROC[uRocId].fuNbShiftedEpochs[get4_index] );
                  ROC[uRocId].fEpochShiftsDurationPerChip->Fill( get4_index,
                        ROC[uRocId].fuNbShiftedEpochs[get4_index] );
               }
               ROC[uRocId].fiEpochShift[get4_index] += (Int_t)get4_32b_ep_epoch - (Int_t)(ROC[uRocId].fuCurrEpoch2[get4_index]+1) ;
               ROC[uRocId].fuNbShiftedEpochs[get4_index] = 0;
            }
               else
               {
                  // far epochs ( > 250us) => probable a full event is missing
                  if( 0 != ROC[uRocId].fiEpochShift[get4_index])
                  {
                     ROC[uRocId].fEpochShiftsDuration[get4_index]->Fill(ROC[uRocId].fiEpochShift[get4_index],
                           ROC[uRocId].fuNbShiftedEpochs[get4_index] );
                     ROC[uRocId].fEpochShiftsDurationPerChip->Fill( get4_index,
                           ROC[uRocId].fuNbShiftedEpochs[get4_index] );
                  }
                  ROC[uRocId].fiEpochShift[get4_index]      = 0 ;
                  ROC[uRocId].fuNbShiftedEpochs[get4_index] = 0;
               }

            ROC[uRocId].fuCurrEpoch2[get4_index] = get4_32b_ep_epoch;
         } // if non consecutive epoch indexes
            else
            {
               if( ROC[uRocId].fuCurrEpoch2[get4_index] > get4_32b_ep_epoch )
                  ROC[uRocId].fuEpoch2Cycle[get4_index]++;
               ROC[uRocId].fuCurrEpoch2[get4_index] = get4_32b_ep_epoch;

               if( 0 != ROC[uRocId].fiEpochShift[get4_index] )
                  ROC[uRocId].fuNbShiftedEpochs[get4_index]++;
            } // else of if non consecutive epoch indexes

         // Event statistics
         ROC[uRocId].fuNbHitsChipEpoch[get4_index] = 0;

         /*
          * Temp fix for nov 2012 epoch problem
          */
/*
         if( 0 == get4_index)
         {
            if( ROC[uRocId].fuCurrEpoch2[get4_index] > get4_32b_ep_epoch )
            {
               ROC[uRocId].fuEpoch2Cycle[1]++;
               ROC[uRocId].fuEpoch2Cycle[5]++;
            }
            ROC[uRocId].fuCurrEpoch2[1] = get4_32b_ep_epoch;
            ROC[uRocId].fuCurrEpoch2[5] = get4_32b_ep_epoch;
         }
         if( 1 != get4_index && 5 != get4_index)
         {
            if( ROC[uRocId].fuCurrEpoch2[get4_index] > get4_32b_ep_epoch )
               ROC[uRocId].fuEpoch2Cycle[get4_index]++;
            ROC[uRocId].fuCurrEpoch2[get4_index] = get4_32b_ep_epoch;
         }
*/

         ROC[uRocId].fDistribEpochs2->Fill(get4_index, ROC[uRocId].fuCurrEpoch2[get4_index]);

         ULong64_t uFullTimeBins = ((ULong64_t)  ROC[uRocId].GetFullEpoch2Number( get4_index )) << 19;
         ULong64_t uFullTime = uFullTimeBins/ 20 + 512;
         Double_t  dFullTime = uFullTimeBins / 20. + 512.;
         extMess.SetFullTime(  uFullTime );
         extMess.SetFullTimeD( dFullTime );

         // Count per global time unit in s
         ULong64_t ulEpochTm = uFullTime / 100000000L;
         ROC[uRocId].fEPOCH2t[get4_index]->Fill((ulEpochTm % 36000) * 0.1);

         // Long duration time distribution (1 min. bin, 10 days length)
         if( kTRUE == fParam->bLongTimeHistos )
            ROC[uRocId].fAllEpoch2LongT->Fill( (ulEpochTm * 0.1 ) / 3600 );

         // Swap the flag indicating which buffer contains currently happening epoch
         ROC[uRocId].fbBufferWithLastFullEpoch2[get4_index] = ( kTRUE == ROC[uRocId].fbBufferWithLastFullEpoch2[get4_index] ? kFALSE: kTRUE );
         // Clear this buffer (Data more than 1 full epoch old => either already selected or junk)
         ROC[uRocId].fPrevEpochs2Buffer[get4_index][ ROC[uRocId].fbBufferWithLastFullEpoch2[get4_index] ].clear();

         break;
      }
      case 1: // slow control message
      {
         UInt_t get4_32b_sl_data = extMess.getGet4V10R32SlData();
         UInt_t get4_32b_sl_type = extMess.getGet4V10R32SlType();
         UInt_t get4_32b_sl_edge = extMess.getGet4V10R32SlEdge();
         UInt_t get4_32b_sl_chan = extMess.getGet4V10R32SlChan();

         if( get4_32b_sl_type < 3)
            ROC[uRocId].fGet4V1SlowControlType->Fill(get4_index, get4_32b_sl_type);

         ULong64_t uFullTimeBins = ((ULong64_t)  ROC[uRocId].GetFullEpoch2Number( get4_index )) << 19;
         ULong64_t uFullTime = uFullTimeBins/ 20 + 512;
         Double_t  dFullTime = uFullTimeBins / 20. + 512.;
         extMess.SetFullTime(  uFullTime );
         extMess.SetFullTimeD( dFullTime );

         uFullTimeBins /= 20;
         uFullTimeBins += 512;
         uFullTimeBins /= 100000000L;
         ROC[uRocId].fSLOWCt->Fill( (uFullTimeBins % 36000) * 0.1 );

         // Long duration time distribution (1 min. bin, 10 days length)
         if( kTRUE == fParam->bLongTimeHistos )
            ROC[uRocId].fSlowCLongT->Fill( (uFullTimeBins * 0.1 ) / 3600 );

         switch(get4_32b_sl_type)
         {
            case 0:
               ROC[uRocId].fGet4V1SlowControlScaler->Fill(
                     NB_CHAN_GET4*get4_index + get4_32b_sl_chan + 0.5*get4_32b_sl_edge, get4_32b_sl_data );
               break;
            case 1:
               ROC[uRocId].fGet4V1SlowControlDeadTime->Fill(
                     NB_CHAN_GET4*get4_index + get4_32b_sl_chan + 0.5*get4_32b_sl_edge, get4_32b_sl_data );
               break;
            case 2:
               TGo4Log::Info("Get4 V1.0 32bit, chip %02d, SPI message: %06x", get4_index, get4_32b_sl_data);
               break;
            case 3:
               if( 0 == get4_32b_sl_chan && 1 == get4_32b_sl_edge )
               {
                  ROC[uRocId].fGet4V1SlowControlType->Fill(get4_index, 4);
                  ROC[uRocId].fGet4V1SlowControlHamming->Fill( get4_index, get4_32b_sl_data );
                  ROC[uRocId].fGet4V1SlowControlSeuEvo->Fill( 
                                ( ROC[uRocId].GetFullEpoch2Number(get4_index) * GET4_EPOCH_IN_PS ) / 1e12, 
                                get4_index, get4_32b_sl_data );
               }
                  else
                  {
                     ROC[uRocId].fGet4V1SlowControlType->Fill(get4_index, get4_32b_sl_type);
                     TGo4Log::Info("Get4 V1.0 32bit, chip %02d, Start message: %c%c%c (%6X)",
                           get4_index,
                           (get4_32b_sl_data>>16)&0xFF, (get4_32b_sl_data>>8)&0xFF,
                           get4_32b_sl_data&0xFF, get4_32b_sl_data);
                  }

               break;
            default:
               break;
         }

         break;
      }
      case 2: // error event
      {
         UInt_t get4_32b_er_code = extMess.getGet4V10R32ErrorData();
         UInt_t get4_32b_er_chan = extMess.getGet4V10R32ErrorChan();
         UInt_t get4_32b_er_edge = extMess.getGet4V10R32ErrorEdge();

         ULong64_t uFullTimeBins = ((ULong64_t)  ROC[uRocId].GetFullEpoch2Number( get4_index )) << 19;
         ULong64_t uFullTime = uFullTimeBins/ 20 + 512;
         Double_t  dFullTime = uFullTimeBins / 20. + 512.;
         extMess.SetFullTime(  uFullTime );
         extMess.SetFullTimeD( dFullTime );

         uFullTimeBins /= 20;
         uFullTimeBins += 512;
         uFullTimeBins /= 100000000L;
         ROC[uRocId].fERRORt->Fill( (uFullTimeBins % 36000) * 0.1 );

         // Long duration time distribution (1 min. bin, 10 days length)
         if( kTRUE == fParam->bLongTimeHistos )
            ROC[uRocId].fErrorLongT->Fill( (uFullTimeBins * 0.1 ) / 3600 );

         ROC[uRocId].fGet4ErrorChip->Fill( get4_index );
         ROC[uRocId].fGet4ErrorPatt->Fill( get4_index, get4_32b_er_code);
         if( (0x03 < get4_32b_er_code && get4_32b_er_code < 0x07) )
            ROC[uRocId].fGet4ErrorChan->Fill(
                  NB_CHAN_GET4*get4_index + get4_32b_er_chan + 0.5*get4_32b_er_edge,
                  get4_32b_er_code - 0x04 );
         else if( 0x11 == get4_32b_er_code ||
                   0x12 == get4_32b_er_code )
            ROC[uRocId].fGet4ErrorChan->Fill(
                  NB_CHAN_GET4*get4_index + get4_32b_er_chan + 0.5*get4_32b_er_edge,
                  get4_32b_er_code - 0x0e );

         break;
      }
      case 3: // data event
      {
         UInt_t get4_32b_dat_tot  = extMess.getGet4V10R32HitTot();
         UInt_t get4_32b_dat_ft   = extMess.getGet4V10R32HitFt();
         UInt_t get4_32b_dat_ts   = extMess.getGet4V10R32HitTs();
         UInt_t get4_32b_dat_chan = extMess.getGet4V10R32HitChan();
         UInt_t get4_32b_dat_dll  = extMess.getGet4V10R32HitDllFlag();
         if( NB_CHAN_GET4 <= get4_32b_dat_chan )
            return -1;

         ULong64_t uFullTimeBins = ((ULong64_t)  ROC[uRocId].GetFullEpoch2Number( get4_index ) << 19) |
                                    (ULong64_t)extMess.getGet4V10R32HitTimeBin();
         ULong64_t uFullTime = uFullTimeBins/ 20 + 512;
         Double_t  dFullTime = ((Double_t)uFullTimeBins)*0.05 + 512.;
         extMess.SetFullTime(  uFullTime );
         extMess.SetFullTimeD( dFullTime );

         uFullTimeBins /= 20;
         uFullTimeBins += 512;
         uFullTimeBins /= 100000000L;
         ROC[uRocId].fDATAt->Fill( (uFullTimeBins % 36000) * 0.1 );

         // Long duration time distribution (1 min. bin, 10 days length)
         if( kTRUE == fParam->bLongTimeHistos )
            ROC[uRocId].fDataLongT->Fill( (uFullTimeBins * 0.1 ) / 3600 );

         if( 0 < ROC[uRocId].fLastExtMess[get4_index][get4_32b_dat_chan].GetFullTimeD() )
         {
            ROC[uRocId].fGet4V1HitsDistanceNs[get4_index]->Fill( extMess.GetFullTimeD()
                  - ROC[uRocId].fLastExtMess[get4_index][get4_32b_dat_chan].GetFullTimeD(),
                  get4_32b_dat_chan);
            ROC[uRocId].fGet4V1HitsDistanceUs[get4_index]->Fill( ( extMess.GetFullTimeD()
                  - ROC[uRocId].fLastExtMess[get4_index][get4_32b_dat_chan].GetFullTimeD() )/1e3,
                  get4_32b_dat_chan);
            ROC[uRocId].fGet4V1HitsDistanceMs[get4_index]->Fill( ( extMess.GetFullTimeD()
                  - ROC[uRocId].fLastExtMess[get4_index][get4_32b_dat_chan].GetFullTimeD() )/1e6,
                  get4_32b_dat_chan);
            ROC[uRocId].fGet4V1HitsDistanceS[get4_index]->Fill( ( extMess.GetFullTimeD()
                  - ROC[uRocId].fLastExtMess[get4_index][get4_32b_dat_chan].GetFullTimeD() )/1e9,
                  get4_32b_dat_chan);
         }

         // Event statistics
         ROC[uRocId].fLastExtMess[get4_index][get4_32b_dat_chan] = extMess;
         ROC[uRocId].fChannelInputMessCount->Fill( get4_index + (Double_t)get4_32b_dat_chan/(Double_t)NB_CHAN_GET4  );
         if( kTRUE == fParam->bChipRateHistoEnable )
            ROC[uRocId].fChipRateEvolution[get4_index]->Fill(
                  (uFullTimeBins ) * 0.1, 1.0/ROC[uRocId].fdRateEvolutionBinSize );
         if( kTRUE == fParam->bChannelRateHistoEnable )
            ROC[uRocId].fChannelRateEvolution[get4_index][get4_32b_dat_chan]->Fill(
                  (uFullTimeBins ) * 0.1, 1.0/ROC[uRocId].fdRateEvolutionBinSize );
         ROC[uRocId].fuNbHitsChipEpoch[get4_index] ++;

         // TODO: bin size for Tot as option!!!
         if( 1 == fParam->bTotHistoEnable )
            ROC[uRocId].fRawTot[get4_index][get4_32b_dat_chan]->Fill( get4_32b_dat_tot*25500.0/255.0 );

         ROC[uRocId].fGet4V1DllLockBit->Fill( NB_CHAN_GET4*get4_index + get4_32b_dat_chan,
                                  get4_32b_dat_dll);
         if( kTRUE == ROC[uRocId].fbDllFlag[get4_index][get4_32b_dat_chan] && 1 == get4_32b_dat_dll)
         {
            ROC[uRocId].fbDllFlag[get4_index][get4_32b_dat_chan] = kFALSE;
            cout<<"DLL lock recovery, chip "<<get4_index<<" chan "<<get4_32b_dat_chan<<" at "<<(Double_t)uFullTimeBins*0.1<<" s"<<endl;
         }
         if( kFALSE == ROC[uRocId].fbDllFlag[get4_index][get4_32b_dat_chan] && 0 == get4_32b_dat_dll)
         {
            ROC[uRocId].fbDllFlag[get4_index][get4_32b_dat_chan] = kTRUE;
            cout<<"DLL lock loss, chip "<<get4_index<<" chan "<<get4_32b_dat_chan<<" at "<<(Double_t)uFullTimeBins*0.1<<" s"<<endl;
         }

         // Early event closure check
         if( kTRUE == fCurrentGet4Event.HasTrigger() &&
             kFALSE == ROC[uRocId].fbSelectionDone[get4_index]  )
         {
            Double_t dTimeToTrigger = 0.0;
            dTimeToTrigger = extMess.GetFullTimeD() - fCurrentGet4Event.fdTriggerFullTime[uRocId];
            if( kFALSE == ROC[uRocId].fTriggerWind->Test( dTimeToTrigger) )
            {
               // Message after the end of trigger window!!
               Bool_t bAllChanInChipOver = kTRUE;

               // If there was already a message from the same channel out of the trigger
               //  window, then the token ring made at least one full turn => ok for all
               // Otherwise: need to check other channels status
               if( kFALSE == ROC[uRocId].fbDataTimeOut[get4_index][get4_32b_dat_chan] )
               {
                  // 32b = always a hit, not just edge !
                  ROC[uRocId].fbDataTimeOut[get4_index][get4_32b_dat_chan] = kTRUE;
                  // Check if chip fully finished
                  for(UInt_t uChanTest = 0; uChanTest < NB_CHAN_GET4; uChanTest ++)
                     if( kFALSE ==  ROC[uRocId].fbDataTimeOut[get4_index][uChanTest] )
                        bAllChanInChipOver = kFALSE;
               }
               // If chip fully finished: don't wait for the next epoch to close future buffer
               // of current event for this chip
               if( kTRUE == bAllChanInChipOver)
               {
                  // If This is the first epoch after the trigger and 
                  // we did not process the epoch before the one where the 
                  // trigger came, we need to initialize the 24 bit temp hits
                  if( kFALSE == ROC[uRocId].fbEpoch2SinceTrigger[get4_index] && 
                      kFALSE == ROC[uRocId].bLookInPreviousEpoch[get4_index] )
                     for( UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++)
                           (ROC[uRocId].fHitTemp24[get4_index][uChan]).Clear();
                           
                  BuildHits(uRocId, get4_index, ROC[uRocId].fbBufferWithLastFullEpoch2[get4_index]);
                  ROC[uRocId].fbSelectionDone[get4_index] = kTRUE;
                  CheckEventClosure();
            
                  for(UInt_t uChanTest = 0; uChanTest < NB_CHAN_GET4; uChanTest ++)
                     ROC[uRocId].fbDataTimeOut[get4_index][uChanTest] = kFALSE;
               } // if( kTRUE == bAllChanInChipOver)
            } // if( kFALSE == ROC[uRocId].fTriggerWind->Test( dTimeToTrigger) )
         } // Event ongoing with a detected trigger and future buffer not closed

         if( kTRUE ==  fParam->bFreeStreaming && 0 < fParam->uNbTriggers )
         {
            for( Int_t iMainTriggerIndex = 0; iMainTriggerIndex < (Int_t)(fParam->uNbTriggers); iMainTriggerIndex++ )
               if( kTRUE == fParam->IsMainOfThisTrigger( iMainTriggerIndex, get4_index, get4_32b_dat_chan ) )
            {
               ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex] = extMess;
               /*
                * TODO: call to ProcessTrigger
                * TEMP: histo Filling + counting
                */
               Bool_t bAllInCoinc = kTRUE;
               for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)
               {
                  Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iMainTriggerIndex][uSecChannel]
                                           - extMess.GetFullTimeD();
                  if( dDistanceToMain < fParam->dCoincidenceWindowStart[iMainTriggerIndex] ||
                        fParam->dCoincidenceWindowStop[iMainTriggerIndex] < dDistanceToMain      )
                  {
                     bAllInCoinc = kFALSE;
                     break;
                  } // if out of coincidence window
               } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iMainTriggerIndex]; uSecChannel++)
               if( kTRUE == bAllInCoinc )
               {
                  Double_t dSameTriggerDistance =
                          ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD()
                        - ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] ;

                  ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iMainTriggerIndex );
                  ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iMainTriggerIndex );

                  if( fParam->dDeadTime <= dSameTriggerDistance )
                  {
                     // Here we have a DATA self-trigger!!!!!!
                     ROC[uRocId].fuDataSelfTriggerCount[iMainTriggerIndex] ++;

                     ROC[uRocId].fdLastFullTimeSelfTrigger[iMainTriggerIndex] =
                           ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTimeD();

                     ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex].GetFullTime();
                     uFullTimeSelfTrigBins /= 100000000L;
                     ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                     // Long duration time distribution (1 min. bin, 10 days length)
                     if( kTRUE == fParam->bLongTimeHistos )
                        ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                     ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iMainTriggerIndex], iMainTriggerIndex);
                  } // if( fParam->dDeadTime <= dSameTriggerDistance )
               } // if( kTRUE == bAllInCoinc )
            } // if( -1 < iMainTriggerIndex )
            for( Int_t iSecTriggerIndex = 0; iSecTriggerIndex < (Int_t)(fParam->uNbTriggers); iSecTriggerIndex++ )
            {
               if( kTRUE == fParam->IsSecOfThisTrigger( iSecTriggerIndex, get4_index, get4_32b_dat_chan ) )
                  {
                     Int_t iSecondaryIndex = fParam->GetSecChannelIndex(iSecTriggerIndex, get4_index, get4_32b_dat_chan);
                     if( -1 < iSecondaryIndex )
                     {
                        ROC[uRocId].fdLastFullTimeSecChannel[iSecTriggerIndex][iSecondaryIndex] = extMess.GetFullTimeD();

                        /*
                         * TODO: call to ProcessTrigger
                         * TEMP: histo Filling + counting
                         */
                        Bool_t bAllInCoinc = kTRUE;
                        for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)
                        {
                           Double_t dDistanceToMain = ROC[uRocId].fdLastFullTimeSecChannel[iSecTriggerIndex][uSecChannel]
                                             - ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();
                           if( dDistanceToMain < fParam->dCoincidenceWindowStart[iSecTriggerIndex] ||
                                 fParam->dCoincidenceWindowStop[iSecTriggerIndex] < dDistanceToMain      )
                           {
                              bAllInCoinc = kFALSE;
                              break;
                           } // if out of coincidence window
                        } // for( UInt_t uSecChannel = 0; uSecChannel < fParam->uNbSecondarySelectionCh[iSecTriggerIndex]; uSecChannel++)
                        if( kTRUE == bAllInCoinc  )
                        {
                           Double_t dSameTriggerDistance =
                                   ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD()
                                 - ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] ;

                           ROC[uRocId].fDataSelfTrigDistanceNs->Fill( dSameTriggerDistance,     iSecTriggerIndex );
                           ROC[uRocId].fDataSelfTrigDistanceUs->Fill( dSameTriggerDistance/1e3, iSecTriggerIndex );
                           ROC[uRocId].fDataSelfTrigDistanceMs->Fill( dSameTriggerDistance/1e6, iSecTriggerIndex );
                           ROC[uRocId].fDataSelfTrigDistanceS->Fill(  dSameTriggerDistance/1e9, iSecTriggerIndex );

                           if( fParam->dDeadTime <= dSameTriggerDistance )
                           {
                              // Here we have a DATA self-trigger!!!!!!
                              ROC[uRocId].fuDataSelfTriggerCount[iSecTriggerIndex] ++;

                              ROC[uRocId].fdLastFullTimeSelfTrigger[iSecTriggerIndex] =
                                    ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTimeD();

                              ULong64_t uFullTimeSelfTrigBins = ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex].GetFullTime();
                              uFullTimeSelfTrigBins /= 100000000L;
                              ROC[uRocId].fSelfTriggT->Fill( (uFullTimeSelfTrigBins % 36000) * 0.1 );

                              // Long duration time distribution (1 min. bin, 10 days length)
                              if( kTRUE == fParam->bLongTimeHistos )
                                 ROC[uRocId].fSelfTriggLongT->Fill( (uFullTimeSelfTrigBins * 0.1 ) / 3600 );

                              ProcessTriggerMessage(uRocId, ROC[uRocId].fextMessLastMainChannel[iSecTriggerIndex], iSecTriggerIndex);
                           } // if( fParam->dDeadTime <= dSameTriggerDistance )
                        } // if( kTRUE == bAllInCoinc  )
                     } // if( -1 < iSecondaryIndex )
                  } //  if( -1 < iSecTriggerIndex )
               } // else of if( -1 < iMainTriggerIndex )
         } // if( kTRUE ==  fParam->bFreeStreaming && 0 < fParam->uNbTriggers )

         break;
      }
      default:
         break;
   } // switch(get4_32b_type)

   return get4_32b_type;
}
/**********************************************************************/

Bool_t TGet4v1Proc::AnalyzeAllGet4Channels( Get4v1Event &eventFull )
{

   /* TODO FILL ME
    * both readout mode histo filling
    */
   for( UInt_t  uRocId =0; uRocId<fParam->numRocs; uRocId++ )
   {
      if( !fParam->IsActiveRoc(uRocId) ) continue;

      for( Int_t iGet4 = 0; iGet4 < MAX_GET4_PER_ROC; iGet4++)
         for( Int_t iGet4Chan = 0; iGet4Chan < NB_CHAN_GET4; iGet4Chan++)
         {
            if( 0 < ( (eventFull.fGet4Boards[iGet4]).fHits[iGet4Chan]).size() )
            {
               for( Int_t iGet4Chan_2 = iGet4Chan+1; iGet4Chan_2 < NB_CHAN_GET4; iGet4Chan_2++)
                  if( 0 < ( (eventFull.fGet4Boards[iGet4]).fHits[iGet4Chan_2]).size() )
                     ROC[uRocId].fChannelsMapping->Fill( iGet4 + (Double_t)iGet4Chan/(Double_t)NB_CHAN_GET4,
                                             iGet4 + (Double_t)iGet4Chan_2/(Double_t)NB_CHAN_GET4 );

               for( Int_t iGet4_2 = iGet4+1; iGet4_2 < MAX_GET4_PER_ROC; iGet4_2++)
                  for( Int_t iGet4Chan_2 = 0; iGet4Chan_2 < NB_CHAN_GET4; iGet4Chan_2++)
                     if( 0 < ( (eventFull.fGet4Boards[iGet4_2]).fHits[iGet4Chan_2]).size() )
                        ROC[uRocId].fChannelsMapping->Fill( iGet4 + (Double_t)iGet4Chan/(Double_t)NB_CHAN_GET4,
                                                iGet4_2 + (Double_t)iGet4Chan_2/(Double_t)NB_CHAN_GET4 );
            }

            ROC[uRocId].fChannelMultiplicity->Fill( iGet4 + (Double_t)iGet4Chan/(Double_t)NB_CHAN_GET4,
                  ( (eventFull.fGet4Boards[iGet4]).fHits[iGet4Chan]).size());
         }

      if( 1 == fParam->bDebugHistoEnable )
      {
         UInt_t uHistosIndexSingleChip = 0;
         UInt_t uHistosIndexChipVsChip = 0;
         for(UInt_t uFirstGet4Channel = 0; uFirstGet4Channel < NB_CHAN_GET4; uFirstGet4Channel++)
         {
            for(UInt_t uSecondGet4Channel = 0; uSecondGet4Channel < NB_CHAN_GET4; uSecondGet4Channel++)
            {
               if( uFirstGet4Channel < uSecondGet4Channel )
               {
                  if( 1 == ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uFirstGet4Channel]).size() &&
                      1 == ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uSecondGet4Channel]).size() )
                  {
                     ROC[uRocId].fTimeDiffInsideChip[0][uHistosIndexSingleChip]->Fill(
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uFirstGet4Channel])[0].GetTimeDiff(
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uSecondGet4Channel])[0]) );
                     // 1D FineTime correlation
                     ROC[uRocId].fFTCorrel[0][uHistosIndexSingleChip]->Fill(
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uSecondGet4Channel])[0].GetHitLeadingFTS()
                          -( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uFirstGet4Channel])[0].GetHitLeadingFTS() );
                     // 2D FineTime correlation
                     ROC[uRocId].fFTCorrel2D[0][uHistosIndexSingleChip]->Fill(
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uFirstGet4Channel])[0].GetHitLeadingFTS(),
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uSecondGet4Channel])[0].GetHitLeadingFTS() );
                  }
                  if( 1 == ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uFirstGet4Channel]).size() &&
                      1 == ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uSecondGet4Channel]).size() )
                  {
                     ROC[uRocId].fTimeDiffInsideChip[1][uHistosIndexSingleChip]->Fill(
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uFirstGet4Channel])[0].GetTimeDiff(
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uSecondGet4Channel])[0]) );
                     // 1D FineTime correlation
                     ROC[uRocId].fFTCorrel[1][uHistosIndexSingleChip]->Fill(
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uSecondGet4Channel])[0].GetHitLeadingFTS()
                          -( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uFirstGet4Channel])[0].GetHitLeadingFTS() );
                     // 2D FineTime correlation
                     ROC[uRocId].fFTCorrel2D[1][uHistosIndexSingleChip]->Fill(
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uFirstGet4Channel])[0].GetHitLeadingFTS(),
                           ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uSecondGet4Channel])[0].GetHitLeadingFTS() );
                  }
                  uHistosIndexSingleChip++;
               } // if( uFirstGet4Channel < uSecondGet4Channel )
               if( 1 == ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uFirstGet4Channel]).size() &&
                   1 == ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uSecondGet4Channel]).size() )
               {
                  ROC[uRocId].fTimeDiffBetweenChips[uHistosIndexChipVsChip]->Fill(
                        ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uFirstGet4Channel])[0].GetTimeDiff(
                        ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uSecondGet4Channel])[0]) );
                  ROC[uRocId].fFTCorrelChipToChip[uHistosIndexChipVsChip]->Fill(
                        ( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip2]).fHits[uSecondGet4Channel])[0].GetHitLeadingFTS()
                       -( (eventFull.fGet4Boards[fParam->uGet4TimeDiffChip1]).fHits[uFirstGet4Channel])[0].GetHitLeadingFTS() );
               }
               uHistosIndexChipVsChip++;
            } // for(UInt_t uSecondGet4Channel = 0; uSecondGet4Channel < MAX_GET4_CH; uSecondGet4Channel++)
         } // for(UInt_t uFirstGet4Channel = 0; uFirstGet4Channel < MAX_GET4_CH; uFirstGet4Channel++)
      } // if( 1 == fParam->bDebugHistoEnable )
   } // for( UInt_t  uRocId =0; uRocId<fParam->numRocs; uRocId++ )

   if( kTRUE == fb32bitsReadoutDetected )
      AnalyzeAllGet4Channels32Bits( fCurrentGet4Event );
      else AnalyzeAllGet4Channels24Bits( fCurrentGet4Event );

   return kTRUE;
}
Bool_t TGet4v1Proc::AnalyzeAllGet4Channels24Bits( Get4v1Event &eventFull )
{

   /* TODO FILL ME
    * 24 bit mode histo filling
    */

   if( 1 == fParam->bDebugHistoEnable )
      for( UInt_t  uRoc =0; uRoc<fParam->numRocs; uRoc++ )
         if( fParam->IsActiveRoc(uRoc) )
            if( 0 == uNbEvents[uRoc]%fParam->uNbEventsDnlUpdate )
            {
               UpdateLeadingDnlHistograms( eventFull, uRoc );
               UpdateTrailingDnlHistograms( eventFull, uRoc );
            }

   return kTRUE;
}
Bool_t TGet4v1Proc::AnalyzeAllGet4Channels32Bits( Get4v1Event &eventFull )
{

   /* TODO FILL ME
    * 32 bit mode histo filling
    */

   if( 1 == fParam->bDebugHistoEnable )
      for( UInt_t  uRoc =0; uRoc<fParam->numRocs; uRoc++ )
         if( fParam->IsActiveRoc(uRoc) )
            if( 0 == uNbEvents[uRoc]%fParam->uNbEventsDnlUpdate )
               UpdateLeadingDnlHistograms( eventFull, uRoc );

   return kTRUE;
}
/**********************************************************************/

Bool_t TGet4v1Proc::PrintRocEpochIndexes(UInt_t uRocId, Int_t uMessagePriority )
{
   TString sOutput = "";

   for( UInt_t uGet4 = 0; uGet4 < fParam->uNbGet4; uGet4++)
   {
      sOutput += Form(" %7d", ROC[uRocId].fuCurrEpoch2[uGet4]);
   }
   Message(uMessagePriority,"Current ROC epoch indexes: %s ", sOutput.Data() );

   return kTRUE;
}
Bool_t TGet4v1Proc::PrintRocEpochCycles(UInt_t uRocId, Int_t uMessagePriority )
{
   TString sOutput = "";

   for( UInt_t uGet4 = 0; uGet4 < fParam->uNbGet4; uGet4++)
   {
      sOutput += Form(" %6d", ROC[uRocId].fuEpoch2Cycle[uGet4]);
   }
   Message(uMessagePriority,"Current ROC cycle indexes: %s ", sOutput.Data() );

   return kTRUE;
}
/**********************************************************************/
void TGet4v1Proc::UpdateLeadingDnlHistograms( Get4v1Event &eventFull, UInt_t uRocId )
{
   for( Int_t iGet4 = 0; iGet4 < MAX_GET4_PER_ROC; iGet4++)
      for( Int_t iGet4Chan = 0; iGet4Chan < NB_CHAN_GET4; iGet4Chan++)
      {
         UInt_t uRemappedGet4Index = fParam->RemapGet4Chip(uRocId, iGet4);
         if( kTRUE == fParam->IsValidGet4Chip(uRemappedGet4Index) &&
             kTRUE == fParam->IsActiveGet4Chip(uRemappedGet4Index) )
         {
            Double_t dDnlLeading = 0;
            Double_t dSumLeading = 0;

            // First Resets everything
            ROC[uRocId].fLeadingDnl[iGet4][iGet4Chan]->Reset();
            ROC[uRocId].fLeadingDnlSum[iGet4][iGet4Chan]->Reset();

            // First bin
            dDnlLeading = ( ROC[uRocId].fLeadingFTS[iGet4][iGet4Chan]->GetBinContent(1)
                           - (ROC[uRocId].fLeadingFTS[iGet4][iGet4Chan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS) ) /
                            (ROC[uRocId].fLeadingFTS[iGet4][iGet4Chan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS);
            ROC[uRocId].fLeadingDnl[iGet4][iGet4Chan]->Fill( 0.0, dDnlLeading);
            dSumLeading += dDnlLeading;
            ROC[uRocId].fLeadingDnlSum[iGet4][iGet4Chan]->Fill( 0.0, dSumLeading );

            for( int j = 2; j <= NB_BIN_GET4_FTS; j++)
            {
             dDnlLeading = ( ROC[uRocId].fLeadingFTS[iGet4][iGet4Chan]->GetBinContent(j)
                             - (ROC[uRocId].fLeadingFTS[iGet4][iGet4Chan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS) ) /
                            (ROC[uRocId].fLeadingFTS[iGet4][iGet4Chan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS);
             ROC[uRocId].fLeadingDnl[iGet4][iGet4Chan]->Fill( (Double_t)(j-1), dDnlLeading );
             dSumLeading += dDnlLeading;
             ROC[uRocId].fLeadingDnlSum[iGet4][iGet4Chan]->Fill( (Double_t)j-1, dSumLeading );
            }
         }
      } // For get4 in ROC, for channel in GET4
}
void TGet4v1Proc::UpdateTrailingDnlHistograms( Get4v1Event &eventFull, UInt_t uRocId )
{
   for( Int_t iGet4 = 0; iGet4 < MAX_GET4_PER_ROC; iGet4++)
      for( Int_t iGet4Chan = 0; iGet4Chan < NB_CHAN_GET4; iGet4Chan++)
      {
         UInt_t uRemappedGet4Index = fParam->RemapGet4Chip(uRocId, iGet4);
         if( kTRUE == fParam->IsValidGet4Chip(uRemappedGet4Index) &&
             kTRUE == fParam->IsActiveGet4Chip(uRemappedGet4Index) )
         {
            Double_t dDnlTrailing = 0;
            Double_t dSumTrailing = 0;

            // First Resets everything
            ROC[uRocId].fTrailingDnl[iGet4][iGet4Chan]->Reset();
            ROC[uRocId].fTrailingDnlSum[iGet4][iGet4Chan]->Reset();

            // First bin
            dDnlTrailing = ( ROC[uRocId].fTrailingFTS[iGet4][iGet4Chan]->GetBinContent(1)
                            - (ROC[uRocId].fTrailingFTS[iGet4][iGet4Chan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS) ) /
                            (ROC[uRocId].fTrailingFTS[iGet4][iGet4Chan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS);
            ROC[uRocId].fTrailingDnl[iGet4][iGet4Chan]->Fill( 0.0, dDnlTrailing );
            dSumTrailing += dDnlTrailing;
            ROC[uRocId].fTrailingDnlSum[iGet4][iGet4Chan]->Fill( 0.0, dSumTrailing );

            for( int j = 2; j <= NB_BIN_GET4_FTS; j++)
            {
             dDnlTrailing = ( ROC[uRocId].fTrailingFTS[iGet4][iGet4Chan]->GetBinContent(j)
                             - (ROC[uRocId].fTrailingFTS[iGet4][iGet4Chan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS) ) /
                            (ROC[uRocId].fTrailingFTS[iGet4][iGet4Chan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS);
             ROC[uRocId].fTrailingDnl[iGet4][iGet4Chan]->Fill( (Double_t)(j-1), dDnlTrailing );
             dSumTrailing += dDnlTrailing;
             ROC[uRocId].fTrailingDnlSum[iGet4][iGet4Chan]->Fill( (Double_t)(j-1), dSumTrailing );
            }
         }
      } // For get4 in ROC, for channel in GET4
}