Phase2TrackerCabling.cc

Go to the documentation of this file.

#include "CondFormats/SiStripObjects/interface/Phase2TrackerCabling.h"
#include "CondFormats/SiStripObjects/interface/Phase2TrackerModule.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <sstream>

// These functions are used to sort and search the cabling objects 

// by FED id/ch
bool Phase2TrackerCabling::chOrdering(Phase2TrackerCabling::key a, Phase2TrackerCabling::key b) {
  if (a->getCh().first==b->getCh().first)
    return a->getCh().second < b->getCh().second;
  else
    return a->getCh().first < b->getCh().first;
}
bool Phase2TrackerCabling::chComp(Phase2TrackerCabling::key a, std::pair<unsigned int, unsigned int> b) {
  if (a->getCh().first==b.first)
    return a->getCh().second < b.second;
  else
    return a->getCh().first < b.first;
}
bool Phase2TrackerCabling::fedeq(key a, key b) {
  return (a->getCh().first==b->getCh().first);
}

// by detid
bool Phase2TrackerCabling::detidOrdering(Phase2TrackerCabling::key a, Phase2TrackerCabling::key b) {
  return a->getDetid() < b->getDetid(); 
}
bool Phase2TrackerCabling::detidComp(Phase2TrackerCabling::key a, uint32_t b) {
  return a->getDetid() < b; 
}

// by gbtid
bool Phase2TrackerCabling::gbtidOrdering(Phase2TrackerCabling::key a, Phase2TrackerCabling::key b) {
  return a->getGbtid() < b->getGbtid(); 
}
bool Phase2TrackerCabling::gbtidComp(Phase2TrackerCabling::key a, uint32_t b) {
  return a->getGbtid() < b; 
}

// by cooling loop
bool Phase2TrackerCabling::coolingOrdering(const Phase2TrackerModule& a, const Phase2TrackerModule& b) {
  return a.getCoolingLoop() < b.getCoolingLoop(); }
bool Phase2TrackerCabling::coolingComp(const Phase2TrackerModule& a, uint32_t b) {
  return a.getCoolingLoop() < b; }
bool Phase2TrackerCabling::cooleq(const Phase2TrackerModule& a, const Phase2TrackerModule& b) {
  return (a.getCoolingLoop()==b.getCoolingLoop());
}

// by power group
bool Phase2TrackerCabling::powerOrdering(const Phase2TrackerModule& a, const Phase2TrackerModule& b) {
  return a.getPowerGroup() < b.getPowerGroup(); }
bool Phase2TrackerCabling::powerComp(const Phase2TrackerModule& a, uint32_t b) {
  return a.getPowerGroup() < b; }
bool Phase2TrackerCabling::poweq(const Phase2TrackerModule& a, const Phase2TrackerModule& b) {
  return (a.getPowerGroup()==b.getPowerGroup());
}

// Phase2TrackerCabling methods

Phase2TrackerCabling::Phase2TrackerCabling( const std::vector<Phase2TrackerModule>& cons ):connections_(cons) {
  // initialize the cabling (fill the transient objects and sort.
  initializeCabling();
}

Phase2TrackerCabling::Phase2TrackerCabling( const Phase2TrackerCabling& src ) {
  connections_ = src.connections_;
  fedCabling_  = src.fedCabling_;
  detCabling_  = src.detCabling_;
  gbtCabling_  = src.gbtCabling_;
}

void Phase2TrackerCabling::initializeCabling() {
  // fill the cabling objects
  fedCabling_.reserve(connections_.size());
  detCabling_.reserve(connections_.size());
  gbtCabling_.reserve(connections_.size());
  for(key module = connections_.begin();module<connections_.end();++module) {
    fedCabling_.push_back(module);
    detCabling_.push_back(module);
    gbtCabling_.push_back(module);
  }
  // sort the cabling objects
  std::sort(fedCabling_.begin(),fedCabling_.end(),chOrdering);
  std::sort(detCabling_.begin(),detCabling_.end(),detidOrdering);
  std::sort(gbtCabling_.begin(),gbtCabling_.end(),gbtidOrdering);
}

const Phase2TrackerModule& Phase2TrackerCabling::findFedCh(std::pair<unsigned int, unsigned int> fedch) const {
  // look for ch
  cabling::const_iterator itid = std::lower_bound(fedCabling_.begin(), fedCabling_.end(), fedch, chComp);
  if (itid != fedCabling_.end() && (*itid)->getCh()==fedch)
    return **itid;
  else
    throw cms::Exception("IndexNotFound") << "No connection corresponding to FED id/ch = " << fedch.first << "/" << fedch.second;
}

const Phase2TrackerModule& Phase2TrackerCabling::findDetid(uint32_t detid) const {
  // look for id 
  cabling::const_iterator itch = std::lower_bound (detCabling_.begin(), detCabling_.end(), detid, detidComp);
  if (itch != detCabling_.end() && (*itch)->getDetid()==detid)
    return **itch;
  else
    throw cms::Exception("IndexNotFound") << "No connection corresponding to detid = 0x" << std::hex << detid << std::dec;
}

const Phase2TrackerModule& Phase2TrackerCabling::findGbtid(uint32_t gbtid) const {
  // look for id 
  cabling::const_iterator itch = std::lower_bound (gbtCabling_.begin(), gbtCabling_.end(), gbtid, gbtidComp);
  if (itch != gbtCabling_.end() && (*itch)->getGbtid()==gbtid)
    return **itch;
  else
    throw cms::Exception("IndexNotFound") << "No connection corresponding to gbtid = 0x" << std::hex << gbtid << std::dec;
}

Phase2TrackerCabling Phase2TrackerCabling::filterByCoolingLine(uint32_t coolingLine) const {
  // NB: this approach involves two copies of the connections. Can we do better?
  // since this is a relatively rare operation, I don't want to pre-sort the connections.

  // make a copy of the store
  store resultStore = connections_;
  // sort according to cooling
  std::sort(resultStore.begin(),resultStore.end(),coolingOrdering);
  // search for the proper range
  std::pair< key, key > range = std::equal_range(resultStore.begin(),resultStore.end(),
                                                 Phase2TrackerModule(Phase2TrackerModule::SS,0,0,0,0,0,coolingLine),coolingOrdering);
  // create a new cabling object
  Phase2TrackerCabling result(store(range.first,range.second));
  // return the new cabling object
  return result;
}

Phase2TrackerCabling Phase2TrackerCabling::filterByPowerGroup(uint32_t powerGroup) const {
  // NB: this approach involves two copies of the connections. Can we do better?
  // since this is a relatively rare operation, I don't want to pre-sort the connections.

  // make a copy of the store
  store resultStore = connections_;
  // sort according to power groups
  std::sort(resultStore.begin(),resultStore.end(),powerOrdering);
  // search for the proper range
  std::pair< key, key > range = std::equal_range(resultStore.begin(),resultStore.end(),
                                                 Phase2TrackerModule(Phase2TrackerModule::SS,0,0,0,0,powerGroup,0),powerOrdering);
  // create a new cabling object
  Phase2TrackerCabling result(store(range.first,range.second));
  // return the new cabling object
  return result;
}

std::string Phase2TrackerCabling::summaryDescription() const {
  std::string mystring("Summary of the cabling\n======================\n");
  std::stringstream ss;
  // number of modules, feds, cooling loop and power groups
  ss << "Number of modules: " << connections_.size() << std::endl;
  store orig(connections_);
  ss << "Number of FEDs: ";
  cabling tmpc(fedCabling_);
  ss << std::distance(tmpc.begin(),std::unique(tmpc.begin(),tmpc.end(),fedeq)) << std::endl; 
  ss << "Number of cooling loops: ";
  std::sort(orig.begin(),orig.end(),coolingOrdering);
  store tmp(orig);
  ss << std::distance(tmp.begin(),std::unique(tmp.begin(),tmp.end(),cooleq)) << std::endl;
  ss << "Number of power groups: ";
  std::sort(orig.begin(),orig.end(),powerOrdering);
  tmp = orig;
  ss << std::distance(tmp.begin(),std::unique(tmp.begin(),tmp.end(),poweq)) << std::endl;
  mystring += ss.str();
  return mystring;
}

std::string Phase2TrackerCabling::description(bool compact) const {
  std::string mystring("Cabling:\n========\n");
  for(std::vector<Phase2TrackerModule>::const_iterator it = connections_.begin();it<connections_.end();++it) {
    mystring += it->description(compact);
  }
  return mystring;
}