SiStripFedCablingFakeESSource.cc

Go to the documentation of this file.

#include "CalibTracker/SiStripESProducers/plugins/fake/SiStripFedCablingFakeESSource.h"
#include "CalibFormats/SiStripObjects/interface/SiStripFecCabling.h"
#include "CalibFormats/SiStripObjects/interface/SiStripModule.h"
#include "CalibTracker/Records/interface/SiStripHashedDetIdRcd.h"
#include "CalibTracker/SiStripCommon/interface/SiStripDetInfoFileReader.h"
#include "CalibTracker/SiStripCommon/interface/SiStripFedIdListReader.h"
#include "CondFormats/SiStripObjects/interface/FedChannelConnection.h"
#include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <sstream>
#include <vector>
#include <map>

using namespace sistrip;

// -----------------------------------------------------------------------------
//
SiStripFedCablingFakeESSource::SiStripFedCablingFakeESSource( const edm::ParameterSet& pset )
  : SiStripFedCablingESProducer( pset ),
    fedIds_( pset.getParameter<edm::FileInPath>("FedIdsFile") ),
    pset_(pset)
{
  findingRecord<SiStripFedCablingRcd>();
  edm::LogVerbatim("FedCabling") 
    << "[SiStripFedCablingFakeESSource::" << __func__ << "]"
    << " Constructing object...";
}

// -----------------------------------------------------------------------------
//
SiStripFedCablingFakeESSource::~SiStripFedCablingFakeESSource() {
  edm::LogVerbatim("FedCabling")
    << "[SiStripFedCablingFakeESSource::" << __func__ << "]"
    << " Destructing object...";
}

// -----------------------------------------------------------------------------
// 
SiStripFedCabling* SiStripFedCablingFakeESSource::make( const SiStripFedCablingRcd& ) {
  edm::LogVerbatim("FedCabling")
    << "[SiStripFedCablingFakeESSource::" << __func__ << "]"
    << " Building \"fake\" FED cabling map"
    << " from real DetIds and FedIds (read from ascii file)";
  
  // Create FEC cabling object 
  SiStripFecCabling* fec_cabling = new SiStripFecCabling();
  
  // Read DetId list from file
  const edm::Service<SiStripDetInfoFileReader> Detreader;
  typedef std::vector<uint32_t>  Dets;
  
  Dets dets = Detreader->getAllDetIds();
  
  // Read FedId list from file
  typedef std::vector<uint16_t> Feds;
  Feds feds = SiStripFedIdListReader( fedIds_.fullPath() ).fedIds();
  
  bool populateAllFeds=pset_.getParameter<bool>("PopulateAllFeds");

  // Iterator through DetInfo objects and populate FEC cabling object
  uint32_t imodule = 0;
  Dets::const_iterator idet = dets.begin();
  Dets::const_iterator jdet = dets.end();
  for ( ; idet != jdet; ++idet ) {
    uint16_t npairs =  Detreader->getNumberOfApvsAndStripLength(*idet).first / 2;
    for ( uint16_t ipair = 0; ipair < npairs; ++ipair ) {
      uint16_t addr = 0;
      if      ( npairs == 2 && ipair == 0 ) { addr = 32; }
      else if ( npairs == 2 && ipair == 1 ) { addr = 36; }
      else if ( npairs == 3 && ipair == 0 ) { addr = 32; }
      else if ( npairs == 3 && ipair == 1 ) { addr = 34; }
      else if ( npairs == 3 && ipair == 2 ) { addr = 36; }
      else {
    edm::LogWarning("FedCabling") 
      << "[SiStripFedCablingFakeESSource::" << __func__ << "]"
      << " Inconsistent values for nPairs (" << npairs
      << ") and ipair (" << ipair << ")!";
      }
      uint32_t module_key = SiStripFecKey(fecCrate( imodule ), 
                      fecSlot( imodule ),  
                      fecRing( imodule ), 
                      ccuAddr( imodule ), 
                      ccuChan( imodule )).key();
      FedChannelConnection conn( fecCrate( imodule ),
                 fecSlot( imodule ), 
                 fecRing( imodule ), 
                 ccuAddr( imodule ), 
                 ccuChan( imodule ), 
                 addr, addr+1, // apv i2c addresses
                                 module_key,         // dcu id
                                 *idet,  // det id
                 npairs );     // apv pairs
      fec_cabling->addDevices( conn );
    }
    imodule++;
  }
  
  // Assign "dummy" FED ids/chans
  bool insufficient = false;
  Feds::const_iterator ifed = feds.begin();
  uint16_t fed_ch = 0;
  for ( std::vector<SiStripFecCrate>::const_iterator icrate = fec_cabling->crates().begin(); icrate != fec_cabling->crates().end(); icrate++ ) {
    for ( std::vector<SiStripFec>::const_iterator ifec = icrate->fecs().begin(); ifec != icrate->fecs().end(); ifec++ ) {
      for ( std::vector<SiStripRing>::const_iterator iring = ifec->rings().begin(); iring != ifec->rings().end(); iring++ ) {
    for ( std::vector<SiStripCcu>::const_iterator iccu = iring->ccus().begin(); iccu != iring->ccus().end(); iccu++ ) {
      for ( std::vector<SiStripModule>::const_iterator imod = iccu->modules().begin(); imod != iccu->modules().end(); imod++ ) {
        if(populateAllFeds){
          for ( uint16_t ipair = 0; ipair < imod->nApvPairs(); ipair++ ) {
        
        if ( ifed == feds.end() ) { fed_ch++; ifed = feds.begin(); }
        if ( fed_ch == 96 ) {
          insufficient = true;
          break;
        }
          
        std::pair<uint16_t,uint16_t> addr = imod->activeApvPair( imod->lldChannel(ipair) );
        SiStripModule::FedChannel fed_channel( (*ifed)/16+1, // 16 FEDs per crate, numbering starts from 1
                               (*ifed)%16+2, // FED slot starts from 2
                               *ifed,
                               fed_ch );
        const_cast<SiStripModule&>(*imod).fedCh( addr.first, fed_channel );
        ifed++;
          
          }
        }else{
          // Patch introduced by D.Giordano 2/12/08
          //to reproduce the fake cabling used in 2x
          //that was designed to fill each fed iteratively
          //filling all channels of a fed before going to the next one
          if ( 96-fed_ch < imod->nApvPairs() ) { ifed++; fed_ch = 0; } // move to next FED
          for ( uint16_t ipair = 0; ipair < imod->nApvPairs(); ipair++ ) {
        std::pair<uint16_t,uint16_t> addr = imod->activeApvPair( (*imod).lldChannel(ipair) );
        SiStripModule::FedChannel fed_channel( (*ifed)/16+1, // 16 FEDs per crate, numbering starts from 1
                               (*ifed)%16+2, // FED slot starts from 2
                               (*ifed), 
                               fed_ch );
        const_cast<SiStripModule&>(*imod).fedCh( addr.first, fed_channel );
        fed_ch++;
          }

        }
      }
    }
      }
    }
  }

  if ( insufficient ) {
    edm::LogWarning(mlCabling_)
      << "[SiStripFedCablingFakeESSource::" << __func__ << "]"
      << " Insufficient FED channels to cable entire system!";
  }
  
  // Some debug
  std::stringstream ss;
  ss << "[SiStripFedCablingFakeESSource::" << __func__ << "]"
     <<" First count devices of FEC cabling " << std::endl;
  fec_cabling->countDevices().print(ss);
  LogTrace(mlCabling_) << ss.str();
  
  // Build FED cabling using FedChannelConnections
  std::vector<FedChannelConnection> conns;
  fec_cabling->connections( conns ); 
  SiStripFedCabling* cabling = new SiStripFedCabling( conns );
  
  return cabling;
  
}

// -----------------------------------------------------------------------------
// 
void SiStripFedCablingFakeESSource::setIntervalFor( const edm::eventsetup::EventSetupRecordKey& key, 
                            const edm::IOVSyncValue& iov_sync, 
                            edm::ValidityInterval& iov_validity ) {
  edm::ValidityInterval infinity( iov_sync.beginOfTime(), iov_sync.endOfTime() );
  iov_validity = infinity;
}