Plexus.h

Go to the documentation of this file.

// $Id: Plexus.h,v 1.36 2007/04/26 14:22:46 west Exp $
//
// Plexus
//
// Plexus is an actual connection map
//
// Author:  R. Hatcher 2000.05.03
//

#ifndef PLEXUS_H
#define PLEXUS_H

#include "Plex/PlexusABC.h"

#include <map>

class DbiValidityRec;

class Plexus : public PlexusABC {

   friend class PlexLoanPool;  // only the loan pool can create/delete one

 public:

   // 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 
                               { return fSpecialDescript; }

   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 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 { return fVldRange; }

   void           IncrementRef() { fRef++; }
   void           DecrementRef() { fRef--; }
   Int_t          CountRef() const { return fRef; }

   void           Print(Option_t *option) const;

   Bool_t         IsCompatible(const VldContext& vldc);
   Bool_t         IsCompatible(const VldContext* vldc);

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

#ifdef PLEX_EXPOSE_STRUCTURES
   // const access to maps ... should not be needed by average users
   const std::multimap<RawChannelId,PlexPixelSpotId>& GetRawChannelIdToPixelSpotId() const { return fChannelToPixel; }
   const std::multimap<PlexPixelSpotId,PlexStripEndId>& GetPixelSpotIdToStripEndId() const { return fPixelToStripEnd; }
   const std::map<PlexStripEndId,PlexPixelSpotId>& GetStripEndIdToPixelSpotId() const { return fStripEndToSpot; }
   const std::map<PlexPixelSpotId,RawChannelId>& GetPixelSpotIdToRawChannelId() const { return fPixelToChannel; }
#endif

 public:

   // to make this i/o-able we need a public default ctor
   Plexus();

   // make these public so that one can selectively purge before saving
   typedef enum EMapSets {
     kPixelMaps      = 0x0001,
     kReadoutMap     = 0x0002,
     kPinDiodeMap    = 0x0004,
     kLedMaps        = 0x0008,
     kAllVectors     = 0x0010
   } MapSets_t;

 protected:

   Plexus(const VldContext& vldc);
   virtual ~Plexus();

   // logically const functions
   virtual void BuildPixelMaps(const VldContext& vldc) const;
   virtual void BuildReadoutMap(const VldContext& vldc) const;
   virtual void BuildPinDiodeMap(const VldContext& vldc) const;
   virtual void BuildLedMaps(const VldContext& vldc) const;

   virtual void PurgeComponents(UInt_t purgeMask);

   void TrimVldRange(const char* tblName="", const DbiValidityRec* dbivrec=0) const;

   typedef enum ETrimSpots {
     kIncludeSpot, 
     kIncludePixel, 
     kIncludeTube 
   } TrimSpots_t;
   
   // one workhorse routine for GetAllPixelSpots,GetAllPixels,GetAllTubes
   virtual const std::vector<PlexPixelSpotId>& 
     GetAllPixelSpotIds(ETrimSpots trim) const;


   mutable Int_t       fRef;           
   mutable VldRange    fVldRange;      // tagging parameter set
   mutable UInt_t      fBuiltMaps;     // components that have been initialized

   // mappings that go through PlexPixelSpotId
   // "mutable" so that methods can be const

   mutable std::multimap<RawChannelId,PlexPixelSpotId>    fChannelToPixel;
   mutable std::multimap<PlexPixelSpotId,PlexStripEndId>  fPixelToStripEnd;

   mutable std::map<PlexStripEndId,PlexPixelSpotId>       fStripEndToSpot;
   mutable std::map<PlexPixelSpotId,RawChannelId>         fPixelToChannel;

   // ideally this mapping would be to ReadoutType::Readout_t
   // but cint can't correctly i/o enum as as second type of map 
   // so use UShort_t (must be > 8 bits to correctly hold all Readout_t values)
   mutable std::map<RawChannelId,UShort_t>                fChannelToReadout;

   mutable std::map<RawChannelId,std::string>             fSpecialDescript;

   mutable std::map<RawChannelId,PlexPinDiodeId>          fChannelToPinDiode;

   mutable std::map<PlexStripEndId,PlexLedId>             fStripEndToLed;
   mutable std::map<PlexPinDiodeId,PlexLedId>             fPinDiodeToLed;

   // the following vectors get filled as necessary from the above maps

   mutable std::vector<PlexStripEndId>                    fAllStripEnds; 
   mutable std::vector<PlexStripEndId>                    fAllEastEnds;  
   mutable std::vector<PlexStripEndId>                    fAllWestEnds;  
   mutable std::vector<PlexStripEndId>                    fAllStrips;    

   mutable std::vector<PlexPixelSpotId>                   fAllTubes;     
   mutable std::vector<PlexPixelSpotId>                   fAllPixels;    
   mutable std::vector<PlexPixelSpotId>                   fAllSpots;     

   mutable std::vector<RawChannelId>                      fAllChannels;  

   mutable std::vector<PlexPinDiodeId>                    fAllPinDiodes; 
   mutable std::vector<PlexLedId>                         fAllLeds;      

 public:

   static void   SetAltLHasBrokenFibers(Bool_t tf) 
     { fgAltLHasBrokenFibers = tf; }
   static Bool_t GetAltLHasBrokenFibers() 
     { return fgAltLHasBrokenFibers; }
   static void   SetAltLInitiallySortedBySEId(Bool_t tf)
     { fgAltLInitiallySortedBySEId = tf; }
   static Bool_t GetAltLInitiallySortedBySEId() 
     { return fgAltLInitiallySortedBySEId; }

 protected:
   // compatibility mode
   static Bool_t fgAltLHasBrokenFibers; // SEIdAltLs will include broken fibers
   static Bool_t fgAltLInitiallySortedBySEId; // sort SEIdAltLs before they have weights
 private:

   ClassDef(Plexus,3) // map between logical components

};

inline const std::vector<PlexPixelSpotId>&
Plexus::GetAllPixelSpots() const
{ return this->GetAllPixelSpotIds(Plexus::kIncludeSpot); }

inline const std::vector<PlexPixelSpotId>&
Plexus::GetAllPixels() const
{ return this->GetAllPixelSpotIds(Plexus::kIncludePixel); }

inline const std::vector<PlexPixelSpotId>&
Plexus::GetAllTubes() const
{ return this->GetAllPixelSpotIds(Plexus::kIncludeTube); }

#endif // PLEXUS_H

---