StGmtStrip.h

#ifndef StGmtStrip_hh
#define StGmtStrip_hh

// STAR headers
#include "StObject.h"
#include "St_base/StMessMgr.h"
#include "StEnumerations.h"

//________________
class StGmtStrip : public StObject {    
 public:
  StGmtStrip();
  StGmtStrip(const StGmtStrip&);
  StGmtStrip& operator=( const StGmtStrip& );
  ~StGmtStrip();
  void Print(Option_t *option="") const;

  //
  // Getters
  //

  Int_t getGeoId() const      { return mGeoId; };
  Int_t getModule() const     { return mModule; }
  Int_t getCoordNum() const   { return mCoordNum; }
  Int_t isY() const           { return mIsY; }
  Int_t  isC()   const        { return mIsC; }
  Float_t getPosition() const { return mPosition; }
  Short_t getAdc( Int_t tb = -1 ) const
  { return mAdc[ (tb < 0 || tb >= kGmtNumTimeBins) ? mDefaultTimeBin : tb ]; }
  Short_t getPedSubtractedAdc( Int_t tb = -1 ) const
  { return mPedSubtractedAdc[ (tb < 0 || tb >= kGmtNumTimeBins) ? mDefaultTimeBin : tb ]; }  
  Short_t getMaxAdc() const   { return mMaxAdc; }
  Short_t getMaxPedSubtractedAdc() const { return mMaxPedSubtractedAdc; }
  Short_t getMaxAdcTB() const { return mMaxAdcTB; }
  Short_t getMaxPedSubtractedAdcTB() const { return mMaxPedSubtractedAdcTB; }

  Float_t getCharge() const   { return mCharge; }
  Float_t getChargeUncert() const { return mChargeUncert; }
  void  getElecCoords( Int_t& rdo, Int_t& arm,  Int_t& apv,  Int_t& chan )
  { rdo = mRdo; arm = mArm; apv = mApv; chan = mChan; }
  Float_t getPed() const       { return mPed; }
  Float_t getPedStdDev() const { return mPedStdDev; }
  Float_t getPedErr() const    { return mPedErr; }
  Bool_t  chargeValid() const
  { return mCharge != 0 && mCharge != kInvalidChargeValue; }
  Int_t getRdo() const         { return mRdo; }
  Int_t getArm() const         { return mArm; }
  Int_t getApv() const         { return mApv; }
  Int_t getChannel() const     { return mChan; }
  static Int_t getDefaultTimeBin() { return mDefaultTimeBin; }

  //
  // Setters
  //
    
  void setGeoId( Int_t geoId )       { mGeoId = geoId; }
  void setModule( Int_t module )     { mModule = module; }
  void setCoordNum( Int_t coord )    { mCoordNum = coord; }
  void setIsY( Int_t isY )           { mIsY = isY; }
  void setIsC( Int_t isC )           { mIsC = isC; }
  void setPosition( Float_t position ) { mPosition = position; }
  void setAdc( Short_t adc, Int_t tb = -1 ) {
    mAdc[ (tb < 0 || tb >= kGmtNumTimeBins) ? mDefaultTimeBin : tb ] = adc;
    if( adc > mMaxAdc ) { mMaxAdc=adc; mMaxAdcTB=tb; }
  }
  void setPedSubtractedAdc( Short_t adc, Int_t tb = -1 ) {
    mPedSubtractedAdc[ (tb < 0 || tb >= kGmtNumTimeBins) ? mDefaultTimeBin : tb ] = adc;
    if( adc > mMaxPedSubtractedAdc ) { mMaxPedSubtractedAdc=adc; mMaxPedSubtractedAdcTB=tb; }
  }
  void setMaxAdc(Short_t adc)        { mMaxAdc=adc; }
  void setMaxPedSubtractedAdc(Short_t adc) { mMaxPedSubtractedAdc = adc; }

  void setCharge( Float_t charge )   { mCharge = charge; }
  void setChargeUncert( Float_t chargeUncert) { mChargeUncert = chargeUncert; }
  void setElecCoords( Int_t rdo, Int_t arm,  Int_t apv,  Int_t chan )
  { mRdo = rdo; mArm = arm; mApv = apv; mChan = chan; }
  void setPed(Float_t ped)           { mPed=ped; }
  void setPedStdDev(Float_t pedStdDev) { mPedStdDev=pedStdDev; }
  void setPedErr(Float_t pedErr)     { mPedErr=pedErr; }
  void invalidateCharge()            { mCharge = kInvalidChargeValue; };
  static void setDefaultTimeBin( Int_t tb ) { mDefaultTimeBin = tb; }

 protected:
  Int_t   mGeoId;
  Int_t   mModule;
  Int_t   mCoordNum;
  Int_t   mIsY;
  Float_t mPosition;
  Short_t mAdc[kGmtNumTimeBins];
  Short_t mPedSubtractedAdc[kGmtNumTimeBins]; 
  Short_t mMaxAdc;
  Short_t mMaxPedSubtractedAdc;
  Short_t mMaxAdcTB;
  Short_t mMaxPedSubtractedAdcTB;
  Float_t mCharge;
  Float_t mChargeUncert;

  // elec coords, straight out of the DAQ file

  Int_t mRdo;
  Int_t mArm; 
  Int_t mApv;
  Int_t mChan;

  Float_t mPed;
  Float_t mPedStdDev;
  Float_t mPedErr;  
  // Is used in a cluster ?
  Int_t mIsC; 
  static Int_t mDefaultTimeBin;
    
  enum { kInvalidChargeValue = -10000 };
    
 private:   
  ClassDef(StGmtStrip,1)
};

ostream& operator<<(ostream& os, StGmtStrip const & v);

// Functor for sorting the strips in the strip weight map.
struct gmtStripPtrLessThan {
  bool operator() (const StGmtStrip* strip1, const StGmtStrip* strip2) const;
};


#endif // #define StGmtStrip_hh