packet.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file packet.h

#ifndef __PACKET_H__
#define __PACKET_H__


#include "generalDefinitions.h"

#include "event_io.h"

#define WINDOWSEXPORT

// --------------------------------------------------
// the virtual base base class for all Packets.
// --------------------------------------------------


#ifndef __CINT__
class WINDOWSEXPORT Packet
#else
class  Packet
#endif
  {

   /* @name Description of the interface routines
      these are the interface routines to get at decoded values.
      iValue and rValue return int's and float's, respectively.
      the optional "what" parameter is needed for some devices
      which have more than one type of information, such as the
      MIZAR board, which gets ADC and TDC values.
      iValue(0), iValue(0,""), and iValue("ADC") all
      return what we call "natural data", which means ADC information
      (I decided that), while iValue(0,"TDC") gives you the TDC
      value of channel 0. All Packet classes accept "RAW" as a type,
      directing them to return unprocessed/undecoded packet raw data.

      The array-type interface iValue(const int channel,const int iy)
      is just a convenient call for devices which inherently have
      two-dimensional arrays of data, such as the Hammond flash ADC
      board, where you get 8 channels with 512 time samples each.
      Another example is a group of several, say, LC2249W ADC's read out
      in one packet, so that iValue(0,2) refers to channel 0 of the
      second ADC in the group.
   */




  public:
  inline virtual ~Packet() {};

  // **** getting decoded values ****



  virtual int    iValue(const int /*channel*/) =0;

  virtual int    iValue(const int /*channel*/, const char * /*what*/) =0;

  virtual int    iValue(const int /*channel*/, const int /*y*/, const char * /*what*/) =0;

  virtual int    iValue(const int /*channel*/,const int /*iy*/) =0;

  virtual int    iValue(const int /*channel*/,const int /*iy*/, const int /*iz*/) =0;

  virtual int    iValue(const int /*channel*/,const int /*iy*/, const int /*iz*/, const char */*what*/) =0;

  virtual float  rValue(const int /*channel*/) =0;

  virtual double  dValue(const int channel)
  {return rValue(channel);};

  virtual double  dValue(const int channel, const char *what)
  {return iValue(channel, what);};

  virtual double  dValue(const int channel, const int iy)
  {return iValue(channel, iy);};

  virtual long long  lValue(const int channel)
  {return iValue(channel);};

  virtual long long  lValue(const int channel, const char *what)
  {return iValue(channel,what);};

  virtual long long  lValue(const int channel, const int iy)
  {return iValue(channel, iy);};

  virtual long long  lValue(const int channel, const int iy, const char *what)
  {return iValue(channel, iy, what);};

  virtual float  rValue(const int /*channel*/, const char * /*what*/) =0;


  virtual float  rValue(const int /*channel*/, const int /*iy*/) =0;

  virtual void * pValue(const int /*channel*/)
  {
    return 0;
  }

  virtual void * pValue(const int /*channel*/, const char * /*what*/)
  {
    return 0;
  }

  virtual void * pValue(const int /*chan*/, const int /*iy*/)
  {
    return 0;
  }




  // *** now getting all the decoded values in one go ***
  // these routines get you all the decoded values into an array
  // of float's or int's. The what parameter has the usual meaning.

  virtual int    getArraylength(const char * what ="") =0;

  virtual int    fillIntArray (int destination[],    // the data go here
                               const int /*length*/,      // space we have in destination
                               int * /*nw*/,              // words actually used
                               const char * what="") = 0; // type of data (see above)

  virtual int    fillFloatArray (float destination[],    // the data go here
                                 const int /*length*/,      // space we have in destination
                                 int * /*nw*/,              // words actually used
                                 const char * what="") = 0; // type of data (see above)

  virtual int*   getIntArray (int * /*nw*/,const char * ="") =0;

  virtual float* getFloatArray (int * /*nw*/,const char * ="") =0;


  virtual int is_pointer_type() const = 0;

  virtual int convert() =0;


  // access to envelope information:

  virtual int   getLength() const = 0;

  //  virtual int   getType() const = 0;
  //  virtual int   getDecoding() const = 0;

  // some more header fields which are not yet implemented, marked "//*"
  //* virtual int   gethdrVersion() const = 0; // Version of header definition
  //* virtual int   getHdrLength() const = 0;     // inclusive of alignment data
  //* virtual int   getStatus() const = 0;             // Status bits describe frame errors/other

  virtual int   getErrorLength() const = 0;    // Length of error block in Dwords

  virtual int   getDebugLength() const = 0;// Length of debug block in Dwords

  virtual int   getIdentifier() const = 0; // Identifier

  //* virtual int       getEndianism() const = 0;  // Big/little endian indicator

  virtual int   getPadding() const = 0;    // number of padding units

  virtual int   getStructure() const = 0;  // Structure of packet

  //* virtual int       getWordSize() const = 0;   // "Word" size used to store packet data
  //* virtual int       getAddrLength() const = 0; // number of bytes used for channel address
  //* virtual int       getHitLength() const = 0;  // Length of a single "hit" in bytes

  virtual int   getHitFormat() const = 0;  // Format of a single hit
  //* virtual int       getNumEntries() const = 0; // Number of "objects" stored in packet

  virtual int   getDataLength() const = 0;  // Format of a single hit

  // debugging-type information
  // identify will write a short identification message to
  // standard output or to the iOSTREAM provided. Nice to see.


  //#ifdef LVL2_WINNT
  //  virtual void  identify( std::OSTREAM&os =std::COUT ) const = 0;
  //  virtual void  fullIdentify( std::OSTREAM& os =std::COUT ) const
  //    { identify(os);};
  //  virtual void  dump ( std::OSTREAM& =std::COUT )  = 0;
  //  virtual void  gdump (const int how = EVT_HEXADECIMAL, std::OSTREAM& =std::COUT) const = 0;



  virtual void identify(std::ostream& os = std::cout) const = 0;

  virtual int   setIdentifier(const int /*newid*/) = 0; // Identifier

  virtual void fullIdentify(std::ostream& os = std::cout) const
  { identify(os);};

  virtual void dump(std::ostream& os = std::cout)  = 0;


  virtual void gdump(const int how = EVT_HEXADECIMAL, std::ostream& os = std::cout) const  = 0;

  virtual int getCheckSumStatus() const { return 0;};
  virtual int   copyMe(int [],  const int /*maxlength*/) const { return 0;};

  virtual int setInternalParameter ( const int p1=0, const int p2=0, const char *what = "") = 0;


  };

// some structures for the LVL triggers

// emcal

struct emcChannelLongList
{
  int channel;
  int time;
  int highpost;
  int lowpost;
  int highpre;
  int lowpre;
};


#define RICH_TIME 0
#define RICH_POSTSAMPLE 1
#define RICH_PRESAMPLE 2

struct richChannelList
{
  int channel;
  int time;
  int post;
  int pre;
};

struct emcChannelShortList
{
  int channel;
  int gain;  // 0 = low, else high
  int time;
  int post;
  int pre;

};

struct tecChannelList
{
  int channel;
  int time;
  int value;

};


#endif /* __PACKET_H__ */