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

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

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

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)

	~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

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

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, edm::ESHandle< Chi2MeasurementEstimatorBase > &estimator, 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, 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 std::string	estimatorName_
	Estimator used to find dets and TrajectoryMeasurements. More...

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 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 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 edm::EDGetTokenT< reco::TrackCollection >	src_
	Labels for input collections. More...

const std::string	theCategory_

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
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::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

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

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

Detailed Description

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

Author: Benjamin Radburn-Smith, Santiago Folgueras, 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 ( 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")),
   tsosDiff1_(iConfig.getParameter<double>("tsosDiff1")),
   tsosDiff2_(iConfig.getParameter<double>("tsosDiff2")),
   propagatorName_(iConfig.getParameter<std::string>("propagatorName")), 
   theCategory_(std::string("Muon|RecoMuon|TSGForOIFromL2"))
 {
   produces<std::vector<TrajectorySeed> >();
 }

TSGForOIFromL2::~TSGForOIFromL2 ( )

override

Definition at line 56 of file TSGForOIFromL2.cc.

                                 {
 
 }

Member Function Documentation

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

private

Calculate the dynamic error SF by analysing the L2.

Definition at line 355 of file TSGForOIFromL2.cc.

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

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

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

static

Definition at line 417 of file TSGForOIFromL2.cc.

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

                                                                                 {
 
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("src",edm::InputTag("hltL2Muons","UpdatedAtVtx"));
   desc.add<int>("layersToTry",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>("tsosDiff1",0.2);
   desc.add<double>("tsosDiff2",0.02);
   desc.add<std::string>("propagatorName","PropagatorWithMaterialParabolicMf");
   descriptions.add("TSGForOIFromL2",desc);
 
 }

void TSGForOIFromL2::makeSeedsFromHits	(	const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	tsos,
		const Propagator &	propagatorAlong,
		edm::ESHandle< Chi2MeasurementEstimatorBase > &	estimator,
		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 289 of file TSGForOIFromL2.cc.

References GeometricSearchDet::compatibleDetsV(), MeasurementDetWithData::fastMeasurements(), runEdmFileComparison::found, MeasurementTrackerEvent::idToDet(), MeasurementDetWithData::isNull(), TrajectoryStateOnSurface::isValid(), LogTrace, maxHitSeeds_, eostools::move(), numOfHitsToTry_, numOfLayersToTry_, oppositeToMomentum, trajectoryStateTransform::persistentState(), edm::OwnVector< T, P >::push_back(), TrajectoryStateOnSurface::rescaleError(), SurveyInfoScenario_cff::seed, edm::OwnVector< T, P >::size(), jetUpdater_cfi::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());
     TrajectorySeed seed(pstate, std::move(seedHits), oppositeToMomentum);
     LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: Number of seedHits: " << seedHits.size() << std::endl;
     out.push_back(seed);
     found++;
     numSeedsMade++;
     hitSeedsMade++;
     if (found == numOfHitsToTry_) break;
     if (hitSeedsMade > maxHitSeeds_) return;
   }
  
   if (found) layerCount++;
 
 }

void TSGForOIFromL2::makeSeedsWithoutHits	(	const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	tsos,
		const Propagator &	propagatorAlong,
		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 251 of file TSGForOIFromL2.cc.

References GeometricSearchDet::compatibleDetsV(), LogTrace, oppositeToMomentum, trajectoryStateTransform::persistentState(), edm::OwnVector< T, P >::push_back(), 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++;
    }
  }
     
 }

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

private

Find compatability between two TSOSs.

Definition at line 392 of file TSGForOIFromL2.cc.

References TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localParameters(), funct::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;
 
 }

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

override

Definition at line 63 of file TSGForOIFromL2.cc.

References funct::abs(), adjustErrorsDynamicallyForHitless_, adjustErrorsDynamicallyForHits_, alongMomentum, Plane::build(), calculateSFFromL2(), estimatorName_, eta1_, eta7_, fixedErrorRescalingForHitless_, fixedErrorRescalingForHits_, MeasurementTrackerEvent::geometricSearchTracker(), edm::EventSetup::get(), edm::Event::getByToken(), trajectoryStateTransform::initialFreeState(), trajectoryStateTransform::innerStateOnSurface(), TrackerGeometry::isThere(), TrajectoryStateOnSurface::isValid(), LogTrace, 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(), gsfElectronCkfTrackCandidateMaker_cff::propagatorAlong, propagatorName_, gsfElectronCkfTrackCandidateMaker_cff::propagatorOpposite, edm::Event::put(), mps_fire::result, SetPropagationDirection(), src_, theCategory_, 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;
 
   // 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;
   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);
 
   // 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
   edm::ESHandle<Propagator> SHPOpposite;
   iSetup.get<TrackingComponentsRecord>().get("hltESPSteppingHelixPropagatorOpposite", SHPOpposite);
 
   // 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;
 
     // 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) {
           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_) {
       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) {
           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) {
           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;
     }
 
     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

const bool TSGForOIFromL2::adjustErrorsDynamicallyForHitless_

private

Definition at line 73 of file TSGForOIFromL2.h.

Referenced by produce().

const bool TSGForOIFromL2::adjustErrorsDynamicallyForHits_

private

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

Definition at line 72 of file TSGForOIFromL2.h.

Referenced by produce().

const std::string TSGForOIFromL2::estimatorName_

private

Estimator used to find dets and TrajectoryMeasurements.

Definition at line 76 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::eta1_

private

Definition at line 95 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2(), and produce().

const double TSGForOIFromL2::eta2_

private

Definition at line 95 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta3_

private

Definition at line 95 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta4_

private

Definition at line 95 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta5_

private

Definition at line 95 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta6_

private

Definition at line 95 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta7_

private

Definition at line 95 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::fixedErrorRescalingForHitless_

private

Definition at line 69 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::fixedErrorRescalingForHits_

private

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

Definition at line 68 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::maxEtaForTOB_

private

Maximum eta value to activate searching in the TOB.

Definition at line 82 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::maxHitlessSeeds_

private

Maximum number of hitless seeds for each L2.

Definition at line 52 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::maxHitSeeds_

private

Maximum number of hitbased seeds for each L2.

Definition at line 55 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits(), and produce().

const unsigned int TSGForOIFromL2::maxSeeds_

private

Maximum number of seeds for each L2.

Definition at line 49 of file TSGForOIFromL2.h.

Referenced by produce().

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

private

Definition at line 91 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::minEtaForTEC_

private

Minimum eta value to activate searching in the TEC.

Definition at line 79 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::numL2ValidHitsCutAllEndcap_

private

Definition at line 65 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::numL2ValidHitsCutAllEta_

private

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

Definition at line 64 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::numOfHitsToTry_

private

How many hits to try per layer.

Definition at line 61 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits().

const unsigned int TSGForOIFromL2::numOfLayersToTry_

private

How many layers to try.

Definition at line 58 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits().

const std::string TSGForOIFromL2::propagatorName_

private

Counters and flags for the implementation.

Definition at line 103 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::pT1_

private

pT, eta ranges and scale factor values

Definition at line 94 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::pT2_

private

Definition at line 94 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::pT3_

private

Definition at line 94 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF1_

private

Definition at line 96 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF2_

private

Definition at line 96 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF3_

private

Definition at line 96 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF4_

private

Definition at line 96 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF5_

private

Definition at line 96 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF6_

private

Definition at line 96 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

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

private

Labels for input collections.

Definition at line 46 of file TSGForOIFromL2.h.

Referenced by produce().

const std::string TSGForOIFromL2::theCategory_

private

Definition at line 104 of file TSGForOIFromL2.h.

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

const double TSGForOIFromL2::tsosDiff1_

private

Distance of L2 TSOSs before and after updated with vertex.

Definition at line 99 of file TSGForOIFromL2.h.

const double TSGForOIFromL2::tsosDiff2_

private

Definition at line 100 of file TSGForOIFromL2.h.

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

private

KFUpdator defined in constructor.

Definition at line 89 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits().

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

Member Function Documentation

Member Data Documentation