Page History

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

    Level::Type level() const; // level

    bool operator==(const Src& s) const;

    //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)) {}

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

    // 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          sizeofPayload() const { return extent - sizeof(Xtc); }

    // Return the Xtc which is immediately following an object of this class.
    Xtc*       next()                { return (Xtc*)((char*)this+extent); }
    const Xtc* next()          const { return (const Xtc*)((char*)this+extent); }

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

    Damage   damage;
    Src      src;
    TypeId   contains;
    uint32_t extent;

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

    virtual int process(Xtc* xtc) = 0;

    void      iterate();

    void      iterate(Xtc*);

    const Xtc* root()  const;

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

  static const char* name(Type type);

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

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

    uint32_t _log; // logical  identifier
    uint32_t _phy; // physical identifier

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

    // 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};

    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
    }

    Id_PrincetonConfig,
static const char *name(Detector);
   Id_EvrData,
 static const    Id_FrameFccdConfig,char *name(Device);
    static const Id_FccdConfig,
      Id_IpimbData,
      Id_IpimbConfig,char *name(const DetInfo &);

 Id_DiodeFexConfig,
    enum Value Id_DiodeFex,{
      Id_PimImageConfig,
DroppedContribution    =  NumberOf};

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
                     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 { return (char*)(this+1); }
    int          sizeofPayload() const { return| extent - sizeof(Xtc); }
   | Xtc*      | next()      |
DroppedContribution          { return (Xtc*)((char*)this+extent); }
 00000000000000000000000000000010
OutOfOrder    const  Xtc* next()          const { return (const Xtc*)((char*)this+extent); }

 00000000000000000001000000000000
OutOfSynch     void*        alloc(uint32_t size)  { void* buffer = next(); extent += size; return buffer; }

00000000000000000010000000000000
UserDefined        Damage   damage;
    Src      src;
00000000000000000100000000000000
IncompleteContribution       TypeId   contains;00000000000000001000000000000000
ContainsIncomplete    uint32_t extent;

    // Constructor
    Damage(uint32_t v) : _damage(v) {}

    uint32_t  value() const             { return _damage; }
    void     increase(Damage::Value v)  { _damage |= ((1<<v) & NotUserBitsMask); }
    void     increase(uint32_t v)       { _damage |= v & NotUserBitsMask; }
    uint32_t bits() const               { return _damage & NotUserBitsMask;}
    uint32_t userBits() const           { return _damage >> UserBitsShift; }
    void     userBits(uint32_t v) {
      _damage &= NotUserBitsMask;
      _damage |= (v << UserBitsShift);
    }

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

    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;

    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};

    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);