PlexPlaneId.h

Go to the documentation of this file.

// $Id: PlexPlaneId.h,v 1.40 2005/08/26 18:47:03 rhatcher Exp $
//
// PlexPlaneId
//
// PlexPlaneId encapsulates plane number encoding
//
// Author:  R. Hatcher 2000.11.28
//

#ifndef PLEXPLANEID_H
#define PLEXPLANEID_H

#include <iosfwd>

#include "Conventions/Detector.h"
#include "Conventions/PlaneView.h"
#include "Conventions/PlaneCoverage.h"

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

class PlexPlaneId {

 public:

   PlexPlaneId();
   PlexPlaneId(Detector::Detector_t detector,
               UInt_t plane, Bool_t isSteel=kFALSE,
               PlaneView::PlaneView_t view=PlaneView::kUnknown,
               PlaneCoverage::PlaneCoverage_t cover=PlaneCoverage::kUnknown);

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

   // use these three with caution as they work on the rawest level
   explicit PlexPlaneId(const UInt_t encoded);
   inline UInt_t            GetEncoded() const;

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

   Detector::Detector_t            GetDetector() const;
   UShort_t                        GetPlane() const;
   PlaneCoverage::PlaneCoverage_t  GetPlaneCoverage() const;
   PlaneView::PlaneView_t          GetPlaneView() const;

   Bool_t                          IsSteel() const;
   Bool_t                          IsVetoShield() const;

   Int_t                           GetVetoSection() const; // 1,2,3,4  0=!Veto
   Int_t                           GetSuperModule() const; // 0,1 for Far
   Bool_t                          IsNearSpect() const;

   virtual Bool_t                  IsValid() const; // !IsNull and Active has scint
   Bool_t                          IsNull() const;  // default nonsense value?

   UShort_t                        NumberOfStrips() const; 

   enum EPlaneType {
      kScintOrSteel,
      kScint,
      kSteel
   };

   // methods for iteration over planes
   // (may be problematic transitioning shield sections)
   PlexPlaneId  GetNext(EPlaneType ptype=PlexPlaneId::kScintOrSteel,
                        PlaneView::PlaneView_t view=PlaneView::kUnknown,
                        PlaneCoverage::PlaneCoverage_t cover=PlaneCoverage::kUnknown) const;
   PlexPlaneId  GetPrevious(EPlaneType ptype=PlexPlaneId::kScintOrSteel,
                            PlaneView::PlaneView_t view=PlaneView::kUnknown,
                            PlaneCoverage::PlaneCoverage_t cover=PlaneCoverage::kUnknown) const;

   // GetAdjoin() returns Previous() if dir<0, otherwise Next()
   PlexPlaneId  GetAdjoin(Int_t dir, 
                          EPlaneType ptype=PlexPlaneId::kScintOrSteel,
                          PlaneView::PlaneView_t view=PlaneView::kUnknown,
                          PlaneCoverage::PlaneCoverage_t cover=PlaneCoverage::kUnknown) const;
   PlexPlaneId  GetAdjoinScint(Int_t dir,
                               PlaneView::PlaneView_t view=PlaneView::kUnknown,
                               PlaneCoverage::PlaneCoverage_t cover=PlaneCoverage::kUnknown) const;
   PlexPlaneId  GetAdjoinSteel(Int_t dir,
                               PlaneView::PlaneView_t view=PlaneView::kUnknown,
                               PlaneCoverage::PlaneCoverage_t cover=PlaneCoverage::kUnknown) const;

   UShort_t     GetNumStrips() const;
   UShort_t     GetNumScintMdls() const;

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

   void SetDetector(Detector::Detector_t detector);
   void SetPlane(UInt_t plane,
                 PlaneView::PlaneView_t view=PlaneView::kUnknown,
                 PlaneCoverage::PlaneCoverage_t cover=PlaneCoverage::kUnknown);

   void SetPlaneCoverage(PlaneCoverage::PlaneCoverage_t coverage);
   void SetPlaneView(PlaneView::PlaneView_t view);
   
   void SetIsSteel(Bool_t isSteel);

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

 protected:

   UInt_t   fEncoded;  // encoded value

 private:

   PlaneView::PlaneView_t
         DefaultPlaneView(Detector::Detector_t detector, UInt_t plane);

   PlaneCoverage::PlaneCoverage_t
         DefaultPlaneCoverage(Detector::Detector_t detector, UInt_t plane);

public:
                                                             // blank
   inline static UInt_t LastPlaneFarSM0()    { return 248; } //   0 + [  1-248]
   inline static UInt_t LastPlaneFarSM1()    { return 485; } // 249 + [250-485]
   inline static UInt_t LastPlaneNearCalor() { return 120; } //   0 + [  1-120]
   inline static UInt_t LastPlaneNearSpect() { return 281; } //       [121-281] by 5

   // ugly public members for handling weird geometries
   //static Bool_t fgFarIsUV;          // far detector is organized as UV or VU
   static Bool_t fgCalDetCosmicsAView; // either A or B view

   ClassDef(PlexPlaneId,4)
};

#ifndef __CINT__
//==========================================================================
// Implementation details 
//==========================================================================
//
// The details of the encoding of PlexPlaneId and PlexStripEndId
// are here in PlexPlaneId.h; this is so that the compiler can
// inline the code.  Users should NOT rely on intimate knowledge of
// these details.
//
//    MSB                          LSB
//     3         2         1         0
//    10987654321098765432109876543210
//    ddddppppppppppSvvvccssssssssxxee  PlexStripEndId
//    ddddppppppppppSvvvccmmmmmmmm----  PlexScintMdlId
//
// detector    dddd       0:15   (0=unknown,1=near,2=far,3=caldet,4=test)
// plane       pppppppppp 0:1023
// issteel     S          0:1    (0=active,1=steel)
// view        vvv        0:7    (X,Y,U,V,A,B,unknown)
// coverage    cc         0:3    (noact,nearpart,nearful,complete)
//                                unknown->complete
//                               (use high-order bit to get 4:11)
// module      mmmmmmmm   0:255
// strip       ssssssss   0:255
// subpart     xx         0:3    (unknown,-,+,whole)
// stripend    ee         0:3    (unknown,-,+,whole)
//
const UInt_t defaultPlexPlaneId    = 0xffffffff;
const UInt_t defaultPlexStripEndId = defaultPlexPlaneId;
const UInt_t defaultPlexScintMdlId = defaultPlexPlaneId;

const UInt_t maskPlexIdDetector     = 0x70000000;
const UInt_t shftPlexIdDetector     = 28;
const UInt_t maskPlexIdPlane        = 0x0FFC0000;
const UInt_t shftPlexIdPlane        = 18;
const UInt_t maskPlexIdIsSteel      = 0x00020000;
const UInt_t maskPlexIdView         = 0x0001C000;
const UInt_t shftPlexIdView         = 14;
const UInt_t bitsPlexIdView         = 3;
const UInt_t maskPlexIdCoverage     = 0x00003000;
const UInt_t shftPlexIdCoverage     = 12;
const UInt_t bitsPlexIdCoverage     = 2;
const UInt_t maskPlexIdStrip        = 0x00000FF0;
const UInt_t shftPlexIdStrip        = 4;
const UInt_t bitsPlexIdStrip        = 8; // used for Build18BitPlnStripKey
const UInt_t maskPlexIdScintMdl     = maskPlexIdStrip;
const UInt_t shftPlexIdScintMdl     = shftPlexIdStrip;
const UInt_t maskPlexIdSubPart      = 0x0000000C;
const UInt_t shftPlexIdSubPart      = 2;
const UInt_t maskPlexIdEnd          = 0x00000003;
const UInt_t shftPlexIdEnd          = 0;
           
const UInt_t zeroPlexIdStripInfo =
   ~(maskPlexIdStrip|maskPlexIdSubPart|maskPlexIdEnd);

// used to test if Far Detector Veto Shield'ness
// veto shield planes are all >= 512
const UInt_t maskPlexIdIsVetoShield = (512 << shftPlexIdPlane);
// each "section" of VetoShield is assigned a range of 64 plane #'s
const UInt_t shftPlexIdVetoSection = 6;
const UInt_t maskPlexIdIsFar =
   (Detector::kFar << shftPlexIdDetector);
const UInt_t setPlexIdVSView       = (1 << bitsPlexIdView);
const UInt_t setPlexIdVSCoverage   = (1 << bitsPlexIdCoverage);
const UInt_t setPlexIdVSCoverage2  = (setPlexIdVSCoverage << 1);
const UInt_t maskPlexIdVSCoverage2 = 0x80000000;

const UInt_t maskPlexIdIsNear =
   (Detector::kNear << shftPlexIdDetector);

//==========================================================================
//
// Be careful of order of inlines so as not to have one depend on
// another that comes later.
//
//==========================================================================

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

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

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

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

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

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

inline PlexPlaneId::PlexPlaneId() : fEncoded(defaultPlexPlaneId) { ; }
inline PlexPlaneId::PlexPlaneId(const UInt_t encoded) : fEncoded(encoded) { ; }

inline UInt_t PlexPlaneId::GetEncoded() const
{ return fEncoded & zeroPlexIdStripInfo; }

inline Detector::Detector_t PlexPlaneId::GetDetector() const
{ 
   Int_t bitField = ( fEncoded & maskPlexIdDetector ) >> shftPlexIdDetector;
   return (Detector::Detector_t) bitField;   
}

inline UShort_t PlexPlaneId::GetPlane() const
{
   return ( fEncoded & maskPlexIdPlane ) >> shftPlexIdPlane;
}

inline Bool_t PlexPlaneId::IsSteel() const
{
   //if (IsVetoShield()) return false;  // only if sharing steel bit
   return ( fEncoded & maskPlexIdIsSteel );
}

inline Bool_t PlexPlaneId::IsNull() const
{ 
  // test if plane # = all bits on as signal of invalid value
  return ( fEncoded & maskPlexIdPlane ) == maskPlexIdPlane;
}

inline Bool_t PlexPlaneId::IsVetoShield() const
{
   if ( IsNull() ) return false;
   switch (GetDetector()) {
   case Detector::kFar:
       return ( fEncoded & maskPlexIdIsVetoShield );
   case Detector::kCalDet:
       return ( GetPlane() > 60 );
   default:
       return false;
   }
}

inline Int_t PlexPlaneId::GetVetoSection() const
{
   // return section # (1,2,3,4) or 0 if not part of VetoShield
   if ( ! IsVetoShield() ) return 0;
   if ( Detector::kCalDet == GetDetector() ) return 1;
   UShort_t plane = GetPlane();
   return ( ( ( plane >> shftPlexIdVetoSection ) & 0x03 ) + 1  );
}

inline Int_t PlexPlaneId::GetSuperModule() const
{
   // return supermodule # (0,1 if Far, else 0)
   if ( ! ( fEncoded & maskPlexIdIsFar ) ) return  0;
   UShort_t plane = GetPlane();
   if      ( plane <= LastPlaneFarSM0() )  return  0;
   else if ( plane <= LastPlaneFarSM1() )  return  1;
   else                                    return -1;
}

inline Bool_t PlexPlaneId::IsNearSpect() const
{
   // return true if part of NearDet spectrometer region
   if ( ! ( fEncoded & maskPlexIdIsNear ) ) return false;
   UShort_t plane = GetPlane();
   return ( plane > LastPlaneNearCalor() );
}

inline PlaneCoverage::PlaneCoverage_t PlexPlaneId::GetPlaneCoverage() const
{
   Int_t bitField = ( fEncoded & maskPlexIdCoverage ) >> shftPlexIdCoverage;
   if (GetDetector()==Detector::kFar && IsVetoShield()) {
     if ( fEncoded & maskPlexIdVSCoverage2 ) bitField |= setPlexIdVSCoverage2;
     else                                    bitField |= setPlexIdVSCoverage;
   }
   return (PlaneCoverage::PlaneCoverage_t) bitField;
}

inline PlaneView::PlaneView_t PlexPlaneId::GetPlaneView() const
{
   Int_t bitField = ( fEncoded & maskPlexIdView ) >> shftPlexIdView;
   if (GetDetector()==Detector::kFar && IsVetoShield()) 
     bitField |= setPlexIdVSView;
   return (PlaneView::PlaneView_t) bitField;
}

inline void PlexPlaneId::SetDetector(Detector::Detector_t detector)
{
   fEncoded = ( fEncoded & ~maskPlexIdDetector ) | 
      ( ( detector << shftPlexIdDetector ) & maskPlexIdDetector );
}

inline void PlexPlaneId::SetIsSteel(Bool_t isSteel)
{
  if (isSteel) fEncoded |=  maskPlexIdIsSteel;
  else         fEncoded &= ~maskPlexIdIsSteel;
}

inline void PlexPlaneId::SetPlaneCoverage(PlaneCoverage::PlaneCoverage_t coverage)
{
   fEncoded = ( fEncoded & ~(maskPlexIdCoverage|maskPlexIdVSCoverage2) ) | 
      ( ( coverage << shftPlexIdCoverage ) & maskPlexIdCoverage );
   // set extra bit for higher VetoShield enum values
   if ( coverage >= PlaneCoverage::kVScS ) fEncoded |= maskPlexIdVSCoverage2;
}

inline void PlexPlaneId::SetPlaneView(PlaneView::PlaneView_t view)
{
   fEncoded = ( fEncoded & ~maskPlexIdView ) | 
      ( ( view << shftPlexIdView ) & maskPlexIdView );
}

inline PlexPlaneId 
  PlexPlaneId::GetAdjoin(Int_t dir, EPlaneType ptype,
                         PlaneView::PlaneView_t view,
                         PlaneCoverage::PlaneCoverage_t cover) const
{
  return (dir<0) ? GetPrevious(ptype,view,cover) : GetNext(ptype,view,cover); 
}

inline PlexPlaneId 
  PlexPlaneId::GetAdjoinScint(Int_t dir,
                              PlaneView::PlaneView_t view,
                              PlaneCoverage::PlaneCoverage_t cover) const
{ return GetAdjoin(dir,PlexPlaneId::kScint,view,cover); }

inline PlexPlaneId 
  PlexPlaneId::GetAdjoinSteel(Int_t dir,
                              PlaneView::PlaneView_t view,
                              PlaneCoverage::PlaneCoverage_t cover) const
{ return GetAdjoin(dir,PlexPlaneId::kSteel,view,cover); }

#endif /* __CINT__ */
#endif // PLEXPLANEID_H

---