beamtime/cern-oct11/go4/TMbsCrateProc.cxx (r4864/r2543)

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"


#define L1182_DEBUG 0
#define L1183_DEBUG 0
#define MADC_DEBUG 0
#define V550_READ_PED 1


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

   fPar = (TMbsCrateParam*) MakeParameter("MbsCratePar", "TMbsCrateParam");

   TString setupmacro="set_MbsPar.C";
   if (!gSystem->AccessPathName(setupmacro.Data())) {
      cout << "**** Executing MBS parameter setup script " << setupmacro.Data() << endl;
      gROOT->ProcessLine(Form(".x %s", setupmacro.Data()));
   }

   TString obname, obtitle;   


   /*********** MADCs *************/
   for (int mad = 0; mad < MAX_MADC; mad++) {
      obname.Form("MADC%d/MADC%d_sample", mad,mad);
      obtitle.Form("Sample of MADC%d readout", mad);
      fMadc_trace[mad]=MakeTH1('I', obname.Data(), obtitle.Data(), N_MADC_CHA, 0, N_MADC_CHA,"channel No.");

      for (int ch = 0; ch < N_MADC_CHA; ch++) {
         obname.Form("MADC%d/MADC%d_ch%d", mad,mad,ch);
         obtitle.Form("MADC %d Channel %d", mad, ch);
         fMadc_adc[mad][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 0x3FF, 0, 0x3FF);

         //          obname.Form("MADC%d/MADC%d_ch%d_pion", mad,mad,ch);
         //          obtitle.Form("MADC %d Channel %d pion", mad, ch);
         //          fMadc_pion[mad][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 0x3FF, 0, 0x3FF);
         //
         //          obname.Form("MADC%d/MADC%d_ch%d_electron", mad,mad,ch);
         //          obtitle.Form("MADC %d Channel %d electron", mad, ch);
         //          fMadc_electron[mad][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 0x3FF, 0, 0x3FF);

      }

      obname.Form("MADC%d_overview", mad);
      pMadc_overview[mad] = GetPicture(obname.Data());
      if (pMadc_overview[mad] == 0) {
         obtitle.Form("Channels overview MADC %2d", mad);
         pMadc_overview[mad] = new TGo4Picture(obname.Data(), obtitle.Data());
         pMadc_overview[mad]->SetDivision(8, 4);
         for(int y=0; y<8;++y)
            for(int x=0;x<4;++x) {
               pMadc_overview[mad]->Pic(y, x)->AddObject(fMadc_adc[mad][4*y+x]);
               pMadc_overview[mad]->Pic(y, x)->SetFillAtt(5, 3001);
               pMadc_overview[mad]->Pic(y, x)->SetRangeX(0, 200);
               pMadc_overview[mad]->Pic(y, x)->SetLogScale(1, 1);
            }
         AddPicture(pMadc_overview[mad]);
      }

      //       obname.Form("MADC%d_pion", mad);
      //       if (GetPicture(obname.Data()) == 0) {
      //          obtitle.Form("Pion channels overview MADC %2d", mad);
      //          TGo4Picture* pic = new TGo4Picture(obname.Data(), obtitle.Data());
      //          pic->SetDivision(8, 4);
      //          for(int y=0; y<8;++y)
      //             for(int x=0;x<4;++x) {
      //                pic->Pic(y, x)->AddObject(fMadc_pion[mad][4*y+x]);
      //                pic->Pic(y, x)->SetFillAtt(5, 3001);
      //                pic->Pic(y, x)->SetRangeX(0, 200);
      //                pic->Pic(y, x)->SetLogScale(1, 1);
      //             }
      //          AddPicture(pic);
      //       }
      //
      //
      //       obname.Form("MADC%d_electron", mad);
      //       if (GetPicture(obname.Data()) == 0) {
      //          obtitle.Form("Electron channels overview MADC %2d", mad);
      //          TGo4Picture* pic = new TGo4Picture(obname.Data(), obtitle.Data());
      //          pic->SetDivision(8, 4);
      //          for(int y=0; y<8;++y)
      //             for(int x=0;x<4;++x) {
      //                pic->Pic(y, x)->AddObject(fMadc_electron[mad][4*y+x]);
      //                pic->Pic(y, x)->SetFillAtt(5, 3001);
      //                pic->Pic(y, x)->SetRangeX(0, 200);
      //                pic->Pic(y, x)->SetLogScale(1, 1);
      //             }
      //          AddPicture(pic);
      //       }

   }


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

   // 1182 histo

   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.);
      }

   for (int n=0;n<MAX_1182;n++)
      for (int ch=0;ch<NUM_1182_CH;ch++) {
         obname.Form("118%d/118%d_pulser_channel%d", n+2, n+2, ch);
         obtitle.Form("118%d Channel %d under pulser", n+2, ch);
         f1182Pulserh[n][ch] = MakeTH1('I', obname.Data(), obtitle.Data(), 1024, 0, 4096.);
      }

   /* some histograms for v550 data:*/

   obname.Form("v550/Fifo0_Trace");
   obtitle.Form("v550 Fifo 0 channels trace");
   f550h_fifo0_trace= MakeTH1('I', obname.Data(), obtitle.Data(),
         NUM_V550_CH, 0, NUM_V550_CH,"channel number");
   obname.Form("v550/Fifo0_Acc");
   obtitle.Form("v550 Fifo 0 channels accumulated");
   f550h_fifo0_acc=MakeTH1('I', obname.Data(), obtitle.Data(),
         NUM_V550_CH, 0, NUM_V550_CH,"channel number");
   obname.Form("v550/Fifo1_Trace");
   obtitle.Form("v550 Fifo 1 channels trace");
   f550h_fifo1_trace=MakeTH1('I', obname.Data(), obtitle.Data(),
         NUM_V550_CH, 0, NUM_V550_CH,"channel number");
   obname.Form("v550/Fifo1_Acc");
   obtitle.Form("v550 Fifo 1 channels accumulated");

   f550h_fifo1_acc= MakeTH1('I', obname.Data(), obtitle.Data(),
         NUM_V550_CH, 0, NUM_V550_CH,"channel number");

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


//   obname.Form("MADC/SiStrip/Pedestal_Trace");
//   obtitle.Form("SiStrip pedestals trace");
//   fMadc_si_ped_trace= MakeTH1('I', obname.Data(), obtitle.Data(),
//                  N_SISTRIP_CHA, 0, N_SISTRIP_CHA,"channel number");
//   obname.Form("MADC/SiStrip/Pedestal_Acc");
//   obtitle.Form("SiStrip pedestals accumulated");
//   fMadc_si_ped_acc=MakeTH1('I', obname.Data(), obtitle.Data(),
//                  N_SISTRIP_CHA, 0, N_SISTRIP_CHA,"channel number");


}

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)
{
   if (fPar->fBucharestSetup) {

      if ((subevt->GetProcid() != 1) || (subevt->GetControl() != 9)) {
         cerr << " Unknown subevent tags for Bucharest setup proc = " << subevt->GetProcid() << " control = " << subevt->GetControl() << endl;
         return;
      }

      if (GetTriggerNumber()>13) {
         cout << "Skip trigger number " << GetTriggerNumber() << endl;
         return;
      }

      //cout << "Process Bucharest event " << GetEventNumber() << "   trigger = " << GetTriggerNumber() << endl;

      const int numtags = 3;
      Int_t tags[numtags] = { 0x4d544443,   // TDC
            0x4d414443,   // MADC
            0x56353630 }; // V560

      Int_t minlen[numtags] = { 1, 1, 16 };

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

      Int_t ntdc(0), nmadc(0), indx(0);

      while (indx < (Int_t) lwords) {
         int tagid = -1;
         for (int n=0;n<numtags;n++)
            if (tags[n] == pdata[indx]) tagid = n;
         if (tagid<0) {
            cerr << "Cannot recognize tag id in MBS event from Bucharest" << endl;
            return;
         }

         // skip tag identifier
         indx++;

         Int_t nextindx = indx + minlen[tagid];

         while (nextindx < (Int_t) lwords) {
            bool foundnexttag = false;

            for (int n=0;n<numtags;n++)
               if (tags[n] == pdata[nextindx]) foundnexttag = true;

            if (foundnexttag) break;

            nextindx++;
         }

//         cout << "   Found TAG = " << tagid << " len = " << nextindx - indx << " x4 bytes" << endl;

         switch (tagid) {
            case 0: // TDC
               Process1290(-1, pdata + indx, nextindx - indx);
               ntdc++;
               break;

            case 1: // MADC
               ProcessMADC(nmadc++, pdata + indx, nextindx - indx);
               break;

            case 2: // V560
               Processv560(pdata + indx, nextindx - indx);
               break;
         }

         indx = nextindx;
      }

      fOutputEvent->SetValid(kTRUE);

      return;
   }

 // use this to test with old beamtime data JAM:
 //  if (subevt->GetProcid() == roc::proc_TRD_MADC) {

   if (subevt->GetProcid() == roc::proc_CERN_Oct11) {
      // MBS data from CERN beamtime, October 11
      // subevt->GetControl() == 9 from Master MBS, subevt->GetControl() == 10 from Slave MBS

      fOutputEvent->fIsPulser = (GetTriggerNumber()==8);

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

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

      const int numtags = 12;

      const uint64_t tags[numtags] = { 
            0x3238313131313832ULL,  // 1182
            0x3338313131313833ULL,  // 1183
            0x3164616d6d616431ULL,  // mad1
            0x3264616d6d616432ULL,  // mad2
            0x3364616d6d616433ULL,  // mad3
            0x3464616d6d616434ULL,  // mad4
            0x3163647474646331ULL,  // tdc1
            0x3263647474646332ULL,  // tdc2
            0x3363647474646333ULL,  // tdc3
            0x3463647474646334ULL,  // tdc4
            0x3036357676353630ULL,  // v560
            0x3035357676353530ULL,  // v550
      };
      Int_t* tagpos[numtags];
      Int_t taglen[numtags];

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

      int lasttag = -1;

      //   Int_t* p0 = pdata;

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

         //      printf("DATA 0x%x\n", *pdata);

         bool find = false;

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

               if (tagpos[ntag]==0) {
                  //               printf("TAG %d  pos %u\n", ntag, pdata - p0);

                  pdata+=2; cur+=1;
                  tagpos[ntag] = pdata;
                  lasttag = ntag;
               } else {
                  printf("FORMAT ERROR found tag %lld twice\n", 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]);



      // SL: in previous version trigger 8 was excluded at all
      //if (GetTriggerNumber()==8) {
      //   fOutputEvent->SetValid(kFALSE);
      //   return;
      //}

      // actually process data in subroutines:

      if (tagpos[0] && taglen[0])   Process1182(0, tagpos[0], taglen[0]);  // 1182
      if (tagpos[1] && taglen[1])   Process1182(1, tagpos[1], taglen[1]);  // 1183
      if (tagpos[2] && taglen[2])   ProcessMADC(0, tagpos[2], taglen[2]);  // mad1
      if (tagpos[3] && taglen[3])   ProcessMADC(1, tagpos[3], taglen[3]);  // mad2
      if (tagpos[4] && taglen[4])   ProcessMADC(2, tagpos[4], taglen[4]);  // mad3
      if (tagpos[5] && taglen[5])   ProcessMADC(3, tagpos[5], taglen[5]);  // mad4
      if (tagpos[6] && taglen[6])   Process1290(0, tagpos[6], taglen[6]);  // tdc1
      if (tagpos[7] && taglen[7])   Process1290(1, tagpos[7], taglen[7]);  // tdc2
      if (tagpos[8] && taglen[8])   Process1290(2, tagpos[8], taglen[8]);  // tdc3
      if (tagpos[9] && taglen[9])   Process1290(3, tagpos[9], taglen[9]);  // tdc4
      if (tagpos[10] && taglen[10]) Processv560(  tagpos[10], taglen[10]); // v560
      if (tagpos[11] && taglen[11]) Processv550(  tagpos[11], taglen[11]); // v550

      fOutputEvent->SetValid(kTRUE);

      return;
   }
}




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++;
      fOutputEvent->fData1182[num][ch] = val; // output event to root tree
   }

   // do not fill histograms if pulser event - used for later analysis
   if (fOutputEvent->IsPulser())
      for(int ch=0;ch<NUM_1182_CH;++ch)
         f1182Pulserh[num][ch]->Fill(fOutputEvent->fData1182[num][ch]);
   else
      for(int ch=0;ch<NUM_1182_CH;++ch)
         f1182h[num][ch]->Fill(fOutputEvent->fData1182[num][ch]);
}

void TMbsCrateProc::ProcessMADC(int i, int* pdata, int len) 
{
   //      printf("MADC %d len %d  \n", i, len);

   if(i>=MAX_MADC) return;
   if(len<2) return;

   fMadc_trace[i]->Reset("");

   int* cursor = pdata;
   // skip event header:
   unsigned int header=*cursor;
   if ((header & 0xff000000) >> 24 != 0x40)
      printf("madc(%d) header error: 0x%08x, expected 0x40nnnnnn \n",i,header);
   cursor++;
   for(int cnt=0;cnt<len-2;cnt++) {
      unsigned int val=*cursor++;

      if ((val & 0xff000000) != 0x4000000)
         printf("madc(%d) seq %u value 0x%08x error, expected 0x04nnnnnn\n", i,cnt, val);

      unsigned chanid= (val >> 16) & 0x1f;
      unsigned adc = val & 0x1fff;

      fMadc_trace[i]->Fill(chanid, adc);
      if (!fOutputEvent->IsPulser())
         fMadc_adc[i][chanid]->Fill(adc);
      fOutputEvent->fMadc[i][chanid] = adc; // to output event, store to root tree
   }
   int trailer=*cursor;
   if ((trailer & 0xf0000000) >> 24 != 0xc0)
      printf("madc(%d) trailer error: 0x%08x, expected 0xcnnnnnnnn \n",i, trailer);

   //   printf("madc(%d) trailer: 0x%08x \n",i,trailer);
   //#endif
}

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 14: num = 0; break;
         case 15: num = 1; break;
         case 13: num = 2; break;
         case 12: num = 3; 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 = 14; break;
         case 1: expected_geo = 15; break;
         case 2: expected_geo = 13; break;
         case 3: expected_geo = 12; break;
      }
   }

   // printf("Process1290 num = %d expected GEO = %d len = %u\n", num, expected_geo, len);

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

   if (!fOutputEvent->IsPulser())
      fTDC[num].FillHistos(fOutputEvent->fMtdc[num]);
}

void TMbsCrateProc::Processv560(int* pdata, unsigned int len)
{
   if (len!=NUM_V560_CH) {
      cout << "wrong number = " << len << " of longwords in v560 data" << endl;
      return;
   }

   for (int ch=0;ch<NUM_V560_CH;ch++)
      fOutputEvent->f560Scaler[ch] = pdata[ch];
}

void TMbsCrateProc::Processv550(int* pdata, unsigned int len)
{
   UInt_t status=*pdata++;
   printf("v550 status:0x%0x \n",status);
   UInt_t bothcount = *pdata++;
   UShort_t wcount0 = (bothcount >> 16);
   UShort_t wcount1 = (bothcount & 0xFFFF);
   printf("v550 wc0:0x%0x wc1:0x%0x\n",wcount0, wcount1);
   if((int) len < wcount0 + wcount1 + 4)
   {
      cout << "TMbsCrateProc::Processv550 data length" << len
            << "not sufficient!" << endl;
      return;
   }

   f550h_fifo0_trace->Reset("");
   for (UShort_t i=0;i<wcount0;i++)
   {
      UInt_t val=*pdata++;
      UInt_t ch=(val >> 12) & 0x7FF;
      UInt_t adc=val & 0xFFF;
      printf("si strip FIFO 0: %d has id 0x%0x, adc:0x%0x \n",i,ch,adc);
      if(ch >= NUM_V550_CH)
      {
         cout << "TMbsCrateProc::Processv550 fifo0 - channel " << ch
               << "out of range - max=" <<NUM_V550_CH << endl;
         continue;
      }
      fOutputEvent->f550Data0[ch]=adc;
      f550h_fifo0_trace->AddBinContent(ch + 1, (Double_t) adc);
      f550h_fifo0_acc->AddBinContent(ch + 1, (Double_t) adc);

   }
   f550h_fifo1_trace->Reset("");
   for (UShort_t i=0;i<wcount1;i++)
   {
      UInt_t val=*pdata++;
      UInt_t ch=(val >> 12) & 0x7FF;
      UInt_t adc=val & 0xFFF;
      printf("si strip FIFO 1: %d has id 0x%0x, adc:0x%0x \n",i,ch,adc);
      if(ch >= NUM_V550_CH)
      {
         cout << "TMbsCrateProc::Processv550 fifo1 - channel " << ch
               << "out of range - max=" <<NUM_V550_CH << endl;
         continue;
      }
      fOutputEvent->f550Data1[ch]=adc;

      if (!fOutputEvent->IsPulser()) {
         f550h_fifo1_trace->AddBinContent(ch + 1, (Double_t) adc);
         f550h_fifo1_acc->AddBinContent(ch + 1, (Double_t) adc);
      }
   }
}