StPicoEvent.h

#ifndef StPicoEvent_h
#define StPicoEvent_h

// C++ headers
#include <vector>

// ROOT headers
#include "TObject.h"
#include "TVector3.h"

#if defined (__TFG__VERSION__)
#include "TEnv.h"
#endif /* __TFG__VERSION__ */

//_________________
class StPicoEvent : public TObject {

 public:
  StPicoEvent();
  StPicoEvent(const StPicoEvent &event);
  virtual ~StPicoEvent();
  virtual void Print(const Char_t *option = "") const;

  //
  // Getters
  //

  Int_t    runId() const               { return mRunId; }
  Int_t    eventId() const             { return mEventId; }
  Int_t    fillId() const              { return (Int_t)mFillId; }
  Float_t  bField() const              { return mBField; }
  Int_t    time() const                { return mTime; }

  TVector3 primaryVertex() const
  { return TVector3( mPrimaryVertexX,mPrimaryVertexY,mPrimaryVertexZ); }
  TVector3 primaryVertexError() const
  { return TVector3(mPrimaryVertexErrorX,mPrimaryVertexErrorY,mPrimaryVertexErrorZ); }
  Float_t  ranking() const             { return mRanking; }
  UShort_t nBEMCMatch() const          { return mNBEMCMatch; }
  UShort_t nBTOFMatch() const          { return mNBTOFMatch; }

  std::vector<unsigned int> triggerIds() const { return mTriggerIds; }
  bool isTrigger(unsigned int) const;

#if defined (__TFG__VERSION__)
  virtual  Bool_t IsGoodTrigger();
#endif /* __TFG__VERSION__ */

  Int_t    refMultPos() const          { return (Int_t)mRefMultPos; }
  Int_t    refMultNeg() const          { return (Int_t)mRefMultNeg; }
  Int_t    refMultFtpcEast() const     { return (Int_t)mRefMultFtpcEast; }
  Int_t    refMultFtpcWest() const     { return (Int_t)mRefMultFtpcWest; }
  Int_t    refMult() const             { return (Int_t)(mRefMultPos + mRefMultNeg); }
  Int_t    refMultFtpc() const         { return (Int_t)(mRefMultFtpcEast + mRefMultFtpcWest); }
  Int_t    refMult2PosEast() const     { return (Int_t)mRefMult2PosEast; }
  Int_t    refMult2NegEast() const     { return (Int_t)mRefMult2NegEast; }
  Int_t    refMult2PosWest() const     { return (Int_t)mRefMult2PosWest; }
  Int_t    refMult2NegWest() const     { return (Int_t)mRefMult2NegWest; }
  Int_t    refMult3PosEast() const     { return (Int_t)mRefMult3PosEast; }
  Int_t    refMult3NegEast() const     { return (Int_t)mRefMult3NegEast; }
  Int_t    refMult3PosWest() const     { return (Int_t)mRefMult3PosWest; }
  Int_t    refMult3NegWest() const     { return (Int_t)mRefMult3NegWest; }
  Int_t    refMult4PosEast() const     { return (Int_t)mRefMult4PosEast; }
  Int_t    refMult4NegEast() const     { return (Int_t)mRefMult4NegEast; }
  Int_t    refMult4PosWest() const     { return (Int_t)mRefMult4PosWest; }
  Int_t    refMult4NegWest() const     { return (Int_t)mRefMult4NegWest; }
  Int_t    refMultHalfPosEast() const  { return (Int_t)mRefMultHalfPosEast; }
  Int_t    refMultHalfNegEast() const  { return (Int_t)mRefMultHalfNegEast; }
  Int_t    refMultHalfPosWest() const  { return (Int_t)mRefMultHalfPosWest; }
  Int_t    refMultHalfNegWest() const  { return (Int_t)mRefMultHalfNegWest; }
  Int_t    refMult2East() const        { return (Int_t)(mRefMult2PosEast + mRefMult2NegEast); }
  Int_t    refMult2West() const        { return (Int_t)(mRefMult2PosWest + mRefMult2NegWest); }
  Int_t    refMult2() const
  { return (Int_t)(mRefMult2PosEast + mRefMult2NegEast + mRefMult2PosWest + mRefMult2NegWest); }
  Int_t    refMultHalfEast() const     { return (Int_t)(mRefMultHalfPosEast + mRefMultHalfNegEast); }
  Int_t    refMultHalfWest() const     { return (Int_t)(mRefMultHalfPosWest + mRefMultHalfNegWest); }
  Int_t    refMult3East() const        { return (Int_t)(mRefMult3PosEast + mRefMult3NegEast); }
  Int_t    refMult3West() const        { return (Int_t)(mRefMult3PosWest + mRefMult3NegWest); }
  Int_t    refMult3() const
  { return (Int_t)(mRefMult3PosEast + mRefMult3NegEast + mRefMult3PosWest + mRefMult3NegWest); }
  Int_t    refMult4East() const        { return (Int_t)(mRefMult4PosEast + mRefMult4NegEast); }
  Int_t    refMult4West() const        { return (Int_t)(mRefMult4PosWest + mRefMult4NegWest); }
  Int_t    refMult4() const
  { return (Int_t)(mRefMult4PosEast + mRefMult4NegEast + mRefMult4PosWest + mRefMult4NegWest); }

  Int_t    grefMult() const              { return (Int_t)(mGRefMult); }
  UShort_t numberOfGlobalTracks() const  { return mNumberOfGlobalTracks; }
  UShort_t btofTrayMultiplicity() const  { return mbTofTrayMultiplicity; }
  Int_t    numberOfPxlInnerHits() const  { return (Int_t)(mNHitsHFT[0]); }
  Int_t    numberOfPxlOuterHits() const  { return (Int_t)(mNHitsHFT[1]); }
  Int_t    numberOfIstHits() const       { return (Int_t)(mNHitsHFT[2]); }
  Int_t    numberOfSsdHits() const       { return (Int_t)(mNHitsHFT[3]); }
  UShort_t etofHitMultiplicity() const   { return mETofHitMultiplicity; }
  UShort_t etofDigiMultiplicity() const  { return mETofDigiMultiplicity; }
  bool eTofGoodEventFlag( UShort_t iSector, UShort_t iModule,  UShort_t iCounter , UShort_t iGet4) const;
  bool eTofGoodEventFlag( UShort_t iDet ) const { return (bool) mETofGoodEventFlag[ iDet ]; }
  bool eTofPulserStatus( UShort_t iSector, UShort_t iModule,  UShort_t iCounter ) const;
  bool eTofPulserStatus( UShort_t iDet ) const { return (bool) mETofGoodEventFlag[ iDet ]; }
  UShort_t numberOfPrimaryTracks() const { return mNumberOfPrimaryTracks; }
  UShort_t fxtMult() const               { return numberOfPrimaryTracks(); }

  Int_t    nVpdHitsEast() const          { return (Int_t)mNVpdHitsEast; }
  Int_t    nVpdHitsWest() const          { return (Int_t)mNVpdHitsWest; }
  Int_t    nTofT0() const                { return (Int_t)mNTofT0; }
  Float_t  vzVpd() const                 { return mVzVpd; }
  // In the following, the factors of 1000. serve to convert times back and forth between external nsec and internal psec
  Int_t    nTofT0Can() const             { return (Int_t)mNTofT0Can; }
  Double_t  tStart() const                { return ((Double_t)mTStart)/1000.; }
  Double_t  tCanFirst() const             { return ((Double_t)mTCanFirst)/1000.; }
  Double_t  tCanLast() const              { return ((Double_t)mTCanLast)/1000.; }
  Int_t    nVpdEGoodHits() const          { return (Int_t)mNVpdEGoodHits; }
  Int_t    nVpdWGoodHits() const          { return (Int_t)mNVpdWGoodHits; }
  Double_t  earliestVpdEHit() const       { return ((Double_t)mEarliestVpdEHit)/1000.; }
  Double_t  earliestVpdWHit() const       { return ((Double_t)mEarliestVpdWHit)/1000.; }
  Double_t  closestVpdEHit() const        { return ((Double_t)mClosestVpdEHit)/1000.; }
  Double_t  closestVpdWHit() const        { return ((Double_t)mClosestVpdWHit)/1000.; }
  Double_t  latestVpdEHit() const         { return ((Double_t)mLatestVpdEHit)/1000.; }
  Double_t  latestVpdWHit() const         { return ((Double_t)mLatestVpdWHit)/1000.; }
  Float_t  ZDCx() const                  { return (Float_t)mZDCx; }
  Float_t  BBCx() const                  { return (Float_t)mBBCx; }
  Float_t  backgroundRate() const        { return mBackgroundRate; }
  Float_t  bbcBlueBackgroundRate() const { return mBbcBlueBackgroundRate; }
  Float_t  bbcYellowBackgroundRate() const { return mBbcYellowBackgroundRate; }
  Float_t  bbcEastRate() const           { return mBbcEastRate; }
  Float_t  bbcWestRate() const           { return mBbcWestRate; }
  Float_t  zdcEastRate() const           { return mZdcEastRate; }
  Float_t  zdcWestRate() const           { return mZdcWestRate; }

  Float_t zdcUnAttenuatedEast() const    { return mZdcUnAttenuated[0]; }
  Float_t zdcUnAttenuatedWest() const    { return mZdcUnAttenuated[1]; }

  Float_t  ZdcSumAdcEast() const         { return (Float_t)mZdcSumAdcEast; }
  Float_t  ZdcSumAdcWest() const         { return (Float_t)mZdcSumAdcWest; }
  Float_t  ZdcSmdEastHorizontal(int i) const { return (Float_t)mZdcSmdEastHorizontal[i]; }
  Float_t  ZdcSmdEastVertical(int i) const   { return (Float_t)mZdcSmdEastVertical[i]; }
  Float_t  ZdcSmdWestHorizontal(int i) const { return (Float_t)mZdcSmdWestHorizontal[i]; }
  Float_t  ZdcSmdWestVertical(int i) const   { return (Float_t)mZdcSmdWestVertical[i]; }

  UShort_t bbcAdcEast(const Int_t i) const   { return mBbcAdcEast[i]; }
  UShort_t bbcAdcWest(const Int_t i) const   { return mBbcAdcWest[i]; }

  Int_t    highTowerThreshold(const Int_t i) const { return mHighTowerThreshold[i]; }
  Int_t    jetPatchThreshold(const Int_t i) const  { return mJetPatchThreshold[i]; }

  Int_t    year() const;
  Int_t    day() const;
  Int_t    bunchId() const                    { return (Int_t)mBunchCrossId; }

  //
  // Setters
  //

  void setRunId(Int_t id)                     { mRunId = id; }
  void setEventId(Int_t id)                   { mEventId = id; }
  void setFillId(Int_t id)                    { mFillId = (UShort_t)id; }
  void setFillId(Float_t id)                  { mFillId = (id > 0) ? (UShort_t)id : 0; }
  void setBField(Double_t bField)             { mBField = (Float_t)bField; }
  void setMagneticField(Double_t bField)      { mBField = (Float_t)bField; }
  void setTime(Int_t time)                    { mTime = time; }

  void setPrimaryVertexPosition(Float_t x, Float_t y, Float_t z)
  { mPrimaryVertexX = x; mPrimaryVertexY = y; mPrimaryVertexZ = z; }
  void setPrimaryVertexPosition(TVector3 vtxPos)
  { mPrimaryVertexX = vtxPos.X(); mPrimaryVertexY = vtxPos.Y(); mPrimaryVertexZ = vtxPos.Z(); }
  void setPrimaryVertexPositionError(Float_t x, Float_t y, Float_t z)
  { mPrimaryVertexErrorX = x; mPrimaryVertexErrorY = y; mPrimaryVertexErrorZ = z; }
  void setPrimaryVertexPositionError(TVector3 vtxPosErr)
  { mPrimaryVertexErrorX=vtxPosErr.X(); mPrimaryVertexErrorY=vtxPosErr.Y(); mPrimaryVertexErrorZ=vtxPosErr.Z(); }
  void setPrimaryVertexRanking(Float_t ranking) { mRanking = (Float_t)ranking; }
  void setNumberOfBEMCMatch(Int_t n)            { mNBEMCMatch = (UShort_t)n; }
  void setNumberOfBTOFMatch(Int_t n)            { mNBTOFMatch = (UShort_t)n; }
  void setETofHitMultiplicity(UShort_t mult)    { mETofHitMultiplicity = (UShort_t)mult; }
  void setETofDigiMultiplicity(UShort_t mult)   { mETofDigiMultiplicity = (UShort_t)mult; }
    void setETofGoodEventFlag( bool flag, UShort_t iSector, UShort_t iModule,  UShort_t iCounter,  UShort_t iGet4 ) { mETofGoodEventFlag[ 3*3*16*(iSector-1) + 3*16*(iModule-1) + 16*(iCounter-1) + (iGet4-1)] = flag; }
  void setETofGoodEventFlag( std::vector<bool> flagVec ); 
    void setETofHasPulsersFlag( std::vector<bool> pulserVec ); 
  void setNumberOfPrimaryTracks(UShort_t mult)  { mNumberOfPrimaryTracks = (UShort_t)mult; }


  void setTriggerId(UInt_t id);
  void setTriggerIds(std::vector<unsigned int> ids);

  void setRefMultFtpcEast(UShort_t mult)        { mRefMultFtpcEast = (UShort_t)mult; }
  void setRefMultFtpcWest(UShort_t mult)        { mRefMultFtpcWest = (UShort_t)mult; }
  void setRefMultNeg(UShort_t mult)             { mRefMultNeg = (UShort_t)mult; }
  void setRefMultPos(UShort_t mult)             { mRefMultPos = (UShort_t)mult; }
  void setRefMult2NegEast(UShort_t mult)        { mRefMult2NegEast = (UShort_t)mult; }
  void setRefMult2PosEast(UShort_t mult)        { mRefMult2PosEast = (UShort_t)mult; }
  void setRefMult2NegWest(UShort_t mult)        { mRefMult2NegWest = (UShort_t)mult; }
  void setRefMult2PosWest(UShort_t mult)        { mRefMult2PosWest = (UShort_t)mult; }
  void setRefMult3NegEast(UShort_t mult)        { mRefMult3NegEast = (UShort_t)mult; }
  void setRefMult3PosEast(UShort_t mult)        { mRefMult3PosEast = (UShort_t)mult; }
  void setRefMult3NegWest(UShort_t mult)        { mRefMult3NegWest = (UShort_t)mult; }
  void setRefMult3PosWest(UShort_t mult)        { mRefMult3PosWest = (UShort_t)mult; }
  void setRefMult4NegEast(UShort_t mult)        { mRefMult4NegEast = (UShort_t)mult; }
  void setRefMult4PosEast(UShort_t mult)        { mRefMult4PosEast = (UShort_t)mult; }
  void setRefMult4NegWest(UShort_t mult)        { mRefMult4NegWest = (UShort_t)mult; }
  void setRefMult4PosWest(UShort_t mult)        { mRefMult4PosWest = (UShort_t)mult; }
  void setRefMultHalfNegEast(UShort_t mult)     { mRefMultHalfNegEast = (UShort_t)mult; }
  void setRefMultHalfPosEast(UShort_t mult)     { mRefMultHalfPosEast = (UShort_t)mult; }
  void setRefMultHalfNegWest(UShort_t mult)     { mRefMultHalfNegWest = (UShort_t)mult; }
  void setRefMultHalfPosWest(UShort_t mult)     { mRefMultHalfPosWest = (UShort_t)mult; }

  void setGRefMult(UShort_t mult)               { mGRefMult = (UShort_t)mult; }
  void setNumberOfGlobalTracks(UShort_t mult)   { mNumberOfGlobalTracks = (UShort_t)mult; }
  void setbTofTrayMultiplicity(UShort_t mult)   { mbTofTrayMultiplicity = (UShort_t)mult; }
  void setNHitsHFT(Int_t layer, UShort_t word);

  void setNVpdHitsEast(UShort_t nHits)          { mNVpdHitsEast = (UChar_t)nHits; }
  void setNVpdHitsWest(UShort_t nHits)          { mNVpdHitsWest = (UChar_t)nHits; };
  void setNTofT0(Int_t t0)                      { mNTofT0 = (UShort_t)t0; }
  void setVzVpd(Float_t vpdVz)                  { mVzVpd = vpdVz; }
  // In the following, the factors of 1000. serve to convert times back and forth between external nsec and internal psec
  void setNTofT0Can(Int_t t0Can)                       { mNTofT0Can = (UShort_t)t0Can; }
  void setTStart(Double_t startTime)                   { mTStart = (Int_t)(startTime*1000.); }  
  void setTCanFirst(Double_t tFirst)                   { mTCanFirst = (Int_t)(tFirst*1000.); } 
  void setTCanLast(Double_t tLast)                     { mTCanLast = (Int_t)(tLast*1000.); }
  void setNVpdEGoodHits(Int_t vpdEGoodHits)            { mNVpdEGoodHits = (UChar_t)vpdEGoodHits; }
  void setNVpdWGoodHits(Int_t vpdWGoodHits)            { mNVpdWGoodHits = (UChar_t)vpdWGoodHits; }
  void setEarliestVpdEHit(Double_t earliestVpdEHit)    { mEarliestVpdEHit = (Int_t)(earliestVpdEHit*1000.); }
  void setEarliestVpdWHit(Double_t earliestVpdWHit)    { mEarliestVpdWHit = (Int_t)(earliestVpdWHit*1000.); }
  void setClosestVpdEHit(Double_t closestVpdEHit)      { mClosestVpdEHit = (Int_t)(closestVpdEHit*1000.); }
  void setClosestVpdWHit(Double_t closestVpdWHit)      { mClosestVpdWHit = (Int_t)(closestVpdWHit*1000.); }
  void setLatestVpdEHit(Double_t latestVpdEHit)        { mLatestVpdEHit = (Int_t)(latestVpdEHit*1000.); }
  void setLatestVpdWHit(Double_t latestVpdWHit)        { mLatestVpdWHit = (Int_t)(latestVpdWHit*1000.); }
  void setZDCx(Float_t zdcCoinRate)             { mZDCx = (UInt_t)zdcCoinRate; }
  void setBBCx(Float_t bbcCoinRate)             { mBBCx = (UInt_t)bbcCoinRate; }
  void setBackgroundRate(Float_t bckgRate)      { mBackgroundRate = (Float_t)bckgRate; }
  void setBbcBlueBackgroundRate(Float_t bbcBlueBckgRate) { mBbcBlueBackgroundRate = (Float_t)bbcBlueBckgRate; }
  void setBbcYellowBackgroundRate(Float_t bbcYellowBckgRate)
  { mBbcYellowBackgroundRate = (Float_t)bbcYellowBckgRate; }
  void setBbcEastRate(Float_t bbcEastRate)      { mBbcEastRate = (Float_t)bbcEastRate; }
  void setBbcWestRate(Float_t bbcWestRate)      { mBbcWestRate = (Float_t)bbcWestRate; }
  void setZdcEastRate(Float_t zdcEastRate)      { mZdcEastRate = (Float_t)zdcEastRate; }
  void setZdcWestRate(Float_t zdcWestRate)      { mZdcWestRate = (Float_t)zdcWestRate; }

  void setZdcSumAdcEast(Float_t zdcSumAdcEast)  { mZdcSumAdcEast = (UShort_t)zdcSumAdcEast; }
  void setZdcSumAdcWest(Float_t zdcSumAdcWest)  { mZdcSumAdcWest = (UShort_t)zdcSumAdcWest; }
  void setZdcSmdEastHorizontal(Int_t strip, Float_t zdcSmdEastHorizontal);
  void setZdcSmdEastVertical(Int_t strip, Float_t zdcSmdEastVertical);
  void setZdcSmdWestHorizontal(Int_t strip, Float_t zdcSmdWestHorizontal);
  void setZdcSmdWestVertical(Int_t strip, Float_t zdcSmdWestVertical);

  void setZdcUnAttenuated(Int_t side, Float_t adc)
  { if ( side == 0 || side == 1 ) { mZdcUnAttenuated[side] = (UShort_t)adc; } }
  void setZdcUnAttenuatedEast(Float_t adc) { mZdcUnAttenuated[0] = (UShort_t)adc; }
  void setZdcUnAttenuatedWest(Float_t adc) { mZdcUnAttenuated[1] = (UShort_t)adc; }

  void setBbcAdcEast(Int_t iPMT, Float_t bbcAdcEast);
  void setBbcAdcWest(Int_t iPMT, Float_t bbcAdcWest);

  void setHighTowerThreshold(const Int_t i, const Int_t th) { mHighTowerThreshold[i] = (UChar_t)th; }
  void setJetPatchThreshold(const Int_t i, const Int_t th)  { mJetPatchThreshold[i] = (UChar_t)th; }

  void setBunchId(Int_t id);

protected:

#if defined (__TFG__VERSION__)
  TString mProductionVersion;
#endif /* __TFG__VERSION__ */

  Int_t    mRunId;
  Int_t    mEventId;
  UShort_t mFillId;
  Float_t  mBField;

  Int_t    mTime;

  Float_t mPrimaryVertexX;
  Float_t mPrimaryVertexY;
  Float_t mPrimaryVertexZ;
  Float_t mPrimaryVertexErrorX;
  Float_t mPrimaryVertexErrorY;
  Float_t mPrimaryVertexErrorZ;

#if defined (__TFG__VERSION__)
  Float16_t mPrimaryVertexCorr[3];
#endif /* __TFG__VERSION__ */

  Float_t  mRanking;
  UShort_t mNBEMCMatch;
  UShort_t mNBTOFMatch;

  std::vector<unsigned int> mTriggerIds;

  UShort_t mRefMultFtpcEast;
  UShort_t mRefMultFtpcWest;
  UShort_t mRefMultNeg;
  UShort_t mRefMultPos;
  UShort_t mRefMult2NegEast;
  UShort_t mRefMult2PosEast;
  UShort_t mRefMult2NegWest;
  UShort_t mRefMult2PosWest;
  UShort_t mRefMult3NegEast;
  UShort_t mRefMult3PosEast;
  UShort_t mRefMult3NegWest;
  UShort_t mRefMult3PosWest;
  UShort_t mRefMult4NegEast;
  UShort_t mRefMult4PosEast;
  UShort_t mRefMult4NegWest;
  UShort_t mRefMult4PosWest;
  UShort_t mRefMultHalfNegEast;
  UShort_t mRefMultHalfPosEast;
  // TPC refMultHalf neg (eta>0)
  UShort_t mRefMultHalfNegWest;
  UShort_t mRefMultHalfPosWest;

  UShort_t mGRefMult;
  UShort_t mNumberOfGlobalTracks ;
  UShort_t mbTofTrayMultiplicity ;
  UShort_t mNHitsHFT[4];

  UChar_t  mNVpdHitsEast;
  UChar_t  mNVpdHitsWest;
  UShort_t mNTofT0;
  Float_t  mVzVpd;
  UShort_t mNTofT0Can;
  Int_t  mTStart; 
  Int_t  mTCanFirst;
  Int_t  mTCanLast;
  UChar_t  mNVpdEGoodHits;
  UChar_t  mNVpdWGoodHits;
  Int_t  mEarliestVpdEHit;
  Int_t  mEarliestVpdWHit;
  Int_t  mClosestVpdEHit;
  Int_t  mClosestVpdWHit;
  Int_t  mLatestVpdEHit;
  Int_t  mLatestVpdWHit;
 
  UInt_t   mZDCx;
  UInt_t   mBBCx;

#if defined (__TFG__VERSION__)
  Float16_t  mBackgroundRate;
  Float16_t  mBbcBlueBackgroundRate;
  Float16_t  mBbcYellowBackgroundRate;
  Float16_t  mBbcEastRate;
  Float16_t  mBbcWestRate;
  Float16_t  mZdcEastRate;
  Float16_t  mZdcWestRate;
#else /* ! __TFG__VERSION__ */
  Float_t  mBackgroundRate;
  Float_t  mBbcBlueBackgroundRate;
  Float_t  mBbcYellowBackgroundRate;
  Float_t  mBbcEastRate;
  Float_t  mBbcWestRate;
  Float_t  mZdcEastRate;
  Float_t  mZdcWestRate;
#endif

  UShort_t mZdcSumAdcEast;
  UShort_t mZdcSumAdcWest;
  UShort_t mZdcSmdEastHorizontal[8];
  UShort_t mZdcSmdEastVertical[8];
  UShort_t mZdcSmdWestHorizontal[8];
  UShort_t mZdcSmdWestVertical[8];

  UShort_t mBbcAdcEast[24];
  UShort_t mBbcAdcWest[24];

  UChar_t  mHighTowerThreshold[4];
  UChar_t  mJetPatchThreshold[4];

  UChar_t  mBunchCrossId;

  UShort_t mETofHitMultiplicity ;
  UShort_t mETofDigiMultiplicity ;
  bool mETofGoodEventFlag[1728];
  bool mETofHasPulsersFlag[108];

  UShort_t mNumberOfPrimaryTracks;

  UShort_t mZdcUnAttenuated[2];

#if defined (__TFG__VERSION__)
  ClassDef(StPicoEvent, 10)
#else /* ! __TFG__VERSION__ */
  ClassDef(StPicoEvent, 8)
#endif
};

#endif