onlinemonitor/framework/TTriglogProc.cxx (r4864/r3724)

Go to the documentation of this file.

#include "TTriglogProc.h"

#include <stdio.h>

#include "TTimeStamp.h"
#include "TH1.h"
#include "TLatex.h"

#include "TGo4Log.h"

#include "TCBMBeamtimeEvent.h"

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


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

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

   fSpillRate = MakeTH1('I', "Triglog/SpillRate", "Number of triggers per second", 1000, 0, 1000, "sec");
   fLastSync = 0;

   fVulomSyncs = MakeTH1('I', "Triglog/Syncs", "Number of sync messages from VULOM", 65536, 0, 65536.);

   for (int n=0;n<NUM_SCALERS;n++)
      fVulomScalers[n] = MakeTH1('I', Form("Triglog/Scaler%d", n), "Distribution of scaler signals", N_SCALERS_CH, 0, N_SCALERS_CH);

   for (int n=0;n<NUM_SCALERS;n++)
      for (int j=0;j<N_SCALERS_CH;j++)
        fRate[n][j] = MakeTH1('I', Form("Triglog/ScalerRate%dCh%d", n, j), Form("VULOM Scaler rate on column %d channel %d", n, j), 500, 0, 20000, "Hz");
   fPrevMbsTime = 0;

   fVulomInfo = new TLatex(0.5,0.5,"-- demo text --");
   fVulomInfo->SetName("TriglogInfo");
   fVulomInfo->SetNDC();
   AddObject(fVulomInfo); // will replace old one of same name

   fFirstMbsTime = 0;
   fLastMbsTime = 0;
   fTotalTriggerCount = 0;

   for (int nch=0;nch<N_SCALERS_CH;nch++)
      fChannelNames[nch].Form("Ch%02d", nch);

   if (channel_names!=0) {
      TObjArray* tokens = TString(channel_names).Tokenize(":");

      if (tokens!=0)
         for (int n=0;n<=tokens->GetLast();n++)
            if (strlen(tokens->At(n)->GetName())>0)
               fChannelNames[n] = tokens->At(n)->GetName();

      delete tokens;
   }
}

TTriglogProc::~TTriglogProc()
{
   double runtime = fLastMbsTime - fFirstMbsTime;
   printf ("Total MBS run time %6.0f sec \n", runtime);

   if (runtime>0) {
       printf ("-------- Total number of triggers %d --------\n", fTotalTriggerCount);

       for (int j=0;j<N_SCALERS_CH;j++) {
          printf ("  %7s", fChannelNames[j].Data());
          for (int n=0;n<NUM_SCALERS;n++)
             printf("   %8u", fLastScaler[n][j] - fFirstScaler[n][j]);
          printf("\n");
      }

       printf ("------- Trigger rate %8.3f Hz ---------\n", fTotalTriggerCount/runtime);

       for (int j=0;j<N_SCALERS_CH;j++) {
          printf ("  %7s", fChannelNames[j].Data());
          for (int n=0;n<NUM_SCALERS;n++)
          printf("   %8.3f", (fLastScaler[n][j] - fFirstScaler[n][j])/runtime);
          printf("\n");
      }
  }
}

void TTriglogProc::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<TTriglogEvent*>(btevent->GetSubEvent("TRIGLOG"));
   }
   else
   {
      fOutputEvent = dynamic_cast<TTriglogEvent*>(outevnt);
   }
   if(fOutputEvent==0) {
      GO4_STOP_ANALYSIS_MESSAGE("**** TTriglogProc: Fatal error: output event is not a TTriglogEvent!!! STOP GO4");
   }
}

void TTriglogProc::ProcessSubevent(TGo4MbsSubEvent* subevt)
{
#if __GO4BUILDVERSION__ > 40500
   Bool_t oldevent=IsKeepInputEvent();
   SetKeepInputEvent(kFALSE); // need this to reset our flag in case rocproc had requested it.
   if(oldevent) return; // ignore this subevent if we already had it
#endif

   if ((subevt->GetProcid() == roc::proc_Triglog) && fOutputEvent) {

      int indx = 0;

      Int_t sync_num = subevt->Data(indx++);

      // cout << " ===================== TRIGLOG EVENT ================= " << sync_num % 0x1000000 <<  endl;

      // just to see that sync number is changing
      fVulomSyncs->Fill(sync_num % 65536);
      fOutputEvent->SetValid(kTRUE);

      fOutputEvent->fVulomSyncNumber = sync_num;

      fOutputEvent->fVulomTriggerPattern = (UInt_t) subevt->Data(indx++);

      fOutputEvent->fMbsTimeSecs = (UInt_t) subevt->Data(indx++);
      fOutputEvent->fMbsTimeMillisec = (UInt_t) subevt->Data(indx++);

      if ((fLastSync!=0) && (sync_num > fLastSync))
         fSpillRate->Fill(fOutputEvent->fMbsTimeSecs % 1000,  sync_num-fLastSync);
      fLastSync = sync_num;


      TTimeStamp mbs_time(fOutputEvent->fMbsTimeSecs, fOutputEvent->fMbsTimeMillisec*1000000);

      TString txt;
      txt.Form("#splitline{#scale[3.0]{#color[2]{Sync number:%d}}}{#scale[2.0]{#color[4]{MBS time:%s}}}",
            sync_num, mbs_time.AsString("s"));
      fVulomInfo->SetText(0.2, 0.5, txt.Data());

      for (int nscaler = 0; nscaler < NUM_SCALERS; nscaler++) {
         // SL 20.10.11 MBS readout was changed and two more scalers were included
         // to be able process old files, add this break condition;

         for (int n = 0; n<N_SCALERS_CH; n++) {
              // SL: put protection against different length of this subevent
              // also trigger-pattern was not correctly counted
            Int_t val = indx < subevt->GetIntLen() ? subevt->Data(indx++) : 0;
            //fVulomScalers[nscaler]->Fill(n,val);
            fVulomScalers[nscaler]->SetBinContent(n+1,val); // scalers accumulate themselves, just show current value
            fOutputEvent->fVulomScaler[nscaler][n] = val;
        }
      }

      fTotalTriggerCount++;

      fLastMbsTime = fOutputEvent->fMbsTimeSecs;

      for (int n=0;n<NUM_SCALERS;n++)
         for (int j=0;j<N_SCALERS_CH;j++) {
            fLastScaler[n][j] = fOutputEvent->fVulomScaler[n][j];
            if (fFirstMbsTime==0) fFirstScaler[n][j] = fLastScaler[n][j];
         }

      if (fFirstMbsTime==0) fFirstMbsTime = fLastMbsTime;

      double tm = fOutputEvent->fMbsTimeSecs + fOutputEvent->fMbsTimeMillisec*1e-3;

      // printf ("MBS time = %10.5f   %d  %d \n", tm, fCrateInputEvent->fMbsTimeSecs, fCrateInputEvent->fMbsTimeMillis);

      if ((fPrevMbsTime==0) || (tm > fPrevMbsTime + 0.1)) {

         double diff = 0;
         if ((fPrevMbsTime>0) && (tm < fPrevMbsTime + 0.15)) diff = tm - fPrevMbsTime;

         for (int n=0;n<NUM_SCALERS;n++)
            for (int j=0;j<N_SCALERS_CH;j++) {
               if (diff>0) {
                  fScalerRate[n][j] = (fOutputEvent->fVulomScaler[n][j] - fPrevScaler[n][j])/diff;
                  fRate[n][j]->Fill(fScalerRate[n][j]);
               }

               fPrevScaler[n][j] = fOutputEvent->fVulomScaler[n][j];
            }

         fPrevMbsTime = tm;
      }
   }
}