TMFeEquipment Class Reference

#include <tmfe.h>

Inheritance diagram for TMFeEquipment:

Collaboration diagram for TMFeEquipment:

Public Member Functions
	TMFeEquipment (const char *eqname, const char *eqfilename)
virtual	~TMFeEquipment ()
TMFeResult	EqInit (const std::vector< std::string > &args)
	Initialize equipment.
TMFeResult	EqPreInit ()
	Initialize equipment, before EquipmentBase::Init()
TMFeResult	EqPostInit ()
	Initialize equipment, after EquipmentBase::Init()
TMFeResult	EqReadCommon ()
	Read TMFeEqInfo from ODB /Equipment/NAME/Common.
TMFeResult	EqWriteCommon (bool create=false)
	Write TMFeEqInfo to ODB /Equipment/NAME/Common.
virtual TMFeResult	HandleInit (const std::vector< std::string > &args)
virtual void	HandleUsage ()
virtual TMFeResult	HandleBeginRun (int run_number)
virtual TMFeResult	HandleEndRun (int run_number)
virtual TMFeResult	HandlePauseRun (int run_number)
virtual TMFeResult	HandleResumeRun (int run_number)
virtual TMFeResult	HandleStartAbortRun (int run_number)
virtual TMFeResult	HandleRpc (const char *cmd, const char *args, std::string &response)
virtual void	HandlePeriodic ()
virtual bool	HandlePoll ()
virtual void	HandlePollRead ()
void	EqPollThread ()
void	EqStartPollThread ()
void	EqStopPollThread ()
TMFeResult	ComposeEvent (char *pevent, size_t size) const
TMFeResult	BkInit (char *pevent, size_t size) const
void *	BkOpen (char *pevent, const char *bank_name, int bank_type) const
TMFeResult	BkClose (char *pevent, void *ptr) const
int	BkSize (const char *pevent) const
TMFeResult	EqSendEvent (const char *pevent, bool write_to_odb=true)
TMFeResult	EqSendEvent (const std::vector< char > &event, bool write_to_odb=true)
TMFeResult	EqSendEvent (const std::vector< std::vector< char > > &event, bool write_to_odb=true)
TMFeResult	EqSendEvent (int sg_n, const char *sg_ptr[], const size_t sg_len[], bool write_to_odb=true)
TMFeResult	EqWriteEventToOdb (const char *pevent)
TMFeResult	EqZeroStatistics ()
TMFeResult	EqWriteStatistics ()
TMFeResult	EqSetStatus (const char *status, const char *color)
	TMFeEquipment (TMFE *mfe, const char *name, TMFeCommon *common)
TMFeError	Init ()
	Initialize equipment.
TMFeError	SendData (const char *data, int size)
	...
TMFeError	ComposeEvent (char *pevent, int size)
TMFeError	BkInit (char *pevent, int size)
void *	BkOpen (char *pevent, const char *bank_name, int bank_type)
TMFeError	BkClose (char *pevent, void *ptr)
int	BkSize (const char *pevent)
TMFeError	SendEvent (const char *pevent)
TMFeError	ZeroStatistics ()
TMFeError	WriteStatistics ()
TMFeError	SetStatus (const char *status, const char *color)
Public Member Functions inherited from TMFeRpcHandlerInterface
virtual TMFeResult	HandleBinaryRpc (const char *cmd, const char *args, std::vector< char > &result)
virtual void	HandleBeginRun ()
virtual void	HandleEndRun ()
virtual void	HandlePauseRun ()
virtual void	HandleResumeRun ()
virtual void	HandleStartAbortRun ()
virtual std::string	HandleRpc (const char *cmd, const char *args)

Public Attributes
std::string	fEqName
std::string	fEqFilename
bool	fEqConfEnableRpc = true
bool	fEqConfEnablePeriodic = true
bool	fEqConfEnablePoll = false
bool	fEqConfReadConfigFromOdb = true
bool	fEqConfEnabled = true
uint16_t	fEqConfEventID = 1
uint16_t	fEqConfTriggerMask = 0
std::string	fEqConfBuffer = "SYSTEM"
int	fEqConfType = 0
int	fEqConfSource = 0
std::string	fEqConfFormat = "MIDAS"
int	fEqConfReadOn = 0
int	fEqConfPeriodMilliSec = 1000
double	fEqConfEventLimit = 0
uint32_t	fEqConfNumSubEvents = 0
int	fEqConfLogHistory = 0
bool	fEqConfHidden = false
int	fEqConfWriteCacheSize = 10000000
bool	fEqConfReadOnlyWhenRunning = true
bool	fEqConfWriteEventsToOdb = false
double	fEqConfPeriodStatisticsSec = 1.0
double	fEqConfPollSleepSec = 0.000100
size_t	fEqConfMaxEventSize = 0
size_t	fEqConfBufferSize = 0
std::mutex	fEqMutex
TMFE *	fMfe = NULL
TMFrontend *	fFe = NULL
MVOdb *	fOdbEq = NULL
	ODB Equipment/EQNAME.
MVOdb *	fOdbEqCommon = NULL
	ODB Equipment/EQNAME/Common.
MVOdb *	fOdbEqSettings = NULL
	ODB Equipment/EQNAME/Settings.
MVOdb *	fOdbEqVariables = NULL
	ODB Equipment/EQNAME/Variables.
MVOdb *	fOdbEqStatistics = NULL
	ODB Equipment/EQNAME/Statistics.
TMEventBuffer *	fEqEventBuffer = NULL
int	fEqSerial = 0
double	fEqStatEvents = 0
double	fEqStatBytes = 0
double	fEqStatEpS = 0
double	fEqStatKBpS = 0
double	fEqStatLastTime = 0
double	fEqStatLastEvents = 0
double	fEqStatLastBytes = 0
double	fEqStatLastWrite = 0
double	fEqStatNextWrite = 0
double	fEqPeriodicLastCallTime = 0
double	fEqPeriodicNextCallTime = 0
std::atomic_bool	fEqPollThreadStarting {false}
std::atomic_bool	fEqPollThreadRunning {false}
std::atomic_bool	fEqPollThreadShutdownRequested {false}
std::thread *	fEqPollThread = NULL
std::string	fName
TMFeCommon *	fCommon
int	fBufferHandle
int	fSerial
double	fStatEvents
double	fStatBytes
double	fStatEpS
double	fStatKBpS
double	fStatLastTime
double	fStatLastEvents
double	fStatLastBytes

Private Member Functions
	TMFeEquipment ()
TMFeResult	EqWriteEventToOdb_locked (const char *pevent)

Detailed Description

Definition at line 156 of file tmfe.h.

Constructor & Destructor Documentation

TMFeEquipment() [1/3]

TMFeEquipment::TMFeEquipment	(	const char *	eqname,
		const char *	eqfilename
	)

Definition at line 1653 of file tmfe.cxx.

{
   assert(eqname != NULL);
   assert(eqfilename != NULL);
   
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::ctor: equipment name [%s] file [%s]\n", eqname, eqfilename);
 
   fMfe = TMFE::Instance();
   fEqName = eqname;
   fEqFilename = eqfilename;
   fEqStatNextWrite = TMFE::GetTime();
}

Here is the call graph for this function:

~TMFeEquipment()

TMFeEquipment::~TMFeEquipment ( )

virtual

Definition at line 1667 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::dtor: equipment name [%s]\n", fEqName.c_str());
 
   EqStopPollThread();
 
   // free data and poison pointers
   if (fOdbEq) {
      delete fOdbEq;
      fOdbEq = NULL;
   }
   if (fOdbEqCommon) {
      delete fOdbEqCommon;
      fOdbEqCommon = NULL;
   }
   if (fOdbEqSettings) {
      delete fOdbEqSettings;
      fOdbEqSettings = NULL;
   }
   if (fOdbEqVariables) {
      delete fOdbEqVariables;
      fOdbEqVariables = NULL;
   }
   if (fOdbEqStatistics) {
      delete fOdbEqStatistics;
      fOdbEqStatistics = NULL;
   }
   fMfe = NULL;
   fFe  = NULL;
   fEqEventBuffer = NULL;
}

Here is the call graph for this function:

TMFeEquipment() [2/3]

TMFeEquipment::TMFeEquipment ( )

inlineprivate

Definition at line 255 of file tmfe.h.

{}; // ctor

TMFeEquipment() [3/3]

TMFeEquipment::TMFeEquipment	(	TMFE *	mfe,
		const char *	name,
		TMFeCommon *	common
	)

Definition at line 611 of file tmfe_rev0.cxx.

{
   fMfe  = mfe;
   fName = name;
   fCommon = common;
   fBufferHandle = 0;
   fSerial = 0;
   fStatEvents = 0;
   fStatBytes  = 0;
   fStatEpS = 0;
   fStatKBpS = 0;
   fStatLastTime = 0;
   fStatLastEvents = 0;
   fStatLastBytes = 0;
   fOdbEq = NULL;
   fOdbEqCommon = NULL;
   fOdbEqSettings = NULL;
   fOdbEqVariables = NULL;
}

Here is the call graph for this function:

Member Function Documentation

BkClose() [1/2]

TMFeError TMFeEquipment::BkClose	(	char *	pevent,
		void *	ptr
	)

Definition at line 780 of file tmfe_rev0.cxx.

{
   bk_close(event + sizeof(EVENT_HEADER), ptr);
   ((EVENT_HEADER*)event)->data_size = BkSize(event);
   return TMFeError();
}

Here is the call graph for this function:

BkClose() [2/2]

TMFeResult TMFeEquipment::BkClose	(	char *	pevent,
		void *	ptr
	)		const

Definition at line 2208 of file tmfe.cxx.

{
   bk_close(event + sizeof(EVENT_HEADER), ptr);
   ((EVENT_HEADER*)event)->data_size = BkSize(event);
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

BkInit() [1/2]

TMFeError TMFeEquipment::BkInit	(	char *	pevent,
		int	size
	)

Definition at line 767 of file tmfe_rev0.cxx.

{
   bk_init32(event + sizeof(EVENT_HEADER));
   return TMFeError();
}

Here is the call graph for this function:

BkInit() [2/2]

TMFeResult TMFeEquipment::BkInit	(	char *	pevent,
		size_t	size
	)		const

Definition at line 2195 of file tmfe.cxx.

{
   bk_init32a(event + sizeof(EVENT_HEADER));
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

BkOpen() [1/2]

void * TMFeEquipment::BkOpen	(	char *	pevent,
		const char *	bank_name,
		int	bank_type
	)

Definition at line 773 of file tmfe_rev0.cxx.

{
   void* ptr;
   bk_create(event + sizeof(EVENT_HEADER), name, tid, &ptr);
   return ptr;
}

Here is the call graph for this function:

BkOpen() [2/2]

void * TMFeEquipment::BkOpen	(	char *	pevent,
		const char *	bank_name,
		int	bank_type
	)		const

Definition at line 2201 of file tmfe.cxx.

{
   void* ptr;
   bk_create(event + sizeof(EVENT_HEADER), name, tid, &ptr);
   return ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BkSize() [1/2]

int TMFeEquipment::BkSize

(

const char *

pevent

)

Definition at line 762 of file tmfe_rev0.cxx.

{
   return bk_size((void*)(event + sizeof(EVENT_HEADER))); // FIXME: need const in prototype!
}

Here is the call graph for this function:

BkSize() [2/2]

int TMFeEquipment::BkSize

(

const char *

pevent

)

const

Definition at line 2190 of file tmfe.cxx.

{
   return bk_size(event + sizeof(EVENT_HEADER));
}

Here is the call graph for this function:

Here is the caller graph for this function:

ComposeEvent() [1/2]

TMFeError TMFeEquipment::ComposeEvent	(	char *	pevent,
		int	size
	)

Definition at line 727 of file tmfe_rev0.cxx.

{
   EVENT_HEADER* pevent = (EVENT_HEADER*)event;
   pevent->event_id = fCommon->EventID;
   pevent->trigger_mask = fCommon->TriggerMask;
   pevent->serial_number = fSerial;
   pevent->time_stamp = TMFE::GetTime();
   pevent->data_size = 0;
   return TMFeError();
}

Here is the call graph for this function:

ComposeEvent() [2/2]

TMFeResult TMFeEquipment::ComposeEvent	(	char *	pevent,
		size_t	size
	)		const

Definition at line 1995 of file tmfe.cxx.

{
   EVENT_HEADER* pevent = (EVENT_HEADER*)event;
   pevent->event_id = fEqConfEventID;
   pevent->trigger_mask = fEqConfTriggerMask;
   pevent->serial_number = fEqSerial;
   pevent->time_stamp = TMFE::GetTime();
   pevent->data_size = 0;
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqInit()

TMFeResult TMFeEquipment::EqInit

(

const std::vector< std::string > &

args

)

Initialize equipment.

Definition at line 1700 of file tmfe.cxx.

{
   TMFeResult r;
 
   r = EqPreInit();
   if (r.error_flag)
      return r;
 
   r = HandleInit(args);
   if (r.error_flag)
      return r;
 
   r = EqPostInit();
   if (r.error_flag)
      return r;
 
   return TMFeOk();
}

Here is the call graph for this function:

EqPollThread()

void TMFeEquipment::EqPollThread

(

)

Definition at line 621 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::EqPollThread: equipment \"%s\" poll thread started\n", fEqName.c_str());
   
   fEqPollThreadRunning = true;
 
   while (!fMfe->fShutdownRequested && !fEqPollThreadShutdownRequested) {
      if (fMfe->fStateRunning || !fEqConfReadOnlyWhenRunning) {
         bool poll = HandlePoll();
         if (poll) {
            HandlePollRead();
         } else {
            if (fEqConfPollSleepSec > 0) {
               TMFE::Sleep(fEqConfPollSleepSec);
            }
         }
      } else {
         TMFE::Sleep(0.1);
      }
   }
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::EqPollThread: equipment \"%s\" poll thread stopped\n", fEqName.c_str());
 
   fEqPollThreadRunning = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqPostInit()

TMFeResult TMFeEquipment::EqPostInit

(

)

Initialize equipment, after EquipmentBase::Init()

Definition at line 1853 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::EqPostInit: for [%s]\n", fEqName.c_str());
 
   if (!fEqConfEnabled) {
      EqSetStatus("Disabled", "yellowLight");
   }
 
   // open event buffer
   
   uint32_t odb_max_event_size = DEFAULT_MAX_EVENT_SIZE;
   fMfe->fOdbRoot->RU32("Experiment/MAX_EVENT_SIZE", &odb_max_event_size, true);
 
   if (fEqConfMaxEventSize == 0) {
      fEqConfMaxEventSize = odb_max_event_size;
   } else if (fEqConfMaxEventSize > odb_max_event_size) {
      fMfe->Msg(MERROR, "TMFeEquipment::EqPostInit", "Equipment \"%s\" requested event size %d is bigger than ODB MAX_EVENT_SIZE %d", fEqName.c_str(), (int)fEqConfMaxEventSize, odb_max_event_size);
      fEqConfMaxEventSize = odb_max_event_size;
   }
 
   if (!fEqConfBuffer.empty()) {
      TMFeResult r = fMfe->EventBufferOpen(&fEqEventBuffer, fEqConfBuffer.c_str(), fEqConfBufferSize);
 
      if (r.error_flag)
         return r;
 
      assert(fEqEventBuffer != NULL);
 
      if (fEqConfMaxEventSize > fEqEventBuffer->fBufMaxEventSize) {
         fMfe->Msg(MERROR, "TMFeEquipment::EqPostInit", "Equipment \"%s\" requested event size %d is bigger than event buffer \"%s\" max event size %d", fEqName.c_str(), (int)fEqConfMaxEventSize, fEqEventBuffer->fBufName.c_str(), (int)fEqEventBuffer->fBufMaxEventSize);
         fEqConfMaxEventSize = fEqEventBuffer->fBufMaxEventSize;
      }
 
      if (fEqConfWriteCacheSize > 0) {
         if (fEqEventBuffer->fBufWriteCacheSize == 0) {
            r = fEqEventBuffer->SetCacheSize(0, fEqConfWriteCacheSize);
 
            if (r.error_flag)
               return r;
         } else if (fEqConfWriteCacheSize < (int)fEqEventBuffer->fBufWriteCacheSize) {
            fMfe->Msg(MERROR, "TMFeEquipment::EqPostInit", "Equipment \"%s\" requested write cache size %d for buffer \"%s\" is smaller then already set write cache size %d, ignoring it", fEqName.c_str(), (int)fEqConfWriteCacheSize, fEqEventBuffer->fBufName.c_str(), (int)fEqEventBuffer->fBufWriteCacheSize);
         } else if (fEqConfWriteCacheSize == (int)fEqEventBuffer->fBufWriteCacheSize) {
            // do nothing
         } else {
            fMfe->Msg(MERROR, "TMFeEquipment::EqPostInit", "Equipment \"%s\" requested write cache size %d for buffer \"%s\" is different from already set write cache size %d", fEqName.c_str(), (int)fEqConfWriteCacheSize, fEqEventBuffer->fBufName.c_str(), (int)fEqEventBuffer->fBufWriteCacheSize);
         
            r = fEqEventBuffer->SetCacheSize(0, fEqConfWriteCacheSize);
            
            if (r.error_flag)
               return r;
         }
      }
   }
 
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::EqPostInit: Equipment \"%s\", max event size: %d\n", fEqName.c_str(), (int)fEqConfMaxEventSize);
 
   // update ODB common
 
   TMFeResult r = EqWriteCommon();
 
   if (r.error_flag)
      return r;
 
   if (fEqConfEnabled && fEqConfEnableRpc) {
      fMfe->AddRpcHandler(this);
   }
 
   return TMFeOk();
};

Here is the call graph for this function:

Here is the caller graph for this function:

EqPreInit()

TMFeResult TMFeEquipment::EqPreInit

(

)

Initialize equipment, before EquipmentBase::Init()

Definition at line 1803 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::PreInit: for [%s]\n", fEqName.c_str());
 
   //
   // Apply frontend index
   //
 
   if (fEqName.find("%") != std::string::npos) {
      fEqName = msprintf(fEqName.c_str(), fFe->fFeIndex);
   }
 
   if (fEqConfBuffer.find("%") != std::string::npos) {
      fEqConfBuffer = msprintf(fEqConfBuffer.c_str(), fFe->fFeIndex);
   }
 
   //
   // create ODB /eq/name/common
   //
 
   fOdbEq = fMfe->fOdbRoot->Chdir((std::string("Equipment/") + fEqName).c_str(), true);
   fOdbEqCommon     = fOdbEq->Chdir("Common", false);
   if (!fOdbEqCommon) {
      if (TMFE::gfVerbose)
         printf("TMFeEquipment::PreInit: creating ODB common\n");
      fOdbEqCommon  = fOdbEq->Chdir("Common", true);
      EqWriteCommon(true);
   }
   fOdbEqSettings   = fOdbEq->Chdir("Settings", true);
   fOdbEqVariables  = fOdbEq->Chdir("Variables", true);
   fOdbEqStatistics = fOdbEq->Chdir("Statistics", true);
 
   TMFeResult r = EqReadCommon();
 
   if (r.error_flag)
      return r;
 
   if (rpc_is_remote()) {
      EqSetStatus((fMfe->fProgramName + "@" + fMfe->fHostname).c_str(), "greenLight");
   } else {
      EqSetStatus(fMfe->fProgramName.c_str(), "greenLight");
   }
 
   EqZeroStatistics();
   EqWriteStatistics();
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqReadCommon()

TMFeResult TMFeEquipment::EqReadCommon

(

)

Read TMFeEqInfo from ODB /Equipment/NAME/Common.

Definition at line 1719 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::EqReadCommon: for [%s]\n", fEqName.c_str());
 
   // list of ODB Common entries always read
 
   fOdbEqCommon->RB("Enabled", &fEqConfEnabled, true);
   fOdbEqCommon->RD("Event limit", &fEqConfEventLimit, true);
 
   if (fEqConfReadConfigFromOdb) {
      // list of ODB Common entries read if we want to control equipment from ODB
 
      fOdbEqCommon->RU16("Event ID",       &fEqConfEventID,        true);
      fOdbEqCommon->RU16("Trigger mask",   &fEqConfTriggerMask,    true);
      fOdbEqCommon->RS("Buffer",           &fEqConfBuffer,         true, NAME_LENGTH);
      fOdbEqCommon->RI("Type",             &fEqConfType,           true);
      fOdbEqCommon->RI("Source",           &fEqConfSource,         true);
      fOdbEqCommon->RS("Format",           &fEqConfFormat,         true, 8);
      fOdbEqCommon->RI("Read on",          &fEqConfReadOn,         true);
      fOdbEqCommon->RI("Period",           &fEqConfPeriodMilliSec, true);
      fOdbEqCommon->RU32("Num subevents",  &fEqConfNumSubEvents,   true);
      fOdbEqCommon->RI("Log history",      &fEqConfLogHistory,     true);
      fOdbEqCommon->RB("Hidden",           &fEqConfHidden,         true);
      fOdbEqCommon->RI("Write cache size", &fEqConfWriteCacheSize, true);
 
      // decode data from ODB Common
 
      fEqConfReadOnlyWhenRunning = !(fEqConfReadOn & (RO_PAUSED|RO_STOPPED));
      fEqConfWriteEventsToOdb    = (fEqConfReadOn & RO_ODB);
   }
 
   // list of ODB Common entries we read and write back to ODB, but do not actually use.
 
   //fOdbEqCommon->RS("Frontend host",       &fEqConfFrontendHost,     true, NAME_LENGTH);
   //fOdbEqCommon->RS("Frontend name",       &fEqConfFrontendName,     true, NAME_LENGTH);
   //fOdbEqCommon->RS("Frontend file name",  &fEqConfFrontendFileName, true, 256);
   //fOdbEqCommon->RS("Status",              &fEqConfStatus,           true, 256);
   //fOdbEqCommon->RS("Status color",        &fEqConfStatusColor,      true, NAME_LENGTH);
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqSendEvent() [1/4]

TMFeResult TMFeEquipment::EqSendEvent	(	const char *	pevent,
		bool	write_to_odb = true
	)

Definition at line 2006 of file tmfe.cxx.

{
   std::lock_guard<std::mutex> guard(fEqMutex);
   
   fEqSerial++;
 
   EVENT_HEADER* pevent = (EVENT_HEADER*)event;
   pevent->data_size = BkSize(event);
   
   if (fEqEventBuffer != NULL) {
      TMFeResult r = fEqEventBuffer->SendEvent(event);
  
   if (r.error_flag)
      return r;
   }
 
   fEqStatEvents += 1;
   fEqStatBytes  += sizeof(EVENT_HEADER) + pevent->data_size;
 
   if (fEqConfWriteEventsToOdb && write_to_odb) {
      TMFeResult r = EqWriteEventToOdb_locked(event);
      if (r.error_flag)
         return r;
   }
 
   if (fMfe->fStateRunning) {
      if (fEqConfEventLimit > 0) {
         if (fEqStatEvents >= fEqConfEventLimit) {
            if (!fMfe->fRunStopRequested) {
               fMfe->Msg(MINFO, "TMFeEquipment::EqSendEvent", "Equipment \"%s\" sent %.0f events out of %.0f requested, run will stop now", fEqName.c_str(), fEqStatEvents, fEqConfEventLimit);
            }
            fMfe->fRunStopRequested = true;
         }
      }
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqSendEvent() [2/4]

TMFeResult TMFeEquipment::EqSendEvent	(	const std::vector< char > &	event,
		bool	write_to_odb = true
	)

Definition at line 2045 of file tmfe.cxx.

{
   std::lock_guard<std::mutex> guard(fEqMutex);
   
   fEqSerial++;
 
   if (fEqEventBuffer == NULL) {
      return TMFeOk();
   }
 
   TMFeResult r = fEqEventBuffer->SendEvent(event);
 
   if (r.error_flag)
      return r;
 
   fEqStatEvents += 1;
   fEqStatBytes  += event.size();
 
   if (fEqConfWriteEventsToOdb && write_to_odb) {
      TMFeResult r = EqWriteEventToOdb_locked(event.data());
      if (r.error_flag)
         return r;
   }
 
   if (fMfe->fStateRunning) {
      if (fEqConfEventLimit > 0) {
         if (fEqStatEvents >= fEqConfEventLimit) {
            if (!fMfe->fRunStopRequested) {
               fMfe->Msg(MINFO, "TMFeEquipment::EqSendEvent", "Equipment \"%s\" sent %.0f events out of %.0f requested, run will stop now", fEqName.c_str(), fEqStatEvents, fEqConfEventLimit);
            }
            fMfe->fRunStopRequested = true;
         }
      }
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

EqSendEvent() [3/4]

TMFeResult TMFeEquipment::EqSendEvent	(	const std::vector< std::vector< char > > &	event,
		bool	write_to_odb = true
	)

Definition at line 2083 of file tmfe.cxx.

{
   std::lock_guard<std::mutex> guard(fEqMutex);
   
   fEqSerial++;
 
   if (fEqEventBuffer == NULL) {
      return TMFeOk();
   }
 
   TMFeResult r = fEqEventBuffer->SendEvent(event);
 
   if (r.error_flag)
      return r;
 
   fEqStatEvents += 1;
   for (auto v: event) {
      fEqStatBytes += v.size();
   }
 
   //if (fEqConfWriteEventsToOdb && write_to_odb) {
   //   TMFeResult r = EqWriteEventToOdb_locked(event.data());
   //   if (r.error_flag)
   //      return r;
   //}
 
   if (fMfe->fStateRunning) {
      if (fEqConfEventLimit > 0) {
         if (fEqStatEvents >= fEqConfEventLimit) {
            if (!fMfe->fRunStopRequested) {
               fMfe->Msg(MINFO, "TMFeEquipment::EqSendEvent", "Equipment \"%s\" sent %.0f events out of %.0f requested, run will stop now", fEqName.c_str(), fEqStatEvents, fEqConfEventLimit);
            }
            fMfe->fRunStopRequested = true;
         }
      }
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

EqSendEvent() [4/4]

TMFeResult TMFeEquipment::EqSendEvent	(	int	sg_n,
		const char *	sg_ptr[],
		const size_t	sg_len[],
		bool	write_to_odb = true
	)

Definition at line 2123 of file tmfe.cxx.

{
   std::lock_guard<std::mutex> guard(fEqMutex);
   
   fEqSerial++;
 
   if (fEqEventBuffer == NULL) {
      return TMFeOk();
   }
 
   TMFeResult r = fEqEventBuffer->SendEvent(sg_n, sg_ptr, sg_len);
 
   if (r.error_flag)
      return r;
 
   fEqStatEvents += 1;
   for (int i=0; i<sg_n; i++) {
      fEqStatBytes += sg_len[i];
   }
 
   //if (fEqConfWriteEventsToOdb && write_to_odb) {
   //   TMFeResult r = EqWriteEventToOdb_locked(event.data());
   //   if (r.error_flag)
   //      return r;
   //}
 
   if (fMfe->fStateRunning) {
      if (fEqConfEventLimit > 0) {
         if (fEqStatEvents >= fEqConfEventLimit) {
            if (!fMfe->fRunStopRequested) {
               fMfe->Msg(MINFO, "TMFeEquipment::EqSendEvent", "Equipment \"%s\" sent %.0f events out of %.0f requested, run will stop now", fEqName.c_str(), fEqStatEvents, fEqConfEventLimit);
            }
            fMfe->fRunStopRequested = true;
         }
      }
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

EqSetStatus()

TMFeResult TMFeEquipment::EqSetStatus	(	const char *	status,
		const char *	color
	)

Definition at line 2215 of file tmfe.cxx.

{
   if (eq_status) {
      fOdbEqCommon->WS("Status", eq_status, 256);
   }
 
   if (eq_color) {
      fOdbEqCommon->WS("Status color", eq_color, NAME_LENGTH);
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqStartPollThread()

void TMFeEquipment::EqStartPollThread

(

)

Definition at line 648 of file tmfe.cxx.

{
   // NOTE: this is thread safe
 
   std::lock_guard<std::mutex> guard(fEqMutex);
 
   if (fEqPollThreadRunning || fEqPollThreadStarting || fEqPollThread) {
      fMfe->Msg(MERROR, "TMFeEquipment::EqStartPollThread", "Equipment \"%s\": poll thread is already running", fEqName.c_str());
      return;
   }
 
   fEqPollThreadShutdownRequested = false;
   fEqPollThreadStarting = true;
 
   fEqPollThread = new std::thread(&TMFeEquipment::EqPollThread, this);
}

Here is the call graph for this function:

EqStopPollThread()

void TMFeEquipment::EqStopPollThread

(

)

Definition at line 665 of file tmfe.cxx.

{
   // NOTE: this is thread safe
   fEqPollThreadStarting = false;
   fEqPollThreadShutdownRequested = true;
   for (int i=0; i<100; i++) {
      if (!fEqPollThreadRunning) {
         std::lock_guard<std::mutex> guard(fEqMutex);
         if (fEqPollThread) {
            fEqPollThread->join();
            delete fEqPollThread;
            fEqPollThread = NULL;
         }
         return;
      }
      TMFE::Sleep(0.1);
   }
   if (fEqPollThreadRunning) {
      fMfe->Msg(MERROR, "TMFeEquipment::EqStopPollThread", "Equipment \"%s\": timeout waiting for shutdown of poll thread", fEqName.c_str());
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqWriteCommon()

TMFeResult TMFeEquipment::EqWriteCommon

(

bool

create = false

)

Write TMFeEqInfo to ODB /Equipment/NAME/Common.

Definition at line 1762 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::EqWriteCommon: for [%s]\n", fEqName.c_str());
 
   // encode data for ODB Common
 
   fEqConfReadOn = 0;
   if (fEqConfReadOnlyWhenRunning)
      fEqConfReadOn |= (RO_RUNNING);
   else
      fEqConfReadOn |= (RO_RUNNING|RO_PAUSED|RO_STOPPED);
   if (fEqConfWriteEventsToOdb)
      fEqConfReadOn |= RO_ODB;
 
   // write to ODB
   
   fOdbEqCommon->WU16("Event ID",          fEqConfEventID);
   fOdbEqCommon->WU16("Trigger mask",      fEqConfTriggerMask);
   fOdbEqCommon->WS("Buffer",              fEqConfBuffer.c_str(), NAME_LENGTH);
   fOdbEqCommon->WI("Type",                fEqConfType);
   fOdbEqCommon->WI("Source",              fEqConfSource);
   fOdbEqCommon->WS("Format",              fEqConfFormat.c_str(), 8);
   fOdbEqCommon->WB("Enabled",             fEqConfEnabled);
   fOdbEqCommon->WI("Read on",             fEqConfReadOn);
   fOdbEqCommon->WI("Period",              fEqConfPeriodMilliSec);
   fOdbEqCommon->WD("Event limit",         fEqConfEventLimit);
   fOdbEqCommon->WU32("Num subevents",     fEqConfNumSubEvents);
   fOdbEqCommon->WI("Log history",         fEqConfLogHistory);
   fOdbEqCommon->WS("Frontend host",       fMfe->fHostname.c_str(), NAME_LENGTH);
   fOdbEqCommon->WS("Frontend name",       fMfe->fProgramName.c_str(), NAME_LENGTH);
   fOdbEqCommon->WS("Frontend file name",  fEqFilename.c_str(), 256);
   if (create) {
      fOdbEqCommon->WS("Status",           "", 256);
      fOdbEqCommon->WS("Status color",     "", NAME_LENGTH);
   }
   fOdbEqCommon->WB("Hidden",              fEqConfHidden);
   fOdbEqCommon->WI("Write cache size",    fEqConfWriteCacheSize);
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqWriteEventToOdb()

TMFeResult TMFeEquipment::EqWriteEventToOdb

(

const char *

pevent

)

Definition at line 2163 of file tmfe.cxx.

{
   std::lock_guard<std::mutex> guard(fEqMutex);
   return EqWriteEventToOdb_locked(event);
}

Here is the call graph for this function:

EqWriteEventToOdb_locked()

TMFeResult TMFeEquipment::EqWriteEventToOdb_locked ( const char *  pevent )

private

Definition at line 2169 of file tmfe.cxx.

{
   std::string path = "";
   path += "/Equipment/";
   path += fEqName;
   path += "/Variables";
 
   HNDLE hKeyVar = 0;
 
   int status = db_find_key(fMfe->fDB, 0, path.c_str(), &hKeyVar);
   if (status != DB_SUCCESS) {
      return TMFeMidasError(msprintf("Cannot find \"%s\" in ODB", path.c_str()), "db_find_key", status);
   }
 
   status = cm_write_event_to_odb(fMfe->fDB, hKeyVar, (const EVENT_HEADER*) event, FORMAT_MIDAS);
   if (status != SUCCESS) {
      return TMFeMidasError("Cannot write event to ODB", "cm_write_event_to_odb", status);
   }
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqWriteStatistics()

TMFeResult TMFeEquipment::EqWriteStatistics

(

)

Definition at line 1950 of file tmfe.cxx.

{
   fEqMutex.lock();
 
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::EqWriteStatistics: write statistics for [%s]\n", fEqName.c_str());
 
   double now = TMFE::GetTime();
   double elapsed = now - fEqStatLastTime;
 
   if (elapsed > 0.9 || fEqStatLastTime == 0) {
      fEqStatEpS = (fEqStatEvents - fEqStatLastEvents) / elapsed;
      fEqStatKBpS = (fEqStatBytes - fEqStatLastBytes) / elapsed / 1000.0;
 
      fEqStatLastTime = now;
      fEqStatLastEvents = fEqStatEvents;
      fEqStatLastBytes = fEqStatBytes;
   }
 
   //printf("TMFeEquipment::EqWriteStatistics: write statistics for [%s], now %f, elapsed %f, sent %f, eps %f, kps %f\n", fEqName.c_str(), now, elapsed, fEqStatEvents, fEqStatEpS, fEqStatKBpS);
 
   fOdbEqStatistics->WD("Events sent", fEqStatEvents);
   fOdbEqStatistics->WD("Events per sec.", fEqStatEpS);
   fOdbEqStatistics->WD("kBytes per sec.", fEqStatKBpS);
 
   fEqStatLastWrite = now;
 
   if (fEqConfPeriodStatisticsSec > 0) {
      // avoid creep of NextWrite: we start it at
      // time of initialization, then increment it strictly
      // by the period value, regardless of when it is actually
      // written to ODB (actual period is longer than requested
      // period because we only over-sleep, never under-sleep). K.O.
      while (fEqStatNextWrite <= now) {
         fEqStatNextWrite += fEqConfPeriodStatisticsSec;
      }
   } else {
      fEqStatNextWrite = now;
   }
 
   fEqMutex.unlock();
   
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqZeroStatistics()

TMFeResult TMFeEquipment::EqZeroStatistics

(

)

Definition at line 1925 of file tmfe.cxx.

{
   fEqMutex.lock();
 
   if (TMFE::gfVerbose)
      printf("TMFeEquipment::EqZeroStatistics: zero statistics for [%s]\n", fEqName.c_str());
 
   double now = TMFE::GetTime();
   
   fEqStatEvents = 0;
   fEqStatBytes = 0;
   fEqStatEpS = 0;
   fEqStatKBpS = 0;
   
   fEqStatLastTime = now;
   fEqStatLastEvents = 0;
   fEqStatLastBytes = 0;
 
   fEqStatNextWrite = now; // force immediate update
 
   fEqMutex.unlock();
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

HandleBeginRun()

virtual TMFeResult TMFeEquipment::HandleBeginRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeRpcHandlerInterface.

Reimplemented in EqRpc, EqEverything, EqTrigger, and Myfe.

Definition at line 262 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

HandleEndRun()

virtual TMFeResult TMFeEquipment::HandleEndRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeRpcHandlerInterface.

Reimplemented in EqRpc, EqEverything, EqTrigger, and Myfe.

Definition at line 263 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

HandleInit()

virtual TMFeResult TMFeEquipment::HandleInit ( const std::vector< std::string > &  args )

inlinevirtual

Reimplemented in EqRandom, EqSlow, EqRare, EqBulk, EqRpc, EqEverything, and EqTrigger.

Definition at line 258 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

Here is the caller graph for this function:

HandlePauseRun()

virtual TMFeResult TMFeEquipment::HandlePauseRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeRpcHandlerInterface.

Reimplemented in EqRpc, and EqEverything.

Definition at line 264 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

HandlePeriodic()

virtual void TMFeEquipment::HandlePeriodic ( )

inlinevirtual

Reimplemented in EqRandom, EqSlow, EqRare, Myfe, Myfe, EqEverything, EqPeriodic, EqPeriodic, and Myfe.

Definition at line 270 of file tmfe.h.

{};

HandlePoll()

virtual bool TMFeEquipment::HandlePoll ( )

inlinevirtual

Reimplemented in EqEverything, and EqTrigger.

Definition at line 273 of file tmfe.h.

{ return false; };

Here is the caller graph for this function:

HandlePollRead()

virtual void TMFeEquipment::HandlePollRead ( )

inlinevirtual

Reimplemented in EqEverything, and EqTrigger.

Definition at line 274 of file tmfe.h.

{};

Here is the caller graph for this function:

HandleResumeRun()

virtual TMFeResult TMFeEquipment::HandleResumeRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeRpcHandlerInterface.

Reimplemented in EqRpc, and EqEverything.

Definition at line 265 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

HandleRpc()

virtual TMFeResult TMFeEquipment::HandleRpc ( const char *  cmd, const char *  args, std::string &  response  )

inlinevirtual

Reimplemented from TMFeRpcHandlerInterface.

Reimplemented in EqRpc, EqEverything, EqTrigger, and Myfe.

Definition at line 267 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

HandleStartAbortRun()

virtual TMFeResult TMFeEquipment::HandleStartAbortRun ( int  run_number )

inlinevirtual

Reimplemented from TMFeRpcHandlerInterface.

Reimplemented in EqRpc, and EqEverything.

Definition at line 266 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

HandleUsage()

virtual void TMFeEquipment::HandleUsage ( )

inlinevirtual

Reimplemented in EqEverything, and EqTrigger.

Definition at line 259 of file tmfe.h.

{};

Init()

TMFeError TMFeEquipment::Init

(

)

Initialize equipment.

Definition at line 631 of file tmfe_rev0.cxx.

{
   //
   // create ODB /eq/name/common
   //
 
   fOdbEq = fMfe->fOdbRoot->Chdir((std::string("Equipment/") + fName).c_str(), true);
   fOdbEqCommon     = fOdbEq->Chdir("Common", true);
   fOdbEqSettings   = fOdbEq->Chdir("Settings", true);
   fOdbEqVariables  = fOdbEq->Chdir("Variables", true);
   fOdbEqStatistics = fOdbEq->Chdir("Statistics", true);
 
   fOdbEqCommon->RU16("Event ID",     &fCommon->EventID, true);
   fOdbEqCommon->RU16("Trigger mask", &fCommon->TriggerMask, true);
   fOdbEqCommon->RS("Buffer",         &fCommon->Buffer, true, NAME_LENGTH);
   fOdbEqCommon->RI("Type",           &fCommon->Type, true);
   fOdbEqCommon->RI("Source",         &fCommon->Source, true);
   fOdbEqCommon->RS("Format",         &fCommon->Format, true, 8);
   fOdbEqCommon->RB("Enabled",        &fCommon->Enabled, true);
   fOdbEqCommon->RI("Read on",        &fCommon->ReadOn, true);
   fOdbEqCommon->RI("Period",         &fCommon->Period, true);
   fOdbEqCommon->RD("Event limit",    &fCommon->EventLimit, true);
   fOdbEqCommon->RU32("Num subevents",  &fCommon->NumSubEvents, true);
   fOdbEqCommon->RI("Log history",    &fCommon->LogHistory, true);
   fOdbEqCommon->RS("Frontend host",  &fCommon->FrontendHost, true, NAME_LENGTH);
   fOdbEqCommon->RS("Frontend name",  &fCommon->FrontendName, true, NAME_LENGTH);
   fOdbEqCommon->RS("Frontend file name",  &fCommon->FrontendFileName, true, 256);
   fOdbEqCommon->RS("Status",         &fCommon->Status, true, 256);
   fOdbEqCommon->RS("Status color",   &fCommon->StatusColor, true, NAME_LENGTH);
   fOdbEqCommon->RB("Hidden",         &fCommon->Hidden, true);
   fOdbEqCommon->RI("Write cache size", &fCommon->WriteCacheSize, true);
 
   fCommon->FrontendHost = fMfe->fFrontendHostname;
   fCommon->FrontendName = fMfe->fFrontendName;
   fCommon->FrontendFileName = fMfe->fFrontendFilename;
 
   fCommon->Status = "";
   fCommon->Status += fMfe->fFrontendName;
   fCommon->Status += "@";
   fCommon->Status += fMfe->fFrontendHostname;
   fCommon->StatusColor = "greenLight";
 
   if (fCommon->Buffer.length() > 0) {
      int status = bm_open_buffer(fCommon->Buffer.c_str(), DEFAULT_BUFFER_SIZE, &fBufferHandle);
      if (status != BM_SUCCESS) {
         return TMFeError(status, "bm_open_buffer");
      }
   }
 
   fOdbEqCommon->WS("Frontend host", fCommon->FrontendHost.c_str(), NAME_LENGTH);
   fOdbEqCommon->WS("Frontend name", fCommon->FrontendName.c_str(), NAME_LENGTH);
   fOdbEqCommon->WS("Frontend file name", fCommon->FrontendFileName.c_str(), 256);
   fOdbEqCommon->WS("Status", fCommon->Status.c_str(), 256);
   fOdbEqCommon->WS("Status color", fCommon->StatusColor.c_str(), NAME_LENGTH);
 
   ZeroStatistics();
   WriteStatistics();
 
   return TMFeError();
};

Here is the call graph for this function:

SendData()

TMFeError TMFeEquipment::SendData	(	const char *	data,
		int	size
	)

...

Definition at line 738 of file tmfe_rev0.cxx.

{
   if (fBufferHandle == 0) {
      return TMFeError();
   }
   int status = bm_send_event(fBufferHandle, (const EVENT_HEADER*)buf, size, BM_WAIT);
   if (status == BM_CORRUPTED) {
      TMFE::Instance()->Msg(MERROR, "TMFeEquipment::SendData", "bm_send_event() returned %d, event buffer is corrupted, shutting down the frontend", status);
      TMFE::Instance()->fShutdownRequested = true;
      return TMFeError(status, "bm_send_event: event buffer is corrupted, shutting down the frontend");
   } else if (status != BM_SUCCESS) {
      return TMFeError(status, "bm_send_event");
   }
   fStatEvents += 1;
   fStatBytes  += size;
   return TMFeError();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SendEvent()

TMFeError TMFeEquipment::SendEvent

(

const char *

pevent

)

Definition at line 756 of file tmfe_rev0.cxx.

{
   fSerial++;
   return SendData(event, sizeof(EVENT_HEADER) + BkSize(event));
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetStatus()

TMFeError TMFeEquipment::SetStatus	(	const char *	status,
		const char *	color
	)

Definition at line 787 of file tmfe_rev0.cxx.

{
   HNDLE hDB;
   int status;
 
   status = cm_get_experiment_database(&hDB, NULL);
   if (status != CM_SUCCESS) {
      return TMFeError(status, "cm_get_experiment_database");
   }
 
   if (eq_status) {
      fOdbEqCommon->WS("Status", eq_status, 256);
   }
 
   if (eq_color) {
      fOdbEqCommon->WS("Status color", eq_color, NAME_LENGTH);
   }
 
   return TMFeError();
}

Here is the call graph for this function:

Here is the caller graph for this function:

WriteStatistics()

TMFeError TMFeEquipment::WriteStatistics

(

)

Definition at line 706 of file tmfe_rev0.cxx.

{
   double now = TMFE::GetTime();
   double elapsed = now - fStatLastTime;
 
   if (elapsed > 0.9 || fStatLastTime == 0) {
      fStatEpS = (fStatEvents - fStatLastEvents) / elapsed;
      fStatKBpS = (fStatBytes - fStatLastBytes) / elapsed / 1000.0;
 
      fStatLastTime = now;
      fStatLastEvents = fStatEvents;
      fStatLastBytes = fStatBytes;
   }
   
   fOdbEqStatistics->WD("Events sent", fStatEvents);
   fOdbEqStatistics->WD("Events per sec.", fStatEpS);
   fOdbEqStatistics->WD("kBytes per sec.", fStatKBpS);
 
   return TMFeError();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ZeroStatistics()

TMFeError TMFeEquipment::ZeroStatistics

(

)

Definition at line 692 of file tmfe_rev0.cxx.

{
   fStatEvents = 0;
   fStatBytes = 0;
   fStatEpS = 0;
   fStatKBpS = 0;
   
   fStatLastTime = 0;
   fStatLastEvents = 0;
   fStatLastBytes = 0;
 
   return TMFeError();
}

Here is the caller graph for this function:

Member Data Documentation

fBufferHandle

int TMFeEquipment::fBufferHandle

Definition at line 140 of file tmfe_rev0.h.

fCommon

TMFeCommon* TMFeEquipment::fCommon

Definition at line 136 of file tmfe_rev0.h.

fEqConfBuffer

std::string TMFeEquipment::fEqConfBuffer = "SYSTEM"

Definition at line 173 of file tmfe.h.

fEqConfBufferSize

size_t TMFeEquipment::fEqConfBufferSize = 0

Definition at line 201 of file tmfe.h.

fEqConfEnabled

bool TMFeEquipment::fEqConfEnabled = true

Definition at line 170 of file tmfe.h.

fEqConfEnablePeriodic

bool TMFeEquipment::fEqConfEnablePeriodic = true

Definition at line 165 of file tmfe.h.

fEqConfEnablePoll

bool TMFeEquipment::fEqConfEnablePoll = false

Definition at line 166 of file tmfe.h.

fEqConfEnableRpc

bool TMFeEquipment::fEqConfEnableRpc = true

Definition at line 164 of file tmfe.h.

fEqConfEventID

uint16_t TMFeEquipment::fEqConfEventID = 1

Definition at line 171 of file tmfe.h.

fEqConfEventLimit

double TMFeEquipment::fEqConfEventLimit = 0

Definition at line 179 of file tmfe.h.

fEqConfFormat

std::string TMFeEquipment::fEqConfFormat = "MIDAS"

Definition at line 176 of file tmfe.h.

fEqConfHidden

bool TMFeEquipment::fEqConfHidden = false

Definition at line 182 of file tmfe.h.

fEqConfLogHistory

int TMFeEquipment::fEqConfLogHistory = 0

Definition at line 181 of file tmfe.h.

fEqConfMaxEventSize

size_t TMFeEquipment::fEqConfMaxEventSize = 0

Definition at line 200 of file tmfe.h.

fEqConfNumSubEvents

uint32_t TMFeEquipment::fEqConfNumSubEvents = 0

Definition at line 180 of file tmfe.h.

fEqConfPeriodMilliSec

int TMFeEquipment::fEqConfPeriodMilliSec = 1000

Definition at line 178 of file tmfe.h.

fEqConfPeriodStatisticsSec

double TMFeEquipment::fEqConfPeriodStatisticsSec = 1.0

Definition at line 198 of file tmfe.h.

fEqConfPollSleepSec

double TMFeEquipment::fEqConfPollSleepSec = 0.000100

Definition at line 199 of file tmfe.h.

fEqConfReadConfigFromOdb

bool TMFeEquipment::fEqConfReadConfigFromOdb = true

Definition at line 168 of file tmfe.h.

fEqConfReadOn

int TMFeEquipment::fEqConfReadOn = 0

Definition at line 177 of file tmfe.h.

fEqConfReadOnlyWhenRunning

bool TMFeEquipment::fEqConfReadOnlyWhenRunning = true

Definition at line 196 of file tmfe.h.

fEqConfSource

int TMFeEquipment::fEqConfSource = 0

Definition at line 175 of file tmfe.h.

fEqConfTriggerMask

uint16_t TMFeEquipment::fEqConfTriggerMask = 0

Definition at line 172 of file tmfe.h.

fEqConfType

int TMFeEquipment::fEqConfType = 0

Definition at line 174 of file tmfe.h.

fEqConfWriteCacheSize

int TMFeEquipment::fEqConfWriteCacheSize = 10000000

Definition at line 186 of file tmfe.h.

fEqConfWriteEventsToOdb

bool TMFeEquipment::fEqConfWriteEventsToOdb = false

Definition at line 197 of file tmfe.h.

fEqEventBuffer

TMEventBuffer* TMFeEquipment::fEqEventBuffer = NULL

Definition at line 218 of file tmfe.h.

fEqFilename

std::string TMFeEquipment::fEqFilename

Definition at line 160 of file tmfe.h.

fEqMutex

std::mutex TMFeEquipment::fEqMutex

Definition at line 204 of file tmfe.h.

fEqName

std::string TMFeEquipment::fEqName

Definition at line 159 of file tmfe.h.

fEqPeriodicLastCallTime

double TMFeEquipment::fEqPeriodicLastCallTime = 0

Definition at line 237 of file tmfe.h.

fEqPeriodicNextCallTime

double TMFeEquipment::fEqPeriodicNextCallTime = 0

Definition at line 238 of file tmfe.h.

fEqPollThread

std::thread* TMFeEquipment::fEqPollThread = NULL

Definition at line 277 of file tmfe.h.

fEqPollThreadRunning

std::atomic_bool TMFeEquipment::fEqPollThreadRunning {false}

Definition at line 242 of file tmfe.h.

{false};

fEqPollThreadShutdownRequested

std::atomic_bool TMFeEquipment::fEqPollThreadShutdownRequested {false}

Definition at line 243 of file tmfe.h.

{false};

fEqPollThreadStarting

std::atomic_bool TMFeEquipment::fEqPollThreadStarting {false}

Definition at line 241 of file tmfe.h.

{false};

fEqSerial

int TMFeEquipment::fEqSerial = 0

Definition at line 219 of file tmfe.h.

fEqStatBytes

double TMFeEquipment::fEqStatBytes = 0

Definition at line 223 of file tmfe.h.

fEqStatEpS

double TMFeEquipment::fEqStatEpS = 0

Definition at line 224 of file tmfe.h.

fEqStatEvents

double TMFeEquipment::fEqStatEvents = 0

Definition at line 222 of file tmfe.h.

fEqStatKBpS

double TMFeEquipment::fEqStatKBpS = 0

Definition at line 225 of file tmfe.h.

fEqStatLastBytes

double TMFeEquipment::fEqStatLastBytes = 0

Definition at line 230 of file tmfe.h.

fEqStatLastEvents

double TMFeEquipment::fEqStatLastEvents = 0

Definition at line 229 of file tmfe.h.

fEqStatLastTime

double TMFeEquipment::fEqStatLastTime = 0

Definition at line 228 of file tmfe.h.

fEqStatLastWrite

double TMFeEquipment::fEqStatLastWrite = 0

Definition at line 233 of file tmfe.h.

fEqStatNextWrite

double TMFeEquipment::fEqStatNextWrite = 0

Definition at line 234 of file tmfe.h.

fFe

TMFrontend* TMFeEquipment::fFe = NULL

Definition at line 208 of file tmfe.h.

fMfe

TMFE * TMFeEquipment::fMfe = NULL

Definition at line 207 of file tmfe.h.

fName

std::string TMFeEquipment::fName

Definition at line 135 of file tmfe_rev0.h.

fOdbEq

MVOdb * TMFeEquipment::fOdbEq = NULL

ODB Equipment/EQNAME.

Definition at line 211 of file tmfe.h.

fOdbEqCommon

MVOdb * TMFeEquipment::fOdbEqCommon = NULL

ODB Equipment/EQNAME/Common.

Definition at line 212 of file tmfe.h.

fOdbEqSettings

MVOdb * TMFeEquipment::fOdbEqSettings = NULL

ODB Equipment/EQNAME/Settings.

Definition at line 213 of file tmfe.h.

fOdbEqStatistics

MVOdb * TMFeEquipment::fOdbEqStatistics = NULL

ODB Equipment/EQNAME/Statistics.

Definition at line 215 of file tmfe.h.

fOdbEqVariables

MVOdb * TMFeEquipment::fOdbEqVariables = NULL

ODB Equipment/EQNAME/Variables.

Definition at line 214 of file tmfe.h.

fSerial

int TMFeEquipment::fSerial

Definition at line 141 of file tmfe_rev0.h.

fStatBytes

double TMFeEquipment::fStatBytes

Definition at line 152 of file tmfe_rev0.h.

fStatEpS

double TMFeEquipment::fStatEpS

Definition at line 153 of file tmfe_rev0.h.

fStatEvents

double TMFeEquipment::fStatEvents

Definition at line 151 of file tmfe_rev0.h.

fStatKBpS

double TMFeEquipment::fStatKBpS

Definition at line 154 of file tmfe_rev0.h.

fStatLastBytes

double TMFeEquipment::fStatLastBytes

Definition at line 158 of file tmfe_rev0.h.

fStatLastEvents

double TMFeEquipment::fStatLastEvents

Definition at line 157 of file tmfe_rev0.h.

fStatLastTime

double TMFeEquipment::fStatLastTime

Definition at line 156 of file tmfe_rev0.h.

---

The documentation for this class was generated from the following files:

• include/tmfe.h
• include/tmfe_rev0.h
• src/tmfe.cxx
• src/tmfe_rev0.cxx