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

#include <TSGForOIFromL2.h>

Inheritance diagram for TSGForOIFromL2:

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

	TSGForOIFromL2 (const edm::ParameterSet &iConfig)

	~TSGForOIFromL2 () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

EDProducer &	operator= (const EDProducer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

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, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

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

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

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
	Calculate the dynamic error SF by analysing the L2. More...

void	makeSeedsFromHits (const GeometricSearchDet &layer, const TrajectoryStateOnSurface &tsos, const Propagator &propagatorAlong, const edm::ESHandle< Chi2MeasurementEstimatorBase > &estimator, const edm::Handle< MeasurementTrackerEvent > &measurementTracker, double errorSF, unsigned int &hitSeedsMade, unsigned int &numSeedsMade, unsigned int &layerCount, std::vector< TrajectorySeed > &out) const
	Find hits on a given layer (TOB or TEC) and create seeds from updated TSOS with hit. More...

void	makeSeedsWithoutHits (const GeometricSearchDet &layer, const TrajectoryStateOnSurface &tsos, const Propagator &propagatorAlong, const edm::ESHandle< Chi2MeasurementEstimatorBase > &estimator, double errorSF, unsigned int &hitlessSeedsMade, unsigned int &numSeedsMade, std::vector< TrajectorySeed > &out) const
	Create seeds without hits on a given layer (TOB or TEC) More...

double	match_Chi2 (const TrajectoryStateOnSurface &tsos1, const TrajectoryStateOnSurface &tsos2) const
	Find compatability between two TSOSs. More...

Private Attributes
const bool	adjustErrorsDynamicallyForHitless_

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

const bool	displacedReco_
	Displaced reconstruction. More...

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

const edm::ESGetToken< Chi2MeasurementEstimatorBase, TrackingComponentsRecord >	estimatorToken_

const double	eta1_

const double	eta2_

const double	eta3_

const double	eta4_

const double	eta5_

const double	eta6_

const double	eta7_

const double	fixedErrorRescalingForHitless_

const double	fixedErrorRescalingForHits_
	Rescale L2 parameter uncertainties (fixed error vs pT, eta) More...

const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	geometryToken_

const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magfieldToken_

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

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

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

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

const edm::EDGetTokenT< MeasurementTrackerEvent >	measurementTrackerTag_

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

const unsigned int	numL2ValidHitsCutAllEndcap_

const unsigned int	numL2ValidHitsCutAllEta_
	L2 valid hit cuts to decide seed creation by both states. More...

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

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

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

const edm::ESGetToken< Propagator, TrackingComponentsRecord >	propagatorToken_

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 double	SF6_

const double	SFHd_

const double	SFHld_

const edm::ESGetToken< Propagator, TrackingComponentsRecord >	sHPOppositeToken_

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

const std::string	theCategory_

const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	tmpTkGeometryToken_

const double	tsosDiff1_
	Distance of L2 TSOSs before and after updated with vertex. More...

const double	tsosDiff2_

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

const bool	useHitLessSeeds_

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

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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)

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

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

Author: Benjamin Radburn-Smith, Santiago Folgueras, Bibhuprasad Mahakud, Jan Frederik Schulte (Purdue University, West Lafayette, USA); Benjamin Radburn-Smith, Santiago Folgueras, Bibhuprasad Mahakud, Jan Frederik Schulte (Purdue University, West Lafayette)

Definition at line 34 of file TSGForOIFromL2.h.

Constructor & Destructor Documentation

◆ TSGForOIFromL2()

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

explicit

Definition at line 14 of file TSGForOIFromL2.cc.

     : src_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("src"))),
       maxSeeds_(iConfig.getParameter<uint32_t>("maxSeeds")),
       maxHitlessSeeds_(iConfig.getParameter<uint32_t>("maxHitlessSeeds")),
       maxHitSeeds_(iConfig.getParameter<uint32_t>("maxHitSeeds")),
       numOfLayersToTry_(iConfig.getParameter<int32_t>("layersToTry")),
       numOfHitsToTry_(iConfig.getParameter<int32_t>("hitsToTry")),
       numL2ValidHitsCutAllEta_(iConfig.getParameter<uint32_t>("numL2ValidHitsCutAllEta")),
       numL2ValidHitsCutAllEndcap_(iConfig.getParameter<uint32_t>("numL2ValidHitsCutAllEndcap")),
       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")),
       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")),
       eta3_(iConfig.getParameter<double>("eta3")),
       eta4_(iConfig.getParameter<double>("eta4")),
       eta5_(iConfig.getParameter<double>("eta5")),
       eta6_(iConfig.getParameter<double>("eta6")),
       eta7_(iConfig.getParameter<double>("eta7")),
       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")),
       SF6_(iConfig.getParameter<double>("SF6")),
       SFHld_(iConfig.getParameter<double>("SFHld")),
       SFHd_(iConfig.getParameter<double>("SFHd")),
       tsosDiff1_(iConfig.getParameter<double>("tsosDiff1")),
       tsosDiff2_(iConfig.getParameter<double>("tsosDiff2")),
       displacedReco_(iConfig.getParameter<bool>("displacedReco")),
       propagatorName_(iConfig.getParameter<std::string>("propagatorName")),
       theCategory_(std::string("Muon|RecoMuon|TSGForOIFromL2")),
       estimatorToken_(esConsumes(edm::ESInputTag("", estimatorName_))),
       magfieldToken_(esConsumes()),
       propagatorToken_(esConsumes(edm::ESInputTag("", propagatorName_))),
       tmpTkGeometryToken_(esConsumes()),
       geometryToken_(esConsumes()),
       sHPOppositeToken_(esConsumes(edm::ESInputTag("", "hltESPSteppingHelixPropagatorOpposite"))) {
   produces<std::vector<TrajectorySeed> >();
 }

◆ ~TSGForOIFromL2()

TSGForOIFromL2::~TSGForOIFromL2 ( )

override

Definition at line 66 of file TSGForOIFromL2.cc.

66 {}

Member Function Documentation

◆ calculateSFFromL2()

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

private

Calculate the dynamic error SF by analysing the L2.

Definition at line 531 of file TSGForOIFromL2.cc.

References funct::abs(), eta1_, eta2_, eta3_, eta4_, eta5_, eta6_, LogTrace, pT1_, pT2_, pT3_, SF1_, SF2_, SF3_, SF4_, SF5_, SF6_, theCategory_, and HLT_2022v15_cff::track.

Referenced by produce().

                                                                        {
   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 different eta ranges depending in pT
   double abseta = std::abs(track->eta());
   if (track->pt() <= pT1_)
     theSF = SF1_;
   else if (track->pt() > pT1_ && track->pt() <= pT2_) {
     if (abseta <= eta3_)
       theSF = SF3_;
     else if (abseta > eta3_ && abseta <= eta6_)
       theSF = SF2_;
     else if (abseta > eta6_)
       theSF = SF3_;
   } else if (track->pt() > pT2_ && track->pt() <= pT3_) {
     if (abseta <= eta1_)
       theSF = SF6_;
     else if (abseta > eta1_ && abseta <= eta2_)
       theSF = SF4_;
     else if (abseta > eta2_ && abseta <= eta3_)
       theSF = SF6_;
     else if (abseta > eta3_ && abseta <= eta4_)
       theSF = SF1_;
     else if (abseta > eta4_ && abseta <= eta5_)
       theSF = SF1_;
     else if (abseta > eta5_)
       theSF = SF5_;
   } else if (track->pt() > pT3_) {
     if (abseta <= eta3_)
       theSF = SF5_;
     else if (abseta > eta3_ && abseta <= eta4_)
       theSF = SF4_;
     else if (abseta > eta4_ && abseta <= eta5_)
       theSF = SF4_;
     else if (abseta > eta5_)
       theSF = SF5_;
   }
 
   LogTrace(theCategory_) << "TSGForOIFromL2::calculateSFFromL2: SF has been calculated as: " << theSF;
 
   return theSF;
 }

◆ fillDescriptions()

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

static

Definition at line 600 of file TSGForOIFromL2.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v15_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("src", edm::InputTag("hltL2Muons", "UpdatedAtVtx"));
   desc.add<int>("layersToTry", 2);
   desc.add<double>("fixedErrorRescaleFactorForHitless", 2.0);
   desc.add<int>("hitsToTry", 1);
   desc.add<bool>("adjustErrorsDynamicallyForHits", false);
   desc.add<bool>("adjustErrorsDynamicallyForHitless", true);
   desc.add<edm::InputTag>("MeasurementTrackerEvent", edm::InputTag("hltSiStripClusters"));
   desc.add<bool>("UseHitLessSeeds", true);
   desc.add<std::string>("estimator", "hltESPChi2MeasurementEstimator100");
   desc.add<double>("maxEtaForTOB", 1.8);
   desc.add<double>("minEtaForTEC", 0.7);
   desc.addUntracked<bool>("debug", false);
   desc.add<double>("fixedErrorRescaleFactorForHits", 1.0);
   desc.add<unsigned int>("maxSeeds", 20);
   desc.add<unsigned int>("maxHitlessSeeds", 5);
   desc.add<unsigned int>("maxHitSeeds", 1);
   desc.add<unsigned int>("numL2ValidHitsCutAllEta", 20);
   desc.add<unsigned int>("numL2ValidHitsCutAllEndcap", 30);
   desc.add<double>("pT1", 13.0);
   desc.add<double>("pT2", 30.0);
   desc.add<double>("pT3", 70.0);
   desc.add<double>("eta1", 0.2);
   desc.add<double>("eta2", 0.3);
   desc.add<double>("eta3", 1.0);
   desc.add<double>("eta4", 1.2);
   desc.add<double>("eta5", 1.6);
   desc.add<double>("eta6", 1.4);
   desc.add<double>("eta7", 2.1);
   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>("SF6", 2.0);
   desc.add<double>("SFHld", 2.0)->setComment("Scale Factor used to rescale the TSOS error of the hitless seeds");
   desc.add<double>("SFHd", 4.0)->setComment("Scale Factor used to rescale the TSOS error of the hit based seeds");
   desc.add<double>("tsosDiff1", 0.2);
   desc.add<double>("tsosDiff2", 0.02);
   desc.add<bool>("displacedReco", false)->setComment("Flag to turn on the displaced seeding");
   desc.add<std::string>("propagatorName", "PropagatorWithMaterialParabolicMf");
   descriptions.add("TSGForOIFromL2", desc);
 }

◆ makeSeedsFromHits()

void TSGForOIFromL2::makeSeedsFromHits	(	const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	tsos,
		const Propagator &	propagatorAlong,
		const edm::ESHandle< Chi2MeasurementEstimatorBase > &	estimator,
		const edm::Handle< MeasurementTrackerEvent > &	measurementTracker,
		double	errorSF,
		unsigned int &	hitSeedsMade,
		unsigned int &	numSeedsMade,
		unsigned int &	layerCount,
		std::vector< TrajectorySeed > &	out
	)		const

private

Find hits on a given layer (TOB or TEC) and create seeds from updated TSOS with hit.

Definition at line 454 of file TSGForOIFromL2.cc.

References MeasurementDetWithData::fastMeasurements(), newFWLiteAna::found, MeasurementDetWithData::isNull(), TrajectoryStateOnSurface::isValid(), phase1PixelTopology::layer, LogTrace, maxHitSeeds_, HLTSiStripMonitoring_cff::measurementTracker, eostools::move(), numOfHitsToTry_, numOfLayersToTry_, oppositeToMomentum, MillePedeFileConverter_cfg::out, trajectoryStateTransform::persistentState(), L1TMuonDQMOffline_cfi::propagatorAlong, edm::OwnVector< T, P >::push_back(), TrajectoryStateOnSurface::rescaleError(), fileCollector::seed, edm::OwnVector< T, P >::size(), jetsAK4_CHS_cff::sort, and updator_.

Referenced by produce().

                                                                              {
   if (layerCount > numOfLayersToTry_)
     return;
 
   // Error Rescaling
   TrajectoryStateOnSurface onLayer(tsos);
   onLayer.rescaleError(errorSF);
 
   std::vector<GeometricSearchDet::DetWithState> dets;
   layer.compatibleDetsV(onLayer, propagatorAlong, *estimator, dets);
 
   // Find Measurements on each DetWithState
   LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: Find measurements on each detWithState  "
                              << dets.size() << std::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, *estimator);  // 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("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: Update TSOS using TMs after sorting, then create "
                                 "Trajectory Seed, number of TM = "
                              << meas.size() << std::endl;
   std::sort(meas.begin(), meas.end(), TrajMeasLessEstim());
 
   unsigned int found = 0;
   for (std::vector<TrajectoryMeasurement>::const_iterator it = meas.begin(); it != meas.end(); ++it) {
     TrajectoryStateOnSurface updatedTSOS = updator_->update(it->forwardPredictedState(), *it->recHit());
     LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: TSOS for TM " << found << std::endl;
     if (not updatedTSOS.isValid())
       continue;
 
     edm::OwnVector<TrackingRecHit> seedHits;
     seedHits.push_back(*it->recHit()->hit());
     PTrajectoryStateOnDet const& pstate =
         trajectoryStateTransform::persistentState(updatedTSOS, it->recHit()->geographicalId().rawId());
     LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: Number of seedHits: " << seedHits.size()
                                << std::endl;
     TrajectorySeed seed(pstate, std::move(seedHits), oppositeToMomentum);
     out.push_back(seed);
     found++;
     numSeedsMade++;
     hitSeedsMade++;
     if (found == numOfHitsToTry_)
       break;
     if (hitSeedsMade > maxHitSeeds_)
       return;
   }
 
   if (found)
     layerCount++;
 }

◆ makeSeedsWithoutHits()

void TSGForOIFromL2::makeSeedsWithoutHits	(	const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	tsos,
		const Propagator &	propagatorAlong,
		const edm::ESHandle< Chi2MeasurementEstimatorBase > &	estimator,
		double	errorSF,
		unsigned int &	hitlessSeedsMade,
		unsigned int &	numSeedsMade,
		std::vector< TrajectorySeed > &	out
	)		const

private

Create seeds without hits on a given layer (TOB or TEC)

Definition at line 420 of file TSGForOIFromL2.cc.

References phase1PixelTopology::layer, LogTrace, oppositeToMomentum, MillePedeFileConverter_cfg::out, trajectoryStateTransform::persistentState(), L1TMuonDQMOffline_cfi::propagatorAlong, and theCategory_.

Referenced by produce().

                                                                                 {
   // create hitless seeds
   LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsWithoutHits: Start hitless" << std::endl;
   std::vector<GeometricSearchDet::DetWithState> dets;
   layer.compatibleDetsV(tsos, propagatorAlong, *estimator, dets);
   if (!dets.empty()) {
     auto const& detOnLayer = dets.front().first;
     auto const& tsosOnLayer = dets.front().second;
     LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsWithoutHits: tsosOnLayer " << tsosOnLayer << std::endl;
     if (!tsosOnLayer.isValid()) {
       edm::LogInfo(theCategory_) << "ERROR!: Hitless TSOS is not valid!";
     } else {
       dets.front().second.rescaleError(errorSF);
       PTrajectoryStateOnDet const& ptsod =
           trajectoryStateTransform::persistentState(tsosOnLayer, detOnLayer->geographicalId().rawId());
       TrajectorySeed::RecHitContainer rHC;
       out.push_back(TrajectorySeed(ptsod, rHC, oppositeToMomentum));
       LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsWithoutHits: TSOS (Hitless) done " << std::endl;
       hitlessSeedsMade++;
       numSeedsMade++;
     }
   }
 }

◆ match_Chi2()

double TSGForOIFromL2::match_Chi2	(	const TrajectoryStateOnSurface &	tsos1,
		const TrajectoryStateOnSurface &	tsos2
	)		const

private

Find compatability between two TSOSs.

Definition at line 578 of file TSGForOIFromL2.cc.

References TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localParameters(), visualization-live-secondInstance_cfg::m, LocalTrajectoryError::matrix(), findQualityFiles::v, and LocalTrajectoryParameters::vector().

                                                                                                                     {
   if (!tsos1.isValid() || !tsos2.isValid())
     return -1.;
 
   AlgebraicVector5 v(tsos1.localParameters().vector() - tsos2.localParameters().vector());
   AlgebraicSymMatrix55 m(tsos1.localError().matrix() + tsos2.localError().matrix());
 
   bool ierr = !m.Invert();
 
   if (ierr) {
     edm::LogInfo("TSGForOIFromL2") << "Error inverting covariance matrix";
     return -1;
   }
 
   double est = ROOT::Math::Similarity(v, m);
 
   return est;
 }

◆ produce()

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

overridevirtual

Implements edm::global::EDProducerBase.

Definition at line 71 of file TSGForOIFromL2.cc.

References funct::abs(), adjustErrorsDynamicallyForHitless_, adjustErrorsDynamicallyForHits_, alongMomentum, Plane::build(), calculateSFFromL2(), displacedReco_, estimatorToken_, eta1_, eta7_, fixedErrorRescalingForHitless_, fixedErrorRescalingForHits_, MeasurementTrackerEvent::geometricSearchTracker(), geometryToken_, edm::EventSetup::getHandle(), iEvent, trajectoryStateTransform::initialFreeState(), trajectoryStateTransform::innerStateOnSurface(), TrackerGeometry::isThere(), TrajectoryStateOnSurface::isValid(), LogTrace, magfieldToken_, makeSeedsFromHits(), makeSeedsWithoutHits(), maxEtaForTOB_, maxHitlessSeeds_, maxHitSeeds_, maxSeeds_, measurementTrackerTag_, minEtaForTEC_, eostools::move(), GeometricSearchTracker::negTecLayers(), GeometricSearchTracker::negTidLayers(), numL2ValidHitsCutAllEndcap_, numL2ValidHitsCutAllEta_, oppositeToMomentum, MillePedeFileConverter_cfg::out, GeomDetEnumerators::P2OTEC, FreeTrajectoryState::position(), GeometricSearchTracker::posTecLayers(), GeometricSearchTracker::posTidLayers(), edm::ESHandle< T >::product(), L1TMuonDQMOffline_cfi::propagatorAlong, L1TMuonDQMOffline_cfi::propagatorOpposite, propagatorToken_, mps_fire::result, SetPropagationDirection(), SFHd_, SFHld_, sHPOppositeToken_, src_, theCategory_, tmpTkGeometryToken_, GeometricSearchTracker::tobLayers(), and useHitLessSeeds_.

                                                                                                  {
   // Initialize variables
   unsigned int numSeedsMade = 0;
   unsigned int layerCount = 0;
   unsigned int hitlessSeedsMadeIP = 0;
   unsigned int hitlessSeedsMadeMuS = 0;
   unsigned int hitSeedsMade = 0;
   unsigned int hitSeedsMadeMuS = 0;
 
   // Surface used to make a TSOS at the PCA to the beamline
   Plane::PlanePointer dummyPlane = Plane::build(Plane::PositionType(), Plane::RotationType());
 
   // Read ESHandles
   edm::Handle<MeasurementTrackerEvent> measurementTrackerH;
   const edm::ESHandle<Chi2MeasurementEstimatorBase> estimatorH = iSetup.getHandle(estimatorToken_);
   const edm::ESHandle<MagneticField> magfieldH = iSetup.getHandle(magfieldToken_);
   const edm::ESHandle<Propagator> propagatorAlongH = iSetup.getHandle(propagatorToken_);
   const edm::ESHandle<Propagator>& propagatorOppositeH = propagatorAlongH;
   const edm::ESHandle<TrackerGeometry> tmpTkGeometryH = iSetup.getHandle(tmpTkGeometryToken_);
   const edm::ESHandle<GlobalTrackingGeometry> geometryH = iSetup.getHandle(geometryToken_);
 
   iEvent.getByToken(measurementTrackerTag_, measurementTrackerH);
 
   // Read L2 track collection
   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
   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();
 
   // Get suitable propagators
   std::unique_ptr<Propagator> propagatorAlong = SetPropagationDirection(*propagatorAlongH, alongMomentum);
   std::unique_ptr<Propagator> propagatorOpposite = SetPropagationDirection(*propagatorOppositeH, oppositeToMomentum);
 
   // Stepping Helix Propagator for propogation from muon system to tracker
   const edm::ESHandle<Propagator> SHPOpposite = iSetup.getHandle(sHPOppositeToken_);
 
   // Loop over the L2's and make seeds for all of them
   LogTrace(theCategory_) << "TSGForOIFromL2::produce: Number of L2's: " << l2TrackCol->size();
   for (unsigned int l2TrackColIndex(0); l2TrackColIndex != l2TrackCol->size(); ++l2TrackColIndex) {
     const reco::TrackRef l2(l2TrackCol, l2TrackColIndex);
 
     // Container of Seeds
     std::vector<TrajectorySeed> out;
     LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: L2 muon pT, eta, phi --> " << l2->pt() << " , " << l2->eta()
                                << " , " << l2->phi() << std::endl;
 
     FreeTrajectoryState fts = trajectoryStateTransform::initialFreeState(*l2, magfieldH.product());
 
     dummyPlane->move(fts.position() - dummyPlane->position());
     TrajectoryStateOnSurface tsosAtIP = TrajectoryStateOnSurface(fts, *dummyPlane);
     LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::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("TSGForOIFromL2") << "TSGForOIFromL2::produce: Created TSOSatMuonSystem: " << tsosAtMuonSystem
                                << std::endl;
 
     LogTrace("TSGForOIFromL2")
         << "TSGForOIFromL2::produce: Check the error of the L2 parameter and use hit seeds if big errors" << std::endl;
 
     StateOnTrackerBound fromInside(propagatorAlong.get());
     TrajectoryStateOnSurface outerTkStateInside = fromInside(fts);
 
     StateOnTrackerBound fromOutside(&*SHPOpposite);
     TrajectoryStateOnSurface outerTkStateOutside = fromOutside(tsosAtMuonSystem);
 
     // Check if the two positions (using updated and not-updated TSOS) agree withing certain extent.
     // If both TSOSs agree, use only the one at vertex, as it uses more information. If they do not agree, search for seeds based on both.
     double L2muonEta = l2->eta();
     double absL2muonEta = std::abs(L2muonEta);
     bool useBoth = false;
     if (outerTkStateInside.isValid() && outerTkStateOutside.isValid()) {
       //following commented out variables dist1 (5 par compatibility of tsos at outertracker surface)
       //dist2 (angle between two tsos) could further be explored in combination of L2 valid hits for seeding. So kept for
       //future developers
       //auto dist1 = match_Chi2(outerTkStateInside,outerTkStateOutside);//for future developers
       //auto dist2 = deltaR(outerTkStateInside.globalMomentum(),outerTkStateOutside.globalMomentum());//for future developers
       //if ((dist1 > tsosDiff1_ || dist2 > tsosDiff2_) && l2->numberOfValidHits() < 20) useBoth = true;//for future developers
       if (l2->numberOfValidHits() < numL2ValidHitsCutAllEta_)
         useBoth = true;
       if (l2->numberOfValidHits() < numL2ValidHitsCutAllEndcap_ && absL2muonEta > eta7_)
         useBoth = true;
       if (absL2muonEta > eta1_ && absL2muonEta < eta1_)
         useBoth = true;
     }
 
     numSeedsMade = 0;
     hitlessSeedsMadeIP = 0;
     hitlessSeedsMadeMuS = 0;
     hitSeedsMade = 0;
     hitSeedsMadeMuS = 0;
 
     // calculate scale factors
     double errorSFHits = (adjustErrorsDynamicallyForHits_ ? calculateSFFromL2(l2) : fixedErrorRescalingForHits_);
     double errorSFHitless =
         (adjustErrorsDynamicallyForHitless_ ? calculateSFFromL2(l2) : fixedErrorRescalingForHitless_);
 
     // BARREL
     if (absL2muonEta < maxEtaForTOB_) {
       layerCount = 0;
       for (auto it = tob.rbegin(); it != tob.rend(); ++it) {
         LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: looping in TOB layer " << layerCount << std::endl;
         if (useHitLessSeeds_ && hitlessSeedsMadeIP < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
           makeSeedsWithoutHits(**it,
                                tsosAtIP,
                                *(propagatorAlong.get()),
                                estimatorH,
                                errorSFHitless,
                                hitlessSeedsMadeIP,
                                numSeedsMade,
                                out);
 
         // Do not create hitbased seeds in barrel region
         if (absL2muonEta > 1.0 && hitSeedsMade < maxHitSeeds_ && numSeedsMade < maxSeeds_)
           makeSeedsFromHits(**it,
                             tsosAtIP,
                             *(propagatorAlong.get()),
                             estimatorH,
                             measurementTrackerH,
                             errorSFHits,
                             hitSeedsMade,
                             numSeedsMade,
                             layerCount,
                             out);
 
         if (useBoth && !displacedReco_) {
           if (useHitLessSeeds_ && hitlessSeedsMadeMuS < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
             makeSeedsWithoutHits(**it,
                                  outerTkStateOutside,
                                  *(propagatorOpposite.get()),
                                  estimatorH,
                                  errorSFHitless,
                                  hitlessSeedsMadeMuS,
                                  numSeedsMade,
                                  out);
         }
       }
       LogTrace("TSGForOIFromL2") << "TSGForOIFromL2:::produce: NumSeedsMade = " << numSeedsMade
                                  << " , layerCount = " << layerCount << std::endl;
     }
 
     // Reset number of seeds if in overlap region
     if (absL2muonEta > minEtaForTEC_ && absL2muonEta < maxEtaForTOB_ && !displacedReco_) {
       numSeedsMade = 0;
       hitlessSeedsMadeIP = 0;
       hitlessSeedsMadeMuS = 0;
       hitSeedsMade = 0;
     }
 
     // ENDCAP+
     if (L2muonEta > minEtaForTEC_) {
       layerCount = 0;
       for (auto it = tecPositive.rbegin(); it != tecPositive.rend(); ++it) {
         LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: looping in TEC+ layer " << layerCount << std::endl;
         if (useHitLessSeeds_ && hitlessSeedsMadeIP < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
           makeSeedsWithoutHits(**it,
                                tsosAtIP,
                                *(propagatorAlong.get()),
                                estimatorH,
                                errorSFHitless,
                                hitlessSeedsMadeIP,
                                numSeedsMade,
                                out);
 
         if (absL2muonEta > 1.0 && hitSeedsMade < maxHitSeeds_ && numSeedsMade < maxSeeds_)
           makeSeedsFromHits(**it,
                             tsosAtIP,
                             *(propagatorAlong.get()),
                             estimatorH,
                             measurementTrackerH,
                             errorSFHits,
                             hitSeedsMade,
                             numSeedsMade,
                             layerCount,
                             out);
 
         if (useBoth && !displacedReco_) {
           if (useHitLessSeeds_ && hitlessSeedsMadeMuS < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
             makeSeedsWithoutHits(**it,
                                  outerTkStateOutside,
                                  *(propagatorOpposite.get()),
                                  estimatorH,
                                  errorSFHitless,
                                  hitlessSeedsMadeMuS,
                                  numSeedsMade,
                                  out);
         }
       }
       LogTrace("TSGForOIFromL2") << "TSGForOIFromL2:::produce: NumSeedsMade = " << numSeedsMade
                                  << " , layerCount = " << layerCount << std::endl;
     }
 
     // ENDCAP-
     if (L2muonEta < -minEtaForTEC_) {
       layerCount = 0;
       for (auto it = tecNegative.rbegin(); it != tecNegative.rend(); ++it) {
         LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: looping in TEC- layer " << layerCount << std::endl;
         if (useHitLessSeeds_ && hitlessSeedsMadeIP < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
           makeSeedsWithoutHits(**it,
                                tsosAtIP,
                                *(propagatorAlong.get()),
                                estimatorH,
                                errorSFHitless,
                                hitlessSeedsMadeIP,
                                numSeedsMade,
                                out);
 
         if (absL2muonEta > 1.0 && hitSeedsMade < maxHitSeeds_ && numSeedsMade < maxSeeds_)
           makeSeedsFromHits(**it,
                             tsosAtIP,
                             *(propagatorAlong.get()),
                             estimatorH,
                             measurementTrackerH,
                             errorSFHits,
                             hitSeedsMade,
                             numSeedsMade,
                             layerCount,
                             out);
 
         if (useBoth && !displacedReco_) {
           if (useHitLessSeeds_ && hitlessSeedsMadeMuS < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
             makeSeedsWithoutHits(**it,
                                  outerTkStateOutside,
                                  *(propagatorOpposite.get()),
                                  estimatorH,
                                  errorSFHitless,
                                  hitlessSeedsMadeMuS,
                                  numSeedsMade,
                                  out);
         }
       }
       LogTrace("TSGForOIFromL2") << "TSGForOIFromL2:::produce: NumSeedsMade = " << numSeedsMade
                                  << " , layerCount = " << layerCount << std::endl;
     }
 
     // Displaced Reconstruction
     if (displacedReco_ && outerTkStateOutside.isValid()) {
       layerCount = 0;
       for (auto it = tob.rbegin(); it != tob.rend(); ++it) {
         LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: looping in TOB layer " << layerCount;
         if (useHitLessSeeds_ && hitlessSeedsMadeMuS < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
           makeSeedsWithoutHits(**it,
                                outerTkStateOutside,
                                *(propagatorOpposite.get()),
                                estimatorH,
                                errorSFHitless * SFHld_,
                                hitlessSeedsMadeMuS,
                                numSeedsMade,
                                out);
         if (hitSeedsMadeMuS < maxHitSeeds_ && numSeedsMade < maxSeeds_)
           makeSeedsFromHits(**it,
                             outerTkStateOutside,
                             *(propagatorOpposite.get()),
                             estimatorH,
                             measurementTrackerH,
                             errorSFHits * SFHd_,
                             hitSeedsMadeMuS,
                             numSeedsMade,
                             layerCount,
                             out);
       }
       LogTrace("TSGForOIFromL2") << "TSGForOIFromL2:::produce: NumSeedsMade = " << numSeedsMade
                                  << " , layerCount = " << layerCount;
       if (L2muonEta >= 0.0) {
         layerCount = 0;
         for (auto it = tecPositive.rbegin(); it != tecPositive.rend(); ++it) {
           LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: looping in TEC+ layer " << layerCount << std::endl;
           if (useHitLessSeeds_ && hitlessSeedsMadeMuS < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
             makeSeedsWithoutHits(**it,
                                  outerTkStateOutside,
                                  *(propagatorOpposite.get()),
                                  estimatorH,
                                  errorSFHitless * SFHld_,
                                  hitlessSeedsMadeMuS,
                                  numSeedsMade,
                                  out);
           if (hitSeedsMadeMuS < maxHitSeeds_ && numSeedsMade < maxSeeds_)
             makeSeedsFromHits(**it,
                               outerTkStateOutside,
                               *(propagatorOpposite.get()),
                               estimatorH,
                               measurementTrackerH,
                               errorSFHits * SFHd_,
                               hitSeedsMadeMuS,
                               numSeedsMade,
                               layerCount,
                               out);
         }
         LogTrace("TSGForOIFromL2") << "TSGForOIFromL2:::produce: NumSeedsMade = " << numSeedsMade
                                    << " , layerCount = " << layerCount;
       }
 
       else {
         layerCount = 0;
         for (auto it = tecNegative.rbegin(); it != tecNegative.rend(); ++it) {
           LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: looping in TEC- layer " << layerCount;
           if (useHitLessSeeds_ && hitlessSeedsMadeMuS < maxHitlessSeeds_ && numSeedsMade < maxSeeds_)
             makeSeedsWithoutHits(**it,
                                  outerTkStateOutside,
                                  *(propagatorOpposite.get()),
                                  estimatorH,
                                  errorSFHitless * SFHld_,
                                  hitlessSeedsMadeMuS,
                                  numSeedsMade,
                                  out);
           if (hitSeedsMadeMuS < maxHitSeeds_ && numSeedsMade < maxSeeds_)
             makeSeedsFromHits(**it,
                               outerTkStateOutside,
                               *(propagatorOpposite.get()),
                               estimatorH,
                               measurementTrackerH,
                               errorSFHits * SFHd_,
                               hitSeedsMadeMuS,
                               numSeedsMade,
                               layerCount,
                               out);
         }
         LogTrace("TSGForOIFromL2") << "TSGForOIFromL2:::produce: NumSeedsMade = " << numSeedsMade
                                    << " , layerCount = " << layerCount;
       }
     }
 
     for (std::vector<TrajectorySeed>::iterator it = out.begin(); it != out.end(); ++it) {
       result->push_back(*it);
     }
 
   }  // L2Collection
 
   edm::LogInfo(theCategory_) << "TSGForOIFromL2::produce: number of seeds made: " << result->size();
 
   iEvent.put(std::move(result));
 }

Member Data Documentation

◆ adjustErrorsDynamicallyForHitless_

const bool TSGForOIFromL2::adjustErrorsDynamicallyForHitless_

private

Definition at line 70 of file TSGForOIFromL2.h.

Referenced by produce().

◆ adjustErrorsDynamicallyForHits_

const bool TSGForOIFromL2::adjustErrorsDynamicallyForHits_

private

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

Definition at line 69 of file TSGForOIFromL2.h.

Referenced by produce().

◆ displacedReco_

const bool TSGForOIFromL2::displacedReco_

private

Displaced reconstruction.

Definition at line 101 of file TSGForOIFromL2.h.

Referenced by produce().

◆ estimatorName_

const std::string TSGForOIFromL2::estimatorName_

private

Estimator used to find dets and TrajectoryMeasurements.

Definition at line 73 of file TSGForOIFromL2.h.

◆ estimatorToken_

const edm::ESGetToken<Chi2MeasurementEstimatorBase, TrackingComponentsRecord> TSGForOIFromL2::estimatorToken_

private

Definition at line 106 of file TSGForOIFromL2.h.

Referenced by produce().

◆ eta1_

const double TSGForOIFromL2::eta1_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2(), and produce().

◆ eta2_

const double TSGForOIFromL2::eta2_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ eta3_

const double TSGForOIFromL2::eta3_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ eta4_

const double TSGForOIFromL2::eta4_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ eta5_

const double TSGForOIFromL2::eta5_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ eta6_

const double TSGForOIFromL2::eta6_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ eta7_

const double TSGForOIFromL2::eta7_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by produce().

◆ fixedErrorRescalingForHitless_

const double TSGForOIFromL2::fixedErrorRescalingForHitless_

private

Definition at line 66 of file TSGForOIFromL2.h.

Referenced by produce().

◆ fixedErrorRescalingForHits_

const double TSGForOIFromL2::fixedErrorRescalingForHits_

private

Rescale L2 parameter uncertainties (fixed error vs pT, eta)

Definition at line 65 of file TSGForOIFromL2.h.

Referenced by produce().

◆ geometryToken_

const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> TSGForOIFromL2::geometryToken_

private

Definition at line 110 of file TSGForOIFromL2.h.

Referenced by produce().

◆ magfieldToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> TSGForOIFromL2::magfieldToken_

private

Definition at line 107 of file TSGForOIFromL2.h.

Referenced by produce().

◆ maxEtaForTOB_

const double TSGForOIFromL2::maxEtaForTOB_

private

Maximum eta value to activate searching in the TOB.

Definition at line 79 of file TSGForOIFromL2.h.

Referenced by produce().

◆ maxHitlessSeeds_

const unsigned int TSGForOIFromL2::maxHitlessSeeds_

private

Maximum number of hitless seeds for each L2.

Definition at line 49 of file TSGForOIFromL2.h.

Referenced by produce().

◆ maxHitSeeds_

const unsigned int TSGForOIFromL2::maxHitSeeds_

private

Maximum number of hitbased seeds for each L2.

Definition at line 52 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits(), and produce().

◆ maxSeeds_

const unsigned int TSGForOIFromL2::maxSeeds_

private

Maximum number of seeds for each L2.

Definition at line 46 of file TSGForOIFromL2.h.

Referenced by produce().

◆ measurementTrackerTag_

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

private

Definition at line 88 of file TSGForOIFromL2.h.

Referenced by produce().

◆ minEtaForTEC_

const double TSGForOIFromL2::minEtaForTEC_

private

Minimum eta value to activate searching in the TEC.

Definition at line 76 of file TSGForOIFromL2.h.

Referenced by produce().

◆ numL2ValidHitsCutAllEndcap_

const unsigned int TSGForOIFromL2::numL2ValidHitsCutAllEndcap_

private

Definition at line 62 of file TSGForOIFromL2.h.

Referenced by produce().

◆ numL2ValidHitsCutAllEta_

const unsigned int TSGForOIFromL2::numL2ValidHitsCutAllEta_

private

L2 valid hit cuts to decide seed creation by both states.

Definition at line 61 of file TSGForOIFromL2.h.

Referenced by produce().

◆ numOfHitsToTry_

const unsigned int TSGForOIFromL2::numOfHitsToTry_

private

How many hits to try per layer.

Definition at line 58 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits().

◆ numOfLayersToTry_

const unsigned int TSGForOIFromL2::numOfLayersToTry_

private

How many layers to try.

Definition at line 55 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits().

◆ propagatorName_

const std::string TSGForOIFromL2::propagatorName_

private

Counters and flags for the implementation.

Definition at line 104 of file TSGForOIFromL2.h.

◆ propagatorToken_

const edm::ESGetToken<Propagator, TrackingComponentsRecord> TSGForOIFromL2::propagatorToken_

private

Definition at line 108 of file TSGForOIFromL2.h.

Referenced by produce().

◆ pT1_

const double TSGForOIFromL2::pT1_

private

pT, eta ranges and scale factor values

Definition at line 91 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ pT2_

const double TSGForOIFromL2::pT2_

private

Definition at line 91 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ pT3_

const double TSGForOIFromL2::pT3_

private

Definition at line 91 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ SF1_

const double TSGForOIFromL2::SF1_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ SF2_

const double TSGForOIFromL2::SF2_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ SF3_

const double TSGForOIFromL2::SF3_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ SF4_

const double TSGForOIFromL2::SF4_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ SF5_

const double TSGForOIFromL2::SF5_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ SF6_

const double TSGForOIFromL2::SF6_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

◆ SFHd_

const double TSGForOIFromL2::SFHd_

private

Definition at line 94 of file TSGForOIFromL2.h.

Referenced by produce().

◆ SFHld_

const double TSGForOIFromL2::SFHld_

private

Definition at line 94 of file TSGForOIFromL2.h.

Referenced by produce().

◆ sHPOppositeToken_

const edm::ESGetToken<Propagator, TrackingComponentsRecord> TSGForOIFromL2::sHPOppositeToken_

private

Definition at line 111 of file TSGForOIFromL2.h.

Referenced by produce().

◆ src_

const edm::EDGetTokenT<reco::TrackCollection> TSGForOIFromL2::src_

private

Labels for input collections.

Definition at line 43 of file TSGForOIFromL2.h.

Referenced by produce().

◆ theCategory_

const std::string TSGForOIFromL2::theCategory_

private

Definition at line 105 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2(), makeSeedsWithoutHits(), and produce().

◆ tmpTkGeometryToken_

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> TSGForOIFromL2::tmpTkGeometryToken_

private

Definition at line 109 of file TSGForOIFromL2.h.

Referenced by produce().

◆ tsosDiff1_

const double TSGForOIFromL2::tsosDiff1_

private

Distance of L2 TSOSs before and after updated with vertex.

Definition at line 97 of file TSGForOIFromL2.h.

◆ tsosDiff2_

const double TSGForOIFromL2::tsosDiff2_

private

Definition at line 98 of file TSGForOIFromL2.h.

◆ updator_

const std::unique_ptr<TrajectoryStateUpdator> TSGForOIFromL2::updator_

private

KFUpdator defined in constructor.

Definition at line 86 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits().

◆ useHitLessSeeds_

const bool TSGForOIFromL2::useHitLessSeeds_

private

Switch ON (True) : use additional hits for seeds depending on the L2 properties (ignores numOfMaxSeeds_) Switch OFF (False): the numOfMaxSeeds_ defines if we will use hitless (numOfMaxSeeds_==1) or hitless+hits (numOfMaxSeeds_>1)

Definition at line 83 of file TSGForOIFromL2.h.

Referenced by produce().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TSGForOIFromL2()

◆ ~TSGForOIFromL2()

Member Function Documentation

◆ calculateSFFromL2()

◆ fillDescriptions()

◆ makeSeedsFromHits()

◆ makeSeedsWithoutHits()

◆ match_Chi2()

◆ produce()

Member Data Documentation

◆ adjustErrorsDynamicallyForHitless_

◆ adjustErrorsDynamicallyForHits_

◆ displacedReco_

◆ estimatorName_

◆ estimatorToken_

◆ eta1_

◆ eta2_

◆ eta3_

◆ eta4_

◆ eta5_

◆ eta6_

◆ eta7_

◆ fixedErrorRescalingForHitless_

◆ fixedErrorRescalingForHits_

◆ geometryToken_

◆ magfieldToken_

◆ maxEtaForTOB_

◆ maxHitlessSeeds_

◆ maxHitSeeds_

◆ maxSeeds_

◆ measurementTrackerTag_

◆ minEtaForTEC_

◆ numL2ValidHitsCutAllEndcap_

◆ numL2ValidHitsCutAllEta_

◆ numOfHitsToTry_

◆ numOfLayersToTry_

◆ propagatorName_

◆ propagatorToken_

◆ pT1_

◆ pT2_

◆ pT3_

◆ SF1_

◆ SF2_

◆ SF3_

◆ SF4_

◆ SF5_

◆ SF6_

◆ SFHd_

◆ SFHld_

◆ sHPOppositeToken_

◆ src_

◆ theCategory_

◆ tmpTkGeometryToken_

◆ tsosDiff1_

◆ tsosDiff2_

◆ updator_

◆ useHitLessSeeds_