onlinemonitor/epicsmonitor/TEpicsProc.cxx (r4864/r4366)

Go to the documentation of this file.

#include "TEpicsProc.h"

#include "TTimeStamp.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TDatime.h"
#include "TCanvas.h"

#include "TGo4Log.h"

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

#define CBM_EPIX_SUBID roc::proc_EPICS

// note: this id was used in cosy December 2010 beamtime.
//#define CBM_EPIX_SUBID 0x08

TEpicsProc::TEpicsProc() :
   TCBMBeamtimeProc(),
   fPar(0),
   fOutputEvent(0)
{
}

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

   fPar = (TEpicsParam*) MakeParameter("EPICSPar", "TEpicsParam", "set_EPICSPar.C");

   for(int nl=0; nl<CBM_EPIX_NUMHIS_LONG; ++nl)
       CreateHist(fPar->LongName(nl));

   for(int dl=0; dl<CBM_EPIX_NUMHIS_DOUBLE; ++dl)
       CreateHist(fPar->DoubleName(dl));

   // picture not yet supports time display for tgraph axis.
   //   if (GetPicture("EPICS/TimeGraphsLong")==0) {
   //      TGo4Picture* pic = new TGo4Picture("TimeGraphsLong", "EPICS long pv time graphs");
   //      int numy = 4;
   //      int numx = (CBM_EPIX_NUMHIS_LONG-1) / numy;
   //      if (numx*numy < (CBM_EPIX_NUMHIS_LONG - 1)) numx++;
   //      pic->SetDivision(numy, numx);
   //
   //      for (UInt_t sid = 1; sid < CBM_EPIX_NUMHIS_LONG; sid++) {
   //        int nx = (sid-1) / numy;
   //        int ny = (sid-1) % numy;
   //        pic->Pic(ny, nx)->AddGraph(fGraphLong[sid]);
   //      }
   //      AddPicture(pic,"EPICS");
   //    }
   //
   //   if (GetPicture("EPICS/TimeGraphsDouble")==0) {
   //         TGo4Picture* pic = new TGo4Picture("TimeGraphsDouble", "EPICS double pv time graphs");
   //         int numy = 4;
   //         int numx = (CBM_EPIX_NUMHIS_DOUBLE) / numy;
   //         if (numx*numy < (CBM_EPIX_NUMHIS_DOUBLE)) numx++;
   //         pic->SetDivision(numy, numx);
   //
   //         for (UInt_t sid = 0; sid < CBM_EPIX_NUMHIS_DOUBLE; sid++) {
   //           int nx = (sid) / numy;
   //           int ny = (sid) % numy;
   //           pic->Pic(ny, nx)->AddGraph(fGraphDouble[sid]);
   //
   //         }
   //         AddPicture(pic,"EPICS");
   //       }
}

TEpicsProc::~TEpicsProc()
{
}

TEpicsProc::VariableHist* TEpicsProc::CreateHist(const char* varname)
{
   if ((varname==0) || (strlen(varname)==0)) return 0;

   const char* dirname = "EPICS";
   Double_t range = CBM_EPIX_STATRANGE;
   Int_t bins = 2*CBM_EPIX_STATRANGE;

   TString obname;
   TString obtitle;

   VariableHist dummy;
   all_hists.push_back(dummy);

   obname.Form("%s/Statistics/Stat_%s", dirname, varname);
   obtitle.Form("EPICS variable %s statistics", varname);
   all_hists.back().fStat = MakeTH1('I', obname.Data(), obtitle.Data(), bins, -range, range);
   obname.Form("%s/Trending/Trend_%s",dirname, varname);
   obtitle.Form("EPICS variable %s trending", varname);
   all_hists.back().fTrend = MakeTH1('I', obname.Data(), obtitle.Data(), CBM_EPIX_TRENDSIZE, 0, CBM_EPIX_TRENDSIZE);

   all_hists.back().fGraph = MakeTimeGraph(varname, dirname);

   return & all_hists.back();
}


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


void TEpicsProc::ProcessSubevent(TGo4MbsSubEvent* psubevt)
{
#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 (psubevt->GetProcid() != CBM_EPIX_SUBID) return;

   fOutputEvent->ResetData(); // Clear() will not erase old values, do this now
   Int_t* pdata = psubevt->GetDataField();
   Int_t* theEnd = psubevt->GetDataField() + psubevt->GetIntLen();
   //first payload: event id number
   fOutputEvent->fEventId = *pdata++;
   if (fPar->fVerbose)
      printf("Found EPICS event id %u\n", fOutputEvent->fEventId);

   // secondly get dabc record time expression
   fOutputEvent->fUTimeSeconds = (UInt_t) *pdata++;
   if (fPar->fVerbose)
      printf("Found EPICS timestring: %s\n", fOutputEvent->GetUpdateTimeString());

   //int numlong = *pdata++;

   Long64_t* plong = (Long64_t*) pdata;

   int numlong= *plong++;
   if (fPar->fVerbose)
      printf("Num long: %d\n", numlong);
   //plong= (Long64_t*) pdata;
   for (int i = 0; i < numlong; ++i) {
      Long64_t val = *plong++;
      if (fPar->fVerbose)
         printf("   Long[%d] = %lld\n", i, val);
      fOutputEvent->fLongRecords.push_back(val);
   }

   // get header with number of double records
   //int numdub = *pdata++;
   int numdub = *plong++;
   if (fPar->fVerbose)
      printf("Num double: %d\n", numdub);
   //plong= (Long64_t*) pdata;
   Double_t* pdouble= (Double_t*) (plong);
   for (int i = 0; i < numdub; ++i) {
#ifdef CBM_EPIX_useDOUBLES
      Double_t val = *pdouble++;
      Long64_t valint = val;
      plong++;
      // cout << "double("<<i<<")=" << val << endl;
#else
      Long64_t valint = *plong++;
      Double_t val = (Double_t) (valint) / CBM_EPIX_DOUBLESCALE; // workaround to avoid number format tricks
#endif

      if (fPar->fVerbose)
         printf("   Double[%d] = int:%lld float:%f\n", i, valint, val);

      fOutputEvent->fDoubleRecords.push_back(val);
   }
   pdata = (Int_t*) plong;
   // process optional additional variable names and update names map
   if(pdata<theEnd) {
      unsigned rest = (char*)theEnd - (char*)pdata;
      if (fPar->fVerbose)
         printf("Found description at mbs event end, pdata:0x%p end: 0x%p, rest=0x%x\n",
               pdata, theEnd, rest);

      fOutputEvent->UpdateRecordNames((const char*) pdata, rest);
   }

  if (!fOutputEvent->CheckConsistent(true)) {
          fOutputEvent->SetValid(kFALSE);
  } else {
    fOutputEvent->SetValid(kTRUE); // mark as newly updated
  }
}

TEpicsProc::VariableHist* TEpicsProc::FindVariable(const char* name)
{
   if ((name==0) || (strlen(name)==0)) return 0;
   for (unsigned n=0;n<all_hists.size();n++)
          if (all_hists[n].IsName(name)) return & all_hists[n];

   return 0;
}


void TEpicsProc::FinalizeEvent()
{
   // skip not updated events
   if (!fOutputEvent->IsValid()) return;

   if(fPar->fVerbose)
      fOutputEvent->PrintEvent();

   if (fPar->fAutoFill) {

      // automatically extend parameter with variables from output event

      for (unsigned n=0;n<fOutputEvent->GetNumLongs();n++) {

         const char* varname = fOutputEvent->GetLongName(n).c_str();
         VariableHist* hist = FindVariable(varname);
         if (hist==0) hist = CreateHist(varname);

         UpdateHist(hist, fOutputEvent->GetLong(n), varname);
      }

      for (unsigned n=0;n<fOutputEvent->GetNumDoubles();n++) {

         const char* varname = fOutputEvent->GetDoubleName(n).c_str();

         VariableHist* hist = FindVariable(varname);
         if (hist==0) hist = CreateHist(varname);

         UpdateHist(hist, fOutputEvent->GetDouble(n), varname);
      }

   } else {

      for (int nl = 0; nl < CBM_EPIX_NUMHIS_LONG; ++nl) {
         const char* varname = fPar->LongName(nl);
         VariableHist* hist = FindVariable(varname);
         if (hist)
            UpdateHist(hist, fOutputEvent->GetLong(varname), varname);
      }

      for (int dl = 0; dl < CBM_EPIX_NUMHIS_DOUBLE; ++dl) {
         const char* varname = fPar->DoubleName(dl);
         VariableHist* hist = FindVariable(varname);
         if (varname)
            UpdateHist(hist, fOutputEvent->GetDouble(varname), varname);
      }
   }
}


void TEpicsProc::UpdateTrending(TH1* histo, Double_t val, time_t time)
{
   // first test: just use simple binwise trending
   IncTrending( histo, val, kTRUE);
}


void  TEpicsProc::IncTrending( TH1 * histo, Double_t value, bool forwards )
{
   if(histo==0) return;
   int bins = histo->GetNbinsX();
   //bool forwards=true;
   int j = forwards ? bins : 0;
   int dj = forwards ? -1 : +1;
   for(int i=0;i<bins;i++) {
      j = forwards ? bins-i : i;
      Double_t oldval = histo->GetBinContent(j+dj);
      histo->SetBinContent(j,oldval);
   }
   histo->SetBinContent(j+dj,value);
}

TGraph* TEpicsProc::MakeTimeGraph(const TString& name, const TString& dir)
{
   TString fullname=dir+"/"+name;
   //cout <<"fullname "<<fullname << endl;
   TGraph* gr=dynamic_cast<TGraph*>(GetObject(fullname));
   if(gr==0) {
      gr=new TGraph();
      gr->SetName(name);
      gr->SetMarkerStyle(33);
      TCanvas* c1 = new TCanvas("c1","c1",3);
      gr->Draw("A");// dummy create axis:
      delete c1;
      gr->GetXaxis()->SetTimeDisplay(1);
      gr->GetXaxis()->SetNdivisions(-503);
      gr->GetXaxis()->SetTimeFormat("%H:%M:%S");
      gr->GetXaxis()->SetTimeOffset(0,"gmt");
      AddObject(gr,dir.Data());
   }
   gr->GetXaxis()->SetTimeOffset(0,"gmt");
   return gr;
}


void TEpicsProc::UpdateTimeGraph(TGraph* gr, Double_t value, time_t time)
{
   TDatime offs(1995,1,1,0,0,0); // substract begin of root time  from unix epoch
   TDatime dt(time, kFALSE);
   Int_t npoints = gr->GetN();
   gr->SetPoint(npoints,(dt.Convert() - offs.Convert()),value);
}

void TEpicsProc::UpdateHist(VariableHist* hst, double val, const char* varname)
{
   if ((varname==0) || (hst==0)) return;

   hst->fStat->Fill(val);
   hst->fStat->SetTitle(Form("Statistics of %s at %s", varname, fOutputEvent->GetUpdateTimeString()));
   UpdateTrending(hst->fTrend, val ,fOutputEvent->GetUpdateTimeSeconds());
   hst->fTrend->SetTitle(Form("Trending of %s at %s", varname, fOutputEvent->GetUpdateTimeString()));
   UpdateTimeGraph(hst->fGraph, val, fOutputEvent->GetUpdateTimeSeconds());
   hst->fGraph->SetTitle(Form("Timegraph of %s", varname));
}