Public Member Functions
	LayerSpec (unsigned short index, const std::string &layerName, const edm::ParameterSet &cfgLayer, edm::ConsumesCollector &iC)

std::string	print (const std::vector< std::string > &names) const

	~LayerSpec ()

Public Attributes
std::shared_ptr < ctfseeding::HitExtractor >	extractor

const std::string	hitBuilder

int	idLayer

const unsigned short	nameIndex

std::string	pixelHitProducer

ctfseeding::SeedingLayer::Side	side

GeomDetEnumerators::SubDetector	subdet

bool	usePixelHitProducer

Detailed Description

Definition at line 51 of file SeedingLayerSetsBuilder.h.

Constructor & Destructor Documentation

SeedingLayerSetsBuilder::LayerSpec::LayerSpec	(	unsigned short	index,
		const std::string &	layerName,
		const edm::ParameterSet &	cfgLayer,
		edm::ConsumesCollector &	iC
	)

Definition at line 103 of file SeedingLayerSetsBuilder.cc.

References edm::ParameterSet::exists(), extractor, edm::ParameterSet::getParameter(), idLayer, GeomDetEnumerators::invalidDet, LogDebug, GeomDetEnumerators::PixelBarrel, GeomDetEnumerators::PixelEndcap, pixelHitProducer, side, subdet, and usePixelHitProducer.

                                                                                                                                                       :
   nameIndex(index),
   hitBuilder(cfgLayer.getParameter<string>("TTRHBuilder"))
 {
   usePixelHitProducer = false;
   if (cfgLayer.exists("HitProducer")) {
     pixelHitProducer = cfgLayer.getParameter<string>("HitProducer");
     usePixelHitProducer = true;
   }
 
   bool skipClusters = cfgLayer.exists("skipClusters");
   if (skipClusters) {
     LogDebug("SeedingLayerSetsBuilder")<<layerName<<" ready for skipping";
   }
   else{
     LogDebug("SeedingLayerSetsBuilder")<<layerName<<" not skipping ";
   }
 
   auto subdetData = nameToEnumId(layerName);
   subdet = std::get<0>(subdetData);
   side = std::get<1>(subdetData);
   idLayer = std::get<2>(subdetData);
   if(subdet == GeomDetEnumerators::PixelBarrel ||
      subdet == GeomDetEnumerators::PixelEndcap) {
     extractor = std::make_shared<HitExtractorPIX>(side, idLayer, pixelHitProducer, iC);
   }
   else if(subdet != GeomDetEnumerators::invalidDet) { // strip
     std::shared_ptr<HitExtractorSTRP> extr = std::make_shared<HitExtractorSTRP>(subdet, side, idLayer);
     if (cfgLayer.exists("matchedRecHits")) {
       extr->useMatchedHits(cfgLayer.getParameter<edm::InputTag>("matchedRecHits"), iC);
     }
     if (cfgLayer.exists("rphiRecHits")) {
       extr->useRPhiHits(cfgLayer.getParameter<edm::InputTag>("rphiRecHits"), iC);
     }
     if (cfgLayer.exists("stereoRecHits")) {
       extr->useStereoHits(cfgLayer.getParameter<edm::InputTag>("stereoRecHits"), iC);
     }
     if (cfgLayer.exists("useRingSlector") && cfgLayer.getParameter<bool>("useRingSlector")) {
       extr->useRingSelector(cfgLayer.getParameter<int>("minRing"),
                                  cfgLayer.getParameter<int>("maxRing"));
     }
     bool useSimpleRphiHitsCleaner = cfgLayer.exists("useSimpleRphiHitsCleaner") ? cfgLayer.getParameter<bool>("useSimpleRphiHitsCleaner") : true;
     extr->useSimpleRphiHitsCleaner(useSimpleRphiHitsCleaner);
 
     double minAbsZ = cfgLayer.exists("MinAbsZ") ? cfgLayer.getParameter<double>("MinAbsZ") : 0.;
     if(minAbsZ > 0.) {
       extr->setMinAbsZ(minAbsZ);
     }
     if(skipClusters) {
       bool useProjection = cfgLayer.exists("useProjection") ? cfgLayer.getParameter<bool>("useProjection") : false;
       if(useProjection) {
         LogDebug("SeedingLayerSetsBuilder")<<layerName<<" will project partially masked matched rechit";
       }
       else {
         extr->setNoProjection();
       }
     }
     extractor = std::move(extr);
   }
   if(extractor && skipClusters) {
     extractor->useSkipClusters(cfgLayer.getParameter<edm::InputTag>("skipClusters"), iC);
   }
 }

SeedingLayerSetsBuilder::LayerSpec::~LayerSpec ( )

Definition at line 166 of file SeedingLayerSetsBuilder.cc.

166 {}

Member Function Documentation

std::string SeedingLayerSetsBuilder::LayerSpec::print ( const std::vector< std::string > & names ) const

Definition at line 168 of file SeedingLayerSetsBuilder.cc.

References ctfseeding::HitExtractorSTRP::getMinMaxRing(), and ctfseeding::HitExtractorSTRP::useRingSelector().

 {
   std::ostringstream str;
   str << "Layer="<<names[nameIndex]<<", hitBldr: "<<hitBuilder;
 
   str << ", useRingSelector: ";
   HitExtractorSTRP *ext = nullptr;
   if((ext = dynamic_cast<HitExtractorSTRP *>(extractor.get())) &&
      ext->useRingSelector()) {
     auto minMaxRing = ext->getMinMaxRing();
     str <<"true,"<<" Rings: ("<< std::get<0>(minMaxRing) <<","<< std::get<1>(minMaxRing) <<")"; 
   } else  str<<"false";
 
   return str.str();
 }