beamtime/cern-oct12/go4/TMbsCrateProc.cxx (r4864/r3723)

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

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

const uint32_t vme_setup[MAX__N_MOD*6] = VME__MODULES;

uint64_t vme_tags[MAX__N_MOD];


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

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

   ExecuteScript("set_MbsPar.C");

   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],"BucharestMADC");
      }

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

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


//   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)
{
 // use this to test with old beamtime data JAM:
 //  if (subevt->GetProcid() == roc::proc_TRD_MADC) {

   if (subevt->GetProcid() == roc::proc_CERN_Oct12) {
      // 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);

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



      // SL: in previous version trigger 8 was excluded at all
      //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_TDC7;tdc++)
         if (tagpos[tdc] && taglen[tdc])
            Process1290(tdc-VME__ID_TDC1, tagpos[tdc], taglen[tdc]);  // all TDCs

      for (int madc=VME__ID_MAD1;madc<=VME__ID_MAD4;madc++)
         if (tagpos[madc] && taglen[madc])
            ProcessMADC(madc-VME__ID_MAD1, tagpos[madc], taglen[madc]);  // all MADCs

      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) {
      printf ("Wrong V1290 module index %d\n",num);
      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;
      }

      num = expected_geo - 9;

      if ((num<0) || (num >= MAX_1290)) {
         printf("Wrong GEO value %d found\n", expected_geo);
         return;
      }

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

   } else {
      expected_geo = num + 9;
   }

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