manalyzer_example_frontend.cxx

Go to the documentation of this file.

//
// MIDAS analyzer example: MIDAS frontend for sending analyzed data back into MIDAS
//
// K.Olchanski
//
 
#undef NDEBUG // midas required assert() to be always enabled
 
#include <stdio.h>
#include <cassert>
 
#include "manalyzer.h"
#include "midasio.h"
 
class TMEventFlow : public TAFlowEvent
{
public:
   TMEvent fEvent;
 
   TMEventFlow(TAFlowEvent* flow, const TMEvent& event)
      : TAFlowEvent(flow)
   {
      fEvent = event;
   }
};
 
/*******************************************************************\
 
  Name:         tmfe_example_everything.cxx
  Created by:   K.Olchanski
 
  Contents:     Example Front end to demonstrate all functions of TMFE class
 
\********************************************************************/
 
 
#include <stdio.h>
#include "tmfe.h"
 
class EqAnalyzer :
   public TMFeEquipment
{
public:
   EqAnalyzer(const char* eqname, const char* eqfilename) // ctor
      : TMFeEquipment(eqname, eqfilename)
   {
      printf("EqAnalyzer::ctor!\n");
 
      // configure the equipment here:
      
      fEqConfReadConfigFromOdb = false;
      fEqConfEventID = 100;
      fEqConfPeriodMilliSec = 0;
      //fEqConfWriteEventsToOdb = true;
      fEqConfBuffer = "ANAA";
   }
 
   ~EqAnalyzer() // dtor
   {
      printf("EqAnalyzer::dtor!\n");
   }
 
   void HandleUsage()
   {
      printf("EqAnalyzer::HandleUsage!\n");
   }
 
   TMFeResult HandleInit(const std::vector<std::string>& args)
   {
      printf("EqAnalyzer::HandleInit!\n");
      fEqConfReadOnlyWhenRunning = false; // overwrite ODB Common RO_RUNNING to false
      //fEqConfWriteEventsToOdb = true; // overwrite ODB Common RO_ODB to true
      //EqSetStatus("Started...", "white");
      return TMFeOk();
   }
};
 
// example frontend
 
class FeAnalyzer: public TMFrontend
{
public:
};
 
/* emacs
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 3
 * indent-tabs-mode: nil
 * End:
 */
 
class ExampleFrontend: public TARunObject
{
public:
   EqAnalyzer* fEq = NULL;
 
public:
   ExampleFrontend(TARunInfo* runinfo, EqAnalyzer* eq)
      : TARunObject(runinfo)
   {
      printf("ExampleFrontend::ctor, run %d, file %s\n", runinfo->fRunNo, runinfo->fFileName.c_str());
      fModuleName = "ExampleFrontend";
      fEq = eq;
   }
 
   ~ExampleFrontend()
   {
      printf("ExampleFrontend::dtor!\n");
   }
 
   TAFlowEvent* Analyze(TARunInfo* runinfo, TMEvent* event, TAFlags* flags, TAFlowEvent* flow)
   {
      printf("ExampleFrontend::Analyze, run %d, event serno %d, id 0x%04x, data size %d\n", runinfo->fRunNo, event->serial_number, (int)event->event_id, event->data_size);
 
      flow = new TMEventFlow(flow, *event);
 
      return flow;
   }
      
   TAFlowEvent* AnalyzeFlowEvent(TARunInfo* runinfo, TAFlags* flags, TAFlowEvent* flow)
   {
      printf("ExampleFrontend::AnalyzeFlowEvent, run %d\n", runinfo->fRunNo);
 
      if (!flow)
         return flow;
 
      TMEventFlow* ef = flow->Find<TMEventFlow>();
 
      if (!ef)
         return flow;
 
      uint32_t anaa_bank[] = { 1, 2, 3, 4 };
 
      ef->fEvent.AddBank("ANAA", TID_UINT32, (const char*)&anaa_bank[0], sizeof(anaa_bank));
 
      ef->fEvent.PrintHeader();
 
      if (fEq) {
         fEq->EqSendEvent(ef->fEvent.data);
         fEq->EqWriteStatistics();
      }
 
      return flow;
   }
};
 
class ExampleFrontendFactory: public TAFactory
{
   FeAnalyzer* fFe = NULL;
   EqAnalyzer* fEq = NULL;
 
   void Init(const std::vector<std::string> &args)
   {
      printf("ExampleFrontendFactory::Init!\n");
 
      assert(fEq == NULL);
 
      fFe = new FeAnalyzer();
      fEq = new EqAnalyzer("analyzer", __FILE__);
      fFe->FeAddEquipment(fEq);
      
      TMFeResult r = fFe->FeInitEquipments(args);
      
      if (r.error_flag) {
         fprintf(stderr, "Cannot initialize equipments, error message: %s, bye.\n", r.error_message.c_str());
         fFe->fMfe->Disconnect();
         exit(1);
      }
   }
 
   void Finish()
   {
      printf("ExampleFrontendFactory::Finish!\n");
 
      //if (fEq) {
      //   delete fEq;
      //   fEq = NULL;
      //}
      if (fFe) {
         delete fFe;
         fFe = NULL;
      }
   }
  
   ExampleFrontend* NewRunObject(TARunInfo* runinfo)
   {
      return new ExampleFrontend(runinfo, fEq);
   }
};
 
static TARegister tar(new ExampleFrontendFactory);
 
/* emacs
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 3
 * indent-tabs-mode: nil
 * End:
 */