PlexHandle.h

Go to the documentation of this file.

// $Id: PlexHandle.h,v 1.24 2005/06/29 23:21:11 rhatcher Exp $
//
// PlexHandle
//
// PlexHandle is a handle for a Plexus
//
// Author:  R. Hatcher 2000.05.03
//

#ifndef PLEXHANDLE_H
#define PLEXHANDLE_H

#include "TObject.h"

#include "Plex/PlexusABC.h"
#include "Plex/Plexus.h"

class Plexus;

class PlexHandle : public PlexusABC {

 public:

   PlexHandle(const VldContext& vldc, Bool_t shared = kTRUE );
   PlexHandle(const PlexHandle& ph);
   virtual ~PlexHandle();

   PlexHandle& operator=(const PlexHandle& ph);

   // these are the normal methods
   virtual RawChannelId     GetRawChannelId(const PlexStripEndId& seid) const;
   virtual RawChannelId     GetRawChannelId(const PlexPixelSpotId& psid) const;
   virtual RawChannelId     GetRawChannelId(const PlexPinDiodeId& diodeid) const;

   virtual PlexSEIdAltL     GetSEIdAltL(const RawChannelId& rcid,
                                        const PlexCalib* calib=0,
                                        Int_t adc=0, Double_t time=0) const;
   virtual PlexStripEndId   GetStripEndId(const PlexPixelSpotId& psid) const;

   virtual std::vector<PlexPixelSpotId>  
                            GetPixelSpotIdVector(const RawChannelId& rcid,
                                                 bool uniquePixels=false) const;
   virtual PlexPixelSpotId  GetPixelSpotId(const PlexStripEndId& seid) const;

   virtual PlexPinDiodeId   GetPinDiodeId(const RawChannelId& rcid) const;

   virtual ReadoutType::Readout_t 
                            GetReadoutType(const RawChannelId& rcid) const;
   virtual std::string      GetSpecialDescript(const RawChannelId& rcid) const;
   virtual RawChannelId     GetSpecialChannelContains(const std::string& key) const;
   virtual const std::map<RawChannelId,std::string>&
                            GetSpecialDescriptMap() const;

   virtual std::vector<PlexStripEndId>   
                            GetStripEndIdVector(const PlexLedId& ledid) const;
   virtual std::pair<PlexPinDiodeId,PlexPinDiodeId> 
                            GetPinDiodeIds(const PlexLedId& ledid) const;
   virtual PlexLedId        GetLedId(const PlexStripEndId& seid) const;
   virtual PlexLedId        GetLedId(const PlexPinDiodeId& diodeid) const;

   virtual RawChannelId     GetTpmtFromLedPulserBox(Int_t ipb) const;
   virtual Int_t            GetLedPulserBoxFromTpmt(const RawChannelId& rcid) const;

   // get gobs of info without exposing data structures
   
   virtual const std::vector<PlexStripEndId>& GetAllStrips() const;
   virtual const std::vector<PlexStripEndId>&
      GetAllStripEnds(StripEnd::StripEnd_t restrictEnd =
                                StripEnd::kUnknown) const;

   virtual const std::vector<PlexPixelSpotId>& GetAllPixelSpots() const;
   virtual const std::vector<PlexPixelSpotId>& GetAllPixels() const;
   virtual const std::vector<PlexPixelSpotId>& GetAllTubes() const;

   virtual const std::vector<RawChannelId>& GetAllRawChannelIds() const;

   virtual const std::vector<PlexPinDiodeId>& GetAllPinDiodes() const;
   virtual const std::vector<PlexLedId>& GetAllLeds() const;

   virtual const VldRange&  GetVldRange() const;

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

   // test maps for consistency
   virtual void             ValidateConsistency() const;

#ifdef PLEX_EXPOSE_STRUCTURES
   // const access to maps ... should not be needed by average users
   // actual format of the data is subject to change and thus users
   // should not rely on these access methods!!!
   const std::multimap<RawChannelId,PlexPixelSpotId>& GetRawChannelIdToPixelSpotId() const;
   const std::multimap<PlexPixelSpotId,PlexStripEndId>& GetPixelSpotIdToStripEndId() const;
   const std::map<PlexStripEndId,PlexPixelSpotId>& GetStripEndIdToPixelSpotId() const;
   const std::map<PlexPixelSpotId,RawChannelId>& GetPixelSpotIdToRawChannelId() const;
#endif

 protected:

 private:
   // Avoid creating PlexHandle without a Validity object
   PlexHandle();                      

   void Copy(PlexHandle& ph) const;
   void Copy(TObject& object) const;

   // data members
   Plexus *fPlexus;

   ClassDef(PlexHandle,1)  // PlexHandle version 1
};

#ifndef __CINT__
//=============================================================================
// Implementation details -- inlines need to be hidden from CINT
//=============================================================================

// Normal methods that just use the underlying Plexus
// inlining these would require #include "Plexus" to be in 
// the PlexHandle.h which means any changes to the guts of
// Plexus then trigger re-compilation.  Plexus is now stable enough
// that this should not be a concern.

inline 
RawChannelId
PlexHandle::GetRawChannelId(const PlexStripEndId& seid) const
{ return fPlexus->GetRawChannelId(seid); }

inline 
RawChannelId
PlexHandle::GetRawChannelId(const PlexPixelSpotId& psid) const
{ return fPlexus->GetRawChannelId(psid); }

inline 
RawChannelId
PlexHandle::GetRawChannelId(const PlexPinDiodeId& diodeid) const
{ return fPlexus->GetRawChannelId(diodeid); }

inline 
PlexSEIdAltL   
PlexHandle::GetSEIdAltL(const RawChannelId& rcid,
                        const PlexCalib* calib,
                        Int_t adc, Double_t time) const
{ return fPlexus->GetSEIdAltL(rcid,calib,adc,time); }

inline 
PlexStripEndId 
PlexHandle::GetStripEndId(const PlexPixelSpotId& psid) const
{ return fPlexus->GetStripEndId(psid); }

inline 
std::vector<PlexPixelSpotId>  
PlexHandle::GetPixelSpotIdVector(const RawChannelId& rcid, bool uniquePixels) const
{ return fPlexus->GetPixelSpotIdVector(rcid,uniquePixels); }

inline 
PlexPixelSpotId  
PlexHandle::GetPixelSpotId(const PlexStripEndId& seid) const
{ return fPlexus->GetPixelSpotId(seid); }

inline 
PlexPinDiodeId 
PlexHandle::GetPinDiodeId(const RawChannelId& rcid) const
{ return fPlexus->GetPinDiodeId(rcid); }

inline 
ReadoutType::Readout_t 
PlexHandle::GetReadoutType(const RawChannelId& rcid) const
{ return fPlexus->GetReadoutType(rcid); }

inline 
std::string 
PlexHandle::GetSpecialDescript(const RawChannelId& rcid) const
{ return fPlexus->GetSpecialDescript(rcid); }

inline 
RawChannelId 
PlexHandle::GetSpecialChannelContains(const std::string& key) const
{ return fPlexus->GetSpecialChannelContains(key); }

inline 
const std::map<RawChannelId,std::string>&
PlexHandle::GetSpecialDescriptMap() const
{ return fPlexus->GetSpecialDescriptMap(); } 

inline 
std::vector<PlexStripEndId> 
PlexHandle::GetStripEndIdVector(const PlexLedId& ledid) const
{ return fPlexus->GetStripEndIdVector(ledid); }

inline 
std::pair<PlexPinDiodeId,PlexPinDiodeId> 
PlexHandle::GetPinDiodeIds(const PlexLedId& ledid) const
{ return fPlexus->GetPinDiodeIds(ledid); }

inline 
PlexLedId
PlexHandle::GetLedId(const PlexStripEndId& seid) const
{ return fPlexus->GetLedId(seid); }

inline 
PlexLedId
PlexHandle::GetLedId(const PlexPinDiodeId& diodeid) const
{ return fPlexus->GetLedId(diodeid); }

inline 
const std::vector<PlexStripEndId>& 
PlexHandle::GetAllStrips() const
{ return fPlexus->GetAllStripEnds(StripEnd::kWhole); }

inline 
const std::vector<PlexStripEndId>& 
PlexHandle::GetAllStripEnds(StripEnd::StripEnd_t restrictEnd) const
{ return fPlexus->GetAllStripEnds(restrictEnd); }

inline 
const std::vector<PlexPixelSpotId>&
PlexHandle::GetAllPixelSpots() const
{ return fPlexus->GetAllPixelSpots(); }

inline 
const std::vector<PlexPixelSpotId>&
PlexHandle::GetAllPixels() const
{ return fPlexus->GetAllPixels(); }

inline 
const std::vector<PlexPixelSpotId>&
PlexHandle::GetAllTubes() const
{ return fPlexus->GetAllTubes(); }

inline 
const std::vector<RawChannelId>&
PlexHandle::GetAllRawChannelIds() const
{ return fPlexus->GetAllRawChannelIds(); }

inline 
const std::vector<PlexPinDiodeId>&
PlexHandle::GetAllPinDiodes() const
{ return fPlexus->GetAllPinDiodes(); }

inline 
const std::vector<PlexLedId>&
PlexHandle::GetAllLeds() const
{ return fPlexus->GetAllLeds(); }

inline 
const VldRange& 
PlexHandle::GetVldRange() const
{ return fPlexus->GetVldRange(); }

inline 
void 
PlexHandle::Print(Option_t *option) const
{ fPlexus->Print(option); }

inline 
void 
PlexHandle::ValidateConsistency() const
{ fPlexus->ValidateConsistency(); }

#endif /* __CINT__ */
#endif // PLEXHANDLE_H

---