PlexSEIdAltL.h

Go to the documentation of this file.

// $Id: PlexSEIdAltL.h,v 1.21 2005/08/26 18:47:03 rhatcher Exp $
//
// PlexSEIdAltL
//
// PlexSEIdAltL is a vector+iterator for PlexSEIdAltLItems 
//
// Author:  R. Hatcher 2001.10.22
//

#ifndef PLEXSEIDALTL_H
#define PLEXSEIDALTL_H

#include <iosfwd>

#include "Plex/PlexSEIdAltLItem.h"

#include <vector>
class PlexCalib;

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

class PlexSEIdAltL : public std::vector<PlexSEIdAltLItem> {
  
   // make operator<< a friend so it can access fCurrent
   friend std::ostream &operator<<(std::ostream& os, const PlexSEIdAltL& alt);
 
public:

   PlexSEIdAltL();                        // necessary for streamer io
   PlexSEIdAltL(const PlexSEIdAltL &rhs);             // need deep copy
   virtual ~PlexSEIdAltL();
#ifdef ALTL_EXPLICIT_ASSIGNMENT
   PlexSEIdAltL& operator=(const PlexSEIdAltL &rhs);  // need deep copy
#endif

   typedef PlexSEIdAltL::iterator          PlexSEIdAltLIter;
   typedef PlexSEIdAltL::const_iterator    PlexSEIdAltLConstIter;

   void           AddStripEndId(const PlexStripEndId& seid, 
                                const PlexPixelSpotId& spot,
                                Float_t weight=0,
                                const PlexCalib* calib=0,
                                Int_t adc=0, Double_t time=0);
   void           ClearWeights();
   void           DropCurrent();
   void           DropZeroWeights();
   void           KeepTopWeights(UInt_t n=2, Bool_t keeporder=kFALSE);

   const PlexSEIdAltLItem&   GetBestItem() const;
         PlexSEIdAltLItem&   GetBestItem();
   PlexStripEndId            GetBestSEId() const;
   Float_t                   GetBestWeight() const;
   const PlexSEIdAltLItem&   GetCurrentItem() const;
         PlexSEIdAltLItem&   GetCurrentItem();
   PlexStripEndId            GetCurrentSEId() const;
   Float_t                   GetCurrentWeight() const; 
   UShort_t                  GetDemuxVetoFlag() const 
     { return fDemuxVetoFlag; }

   // in principle (for a correctly cabled detector) these are meaningful
   Bool_t                    IsVetoShield(Bool_t reportError=true) const;
   Detector::Detector_t      GetDetector(Bool_t reportError=true) const;
   StripEnd::StripEnd_t      GetEnd(Bool_t reportError=true) const;
   Int_t                     GetPlane(Bool_t reportError=true) const;
   PlaneView::PlaneView_t    GetPlaneView(Bool_t reportError=true) const;
   Int_t                     GetError(Bool_t reportError=true) const
      { TestConsistency(reportError); return fError; }

   Bool_t         SetToOppositeEnds(PlexSEIdAltL& that);

   inline Int_t   GetSize() const { return this->size(); } 

   Bool_t         IsValid()  const;
   inline void    Next()     const { fCurrent++; }
   inline void    Previous() const { fCurrent--; }
   inline void    SetFirst() const { fCurrent = 0; }
   inline void    SetLast()  const { fCurrent = GetSize()-1; }

   void           SetCurrentWeight(Float_t weight);
   void           AddToCurrentWeight(Float_t wgtadd);
   void           NormalizeWeights(Float_t wgtsum = 1.0);

   void           SetDemuxVetoFlag(UShort_t flag) { fDemuxVetoFlag = flag; }

   // CINT doesn't make size(), push_back() available
   // make alternatives available
   UInt_t         Size() const { return this->size(); }
   void Push_Back(const PlexSEIdAltLItem& item) { this->push_back(item); }

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

   typedef enum EErrorMasks {
      kOkay         = 0x0000,
      kBadDetector  = 0x0001,
      kBadEnd       = 0x0002,
      kBadPlane     = 0x0004,
      kBadPlaneView = 0x0008,
      kUnchecked    = 0x0010,
      kBadIsVeto    = 0x0020
   } ErrorMask_t;

   typedef enum EFmtFlagBits {
     fmt_Index     = 0x0001,
     fmt_Cursor    = 0x0002,
     fmt_Best      = 0x0004,
     fmt_StripEnd  = 0x0008,
     fmt_PixelSpot = 0x0010,
     fmt_Weight    = 0x0020,
     fmt_PE        = 0x0040,
     fmt_SigLin    = 0x0080,
     fmt_SigCorr   = 0x0100,
     fmt_Time      = 0x0200
   } FmtFlagBits_t;

   static void   SetFmtFlag(const UInt_t fmtflg) { fgFmtFlag = fmtflg; }
   static UInt_t GetFmtFlag() { return fgFmtFlag; }

 protected:

 private:

   void           TestConsistency(Bool_t reportError = true) const;

   mutable UShort_t fCurrent;       // current position
           UShort_t fDemuxVetoFlag; // 0=okay, otherwise demux problem
   mutable UShort_t fError;         // see EErrorMasks

   // a global formatting flag
   static UInt_t fgFmtFlag;

   ClassDef(PlexSEIdAltL,6)
};

#endif // PLEXSEIDALTL_H

---