sPhenix code displayed by LXR master/​online_distribution/​eventlibraries/​Event.h	Source navigation Diff markup Identifier search General search
	Version: master Revert   Change

File indexing completed on 2025-08-03 08:20:33

 // -*- c++ -*-
 #ifndef __EVENT_H__
 #define __EVENT_H__
 
 //#include <stddef.h>
 #include <vector>
 
 #include "packet.h"
 #include <ctime>
 
 // virtual base class for an "event"
 
 const char *get_evt_mnemonic(const int);
 
 /** 
 This is the abstract Event class.
 
 It defines all interfaces to deal with Event data. It is a pure
 virtual class which does not define any implementation details (it has
 only member function defintions, no data members). It is meant to be
 subclassed by the classes which define the actual implementation.
 */
 
 //class PHLeanTimeStamp;
 
 #ifndef __CINT__
 class WINDOWSEXPORT Event {
 #else
 class  Event {
 #endif
 
 public:
   inline virtual ~Event(){};
 
   // **** info & debug utils ******
   /** getEvtLength() returns the length of the event raw data
    in longwords (32bit). If you want to copy the event somewhere,
    you can find out whether or not you have enough space left.
   */
   virtual unsigned int getEvtLength() const =0;
 
   /**
       getEvtType() returns the type of the event. Most of the
    events have the type DATAEVENT, but there are also
    BEGRUNEVENT, SPILLONEVENT, SPILLOFFEVENT, ENDRUNEVENT,
    and so on.
   */
   virtual int getEvtType() const =0;
 
   /**
    getEvtSequence() returns the number of the event in a 
    particular run. This number is a property of the event. Its run number and the 
    sequence number uniquely indentify an event. It has nothing to do with the position
    of the event in any given data file.
   */
   virtual int getEvtSequence() const =0;
   
   /**
    getRunNumber() returns the number of the run to which this
    event belongs.
   */
   virtual int getRunNumber() const =0;
 
   /**
    identify will write a short identification message to 
    standard output or to the ostream provided. 
     */
 
 
   virtual void identify(std::ostream& os = std::cout) const = 0;
 
   /**
    listFrame will write a short descriptor of the frame header to the output stream 
    provided. If id == 0, it will list all frame headers. Otherwise it will list
    the header of the frame in which the packet with id resides. 
   */
 
 
   virtual void listFrame(  const int /*id*/=0, std::ostream& /*os*/=std::cout) const {};
 
   virtual void listHistory(  const int /*id*/=0, std::ostream& /*os*/=std::cout) const {};
   virtual void listError(  const int /*id*/=0, std::ostream& /*os*/=std::cout) const {};
 
   /**
    getFrameEntry will return a particular entry from the frame header which contains
    the packet with the specidied id. If id == 0, the first frame will be selected.
 
    keywords to return are:
    
    FRAMELENGTH
    FRAMEMARK
    FRAMEHDRVERSION
    FRAMEHDRLENGTH
    FRAMESTATUS
    FRAMESOURCEID
    FRAMEDATATYPE
    FRAMETYPE
    FRAMEALIGNLENGTH
    FRAMEALIGNMENTWORD[index]
 
    The last  FRAMEALIGNMENTWORD is an array, you need to call 
    getFrameEntry(id,"FRAMEALIGNMENTWORD",1) to get the index 1, and so on. 
    Asking for a word beyond the number of such words will return 0.
   */
 
   virtual unsigned int getFrameEntry(  const char * /*what*/, const int /*id*/=0, const int /*index */=0) const { return 0; };
 
 
   // ***** packet handling *****
   /**
    getPacket creates and returns a pointer to the
    packet object with the specified packet id (think of it 
    as a house number). 
   */
   virtual Packet* getPacket(const int)=0;
 
   /**
    This interface allows to override the hitformat of the packet.
    For debugging purposes mostly.
     
   */
   virtual Packet* getPacket(const int, const int /*hitFormat*/)=0;
 
   /**
     getPacketList returns a simple-minded array of pointers
     to the packets in the given event. It returns the number 
     of packets returned in the array. The second parameter tells
     the packet how long the array is.
   */
   virtual int getPacketList(Packet*[], const int /*length*/) =0;
 
   /**
     getPacketVector returns a stdd:vector of the packet pointers. 
   */
   virtual std::vector<Packet *> getPacketVector() =0;
 
   /**
    existPacket returns 1 if such a packet exists in the
    event. 0 else.
   */
   virtual int existPacket (const int /*packetid*/)=0;
 
   // **** event copying *****
   /**
    the event's raw data are copied to destination. length is the
    size of destination, and nw is the number of words
    actually copied.
 
    if what = "RAW" then we just copy the payload data without the event header.
   */
   virtual int Copy ( int *destination, const unsigned int /*length*/, int *nw, const char * /*what */="" )=0;
 
 
   /**
    getErrorCode() returns a non-zero error code if something in the event
    structure is wrong. Test for 0 to see that the event passes some 
    consistency checks.
   */
   virtual int getErrorCode() {return 0;};
 
 
   /**
    getTagWord() returns the bit pattern that the event builder may have put into
    the header for fast event selection purposes. This is mainly used by the
    ET system to distribute events based on its properties.
   */
   virtual unsigned int getTagWord( const int /*i*/ =0) const { return 0;};
 
   virtual int is_pointer_type() const =0;
 
   // **** convert event from pointer- to data-based *****
   /**
    converting the Event object means that the actual data it manages 
    are copied to an internal location and are thus safe from being overwritten. 
    For efficiency,  most Event objects initially maintain a pointer to the 
    external raw data only. They are referred to as being pointer-based. 
    If an Event object has already been converted, a second convert operation 
    has no effect.  
   */
   virtual int convert ()=0;
 
   virtual int getDate() = 0;
   virtual time_t getTime() const = 0;
 
   virtual void setOriginBuffer(const int n) = 0;
   virtual int getOriginBuffer() const =0;
 
 
 };
 
 #endif /* __EVENT_H__ */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team