#include <GeometryInterface.h>

Classes
struct	InterestingQuantities

Public Types
typedef ID	Column

typedef int	ID

typedef double	Value

typedef std::vector< std::pair < Column, Value > >	Values

Public Member Functions
std::vector < InterestingQuantities > const &	allModules ()

Value	binWidth (ID id)

std::pair< Column, Value >	extract (Column const &col, InterestingQuantities const &iq)

Value	extract (ID id, DetId did, edm::Event *ev=0, int16_t col=0, int16_t row=0)

void	extractColumns (std::vector< Column > const &names, InterestingQuantities const &iq, Values &out)

std::string	formatValue (Column, Value)

	GeometryInterface (const edm::ParameterSet &conf)

ID	intern (std::string const &id)

void	load (edm::EventSetup const &iSetup)

bool	loaded ()

Value	maxValue (ID id)

Value	minValue (ID id)

std::string	pretty (Column col)

std::string	unintern (ID id)

Static Public Attributes
static const Value	UNDEFINED = 999999999.9f

Private Member Functions
void	addExtractor (ID id, std::function< Value(InterestingQuantities const &iq)> func, Value min=UNDEFINED, Value max=UNDEFINED, Value binwidth=1)

void	loadFEDCabling (edm::EventSetup const &iSetup, const edm::ParameterSet &iConfig)

void	loadFromSiPixelCoordinates (edm::EventSetup const &iSetup, const edm::ParameterSet &iConfig)

void	loadFromTopology (edm::EventSetup const &iSetup, const edm::ParameterSet &iConfig)

void	loadModuleLevel (edm::EventSetup const &iSetup, const edm::ParameterSet &iConfig)

void	loadTimebased (edm::EventSetup const &iSetup, const edm::ParameterSet &iConfig)

Private Attributes
std::vector < InterestingQuantities >	all_modules

std::map< ID, Value >	bin_width

std::vector< std::function < Value(InterestingQuantities const &iq)> >	extractors

std::map< std::pair< Column, Value >, std::string >	format_value

const edm::ParameterSet	iConfig

std::map< std::string, ID >	ids {std::make_pair(std::string("INVALID"), ID(0))}

bool	is_loaded = false

ID	max_id = 0

std::map< ID, Value >	max_value

std::map< ID, Value >	min_value

Detailed Description

Definition at line 27 of file GeometryInterface.h.

Member Typedef Documentation

typedef ID GeometryInterface::Column

Definition at line 33 of file GeometryInterface.h.

typedef int GeometryInterface::ID

Definition at line 30 of file GeometryInterface.h.

typedef double GeometryInterface::Value

Definition at line 34 of file GeometryInterface.h.

typedef std::vector<std::pair<Column, Value> > GeometryInterface::Values

Definition at line 39 of file GeometryInterface.h.

Constructor & Destructor Documentation

GeometryInterface::GeometryInterface ( const edm::ParameterSet & conf )

inline

Definition at line 41 of file GeometryInterface.h.

41 : iConfig(conf){};

GeometryInterface::iConfig

const edm::ParameterSet iConfig

Definition: GeometryInterface.h:143

Member Function Documentation

void GeometryInterface::addExtractor	(	ID	id,
		std::function< Value(InterestingQuantities const &iq)>	func,
		Value	min = `UNDEFINED`,
		Value	max = `UNDEFINED`,
		Value	binwidth = `1`
	)

inlineprivate

Definition at line 161 of file GeometryInterface.h.

References bin_width, extractors, RecoJets_EventContent_cff::func, bookConverter::max, max_value, min(), and min_value.

Referenced by loadFEDCabling(), loadFromSiPixelCoordinates(), loadFromTopology(), loadModuleLevel(), and loadTimebased().

                                                                                       {
     max_value[id] = max;
     min_value[id] = min;
     bin_width[id] = binwidth;
     extractors[id] = func;
   }

std::vector<InterestingQuantities> const& GeometryInterface::allModules ( )

inline

Definition at line 94 of file GeometryInterface.h.

References all_modules.

Referenced by SiPixelPhase1GeometryDebug::analyze(), HistogramManager::book(), and HistogramManager::loadFromDQMStore().

                                                        {
     return all_modules;
   }

Value GeometryInterface::binWidth ( ID id )

inline

Definition at line 100 of file GeometryInterface.h.

References bin_width.

Referenced by HistogramManager::book().

100 { return bin_width[id]; };

GeometryInterface::bin_width

std::map< ID, Value > bin_width

Definition: GeometryInterface.h:155

std::pair<Column, Value> GeometryInterface::extract	(	Column const &	col,
		InterestingQuantities const &	iq
	)

inline

Definition at line 70 of file GeometryInterface.h.

References assert(), cuy::col, extractors, UNDEFINED, unintern(), and SpecificationBuilder_cfi::val().

Referenced by BeautifulSoup.PageElement::_invert(), SiPixelPhase1GeometryDebug::analyze(), HistogramManager::book(), BeautifulSoup.Tag::decompose(), extractColumns(), and HistogramManager::fillInternal().

                                                                                      {
     assert(col != 0 || !"Extracting invalid column.");
     ID id = col;
     assert(ID(extractors.size()) > id || !"extractors vector too small!");
     auto& ex = extractors[id];
     if (!ex) {  // we have never heard about this. This is a typo for sure.
       edm::LogError("GeometryInterface")
           << "Undefined column used: " << unintern(id)
           << ". Check your spelling.\n";
     } else {
       auto val = ex(iq);
       if (val != UNDEFINED) {
         return std::make_pair(Column{id}, val);  // double braces for g++
       }
     }
     return std::make_pair(col, UNDEFINED);
   }

Value GeometryInterface::extract	(	ID	id,
		DetId	did,
		edm::Event *	ev = `0`,
		int16_t	col = `0`,
		int16_t	row = `0`
	)

inline

Definition at line 88 of file GeometryInterface.h.

References cuy::col, ev, and extractors.

Referenced by BeautifulSoup.PageElement::_invert(), and BeautifulSoup.Tag::decompose().

                                  {
     InterestingQuantities iq = {ev, did, col, row};
     return extractors[id](iq);
   }

void GeometryInterface::extractColumns	(	std::vector< Column > const &	names,
		InterestingQuantities const &	iq,
		Values &	out
	)

inline

Definition at line 59 of file GeometryInterface.h.

References cuy::col, extract(), and SpecificationBuilder_cfi::val().

Referenced by HistogramManager::book(), HistogramManager::executeExtend(), HistogramManager::executeGroupBy(), HistogramManager::executePerEventHarvesting(), HistogramManager::fill(), and HistogramManager::loadFromDQMStore().

                                                                     {
     out.clear();
     for (Column const& col : names) {
       auto val = extract(col, iq);
       out.push_back(val);
     }
   }

std::string GeometryInterface::formatValue	(	Column	col,
		Value	val
	)

Definition at line 389 of file GeometryInterface.cc.

References format_value, mergeVDriftHistosByStation::name, pretty(), AlCaHLTBitMon_QueryRunRegistry::string, UNDEFINED, and relativeConstraints::value.

Referenced by HistogramManager::makePathName().

                                                               {
   auto it = format_value.find(std::make_pair(col, val));
   if (it != format_value.end()) return it->second;
 
   // non-number output names (_pO etc.) are hardwired here.
   std::string name = pretty(col);
   std::string value = "_" + std::to_string(int(val));
   if (val == 0) value = "";         // hide Barrel_0 etc.
   if (name == "PXDisk" && val > 0)  // +/- sign for disk num
     value = "_+" + std::to_string(int(val));
   // pretty (legacy?) names for Shells and HalfCylinders
   std::map<int, std::string> shellname{
       {11, "_mI"}, {12, "_mO"}, {21, "_pI"}, {22, "_pO"}};
   if (name == "HalfCylinder" || name == "Shell") value = shellname[int(val)];
   if (val == UNDEFINED) value = "_UNDEFINED";
   return format_value[std::make_pair(col, val)] = name+value;
 }

ID GeometryInterface::intern ( std::string const & id )

inline

Definition at line 105 of file GeometryInterface.h.

References extractors, ids, and max_id.

Referenced by SiPixelPhase1GeometryDebug::analyze(), loadFEDCabling(), loadFromSiPixelCoordinates(), loadFromTopology(), loadModuleLevel(), loadTimebased(), and SummationSpecification::parse_columns().

                                  {
     auto it = ids.find(id);
     if (it == ids.end()) {
       ids[id] = ++max_id;
       extractors.resize(max_id + 1);
     }
     return ids[id];
   };

void GeometryInterface::load ( edm::EventSetup const & iSetup )

Definition at line 42 of file GeometryInterface.cc.

References alignCSCRings::e, extractors, iConfig, ids, is_loaded, loadFEDCabling(), loadFromSiPixelCoordinates(), loadFromTopology(), loadModuleLevel(), loadTimebased(), dqm-mbProfile::log, max_value, and min_value.

Referenced by HistogramManager::book(), and HistogramManager::executePerLumiHarvesting().

                                                         {
   //loadFromAlignment(iSetup, iConfig);
   loadFromTopology(iSetup, iConfig);
   loadTimebased(iSetup, iConfig);
   loadModuleLevel(iSetup, iConfig);
   loadFEDCabling(iSetup, iConfig);
   loadFromSiPixelCoordinates(iSetup, iConfig);
   edm::LogInfo log("GeometryInterface");
   log << "Known colum names:\n";
   for (auto e : ids) log << "+++ column: " << e.first
     << " ok " << bool(extractors[e.second]) << " min " << min_value[e.second] << " max " << max_value[e.second] << "\n";
   is_loaded = true;
 }

bool GeometryInterface::loaded ( )

inline

Definition at line 43 of file GeometryInterface.h.

References is_loaded.

Referenced by HistogramManager::book(), and HistogramManager::executePerLumiHarvesting().

43 { return is_loaded; };

GeometryInterface::is_loaded

bool is_loaded

Definition: GeometryInterface.h:145

void GeometryInterface::loadFEDCabling	(	edm::EventSetup const &	iSetup,
		const edm::ParameterSet &	iConfig
	)

private

Definition at line 346 of file GeometryInterface.cc.

References addExtractor(), GeometryInterface::InterestingQuantities::col, edm::EventSetup::get(), edm::ParameterSet::getParameter(), runTauDisplay::gp, intern(), DetId::rawId(), GeometryInterface::InterestingQuantities::row, GeometryInterface::InterestingQuantities::sourceModule, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by load().

                                                                                                   {
   auto cablingMapLabel = iConfig.getParameter<std::string>("CablingMapLabel");
   edm::ESHandle<SiPixelFedCablingMap> theCablingMap;
   iSetup.get<SiPixelFedCablingMapRcd>().get(cablingMapLabel, theCablingMap);
 
   std::shared_ptr<SiPixelFrameReverter> siPixelFrameReverter =
       // I think passing the bare pointer here is safe, but who knows...
       std::make_shared<SiPixelFrameReverter>(iSetup, theCablingMap.operator->());
 
   addExtractor(intern("FED"),
     [siPixelFrameReverter] (InterestingQuantities const& iq) {
       if (iq.sourceModule == 0xFFFFFFFF)
         return Value(iq.col); // hijacked for the raw data plugin
       return Value(siPixelFrameReverter->findFedId(iq.sourceModule.rawId()));
     }
   );
 
   // TODO: ranges should be set manually below, since booking probably cannot
   // infer them correctly (no ROC-level granularity)
   addExtractor(intern("LinkInFed"),
     [siPixelFrameReverter] (InterestingQuantities const& iq) {
       if (iq.sourceModule == 0xFFFFFFFF)
         return Value(iq.row); // hijacked for the raw data plugin
       sipixelobjects::GlobalPixel gp = {iq.row, iq.col};
       return Value(siPixelFrameReverter->findLinkInFed(iq.sourceModule.rawId(), gp));
     }
   );
   // not sure if this is useful anywhere.
   addExtractor(intern("RocInLink"),
     [siPixelFrameReverter] (InterestingQuantities const& iq) {
       sipixelobjects::GlobalPixel gp = {iq.row, iq.col};
       return Value(siPixelFrameReverter->findRocInLink(iq.sourceModule.rawId(), gp));
     }
   );
   // This might be equivalent to our ROC numbering.
   addExtractor(intern("RocInDet"),
     [siPixelFrameReverter] (InterestingQuantities const& iq) {
       sipixelobjects::GlobalPixel gp = {iq.row, iq.col};
       return Value(siPixelFrameReverter->findRocInDet(iq.sourceModule.rawId(), gp));
     }
   );
 }

void GeometryInterface::loadFromSiPixelCoordinates	(	edm::EventSetup const &	iSetup,
		const edm::ParameterSet &	iConfig
	)

private

Definition at line 169 of file GeometryInterface.cc.

References addExtractor(), GeometryInterface::InterestingQuantities::col, extractors, edm::ParameterSet::getParameter(), recoMuon::in, intern(), GeometryInterface::InterestingQuantities::row, GeometryInterface::InterestingQuantities::sourceModule, and UNDEFINED.

Referenced by load().

                                                                                                               {
   // TODO: SiPixelCoordinates has a large overlap with theis GeometryInterface 
   // in general.
   // Rough convention is to use own code for things that are easy and fast to
   // determine, and use SiPixelCoordinates for complicated things.
   // SiPixelCoordinates uses lookup maps for everything, so it is faster than
   // most other code, but still slow on DQM scales. 
   int phase = iConfig.getParameter<int>("upgradePhase");
 
   // this shared pointer is kept alive by the references in the lambdas that follow.
   // That is a bit less obvious than keeping it as a member but more correct.
   auto coord = std::make_shared<SiPixelCoordinates>(phase);
 
   // note that we should reeinit for each event. But this probably won't explode
   // thanks to the massive memoization in SiPixelCoordinates which is completely
   // initialized while booking.
   coord->init(iSetup); 
 
   // SiPixelCoordinates uses a different convention for UNDEFINED:
   auto from_coord = [](double in) { return (in == -9999.0) ? UNDEFINED : Value(in); };
 
   // Rings are a concept that cannot be derived from bitmasks. 
   addExtractor(intern("PXRing"), 
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->ring(iq.sourceModule));
     }
   );
 
   // Quadrant names.
   auto pxbarrel = extractors[intern("PXBarrel")];
   addExtractor(intern("HalfCylinder"),
     [coord, pxbarrel] (InterestingQuantities const& iq) {
       if (pxbarrel(iq) != UNDEFINED) return UNDEFINED;
       int quadrant = coord->quadrant(iq.sourceModule);
       switch (quadrant) {
         case 1: return Value(12); // mO
         case 2: return Value(11); // mI
         case 3: return Value(22); // pO
         case 4: return Value(21); // pI
         default: return UNDEFINED;
       }
     }, 0, 0 // N/A
   );
   addExtractor(intern("Shell"),
     [coord, pxbarrel] (InterestingQuantities const& iq) {
       if (pxbarrel(iq) == UNDEFINED) return UNDEFINED;
       int quadrant = coord->quadrant(iq.sourceModule);
       switch (quadrant) {
         case 1: return Value(12); // mO
         case 2: return Value(11); // mI
         case 3: return Value(22); // pO
         case 4: return Value(21); // pI
         default: return UNDEFINED;
       }
     }, 0, 0 // N/A
   );
 
   // Online Numbering.
   addExtractor(intern("SignedLadder"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->signed_ladder(iq.sourceModule()));
     }
   );
   addExtractor(intern("SignedModule"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->signed_module(iq.sourceModule()));
     }
   );
   addExtractor(intern("SignedBlade"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->signed_blade(iq.sourceModule()));
     }
   );
 
   // Pixel Map axis. 
   // TODO: binning should be phase-dependent. Or maybe even per-plot configurable.
   addExtractor(intern("SignedModuleCoord"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->signed_module_coord(iq.sourceModule(),
         std::make_pair(int(iq.row), int(iq.col))));
     }, UNDEFINED, UNDEFINED, 1.0/8.0
   );
   addExtractor(intern("SignedLadderCoord"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->signed_ladder_coord(iq.sourceModule(),
         std::make_pair(int(iq.row), int(iq.col))));
     }, UNDEFINED, UNDEFINED, 1.0/2.0
   );
   addExtractor(intern("SignedDiskCoord"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->signed_disk_coord(iq.sourceModule(),
         std::make_pair(int(iq.row), int(iq.col))));
     }, UNDEFINED, UNDEFINED, 1.0/8.0
   );
   addExtractor(intern("SignedBladePanelCoord"),
     [coord, from_coord, phase] (InterestingQuantities const& iq) {
       if (phase == 0) {
         return from_coord(coord->signed_blade_coord(
           iq.sourceModule(), std::make_pair(int(iq.row), int(iq.col))));
       } else if (phase == 1) {
         return from_coord(coord->signed_blade_panel_coord(
           iq.sourceModule(), std::make_pair(int(iq.row), int(iq.col))));
       } else {
         // TODO: phase2
         return UNDEFINED;
       }
     }, UNDEFINED, UNDEFINED, phase == 1 ? 0.25 : 0.2
   );
 
   addExtractor(intern("SignedBladePanel"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->signed_blade_panel_coord(iq.sourceModule(), std::make_pair(int(iq.row), int(iq.col))));
     }, UNDEFINED, UNDEFINED, 1.0/2.0
   );
 
   // more readout-related things.
   addExtractor(intern("ROC"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->roc(iq.sourceModule(),
         std::make_pair(int(iq.row), int(iq.col))));
     }
   );
   addExtractor(intern("Sector"),
     [coord, from_coord] (InterestingQuantities const& iq) {
       return from_coord(coord->sector(iq.sourceModule()));
     }
   );
 
 }

void GeometryInterface::loadFromTopology	(	edm::EventSetup const &	iSetup,
		const edm::ParameterSet &	iConfig
	)

private

Definition at line 56 of file GeometryInterface.cc.

References addExtractor(), all_modules, assert(), alignCSCRings::e, Reference_intrackfit_cff::endcap, extractors, format_value, edm::EventSetup::get(), edm::ParameterSet::getParameter(), intern(), edm::ESHandleBase::isValid(), mod(), PixelEndcapName::name(), PixelBarrelName::name(), mergeVDriftHistosByStation::name, TrackerTopology::PBLadder, TrackerTopology::PBLayer, TrackerTopology::PBModule, TrackerTopology::PFBlade, TrackerTopology::PFDisk, TrackerTopology::PFModule, TrackerTopology::PFPanel, TrackerTopology::PFSide, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, GeometryInterface::InterestingQuantities::sourceModule, AlCaHLTBitMon_QueryRunRegistry::string, groupFilesInBlocks::tt, and UNDEFINED.

Referenced by load().

                                                                                                     {
   // Get a Topology
   edm::ESHandle<TrackerTopology> trackerTopologyHandle;
   iSetup.get<TrackerTopologyRcd>().get(trackerTopologyHandle);
   assert(trackerTopologyHandle.isValid());
 
   std::vector<ID> geomquantities;
 
   struct TTField {
     const TrackerTopology* tt;
     TrackerTopology::DetIdFields field;
     Value operator()(InterestingQuantities const& iq) {
       if (tt->hasField(iq.sourceModule, field))
         return tt->getField(iq.sourceModule, field);
       else
         return UNDEFINED;
     };
   };
 
   const TrackerTopology* tt = trackerTopologyHandle.operator->();
 
 
   std::vector<std::pair<std::string, TTField>> namedPartitions {
     {"PXEndcap" , {tt, TrackerTopology::PFSide}},
 
     {"PXLayer"  , {tt, TrackerTopology::PBLayer}},
     {"PXLadder" , {tt, TrackerTopology::PBLadder}},
     {"PXBModule", {tt, TrackerTopology::PBModule}},
 
     {"PXBlade"  , {tt, TrackerTopology::PFBlade}},
     {"PXDisk"   , {tt, TrackerTopology::PFDisk}},
     {"PXPanel"  , {tt, TrackerTopology::PFPanel}},
     {"PXFModule", {tt, TrackerTopology::PFModule}},
   };
 
   for (auto& e : namedPartitions) {
     geomquantities.push_back(intern(e.first));
     addExtractor(intern(e.first), e.second, UNDEFINED, UNDEFINED);
   }
 
   auto pxbarrel  = [] (InterestingQuantities const& iq) { return iq.sourceModule.subdetId() == PixelSubdetector::PixelBarrel ? 0 : UNDEFINED; };
   auto pxforward = [] (InterestingQuantities const& iq) { return iq.sourceModule.subdetId() == PixelSubdetector::PixelEndcap ? 0 : UNDEFINED; };
   addExtractor(intern("PXBarrel"),  pxbarrel,  0, 0);
   addExtractor(intern("PXForward"), pxforward, 0, 0);
 
   // Redefine the disk numbering to use the sign
   auto pxendcap = extractors[intern("PXEndcap")];
   auto diskid = intern("PXDisk");
   auto pxdisk = extractors[diskid];
   extractors[diskid] = [pxdisk, pxendcap] (InterestingQuantities const& iq) {
     auto disk = pxdisk(iq);
     if (disk == UNDEFINED) return UNDEFINED;
     auto endcap = pxendcap(iq);
     return endcap == 1 ? -disk : disk;
   };
 
   // DetId and module names
   auto detid = [] (InterestingQuantities const& iq) {
     uint32_t id = iq.sourceModule.rawId();
     return Value(id);
   };
   addExtractor(intern("DetId"), detid,
     0, 0 // No sane value possible here.
   );
   // these are just aliases with special handling in formatting
   // the names are created with PixelBarrelName et. al. later
   addExtractor(intern("PXModuleName"), detid, 0, 0);
 
   int phase = iConfig.getParameter<int>("upgradePhase");
   bool isUpgrade = phase == 1;
 
   // Get a Geometry
   edm::ESHandle<TrackerGeometry> trackerGeometryHandle;
   iSetup.get<TrackerDigiGeometryRecord>().get(trackerGeometryHandle);
   assert(trackerGeometryHandle.isValid());
 
   // some parameters to record the ROCs here
   auto module_rows = iConfig.getParameter<int>("module_rows") - 1;
   auto module_cols = iConfig.getParameter<int>("module_cols") - 1;
 
   // Now traverse the detector and collect whatever we need.
   auto detids = trackerGeometryHandle->detIds();
   for (DetId id : detids) {
     if (id.subdetId() != PixelSubdetector::PixelBarrel && id.subdetId() != PixelSubdetector::PixelEndcap) continue;
     auto iq = InterestingQuantities{nullptr, id, 0, 0};
 
     // prepare pretty names
     std::string name = "";
     if (id.subdetId() == PixelSubdetector::PixelBarrel) { // Barrel
       PixelBarrelName mod(id, tt, isUpgrade);
       name = mod.name();
     } else { // assume Endcap
       PixelEndcapName mod(id, tt, isUpgrade);
       name = mod.name();
     }
     format_value[std::make_pair(intern("PXModuleName"), Value(id.rawId()))] = name;
 
     // we record each module 4 times, one for each corner, so we also get ROCs
     // in booking (at least for the ranges)
     // TODO: add all ROCs?
     // TODO: Things are more complicated for phase2, and we support that via 
     // SiPixelCoordinates, so we should support it here too.
     iq.row = 1; iq.col = 1;
     all_modules.push_back(iq);
     iq.row = module_rows-1; iq.col = 1;
     all_modules.push_back(iq);
     iq.row = 1; iq.col = module_cols-1;
     all_modules.push_back(iq);
     iq.row = module_rows-1; iq.col = module_cols-1;
     all_modules.push_back(iq);
   }
 }

void GeometryInterface::loadModuleLevel	(	edm::EventSetup const &	iSetup,
		const edm::ParameterSet &	iConfig
	)

private

Definition at line 329 of file GeometryInterface.cc.

References addExtractor(), GeometryInterface::InterestingQuantities::col, edm::ParameterSet::getParameter(), intern(), and GeometryInterface::InterestingQuantities::row.

Referenced by load().

                                                                                                    {
   // stuff that is within modules. Might require some phase0/phase1/strip switching later
   addExtractor(intern("row"),
     [] (InterestingQuantities const& iq) {
       return Value(iq.row);
     },
     0, iConfig.getParameter<int>("module_rows") - 1
   );
   addExtractor(intern("col"),
     [] (InterestingQuantities const& iq) {
       return Value(iq.col);
     },
     0, iConfig.getParameter<int>("module_cols") - 1
   );
 
 }

void GeometryInterface::loadTimebased	(	edm::EventSetup const &	iSetup,
		const edm::ParameterSet &	iConfig
	)

private

Definition at line 299 of file GeometryInterface.cc.

References addExtractor(), edm::EventBase::bunchCrossing(), edm::ParameterSet::getParameter(), intern(), edm::EventBase::luminosityBlock(), GeometryInterface::InterestingQuantities::sourceEvent, and UNDEFINED.

Referenced by load().

                                                                                                  {
   // extractors for quantities that are roughly time-based. We cannot book plots based on these; they have to
   // be grouped away in step1.
   addExtractor(intern("Lumisection"),
     [] (InterestingQuantities const& iq) {
       if(!iq.sourceEvent) return UNDEFINED;
       return Value(iq.sourceEvent->luminosityBlock());
     },
     1, iConfig.getParameter<int>("max_lumisection")
   );
   int onlineblock = iConfig.getParameter<int>("onlineblock");
   int n_onlineblocks = iConfig.getParameter<int>("n_onlineblocks");
   addExtractor(intern("OnlineBlock"),
     [onlineblock] (InterestingQuantities const& iq) {
       if(!iq.sourceEvent) return UNDEFINED;
       return Value(onlineblock + iq.sourceEvent->luminosityBlock() / onlineblock);
     },
     // note: this range is not visible anywhere (if the RenderPlugin does its job),
     // but the strange range allows the RenderPlugin to know the block size.
     onlineblock, onlineblock+n_onlineblocks-1
   );
   addExtractor(intern("BX"),
     [] (InterestingQuantities const& iq) {
       if(!iq.sourceEvent) return UNDEFINED;
       return Value(iq.sourceEvent->bunchCrossing());
     },
     1, iConfig.getParameter<int>("max_bunchcrossing")
   );
 }

Value GeometryInterface::maxValue ( ID id )

inline

Definition at line 98 of file GeometryInterface.h.

References max_value.

Referenced by HistogramManager::book().

98 { return max_value[id]; };

GeometryInterface::max_value

std::map< ID, Value > max_value

Definition: GeometryInterface.h:153

Value GeometryInterface::minValue ( ID id )

inline

Definition at line 99 of file GeometryInterface.h.

References min_value.

Referenced by HistogramManager::book().

99 { return min_value[id]; };

GeometryInterface::min_value

std::map< ID, Value > min_value

Definition: GeometryInterface.h:154

std::string GeometryInterface::pretty ( Column col )

inline

Definition at line 123 of file GeometryInterface.h.

References unintern().

Referenced by HistogramManager::book(), HistogramManager::executeExtend(), formatValue(), and HistogramManager::makePathName().

                                {
     return unintern(col);
   }

std::string GeometryInterface::unintern ( ID id )

inline

Definition at line 117 of file GeometryInterface.h.

References alignCSCRings::e, and ids.

Referenced by extract(), and pretty().

                             {
     for (auto& e : ids)
       if (e.second == id) return e.first;
     return "INVALID";
   }

Member Data Documentation

std::vector<InterestingQuantities> GeometryInterface::all_modules

private

Definition at line 170 of file GeometryInterface.h.

Referenced by allModules(), and loadFromTopology().

std::map<ID, Value> GeometryInterface::bin_width

private

Definition at line 155 of file GeometryInterface.h.

Referenced by addExtractor(), and binWidth().

std::vector<std::function<Value(InterestingQuantities const& iq)> > GeometryInterface::extractors

private

Definition at line 149 of file GeometryInterface.h.

Referenced by addExtractor(), extract(), intern(), load(), loadFromSiPixelCoordinates(), and loadFromTopology().

std::map<std::pair<Column, Value>, std::string> GeometryInterface::format_value

private

Definition at line 159 of file GeometryInterface.h.

Referenced by formatValue(), and loadFromTopology().

const edm::ParameterSet GeometryInterface::iConfig

private

Definition at line 143 of file GeometryInterface.h.

Referenced by load().

std::map<std::string, ID> GeometryInterface::ids {std::make_pair(std::string("INVALID"), ID(0))}

private

Definition at line 173 of file GeometryInterface.h.

Referenced by intern(), load(), and unintern().

bool GeometryInterface::is_loaded = false

private

Definition at line 145 of file GeometryInterface.h.

Referenced by load(), and loaded().

ID GeometryInterface::max_id = 0

private

Definition at line 174 of file GeometryInterface.h.

Referenced by intern().

std::map<ID, Value> GeometryInterface::max_value

private

Definition at line 153 of file GeometryInterface.h.

Referenced by addExtractor(), load(), and maxValue().

std::map<ID, Value> GeometryInterface::min_value

private

Definition at line 154 of file GeometryInterface.h.

Referenced by addExtractor(), load(), and minValue().

const GeometryInterface::Value GeometryInterface::UNDEFINED = 999999999.9f

static

Definition at line 35 of file GeometryInterface.h.

Referenced by SiPixelPhase1GeometryDebug::analyze(), HistogramManager::book(), extract(), formatValue(), loadFromSiPixelCoordinates(), loadFromTopology(), and loadTimebased().

Classes

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation