Plexus.cxx

Go to the documentation of this file.

// $Id: Plexus.cxx,v 1.48 2005/07/01 20:10:21 rhatcher Exp $
//
// Plexus
//
// Plexus is an actual connection map
//
// Author:  R. Hatcher 2000.05.03
//

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

#include "DatabaseInterface/DbiResultPtr.h"
#include "DatabaseInterface/DbiTableProxy.h"
#include "DatabaseInterface/DbiCache.h"

#include "Plex/PlexPixelSpotToStripEnd.h"
#include "Plex/PlexPixelToRawChannel.h"
#include "Plex/PlexRawChannelReadoutType.h"
#include "Plex/PlexRawChannelToPinDiode.h"
#include "Plex/PlexPinDiodeToLed.h"
#include "Plex/PlexStripEndToLed.h"

#include "Plex/PlexVetoShieldHack.h"

#include "MessageService/MsgService.h"
CVSID("$Id: Plexus.cxx,v 1.48 2005/07/01 20:10:21 rhatcher Exp $");

#include "TSystem.h"
#include "TString.h"

#include <set>
#include <cassert>

ClassImp(Plexus)

Bool_t Plexus::fgAltLHasBrokenFibers = false;

RawChannelId rcidNull;

int paranoia = 0;

//_____________________________________________________________________________
Plexus::Plexus()
   : fRef(0), fVldRange(), fBuiltMaps(0)
{
   // Default constructor
   MSG("Plex",Msg::kVerbose) << "default ctor " << endl;
}

//_____________________________________________________________________________
Plexus::Plexus(const VldContext& vldc)
   : 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() == DetectorType::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()
{
   // delete all the owned sub-objects

}

//_____________________________________________________________________________
Bool_t Plexus::IsCompatible(const VldContext &vldc)
{
   // check compatibility of this plex with a context

   return fVldRange.IsCompatible(vldc);

}

//_____________________________________________________________________________
Bool_t Plexus::IsCompatible(const VldContext *vldc)
{
   // check compatibility of this plex with a context

   return fVldRange.IsCompatible(vldc);

}

//_____________________________________________________________________________
void Plexus::Print(Option_t *option) const
{
   // 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:    %6d   PixelToChannel:     %6d\n",
            fChannelToPixel.size(),fPixelToChannel.size());
     printf("   PixelToStripEnd:   %6d   StripEndToSpot:     %6d\n",
            fPixelToStripEnd.size(),fStripEndToSpot.size());
     printf("   ChannelToReadout:  %6d\n",fChannelToReadout.size());
     printf("   ChannelToPinDiode: %6d\n",fChannelToPinDiode.size());
     printf("   StripEndToLed:     %6d   PinDiodeToLed:      %6d\n",
            fStripEndToLed.size(),fPinDiodeToLed.size());

     // classify readout types
     if (opt.Contains("r")) {
       const vector<RawChannelId>& all_rcid = GetAllRawChannelIds();
       printf("   There are %d unique RawChannelIds\n",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++;
       }
     }
   }
}

//_____________________________________________________________________________
RawChannelId Plexus::GetRawChannelId(const PlexStripEndId& seid) const
{
   // 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;
    }    
  }

   PlexPixelSpotId psid = fStripEndToSpot[seid];

   // clear the spot value as that isn't used in pixel->channel
   psid.SetSpot(0);
   return fPixelToChannel[psid];
}

//_____________________________________________________________________________
RawChannelId Plexus::GetRawChannelId(const PlexPixelSpotId& psid) const
{
   // 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);
   return fPixelToChannel[psid_nospot];
}

//_____________________________________________________________________________
RawChannelId Plexus::GetRawChannelId(const PlexPinDiodeId& diodeid) const
{
   // 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();
}

//_____________________________________________________________________________
PlexSEIdAltL Plexus::GetSEIdAltL(const RawChannelId& rcid,
                                 const PlexCalib* calib,
                                 Int_t adc, Double_t time) const
{ 
   // 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

   return altlist;
}

//_____________________________________________________________________________
PlexStripEndId Plexus::GetStripEndId(const PlexPixelSpotId& psid) const
{ 
   // 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
      PlexPixelSpotId testspot = fStripEndToSpot[seid];
      if (testspot == psid) return seid;
   }

   return PlexStripEndId();  // no match

}

//_____________________________________________________________________________
vector<PlexPixelSpotId> Plexus::GetPixelSpotIdVector(const RawChannelId& rcid, 
                                                     bool uniquePixels) const
{ 
   // 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;
}

//_____________________________________________________________________________
PlexPixelSpotId Plexus::GetPixelSpotId(const PlexStripEndId& seid) const
{ 
   // Convert PlexStripEndId into a PlexPixelSpotId (1:1)

   return fStripEndToSpot[seid];
}

//_____________________________________________________________________________
PlexPinDiodeId Plexus::GetPinDiodeId(const RawChannelId& rcid) const
{
   // Convert RawChannelId into PlexPinDiodeId (if possible)

   // the map has the {pedestal,spars,common} mode bits off
   RawChannelId rcid0 = rcid;
   rcid0.ClearModeBits();

   return fChannelToPinDiode[rcid0];
}

//_____________________________________________________________________________
ReadoutType::Readout_t Plexus::GetReadoutType(const RawChannelId& rcid) const
{ 
   // 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];

}

//_____________________________________________________________________________
std::string Plexus::GetSpecialDescript(const RawChannelId& rcid) const
{
   // if a special channel (Cerenkov, TOF, etc) from the 
   // PLEXRAWCHANNELREADOUTTYPE table return the associated string
   RawChannelId rcid0 = rcid;
   rcid0.ClearModeBits();

   return fSpecialDescript[rcid0];
}
//_____________________________________________________________________________
RawChannelId Plexus::GetSpecialChannelContains(const std::string& key)const
{
   // 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::vector<PlexStripEndId> 
Plexus::GetStripEndIdVector(const PlexLedId& ledid) const
{
   // 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;
}

//_____________________________________________________________________________
std::pair<PlexPinDiodeId,PlexPinDiodeId> 
Plexus::GetPinDiodeIds(const PlexLedId& ledid) const
{
   // 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;
         if (pinid.GetGain()) {
            // 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 = high_gain;
   diodepair.second = low_gain;
   return diodepair;
}

//_____________________________________________________________________________
PlexLedId Plexus::GetLedId(const PlexStripEndId& seid) const
{
   // Convert PlexStripEndId into a PlexLedId (N:1)

   return fStripEndToLed[seid];
}

//_____________________________________________________________________________
PlexLedId Plexus::GetLedId(const PlexPinDiodeId& diodeid) const
{
   // Convert PlexPinDiodeId into a PlexLedId (N:1)

   return fPinDiodeToLed[diodeid];
}

//_____________________________________________________________________________
const std::vector<PlexStripEndId>&
Plexus::GetAllStripEnds(StripEnd::StripEnd_t restrictEnd) const
{ 
  // 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::GetAllPixelSpotIds(Plexus::ETrimSpots trim) const
{
  // 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<RawChannelId>& 
Plexus::GetAllRawChannelIds() const
{
  // 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<PlexPinDiodeId>& 
Plexus::GetAllPinDiodes() const
{
  // 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<PlexLedId>& 
Plexus::GetAllLeds() const
{
  // 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;
}


//_____________________________________________________________________________
void Plexus::LoadRDBCHack() const
{
   static Bool_t first = true;
   if (!first) return;
   first = false;

#ifdef MINOS_PROFILE
   MSG("Plex",Msg::kWarning)
      << " skip dynamic loading of libRDBC.so" << endl;
#else
#ifdef KEEP_SILLY_HACK
   MSG("Plex",Msg::kWarning)
      << " silly hack for libRDBC.so, expect this message once"
      << endl;
   gSystem->Load("libRDBC.so");
#endif
#endif
}

//_____________________________________________________________________________
void Plexus::BuildPixelMaps(const VldContext& vldc) const
{ 
   // build the basic maps   RawChannel <--> PixelSpot <--> StripEnd

   if (kPixelMaps & fBuiltMaps) return;
   fBuiltMaps |= kPixelMaps;
   LoadRDBCHack();

   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
{ 
   // build the basic map:  RawChannel --> ReadoutType

   if (kReadoutMap & fBuiltMaps) return;
   fBuiltMaps |= kReadoutMap;
   LoadRDBCHack();

   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;
}

//_____________________________________________________________________________
void Plexus::BuildPinDiodeMap(const VldContext& vldc) const
{ 
   // build the basic map:  RawChannel --> PinDiode

   if (kPinDiodeMap & fBuiltMaps) return;
   fBuiltMaps |= kPinDiodeMap;
   LoadRDBCHack();

   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::BuildLedMaps(const VldContext& vldc) const
{ 
   // build the basic map:  StripEndIds <--> LED <--> PinDiodes

   if (kLedMaps & fBuiltMaps) return;
   fBuiltMaps |= kLedMaps;
   LoadRDBCHack();

   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::PurgeComponents(UInt_t purgeMask)
{ 
  // 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::TrimVldRange(const char* tblName,
                          const DbiValidityRec* dbivrec) const
{ 
   // 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
{ 
   // 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() == DetectorType::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;


}

//_____________________________________________________________________________

---