GeometryInterface Class Reference

#include <GeometryInterface.h>

Classes
struct	InterestingQuantities
struct	Values

Public Types
typedef std::array< ID, 2 >	Column
typedef int	ID
typedef int	Value

Public Member Functions
std::vector < InterestingQuantities > const &	allModules ()
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)
	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 = 0x0FFFFFFF

Private Member Functions
void	addExtractor (ID id, std::function< Value(InterestingQuantities const &iq)> func, Value min=UNDEFINED, Value max=UNDEFINED)
void	loadFEDCabling (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::vector< std::function < Value(InterestingQuantities const &iq)> >	extractors
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 std::array<ID, 2> GeometryInterface::Column

Definition at line 37 of file GeometryInterface.h.

typedef int GeometryInterface::ID

Definition at line 30 of file GeometryInterface.h.

typedef int GeometryInterface::Value

Definition at line 38 of file GeometryInterface.h.

Constructor & Destructor Documentation

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

inline

Definition at line 83 of file GeometryInterface.h.

: iConfig(conf){};

Member Function Documentation

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

inlineprivate

Definition at line 197 of file GeometryInterface.h.

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

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

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

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

inline

Definition at line 137 of file GeometryInterface.h.

References all_modules.

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

                                                       {
    return all_modules;
  };

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

inline

Definition at line 110 of file GeometryInterface.h.

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

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

                                                                                     {
    assert(col[0] != 0 || !"Extracting invalid column.");
    for (ID id : col) {
      if (id == 0) break;  // all set columns failed
      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, 0}}, val);  // double braces for g++
          break;
        }
      }
    }
    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 131 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 101 of file GeometryInterface.h.

References GeometryInterface::Values::clear(), cuy::col, extract(), GeometryInterface::Values::put(), 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.put(val.first, val.second);
    }
  };

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

inline

Definition at line 146 of file GeometryInterface.h.

References extractors, ids, and max_id.

Referenced by SiPixelPhase1Clusters::analyze(), SiPixelPhase1Digis::analyze(), loadFEDCabling(), 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 34 of file GeometryInterface.cc.

References alignCSCRings::e, extractors, iConfig, ids, is_loaded, loadFEDCabling(), 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);
  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 85 of file GeometryInterface.h.

References is_loaded.

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

{ return is_loaded; };

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

private

Definition at line 315 of file GeometryInterface.cc.

References addExtractor(), all_modules, GeometryInterface::InterestingQuantities::col, edm::EventSetup::get(), edm::ParameterSet::getParameter(), intern(), AlCaHLTBitMon_ParallelJobs::p, mergeAndRegister::paths, GeometryInterface::InterestingQuantities::row, GeometryInterface::InterestingQuantities::sourceModule, AlCaHLTBitMon_QueryRunRegistry::string, and UNDEFINED.

Referenced by load().

                                                                                                  {
  auto cablingMapLabel = iConfig.getParameter<std::string>("CablingMapLabel");
  edm::ESHandle<SiPixelFedCablingMap> theCablingMap;
  iSetup.get<SiPixelFedCablingMapRcd>().get(cablingMapLabel, theCablingMap);
  std::map<DetId, Value> fedmap;
  uint32_t minFED = UNDEFINED, maxFED = 0;

  if (theCablingMap.isValid()) {
    auto map = theCablingMap.product();

    for(auto iq : all_modules) {
      std::vector<sipixelobjects::CablingPathToDetUnit> paths = map->pathToDetUnit(iq.sourceModule.rawId());
      for (auto p : paths) {
        //std::cout << "+++ cabling " << iq.sourceModule.rawId() << " " << p.fed << " " << p.link << " " << p.roc << "\n";
        fedmap[iq.sourceModule] = Value(p.fed);
        if (p.fed > maxFED) maxFED = p.fed;
        if (p.fed < minFED) minFED = p.fed;
      }
    }
  } else {
    edm::LogError("GeometryInterface") << "+++ No cabling map. Cannot extract FEDs.\n";
  }

  addExtractor(intern("FED"),
    [fedmap] (InterestingQuantities const& iq) {
      if (iq.sourceModule == 0xFFFFFFFF)
        return Value(iq.col); // hijacked for the raw data plugin
      auto it = fedmap.find(iq.sourceModule);
      if (it == fedmap.end()) return GeometryInterface::UNDEFINED;
      return it->second;
    }
  );
  addExtractor(intern("FEDChannel"),
    [] (InterestingQuantities const& iq) {
      // TODO: we also should be able to compute the channel from the ROC.
      // But for raw data, we only need this hack.
      //if (iq.sourceModule == 0xFFFFFFFF)
      return Value(iq.row); // hijacked for the raw data plugin
    },
    0, 39 // TODO: real range
  );
}

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

private

Definition at line 47 of file GeometryInterface.cc.

References addExtractor(), all_modules, assert(), alignCSCRings::e, Reference_intrackfit_cff::endcap, extractors, cropTnPTrees::frac, edm::EventSetup::get(), edm::ParameterSet::getParameter(), intern(), edm::ESHandleBase::isValid(), mod(), python.rootplot.argparse::module, TrackerTopology::PBLadder, TrackerTopology::PBLayer, TrackerTopology::PBModule, TrackerTopology::PFBlade, TrackerTopology::PFDisk, TrackerTopology::PFModule, TrackerTopology::PFPanel, TrackerTopology::PFSide, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, GeometryInterface::InterestingQuantities::sourceModule, 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;
  };

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

  // We need to track some extra stuff here for the Shells later.
  auto pxlayer  = extractors[intern("PXLayer")];
  auto pxladder = extractors[intern("PXLadder")];
  auto pxmodule = extractors[intern("PXBModule")];
  auto pxblade  = extractors[intern("PXBlade")];
  std::vector<Value> maxladders;
  Value maxmodule = 0;
  Value innerring = iConfig.getParameter<int>("n_inner_ring_blades");
  Value outerring = 0;

  // Now travrse 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};
    auto layer = pxlayer(iq);
    if (layer != UNDEFINED) {
      if (layer >= Value(maxladders.size())) maxladders.resize(layer+1);
      auto ladder = pxladder(iq);
      if (ladder > maxladders[layer]) maxladders[layer] = ladder;
    }
    auto module = pxmodule(iq);
    if (module != UNDEFINED && module > maxmodule) maxmodule = module;
    auto blade = pxblade(iq);
    if (blade != UNDEFINED && blade > outerring) outerring = blade;

    // we record each module 4 times, one for each corner, so we also get ROCs
    // in booking (at least for the ranges)
    iq.row = 0; iq.col = 0;
    all_modules.push_back(iq);
    iq.row = module_rows; iq.col = 0;
    all_modules.push_back(iq);
    iq.row = 0; iq.col = module_cols;
    all_modules.push_back(iq);
    iq.row = module_rows; iq.col = module_cols;
    all_modules.push_back(iq);
  }

  outerring = outerring - innerring;

  // Shells are a concept that cannot be derived from bitmasks. 
  // Use hardcoded logic here.
  // This contains a lot more assumptions about general geometry than the rest
  // of the code, but it might work for Phase0 as well.
  addExtractor(intern("PXRing"), 
    [pxblade, innerring] (InterestingQuantities const& iq) {
      auto blade = pxblade(iq);
      if (blade == UNDEFINED) return UNDEFINED;
      if (blade <= innerring) return Value(1);
      else return Value(2);
    }
  );

  addExtractor(intern("HalfCylinder"),
    [pxendcap, pxblade, innerring, outerring] (InterestingQuantities const& iq) {
      auto ec = pxendcap(iq);
      if (ec == UNDEFINED) return UNDEFINED;
      auto blade = pxblade(iq);
      // blade 1 and 56 are at 3 o'clock. This is a mess.
      auto inring  = blade > innerring ? (innerring+outerring+1) - blade : blade;
      auto perring = blade > innerring ? outerring : innerring;
      // inring is now 1-based, 1 at 3 o'clock, upto perring.
      int frac = (int) ((inring-1) / float(perring) * 4); // floor semantics here
      if (frac == 0 || frac == 3) return 10*ec + 1; // inner half
      if (frac == 1 || frac == 2) return 10*ec + 2; // outer half
      assert(!"HalfCylinder logic problem");
      return UNDEFINED;
    }, 0, 0 // N/A
  );

  // For the '+-shape' (ladder vs. module) plots, we need signed numbers with
  // (unused) 0-ladder/module at x=0/z=0. This means a lot of messing with the
  // ladder/shell numbering...
  addExtractor(intern("signedLadder"),
    [pxbarrel, pxladder, pxlayer, maxladders, maxmodule] (InterestingQuantities const& iq) {
      if(pxbarrel(iq) == UNDEFINED) return UNDEFINED;
      auto layer  = pxlayer(iq);
      auto ladder = pxladder(iq);
      int frac = (int) ((ladder-1) / float(maxladders[layer]) * 4); // floor semantics
      Value quarter = maxladders[layer] / 4;
      if (frac == 0) return -ladder + quarter + 1; // top right - +1 for gap
      if (frac == 1) return -ladder + quarter; // top left -
      if (frac == 2) return -ladder + quarter; // bot left - same
      if (frac == 3) return -ladder  + 4*quarter + quarter + 1; // bot right - like top right but wrap around
      assert(!"Shell logic problem");
      return UNDEFINED;
    }
  );

  addExtractor(intern("signedModule"),
    [pxmodule, maxmodule] (InterestingQuantities const& iq) {
      Value mod = pxmodule(iq);  // range 1..maxmodule
      if (mod == UNDEFINED) return UNDEFINED;
      mod -= (maxmodule/2 + 1); // range -(max_module/2)..-1, 0..
      if (mod >= 0) mod += 1;    // range -(max_module/2)..-1, 1..
      return mod;
    }
  );

  auto signedladder = extractors[intern("signedLadder")];
  auto signedmodule = extractors[intern("signedModule")];
  addExtractor(intern("Shell"),
    [signedladder, signedmodule] (InterestingQuantities const& iq) {
      auto sl = signedladder(iq);
      auto sm = signedmodule(iq);
      if (sl == UNDEFINED) return UNDEFINED;
      return Value((sm < 0 ? 10 : 20) + (sl < 0 ? 2 : 1)); // negative means outer shell!?
    }, 0, 0 // N/A
  );

  addExtractor(intern(""), // A dummy column. Not much special handling required.
    [] (InterestingQuantities const& iq) { return 0; },
    0, 0
  );

}

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

private

Definition at line 259 of file GeometryInterface.cc.

References addExtractor(), GeometryInterface::InterestingQuantities::col, extractors, edm::ParameterSet::getParameter(), intern(), mod(), DetId::rawId(), GeometryInterface::InterestingQuantities::row, GeometryInterface::InterestingQuantities::sourceModule, and UNDEFINED.

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
  );

  int   n_rocs     = iConfig.getParameter<int>("n_rocs");
  float roc_cols   = iConfig.getParameter<int>("roc_cols");
  float roc_rows   = iConfig.getParameter<int>("roc_rows");
  auto  pxmodule   = extractors[intern("PXBModule")];
  auto  pxpanel    = extractors[intern("PXPanel")];
  addExtractor(intern("ROC"),
    [n_rocs, roc_cols, roc_rows] (InterestingQuantities const& iq) {
      int fedrow = int(iq.row / roc_rows);
      int fedcol = int(iq.col / roc_cols);
      if (fedrow == 0) return Value(fedcol);
      if (fedrow == 1) return Value(n_rocs - 1 - fedcol);
      return UNDEFINED;
    }
  );

  // arbitrary per-ladder numbering (for inefficiencies)
  auto roc = extractors[intern("ROC")];
  addExtractor(intern("ROCinLadder"),
    [pxmodule, roc, n_rocs] (InterestingQuantities const& iq) {
      auto mod = pxmodule(iq);
      if (mod == UNDEFINED) return UNDEFINED;
      return Value(roc(iq) + n_rocs * (mod-1));
    }
  );
  addExtractor(intern("ROCinBlade"),
    [pxmodule, pxpanel, roc, n_rocs] (InterestingQuantities const& iq) {
      auto mod = pxpanel(iq);
      if (mod == UNDEFINED) return UNDEFINED;
      return Value(roc(iq) + n_rocs * (mod-1));
    }
  );

  addExtractor(intern("DetId"),
    [] (InterestingQuantities const& iq) {
      uint32_t id = iq.sourceModule.rawId();
      return Value(id);
    },
    0, 0 // No sane value possible here.
  );
}

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

private

Definition at line 229 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 140 of file GeometryInterface.h.

References max_value.

Referenced by HistogramManager::book().

{ return max_value[id]; };

Value GeometryInterface::minValue ( ID  id )

inline

Definition at line 141 of file GeometryInterface.h.

References min_value.

Referenced by HistogramManager::book().

{ return min_value[id]; };

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

inline

Definition at line 164 of file GeometryInterface.h.

References unintern().

Referenced by HistogramManager::book(), HistogramManager::executeExtend(), HistogramManager::makeName(), and HistogramManager::makePath().

                               {
    if (col[1] == 0)  // normal column
      return unintern(col[0]);
    else
      return unintern(col[0]) +
             /*"|" +*/ unintern(col[1]);  // TODO: should loop.
  }

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

inline

Definition at line 158 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 205 of file GeometryInterface.h.

Referenced by allModules(), loadFEDCabling(), and loadFromTopology().

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

private

Definition at line 190 of file GeometryInterface.h.

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

const edm::ParameterSet GeometryInterface::iConfig

private

Definition at line 184 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 208 of file GeometryInterface.h.

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

bool GeometryInterface::is_loaded = false

private

Definition at line 186 of file GeometryInterface.h.

Referenced by load(), and loaded().

ID GeometryInterface::max_id = 0

private

Definition at line 209 of file GeometryInterface.h.

Referenced by intern().

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

private

Definition at line 194 of file GeometryInterface.h.

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

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

private

Definition at line 195 of file GeometryInterface.h.

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

const GeometryInterface::Value GeometryInterface::UNDEFINED = 0x0FFFFFFF

static

Definition at line 39 of file GeometryInterface.h.

Referenced by SiPixelPhase1Clusters::analyze(), HistogramManager::book(), extract(), GeometryInterface::Values::get(), loadFEDCabling(), loadFromTopology(), loadModuleLevel(), loadTimebased(), and HistogramManager::makePath().