Create L3MuonTrajectorySeeds from L2 Muons updated at vertex in an outside in manner. More...

#include <TSGForOI.h>

Inheritance diagram for TSGForOI:

Public Member Functions
virtual void	produce (edm::StreamID sid, edm::Event &iEvent, const edm::EventSetup &iSetup) const override

	TSGForOI (const edm::ParameterSet &iConfig)

virtual	~TSGForOI ()

Public Member Functions inherited from edm::global::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::global::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
double	calculateSFFromL2 (const reco::TrackRef track) const
	Function used to calculate the dynamic error SF by analysing the L2. More...

void	findSeedsOnLayer (const TrackerTopology *tTopo, const GeometricSearchDet &layer, const TrajectoryStateOnSurface &tsosAtIP, const Propagator &propagatorAlong, const Propagator &propagatorOpposite, const reco::TrackRef l2, edm::ESHandle< Chi2MeasurementEstimatorBase > &estimator_, edm::Handle< MeasurementTrackerEvent > &measurementTrackerH, unsigned int &numSeedsMade, unsigned int &numOfMaxSeeds, unsigned int &layerCount, bool &foundHitlessSeed, bool &analysedL2, std::unique_ptr< std::vector< TrajectorySeed > > &out) const
	Function to find seeds on a given layer. More...

int	makeSeedsFromHits (const TrackerTopology *tTopo, const GeometricSearchDet &layer, const TrajectoryStateOnSurface &tsosAtIP, std::vector< TrajectorySeed > &out, const Propagator &propagatorAlong, const MeasurementTrackerEvent &measurementTracker, edm::ESHandle< Chi2MeasurementEstimatorBase > &estimator_, const double errorSF) const
	Function to find hits on layers and create seeds from updated TSOS. More...

Private Attributes
const bool	adjustErrorsDynamicallyForHitless_

const bool	adjustErrorsDynamicallyForHits_
	Whether or not to use an automatically calculated scale-factor value. More...

const std::string	estimatorName_
	Estimator used to find dets and TrajectoryMeasurements. More...

const double	eta1_

const double	eta2_

const double	fixedErrorRescalingForHitless_

const double	fixedErrorRescalingForHits_
	How much to rescale errors from the L2 (fixed error vs pT, eta) More...

const double	maxEtaForTOB_
	Maximum eta value to activate searching in the TOB. More...

const edm::EDGetTokenT< MeasurementTrackerEvent >	measurementTrackerTag_

const double	minEtaForTEC_
	Minimum eta value to activate searching in the TEC. More...

const unsigned int	numOfHitsToTry_
	How many hits to try per layer. More...

const unsigned int	numOfLayersToTry_
	How many layers to try. More...

const unsigned int	numOfMaxSeedsParam_
	Maximum number of seeds for each L2. More...

const double	pT1_
	pT, eta ranges and scale factor values More...

const double	pT2_

const double	pT3_

const double	SF1_

const double	SF2_

const double	SF3_

const double	SF4_

const double	SF5_

const edm::EDGetTokenT< reco::TrackCollection >	src_
	Labels for input collections. More...

const std::string	theCategory
	Counters and flags for the implementation. More...

const double	tsosDiff_
	Distance of TSOSs to trigger using hits or not. More...

const std::unique_ptr< TrajectoryStateUpdator >	updator_
	KFUpdator defined in constructor. More...

const bool	useHitLessSeeds_

const bool	useStereoLayersInTEC_
	Switch ON to use Stereo layers instead of using every layer in TEC. More...

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Create L3MuonTrajectorySeeds from L2 Muons updated at vertex in an outside in manner.

Author: Benjamin Radburn-Smith, Santiago Folgueras

Definition at line 33 of file TSGForOI.h.

Constructor & Destructor Documentation

TSGForOI::TSGForOI ( const edm::ParameterSet & iConfig )

explicit

Definition at line 15 of file TSGForOI.cc.

                                                   :
   src_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("src"))),
   numOfMaxSeedsParam_(iConfig.getParameter<uint32_t>("maxSeeds")),
   numOfLayersToTry_(iConfig.getParameter<int32_t>("layersToTry")),
   numOfHitsToTry_(iConfig.getParameter<int32_t>("hitsToTry")),
   fixedErrorRescalingForHits_(iConfig.getParameter<double>("fixedErrorRescaleFactorForHits")),
   fixedErrorRescalingForHitless_(iConfig.getParameter<double>("fixedErrorRescaleFactorForHitless")),
   adjustErrorsDynamicallyForHits_(iConfig.getParameter<bool>("adjustErrorsDynamicallyForHits")),
   adjustErrorsDynamicallyForHitless_(iConfig.getParameter<bool>("adjustErrorsDynamicallyForHitless")),
   estimatorName_(iConfig.getParameter<std::string>("estimator")),
   minEtaForTEC_(iConfig.getParameter<double>("minEtaForTEC")),
   maxEtaForTOB_(iConfig.getParameter<double>("maxEtaForTOB")),
   useHitLessSeeds_(iConfig.getParameter<bool>("UseHitLessSeeds")),
   useStereoLayersInTEC_(iConfig.getParameter<bool>("UseStereoLayersInTEC")),
   updator_(new KFUpdator()),
   measurementTrackerTag_(consumes<MeasurementTrackerEvent>(iConfig.getParameter<edm::InputTag>("MeasurementTrackerEvent"))),
   pT1_(iConfig.getParameter<double>("pT1")),
   pT2_(iConfig.getParameter<double>("pT2")),
   pT3_(iConfig.getParameter<double>("pT3")),
   eta1_(iConfig.getParameter<double>("eta1")),
   eta2_(iConfig.getParameter<double>("eta2")),
   SF1_(iConfig.getParameter<double>("SF1")),
   SF2_(iConfig.getParameter<double>("SF2")),
   SF3_(iConfig.getParameter<double>("SF3")),
   SF4_(iConfig.getParameter<double>("SF4")),
   SF5_(iConfig.getParameter<double>("SF5")),
   tsosDiff_(iConfig.getParameter<double>("tsosDiff")),
   theCategory(string("Muon|RecoMuon|TSGForOI"))
 {
   produces<std::vector<TrajectorySeed> >();
 }

TSGForOI::~TSGForOI ( )

virtual

Definition at line 48 of file TSGForOI.cc.

48 {

49 }

Member Function Documentation

double TSGForOI::calculateSFFromL2 ( const reco::TrackRef track ) const

private

Function used to calculate the dynamic error SF by analysing the L2.

Definition at line 256 of file TSGForOI.cc.

References funct::abs(), eta1_, eta2_, LogTrace, pT1_, pT2_, pT3_, SF1_, SF2_, SF3_, SF4_, SF5_, and theCategory.

Referenced by findSeedsOnLayer().

                                                                 {
 
   double theSF=1.0;
   //    L2 direction vs pT blowup - as was previously done:
   //    Split into 4 pT ranges: <pT1_, pT1_<pT2_, pT2_<pT3_, <pT4_: 13,30,70
   //    Split into 2 eta ranges for the middle two pT ranges: 1.0,1.4
   double abseta = std::abs(track->eta());
   if (track->pt()<=pT1_) theSF=SF1_;
   if (track->pt()>pT1_ && track->pt()<=pT2_){
     if (abseta<=eta1_) theSF=SF3_;
     if (abseta>eta1_ && abseta<=eta2_) theSF=SF2_;
     if (abseta>eta2_) theSF=SF3_;
   }
   if (track->pt()>pT2_ && track->pt()<=pT3_){
     if (abseta<=eta1_) theSF=SF5_;
     if (abseta>eta1_ && abseta<=eta2_) theSF=SF4_;
     if (abseta>eta2_) theSF=SF5_;
   }
   if (track->pt()>pT3_) theSF=SF5_;
 
   LogTrace(theCategory) << "TSGForOI::calculateSFFromL2: SF has been calculated as: " << theSF;
   return theSF;
 }

void TSGForOI::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 345 of file TSGForOI.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), DEFINE_FWK_MODULE, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                           {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("src",edm::InputTag("hltL2Muons","UpdatedAtVtx"));
   desc.add<int>("layersToTry",1);
   desc.add<double>("fixedErrorRescaleFactorForHitless",2.0);
   desc.add<int>("hitsToTry",1);
   desc.add<bool>("adjustErrorsDynamicallyForHits",false);
   desc.add<bool>("adjustErrorsDynamicallyForHitless",false);
   desc.add<edm::InputTag>("MeasurementTrackerEvent",edm::InputTag("hltSiStripClusters"));
   desc.add<bool>("UseHitLessSeeds",true);
   desc.add<bool>("UseStereoLayersInTEC",false);
   desc.add<std::string>("estimator","hltESPChi2MeasurementEstimator100");
   desc.add<double>("maxEtaForTOB",1.2);
   desc.add<double>("minEtaForTEC",0.8);
   desc.addUntracked<bool>("debug",true);
   desc.add<double>("fixedErrorRescaleFactorForHits",2.0);
   desc.add<unsigned int>("maxSeeds",1);
   desc.add<double>("pT1",13.0);
   desc.add<double>("pT2",30.0);
   desc.add<double>("pT3",70.0);
   desc.add<double>("eta1",1.0);
   desc.add<double>("eta2",1.4);
   desc.add<double>("SF1",3.0);
   desc.add<double>("SF2",4.0);
   desc.add<double>("SF3",5.0);
   desc.add<double>("SF4",7.0);
   desc.add<double>("SF5",10.0);
   desc.add<double>("tsosDiff",0.03);
   descriptions.add("TSGForOI",desc);
 }

void TSGForOI::findSeedsOnLayer	(	const TrackerTopology *	tTopo,
		const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	tsosAtIP,
		const Propagator &	propagatorAlong,
		const Propagator &	propagatorOpposite,
		const reco::TrackRef	l2,
		edm::ESHandle< Chi2MeasurementEstimatorBase > &	estimator_,
		edm::Handle< MeasurementTrackerEvent > &	measurementTrackerH,
		unsigned int &	numSeedsMade,
		unsigned int &	numOfMaxSeeds,
		unsigned int &	layerCount,
		bool &	foundHitlessSeed,
		bool &	analysedL2,
		std::unique_ptr< std::vector< TrajectorySeed > > &	out
	)		const

private

Function to find seeds on a given layer.

Definition at line 194 of file TSGForOI.cc.

References adjustErrorsDynamicallyForHitless_, adjustErrorsDynamicallyForHits_, calculateSFFromL2(), GeometricSearchDet::compatibleDetsV(), fixedErrorRescalingForHitless_, fixedErrorRescalingForHits_, LogTrace, makeSeedsFromHits(), numOfLayersToTry_, oppositeToMomentum, MillePedeFileConverter_cfg::out, trajectoryStateTransform::persistentState(), theCategory, and useHitLessSeeds_.

Referenced by produce().

                                                                       {
   
   if (numSeedsMade>numOfMaxSeeds) return;
   LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: numSeedsMade = " << numSeedsMade << " , layerCount = " <<  layerCount << endl;
   
   double errorSFHits=1.0;
   double errorSFHitless=1.0;
   if (!adjustErrorsDynamicallyForHits_)    errorSFHits = fixedErrorRescalingForHits_;
   if (!adjustErrorsDynamicallyForHitless_) errorSFHitless = fixedErrorRescalingForHitless_;
 
   // Hitless:
   if (useHitLessSeeds_ && !foundHitlessSeed) {
     LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: Start hitless" << endl;
     std::vector< GeometricSearchDet::DetWithState > dets;
     layer.compatibleDetsV(tsosAtIP, propagatorAlong, *estimatorH, dets);
     if (!dets.empty()) {  
       auto const& detOnLayer = dets.front().first;
       auto const& tsosOnLayer = dets.front().second;
       LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: tsosOnLayer " << tsosOnLayer << endl;
       if (!tsosOnLayer.isValid()){
     edm::LogInfo(theCategory) << "ERROR!: Hitless TSOS is not valid!";
       }
       else{
     // calculate SF from L2 (only once -- if needed)
     if (!analysedL2 && adjustErrorsDynamicallyForHitless_) {
       errorSFHitless=calculateSFFromL2(l2);
       analysedL2=true;
     }
     
     dets.front().second.rescaleError(errorSFHitless);
     PTrajectoryStateOnDet const& ptsod = trajectoryStateTransform::persistentState(tsosOnLayer,detOnLayer->geographicalId().rawId());
     TrajectorySeed::recHitContainer rHC;
     out->push_back(TrajectorySeed(ptsod,rHC,oppositeToMomentum));
     LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: TSOD (Hitless) done " << endl;
     foundHitlessSeed=true;
       }
       numSeedsMade=out->size();
     }
   }
   //  numSeedsMade=out->size();
 
   // Hits:
   if (layerCount>numOfLayersToTry_) return;
   LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: Start Hits" <<endl;  
   if (makeSeedsFromHits(tTopo, layer, tsosAtIP, *out, propagatorAlong, *measurementTrackerH, estimatorH, errorSFHits))  ++layerCount; 
   numSeedsMade=out->size();
 }

int TSGForOI::makeSeedsFromHits	(	const TrackerTopology *	tTopo,
		const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	tsosAtIP,
		std::vector< TrajectorySeed > &	out,
		const Propagator &	propagatorAlong,
		const MeasurementTrackerEvent &	measurementTracker,
		edm::ESHandle< Chi2MeasurementEstimatorBase > &	estimator_,
		const double	errorSF
	)		const

private

Function to find hits on layers and create seeds from updated TSOS.

Definition at line 281 of file TSGForOI.cc.

References GeometricSearchDet::compatibleDetsV(), MeasurementDetWithData::fastMeasurements(), runEdmFileComparison::found, MeasurementDetWithData::isNull(), TrajectoryStateOnSurface::isValid(), LogTrace, eostools::move(), numOfHitsToTry_, oppositeToMomentum, trajectoryStateTransform::persistentState(), edm::OwnVector< T, P >::push_back(), DetId::rawId(), TrajectoryStateOnSurface::rescaleError(), SurveyInfoScenario_cff::seed, edm::OwnVector< T, P >::size(), DetId::subdetId(), StripSubdetector::TEC, TrackerTopology::tecIsStereo(), updator_, and useStereoLayersInTEC_.

Referenced by findSeedsOnLayer().

                                             {
 
   //        Error Rescaling:
   TrajectoryStateOnSurface onLayer(tsosAtIP);
   onLayer.rescaleError(errorSF);    
 
   std::vector< GeometricSearchDet::DetWithState > dets;
   layer.compatibleDetsV(onLayer, propagatorAlong, *estimatorH, dets);
   
   //    Find Measurements on each DetWithState:
   LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: find measurements on each detWithState  " << dets.size() << endl;
   std::vector<TrajectoryMeasurement> meas;
   for (std::vector<GeometricSearchDet::DetWithState>::iterator it=dets.begin(); it!=dets.end(); ++it) {
     MeasurementDetWithData det = measurementTracker.idToDet(it->first->geographicalId());
     if (det.isNull()) {
       continue;
     }
     if (!it->second.isValid()) continue;    //Skip if TSOS is not valid
 
     std::vector < TrajectoryMeasurement > mymeas = det.fastMeasurements(it->second, onLayer, propagatorAlong, *estimatorH); //Second TSOS is not used
     for (std::vector<TrajectoryMeasurement>::const_iterator it2 = mymeas.begin(), ed2 = mymeas.end(); it2 != ed2; ++it2) {
       if (it2->recHit()->isValid()) meas.push_back(*it2);   //Only save those which are valid
     }
   }
   
   
   //    Update TSOS using TMs after sorting, then create Trajectory Seed and put into vector:
   LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: Update TSOS using TMs after sorting, then create Trajectory Seed, number of TM = " << meas.size() << endl;
   unsigned int found = 0;
   std::sort(meas.begin(), meas.end(), TrajMeasLessEstim());
   for (std::vector<TrajectoryMeasurement>::const_iterator it=meas.begin(); it!=meas.end(); ++it) {
     TrajectoryStateOnSurface updatedTSOS = updator_->update(it->forwardPredictedState(), *it->recHit());
     LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: TSOS for TM " << found << endl;
     if (not updatedTSOS.isValid()) continue;
 
     // CHECK if is StereoLayer: 
     if (useStereoLayersInTEC_) { 
       DetId detid = ((*it).recHit()->hit())->geographicalId();
       if (detid.subdetId() == StripSubdetector::TEC) {
         if (!tTopo->tecIsStereo(detid.rawId())) break;  // try another layer
       }
     }
     
     edm::OwnVector<TrackingRecHit> seedHits;
     seedHits.push_back(*it->recHit()->hit());
     PTrajectoryStateOnDet const& pstate = trajectoryStateTransform::persistentState(updatedTSOS, it->recHit()->geographicalId().rawId());
     TrajectorySeed seed(pstate, std::move(seedHits), oppositeToMomentum);
     LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: number of seedHits: " << seedHits.size() << endl;
     out.push_back(seed);
     found++;
     if (found == numOfHitsToTry_) break;
   }
   return found;
 }

void TSGForOI::produce	(	edm::StreamID	sid,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)		const

overridevirtual

Init variables

Surface used to make a TSOS at the PCA to the beamline

Read ESHandles

Read L2 track collection

Definition at line 52 of file TSGForOI.cc.

References funct::abs(), alongMomentum, Plane::build(), estimatorName_, PV3DBase< T, PVType, FrameType >::eta(), findSeedsOnLayer(), edm::EventSetup::get(), edm::Event::getByToken(), TrajectoryStateOnSurface::globalPosition(), trajectoryStateTransform::initialFreeState(), trajectoryStateTransform::innerStateOnSurface(), TrackerGeometry::isThere(), TrajectoryStateOnSurface::isValid(), LogTrace, maxEtaForTOB_, measurementTrackerTag_, minEtaForTEC_, eostools::move(), numOfMaxSeedsParam_, oppositeToMomentum, MillePedeFileConverter_cfg::out, GeomDetEnumerators::P2OTEC, PV3DBase< T, PVType, FrameType >::phi(), FreeTrajectoryState::position(), edm::ESHandle< T >::product(), gsfElectronCkfTrackCandidateMaker_cff::propagatorAlong, gsfElectronCkfTrackCandidateMaker_cff::propagatorOpposite, edm::Event::put(), mps_fire::result, SetPropagationDirection(), mathSSE::sqrt(), src_, theCategory, tsosDiff_, and useHitLessSeeds_.

                                                                                            {
   unsigned int numOfMaxSeeds = numOfMaxSeedsParam_;
   unsigned int numSeedsMade=0;
   bool analysedL2 = false;
   bool foundHitlessSeed = false; 
   unsigned int layerCount = 0;
 
 
   Plane::PlanePointer dummyPlane = Plane::build(Plane::PositionType(), Plane::RotationType());
 
   edm::Handle<MeasurementTrackerEvent>          measurementTrackerH;
   edm::ESHandle<Chi2MeasurementEstimatorBase>   estimatorH;
   edm::ESHandle<MagneticField>                  magfieldH;
   edm::ESHandle<Propagator>                     propagatorAlongH;
   edm::ESHandle<Propagator>                     propagatorOppositeH;
   edm::ESHandle<TrackerGeometry>                tmpTkGeometryH;  
   edm::ESHandle<GlobalTrackingGeometry>         geometryH;
 
   iSetup.get<IdealMagneticFieldRecord>().get(magfieldH);
   iSetup.get<TrackingComponentsRecord>().get("PropagatorWithMaterial", propagatorOppositeH);
   iSetup.get<TrackingComponentsRecord>().get("PropagatorWithMaterial", propagatorAlongH);
   iSetup.get<GlobalTrackingGeometryRecord>().get(geometryH);
   iSetup.get<TrackerDigiGeometryRecord>().get(tmpTkGeometryH);
   iSetup.get<TrackingComponentsRecord>().get(estimatorName_,estimatorH);
   iEvent.getByToken(measurementTrackerTag_, measurementTrackerH);
 
   edm::Handle<reco::TrackCollection> l2TrackCol;
   iEvent.getByToken(src_, l2TrackCol);
 
   //    The product:
   std::unique_ptr<std::vector<TrajectorySeed> > result(new std::vector<TrajectorySeed>());
 
   //    Get vector of Detector layers once:
   std::vector<BarrelDetLayer const*> const& tob = measurementTrackerH->geometricSearchTracker()->tobLayers();
   std::vector<ForwardDetLayer const*> const& tecPositive = tmpTkGeometryH->isThere(GeomDetEnumerators::P2OTEC) ? 
                                                                 measurementTrackerH->geometricSearchTracker()->posTidLayers() : 
                                                                 measurementTrackerH->geometricSearchTracker()->posTecLayers(); 
   std::vector<ForwardDetLayer const*> const& tecNegative = tmpTkGeometryH->isThere(GeomDetEnumerators::P2OTEC) ? 
                                                                 measurementTrackerH->geometricSearchTracker()->negTidLayers() : 
                                                                 measurementTrackerH->geometricSearchTracker()->negTecLayers();
   edm::ESHandle<TrackerTopology> tTopo_handle;
   iSetup.get<TrackerTopologyRcd>().get(tTopo_handle);
   const TrackerTopology* tTopo = tTopo_handle.product();
 
   //    Get the suitable propagators:
   std::unique_ptr<Propagator> propagatorAlong = SetPropagationDirection(*propagatorAlongH,alongMomentum);
   std::unique_ptr<Propagator> propagatorOpposite = SetPropagationDirection(*propagatorOppositeH,oppositeToMomentum);
 
   edm::ESHandle<Propagator> SmartOpposite;
   edm::ESHandle<Propagator> SHPOpposite;
   iSetup.get<TrackingComponentsRecord>().get("hltESPSmartPropagatorAnyOpposite", SmartOpposite);
   iSetup.get<TrackingComponentsRecord>().get("hltESPSteppingHelixPropagatorOpposite", SHPOpposite);
 
   //    Loop over the L2's and make seeds for all of them:
   LogTrace(theCategory) << "TSGForOI::produce: Number of L2's: " << l2TrackCol->size();
   for (unsigned int l2TrackColIndex(0);l2TrackColIndex!=l2TrackCol->size();++l2TrackColIndex){
     const reco::TrackRef l2(l2TrackCol, l2TrackColIndex);
     std::unique_ptr<std::vector<TrajectorySeed> > out(new std::vector<TrajectorySeed>());
     LogTrace("TSGForOI") << "TSGForOI::produce: L2 muon pT, eta, phi --> " << l2->pt() << " , " << l2->eta() << " , " << l2->phi() << endl;
     
     FreeTrajectoryState fts = trajectoryStateTransform::initialFreeState(*l2, magfieldH.product());
     dummyPlane->move(fts.position() - dummyPlane->position());
     TrajectoryStateOnSurface tsosAtIP = TrajectoryStateOnSurface(fts, *dummyPlane);
     LogTrace("TSGForOI") << "TSGForOI::produce: Created TSOSatIP: " << tsosAtIP << std::endl;
     
     // get the TSOS on the innermost layer of the L2. 
     TrajectoryStateOnSurface tsosAtMuonSystem = trajectoryStateTransform::innerStateOnSurface(*l2, *geometryH, magfieldH.product());
     LogTrace("TSGForOI") << "TSGForOI::produce: Created TSOSatMuonSystem: " << tsosAtMuonSystem <<endl;
     
     if (useHitLessSeeds_){  // 
       LogTrace("TSGForOI") << "TSGForOI::produce: Check the error of the L2 parameter and use hit seeds if big errors" << endl;
       StateOnTrackerBound fromInside(propagatorAlong.get());
       TrajectoryStateOnSurface outerTkStateInside = fromInside(fts);
       
       StateOnTrackerBound fromOutside(&*SmartOpposite);
       TrajectoryStateOnSurface outerTkStateOutside = fromOutside(tsosAtMuonSystem);
 
       // for now only checking if the two positions (using updated and not-updated) agree withing certain extent, 
       // will probably have to design something fancier for the future. 
       auto dist=0.0;
       if (outerTkStateInside.isValid() && outerTkStateOutside.isValid()){
         float deta = outerTkStateInside.globalPosition().eta() - outerTkStateOutside.globalPosition().eta();
         float dphi = outerTkStateInside.globalPosition().phi() - outerTkStateOutside.globalPosition().phi();
     dist = sqrt(deta*deta+dphi*dphi);
       }
       if (dist>tsosDiff_){
     ++numOfMaxSeeds;    // add a hit-based seed
       }
     } 
 
     numSeedsMade=0;
     analysedL2 = false;
     foundHitlessSeed = false; 
 
     //      BARREL
     if (std::abs(l2->eta()) < maxEtaForTOB_) {
       layerCount = 0;
       for (auto it=tob.rbegin(); it!=tob.rend(); ++it) {    //This goes from outermost to innermost layer
     LogTrace("TSGForOI") << "TSGForOI::produce: looping in TOB layer " << layerCount << endl; 
     findSeedsOnLayer(tTopo, **it, tsosAtIP,  *(propagatorAlong.get()), *(propagatorOpposite.get()), l2, 
              estimatorH, measurementTrackerH, numSeedsMade, numOfMaxSeeds, layerCount, foundHitlessSeed, analysedL2, out);
       }
     }
     
     //      Reset Number of seeds if in overlap region:
     if (std::abs(l2->eta())>minEtaForTEC_ && std::abs(l2->eta())<maxEtaForTOB_){
       numSeedsMade=0;
     }
 
     //      ENDCAP+
     if (l2->eta() > minEtaForTEC_) {
       layerCount = 0;
       for (auto it=tecPositive.rbegin(); it!=tecPositive.rend(); ++it) {
     LogTrace("TSGForOI") << "TSGForOI::produce: looping in TEC+ layer " << layerCount << endl; 
     findSeedsOnLayer(tTopo, **it, tsosAtIP,  *(propagatorAlong.get()), *(propagatorOpposite.get()), l2, 
              estimatorH, measurementTrackerH, numSeedsMade, numOfMaxSeeds, layerCount, foundHitlessSeed, analysedL2, out);
       }
     }
 
     //      ENDCAP-
     if (l2->eta() < -minEtaForTEC_) {
       layerCount = 0;
       for (auto it=tecNegative.rbegin(); it!=tecNegative.rend(); ++it) {
     LogTrace("TSGForOI") << "TSGForOI::produce: looping in TEC- layer " << layerCount << endl; 
     findSeedsOnLayer(tTopo, **it, tsosAtIP,  *(propagatorAlong.get()), *(propagatorOpposite.get()), l2, 
              estimatorH, measurementTrackerH, numSeedsMade, numOfMaxSeeds, layerCount, foundHitlessSeed, analysedL2, out);
       }
     }
 
     for (std::vector<TrajectorySeed>::iterator it=out->begin(); it!=out->end(); ++it){
       result->push_back(*it);
     }
   } //L2Collection
   edm::LogInfo(theCategory) << "TSGForOI::produce: number of seeds made: " << result->size();
 
   iEvent.put(std::move(result));
 }

Member Data Documentation

const bool TSGForOI::adjustErrorsDynamicallyForHitless_

private

Definition at line 58 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const bool TSGForOI::adjustErrorsDynamicallyForHits_

private

Whether or not to use an automatically calculated scale-factor value.

Definition at line 57 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const std::string TSGForOI::estimatorName_

private

Estimator used to find dets and TrajectoryMeasurements.

Definition at line 61 of file TSGForOI.h.

Referenced by produce().

const double TSGForOI::eta1_

private

Definition at line 83 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::eta2_

private

Definition at line 83 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::fixedErrorRescalingForHitless_

private

Definition at line 54 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const double TSGForOI::fixedErrorRescalingForHits_

private

How much to rescale errors from the L2 (fixed error vs pT, eta)

Definition at line 53 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const double TSGForOI::maxEtaForTOB_

private

Maximum eta value to activate searching in the TOB.

Definition at line 67 of file TSGForOI.h.

Referenced by produce().

const edm::EDGetTokenT<MeasurementTrackerEvent> TSGForOI::measurementTrackerTag_

private

Definition at line 79 of file TSGForOI.h.

Referenced by produce().

const double TSGForOI::minEtaForTEC_

private

Minimum eta value to activate searching in the TEC.

Definition at line 64 of file TSGForOI.h.

Referenced by produce().

const unsigned int TSGForOI::numOfHitsToTry_

private

How many hits to try per layer.

Definition at line 50 of file TSGForOI.h.

Referenced by makeSeedsFromHits().

const unsigned int TSGForOI::numOfLayersToTry_

private

How many layers to try.

Definition at line 47 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const unsigned int TSGForOI::numOfMaxSeedsParam_

private

Maximum number of seeds for each L2.

Definition at line 44 of file TSGForOI.h.

Referenced by produce().

const double TSGForOI::pT1_

private

pT, eta ranges and scale factor values

Definition at line 82 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::pT2_

private

Definition at line 82 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::pT3_

private

Definition at line 82 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::SF1_

private