#include <Phase2TrackerCabling.h>

Public Member Functions
const std::vector< Phase2TrackerModule > &	connections () const

std::string	description (bool compact=false) const

Phase2TrackerCabling	filterByCoolingLine (uint32_t coolingLine) const

Phase2TrackerCabling	filterByPowerGroup (uint32_t powerGroup) const

const Phase2TrackerModule &	findDetid (uint32_t detid) const

const Phase2TrackerModule &	findFedCh (std::pair< unsigned int, unsigned int > fedch) const

const Phase2TrackerModule &	findGbtid (uint32_t gbtid) const

void	initializeCabling ()

	Phase2TrackerCabling (const std::vector< Phase2TrackerModule > &cons)

	Phase2TrackerCabling (const Phase2TrackerCabling &src)

	Phase2TrackerCabling ()

std::string	summaryDescription () const

virtual	~Phase2TrackerCabling ()

Private Types
typedef std::vector< key >	cabling

typedef std::vector< Phase2TrackerModule >::const_iterator	key

typedef std::vector< Phase2TrackerModule >	store

Private Member Functions
template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Static Private Member Functions
static bool	chComp (key a, std::pair< unsigned int, unsigned int > b)

static bool	chOrdering (key a, key b)

static bool	cooleq (const Phase2TrackerModule &a, const Phase2TrackerModule &b)

static bool	coolingComp (const Phase2TrackerModule &a, uint32_t b)

static bool	coolingOrdering (const Phase2TrackerModule &a, const Phase2TrackerModule &b)

static bool	detidComp (key a, uint32_t b)

static bool	detidOrdering (key a, key b)

static bool	fedeq (key a, key b)

static bool	gbtidComp (key a, uint32_t b)

static bool	gbtidOrdering (key a, key b)

static bool	poweq (const Phase2TrackerModule &a, const Phase2TrackerModule &b)

static bool	powerComp (const Phase2TrackerModule &a, uint32_t b)

static bool	powerOrdering (const Phase2TrackerModule &a, const Phase2TrackerModule &b)

Private Attributes
store	connections_

cabling	detCabling_

cabling	fedCabling_

cabling	gbtCabling_

Friends
class	boost::serialization::access

template<typename CondSerializationT , typename Enabled >
struct	cond::serialization::access

Detailed Description

Definition at line 9 of file Phase2TrackerCabling.h.

Member Typedef Documentation

typedef std::vector<key> Phase2TrackerCabling::cabling

private

Definition at line 12 of file Phase2TrackerCabling.h.

typedef std::vector<Phase2TrackerModule>::const_iterator Phase2TrackerCabling::key

private

Definition at line 11 of file Phase2TrackerCabling.h.

typedef std::vector<Phase2TrackerModule> Phase2TrackerCabling::store

private

Definition at line 10 of file Phase2TrackerCabling.h.

Constructor & Destructor Documentation

Phase2TrackerCabling::Phase2TrackerCabling ( const std::vector< Phase2TrackerModule > & cons )

Definition at line 56 of file Phase2TrackerCabling.cc.

References initializeCabling().

                                                                                      : connections_(cons) {
   // initialize the cabling (fill the transient objects and sort.
   initializeCabling();
 }

Phase2TrackerCabling::Phase2TrackerCabling ( const Phase2TrackerCabling & src )

Definition at line 61 of file Phase2TrackerCabling.cc.

References connections_, detCabling_, fedCabling_, and gbtCabling_.

                                                                           {
   connections_ = src.connections_;
   fedCabling_ = src.fedCabling_;
   detCabling_ = src.detCabling_;
   gbtCabling_ = src.gbtCabling_;
 }

Phase2TrackerCabling::Phase2TrackerCabling ( )

inline

Definition at line 22 of file Phase2TrackerCabling.h.

22 {}

virtual Phase2TrackerCabling::~Phase2TrackerCabling ( )

inlinevirtual

Definition at line 25 of file Phase2TrackerCabling.h.

References initializeCabling().

25 {}

Member Function Documentation

bool Phase2TrackerCabling::chComp	(	Phase2TrackerCabling::key	a,
		std::pair< unsigned int, unsigned int >	b
	)

staticprivate

Definition at line 16 of file Phase2TrackerCabling.cc.

Referenced by findFedCh().

                                                                                                   {
   if (a->getCh().first == b.first)
     return a->getCh().second < b.second;
   else
     return a->getCh().first < b.first;
 }

bool Phase2TrackerCabling::chOrdering	(	Phase2TrackerCabling::key	a,
		Phase2TrackerCabling::key	b
	)

staticprivate

Definition at line 10 of file Phase2TrackerCabling.cc.

Referenced by initializeCabling().

                                                                                           {
   if (a->getCh().first == b->getCh().first)
     return a->getCh().second < b->getCh().second;
   else
     return a->getCh().first < b->getCh().first;
 }

const std::vector<Phase2TrackerModule>& Phase2TrackerCabling::connections ( ) const

inline

Definition at line 31 of file Phase2TrackerCabling.h.

References connections_, description(), filterByCoolingLine(), filterByPowerGroup(), findDetid(), findFedCh(), findGbtid(), AlCaHLTBitMon_QueryRunRegistry::string, and summaryDescription().

31 { return connections_; }

Phase2TrackerCabling::connections_

store connections_

Definition: Phase2TrackerCabling.h:56

bool Phase2TrackerCabling::cooleq	(	const Phase2TrackerModule &	a,
		const Phase2TrackerModule &	b
	)

staticprivate

Definition at line 41 of file Phase2TrackerCabling.cc.

References Phase2TrackerModule::getCoolingLoop().

Referenced by summaryDescription().

                                                                                             {
   return (a.getCoolingLoop() == b.getCoolingLoop());
 }

bool Phase2TrackerCabling::coolingComp	(	const Phase2TrackerModule &	a,
		uint32_t	b
	)

staticprivate

Definition at line 40 of file Phase2TrackerCabling.cc.

References b, and Phase2TrackerModule::getCoolingLoop().

40 { return a.getCoolingLoop() < b; }

Phase2TrackerModule::getCoolingLoop

uint32_t getCoolingLoop() const

Definition: Phase2TrackerModule.h:43

b

double b

Definition: hdecay.h:118

bool Phase2TrackerCabling::coolingOrdering	(	const Phase2TrackerModule &	a,
		const Phase2TrackerModule &	b
	)

staticprivate

Definition at line 37 of file Phase2TrackerCabling.cc.

References Phase2TrackerModule::getCoolingLoop().

Referenced by filterByCoolingLine(), and summaryDescription().

                                                                                                      {
   return a.getCoolingLoop() < b.getCoolingLoop();
 }

std::string Phase2TrackerCabling::description ( bool compact = false ) const

Definition at line 173 of file Phase2TrackerCabling.cc.

References connections_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by connections().

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

bool Phase2TrackerCabling::detidComp	(	Phase2TrackerCabling::key	a,
		uint32_t	b
	)

staticprivate

Definition at line 28 of file Phase2TrackerCabling.cc.

References b.

Referenced by findDetid().

28 { return a->getDetid() < b; }

b

double b

Definition: hdecay.h:118

a

double a

Definition: hdecay.h:119

bool Phase2TrackerCabling::detidOrdering	(	Phase2TrackerCabling::key	a,
		Phase2TrackerCabling::key	b
	)

staticprivate

Definition at line 25 of file Phase2TrackerCabling.cc.

Referenced by initializeCabling().

                                                                                              {
   return a->getDetid() < b->getDetid();
 }

bool Phase2TrackerCabling::fedeq	(	key	a,
		key	b
	)

staticprivate

Definition at line 22 of file Phase2TrackerCabling.cc.

Referenced by summaryDescription().

22 { return (a->getCh().first == b->getCh().first); }

b

double b

Definition: hdecay.h:118

a

double a

Definition: hdecay.h:119

Phase2TrackerCabling Phase2TrackerCabling::filterByCoolingLine ( uint32_t coolingLine ) const

Definition at line 114 of file Phase2TrackerCabling.cc.

References connections_, coolingOrdering(), FastTimerService_cff::range, mps_fire::result, and Phase2TrackerModule::SS.

Referenced by connections().

                                                                                          {
   // 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

Definition at line 133 of file Phase2TrackerCabling.cc.

References connections_, powerOrdering(), FastTimerService_cff::range, mps_fire::result, and Phase2TrackerModule::SS.

Referenced by connections().

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

const Phase2TrackerModule & Phase2TrackerCabling::findDetid ( uint32_t detid ) const

Definition at line 94 of file Phase2TrackerCabling.cc.

References TauDecayModes::dec, detCabling_, detidComp(), and Exception.

Referenced by connections().

                                                                                {
   // 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::findFedCh ( std::pair< unsigned int, unsigned int > fedch ) const

Definition at line 84 of file Phase2TrackerCabling.cc.

References chComp(), Exception, and fedCabling_.

Referenced by connections(), and Phase2Tracker::Phase2TrackerDigiProducer::produce().

                                                                                                           {
   // 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::findGbtid ( uint32_t gbtid ) const

Definition at line 104 of file Phase2TrackerCabling.cc.

References TauDecayModes::dec, Exception, gbtCabling_, and gbtidComp().

Referenced by connections().

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

bool Phase2TrackerCabling::gbtidComp	(	Phase2TrackerCabling::key	a,
		uint32_t	b
	)

staticprivate

Definition at line 34 of file Phase2TrackerCabling.cc.

References b.

Referenced by findGbtid().

34 { return a->getGbtid() < b; }

b

double b

Definition: hdecay.h:118

a

double a

Definition: hdecay.h:119

bool Phase2TrackerCabling::gbtidOrdering	(	Phase2TrackerCabling::key	a,
		Phase2TrackerCabling::key	b
	)

staticprivate

Definition at line 31 of file Phase2TrackerCabling.cc.

Referenced by initializeCabling().

                                                                                              {
   return a->getGbtid() < b->getGbtid();
 }

void Phase2TrackerCabling::initializeCabling ( )

Definition at line 68 of file Phase2TrackerCabling.cc.

References chOrdering(), connections_, detCabling_, detidOrdering(), fedCabling_, gbtCabling_, and gbtidOrdering().

Referenced by Phase2TrackerCabling(), and ~Phase2TrackerCabling().

                                              {
   // 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);
 }

bool Phase2TrackerCabling::poweq	(	const Phase2TrackerModule &	a,
		const Phase2TrackerModule &	b
	)

staticprivate

Definition at line 50 of file Phase2TrackerCabling.cc.

References Phase2TrackerModule::getPowerGroup().

Referenced by summaryDescription().

                                                                                            {
   return (a.getPowerGroup() == b.getPowerGroup());
 }

bool Phase2TrackerCabling::powerComp	(	const Phase2TrackerModule &	a,
		uint32_t	b
	)

staticprivate

Definition at line 49 of file Phase2TrackerCabling.cc.

References b, and Phase2TrackerModule::getPowerGroup().

49 { return a.getPowerGroup() < b; }

Phase2TrackerModule::getPowerGroup

uint32_t getPowerGroup() const

Definition: Phase2TrackerModule.h:44

b

double b

Definition: hdecay.h:118

bool Phase2TrackerCabling::powerOrdering	(	const Phase2TrackerModule &	a,
		const Phase2TrackerModule &	b
	)

staticprivate

Definition at line 46 of file Phase2TrackerCabling.cc.

References Phase2TrackerModule::getPowerGroup().

Referenced by filterByPowerGroup(), and summaryDescription().

                                                                                                    {
   return a.getPowerGroup() < b.getPowerGroup();
 }

template<class Archive >

void Phase2TrackerCabling::serialize	(	Archive &	ar,
		const unsigned int	version
	)

private

std::string Phase2TrackerCabling::summaryDescription ( ) const

Definition at line 152 of file Phase2TrackerCabling.cc.

References connections_, cooleq(), coolingOrdering(), HLT_2018_cff::distance, fedCabling_, fedeq(), poweq(), powerOrdering(), contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, createJobs::tmp, and tier0::unique().

Referenced by connections().

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