beamtime/gsi-aug12/prod/go4/MBSUNPACK/TMbsCrateProc.cxx (r4864/r3742)

Go to the documentation of this file.

#include "TMbsCrateProc.h"

#include <stdlib.h>

#include "TTimeStamp.h"
#include "TSystem.h"
#include "TROOT.h"
#include "TGo4Log.h"

#include "TTriglogEvent.h"

// still need this for subevent types:
#include "roc/Message.h"
#include "roc/Board.h"

#if defined(VERSION_VFTX) || defined(VERSION_VFTX_28)  // For Heidelberg tests!
   #include "../mbs/cbmvme0.h"
#else
   #include "../mbs/cbmvme.h"
#endif

const uint32_t vme_setup[MAX__N_MOD*6] = VME__MODULES;

uint64_t vme_tags[MAX__N_MOD];

#define CAEN1290_DEBUG 0
#define L1182_DEBUG 0

TMbsCrateProc::TMbsCrateProc() :
   TCBMBeamtimeProc(),
   fOutputEvent(0)
{
}

TMbsCrateProc::TMbsCrateProc(const char* name) :
   TCBMBeamtimeProc(name),
   fOutputEvent(0)
{
   TGo4Log::Info("TMbsCrateProc: Create instance %s", name);

   TString obname, obtitle;   

   fPar = (TMbsCrateParam*) MakeParameter("MbsCratePar", "TMbsCrateParam");
   
   // v1290 histograms

   iCaenEnabled = 0;
   for (int n=0;n<MAX_1290;n++)
      if( 1 == fPar->uCaenTdcHistosEnabled[n] )
      {
         if( kTRUE == fPar->bCaenDebug || kTRUE == fPar->bCaenTriggerTime )
            fTDC[n].MakeHistos(this, fPar->bCaenDebug, fPar->bCaenTriggerTime, Form("TDC%d",n));
         else {
            fTDC[n].MakeHistos(this, Form("TDC%d",n));
            if( CAEN1290_DEBUG )
               fTDC[n].MakeDebugHistos(this, Form("TDC%d",n));
         }
         iCaenEnabled++;
      }

   if( 1 < iCaenEnabled && 1 == fPar->uCaenCoincidenceMap)
   {
      /*
      fAllTDC_chanMapL = MakeTH2('I', "CAEN/chanMap_CaenTdcL", "Channel (L) during same event?",
            MAX_1290*T1290Data::NumChan, -0.5, MAX_1290*T1290Data::NumChan-0.5,
            MAX_1290*T1290Data::NumChan, -0.5, MAX_1290*T1290Data::NumChan-0.5,
           "Channel 1 []", "Channel 2[]", "Events []");
      */
      iMapIndex = 0;
      for( Int_t iModule1 = 0; iModule1 < MAX_1290; iModule1 ++)
         for( Int_t iModule2 = iModule1; iModule2 < MAX_1290; iModule2 ++)
         {
            if( MAX_1290*(MAX_1290+1)/2 < iMapIndex )
            {
               TGo4Log::Info("****Mbs unpacker: Error creating caen mapping histos: index out of boundary : %d / %d (tdc #%d VS tdc #%d)",
                     iMapIndex, MAX_1290*(MAX_1290+1)/2, iModule1, iModule2);
               break;
            }
            fTDC_chanMapL[ iMapIndex ] =
                     MakeTH2('I', Form("CAEN/Mapping/Mapp%d_%dCaen", iModule1, iModule2 ),
                                  Form("Channel during same event?, Tdc %d VS Tdc %d", iModule1, iModule2),
                                  T1290Data::NumChan, -0.5, T1290Data::NumChan - 0.5,
                                  T1290Data::NumChan, -0.5, T1290Data::NumChan - 0.5,
                                  Form("Channel Tdc #%d []", iModule1),
                                  Form("Channel Tdc #%d []", iModule2),"Events []");
            iMapIndex++;
         }
   }

   for (int n=0;n<MAX_965;n++)
      if( 1 == fPar->uCaenQdcHistosEnabled[n] )
         for (int ch=0;ch<MQDC_t::NumChan;ch++) {
            obname.Form("QDC%d/Charge%d_%d",n,n,ch);
            obtitle.Form("Charge of QDC %d channel %d",n,ch);
            fQdc_Charge[n][ch] = MakeTH1('I',obname.Data(),obtitle.Data(),4096,1,4096,"charge");
         }

   for (int n=0;n<MAX_FPGA_TDC;n++)
      if( 1 == fPar->uVftxHistosEnabled[n] )
         for (int ch=0;ch<FPGA_TDC_NBCHAN;ch++) {
            obname.Form("FPGA_TDC%d/FPGA_TDC%d_Ch%d", n, n, ch);
            obtitle.Form("Fine counter of TDC%d channel %d", n, ch);
            fFPGA_Ch[n][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 0x800, 0, 0x800, "cnt");
         }

   // 1182 histograms
   for (int n=0;n<MAX_1182;n++)
      if( 1 == fPar->uLecroyQdcHistosEnabled[n] )
         for (int ch=0;ch<NUM_1182_CH;ch++) {
            obname.Form("118%d/118%d_channel%d", n+2, n+2, ch);
            obtitle.Form("118%d Channel %d", n+2, ch);
            f1182h[n][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 1024, 0, 4096.);
         }


   // QFW histograms
   if( 1 == fPar->uQFWHistosEnabled )
   {
      fQFWcnt = MakeTH1('I', "QFW/QFWcnt", "Counts in QFW channels", 4, 0, 4, "cnt");
      fQFWerr = MakeTH1('I', "QFW/QFWerr", "Error counts in QFW channels", 4, 0, 4, "err");

      fQFWInfo = new TLatex(0.5,0.5,"-- demo text --");
      fQFWInfo->SetName("QFWInfo");
      fQFWInfo->SetNDC();
      AddObject(fQFWInfo);
   }

   for (int n=0;n<MAX__N_MOD;n++) {
      if (n != (int)vme_setup[n*6]) {
         TGo4Log::Error("Wrong setup in cbmvme.h file in row %d",n);
         exit(1);
      }

      vme_tags[n] = (((uint64_t) vme_setup[n*6+5]) << 32) | vme_setup[n*6+4];

      if ((n>0) && (vme_tags[n]==0)) {
         TGo4Log::Error("Wrong setup in cbmvme.h - zero tag in row %d", n);
         exit(1);
      }
   }

   // Initial value of event number
   iLastEventNumber = -1;

   TGo4Log::Info("TMbsCrateProc - Histograms created");
}

TMbsCrateProc::~TMbsCrateProc()
{
   TGo4Log::Info("Last Event: %d", iLastEventNumber);
   cout << "**** TMbsCrateProc: Delete instance " << endl;
}

void TMbsCrateProc::InitEvent(TGo4EventElement* outevnt)
{
   TCBMBeamtimeEvent* btevent=dynamic_cast<TCBMBeamtimeEvent*>(outevnt);
   if(btevent)
   {
      // 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)
         fOutputEvent=dynamic_cast<TMbsCrateEvent*>(btevent->GetSubEvent("MBSCRATE"));
   }
   else
   {

      fOutputEvent= dynamic_cast<TMbsCrateEvent*>(outevnt);
   }
   if(fOutputEvent==0) {
      GO4_STOP_ANALYSIS_MESSAGE("**** TMbsCrateProc: Fatal error: output event is not a TMbsCrateEvent!!! STOP GO4");
   }
}

void TMbsCrateProc::ProcessSubevent(TGo4MbsSubEvent* subevt)
{
// uncomment this to test with previous beamtime lmds:
   if (subevt->GetProcid() == roc::proc_Triglog) {
      if( -1 == iLastEventNumber )
      {
         iLastEventNumber = GetEventNumber();
         TGo4Log::Info("First Event: %d", iLastEventNumber);
      }
         else iLastEventNumber =  GetEventNumber();

      UInt_t lwords = subevt->GetIntLen();
      Int_t  indx = 0;
      if(  4+ NUM_SCALERS*N_SCALERS_CH < lwords)
      {
         indx = 4+ NUM_SCALERS*N_SCALERS_CH;
         fOutputEvent->fTriglogInputPattern = subevt->Data(indx++);

         if( indx < subevt->GetIntLen() )
            fOutputEvent->fTriglogReferenceClock = subevt->Data(indx++) ;
      }
   }
   if (subevt->GetProcid() == roc::proc_COSY_Nov11) {
// comment this to test with previous beamtime lmds:
//   if (subevt->GetProcid() == roc::proc_GSI_Aug12) {
      // MBS data from GSI beamtime, August 11
      // subevt->GetControl() == 9 from Master MBS, subevt->GetControl() == 10 from Slave MBS

      Int_t *pdata = subevt->GetDataField();
      UInt_t lwords = subevt->GetIntLen();

      // printf("CERN subevent Control %u TOTALLEN = %u\n", subevt->GetControl(), lwords);

      Int_t* tagpos[MAX__N_MOD];
      Int_t taglen[MAX__N_MOD];

      for (int n=0;n<MAX__N_MOD;n++) {
         tagpos[n] = 0;
         taglen[n] = 0;
      }

      int lasttag = -1;

      for (UInt_t cur = 0; cur < lwords; ++cur) {
         uint64_t* ptag = (uint64_t*) pdata;
         bool find = false;

         for (int ntag=1;ntag<MAX__N_MOD;ntag++)
            if ((*ptag == vme_tags[ntag]) && (vme_tags[ntag]!=0)) {
               if (lasttag>=0) {
                  taglen[lasttag] = pdata - tagpos[lasttag];
                  lasttag = -1;
               }

               if (tagpos[ntag]==0) {
                  pdata+=2; cur+=1;
                  tagpos[ntag] = pdata;
                  lasttag = ntag;
               } else {
                  TGo4Log::Error("FORMAT ERROR found tag %lld twice\n", vme_tags[ntag]);
                  pdata+=2; cur+=1;
               }

               find = true;
               break;
            }

         if (!find) pdata++;
      }

      if (lasttag>=0)
         taglen[lasttag] = pdata - tagpos[lasttag];

      // for (int ntag=0;ntag<numtags;ntag++)
      //    if (tagpos[ntag])
      //       printf("TAG %d POS %lu LEN %d\n", ntag, tagpos[ntag] - p0, taglen[ntag]);


      // if (GetTriggerNumber()==8) {
      //   fOutputEvent->SetValid(kFALSE);
      //   return;
      // }


      // actually process data in subroutines:

      if (tagpos[VME__ID_1182] && taglen[VME__ID_1182])
         Process1182(0, tagpos[VME__ID_1182], taglen[VME__ID_1182]);  // 1182
      if (tagpos[VME__ID_1183] && taglen[VME__ID_1183])
         Process1182(1, tagpos[VME__ID_1183], taglen[VME__ID_1183]);  // 1183

      for (int tdc=VME__ID_TDC1;tdc<=VME__ID_TDC8;tdc++)
         if (tagpos[tdc] && taglen[tdc])
            Process1290(tdc-VME__ID_TDC1, tagpos[tdc], taglen[tdc]);  // all TDCs

      for (int qdc=VME__ID_QDC1;qdc<=VME__ID_QDC2;qdc++)
         if (tagpos[qdc] && taglen[qdc])
            Process965(qdc-VME__ID_QDC1, tagpos[qdc], taglen[qdc]);  // all QDCs

      for (int fpga=VME__ID_FPGA1;fpga<=VME__ID_FPGA11;fpga++)
         if (tagpos[fpga] && taglen[fpga])
            ProcessVFTX(fpga-VME__ID_FPGA1, (uint32_t*) tagpos[fpga], taglen[fpga]);  // all FPGAs

      if (tagpos[VME__ID_QFW] && taglen[VME__ID_QFW])
         ProcessQFW((uint32_t*)tagpos[VME__ID_QFW], taglen[VME__ID_QFW]);  // QFW

      if (tagpos[VME__ID_SCOM] && taglen[VME__ID_SCOM])
         ProcessScalOrMu((uint32_t*)tagpos[VME__ID_SCOM], taglen[VME__ID_SCOM]);  // Scaler Or Multiplicity

      if( 1 < iCaenEnabled && 1 == fPar->uCaenCoincidenceMap)
         for (Int_t iCaentdc1 = 0; iCaentdc1 < MAX_1290; iCaentdc1++)
            if( 1 == fPar->uCaenTdcHistosEnabled[iCaentdc1] )
               for (Int_t iChannel1 = 0; iChannel1 < T1290Data::NumChan; iChannel1++)
               {
                  // Go back to index for VFTX internal map
                  iMapIndex = MAX_1290*(MAX_1290+1)/2
                           - (MAX_1290-iCaentdc1)*((MAX_1290-iCaentdc1)+1)/2;

                  if( MAX_1290*(MAX_1290+1)/2 < iMapIndex )
                  {
                     TGo4Log::Info("****Vftx monitor: Error filling mapping histos: index out of boundary : %d / %d (tdc #%d VS tdc #%d)",
                           iMapIndex, MAX_1290*(MAX_1290+1)/2, iCaentdc1, iCaentdc1);
                     return;
                  } // if( MAX_1290*(MAX_1290+1)/2 < iMapIndex )

                  //if( 0 < fOutputEvent->fMtdc[iCaentdc1].hit_lead[iChannel1] &&
                  //    0 < fOutputEvent->fMtdc[iCaentdc1].hit_trail[iChannel1] )
                  if( 0 < fOutputEvent->fMtdc[iCaentdc1].hit_lead[iChannel1] )
                  {
                     for (Int_t iChannel2 = iChannel1+1; iChannel2 < T1290Data::NumChan; iChannel2++)
                        //if( 0 < fOutputEvent->fMtdc[iCaentdc1].hit_lead[iChannel2] &&
                        //    0 < fOutputEvent->fMtdc[iCaentdc1].hit_trail[iChannel2])
                        if( 0 < fOutputEvent->fMtdc[iCaentdc1].hit_lead[iChannel2] )
                           /*
                           fAllTDC_chanMapL->Fill( iCaentdc1*T1290Data::NumChan + iChannel1,
                                                  iCaentdc1*T1290Data::NumChan + iChannel2);
                                                  */
                           fTDC_chanMapL[iMapIndex] ->Fill( iChannel1, iChannel2);

                     for (Int_t iCaentdc2 = iCaentdc1+1; iCaentdc2 < MAX_1290; iCaentdc2++)
                     {
                        // Find index for corresponding VFTX against VFTX map
                        iMapIndex = MAX_1290*(MAX_1290+1)/2
                                 - (MAX_1290-iCaentdc1)*((MAX_FPGA_TDC-iCaentdc1)+1)/2
                                 + (iCaentdc2 - iCaentdc1);
                        if( MAX_1290*(MAX_1290+1)/2 < iMapIndex )
                        {
                           TGo4Log::Info("****Vftx monitor: Error filling mapping histos: index out of boundary : %d / %d (tdc #%d VS tdc #%d)",
                                 iMapIndex, MAX_1290*(MAX_1290+1)/2, iCaentdc1, iCaentdc2);
                           return;
                        } // if( MAX_1290*(MAX_1290+1)/2 < iMapIndex )

                        if( 1 == fPar->uCaenTdcHistosEnabled[iCaentdc2] )
                           for (Int_t iChannel2 = 0; iChannel2 < T1290Data::NumChan; iChannel2++)
                              //if( 0 < fOutputEvent->fMtdc[iCaentdc2].hit_lead[iChannel2] &&
                              //    0 < fOutputEvent->fMtdc[iCaentdc2].hit_trail[iChannel2] )
                              if( 0 < fOutputEvent->fMtdc[iCaentdc2].hit_lead[iChannel2]  )
                              /*
                                 fAllTDC_chanMapL->Fill( iCaentdc1*T1290Data::NumChan + iChannel1,
                                                        iCaentdc2*T1290Data::NumChan + iChannel2);
                              */
                                 fTDC_chanMapL[iMapIndex] ->Fill( iChannel1, iChannel2);
                     } // for (Int_t iCaentdc2 = iCaentdc1+1; iCaentdc2 < MAX_1290; iCaentdc2++)
                  } // if( 0 < fOutputEvent->fMtdc[iCaentdc1].hit_lead[iChannel1] && same for trail )
               } // for (Int_t iChannel1 = 0; iChannel1 < T1290Data::NumChan; iChannel1++)

      fOutputEvent->SetValid(kTRUE);
   }
}




void TMbsCrateProc::Process1182(int num, int* pdata, int len)
{
   if (len < 2 + NUM_1182_CH ) {
      cout <<"TBeamMonitorProc:Process1182 data length"<< len << "not sufficient!" <<endl;
      return;
   }

   if (num>=MAX_1182) {
      cout << "Wrong ID=" << num << " of 1182 module" << endl;
      return;
   }

   // skip event header:
   int header = *pdata++;
   if (L1182_DEBUG)  printf("1182 header:0x%0x \n",header);

   // skip status
   int status = *pdata++;
   if (L1182_DEBUG)
      printf("1182 status:0x%0x :  \n"
            "        conversion complete    (bit0): 0x%x\n"
            "        conversion in progress (bit1): 0x%x\n"
            "        front(1)/rear(0) panel (bit2): 0x%x\n"
            "        Event buffer not full  (bit3): 0x%x\n"
            "        Event count       (bits 4..7): 0x%x\n"
            "        should be 0            (bit8): 0x%x\n"
            "        should be 0            (bit9): 0x%x\n",
            status, status & 1, (status >> 1) & 1 , (status >> 2) & 1, (status >> 3) & 1,
            (status >> 4) & 0xf,  (status >> 8) & 1, (status >> 9) & 1);

   for(int ch=0;ch<NUM_1182_CH;++ch) {
      int val = *pdata++;
      
      if( 1 == fPar->uLecroyQdcHistosEnabled[num] )
         f1182h[num][ch]->Fill(val);

      fOutputEvent->fData1182[num][ch] = val; // output event to root tree
   }

   fOutputEvent->SetValid(kTRUE);
}

void TMbsCrateProc::Process1290(int num, int* pdata, unsigned int len)
{
   if (num >= MAX_1290) {
      cout << "Wrong 1290 index " << num << endl;
      return;
   }

   int expected_geo = 0;

   if (num<0) {
      // if number is not specified, try to identify it base on GEO value
      expected_geo = T1290Data::FindGeo(pdata, len);
      if (expected_geo<=0) {
         printf("ERROR: Did not found GEO in the data\n");
         return;
      }

      switch (expected_geo) {
         case 5: num = 8; break;
         case 6: num = 9; break;
         case 7: num = 10; break;
         case 8: num = 11; break;
         case 9: num = 12; break;
         case 10: num = 13; break;
         case 11: num = 14; break;
         default:
            printf("Unsupported GEO code %d\n", expected_geo);
            return;
      }

      // printf("Found GEO code %d defined num %d\n", expected_geo, num);

   } else {
      switch(num) {
         case 0: expected_geo = 8; break;
         case 1: expected_geo = 9; break;
         case 2: expected_geo = 10; break;
         case 3: expected_geo = 11; break;
         case 4: expected_geo = 12; break;
         case 5: expected_geo = 13; break;
         case 6: expected_geo = 14; break;
         case 7: expected_geo = 15; break;
       }
   }
   // printf("Process1290 num = %d expected GEO = %d len = %u\n", num, expected_geo, len);

   fOutputEvent->fMtdc[num].Unpack(pdata, len, expected_geo);

   if( 1 == fPar->uCaenTdcHistosEnabled[num] )
   {
      if( kTRUE == fPar->bCaenDebug || kTRUE == fPar->bCaenTriggerTime )
         fTDC[num].FillHistos(fOutputEvent->fMtdc[num], fPar->bCaenDebug, fPar->bCaenTriggerTime);
      else
      {
         fTDC[num].FillHistos(fOutputEvent->fMtdc[num]);
         if( CAEN1290_DEBUG )
            fTDC[num].FillDebugHistos(fOutputEvent->fMtdc[num]);
      }
   }

   fOutputEvent->SetValid(kTRUE);
}

void TMbsCrateProc::Process965(int num, int* pdata, unsigned int len)
{
        int geo, crate, count;
        Int_t timeOffset;
        int data;
        
        if (num >= MAX_965) {
                cout << "Wrong 965 index " << num << endl;
                return;
        }
        geo = 0;
        timeOffset = 0;
        data = *pdata++;
        len--;
        count = 0;
        if (num<0) {
                // if number is not specified, try to identify it base on GEO value
                geo = MQDC_t::FindGeo(pdata, &count, &crate);
                if (geo<=0) {
                        printf("ERROR: Did not found GEO in the data\n");
                        return;
                }
                switch (geo) {
                        case 0: num = 0; break;
                        case 1: num = 1; break;
                        case 2: num = 2; break;
                        default:
                                printf("Unsupported GEO code %d\n", geo);
                                return;
                }
        }
        else
        {
                if(((data>>24) & 0x7) == 0x2)
                {
                        count = (data >> 8) & 0x3f;
                }
                switch(num) {
                        case 0: geo = 0; break;
                        case 1: geo = 1; break;
                        case 2: geo = 2; break;
                }
        }
        fOutputEvent->fMqdc[num].Unpack(pdata, count, geo);
        
   if( 1 == fPar->uCaenQdcHistosEnabled[num] )
      for (int ch=0; ch<MQDC_t::NumChan; ch++) {
         if(fOutputEvent->fMqdc[num].charge[ch]>0)
            fQdc_Charge[num][ch]->Fill(fOutputEvent->fMqdc[num].charge[ch]);
       }
        
        fOutputEvent->SetValid(kTRUE);
}

void TMbsCrateProc::ProcessVFTX(int num, uint32_t* pdata, unsigned int len)
{
   if ((num<0) || (num>=MAX_FPGA_TDC)) 
   {
      TGo4Log::Error("Error VFTX number %d out of bound (max %d) ", num, MAX_FPGA_TDC);
      return;
   }

   uint32_t l_dat = *pdata++; // module header
   if ( (l_dat & TDC_EVT_HEADER_KEY_MASK)>>TDC_EVT_HEADER_KEY_SHIFT != TDC_EVT_HEADER_KEYWORD ) 
   {
      TGo4Log::Warn("this is not a vftx %d header, jumping this sub-event...", num);
      //return;
   }
   FPGA_TDC_header header;
   uint32_t l_nr_cha   = (l_dat & TDC_EVT_HEADER_NB_MASK);
   header.nr_data = l_nr_cha;
   header.mod_nr = ((l_dat & TDC_EVT_HEADER_MOD_MASK) >> TDC_EVT_HEADER_MOD_SHIFT); 
   if (l_nr_cha+2 != len && l_nr_cha+2 + 256 != len)
   {
     TGo4Log::Warn("wrong length in vftx %d header, jumping this sub-event... %d vs %d", num, l_nr_cha+2, len);
     // Return commented: MBS vftxlib.c for gsi aug 12 not compatible with too many data in event: 
     // only 8 bit where used to code event size => effective limitation to 256 hits then loop
      //return;
   }
   
   l_dat = *pdata++;  // vulom tdc fifo header
   if (l_dat & TDC_FIFO_MESSAGE_TYPE) 
   {
      header.fpga_fifo_tt = (l_dat & TDC_FIFO_HEADER_TRIG_TYPE) >> TDC_FIFO_HEADER_TRIG_TYPE_SHIFT;
      header.fpga_fifo_ct = (l_dat & TDC_FIFO_HEADER_TRIG_TIME) >> TDC_FIFO_HEADER_TRIG_TIME_SHIFT;
      header.fpga_fifo_nd = (l_dat & TDC_FIFO_HEADER_DATA_CNT);
   } // if (l_dat & TDC_FIFO_MESSAGE_TYPE) 
   else 
   {
      TGo4Log::Warn("vftx %d fifo header missing... ", num);
   }
   
      
   // cout << "mod: " << num << " ct: " << header.fpga_fifo_ct << endl;
   fOutputEvent->fFPGAHEAD[num].push_back(header);
   // cout << "TDC" << num << " , data items: " << header.nr_data << endl;
   // cout << "trigger ct: " << header.fpga_fifo_ct << "data nb: " << header.fpga_fifo_nd << endl;
   while (l_nr_cha-- > 0) 
   {
      uint32_t l_da0 = *pdata++;

      FPGA_TDC_hit hit;
      if ((l_da0 & TDC_FIFO_MESSAGE_TYPE) == TDC_FIFO_MESSAGE_TYPE) 
      {
         TGo4Log::Warn("wrong data item in vftx %d: type %d (message %08x, header %08x), jumping this sub-event...", 
                       num, (l_da0 & TDC_FIFO_MESSAGE_TYPE)>>TDC_FIFO_MESSAGE_TYPE_SHIFT, l_da0, l_dat);
         TGo4Log::Warn("Message: tt %01u ct %5u nd %3u", 
                      (l_da0 & TDC_FIFO_HEADER_TRIG_TYPE) >> TDC_FIFO_HEADER_TRIG_TYPE_SHIFT,
                      (l_da0 & TDC_FIFO_HEADER_TRIG_TIME) >> TDC_FIFO_HEADER_TRIG_TIME_SHIFT,
                      (l_da0 & TDC_FIFO_HEADER_DATA_CNT) );
         TGo4Log::Warn("Header : tt %01u ct %5u nd %3u", 
                      (l_dat & TDC_FIFO_HEADER_TRIG_TYPE) >> TDC_FIFO_HEADER_TRIG_TYPE_SHIFT,
                      (l_dat & TDC_FIFO_HEADER_TRIG_TIME) >> TDC_FIFO_HEADER_TRIG_TIME_SHIFT,
                      (l_dat & TDC_FIFO_HEADER_DATA_CNT) );
         return;
      }
      hit.ch_ix        = (l_da0 & TDC_FIFO_DATA_CHAN) >> TDC_FIFO_DATA_CHAN_SHIFT; //4-5 bit
      if (hit.ch_ix > FPGA_TDC_NBCHAN - 1)
         TGo4Log::Warn("channel number larger then %d found in vftx %d", FPGA_TDC_NBCHAN -1, num);
         
      hit.future_bit   = (l_da0 & TDC_FIFO_FUTURE_BIT) >> TDC_FIFO_FUTURE_BIT_SHIFT;  //  1 bit
      hit.coarse_ct    = (l_da0 & TDC_FIFO_COARSE_CT) >> TDC_FIFO_COARSE_CT_SHIFT;   // 15 bit
      hit.ch_tim       = (l_da0 & TDC_FIFO_FINE_CT);        // 10 bit, 11th bit empty

      // cout << "data: "<< l_nr_cha << " ch: " << hit.ch_ix << " ct: " << hit.coarse_ct;
      // cout << " ft: " << hit.ch_tim << " fut: " << hit.future_bit << endl;
      fOutputEvent->fFPGA[num].push_back(hit);
      
      if( 1 == fPar->uVftxHistosEnabled[num] )
         if (hit.ch_ix<FPGA_TDC_NBCHAN)
            fFPGA_Ch[num][hit.ch_ix]->Fill(hit.ch_tim);
    } // while (l_nr_cha-- > 0) 
    
    //cout<<" FPGA TDC num "<<num<<" finished"<<endl;
   fOutputEvent->SetValid(kTRUE);
}

void TMbsCrateProc::ProcessQFW(uint32_t* pdata, unsigned int len)
{
   if (len!=9) {
      TGo4Log::Error("Wrong QFW format");
      return;
   }

   for (int n=0;n<4;n++) {
      fOutputEvent->fQFW.counters[n] = *pdata++;
      if( 1 == fPar->uQFWHistosEnabled )
         fQFWcnt->SetBinContent(n+1, fOutputEvent->fQFW.counters[n]);
   }

   TString txt = "#splitline";

   for (int n=0;n<4;n++) {
      fOutputEvent->fQFW.errcnt[n] = *pdata++;
      if( 1 == fPar->uQFWHistosEnabled )
         fQFWerr->SetBinContent(n+1, fOutputEvent->fQFW.errcnt[n]);

      txt+=Form("{#scale[2.0]{#color[2]{Ch%d cnt:%10u err:%10u}}}", n, fOutputEvent->fQFW.counters[n], fOutputEvent->fQFW.errcnt[n]);
   }

   fOutputEvent->fQFW.setup = *pdata;

   txt+=Form("{#scale[2.0]{#color[2]{Setup: %d}}}", fOutputEvent->fQFW.setup);

   if( 1 == fPar->uQFWHistosEnabled )
      fQFWInfo->SetText(0.2, 0.5, txt.Data());

   fOutputEvent->SetValid(kTRUE);
}

void TMbsCrateProc::ProcessScalOrMu(uint32_t* pdata, unsigned int len)
{
   if( 16 == SCALORMU_NB_SCAL )
   {
      if (len != SCALORMU_NB_SCAL) {
         TGo4Log::Error("Wrong Scaler Or Multiplicity sub-event length: %u instead of %d",
               len, SCALORMU_NB_SCAL);
         return;
      }
      if( 1 == fPar->uDebug )
         TGo4Log::Info("Scaler Or Multiplicity sub-event found!");
      for( Int_t iScalerInd=0; iScalerInd < SCALORMU_NB_SCAL; iScalerInd++)
         fOutputEvent->fScalOrMu.uScaler[iScalerInd] = (UInt_t)*pdata++;
   }
      else
      {
         if (len != SCALORMU_NB_SCAL + 1) {
            TGo4Log::Error("Wrong Scaler Or Multiplicity sub-event length: %u instead of %d",
                  len, SCALORMU_NB_SCAL + 1);
            return;
         }
         if( 1 == fPar->uDebug )
            TGo4Log::Info("Scaler Or Multiplicity sub-event found!");
         for( Int_t iScalerInd=0; iScalerInd < SCALORMU_NB_SCAL; iScalerInd++)
            fOutputEvent->fScalOrMu.uScaler[iScalerInd] = (UInt_t)*pdata++;
         fOutputEvent->fScalOrMu.uReferenceClock = (UInt_t)*pdata++;
      }
}