onlinemonitor/rocmonitor/TRocProc.cxx (r4864/r3871)

Go to the documentation of this file.

#include "TRocProc.h"

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

#include "TRocAnalysis.h"
#include "TRocParam.h"
#include "TPedestalExtractor.h"
#include "TGo4MbsEvent.h"
#include "TGo4WinCond.h"
#include "TGo4Log.h"
#include "TGo4Version.h"

#include "roc/Message.h"
//#include "roc/Iterator.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 TRocParam::maxBufferTriggers per buffer (only offline mode with no lost samples!)
#define ROC_SINGLETRIGGERMODE 1

//#define DUMPMODE 1

//#define DUMPALLMESSAGES 1

#define GET4_BUFFERS_SIZE_LIMIT 100000

TRocProc::TRocProc() :
   TCBMBeamtimeProc(),
   //fIter(fDefaultIter),
   fPedestals(0),
   fIsTimeSorted(kFALSE),
   fOutputEvent(0),
   fHasNewGlobalTrigger(kFALSE)
{
}

//***********************************************************
TRocProc::~TRocProc()
{
   // Control over Automatic reset
   if ((fParam->uNbFeets>0) || (fParam->uNbRocsGet4>0))
      TGo4Log::Info("Total Nb GET4 resets: %d", uIndexResetGet4);

   TGo4Log::Info("TRocProc: Delete instance ");
   if (fParam->baselineCalibr && (fParam->pedSaveToFile.Length()>0) && fPedestals) {
      fPedestals->Extract();
      fPedestals->SaveToFile(fParam->pedSaveToFile.Data());
   }

   if (fPedestals) {
      delete fPedestals;
      fPedestals = 0;
   }
}

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

   // here we optionally override parameter values with setup macro, if existing:
   TString setupmacro = "set_RocPar.C";
   if(TString(TGo4Analysis::Instance()->ClassName())=="TRocAnalysis") {
      // in standalone roc analysis, take name of parameter setter macro from commandline arguments "-args -p mymacro.C"
      //JAM note that dynamic_cast would lead to linker problems here when working in full beamtime analysis
      TString usermacro = ((TRocAnalysis*)TGo4Analysis::Instance())->getUserPars();
      if (!usermacro.IsNull()) setupmacro = usermacro;
   }

   fParam = (TRocParam *) MakeParameter("RocPar", "TRocParam", setupmacro.Data());

        //ExecuteScript(setupmacro.Data());

   if (fParam)
      fParam->SetConfigRocs();

   //   fParam->triggerSignal = 10;
   //   fNumRocs = 3;

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



   if( kFALSE == fParam->noTrigger && 1 == fParam->uUseLocalEpochs )
   {
      fParam->uUseLocalEpochs = 0;
      cout<<"Disabling usage of local epochs for the Get4s, as incompatible with trigger window!"<<endl;
   }
   if (fParam->uNbRocsGet4>0)
      fParam->PrintGet4Options();
   if (fParam->numRocs > 0) fNumRocs = (unsigned) fParam->numRocs;
   if (fNumRocs > MAX_ROC) fNumRocs = MAX_ROC;

   for (int nx=0;nx<MAX_NX;nx++)
      nx_use_mask[nx] = false;

   switch (fParam->numNX) {
      case 0: break;
      case 1: nx_use_mask[0] = true; break; // show only even numbers
      case 2: nx_use_mask[0] = true; nx_use_mask[2] = true; break;
      default:
         for (int nx=0;nx<MAX_NX;nx++) nx_use_mask[nx] = true;
         break;
   }

   for (int n=0;n<MAX_GET4;n++)
      get4_use_mask[n] = false;

   int nget4 = fParam->uNbFeets*2;
   if (nget4>MAX_GET4) nget4 = MAX_GET4;
   for (int n=0;n<nget4;n++)
      get4_use_mask[n] = true;

   for (unsigned n=0; n<fNumRocs;n++) {
      ROC.push_back(TRocRec());
      ROC[n].fRocId = n;
   }

   fEvntSize = MakeTH1('I', "EvntSize", "Number of messages in event", 250, 1., 2000.);

   int hnumroc = fNumRocs > 8 ? fNumRocs : 8;

   fMsgsPerRoc = MakeTH1('I', "MsgsPerRoc", "Number of messages per ROC", hnumroc, 0., hnumroc);

   fTriggerPerRoc = MakeTH1('I', "TriggersPerRoc", "Number of Trigger messages per ROC", hnumroc, 0., hnumroc);

   fDeltaTriggerTime = MakeTH1('I', "TriggerDeltaTime", "Corrected hits time difference of all ROCs", 5000, -5000., 5000., "#Delta t");
   
   fGlobalTriggerWind = MakeWinCond("TriggerWindow", -100, 2000., fDeltaTriggerTime->GetName());
   fGlobalAUXWind = MakeWinCond("AUXWindow", -100, 100., fDeltaTriggerTime->GetName());

   fAUX2_R01 = 0;
   fSYNC_R0_R10 = 0;

//   if (fNumRocs>1)
//      fAUX2_R01 = MakeTH1('I', "AUX2_R01", "Time difference between AUX2 messages on ROC0 and ROC1", 200, -200., +200);

//   if (fNumRocs>9)
//      fSYNC_R0_R10 = MakeTH1('I', "SYNC_R0_R10", "Time difference between SYNC0/R10 and SYNC1/R0", 20000, -100000., +100000);

   fPedestals = 0;

   if (fParam->baselineCalibr) {
      fPedestals = new TPedestalExtractor(fNumRocs, MAX_NX, fParam->pedInitState );
      fPedestals->SetExttrigCalibrPeriod( fParam->pedTtriCalibrPeriod );
      fPedestals->SetVerbose( fParam->pedVerbose );
      if (fParam->pedestalFile.Length()>0) {
         fPedestals->LoadFromFile(fParam->pedestalFile.Data());
      }
   }

   for (unsigned n=0; n<fNumRocs;n++) {
      ROC[n].fIsEventComplete = kFALSE;
      ROC[n].fHasNewData = kFALSE;

      // do not build histograms for non-used ROC
      if (!AssertRoc(n)) continue;

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

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

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

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

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

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

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

      ROC[n].fTrigger_AllNX = MakeTH1('I', Form("%sRoc%u_Trigger", folder, n), Form("Time difference between all hits and last trigger signal on ROC%u", n), 2500, -1000., 4000.);
      ROC[n].fTrigger_AllNX_100 = MakeTH1('I', Form("%sRoc%u_Trigger_100", folder, n), Form("Time difference between all hits and last trigger signal on ROC%u", n), 50005, -100000., 1e6);

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

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

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

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

      ROC[n].fALLt = MakeTH1('I', Form("%sRoc%u_ALL_t", folder,n), Form("Time distribution of ALL hits on ROC%u", n), 10000, 0., 1000.,"s");



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

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

      for (int k=0;k<2;k++)
         ROC[n].fFebADC[k] = MakeTH1('I', Form("%sRoc%u_Feb%d_adcs", folder, n, k), Form("ADC values on ROC%u FEB%d", n, k), 4, 0., 4., "channel", "ADC");

      for(unsigned nx=0;nx<MAX_NX;nx++) {

         if (!AssertNX(nx)) continue;

         char nxfolder[30], nxinfo[30];
         sprintf(nxfolder,"%sNX%u/Roc%u_nx%u_", folder, nx, n, nx);
         sprintf(nxinfo,"ROC = %u NXYTER = %u", n, nx);

         ROC[n].fChs[nx] = MakeTH1('I', Form("%schannels", nxfolder), Form("Channels from %s", nxinfo), 128, 0., 128.);
         ROC[n].fTrigger_Chs[nx] = MakeTH1('I', Form("%schs_trigg", nxfolder), Form("Channels from %s under trigger cut", nxinfo), 128, 0., 128.);
         ROC[n].fADCs[nx] = MakeTH2('I', Form("%sadc", nxfolder), Form("ADC distribution for %s", nxinfo), 128, 0., 128., 1024, 0., 4096., "Channel number", "ADC values");
                 ROC[n].fTrigADCs[nx] = MakeTH2('I', Form("%sadctrig", nxfolder), Form("ADC distribution for %s for the Trigger condition", nxinfo), 128, 0., 128., 1024, 0., 4096., "Channel number", "ADC values");
         ROC[n].fBaseline[nx] = MakeTH2('I', Form("%sBaseline", nxfolder), Form("Baseline for %s", nxinfo), 128, 0., 128., 4096, 0., 4096., "Channel number", "Baseline, ADC counts");
         if (fParam->baselineCalibr)
            ROC[n].fADCs_wo_baseline[nx] = MakeTH2('I', Form("%sadc_wo_baseline", nxfolder), Form("ADC - Baseline   for %s", nxinfo), 128, 0., 128., 1024, -200., 824., "Channel number", "ADC values (baseline subtracted)");
         ROC[n].fTrigger_NX[nx] = MakeTH1('I', Form("%sTrigger", nxfolder), Form("Time difference between hit and last trigger signal on %s", nxinfo), 2500, -1000., 4000.);

         ROC[n].fHITt[nx] = MakeTH1('I', Form("%sHIT_t", nxfolder), Form("Time distribution of HIT signal on %s", nxinfo), 10000, 0., 1000.,"s");


         if (fParam->nxDiffCh>=0)
            for (int ndiff=0;ndiff<NUM_DIFFS; ndiff++) {
               int nch = ndiff * (MOD_DIFFS + 1) + MOD_DIFFS;
               ROC[n].fTmDiff[nx][ndiff] = MakeTH1('I', Form("%sDiff_%d_%d", nxfolder, fParam->nxDiffCh, nch), Form("Time difference between channels %d and %d from %s", fParam->nxDiffCh, nch, nxinfo), 2000, -1000., 1000.);
            }

      } // for nx


      if (fParam->uNbFeets>0) {

         ROC[n].fGet4SysTypes = MakeTH1('I', Form("%sGet4SysTypes%u", folder, n), Form("ROC%u Distribution of GET4 system messages", n), 2, 0., 2.);
         if (IsObjMade()) {
            ROC[n].fGet4SysTypes->GetXaxis()->SetBinLabel(1, "ERROR");
            ROC[n].fGet4SysTypes->GetXaxis()->SetBinLabel(2, "EXT_SYNC");
         }
         
         ROC[n].fGet4Chips = MakeTH1('I', Form("%sGet4Chips%u", folder, n), Form("ROC%u distribution of GET4 messages", n), MAX_GET4, 0, MAX_GET4);
      }

      for (unsigned g4=0;g4<MAX_GET4;g4++) {
         if (!AssertGET4(g4)) continue;

         char g4folder[30], g4info[30];
         sprintf(g4folder,"%sG4%u/Roc%u_g4%u_", folder, g4, n, g4);
         sprintf(g4info,"ROC = %u GET4 = %u", n, g4);

         ROC[n].fGet4Channels[g4] = MakeTH1('I', Form("%sChannels", g4folder), Form("Channels distribution on %s", g4info), MAX_GET4_CH*2, 0, MAX_GET4_CH*2, "chip");
         ROC[n].fGet4Tm[g4] = MakeTH1('I', Form("%sStamp", g4folder), Form("Time stamp distribution on %s", g4info), 26215, 0., 26215., "ns");
         ROC[n].fGet4DiffSync[g4] = MakeTH1('I', Form("%sDiffSync", g4folder), Form("Difference to last epoch2 with sync on %s", g4info), 65536, 0., 655360., "ns");

         ROC[n].fGet4Trigger[g4] = MakeTH1('I', Form("%sTrigger", g4folder), Form("Time difference between Get4 hits and last trigger on %s", g4info), 2500, -1000., 4000.);
         ROC[n].fGet4Trigger100[g4] = MakeTH1('I', Form("%sTrigger100", g4folder), Form("Time difference between Get4 hits and last trigger signal on %s", g4info), 5005, -1000., 1e6);

         for(int k=0;k<MAX_GET4_CH;k++)
            for (int fl=0;fl<2;fl++) {
               ROC[n].fGet4TmCh[g4][k][fl] = MakeTH1('I', Form("%sStamp_ch%d_%s", g4folder, k, (fl ? "fall" : "rise")), Form("Time stamps distribution on %s channel %d edge %s", g4info, k, (fl ? "rise" : "fall")), 26215, 0., 26215., "ns");
               
               ROC[n].fGet4Channels[g4]->GetXaxis()->SetBinLabel(1+k*2+fl,Form("Ch%d %s",k,(fl ? "fall" : "rise")));
            }

         ROC[n].fGet4Info[g4] = new TLatex(0.2, 0.2, "--- sample text ---");
         ROC[n].fGet4Info[g4]->SetName(Form("ROC%u_get4%u_info", n, g4));
         ROC[n].fGet4Info[g4]->SetNDC();
         AddObject(ROC[n].fGet4Info[g4]); // will replace old one of same name
      }
   }
   
   if( kFALSE == fParam->NoGet4Cleaning )
   { // Remove all Cleaning related histograms
      for( UInt_t uChip = 0; uChip < 2*fParam->uNbFeets; uChip++ )
         FECHIP.push_back(TGet4Rec());

      // GET4 chip specific initialization
      for( UInt_t uChip = 0; uChip < 2*fParam->uNbFeets; uChip++ )
      { // Loop on chips, 2 chip per board
         //~ FECHIP[uChip].fIsEventComplete=kFALSE;
         
         // Multiple buffers solution
         FECHIP[uChip].uLastEpoch2                     = 0;
         FECHIP[uChip].uRocEpochCycle                  = 0;
         FECHIP[uChip].uLocalEpochNb                   = 0;
         FECHIP[uChip].uLocalEpochCycle                = 0;
         (FECHIP[uChip].bValidEpochFlag).resize(  fParam->uNbBuffers );
         (FECHIP[uChip].fCurrentEventMsg).resize( fParam->uNbBuffers );
         (FECHIP[uChip].uEpochStart).resize(      fParam->uNbBuffers );
         (FECHIP[uChip].uCycleStart).resize(      fParam->uNbBuffers );
         (FECHIP[uChip].bMessageInterBufferOk).resize(fParam->uNbBuffers );
         (FECHIP[uChip].fCurrentUnprocessedMsg).resize( fParam->uNbBuffers );
         for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++)
         {  // Same number of buffers for chip and epoch buffers
            (FECHIP[uChip].bValidEpochFlag)[uBuffer] = kFALSE;
            (FECHIP[uChip].fCurrentEventMsg)[uBuffer].clear();
            (FECHIP[uChip].uEpochStart)[uBuffer]     = 0;
            (FECHIP[uChip].uCycleStart)[uBuffer]     = 0;
            (FECHIP[uChip].bMessageInterBufferOk)[uBuffer] = kFALSE;
            (FECHIP[uChip].fCurrentUnprocessedMsg)[uBuffer].clear();
         }

         TString sChipFolder = Form("Feet/Get4/Chip%u/",uChip);
         TString sChanFolder[NB_CHAN_GET4];
         for(Int_t iChan = 0; iChan < NB_CHAN_GET4; iChan++)
            sChanFolder[iChan] = Form("Channel%d/",NB_CHAN_GET4*uChip + iChan);

         // Chip Related histograms
         FECHIP[uChip].fGet4SyncSpacing = MakeTH1('I',
            sChipFolder + Form( "SyncSpacing%d", uChip),
            Form( "Non synced Epochs between synced Epochs on Chip %d", uChip ),
            2*fParam->uSyncCycleSize, 0, 2*fParam->uSyncCycleSize, "No of Epochs [1]", "Entries [1]" );
         FECHIP[uChip].fGet4SyncSpacingComp = MakeTH2('I',
            sChipFolder + Form( "SyncSpacing%dComp", uChip),
            Form( "Non synced Epochs between synced Epochs, corrected for sync losses versus uncorrected on Chip %d", uChip ),
            2*fParam->uSyncCycleSize, 0, 2*fParam->uSyncCycleSize, 2*fParam->uSyncCycleSize, 0, 2*fParam->uSyncCycleSize,
            "No of Epochs [1]", "No of Epochs [1]", "Entries [1]" );

         FECHIP[uChip].fGet4ValidSpacing = MakeTH1('I',
            sChipFolder + Form( "ValidSpacing%d", uChip),
            Form( "Non synced Epochs between synced valid Epochs on Chip %d", uChip ),
            30, 0, 30, "No of Epochs [1]", "Entries [1]" );

         FECHIP[uChip].fGet4InvalidSpacing = MakeTH1('I',
            sChipFolder + Form( "InvalidSpacing%d", uChip),
            Form( "Non synced Epochs between synced invalid Epochs on Chip %d", uChip ),
            3*fParam->uSyncCycleSize, 0, 3*fParam->uSyncCycleSize, "No of Epochs [1]", "Entries [1]" );

         FECHIP[uChip].fGet4ValidEpochs = MakeTH1( 'I',
            sChipFolder + Form( "ValidEpochs%d", uChip),
            Form( "Valid epochs (chips %d synched)", uChip ),
            2, -0.5, 1.5, "Valid? [0 = False, 1= True]", "Entries [1]" );
         FECHIP[uChip].fGet4MessValidEpochs = MakeTH1( 'I',
            sChipFolder + Form( "Raw/RawMessValidEpochs%d", uChip),
            Form( "Messages in Valid epochs (chips %d synched)", uChip ),
            501, -0.5, 500.5, "Mess Nb [1]", "Entries [1]" );
         FECHIP[uChip].fGet4AccMessNotValidated = MakeTH1( 'I',
            sChipFolder + Form( "Raw/RawAccMessNotValidEpochs%d", uChip),
            Form( "Nb of messages matching the trigger accepted without epoch validation bec. event (chips %d not synched)", uChip ),
            501, -0.5, 500.5, "Mess Nb [1]", "Entries [1]" );

         FECHIP[uChip].fModuloSyncRoc= MakeTH2( 'I',
            sChipFolder + Form( "ModuloSyncRoc%d", uChip),
            "Evolution of the modulo for the ROC epoch with sync",
            501, -0.5, 500.5, 2*fParam->uSyncCycleSize, 0, 2*fParam->uSyncCycleSize,
            "Cycle (~27s) [1]", "; Modulo [1]" );
         FECHIP[uChip].fModuloSyncLocal= MakeTH2( 'I',
            sChipFolder + Form( "ModuloSyncLocal%d", uChip),
            "Evolution of the modulo for the local epoch with sync",
            501, -0.5, 500.5, 2*fParam->uSyncCycleSize, 0, 2*fParam->uSyncCycleSize,
            "Cycle (~27s) [1]", "; Modulo [1]" );
         FECHIP[uChip].fModuloSyncMainClock= MakeTH2( 'I',
            sChipFolder + Form( "ModuloSyncMain%d", uChip),
            "Evolution of the modulo for the 250MHz epoch in 150MHz epoch with sync",
            501, -0.5, 500.5, 2*fParam->uMainSyncCycleSize, 0, 2*fParam->uMainSyncCycleSize,
            "Cycle (~27s) [1]", "; Modulo [1]" );

         FECHIP[uChip].fInterChipSyncEpochShiftEvol= MakeTH2( 'I',
            sChipFolder + Form( "InterChipSyncEpochShiftEvol%d", uChip),
            "Evolution of the Inter chip epoch shift check",
            501, -0.5, 500.5, 10, -5.5, 4.5,
            "Cycle (~27s) [1]", "; Shift [1]" );

         // Channels related Histograms
         for(Int_t iChan = 0; iChan < NB_CHAN_GET4; iChan++)
         { // Loop on channels per chips
            Int_t iFullChan = NB_CHAN_GET4*uChip + iChan;

            // Just to be sure, hopefully useless
            FECHIP[uChip].fGet4FineTimeLE[iChan]       = 0; // Finetime of Leading Edge
            FECHIP[uChip].fGet4FineTimeTE[iChan]       = 0; // Finetime of Trailing Edge
            FECHIP[uChip].fGet4LeDnl[iChan]            = 0; // DNL value for each bin
            FECHIP[uChip].fGet4LeDnlSum[iChan]         = 0; // Integral of DNL value up to each bin
            FECHIP[uChip].fGet4TeDnl[iChan]            = 0; // DNL value for each bin
            FECHIP[uChip].fGet4TeDnlSum[iChan]         = 0; // Integral of DNL value up to each bin
            FECHIP[uChip].fNbConsecutiveLE[iChan]      = 0; // Nb of consecutive Leading edges (should stay at 1 or max 2 when multi hits)
            FECHIP[uChip].fNbConsecutiveTE[iChan]      = 0; // Nb of consecutive Trailing edges (should stay at 1 or max 2 when multi hits)

            // Histos
            FECHIP[uChip].fGet4RisEdgesNbEvol[iChan] = MakeTH1( 'I',
               "Feet/debug/"+ sChanFolder[iChan] + Form("Raw/RawRisingNbEvo%d", iFullChan),
               Form( "Nb of rising  edges per cycle, channel %d ", iFullChan ),
               500, 0, 499, "Cycle []", "Edges [1]" );
            FECHIP[uChip].fGet4FalEdgesNbEvol[iChan] = MakeTH1( 'I',
               "Feet/debug/"+ sChanFolder[iChan] + Form("Raw/RawFallingNbEvo%d", iFullChan),
               Form( "Nb of falling edges per cycle, channel %d ", iFullChan ),
               500, 0, 499, "Cycle []", "Edges [1]" );

            if( 1 == fParam->uDebugHistoOn )
            {
                  FECHIP[uChip].fGet4FineTimeLE[iChan] = MakeTH1('I',
                     "Feet/Channels/"+ sChanFolder[iChan] + Form("LeadingEdge/RawFineTimeL%d", iFullChan),
                     Form( "Nonlinearity Histogram of Channel %d Leading Edge",iFullChan),
                     NB_BIN_GET4_FTS,-0.5, NB_BIN_GET4_FTS- 0.5, "Bin [1]","Entries [1]" );

                  FECHIP[uChip].fGet4FineTimeTE[iChan] = MakeTH1('I',
                     "Feet/Channels/"+ sChanFolder[iChan] + Form("TrailingEdge/RawFineTimeT%d", iFullChan),
                     Form( "Nonlinearity Histogram of Channel %d Trailing Edge",iFullChan),
                     NB_BIN_GET4_FTS,-0.5, NB_BIN_GET4_FTS - 0.5, "Bin [1]","Entries [1]" );

                  FECHIP[uChip].fGet4LeDnl[iChan] = MakeTH1('I',
                     "Feet/Channels/"+ sChanFolder[iChan] + Form("LeadingEdge/RawDnlL%d", iFullChan),
                     Form( "DNL of Channel %d Leading Edge",iFullChan),
                     NB_BIN_GET4_FTS,-0.5,NB_BIN_GET4_FTS - 0.5, "Bin [1]","DNL offset [Bin]" );
                  FECHIP[uChip].fGet4LeDnlSum[iChan] = MakeTH1('I',
                     "Feet/Channels/"+ sChanFolder[iChan] + Form("LeadingEdge/RawDnlIntL%d", iFullChan),
                     Form( "Dnl Sum of Channel %d Leading Edge",iFullChan),
                     NB_BIN_GET4_FTS,-0.5,NB_BIN_GET4_FTS - 0.5, "Bin [1]","DNL Sum [Bin]" );

                  FECHIP[uChip].fGet4TeDnl[iChan] = MakeTH1('I',
                     "Feet/Channels/"+ sChanFolder[iChan] + Form("TrailingEdge/RawDnlT%d", iFullChan),
                     Form( "DNL of Channel %d Trailing Edge",iFullChan),
                     NB_BIN_GET4_FTS,-0.5,NB_BIN_GET4_FTS - 0.5, "Bin [1]","DNL offset [Bin]" );
                  FECHIP[uChip].fGet4TeDnlSum[iChan] = MakeTH1('I',
                     "Feet/Channels/"+ sChanFolder[iChan] + Form("TrailingEdge/RawDnlIntT%d", iFullChan),
                     Form( "DNL Sum of Channel %d Trailing Edge",iFullChan),
                     NB_BIN_GET4_FTS,-0.5,NB_BIN_GET4_FTS - 0.5, "Bin [1]","DNL Sum [Bin]" );

                  FECHIP[uChip].fNbConsecutiveLE[iChan] = MakeTH1( 'I',
                     "Feet/debug/"+ sChanFolder[iChan] + Form("RawConsLE%d", iFullChan),
                     Form( "Nb of consecutive Leading edges in Valid epochs (chips %d synched)", uChip ),
                     15, 0.5, 15.5, "LE Nb [1]", "Entries [1]" );
                  FECHIP[uChip].fNbConsecutiveTE[iChan] = MakeTH1( 'I',
                     "Feet/debug/"+ sChanFolder[iChan] + Form("RawConsTE%d", iFullChan),
                     Form( "Nb of consecutive Leading edges in Valid epochs (chips %d synched)", uChip ),
                     15, 0.5, 15.5, "TE Nb [1]", "Entries [1]" );
            } // if( 1 == fParam->uDebugHistoOn )
         } // for(Int_t iChan = 0; iChan < NB_CHAN_GET4; iChan++)
      } // for( UInt_t uChip = 0; uChip < fParam->uNbFeets; uChip++ )

      // General variables
      for(UInt_t uTempFeetRoc = 0; uTempFeetRoc < fParam->uNbRocsGet4;uTempFeetRoc++)
         uNbEvents[uTempFeetRoc] = 0;
      // GET4 general variables
      uCurrentEpoch2 = 0;
      uCurrentCycle2 = 0;

      uLastEpochMainClock = 0;
      uMainEpochCycle     = 0;
   
      uRocEpochFirstSyncedChip = 0;
      uRocCycleFirstSyncedChip = 0;
   
      uEpochFirstSyncAfterReset = 0;
      uCycleFirstSyncAfterReset = 0;
   
      bTransferMessageNext = kFALSE;

      uEpochBufferStart = 0 ;
      uCycleBufferStart = 0 ;

      vMessageInterBuffer.resize( fParam->uNbBuffers );
      vMessageInterBufferUnprocessed.resize( fParam->uNbBuffers );
      for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++)
      {
         vMessageInterBuffer[uBuffer].clear();
         vMessageInterBufferUnprocessed[uBuffer].clear();
      }
      vMessageEventBuffer.clear();

      vUnprocessedMessages.resize( fNumRocs );
      for( UInt_t uRoc = 0; uRoc < fNumRocs; uRoc ++)
         vUnprocessedMessages[uRoc].clear();
   } // if( kFALSE == fParam->NoGet4Cleaning )

   // GET4 general histograms

   fDistribEpochsMain = 0;

   if ((fParam->uNbFeets>0) || (fParam->uNbRocsGet4>0)) {

      fGet4SynchChip = MakeTH1('I', "Feet/Messages/Get4ExternalSynchChip",
                              "Get4 chip sending External Synch message",
                              fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, "Ext Sync chip","Entries [1]");
      fGet4SynchPatt = MakeTH2('I', "Feet/Messages/Get4ExternalSynchPatt",
                              "Pattern of Get4 External Synch message",
                              fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, 64, 0., 64.,
                              "Ext Sync chip", "Sync Pattern","Entries [1]");
      fGet4ErrorChip = MakeTH1('I', "Feet/Messages/Get4ErrorChip",
                              "Get4 chip sending Error message",
                              fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, "Error Chip","Entries [1]");
      fGet4ErrorPatt = MakeTH2('I', "Feet/Messages/Get4ErrorPatt",
                              "Pattern of Get4 Error message",
                              fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, 64, 0., 64.,
                              "Error chip","Error Pattern","Entries [1]");
      fGet4DataLoss = MakeTH1('I', "Feet/GET4/Dataloss", "Epochs with data Loss",
                              fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5,
                              "Get 4 Chip","Nb epochs with Loss [1]");
      fGet4EdgeMessagePerRawEvent = MakeTH2('I', "Feet/GET4/EdgePerRawEvt", "Nb of accepted edge message per event",
                              2000, -0.5, 2000 -0.5, fParam->uNbRocsGet4, 0, fParam->uNbRocsGet4,
                              "Nb accepted edge message [1]","Feet ROC ID [1]");
   if( kFALSE == fParam->NoGet4Cleaning )
   { // Remove all Cleaning related histograms
      fGet4NotValidMessRawEvent   = MakeTH2('I', "Feet/GET4/NotValidMessRawEvt",
                              "Nb of not validated accepted edge message per event",
                              2000, -0.5, 2000 -0.5, fParam->uNbRocsGet4, 0, fParam->uNbRocsGet4,
                              "Nb of not validated accepted edge message [1]","Feet ROC ID [1]");

      fMapEpochsRoc= MakeTH2( 'I', "Feet/Epochs/MapEpochsRoc",
            Form("Modulo %u of epoch counter value for Roc sync epoch messages",fParam->uSyncCycleSize),
            fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, 30, -0.5, 29.5,
            "chip []", Form("Modulo %u of Epoch counter[]", fParam->uSyncCycleSize), "Counts []" );
      fMapEpochsLocal= MakeTH2( 'I', "Feet/Epochs/MapEpochsLocal",
            Form("Modulo %u of epoch counter value for local sync epoch messages", fParam->uSyncCycleSize),
            fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, fParam->uSyncCycleSize, -0.5, fParam->uSyncCycleSize-0.5,
            "chip []", Form("Modulo %u of Epoch counter[]", fParam->uSyncCycleSize), "Counts []" );
      fMapEpochsMain= MakeTH2( 'I', "Feet/Epochs/MapEpochsMain",
            Form("Modulo %u of epoch counter value for 250MHz epoch messages", fParam->uMainSyncCycleSize),
            fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5,
            2*(fParam->uMainSyncCycleSize), -0.5, 2*(fParam->uMainSyncCycleSize)-0.5,
            "chip []", Form("Modulo %u of Epoch counter[]", fParam->uSyncCycleSize), "Counts []" );
      fDistribEpochsRoc= MakeTH2( 'I', "Feet/Epochs/DistribEpochsRoc",
            "Distribution of epoch counter value for Roc epoch messages",
            fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, 1050, 0, 1050000,
            "chip []", "Value of Roc Epoch Cnt []", "Counts []" );
      fDistribEpochsLocal= MakeTH2( 'I', "Feet/Epochs/DistribEpochsLocal",
            "Distribution of epoch counter value for 250MHz epoch messages",
            fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, 1050, 0, 1050000,
            "chip []", "Value of Local Epoch Cnt []", "Counts []" );
      fDistribEpochsMain= MakeTH1( 'I', "Feet/Epochs/DistribEpochsMain",
            "Distribution of epoch counter value for Local epoch messages",
            4100, 0, 4100,
            "Value of Local Epoch Cnt []", "Counts []" );
      fNbMissedSync= MakeTH2( 'I', "Feet/Epochs/NbMissedSync",
            "Distribution of missed sync nb per chip",
            fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2 -0.5, 30, 0, 30,
            "chip []", "Nb of Missed Sync []", "Counts []" );

      fInterChipSyncEpochShift= MakeTH2( 'I', "Feet/Epochs/InterChipSyncEpochShift",
            "Inter chip epoch shift check",
            fParam->uNbFeets*2, -0.5, fParam->uNbFeets*2,
            10, -5.5, 4.5,
            "Chip [1]", "; Shift [1]" );
      fGet4RisEdgesNb = MakeTH1('I', "Feet/Get4EdgesCount/Raw/RawRisingEdgesNb",
                      "Number of Rising edges per channel",
                      fParam->uNbFeets * 8, -0.5, fParam->uNbFeets * 8 - 0.5,
                      "Channel [1]", "Entries [1]" );
      fGet4FalEdgesNb = MakeTH1('I', "Feet/Get4EdgesCount/Raw/RawFallingEdgesNb",
                      "Number of Falling edges per channel",
                      fParam->uNbFeets * 8, -0.5, fParam->uNbFeets * 8 - 0.5,
                      "Channel [1]", "Entries [1]" );
      fGet4EdgesDiffEvol= MakeTH2('I', "Feet/Get4EdgesCount/Raw/RawEdgesDiffEvol",
                      "diff ( nb falling - nb rising ) for each cycle/channel",
                      500, 0, 500, fParam->uNbFeets * 8, -0.5, fParam->uNbFeets * 8 - 0.5,
                      "Cycle []", "Chan []", "(Falling - Rising[1]" );
      fGet4RisEdgesEvol = MakeTH1('I', "Feet/Get4EdgesCount/Raw/RawRisingEdgesEvol",
                      "Number of Rising edges per cycle",
                      500, 0, 500, "Cycle []", "Edges [1]" );
      fGet4FalEdgesEvol = MakeTH1('I', "Feet/Get4EdgesCount/Raw/RawFallingEdgesEvol",
                      "Number of Falling edges per cycle",
                      500, 0, 500, "Cycle []", "Edges [1]" );

      } // if( kFALSE == fParam->NoGet4Cleaning)
   } // if ((fParam->uNbFeets>0) || (fParam->uNbRocsGet4>0))

   // Control over Automatic reset
   uIndexResetGet4 = 0; // AUTO reset
   /*************************************/

   setupmacro = "set_RocCond.C";
   // in standalone roc analysis, take name of condition setter macro from commandline arguments "-args -c mymacro.C"
   //JAM note that dynamic_cast would lead to linker problems here when working in full beamtime analysis
   if(TString(TGo4Analysis::Instance()->ClassName())=="TRocAnalysis") {
      TString usermacro = ((TRocAnalysis*)TGo4Analysis::Instance())->getUserConds();
      if (!usermacro.IsNull()) setupmacro = usermacro;
   }

   ExecuteScript(setupmacro.Data());
   
   ResetEndOfBuffer();
}







void TRocProc::ProcessTriggerMessage(TRocData* rocevent, int rocid, uint64_t fulltm)
{
//   if (fParam->noTrigger) return;

   // JAM: for multiaux mode: better only count the applied triggers, not all trigger messages
   // fTriggerPerRoc->Fill(rocid);

   if (!ROC[rocid].fHasNewTrigger) {
         // JAM avoid that trigger message on slave roc will override real master trigger!
         if((!fParam->globalTrigger) // local triggers are always taken
               ||
               (fParam->globalTrigger
                      &&  !fHasNewGlobalTrigger // any following trigger inside delta time window is ignored
                     && (((unsigned) rocid==fParam->masterRoc) || ROC[fParam->masterRoc].fHasNewTrigger)))
                     // only accept new trigger if we are the master, or if the master had a new trigger that is distributed to us
            {
#ifdef DUMPMODE
         printf("Find trigger for roc %d\n", rocid); cout << endl;
#endif
         fTriggerPerRoc->Fill(rocid);
         ROC[rocid].fLastTriggerTm = fulltm;
#ifndef  ROC_SINGLETRIGGERMODE         
         if(!fParam->globalTrigger || (unsigned) rocid==fParam->masterRoc) // JAM only set trigger flag for master, slaves must be corrected by sync first!
#endif
            ROC[rocid].fHasNewTrigger = kTRUE;
         ROC[rocid].fTriggersPerBuffer++;
         if (rocevent)
            rocevent->fLastTriggerTm = fulltm;
      }
 //  }
#ifndef  ROC_SINGLETRIGGERMODE

   if ((unsigned) rocid==fParam->masterRoc) {
      fOutputEvent->fLastGlobalTriggerTm = fulltm;
      if (fParam->globalTrigger && !fHasNewGlobalTrigger) {
         if (!fFirstSubEvent) {
            TGo4Log::Error("Master trigger defined not in the first subevent - change ROC readout !!!");
            exit(1);
         }
         // JAM put here distribution of master trigger to slaves:
#ifdef DUMPMODE
         cout <<"TTTTTTTTTTTTTTTTTTT ProcessTriggerMessage as master"<<rocid << endl;
#endif
         // FIXME: SL: it is only for the case when many trigger in buffer are defined, not necessary in normal config



         // this alone will not work, because start sync time of slaves is not available here! is corrected at next slave sync.
         for (unsigned n = 0; n < fNumRocs; n++) {
            if (!AssertRoc(n))
               continue;
            if(n== (unsigned) rocid) continue;
            TRocData* reventn = dynamic_cast<TRocData*> (fOutputEvent->getEventElement(n));
            uint64_t triggertm(0);
            // TODO: reintroduce calibration coefficients
            if (ROC[rocid].fLastTriggerTm > ROC[rocid].fStartSyncTm)
               triggertm = ROC[n].fStartSyncTm
                     + (ROC[rocid].fLastTriggerTm - ROC[rocid].fStartSyncTm);
            else
               triggertm = ROC[n].fStartSyncTm
                     - (ROC[rocid].fStartSyncTm - ROC[rocid].fLastTriggerTm);
#ifdef DUMPMODE
            cout <<"TTTTTTTTTTTTTTTTTTT ProcessTriggerMessage distributes triggertime "<< triggertm<<" to roc "<<n << endl;
            cout <<"      Master trigger: "<< ROC[rocid].fLastTriggerTm <<", Master Sync: "<< ROC[rocid].fStartSyncTm <<", Our Sync:"<<ROC[n].fStartSyncTm<< endl;
#endif
            ProcessTriggerMessage(reventn, n, triggertm);
            if(ROC[rocid].fTriggersPerBuffer==1)
               ROC[n].fHasNewTrigger = kFALSE; // first trigger: mark slave trigger as not ready until we correct sync shifts
            else
               ROC[n].fHasNewTrigger = kTRUE; // for subsequent triggers, sync correction has already been done
         }
         fHasNewGlobalTrigger = kTRUE; // need to set this flag after slaves are set
      }
   }

#endif

   if (ROC[rocid].fHasNewTrigger) {
      // reprocess unprocessed messages already here, do not let them go back to unprocessed
      HandleUnprocessedMessages(rocevent, rocid);
      } // if (ROC[rocid].fHasNewTrigger)
   } // if (!ROC[rocid].fHasNewTrigger)
}


void TRocProc::HandleUnprocessedMessages(TRocData* rocevent, int rocid)
{
   for (unsigned i=0; i<ROC[rocid].fUnprocessedMsg.size(); i++) {
      ProcessExtendedMessage(rocid, rocevent, ROC[rocid].fUnprocessedMsg[i], false);
//         if (rocid==0) {
//            printf("Unproc ExMsg = %lu\n",ROC[rocid].fUnprocessedMsg[i].GetFullTime());
//            ROC[rocid].fUnprocessedMsg[i].GetRocMessage().printData();
//         }
   }
   ROC[rocid].fUnprocessedMsg.clear(); // is filled again from current event below

   // TEST: attempt to make get4 cleaning compatible with trigger selection
   if( kFALSE == fParam->NoGet4Cleaning && -1 != fParam->FindFeetRocId(rocid) )
   {
      for( unsigned int uChipCheck = 0; uChipCheck < fParam->uNbFeets*2; uChipCheck++)
      {
         if( fParam->uGet4Active[ uChipCheck ] )
            for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++ )
            {
               for (unsigned i=0; i<(FECHIP[uChipCheck].fCurrentUnprocessedMsg[uBuffer]).size(); i++)
               {
                  TRocMessageExtended mTemp = (FECHIP[uChipCheck].fCurrentUnprocessedMsg[uBuffer]).at(i);
                  if (fParam->noTrigger)
                  {
                     (FECHIP[uChipCheck].fCurrentEventMsg[ uBuffer ]).push_back(mTemp);
                  } // if (fParam->noTrigger)
                  else
                  {
                     Bool_t bAdd_to_event(kFALSE);

                     Double_t dDiff = 0.;
                     Bool_t bIsdiff = kFALSE;

                     if(mTemp.GetFullTime() >= ROC[rocid].fLastTriggerTm)
                        dDiff = mTemp.GetFullTime() - ROC[rocid].fLastTriggerTm;
                     else
                        dDiff = -1.0 * (ROC[rocid].fLastTriggerTm - mTemp.GetFullTime());

                     mTemp.SetTriggerDeltaT(dDiff);

                     bIsdiff = kTRUE;

                     TGo4WinCond* cond = fParam->globalTrigger ? fGlobalTriggerWind : ROC[rocid].fTriggerWind;

                     if (cond->Test(dDiff))
                     {
                        bAdd_to_event = kTRUE;
                     }

                     if (bIsdiff) {
                           fDeltaTriggerTime->Fill(dDiff);
                           ROC[rocid].fTrigger_AllNX->Fill(dDiff);
                           ROC[rocid].fTrigger_AllNX_100->Fill(dDiff);

                           unsigned g4 = mTemp.GetGet4Number();
                           if (ROC[rocid].fGet4Trigger[g4])
                              ROC[rocid].fGet4Trigger[g4]->Fill(dDiff);
                           if (ROC[rocid].fGet4Trigger100[g4])
                              ROC[rocid].fGet4Trigger100[g4]->Fill(dDiff);
                     }

                     if ( bAdd_to_event )
                     {
                        (FECHIP[uChipCheck].fCurrentEventMsg[ uBuffer ]).push_back(mTemp);
                     } // if ( bAdd_to_event )
                  } // else of if (fParam->noTrigger)
               } // for (unsigned i=0; i<(FECHIP[uChipCheck].fCurrentUnprocessedMsg[uBuffer]).size(); i++)
               (FECHIP[uChipCheck].fCurrentUnprocessedMsg[uBuffer]).clear();
            } // for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++ )
      } // for( unsigned int uChipCheck = 0; uChipCheck < fParam->uNbFeets*2; uChipCheck++)
      for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++ )
      {
         for (unsigned i=0; i<(vMessageInterBufferUnprocessed[uBuffer]).size(); i++)
         {
            TRocMessageExtended mTemp = (vMessageInterBufferUnprocessed[uBuffer]).at(i);
            if (fParam->noTrigger)
            {
               (vMessageInterBuffer[uBuffer]).push_back(mTemp);
            } // if (fParam->noTrigger)
            else
            {
               Bool_t bAdd_to_event(kFALSE);

               Double_t dDiff = 0.;
               Bool_t bIsdiff = kFALSE;

               if(mTemp.GetFullTime() >= ROC[rocid].fLastTriggerTm)
                  dDiff = mTemp.GetFullTime() - ROC[rocid].fLastTriggerTm;
               else
                  dDiff = -1.0 * (ROC[rocid].fLastTriggerTm - mTemp.GetFullTime());

               mTemp.SetTriggerDeltaT(dDiff);

               bIsdiff = kTRUE;

               TGo4WinCond* cond = fParam->globalTrigger ? fGlobalTriggerWind : ROC[rocid].fTriggerWind;

               if (cond->Test(dDiff))
               {
                  bAdd_to_event = kTRUE;
               }

               if (bIsdiff) {
                  fDeltaTriggerTime->Fill(dDiff);
                  ROC[rocid].fTrigger_AllNX->Fill(dDiff);
                  ROC[rocid].fTrigger_AllNX_100->Fill(dDiff);

                  unsigned g4 = mTemp.GetGet4Number();
                  if (ROC[rocid].fGet4Trigger[g4])
                     ROC[rocid].fGet4Trigger[g4]->Fill(dDiff);
                  if (ROC[rocid].fGet4Trigger100[g4])
                     ROC[rocid].fGet4Trigger100[g4]->Fill(dDiff);
               }

               if ( bAdd_to_event )
               {
                  (vMessageInterBuffer[uBuffer]).push_back(mTemp);
               }
            } // else of if (fParam->noTrigger)
         } // for (unsigned i=0; i<(vMessageInterBufferUnprocessed[uBuffer]).size(); i++)
         (vMessageInterBufferUnprocessed[uBuffer]).clear();
      } // for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++ )
      for (unsigned i=0; i<vUnprocessedMessages[rocid].size(); i++)
      {
         TRocMessageExtended mTemp = (vUnprocessedMessages[rocid]).at(i);
         if (fParam->noTrigger)
         {
            rocevent->fExtMessages.push_back(mTemp);
         } // if (fParam->noTrigger)
         else
         {
            Bool_t bAdd_to_event(kFALSE);

            Double_t dDiff = 0.;
            Bool_t bIsdiff = kFALSE;

            if(mTemp.GetFullTime() >= ROC[rocid].fLastTriggerTm)
               dDiff = mTemp.GetFullTime() - ROC[rocid].fLastTriggerTm;
            else
               dDiff = -1.0 * (ROC[rocid].fLastTriggerTm - mTemp.GetFullTime());

            mTemp.SetTriggerDeltaT(dDiff);

            bIsdiff = kTRUE;

            TGo4WinCond* cond = fParam->globalTrigger ? fGlobalTriggerWind : ROC[rocid].fTriggerWind;

            if (cond->Test(dDiff))
            {
               bAdd_to_event = kTRUE;
            }

            if (bIsdiff) {
               fDeltaTriggerTime->Fill(dDiff);
               ROC[rocid].fTrigger_AllNX->Fill(dDiff);
               ROC[rocid].fTrigger_AllNX_100->Fill(dDiff);

               unsigned g4 = mTemp.GetGet4Number();
               if (ROC[rocid].fGet4Trigger[g4])
                  ROC[rocid].fGet4Trigger[g4]->Fill(dDiff);
               if (ROC[rocid].fGet4Trigger100[g4])
                  ROC[rocid].fGet4Trigger100[g4]->Fill(dDiff);
            }

            if ( bAdd_to_event )
            {
               rocevent->fExtMessages.push_back(mTemp);
            }
         } // else of if (fParam->noTrigger)
      } // for (unsigned i=0; i<(vUnprocessedMessages[rocid]).size(); i++)
      (vUnprocessedMessages[rocid]).clear();
   } // if( kFALSE == fParam->NoGet4Cleaning )


}




void TRocProc::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<TRocEvent*>(btevent->GetSubEvent("ROC"));
      }
      else
      {

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

   fFirstSubEvent = true;

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



//-----------------------------------------------------------
// event function
void TRocProc::ProcessSubevent(TGo4MbsSubEvent* psubevt)
{
   uint32_t nxid(0), g4id(0), g4ch(0), g4fl(0), nxch(0), nxadc(0), auxid(0), syncid(0);
   uint64_t fulltm(0);
   uint32_t typ(0), rocid(0);
   Double_t nxadc_corr = 0.;
   static int cnt=0;
   unsigned msgcount=0;
#ifdef DUMPMODE
   static unsigned count=0;
   static unsigned bcount=0;
#endif

   //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);

   if (!is_dabc_evt && !is_raw_evt) return;

   // fIsTimeSorted = (psubevt->GetProcid() == roc::proc_MergedEvent);

#ifdef   ROC_SINGLETRIGGERMODE
     fIsTimeSorted = kFALSE; // SL to avoid any mismatches, should be implemented anyway differently
#else
     fIsTimeSorted = kTRUE; // JAM used for TEST!
#endif

   if(cnt==0) {
      TGo4Log::Info("Multitriggermode: %s", fIsTimeSorted ? "true" : "false");
      cnt=1;
   }


   unsigned rid = psubevt->GetSubcrate();
//   //     cout << "RocID = " << (int) psubevt->GetSubcrate() << "  data kind = " << (int) psubevt->GetProcid() << endl;
//
   
   if (!AssertRoc(rid)) {
     // to see that messages are comming from the ROC
     fMsgsPerRoc->Fill(rid, (psubevt->GetDlen() - 2)/4);
     return;
   }


   
//   printf("Process ROC event\n");

// BEGIN INITIAL EVENT PART
   if(ROC[rid].fLoopsPerBuffer==0)
   {

#ifdef DUMPMODE
      cout << "#################### ProcessSubevent rid:"<<rid<<" has new input event #"<< GetEventNumber() << endl;
#endif
      int datasize = (psubevt->GetDlen() - 2) * 2;
      int msg_fmt = psubevt->GetControl();
      ROC[rid].fIter.setFormat(msg_fmt);
      ROC[rid].fIter.setRocNumber(rid);

//      printf("ROCID %d datasize %d trigger %d\n", rid, datasize, GetTriggerNumber());

      // we can exclude messages (SYNC and may be EPOCH) which are added by DABC at the end of subevent

      if( kFALSE == fParam->NoGet4Cleaning )
      { // Remove all Cleaning related histograms
         if( -1 != fParam->FindFeetRocId( psubevt->GetSubcrate() ) )
         {
            Int_t iFeetRocIndex = fParam->FindFeetRocId( psubevt->GetSubcrate() );
            if(uNbEvents[iFeetRocIndex] == 0) {
               uFirstEventIndex[iFeetRocIndex] = GetEventNumber();
               // not needed but for safety, happen only once per run!
               for ( UInt_t uChip = 0; uChip < fParam->uNbFeets * 2; uChip++ )
                  FECHIP[uChip].bFirstEpochBlock = kTRUE;
               cout<<"***** First event on Get4 roc "<<iFeetRocIndex<<": "<<uFirstEventIndex[iFeetRocIndex]<<endl;
            } // if(uNbEvents[iFeetRocIndex] == 0)
            else {
               if( 0 < fParam->iEventNbGap &&
                   (Int_t)uPrevEventIndex[iFeetRocIndex] + fParam->iEventNbGap != GetEventNumber() ) {
                  Message(0, "***** 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);
                   for ( UInt_t uChip = 0; uChip < fParam->uNbFeets * 2; uChip++ )
                      FECHIP[uChip].bFirstSyncAfterEventJump = kTRUE;
               } // if not matching expected event gap
            } // else of if(uNbEvents[iFeetRocIndex] == 0)
            uPrevEventIndex[iFeetRocIndex]  = GetEventNumber();
            uNbEvents[iFeetRocIndex]++;
         } // if( -1 != fParam->FindFeetRocId( psubevt->GetSubcrate() ) )
      } // if( kFALSE == fParam->NoGet4Cleaning)
      /*************************************/
   
      if (is_dabc_evt) {
      
         // ignore all irrelevant events
         if (GetTriggerNumber()>8) return;

         roc::Message msg1, msg2;

         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 {
            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()) break;
               }
               shift+=msglen;
            }
            // exclude special epoch message for sync only
            if ((shift==msglen) && msg2.isEpochMsg()) datasize -= msglen;
         }

         // In special case when same sync message is used as trigger, we also can extend
         // our trigger analysis and exclude most messages from the consideration

         if (msg1.isSyncMsg() && msg2.isEpochMsg() && (msg1.getRocNumber()==msg2.getRocNumber())) {
            unsigned rocid = msg1.getRocNumber();
            if (rocid<fNumRocs) ROC[rocid].fStopSyncTm = msg1.getMsgFullTime(msg2.getEpochNumber());
         }
      }

      fTotaldatasize += datasize;

      if (!ROC[rid].fIter.assign(psubevt->GetDataField(), datasize)) return;


      //     cout << "nummsgs = " << datasize << "  len = " << datasize*6 << endl;

      fEvntSize->Fill(datasize);

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

#ifdef   ROC_SINGLETRIGGERMODE
      // first take over incomplete event messages from previous buffer:
      if (ROC[rid].fHasNewTrigger && !ROC[rid].fIsEventComplete &&
               (ROC[rid].fTmpMessages.size() > 0)) {

            //printf("Reassign messages to output event %u\n", ROC[rid].fTmpMessages.size());
            TRocData* devt = dynamic_cast<TRocData*> (fOutputEvent->getEventElement(rid));

            if (devt)
               devt->fExtMessages = ROC[rid].fTmpMessages;

            ROC[rid].fTmpMessages.clear();
         }
#endif


      } // if !IsKeepInputEvent
// END INITIAL EVENT PART

   ROC[rid].fLoopsPerBuffer++;

   uint32_t lastevrocid(0);
   TRocData* rocevent(0);

   roc::Message* data = & ROC[rid].fIter.msg();
//   printf("Start loop for ROCID %d use nx0 %d use nx2 %d\n", rid, nx_use_mask[0], nx_use_mask[2]);








#ifdef   ROC_SINGLETRIGGERMODE
    while (ROC[rid].fIter.next()) {
#else
     bool hasmoredata=false;
     while (!ROC[rid].fIsEventComplete && (hasmoredata=ROC[rid].fIter.next())==true) {
      // JAM: only process messages if current event for this roc is not yet complete.
      // otherwise, we keep input buffer until we look for next event.
#endif
      msgcount++;
      rocid = data->getRocNumber();

      fMsgsPerRoc->Fill(rocid);
      if ((rocid>=fNumRocs) || (ROC[rocid].fMsgTypes==0)) continue;




      ROC[rocid].fHasNewData = kTRUE;

      // SL: extract TRocData from composite event only when it necessary
      // in 99% of cases rocid is not changing and we do not search and dynamic_cast again
      if ((rocevent==0) || (lastevrocid!=rocid)) {
         rocevent = dynamic_cast<TRocData*> (fOutputEvent->getEventElement(rocid));
         lastevrocid = rocid;
         if (fParam->noTrigger && fParam->doSorting) {
            // reprocess unprocessed messages already here, do not let them go back to unprocessed
            // do it only when sorting was requested, otherwise unprocessed should not exists at all
            for (unsigned i=0; i<ROC[rocid].fUnprocessedMsg.size(); i++)
               ProcessExtendedMessage(rocid, rocevent, ROC[rocid].fUnprocessedMsg[i], false);
            ROC[rocid].fUnprocessedMsg.clear(); // is filled again from current event below
         }
      }


#ifndef   ROC_SINGLETRIGGERMODE
      // JAM special case: last event was closed by aux trigger itself, needs to be assigned:
      if (!fParam->globalTrigger || rocid == fParam->masterRoc) {
         if (msgcount > 2 && !ROC[rocid].fHasNewTrigger
               && ROC[rocid].fUnprocessedMsg.size() > 0) {
//            cout << "uuuuuuuuuuuuuu Unprocessed roc:" << rocid
//                  << " with entries" << ROC[rocid].fUnprocessedMsg.size()
//                  << endl;
            if (ROC[rocid].fUnprocessedMsg[0].GetMessageType()
                  == roc::MSG_AUX) {
               int auxid =
                     ROC[rocid].fUnprocessedMsg[0].GetRocMessage().getAuxChNum();
               if (fParam->triggerSignal == (int) auxid) {
                  uint64_t trigtm = ROC[rocid].fUnprocessedMsg[0].GetFullTime();
#ifdef DUMPMODE
                  cout << "Found previous trig MSG- ROC:" << rocid << ", auxid:"
                        << auxid << ", cnt:" << msgcount << endl;
#endif
                  ProcessTriggerMessage(rocevent, rocid, trigtm); // will invoke processextended msg of unprocessed
               }
            }

         }
      }
#endif

      /*************************************/

      typ = data->getMessageType();
      //cout << "MSG- ROC:"<<rocid << ", typ:" <<typ<<", cnt:"<<msgcount<< endl;
#ifdef DUMPALLMESSAGES
      data->printData(roc::msg_print_Human | roc::msg_print_Prefix);
#endif

      double msgtm = 0.;

      if(typ==roc::MSG_GET4) {
         fulltm = data->getMsgFullTime(ROC[rocid].fLastEpoch2[data->getGet4Number()]);
         msgtm = (fulltm % 20000000000000LLU)*1e-9;
      } else {
         fulltm = data->getMsgFullTime(ROC[rocid].fCurrEpoch);
         msgtm = (fulltm % 1000000000000LLU)*1e-9;
      }

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

      TRocMessageExtended exmess(*data,fulltm);

      if (fParam->baselineCalibr && fParam->dynamicPedestal ) {
         Bool_t extTrigHit = kFALSE;
         if (typ == roc::MSG_HIT) {
            if (fParam->ttriMode[rocid][data->getNxNumber()]) {
               extTrigHit = kTRUE;
            }
         }
         if (extTrigHit) {
            fPedestals->ExtractExttrigStream(*data, fulltm);
         } else {
            fPedestals->ExtractAutocalibrStream(*data, fulltm);
         }
      }

      switch (typ)
      {
         case roc::MSG_NOP:
            break;

         case roc::MSG_HIT: {
            nxid = data->getNxNumber();
            nxch = data->getNxChNum();
            nxadc = data->getNxAdcValue();

            if ((nxid >= MAX_NX) || !nx_use_mask[nxid])
               continue;


            Bool_t data_hit(kTRUE), ped_hit(kFALSE);

            if( fParam->baselineCalibr && fParam->dynamicPedestal ) {
                if( fParam->ttriMode[rocid][nxid] ) {
                    if( fParam->dynamicPedestal ) {
                        data_hit = kTRUE;
                        ped_hit = kTRUE;
                    } else {
                        data_hit = kTRUE;
                        ped_hit = kFALSE;
                    }
                } else {
                    switch (fPedestals->GetState(rocid)) {
                        case roc::SYSMSG_USER_CALIBR_OFF:
                            data_hit = kTRUE;
                            ped_hit = kFALSE;
                            break;
                        case roc::SYSMSG_USER_CALIBR_ON:
                            data_hit = kFALSE;
                            ped_hit = kTRUE;
                            break;
                        default: // roc::SYSMSG_USER_RECONFIGURE:
                            data_hit = kFALSE;
                            ped_hit = kFALSE;
                            break;
                    }
                }
            }

//            if (!data_hit && !ped_hit) printf("Undefined hit\n");
//                                 else printf("--------------- Usual hit --------------\n");

            if( data_hit ) {
               ROC[rocid].fNxTm[nxid][nxch] = fulltm;

               ROC[rocid].fHITt[nxid]->Fill(msgtm);

               if (fParam->nxDiffCh >= 0)
               {
                  if (nxch == (unsigned) fParam->nxDiffCh)
                  {
                     for (int ndiff = 0; ndiff < NUM_DIFFS; ndiff++)
                     {
                        int ch2 = ndiff * (MOD_DIFFS + 1) + MOD_DIFFS;
                        double diff = 0.
                              + ROC[rocid].fNxTm[nxid][fParam->nxDiffCh]
                                                       - ROC[rocid].fNxTm[nxid][ch2];
                        if (TMath::Abs(diff) < 1e4)
                           ROC[rocid].fTmDiff[nxid][ndiff]->Fill(diff);
                     }
                  }

                  if (nxch % (MOD_DIFFS + 1) == MOD_DIFFS)
                  {
                     int ndiff = nxch / (MOD_DIFFS + 1);
                     double diff = 0. + ROC[rocid].fNxTm[nxid][fParam->nxDiffCh]
                                                            - ROC[rocid].fNxTm[nxid][nxch];
                     if (TMath::Abs(diff) < 1e4)
                        ROC[rocid].fTmDiff[nxid][ndiff]->Fill(diff);
                  }
               }

               ROC[rocid].fChs[nxid]->Fill(nxch);
               ROC[rocid].fADCs[nxid]->Fill(nxch, nxadc);
               if (fParam->baselineCalibr) {
                  nxadc_corr = fPedestals->GetPedestal(rocid, nxid, nxch) - nxadc;
                  ROC[rocid].fADCs_wo_baseline[nxid]->Fill(nxch, nxadc_corr);
               }
               else {
                  nxadc_corr = 4095 - nxadc;
               }
               ProcessNxHit(data, nxadc_corr);
               // pass message data over to output event
               exmess.SetCorrectedNxADC(nxadc_corr);
               ProcessExtendedMessage(rocid, rocevent, exmess);
            }

            if( ped_hit ) {
                ROC[rocid].fBaseline[nxid]->Fill(nxch, nxadc);
            }

            break;
         }

         case roc::MSG_GET4:
             if (ROC[rocid].bIgnoreData) continue;

             g4id = data->getGet4Number();
             g4ch = data->getGet4ChNum();
             g4fl = data->getGet4Edge();
             
             ROC[rocid].fLastGet4Tm[g4id][g4ch][g4fl] = fulltm;

             if (ROC[rocid].fGet4Chips)
                ROC[rocid].fGet4Chips->Fill(g4id);

             if (ROC[rocid].fGet4Tm[g4id])
                ROC[rocid].fGet4Tm[g4id]->Fill(data->getGet4Ts()/20.);
             
             if (ROC[rocid].fGet4Channels[g4id])
                ROC[rocid].fGet4Channels[g4id]->Fill(g4ch*2 + g4fl);

             if (ROC[rocid].fGet4TmCh[g4id][g4ch][g4fl])
                ROC[rocid].fGet4TmCh[g4id][g4ch][g4fl]->Fill(data->getGet4Ts()/20.);

             ROC[rocid].fGet4ChCnt[g4id][g4ch][g4fl]++;

                // reset counter when changing sign
                if ((ROC[rocid].fGet4EdgeCnt[g4id][g4ch]>0) ^ g4fl) {

                   // calculate difference to last time of different edge
                   uint64_t diff2 = fulltm - ROC[rocid].fLastGet4Tm[g4id][g4ch][1-g4fl];

                   // printf("diff2 = %llu\n", diff2);

                   // lets define interval of +-500 ns around full epoch and test three epochs
                   bool suspicios = false;
                   for (unsigned k=1;k<4;k++)
                      if ((diff2 > (k*26214 - 500)) && (diff2 < (k*26214 + 500))) suspicios = true;

                   ROC[rocid].fGet4ChangeCnt[g4id][g4ch]++;
                   if (suspicios) ROC[rocid].fGet4SuspiciousCnt[g4id][g4ch]++;

                   ROC[rocid].fGet4EdgeCnt[g4id][g4ch] = 0;
                }

              ROC[rocid].fGet4EdgeCnt[g4id][g4ch] += (g4fl ? +1 : -1);

              if (abs(ROC[rocid].fGet4EdgeCnt[g4id][g4ch])>3) {
                 // printout only several first errors
                 if (++ROC[rocid].fGet4ErrCnt[g4id][g4ch]<4)
                    if (fParam->bGet4Debug)
                       printf("**** GET4 EDGE error on roc:%u Get4:%u ch:%u epoch2:%u edgecnt:%d ****\n", rocid, g4id, g4ch, ROC[rocid].fLastEpoch2[g4id], ROC[rocid].fGet4EdgeCnt[g4id][g4ch]);
              }

             if (ROC[rocid].fGet4DiffSync[g4id]) {
                uint64_t ff = roc::Message::FullTimeStamp2(ROC[rocid].fLastEpoch2[g4id] - ROC[rocid].fLastEpoch2Sync[g4id],  data->getGet4Ts());

                ROC[rocid].fGet4DiffSync[g4id]->Fill(ff/20.);
             }

             // a GET4 Data event
             if( kTRUE == fParam->NoGet4Cleaning) {
                exmess.SetRocEpoch(ROC[rocid].fLastEpoch2[data->getGet4Number()]);
                ProcessExtendedMessage(rocid, rocevent, exmess);
             } else
                ProcessGet4DataMessage(rocid, fParam->DefineGet4IndexOffset(rocid), data);

             break;

         case roc::MSG_EPOCH:
            ROC[rocid].fCurrEpoch = data->getEpochNumber();
            //ProcessExtendedMessage(rocid, rocevent, exmess); // NOT anymore used for closing condition of event JAM
            
            if( kFALSE == fParam->NoGet4Cleaning )
            { // Remove all Cleaning related histograms
               if( uLastEpochMainClock > data->getEpochNumber() )
                  uMainEpochCycle++;
               uLastEpochMainClock = data->getEpochNumber();
               if (fDistribEpochsMain) fDistribEpochsMain->Fill(uLastEpochMainClock);
               for ( unsigned int uChip = 0; uChip < fParam->uNbFeets * 2; uChip++ )
                  (FECHIP[uChip].uEpochMainClockSinceLastSync)++; // Main 250MHz clock epoch counter
            } // if( kFALSE == fParam->NoGet4Cleaning)
      /************************************/
            break;

         case roc::MSG_EPOCH2:
            g4id = data->getEpoch2ChipNumber();

            ROC[rocid].ProcessEpoch2(g4id, data->getEpoch2Number(), data->getEpoch2Sync(), fParam->bGet4Debug);

            // disable ignore of input data after two epoch2 with sync
            if (ROC[rocid].bIgnoreData) {
               if (data->getEpoch2Sync() && (++ROC[rocid].fIgnoreCnt > 1)) {
                  ROC[rocid].bIgnoreData = false;
                  if (fParam->bGet4Debug)
                     printf("Enable analysis for roc %d again after two epoch2 with sync epoch2:%u fulltm = %10.6f\n", rocid, data->getEpoch2Number(), fulltm*1e-9);
               }
            }

            // MSG_EPOCH2 describes a GET4 epoch events caused by a 4096 clock
            // cycle epoch of the 156.25 MHz clock.
            if( kFALSE == fParam->NoGet4Cleaning )
               ProcessGet4EpochMessage(rocid, rocevent, fParam->DefineGet4IndexOffset(rocid), data);
            /************************************/
            break;

         case roc::MSG_SYNC:
            syncid = data->getSyncChNum();
            if (syncid < MAX_SYNC)  {
               ROC[rocid].fLastSyncTm[syncid] = fulltm;
               ROC[rocid].fLastSyncId[syncid] = data->getSyncData();
               if (rocevent)
                  rocevent->fLastSyncTm[syncid] = fulltm;
               ROC[rocid].fSYNCt[syncid]->Fill(msgtm);


            if((msgcount<3) && !is_raw_evt) {
               //cout << "Sync message for roc "<<rocid << ", msgcount:" <<msgcount<<", time:"<<fulltm<< endl;
#ifndef ROC_SINGLETRIGGERMODE
               uint64_t oldstartsynctm=ROC[rocid].fStartSyncTm;
//               if(rocid==0)
//               {
//
//                  //cout << "Sync: fulltm:"<<fulltm << ", synctm:" <<synctm<<", oldfulltime:"<<oldstartsynctm<< endl;
//               }
#endif
               ROC[rocid].fStartSyncTm = fulltm;
               ROC[rocid].fDabcSeparator = data->getSyncChNum()+10;


               unsigned mrocid = fParam->masterRoc;
               // try to reintroduce trigger message in local time
               if (AssertRoc(mrocid) && (rocid!=mrocid) && ROC[mrocid].fHasNewTrigger) {
#ifdef ROC_SINGLETRIGGERMODE
                  uint64_t triggertm(0);

                  // TODO: reintroduce calibration coefficients
                  if (ROC[mrocid].fLastTriggerTm > ROC[mrocid].fStartSyncTm)
                     triggertm = ROC[rocid].fStartSyncTm + (ROC[mrocid].fLastTriggerTm - ROC[mrocid].fStartSyncTm);
                  else
                     triggertm = ROC[rocid].fStartSyncTm - (ROC[mrocid].fStartSyncTm - ROC[mrocid].fLastTriggerTm);

                  ProcessTriggerMessage(rocevent, rocid, triggertm);
#else
                  // JAM in multiple trigger mode, we still have to correct the trigger times as distributed from master,
                  // because for first trigger they were related to previous start sync time:

                  if(fParam->globalTrigger && fHasNewGlobalTrigger &&  !ROC[rocid].fHasNewTrigger)
                  {
                      //JAM FIXME: this will fail if we have intermediate buffers without any events on slave stream!
                     ROC[rocid].fLastTriggerTm=ROC[rocid].fLastTriggerTm + ROC[rocid].fStartSyncTm - oldstartsynctm;
                     ROC[rocid].fHasNewTrigger=kTRUE; // JAM this flag avoids that we destroy correct trigger time when time window overlaps with end of buffer
                     HandleUnprocessedMessages(rocevent, rocid); // need to care for unprocessed that were ignored in ProcessTriggerMessage before our correction JAM
#ifdef DUMPMODE
                     cout <<"TTTTTTTTTTTTTTTTTTT Process Subevent corrects slave trigger time"<< ROC[rocid].fLastTriggerTm<<" for roc "<<rocid<<", SHIFT="<< ROC[rocid].fStartSyncTm - oldstartsynctm << endl;
#endif
                  }
#endif
               } // AssertRoc






            }

            if (fParam->triggerSignal == (int) (syncid + 10)) // then may use it for new trigger
               ProcessTriggerMessage(rocevent, rocid, fulltm);

            ProcessExtendedMessage(rocid, rocevent, exmess);

            } // if < MAXSYNC
            break;

         case roc::MSG_AUX:
            auxid = data->getAuxChNum();
            ROC[rocid].fAUXch->Fill(auxid);

            //printf ("ROC%d get AUX%d\n", rocid, auxid);

            if (auxid < MAX_AUX) {
               ROC[rocid].fLastAuxTm[auxid] = fulltm;
               ROC[rocid].fAUXt[auxid]->Fill(msgtm);
            }

            if (fParam->triggerSignal == (int) auxid) {
                ProcessTriggerMessage(rocevent, rocid, fulltm);
#ifdef DUMPMODE
                if (rocid==0) printf("AUX msg = %lu\n", fulltm);
#endif
            }
            ProcessExtendedMessage(rocid, rocevent, exmess);
            break;

         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;
                     if( kFALSE == fParam->NoGet4Cleaning && 0< fParam->uNbBlockJumpedReset)
                     { // Remove all Cleaning related histograms
                        for ( UInt_t uChip = 0; uChip < fParam->uNbFeets * 2; uChip++ )
                        {
                           FECHIP[uChip].bJumpEpochBlockAfterReset = kTRUE;
                           FECHIP[uChip].uNbEpochBlockAfterReset = 0;
                        }
                        uEpochFirstSyncAfterReset = 0;
                        uCycleFirstSyncAfterReset = 0;
                     } // if( kFALSE == fParam->NoGet4Cleaning)

                     uIndexResetGet4 ++; // AUTO reset
                     /*************************************/
                     break;

                  default:
                     // forward all other kinds to next step
                     ProcessExtendedMessage(rocid, rocevent, exmess);
                     break;
               } // switch (data->getSysMesData())
            } // if (data->getSysMesType() == roc::SYSMSG_USER)
            else if (data->getSysMesType() == roc::SYSMSG_ADC)
            {
               int febid = (data->getSysMesData() >> 31) & 1;
               int nch = (data->getSysMesData() >> 24) & 0x7f;
               int val = data->getSysMesData() & 0xffff;
               ROC[rocid].fFebADC[febid]->SetBinContent(nch + 1, val);

               ProcessExtendedMessage(rocid, rocevent, exmess);
            }
            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);

               if(uGet4SysMessType)
               {
                  // Get4 system message type = Sync
                  if( kFALSE == fParam->NoGet4Cleaning)
                     if( kFALSE == ProcessGet4ExtSyncMessage( uGet4IndexOffset, data) )
                        continue;
               } // if(uGet4SysMessType)
               else
               {
                  // Get4 system message type = Error
                  UInt_t uChip = data->getField(40, 8) + uGet4IndexOffset;

                  // Remap the Get4 chip index
                  uChip = fParam->RemapGet4Chip(uChip);

                  if (!fParam->IsValidGet4Chip(uChip)) {
                      cout << "Error: Bad chip nb in Epoch message = " << uChip << endl;
                      cout << " => This message will be skipped!!!! "<<endl;
                      continue;
                  }

                  // SL: FIXME: is it required, message has different format here??
                  data->setGet4Number(uChip);

                  fGet4ErrorChip->Fill( uChip );
                  fGet4ErrorPatt->Fill(uChip, (data->getSysMesData()) & 0x3f);
               } // else of if(uGet4SysMessType)
            } // if( data->getSysMesType() == roc::SYSMSG_GET4_EVENT )
            break;
      /*************************************/      
      } // switch

      // in strict timesorting mode, we may find end of event before processing whole
      // input buffer:
      if(fIsTimeSorted)
      {
         if(ROC[rid].fIsEventComplete)
            {
               //cout <<"STRICT Timesorting mode finds complete event for rocid:"<< rid <<endl;//<<", keep mbs input!" << endl;
               break; // do not stop processing this buffer until we have next trigger!
            }
      }


    } // while


// JAM FIXME: rule single/multitriggermode with parameter, not compiler flags!
   if(fIsTimeSorted)
      {
#ifndef ROC_SINGLETRIGGERMODE
#if __GO4BUILDVERSION__ > 40500
      ROC[rid].fHasEndOfBuffer=!hasmoredata;
#endif
#endif
      }
   //  cout << "Stop processing" << endl;

   fFirstSubEvent = kFALSE;
}



void TRocProc::FinalizeEvent()
{

#ifdef DUMPMODE
    static unsigned count=0;
    static unsigned bcount=0;
#endif

   fOutputEvent->fMbsEventNumber = GetEventNumber();
   // now we should decide if event should be delivered to the output
   // either all used ROCs are ready with their events or sync is used as trigger

   bool allEventComplete(true), isAnyData(false), isAllSyncSepar(true), allInputsComplete(true);

   if ((fAUX2_R01!=0) && AssertRoc(0) && AssertRoc(1) &&
       (ROC[0].fLastAuxTm[2] > ROC[0].fStartSyncTm) &&
       (ROC[1].fLastAuxTm[2] > ROC[1].fStartSyncTm)) {
      int diff0 = ROC[0].fLastAuxTm[2] - ROC[0].fStartSyncTm;
      int diff1 = ROC[1].fLastAuxTm[2] - ROC[1].fStartSyncTm;

      fAUX2_R01->Fill(diff0-diff1);

//      printf ("%5d   %5d %5d\n", diff0-diff1, diff0, diff1);
   }

   if (fSYNC_R0_R10 && AssertRoc(0) && AssertRoc(10)) {
      double diff = ROC[0].fLastSyncTm[1] - ROC[10].fLastSyncTm[0];
      double iddiff = 0. + ROC[0].fLastSyncId[1] - ROC[10].fLastSyncId[0];
      
      if (iddiff != 0) printf("iddiff = %5.0f\n", iddiff);
      
      fSYNC_R0_R10->Fill(diff);
   }

   for (unsigned r=0; r<fNumRocs;r++) {
      if (!AssertRoc(r)) continue;
      TRocData* theRoc = dynamic_cast<TRocData*>(fOutputEvent->getEventElement(r));
      if(theRoc==0) continue;
      
#ifdef ROC_SINGLETRIGGERMODE
      // protection against producing too large history in unprocessed messages in case when AUX used as trigger
      // WORKAROUND - should be done more correctly
       if ((fParam->triggerSignal>=0) && (fParam->triggerSignal<10))
          ROC[r].fUnprocessedMsg.clear(); 
#endif

      if( (theRoc->fExtMessages.size() > 0) || (theRoc->vMessageEventBuffer.size() > 0))
         isAnyData = true;
      /*************************************/


#ifdef ROC_SINGLETRIGGERMODE
      if (!ROC[r].fIsEventComplete && ROC[r].fHasNewTrigger && (ROC[r].fStopSyncTm > ROC[r].fStartSyncTm) && 
            (ROC[r].fStopSyncTm > ROC[r].fLastTriggerTm)) {
         double diff = ROC[r].fStopSyncTm - ROC[r].fLastTriggerTm;

         TGo4WinCond* cond = fParam->globalTrigger ? fGlobalTriggerWind : ROC[r].fTriggerWind;

         double rightdist = diff - cond->GetXUp();
         
         //printf ("ROC%d rightdist %5.1f\n", r, rightdist);
         // if hit far away on right side, event can be close for this ROC
         if (rightdist > 5000.) ROC[r].fIsEventComplete = kTRUE;
      }
#endif
      // we only care about incomplete event if any data at all seen by the ROC!
      if(!ROC[r].fIsEventComplete && ROC[r].fHasNewData) allEventComplete = false;
      if (ROC[r].fDabcSeparator != fParam->triggerSignal) isAllSyncSepar = false;

#ifdef DUMPMODE
      printf("ROC%d event complete = %d\n", r, ROC[r].fIsEventComplete);
#endif

      // multi trigger mode: we only keep current input buffer
      // if we have any data, we are not at the end of buffer and below the break counter conditions
      if( (ROC[r].fHasNewData) && (!ROC[r].fHasEndOfBuffer)
            && (ROC[r].fTriggersPerBuffer<=fParam->maxBufferTriggers)
            && (ROC[r].fLoopsPerBuffer<=fParam->maxBufferLoops))
         {
            allInputsComplete = false;
         }

#ifdef DUMPMODE
      printf("ROC%d buffer complete = %d, has new data: %d\n", r, ROC[r].fHasEndOfBuffer, ROC[r].fHasNewData);
#endif
//
//      if (ROC[r].fTriggersPerBuffer > fParam->maxBufferTriggers) {
//         printf("ROC%d # of triggers %d per buffer exceeds %d \n", r,
//               ROC[r].fTriggersPerBuffer, (int) fParam->maxBufferTriggers);
//         cout << endl;
//      }
//      if (ROC[r].fLoopsPerBuffer > fParam->maxBufferLoops) {
//         printf("ROC%d # of loops %d per buffer exceeds %d\n", r,
//               ROC[r].fLoopsPerBuffer, (int) fParam->maxBufferLoops);
//         cout << endl;
//      }

   } // for r

   if (fParam->noTrigger && isAnyData) allEventComplete = true;
   if (isAllSyncSepar) allEventComplete = true;



   if (allEventComplete) {
#ifdef DUMPMODE
      printf("!!!!!!!!! Event %d is complete !!!!!!!!!\n",count++);
#endif
      for (unsigned rocid=0; rocid<fNumRocs;rocid++) {
         TRocData* theRoc = dynamic_cast<TRocData*>(fOutputEvent->getEventElement(rocid));
         if(theRoc==0) continue;

//#ifndef   ROC_SINGLETRIGGERMODE
      // take over incomplete event messages from previous buffe no sooner than we have completed eventr:
      // this is important if between trigger and closing message are several mbs buffers JAM
      if (ROC[rocid].fTmpMessages.size() > 0) {
#ifdef DUMPMODE
            printf("Event is complete- Insert leftover messages of roc %d to output event %u\n", rocid, ROC[rocid].fTmpMessages.size());
#endif
            theRoc->fExtMessages.insert (theRoc->fExtMessages.end(),ROC[rocid].fTmpMessages.begin(),ROC[rocid].fTmpMessages.end());
            ROC[rocid].fTmpMessages.clear();
         }
//#endif



         Int_t iFeetRocId = fParam->FindFeetRocId(rocid);
         if( -1 != iFeetRocId)
         {
            // Histogram of edge messages/event
            if( kTRUE == fParam->noTrigger )
               fGet4EdgeMessagePerRawEvent->Fill( (theRoc->vMessageEventBuffer).size(), iFeetRocId );
               else if( kFALSE == fParam->NoGet4Cleaning )
               {
                  UInt_t uTotalUnvalidatedMessAccepted = 0;
                  // UInt_t uInitialOutputSize = theRoc->fExtMessages.size();
                  for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++ )
                  {
                     uTotalUnvalidatedMessAccepted += vMessageInterBuffer[ uBuffer ].size();
                     theRoc->fExtMessages.insert( theRoc->fExtMessages.end(),
                                       vMessageInterBuffer[ uBuffer ].begin(),
                                       vMessageInterBuffer[ uBuffer ].end() );
                     vMessageInterBuffer[ uBuffer ].clear();
                  } // for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++ )

                  for( unsigned int uChipCheck = 0; uChipCheck < fParam->uNbFeets*2; uChipCheck++)
                  {
                     FECHIP[uChipCheck].uNotValidatedMessagesAccepted = 0;
                     for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++ )
                     {
                        FECHIP[uChipCheck].uNotValidatedMessagesAccepted += (FECHIP[uChipCheck].fCurrentEventMsg[ uBuffer ]).size();
                        theRoc->fExtMessages.insert( theRoc->fExtMessages.end(),
                                 (FECHIP[uChipCheck].fCurrentEventMsg[ uBuffer ]).begin(),
                                 (FECHIP[uChipCheck].fCurrentEventMsg[ uBuffer ]).end());
                        (FECHIP[uChipCheck].fCurrentEventMsg[uBuffer]).clear();
                     } // for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++ )
                     uTotalUnvalidatedMessAccepted += FECHIP[uChipCheck].uNotValidatedMessagesAccepted;

                     (FECHIP[uChipCheck].fGet4AccMessNotValidated)->Fill( FECHIP[uChipCheck].uNotValidatedMessagesAccepted );
                  } // for( unsigned int uChipCheck = 0; uChipCheck < fParam->uNbFeets*2; uChipCheck++)
                  fGet4NotValidMessRawEvent->Fill( uTotalUnvalidatedMessAccepted, iFeetRocId);
                  fGet4EdgeMessagePerRawEvent->Fill( (theRoc->fExtMessages).size(), iFeetRocId );
               } // else if( kFALSE == fParam->NoGet4Cleaning )
               else fGet4EdgeMessagePerRawEvent->Fill( (theRoc->fExtMessages).size(), iFeetRocId );
         } // if( -1 != iFeetRocId)
      /*************************************/

         if (fParam->doSorting)
         {

/*
            printf("======== Before %u ========== \n", theRoc->fExtMessages.size());
            for (unsigned n=0; n<theRoc->fExtMessages.size();n++)
               theRoc->fExtMessages[n].GetRocMessage().printData();
            printf("======================================================= \n");
*/

            std::sort(theRoc->fExtMessages.begin(), theRoc->fExtMessages.end());
            
            // Only if not trigger window us applied
            if( kTRUE == fParam->noTrigger )
            {
               if( -1 != iFeetRocId)
                  // Time ordering valid get4 data messages
                  if( kFALSE == TimeOrderMessageBuffer( theRoc ) )
                  {
                     // Do something? means it's empty!
                     // => Case should never popup with previous checks...
                  }
            }
      /*************************************/
         }

         ROC[rocid].fEvntMultipl->Fill(theRoc->fExtMessages.size());


//         if (theRoc->fExtMessages.size() == 0) {
//            printf("======== ZERO messages for ROC %d, count %d \n", rocid,
//                  bcount++);
//
//         }

         theRoc->SetValid(kTRUE);

/*
         printf("======== SetValid TRUE %u ========== \n", theRoc->fExtMessages.size());
         for (unsigned n=0; n<theRoc->fExtMessages.size();n++) {
            printf ("Tm: %10llu", theRoc->fExtMessages[n].GetFullTime());
            theRoc->fExtMessages[n].GetRocMessage().printData();
         }
         printf("======================================================= \n");
*/


/*
         unsigned sz = theRoc->fExtMessages.size();
         printf("ROC%d has %u messages\n", rocid, sz);
         for (unsigned n=0;n<sz;n++) {
            printf("  Msg %3u fulltime:%10llu ", n, theRoc->fExtMessages[n].GetFullTime());
            theRoc->fExtMessages[n].GetRocMessage().printData();

            static uint64_t lasttm = 0;
            if (lasttm > theRoc->fExtMessages[n].GetFullTime()) {
               printf ("!!!!!!!!!!!! error with sorting !!!!!!!!!!!!");
               exit(5);
            }
            lasttm = theRoc->fExtMessages[n].GetFullTime();
         }
*/
      }

      fOutputEvent->SetValid(kTRUE);

      ResetTrigger();



   } else {
      fOutputEvent->SetValid(kFALSE);

      // another workaround - try to keep data which could be discarded
      // this is a case when MBS event ends, but we were not able to complete event

      for (unsigned rocid=0; rocid<fNumRocs;rocid++) {
         TRocData* theRoc = dynamic_cast<TRocData*>(fOutputEvent->getEventElement(rocid));
         if(theRoc==0) continue;
#ifdef ROC_SINGLETRIGGERMODE
                        if (ROC[rocid].fHasNewTrigger && !ROC[rocid].fIsEventComplete && theRoc->fExtMessages.size()>0 ){    
#else         
         if (ROC[rocid].fHasNewTrigger && theRoc->fExtMessages.size()>0 ){
#endif
         // do not check if this subevent is not complete, since we have to save anyway if full event is incomplete
         //if (ROC[rocid].fHasNewTrigger && !ROC[rocid].fIsEventComplete && theRoc->fExtMessages.size()>0 ){
               //&& (ROC[rocid].fLastTriggerTm > ROC[rocid].fStartSyncTm)) { // JAM this one will lead to missed events between start and end buffer
#ifdef DUMPMODE
            printf("Very special case - not closed event in ROC %u, saving %d messages\n", rocid,theRoc->fExtMessages.size());
#endif
            //ROC[rocid].fTmpMessages = theRoc->fExtMessages; // JAM this will lead to trouble with complete empty buffers between trigger and closing msg
            ROC[rocid].fTmpMessages.insert(ROC[rocid].fTmpMessages.end(),theRoc->fExtMessages.begin(),theRoc->fExtMessages.end());
            theRoc->fExtMessages.clear();
         }
      }
   }



   // was triggered by parameter update
   if(fParam->storePedestalFile && (fParam->pedSaveToFile.Length()>0))  {
      fParam->storePedestalFile = kFALSE;
      if(fPedestals) fPedestals->SaveToFile( fParam->pedSaveToFile.Data());
   }

   if(GetTriggerNumber()>8)
   {
          //ignore pulser events in spill pause for the moment
          fOutputEvent->SetValid(kFALSE);
   }

   // Decide if we need to keep input event or request next one when all buffers are done:

   if(fIsTimeSorted)
        {
            if(allInputsComplete)
            {

#ifdef DUMPMODE
                   cout <<"STRICT Timesorting mode finds all input buffers processed. Get new mbs input "<<bcount++ << endl;
#endif

#if __GO4BUILDVERSION__ > 40500
                   SetKeepInputEvent(kFALSE); // request new mbs container
#endif
                   ResetEndOfBuffer();
            }
            else
            {
#ifdef DUMPMODE
             cout <<"STRICT Timesorting mode sets KEEP mbs input!" << endl;
#endif
#if __GO4BUILDVERSION__ > 40500

                   SetKeepInputEvent(kTRUE);  // unless we have processed buffers of all rocs completely, we keep input
#endif
            }

        }


#ifdef ROC_SINGLETRIGGERMODE
      ResetEndOfBuffer(); // necessary to enter initialization part for each roc
#endif


   // calculation of the rate:
     double tm = TTimeStamp().AsDouble();
     double diff = tm - fLastRateTm;
     if (diff>1.) {
        double rate = fTotaldatasize / diff;
        if (fRate==0.) fRate = rate;
        fRate = fRate * 0.9 + rate * 0.1;
        fEvntSize->SetTitle(Form("RATE %5.1f KB/s", fRate/1024.));
        fTotaldatasize = 0;
        fLastRateTm = tm;
     }


    //printf(" =============== TRocProc::FinalizeEvent ===================\n ");
}


void TRocProc::ProcessExtendedMessage(unsigned rocid, TRocData* rocevent, TRocMessageExtended& exmsg, bool with_unprocessed)
{
   bool isinside(false), add_to_unprocessed(false), add_to_event(false);

   double diff = 0;

   if (ROC[rocid].fLastTriggerTm!=0) {
      if(exmsg.GetFullTime() >= ROC[rocid].fLastTriggerTm)
         diff = exmsg.GetFullTime() - ROC[rocid].fLastTriggerTm;
      else
         diff = -1.0 * (ROC[rocid].fLastTriggerTm - exmsg.GetFullTime());

   //if(with_unprocessed) cout << "       dt="<<diff<< endl;
   }

   if (fParam->noTrigger) {

      // to avoid situation when sorting over buffer boundary should be done,
      // only messages which are far away from last sync message, will be accepted into output event

      if (!fParam->doSorting || (ROC[rocid].fStopSyncTm==0)) {
         add_to_event = true;
      } else {
         if (exmsg.GetFullTime() + 16000 < ROC[rocid].fStopSyncTm)
            add_to_event = true;
         else
            add_to_unprocessed = true;
      }
   } else
   if (ROC[rocid].fHasNewTrigger) {

      TGo4WinCond* cond = fParam->globalTrigger ? fGlobalTriggerWind : ROC[rocid].fTriggerWind;
      TGo4WinCond* eventcond=cond; // only use this window for event building! JAM
      if(exmsg.GetMessageType() == roc::MSG_AUX)
         cond = fParam->globalTrigger ? fGlobalAUXWind : ROC[rocid].fAUXWind;

      exmsg.SetTriggerDeltaT(diff);

      if (cond->Test(diff)) {
         add_to_event = true;
         isinside = true;
      } else {
         double rightdist = diff - eventcond->GetXUp();
         if(fIsTimeSorted)
            {
               // we assume that message stream was strictly time sorted by dabc/ or go4 lmd user source JAM
               //if (rightdist>0.){
               // test: only real hits may close
               if (rightdist>0. && (exmsg.GetMessageType() != roc::MSG_SYNC || fParam->triggerSignal>9 )) {
                  // JAM in aux trigger mode, we do not allow sync messages to close event window
                  ROC[rocid].fIsEventComplete = kTRUE;
//                  ROC[rocid].fHasNewTrigger= kFALSE; // everything after us is buffered until next trigger is found
//                  if(fParam->globalTrigger && rocid==fParam->masterRoc)
//                     fHasNewGlobalTrigger=kFALSE; // in master mode, enable accepting new trigger immediately!
                  add_to_unprocessed = kTRUE; // keep this message for next event.
#ifdef DUMPMODE
                  cout <<"STRICT Timesorting mode marks complete event with msgtype:"<< (int) exmsg.GetMessageType() <<" for roc:"<<rocid<<" at dt="<<rightdist << endl;
#endif
               }
            }
         else
            {
         //BEGIN NOT STRICTLY SORTED, 1 EVENT PER MBS CONTAINER, for fast online monitoring  JAM
                  // if hit far away on right side, event can be close for this ROC
                  if (rightdist > 5000.) ROC[rocid].fIsEventComplete = kTRUE;
                  if (rightdist>0.) {
                     if (ROC[rocid].fStopSyncTm==0) {
                        add_to_unprocessed = true;
                     } else {
                        double diff2 = 0;
                        if(exmsg.GetFullTime() >= ROC[rocid].fStopSyncTm)
                           diff2 = exmsg.GetFullTime() - ROC[rocid].fStopSyncTm;
                        else
                           diff2 = -1.0 * (ROC[rocid].fStopSyncTm - exmsg.GetFullTime());

                        // only keep message if it have chance to go into next event
                        add_to_unprocessed = diff2 >= cond->GetXLow();

                        // if (add_to_unprocessed && (rocid==0)) printf("diff2 = %7.1f\n", diff2);
                     }
                  }
         // END NOT STRICTLY
            } //if(fIsTimeSorted)
      } // if (cond->Test(diff))
   } // if (ROC[rocid].fHasNewTrigger)
   else 
   {
     // if no new trigger was found up to now, we need to add message to unprocessed
     // at the end of the message we should check if unprocessed messages are still interesting
     add_to_unprocessed = true;
   }

   //cout <<"....... isinside="<<isinside<<", add2event="<<add_to_event<<", add2unprocessed="<< add_to_unprocessed<< endl;

   if(isinside && (exmsg.GetMessageType() == roc::MSG_HIT)) { // but we put only nx hist to local histograms...
      unsigned nxid = exmsg.GetNxNumber();
      unsigned nxch = exmsg.GetNxChNum();
          unsigned nxadc = exmsg.GetNxADC();
      if (ROC[rocid].fTrigger_Chs[nxid])
         ROC[rocid].fTrigger_Chs[nxid]->Fill(nxch);
      if (ROC[rocid].fTrigADCs[nxid])
         ROC[rocid].fTrigADCs[nxid]->Fill(nxch, nxadc);
   }

    if((exmsg.GetMessageType() == roc::MSG_HIT || exmsg.GetMessageType() == roc::MSG_GET4) && (diff!=0)) {
     // if (rocid==0) printf("Diff = %9.1f\n", diff);
      fDeltaTriggerTime->Fill(diff);
      ROC[rocid].fTrigger_AllNX->Fill(diff);
      ROC[rocid].fTrigger_AllNX_100->Fill(diff);
      if(exmsg.GetMessageType() == roc::MSG_HIT) {
         unsigned nxid = exmsg.GetNxNumber();
         if (ROC[rocid].fTrigger_NX[nxid])
            ROC[rocid].fTrigger_NX[nxid]->Fill(diff);
      }

      if(exmsg.GetMessageType() == roc::MSG_GET4) {
         unsigned g4 = exmsg.GetGet4Number();
         if (ROC[rocid].fGet4Trigger[g4])
            ROC[rocid].fGet4Trigger[g4]->Fill(diff);
         if (ROC[rocid].fGet4Trigger100[g4])
            ROC[rocid].fGet4Trigger100[g4]->Fill(diff);
      }
   }

   if(exmsg.GetMessageType() == roc::MSG_AUX) {
      ROC[rocid].fTrigger_AUX->Fill(diff);
   }


   if(exmsg.GetMessageType() == roc::MSG_EPOCH)
   {
      // we use epoch messages to finish event time window, but do not want it stored.
      add_to_unprocessed=kFALSE;
      add_to_event=kFALSE;

   }

   if (rocevent && add_to_event)
      rocevent->fExtMessages.push_back(exmsg);

   if (add_to_unprocessed && with_unprocessed)
      ROC[rocid].fUnprocessedMsg.push_back(exmsg);
}

void TRocProc::ResetTrigger()
{
#ifdef DUMPMODE
   cout <<"RRRRRRRRRRRR ResetTrigger" << endl;
#endif
   fHasNewGlobalTrigger = kFALSE;
   for (unsigned n=0; n<fNumRocs;n++)
   {
      ROC[n].fIsEventComplete = kFALSE;

      // why this JAM?V
//#ifdef ROC_SINGLETRIGGERMODE
 //     if (ROC[n].fHasEndOfBuffer) ROC[n].fHasNewData = kFALSE;
//#endif
      ROC[n].fHasNewTrigger = kFALSE;
// SL: we keep last trigger time for histogramm filling
//      ROC[n].fLastTriggerTm = 0;
      ROC[n].fDabcSeparator = -1;

   }
}


void TRocProc::ResetEndOfBuffer()
{
#ifdef DUMPMODE
   cout <<"RRRRRRRRRRRR ResetEndOfBuffer:" << endl;
#endif

   for (unsigned n=0; n<fNumRocs;n++)
   {
#ifdef DUMPMODE
      cout <<" Roc"<<n<<" triggers:"<<  ROC[n].fTriggersPerBuffer <<", loops:"<<ROC[n].fLoopsPerBuffer<< endl;
#endif
      ROC[n].fTriggersPerBuffer=0;
      ROC[n].fLoopsPerBuffer=0;
      ROC[n].fHasEndOfBuffer = kFALSE;
      ROC[n].fHasNewData = kFALSE;
   }

   ;
}

/**********************************************************************/
/*
 * This function process the data message when it is a GET4 epoch message
 */
Bool_t TRocProc::ProcessGet4EpochMessage(UInt_t uRocId, TRocData* rocEvent, UInt_t uGet4IndexOffset, roc::Message* mesData)
{
   // each GET4 chip generates epoch events
   UInt_t uChip = mesData->getEpoch2ChipNumber() + uGet4IndexOffset;
   
   // Remap the Get4 chip index
   uChip = fParam->RemapGet4Chip(uChip);

   // SL: test if chip ID is inside valid range
   if (!fParam->IsValidGet4Chip(uChip)) {
      TGo4Log::Error("Wrong chip id %u",uChip);
      return kFALSE;
   }

   mesData->setEpoch2ChipNumber(uChip);

  
   // Print debug data in the analysis log window for the
   // "fParam->uGet4Print" first messages
   if(printData<fParam->uGet4Print  )
   {
      // Print the informations of this epoch message
      Message(0,"Epoch chip %2d, ROC epoch %7d cycle %6d, local epoch %7d cycle %6d, Synched? %d, Loss? %d, Event %u, Un %d, Un Tot %d",
               uChip, mesData->getEpoch2Number(), FECHIP[uChip].uRocEpochCycle, FECHIP[uChip].uLocalEpochNb,
               FECHIP[uChip].uLocalEpochCycle,( mesData->getEpoch2Sync() != 0 ), ( mesData->getEpoch2DataLost() != 0 ),
               uNbEvents[0], FECHIP[uChip].uUnsyncedEpochs, FECHIP[uChip].uUnsyncedEpochsSinceLastSync);
      Message(0,"First synced epoc %7d, First Synced cycle %6d, shift last %3d, Status shift: %1d %1d %1d %1d %1d %1d",
                uRocEpochFirstSyncedChip, uRocCycleFirstSyncedChip, FECHIP[uChip].iInterChipEpochShiftLast,
                FECHIP[0].bChipGotASync, FECHIP[1].bChipGotASync, FECHIP[2].bChipGotASync, FECHIP[3].bChipGotASync, 
                FECHIP[4].bChipGotASync, FECHIP[5].bChipGotASync);
      PrintLocalEpochIndexes( 0 );
      PrintRocEpochIndexes( 0 );
      Message(0, "Current Buffer: %2d", FECHIP[uChip].uCurrentMessagesBuffer);
      printData++;
   }
    
   // Test if chip is software disabled
   if( !fParam->uGet4Active[uChip] )
      return kTRUE;

   if( GET4_BUFFERS_SIZE_LIMIT < (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessagesBuffer ]).size() ||
       GET4_BUFFERS_SIZE_LIMIT < (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessagesBuffer ]).size()  )
   {
      Message(1,"Get4 warning: buffer on chip %2u reached the limit size of %uk messages: current size %6d",
            uChip, GET4_BUFFERS_SIZE_LIMIT/1000, (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessagesBuffer ]).size());
      Message(1," => Check the active chips parameters, if OK there is probably oscillations!");
      Message(1," => Buffer will be cleared");
      (FECHIP[uChip].fCurrentEventMsg[       FECHIP[uChip].uCurrentMessagesBuffer ]).clear();
      (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessagesBuffer ]).clear();
   }

   for( UInt_t uBufferTemp = 0; uBufferTemp < fParam->uNbBuffers; uBufferTemp ++)
      if( GET4_BUFFERS_SIZE_LIMIT <  vMessageInterBuffer[ uBufferTemp ].size() ||
          GET4_BUFFERS_SIZE_LIMIT <  vMessageInterBufferUnprocessed[ uBufferTemp ].size()  )
      {
         Message(1,"Get4 warning: inter buffer #%2u reached the limit size of %uk messages: current size %6d",
               uBufferTemp, GET4_BUFFERS_SIZE_LIMIT/1000, vMessageInterBuffer[ uBufferTemp ].size());
         Message(1," => Check the active chips parameters, if OK there is probably oscillations!");
         Message(1," => Buffer will be cleared");
         vMessageInterBuffer[uBufferTemp].clear();
         vMessageInterBufferUnprocessed[uBufferTemp].clear();
      }

   // bLossFlag indicates whether some data were lost for this
   // get4 in ROC buffer during this epoch
   Bool_t bLossFlag = ( mesData->getEpoch2DataLost() != 0 );
   
   // bSyncFlag indicates whether the GET4 asic was synchronised
   // in this epoch
   Bool_t bSyncFlag = ( mesData->getEpoch2Sync() != 0 );
   
   if( bLossFlag )
   {
      fGet4DataLoss->Fill( uChip );
      if ( uChip >= 0 && uChip < fParam->uNbFeets * 2 )
         FECHIP[uChip].uLastEpoch2 = mesData->getEpoch2Number();
      
      if( 0 == fParam->uSilentMode )
      {
         Message(3,"****** Data Loss on chip %2d in epoch %7d cycle %6d (local epoch %7d cycle %6d) Synched? %d, Event %u, Un %d, Un Tot %d",
                     uChip, mesData->getEpoch2Number(), FECHIP[uChip].uRocEpochCycle, FECHIP[uChip].uLocalEpochNb,
                     FECHIP[uChip].uLocalEpochCycle,bSyncFlag, uNbEvents[0],
                     FECHIP[uChip].uUnsyncedEpochs, FECHIP[uChip].uUnsyncedEpochsSinceLastSync);
         PrintMessageBufferIndexes( 0 );
         PrintMessageBufferSizes( 0 );
      }
      FECHIP[uChip].bDataLossSinceLastSync = kTRUE;
      return kFALSE;
   }

   // Analyses works now with a variable number of FEET boards
   // e.g. fParam->uNbFeets * 2 GET4 ASICs
   if ( uChip >= 0 && uChip < fParam->uNbFeets * 2 )
   {         
      fDistribEpochsRoc->Fill(uChip, (UInt_t)(mesData->getEpoch2Number()) );
      fDistribEpochsLocal->Fill(uChip, FECHIP[uChip].uLocalEpochNb );
      (FECHIP[uChip].uLocalEpochNb)++;
      
      // uLastEpoch contains the current epoch number
      if( mesData->getEpoch2Number() < (FECHIP[uChip].uLastEpoch2) )
      {
         (FECHIP[uChip].uRocEpochCycle)++;
      }             
         
      // uLastEpoch contains the current epoch number
      if( FECHIP[uChip].uLocalEpochNb == fParam->uRocCycleSize)
      {
         (FECHIP[uChip].uLocalEpochCycle)++;
         FECHIP[uChip].uLocalEpochNb = 0;
         if( 1 == fParam->uDebugHistoOn )
         {
            //Update DNL histograms
            for (UInt_t uChan = 0; uChan < NB_CHAN_GET4; uChan++) 
            {
               Double_t dDnlLeading = 0;
               Double_t dSumLeading = 0;
               Double_t dDnlTrailing = 0;
               Double_t dSumTrailing = 0;
               
               // First Resets everything
               (FECHIP[uChip].fGet4LeDnl)[uChan]->Reset();
               (FECHIP[uChip].fGet4LeDnlSum)[uChan]->Reset();
               (FECHIP[uChip].fGet4TeDnl)[uChan]->Reset();
               (FECHIP[uChip].fGet4TeDnlSum)[uChan]->Reset();
         
               // First bin
               dDnlLeading = ((FECHIP[uChip].fGet4FineTimeLE)[uChan]->GetBinContent(1)- 
                                    ((FECHIP[uChip].fGet4FineTimeLE)[uChan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS) ) /
                                 ((FECHIP[uChip].fGet4FineTimeLE)[uChan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS);
               (FECHIP[uChip].fGet4LeDnl)[uChan]->Fill( 0.0, dDnlLeading);
               dSumLeading += dDnlLeading;
               (FECHIP[uChip].fGet4LeDnlSum)[uChan]->Fill( 0.0, dSumLeading );
               
               dDnlTrailing = ((FECHIP[uChip].fGet4FineTimeTE)[uChan]->GetBinContent(1)- 
                                    ((FECHIP[uChip].fGet4FineTimeTE)[uChan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS) ) /
                                 ((FECHIP[uChip].fGet4FineTimeTE)[uChan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS);
               (FECHIP[uChip].fGet4TeDnl)[uChan]->Fill( 0.0, dDnlTrailing );
               dSumTrailing += dDnlTrailing;
               (FECHIP[uChip].fGet4TeDnlSum)[uChan]->Fill( 0.0, dSumTrailing );
               
               for( Int_t iBin = 2; iBin <= NB_BIN_GET4_FTS; iBin++)
               {
                  dDnlLeading = ((FECHIP[uChip].fGet4FineTimeLE)[uChan]->GetBinContent(iBin)- 
                                       ((FECHIP[uChip].fGet4FineTimeLE)[uChan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS) ) /
                                 ((FECHIP[uChip].fGet4FineTimeLE)[uChan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS);
                  (FECHIP[uChip].fGet4LeDnl)[uChan]->Fill( (Double_t)(iBin-1), dDnlLeading );
                  dSumLeading += dDnlLeading;
                  (FECHIP[uChip].fGet4LeDnlSum)[uChan]->Fill( (Double_t)(iBin-1), dSumLeading );
                  
                  dDnlTrailing = ((FECHIP[uChip].fGet4FineTimeTE)[uChan]->GetBinContent(iBin)- 
                                       ((FECHIP[uChip].fGet4FineTimeTE)[uChan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS) ) /
                                 ((FECHIP[uChip].fGet4FineTimeTE)[uChan]->GetEntries()/(Double_t)NB_BIN_GET4_FTS);
                  (FECHIP[uChip].fGet4TeDnl)[uChan]->Fill( (Double_t)(iBin-1), dDnlTrailing );
                  dSumTrailing += dDnlTrailing;
                  (FECHIP[uChip].fGet4TeDnlSum)[uChan]->Fill( (Double_t)(iBin-1), dSumTrailing );
               } // for( Int_t iBin = 2; iBin <= NB_BIN_GET4_FTS; iBin++)
            } // for (Int_t uChan = uChip*4; uChan < (uChip+1)*4; uChan++) 
         } // if( 1 == uDebugHistoOn )
      } // if( FECHIP[uChip].uLocalEpochNb == fParam->uRocCycleSize)
      
      FECHIP[uChip].uLastEpoch2 = mesData->getEpoch2Number();

      if( 1 == fParam->uUseLocalEpochs)
      {
         uCurrentEpoch2 = FECHIP[uChip].uLocalEpochNb;
         uCurrentCycle2 = FECHIP[uChip].uLocalEpochCycle;
      }
      else
      {
         uCurrentEpoch2 = mesData->getEpoch2Number();
         uCurrentCycle2 = FECHIP[uChip].uRocEpochCycle;
      }
      
      if ( bSyncFlag )
      {
         // Reject everything before the first synchronization!
         if( FECHIP[uChip].bFirstEpochBlock == kTRUE)
         {
            for(UInt_t uChipTemp = 0; uChipTemp < 2*fParam->uNbFeets; uChipTemp++ )
                  if( kTRUE == FECHIP[uChipTemp].bFirstEpochBlock && 1 == FECHIP[uChipTemp].uNbEpochBlockAfterReset
                        && 0 == FECHIP[uChip].uNbEpochBlockAfterReset
                        && 15 < FECHIP[uChipTemp].uUnsyncedEpochsSinceLastSync)
                  {
                     Message(0,"Jump chip %2d which started earlier than others: %7d epoch since first sync!",
                               uChipTemp, FECHIP[uChipTemp].uUnsyncedEpochsSinceLastSync);
                     FECHIP[uChipTemp].uNbEpochBlockAfterReset = 0;
                     FECHIP[uChipTemp].uUnsyncedEpochsSinceLastSync = 0;
                  }

            if( 1 == FECHIP[uChip].uNbEpochBlockAfterReset )
               FECHIP[uChip].bFirstEpochBlock = kFALSE;
            
            FECHIP[uChip].uLocalEpochCycle = 0;
            FECHIP[uChip].uLocalEpochNb    = 0;
            
            // clear the "fParam->uSyncCycleSize" epochs data message & epochs number buffers
            for( UInt_t uBuffer = 0; uBuffer < fParam->uNbBuffers; uBuffer ++)
            {
               (FECHIP[uChip].fCurrentEventMsg)[uBuffer].clear();
               (FECHIP[uChip].fCurrentUnprocessedMsg)[uBuffer].clear();
            }
            FECHIP[uChip].uCurrentMessagesBuffer = 0;
            
            if( 1 == fParam->uUseLocalEpochs)
            {
               FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochNb;
               FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochCycle;
            }
            else
            {
               FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLastEpoch2;
               FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uRocEpochCycle;
            }

            // Reset the variable storing the total nb of messages
            // buffered at the end of last epoch
            // (Overkill, but safer)
            FECHIP[uChip].u_messageCountLastEpoch = 0;
            
            // the number of unsynced epochs is reseted here
            FECHIP[uChip].uUnsyncedEpochs = 0;
            FECHIP[uChip].uUnsyncedEpochsSinceLastSync = 0;
            FECHIP[uChip].bDataLossSinceLastSync = kFALSE;
            FECHIP[uChip].cAutomaticFakeSyncSinceLastSync = 0;
                     
            FECHIP[uChip].uEpochMainClockSinceLastSync = 0;
            
            
            FECHIP[uChip].bFirstSyncAfterEventJump = kFALSE;
            
            FECHIP[uChip].bChipGotASync = kTRUE;
            uRocEpochFirstSyncedChip = 0;
            uRocCycleFirstSyncedChip = 0;
            FECHIP[uChip].iInterChipEpochShiftLast = 0;

            // Preparing modulo debug variables
            FECHIP[uChip].uModuloLastSynch = mesData->getEpoch2Number()%(fParam->uSyncCycleSize);
            FECHIP[uChip].uCycleLastSynch = FECHIP[uChip].uRocEpochCycle;
            if( 1 == FECHIP[uChip].uNbEpochBlockAfterReset )
            {
               Message(1,"Here we start for chip %2d (1st sync just passed, Roc epoch %10d, cycle %6d)",
                     uChip, FECHIP[uChip].uLastEpoch2, FECHIP[uChip].uRocEpochCycle);
               PrintMessageBufferIndexes( 0 );
               PrintLocalEpochIndexes( 0 );
               PrintLocalEpochCycles( 0 );
            }

            FECHIP[uChip].bJumpEpochBlockAfterReset = kFALSE;
            if( 1 == FECHIP[uChip].uNbEpochBlockAfterReset )
               FECHIP[uChip].uNbEpochBlockAfterReset = 0;
               else FECHIP[uChip].uNbEpochBlockAfterReset ++;
            
            // Goes on without doing anything else
            return kTRUE;
         } // if( FECHIP[uChip].bFirstEpochBlock == kTRUE)
            
         // Reject everything in fParam->uNbBlockJumpedReset epoch blocks
         // after a GET4 reset message has been received
         // 2*27µs + 37µs = ~100µs data thronw out
         if( FECHIP[uChip].bJumpEpochBlockAfterReset == kTRUE)
         {
            if( 0 == uEpochFirstSyncAfterReset && 0 == uCycleFirstSyncAfterReset)
            {
               if( 1 == fParam->uUseLocalEpochs)
               {
                  uEpochFirstSyncAfterReset = FECHIP[uChip].uLocalEpochNb;
                  uCycleFirstSyncAfterReset = FECHIP[uChip].uLocalEpochCycle;
               }
               else
               {
                  uEpochFirstSyncAfterReset = FECHIP[uChip].uLastEpoch2;
                  uCycleFirstSyncAfterReset = FECHIP[uChip].uRocEpochCycle;
               }
            }
            /*
             * For now no check on Epoch cycle, should not matter with new version of
             * ROC firmware!!!
             */
            ULong64_t ulHighestStartEpoch = 0;
            ULong64_t ulLocalEpochHighestStart = 0;
            UInt_t    uBufferWithHighestStart = 0;
            UInt_t    uInterBufferWithHighestStart = 0;
            Bool_t    bTestFirstAfterReset = kTRUE;
            for ( UInt_t uChipTemp = 0; uChipTemp < fParam->uNbFeets * 2; uChipTemp++ )
            {
               if( !fParam->uGet4Active[uChipTemp] )
                  continue;
               if( 0 < FECHIP[uChipTemp].uNbEpochBlockAfterReset )
               {
                  bTestFirstAfterReset = kFALSE;
                  break;
               }
               for( UInt_t uBufferTemp = 0; uBufferTemp < fParam->uNbBuffers; uBufferTemp ++)
                  if( ulHighestStartEpoch < FECHIP[uChipTemp].uEpochStart[uBufferTemp] )
                  {
                     ulHighestStartEpoch = FECHIP[uChipTemp].uEpochStart[uBufferTemp];
                     ulLocalEpochHighestStart = FECHIP[uChipTemp].uLocalEpochNb;
                     uBufferWithHighestStart = uBufferTemp;
                     uInterBufferWithHighestStart = FECHIP[uChipTemp].uCurrentMessageInterBuffer;
                  }
            }
            if( kTRUE == bTestFirstAfterReset )
            {
               for ( UInt_t uChipTemp = 0; uChipTemp < fParam->uNbFeets * 2; uChipTemp++ )
               {
                  if( !fParam->uGet4Active[uChipTemp] )
                     continue;
                  for( UInt_t uBufferTemp = 0; uBufferTemp < fParam->uNbBuffers; uBufferTemp ++)
                  {
                     if( FECHIP[uChipTemp].uEpochStart[uBufferTemp] < ulHighestStartEpoch )
                     {
                        (FECHIP[uChipTemp].fCurrentEventMsg)[uBufferTemp].clear();
                        (FECHIP[uChipTemp].fCurrentUnprocessedMsg)[uBufferTemp].clear();
                     }
                  }

                  FECHIP[uChipTemp].uCurrentMessagesBuffer = uBufferWithHighestStart;
                  FECHIP[uChipTemp].uCurrentMessageInterBuffer = uInterBufferWithHighestStart;
                  FECHIP[uChipTemp].uEpochStart[FECHIP[uChipTemp].uCurrentMessagesBuffer] = 0;
                  FECHIP[uChipTemp].uCycleStart[FECHIP[uChipTemp].uCurrentMessagesBuffer] = 0;

                  FECHIP[uChipTemp].uLocalEpochNb = ulLocalEpochHighestStart;
               }
            }

            (FECHIP[uChip].uNbEpochBlockAfterReset)++;
            
            Message(0,"Throwing Epoch block for chip %2d because of GET4 reset: block %2d (Epoch %11d, local %11d, %11d %7d, %d)",
                      uChip,FECHIP[uChip].uNbEpochBlockAfterReset,  FECHIP[uChip].uLastEpoch2, FECHIP[uChip].uLocalEpochNb,
                      uEpochFirstSyncAfterReset, uCycleFirstSyncAfterReset, FECHIP[uChip].uCurrentMessagesBuffer);
            
            if( 1 == fParam->uUseLocalEpochs)
            {
               if( fParam->uNbBlockJumpedReset == FECHIP[uChip].uNbEpochBlockAfterReset)
               {
                  FECHIP[uChip].bJumpEpochBlockAfterReset = kFALSE;
                  FECHIP[uChip].uNbEpochBlockAfterReset = 0;
               }
            }
               else if( ( uEpochFirstSyncAfterReset + (fParam->uNbBlockJumpedReset -1) * fParam->uSyncCycleSize
                           <= FECHIP[uChip].uLastEpoch2 ) ||
                   uCycleFirstSyncAfterReset < FECHIP[uChip].uRocEpochCycle )
               {
                  FECHIP[uChip].bJumpEpochBlockAfterReset = kFALSE;
                  FECHIP[uChip].uNbEpochBlockAfterReset = 0;
               }
            
            // clear the "fParam->uSyncCycleSize" epochs data message & epochs number buffers
            (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
            (FECHIP[uChip].fCurrentUnprocessedMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
            
            Int_t iNbEpochToIgnore = FECHIP[uChip].uUnsyncedEpochs + 1;

            if( (Int_t)(FECHIP[uChip].uLocalEpochNb) < iNbEpochToIgnore )
            {
               (FECHIP[uChip].uLocalEpochCycle)--;
               FECHIP[uChip].uLocalEpochNb = fParam->uRocCycleSize
                                              + FECHIP[uChip].uLocalEpochNb
                                              - iNbEpochToIgnore ;
            }
            else if( fParam->uRocCycleSize < (FECHIP[uChip].uLocalEpochNb - iNbEpochToIgnore ) )
            {
               (FECHIP[uChip].uLocalEpochCycle)++;
               FECHIP[uChip].uLocalEpochNb = FECHIP[uChip].uLocalEpochNb - iNbEpochToIgnore
                                                           - fParam->uRocCycleSize;
            }
            else
               FECHIP[uChip].uLocalEpochNb -= iNbEpochToIgnore;
            if( 1 == fParam->uUseLocalEpochs)
            {
               FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochNb;
               FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochCycle;
            }
            else
            {
               FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLastEpoch2;
               FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uRocEpochCycle;
            }

            // Reset the variable storing the total nb of messages
            // buffered at the end of last epoch
            // (Overkill, but safer)
            FECHIP[uChip].u_messageCountLastEpoch = 0;
            
            // the number of unsynced epochs is reseted here
            FECHIP[uChip].uUnsyncedEpochs = 0;
            FECHIP[uChip].uUnsyncedEpochsSinceLastSync = 0;
            FECHIP[uChip].bDataLossSinceLastSync = kFALSE;
            FECHIP[uChip].cAutomaticFakeSyncSinceLastSync = 0;
                     
            FECHIP[uChip].uEpochMainClockSinceLastSync = 0;

            // Preparing modulo debug variables
            FECHIP[uChip].uModuloLastSynch = mesData->getEpoch2Number()%(fParam->uSyncCycleSize);
            FECHIP[uChip].uCycleLastSynch = FECHIP[uChip].uRocEpochCycle;
            
            // Goes on without doing anything else
            return kTRUE;
         } // if( FECHIP[uChip].bJumpEpochBlockAfterReset == kTRUE)
         
         // To survive missing events with a stream server
         if( FECHIP[uChip].bFirstSyncAfterEventJump == kTRUE)
         {
            FECHIP[uChip].bFirstSyncAfterEventJump = kFALSE;
            
            // clear the "fParam->uSyncCycleSize" epochs data message & epochs number buffers
            (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
            (FECHIP[uChip].fCurrentUnprocessedMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
            
            Int_t iNbEpochToIgnore = FECHIP[uChip].uUnsyncedEpochs + 1;
               
            if( (Int_t)(FECHIP[uChip].uLocalEpochNb) < iNbEpochToIgnore )
            {
               (FECHIP[uChip].uLocalEpochCycle)--;
               FECHIP[uChip].uLocalEpochNb = fParam->uRocCycleSize
                                              + FECHIP[uChip].uLocalEpochNb
                                              - iNbEpochToIgnore ;
            }
            else if( fParam->uRocCycleSize < (FECHIP[uChip].uLocalEpochNb - iNbEpochToIgnore ) )
            {
               (FECHIP[uChip].uLocalEpochCycle)++;
               FECHIP[uChip].uLocalEpochNb = FECHIP[uChip].uLocalEpochNb - iNbEpochToIgnore
                                                           - fParam->uRocCycleSize;
            }
            else
               FECHIP[uChip].uLocalEpochNb -= iNbEpochToIgnore;
            if( 1 == fParam->uUseLocalEpochs)
            {
               FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochNb;
               FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochCycle;
            }
            else
            {
               FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLastEpoch2;
               FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uRocEpochCycle;
            }

            // Reset the variable storing the total nb of messages
            // buffered at the end of last epoch
            // (Overkill, but safer)
            FECHIP[uChip].u_messageCountLastEpoch = 0;
            
            // the number of unsynced epochs is reseted here
            FECHIP[uChip].uUnsyncedEpochs = 0;
            FECHIP[uChip].uUnsyncedEpochsSinceLastSync = 0;
            FECHIP[uChip].bDataLossSinceLastSync = kFALSE;
            FECHIP[uChip].cAutomaticFakeSyncSinceLastSync = 0;
                     
            FECHIP[uChip].uEpochMainClockSinceLastSync = 0;

            // Preparing modulo debug variables
            FECHIP[uChip].uModuloLastSynch = mesData->getEpoch2Number()%(fParam->uSyncCycleSize);
            FECHIP[uChip].uCycleLastSynch = FECHIP[uChip].uRocEpochCycle;
            
            Message(0,"Here we re-start for chip %2d (1st sync after missing event just passed)", uChip);
            
            // Goes on without doing anything else
            return kTRUE;
         }
          
         if( FECHIP[0].uRocEpochCycle==0)
         {
            fMapEpochsRoc->Fill(uChip, mesData->getEpoch2Number()%(fParam->uSyncCycleSize) );
         }
         (FECHIP[uChip].fModuloSyncRoc)->Fill(FECHIP[uChip].uRocEpochCycle, mesData->getEpoch2Number()%(fParam->uSyncCycleSize));
         
         fMapEpochsMain->Fill(uChip, uLastEpochMainClock%(fParam->uMainSyncCycleSize) );
         (FECHIP[uChip].fModuloSyncMainClock)->Fill(uMainEpochCycle, uLastEpochMainClock%(fParam->uMainSyncCycleSize));
         
         // if the sync flag is set the number of unsynced epoch
         // since the
         // last epoch flag was set is filled into a histogram
         (FECHIP[uChip].fGet4SyncSpacing)->Fill( FECHIP[uChip].uUnsyncedEpochsSinceLastSync );
         (FECHIP[uChip].fGet4SyncSpacingComp)->Fill( FECHIP[uChip].uUnsyncedEpochsSinceLastSync, FECHIP[uChip].uUnsyncedEpochs );
         fNbMissedSync->Fill( uChip, FECHIP[uChip].cAutomaticFakeSyncSinceLastSync);
         
         UInt_t uMeanEpochNb = 0;
         UInt_t uNbActiveChips = 0;
         for( UInt_t uChipLoop = 0; uChipLoop < fParam->uNbFeets * 2; uChipLoop++)
            if( uChipLoop != uChip && fParam->uGet4Active[ uChipLoop ] )
            {
               uMeanEpochNb += FECHIP[uChipLoop].uLocalEpochNb;
               uNbActiveChips++;
            }
         if( 0 < uNbActiveChips )
            uMeanEpochNb /= uNbActiveChips;
               
         // Only if we will not ignore this fake "epoch block" in later analysis
         // aka if more than half of number of unsynchronized epochs
         // Do it also if there was some data loss since last sync, because then we
         // don't know how much was lost! => Wrong?!?
         if( ( FECHIP[uChip].uUnsyncedEpochs > ( (fParam->uSyncCycleSize - 1)/2 + 1) ||
              ( FECHIP[uChip].uUnsyncedEpochs == ( (fParam->uSyncCycleSize - 1)/2 + 1) && 
                FECHIP[uChip].uLocalEpochNb <= uMeanEpochNb) )||
             ( kTRUE == FECHIP[uChip].bDataLossSinceLastSync && 3 < FECHIP[uChip].uUnsyncedEpochs ) || 
             ( 0 < FECHIP[uChip].cAutomaticFakeSyncSinceLastSync && 3 < FECHIP[uChip].uUnsyncedEpochs ) )
         {
            if( 0 == fParam->uSilentSyncMode )
            {
               if(kTRUE == FECHIP[uChip].bDataLossSinceLastSync )
               {
                  Message(0,"After Loss: chip %2d Local epoch %7d, cycle %6d, Unsynched Counts: %3d, Total Unsync %3d",
                              uChip, FECHIP[uChip].uLocalEpochNb, FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs,
                              FECHIP[uChip].uUnsyncedEpochsSinceLastSync);
                  PrintLocalEpochIndexes( 0 );
                  PrintLocalEpochCycles( 0 );
               }
               if(0 < FECHIP[uChip].cAutomaticFakeSyncSinceLastSync )
               {
                  Message(0,"After Auto: chip %2d Local epoch %7d, cycle %6d, Unsynched Counts: %3d, Total Unsync %3d",
                              uChip, FECHIP[uChip].uLocalEpochNb, FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs,
                              FECHIP[uChip].uUnsyncedEpochsSinceLastSync);
                  PrintLocalEpochIndexes( 0 );
                  PrintLocalEpochCycles( 0 );
               }
               if( FECHIP[uChip].uUnsyncedEpochs == ( (fParam->uSyncCycleSize - 1)/2 + 1) )
               {
                  Message(0,"After Eq +: chip %2d Local epoch %7d, cycle %6d, Unsynched Counts: %3d, Total Unsync %3d Mean %7d",
                              uChip, FECHIP[uChip].uLocalEpochNb, FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs,
                              FECHIP[uChip].uUnsyncedEpochsSinceLastSync, uMeanEpochNb);
                  PrintLocalEpochIndexes( 0 );
                  PrintLocalEpochCycles( 0 );
               }
            }
               
            // Analyse data from next buffer
            Bool_t bNextEpochValid = kFALSE;
            if( fParam->uNbBuffers - 1 == FECHIP[uChip].uCurrentMessagesBuffer) // index made a loop => next is 1st buffer
               bNextEpochValid = FECHIP[uChip].bValidEpochFlag[ 0 ];
               else bNextEpochValid = FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer + 1];
            
            FECHIP[uChip].bMessageInterBufferOk[ FECHIP[uChip].uCurrentMessageInterBuffer ] = kTRUE;
            
            if(bNextEpochValid == kTRUE)
            {
               (vMessageInterBuffer[ FECHIP[uChip].uCurrentMessageInterBuffer ]).insert(
                        (vMessageInterBuffer[ FECHIP[uChip].uCurrentMessageInterBuffer ]).end(),
                        (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).begin(),
                        (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).end());
               (vMessageInterBufferUnprocessed[ FECHIP[uChip].uCurrentMessageInterBuffer ]).insert(
                        (vMessageInterBufferUnprocessed[ FECHIP[uChip].uCurrentMessageInterBuffer ]).end(),
                        (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).begin(),
                        (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).end());
               FECHIP[uChip].fGet4MessValidEpochs->Fill( 
                     (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).size() );
               (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).clear();
               (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).clear();
            }

            bTransferMessageNext = kTRUE;
            for( unsigned int uChipCheck = 0; uChipCheck < fParam->uNbFeets*2; uChipCheck++)
            {
               // two buffers solution
               if( FECHIP[uChipCheck].bMessageInterBufferOk[ FECHIP[uChip].uCurrentMessageInterBuffer ] == kFALSE 
                     && fParam->uGet4Active[ uChipCheck ])
               {
                  bTransferMessageNext = kFALSE;
                  break;
               }
            }
            if( bTransferMessageNext == kTRUE )
            {
               // Multiple buffers solution
               UInt_t uIndexNextInterMessBuff = 0;
               if( fParam->uNbBuffers - 1 == FECHIP[uChip].uCurrentMessageInterBuffer )
                  uIndexNextInterMessBuff = 0;
                  else uIndexNextInterMessBuff = FECHIP[uChip].uCurrentMessageInterBuffer + 1;

               if( kTRUE == fParam->noTrigger )
                  rocEvent->vMessageEventBuffer.insert( rocEvent->vMessageEventBuffer.end(),
                                    vMessageInterBuffer[ uIndexNextInterMessBuff ].begin(),
                                    vMessageInterBuffer[ uIndexNextInterMessBuff ].end() );
                  else
                  {
                     // TEST: attempt to make get4 processing compatible with trigger selection
                     rocEvent->fExtMessages.insert( rocEvent->fExtMessages.end(),
                                       vMessageInterBuffer[ uIndexNextInterMessBuff ].begin(),
                                       vMessageInterBuffer[ uIndexNextInterMessBuff ].end() );
                     (vUnprocessedMessages[uRocId]).insert((vUnprocessedMessages[uRocId]).end(),
                                    vMessageInterBufferUnprocessed[ uIndexNextInterMessBuff ].begin(),
                                    vMessageInterBufferUnprocessed[ uIndexNextInterMessBuff ].end() );
                  }
               
               for( unsigned int uChipCheck = 0; uChipCheck < fParam->uNbFeets*2; uChipCheck++)
               {
                  FECHIP[uChipCheck].bStoredHitUnp = kFALSE;
                  FECHIP[uChipCheck].bMessageInterBufferOk[ FECHIP[uChip].uCurrentMessageInterBuffer ] = kFALSE;
               }
               (vMessageInterBuffer[ uIndexNextInterMessBuff ]).clear();
               (vMessageInterBufferUnprocessed[ uIndexNextInterMessBuff ]).clear();
            }
            // Multiples buffers solution
            FECHIP[uChip].uCurrentMessageInterBuffer = (FECHIP[uChip].uCurrentMessageInterBuffer + 1)%fParam->uNbBuffers;
         } // if we will not ignore this fake "epoch block" in later analysis
            
         // If there was exactly "fParam->uSyncCycleSize - 1) epochs since last synched one,
         // all those "fParam->uSyncCycleSize" are valid, else they are all to be rejected
         if( FECHIP[uChip].uUnsyncedEpochs == (fParam->uSyncCycleSize - 1) && 
             FECHIP[uChip].uUnsyncedEpochsSinceLastSync == FECHIP[uChip].uUnsyncedEpochs 
             && kFALSE == FECHIP[uChip].bDataLossSinceLastSync)
            FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer] = kTRUE;
            else FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer] = kFALSE;

         FECHIP[uChip].bStoredHitUnp = kTRUE;
         if( FECHIP[0].uLocalEpochCycle == 0 )
         {
            fMapEpochsLocal->Fill(uChip, (FECHIP[uChip].uLocalEpochNb)%(fParam->uSyncCycleSize) );
         }
         (FECHIP[uChip].fModuloSyncLocal)->Fill(FECHIP[uChip].uLocalEpochCycle, (FECHIP[uChip].uLocalEpochNb)%(fParam->uSyncCycleSize));
         
         // Analyse data only from valid epochs
         if(FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer])
         {
            // Don't work straight because I need to take into account the cycles!
            //~ if( 0 != (FECHIP[uChip].uLocalEpochNb)%(fParam->uSyncCycleSize) )
               //~ GO4_STOP_ANALYSIS_MESSAGE("Et bimmmmmmm! %d %d", uChip, FECHIP[uChip].uLocalEpochNb );
            // Accepted epochs bunch
            (FECHIP[uChip].fGet4ValidSpacing)->Fill( FECHIP[uChip].uUnsyncedEpochs );
            
            if( mesData->getEpoch2Number()%(fParam->uSyncCycleSize) != FECHIP[uChip].uModuloLastSynch 
                && (FECHIP[uChip].uRocEpochCycle) == FECHIP[uChip].uCycleLastSynch
                && 0 == fParam->uSilentSyncMode)
               Message(2,"Synch ROC Epoch shift chip: %2d in Roc Epoch: %7d, cycle %6d (Local epoch %7d, cycle %6d) Unsynched Counts: %3d, last modulo %u/ modulo %u",
                           uChip, FECHIP[uChip].uLastEpoch2, FECHIP[uChip].uRocEpochCycle, FECHIP[uChip].uLocalEpochNb, 
                           FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs,
                           FECHIP[uChip].uModuloLastSynch, mesData->getEpoch2Number()%(fParam->uSyncCycleSize));
            FECHIP[uChip].uModuloLastSynch = mesData->getEpoch2Number()%(fParam->uSyncCycleSize);
            FECHIP[uChip].uCycleLastSynch = FECHIP[uChip].uRocEpochCycle;
            
            // Inter chip epoch shift check
            Bool_t bFirstToSyncCheck = kTRUE;
            for( UInt_t uTempChip = 0; uTempChip < 2*fParam->uNbFeets; uTempChip++)
               if( kFALSE == FECHIP[uTempChip].bChipGotASync )
                  bFirstToSyncCheck = kFALSE;
            if( kTRUE == bFirstToSyncCheck )
            {
               uRocEpochFirstSyncedChip = FECHIP[uChip].uLastEpoch2;
               uRocCycleFirstSyncedChip = FECHIP[uChip].uRocEpochCycle;
               for( UInt_t uTempChip = 0; uTempChip < 2*fParam->uNbFeets; uTempChip++)
                  FECHIP[uTempChip].bChipGotASync = kFALSE;
               FECHIP[uChip].bChipGotASync = kTRUE;
            }
            else
            {
               FECHIP[uChip].bChipGotASync = kTRUE;
               Int_t iEpochShift = (Int_t)(FECHIP[uChip].uLastEpoch2) - (Int_t)uRocEpochFirstSyncedChip 
                                 + CYCLE_IN_EPOCHS*( (Int_t)(FECHIP[uChip].uRocEpochCycle) - (Int_t)uRocCycleFirstSyncedChip);
               if( iEpochShift != FECHIP[uChip].iInterChipEpochShiftLast )
               {
                  // Add option in Parameter!!!!!
                  //~ Message(0,"%2d epoch %7d cycle %6d Shift %3d", 
                            //~ uChip, FECHIP[uChip].uLastEpoch2, FECHIP[uChip].uRocEpochCycle,iEpochShift);
                      
                  FECHIP[uChip].iInterChipEpochShiftLast = iEpochShift;
               }
            }
            
            fInterChipSyncEpochShift->Fill(uChip, FECHIP[uChip].iInterChipEpochShiftLast); 
            (FECHIP[uChip].fInterChipSyncEpochShiftEvol)->Fill(FECHIP[uChip].uRocEpochCycle, FECHIP[uChip].iInterChipEpochShiftLast); 
         } // if(FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer])
         else
         {       
            // Inter chip epoch shift check
            FECHIP[uChip].bChipGotASync = kTRUE;     
            
            // When rejection enabled, some epochs bunch are invalid
            (FECHIP[uChip].fGet4InvalidSpacing)->Fill( FECHIP[uChip].uUnsyncedEpochsSinceLastSync ); 
            
            if( 0 == fParam->uSilentSyncMode )
            {
               Message(2,"Invalid Block chip: %2d in Roc Epoch: %7d Cycle %6d (Local ep %7d Cy %6d) Unsynched Counts: %3d Unsynch Total: %3d M Buffer %1d B Buffer %1d",
                           uChip, FECHIP[uChip].uLastEpoch2, FECHIP[uChip].uRocEpochCycle, FECHIP[uChip].uLocalEpochNb, 
                           FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs, FECHIP[uChip].uUnsyncedEpochsSinceLastSync,
                           FECHIP[uChip].uCurrentMessagesBuffer, FECHIP[uChip].uCurrentMessageInterBuffer);
               Message(1,"Current 250MHz epoch count since last sync: %3d", FECHIP[uChip].uEpochMainClockSinceLastSync);
               PrintLocalEpochIndexes( 1 );
               PrintLocalEpochCycles( 1 );
            }

            // clear the "fParam->uSyncCycleSize" epochs data message & epochs number buffers
            (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
            (FECHIP[uChip].fCurrentUnprocessedMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
            
            // If less than half of a normal sync period => no real sync
            // Go back as if last epochs did not exist!
            // Except if there was some data loss since last sync, because then we
            // don't know how much was lost!
            if( ( FECHIP[uChip].uUnsyncedEpochs < ( (fParam->uSyncCycleSize - 1)/2 + 1) ||
                  ( FECHIP[uChip].uUnsyncedEpochs == ( (fParam->uSyncCycleSize - 1)/2 + 1) && 
                    FECHIP[uChip].uLocalEpochNb > uMeanEpochNb)  ) && 
                ( kFALSE == FECHIP[uChip].bDataLossSinceLastSync || 3 >= FECHIP[uChip].uUnsyncedEpochs ) && 
                ( 0 == FECHIP[uChip].cAutomaticFakeSyncSinceLastSync || 3 >= FECHIP[uChip].uUnsyncedEpochs ) )
            {
               if( 0 == fParam->uSilentSyncMode )
               {
                  if( FECHIP[uChip].uUnsyncedEpochs == ( (fParam->uSyncCycleSize - 1)/2 + 1) )
                  {
                     Message(0,"After Eq -: chip %2d Local epoch %7d, cycle %6d, Unsynched Counts: %3d, Total Unsync %3d Mean %7d",
                                 uChip, FECHIP[uChip].uLocalEpochNb, FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs,
                                 FECHIP[uChip].uUnsyncedEpochsSinceLastSync, uMeanEpochNb);
                     PrintLocalEpochIndexes( 0 );
                     PrintLocalEpochCycles( 0 );
                  }
                  else
                  {
                     Message(0,"Ignore block: chip %2d Local epoch %7d, cycle %6d, Unsynched Counts: %3d, Total Unsync %3d Nb auto %2d Test %2d Mean %2d",
                                 uChip, FECHIP[uChip].uLocalEpochNb, FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs,
                                 FECHIP[uChip].uUnsyncedEpochsSinceLastSync, FECHIP[uChip].cAutomaticFakeSyncSinceLastSync,
                                 (Int_t)uMeanEpochNb - (Int_t)FECHIP[uChip].uLocalEpochNb, uMeanEpochNb);
                     PrintLocalEpochIndexes( 0 );
                     PrintLocalEpochCycles( 0 );
                  }
               }
               
               // Case where the invalid block is the 
               // first block after a cycle change
               Int_t iNbEpochToIgnore = 0;
               if( FECHIP[uChip].uUnsyncedEpochsSinceLastSync == FECHIP[uChip].uUnsyncedEpochs )
                  iNbEpochToIgnore = FECHIP[uChip].uUnsyncedEpochs + 1;
                  else if( 17 < (Int_t)uMeanEpochNb - (Int_t)FECHIP[uChip].uLocalEpochNb )
                     iNbEpochToIgnore = (Int_t)FECHIP[uChip].uLocalEpochNb - (Int_t)uMeanEpochNb;
                  else iNbEpochToIgnore = FECHIP[uChip].uUnsyncedEpochs + 1;
                  
               if( (Int_t)(FECHIP[uChip].uLocalEpochNb) < iNbEpochToIgnore )
               {
                  (FECHIP[uChip].uLocalEpochCycle)--;
                  FECHIP[uChip].uLocalEpochNb = fParam->uRocCycleSize
                                                 + FECHIP[uChip].uLocalEpochNb
                                                 - iNbEpochToIgnore ;
               }
               else if( fParam->uRocCycleSize < (FECHIP[uChip].uLocalEpochNb - iNbEpochToIgnore ) )
               {
                  (FECHIP[uChip].uLocalEpochCycle)++;
                  FECHIP[uChip].uLocalEpochNb = FECHIP[uChip].uLocalEpochNb - iNbEpochToIgnore
                                                              - fParam->uRocCycleSize;
               }
               else
                  FECHIP[uChip].uLocalEpochNb -= iNbEpochToIgnore;
               
               FECHIP[uChip].uUnsyncedEpochs = 0;
               FECHIP[uChip].uUnsyncedEpochsSinceLastSync = 0;
               FECHIP[uChip].bDataLossSinceLastSync = kFALSE;
               FECHIP[uChip].cAutomaticFakeSyncSinceLastSync = 0;
               
               FECHIP[uChip].uEpochMainClockSinceLastSync = 0;
               
               if( 0 == fParam->uSilentSyncMode )
               {
                  PrintLocalEpochIndexes( 1 );
                  PrintLocalEpochCycles( 1 );
               }
                  
               return kFALSE;
            } // if( FECHIP[uChip].uUnsyncedEpochs < ( (fParam->uSyncCycleSize - 1)/2 + 1) && kFALSE == FECHIP[uChip].bDataLossSinceLastSync )
            else
            {
               // Case where the invalid block is the 
               // first block after a cycle change
               if( (Int_t)(FECHIP[uChip].uLocalEpochNb) < ( (Int_t)FECHIP[uChip].uUnsyncedEpochs - (Int_t)(fParam->uSyncCycleSize - 1)))
               {
                  (FECHIP[uChip].uLocalEpochCycle)--;
                  FECHIP[uChip].uLocalEpochNb = fParam->uRocCycleSize + FECHIP[uChip].uLocalEpochNb
                                                 - ((Int_t)FECHIP[uChip].uUnsyncedEpochs - (Int_t)(fParam->uSyncCycleSize - 1)) ;
               }
               else if( fParam->uRocCycleSize <
                        (FECHIP[uChip].uLocalEpochNb - ( (Int_t)FECHIP[uChip].uUnsyncedEpochs - (Int_t)(fParam->uSyncCycleSize - 1) ) ) )
               {
                  (FECHIP[uChip].uLocalEpochCycle)++;
                  FECHIP[uChip].uLocalEpochNb = FECHIP[uChip].uLocalEpochNb 
                                                - ((Int_t)FECHIP[uChip].uUnsyncedEpochs - (Int_t)(fParam->uSyncCycleSize - 1))
                                                - fParam->uRocCycleSize;
               }
               else
                  FECHIP[uChip].uLocalEpochNb -= (Int_t)FECHIP[uChip].uUnsyncedEpochs - (Int_t)(fParam->uSyncCycleSize - 1);
                  
               if( 0 == fParam->uSilentSyncMode )
               {
                  PrintLocalEpochIndexes( 1 );
                  PrintLocalEpochCycles( 1 );
               }
            } // else of // if( FECHIP[uChip].uUnsyncedEpochs < ( (fParam->uSyncCycleSize - 1)/2 + 1) && kFALSE == FECHIP[uChip].bDataLossSinceLastSync )
         } // else of if(FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer])
         
         // Go to next buffers
         FECHIP[uChip].uCurrentMessagesBuffer = ( FECHIP[uChip].uCurrentMessagesBuffer + 1)%fParam->uNbBuffers;
         // clear buffer of previous "fParam->uSyncCycleSize" epochs (keep the last "fParam->uSyncCycleSize")
         (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
         (FECHIP[uChip].fCurrentUnprocessedMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
         // Save "fParam->uSyncCycleSize" Epoch block start
         if( 1 == fParam->uUseLocalEpochs)
         {
            FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochNb;
            FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochCycle;
         }
         else
         {
            FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLastEpoch2;
            FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uRocEpochCycle;
         } // if( 1 == fParam->uUseLocalEpochs)

         // Reset the variable storing the total nb of messages
         // buffered at the end of last epoch
         // (Overkill, but safer)
         FECHIP[uChip].u_messageCountLastEpoch = 0;
         
         // the number of unsynced epochs is reseted here
         FECHIP[uChip].uUnsyncedEpochs = 0;
         FECHIP[uChip].uUnsyncedEpochsSinceLastSync = 0;
         FECHIP[uChip].bDataLossSinceLastSync = kFALSE;
         FECHIP[uChip].cAutomaticFakeSyncSinceLastSync = 0;
         
         FECHIP[uChip].uEpochMainClockSinceLastSync = 0;
      } // if ( bSyncFlag )
      else // of if ( bSyncFlag )
      {
         // If = CycleSize - 1 => should be a sync!
         // => will make it a bad epoch block without waiting for sync
         // => act immediatly as if a sync message was just lost
         if( (fParam->uSyncCycleSize - 1) == FECHIP[uChip].uUnsyncedEpochs )
         {
            // 1 more fake sync automatically generated
            if( kTRUE == FECHIP[uChip].bDataLossSinceLastSync )
               (FECHIP[uChip].cAutomaticFakeSyncSinceLastSync) ++;
            
               
            UInt_t uMeanEpoch = 0;
            UInt_t uNbActiveChips = 0;
            for( UInt_t uChipTemp = 0; uChipTemp < fParam->uNbFeets*2; uChipTemp++)
               if( uChipTemp != uChip && fParam->uGet4Active[ uChipTemp ])
               {
                  uMeanEpoch += FECHIP[uChipTemp].uLocalEpochCycle;
                  uNbActiveChips++;
               }
            if( 0 < uNbActiveChips )
               uMeanEpoch /= uNbActiveChips;
            if( 15 <  (Int_t)FECHIP[uChip].uLocalEpochCycle - (Int_t)uMeanEpoch )
            {
               Message(1, "Auto Sync with high epoch diff on chip %d", uChip);
               PrintLocalEpochIndexes( 1 );
               PrintLocalEpochCycles( 1 );
            }
               
            // Reject everything in fParam->uNbBlockJumpedReset epoch blocks
            // after a GET4 reset message has been received
            // 2*27µs + 37µs = ~100µs data thronw out
            if( FECHIP[uChip].bJumpEpochBlockAfterReset == kTRUE)
            {
               if( 0 == uEpochFirstSyncAfterReset && 0 == uCycleFirstSyncAfterReset)
               {
                  if( 1 == fParam->uUseLocalEpochs)
                  {
                     uEpochFirstSyncAfterReset = FECHIP[uChip].uLocalEpochNb;
                     uCycleFirstSyncAfterReset = FECHIP[uChip].uLocalEpochCycle;
                  }
                  else
                  {
                     uEpochFirstSyncAfterReset = FECHIP[uChip].uLastEpoch2;
                     uCycleFirstSyncAfterReset = FECHIP[uChip].uRocEpochCycle;
                  }
               }
               /*
                * For now no check on Epoch cycle, should not matter with new version of
                * ROC firmware!!!
                */
               ULong64_t ulHighestStartEpoch = 0;
               ULong64_t ulLocalEpochHighestStart = 0;
               UInt_t    uBufferWithHighestStart = 0;
               UInt_t    uInterBufferWithHighestStart = 0;
               Bool_t    bTestFirstAfterReset = kTRUE;
               for ( UInt_t uChipTemp = 0; uChipTemp < fParam->uNbFeets * 2; uChipTemp++ )
               {
                  if( !fParam->uGet4Active[uChipTemp] )
                     continue;
                  if( 0 < FECHIP[uChipTemp].uNbEpochBlockAfterReset )
                  {
                     bTestFirstAfterReset = kFALSE;
                     break;
                  }
                  for( UInt_t uBufferTemp = 0; uBufferTemp < fParam->uNbBuffers; uBufferTemp ++)
                     if( ulHighestStartEpoch < FECHIP[uChipTemp].uEpochStart[uBufferTemp] )
                     {
                        ulHighestStartEpoch = FECHIP[uChipTemp].uEpochStart[uBufferTemp];
                        ulLocalEpochHighestStart = FECHIP[uChipTemp].uLocalEpochNb;
                        uBufferWithHighestStart = uBufferTemp;
                        uInterBufferWithHighestStart = FECHIP[uChipTemp].uCurrentMessageInterBuffer;
                     }
               }
               if( kTRUE == bTestFirstAfterReset )
               {
                  for ( UInt_t uChipTemp = 0; uChipTemp < fParam->uNbFeets * 2; uChipTemp++ )
                  {
                     if( !fParam->uGet4Active[uChipTemp] )
                        continue;
                     for( UInt_t uBufferTemp = 0; uBufferTemp < fParam->uNbBuffers; uBufferTemp ++)
                     {
                        if( FECHIP[uChipTemp].uEpochStart[uBufferTemp] < ulHighestStartEpoch )
                        {
                           (FECHIP[uChipTemp].fCurrentEventMsg)[uBufferTemp].clear();
                           (FECHIP[uChipTemp].fCurrentUnprocessedMsg[uBufferTemp]).clear();
                        }
                     }

                     FECHIP[uChipTemp].uCurrentMessagesBuffer = uBufferWithHighestStart;
                     FECHIP[uChipTemp].uCurrentMessageInterBuffer = uInterBufferWithHighestStart;
                     FECHIP[uChipTemp].uEpochStart[FECHIP[uChipTemp].uCurrentMessagesBuffer] = 0;
                     FECHIP[uChipTemp].uCycleStart[FECHIP[uChipTemp].uCurrentMessagesBuffer] = 0;

                     FECHIP[uChipTemp].uLocalEpochNb = ulLocalEpochHighestStart;
                  }
               }

               (FECHIP[uChip].uNbEpochBlockAfterReset)++;
               
               Message(0,"Throwing Epoch block for chip %2d because of GET4 reset: block %2d (Epoch %11d, local %11d, %11d %7d)",
                         uChip,FECHIP[uChip].uNbEpochBlockAfterReset,  FECHIP[uChip].uLastEpoch2, FECHIP[uChip].uLocalEpochNb,
                         uEpochFirstSyncAfterReset, uCycleFirstSyncAfterReset);
               
               if( 1 == fParam->uUseLocalEpochs)
               {
                  if( fParam->uNbBlockJumpedReset == FECHIP[uChip].uNbEpochBlockAfterReset)
                  {
                     FECHIP[uChip].bJumpEpochBlockAfterReset = kFALSE;
                     FECHIP[uChip].uNbEpochBlockAfterReset = 0;
                  }
               }
                  else if( ( uEpochFirstSyncAfterReset + (fParam->uNbBlockJumpedReset -1) * fParam->uSyncCycleSize
                              <= FECHIP[uChip].uLastEpoch2 ) ||
                      uCycleFirstSyncAfterReset < FECHIP[uChip].uRocEpochCycle )
                  {
                     FECHIP[uChip].bJumpEpochBlockAfterReset = kFALSE;
                     FECHIP[uChip].uNbEpochBlockAfterReset = 0;
                  }
               
               // clear the "fParam->uSyncCycleSize" epochs data message & epochs number buffers
               (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
               (FECHIP[uChip].fCurrentUnprocessedMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
               
               Int_t iNbEpochToIgnore = FECHIP[uChip].uUnsyncedEpochs + 1;
                  
               if( (Int_t)(FECHIP[uChip].uLocalEpochNb) < iNbEpochToIgnore )
               {
                  (FECHIP[uChip].uLocalEpochCycle)--;
                  FECHIP[uChip].uLocalEpochNb = fParam->uRocCycleSize
                                                 + FECHIP[uChip].uLocalEpochNb
                                                 - iNbEpochToIgnore ;
               }
               else if( fParam->uRocCycleSize < (FECHIP[uChip].uLocalEpochNb - iNbEpochToIgnore ) )
               {
                  (FECHIP[uChip].uLocalEpochCycle)++;
                  FECHIP[uChip].uLocalEpochNb = FECHIP[uChip].uLocalEpochNb - iNbEpochToIgnore
                                                              - fParam->uRocCycleSize;
               }
               else
                  FECHIP[uChip].uLocalEpochNb -= iNbEpochToIgnore;
               if( 1 == fParam->uUseLocalEpochs)
               {
                  FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochNb;
                  FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochCycle;
               }
               else
               {
                  FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLastEpoch2;
                  FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uRocEpochCycle;
               }

               // Reset the variable storing the total nb of messages
               // buffered at the end of last epoch
               // (Overkill, but safer)
               FECHIP[uChip].u_messageCountLastEpoch = 0;
               
               // the number of unsynced epochs is reseted here
               FECHIP[uChip].uUnsyncedEpochs = 0;
               FECHIP[uChip].uUnsyncedEpochsSinceLastSync = 0;
               FECHIP[uChip].bDataLossSinceLastSync = kFALSE;
               FECHIP[uChip].cAutomaticFakeSyncSinceLastSync = 0;
                        
               FECHIP[uChip].uEpochMainClockSinceLastSync = 0;

               // Preparing modulo debug variables
               FECHIP[uChip].uModuloLastSynch = mesData->getEpoch2Number()%(fParam->uSyncCycleSize);
               FECHIP[uChip].uCycleLastSynch = FECHIP[uChip].uRocEpochCycle;
               
               // Goes on without doing anything else
               return kTRUE;
            } // if( FECHIP[uChip].bJumpEpochBlockAfterReset == kTRUE)
            
            if( 0 == fParam->uSilentSyncMode )
            {
               Message(2,"Automat Block chip: %2d in Roc Epoch: %7d Cycle %6d (Local ep %7d Cy %6d) Unsynched Counts: %3d Unsynch Total: %3d M Buffer %1d B Buffer %1d Loss %1d",
                           uChip, FECHIP[uChip].uLastEpoch2, FECHIP[uChip].uRocEpochCycle, FECHIP[uChip].uLocalEpochNb, 
                           FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs, FECHIP[uChip].uUnsyncedEpochsSinceLastSync,
                           FECHIP[uChip].uCurrentMessagesBuffer, FECHIP[uChip].uCurrentMessageInterBuffer, FECHIP[uChip].bDataLossSinceLastSync);
               if(kTRUE == FECHIP[uChip].bDataLossSinceLastSync )
               {
                  Message(0,"After Loss: chip %2d Local epoch %7d, cycle %6d, Unsynched Counts: %3d, Total Unsync %3d Automat!!",
                              uChip, FECHIP[uChip].uLocalEpochNb, FECHIP[uChip].uLocalEpochCycle, FECHIP[uChip].uUnsyncedEpochs,
                              FECHIP[uChip].uUnsyncedEpochsSinceLastSync);
                  PrintLocalEpochIndexes( 0 );
                  PrintLocalEpochCycles( 0 );
               }
            }
                           
            // Add 1 to epoch index for the missing synched epoch
            (FECHIP[uChip].uLocalEpochNb)++;      
            // uLocalEpochNb contains the current epoch number
            if( FECHIP[uChip].uLocalEpochNb == fParam->uRocCycleSize)
            {
               (FECHIP[uChip].uLocalEpochCycle)++;
               FECHIP[uChip].uLocalEpochNb = 0;
            }
            else if( FECHIP[uChip].uLocalEpochNb > fParam->uRocCycleSize)
               cout<<"Problem!"<<endl;
            
            // This Epoch block is of course not valid!
            FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer] = kFALSE;
            
            // Analyse data from next buffer
            Bool_t bNextEpochValid = kFALSE;
            if( fParam->uNbBuffers - 1 == FECHIP[uChip].uCurrentMessagesBuffer) // index made a loop => next is 1st buffer
               bNextEpochValid = FECHIP[uChip].bValidEpochFlag[ 0 ];
               else bNextEpochValid = FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer + 1];
            
            FECHIP[uChip].bMessageInterBufferOk[ FECHIP[uChip].uCurrentMessageInterBuffer ] = kTRUE;
            
            if(bNextEpochValid == kTRUE)
            {
               (vMessageInterBuffer[ FECHIP[uChip].uCurrentMessageInterBuffer ]).insert(
                        (vMessageInterBuffer[ FECHIP[uChip].uCurrentMessageInterBuffer ]).end(),
                        (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).begin(),
                        (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).end());
               (vMessageInterBufferUnprocessed[ FECHIP[uChip].uCurrentMessageInterBuffer ]).insert(
                        (vMessageInterBufferUnprocessed[ FECHIP[uChip].uCurrentMessageInterBuffer ]).end(),
                        (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).begin(),
                        (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).end());
               FECHIP[uChip].fGet4MessValidEpochs->Fill( 
                     (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).size() );
               (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).clear();
               (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessageInterBuffer ]).clear();
            }

            bTransferMessageNext = kTRUE;
            for( unsigned int uChipCheck = 0; uChipCheck < fParam->uNbFeets*2; uChipCheck++)
            {
               // two buffers solution
               if( FECHIP[uChipCheck].bMessageInterBufferOk[ FECHIP[uChip].uCurrentMessageInterBuffer ] == kFALSE 
                     && fParam->uGet4Active[ uChipCheck ])
               {
                  bTransferMessageNext = kFALSE;
                  break;
               }
            }
            if( bTransferMessageNext == kTRUE )
            {
               // Multiple buffers solution
               UInt_t uIndexNextInterMessBuff = 0;
               if( fParam->uNbBuffers - 1 == FECHIP[uChip].uCurrentMessageInterBuffer )
                  uIndexNextInterMessBuff = 0;
                  else uIndexNextInterMessBuff = FECHIP[uChip].uCurrentMessageInterBuffer + 1;

               if( kTRUE == fParam->noTrigger )
                  rocEvent->vMessageEventBuffer.insert( rocEvent->vMessageEventBuffer.end(),
                                    vMessageInterBuffer[ uIndexNextInterMessBuff ].begin(),
                                    vMessageInterBuffer[ uIndexNextInterMessBuff ].end() );
               else
               {
                  // TEST: attempt to make get4 processing compatible with trigger selection
                  rocEvent->fExtMessages.insert( rocEvent->fExtMessages.end(),
                                    vMessageInterBuffer[ uIndexNextInterMessBuff ].begin(),
                                    vMessageInterBuffer[ uIndexNextInterMessBuff ].end() );
                  (vUnprocessedMessages[uRocId]).insert((vUnprocessedMessages[uRocId]).end(),
                                 vMessageInterBufferUnprocessed[ uIndexNextInterMessBuff ].begin(),
                                 vMessageInterBufferUnprocessed[ uIndexNextInterMessBuff ].end() );
               }
               
               for( unsigned int uChipCheck = 0; uChipCheck < fParam->uNbFeets*2; uChipCheck++)
               {
                  FECHIP[uChipCheck].bStoredHitUnp = kFALSE;
                  FECHIP[uChipCheck].bMessageInterBufferOk[ FECHIP[uChip].uCurrentMessageInterBuffer ] = kFALSE;
               }
               (vMessageInterBuffer[ uIndexNextInterMessBuff ]).clear();
               (vMessageInterBufferUnprocessed[ uIndexNextInterMessBuff ]).clear();
            } // if( bTransferMessageNext == kTRUE )
            // Multiples buffers solution
            FECHIP[uChip].uCurrentMessageInterBuffer = (FECHIP[uChip].uCurrentMessageInterBuffer + 1)%fParam->uNbBuffers;
            
            // Go to next buffers
            FECHIP[uChip].uCurrentMessagesBuffer = ( FECHIP[uChip].uCurrentMessagesBuffer + 1)%fParam->uNbBuffers;
            // clear the "fParam->uSyncCycleSize" epochs data message & epochs number buffers (Should be already cleared but ...)
            (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
            (FECHIP[uChip].fCurrentUnprocessedMsg[FECHIP[uChip].uCurrentMessagesBuffer]).clear();
            
            // Save "fParam->uSyncCycleSize" Epoch block start
            if( 1 == fParam->uUseLocalEpochs)
            {
               FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochNb;
               FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLocalEpochCycle;
            }
            else
            {
               FECHIP[uChip].uEpochStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uLastEpoch2;
               FECHIP[uChip].uCycleStart[FECHIP[uChip].uCurrentMessagesBuffer] = FECHIP[uChip].uRocEpochCycle;
            }

            // Reset the variable storing the total nb of messages
            // buffered at the end of last epoch
            // (Overkill, but safer)
            FECHIP[uChip].u_messageCountLastEpoch = 0;
            
            // the number of unsynced epochs is reseted here:
            // Goes to one in next lines because we have already one
            // epoch more on top of the missing synch
            FECHIP[uChip].uUnsyncedEpochs = 0;
            FECHIP[uChip].bDataLossSinceLastSync = kFALSE;
            
            FECHIP[uChip].uEpochMainClockSinceLastSync = 0;
         } // if( (fParam->uSyncCycleSize - 1) == FECHIP[uChip].uUnsyncedEpochs )
         
         (FECHIP[uChip].uUnsyncedEpochs)++;
         (FECHIP[uChip].uUnsyncedEpochsSinceLastSync)++;
      } // else of if ( bSyncFlag )
      
      // Update the variable storing the total nb of messages
      // buffered at the end of last epoch
      FECHIP[uChip].u_messageCountLastEpoch = (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).size();
         
   } // if ( uChip >= 0 && uChip < fParam->uNbFeets * 2 )
   else
   {  
         Message(3, "Error: Bad chip nb in Epoch message = %u", uChip);
         Message(3, " => This message will be skipped!!!! ");
         return kFALSE;
   }

   // Fill Histograms of valid epochs flags
   (FECHIP[uChip].fGet4ValidEpochs)->Fill(FECHIP[uChip].bValidEpochFlag[FECHIP[uChip].uCurrentMessagesBuffer]);
      
   return kTRUE;
}
/**********************************************************************/
/*
 * This function process the data message when it is a GET4 data message
 */
Bool_t TRocProc::ProcessGet4DataMessage(UInt_t uRocId, UInt_t uGet4IndexOffset, roc::Message* mesData)
{
   // store it in the "fParam->uSyncCycleSize" epochs buffer
   // store also the corresponding epoch number
   // (for spacing & ToT measure)
   UInt_t uChip = mesData->getGet4Number() + uGet4IndexOffset;
      
   // Remap the Get4 chip index
   uChip = fParam->RemapGet4Chip(uChip);

   // SL: test if chip ID is inside valid range
   if (!fParam->IsValidGet4Chip(uChip)) {
      return kFALSE;
   }

   mesData->setGet4Number(uChip);

   // Test if chip is software disabled
   if( !fParam->uGet4Active[uChip] )
      return kFALSE;

   if ( !(uChip >= 0 && uChip < fParam->uNbFeets * 2) )
   {  
         cout << "Error: Bad chip nb in Epoch message = " << uChip << endl;
         cout << " => This message will be skipped!!!! "<<endl;
         return kFALSE;
   }

   TRocMessageExtended mTemp;
   UInt_t uTempRocEp = 0;
   UInt_t uTempRocCy = 0;
   UInt_t uTempLocEp = 0;
   UInt_t uTempLocCy = 0;

   if( fParam->uGet4EdgeInversion[uChip] == 1 )
      mesData->setGet4Edge( !( mesData->getGet4Edge() ) );

   uTempRocEp = FECHIP[uChip].uLastEpoch2;
//   uTempRocEp = ROC[uRocId].fLastEpoch2[mesData->getGet4Number()];
   uTempRocCy = FECHIP[uChip].uRocEpochCycle;
   uTempLocEp = FECHIP[uChip].uLocalEpochNb;
   uTempLocCy = FECHIP[uChip].uLocalEpochCycle;
   mTemp.SetGet4MessageFull(*mesData, uTempRocEp, uTempRocCy, uTempLocEp, uTempLocCy, 1 == fParam->uUseLocalEpochs);

   // TEST: Modifications to adapt trigger selection to the GET4 processing
   if (fParam->noTrigger)
   {
      (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).push_back(mTemp);

      Int_t iIndexVector = (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).size() -1;
      if( (((FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).at(iIndexVector)).GetRocMessage()).getMessageType()
          != roc::MSG_GET4 )
         Message(3, "Error 1 on %2u: this message is not a GET4 data: type %2u VS %2u VS %2u VS %2u",
           uChip, mesData->getMessageType(), (mTemp.GetRocMessage()).getMessageType(),
           (((FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).back()).GetRocMessage()).getMessageType(),
           (((FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).at(iIndexVector)).GetRocMessage()).getMessageType());
   } // if (fParam->noTrigger)
      else
      {
         Double_t dDiff = 0.;
         Bool_t bIsdiff = kFALSE;

         if(mTemp.GetFullTime() >= ROC[uRocId].fLastTriggerTm)
           dDiff = mTemp.GetFullTime() - ROC[uRocId].fLastTriggerTm;
         else
           dDiff = -1.0 * (ROC[uRocId].fLastTriggerTm - mTemp.GetFullTime());

         bIsdiff = kTRUE;

         if (ROC[uRocId].fHasNewTrigger)
         {
            Bool_t bIsInside(kFALSE), bAdd_to_unprocessed(kFALSE), bAdd_to_event(kFALSE);

            TGo4WinCond* cond = fParam->globalTrigger ? fGlobalTriggerWind : ROC[uRocId].fTriggerWind;

            mTemp.SetTriggerDeltaT(dDiff);

            if (cond->Test(dDiff))
            {
              bAdd_to_event = kTRUE;
              bIsInside = kTRUE;
            }
              else
              {
                 Double_t dRightdist = dDiff - cond->GetXUp();
                 //BEGIN NOT STRICTLY SORTED, 1 EVENT PER MBS CONTAINER, for fast online monitoring  JAM
                 // if hit far away on right side, event can be close for this ROC
                 if (dRightdist > 5000.) ROC[uRocId].fIsEventComplete = kTRUE;
                 if (dRightdist>0.)
                 {
                    if (ROC[uRocId].fStopSyncTm==0)
                       bAdd_to_unprocessed = kTRUE;
                       else
                       {
                          Double_t dDiff2 = 0;
                          if(mTemp.GetFullTime() >= ROC[uRocId].fStopSyncTm)
                             dDiff2 = mTemp.GetFullTime() - ROC[uRocId].fStopSyncTm;
                          else
                             dDiff2 = -1.0 * (ROC[uRocId].fStopSyncTm - mTemp.GetFullTime());

                          // only keep message if it have change to go into next event
                          bAdd_to_unprocessed = dDiff2 >= cond->GetXLow();
                       }
                 }
              } // else of if (cond->Test(diff))

            if ( bAdd_to_event )
            {
              (FECHIP[uChip].fCurrentEventMsg[ FECHIP[uChip].uCurrentMessagesBuffer ]).push_back(mTemp);
            }

            if (bAdd_to_unprocessed )
            {
              (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessagesBuffer ]).push_back(mTemp);
            }
         } // if (ROC[uRocId].fHasNewTrigger)
            else
            {
               // if no new trigger was found up to now, we need to add message to unprocessed
               // at the end of the message we should check if unprocessed messages are still interesting
               (FECHIP[uChip].fCurrentUnprocessedMsg[ FECHIP[uChip].uCurrentMessagesBuffer ]).push_back(mTemp);
            } // else of if (ROC[uRocId].fHasNewTrigger)

         if (bIsdiff) {
               fDeltaTriggerTime->Fill(dDiff);
               ROC[uRocId].fTrigger_AllNX->Fill(dDiff);
               ROC[uRocId].fTrigger_AllNX_100->Fill(dDiff);

               unsigned g4 = mTemp.GetGet4Number();
               if (ROC[uRocId].fGet4Trigger[g4])
                  ROC[uRocId].fGet4Trigger[g4]->Fill(dDiff);
               if (ROC[uRocId].fGet4Trigger100[g4])
                  ROC[uRocId].fGet4Trigger100[g4]->Fill(dDiff);
         }
      }// else of if (fParam->noTrigger)
      
   // Control Histograms filling
   UInt_t uEdge        = mesData->getGet4Edge();
   UInt_t uChannel     = mesData->getGet4ChNum();
   UInt_t uFullChannel = uChip*4 + mesData->getGet4ChNum();

   if ( uEdge == 0 )
   {        
      fGet4RisEdgesNb->Fill( uFullChannel );
      if( 1 == fParam->uUseLocalEpochs)
      {
         fGet4EdgesDiffEvol->Fill( mTemp.GetLocalCycle(), uFullChannel, -1);
         fGet4RisEdgesEvol->Fill( mTemp.GetLocalCycle() );
      }
         else
         { 
            fGet4EdgesDiffEvol->Fill( mTemp.GetRocCycle(), uFullChannel, -1);
            fGet4RisEdgesEvol->Fill( mTemp.GetRocCycle() );
         }
      if( 1 == fParam->uDebugHistoOn )
      {
         (FECHIP[uChip].fGet4FineTimeLE)[uChannel]->Fill( mesData->getGet4Ts() % NB_BIN_GET4_FTS);
         if( 1 == fParam->uUseLocalEpochs)
            (FECHIP[uChip].fGet4RisEdgesNbEvol[uChannel])->Fill( mTemp.GetLocalCycle());
            else (FECHIP[uChip].fGet4RisEdgesNbEvol[uChannel])->Fill(mTemp.GetLocalCycle());
         (FECHIP[uChip].u_nbConsLE[uChannel])++;
         if( (FECHIP[uChip].u_nbConsTE[uChannel]) )
         {
            (FECHIP[uChip].fNbConsecutiveTE[uChannel])->Fill((FECHIP[uChip].u_nbConsTE[uChannel]));
            (FECHIP[uChip].u_nbConsTE[uChannel]) = 0;
         }
      }
   }
      else
      {
         fGet4FalEdgesNb->Fill( uFullChannel );
         if( 1 == fParam->uUseLocalEpochs)
         {
            fGet4EdgesDiffEvol->Fill( mTemp.GetLocalCycle(), uFullChannel, 1);
            fGet4FalEdgesEvol->Fill( mTemp.GetLocalCycle() );
         }
            else
            { 
               fGet4EdgesDiffEvol->Fill( mTemp.GetRocCycle(), uFullChannel, 1);
               fGet4FalEdgesEvol->Fill( mTemp.GetRocCycle() );
            }
            
         if( 1 == fParam->uDebugHistoOn )
         {
            (FECHIP[uChip].fGet4FineTimeTE[uChannel])->Fill( mesData->getGet4Ts() % NB_BIN_GET4_FTS);
            if( 1 == fParam->uUseLocalEpochs)
               (FECHIP[uChip].fGet4FalEdgesNbEvol[uChannel])->Fill(mTemp.GetLocalCycle());
               else (FECHIP[uChip].fGet4FalEdgesNbEvol[uChannel])->Fill(mTemp.GetRocCycle());
            (FECHIP[uChip].u_nbConsTE[uChannel])++;
            if( (FECHIP[uChip].u_nbConsLE[uChannel]) )
            {
            (FECHIP[uChip].fNbConsecutiveLE[uChannel])->Fill((FECHIP[uChip].u_nbConsLE[uChannel]));
            (FECHIP[uChip].u_nbConsLE[uChannel]) = 0;
            }
         } // if( 1 == fParam->uDebugHistoOn )
      }
      
   return kTRUE;
}
/**********************************************************************/
/*
 * This function process the data message when it is a GET4 External Synch
 */
Bool_t TRocProc::ProcessGet4ExtSyncMessage(UInt_t uGet4IndexOffset, roc::Message* mesData)
{
   UChar_t uChip = mesData->getField(40, 8) + uGet4IndexOffset;
   // Remap the Get4 chip index

   uChip = fParam->RemapGet4Chip(uChip);

   // SL: test if chip ID is inside valid range
   if (!fParam->IsValidGet4Chip(uChip)) {
         cout << "Error: Bad chip nb in Epoch message = " << uChip << endl;
         cout << " => This message will be skipped!!!! "<<endl;
         return kFALSE;
   }

   // SL: FIXME: is it required??? message has different format here!!!
   mesData->setGet4Number(uChip);

   fGet4SynchChip->Fill( uChip );
   fGet4SynchPatt->Fill(uChip, (mesData->getSysMesData()) & 0x3f);

   // Store Ext sync messages from expected Get4 chips
   // as a "fake" last extra channel, which will always have
   // only a leading edge
   //~ if( uChip == 2 || uChip == 3)
   {
      TRocMessageExtended mTemp;
      mTemp.SetGet4MessageFull(*mesData, FECHIP[uChip].uLastEpoch2, FECHIP[uChip].uRocEpochCycle,
                                     FECHIP[uChip].uLocalEpochNb, FECHIP[uChip].uLocalEpochCycle,
                                     1 == fParam->uUseLocalEpochs);
      (FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).push_back(mTemp);
      
      if( (((FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).back()).GetRocMessage()).getMessageType() != roc::MSG_SYS )
         Message(3, "Error 1 on %2u: this message is not a SYNC data: type %2u VS %2uVS %2u", 
                 uChip, mesData->getMessageType(), (mTemp.GetRocMessage()).getMessageType(),
                 (((FECHIP[uChip].fCurrentEventMsg[FECHIP[uChip].uCurrentMessagesBuffer]).back()).GetRocMessage()).getMessageType());
   }
   
      
   return kTRUE;
}
/**********************************************************************/
/*
 * This function order all data messages in the current message buffer
 * by time, using ths standard C++ vector/list functions 
 */
Bool_t TRocProc::TimeOrderMessageBuffer( TRocData* rocToSort )
{       
   if(0 == rocToSort->vMessageEventBuffer.size())
   {
      rocToSort->vMessageEventBuffer.clear();
      return kFALSE;
   }

   list<TRocMessageExtended> lSortingList;
   lSortingList.clear();

   // Insert all event from this Epoch in the list
   lSortingList.insert( lSortingList.begin(), rocToSort->vMessageEventBuffer.begin(),
                           rocToSort->vMessageEventBuffer.end() );

   // Sort the messages in the list
   lSortingList.sort( );

   rocToSort->vMessageEventBuffer.clear();
   rocToSort->vMessageEventBuffer.insert(rocToSort->vMessageEventBuffer.begin(),
                                 lSortingList.begin(),
                                 lSortingList.end() );
   
   // No check needed, we trust std C++ ?!?
   
   return kTRUE;
}
/**********************************************************************/

Bool_t TRocProc::PrintRocEpochIndexes(Int_t uMessagePriority )
{
   switch( fParam->uNbFeets )
   {
      case 1:
         Message(uMessagePriority,"Current ROC epoch indexes: %7d %7d ",
                  FECHIP[0].uLastEpoch2,  FECHIP[1].uLastEpoch2);
         break;
      case 2:
         Message(uMessagePriority,"Current ROC epoch indexes: %7d %7d %7d %7d ",
                  FECHIP[0].uLastEpoch2,  FECHIP[1].uLastEpoch2,  FECHIP[2].uLastEpoch2,  FECHIP[3].uLastEpoch2);
         break;
      case 3:
         Message(uMessagePriority,"Current ROC epoch indexes: %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLastEpoch2,  FECHIP[1].uLastEpoch2,  FECHIP[2].uLastEpoch2,  FECHIP[3].uLastEpoch2, FECHIP[4].uLastEpoch2,
                  FECHIP[5].uLastEpoch2);
         break;
      case 4:
         Message(uMessagePriority,"Current ROC epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLastEpoch2,  FECHIP[1].uLastEpoch2,  FECHIP[2].uLastEpoch2,  FECHIP[3].uLastEpoch2, FECHIP[4].uLastEpoch2,
                  FECHIP[5].uLastEpoch2,  FECHIP[6].uLastEpoch2,  FECHIP[7].uLastEpoch2);
         break;
      case 5:
         Message(uMessagePriority,"Current ROC epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLastEpoch2,  FECHIP[1].uLastEpoch2,  FECHIP[2].uLastEpoch2,  FECHIP[3].uLastEpoch2, FECHIP[4].uLastEpoch2,
                  FECHIP[5].uLastEpoch2,  FECHIP[6].uLastEpoch2,  FECHIP[7].uLastEpoch2,  FECHIP[8].uLastEpoch2, FECHIP[9].uLastEpoch2);
         break;
      case 6:
         Message(uMessagePriority,"Current ROC epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLastEpoch2,  FECHIP[1].uLastEpoch2,  FECHIP[2].uLastEpoch2,  FECHIP[3].uLastEpoch2, FECHIP[4].uLastEpoch2,
                  FECHIP[5].uLastEpoch2,  FECHIP[6].uLastEpoch2,  FECHIP[7].uLastEpoch2,  FECHIP[8].uLastEpoch2, FECHIP[9].uLastEpoch2,
                  FECHIP[10].uLastEpoch2, FECHIP[11].uLastEpoch2);
         break;
      case 7:
         Message(uMessagePriority,"Current ROC epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLastEpoch2,  FECHIP[1].uLastEpoch2,  FECHIP[2].uLastEpoch2,  FECHIP[3].uLastEpoch2, FECHIP[4].uLastEpoch2,
                  FECHIP[5].uLastEpoch2,  FECHIP[6].uLastEpoch2,  FECHIP[7].uLastEpoch2,  FECHIP[8].uLastEpoch2, FECHIP[9].uLastEpoch2,
                  FECHIP[10].uLastEpoch2, FECHIP[11].uLastEpoch2, FECHIP[12].uLastEpoch2, FECHIP[13].uLastEpoch2);
         break;
      default:
         Message(uMessagePriority,"Current ROC epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d (Limited to 7 first chips)",
                  FECHIP[0].uLastEpoch2,  FECHIP[1].uLastEpoch2,  FECHIP[2].uLastEpoch2,  FECHIP[3].uLastEpoch2, FECHIP[4].uLastEpoch2,
                  FECHIP[5].uLastEpoch2,  FECHIP[6].uLastEpoch2,  FECHIP[7].uLastEpoch2,  FECHIP[8].uLastEpoch2, FECHIP[9].uLastEpoch2,
                  FECHIP[10].uLastEpoch2, FECHIP[11].uLastEpoch2, FECHIP[12].uLastEpoch2, FECHIP[13].uLastEpoch2);
         break;
   }
   return kTRUE;
}
Bool_t TRocProc::PrintRocEpochCycles(Int_t uMessagePriority )
{
   switch( fParam->uNbFeets )
   {
      case 1:
         Message(uMessagePriority,"Current ROC cycle indexes: %6d %6d ",
                  FECHIP[0].uRocEpochCycle,  FECHIP[1].uRocEpochCycle);
         break;
      case 2:
         Message(uMessagePriority,"Current ROC cycle indexes: %6d %6d %6d %6d ",
                  FECHIP[0].uRocEpochCycle,  FECHIP[1].uRocEpochCycle,  FECHIP[2].uRocEpochCycle,  FECHIP[3].uRocEpochCycle);
         break;
      case 3:
         Message(uMessagePriority,"Current ROC cycle indexes: %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uRocEpochCycle,  FECHIP[1].uRocEpochCycle,  FECHIP[2].uRocEpochCycle,  FECHIP[3].uRocEpochCycle, 
                  FECHIP[4].uRocEpochCycle,  FECHIP[5].uRocEpochCycle);
         break;
      case 4:
         Message(uMessagePriority,"Current ROC cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uRocEpochCycle,  FECHIP[1].uRocEpochCycle,  FECHIP[2].uRocEpochCycle,  FECHIP[3].uRocEpochCycle,
                  FECHIP[4].uRocEpochCycle,  FECHIP[5].uRocEpochCycle,  FECHIP[6].uRocEpochCycle,  FECHIP[7].uRocEpochCycle);
         break;
      case 5:
         Message(uMessagePriority,"Current ROC cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uRocEpochCycle,  FECHIP[1].uRocEpochCycle,  FECHIP[2].uRocEpochCycle,  FECHIP[3].uRocEpochCycle,
                  FECHIP[4].uRocEpochCycle,  FECHIP[5].uRocEpochCycle,  FECHIP[6].uRocEpochCycle,  FECHIP[7].uRocEpochCycle,
                  FECHIP[8].uRocEpochCycle, FECHIP[9].uRocEpochCycle);
         break;
      case 6:
         Message(uMessagePriority,"Current ROC cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uRocEpochCycle,  FECHIP[1].uRocEpochCycle,  FECHIP[2].uRocEpochCycle,  FECHIP[3].uRocEpochCycle,
                  FECHIP[4].uRocEpochCycle,  FECHIP[5].uRocEpochCycle,  FECHIP[6].uRocEpochCycle,  FECHIP[7].uRocEpochCycle,  
                  FECHIP[8].uRocEpochCycle,  FECHIP[9].uRocEpochCycle,  FECHIP[10].uRocEpochCycle, FECHIP[11].uRocEpochCycle);
         break;
      case 7:
         Message(uMessagePriority,"Current ROC cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uRocEpochCycle,  FECHIP[1].uRocEpochCycle,  FECHIP[2].uRocEpochCycle,  FECHIP[3].uRocEpochCycle, 
                  FECHIP[4].uRocEpochCycle,  FECHIP[5].uRocEpochCycle,  FECHIP[6].uRocEpochCycle,  FECHIP[7].uRocEpochCycle,
                  FECHIP[8].uRocEpochCycle,  FECHIP[9].uRocEpochCycle,  FECHIP[10].uRocEpochCycle, FECHIP[11].uRocEpochCycle, 
                  FECHIP[12].uRocEpochCycle, FECHIP[13].uRocEpochCycle);
         break;
      default:
         Message(uMessagePriority,"Current ROC cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d (Limited to 7 first chips)",
                  FECHIP[0].uRocEpochCycle,  FECHIP[1].uRocEpochCycle,  FECHIP[2].uRocEpochCycle,  FECHIP[3].uRocEpochCycle, 
                  FECHIP[4].uRocEpochCycle,  FECHIP[5].uRocEpochCycle,  FECHIP[6].uRocEpochCycle,  FECHIP[7].uRocEpochCycle,
                  FECHIP[8].uRocEpochCycle,  FECHIP[9].uRocEpochCycle,  FECHIP[10].uRocEpochCycle, FECHIP[11].uRocEpochCycle, 
                  FECHIP[12].uRocEpochCycle, FECHIP[13].uRocEpochCycle);
         break;
   }
   return kTRUE;
}
Bool_t TRocProc::PrintLocalEpochIndexes(Int_t uMessagePriority )
{
   switch( fParam->uNbFeets )
   {
      case 1:
         Message(uMessagePriority,"Current epoch indexes: %7d %7d ",
                  FECHIP[0].uLocalEpochNb,  FECHIP[1].uLocalEpochNb);
         break;
      case 2:
         Message(uMessagePriority,"Current epoch indexes: %7d %7d %7d %7d ",
                  FECHIP[0].uLocalEpochNb,  FECHIP[1].uLocalEpochNb,  FECHIP[2].uLocalEpochNb,  FECHIP[3].uLocalEpochNb);
         break;
      case 3:
         Message(uMessagePriority,"Current epoch indexes: %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLocalEpochNb,  FECHIP[1].uLocalEpochNb,  FECHIP[2].uLocalEpochNb,  FECHIP[3].uLocalEpochNb,
                  FECHIP[4].uLocalEpochNb,  FECHIP[5].uLocalEpochNb);
         break;
      case 4:
         Message(uMessagePriority,"Current epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLocalEpochNb,  FECHIP[1].uLocalEpochNb,  FECHIP[2].uLocalEpochNb,  FECHIP[3].uLocalEpochNb, 
                  FECHIP[4].uLocalEpochNb,  FECHIP[5].uLocalEpochNb,  FECHIP[6].uLocalEpochNb,  FECHIP[7].uLocalEpochNb);
         break;
      case 5:
         Message(uMessagePriority,"Current epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLocalEpochNb,  FECHIP[1].uLocalEpochNb,  FECHIP[2].uLocalEpochNb,  FECHIP[3].uLocalEpochNb,
                  FECHIP[4].uLocalEpochNb,  FECHIP[5].uLocalEpochNb,  FECHIP[6].uLocalEpochNb,  FECHIP[7].uLocalEpochNb,
                  FECHIP[8].uLocalEpochNb,  FECHIP[9].uLocalEpochNb);
         break;
      case 6:
         Message(uMessagePriority,"Current epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLocalEpochNb,  FECHIP[1].uLocalEpochNb,  FECHIP[2].uLocalEpochNb,  FECHIP[3].uLocalEpochNb, 
                  FECHIP[4].uLocalEpochNb,  FECHIP[5].uLocalEpochNb,  FECHIP[6].uLocalEpochNb,  FECHIP[7].uLocalEpochNb, 
                  FECHIP[8].uLocalEpochNb,  FECHIP[9].uLocalEpochNb,  FECHIP[10].uLocalEpochNb, FECHIP[11].uLocalEpochNb);
         break;
      case 7:
         Message(uMessagePriority,"Current epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d ",
                  FECHIP[0].uLocalEpochNb,  FECHIP[1].uLocalEpochNb,  FECHIP[2].uLocalEpochNb,  FECHIP[3].uLocalEpochNb,
                  FECHIP[4].uLocalEpochNb,  FECHIP[5].uLocalEpochNb,  FECHIP[6].uLocalEpochNb,  FECHIP[7].uLocalEpochNb,
                  FECHIP[8].uLocalEpochNb,  FECHIP[9].uLocalEpochNb,  FECHIP[10].uLocalEpochNb, FECHIP[11].uLocalEpochNb,
                  FECHIP[12].uLocalEpochNb, FECHIP[13].uLocalEpochNb);
         break;
      default:
         Message(uMessagePriority,"Current epoch indexes: %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d %7d (Limited to 7 first chips)",
                  FECHIP[0].uLocalEpochNb,  FECHIP[1].uLocalEpochNb,  FECHIP[2].uLocalEpochNb,  FECHIP[3].uLocalEpochNb,
                  FECHIP[4].uLocalEpochNb,  FECHIP[5].uLocalEpochNb,  FECHIP[6].uLocalEpochNb,  FECHIP[7].uLocalEpochNb,
                  FECHIP[8].uLocalEpochNb,  FECHIP[9].uLocalEpochNb,  FECHIP[10].uLocalEpochNb, FECHIP[11].uLocalEpochNb,
                  FECHIP[12].uLocalEpochNb, FECHIP[13].uLocalEpochNb);
         break;
   }
   return kTRUE;
}
Bool_t TRocProc::PrintLocalEpochCycles(Int_t uMessagePriority )
{
   switch( fParam->uNbFeets )
   {
      case 1:
         Message(uMessagePriority,"Current cycle indexes: %6d %6d ",
                  FECHIP[0].uLocalEpochCycle,  FECHIP[1].uLocalEpochCycle);
         break;
      case 2:
         Message(uMessagePriority,"Current cycle indexes: %6d %6d %6d %6d ",
                  FECHIP[0].uLocalEpochCycle,  FECHIP[1].uLocalEpochCycle,  FECHIP[2].uLocalEpochCycle,  FECHIP[3].uLocalEpochCycle);
         break;
      case 3:
         Message(uMessagePriority,"Current cycle indexes: %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uLocalEpochCycle,  FECHIP[1].uLocalEpochCycle,  FECHIP[2].uLocalEpochCycle,  FECHIP[3].uLocalEpochCycle,
                  FECHIP[4].uLocalEpochCycle,  FECHIP[5].uLocalEpochCycle);
         break;
      case 4:
         Message(uMessagePriority,"Current cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uLocalEpochCycle,  FECHIP[1].uLocalEpochCycle,  FECHIP[2].uLocalEpochCycle,  FECHIP[3].uLocalEpochCycle,
                  FECHIP[4].uLocalEpochCycle,  FECHIP[5].uLocalEpochCycle,  FECHIP[6].uLocalEpochCycle,  FECHIP[7].uLocalEpochCycle);
         break;
      case 5:
         Message(uMessagePriority,"Current cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uLocalEpochCycle,  FECHIP[1].uLocalEpochCycle,  FECHIP[2].uLocalEpochCycle,  FECHIP[3].uLocalEpochCycle,
                  FECHIP[4].uLocalEpochCycle,  FECHIP[5].uLocalEpochCycle,  FECHIP[6].uLocalEpochCycle,  FECHIP[7].uLocalEpochCycle,
                  FECHIP[8].uLocalEpochCycle,  FECHIP[9].uLocalEpochCycle);
         break;
      case 6:
         Message(uMessagePriority,"Current cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uLocalEpochCycle,  FECHIP[1].uLocalEpochCycle,  FECHIP[2].uLocalEpochCycle,  FECHIP[3].uLocalEpochCycle,
                  FECHIP[4].uLocalEpochCycle,  FECHIP[5].uLocalEpochCycle,  FECHIP[6].uLocalEpochCycle,  FECHIP[7].uLocalEpochCycle,
                  FECHIP[8].uLocalEpochCycle,  FECHIP[9].uLocalEpochCycle,  FECHIP[10].uLocalEpochCycle, FECHIP[11].uLocalEpochCycle);
         break;
      case 7:
         Message(uMessagePriority,"Current cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d ",
                  FECHIP[0].uLocalEpochCycle,  FECHIP[1].uLocalEpochCycle,  FECHIP[2].uLocalEpochCycle,  FECHIP[3].uLocalEpochCycle,
                  FECHIP[4].uLocalEpochCycle,  FECHIP[5].uLocalEpochCycle,  FECHIP[6].uLocalEpochCycle,  FECHIP[7].uLocalEpochCycle,
                  FECHIP[8].uLocalEpochCycle,  FECHIP[9].uLocalEpochCycle,  FECHIP[10].uLocalEpochCycle, FECHIP[11].uLocalEpochCycle,
                  FECHIP[12].uLocalEpochCycle, FECHIP[13].uLocalEpochCycle);
         break;
      default:
         Message(uMessagePriority,"Current cycle indexes: %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d %6d (Limited to 7 first chips)",
                  FECHIP[0].uLocalEpochCycle,  FECHIP[1].uLocalEpochCycle,  FECHIP[2].uLocalEpochCycle,  FECHIP[3].uLocalEpochCycle,
                  FECHIP[4].uLocalEpochCycle,  FECHIP[5].uLocalEpochCycle,  FECHIP[6].uLocalEpochCycle,  FECHIP[7].uLocalEpochCycle,
                  FECHIP[8].uLocalEpochCycle,  FECHIP[9].uLocalEpochCycle,  FECHIP[10].uLocalEpochCycle, FECHIP[11].uLocalEpochCycle,
                  FECHIP[12].uLocalEpochCycle, FECHIP[13].uLocalEpochCycle);
         break;
   }
   return kTRUE;
}
Bool_t TRocProc::PrintUnsynchronizedEpochCount(Int_t uMessagePriority)
{
   switch( fParam->uNbFeets )
   {
      case 1:
         Message(uMessagePriority,"Current unsynchronized count: %3d %3d ",
                  FECHIP[0].uUnsyncedEpochs,  FECHIP[1].uUnsyncedEpochs);
         break;
      case 2:
         Message(uMessagePriority,"Current unsynchronized count: %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochs,  FECHIP[1].uUnsyncedEpochs,  FECHIP[2].uUnsyncedEpochs,  FECHIP[3].uUnsyncedEpochs);
         break;
      case 3:
         Message(uMessagePriority,"Current unsynchronized count: %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochs,  FECHIP[1].uUnsyncedEpochs,  FECHIP[2].uUnsyncedEpochs,  FECHIP[3].uUnsyncedEpochs,
                  FECHIP[4].uUnsyncedEpochs,  FECHIP[5].uUnsyncedEpochs);
         break;
      case 4:
         Message(uMessagePriority,"Current unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochs,  FECHIP[1].uUnsyncedEpochs,  FECHIP[2].uUnsyncedEpochs,  FECHIP[3].uUnsyncedEpochs,
                  FECHIP[4].uUnsyncedEpochs,  FECHIP[5].uUnsyncedEpochs,  FECHIP[6].uUnsyncedEpochs,  FECHIP[7].uUnsyncedEpochs);
         break;
      case 5:
         Message(uMessagePriority,"Current unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochs,  FECHIP[1].uUnsyncedEpochs,  FECHIP[2].uUnsyncedEpochs,  FECHIP[3].uUnsyncedEpochs,
                  FECHIP[4].uUnsyncedEpochs,  FECHIP[5].uUnsyncedEpochs,  FECHIP[6].uUnsyncedEpochs,  FECHIP[7].uUnsyncedEpochs,
                  FECHIP[8].uUnsyncedEpochs,  FECHIP[9].uUnsyncedEpochs);
         break;
      case 6:
         Message(uMessagePriority,"Current unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochs,  FECHIP[1].uUnsyncedEpochs,  FECHIP[2].uUnsyncedEpochs,  FECHIP[3].uUnsyncedEpochs,
                  FECHIP[4].uUnsyncedEpochs,  FECHIP[5].uUnsyncedEpochs,  FECHIP[6].uUnsyncedEpochs,  FECHIP[7].uUnsyncedEpochs,
                  FECHIP[8].uUnsyncedEpochs,  FECHIP[9].uUnsyncedEpochs,  FECHIP[10].uUnsyncedEpochs, FECHIP[11].uUnsyncedEpochs);
         break;
      case 7:
         Message(uMessagePriority,"Current unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochs,  FECHIP[1].uUnsyncedEpochs,  FECHIP[2].uUnsyncedEpochs,  FECHIP[3].uUnsyncedEpochs,
                  FECHIP[4].uUnsyncedEpochs,  FECHIP[5].uUnsyncedEpochs,  FECHIP[6].uUnsyncedEpochs,  FECHIP[7].uUnsyncedEpochs,
                  FECHIP[8].uUnsyncedEpochs,  FECHIP[9].uUnsyncedEpochs,  FECHIP[10].uUnsyncedEpochs, FECHIP[11].uUnsyncedEpochs,
                  FECHIP[12].uUnsyncedEpochs, FECHIP[13].uUnsyncedEpochs);
         break;
      default:
         Message(uMessagePriority,"Current unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d (Limited to 7 first chips)",
                  FECHIP[0].uUnsyncedEpochs,  FECHIP[1].uUnsyncedEpochs,  FECHIP[2].uUnsyncedEpochs,  FECHIP[3].uUnsyncedEpochs,
                  FECHIP[4].uUnsyncedEpochs,  FECHIP[5].uUnsyncedEpochs,  FECHIP[6].uUnsyncedEpochs,  FECHIP[7].uUnsyncedEpochs,
                  FECHIP[8].uUnsyncedEpochs,  FECHIP[9].uUnsyncedEpochs,  FECHIP[10].uUnsyncedEpochs, FECHIP[11].uUnsyncedEpochs,
                  FECHIP[12].uUnsyncedEpochs, FECHIP[13].uUnsyncedEpochs);
         break;
   }
   return kTRUE;
}
Bool_t TRocProc::PrintTotalUnsynchronizedEpochCount(Int_t uMessagePriority)
{
   switch( fParam->uNbFeets )
   {
      case 1:
         Message(uMessagePriority,"Current total unsynchronized count: %3d %3d ",
                  FECHIP[0].uUnsyncedEpochsSinceLastSync,  FECHIP[1].uUnsyncedEpochsSinceLastSync);
         break;
      case 2:
         Message(uMessagePriority,"Current total unsynchronized count: %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochsSinceLastSync,  FECHIP[1].uUnsyncedEpochsSinceLastSync,  FECHIP[2].uUnsyncedEpochsSinceLastSync,
                  FECHIP[3].uUnsyncedEpochsSinceLastSync);
         break;
      case 3:
         Message(uMessagePriority,"Current total unsynchronized count: %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochsSinceLastSync,  FECHIP[1].uUnsyncedEpochsSinceLastSync,  FECHIP[2].uUnsyncedEpochsSinceLastSync,
                  FECHIP[3].uUnsyncedEpochsSinceLastSync,  FECHIP[4].uUnsyncedEpochsSinceLastSync,  FECHIP[5].uUnsyncedEpochsSinceLastSync);
         break;
      case 4:
         Message(uMessagePriority,"Current total unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochsSinceLastSync,  FECHIP[1].uUnsyncedEpochsSinceLastSync,  FECHIP[2].uUnsyncedEpochsSinceLastSync,
                  FECHIP[3].uUnsyncedEpochsSinceLastSync,  FECHIP[4].uUnsyncedEpochsSinceLastSync,  FECHIP[5].uUnsyncedEpochsSinceLastSync,
                  FECHIP[6].uUnsyncedEpochsSinceLastSync,  FECHIP[7].uUnsyncedEpochsSinceLastSync);
         break;
      case 5:
         Message(uMessagePriority,"Current total unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochsSinceLastSync,  FECHIP[1].uUnsyncedEpochsSinceLastSync,  FECHIP[2].uUnsyncedEpochsSinceLastSync,
                  FECHIP[3].uUnsyncedEpochsSinceLastSync,  FECHIP[4].uUnsyncedEpochsSinceLastSync,  FECHIP[5].uUnsyncedEpochsSinceLastSync,
                  FECHIP[6].uUnsyncedEpochsSinceLastSync,  FECHIP[7].uUnsyncedEpochsSinceLastSync,  FECHIP[8].uUnsyncedEpochsSinceLastSync, 
                  FECHIP[9].uUnsyncedEpochsSinceLastSync);
         break;
      case 6:
         Message(uMessagePriority,"Current total unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochsSinceLastSync,  FECHIP[1].uUnsyncedEpochsSinceLastSync,  FECHIP[2].uUnsyncedEpochsSinceLastSync,
                  FECHIP[3].uUnsyncedEpochsSinceLastSync,  FECHIP[4].uUnsyncedEpochsSinceLastSync,  FECHIP[5].uUnsyncedEpochsSinceLastSync,
                  FECHIP[6].uUnsyncedEpochsSinceLastSync,  FECHIP[7].uUnsyncedEpochsSinceLastSync,  FECHIP[8].uUnsyncedEpochsSinceLastSync,
                  FECHIP[9].uUnsyncedEpochsSinceLastSync,  FECHIP[10].uUnsyncedEpochsSinceLastSync, FECHIP[11].uUnsyncedEpochsSinceLastSync);
         break;
      case 7:
         Message(uMessagePriority,"Current total unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d ",
                  FECHIP[0].uUnsyncedEpochsSinceLastSync,  FECHIP[1].uUnsyncedEpochsSinceLastSync,  FECHIP[2].uUnsyncedEpochsSinceLastSync,
                  FECHIP[3].uUnsyncedEpochsSinceLastSync,  FECHIP[4].uUnsyncedEpochsSinceLastSync,  FECHIP[5].uUnsyncedEpochsSinceLastSync,
                  FECHIP[6].uUnsyncedEpochsSinceLastSync,  FECHIP[7].uUnsyncedEpochsSinceLastSync,  FECHIP[8].uUnsyncedEpochsSinceLastSync,
                  FECHIP[9].uUnsyncedEpochsSinceLastSync,  FECHIP[10].uUnsyncedEpochsSinceLastSync, FECHIP[11].uUnsyncedEpochsSinceLastSync,
                  FECHIP[12].uUnsyncedEpochsSinceLastSync, FECHIP[13].uUnsyncedEpochsSinceLastSync);
         break;
      default:
         Message(uMessagePriority,"Current total unsynchronized count: %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d %3d (Limited to 7 first chips)",
                  FECHIP[0].uUnsyncedEpochsSinceLastSync,  FECHIP[1].uUnsyncedEpochsSinceLastSync,  FECHIP[2].uUnsyncedEpochsSinceLastSync,
                  FECHIP[3].uUnsyncedEpochsSinceLastSync,  FECHIP[4].uUnsyncedEpochsSinceLastSync,  FECHIP[5].uUnsyncedEpochsSinceLastSync,
                  FECHIP[6].uUnsyncedEpochsSinceLastSync,  FECHIP[7].uUnsyncedEpochsSinceLastSync,  FECHIP[8].uUnsyncedEpochsSinceLastSync,
                  FECHIP[9].uUnsyncedEpochsSinceLastSync,  FECHIP[10].uUnsyncedEpochsSinceLastSync, FECHIP[11].uUnsyncedEpochsSinceLastSync,
                  FECHIP[12].uUnsyncedEpochsSinceLastSync, FECHIP[13].uUnsyncedEpochsSinceLastSync);
         break;
   }
   return kTRUE;
}
Bool_t TRocProc::PrintMessageBufferIndexes(Int_t uMessagePriority )
{
   switch( fParam->uNbFeets )
   {
      case 1:
         Message(uMessagePriority,"Current Mess Buff : %1d %1d ",
                  FECHIP[0].uCurrentMessagesBuffer,  FECHIP[1].uCurrentMessagesBuffer);
         break;
      case 2:
         Message(uMessagePriority,"Current Mess Buff : %1d %1d %1d %1d ",
                  FECHIP[0].uCurrentMessagesBuffer,  FECHIP[1].uCurrentMessagesBuffer,  FECHIP[2].uCurrentMessagesBuffer,
                  FECHIP[3].uCurrentMessagesBuffer);
         break;
      case 3:
         Message(uMessagePriority,"Current Mess Buff : %1d %1d %1d %1d %1d %1d ",
                  FECHIP[0].uCurrentMessagesBuffer,  FECHIP[1].uCurrentMessagesBuffer,  FECHIP[2].uCurrentMessagesBuffer,
                  FECHIP[3].uCurrentMessagesBuffer,  FECHIP[4].uCurrentMessagesBuffer,  FECHIP[5].uCurrentMessagesBuffer);
         break;
      case 4:
         Message(uMessagePriority,"Current Mess Buff : %1d %1d %1d %1d %1d %1d %1d %1d ",
                  FECHIP[0].uCurrentMessagesBuffer,  FECHIP[1].uCurrentMessagesBuffer,  FECHIP[2].uCurrentMessagesBuffer,
                  FECHIP[3].uCurrentMessagesBuffer,  FECHIP[4].uCurrentMessagesBuffer,  FECHIP[5].uCurrentMessagesBuffer,
                  FECHIP[6].uCurrentMessagesBuffer,  FECHIP[7].uCurrentMessagesBuffer);
         break;
      case 5:
         Message(uMessagePriority,"Current Mess Buff : %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d ",
                  FECHIP[0].uCurrentMessagesBuffer,  FECHIP[1].uCurrentMessagesBuffer,  FECHIP[2].uCurrentMessagesBuffer,
                  FECHIP[3].uCurrentMessagesBuffer,  FECHIP[4].uCurrentMessagesBuffer,  FECHIP[5].uCurrentMessagesBuffer,
                  FECHIP[6].uCurrentMessagesBuffer,  FECHIP[7].uCurrentMessagesBuffer,  FECHIP[8].uCurrentMessagesBuffer,
                  FECHIP[9].uCurrentMessagesBuffer);
         break;
      case 6:
         Message(uMessagePriority,"Current Mess Buff : %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d ",
                  FECHIP[0].uCurrentMessagesBuffer,  FECHIP[1].uCurrentMessagesBuffer,  FECHIP[2].uCurrentMessagesBuffer,
                  FECHIP[3].uCurrentMessagesBuffer,  FECHIP[4].uCurrentMessagesBuffer,  FECHIP[5].uCurrentMessagesBuffer,
                  FECHIP[6].uCurrentMessagesBuffer,  FECHIP[7].uCurrentMessagesBuffer,  FECHIP[8].uCurrentMessagesBuffer,
                  FECHIP[9].uCurrentMessagesBuffer,  FECHIP[10].uCurrentMessagesBuffer, FECHIP[11].uCurrentMessagesBuffer);
         break;
      case 7:
         Message(uMessagePriority,"Current Mess Buff : %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d ",
                  FECHIP[0].uCurrentMessagesBuffer,  FECHIP[1].uCurrentMessagesBuffer,  FECHIP[2].uCurrentMessagesBuffer,
                  FECHIP[3].uCurrentMessagesBuffer,  FECHIP[4].uCurrentMessagesBuffer,  FECHIP[5].uCurrentMessagesBuffer,
                  FECHIP[6].uCurrentMessagesBuffer,  FECHIP[7].uCurrentMessagesBuffer,  FECHIP[8].uCurrentMessagesBuffer,
                  FECHIP[9].uCurrentMessagesBuffer,  FECHIP[10].uCurrentMessagesBuffer, FECHIP[11].uCurrentMessagesBuffer,
                  FECHIP[12].uCurrentMessagesBuffer, FECHIP[13].uCurrentMessagesBuffer);
         break;
      default:
         Message(uMessagePriority,"Current Mess Buff : %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d %1d (Limited to 7 first chips)",
                  FECHIP[0].uCurrentMessagesBuffer,  FECHIP[1].uCurrentMessagesBuffer,  FECHIP[2].uCurrentMessagesBuffer,
                  FECHIP[3].uCurrentMessagesBuffer,  FECHIP[4].uCurrentMessagesBuffer,  FECHIP[5].uCurrentMessagesBuffer,
                  FECHIP[6].uCurrentMessagesBuffer,  FECHIP[7].uCurrentMessagesBuffer,  FECHIP[8].uCurrentMessagesBuffer,
                  FECHIP[9].uCurrentMessagesBuffer,  FECHIP[10].uCurrentMessagesBuffer, FECHIP[11].uCurrentMessagesBuffer,
                  FECHIP[12].uCurrentMessagesBuffer, FECHIP[13].uCurrentMessagesBuffer);
         break;
   }
   return kTRUE;
}
Bool_t TRocProc::PrintMessageBufferSizes(Int_t uMessagePriority )
{
   for(UInt_t uBufferTestIndex = 0; uBufferTestIndex < fParam->uNbBuffers ; uBufferTestIndex++)
      {
      switch( fParam->uNbFeets )
      {
         case 1:
            Message(uMessagePriority,"Mess Buff %1d Size  : %4d %4d ", uBufferTestIndex,
                     FECHIP[0].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[1].fCurrentEventMsg[uBufferTestIndex].size());
            break;
         case 2:
            Message(uMessagePriority,"Mess Buff %1d Size  : %4d %4d %4d %4d ", uBufferTestIndex,
                     FECHIP[0].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[1].fCurrentEventMsg[uBufferTestIndex].size(),  
                     FECHIP[2].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[3].fCurrentEventMsg[uBufferTestIndex].size());
            break;
         case 3:
            Message(uMessagePriority,"Mess Buff %1d Size  : %4d %4d %4d %4d %4d %4d ", uBufferTestIndex,
                     FECHIP[0].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[1].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[2].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[3].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[4].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[5].fCurrentEventMsg[uBufferTestIndex].size());
            break;
         case 4:
            Message(uMessagePriority,"Mess Buff %1d Size  : %4d %4d %4d %4d %4d %4d %4d %4d ", uBufferTestIndex,
                     FECHIP[0].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[1].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[2].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[3].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[4].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[5].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[6].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[7].fCurrentEventMsg[uBufferTestIndex].size());
            break;
         case 5:
            Message(uMessagePriority,"Mess Buff %1d Size  : %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d ", uBufferTestIndex,
                     FECHIP[0].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[1].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[2].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[3].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[4].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[5].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[6].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[7].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[8].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[9].fCurrentEventMsg[uBufferTestIndex].size());
            break;
         case 6:
            Message(uMessagePriority,"Mess Buff %1d Size  : %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d ", uBufferTestIndex,
                     FECHIP[0].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[1].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[2].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[3].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[4].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[5].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[6].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[7].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[8].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[9].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[10].fCurrentEventMsg[uBufferTestIndex].size(), FECHIP[11].fCurrentEventMsg[uBufferTestIndex].size());
            break;
         case 7:
            Message(uMessagePriority,"Mess Buff %1d Size  : %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d ", uBufferTestIndex,
                     FECHIP[0].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[1].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[2].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[3].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[4].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[5].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[6].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[7].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[8].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[9].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[10].fCurrentEventMsg[uBufferTestIndex].size(), FECHIP[11].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[12].fCurrentEventMsg[uBufferTestIndex].size(), FECHIP[13].fCurrentEventMsg[uBufferTestIndex].size());
            break;
         default:
            Message(uMessagePriority,"Mess Buff %1d Size  : %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d %4d (Limited to 7 first chips)",
                     uBufferTestIndex,
                     FECHIP[0].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[1].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[2].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[3].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[4].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[5].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[6].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[7].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[8].fCurrentEventMsg[uBufferTestIndex].size(),  FECHIP[9].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[10].fCurrentEventMsg[uBufferTestIndex].size(), FECHIP[11].fCurrentEventMsg[uBufferTestIndex].size(),
                     FECHIP[12].fCurrentEventMsg[uBufferTestIndex].size(), FECHIP[13].fCurrentEventMsg[uBufferTestIndex].size());
            break;
      }
   }
   return kTRUE;
}