Page History

...

The Xtc package defines several classes.

Class

...

XtcFileIterator

This An xtc file is a base class for any source of information in the xtc file (e.g. Detector, Beamline, Process). Defined in pdsdata/xtc/Src.hhcollection of datagrams (Dgram). This is an iterator to loop through all datagrams in a file.

Public Member Functions:

Code Block
// Constructor //and Constructorsdestructor XtcFileIterator(int fd, size_t Src(maxDgramSize); Src(Level::Type level~XtcFileIterator(); uint32_t logDgram* next() const;;

Class Dgram

Datagram - structure of a piece of information within the xtc file.
A datagram contains: Sequence, Env and Xtc.

Code Block
// logical identifier uint32_t phy() const; // physical identifierDgram Level::Type level() const; // level -------------------------------------- \| bool operator==(const Src& s) const;

Protected Attributes

Code Block
uint32_t _log; // logical identifier \| uint32_t _phy; // physical identifier

Class BldInfo

Beamline data Information. This is a derived class that inherits from Src.
Defined in pdsdata/xtc/BldInfo.hh

Public Types:

Code Block
enum Type { EBeam =\| 0,Sequence PhaseCavity = 1, FEEGasDetEnergy = 2, NumberOf = 3 };

Public Member Functions

...

Env

...

Xtc

...

Public Attributes:

Code Block

...

 PDS_DGRAM_STRUCT // #define PDS_DGRAM_STRUCT Sequence seq; Env env; Xtc xtc

Class Sequence

Defined in pdsdata/xtc/Sequence.hh.

Public Types:

Code Block
enum Type {Event = 0, Occurrence = 1, Marker = 2}; enum {NumberOfTypes = 3};

Static Public Member Functions

Code Block
static const char* name(const BldInfo&);

Class ProcInfo

Process information class. This is a derived class that inherits from Src.
Holds process info for all Levels except Source.

Public Member Functions:

Code Block

    // ConstructorConstructors
    ProcInfo(Level::Type level,Sequence() {}
     //Sequence(const Sequence&);
    Sequence(const ClockTime& clock, const TimeStamp& stamp);
    uint32_t processIdSequence(Type, TransitionId::Value, const ClockTime&,  //const TimeStamp&);

    Type type() const;
    TransitionId::Value   uint32_t ipAddr);service() const;
    bool  //

isExtended() const;
    uint32_tbool processIdisEvent() const;
    const uint32_t ipAddrClockTime& clock() const {return  const_clock;}
    voidconst TimeStamp& stamp() const  ipAddr(int{return _stamp;}

    Sequence& operator=(const Sequence&);

Class

...

Env

Detector information. Inherits from Src. Defined in pdsdata/xtc/DetInfoEnv.hh and implemented in pdsdata/xtc/src/DetInfo.cc.

Public Types:Member Functions

Code Block

    enum Detector {// Constructors
    Env() {}
 NoDetector   Env(const = 0,
   Env& in) : _env(in._env) {}
   AmoIms Env(uint32_t env);

    uint32_t  = 1,  // AMO Ion Momentum Spectrometervalue() const;

    const Env& operator=(const Env& that);

Class Xtc

This class defines a container for data stored in an xtc file. An event is a collection of such containers. The size and location of the unspecified data contained are defined by the "sizeofPayload" and "payload" functions. To iterate over a set of such containers see "XtcIterator.hh".

Public Member Functions:
Constructors:

Code Block


    //Constructor used to create an empty, unlabeled
    Xtc() : damage(0), extent(0) {};

    // Copy constructor, will copy everything, but NOT the payload.
    Xtc(const Xtc& xtc) :
      damage(xtc.damage), src(xtc.src), contains(xtc.contains), extent(sizeof(Xtc)) {}

    //
    Xtc(const TypeId& type) :
      damage(0), contains(type), extent(sizeof(Xtc)) {}

    Xtc(const TypeId& type, const Src& _src) :
      damage(0), src(_src), contains(type), extent(sizeof(Xtc)) {}

    Xtc(const TypeId& _tag, const Src& _src, unsigned _damage) :
      damage(_damage), src(_src), contains(_tag), extent(sizeof(Xtc)) {}

    Xtc(const TypeId& _tag, const Src& _src, const Damage& _damage) :
      damage(_damage), src(_src), contains(_tag), extent(sizeof(Xtc)) {}

Overloaded allocation operators to allow the insertion of a dummy "Xtc" within a datagram.

Code Block
void* operator new(size_t size, char* p) { return (void)p; } void operator new(size_t size, Xtc* p) { return p->alloc(size); }

Code Block


    // Return a pointer (of unspecified type) to the payload associated with this class
    char*        payload()       const { return (char*)(this+1); }

    // Return the size (in bytes) of the payload associated with the class.
    int AmoGasdet     = 2,  // AMO Gas Detector (in FrontEnd Enclosure)
      AmoETof       = 3,  // AMO Electron Time-of-flight
      AmoITof       = 4,  // AMO Ion Time-of-flight
      AmoMbes       = 5,  // AMO Magnetic bottle electron spectrometer
      AmoVmi        = 6,  // AMO Velocity map imaging
      AmoBps        = 7,  // AMO Beam position screen
      Camp          = 8,  // CFel-ASG-Multi-Purpose EndStation
      EpicsArch     = 9,  //
      BldEb         = 10,
      SxrBeamline   = 11,
      SxrEndstation = 12,
      XppSb1Ipm     = 13,
      XppSb1Pim     = 14,
      XppMonPim     = 15,
      XppSb2Ipm     = 16,
      XppSb3Ipm     = 17,
      XppSb3Pim     = 18,
      XppSb4Pim     = 19,
      XppGon        = 20,
      XppLas        = 21,
 sizeofPayload() const { return extent XppEndstation = 22,- sizeof(Xtc); }

    // Return AmoEndstationthe =Xtc 23,
which is immediately following an object CxiEndstationof =this 24,class.
    Xtc*  XcsEndstation = 25,
   next()   MecEndstation = 26,
      NumDetector   = 27
 { return (Xtc*)((char*)this+extent); };
    enum Device {
const Xtc* next()       NoDevice  = 0,
const { return (const Xtc*)((char*)this+extent); }

 Evr   void*    = 1,
   alloc(uint32_t size)  { void* Acqirisbuffer   = 2,
      Opal1000  = 3,next(); extent += size; return buffer; }

Public Attributes:

Code Block
Damage TM6740 = 4, damage; Src pnCCD = 5,src; TypeId Princeton = 6, contains; Fccd = 7, Ipimb = 8, Encoder = 9, Cspad = 10, NumDevice = 11 };

Public Member Functions

Code Block


    // Constructors
    DetInfo() {}
    DetInfo(uint32_t   processId,   //
            Detector   det,         //
            uint32_t   detId,       //
            Device     dev,         //
            uint32_t   devId);      //

    bool operator==(const DetInfo &) const;

    uint32_t processId() const;
    Detector detector() const;
    Device device() const;
    uint32_t detId() const;
    uint32_t devId() const;

Static Public Member Functions

uint32_t extent;

Class XtcIterator

This class allows iteration over a collection of "Xtc" objects. An "event" generated from DataFlow consists of data described by a collection of "Xtc" objects. Therefore, this class is instrumental in the navigation of an event's data. The set of "Xtc"s is determined by passing (typically to the constructor) a root "Xtc" which describes the collection of "Xtc"s to process. This root, for example is provided by an event's datagram.

As this is an Abstract-Base-Class, it is expected that an application will subclass from this class, providing an implementation of the "process" method. This method will be called back for each "Xtc" in the collection. Note that the "Xtc" to process is passed as an argument. If the "process" method wishes to abort the iteration a zero (0) value is returned. The iteration is initiated by calling the "iterate" member function.

Public Member Functions:
Constructors and destructor:

Code Block
XtcIterator(Xtc* root); XtcIterator() {} virtual ~XtcIterator() {}

The first constructor takes an argument the "Xtc" which defines the collection to iterate over.

Code Block
virtual int process(Xtc* xtc) = 0;

This function is pure virtual and must be implemented by all derived classes.

Code Block
void iterate();

This function commences iteration over the collection specified by the constructor.

Code Block
void iterate(Xtc*);

Iterate over the collection specifed as an argument to the function. For each "Xtc" found call back the "process" function. If the "process" function returns zero (0) the iteration is aborted and control is returned to the caller. Otherwise, control is returned when all elements of the collection have been scanned.

Code Block
const Xtc* root() const;

This function returns the collection specified by the constructor.

Class Level

Defined in pdsdata/xtc/Level.hh

Public Types:

Code Block
enum Type{Control, Source, Segment, Event, Recorder, Observer, Reporter, NumberOfLevels};

Static Public Member Functions

Code Block
static const char* name(Type type);

Class TransitionId

Public Types:

Code Block
enum Value { Unknown, Reset, Map, Unmap, Configure, Unconfigure, BeginRun, EndRun, BeginCalibCycle, EndCalibCycle, Enable, Disable, L1Accept, NumberOf };

Static Public Member Functions:

Code Block

Code Block
static const char name(Detector); static const char name(Device); static const char* *name(const DetInfo &TransitionId::Value id);

Class

...

Src

This is a base class for any source of information in the xtc file (e.g. Detector, Beamline, Process). Defined in pdsdata/xtc/ClockTimeSrc.hh.

Public Member Functions:

...

Code Block

...

// Constructors
    Src();

...

Src(Level::Type level);

...

uint32_t log()   const;    // logical identifier
    uint32_t phy()   const;    // physical identifier

...

Level::Type level() const;

...

// level

...

bool operator==(const

...

Src& s) const;

Protected Attributes

Code Block

...

uint32_t _log; // logical  identifier

...

uint32_t _phy; // physical identifier

Class BldInfo

...

Beamline data Information. This is a derived class that inherits from Src.

Defined in pdsdata/xtc/DamageBldInfo.hh, inline implementation.

Public Types:

Code Block
enum ValueType { EBeam = 0, PhaseCavity DroppedContribution = 1, FEEGasDetEnergy = 2, NumberOf = OutOfOrder 3 };

Public Member Functions

Constructors and Destructor

Code Block
BldInfo() {} BldInfo(uint32_t processId,

...

Type type);
Accessors
Code Block
uint32_t

...

processId() const;
    Type     type()  const;

Static Public Member Functions

Code Block
= 13, static const UserDefinedchar* name(const BldInfo&);

Class ProcInfo

Process information class. This is a derived class that inherits from Src.
Holds process info for all Levels except Source.

Public Member Functions:

Code Block


    // Constructor
     = 14,
ProcInfo(Level::Type level,      IncompleteContribution = 15,
  //
    ContainsIncomplete     = 16
    };
uint32_t processId,    //
 reserve the top byte to augment user defined errors
    enum {NotUserBitsMask=0x00FFFFFF, UserBitsShift = 24};

Public Member Functions:

Code Block


 uint32_t ipAddr);      // Constructor

    Damage(uint32_t v) : _damage(vprocessId() {}const;

    uint32_t  valueipAddr() const             { return _damage; }const;
    void     increase(Damage::Value v)  { _damage |= ((1<<v) & NotUserBitsMask); }
    void     increase(uint32_t v)ipAddr(int);

Class DetInfo

Detector information. Inherits from Src. Defined in pdsdata/xtc/DetInfo.hh and implemented in pdsdata/xtc/src/DetInfo.cc.

Public Types:

Code Block


    enum Detector {
      NoDetector  { _damage |= v0,
 & NotUserBitsMask; }
   AmoIms uint32_t bits() const     = 1,  // AMO Ion Momentum Spectrometer
   { return _damage &AmoGasdet NotUserBitsMask;}
    uint32_t userBits() const       = 2,  // AMO Gas Detector (in FrontEnd Enclosure)
    { return _damageAmoETof >> UserBitsShift; }
    void= 3,  // AMO userBits(uint32_t v) {Electron Time-of-flight
      _damageAmoITof &= NotUserBitsMask;
     = _damage |= (v << UserBitsShift);4,  // AMO Ion Time-of-flight
    }

Class Dgram

Datagram - structure of a piece of information within the xtc file.

Public Attributes:

Code Block
AmoMbes PDS_DGRAM_STRUCT // #define PDS_DGRAM_STRUCT Sequence= seq;5, Env env;// Xtc xtc

Class Sequence

Defined in pdsdata/xtc/Sequence.hh.

Public Types:

Code Block
enum TypeAMO Magnetic bottle electron spectrometer AmoVmi {Event = 06, Occurrence =// 1,AMO MarkerVelocity =map 2};imaging enum AmoBps {NumberOfTypes = 3};

Public Member Functions:

Code Block


 7,   // Constructors
AMO Beam   Sequence() {}position screen
    Sequence(const Sequence&);
 Camp   Sequence(const ClockTime& clock, const TimeStamp& stamp);
  =  Sequence(Type8, TransitionId::Value, const ClockTime&, const TimeStamp&);

 // CFel-ASG-Multi-Purpose EndStation
    Type type() const;
 EpicsArch    TransitionId::Value  service() const;
    bool isExtended() const;
 = 9,  //
      BldEb        bool isEvent() const;
= 10,
     const ClockTime&SxrBeamline clock() const {return _clock;}
 = 11,
   const TimeStamp& stamp() constSxrEndstation {return _stamp;}

= 12,
     Sequence& operator=(const Sequence&);

Class Env

Defined in pdsdata/xtc/Env.hh

Public Member Functions

Code Block


 XppSb1Ipm     = 13,
      //XppSb1Pim Constructors
    Env() {}= 14,
    Env(const Env& in) : _env(in._env) {}  XppMonPim     = 15,
    Env(uint32_t env);

  XppSb2Ipm    uint32_t value() const;
 = 16,
    const Env& operator=(const Env& that);

Class Level

Defined in pdsdata/xtc/Level.hh

Public Types:

Code Block
enum Type{Control, Source, Segment, Event, Recorder, Observer, Reporter XppSb3Ipm = 17, XppSb3Pim = 18, XppSb4Pim = NumberOfLevels};

Static Public Member Functions

Code Block
19, static const char*XppGon name(Type type);

Class TimeStamp

Public Types:

Code Block
enum {NumFiducialBits = 17};20, enum {MaxFiducials = (1<<17)-32}; XppLas enum {ErrFiducial = (1<<17)-1};

Public Member Functions:

Code Block

21,
    TimeStamp();
  XppEndstation  TimeStamp(const TimeStamp&);
= 22,
     TimeStamp(const TimeStamp&, unsigned control); AmoEndstation = 23,
    TimeStamp(unsigned ticks, unsignedCxiEndstation fiducials, unsigned vector, unsigned control=0);

= 24,
      unsigned ticksXcsEndstation = 25,
      MecEndstation () const;= 26,
    unsigned fiducials() const;
 NumDetector   = unsigned27
 control  () const};
    unsignedenum vectorDevice {
  () const;

   NoDevice TimeStamp& operator= (const TimeStamp&);
0,
      boolEvr       operator==(const TimeStamp&) const; 1,
    bool  Acqiris     operator>=(const TimeStamp&) const; 2,
    bool  Opal1000  = 3,
  operator<=(const TimeStamp&) const;
  TM6740  bool  =  4,
   operator< (const TimeStamp&) const;
 pnCCD    bool = 5,
     operator> (const TimeStamp&) const;

Class TransitionId

Public Types:

Code Block


Princeton = 6,
    enum Value {
Fccd      Unknown,= Reset7,
      Map, Unmap,
Ipimb     = 8,
  Configure, Unconfigure,
   Encoder   BeginRun,= EndRun9,
      BeginCalibCycle,Cspad EndCalibCycle,
    =  Enable, Disable10,
      L1Accept,
NumDevice = 11
    NumberOf };

Static Public Member Functions:

Code Block
// Constructors static const char* name(TransitionId::Value id);

Class TypeId

Public Types:

Code Block


    enum Type {DetInfo() {}
    DetInfo(uint32_t   processId,   //
      Any,
      Detector  Id_Xtc det,          //
    generic hierarchical container
      Id_Frame, uint32_t   detId,       //
 raw    image
      Id_AcqWaveform,
 Device     Id_AcqConfigdev,
       Id_TwoDGaussian,  // 2-D Gaussian + covariances
      Id_Opal1kConfig,
      Iduint32_FrameFexConfig,
t   devId);   Id_EvrConfig,
   //

   Id_TM6740Config,
 bool operator==(const DetInfo   Id_ControlConfig,&) const;

    uint32_t  Id_pnCCDframe,processId() const;
    Detector  Id_pnCCDconfig,detector() const;
    Device  Id_Epics,device() const;
    uint32_t    // Epics Data TypedetId() const;
    uint32_t  Id_FEEGasDetEnergy,
devId() const;

Static Public Member Functions

Code Block
static const Id_EBeam,char name(Detector); static Id_PhaseCavity,const char name(Device); static const Id_PrincetonFrame, Id_PrincetonConfig,char *name(const DetInfo &);

Class ClockTime

Defined in pdsdata/xtc/ClockTime.hh.

Public Member Functions:

Constructors (ClockTime has no destructor)
Code Block

...

ClockTime(); ClockTime(const

...

ClockTime& t); ClockTime(unsigned

...

sec, unsigned nsec);
Accessors:
Code Block
unsigned seconds

...

() const {return

...

_

...

high;} unsigned

...

nanoseconds() const {return _low;}
Operators
Code Block
ClockTime&

...

operator=(const ClockTime&); bool

...

operator> (const ClockTime&) const;
    bool operator==(const ClockTime&) const;

Class Damage

Defined in pdsdata/xtc/Damage.hh, inline implementation.

Public Types:

Code Block

 Id_PrincetonInfo,
    enum Value Id_CspadElement,{
      Id_CspadConfig,
DroppedContribution    =  Id_IpmFexConfig,  // LUSI Diagnostics
1,
      OutOfOrder        Id_IpmFex,
     = Id_DiodeFexConfig12,
      OutOfSynch Id_DiodeFex,
       Id_PimImageConfig,
     = NumberOf};

Public Member Functions:

Code Block


13,
    TypeId() {}
 UserDefined   TypeId(const TypeId& v);
    TypeId(Type type, uint32_t version);
 = 14,
      IncompleteContribution = 15,
    Type  ContainsIncomplete   id()  = 16
    const};
    uint32_t version() const;
    uint32_t value()   const;

// reserve the top byte to augment user defined errors
    static const char* name(Type type);

Class XtcFileIterator

Public Member Functions:

Code Block
// Constructor and destructor XtcFileIterator(int fd, size_t maxDgramSize); ~XtcFileIterator(); Dgram* next();

Class Xtc

This class is not used by any other classes in the xtc package.
But it is used by some applications in the app package.

enum {NotUserBitsMask=0x00FFFFFF, UserBitsShift = 24};

DroppedContribution - means that event is "split" and contains only partial data from incomplete set of detectors. There may be another (or even few) datagram with the same timestamp containing remaining data from the same event.

OutOfOrder - In this case the event may contain data from one or more detector which actually belong to a different event.

OutOfSynch

UserDefined - reserved for user-defined conditions

IncompleteContribution - means that data in that particular container is badly damaged, are incomplete, and cannot be used

ContainsIncomplete - means that it contains one or more containers at deeper XTC levels which have IncompleteContribution damage, events with this damage may be partially useful

Code Block


Bit   Mask   Name
-----------------------------------
 1  0x00002  DroppedContribution
12  0x01000  OutOfOrder
13  0x02000  OutOfSynch
14  0x04000  UserDefined
15  0x08000  IncompleteContribution
16  0x10000  ContainsIncomplete

Bit = n means 1<<n, i.e. 1 shifted left n bits:

                    Decimal     Binary
int32_t value =     1           00000000000000000000000000000001
                                |       |       |       |
DroppedContribution             00000000000000000000000000000010
OutOfOrder

Code Block


    Xtc() : damage(0), extent(0) {};
    Xtc(const Xtc& xtc) :
      damage(xtc.damage), src(xtc.src), contains(xtc.contains), extent(sizeof(Xtc)) {}
    Xtc(const TypeId& type) :
      damage(0), contains(type), extent(sizeof(Xtc)) {}
    Xtc(const TypeId& type, const Src& _src) :
      damage(0), src(_src), contains(type), extent(sizeof(Xtc)) {}
    Xtc(const TypeId& _tag, const Src& _src, unsigned _damage) :
      damage(_damage), src(_src), contains(_tag), extent(sizeof(Xtc)) {}
    Xtc(const TypeId& _tag, const Src& _src, const Damage& _damage) : damage(_damage), src(_src), contains(_tag), extent(sizeof(Xtc)) {}

    void* operator new(size_t size, char* p)     { return (void*)p; }
    void* operator new(size_t size, Xtc* p)      { return p->alloc(size); }

    char*        payload()       const {00000000000000000001000000000000
OutOfSynch return (char*)(this+1); }
    int          sizeofPayload() const { return extent - sizeof(Xtc); }
00000000000000000010000000000000
UserDefined      Xtc*       next()        00000000000000000100000000000000
IncompleteContribution        { return (Xtc*)((char*)this+extent); }
 00000000000000001000000000000000
ContainsIncomplete    const Xtc* next()        00000000000000010000000000000000

Public Member Functions:

Code Block


  const { return (const Xtc*)((char*)this+extent);  // Constructor
    Damage(uint32_t v) : _damage(v) {}

    void*uint32_t  value() const     alloc(uint32_t size)  { void* buffer = next(); extent += size; { return buffer_damage; }

    Damagevoid   damage;
    Src increase(Damage::Value v)  { _damage  src;
|= ((1<<v) & NotUserBitsMask); }
    void     increase(uint32_t v)      TypeId   contains; { _damage |= v & NotUserBitsMask; }
    uint32_t extent;

Class XtcIterator

This is an abstract class.
This class is not used by any other classes in the xtc package.
But it is used by some applications in the app package.

This class allows iteration over a collection of "Xtc" objects. An "event" generated from DataFlow consists of data described by a collection of "Xtc" objects. Therefore, this class is instrumental in the navigation of an event's data. The set of "Xtc"s is determined by passing (typically to the constructor) a root "Xtc" which describes the collection of "Xtc"s to process. This root, for example is provided by an event's datagram. As this is an Abstract-Base-Class, it is expected that an application will subclass from this class, providing an implementation of the "process" method. This method will be called back for each "Xtc" in the collection. Note that the "Xtc" to process is passed as an argument. If the "process" method wishes to abort the iteration a zero (0) value is returned. The iteration is initiated by calling the "iterate" member function.

Public Member Functions:
Constructors and destructor:

Code Block
XtcIterator(Xtc* root); XtcIterator() {} virtual ~XtcIterator() {}

The first constructor takes an argument the "Xtc" which defines the collection to iterate over.

Code Block
virtual int process(Xtc* xtc) = 0;

This function is pure virtual and must be implemented by all derived classes.

Code Block
void iterate();

This function commences iteration over the collection specified by the constructor.

Code Block
void iterate(Xtc*);

Iterate over the collection specifed as an argument to the function. For each "Xtc" found call back the "process" function. If the "process" function returns zero (0) the iteration is aborted and control is returned to the caller. Otherwise, control is returned when all elements of the collection have been scanned.

Code Block
const Xtc* root() const;

...

 bits() const               { return _damage & NotUserBitsMask;}
    uint32_t userBits() const           { return _damage >> UserBitsShift; }
    void     userBits(uint32_t v) {
      _damage &= NotUserBitsMask;
      _damage |= (v << UserBitsShift);
    }

Class TimeStamp

Public Types:

Code Block
enum {NumFiducialBits = 17}; enum {MaxFiducials = (1<<17)-32}; enum {ErrFiducial = (1<<17)-1};

Public Member Functions:

Code Block


    TimeStamp();
    TimeStamp(const TimeStamp&);
    TimeStamp(const TimeStamp&, unsigned control);
    TimeStamp(unsigned ticks, unsigned fiducials, unsigned vector, unsigned control=0);

    unsigned ticks    () const;
    unsigned fiducials() const;
    unsigned control  () const;
    unsigned vector   () const;

    TimeStamp& operator= (const TimeStamp&);
    bool       operator==(const TimeStamp&) const;
    bool       operator>=(const TimeStamp&) const;
    bool       operator<=(const TimeStamp&) const;
    bool       operator< (const TimeStamp&) const;
    bool       operator> (const TimeStamp&) const;

Class TypeId

Public Types:

Code Block


    enum Type {
      Any,
      Id_Xtc,          // generic hierarchical container
      Id_Frame,        // raw image
      Id_AcqWaveform,
      Id_AcqConfig,
      Id_TwoDGaussian, // 2-D Gaussian + covariances
      Id_Opal1kConfig,
      Id_FrameFexConfig,
      Id_EvrConfig,
      Id_TM6740Config,
      Id_ControlConfig,
      Id_pnCCDframe,
      Id_pnCCDconfig,
      Id_Epics,        // Epics Data Type
      Id_FEEGasDetEnergy,
      Id_EBeam,
      Id_PhaseCavity,
      Id_PrincetonFrame,
      Id_PrincetonConfig,
      Id_EvrData,
      Id_FrameFccdConfig,
      Id_FccdConfig,
      Id_IpimbData,
      Id_IpimbConfig,
      Id_EncoderData,
      Id_EncoderConfig,
      Id_EvrIOConfig,
      Id_PrincetonInfo,
      Id_CspadElement,
      Id_CspadConfig,
      Id_IpmFexConfig,  // LUSI Diagnostics
      Id_IpmFex,
      Id_DiodeFexConfig,
      Id_DiodeFex,
      Id_PimImageConfig,
      NumberOf};

Public Member Functions:

Code Block
TypeId() {} TypeId(const TypeId& v); TypeId(Type type, uint32_t version); Type id() const; uint32_t version() const; uint32_t value() const; static const char* name(Type type);

Page tree

Versions Compared

Old Version 9

New Version Current

Key

Class

XtcFileIterator

Class Dgram

Class BldInfo

Class Sequence

Class ProcInfo

Class

Env

Class Xtc

Class XtcIterator

Class Level

Class TransitionId

Class

Src

Class BldInfo

Class ProcInfo

Class DetInfo

Class Dgram

Class Sequence

Class Env

Class Level

Class TimeStamp

Class TransitionId

Class TypeId

Class ClockTime

Class Damage

Class XtcFileIterator

Class Xtc

Class XtcIterator

Class TimeStamp

Class TypeId