Plexus Class Reference

#include <Plexus.h>

Inheritance diagram for Plexus:

List of all members.

Public Types
typedef enum Plexus::EMapSets	MapSets_t
enum	EMapSets {   kPixelMaps = 0x0001, kReadoutMap = 0x0002, kPinDiodeMap = 0x0004, kLedMaps = 0x0008,   kAllVectors = 0x0010 }
Public Member Functions
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 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	IncrementRef ()
void	DecrementRef ()
Int_t	CountRef () const
void	Print (Option_t *option) const
Bool_t	IsCompatible (const VldContext &vldc)
Bool_t	IsCompatible (const VldContext *vldc)
virtual void	ValidateConsistency () const
	Plexus ()
Static Public Member Functions
void	SetAltLHasBrokenFibers (Bool_t tf)
Bool_t	GetAltLHasBrokenFibers ()
void	SetAltLInitiallySortedBySEId (Bool_t tf)
Bool_t	GetAltLInitiallySortedBySEId ()
Protected Types
typedef enum Plexus::ETrimSpots	TrimSpots_t
enum	ETrimSpots { kIncludeSpot, kIncludePixel, kIncludeTube }
Protected Member Functions
	Plexus (const VldContext &vldc)
virtual	~Plexus ()
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
virtual const std::vector< PlexPixelSpotId > &	GetAllPixelSpotIds (ETrimSpots trim) const
Protected Attributes
Int_t	fRef
VldRange	fVldRange
	outstanding handles
UInt_t	fBuiltMaps
std::multimap< RawChannelId, PlexPixelSpotId >	fChannelToPixel
std::multimap< PlexPixelSpotId, PlexStripEndId >	fPixelToStripEnd
std::map< PlexStripEndId, PlexPixelSpotId >	fStripEndToSpot
std::map< PlexPixelSpotId, RawChannelId >	fPixelToChannel
std::map< RawChannelId, UShort_t >	fChannelToReadout
std::map< RawChannelId, std::string >	fSpecialDescript
std::map< RawChannelId, PlexPinDiodeId >	fChannelToPinDiode
std::map< PlexStripEndId, PlexLedId >	fStripEndToLed
std::map< PlexPinDiodeId, PlexLedId >	fPinDiodeToLed
std::vector< PlexStripEndId >	fAllStripEnds
std::vector< PlexStripEndId >	fAllEastEnds
std::vector< PlexStripEndId >	fAllWestEnds
std::vector< PlexStripEndId >	fAllStrips
std::vector< PlexPixelSpotId >	fAllTubes
std::vector< PlexPixelSpotId >	fAllPixels
std::vector< PlexPixelSpotId >	fAllSpots
std::vector< RawChannelId >	fAllChannels
std::vector< PlexPinDiodeId >	fAllPinDiodes
std::vector< PlexLedId >	fAllLeds
Static Protected Attributes
Bool_t	fgAltLHasBrokenFibers = false
Bool_t	fgAltLInitiallySortedBySEId = false
Friends
class	PlexLoanPool

---

Member Typedef Documentation

typedef enum Plexus::EMapSets Plexus::MapSets_t

typedef enum Plexus::ETrimSpots Plexus::TrimSpots_t [protected]

---

Member Enumeration Documentation

enum Plexus::EMapSets

Enumeration values: kPixelMaps  kReadoutMap  kPinDiodeMap  kLedMaps  kAllVectors  Definition at line 101 of file Plexus.h. { kPixelMaps = 0x0001, kReadoutMap = 0x0002, kPinDiodeMap = 0x0004, kLedMaps = 0x0008, kAllVectors = 0x0010 } MapSets_t;

enum Plexus::ETrimSpots [protected]

Enumeration values: kIncludeSpot  kIncludePixel  kIncludeTube  Definition at line 124 of file Plexus.h. { kIncludeSpot, kIncludePixel, kIncludeTube } TrimSpots_t;

---

Constructor & Destructor Documentation

Plexus::Plexus (   )

Definition at line 59 of file Plexus.cxx. References MSG. Referenced by PlexLoanPool::BuildPlexus(). : fRef(0), fVldRange(), fBuiltMaps(0) { // Default constructor MSG("Plex",Msg::kVerbose) << "default ctor " << endl; }

Plexus::Plexus (  const VldContext &  vldc  )  [protected]

Definition at line 67 of file Plexus.cxx. References BuildLedMaps(), BuildPinDiodeMap(), BuildPixelMaps(), BuildReadoutMap(), fVldRange, Registry::Get(), CfgConfigurable::GetConfig(), VldContext::GetDetector(), PlexLoanPool::Instance(), MSG, and paranoia. : fRef(0), fBuiltMaps(0) { // normal constructor MSG("Plex",Msg::kVerbose) << "Plexus(vldc) ctor " << endl; const Int_t mostbits = 0x7fffffff; const VldTimeStamp longago = VldTimeStamp((time_t)0,0); const VldTimeStamp forevermore = VldTimeStamp((time_t)mostbits,999999999); fVldRange = VldRange(mostbits,mostbits,longago,forevermore,""); const Registry& config = PlexLoanPool::Instance()->GetConfig(); config.Get("Paranoia",paranoia); if (paranoia) { MSG("Plex",Msg::kInfo) << "Plexus(vldc) paranoia level " << paranoia << endl; } // prime veto shield converter table so that // DBI accounting for PlexPixelSpotToStripEnd is correctly attributed. if (vldc.GetDetector() == Detector::kFar) { MSG("Plex",Msg::kDebug) << "Plexus(vldc) ctor - mux2mdl " << vldc << endl; DbiResultPtr<PlexVetoShieldMuxToMdl> mux2mdl(vldc); } BuildPixelMaps(vldc); BuildPinDiodeMap(vldc); // do Readout Map *after* we know ScintStrips and PinDiodes BuildReadoutMap(vldc); BuildLedMaps(vldc); }

Plexus::~Plexus (   )  [protected, virtual]

Definition at line 102 of file Plexus.cxx. { // delete all the owned sub-objects }

---

Member Function Documentation

void Plexus::BuildLedMaps (  const VldContext &  vldc  )  const [protected, virtual]

Definition at line 1057 of file Plexus.cxx. References PlexStripEndId::AsString(), PlexLedId::AsString(), PlexPinDiodeId::AsString(), fBuiltMaps, fPinDiodeToLed, fStripEndToLed, DbiTableProxy::GetCache(), DbiResultPtr< T >::GetNumRows(), PlexPlaneId::GetPlane(), PlexStripEndToLed::GetPlexLedId(), PlexPinDiodeToLed::GetPlexLedId(), PlexPinDiodeToLed::GetPlexPinDiodeId(), PlexStripEndToLed::GetPlexStripEndId(), DbiResultPtr< T >::GetRow(), DbiResultPtr< T >::GetValidityRec(), PlexLoanPool::Instance(), kLedMaps, MSG, paranoia, DbiCache::Purge(), PlexLoanPool::PurgeDbiTableCache(), DbiResultPtr< T >::TableProxy(), and TrimVldRange(). Referenced by Plexus(). { // build the basic map: StripEndIds <--> LED <--> PinDiodes if (kLedMaps & fBuiltMaps) return; fBuiltMaps |= kLedMaps; DbiCache* pd2ledTblCache = 0; DbiCache* se2ledTblCache = 0; { // start of inner scope to that DbiResultPtr's will die, die, die // and thus Purge will see no remaining clients DbiResultPtr<PlexPinDiodeToLed> pd2ledResPtr(vldc); DbiResultPtr<PlexStripEndToLed> se2ledResPtr(vldc); // update the fVldRange TrimVldRange("PlexPinDiodeToLed",pd2ledResPtr.GetValidityRec()); TrimVldRange("PlexStripEndToLed",se2ledResPtr.GetValidityRec()); // get a handle for the cache pd2ledTblCache = pd2ledResPtr.TableProxy().GetCache(); se2ledTblCache = se2ledResPtr.TableProxy().GetCache(); // build the map: PinDiode --> Led for (UInt_t irow = 0; irow < pd2ledResPtr.GetNumRows(); ++irow) { const PlexPinDiodeToLed* pd2led = pd2ledResPtr.GetRow(irow); PlexPinDiodeId pinid = pd2led->GetPlexPinDiodeId(); PlexLedId ledid = pd2led->GetPlexLedId(); if ( ! paranoia ) { fPinDiodeToLed[pinid] = ledid; } else { if ( fPinDiodeToLed.find(pinid) == fPinDiodeToLed.end() ) { fPinDiodeToLed[pinid] = ledid; } else { MSG("Plex",Msg::kInfo) << "BuildLedMaps PinDiode " << pinid.AsString("c") << " to Led " << fPinDiodeToLed[pinid].AsString("c") << ", new Led " << ledid.AsString("c") << endl; } } } // build the map: StripEnd --> Led for (UInt_t irow = 0; irow < se2ledResPtr.GetNumRows(); ++irow) { const PlexStripEndToLed* se2led = se2ledResPtr.GetRow(irow); PlexStripEndId seid = se2led->GetPlexStripEndId(); PlexLedId ledid = se2led->GetPlexLedId(); if ( ! paranoia ) { fStripEndToLed[seid] = ledid; } else { if ( fStripEndToLed.find(seid) == fStripEndToLed.end() ) { fStripEndToLed[seid] = ledid; } else { if ( paranoia > 1 || seid.GetPlane() != 1023 ) MSG("Plex",Msg::kInfo) << "BuildLedMaps StripEnd " << seid.AsString("c") << " to Led " << fStripEndToLed[seid].AsString("c") << ", new Led " << ledid.AsString("c") << endl; } } } } if ( PlexLoanPool::Instance()->PurgeDbiTableCache() ) { // now there should be no active clients so it should be // possible to purge to our heart's content if (pd2ledTblCache) pd2ledTblCache->Purge(); if (se2ledTblCache) se2ledTblCache->Purge(); } return; }

void Plexus::BuildPinDiodeMap (  const VldContext &  vldc  )  const [protected, virtual]

Reimplemented in PlexusReroot. Definition at line 975 of file Plexus.cxx. References RawChannelId::AsString(), PlexPinDiodeId::AsString(), RawChannelId::ClearModeBits(), fBuiltMaps, fChannelToPinDiode, DbiTableProxy::GetCache(), DbiResultPtr< T >::GetNumRows(), PlexRawChannelToPinDiode::GetPlexPinDiodeId(), GetRawChannelId(), PlexRawChannelToPinDiode::GetRawChannelId(), DbiResultPtr< T >::GetRow(), DbiResultPtr< T >::GetValidityRec(), PlexLoanPool::Instance(), kPinDiodeMap, MSG, DbiCache::Purge(), PlexLoanPool::PurgeDbiTableCache(), DbiResultPtr< T >::TableProxy(), and TrimVldRange(). Referenced by BuildReadoutMap(), and Plexus(). { // build the basic map: RawChannel --> PinDiode if (kPinDiodeMap & fBuiltMaps) return; fBuiltMaps |= kPinDiodeMap; DbiCache* rc2pdTblCache = 0; { // start of inner scope to that DbiResultPtr's will die, die, die // and thus Purge will see no remaining clients DbiResultPtr<PlexRawChannelToPinDiode> rc2pdResPtr(vldc); // update the fVldRange TrimVldRange("PlexRawChannelToPinDiode",rc2pdResPtr.GetValidityRec()); // get a handle for the cache rc2pdTblCache = rc2pdResPtr.TableProxy().GetCache(); std::set<PlexPinDiodeId> pins_seen; // local temp for paranoia checking // build the map: RawChannel --> PinDiode for (UInt_t irow = 0; irow < rc2pdResPtr.GetNumRows(); ++irow) { const PlexRawChannelToPinDiode* rc2pd = rc2pdResPtr.GetRow(irow); RawChannelId rcid = rc2pd->GetRawChannelId(); PlexPinDiodeId pinid = rc2pd->GetPlexPinDiodeId(); // the map has the {pedestal,spars,common} mode bits off rcid.ClearModeBits(); // if ( ! paranoia ) { fChannelToPinDiode[rcid] = pinid; } else { if ( fChannelToPinDiode.find(rcid) == fChannelToPinDiode.end() ) { if ( pins_seen.find(pinid) == pins_seen.end() ) { fChannelToPinDiode[rcid] = pinid; pins_seen.insert(pinid); } else { RawChannelId rcid_already = GetRawChannelId(pinid); MSG("Plex",Msg::kInfo) << "BuildPinDiodeMap PinDiode " << pinid.AsString("c") << endl << " attached to RawChannel " << rcid_already.AsString("ec") << endl << " new RawChannel entry " << rcid.AsString("ec") << endl; } } else { MSG("Plex",Msg::kInfo) << "BuildPinDiodeMap RawChannelId " << rcid.AsString("ec") << endl << " attached to PinDiode " << fChannelToPinDiode[rcid].AsString("c") << endl << " new PinDiode entry " << pinid.AsString("c") << endl; } } } } if ( PlexLoanPool::Instance()->PurgeDbiTableCache() ) { // now there should be no active clients so it should be // possible to purge to our heart's content if (rc2pdTblCache) rc2pdTblCache->Purge(); } return; }

void Plexus::BuildPixelMaps (  const VldContext &  vldc  )  const [protected, virtual]

Reimplemented in PlexusReroot. Definition at line 781 of file Plexus.cxx. References RawChannelId::AsString(), PlexPixelSpotId::AsString(), PlexStripEndId::AsString(), RawChannelId::ClearModeBits(), fBuiltMaps, fChannelToPixel, fPixelToChannel, fPixelToStripEnd, fStripEndToSpot, DbiTableProxy::GetCache(), DbiResultPtr< T >::GetNumRows(), PlexPlaneId::GetPlane(), PlexPixelToRawChannel::GetPlexPixelSpotId(), PlexPixelSpotToStripEnd::GetPlexPixelSpotId(), PlexPixelSpotToStripEnd::GetPlexStripEndId(), PlexPixelToRawChannel::GetRawChannelId(), DbiResultPtr< T >::GetRow(), DbiResultPtr< T >::GetValidityRec(), PlexLoanPool::Instance(), kPixelMaps, MSG, paranoia, DbiCache::Purge(), PlexLoanPool::PurgeDbiTableCache(), PlexPixelSpotId::SetSpot(), DbiResultPtr< T >::TableProxy(), and TrimVldRange(). Referenced by BuildReadoutMap(), and Plexus(). { // build the basic maps RawChannel <--> PixelSpot <--> StripEnd if (kPixelMaps & fBuiltMaps) return; fBuiltMaps |= kPixelMaps; DbiCache* pstoseTblCache = 0; DbiCache* ptorcTblCache = 0; { // start of inner scope to that DbiResultPtr's will die, die, die // and thus Purge will see no remaining clients DbiResultPtr<PlexPixelSpotToStripEnd> pstoseResPtr(vldc); DbiResultPtr<PlexPixelToRawChannel> ptorcResPtr(vldc); // update the fVldRange TrimVldRange("PlexPixelSpotToStripEnd",pstoseResPtr.GetValidityRec()); TrimVldRange("PlexPixelToRawChannel",ptorcResPtr.GetValidityRec()); // get a handle for the caches pstoseTblCache = pstoseResPtr.TableProxy().GetCache(); ptorcTblCache = ptorcResPtr.TableProxy().GetCache(); // how many rows did we get? UInt_t npstose = pstoseResPtr.GetNumRows(); UInt_t nptorc = ptorcResPtr.GetNumRows(); // complain bitterly if either is zero // this is indicative of a serious database problem if (npstose == 0) MSG("Plex",Msg::kFatal) << "No entries retrieved from PlexPixelSpotToStripEnd table." << endl; if (nptorc == 0) MSG("Plex",Msg::kFatal) << "No entries retrieved from PlexPixelToRawChannel table." << endl; // build the maps: PixelSpot <--> StripEnd for (UInt_t irow = 0; irow < npstose; ++irow) { const PlexPixelSpotToStripEnd* pstose = pstoseResPtr.GetRow(irow); PlexPixelSpotId spotid = pstose->GetPlexPixelSpotId(); PlexStripEndId seid = pstose->GetPlexStripEndId(); bool isokay_pstose = true; if ( paranoia ) { if ( fStripEndToSpot.find(seid) != fStripEndToSpot.end() ) { isokay_pstose = false; if ( paranoia > 1 || seid.GetPlane() != 1023 ) MSG("Plex",Msg::kInfo) << "BuildPixelMaps StripEnd " << seid.AsString("c") << endl << " attached to PixelSpot " << fStripEndToSpot[seid].AsString("c") << endl << " new PixelSpot entry " << spotid.AsString("c") << endl; } } if (isokay_pstose) { fStripEndToSpot[seid] = spotid; // for multimap sake throw away the "spot" info in this direction PlexPixelSpotId pixelid = spotid; pixelid.SetSpot(0); fPixelToStripEnd.insert(make_pair(pixelid,seid)); } } // build the maps: PixelSpot <--> RawChannel for (UInt_t irow = 0; irow < nptorc; ++irow) { const PlexPixelToRawChannel* ptorc = ptorcResPtr.GetRow(irow); PlexPixelSpotId pixelid = ptorc->GetPlexPixelSpotId(); RawChannelId rcid = ptorc->GetRawChannelId(); // the map has the {pedestal,spars,common} mode bits off rcid.ClearModeBits(); // ensure that pixelid doesn't have "spot" field filled // in either direction pixelid.SetSpot(0); bool isokay_ptorc = true; if ( paranoia ) { if ( fPixelToChannel.find(pixelid) != fPixelToChannel.end() ) { isokay_ptorc = false; MSG("Plex",Msg::kInfo) << "BuildPixelMaps Pixel " << pixelid.AsString("p") << endl << " attached to RawChannel " << fPixelToChannel[pixelid].AsString("ec") << endl << " new RawChannel entry " << rcid.AsString("ec") << endl; } } if (isokay_ptorc) { fPixelToChannel[pixelid] = rcid; fChannelToPixel.insert(make_pair(rcid,pixelid)); } } } if ( PlexLoanPool::Instance()->PurgeDbiTableCache() ) { // now there should be no active clients so it should be // possible to purge to our heart's content if (pstoseTblCache) pstoseTblCache->Purge(); if (ptorcTblCache) ptorcTblCache->Purge(); } return; }

void Plexus::BuildReadoutMap (  const VldContext &  vldc  )  const [protected, virtual]

Reimplemented in PlexusReroot. Definition at line 902 of file Plexus.cxx. References BuildPinDiodeMap(), BuildPixelMaps(), RawChannelId::ClearModeBits(), fBuiltMaps, fChannelToPinDiode, fChannelToPixel, fChannelToReadout, fSpecialDescript, DbiTableProxy::GetCache(), PlexRawChannelReadoutType::GetDescript(), DbiResultPtr< T >::GetNumRows(), PlexRawChannelReadoutType::GetRawChannelId(), PlexRawChannelReadoutType::GetReadoutType(), DbiResultPtr< T >::GetRow(), DbiResultPtr< T >::GetValidityRec(), PlexLoanPool::Instance(), kReadoutMap, DbiCache::Purge(), PlexLoanPool::PurgeDbiTableCache(), DbiResultPtr< T >::TableProxy(), and TrimVldRange(). Referenced by Plexus(). { // build the basic map: RawChannel --> ReadoutType if (kReadoutMap & fBuiltMaps) return; fBuiltMaps |= kReadoutMap; DbiCache* rcrtTblCache = 0; { // start of inner scope to that DbiResultPtr's will die, die, die // and thus Purge will see no remaining clients DbiResultPtr<PlexRawChannelReadoutType> rcrtResPtr(vldc); // update the fVldRange TrimVldRange("PlexRawChannelReadoutType",rcrtResPtr.GetValidityRec()); // get a handle for the cache rcrtTblCache = rcrtResPtr.TableProxy().GetCache(); // build the map: RawChannel --> ReadoutType for (UInt_t irow = 0; irow < rcrtResPtr.GetNumRows(); ++irow) { const PlexRawChannelReadoutType* rcrt = rcrtResPtr.GetRow(irow); RawChannelId rcid = rcrt->GetRawChannelId(); ReadoutType::Readout_t rtype = rcrt->GetReadoutType(); // the map has the {pedestal,spars,common} mode bits off rcid.ClearModeBits(); fChannelToReadout[rcid] = rtype; fSpecialDescript[rcid] = rcrt->GetDescript(); } // use RawChannel->Pixel to make additions BuildPixelMaps(vldc); typedef multimap<RawChannelId,PlexPixelSpotId>::const_iterator rc2ps_itr; for (rc2ps_itr irc2ps = fChannelToPixel.begin(); irc2ps != fChannelToPixel.end(); ++irc2ps) { RawChannelId rcid = irc2ps->first; // the map has the {pedestal,spars,common} mode bits off rcid.ClearModeBits(); // Change NJT 29/8/03: Only set kScintStrip if there // is no previous type set. This ensures the DB always wins. // Useful for the 'UnconnectedPixel' type. if(fChannelToReadout.find(rcid)==fChannelToReadout.end()) fChannelToReadout[rcid] = ReadoutType::kScintStrip; } } if ( PlexLoanPool::Instance()->PurgeDbiTableCache() ) { // now there should be no active clients so it should be // possible to purge to our heart's content if (rcrtTblCache) rcrtTblCache->Purge(); } // use RawChannel->PinDiode to make additions BuildPinDiodeMap(vldc); typedef map<RawChannelId,PlexPinDiodeId>::const_iterator rc2pd_itr; for (rc2pd_itr irc2pd = fChannelToPinDiode.begin(); irc2pd != fChannelToPinDiode.end(); ++irc2pd) { RawChannelId rcid = irc2pd->first; // the map has the {pedestal,spars,common} mode bits off rcid.ClearModeBits(); fChannelToReadout[rcid] = ReadoutType::kPinDiode; } return; }

Int_t Plexus::CountRef (   )  const [inline]

Definition at line 77 of file Plexus.h. Referenced by PlexLoanPool::GetPlexus(), and Print(). { return fRef; }

void Plexus::DecrementRef (   )  [inline]

Definition at line 76 of file Plexus.h. References fRef. Referenced by PlexHandle::operator=(), and PlexHandle::~PlexHandle(). { fRef--; }

const std::vector< PlexLedId > & Plexus::GetAllLeds (   )  const [virtual]

Definition at line 743 of file Plexus.cxx. References fAllLeds, fPinDiodeToLed, and fStripEndToLed. Referenced by PlexHandle::GetAllLeds(). { // Return (build if necessary) a list of legal PlexLedIds if ( fAllLeds.empty() ) { // we need to fill the vector // but use an intermediate set to force uniqueness and ordering // base on normal PlexLedId order std::set<PlexLedId> ledSet; // fill from mapping of stripends to leds typedef std::map<PlexStripEndId,PlexLedId>::const_iterator seid2led_itr; seid2led_itr seledItr = fStripEndToLed.begin(); seid2led_itr seledItrEnd = fStripEndToLed.end(); for ( ; seledItr != seledItrEnd; ++seledItr) ledSet.insert(seledItr->second); // fill from mapping of pindiodes to leds typedef std::map<PlexPinDiodeId,PlexLedId>::const_iterator pind2led_itr; pind2led_itr pinledItr = fPinDiodeToLed.begin(); pind2led_itr pinledItrEnd = fPinDiodeToLed.end(); for ( ; pinledItr != pinledItrEnd; ++pinledItr) ledSet.insert(pinledItr->second); // copy set values into vector typedef std::set<PlexLedId>::iterator ledset_itr; ledset_itr ledItr = ledSet.begin(); ledset_itr ledItrEnd = ledSet.end(); for ( ; ledItr != ledItrEnd; ++ledItr) fAllLeds.push_back(*ledItr); } return fAllLeds; }

const std::vector< PlexPinDiodeId > & Plexus::GetAllPinDiodes (   )  const [virtual]

Definition at line 705 of file Plexus.cxx. References fAllPinDiodes, fChannelToPinDiode, and fPinDiodeToLed. Referenced by PlexHandle::GetAllPinDiodes(), and ValidateConsistency(). { // Return (build if necessary) a list of legal PlexPindDiodeIds if ( fAllPinDiodes.empty() ) { // we need to fill the vector // but use an intermediate set to force uniqueness and ordering // base on normal PlexPinDiodeId order std::set<PlexPinDiodeId> pindSet; // fill from list of raw channel list mapped to pin diodes typedef std::map<RawChannelId,PlexPinDiodeId>::const_iterator rc2pin_itr; rc2pin_itr rcpinItr = fChannelToPinDiode.begin(); rc2pin_itr rcpinItrEnd = fChannelToPinDiode.end(); for ( ; rcpinItr != rcpinItrEnd; ++rcpinItr) pindSet.insert(rcpinItr->second); // fill fromlist of pin diodes mapped to leds typedef std::map<PlexPinDiodeId,PlexLedId>::const_iterator pin2led_itr; pin2led_itr pinledItr = fPinDiodeToLed.begin(); pin2led_itr pinledItrEnd = fPinDiodeToLed.end(); for ( ; pinledItr != pinledItrEnd; ++pinledItr) pindSet.insert(pinledItr->first); // copy set values into vector typedef std::set<PlexPinDiodeId>::iterator pindset_itr; pindset_itr pindItr = pindSet.begin(); pindset_itr pindItrEnd = pindSet.end(); for ( ; pindItr != pindItrEnd; ++pindItr) fAllPinDiodes.push_back(*pindItr); } return fAllPinDiodes; }

const std::vector< PlexPixelSpotId > & Plexus::GetAllPixels (   )  const [inline, virtual]

Implements PlexusABC. Definition at line 202 of file Plexus.h. References GetAllPixelSpotIds(), and kIncludePixel. Referenced by PlexHandle::GetAllPixels(). { return this->GetAllPixelSpotIds(Plexus::kIncludePixel); }

const std::vector< PlexPixelSpotId > & Plexus::GetAllPixelSpotIds (  ETrimSpots  trim  )  const [protected, virtual]

Definition at line 603 of file Plexus.cxx. References fStripEndToSpot, kIncludePixel, kIncludeTube, PlexPixelSpotId::SetPixel(), and PlexPixelSpotId::SetSpot(). Referenced by GetAllPixels(), GetAllPixelSpots(), and GetAllTubes(). { // Return (build if necessary) a list of legal spots, pixels, tubes // If restrictEnd is kEast or kWest limit list to that end // If restrictEnd is kWhole force ids to be only for whole strip // (and eliminate duplicates) std::vector<PlexPixelSpotId>* thevector = 0; switch (trim) { case kIncludeTube: thevector = &fAllTubes; break; case kIncludePixel: thevector = &fAllPixels; break; default: thevector = &fAllSpots; break; } if ( thevector->empty() ) { // we need to fill the vector // but use an intermediate set to force uniqueness and ordering // based on normal PlexPixelSpotId order typedef std::map<PlexStripEndId,PlexPixelSpotId>::const_iterator se2spot_itr; se2spot_itr seItr = fStripEndToSpot.begin(); se2spot_itr seItrEnd = fStripEndToSpot.end(); std::set<PlexPixelSpotId> spotSet; for ( ; seItr != seItrEnd; ++seItr) { PlexPixelSpotId spot = seItr->second; switch (trim) { // rely on fall through case kIncludeTube: spot.SetPixel(0); case kIncludePixel: spot.SetSpot(0); default: break; } // add to the set, let it take care of uniqueness spotSet.insert(spot); } // copy set values into vector typedef std::set<PlexPixelSpotId>::iterator spotset_itr; spotset_itr spotItr = spotSet.begin(); spotset_itr spotItrEnd = spotSet.end(); for ( ; spotItr != spotItrEnd; ++spotItr) thevector->push_back(*spotItr); } return *thevector; }

const std::vector< PlexPixelSpotId > & Plexus::GetAllPixelSpots (   )  const [inline, virtual]

Implements PlexusABC. Definition at line 198 of file Plexus.h. References GetAllPixelSpotIds(), and kIncludeSpot. Referenced by PlexHandle::GetAllPixelSpots(). { return this->GetAllPixelSpotIds(Plexus::kIncludeSpot); }

const std::vector< RawChannelId > & Plexus::GetAllRawChannelIds (   )  const [virtual]

Implements PlexusABC. Definition at line 655 of file Plexus.cxx. References fAllChannels, fChannelToPinDiode, fChannelToPixel, fChannelToReadout, and fSpecialDescript. Referenced by PlexHandle::GetAllRawChannelIds(), and Print(). { // Return (build if necessary) a list of legal RawChannelIds if ( fAllChannels.empty() ) { // we need to fill the vector // but use an intermediate set to force uniqueness and ordering // base on normal RawChannelId order std::set<RawChannelId> rcidSet; // fill from mapping of channels to pixels typedef std::map<RawChannelId,PlexPixelSpotId>::const_iterator rc2pixel_itr; rc2pixel_itr rcpxItr = fChannelToPixel.begin(); rc2pixel_itr rcpxItrEnd = fChannelToPixel.end(); for ( ; rcpxItr != rcpxItrEnd; ++rcpxItr) rcidSet.insert(rcpxItr->first); // typedef std::map<RawChannelId,PlexPinDiodeId>::const_iterator rc2pin_itr; rc2pin_itr rcpinItr = fChannelToPinDiode.begin(); rc2pin_itr rcpinItrEnd = fChannelToPinDiode.end(); for ( ; rcpinItr != rcpinItrEnd; ++rcpinItr) rcidSet.insert(rcpinItr->first); // typedef std::map<RawChannelId,UShort_t>::const_iterator rc2type_itr; rc2type_itr rctypeItr = fChannelToReadout.begin(); rc2type_itr rctypeItrEnd = fChannelToReadout.end(); for ( ; rctypeItr != rctypeItrEnd; ++rctypeItr) rcidSet.insert(rctypeItr->first); // typedef std::map<RawChannelId,std::string>::const_iterator rc2desc_itr; rc2desc_itr rcdescItr = fSpecialDescript.begin(); rc2desc_itr rcdescItrEnd = fSpecialDescript.end(); for ( ; rcdescItr != rcdescItrEnd; ++rcdescItr) rcidSet.insert(rcdescItr->first); // copy set values into vector typedef std::set<RawChannelId>::iterator rcidset_itr; rcidset_itr rcidItr = rcidSet.begin(); rcidset_itr rcidItrEnd = rcidSet.end(); for ( ; rcidItr != rcidItrEnd; ++rcidItr) fAllChannels.push_back(*rcidItr); } return fAllChannels; }

const std::vector< PlexStripEndId > & Plexus::GetAllStripEnds (  StripEnd::StripEnd_t  restrictEnd = StripEnd::kUnknown  )  const [virtual]

Implements PlexusABC. Definition at line 546 of file Plexus.cxx. References fStripEndToSpot, PlexStripEndId::GetEnd(), and PlexStripEndId::SetEnd(). Referenced by PlexHandle::GetAllStripEnds(), and PlexHandle::GetAllStrips(). { // Return (build if necessary) a list of legal PlexStripEndIds // If restrictEnd is kEast or kWest limit list to that end // If restrictEnd is kWhole force ids to be only for whole strip // (and eliminate duplicates) std::vector<PlexStripEndId>* thevector = 0; switch (restrictEnd) { case StripEnd::kEast: thevector = &fAllEastEnds; break; case StripEnd::kWest: thevector = &fAllWestEnds; break; case StripEnd::kWhole: thevector = &fAllStrips; break; default: thevector = &fAllStripEnds; break; } if ( thevector->empty() ) { // we need to fill the vector typedef map<PlexStripEndId,PlexPixelSpotId>::const_iterator se2spot_itr; se2spot_itr seItr = fStripEndToSpot.begin(); se2spot_itr seItrEnd = fStripEndToSpot.end(); PlexStripEndId seidLast; for ( ; seItr != seItrEnd; ++seItr) { PlexStripEndId seid = seItr->first; switch (restrictEnd) { // if a particular side is chosen only add those case StripEnd::kEast: case StripEnd::kWest: if ( seid.GetEnd() != restrictEnd ) continue; break; case StripEnd::kWhole: seid.SetEnd(StripEnd::kWhole); // for whole-ness // this next test is under the assumption that the PlexStripEndId // sorts ends of the same strips to consecutive places in the map // otherwise we'd have to be constructing a std::set to guarentee // uniqueness of the strips (or do ever lengthening searches) if ( seid == seidLast ) continue; seidLast = seid; break; default: // just add it with no restrictions break; } // add to the list thevector->push_back(seid); } } return *thevector; }

const std::vector< PlexPixelSpotId > & Plexus::GetAllTubes (   )  const [inline, virtual]

Implements PlexusABC. Definition at line 206 of file Plexus.h. References GetAllPixelSpotIds(), and kIncludeTube. Referenced by PlexHandle::GetAllTubes(). { return this->GetAllPixelSpotIds(Plexus::kIncludeTube); }

Bool_t Plexus::GetAltLHasBrokenFibers (   )  [inline, static]

Definition at line 180 of file Plexus.h. { return fgAltLHasBrokenFibers; }

Bool_t Plexus::GetAltLInitiallySortedBySEId (   )  [inline, static]

Definition at line 184 of file Plexus.h. { return fgAltLInitiallySortedBySEId; }

PlexLedId Plexus::GetLedId (  const PlexPinDiodeId &  diodeid  )  const [virtual]

Implements PlexusABC. Definition at line 537 of file Plexus.cxx. References fPinDiodeToLed. { // Convert PlexPinDiodeId into a PlexLedId (N:1) return fPinDiodeToLed[diodeid]; }

PlexLedId Plexus::GetLedId (  const PlexStripEndId &  seid  )  const [virtual]

Implements PlexusABC. Definition at line 529 of file Plexus.cxx. References fStripEndToLed. Referenced by PlexHandle::GetLedId(). { // Convert PlexStripEndId into a PlexLedId (N:1) return fStripEndToLed[seid]; }

PlexPinDiodeId Plexus::GetPinDiodeId (  const RawChannelId &  rcid  )  const [virtual]

Implements PlexusABC. Reimplemented in PlexusReroot. Definition at line 388 of file Plexus.cxx. References RawChannelId::ClearModeBits(), and fChannelToPinDiode. Referenced by PlexHandle::GetPinDiodeId(). { // Convert RawChannelId into PlexPinDiodeId (if possible) // the map has the {pedestal,spars,common} mode bits off RawChannelId rcid0 = rcid; rcid0.ClearModeBits(); return fChannelToPinDiode[rcid0]; }

std::pair< PlexPinDiodeId, PlexPinDiodeId > Plexus::GetPinDiodeIds (  const PlexLedId &  ledid  )  const [virtual]

Implements PlexusABC. Definition at line 480 of file Plexus.cxx. References PlexPinDiodeId::AsString(), fPinDiodeToLed, PlexPinDiodeId::IsHighGain(), PlexPinDiodeId::IsValid(), and MSG. Referenced by PlexHandle::GetPinDiodeIds(). { // Convert PlexLedId into a pair of PlexPinDiodeId's (1:[1,2]) pair<PlexPinDiodeId,PlexPinDiodeId> diodepair; PlexPinDiodeId high_gain; PlexPinDiodeId low_gain; typedef map<PlexPinDiodeId,PlexLedId>::const_iterator pd2led_itr; for (pd2led_itr ipd2led = fPinDiodeToLed.begin(); ipd2led != fPinDiodeToLed.end(); ++ipd2led) { if (ipd2led->second == ledid) { PlexPinDiodeId pinid = ipd2led->first; // Gain: 1=LO, 0=HIGH !Arghhh! if (pinid.IsHighGain()) { // high gain pin diode if (!high_gain.IsValid()) high_gain = pinid; else { // this shouldn't happen MSG("Plex",Msg::kError) << "GetPinDiodeIds already found high gain " << high_gain.AsString() << " before " << pinid.AsString() << ", ignore new " << endl; } } else { // low gain pin diode if (!low_gain.IsValid()) low_gain = pinid; else { // this shouldn't happen MSG("Plex",Msg::kError) << "GetPinDiodeIds already found low gain " << low_gain.AsString() << " before " << pinid.AsString() << ", ignore new " << endl; } } } } diodepair.first = low_gain; diodepair.second = high_gain; return diodepair; }

PlexPixelSpotId Plexus::GetPixelSpotId (  const PlexStripEndId &  seid  )  const [virtual]

Implements PlexusABC. Definition at line 374 of file Plexus.cxx. References fStripEndToSpot. Referenced by PlexHandle::GetPixelSpotId(), and GetPixelSpotIdVector(). { // Convert PlexStripEndId into a PlexPixelSpotId (1:1) //was: return fStripEndToSpot[seid]; //use find() to avoid adding null entries std::map<PlexStripEndId,PlexPixelSpotId>::const_iterator sepsItr = fStripEndToSpot.find(seid); if (sepsItr == fStripEndToSpot.end()) return PlexPixelSpotId(); // not there! return sepsItr->second; }

vector< PlexPixelSpotId > Plexus::GetPixelSpotIdVector (  const RawChannelId &  rcid, bool  uniquePixels = false )  const [virtual]

Implements PlexusABC. Definition at line 334 of file Plexus.cxx. References RawChannelId::ClearModeBits(), fChannelToPixel, GetPixelSpotId(), and GetSEIdAltL(). Referenced by PlexHandle::GetPixelSpotIdVector(). { // Convert RawChannelId into a vector of PlexPixelSpotId's // if uniquePixels=true then set spot=0 (1:m) and return // a list of *pixels* not pixel-spots. // // RawChannelId may not map to single Pixel in the case of // near detector. vector<PlexPixelSpotId> pixelspots; if (uniquePixels) { // the map has the {pedestal,spars,common} mode bits off RawChannelId rcid0 = rcid; rcid0.ClearModeBits(); typedef multimap<RawChannelId,PlexPixelSpotId>::const_iterator rc2p_itr; pair<rc2p_itr,rc2p_itr> rc2p_limits = fChannelToPixel.equal_range(rcid0); for (rc2p_itr irc2p = rc2p_limits.first; irc2p != rc2p_limits.second; ++irc2p) { PlexPixelSpotId aspot = irc2p->second; pixelspots.push_back(aspot); } } else { // return all spots, even if the pixel part isn't unique // take the easy road out and use existing mechanism PlexSEIdAltL altl = this->GetSEIdAltL(rcid); for (size_t i=0; i < altl.size(); ++i) pixelspots.push_back(altl[i].GetPixelSpotId()); } return pixelspots; }

RawChannelId Plexus::GetRawChannelId (  const PlexPinDiodeId &  diodeid  )  const [virtual]

Implements PlexusABC. Reimplemented in PlexusReroot. Definition at line 222 of file Plexus.cxx. References fChannelToPinDiode. { // Convert PinDiodeId into a RawChannelId // walk through the map looking for a match // this is slower than the reverse operation but // means that we don't need a second copy of the information typedef map<RawChannelId,PlexPinDiodeId>::const_iterator rc2pd_itr; for (rc2pd_itr irc2pd = fChannelToPinDiode.begin(); irc2pd != fChannelToPinDiode.end(); ++irc2pd) { if (irc2pd->second == diodeid) return irc2pd->first; } // nothing appropriate found return RawChannelId(); }

RawChannelId Plexus::GetRawChannelId (  const PlexPixelSpotId &  psid  )  const [virtual]

Implements PlexusABC. Reimplemented in PlexusReroot. Definition at line 204 of file Plexus.cxx. References fPixelToChannel, and PlexPixelSpotId::SetSpot(). { // Convert PlexPixelSpotId into RawChannelId (m:1 mapping) // clear the spot value as that isn't used in pixel->channel PlexPixelSpotId psid_nospot = psid; psid_nospot.SetSpot(0); // was: return fPixelToChannel[psid_nospot]; // use find() to avoid adding null entries std::map<PlexPixelSpotId,RawChannelId>::const_iterator psrcItr = fPixelToChannel.find(psid_nospot); if (psrcItr == fPixelToChannel.end()) return RawChannelId(); // not there! return psrcItr->second; }

RawChannelId Plexus::GetRawChannelId (  const PlexStripEndId &  seid  )  const [virtual]

Implements PlexusABC. Reimplemented in PlexusReroot. Definition at line 171 of file Plexus.cxx. References fStripEndToSpot, PlexPlaneId::GetDetector(), PlexStripEndId::GetEnd(), and MAXMSG. Referenced by BuildPinDiodeMap(), and PlexHandle::GetRawChannelId(). { // Convert PlexStripEndId into RawChannelId (m:1 mapping) StripEnd::StripEnd_t end = seid.GetEnd();; if ( StripEnd::kWhole == end || StripEnd::kUnknown == end ) { MAXMSG("Plex",Msg::kInfo,10) << "GetRawChannelId called for SEId=" << seid << " which has StripEnd either 'Unknown' or 'Whole';" << " this is unlikely to succeed." << endl; } else { Detector::Detector_t det = seid.GetDetector(); if ( Detector::kNear == det && StripEnd::kEast == end ) { MAXMSG("Plex",Msg::kInfo,10) << "GetRawChannelId called for SEId=" << seid << " which has StripEnd of 'East';" << " this is unlikely to succeed." << endl; } } // was: PlexPixelSpotId psid = fStripEndToSpot[seid]; // use find() to avoid adding null entries std::map<PlexStripEndId,PlexPixelSpotId>::const_iterator sepsItr = fStripEndToSpot.find(seid); if (sepsItr == fStripEndToSpot.end()) return RawChannelId(); // not there! return GetRawChannelId(sepsItr->second); }

ReadoutType::Readout_t Plexus::GetReadoutType (  const RawChannelId &  rcid  )  const [virtual]

Implements PlexusABC. Reimplemented in PlexusReroot. Definition at line 400 of file Plexus.cxx. References RawChannelId::ClearModeBits(), fChannelToReadout, and RawChannelId::GetVaChannel(). Referenced by PlexHandle::GetReadoutType(), and Print(). { // Determine what (eg. scint strip, pin diode, cerenkov, tof) // is attached to raw channel if ( rcid == rcidNull ) return ReadoutType::kUnknown; // deal with special case of VA common mode rejection channels // no need to explicitly test for electronics type as unpacker does // (returns -1 if not a VA channel) switch (rcid.GetVaChannel()) { case 0: case 1: case 19: case 20: case 21: return ReadoutType::kVACommonMode; break; } // the map has the {pedestal,spars,common} mode bits off RawChannelId rcid0 = rcid; rcid0.ClearModeBits(); // ideally this mapping would be to ReadoutType::Readout_t // but cint can't correctly handle enum as as second type of map // so use UShort_t (must be > 8 bits to correctly hold all Readout_t values) return (ReadoutType::Readout_t)fChannelToReadout[rcid0]; }

PlexSEIdAltL Plexus::GetSEIdAltL (  const RawChannelId &  rcid, const PlexCalib *  calib = 0, Int_t  adc = 0, Double_t  time = 0 )  const [virtual]

Implements PlexusABC. Reimplemented in PlexusReroot. Definition at line 242 of file Plexus.cxx. References PlexSEIdAltL::AddStripEndId(), RawChannelId::ClearModeBits(), fChannelToPixel, fgAltLHasBrokenFibers, fPixelToStripEnd, fStripEndToSpot, PlexStripEndId::GetEncoded(), PlexPixelSpotId::GetSpot(), PlexStripEndId::IsValid(), MSG, and NR::sort(). Referenced by GetPixelSpotIdVector(), PlexHandle::GetSEIdAltL(), and ValidateConsistency(). { // Convert RawChannelId into PlexStripEndId Alternative List (1:m mapping) //MSG("Plex",Msg::kVerbose) // << " GetSEIdAltL RCID=" << rcid << ":" << endl; PlexSEIdAltL altlist; // start with empty altlist // the map has the {pedestal,spars,common} mode bits off RawChannelId rcid0 = rcid; rcid0.ClearModeBits(); // the near detector spectrometer can map RawChannel to >1 Pixel // far detector maps each Pixel to more than one StripEnd // do this as a nested loop over two multimaps typedef multimap<RawChannelId,PlexPixelSpotId>::const_iterator rc2p_itr; typedef multimap<PlexPixelSpotId,PlexStripEndId>::const_iterator p2se_itr; pair<rc2p_itr,rc2p_itr> rc2p_limits = fChannelToPixel.equal_range(rcid0); for (rc2p_itr irc2p = rc2p_limits.first; irc2p != rc2p_limits.second; ++irc2p) { pair<p2se_itr,p2se_itr> p2se_limits = fPixelToStripEnd.equal_range(irc2p->second); for (p2se_itr ip2se = p2se_limits.first; ip2se != p2se_limits.second; ++ip2se) { PlexStripEndId seid = ip2se->second; if (seid.IsValid()) { // look to see if the spot is 0 signalling broken fiber PlexPixelSpotId spotid = fStripEndToSpot[seid]; if (fgAltLHasBrokenFibers || spotid.GetSpot() != 0) { altlist.AddStripEndId(seid,spotid,0,calib,adc,time); //MSG("Plex",Msg::kVerbose) // << " add SEID=" << seid // << " " << seid.GetEncoded() // << endl; } else { MSG("Plex",Msg::kVerbose) << " suppress broken fiber SEID=" << seid << " " << seid.GetEncoded() << endl; } } // seid.IsValid() } // loop over Pixel->StripEnd } // loop over RawChannel->Pixel if ( fgAltLInitiallySortedBySEId ) std::sort(altlist.begin(),altlist.end(),less_altl_seid()); return altlist; }

RawChannelId Plexus::GetSpecialChannelContains (  const std::string &  key  )  const [virtual]

Definition at line 443 of file Plexus.cxx. References fSpecialDescript. Referenced by PlexHandle::GetSpecialChannelContains(). { // look for a special channel description string that contains // the passed key. Allowing one to distinguish between different // special channels of the same readout type by extending what // is put in the PLEXRAWCHANNELREADOUTTYPE table typedef map<RawChannelId,std::string>::const_iterator rc2string_itr; for (rc2string_itr irc2s = fSpecialDescript.begin(); irc2s != fSpecialDescript.end(); ++ irc2s) { // lazy approach ... use TString's Contains() to do work TString description(irc2s->second.c_str()); if (description.Contains(key.c_str())) return irc2s->first; } return RawChannelId(); }

std::string Plexus::GetSpecialDescript (  const RawChannelId &  rcid  )  const [virtual]

Definition at line 433 of file Plexus.cxx. References RawChannelId::ClearModeBits(), and fSpecialDescript. Referenced by PlexHandle::GetSpecialDescript(). { // if a special channel (Cerenkov, TOF, etc) from the // PLEXRAWCHANNELREADOUTTYPE table return the associated string RawChannelId rcid0 = rcid; rcid0.ClearModeBits(); return fSpecialDescript[rcid0]; }

virtual const std::map<RawChannelId,std::string>& Plexus::GetSpecialDescriptMap (   )  const [inline, virtual]

Definition at line 49 of file Plexus.h. Referenced by PlexHandle::GetSpecialDescriptMap(). { return fSpecialDescript; }

PlexStripEndId Plexus::GetStripEndId (  const PlexPixelSpotId &  psid  )  const [virtual]

Implements PlexusABC. Definition at line 300 of file Plexus.cxx. References fPixelToStripEnd, fStripEndToSpot, and PlexPixelSpotId::SetSpot(). Referenced by PlexHandle::GetStripEndId(). { // Convert PlexPixelSpotId into a PlexStripEndId (1:1) // this is a bit tricky because we've tossed the spot info // from the multimap fPixelToStripEnd for ease of building // AltL's, so we need to loop and test the round trip typedef multimap<PlexPixelSpotId,PlexStripEndId>::const_iterator p2se_itr; PlexPixelSpotId pixelid = psid; pixelid.SetSpot(0); // zero out spot info for multimap pixel->seid(s) pair<p2se_itr,p2se_itr> p2se_limits = fPixelToStripEnd.equal_range(pixelid); for (p2se_itr ip2se = p2se_limits.first; ip2se != p2se_limits.second; ++ip2se) { PlexStripEndId seid = ip2se->second; // check that this leads back to the *spot* we were given //was: PlexPixelSpotId testspot = fStripEndToSpot[seid]; // if (testspot == psid) return seid; //use find() to avoid adding null entries std::map<PlexStripEndId,PlexPixelSpotId>::const_iterator sepsItr = fStripEndToSpot.find(seid); if (sepsItr->second == psid) return seid; } return PlexStripEndId(); // no match }

std::vector< PlexStripEndId > Plexus::GetStripEndIdVector (  const PlexLedId &  ledid  )  const [virtual]

Implements PlexusABC. Definition at line 462 of file Plexus.cxx. References fStripEndToLed. Referenced by PlexHandle::GetStripEndIdVector(). { // Convert PlexLedId into a vector of PlexStripEndId's (1:m) vector<PlexStripEndId> stripends; typedef map<PlexStripEndId,PlexLedId>::const_iterator se2led_itr; for (se2led_itr ise2led = fStripEndToLed.begin(); ise2led != fStripEndToLed.end(); ++ise2led) { if (ise2led->second == ledid) stripends.push_back(ise2led->first); } return stripends; }

virtual const VldRange& Plexus::GetVldRange (   )  const [inline, virtual]

Implements PlexusABC. Definition at line 73 of file Plexus.h. Referenced by PlexHandle::GetVldRange(). { return fVldRange; }

void Plexus::IncrementRef (   )  [inline]

Definition at line 75 of file Plexus.h. References fRef. Referenced by PlexHandle::operator=(), and PlexHandle::PlexHandle(). { fRef++; }

Bool_t Plexus::IsCompatible (  const VldContext *  vldc  )

Definition at line 118 of file Plexus.cxx. References fVldRange, and VldRange::IsCompatible(). { // check compatibility of this plex with a context return fVldRange.IsCompatible(vldc); }

Bool_t Plexus::IsCompatible (  const VldContext &  vldc  )

Definition at line 109 of file Plexus.cxx. References fVldRange, and VldRange::IsCompatible(). Referenced by PlexLoanPool::GetExistingPlexus(). { // check compatibility of this plex with a context return fVldRange.IsCompatible(vldc); }

void Plexus::Print (  Option_t *  option  )  const

Definition at line 127 of file Plexus.cxx. References VldRange::AsString(), CountRef(), fChannelToPinDiode, fChannelToPixel, fChannelToReadout, fPinDiodeToLed, fPixelToChannel, fPixelToStripEnd, fStripEndToLed, fStripEndToSpot, fVldRange, GetAllRawChannelIds(), Nav::GetName(), GetReadoutType(), and option. Referenced by PlexLoanPool::Print(), and PlexHandle::Print(). { // Print info about this object cout << " " << TObject::GetName() << " has " << CountRef() << " references " << endl << " " << fVldRange.AsString("a") << endl; TString opt(option); if (opt.Contains("s")) { printf(" ChannelToPixel: %6u PixelToChannel: %6u\n", (UInt_t)fChannelToPixel.size(),(UInt_t)fPixelToChannel.size()); printf(" PixelToStripEnd: %6u StripEndToSpot: %6u\n", (UInt_t)fPixelToStripEnd.size(),(UInt_t)fStripEndToSpot.size()); printf(" ChannelToReadout: %6u\n",(UInt_t)fChannelToReadout.size()); printf(" ChannelToPinDiode: %6u\n",(UInt_t)fChannelToPinDiode.size()); printf(" StripEndToLed: %6u PinDiodeToLed: %6u\n", (UInt_t)fStripEndToLed.size(),(UInt_t)fPinDiodeToLed.size()); // classify readout types if (opt.Contains("r")) { const vector<RawChannelId>& all_rcid = GetAllRawChannelIds(); printf(" There are %u unique RawChannelIds\n",(UInt_t)all_rcid.size()); std::map<ReadoutType::Readout_t,UInt_t> readoutTypeCount; for (size_t i=0; i<all_rcid.size(); ++i) { RawChannelId rcid = all_rcid[i]; ReadoutType::Readout_t rtype = GetReadoutType(rcid); readoutTypeCount[rtype]++; } std::map<ReadoutType::Readout_t,UInt_t>::const_iterator rtcItr = readoutTypeCount.begin(); while ( rtcItr != readoutTypeCount.end() ) { printf(" %-15s had %5d channels\n", ReadoutType::AsString(rtcItr->first), rtcItr->second); rtcItr++; } } } }

void Plexus::PurgeComponents (  UInt_t  purgeMask  )  [protected, virtual]

Definition at line 1138 of file Plexus.cxx. References fAllChannels, fAllEastEnds, fAllLeds, fAllPinDiodes, fAllPixels, fAllSpots, fAllStripEnds, fAllStrips, fAllTubes, fAllWestEnds, fBuiltMaps, fChannelToPinDiode, fChannelToPixel, fChannelToReadout, fPinDiodeToLed, fPixelToChannel, fPixelToStripEnd, fSpecialDescript, fStripEndToLed, and fStripEndToSpot. Referenced by PlexLoanPool::PurgeComponents(). { // clear out components of the plex // generally done before writing it out to save space // clear both the map themselves and the flag bit indicating // whether the map is filled (used by lazy building) if (purgeMask & kPixelMaps) { fBuiltMaps &= ~kPixelMaps; fStripEndToSpot.clear(); fPixelToStripEnd.clear(); fPixelToChannel.clear(); fChannelToPixel.clear(); } if (purgeMask & kReadoutMap) { fBuiltMaps &= ~kReadoutMap; fChannelToReadout.clear(); fSpecialDescript.clear(); } if (purgeMask & kPinDiodeMap) { fBuiltMaps &= ~kPinDiodeMap; fChannelToPinDiode.clear(); } if (purgeMask & kLedMaps) { fBuiltMaps &= ~kLedMaps; fPinDiodeToLed.clear(); fStripEndToLed.clear(); } if (purgeMask & kAllVectors) { fAllStripEnds.clear(); fAllEastEnds.clear(); fAllWestEnds.clear(); fAllStrips.clear(); fAllTubes.clear(); fAllPixels.clear(); fAllSpots.clear(); fAllChannels.clear(); fAllPinDiodes.clear(); fAllLeds.clear(); } }

void Plexus::SetAltLHasBrokenFibers (  Bool_t  tf  )  [inline, static]

Definition at line 178 of file Plexus.h. References fgAltLHasBrokenFibers. { fgAltLHasBrokenFibers = tf; }

void Plexus::SetAltLInitiallySortedBySEId (  Bool_t  tf  )  [inline, static]

Definition at line 182 of file Plexus.h. References fgAltLInitiallySortedBySEId. { fgAltLInitiallySortedBySEId = tf; }

void Plexus::TrimVldRange (  const char *  tblName = "", const DbiValidityRec *  dbivrec = 0 )  const [protected]

Definition at line 1188 of file Plexus.cxx. References fVldRange, DbiValidityRec::GetVldRange(), MSG, and VldRange::TrimTo(). Referenced by BuildLedMaps(), BuildPinDiodeMap(), BuildPixelMaps(), and BuildReadoutMap(). { // Trim VldRange based on DbiValidityRec range info if (dbivrec) { fVldRange.TrimTo(dbivrec->GetVldRange()); } else { MSG("Plex",Msg::kWarning) << "No DbiValidityRec for table " << tblName << endl; } }

void Plexus::ValidateConsistency (   )  const [virtual]

Definition at line 1202 of file Plexus.cxx. References RawChannelId::AsString(), fChannelToPixel, fPinDiodeToLed, GetAllPinDiodes(), PlexSEIdAltL::GetBestSEId(), RawChannelId::GetDetector(), PlexSEIdAltL::GetError(), GetSEIdAltL(), PlexPlaneId::IsVetoShield(), MSG, and PlexSEIdAltL::Print(). Referenced by PlexHandle::ValidateConsistency(). { // Test tables for internal consistency typedef multimap<RawChannelId,PlexPixelSpotId>::const_iterator rc2p_itr; RawChannelId rcid_last; rc2p_itr rcitr = fChannelToPixel.begin(); rc2p_itr rcend = fChannelToPixel.end(); while (rcitr != rcend) { RawChannelId rcid = rcitr->first; if (rcid != rcid_last) { // RawChannelId->PixelSpot is multimap PlexSEIdAltL altl = GetSEIdAltL(rcid,0,0,0); Bool_t printit = false; // make sure that far detector altl has 8 entries if (rcid.GetDetector() == Detector::kFar) { if ( altl.size() == 0 ) printit = true; else { PlexPlaneId plnid = altl.GetBestSEId(); if ( altl.size() != 8 && !plnid.IsVetoShield() ) { MSG("Plex",Msg::kInfo) << endl << " far detector PlexSEIdAltL.size() " << altl.size() << " != 8" << endl; printit = true; } } } // test the alternative list for consistency Int_t error = altl.GetError(false); if (error) { printit = true; if (altl.empty()) { MSG("Plex",Msg::kInfo) << " PlexSEIdAltL empty" << endl; printit = false; } else { string etxt = " bad: "; if (error & PlexSEIdAltL::kBadDetector) etxt += "detector "; if (error & PlexSEIdAltL::kBadEnd) etxt += "end "; if (error & PlexSEIdAltL::kBadPlane) etxt += "plane "; if (error & PlexSEIdAltL::kBadPlaneView) etxt += "view "; if (error & PlexSEIdAltL::kUnchecked) etxt = " unchecked? "; MSG("Plex",Msg::kInfo) << endl << " PlexSEIdAltL consistency error 0x" << hex << error << dec << etxt << endl; } pair<rc2p_itr,rc2p_itr> rc2p_limits = fChannelToPixel.equal_range(rcid); rc2p_itr next = rc2p_limits.first; // range means 2nd is 1 too far if (++next == rc2p_limits.second) { // RawChannel only maps to one pixel MSG("Plex",Msg::kInfo) << " rcid " << rcid.AsString("ec") << " single pixel: " << rc2p_limits.first->second.AsString("p") << endl; } else { // RawChannel maps to multiple pixels MSG("Plex",Msg::kInfo) << " rcid " << rcid.AsString("ec") << " pixel list: " << endl; for (rc2p_itr irc2p = rc2p_limits.first; irc2p != rc2p_limits.second; ++irc2p) { MSG("Plex",Msg::kInfo) << " " << irc2p->second.AsString("p") << endl; } } } if (printit) { // MSG("Plex",Msg::kInfo) << endl; altl.Print(); } } // if new rcid // move along ++rcitr; rcid_last = rcid; } // while // test PinDiodes const std::vector<PlexPinDiodeId>& allpindiodes = GetAllPinDiodes(); //if ( allpindiodes.size() != fChannelToPinDiode.size() ) // MSG("Plex",Msg::kInfo) // << "AllPinDiodes.size() = " << allpindiodes.size() // << " vs. fChannelToPinDiode.size() = " << fChannelToPinDiode.size() // << endl; if ( allpindiodes.size() != fPinDiodeToLed.size() ) MSG("Plex",Msg::kInfo) << "AllPinDiodes.size() = " << allpindiodes.size() << " vs. fPinDiodeToLed.size() = " << fPinDiodeToLed.size() << endl; // test Leds //const std::vector<PlexLedId>& allleds = GetAllLeds(); //if ( allleds.size() != fStripEndToLed.size() ) // MSG("Plex",Msg::kInfo) // << "AllLeds.size() = " << allleds.size() // << " vs. fStripEndToLed.size() = " << fStripEndToLed.size() // << endl; //if ( allled.size() != fPinDiodeToLed.size() ) // MSG("Plex",Msg::kInfo) // << "AllLeds.size() = " << allleds.size() // << " vs. fPinDiodeToLed.size() = " << fPinDiodeToLed.size() // << endl; }

---

Friends And Related Function Documentation

friend class PlexLoanPool [friend]

Reimplemented from PlexusABC. Reimplemented in PlexusReroot. Definition at line 23 of file Plexus.h.

---

Member Data Documentation

std::vector<RawChannelId> Plexus::fAllChannels [mutable, protected]

Definition at line 171 of file Plexus.h. Referenced by GetAllRawChannelIds(), and PurgeComponents().

std::vector<PlexStripEndId> Plexus::fAllEastEnds [mutable, protected]

Definition at line 163 of file Plexus.h. Referenced by PurgeComponents().

std::vector<PlexLedId> Plexus::fAllLeds [mutable, protected]

Definition at line 174 of file Plexus.h. Referenced by GetAllLeds(), and PurgeComponents().

std::vector<PlexPinDiodeId> Plexus::fAllPinDiodes [mutable, protected]

Definition at line 173 of file Plexus.h. Referenced by GetAllPinDiodes(), and PurgeComponents().

std::vector<PlexPixelSpotId> Plexus::fAllPixels [mutable, protected]

Definition at line 168 of file Plexus.h. Referenced by PurgeComponents().

std::vector<PlexPixelSpotId> Plexus::fAllSpots [mutable, protected]

Definition at line 169 of file Plexus.h. Referenced by PurgeComponents().

std::vector<PlexStripEndId> Plexus::fAllStripEnds [mutable, protected]

Definition at line 162 of file Plexus.h. Referenced by PurgeComponents().

std::vector<PlexStripEndId> Plexus::fAllStrips [mutable, protected]

Definition at line 165 of file Plexus.h. Referenced by PurgeComponents().

std::vector<PlexPixelSpotId> Plexus::fAllTubes [mutable, protected]

Definition at line 167 of file Plexus.h. Referenced by PurgeComponents().

std::vector<PlexStripEndId> Plexus::fAllWestEnds [mutable, protected]

Definition at line 164 of file Plexus.h. Referenced by PurgeComponents().

UInt_t Plexus::fBuiltMaps [mutable, protected]

Definition at line 137 of file Plexus.h. Referenced by BuildLedMaps(), BuildPinDiodeMap(), BuildPixelMaps(), BuildReadoutMap(), and PurgeComponents().

std::map<RawChannelId,PlexPinDiodeId> Plexus::fChannelToPinDiode [mutable, protected]

Definition at line 155 of file Plexus.h. Referenced by BuildPinDiodeMap(), BuildReadoutMap(), GetAllPinDiodes(), GetAllRawChannelIds(), GetPinDiodeId(), GetRawChannelId(), Print(), and PurgeComponents().

std::multimap<RawChannelId,PlexPixelSpotId> Plexus::fChannelToPixel [mutable, protected]

Definition at line 142 of file Plexus.h. Referenced by BuildPixelMaps(), BuildReadoutMap(), GetAllRawChannelIds(), GetPixelSpotIdVector(), GetSEIdAltL(), Print(), PurgeComponents(), and ValidateConsistency().

std::map<RawChannelId,UShort_t> Plexus::fChannelToReadout [mutable, protected]

Definition at line 151 of file Plexus.h. Referenced by BuildReadoutMap(), GetAllRawChannelIds(), GetReadoutType(), Print(), and PurgeComponents().

Bool_t Plexus::fgAltLHasBrokenFibers = false [static, protected]

Definition at line 40 of file Plexus.cxx. Referenced by GetSEIdAltL(), and SetAltLHasBrokenFibers().

Bool_t Plexus::fgAltLInitiallySortedBySEId = false [static, protected]

Definition at line 41 of file Plexus.cxx. Referenced by SetAltLInitiallySortedBySEId().

std::map<PlexPinDiodeId,PlexLedId> Plexus::fPinDiodeToLed [mutable, protected]

Definition at line 158 of file Plexus.h. Referenced by BuildLedMaps(), GetAllLeds(), GetAllPinDiodes(), GetLedId(), GetPinDiodeIds(), Print(), PurgeComponents(), and ValidateConsistency().

std::map<PlexPixelSpotId,RawChannelId> Plexus::fPixelToChannel [mutable, protected]

Definition at line 146 of file Plexus.h. Referenced by BuildPixelMaps(), GetRawChannelId(), Print(), and PurgeComponents().

std::multimap<PlexPixelSpotId,PlexStripEndId> Plexus::fPixelToStripEnd [mutable, protected]

Definition at line 143 of file Plexus.h. Referenced by BuildPixelMaps(), GetSEIdAltL(), GetStripEndId(), Print(), and PurgeComponents().

Int_t Plexus::fRef [mutable, protected]

Definition at line 135 of file Plexus.h. Referenced by DecrementRef(), and IncrementRef().

std::map<RawChannelId,std::string> Plexus::fSpecialDescript [mutable, protected]

Definition at line 153 of file Plexus.h. Referenced by BuildReadoutMap(), GetAllRawChannelIds(), GetSpecialChannelContains(), GetSpecialDescript(), and PurgeComponents().

std::map<PlexStripEndId,PlexLedId> Plexus::fStripEndToLed [mutable, protected]

Definition at line 157 of file Plexus.h. Referenced by BuildLedMaps(), GetAllLeds(), GetLedId(), GetStripEndIdVector(), Print(), and PurgeComponents().

std::map<PlexStripEndId,PlexPixelSpotId> Plexus::fStripEndToSpot [mutable, protected]

Definition at line 145 of file Plexus.h. Referenced by BuildPixelMaps(), GetAllPixelSpotIds(), GetAllStripEnds(), GetPixelSpotId(), GetRawChannelId(), GetSEIdAltL(), GetStripEndId(), Print(), and PurgeComponents().

VldRange Plexus::fVldRange [mutable, protected]

outstanding handles Definition at line 136 of file Plexus.h. Referenced by IsCompatible(), Plexus(), Print(), and TrimVldRange().

---

The documentation for this class was generated from the following files:

• Plexus.h
• Plexus.cxx

---