CMSSW Reference Manual

00001 // Last commit: $Id: SiStripFedCablingBuilderFromDb.cc,v 1.55 2008/07/09 17:03:33 bainbrid Exp $
00002 
00003 #include "OnlineDB/SiStripESSources/interface/SiStripFedCablingBuilderFromDb.h"
00004 #include "CalibFormats/SiStripObjects/interface/SiStripFecCabling.h"
00005 #include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
00006 #include "CondFormats/SiStripObjects/interface/FedChannelConnection.h"
00007 #include "DataFormats/SiStripCommon/interface/SiStripEnumsAndStrings.h"
00008 #include "DataFormats/SiStripCommon/interface/SiStripFecKey.h"
00009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
00010 #include "FWCore/ServiceRegistry/interface/Service.h"
00011 #include "OnlineDB/SiStripConfigDb/interface/SiStripConfigDb.h"
00012 #include <cstdlib>
00013 #include <iostream>
00014 #include <sstream>
00015 #include <iomanip>
00016 
00017 using namespace std;
00018 using namespace sistrip;
00019 
00020 // -----------------------------------------------------------------------------
00022 SiStripFedCablingBuilderFromDb::SiStripFedCablingBuilderFromDb( const edm::ParameterSet& pset ) 
00023   : SiStripFedCablingESProducer( pset ),
00024     db_(0),
00025     source_(sistrip::UNDEFINED_CABLING_SOURCE)
00026 {
00027   findingRecord<SiStripFedCablingRcd>();
00028   
00029   LogTrace(mlCabling_) 
00030     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00031     << " Constructing object...";
00032   
00033   // Defined cabling "source" (connections, devices, detids)
00034   string source = pset.getUntrackedParameter<string>( "CablingSource", "UNDEFINED" );
00035   source_ = SiStripEnumsAndStrings::cablingSource( source );
00036   
00037   LogTrace(mlCabling_) 
00038     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00039     << " CablingSource configurable set to \"" << source << "\""
00040     << ". CablingSource member data set to: \"" 
00041     << SiStripEnumsAndStrings::cablingSource( source_ ) << "\"";
00042 }
00043 
00044 // -----------------------------------------------------------------------------
00046 SiStripFedCablingBuilderFromDb::~SiStripFedCablingBuilderFromDb() {
00047   LogTrace(mlCabling_)
00048     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00049     << " Destructing object...";
00050 }
00051 
00052 // -----------------------------------------------------------------------------
00054 SiStripFedCabling* SiStripFedCablingBuilderFromDb::make( const SiStripFedCablingRcd& ) {
00055   LogTrace(mlCabling_) 
00056     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00057     << " Constructing FED cabling...";
00058    
00059   // Create FED cabling object 
00060   SiStripFedCabling* fed_cabling = new SiStripFedCabling();
00061   
00062   // Build and retrieve SiStripConfigDb object using service
00063   db_ = edm::Service<SiStripConfigDb>().operator->(); 
00064 
00065   // Check pointer
00066   if ( db_ ) {
00067     edm::LogVerbatim(mlCabling_)
00068       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00069       << " Pointer to SiStripConfigDb: 0x" 
00070       << std::setw(8) << std::setfill('0')
00071       << std::hex << db_ << std::dec;
00072   } else {
00073     edm::LogError(mlCabling_)
00074       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00075       << " NULL pointer to SiStripConfigDb returned by DB \"service\"!"
00076       << " Cannot build FED cabling object!";
00077     return fed_cabling;
00078   }
00079   
00080   // Check if DB connection is made 
00081   if ( db_->deviceFactory() || 
00082        db_->databaseCache() ) { 
00083     
00084     // Build FEC cabling object
00085     SiStripFecCabling fec_cabling;
00086     buildFecCabling( db_, fec_cabling, source_ );
00087     
00088     // Populate FED cabling object
00089     getFedCabling( fec_cabling, *fed_cabling );
00090     
00091     // Call virtual method that writes FED cabling object to conditions DB
00092     writeFedCablingToCondDb( *fed_cabling );
00093     
00094     // Prints FED cabling
00095     //stringstream ss;
00096     //ss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]" 
00097     //<< " Printing cabling map..." << endl 
00098     //<< *fed_cabling;
00099     //LogTrace(mlCabling_) << ss.str();
00100     
00101   } else {
00102     edm::LogError(mlCabling_)
00103       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00104       << " NULL pointers to DeviceFactory and DatabaseCache returned by SiStripConfigDb!"
00105       << " Cannot build FED cabling object!";
00106   }
00107   
00108   return fed_cabling;
00109   
00110 }
00111 
00112 // -----------------------------------------------------------------------------
00114 void SiStripFedCablingBuilderFromDb::buildFecCabling( SiStripConfigDb* const db,
00115                                                       SiStripFecCabling& fec_cabling,
00116                                                       const sistrip::CablingSource& source ) {
00117 
00118   if      ( source == sistrip::CABLING_FROM_CONNS )       { buildFecCablingFromFedConnections( db, fec_cabling ); }
00119   else if ( source == sistrip::CABLING_FROM_DEVICES )     { buildFecCablingFromDevices( db, fec_cabling ); }
00120   else if ( source == sistrip::CABLING_FROM_DETIDS )      { buildFecCablingFromDetIds( db, fec_cabling ); }
00121   else if ( source == sistrip::UNDEFINED_CABLING_SOURCE ) {
00122     
00123     LogTrace(mlCabling_)
00124       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00125       << " Unexpected value for CablingSource: \"" 
00126       << SiStripEnumsAndStrings::cablingSource( source )
00127       << "\" Querying DB in order to build cabling from one of connections, devices or DetIds...";
00128     buildFecCabling( db, fec_cabling );
00129     return;
00130     
00131   } else {
00132 
00133     edm::LogError(mlCabling_)
00134       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00135       << " Cannot build SiStripFecCabling object!"
00136       << " sistrip::CablingSource has value: "  
00137       << SiStripEnumsAndStrings::cablingSource( source );
00138     return;
00139 
00140   }
00141 
00142   // Debug
00143   const NumberOfDevices& devs = fec_cabling.countDevices();
00144   std::stringstream ss;
00145   ss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00146      << " Built SiStripFecCabling object with following devices:" 
00147      << endl << devs;
00148   edm::LogVerbatim(mlCabling_) << ss.str() << endl;
00149   
00150 }
00151 
00152 // -----------------------------------------------------------------------------
00154 void SiStripFedCablingBuilderFromDb::buildFecCabling( SiStripConfigDb* const db,
00155                                                       SiStripFecCabling& fec_cabling ) {
00156   LogTrace(mlCabling_)
00157     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00158     << " Building cabling object...";
00159   
00160   if      ( !db->getFedConnections().empty() )     { buildFecCablingFromFedConnections( db, fec_cabling ); }
00161   else if ( !db->getDeviceDescriptions().empty() ) { buildFecCablingFromDevices( db, fec_cabling ); }
00162   else if ( !db->getDcuDetIds().empty() )          { buildFecCablingFromDetIds( db, fec_cabling ); }
00163   else { 
00164     
00165     edm::LogError(mlCabling_)
00166       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00167       << " Cannot build SiStripFecCabling object!"
00168       << " FedConnections, DeviceDescriptions and DcuDetIds vectors are all empty!";
00169     return;
00170 
00171   }
00172   
00173   // Debug
00174   const NumberOfDevices& devices = fec_cabling.countDevices();
00175   std::stringstream ss;
00176   ss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00177      << " Built SiStripFecCabling object with following devices:" 
00178      << std::endl << devices;
00179   edm::LogVerbatim(mlCabling_) << ss.str() << endl;
00180   
00181 }
00182 
00183 // -----------------------------------------------------------------------------
00219 void SiStripFedCablingBuilderFromDb::buildFecCablingFromFedConnections( SiStripConfigDb* const db,
00220                                                                         SiStripFecCabling& fec_cabling ) {
00221   edm::LogVerbatim(mlCabling_)
00222     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00223     << " Building FEC cabling from FED connections descriptions...";
00224   
00225   // ---------- Some initialization ----------
00226   
00227   //fec_cabling.clear(); //@@ Need to add method to "clear" FecCabling?
00228   
00229   // ---------- Retrieve connection descriptions from database ----------
00230   
00231   SiStripConfigDb::FedConnectionsRange conns = db->getFedConnections();
00232   if ( conns.empty() ) { 
00233     edm::LogError(mlCabling_) 
00234       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00235       << " Unable to build FEC cabling!"
00236       << " No entries in FedConnections vector!";
00237     return;
00238   }
00239   
00240   // ---------- Retrieve DCU-DetId vector from database ----------
00241 
00242   LogTrace(mlCabling_) 
00243     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00244     << " Retrieving DCU-DetId vector from database...";
00245   SiStripConfigDb::DcuDetIdsRange range = db->getDcuDetIds();
00246   const SiStripConfigDb::DcuDetIdsV dcu_detid_vector( range.begin(), range.end() );
00247   if ( !dcu_detid_vector.empty() ) { 
00248     LogTrace(mlCabling_) 
00249       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00250       << " Found " << dcu_detid_vector.size()
00251       << " entries in DCU-DetId vector retrieved from database!";
00252   } else {
00253     edm::LogWarning(mlCabling_)
00254       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00255       << " No entries in DCU-DetId vector retrieved from database!";
00256   }
00257 
00258   // ---------- Populate FEC cabling object with retrieved info ----------
00259 
00260   SiStripConfigDb::FedConnectionsV::const_iterator ifed = conns.begin();
00261   SiStripConfigDb::FedConnectionsV::const_iterator jfed = conns.end();
00262   for ( ; ifed != jfed; ++ifed ) {
00263     
00264     if ( !(*ifed) ) {
00265       edm::LogWarning(mlCabling_)
00266         << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00267         << " NULL pointer to FedConnection!";
00268       continue;
00269     }
00270     
00271 #ifdef USING_NEW_DATABASE_MODEL
00272     //uint16_t fec_id    = static_cast<uint16_t>( (*ifed)->getFecHardwareId() );
00273     uint16_t fec_crate = static_cast<uint16_t>( (*ifed)->getFecCrateId() + sistrip::FEC_CRATE_OFFSET ); //@@ temporary offset!
00274     uint16_t fec_slot  = static_cast<uint16_t>( (*ifed)->getFecSlot() );
00275     uint16_t fec_ring  = static_cast<uint16_t>( (*ifed)->getRingSlot() + sistrip::FEC_RING_OFFSET ); //@@ temporary offset!
00276     uint16_t ccu_addr  = static_cast<uint16_t>( (*ifed)->getCcuAddress() );
00277     uint16_t ccu_chan  = static_cast<uint16_t>( (*ifed)->getI2cChannel() );
00278     uint16_t apv0      = static_cast<uint16_t>( (*ifed)->getApvAddress() );
00279     uint16_t apv1      = apv0 + 1; //@@ needs implementing!
00280     uint32_t dcu_id    = static_cast<uint32_t>( (*ifed)->getDcuHardId() );
00281     uint32_t det_id    = 0; //@@ static_cast<uint32_t>( (*ifed)->getDetId() );
00282     uint16_t npairs    = 0; //@@ static_cast<uint16_t>( (*ifed)->getApvPairs() ); 
00283     uint16_t fed_id    = static_cast<uint16_t>( (*ifed)->getFedId() );
00284     uint16_t fed_ch    = static_cast<uint16_t>( (*ifed)->getFedChannel() );
00285     uint16_t length    = 0; //@@ static_cast<uint16_t>( (*ifed)->getFiberLength() );
00286 #else
00287     uint16_t fec_crate = static_cast<uint16_t>( (*ifed)->getFecInstance() + sistrip::FEC_CRATE_OFFSET ); //@@ temporary offset!
00288     uint16_t fec_slot  = static_cast<uint16_t>( (*ifed)->getSlot() );
00289     uint16_t fec_ring  = static_cast<uint16_t>( (*ifed)->getRing() + sistrip::FEC_RING_OFFSET ); //@@ temporary offset!
00290     uint16_t ccu_addr  = static_cast<uint16_t>( (*ifed)->getCcu() );
00291     uint16_t ccu_chan  = static_cast<uint16_t>( (*ifed)->getI2c() );
00292     uint16_t apv0      = static_cast<uint16_t>( (*ifed)->getApv() );
00293     uint16_t apv1      = apv0 + 1; //@@ needs implementing!
00294     uint32_t dcu_id    = static_cast<uint32_t>( (*ifed)->getDcuHardId() );
00295     uint32_t det_id    = static_cast<uint32_t>( (*ifed)->getDetId() );
00296     uint16_t npairs    = static_cast<uint16_t>( (*ifed)->getApvPairs() );
00297     uint16_t fed_id    = static_cast<uint16_t>( (*ifed)->getFedId() );
00298     uint16_t fed_ch    = static_cast<uint16_t>( (*ifed)->getFedChannel() ); // "internal" numbering scheme
00299     uint16_t length    = static_cast<uint16_t>( (*ifed)->getFiberLength() );
00300 #endif
00301 
00302     FedChannelConnection conn( fec_crate, fec_slot, fec_ring, ccu_addr, ccu_chan,
00303                                apv0, apv1,
00304                                dcu_id, det_id, npairs,
00305                                fed_id, fed_ch,
00306                                length );
00307 
00308     uint16_t fed_crate = sistrip::invalid_; 
00309     uint16_t fed_slot  = sistrip::invalid_; 
00310 #ifdef USING_NEW_DATABASE_MODEL
00311     fed_crate = static_cast<uint16_t>( (*ifed)->getFedCrateId() );
00312     fed_slot  = static_cast<uint16_t>( (*ifed)->getFedSlot() );
00313 #else
00314     uint16_t id = static_cast<uint16_t>( (*ifed)->getFedId() );
00315     fed_crate = id / 16 + 1; // dummy numbering: FED crate starts from 1 (16 FEDs per crate)
00316     fed_slot  = id % 16 + 2; // dummy numbering: FED slot starts from 2 (16 FEDs per crate)
00317 #endif
00318     conn.fedCrate( fed_crate );
00319     conn.fedSlot( fed_slot );
00320 
00321     fec_cabling.addDevices( conn );
00322 
00323   }
00324   
00325   // ---------- Assign DCU and DetIds and then FED cabling ----------
00326   
00327   assignDcuAndDetIds( fec_cabling, dcu_detid_vector );
00328   
00329 }
00330 
00331 // -----------------------------------------------------------------------------
00374 void SiStripFedCablingBuilderFromDb::buildFecCablingFromDevices( SiStripConfigDb* const db,
00375                                                                  SiStripFecCabling& fec_cabling ) {
00376   edm::LogVerbatim(mlCabling_) 
00377     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00378     << " Building FEC cabling object from device descriptions...";
00379   
00380   // ---------- Some initialization ----------
00381 
00382   // fec_cabling.clear(); //@@ Need to add method to "clear" FecCabling?
00383   
00384   // ---------- Retrieve APV descriptions from database ----------
00385   
00386   LogTrace(mlCabling_) 
00387     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00388     << " Retrieving APV descriptions from database...";
00389   SiStripConfigDb::DeviceDescriptionsRange apv_desc = db->getDeviceDescriptions( APV25 );
00390   if ( !apv_desc.empty() ) { 
00391     LogTrace(mlCabling_) 
00392       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00393       << " Retrieved " << apv_desc.size()
00394       << " APV descriptions from database!";
00395   } else {
00396     edm::LogError(mlCabling_) 
00397       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00398       << " Unable to build FEC cabling!"
00399       << " No APV descriptions found!";
00400     return;
00401   }
00402   
00403   // ---------- Retrieve DCU descriptions from database ----------
00404 
00405   LogTrace(mlCabling_) 
00406     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00407     << " Retrieving DCU descriptions from database...";
00408   SiStripConfigDb::DeviceDescriptionsRange dcu_desc = db->getDeviceDescriptions( DCU );
00409 
00410   if ( !dcu_desc.empty() ) { 
00411 
00412     uint16_t feh = 0;
00413     uint16_t ccu = 0;
00414     SiStripConfigDb::DeviceDescriptionsV::const_iterator idcu;
00415     for ( idcu = dcu_desc.begin(); idcu != dcu_desc.end(); idcu++ ) {
00416       dcuDescription* dcu = dynamic_cast<dcuDescription*>( *idcu );
00417       if ( !dcu ) { continue; }
00418       if ( dcu->getDcuType() == "FEH" ) { feh++; }
00419       else { ccu++; }
00420     }
00421 
00422     LogTrace(mlCabling_) 
00423       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00424       << " Retrieved " << feh
00425       << " DCU-FEH descriptions from database!"
00426       << " (and a further " << ccu << " DCUs for CCU modules, etc...)";
00427 
00428   } else {
00429     edm::LogWarning(mlCabling_)
00430       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00431       << " No DCU descriptions found!";
00432   }
00433   
00434   // ---------- Retrieve DCU-DetId vector from database ----------
00435 
00436 
00437   LogTrace(mlCabling_) 
00438     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00439     << " Retrieving DCU-DetId vector from database...";
00440   SiStripConfigDb::DcuDetIdsRange range = db->getDcuDetIds();
00441   const SiStripConfigDb::DcuDetIdsV dcu_detid_vector( range.begin(), range.end() );
00442   if ( !dcu_detid_vector.empty() ) { 
00443     LogTrace(mlCabling_) 
00444       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00445       << " Found " << dcu_detid_vector.size()
00446       << " entries in DCU-DetId vector retrieved from database!";
00447   } else {
00448     edm::LogWarning(mlCabling_)
00449       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00450       << " No entries in DCU-DetId vector retrieved from database!";
00451   }
00452 
00453   // ---------- Retrieve FED ids from database ----------
00454   
00455   LogTrace(mlCabling_) 
00456     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00457     << " Retrieving FED ids from database...";
00458   SiStripConfigDb::FedIdsRange fed_ids = db->getFedIds();
00459   
00460   if ( !fed_ids.empty() ) { 
00461     LogTrace(mlCabling_) 
00462       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00463       << " Retrieved " << fed_ids.size()
00464       << " FED ids from database!";
00465   } else {
00466     edm::LogWarning(mlCabling_)
00467       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00468       << " No FED ids found!";
00469   }
00470   
00471   // ---------- Populate FEC cabling object with retrieved info ----------
00472 
00473   edm::LogVerbatim(mlCabling_) 
00474     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00475     << " Building FEC cabling object from APV and DCU descriptions...";
00476   
00477   SiStripConfigDb::DeviceDescriptionsV::const_iterator iapv;
00478   for ( iapv = apv_desc.begin(); iapv != apv_desc.end(); iapv++ ) {
00479     
00480     if ( !(*iapv) ) {
00481       edm::LogWarning(mlCabling_)
00482         << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00483         << " NULL pointer to DeviceDescription (of type APV25)!";
00484       continue;
00485     }
00486     
00487     SiStripConfigDb::DeviceAddress addr = db->deviceAddress(**iapv);
00488     FedChannelConnection conn( addr.fecCrate_ + sistrip::FEC_CRATE_OFFSET, //@@ temp
00489                                addr.fecSlot_, 
00490                                addr.fecRing_ + sistrip::FEC_RING_OFFSET, //@@ temp
00491                                addr.ccuAddr_, 
00492                                addr.ccuChan_, 
00493                                addr.i2cAddr_ ); 
00494     fec_cabling.addDevices( conn );
00495 
00496   } 
00497   
00498   SiStripConfigDb::DeviceDescriptionsV::const_iterator idcu;
00499   for ( idcu = dcu_desc.begin(); idcu != dcu_desc.end(); idcu++ ) {
00500 
00501     if ( !(*idcu) ) {
00502       edm::LogWarning(mlCabling_)
00503         << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00504         << " NULL pointer to DeviceDescription (of type DCU)!";
00505       continue;
00506     }
00507 
00508     SiStripConfigDb::DeviceAddress addr = db->deviceAddress(**idcu);
00509     dcuDescription* dcu = dynamic_cast<dcuDescription*>( *idcu );
00510     if ( !dcu ) { continue; }
00511     if ( dcu->getDcuType() != "FEH" ) { continue; }
00512     FedChannelConnection conn( addr.fecCrate_ + sistrip::FEC_CRATE_OFFSET, //@@ temp,
00513                                addr.fecSlot_, 
00514                                addr.fecRing_ + sistrip::FEC_RING_OFFSET, //@@ temp, 
00515                                addr.ccuAddr_, 
00516                                addr.ccuChan_,
00517                                0, 0, // APV I2C addresses not used
00518                                dcu->getDcuHardId() ); 
00519     fec_cabling.dcuId( conn );
00520 
00521   }
00522 
00523   LogTrace(mlCabling_) 
00524     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00525     << " Finished building FEC cabling object from APV and DCU descriptions!";
00526 
00527   NumberOfDevices devs1 = fec_cabling.countDevices();
00528   std::stringstream ss1;
00529   ss1 << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00530       << " Number of devices in FEC cabling object:" << std::endl;
00531   devs1.print(ss1);
00532   LogTrace(mlCabling_) << ss1.str();
00533 
00534   // ---------- Counters used in assigning "dummy" FED ids and channels ----------
00535   
00536   std::vector<uint16_t>::const_iterator ifed = fed_ids.begin();
00537   uint16_t fed_ch = 0;
00538   
00539   // ---------- Assign "dummy" FED crates/slots/ids/chans to constructed modules ----------
00540 
00541   std::vector<uint32_t> used_keys;
00542 
00543   LogTrace(mlCabling_) 
00544     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00545     << " Randomly assigning FED ids/channels to APV pairs in front-end modules...";
00546 
00547   if ( fed_ids.empty() ) {
00548     edm::LogError(mlCabling_)
00549       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00550       << " No FED ids retrieved from database! Unable to cable system!";
00551   } else {
00552 
00553     bool complete = false;
00554     std::vector<SiStripFecCrate>::const_iterator icrate = fec_cabling.crates().begin();
00555     std::vector<SiStripFecCrate>::const_iterator jcrate = fec_cabling.crates().end();
00556     while ( !complete && icrate != jcrate ) {
00557       std::vector<SiStripFec>::const_iterator ifec = icrate->fecs().begin();
00558       std::vector<SiStripFec>::const_iterator jfec = icrate->fecs().end();
00559       while ( !complete && ifec != jfec ) {
00560         std::vector<SiStripRing>::const_iterator iring = ifec->rings().begin();
00561         std::vector<SiStripRing>::const_iterator jring = ifec->rings().end();
00562         while ( !complete && iring != jring ) {
00563           std::vector<SiStripCcu>::const_iterator iccu = iring->ccus().begin(); 
00564           std::vector<SiStripCcu>::const_iterator jccu = iring->ccus().end(); 
00565           while ( !complete && iccu != jccu ) {
00566             std::vector<SiStripModule>::const_iterator imod = iccu->modules().begin(); 
00567             std::vector<SiStripModule>::const_iterator jmod = iccu->modules().end(); 
00568             while ( !complete && imod != jmod ) {
00569             
00570               // Set number of APV pairs based on devices found 
00571               const_cast<SiStripModule&>(*imod).nApvPairs(0); 
00572               
00573               used_keys.push_back( SiStripFecKey( imod->fecCrate(),
00574                                                   imod->fecSlot(), 
00575                                                   imod->fecRing(),
00576                                                   imod->ccuAddr(), 
00577                                                   imod->ccuChan() ).key() );
00578               
00579 //            // Add middle LLD channel if missing (to guarantee all FED channels are cabled!)
00580 //            if ( imod->nApvPairs() == 2 ) {
00581 //              const_cast<SiStripModule&>(*imod).nApvPairs(3); 
00582 //              FedChannelConnection temp( imod->fecCrate(),
00583 //                                         imod->fecSlot(), 
00584 //                                         imod->fecRing(),
00585 //                                         imod->ccuAddr(), 
00586 //                                         imod->ccuChan(), 
00587 //                                         SiStripFecKey::i2cAddr(2,true),
00588 //                                         SiStripFecKey::i2cAddr(2,false) ); 
00589 //              const_cast<SiStripModule&>(*imod).addDevices( temp );
00590 //            }
00591 //            const_cast<SiStripModule&>(*imod).nApvPairs(0); 
00592             
00593               // Iterate through APV pairs 
00594               for ( uint16_t ipair = 0; ipair < imod->nApvPairs(); ipair++ ) {
00595               
00596                 // Check FED id and channel
00597                 if ( ifed == fed_ids.end() ) { fed_ch++; ifed = fed_ids.begin(); } 
00598                 if ( fed_ch == 96 ) {
00599                   edm::LogWarning(mlCabling_)
00600                     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00601                     << " Insufficient FED channels to cable all devices in control system!";
00602                   complete = true;
00603                   break;
00604                 }
00605               
00606                 // Set "dummy" FED id and channel
00607                 pair<uint16_t,uint16_t> addr = imod->activeApvPair( imod->lldChannel(ipair) );
00608                 SiStripModule::FedChannel fed_channel( (*ifed)/16+1, // 16 FEDs per crate, numbering starts from 1
00609                                                        (*ifed)%16+2, // FED slot starts from 2
00610                                                        *ifed, 
00611                                                        fed_ch );
00612                 const_cast<SiStripModule&>(*imod).fedCh( addr.first, fed_channel );
00613                 ifed++;
00614               
00615               }
00616             
00617               imod++;
00618             }
00619             iccu++;
00620           }
00621           iring++;
00622         }
00623         ifec++;
00624       }
00625       icrate++;
00626     }
00627 
00628   }
00629 
00630   std::sort( used_keys.begin(), used_keys.end() );
00631 
00632   NumberOfDevices devs2 = fec_cabling.countDevices();
00633   std::stringstream ss2;
00634   ss2 << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00635       << " Number of devices in FEC cabling object:" << std::endl;
00636   devs2.print(ss2);
00637   LogTrace(mlCabling_) << ss2.str();
00638 
00639   LogTrace(mlCabling_) 
00640     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00641     << " Finished randomly assigning FED ids/channels to APV pairs in front-end modules...";
00642  
00643   // ---------- Assign "dummy" devices to remaining FED ids/chans ----------
00644 
00645   LogTrace(mlCabling_) 
00646     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00647     << " Assigning APV pairs in dummy front-end modules to any remaining \"uncabled\" FED ids/channels...";
00648 
00649   if ( fed_ids.empty() ) {
00650     edm::LogError(mlCabling_)
00651       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00652       << " No FED ids retrieved from database! Unable to cable system!";
00653   } else {
00654 
00655     uint16_t module = 0;
00656     bool complete = false;
00657     while ( !complete ) { 
00658       for ( uint16_t lld = sistrip::LLD_CHAN_MIN; lld < sistrip::LLD_CHAN_MAX+1; lld++ ) {
00659       
00660         // Check FED id and channel
00661         if ( ifed == fed_ids.end() ) { fed_ch++; ifed = fed_ids.begin(); } 
00662         if ( fed_ch == 96 ) {
00663           LogTrace(mlCabling_)
00664             << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00665             << " All FED channels are now cabled!";
00666           complete = true;
00667           break;
00668         }
00669 
00670         uint32_t key = SiStripFecKey( fecCrate( module ), 
00671                                       fecSlot( module ), 
00672                                       fecRing( module ), 
00673                                       ccuAddr( module ), 
00674                                       ccuChan( module ) ).key();
00675         
00676         //if ( std::find( used_keys.begin(), used_keys.end(), key ) != used_keys.end() ) { break; }
00677         
00678         FedChannelConnection temp( fecCrate( module ), 
00679                                    fecSlot( module ), 
00680                                    fecRing( module ), 
00681                                    ccuAddr( module ), 
00682                                    ccuChan( module ), 
00683                                    SiStripFecKey::i2cAddr(lld,true),
00684                                    SiStripFecKey::i2cAddr(lld,false),
00685                                    sistrip::invalid32_,
00686                                    sistrip::invalid32_,
00687                                    3, // npairs
00688                                    *ifed, 
00689                                    fed_ch );
00690         uint16_t fed_crate = (*ifed)/16+1; // 16 FEDs per crate, numbering starts from 1
00691         uint16_t fed_slot  = (*ifed)%16+2; // FED slot starts from 2
00692         temp.fedCrate( fed_crate );
00693         temp.fedSlot( fed_slot );
00694         fec_cabling.addDevices( temp );
00695         ifed++;
00696       
00697       } 
00698       module++;
00699     }
00700 
00701   }
00702 
00703   LogTrace(mlCabling_) 
00704     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00705     << " Finished assigning APV pairs in dummy front-end modules to any remaining \"uncabled\" FED ids/channels...";
00706 
00707   NumberOfDevices devs3 = fec_cabling.countDevices();
00708   std::stringstream ss3;
00709   ss3 << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00710       << " Number of devices in FEC cabling object:" << std::endl;
00711   devs3.print(ss3);
00712   LogTrace(mlCabling_) << ss3.str();
00713 
00714   // ---------- Assign DCU and DetIds and then FED cabling ----------
00715   
00716   assignDcuAndDetIds( fec_cabling, dcu_detid_vector );
00717   
00718 }
00719 
00720 // -----------------------------------------------------------------------------
00758 void SiStripFedCablingBuilderFromDb::buildFecCablingFromDetIds( SiStripConfigDb* const db,
00759                                                                 SiStripFecCabling& fec_cabling ) {
00760   edm::LogVerbatim(mlCabling_)
00761     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00762     << " Building FEC cabling object from DetIds...";
00763   
00764   // ---------- Some initialization ----------
00765 
00766   // fec_cabling.clear();
00767   
00768   // chans_per_ring = chans_per_ccu * ccus_per_ring = 100 (TOB gives lower limit of 60)
00769   uint32_t chans_per_ccu  = 10; 
00770   uint32_t ccus_per_ring  = 10;
00771   uint32_t rings_per_fec  = 8;
00772   uint32_t fecs_per_crate = 11;
00773 
00774   // ---------- Retrieve necessary descriptions from database ----------
00775 
00776 
00777   LogTrace(mlCabling_) 
00778     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00779     << " Retrieving DCU-DetId vector from database...";
00780   SiStripConfigDb::DcuDetIdsRange range = db->getDcuDetIds();
00781   const SiStripConfigDb::DcuDetIdsV dcu_detid_vector( range.begin(), range.end() );
00782   if ( !dcu_detid_vector.empty() ) { 
00783     LogTrace(mlCabling_) 
00784       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00785       << " Found " << dcu_detid_vector.size()
00786       << " entries in DCU-DetId vector retrieved from database!";
00787   } else {
00788     edm::LogWarning(mlCabling_)
00789       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00790       << " No entries in DCU-DetId vector retrieved from database!"
00791       << " Unable to build FEC cabling!";
00792     return;
00793   }
00794 
00795   // ---------- Populate FEC cabling object with DCU, DetId and "dummy" control info ----------
00796 
00797   uint32_t imodule = 0;
00798   SiStripConfigDb::DcuDetIdsV::const_iterator iter;
00799   for ( iter = dcu_detid_vector.begin(); iter != dcu_detid_vector.end(); iter++ ) {
00800 
00801     if ( !(iter->second) ) {
00802       edm::LogWarning(mlCabling_)
00803         << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00804         << " NULL pointer to TkDcuInfo!";
00805       continue;
00806     }
00807     
00808     uint16_t fec_crate = ( imodule / ( chans_per_ccu * ccus_per_ring * rings_per_fec * fecs_per_crate ) ) + 1;
00809     uint16_t fec_slot  = ( imodule / ( chans_per_ccu * ccus_per_ring * rings_per_fec ) ) % fecs_per_crate + 2;
00810     uint16_t fec_ring  = ( imodule / ( chans_per_ccu * ccus_per_ring ) ) % rings_per_fec + 1;
00811     uint16_t ccu_addr  = ( imodule / ( chans_per_ccu) ) % ccus_per_ring + 1;
00812     uint16_t ccu_chan  = ( imodule ) % chans_per_ccu + 16;
00813     
00814     uint32_t dcu_id = iter->second->getDcuHardId(); // 
00815     uint32_t det_id = iter->second->getDetId();
00816     uint16_t npairs = iter->second->getApvNumber()/2;
00817     uint16_t length = (uint16_t) iter->second->getFibreLength(); //@@ should be double!
00818 
00819     // --- Check if DCU, DetId and nApvPairs are null ---
00820 
00821     if ( !dcu_id ) {
00822       dcu_id = SiStripFecKey( fec_crate,
00823                               fec_slot,
00824                               fec_ring,
00825                               ccu_addr,
00826                               ccu_chan ).key();
00827     }
00828     if ( !det_id ) { det_id = 0xFFFF + imodule; } 
00829     if ( !npairs ) { npairs = rand()/2 ? 2 : 3; }
00830     
00831     // --- Construct FedChannelConnection objects ---
00832 
00833     for ( uint16_t ipair = 0; ipair < npairs; ipair++ ) {
00834       uint16_t iapv = 
00835         ( ipair == 1 && npairs == 2 ) ?
00836         ( iapv = 36 ) :
00837         ( iapv = 32 + 2 * ipair ) ;
00838       FedChannelConnection conn( fec_crate, 
00839                                  fec_slot, 
00840                                  fec_ring, 
00841                                  ccu_addr, 
00842                                  ccu_chan, 
00843                                  iapv, iapv+1,
00844                                  dcu_id, det_id, npairs,
00845                                  0, 0, // FED id and channel
00846                                  length,
00847                                  true, true, true, true );
00848       fec_cabling.addDevices( conn );
00849     } 
00850 
00851     imodule++;
00852   }
00853 
00854   // ---------- Assign "dummy" FED ids/chans to Modules of FEC cabling object ----------
00855   
00856   uint32_t fed_id = 50;
00857   uint32_t fed_ch = 0;
00858   for ( vector<SiStripFecCrate>::const_iterator icrate = fec_cabling.crates().begin(); icrate != fec_cabling.crates().end(); icrate++ ) {
00859     for ( vector<SiStripFec>::const_iterator ifec = icrate->fecs().begin(); ifec != icrate->fecs().end(); ifec++ ) {
00860       for ( vector<SiStripRing>::const_iterator iring = ifec->rings().begin(); iring != ifec->rings().end(); iring++ ) {
00861         for ( vector<SiStripCcu>::const_iterator iccu = iring->ccus().begin(); iccu != iring->ccus().end(); iccu++ ) {
00862           for ( vector<SiStripModule>::const_iterator imod = iccu->modules().begin(); imod != iccu->modules().end(); imod++ ) {
00863             if ( 96-fed_ch < imod->nApvPairs() ) { fed_id++; fed_ch = 0; } // move to next FED
00864             for ( uint16_t ipair = 0; ipair < imod->nApvPairs(); ipair++ ) {
00865               pair<uint16_t,uint16_t> addr = imod->activeApvPair( (*imod).lldChannel(ipair) );
00866               SiStripModule::FedChannel fed_channel( (fed_id-50)/16+1, // 16 FEDs per crate, numbering starts from 1
00867                                                      (fed_id-50)%16+2, // FED slot starts from 2
00868                                                      fed_id, 
00869                                                      fed_ch );
00870               const_cast<SiStripModule&>(*imod).fedCh( addr.first, fed_channel );
00871               fed_ch++;
00872             }
00873           }
00874         }
00875       }
00876     }
00877   }
00878 
00879 }
00880 
00881 // -----------------------------------------------------------------------------
00883 void SiStripFedCablingBuilderFromDb::assignDcuAndDetIds( SiStripFecCabling& fec_cabling,
00884                                                          std::vector< std::pair<uint32_t,TkDcuInfo*> > in ) {
00885   
00886   // ---------- Check if entries found in DCU-DetId vector ----------
00887 
00888   if ( in.empty() ) { 
00889     edm::LogError(mlCabling_)
00890       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00891       << " No entries in DCU-DetId vector!";
00892   }
00893 
00894   // ---------- Assign DCU and DetId to Modules in FEC cabling object ----------
00895 
00896   LogTrace(mlCabling_) 
00897     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00898     << " Assigning DCU ids and DetIds to constructed modules...";
00899 
00900   uint16_t channels = 0;
00901   uint16_t six      = 0;
00902   uint16_t four     = 0;
00903   uint16_t unknown  = 0;
00904   uint16_t missing  = 0;
00905   
00906   for ( vector<SiStripFecCrate>::const_iterator icrate = fec_cabling.crates().begin(); icrate != fec_cabling.crates().end(); icrate++ ) {
00907     for ( vector<SiStripFec>::const_iterator ifec = icrate->fecs().begin(); ifec != icrate->fecs().end(); ifec++ ) {
00908       for ( vector<SiStripRing>::const_iterator iring = ifec->rings().begin(); iring != ifec->rings().end(); iring++ ) {
00909         for ( vector<SiStripCcu>::const_iterator iccu = iring->ccus().begin(); iccu != iring->ccus().end(); iccu++ ) {
00910           for ( vector<SiStripModule>::const_iterator imod = iccu->modules().begin(); imod != iccu->modules().end(); imod++ ) {
00911             SiStripModule& module = const_cast<SiStripModule&>(*imod);
00912 
00913             //@@ TEMP FIX UNTIL LAURENT DEBUGS FedChannelConnectionDescription CLASS
00914             module.nApvPairs(0);
00915             
00916             // --- Check for null DCU ---
00917             
00918             if ( !module.dcuId() ) { 
00919               SiStripFecKey path( icrate->fecCrate(),
00920                                   ifec->fecSlot(), 
00921                                   iring->fecRing(), 
00922                                   iccu->ccuAddr(), 
00923                                   imod->ccuChan() );
00924               uint32_t module_key = path.key();
00925               module.dcuId( module_key ); // Assign DCU id equal to control key
00926               stringstream ss;
00927               ss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00928                  << " Found NULL DcuId! Setting 'dummy' value based control key 0x"
00929                  << hex << setw(8) << setfill('0') << module_key << dec;
00930               edm::LogWarning(mlCabling_) << ss.str();
00931             }
00932             
00933             // --- Check for null DetId ---
00934             
00935             if ( !module.detId() ) { 
00936               
00937               // --- Search for DcuId in map ---
00938               
00939               SiStripConfigDb::DcuDetIdsV::iterator iter = in.end();
00940               iter = SiStripConfigDb::findDcuDetId( in.begin(), in.end(), module.dcuId() );
00941               if ( iter != in.end() ) { 
00942                 
00943                 if ( !(iter->second) ) {
00944                   edm::LogWarning(mlCabling_)
00945                     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
00946                     << " NULL pointer to TkDcuInfo!";
00947                   continue;
00948                 }
00949 
00950                 // --- Assign DetId and set nApvPairs based on APVs found in given Module ---
00951                 
00952                 module.detId( iter->second->getDetId() ); 
00953                 module.nApvPairs(0); 
00954                 
00955                 // count expected channels
00956                 uint16_t pairs = iter->second->getApvNumber()/2;
00957                 channels += pairs;
00958                 if ( pairs == 2 ) { four++; }
00959                 else if ( pairs == 3 ) { six++; }
00960                 else { unknown++; }
00961                 
00962                 // --- Check number of APV pairs is valid and consistent with cached map ---
00963 
00964                 if ( module.nApvPairs() != 2 && module.nApvPairs() != 3 ) { 
00965 
00966                   missing += ( iter->second->getApvNumber()/2 - module.nApvPairs() );
00967                   stringstream ss1;
00968                   ss1 << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]" << std::endl
00969                       << " Module with DCU id 0x" 
00970                       << hex << setw(8) << setfill('0') << module.dcuId() << dec
00971                       << " and DetId 0x"
00972                       << hex << setw(8) << setfill('0') << module.detId() << dec
00973                       << " has unexpected number of APV pairs (" 
00974                       << module.nApvPairs() << ")." << std::endl
00975                       << " Some APV pairs may have not been detected by the FEC scan." << std::endl
00976                       << " Setting to value found in static map (" 
00977                       << iter->second->getApvNumber()/2 << ")...";
00978                   edm::LogWarning(mlCabling_) << ss1.str();
00979                   module.nApvPairs( iter->second->getApvNumber()/2 ); 
00980 
00981                 } else if ( module.nApvPairs() < iter->second->getApvNumber()/2 ) {
00982 
00983                   missing += ( iter->second->getApvNumber()/2 - module.nApvPairs() );
00984                   stringstream ss2;
00985                   ss2 << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]" << std::endl
00986                       << " Module with DCU id 0x" 
00987                       << hex << setw(8) << setfill('0') << module.dcuId() << dec
00988                       << " and DetId 0x"
00989                       << hex << setw(8) << setfill('0') << module.detId() << dec
00990                       << " has number of APV pairs (" 
00991                       << module.nApvPairs() 
00992                       << ") that does not match value found in DCU-DetId vector (" 
00993                       << iter->second->getApvNumber()/2 << ")." << std::endl
00994                       << " Some APV pairs may have not been detected by"
00995                       << " the FEC scan or the DCU-DetId vector may be incorrect." << std::endl
00996                       << " Setting to value found in static map ("
00997                       << iter->second->getApvNumber()/2 << ")...";
00998                   edm::LogWarning(mlCabling_) << ss2.str();
00999                   module.nApvPairs( iter->second->getApvNumber()/2 ); 
01000 
01001                 }
01002                 
01003                 // --- Check for null fibre length ---
01004                 
01005                 if ( !module.length() ) { 
01006                   module.length( static_cast<uint16_t>( iter->second->getFibreLength() ) );
01007                 }
01008 
01009                 // --- Remove TkDcuInfo object from cached map ---
01010 
01011                 in.erase( iter );
01012 
01013               } // Set for DCU in static table
01014             } // Check for null DetId
01015 
01016           } // Module loop
01017         } // CCU loop
01018       } // FEC ring loop
01019     } // FEC loop
01020   } // FEC crate loop
01021 
01022   std::stringstream sss;
01023   sss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]" << std::endl
01024       << " Connections in DCU-DetId map : " << channels << std::endl
01025       << " 4-APV modules                : " << four << std::endl
01026       << " 6-APV modules                : " << six << std::endl
01027       << " Unknown number of APV pairs  : " << unknown << std::endl
01028       << " Total found APV pairs        : " << ( channels - missing ) << std::endl
01029       << " Total missing APV pairs      : " << missing << std::endl;
01030   edm::LogVerbatim(mlCabling_) << sss.str();
01031   
01032   LogTrace(mlCabling_) 
01033     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01034     << " Finished assigning DCU ids and DetIds to constructed modules...";
01035 
01036   // ---------- "Randomly" assign DetIds to Modules with DCU ids not found in static table ----------
01037 
01038   LogTrace(mlCabling_) 
01039     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01040     << " Assigning \"random\" DetIds to modules with DCU ids not found in static table...";
01041   
01042   uint32_t detid = 0x10000; // Incremented "dummy" DetId
01043   for ( vector<SiStripFecCrate>::const_iterator icrate = fec_cabling.crates().begin(); icrate != fec_cabling.crates().end(); icrate++ ) {
01044     for ( vector<SiStripFec>::const_iterator ifec = icrate->fecs().begin(); ifec != icrate->fecs().end(); ifec++ ) {
01045       for ( vector<SiStripRing>::const_iterator iring = ifec->rings().begin(); iring != ifec->rings().end(); iring++ ) {
01046         for ( vector<SiStripCcu>::const_iterator iccu = iring->ccus().begin(); iccu != iring->ccus().end(); iccu++ ) {
01047           for ( vector<SiStripModule>::const_iterator imod = iccu->modules().begin(); imod != iccu->modules().end(); imod++ ) {
01048             SiStripModule& module = const_cast<SiStripModule&>(*imod);
01049             
01050             // --- Check for null DetId and search for DCU in cached map ---
01051             
01052             if ( !module.detId() ) { 
01053               
01054               SiStripConfigDb::DcuDetIdsV::iterator iter = in.end();
01055               iter = SiStripConfigDb::findDcuDetId( in.begin(), in.end(), module.dcuId() );
01056               if ( iter != in.end() ) { 
01057                                 
01058                 // --- Search for "random" module with consistent number of APV pairs ---
01059                 
01060                 SiStripConfigDb::DcuDetIdsV::iterator idcu;
01061                 if ( in.empty() ) { idcu = in.end(); }
01062                 else {
01063                   idcu = in.begin();
01064                   while ( idcu != in.end() ) { 
01065                     if ( idcu->second ) {
01066                       if ( static_cast<uint32_t>(idcu->second->getApvNumber()) == 
01067                            static_cast<uint32_t>(2*module.nApvPairs()) ) { break; }
01068                     }
01069                     idcu++; 
01070                   }
01071                 } 
01072                 
01073                 // --- Assign "random" DetId if number of APV pairs is consistent ---
01074                 
01075                 if ( idcu != in.end() ) {
01076                   
01077                   if ( !(idcu->second) ) {
01078                     edm::LogWarning(mlCabling_)
01079                       << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01080                       << " NULL pointer to TkDcuInfo!";
01081                     continue;
01082                   }
01083 
01084                   module.detId( idcu->second->getDetId() );
01085                   in.erase( idcu );
01086                   
01087                   stringstream ss;
01088                   ss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01089                      << " Did not find module with DCU id 0x"
01090                      << hex << setw(8) << setfill('0') << module.dcuId() << dec
01091                      << " in DCU-DetId vector!" << endl
01092                      << " Assigned 'random' DetId 0x"
01093                      << hex << setw(8) << setfill('0') << module.detId() << dec;
01094                   edm::LogWarning(mlCabling_) << ss.str();
01095                   
01096                 } else { // --- Else, assign "dummy" DetId based on counter ---
01097                   
01098                   // If no match found, then assign DetId using incremented counter
01099                   module.detId( detid );
01100                   detid++;
01101 
01102                   stringstream ss;
01103                   if ( in.empty() ) {
01104                     ss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01105                        << " Did not find module with DCU id 0x"
01106                        << hex << setw(8) << setfill('0') << module.dcuId() << dec
01107                        << " in DCU-DetId vector!" 
01108                        << " Could not assign 'random' DetId as DCU-DetID map is empty!"
01109                        << " Assigned DetId based on incremented counter, with value 0x"
01110                        << hex << setw(8) << setfill('0') << module.detId() << dec;
01111                   } else {
01112                     ss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01113                        << " Did not find module with DCU id 0x"
01114                        << hex << setw(8) << setfill('0') << module.dcuId() << dec
01115                        << " in DCU-DetId vector!" 
01116                        << " Could not assign 'random' DetId as no modules had appropriate number of APV pairs ("
01117                        << module.nApvPairs()
01118                        << "). Assigned DetId based on incremented counter, with value 0x"
01119                        << hex << setw(8) << setfill('0') << module.detId() << dec;
01120                   }
01121                   edm::LogWarning(mlCabling_) << ss.str();
01122 
01123                 }
01124               }
01125 
01126             } 
01127 
01128           } // Module loop
01129         } // CCU loop
01130       } // FEC ring loop
01131     } // FEC loop
01132   } // FEC crate loop
01133 
01134   LogTrace(mlCabling_) 
01135     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01136     << " Finished assigning \"random\" DetIds to modules with DCU ids not found in static table...";
01137   
01138   LogTrace(mlCabling_) 
01139     << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01140     << " Assigning \"random\" DetIds to modules with DCU ids not found in static table...";
01141   
01142   // ---------- Check for unassigned DetIds ----------
01143   
01144   if ( !in.empty() ) {
01145     stringstream ss;
01146     ss << "[SiStripFedCablingBuilderFromDb::" << __func__ << "]"
01147        << " Not all DetIds have been assigned to a DcuId! " 
01148        << in.size() << " DetIds are unassigned!";
01149     edm::LogWarning(mlCabling_) << ss.str();
01150   }
01151   
01152 }
01153 
01154 // -----------------------------------------------------------------------------
01156 void SiStripFedCablingBuilderFromDb::getFedCabling( const SiStripFecCabling& fec_cabling, 
01157                                                     SiStripFedCabling& fed_cabling ) {
01158   vector<FedChannelConnection> conns;
01159   fec_cabling.connections( conns );
01160   fed_cabling.buildFedCabling( conns );
01161 }
01162 
01163 // -----------------------------------------------------------------------------
01165 void SiStripFedCablingBuilderFromDb::getFecCabling( const SiStripFedCabling& fed_cabling, 
01166                                                     SiStripFecCabling& fec_cabling ) {
01167   fec_cabling.buildFecCabling( fed_cabling );
01168 }
01169 
01170 // -----------------------------------------------------------------------------
01171 // 
01172 void SiStripFedCablingBuilderFromDb::setIntervalFor( const edm::eventsetup::EventSetupRecordKey& key, 
01173                                                      const edm::IOVSyncValue& iov_sync, 
01174                                                      edm::ValidityInterval& iov_validity ) {
01175   edm::ValidityInterval infinity( iov_sync.beginOfTime(), iov_sync.endOfTime() );
01176   iov_validity = infinity;
01177 }
01178