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

#include <TSGForOI.h>

Inheritance diagram for TSGForOI:

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

	TSGForOI (const edm::ParameterSet &iConfig)

	~TSGForOI () 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
	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 &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_, unsigned int &numSeedsMade, const double errorSF, const double l2Eta) const
	Function to find hits on layers and create seeds from updated TSOS. More...

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

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 std::string	propagatorName_
	Counters and flags for the implementation. 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

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

Definition at line 33 of file TSGForOI.h.

Constructor & Destructor Documentation

◆ TSGForOI()

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

explicit

Definition at line 16 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")),
       propagatorName_(iConfig.getParameter<std::string>("propagatorName")),
       theCategory(string("Muon|RecoMuon|TSGForOI")) {
   produces<std::vector<TrajectorySeed> >();
 }

◆ ~TSGForOI()

TSGForOI::~TSGForOI ( )

override

Definition at line 49 of file TSGForOI.cc.

49 {}

Member Function Documentation

◆ calculateSFFromL2()

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

private

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

Definition at line 357 of file TSGForOI.cc.

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

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

◆ fillDescriptions()

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

static

Definition at line 483 of file TSGForOI.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_2022v12_cff::InputTag, 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);
   desc.add<std::string>("propagatorName", "PropagatorWithMaterial");
   descriptions.add("TSGForOI", desc);
 }

◆ findSeedsOnLayer()

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 &	analysedL2,
		std::unique_ptr< std::vector< TrajectorySeed > > &	out
	)		const

private

Function to find seeds on a given layer.

Definition at line 284 of file TSGForOI.cc.

References adjustErrorsDynamicallyForHitless_, adjustErrorsDynamicallyForHits_, calculateSFFromL2(), fixedErrorRescalingForHitless_, fixedErrorRescalingForHits_, phase1PixelTopology::layer, LogTrace, makeSeedsFromHits(), numOfLayersToTry_, oppositeToMomentum, MillePedeFileConverter_cfg::out, trajectoryStateTransform::persistentState(), L1TMuonDQMOffline_cfi::propagatorAlong, 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_;
   else
     errorSFHits = calculateSFFromL2(l2);
   if (!adjustErrorsDynamicallyForHitless_)
     errorSFHitless = fixedErrorRescalingForHitless_;
 
   // Hitless:  TO Be discarded from here at some point.
   if (useHitLessSeeds_) {
     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;
         numSeedsMade++;
       }
     }
   }
 
   // Hits:
   if (layerCount > numOfLayersToTry_)
     return;
   LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: Start Hits" << endl;
   if (makeSeedsFromHits(tTopo,
                         layer,
                         tsosAtIP,
                         *out,
                         propagatorAlong,
                         *measurementTrackerH,
                         estimatorH,
                         numSeedsMade,
                         errorSFHits,
                         l2->eta()))
     ++layerCount;
 }

◆ makeSeedsFromHits()

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_,
		unsigned int &	numSeedsMade,
		const double	errorSF,
		const double	l2Eta
	)		const

private

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

Definition at line 388 of file TSGForOI.cc.

References MeasurementDetWithData::fastMeasurements(), newFWLiteAna::found, MeasurementDetWithData::isNull(), TrajectoryStateOnSurface::isValid(), phase1PixelTopology::layer, LogTrace, HLTSiStripMonitoring_cff::measurementTracker, eostools::move(), numOfHitsToTry_, oppositeToMomentum, MillePedeFileConverter_cfg::out, trajectoryStateTransform::persistentState(), L1TMuonDQMOffline_cfi::propagatorAlong, edm::OwnVector< T, P >::push_back(), DetId::rawId(), TrajectoryStateOnSurface::rescaleError(), fileCollector::seed, edm::OwnVector< T, P >::size(), jetUpdater_cfi::sort, 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_ && (fabs(l2Eta) > 0.8 && fabs(l2Eta) < 1.6)) {
       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());
     LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: number of seedHits: " << seedHits.size() << endl;
     TrajectorySeed seed(pstate, std::move(seedHits), oppositeToMomentum);
     out.push_back(seed);
     found++;
     numSeedsMade++;
     if (found == numOfHitsToTry_)
       break;
   }
   return found;
 }

◆ match_Chi2()

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

private

Definition at line 464 of file TSGForOI.cc.

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

Referenced by produce().

                                                                                                               {
   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("TSGForOI") << "Error inverting covariance matrix";
     return -1;
   }
 
   double est = ROOT::Math::Similarity(v, m);
 
   return est;
 }

◆ produce()

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

Implements edm::global::EDProducerBase.

Definition at line 51 of file TSGForOI.cc.

References funct::abs(), alongMomentum, Plane::build(), estimatorName_, findSeedsOnLayer(), edm::EventSetup::get(), iEvent, trajectoryStateTransform::initialFreeState(), trajectoryStateTransform::innerStateOnSurface(), TrackerGeometry::isThere(), TrajectoryStateOnSurface::isValid(), LogTrace, match_Chi2(), maxEtaForTOB_, measurementTrackerTag_, minEtaForTEC_, eostools::move(), numOfMaxSeedsParam_, oppositeToMomentum, MillePedeFileConverter_cfg::out, GeomDetEnumerators::P2OTEC, FreeTrajectoryState::position(), edm::ESHandle< T >::product(), L1TMuonDQMOffline_cfi::propagatorAlong, propagatorName_, L1TMuonDQMOffline_cfi::propagatorOpposite, mps_fire::result, SetPropagationDirection(), src_, theCategory, and tsosDiff_.

                                                                                            {
   unsigned int numOfMaxSeeds = numOfMaxSeedsParam_;
   unsigned int numSeedsMade = 0;
   bool analysedL2 = 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(propagatorName_, propagatorOppositeH);
   iSetup.get<TrackingComponentsRecord>().get(propagatorName_, 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;
 
     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;
     bool useBoth = false;
     if (outerTkStateInside.isValid() && outerTkStateOutside.isValid()) {
       dist = match_Chi2(outerTkStateInside, outerTkStateOutside);
     }
     if (dist > tsosDiff_) {
       useBoth = true;
     }
 
     numSeedsMade = 0;
     analysedL2 = false;
 
     // if both TSOSs agree, use only the one at vertex, as it uses more information. If they do not agree, search for seed based on both
 
     //      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,
                          analysedL2,
                          out);
       }
       if (useBoth) {
         numSeedsMade = 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,
                            tsosAtMuonSystem,
                            *(propagatorOpposite.get()),
                            *(propagatorOpposite.get()),
                            l2,
                            estimatorH,
                            measurementTrackerH,
                            numSeedsMade,
                            numOfMaxSeeds,
                            layerCount,
                            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,
                          analysedL2,
                          out);
       }
       if (useBoth) {
         numSeedsMade = 0;
         for (auto it = tecPositive.rbegin(); it != tecPositive.rend(); ++it) {
           LogTrace("TSGForOI") << "TSGForOI::produce: looping in TEC+ layer " << layerCount << endl;
           findSeedsOnLayer(tTopo,
                            **it,
                            tsosAtMuonSystem,
                            *(propagatorOpposite.get()),
                            *(propagatorOpposite.get()),
                            l2,
                            estimatorH,
                            measurementTrackerH,
                            numSeedsMade,
                            numOfMaxSeeds,
                            layerCount,
                            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,
                          analysedL2,
                          out);
       }
       if (useBoth) {
         numSeedsMade = 0;
         for (auto it = tecNegative.rbegin(); it != tecNegative.rend(); ++it) {
           LogTrace("TSGForOI") << "TSGForOI::produce: looping in TEC- layer " << layerCount << endl;
           findSeedsOnLayer(tTopo,
                            **it,
                            tsosAtMuonSystem,
                            *(propagatorOpposite.get()),
                            *(propagatorOpposite.get()),
                            l2,
                            estimatorH,
                            measurementTrackerH,
                            numSeedsMade,
                            numOfMaxSeeds,
                            layerCount,
                            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

◆ adjustErrorsDynamicallyForHitless_

const bool TSGForOI::adjustErrorsDynamicallyForHitless_

private

Definition at line 59 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

◆ adjustErrorsDynamicallyForHits_

const bool TSGForOI::adjustErrorsDynamicallyForHits_

private

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

Definition at line 58 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

◆ estimatorName_

const std::string TSGForOI::estimatorName_

private

Estimator used to find dets and TrajectoryMeasurements.

Definition at line 62 of file TSGForOI.h.

Referenced by produce().

◆ eta1_

const double TSGForOI::eta1_

private

Definition at line 84 of file TSGForOI.h.

Referenced by calculateSFFromL2().

◆ eta2_

const double TSGForOI::eta2_

private

Definition at line 84 of file TSGForOI.h.

Referenced by calculateSFFromL2().

◆ fixedErrorRescalingForHitless_

const double TSGForOI::fixedErrorRescalingForHitless_

private

Definition at line 55 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

◆ fixedErrorRescalingForHits_

const double TSGForOI::fixedErrorRescalingForHits_

private

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

Definition at line 54 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

◆ maxEtaForTOB_

const double TSGForOI::maxEtaForTOB_

private

Maximum eta value to activate searching in the TOB.

Definition at line 68 of file TSGForOI.h.

Referenced by produce().

◆ measurementTrackerTag_

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

private

Definition at line 80 of file TSGForOI.h.

Referenced by produce().

◆ minEtaForTEC_

const double TSGForOI::minEtaForTEC_

private

Minimum eta value to activate searching in the TEC.

Definition at line 65 of file TSGForOI.h.

Referenced by produce().

◆ numOfHitsToTry_

const unsigned int TSGForOI::numOfHitsToTry_

private

How many hits to try per layer.

Definition at line 51 of file TSGForOI.h.

Referenced by makeSeedsFromHits().

◆ numOfLayersToTry_

const unsigned int TSGForOI::numOfLayersToTry_

private

How many layers to try.

Definition at line 48 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

◆ numOfMaxSeedsParam_

const unsigned int TSGForOI::numOfMaxSeedsParam_

private

Maximum number of seeds for each L2.

Definition at line 45 of file TSGForOI.h.

Referenced by produce().

◆ propagatorName_

const std::string TSGForOI::propagatorName_

private

Counters and flags for the implementation.

Definition at line 91 of file TSGForOI.h.

Referenced by produce().

◆ pT1_

const double TSGForOI::pT1_

private

pT, eta ranges and scale factor values

Definition at line 83 of file TSGForOI.h.

Referenced by calculateSFFromL2().

◆ pT2_

const double TSGForOI::pT2_

private

Definition at line 83 of file TSGForOI.h.

Referenced by calculateSFFromL2().

◆ pT3_

const double TSGForOI::pT3_

private

Definition at line 83 of file TSGForOI.h.

Referenced by calculateSFFromL2().