PlexStripEndId.h

Go to the documentation of this file.

// $Id: PlexStripEndId.h,v 1.28 2005/08/26 18:47:04 rhatcher Exp $
//
// PlexStripEndId
//
// PlexStripEndId encapsulates strip end encoding
//
// Author:  R. Hatcher 2000.05.03
//

#ifndef PLEXSTRIPENDID_H
#define PLEXSTRIPENDID_H

#include <iosfwd>

#include "Plex/PlexPlaneId.h"
#include "Plex/PlexScintMdlId.h"
#include "Conventions/StripEnd.h"

class PlexStripEndId;
std::ostream& operator<<(std::ostream& os, const PlexStripEndId& p);

class PlexStripEndId : public PlexPlaneId {

 public:

   PlexStripEndId();                        // necessary for streamer io
   PlexStripEndId(PlexPlaneId plnid,
                  UInt_t strip,
                  StripEnd::StripEnd_t end=StripEnd::kUnknown,
                  StripEnd::StripEnd_t subpart=StripEnd::kWhole);
   PlexStripEndId(Detector::Detector_t detector,
                  UInt_t plane, UInt_t strip,
                  StripEnd::StripEnd_t end=StripEnd::kUnknown,
                  StripEnd::StripEnd_t subpart=StripEnd::kWhole,
                  PlaneView::PlaneView_t view=PlaneView::kUnknown,
                  PlaneCoverage::PlaneCoverage_t cover=PlaneCoverage::kUnknown);

   virtual ~PlexStripEndId() { ; } // no owned data members

   // use these two with caution as they work on the rawest level
   explicit PlexStripEndId(const UInt_t encoded);
   inline UInt_t            GetEncoded() const { return fEncoded; }

   const char              *AsString(Option_t *option="") const;

   StripEnd::StripEnd_t     GetEnd() const;
   UShort_t                 GetStrip() const;
   StripEnd::StripEnd_t     GetSubPart() const;

   PlexStripEndId           GetOppositeSEId() const;
   PlexScintMdlId           GetScintMdlId() const;
   UShort_t                 GetStripInMdl() const;

   // Conversion to construction based notation
   // note: GetStripInMdl returns 1-based numbering that flip flops
   // depending on installation of the module
   UShort_t                 GetMapperStripInMdl() const;
   // GetManifoldF1 is only relevant for Far detector
   // (and CalDet -- but it may be wrong for that)
   StripEnd::StripEnd_t     GetManifoldF1() const;

   // build a useful int of known size for use in further NavKey creation
   // includes just the Plane and Strip #'s
   Int_t                    Build18BitPlnStripKey() const;
   static PlexStripEndId    Unbuild18BitPlnStripKey(Detector::Detector_t det, Int_t key);

   // compactified plane,strip,end (assuming only east/west ends)
   // packed tightly, not simple bit shifts
   // 18 bits or less (unless Far has more than 682 planes)
   Int_t                    BuildPlnStripEndKey() const;
   static PlexStripEndId    UnbuildPlnStripEndKey(Detector::Detector_t det, Int_t key);

   // uncompactified, but unencumbered w/ end and subpart
   // and still usable for creating a PlexStripEndId (sets whole for both)
   UInt_t                   GetUniqueStripEncodedValue() const;

   Bool_t                   IsSameStrip(const PlexStripEndId &other) const;
   Bool_t                   IsSameStripEnd(const PlexStripEndId &other) const;
   Bool_t                   IsOppositeStripEnd(const PlexStripEndId &other) const;

   virtual Bool_t           IsValid() const;

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

   void                     SetEnd(StripEnd::StripEnd_t end);
   void                     SetStrip(UInt_t strip);
   void                     SetSubPart(StripEnd::StripEnd_t subpart);

   friend Bool_t operator< (const PlexStripEndId &lhs, const PlexStripEndId &rhs);
   friend Bool_t operator<=(const PlexStripEndId &lhs, const PlexStripEndId &rhs);
   friend Bool_t operator==(const PlexStripEndId &lhs, const PlexStripEndId &rhs);
   friend Bool_t operator!=(const PlexStripEndId &lhs, const PlexStripEndId &rhs);
   friend Bool_t operator> (const PlexStripEndId &lhs, const PlexStripEndId &rhs);
   friend Bool_t operator>=(const PlexStripEndId &lhs, const PlexStripEndId &rhs);

 protected:

 private:

   // hide PlexPlaneId's version of this member function
   // as this doesn't make sense for a PlexStripEndId
   void                     SetIsSteel(Bool_t /* isSteel */) {;}

   ClassDef(PlexStripEndId,3)
};

#ifndef __CINT__
//==========================================================================
// Implementation details 
//==========================================================================

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

inline Bool_t operator<=(const PlexStripEndId &lhs, const PlexStripEndId &rhs)
{ return lhs.fEncoded <= rhs.fEncoded; }

inline Bool_t operator==(const PlexStripEndId &lhs, const PlexStripEndId &rhs)
{ return lhs.fEncoded == rhs.fEncoded; }

inline Bool_t operator!=(const PlexStripEndId &lhs, const PlexStripEndId &rhs)
{ return lhs.fEncoded != rhs.fEncoded; }

inline Bool_t operator> (const PlexStripEndId &lhs, const PlexStripEndId &rhs)
{ return lhs.fEncoded >  rhs.fEncoded; }

inline Bool_t operator>=(const PlexStripEndId &lhs, const PlexStripEndId &rhs)
{ return lhs.fEncoded >= rhs.fEncoded; }

inline PlexStripEndId::PlexStripEndId() { fEncoded = defaultPlexStripEndId; }
inline PlexStripEndId::PlexStripEndId(const UInt_t encoded) 
{ fEncoded = encoded; }

inline StripEnd::StripEnd_t PlexStripEndId::GetEnd() const
{
   Int_t bitField = ( fEncoded & maskPlexIdEnd ) >> shftPlexIdEnd;
   return (StripEnd::StripEnd_t) bitField;
}

inline UShort_t PlexStripEndId::GetStrip() const
{
   return ( fEncoded & maskPlexIdStrip ) >> shftPlexIdStrip;
}

inline StripEnd::StripEnd_t PlexStripEndId::GetSubPart() const
{
   Int_t bitField = ( fEncoded & maskPlexIdSubPart ) >> shftPlexIdSubPart;
   return (StripEnd::StripEnd_t) bitField;
}

inline UInt_t PlexStripEndId::GetUniqueStripEncodedValue() const
{
   // uncompactified, but unencumbered w/ end and subpart
   // and still usable for creating a PlexStripEndId (sets kWhole for both)
  
  return
    ( fEncoded & ~(maskPlexIdEnd|maskPlexIdSubPart) )                 |
    ( ( StripEnd::kWhole << shftPlexIdSubPart ) & maskPlexIdSubPart ) |
    ( ( StripEnd::kWhole << shftPlexIdEnd      ) & maskPlexIdEnd    ) ;
                 
}

inline void PlexStripEndId::SetEnd(StripEnd::StripEnd_t end)
{
   fEncoded = ( fEncoded & ~maskPlexIdEnd ) | 
      ( ( end << shftPlexIdEnd ) & maskPlexIdEnd );
}

inline void PlexStripEndId::SetStrip(UInt_t strip)
{
   fEncoded = ( fEncoded & ~maskPlexIdStrip ) | 
      ( ( strip << shftPlexIdStrip ) & maskPlexIdStrip );
}

inline void PlexStripEndId::SetSubPart(StripEnd::StripEnd_t subpart)
{
   fEncoded = ( fEncoded & ~maskPlexIdSubPart ) | 
      ( ( subpart << shftPlexIdSubPart ) & maskPlexIdSubPart );
}

#endif /* __CINT__ */
#endif // PLEXSTRIPENDID_H

---