PlexSEIdAltLItem.h

Go to the documentation of this file.

// $Id: PlexSEIdAltLItem.h,v 1.8 2005/02/02 11:45:48 tagg Exp $
//
// PlexSEIdAltLItem
//
// PlexSEIdAltLItem is a strip-end alternative list (vector) item
//
// Author:  R. Hatcher 2001.10.22
//

#ifndef PLEXSEIDALTLITEM_H
#define PLEXSEIDALTLITEM_H

#include "Plex/PlexStripEndId.h"
#include "Plex/PlexPixelSpotId.h"
#include "LeakChecker/Lea.h"

#include <iosfwd>

// put operator<< declaration here so CINT dictionary generator can see it
class PlexSEIdAltLItem;
std::ostream& operator<<(std::ostream& os, const PlexSEIdAltLItem& item);

class PlexSEIdAltLItem {

  // make operator<< a friend so it can look at PlexSEIdAltLItem's privates
  friend std::ostream& operator<<(std::ostream& os, const PlexSEIdAltLItem& item);

public:

   PlexSEIdAltLItem() :   // null ctor
     fStripEndId(),
     fPixelSpotId(),
     fWeight(0), fPE(0), fSigLin(0), fSigCorr(0), fTime(-1) { LEA_CTOR; };

   PlexSEIdAltLItem(const PlexStripEndId& seid, 
                    const PlexPixelSpotId& spotid, 
                    Float_t wgt=0,
                    Float_t pe=0, Float_t siglin=0, Float_t sigcorr=0,
                    Double_t time=0) : // basic ctor
     fStripEndId(seid),
     fPixelSpotId(spotid),
     fWeight(wgt), fPE(pe), 
     fSigLin(siglin), fSigCorr(sigcorr),
     fTime(time) { LEA_CTOR; };

   PlexSEIdAltLItem(const PlexSEIdAltLItem& that) // copy ctor
     { LEA_CTOR; *this = that; }

   virtual ~PlexSEIdAltLItem() { LEA_DTOR; } // dtor

   PlexStripEndId  GetSEId() const { return fStripEndId; }
   PlexPixelSpotId GetPixelSpotId() const { return fPixelSpotId; }
   Float_t         GetWeight() const { return fWeight; }
   Bool_t          IsZeroWeight() const { return fWeight == 0; }
   Float_t         GetPE() const { return fPE; }
   Float_t         GetSigLin() const { return fSigLin; }
   Float_t         GetSigCorr() const { return fSigCorr; }
   Double_t        GetTime() const { return fTime; }

   void            SetWeight(Float_t wgt) { fWeight = wgt; }
   void            AddToWeight(Float_t wgtadd) { fWeight += wgtadd; }
                    
   void            SetPE(Float_t pe) { fPE = pe; }
   void            SetSigLin(Float_t siglin) { fSigLin = siglin; }
   void            SetSigCorr(Float_t sigcorr) { fSigCorr = sigcorr; }
   void            SetTime(Double_t time) { fTime = time; }

   void            AddToTime(Double_t tadd) { fTime += tadd; }

   friend Bool_t   operator==(const PlexSEIdAltLItem &lhs,
                              const PlexSEIdAltLItem &rhs);

   // sort (by default) based on weight
   friend Bool_t   operator<(const PlexSEIdAltLItem &lhs,
                             const PlexSEIdAltLItem &rhs);

   virtual void    Print(Option_t *option="") const;

protected:

   PlexStripEndId    fStripEndId;  // which strip-end
   PlexPixelSpotId   fPixelSpotId; // which pixel-spot
   Float_t           fWeight;      // stored demux weight
   Float_t           fPE;          // ADC value converted to photoelectrons
   Float_t           fSigLin;      // correct for time depend & linearity by LI
   Float_t           fSigCorr;     // correct for strip-to-strip variations
   Double_t          fTime;        // timestamp, corrected for offsets and scale differences. 

private:

   ClassDef(PlexSEIdAltLItem,3)
};

#ifndef __CINT__
inline Bool_t operator==(const PlexSEIdAltLItem& lhs, 
                         const PlexSEIdAltLItem& rhs)
{
   return lhs.fStripEndId == rhs.fStripEndId;
}

inline Bool_t operator<(const PlexSEIdAltLItem& lhs, 
                         const PlexSEIdAltLItem& rhs)
{
   return lhs.fWeight < rhs.fWeight;
}

#endif /* __CINT__ */
#endif // PLEXSEIDALTLITEM_H

---