SeedingLayerSetsBuilder Class Reference

#include <SeedingLayerSetsBuilder.h>

Classes
struct	LayerSpec

Public Types
using	SeedingLayerId = std::tuple< GeomDetEnumerators::SubDetector, TrackerDetSide, int >

Public Member Functions
std::unique_ptr< SeedingLayerSetsHits >	hits (const edm::Event &ev, const edm::EventSetup &es)
std::vector< SeedingLayerId >	layers () const
const std::vector< SeedingLayerSetsHits::LayerSetIndex > &	layerSetIndices () const
std::unique_ptr< SeedingLayerSetsHits >	makeSeedingLayerSetsHitsforFastSim (const edm::Event &ev, const edm::EventSetup &es)
unsigned short	numberOfLayers () const
unsigned short	numberOfLayerSets () const
	SeedingLayerSetsBuilder ()=default
	SeedingLayerSetsBuilder (const edm::ParameterSet &cfg, edm::ConsumesCollector &iC, const edm::InputTag &fastsimHitTag)
	SeedingLayerSetsBuilder (const edm::ParameterSet &cfg, edm::ConsumesCollector &iC)
	SeedingLayerSetsBuilder (const edm::ParameterSet &cfg, edm::ConsumesCollector &&iC)
SeedingLayerSetsLooper	seedingLayerSetsLooper () const
	~SeedingLayerSetsBuilder ()

Static Public Member Functions
static void	fillDescriptions (edm::ParameterSetDescription &desc)
static std::vector< std::vector< std::string > >	layerNamesInSets (const std::vector< std::string > &namesPSet)
static SeedingLayerId	nameToEnumId (const std::string &name)

Private Member Functions
edm::ParameterSet	layerConfig (const std::string &nameLayer, const edm::ParameterSet &cfg) const
void	updateEventSetup (const edm::EventSetup &es)

Private Attributes
edm::EDGetTokenT< FastTrackerRecHitCollection >	fastSimrecHitsToken_
edm::ESWatcher< TrackerRecoGeometryRecord >	geometryWatcher_
std::vector< const DetLayer * >	theLayerDets
std::vector< std::string >	theLayerNames
std::vector< LayerSpec >	theLayers
std::vector< SeedingLayerSetsHits::LayerSetIndex >	theLayerSetIndices
unsigned short	theNumberOfLayersInSet
std::vector< const TransientTrackingRecHitBuilder * >	theTTRHBuilders
edm::ESWatcher< TransientRecHitRecord >	trhWatcher_

Detailed Description

Definition at line 25 of file SeedingLayerSetsBuilder.h.

Member Typedef Documentation

using SeedingLayerSetsBuilder::SeedingLayerId = std::tuple<GeomDetEnumerators::SubDetector, TrackerDetSide, int>

Definition at line 28 of file SeedingLayerSetsBuilder.h.

Constructor & Destructor Documentation

SeedingLayerSetsBuilder::SeedingLayerSetsBuilder ( )

default

SeedingLayerSetsBuilder::SeedingLayerSetsBuilder	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &	iC,
		const edm::InputTag &	fastsimHitTag
	)

Definition at line 182 of file SeedingLayerSetsBuilder.cc.

References edm::ConsumesCollector::consumes(), and fastSimrecHitsToken_.

                                                                                                                                       :
  SeedingLayerSetsBuilder(cfg, iC)
{
  fastSimrecHitsToken_ = iC.consumes<FastTrackerRecHitCollection>(fastsimHitTag); 
}

SeedingLayerSetsBuilder::SeedingLayerSetsBuilder	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &	iC
	)

Definition at line 190 of file SeedingLayerSetsBuilder.cc.

References Exception, spr::find(), runEdmFileComparison::found, edm::ParameterSet::getParameter(), layerConfig(), layerNamesInSets(), SiStripPI::max, str, AlCaHLTBitMon_QueryRunRegistry::string, theLayerDets, theLayerNames, theLayers, theLayerSetIndices, theNumberOfLayersInSet, and theTTRHBuilders.

{
  std::vector<std::string> namesPset = cfg.getParameter<std::vector<std::string> >("layerList");
  std::vector<std::vector<std::string> > layerNamesInSets = this->layerNamesInSets(namesPset);
  // debug printout of layers
  typedef std::vector<std::string>::const_iterator IS;
  typedef std::vector<std::vector<std::string> >::const_iterator IT;
  std::ostringstream str;
  // The following should not be set to cout
//  for (IT it = layerNamesInSets.begin(); it != layerNamesInSets.end(); it++) {
//    str << "SET: ";
//    for (IS is = it->begin(); is != it->end(); is++)  str << *is <<" ";  
//    str << std::endl;
//  }
//  std::cout << str.str() << std::endl;
  if(layerNamesInSets.empty())
    theNumberOfLayersInSet = 0;
  else
    theNumberOfLayersInSet = layerNamesInSets[0].size();


  for (IT it = layerNamesInSets.begin(); it != layerNamesInSets.end(); it++) {
    if(it->size() != theNumberOfLayersInSet)
      throw cms::Exception("Configuration") << "Assuming all SeedingLayerSets to have same number of layers. LayerSet " << (it-layerNamesInSets.begin()) << " has " << it->size() << " while 0th has " << theNumberOfLayersInSet;
    for(const std::string& layerName: *it) {
      auto found = std::find(theLayerNames.begin(), theLayerNames.end(), layerName);
      unsigned short layerIndex = 0;
      if(found != theLayerNames.end()) {
        layerIndex = found-theLayerNames.begin();
      }
      else {
        if(std::numeric_limits<unsigned short>::max() == theLayerNames.size()) {
          throw cms::Exception("Assert") << "Too many layers in " << __FILE__ << ":" << __LINE__ << ", we may have to enlarge the index type from unsigned short to unsigned int";
        }

        layerIndex = theLayers.size();
        theLayers.emplace_back(theLayerNames.size(), layerName, layerConfig(layerName, cfg), iC);
        theLayerNames.push_back(layerName);
      }
      theLayerSetIndices.push_back(layerIndex);
    }
  }
  theLayerDets.resize(theLayers.size());
  theTTRHBuilders.resize(theLayers.size());

  // debug printout
  // The following should not be set to cout
  //for(const LayerSpec& layer: theLayers) {
  //  std::cout << layer.print(theLayerNames) << std::endl;
  //}
}

SeedingLayerSetsBuilder::SeedingLayerSetsBuilder	(	const edm::ParameterSet &	cfg,
		edm::ConsumesCollector &&	iC
	)

Definition at line 187 of file SeedingLayerSetsBuilder.cc.

                                                                                                      :
  SeedingLayerSetsBuilder(cfg, iC)
{}

SeedingLayerSetsBuilder::~SeedingLayerSetsBuilder

(

)

Definition at line 242 of file SeedingLayerSetsBuilder.cc.

{}

Member Function Documentation

void SeedingLayerSetsBuilder::fillDescriptions ( edm::ParameterSetDescription &  desc )

static

Definition at line 244 of file SeedingLayerSetsBuilder.cc.

References edm::ParameterSetDescription::add(), relativeConstraints::empty, and edm::ParameterSetDescription::setAllowAnything().

Referenced by SeedingLayersEDProducer::fillDescriptions(), and PixelInactiveAreaTrackingRegionsSeedingLayersProducer::fillDescriptions().

                                                                               {
  edm::ParameterSetDescription empty;
  empty.setAllowAnything(); // for now accept any parameter in the PSets, consider improving later

  desc.add<std::vector<std::string> >("layerList", {});
  desc.add<edm::ParameterSetDescription>("BPix", empty);
  desc.add<edm::ParameterSetDescription>("FPix", empty);
  desc.add<edm::ParameterSetDescription>("TIB", empty);
  desc.add<edm::ParameterSetDescription>("TID", empty);
  desc.add<edm::ParameterSetDescription>("TOB", empty);
  desc.add<edm::ParameterSetDescription>("TEC", empty);
  desc.add<edm::ParameterSetDescription>("MTIB", empty);
  desc.add<edm::ParameterSetDescription>("MTID", empty);
  desc.add<edm::ParameterSetDescription>("MTOB", empty);
  desc.add<edm::ParameterSetDescription>("MTEC", empty);
}

std::unique_ptr< SeedingLayerSetsHits > SeedingLayerSetsBuilder::hits	(	const edm::Event &	ev,
		const edm::EventSetup &	es
	)

Definition at line 369 of file SeedingLayerSetsBuilder.cc.

References theLayerDets, theLayerNames, theLayers, theLayerSetIndices, theNumberOfLayersInSet, theTTRHBuilders, and updateEventSetup().

Referenced by SeedingLayersEDProducer::produce(), and PixelInactiveAreaTrackingRegionsSeedingLayersProducer::produce().

                                                                                                             {
  updateEventSetup(es);
  
  auto ret = std::make_unique<SeedingLayerSetsHits>(theNumberOfLayersInSet,
                                                    &theLayerSetIndices,
                                                    &theLayerNames,
                                                    &theLayerDets);
  
  for(auto& layer: theLayers) {
    ret->addHits(layer.nameIndex, layer.extractor->hits((const TkTransientTrackingRecHitBuilder &)(*theTTRHBuilders[layer.nameIndex]), ev, es));
  }
  ret->shrink_to_fit();
  return ret;
}

edm::ParameterSet SeedingLayerSetsBuilder::layerConfig ( const std::string &  nameLayer, const edm::ParameterSet &  cfg  ) const

private

Definition at line 261 of file SeedingLayerSetsBuilder.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), dataset::name, and mps_fire::result.

Referenced by SeedingLayerSetsBuilder().

{
  edm::ParameterSet result;
   
  for (string::size_type iEnd=nameLayer.size(); iEnd > 0; --iEnd) {
    string name = nameLayer.substr(0,iEnd);
    if (cfg.exists(name)) return cfg.getParameter<edm::ParameterSet>(name);
  } 
  edm::LogError("SeedingLayerSetsBuilder") <<"configuration for layer: "<<nameLayer<<" not found, job will probably crash!";
  return result;
}

vector< vector< string > > SeedingLayerSetsBuilder::layerNamesInSets ( const std::vector< std::string > &  namesPSet )

static

Definition at line 273 of file SeedingLayerSetsBuilder.cc.

References mps_splice::line, and mps_fire::result.

Referenced by MTVHistoProducerAlgoForTracker::MTVHistoProducerAlgoForTracker(), and SeedingLayerSetsBuilder().

{
  std::vector<std::vector<std::string> > result; 
  for (std::vector<std::string>::const_iterator is=namesPSet.begin(); is < namesPSet.end(); ++is) {
    vector<std::string> layersInSet;
    string line = *is;
    string::size_type pos=0;
    while (pos != string::npos ) {
      pos=line.find("+");
      string layer = line.substr(0,pos);
      layersInSet.push_back(layer);
      line=line.substr(pos+1,string::npos); 
    }
    result.push_back(layersInSet);
  }
  return result;
}

std::vector< SeedingLayerSetsBuilder::SeedingLayerId > SeedingLayerSetsBuilder::layers

(

)

const

Definition at line 360 of file SeedingLayerSetsBuilder.cc.

References numberOfLayers(), and theLayers.

                                                                                       {
  std::vector<SeedingLayerId> ret;
  ret.reserve(numberOfLayers());
  for(const auto& layer: theLayers) {
    ret.emplace_back(layer.subdet, layer.side, layer.idLayer);
  }
  return ret;
}

const std::vector<SeedingLayerSetsHits::LayerSetIndex>& SeedingLayerSetsBuilder::layerSetIndices ( ) const

inline

Definition at line 43 of file SeedingLayerSetsBuilder.h.

References looper::cfg, ev, hfClusterShapes_cfi::hits, dataset::name, and AlCaHLTBitMon_QueryRunRegistry::string.

{ return theLayerSetIndices; }

std::unique_ptr< SeedingLayerSetsHits > SeedingLayerSetsBuilder::makeSeedingLayerSetsHitsforFastSim	(	const edm::Event &	ev,
		const edm::EventSetup &	es
	)

Definition at line 384 of file SeedingLayerSetsBuilder.cc.

References b, Barrel, TrackingRecHit::clone(), fastSimrecHitsToken_, edm::EventSetup::get(), edm::Event::getByToken(), GeomDetEnumerators::invalidDet, eostools::move(), NegEndcap, PixelSubdetector::PixelBarrel, GeomDetEnumerators::PixelBarrel, PixelSubdetector::PixelEndcap, GeomDetEnumerators::PixelEndcap, PosEndcap, edm::ESHandle< T >::product(), TrackerTopology::pxbLayer(), TrackerTopology::pxfDisk(), TrackerTopology::pxfSide(), theLayerDets, theLayerNames, theLayers, theLayerSetIndices, theNumberOfLayersInSet, and updateEventSetup().

                                                                                                                                           {
  updateEventSetup(es);

  edm::Handle<FastTrackerRecHitCollection> fastSimrechits_;
  ev.getByToken(fastSimrecHitsToken_,fastSimrechits_); //using FastSim RecHits
  edm::ESHandle<TrackerTopology> trackerTopology;
  es.get<TrackerTopologyRcd>().get(trackerTopology);
  const TrackerTopology* const tTopo = trackerTopology.product();
  SeedingLayerSetsHits::OwnedHits layerhits_;

  auto ret = std::make_unique<SeedingLayerSetsHits>(theNumberOfLayersInSet,
                                                    &theLayerSetIndices,
                                                    &theLayerNames,
                                                    &theLayerDets);

  for(auto& layer: theLayers) {
    layerhits_.clear();
    for(auto &rh : *fastSimrechits_){
      GeomDetEnumerators::SubDetector subdet = GeomDetEnumerators::invalidDet;
      TrackerDetSide side = TrackerDetSide::Barrel;
      int idLayer = 0;
      if( (rh.det()->geographicalId()).subdetId() == PixelSubdetector::PixelBarrel){
        subdet = GeomDetEnumerators::PixelBarrel;
    side = TrackerDetSide::Barrel;
    idLayer = tTopo->pxbLayer(rh.det()->geographicalId());
      }
      else if ((rh.det()->geographicalId()).subdetId() == PixelSubdetector::PixelEndcap){
    subdet = GeomDetEnumerators::PixelEndcap;
    idLayer = tTopo->pxfDisk(rh.det()->geographicalId());
    if(tTopo->pxfSide(rh.det()->geographicalId())==1)
      side = TrackerDetSide::NegEndcap;
    else
      side = TrackerDetSide::PosEndcap;
      }
      
      if(layer.subdet == subdet && layer.side == side && layer.idLayer == idLayer){
    BaseTrackerRecHit const & b(rh);
    auto ptrHit = (BaseTrackerRecHit *)(b.clone());
    layerhits_.emplace_back(ptrHit);
      }
      else continue;
    }
    ret->addHits(layer.nameIndex, std::move(layerhits_));
  }
  ret->shrink_to_fit();
  return ret;
}

SeedingLayerSetsBuilder::SeedingLayerId SeedingLayerSetsBuilder::nameToEnumId ( const std::string &  name )

static

Definition at line 33 of file SeedingLayerSetsBuilder.cc.

References Barrel, GeomDetEnumerators::invalidDet, NegEndcap, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, PosEndcap, GeomDetEnumerators::TEC, GeomDetEnumerators::TIB, GeomDetEnumerators::TID, and GeomDetEnumerators::TOB.

Referenced by SeedingLayerSetsBuilder::LayerSpec::LayerSpec(), and MTVHistoProducerAlgoForTracker::MTVHistoProducerAlgoForTracker().

                                                                                                 {
    GeomDetEnumerators::SubDetector subdet = GeomDetEnumerators::invalidDet;
    TrackerDetSide side = TrackerDetSide::Barrel;
    int idLayer = 0;

    size_t index;
    //
    // BPIX
    //
    if ((index = name.find("BPix")) != string::npos) {
      subdet = GeomDetEnumerators::PixelBarrel;
      side = TrackerDetSide::Barrel;
      idLayer = atoi(name.substr(index+4,1).c_str());
    }
    //
    // FPIX
    //
    else if ((index = name.find("FPix")) != string::npos) {
      subdet = GeomDetEnumerators::PixelEndcap;
      idLayer = atoi(name.substr(index+4).c_str());
      if ( name.find("pos") != string::npos ) {
        side = TrackerDetSide::PosEndcap;
      } else {
        side = TrackerDetSide::NegEndcap;
      }
    }
    //
    // TIB
    //
    else if ((index = name.find("TIB")) != string::npos) {
      subdet = GeomDetEnumerators::TIB;
      side = TrackerDetSide::Barrel;
      idLayer = atoi(name.substr(index+3,1).c_str());
    }
    //
    // TID
    //
    else if ((index = name.find("TID")) != string::npos) {
      subdet = GeomDetEnumerators::TID;
      idLayer = atoi(name.substr(index+3,1).c_str());
      if ( name.find("pos") != string::npos ) {
        side = TrackerDetSide::PosEndcap;
      } else {
        side = TrackerDetSide::NegEndcap;
      }
    }
    //
    // TOB
    //
    else if ((index = name.find("TOB")) != string::npos) {
      subdet = GeomDetEnumerators::TOB;
      side = TrackerDetSide::Barrel;
      idLayer = atoi(name.substr(index+3,1).c_str());
    }
    //
    // TEC
    //
    else if ((index = name.find("TEC")) != string::npos) {
      subdet = GeomDetEnumerators::TEC;
      idLayer = atoi(name.substr(index+3,1).c_str());
      if ( name.find("pos") != string::npos ) {
        side = TrackerDetSide::PosEndcap;
      } else {
        side = TrackerDetSide::NegEndcap;
      }
    }
    return std::make_tuple(subdet, side, idLayer);
}

unsigned short SeedingLayerSetsBuilder::numberOfLayers ( ) const

inline

Definition at line 38 of file SeedingLayerSetsBuilder.h.

Referenced by layers().

{ return theLayers.size(); }

unsigned short SeedingLayerSetsBuilder::numberOfLayerSets ( ) const

inline

Definition at line 39 of file SeedingLayerSetsBuilder.h.

References LayerTriplets::layers().

{ return theNumberOfLayersInSet > 0 ? theLayerSetIndices.size()/theNumberOfLayersInSet : 0; }

SeedingLayerSetsLooper SeedingLayerSetsBuilder::seedingLayerSetsLooper ( ) const

inline

Definition at line 41 of file SeedingLayerSetsBuilder.h.

{ return SeedingLayerSetsLooper(theNumberOfLayersInSet, &theLayerSetIndices); }

void SeedingLayerSetsBuilder::updateEventSetup ( const edm::EventSetup &  es )

private

Definition at line 291 of file SeedingLayerSetsBuilder.cc.

References GeometricSearchTracker::barrelLayers(), edm::ESWatcher< T >::check(), Exception, geometryWatcher_, edm::EventSetup::get(), GeometricSearchTracker::negForwardLayers(), GeometricSearchTracker::negTecLayers(), GeometricSearchTracker::negTidLayers(), GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, PosEndcap, GeometricSearchTracker::posForwardLayers(), GeometricSearchTracker::posTecLayers(), GeometricSearchTracker::posTidLayers(), edm::ESHandle< T >::product(), GeomDetEnumerators::TEC, theLayerDets, theLayerNames, theLayers, theTTRHBuilders, GeomDetEnumerators::TIB, GeometricSearchTracker::tibLayers(), GeomDetEnumerators::TID, GeomDetEnumerators::TOB, GeometricSearchTracker::tobLayers(), trackingTruthProducer_cfi::tracker, and trhWatcher_.

Referenced by hits(), and makeSeedingLayerSetsHitsforFastSim().

                                                                      {
  // We want to evaluate both in the first invocation (to properly
  // initialize ESWatcher), and this way we avoid one branch compared
  // to || (should be tiny effect)
  if(! (geometryWatcher_.check(es) | trhWatcher_.check(es)) )
    return;

  edm::ESHandle<GeometricSearchTracker> htracker;
  es.get<TrackerRecoGeometryRecord>().get( htracker );
  const GeometricSearchTracker& tracker = *htracker;

  const std::vector<BarrelDetLayer const*>&  bpx  = tracker.barrelLayers();
  const std::vector<BarrelDetLayer const*>&  tib  = tracker.tibLayers();
  const std::vector<BarrelDetLayer const*>&  tob  = tracker.tobLayers();

  const std::vector<ForwardDetLayer const*>& fpx_pos = tracker.posForwardLayers();
  const std::vector<ForwardDetLayer const*>& tid_pos = tracker.posTidLayers();
  const std::vector<ForwardDetLayer const*>& tec_pos = tracker.posTecLayers();

  const std::vector<ForwardDetLayer const*>& fpx_neg = tracker.negForwardLayers();
  const std::vector<ForwardDetLayer const*>& tid_neg = tracker.negTidLayers();
  const std::vector<ForwardDetLayer const*>& tec_neg = tracker.negTecLayers();

  for(const auto& layer: theLayers) {
    const DetLayer * detLayer = nullptr;
    int index = layer.idLayer-1;

    if (layer.subdet == GeomDetEnumerators::PixelBarrel) {
      detLayer = bpx[index];
    }
    else if (layer.subdet == GeomDetEnumerators::PixelEndcap) {
      if (layer.side == TrackerDetSide::PosEndcap) {
        detLayer = fpx_pos[index];
      } else {
        detLayer = fpx_neg[index];
      }
    }
    else if (layer.subdet == GeomDetEnumerators::TIB) {
      detLayer = tib[index];
    }
    else if (layer.subdet == GeomDetEnumerators::TID) {
      if (layer.side == TrackerDetSide::PosEndcap) {
        detLayer = tid_pos[index];
      } else {
        detLayer = tid_neg[index];
      }
    }
    else if (layer.subdet == GeomDetEnumerators::TOB) {
      detLayer = tob[index];
    }
    else if (layer.subdet == GeomDetEnumerators::TEC) {
      if (layer.side == TrackerDetSide::PosEndcap) {
        detLayer = tec_pos[index];
      } else {
        detLayer = tec_neg[index];
      }
    }
    else {
      throw cms::Exception("Configuration") << "Did not find DetLayer for layer " << theLayerNames[layer.nameIndex];
    }

    edm::ESHandle<TransientTrackingRecHitBuilder> builder;
    es.get<TransientRecHitRecord>().get(layer.hitBuilder, builder);

    theLayerDets[layer.nameIndex] = detLayer;
    theTTRHBuilders[layer.nameIndex] = builder.product();
  }
}

Member Data Documentation

edm::EDGetTokenT<FastTrackerRecHitCollection> SeedingLayerSetsBuilder::fastSimrecHitsToken_

private

Definition at line 58 of file SeedingLayerSetsBuilder.h.

Referenced by makeSeedingLayerSetsHitsforFastSim(), and SeedingLayerSetsBuilder().

edm::ESWatcher<TrackerRecoGeometryRecord> SeedingLayerSetsBuilder::geometryWatcher_

private

Definition at line 56 of file SeedingLayerSetsBuilder.h.

Referenced by updateEventSetup().

std::vector<const DetLayer *> SeedingLayerSetsBuilder::theLayerDets

private

Definition at line 81 of file SeedingLayerSetsBuilder.h.

Referenced by hits(), makeSeedingLayerSetsHitsforFastSim(), SeedingLayerSetsBuilder(), and updateEventSetup().

std::vector<std::string> SeedingLayerSetsBuilder::theLayerNames

private

Definition at line 80 of file SeedingLayerSetsBuilder.h.

Referenced by hits(), makeSeedingLayerSetsHitsforFastSim(), SeedingLayerSetsBuilder(), and updateEventSetup().

std::vector<LayerSpec> SeedingLayerSetsBuilder::theLayers

private

Definition at line 83 of file SeedingLayerSetsBuilder.h.

Referenced by hits(), layers(), makeSeedingLayerSetsHitsforFastSim(), SeedingLayerSetsBuilder(), and updateEventSetup().

std::vector<SeedingLayerSetsHits::LayerSetIndex> SeedingLayerSetsBuilder::theLayerSetIndices

private

Definition at line 79 of file SeedingLayerSetsBuilder.h.

Referenced by hits(), makeSeedingLayerSetsHitsforFastSim(), and SeedingLayerSetsBuilder().

unsigned short SeedingLayerSetsBuilder::theNumberOfLayersInSet

private

Definition at line 78 of file SeedingLayerSetsBuilder.h.

Referenced by hits(), makeSeedingLayerSetsHitsforFastSim(), and SeedingLayerSetsBuilder().

std::vector<const TransientTrackingRecHitBuilder *> SeedingLayerSetsBuilder::theTTRHBuilders

private

Definition at line 82 of file SeedingLayerSetsBuilder.h.

Referenced by hits(), SeedingLayerSetsBuilder(), and updateEventSetup().

edm::ESWatcher<TransientRecHitRecord> SeedingLayerSetsBuilder::trhWatcher_

private

Definition at line 57 of file SeedingLayerSetsBuilder.h.

Referenced by updateEventSetup().