beamtime/cosy-nov11/go4/TMbsCrateProc.cxx (r4864/r2600)

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"

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

#include "../mbs/cbmvme.h"

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;   

   // v1290 histograms

   for (int n=0;n<MAX_1290;n++)
   {
      fTDC[n].MakeHistos(this, Form("TDC%d",n));
      if( CAEN1290_DEBUG )
         fTDC[n].MakeDebugHistos(this, Form("TDC%d",n));
   }

   for (int n=0;n<MAX_965;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++)
      for (int ch=0;ch<MAX_FPGA_TDC_Channel;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++)
      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
   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);
      }
   }

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

TMbsCrateProc::~TMbsCrateProc()
{
}

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_CERN_Oct11) {
// comment this to test with previous beamtime lmds:
   if (subevt->GetProcid() == roc::proc_COSY_Nov11) {
      // MBS data from COSY beamtime, November 11
      // subevt->GetControl() == 9 from Master MBS, subevt->GetControl() == 10 from Slave MBS

      fOutputEvent->SetValid(kTRUE);

      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_QDC3;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_FPGA4;fpga++)
         if (tagpos[fpga] && taglen[fpga])
            ProcessFPGA_TDC(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
   }
}




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

   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);
        
        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::ProcessFPGA_TDC(int num, uint32_t* pdata, unsigned int len)
{
   if ((num<0) || (num>=MAX_FPGA_TDC)) {
      TGo4Log::Error("Error number %d for FPGA TDC", num);
      return;
   }

   uint32_t l_dat = *pdata++; // module header
   if ( (l_dat & 0xffff0000) != 0xabcd0000 ) {
      printf ("this is not a vulom header, exiting.. \n");
      return;
   }

   uint32_t l_nr_cha   = (l_dat & 0xff);

   if (l_nr_cha+2 != len) {
      printf ("wrong length in vulom header, exiting.. \n");
      return;
   }

   pdata++;  // vulom tdc fifo header

   while (l_nr_cha-- > 0) {

      uint32_t l_da0 = *pdata++;
      

      FPGA_TDC_hit hit;

      hit.ch_ix        = (l_da0 & 0x78000000) >> 27;  //  4 bit
      hit.coarse_ct    = (l_da0 & 0x3fff800)  >> 11;  // 15 bit
      hit.ch_tim       = (l_da0 & 0x7ff);             // 11 bit

      // old format
      // l_ch_ix        = (l_da0 & 0xfc000000) >> 26;
      // l_coarse_ct    = (l_da0 & 0x1fffc00)  >> 10;
      // l_ch_tim       = (l_da0 & 0x3ff);

      fOutputEvent->fFPGA[num].push_back(hit);

      if (hit.ch_ix<MAX_FPGA_TDC_Channel)
         fFPGA_Ch[num][hit.ch_ix]->Fill(hit.ch_tim);
         
         
    }

   fOutputEvent->SetValid(kTRUE);
}

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


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

   TString txt = "#splitline";

   for (int n=0;n<4;n++) {
      fOutputEvent->fQFW.errcnt[n] = *pdata++;
      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);

   fQFWInfo->SetText(0.2, 0.5, txt.Data());

   fOutputEvent->SetValid(kTRUE);
}