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)
	SeedingLayerSetsBuilder (const edm::ParameterSet &cfg, edm::ConsumesCollector &iC)
	SeedingLayerSetsBuilder (const edm::ParameterSet &cfg, edm::ConsumesCollector &iC, const edm::InputTag &fastsimHitTag)
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 31 of file SeedingLayerSetsBuilder.h.

Member Typedef Documentation

SeedingLayerId

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

Definition at line 33 of file SeedingLayerSetsBuilder.h.

Constructor & Destructor Documentation

SeedingLayerSetsBuilder() [1/4]

SeedingLayerSetsBuilder::SeedingLayerSetsBuilder ( )

default

SeedingLayerSetsBuilder() [2/4]

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

Definition at line 181 of file SeedingLayerSetsBuilder.cc.

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

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

SeedingLayerSetsBuilder() [3/4]

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

Definition at line 189 of file SeedingLayerSetsBuilder.cc.

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

References looper::cfg, Exception, spr::find(), newFWLiteAna::found, layerConfig(), phase1PixelTopology::layerName, layerNamesInSets(), SiStripPI::max, str, AlCaHLTBitMon_QueryRunRegistry::string, theLayerDets, theLayerNames, theLayers, theLayerSetIndices, theNumberOfLayersInSet, and theTTRHBuilders.

SeedingLayerSetsBuilder() [4/4]

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

Definition at line 187 of file SeedingLayerSetsBuilder.cc.

    : SeedingLayerSetsBuilder(cfg, iC) {}

~SeedingLayerSetsBuilder()

SeedingLayerSetsBuilder::~SeedingLayerSetsBuilder

(

)

Definition at line 242 of file SeedingLayerSetsBuilder.cc.

{}

Member Function Documentation

fillDescriptions()

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

static

Definition at line 244 of file SeedingLayerSetsBuilder.cc.

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

References submitPVResolutionJobs::desc, and relativeConstraints::empty.

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

hits()

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

Definition at line 364 of file SeedingLayerSetsBuilder.cc.

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

References ev, phase1PixelTopology::layer, runTheMatrix::ret, theLayerDets, theLayerNames, theLayers, theLayerSetIndices, theNumberOfLayersInSet, theTTRHBuilders, and updateEventSetup().

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

layerConfig()

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

private

Definition at line 261 of file SeedingLayerSetsBuilder.cc.

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

References looper::cfg, Skims_PA_cff::name, and mps_fire::result.

Referenced by SeedingLayerSetsBuilder().

layerNamesInSets()

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

static

Definition at line 275 of file SeedingLayerSetsBuilder.cc.

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

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

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

layers()

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

(

)

const

Definition at line 355 of file SeedingLayerSetsBuilder.cc.

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

References phase1PixelTopology::layer, numberOfLayers(), runTheMatrix::ret, and theLayers.

layerSetIndices()

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

inline

Definition at line 54 of file SeedingLayerSetsBuilder.h.

{ return theLayerSetIndices; }

References theLayerSetIndices.

makeSeedingLayerSetsHitsforFastSim()

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

Definition at line 379 of file SeedingLayerSetsBuilder.cc.

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

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

nameToEnumId()

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

static

Definition at line 32 of file SeedingLayerSetsBuilder.cc.

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

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

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

numberOfLayers()

unsigned short SeedingLayerSetsBuilder::numberOfLayers ( ) const

inline

Definition at line 45 of file SeedingLayerSetsBuilder.h.

{ return theLayers.size(); }

References theLayers.

Referenced by layers().

numberOfLayerSets()

unsigned short SeedingLayerSetsBuilder::numberOfLayerSets ( ) const

inline

Definition at line 46 of file SeedingLayerSetsBuilder.h.

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

References theLayerSetIndices, and theNumberOfLayersInSet.

seedingLayerSetsLooper()

SeedingLayerSetsLooper SeedingLayerSetsBuilder::seedingLayerSetsLooper ( ) const

inline

Definition at line 50 of file SeedingLayerSetsBuilder.h.

                                                        {
    return SeedingLayerSetsLooper(theNumberOfLayersInSet, &theLayerSetIndices);
  }

References theLayerSetIndices, and theNumberOfLayersInSet.

updateEventSetup()

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

private

Definition at line 292 of file SeedingLayerSetsBuilder.cc.

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

References edm::ESWatcher< T >::check(), Exception, geometryWatcher_, edm::EventSetup::get(), get, phase1PixelTopology::layer, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, PosEndcap, edm::ESHandle< T >::product(), GeomDetEnumerators::TEC, theLayerDets, theLayerNames, theLayers, theTTRHBuilders, GeomDetEnumerators::TIB, GeomDetEnumerators::TID, GeomDetEnumerators::TOB, PbPb_ZMuSkimMuonDPG_cff::tracker, and trhWatcher_.

Referenced by hits(), and makeSeedingLayerSetsHitsforFastSim().

Member Data Documentation

fastSimrecHitsToken_

edm::EDGetTokenT<FastTrackerRecHitCollection> SeedingLayerSetsBuilder::fastSimrecHitsToken_

private

Definition at line 70 of file SeedingLayerSetsBuilder.h.

Referenced by makeSeedingLayerSetsHitsforFastSim(), and SeedingLayerSetsBuilder().

geometryWatcher_

edm::ESWatcher<TrackerRecoGeometryRecord> SeedingLayerSetsBuilder::geometryWatcher_

private

Definition at line 68 of file SeedingLayerSetsBuilder.h.

Referenced by updateEventSetup().

theLayerDets

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

private

Definition at line 96 of file SeedingLayerSetsBuilder.h.

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

theLayerNames

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

private

Definition at line 95 of file SeedingLayerSetsBuilder.h.

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

theLayers

std::vector<LayerSpec> SeedingLayerSetsBuilder::theLayers

private

Definition at line 98 of file SeedingLayerSetsBuilder.h.

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

theLayerSetIndices

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

private

Definition at line 94 of file SeedingLayerSetsBuilder.h.

Referenced by hits(), layerSetIndices(), makeSeedingLayerSetsHitsforFastSim(), numberOfLayerSets(), SeedingLayerSetsBuilder(), and seedingLayerSetsLooper().

theNumberOfLayersInSet

unsigned short SeedingLayerSetsBuilder::theNumberOfLayersInSet

private

Definition at line 93 of file SeedingLayerSetsBuilder.h.

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

theTTRHBuilders

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

private

Definition at line 97 of file SeedingLayerSetsBuilder.h.

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

trhWatcher_

edm::ESWatcher<TransientRecHitRecord> SeedingLayerSetsBuilder::trhWatcher_

private

Definition at line 69 of file SeedingLayerSetsBuilder.h.

Referenced by updateEventSetup().