SiStripModule.cc

Go to the documentation of this file.

#include "CalibFormats/SiStripObjects/interface/SiStripModule.h"
#include "DataFormats/SiStripCommon/interface/SiStripConstants.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <iostream>
#include <iomanip>

using namespace sistrip;

// -----------------------------------------------------------------------------
//
SiStripModule::SiStripModule( const FedChannelConnection& conn ) 
  : key_( conn.fecCrate(), 
      conn.fecSlot(), 
      conn.fecRing(), 
      conn.ccuAddr(), 
      conn.ccuChan() ),
    apv32_(0), 
    apv33_(0), 
    apv34_(0), 
    apv35_(0), 
    apv36_(0), 
    apv37_(0), 
    dcu0x00_(0), 
    mux0x43_(0), 
    pll0x44_(0), 
    lld0x60_(0), 
    dcuId_(0), 
    detId_(0), 
    nApvPairs_(0),
    cabling_(), 
    length_(0) 
{ 
  addDevices( conn ); 
}

// -----------------------------------------------------------------------------
//
void SiStripModule::addDevices( const FedChannelConnection& conn ) {
  
  if ( key_.fecCrate() && key_.fecCrate() != conn.fecCrate() ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected FEC crate ("
      << conn.fecCrate() << ") for this module ("
      << key_.fecCrate() << ")!";
    return;
  }

  if ( key_.fecSlot() && key_.fecSlot() != conn.fecSlot() ) {
    edm::LogWarning(mlCabling_)
            << "SiStripModule::" << __func__ << "]"
        << " Unexpected FEC slot ("
        << conn.fecSlot() << ") for this module ("
        << key_.fecSlot() << ")!";
    return;
  }

  if ( key_.fecRing() && key_.fecRing() != conn.fecRing() ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected FEC ring ("
      << conn.fecRing() << ") for this module ("
      << key_.fecRing() << ")!";
    return;
  }

  if ( key_.ccuAddr() && key_.ccuAddr() != conn.ccuAddr() ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected CCU addr ("
      << conn.ccuAddr() << ") for this module ("
      << key_.ccuAddr() << ")!";
    return;
  }

  if ( key_.ccuChan() && key_.ccuChan() != conn.ccuChan() ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected CCU chan ("
      << conn.ccuChan() << ") for this module ("
      << key_.ccuChan() << ")!";
    return;
  }

  // APVs
  if ( conn.i2cAddr(0) ) { addApv( conn.i2cAddr(0) ); }
  if ( conn.i2cAddr(1) ) { addApv( conn.i2cAddr(1) ); }
  
  // Detector
  dcuId( conn.dcuId() ); 
  detId( conn.detId() ); 
  nApvPairs( conn.nApvPairs() ); 
  
  // FED cabling
  FedChannel fed_ch( conn.fedCrate(), 
             conn.fedSlot(), 
             conn.fedId(), 
             conn.fedCh() ); 
  fedCh( conn.i2cAddr(0), fed_ch );
  
  // DCU, MUX, PLL, LLD
  if ( conn.dcu() ) { dcu0x00_ = true; }
  if ( conn.mux() ) { mux0x43_ = true; }
  if ( conn.pll() ) { pll0x44_ = true; }
  if ( conn.lld() ) { lld0x60_ = true; }
  
}

// -----------------------------------------------------------------------------
//
std::vector<uint16_t> SiStripModule::activeApvs() const {
  std::vector<uint16_t> apvs;
  if ( apv32_ ) { apvs.push_back( apv32_ ); }
  if ( apv33_ ) { apvs.push_back( apv33_ ); }
  if ( apv34_ ) { apvs.push_back( apv34_ ); }
  if ( apv35_ ) { apvs.push_back( apv35_ ); }
  if ( apv36_ ) { apvs.push_back( apv36_ ); }
  if ( apv37_ ) { apvs.push_back( apv37_ ); }
  return apvs;
}

// -----------------------------------------------------------------------------
//
 const uint16_t& SiStripModule::activeApv( const uint16_t& apv_address ) const {
  if      ( apv_address == 0 || apv_address == 32 ) { return apv32_; }
  else if ( apv_address == 1 || apv_address == 33 ) { return apv33_; }
  else if ( apv_address == 2 || apv_address == 34 ) { return apv34_; }
  else if ( apv_address == 3 || apv_address == 35 ) { return apv35_; }
  else if ( apv_address == 4 || apv_address == 36 ) { return apv36_; }
  else if ( apv_address == 5 || apv_address == 37 ) { return apv37_; }
  else {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected I2C address or number (" 
      << apv_address << ") for this module!";
  }
  static const uint16_t address = 0;
  return address;
}

// -----------------------------------------------------------------------------
//
void SiStripModule::addApv( const uint16_t& apv_address ) {

  // Some checks on value of APV I2C address
  if ( apv_address == 0 ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Null APV I2C address!"; 
    return;
  } else if ( apv_address < 32 && apv_address > 37 ) {
    edm::LogWarning(mlCabling_)
            << "SiStripModule::" << __func__ << "]"
        << " Unexpected I2C address (" 
        << apv_address << ") for APV!"; 
    return;
  }

  bool added_apv = false; 
  if      ( !apv32_ && apv_address == 32 ) { apv32_ = 32; added_apv = true; }
  else if ( !apv33_ && apv_address == 33 ) { apv33_ = 33; added_apv = true; }
  else if ( !apv34_ && apv_address == 34 ) { apv34_ = 34; added_apv = true; }
  else if ( !apv35_ && apv_address == 35 ) { apv35_ = 35; added_apv = true; }
  else if ( !apv36_ && apv_address == 36 ) { apv36_ = 36; added_apv = true; }
  else if ( !apv37_ && apv_address == 37 ) { apv37_ = 37; added_apv = true; }
  
  std::stringstream ss;
  ss << "SiStripModule::" << __func__ << "]";
  if ( added_apv ) { ss << " Added new APV for"; }
  else { ss << " APV already exists for"; }
  ss << " Crate/FEC/Ring/CCU/Module: "
     << key_.fecCrate() << "/"
     << key_.fecSlot() << "/"
     << key_.fecRing() << "/"
     << key_.ccuAddr() << "/"
     << key_.ccuChan() << "/"
     << apv_address;
  //if ( added_apv ) { LogTrace(mlCabling_) << ss.str(); }
  /* else */ if ( !added_apv ) { edm::LogWarning(mlCabling_) << ss.str(); }
  
}

// -----------------------------------------------------------------------------
//
void SiStripModule::nApvPairs( const uint16_t& npairs ) { 
  if ( npairs == 2 || npairs == 3 ) { nApvPairs_ = npairs; } 
  else if ( npairs == 0 ) {
    nApvPairs_ = 0;
    if ( apv32_ || apv33_ ) { nApvPairs_++; }
    if ( apv34_ || apv35_ ) { nApvPairs_++; }
    if ( apv36_ || apv37_ ) { nApvPairs_++; }
  } else { 
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected number of APV pairs: " 
      << npairs;
  }
} 

// -----------------------------------------------------------------------------
//
SiStripModule::PairOfU16 SiStripModule::activeApvPair( const uint16_t& lld_channel ) const {
  if      ( lld_channel == 1 ) { return PairOfU16(apv32_,apv33_); }
  else if ( lld_channel == 2 ) { return PairOfU16(apv34_,apv35_); }
  else if ( lld_channel == 3 ) { return PairOfU16(apv36_,apv37_); }
  else { 
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected LLD channel: " << lld_channel;
    return PairOfU16(0,0); 
  }
}

// -----------------------------------------------------------------------------
//
uint16_t SiStripModule::lldChannel( const uint16_t& apv_pair_num ) const {
  if ( apv_pair_num > 2 ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected APV pair number: " << apv_pair_num;
    return 0;
  }
  if ( nApvPairs_ != 2 && nApvPairs_ != 3 ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected number of APV pairs: " << nApvPairs_;
    return 0;
  }
  if ( nApvPairs_ == 2 && apv_pair_num == 1 ) { return 3; }
  else if ( nApvPairs_ == 2 && apv_pair_num == 2 ) { 
    edm::LogWarning(mlCabling_)
      << "[SiStripFecCabling::" << __func__ << "]"
      << " APV pair number is incompatible with"
      << " respect to number of !";
    return 0;
  } else { return apv_pair_num + 1; } 
}

// -----------------------------------------------------------------------------
//
uint16_t SiStripModule::apvPairNumber( const uint16_t& lld_channel ) const {
  if ( lld_channel < 1 || lld_channel > 3 ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected LLD channel: " << lld_channel;
    return 0;
  }
  if ( nApvPairs_ != 2 && nApvPairs_ != 3 ) {
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected number of APV pairs: " << nApvPairs_;
    return 0;
  }
  if ( nApvPairs_ == 2 && lld_channel == 3 ) { return 1; }
  else if ( nApvPairs_ == 2 && lld_channel == 2 ) { 
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " LLD channel is incompatible with"
      << " respect to number of APV pairs!";
    return 0;
  } else { return lld_channel - 1; }
}

// -----------------------------------------------------------------------------
//
SiStripModule::FedChannel SiStripModule::fedCh( const uint16_t& apv_pair ) const {

  FedChannel fed_ch(0,0,0,0);
  
  if ( !nApvPairs() ) {
    
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " No APV pairs exist!";
    return fed_ch; 

  } else {

    uint16_t lld_ch = 0;
    if ( nApvPairs() == 2 ) {

      if      ( apv_pair == 0 ) { lld_ch = 1; }
      else if ( apv_pair == 1 ) { lld_ch = 3; }
      else { 
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected pair number! " << apv_pair;
      }

    } else if ( nApvPairs() == 3 ) {

      if      ( apv_pair == 0 ) { lld_ch = 1; }
      else if ( apv_pair == 1 ) { lld_ch = 2; }
      else if ( apv_pair == 2 ) { lld_ch = 3; }
      else { 
    edm::LogWarning(mlCabling_)
      << "SiStripModule::" << __func__ << "]"
      << " Unexpected pair number! " << apv_pair;
      }

    } else {

      edm::LogWarning(mlCabling_) 
    << "SiStripModule::" << __func__ << "]"
    << " Unexpected number of APV pairs: " << nApvPairs();

    }
    
    FedCabling::const_iterator ipair = cabling_.find( lld_ch );
    if ( ipair != cabling_.end() ) { return (*ipair).second; }
    else { return fed_ch; }

  }

}

// -----------------------------------------------------------------------------
//
bool SiStripModule::fedCh( const uint16_t& apv_address, 
               const FedChannel& fed_ch ) {
  // Determine LLD channel
  int16_t lld_ch = 1;
  if      ( apv_address == 32 || apv_address == 33 ) { lld_ch = 1; }
  else if ( apv_address == 34 || apv_address == 35 ) { lld_ch = 2; }
  else if ( apv_address == 36 || apv_address == 37 ) { lld_ch = 3; }
  else if ( apv_address == 0 ) { ; } //@@ do nothing?
  else { 
    edm::LogWarning(mlCabling_) << "[SiStripModule::fedCh]" 
                << " Unexpected I2C address (" 
                << apv_address << ") for APV!"; 
    return false;
  }
  // Search for entry in std::map
  //@@ use FedKey as key instead of lld chan? what about "duplicates"? 
  //@@ always append to std::map? then can have >3 entries. useful for debug?
  FedCabling::iterator ipair = cabling_.find( lld_ch );
  if ( ipair == cabling_.end() ) { cabling_[lld_ch] = fed_ch; }
  else { ipair->second = fed_ch; }
  return true;
}

// -----------------------------------------------------------------------------
//
void SiStripModule::print( std::stringstream& ss ) const {

  ss << " [SiStripModule::" << __func__ << "]" << std::endl
     << " Crate/FEC/Ring/CCU/Module               : "
     << key().fecCrate() << "/"
     << key().fecSlot() << "/"
     << key().fecRing() << "/"
     << key().ccuAddr() << "/"
     << key().ccuChan() << std::endl;

  ss << " ActiveApvs                              : ";
  std::vector<uint16_t> apvs = activeApvs();
  if ( apvs.empty() ) { ss << "NONE!"; }
  std::vector<uint16_t>::const_iterator iapv = apvs.begin();
  for ( ; iapv != apvs.end(); ++iapv ) { ss << *iapv << ", "; }
  ss << std::endl;
  
  ss << " DcuId/DetId/nPairs                      : "
     << std::hex
     << "0x" << std::setfill('0') << std::setw(8) << dcuId() << "/"
     << "0x" << std::setfill('0') << std::setw(8) << detId() << "/"
     << std::dec
     << nApvPairs() << std::endl;
  
  FedCabling channels = fedChannels();
  ss << " ApvPairNum/FedCrate/FedSlot/FedId/FedCh : ";
  FedCabling::const_iterator ichan = channels.begin();
  for ( ; ichan != channels.end(); ++ichan ) {
    ss << ichan->first << "/"
       << ichan->second.fedCrate_ << "/"
       << ichan->second.fedSlot_ << "/"
       << ichan->second.fedId_ << "/"
       << ichan->second.fedCh_ << ", ";
  }
  ss << std::endl;
  
  ss << " DCU/MUX/PLL/LLD found                   : "
     << bool(dcu0x00_) << "/"
     << bool(mux0x43_) << "/"
     << bool(pll0x44_) << "/"
     << bool(lld0x60_);
  
}

// -----------------------------------------------------------------------------
//@@ NEEDS MODIFYING!!!!
void SiStripModule::terse( std::stringstream& ss ) const {

  ss << " [SiStripModule::" << __func__ << "]" << std::endl
     << " Crate/FEC/Ring/CCU/Module               : "
     << key().fecCrate() << "/"
     << key().fecSlot() << "/"
     << key().fecRing() << "/"
     << key().ccuAddr() << "/"
     << key().ccuChan() << std::endl;

  ss << " ActiveApvs                              : ";
  std::vector<uint16_t> apvs = activeApvs();
  if ( apvs.empty() ) { ss << "NONE!"; }
  std::vector<uint16_t>::const_iterator iapv = apvs.begin();
  for ( ; iapv != apvs.end(); ++iapv ) { ss << *iapv << ", "; }
  ss << std::endl;
  
  ss << " DcuId/DetId/nPairs                      : "
     << std::hex
     << "0x" << std::setfill('0') << std::setw(8) << dcuId() << "/"
     << "0x" << std::setfill('0') << std::setw(8) << detId() << "/"
     << std::dec
     << nApvPairs() << std::endl;
  
  FedCabling channels = fedChannels();
  ss << " ApvPairNum/FedCrate/FedSlot/FedId/FedCh : ";
  FedCabling::const_iterator ichan = channels.begin();
  for ( ; ichan != channels.end(); ++ichan ) {
    ss << ichan->first << "/"
       << ichan->second.fedCrate_ << "/"
       << ichan->second.fedSlot_ << "/"
       << ichan->second.fedId_ << "/"
       << ichan->second.fedCh_ << ", ";
  }
  ss << std::endl;
  
  ss << " DCU/MUX/PLL/LLD found                   : "
     << bool(dcu0x00_) << "/"
     << bool(mux0x43_) << "/"
     << bool(pll0x44_) << "/"
     << bool(lld0x60_);
  
}

// -----------------------------------------------------------------------------
//
std::ostream& operator<< ( std::ostream& os, const SiStripModule& device ) {
  std::stringstream ss;
  device.print(ss);
  os << ss.str();
  return os;
}