onlinemonitor/spadicV10monitor/TSpadicV10Proc.cxx (r4864/r3724)

Go to the documentation of this file.

#include "TSpadicV10Proc.h"

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

#include "TSpadicV10Param.h"
#include "TGo4MbsEvent.h"
#include "TGo4WinCond.h"
#include "TGo4Log.h"


#include "base/commons.h"
#include "sp605/Message.h"
//#include "sp605/Iterator.h"
#include "sp605/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 TSpadicV10Param::maxBufferTriggers per buffer (only offline mode with no lost samples!)
#define SPADICV10_SINGLETRIGGERMODE 1
//#define SPADICV10_DEBUG 1


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

//***********************************************************
TSpadicV10Proc::~TSpadicV10Proc()
{

   TGo4Log::Info("TSpadicV10Proc: 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
TSpadicV10Proc::TSpadicV10Proc(const char* name) :
   TCBMBeamtimeProc(name),
   fIsTimeSorted(kFALSE),
   fOutputEvent(0),
   fHasNewGlobalTrigger(kFALSE)
{
   TGo4Log::Info("TSpadicV10Proc: Create instance %s", GetName());

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

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

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

   int hnumbrds = fParam->numBoards > 8 ? fParam->numBoards : 8;

   fMsgsPerBoard = MakeTH1('I', "MsgsPerSpadicV10", "Number of messages per SPADICV10 board", hnumbrds, 0., hnumbrds);

   fTriggersPerBoard = MakeTH1('I', "TriggersPerSpadicV10", "Number of Trigger messages per SPADICV10 board", hnumbrds, 0., hnumbrds);

   fSYNC1_R01 = MakeTH1('I', "Spadic_SYNC1_R01", "Time difference between SYNC1 on boards 0 and 1", 5000, -5000., 5000., "#Delta t");
   fAUX2_R01 = MakeTH1('I', "Spadic_AUX2_R01", "Time difference between AUX2 on boards 0 and 1", 5000, -5000., 5000., "#Delta t");

   fDeltaTriggerTime = MakeTH1('I', "TriggerDeltaTimeSpadicV10", "Corrected hits time difference of all SPADICV10s", 5000, -5000., 5000., "#Delta t");
   fGlobalTriggerWind = MakeWinCond("SP605_TriggerWindow", -100, 2000., fDeltaTriggerTime->GetName());
   fGlobalAUXWind = MakeWinCond("SP605_AUXWindow", -100, 100., fDeltaTriggerTime->GetName());

   for (int brd=0; brd<fParam->numBoards; brd++) {
      BRDS.push_back(TSpadicV10BoardRec());
      BRDS[brd].MakeSpadicsVector(fParam->activeBoards[brd]);

      if (!AssertBoard(brd)) continue;

      char folder[100];
      sprintf(folder,"SP605_%u/", brd);

      BRDS[brd].fMsgCnt = MakeTH1('I', Form("%sMsgCounts%u", folder, brd), Form("Distribution of messages counts on SP605 %u board", brd), 9, 0., 9.);
      if (IsObjMade()) {
         BRDS[brd].fMsgCnt->GetXaxis()->SetBinLabel(1, "Black-box");
         for (int n=0;n<8;n++)
            BRDS[brd].fMsgCnt->GetXaxis()->SetBinLabel(1 + n+1, Form("SPADIC%d",n));
      }

      BRDS[brd].fMsgTypes = MakeTH1('I', Form("%sBlackBox/SP605MsgTypes%u", folder, brd), Form("Distribution of messages types in SP605 %u board", brd), 8, 0., 8.);

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

      BRDS[brd].fAUXch = MakeTH1('I', Form("%sBlackBox/SP605_%u_AuxCh", folder, brd), "Number events per aux channel", 4, 0., 4.);

      for (unsigned nsync=0; nsync<MAX_SPADICV10_SYNC; nsync++)
         BRDS[brd].fSYNCt[nsync] = MakeTH1('I', Form("%sBlackBox/SP605_%u_Sync%u_t", folder, brd, nsync), Form("Time distribution of SYNC%u signal on SP605%u", nsync, brd), 10000, 0., 1000.);

      for (unsigned naux=0; naux<MAX_SPADICV10_AUX; naux++)
         BRDS[brd].fAUXt[naux] = MakeTH1('I', Form("%sBlackBox/SP605_%u_Aux%u_t", folder, brd, naux), Form("Time distribution of AUX%u signal on SP605%u", naux, brd), 10000, 0., 1000.);

      BRDS[brd].fSysTypes = MakeTH1('I', Form("%sBlackBox/SP605_%u_SysTypes", folder, brd), Form("SP605%u Distribution of black-box system messages", brd), roc::SYSMSG_PACKETLOST+1, 0., roc::SYSMSG_PACKETLOST+1);
      if (IsObjMade()) {
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_DAQ_START,  "DAQ_START");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_DAQ_FINISH, "DAQ_FINISH");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_NX_PARITY,  "NX_PARITY");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_SYNC_PARITY,"SYNC_PARITY");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_DAQ_RESUME, "DAQ_RESUME");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_FIFO_RESET, "FIFO_RESET");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_USER,       "USER_MSG");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_PCTIME,     "PCTIME");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_ADC,        "ADC");
         BRDS[brd].fSysTypes->GetXaxis()->SetBinLabel(1 + roc::SYSMSG_PACKETLOST, "PACKETLOST");
      }

      BRDS[brd].fTrigger = MakeTH1('I', Form("%sSP605_%u_Trigger", folder, brd), Form("Time difference between all hits and last trigger signal on SP605 %u", brd), 2500, -1000., 4000.);
      BRDS[brd].fTrigger_100 = MakeTH1('I', Form("%sSP605_%u_Trigger_100", folder, brd), Form("Time difference between all hits and last trigger signal on SP605 %u", brd), 50005, -100000., 1e6);
      BRDS[brd].fTriggerWind = MakeWinCond(Form("SP605_%u_EventWindow",brd), 485., 885., BRDS[brd].fTrigger->GetName());
      BRDS[brd].fEvntMultipl = MakeTH1('I', Form("%sSP605_%u_Event_Multiplicity", folder, brd), Form("Event multiplicity for SP605 %u in time window", brd), 100, 0., 100.);

      for (unsigned spid=0; spid<BRDS[brd].numSpadics(); spid++) {
         if (!AssertSpadic(brd, spid)) continue;

         char dfolder[100];
         sprintf(folder, "%sSPADIC_%u/", folder, spid);

         TSpadicV10Rec& rec = BRDS[brd].SPADICS[spid];

         rec.fMsgTypes = MakeTH1('I', Form("%sMsgTypes_%u_%u", dfolder, brd, spid), Form("Distribution of messages types in SP605 %u board", brd), 8, 0., 8.);
         if (IsObjMade()) {
            rec.fMsgTypes->GetXaxis()->SetBinLabel(1 + sp605::MSG_NOP, "NOP");
            rec.fMsgTypes->GetXaxis()->SetBinLabel(1 + sp605::MSG_HIT, "HIT");
            rec.fMsgTypes->GetXaxis()->SetBinLabel(1 + sp605::MSG_OVERFLOW, "OVFL");
            rec.fMsgTypes->GetXaxis()->SetBinLabel(1 + sp605::MSG_INFO, "INFO");
            rec.fMsgTypes->GetXaxis()->SetBinLabel(1 + sp605::MSG_EPOCH, "EPOCH");
         }

         rec.fTrigTypes = MakeTH1('I', Form("%sHitTypes_%u_%u", dfolder, brd, spid), Form("Distribution of hit types for board %u spadic %u", brd, spid), 4, 0., 4);
         if (IsObjMade()) {
            rec.fTrigTypes->GetXaxis()->SetBinLabel(1 + sp605::TRIG_GLOBAL,     "GLOB");
            rec.fTrigTypes->GetXaxis()->SetBinLabel(1 + sp605::TRIG_SELF,       "SELF");
            rec.fTrigTypes->GetXaxis()->SetBinLabel(1 + sp605::TRIG_NEIGHBOR,   "NEIGH");
            rec.fTrigTypes->GetXaxis()->SetBinLabel(1 + sp605::TRIG_BOTH,       "BOTH");
         }

         rec.fStopTypes = MakeTH1('I', Form("%sStopTypes_%u_%u", dfolder, brd, spid), Form("Distribution of stop types for board %u spadic %u", brd, spid), 8, 0., 8.);
         if (IsObjMade()) {
            rec.fStopTypes->GetXaxis()->SetBinLabel(1 + sp605::STOP_NORMAL,             "NORM");
            rec.fStopTypes->GetXaxis()->SetBinLabel(1 + sp605::STOP_OUTBUFFULL,         "FULBUF");
            rec.fStopTypes->GetXaxis()->SetBinLabel(1 + sp605::STOP_FIFOFULL,           "FULFIFO");
            rec.fStopTypes->GetXaxis()->SetBinLabel(1 + sp605::STOP_MULTIHIT,           "MULTI");
            rec.fStopTypes->GetXaxis()->SetBinLabel(1 + sp605::STOP_OUTBUFFULLMULTIHIT, "MULTIFULBUF");
            rec.fStopTypes->GetXaxis()->SetBinLabel(1 + sp605::STOP_FIFOFULLMULTIHIT,   "MULTIFULFIFO");      ;
         }

         rec.fInfoTypes = MakeTH1('I', Form("%sInfoTypes_%u_%u", dfolder, brd, spid), Form("Distribution of info types for board %u spadic %u", brd, spid), 8, 0., 8.);
         if (IsObjMade()) {
            rec.fInfoTypes->GetXaxis()->SetBinLabel(1 + sp605::INFO_DIS, "DIS");
            rec.fInfoTypes->GetXaxis()->SetBinLabel(1 + sp605::INFO_NGT, "NGT");
            rec.fInfoTypes->GetXaxis()->SetBinLabel(1 + sp605::INFO_NRT, "NRT");
            rec.fInfoTypes->GetXaxis()->SetBinLabel(1 + sp605::INFO_NBE, "NBE");
            rec.fInfoTypes->GetXaxis()->SetBinLabel(1 + sp605::INFO_MSB, "MSB");
            rec.fInfoTypes->GetXaxis()->SetBinLabel(1 + sp605::INFO_NOP, "NOP");
            rec.fInfoTypes->GetXaxis()->SetBinLabel(1 + sp605::INFO_SYN, "SYN");
         }

         rec.fSpadic_overflows = MakeTH2('I', Form("%sOverflowMap_%u_%u", dfolder, brd, spid), Form("Map of overflow counts SP605 %u SPADIC %u", brd, spid), MAX_SPADICV10_GROUPS, 0, MAX_SPADICV10_GROUPS, MAX_SPADICV10CHANNELS, -0.5, MAX_SPADICV10CHANNELS-0.5, "group","Channel ID");

         rec.fSpadic_trace2D = MakeTH2('I', Form("%sTrace2D_%u_%u", dfolder, brd, spid), Form("Trace2D from BOARD %u SPADIC %u", brd, spid), SPADICV10_TRACE_SIZE, 0, SPADICV10_TRACE_SIZE, MAX_SPADICV10CHANNELS, -0.5, MAX_SPADICV10CHANNELS-0.5, "time (50 ns)","Channel ID");
         rec.fSpadic_trace2D->SetContour(99);

         rec.fTrigger_Chs = MakeTH1('I', Form("%sChannels_trigg_%u_%u", dfolder, brd, spid), Form("Channels from BOARD %u SPADIC %u", brd, spid), MAX_SPADICV10CHANNELS, 0., MAX_SPADICV10CHANNELS);

         for (int ch = 0; ch < MAX_SPADICV10CHANNELS; ch++) {
            char d2name[100], d2info[100];
            sprintf(d2name, "%sChannel%u/Brd%u_Sp%u_Ch%u", dfolder, ch, brd, spid, ch);
            sprintf(d2info, "SP605 %u SPADIC %u Channel %u", brd, spid, ch);
            // printf("Create histograms for channel %s\n", d2name);

            rec.fSpadic_trace[ch] = MakeTH1('I', Form("%strace", d2name),  Form("Trace  from %s", d2info), SPADICV10_TRACE_SIZE, 0, SPADICV10_TRACE_SIZE, "time (40ns)");
            rec.fSpadic_trace_clean[ch] = MakeTH1('I', Form("%strace_clean", d2name),  Form("Trace clean  from %s", d2info), SPADICV10_TRACE_SIZE, 0, SPADICV10_TRACE_SIZE, "time (40ns)");
            rec.fSpadic_ADCdist[ch] = MakeTH1('I', Form("%sADCdist", d2name),  Form("ADC value distribution from %s", d2info), SPADICV10_TRACE_SIZE, 0, SPADICV10_TRACE_SIZE, "time (40ns)");
         } // for Channels
      }  // for SPADICS
   } // for boards

/*

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

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


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

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





         SPADICV10[n].fTrigger_Fronts[nx] = MakeTH1('I', Form("%sTrigger", nxfolder), Form("Time difference between hit and last trigger signal on %s", nxinfo), 2500, -1000., 4000.);

      } // for nx

   } //

*/

   ExecuteScript("set_SpadicV10Cond.C");
   
   ResetEndOfBuffer();
}

void TSpadicV10Proc::ProcessTriggerMessage(TSpadicV10Data* theSpadic, int brd_id, uint64_t fulltm)
{
   fTriggersPerBoard->Fill(brd_id);

   if (!BRDS[brd_id].fHasNewTrigger) {

      //printf("Find trigger for roc %d\n",sid); cout << endl;

      BRDS[brd_id].fLastTriggerTm = fulltm;
      BRDS[brd_id].fHasNewTrigger = kTRUE;
      BRDS[brd_id].fTriggersPerBuffer++;
      if(theSpadic)
         theSpadic->fLastTriggerTm = fulltm;
   }

#ifndef   SPADICV10_SINGLETRIGGERMODE
   if (brd_id == fParam->masterBoard) {
      fOutputEvent->fLastGlobalTriggerTm = fulltm;
      if (fParam->globalTrigger && !fHasNewGlobalTrigger) {
         fHasNewGlobalTrigger = kTRUE;
         if (!fFirstSubEvent) {
            TGo4Log::Error("Master trigger defined not in the first subevent - change SPADICV10 readout !!!");
            exit(1);
         }
         // JAM put here distribution of master trigger to slaves:
         //cout <<"TTTTTTTTTTTTTTTTTTT ProcessTriggerMessage as master"<<sid << endl;

         // FIXME: SL: it is only for the case when many trigger in buffer are defined, not necessary in normal config
         for (unsigned n = 0; n < numBoards(); n++) {
            if (!AssertBoard(n) || (n==(unsigned) brd_id)) continue;

            TSpadicV10Data* reventn = dynamic_cast<TSpadicV10Data*> (fOutputEvent->getEventElement(n));
            uint64_t triggertm(0);
            // TODO: reintroduce calibration coefficients
            if (BRDS[brd_id].fLastTriggerTm > BRDS[brd_id].fStartSyncTm)
               triggertm = BRDS[n].fStartSyncTm + (BRDS[brd_id].fLastTriggerTm - BRDS[brd_id].fStartSyncTm);
            else
               triggertm = BRDS[n].fStartSyncTm - (BRDS[brd_id].fStartSyncTm - BRDS[brd_id].fLastTriggerTm);
            //cout <<"TTTTTTTTTTTTTTTTTTT ProcessTriggerMessage distributes triggertime "<< triggertm<<" to roc "<<n << endl;
            ProcessTriggerMessage(reventn, n, triggertm);
         }
      }
   }
#endif


   if (BRDS[brd_id].fHasNewTrigger) {
      // reprocess unprocessed messages already here, do not let them go back to unprocessed
      
      for (unsigned i=0; i<BRDS[brd_id].fUnprocessedMsg.size(); i++)
         ProcessExtendedMessage(brd_id, theSpadic, BRDS[brd_id].fUnprocessedMsg[i], false);
      
      BRDS[brd_id].fUnprocessedMsg.clear(); // is filled again from current event below
   }
}


void TSpadicV10Proc::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<TSpadicV10Event*>(btevent->GetSubEvent("SPADICV10"));
      }
      else
      {

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

   fFirstSubEvent = true;

   for (unsigned n=0;n<numBoards();n++) {
      BRDS[n].fStartSyncTm = 0;
      BRDS[n].fStopSyncTm = 0;
   }

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



//-----------------------------------------------------------
// event function
void TSpadicV10Proc::ProcessSubevent(TGo4MbsSubEvent* psubevt)
{
//   uint32_t nxch(0), auxid(0), syncid(0);
//   uint64_t fulltm(0);
//   uint32_t typ(0), lastevsid(0);
//   uint8_t stop(0), info(0), trig(0), lost(0);
//   uint8_t fid(0), chipid(0);
   static int cnt=0;
   unsigned msgcount=0;

   //cout << "#################### ProcessSubevent Start" << endl;
   bool is_dabc_evt = (psubevt->GetProcid() == roc::proc_SpadicV10Event);
   bool is_raw_evt = (psubevt->GetProcid() == roc::proc_SpadicV10Raw);

   // printf("RAW %d DABC %d fullid 0x%x \n", is_raw_evt, is_dabc_evt, psubevt->GetFullId());

   if (!is_dabc_evt && !is_raw_evt) return;

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

#ifdef   SPADICV10_SINGLETRIGGERMODE
       fIsTimeSorted = kFALSE; // SL to avoid any mismatches, should be implemented anyway differently
#else
     fIsTimeSorted=kTRUE; // JAM used for TEST!
#endif
   if(cnt==0) {
       cout << "TTTTTTT fIsTimeSorted is: "<< fIsTimeSorted<< endl;
       cnt=1;
   }


   unsigned brd_id = psubevt->GetSubcrate(); // this is sp605 board id
   int msg_fmt = psubevt->GetControl();

   if (fParam->debugLevel>0)
      printf("SPADICV1 %s data BRD_ID:%u fmt:%d \n", (is_dabc_evt ? "DABC" : "RAW"), brd_id, msg_fmt);

   // printf("BRDID %u FORMAT %d\n", brd_id, msg_fmt);

   if (!AssertBoard(brd_id)) {
      printf("Cannot analyze data from board %u - skip\n",brd_id);
      return;
   }

   //fIter = SPADICV10[brd_id].fIter; // use separate iterators for each roc subevent
   //printf ("IIIIIIII Set iterator 0x%x for sid %d\n", (unsigned) &(SPADICV10[brd_id].fIter),brd_id);

//
//
//   //     cout << "SpadicV10ID = " << (int) psubevt->GetSubcrate() << "  data kind = " << (int) psubevt->GetPsid() << endl;
//
//   fIter.setSpadicV10Number(psubevt->GetSubcrate());

   
// BEGIN INITIAL EVENT PART
   if(!IsKeepInputEvent())
   {
      //cout << "#################### ProcessSubevent has new input event" << endl;
      int datasize = (psubevt->GetDlen() - 2) * 2;
//      int msg_fmt = psubevt->GetControl();
//      SPADICV10[brd_id].fIter.setFormat(msg_fmt);
//      SPADICV10[brd_id].fIter.setSpadicV10Number(brd_id);


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


      if (is_dabc_evt) {
      
         // ignore all irrelevant events
         if (GetTriggerNumber()>7) return;

         // extract SYNC time directly in the loop

      } // isdabcevent

      fTotaldatasize += datasize;

      BRDS[brd_id].fIter.setFormat(msg_fmt);

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

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

      fEvntSize->Fill(datasize);

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

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

   BRDS[brd_id].fLoopsPerBuffer++;

   TSpadicV10Data* theSpadic = 0;
   unsigned last_brd_id = 0;

   sp605::Message* data = & BRDS[brd_id].fIter.msg();
   roc::Message* rocmsg = & BRDS[brd_id].fIter.rocmsg();

#ifdef   SPADICV10_SINGLETRIGGERMODE
    while (BRDS[brd_id].fIter.next()) {
#else
     while (!(BRDS[brd_id].fIsEventComplete) && BRDS[brd_id].fIter.next()) {
      // 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++;
      // sid=brd_id;
      // data->setSpadicNumber(brd_id); //
      //sid = data->getSpadicNumber();

      if (fParam->debugLevel>1)
         BRDS[brd_id].fIter.printMessage();

      fMsgsPerBoard->Fill(brd_id);

      BRDS[brd_id].fHasNewData = kTRUE;

      // SL: extract TSpadicV10Data from composite event only when it necessary
      // in 99% of cases board_id is not changing and we do not search and dynamic_cast again
      if ((theSpadic==0) || (last_brd_id!=brd_id)) {
         theSpadic = dynamic_cast<TSpadicV10Data*> (fOutputEvent->getEventElement(brd_id));
         last_brd_id = brd_id;
         if (fParam->noTrigger && fParam->doSorting && theSpadic) {
            // 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<BRDS[brd_id].fUnprocessedMsg.size(); i++)
               ProcessExtendedMessage(brd_id, theSpadic, BRDS[brd_id].fUnprocessedMsg[i], false);
            BRDS[brd_id].fUnprocessedMsg.clear(); // is filled again from current event below
         }
      }

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

      uint64_t fulltm = BRDS[brd_id].fIter.getMsgFullTime();


      if (BRDS[brd_id].fIter.isRocMsg()) {
         unsigned typ = rocmsg->getMessageType();

         BRDS[brd_id].fMsgCnt->Fill(0); // account black-box messages

         BRDS[brd_id].fMsgTypes->Fill(typ);

         switch (typ) {
            case roc::MSG_EPOCH: break;
            case roc::MSG_SYNC: {

               // if iterator reached buffer end, it is second SYNC which should not be accounted
               if (msgcount>2 && is_dabc_evt && BRDS[brd_id].fIter.at_the_end()) {
                  BRDS[brd_id].fStopSyncTm = fulltm;
                  continue;
               }


               unsigned syncid = rocmsg->getSyncChNum();
               if (syncid < MAX_SPADICV10_SYNC)  {
                  BRDS[brd_id].fLastSyncTm[syncid] = fulltm;
                  BRDS[brd_id].fLastSyncId[syncid] = rocmsg->getSyncData();
                  if (theSpadic)
                     theSpadic->fLastSyncTm[syncid] = fulltm;
                  uint64_t synctm = fulltm / 100000000L;
                  BRDS[brd_id].fSYNCt[syncid]->Fill((synctm % 10000) * 0.1);
               }

               if((msgcount==2) && is_dabc_evt) {
                  BRDS[brd_id].fStartSyncTm = fulltm;
                  BRDS[brd_id].fDabcSeparator = rocmsg->getSyncChNum()+10;

   #ifdef SPADICV10_SINGLETRIGGERMODE
                  unsigned master_id = fParam->masterBoard;
                  // try to reintroduce trigger message in local time
                  if (AssertBoard(master_id) && (master_id!=brd_id) && BRDS[master_id].fHasNewTrigger) {

                     uint64_t triggertm(0);

                     // TODO: introduce time calibration coefficients
                     if (BRDS[master_id].fLastTriggerTm > BRDS[master_id].fStartSyncTm)
                        triggertm = BRDS[brd_id].fStartSyncTm + (BRDS[master_id].fLastTriggerTm - BRDS[master_id].fStartSyncTm);
                     else
                        triggertm = BRDS[brd_id].fStartSyncTm - (BRDS[master_id].fStartSyncTm - BRDS[master_id].fLastTriggerTm);

                     ProcessTriggerMessage(theSpadic, brd_id, triggertm);
                  }
   #endif
               }

               if (fParam->triggerSignal == (int) (syncid + 10))
                  ProcessTriggerMessage(theSpadic, brd_id, fulltm);

               // SL: SYNC/AUX messages are excluded , probably should be reintroduced again
               //ProcessExtendedMessage(brd_id, theSpadic, exmess);
               break;
            }

            case roc::MSG_AUX: {
               unsigned auxid = rocmsg->getAuxChNum();
               BRDS[brd_id].fAUXch->Fill(auxid);

               if (auxid < MAX_SPADICV10_AUX) {
                  BRDS[brd_id].fLastAuxTm[auxid] = fulltm;
                  uint64_t auxtm = fulltm / 100000000L;
                  BRDS[brd_id].fAUXt[auxid]->Fill((auxtm % 10000) * 0.1);
               }

               if (fParam->triggerSignal == (int) auxid) {
                  ProcessTriggerMessage(theSpadic, brd_id, fulltm);
                  //if (sid==0) printf("AUX msg = %lu\n", fulltm);
               }

               // SL: SYNC/AUX messages are excluded , probably should be reintroduced again
               //ProcessExtendedMessage(brd_id, theSpadic, exmess);
               break;
            }

            case roc::MSG_SYS: {
               BRDS[brd_id].fSysTypes->Fill(rocmsg->getSysMesType());
               break;
            }

            default:
               printf("Unsupported ROC message kind %u\n", typ);
               break;
         }

         continue;
      }


      unsigned typ = data->getMsgType();
      //cout << "MSG- SPADICV10:"<<sid << ", typ:" <<typ<<", cnt:"<<msgcount<< endl;
      //data->printData(sp605::msg_print_Human | sp605::msg_print_Prefix);

      // data->printData();

      BRDS[brd_id].fMsgTypes->Fill(typ);

      unsigned sp_id = BRDS[brd_id].fIter.getSpadicId();

      BRDS[brd_id].fMsgCnt->Fill(sp_id+1); // account SPADIC messages

      if (!AssertSpadic(brd_id, sp_id)) continue;

      unsigned gr_id = data->getGroup();

      TSpadicV10Rec& rec = BRDS[brd_id].SPADICS[sp_id];

      rec.fMsgTypes->Fill(typ);

      TSpadicV10MessageExtended exmess(*data,fulltm);
      exmess.SetSpadicId(sp_id);

// TODO: add baseline calibration?
//      if (fParam->baselineCalibr && fParam->dynamicPedestal ) {
//         Bool_t extTrigHit = kFALSE;
//         if (typ == sp605::MSG_HIT) {
//            if (fParam->ttriMode[sid][data->getNxNumber()]) {
//               extTrigHit = kTRUE;
//            }
//         }
//         if (extTrigHit) {
//            fPedestals->ExtractExttrigStream(*data, fulltm);
//         } else {
//            fPedestals->ExtractAutocalibrStream(*data, fulltm);
//         }
//      }

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

         case sp605::MSG_HIT: {
            unsigned stop = data->getStopType();
            unsigned trig = data->getHitType();
            rec.fTrigTypes->Fill(trig);
            rec.fStopTypes->Fill(stop);

            unsigned ch_id = data->getChNum();

#ifdef SPADICV10_DEBUG
            cout << "*** Found MSG_HIT- SPADICV10:"<<sid <<", group:"<<fid<<", chan:"<<nxch<< ", stop type:0x"<<std::hex <<stop;
            cout << ", hit type:0x"<<std::hex <<trig<<std::dec<< endl;
#endif
            if (ch_id < MAX_SPADICV10CHANNELS) {
               // TODO - implement raw histograms of trace data in message payload here
               for (UInt_t bin = 0; bin < data->getTraceSize(); bin++) {
                  int16_t val = data->getTrace(bin);
                  rec.fSpadic_trace[ch_id]->SetBinContent(bin + 1, (int) val); // // // copy of original sampels, this spectra will be corrected
                  rec.fSpadic_trace2D->SetBinContent((int) bin + 1, (int) ch_id + 1, (int) val);
                  rec.fSpadic_ADCdist[ch_id]->Fill(val);
               }
               // TODO: add other things to to with the traces like in spadicv03 processor!
               // may do this in separate function call


               //
               // TODO: <put more sophisticated code for trace display END
               ProcessExtendedMessage(brd_id, theSpadic, exmess); // this will do the message time cut
            } else {
               GO4_STOP_ANALYSIS_MESSAGE(
                     "Data index out of range error - brd:0x%x channel:0x%x !! Check your setup.",
                     brd_id, ch_id);
            }
            break;
         }

         case sp605::MSG_OVERFLOW: {

            unsigned lost = data->getOverflowHits();
            unsigned ch_id = data->getChNum();

            rec.fSpadic_overflows->Fill(gr_id, ch_id, lost);
#ifdef SPADICV10_DEBUG
            cout << "*** Found MSG_OVERFLOW- SPADICV10:"<< brd_id <<", group:"<<gr_id<<", chan:"<<ch_id<< ", lost hits:0x"<<std::hex <<lost<<std::dec<< endl;
#endif

            //ProcessExtendedMessage(sid, theSpadic, exmess);
            break;
         }

         case sp605::MSG_EPOCH: {
            rec.fCurrEpoch = data->getEpoch();
#ifdef SPADICV10_DEBUG
            cout << "*** Found MSG_EPOCH- SPADICV10:"<<sid << ", epoch:0x"<<std::hex <<data->getEpochNumber()<<std::dec<< endl;
#endif
            ProcessExtendedMessage(brd_id, theSpadic, exmess); // used for closing condition of event

            break;
         }

         case sp605::MSG_INFO: {

            unsigned info = data->getInfoType();

            rec.fInfoTypes->Fill(info);
#ifdef SPADICV10_DEBUG
            cout << "*** Found INFO- SPADICV10:"<<sid << ", info:0x"<<std::hex <<typ<<std::dec<<", chan:"<<nxch<< endl;
#endif
            if(info==sp605::INFO_SYN)
               {
                  uint8_t ep = data->getInfoEpoch();
                  std::cout << "  !!! Out of Sync at epoch:0x" << std::hex<< ep << std::dec << std::endl;
               }

            //ProcessExtendedMessage(sid, theSpadic, exmess); // no timestamp
            break;
         }

      /*************************************/      
      } // switch

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

   if (fParam->debugLevel>0)
     printf("SPADICV10Proc process %d messages\n", msgcount);

   if(fIsTimeSorted) {
         // check after loop if we are already at the end of container:
      if(BRDS[brd_id].fIter.at_the_end()) {
               //cout <<"STRICT Timesorting mode is at the end of container for sid:"<< brd_id <<". Set EOB!" << endl;
             #if __GO4BUILDVERSION__ > 40500
               BRDS[brd_id].fHasEndOfBuffer=kTRUE;
             #endif
            }
      }
   //  cout << "Stop processing" << endl;

   fFirstSubEvent = kFALSE;
}



void TSpadicV10Proc::FinalizeEvent()
{
//   static unsigned count=0;
//   static unsigned bcount=0;
   fOutputEvent->fMbsEventNumber = GetEventNumber();
   // now we should decide if event should be delivered to the output
   // either all used SPADICV10s are ready with their events or sync is used as trigger

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

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

      fAUX2_R01->Fill(diff0-diff1);

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

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

   for (unsigned r=0; r<numBoards();r++) {
      if (!AssertBoard(r)) continue;
      TSpadicV10Data* theSpadicV10 = dynamic_cast<TSpadicV10Data*>(fOutputEvent->getEventElement(r));
      if(theSpadicV10==0) continue;
      
#ifdef SPADICV10_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))
          BRDS[r].fUnprocessedMsg.clear();
#endif

     if( theSpadicV10->fExtMessages.size() > 0)
         isAnyData = true;
      /*************************************/


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

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

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

      //printf("SPADICV10%d event complete = %d\n", r, SPADICV10[r].fIsEventComplete);

      if( (!BRDS[r].fHasEndOfBuffer)
            && (BRDS[r].fTriggersPerBuffer<=fParam->maxBufferTriggers)
            && (BRDS[r].fLoopsPerBuffer<=fParam->maxBufferLoops))
         {
            allInputsComplete = false;
         }


      //printf("SPADICV10%d buffer complete = %d\n", r, SPADICV10[r].fHasEndOfBuffer);

//      if (SPADICV10[r].fTriggersPerBuffer > fParam->maxBufferTriggers) {
//         printf("SPADICV10%d # of triggers %d per buffer exceeds %d \n", r,
//               SPADICV10[r].fTriggersPerBuffer, (int) fParam->maxBufferTriggers);
//         cout << endl;
//      }
//      if (SPADICV10[r].fLoopsPerBuffer > fParam->maxBufferLoops) {
//         printf("SPADICV10%d # of loops %d per buffer exceeds %d\n", r,
//               SPADICV10[r].fLoopsPerBuffer, (int) fParam->maxBufferLoops);
//         cout << endl;
//      }

   } // for r

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



   if (allEventComplete) {
     
      //printf("!!!!!!!!! Event %d is complete !!!!!!!!!\n",count++);

      for (unsigned r=0; r<numBoards(); r++) {
         TSpadicV10Data* theSpadicV10 = dynamic_cast<TSpadicV10Data*>(fOutputEvent->getEventElement(r));
         if(theSpadicV10==0) continue;

         if (fParam->doSorting)
         {
            std::sort(theSpadicV10->fExtMessages.begin(), theSpadicV10->fExtMessages.end());
         }

         BRDS[r].fEvntMultipl->Fill(theSpadicV10->fExtMessages.size());

         theSpadicV10->SetValid(kTRUE);

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

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

      fOutputEvent->SetValid(kTRUE);

      ResetTrigger();

   } else {
      fOutputEvent->SetValid(kFALSE);
   }



   // 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)
            {
                   //cout <<"STRICT Timesorting mode finds all input buffers processed. Get new mbs input "<<bcount++ << endl;
#if __GO4BUILDVERSION__ > 40500
                   SetKeepInputEvent(kFALSE); // request new mbs container
#endif
                   ResetEndOfBuffer();
            }


// JAM: this one will throw away almost everything...
//            else if (anyInputComplete && !allEventComplete)
//            {
//               cout <<"STRICT Timesorting mode finds some input buffer at the end, but not all events complete. Discard rest of buffers and  get new mbs input "<< bcount++<< endl;
//#if __GO4BUILDVERSION__ > 40500
//               SetKeepInputEvent(kFALSE); // request new mbs container
//#endif
//               ResetEndOfBuffer();
//            }

            else
            {
#if __GO4BUILDVERSION__ > 40500
                   //cout <<"STRICT Timesorting mode sets KEEP mbs input!" << endl;
                   SetKeepInputEvent(kTRUE);  // unless we have processed buffers of all rocs completely, we keep input
#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(" =============== TSpadicV10Proc::FinalizeEvent ===================\n ");
}


void TSpadicV10Proc::ProcessExtendedMessage(unsigned brd_id, TSpadicV10Data* theSpadic, TSpadicV10MessageExtended& exmsg, bool with_unprocessed)
{
   bool isinside(false), add_to_unprocessed(false), add_to_event(false);

   double diff = 0;

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

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

   if (fParam->noTrigger) {

      // JAM: for the moment, we can only handle untriggered mode. Take all input messagesas is
      add_to_event = true;

      // 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 || (SPADICV10[sid].fStopSyncTm==0)) {
//         add_to_event = true;
//      } else {
//         if (exmsg.GetFullTime() + 16000 < SPADICV10[sid].fStopSyncTm)
//            add_to_event = true;
//         else
//            add_to_unprocessed = true;
//      }
   } else
   if (BRDS[brd_id].fHasNewTrigger) {

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

//      if(exmsg.GetMessageType() == sp605::MSG_AUX)
//         cond = fParam->globalTrigger ? fGlobalAUXWind : SPADICV10[sid].fAUXWind;

      exmsg.SetTriggerDeltaT(diff);

      if (cond->Test(diff)) {
         add_to_event = true;
         isinside = true;
      } else {
         double rightdist = diff - cond->GetXUp();
         if(fIsTimeSorted)
            {
               // we assume that message stream was strictly time sorted by dabc/ or go4 lmd user source JAM
               if (rightdist>0.) {
                  BRDS[brd_id].fIsEventComplete = kTRUE;
                  //SPADICV10[sid].fHasNewTrigger= kFALSE; // everything after us is buffered until next trigger is found
                  add_to_unprocessed = kTRUE; // keep this message for next event.
                  //cout <<"STRICT Timesorting mode marks complete event for roc:"<<sid<<" at dt="<<rightdist << endl;
               }
            }
         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 SPADICV10
                  if (rightdist > 5000.) BRDS[brd_id].fIsEventComplete = kTRUE;
                  if (rightdist>0.) {
                     if (BRDS[brd_id].fStopSyncTm==0) {
                        add_to_unprocessed = true;
                     } else {
                        double diff2 = 0;
                        if(exmsg.GetFullTime() >= BRDS[brd_id].fStopSyncTm)
                           diff2 = exmsg.GetFullTime() - BRDS[brd_id].fStopSyncTm;
                        else
                           diff2 = -1.0 * (BRDS[brd_id].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 && (sid==0)) printf("diff2 = %7.1f\n", diff2);
                     }
                  }
         // END NOT STRICTLY
            } //if(fIsTimeSorted)
      } // if (cond->Test(diff))
   } // if (SPADICV10[sid].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;
   }

   if(isinside && (exmsg.GetMessageType() == sp605::MSG_HIT)) { // but we put only nx hist to local histograms...
      unsigned sp_id = exmsg.GetSpadicId();
      unsigned ch_id = exmsg.GetFullChNum();
      BRDS[brd_id].SPADICS[sp_id].fTrigger_Chs->Fill(ch_id);
   }

    if((exmsg.GetMessageType() == sp605::MSG_HIT) && (diff!=0)) {
     // if (sid==0) printf("Diff = %9.1f\n", diff);
      fDeltaTriggerTime->Fill(diff);
      BRDS[brd_id].fTrigger->Fill(diff);
      BRDS[brd_id].fTrigger_100->Fill(diff);
   }

//   if(exmsg.GetMessageType() == sp605::MSG_AUX) {
//      SPADICV10[sid].fTrigger_AUX->Fill(diff);
//   }


   if(exmsg.GetMessageType() == sp605::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 (theSpadic && add_to_event)
      theSpadic->fExtMessages.push_back(exmsg);

   if (add_to_unprocessed && with_unprocessed)
      BRDS[brd_id].fUnprocessedMsg.push_back(exmsg);
}

void TSpadicV10Proc::ResetTrigger()
{
   //cout <<"RRRRRRRRRRRR ResetTrigger" << endl;
   fHasNewGlobalTrigger = kFALSE;
   for (unsigned n=0; n<numBoards();n++) {
      BRDS[n].fIsEventComplete = kFALSE;
      if (BRDS[n].fHasEndOfBuffer) BRDS[n].fHasNewData = kFALSE;
      BRDS[n].fHasNewTrigger = kFALSE;
// SL: we keep last trigger time for histogramm filling
//      SPADICV10[n].fLastTriggerTm = 0;
      BRDS[n].fDabcSeparator = -1;
   }
}


void TSpadicV10Proc::ResetEndOfBuffer()
{
   //cout <<"RRRRRRRRRRRR ResetEndOfBuffer:" << endl;
   for (unsigned n=0; n<numBoards();n++) {
      //cout <<" SpadicV10"<<n<<" triggers:"<<  SPADICV10[n].fTriggersPerBuffer <<", loops:"<<SPADICV10[n].fLoopsPerBuffer<< endl;
      BRDS[n].fTriggersPerBuffer=0;
      BRDS[n].fLoopsPerBuffer=0;
      BRDS[n].fHasEndOfBuffer = kFALSE;
   }
}