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

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

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)

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

Detailed Description

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

Author: Benjamin Radburn-Smith, Santiago Folgueras

Definition at line 33 of file TSGForOI.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 15 of file TSGForOI.cc.

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

TSGForOI::~TSGForOI ( )

override

Definition at line 49 of file TSGForOI.cc.

49 {

50 }

Member Function Documentation

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

private

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

Definition at line 277 of file TSGForOI.cc.

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

Referenced by findSeedsOnLayer().

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

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

static

Definition at line 393 of file TSGForOI.cc.

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

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

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

private

Function to find seeds on a given layer.

Definition at line 218 of file TSGForOI.cc.

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

Referenced by produce().

                                                                       {
   
   if (numSeedsMade>numOfMaxSeeds) return;
   LogTrace("TSGForOI") << "TSGForOI::findSeedsOnLayer: numSeedsMade = " << numSeedsMade << " , layerCount = " <<  layerCount << endl;
   
   double errorSFHits=1.0;
   double errorSFHitless=1.0;
   if (!adjustErrorsDynamicallyForHits_) errorSFHits = fixedErrorRescalingForHits_;
   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; 
 }

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 302 of file TSGForOI.cc.

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

Referenced by findSeedsOnLayer().

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

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

private

Definition at line 371 of file TSGForOI.cc.

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

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

override

Init variables

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

Read ESHandles

Read L2 track collection

Definition at line 53 of file TSGForOI.cc.

References funct::abs(), alongMomentum, Plane::build(), estimatorName_, findSeedsOnLayer(), edm::EventSetup::get(), edm::Event::getByToken(), 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(), gsfElectronCkfTrackCandidateMaker_cff::propagatorAlong, propagatorName_, gsfElectronCkfTrackCandidateMaker_cff::propagatorOpposite, edm::Event::put(), 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

const bool TSGForOI::adjustErrorsDynamicallyForHitless_

private

Definition at line 58 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const bool TSGForOI::adjustErrorsDynamicallyForHits_

private

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

Definition at line 57 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const std::string TSGForOI::estimatorName_

private

Estimator used to find dets and TrajectoryMeasurements.

Definition at line 61 of file TSGForOI.h.

Referenced by produce().

const double TSGForOI::eta1_

private

Definition at line 83 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::eta2_

private

Definition at line 83 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::fixedErrorRescalingForHitless_

private

Definition at line 54 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const double TSGForOI::fixedErrorRescalingForHits_

private

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

Definition at line 53 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const double TSGForOI::maxEtaForTOB_

private

Maximum eta value to activate searching in the TOB.

Definition at line 67 of file TSGForOI.h.

Referenced by produce().

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

private

Definition at line 79 of file TSGForOI.h.

Referenced by produce().

const double TSGForOI::minEtaForTEC_

private

Minimum eta value to activate searching in the TEC.

Definition at line 64 of file TSGForOI.h.

Referenced by produce().

const unsigned int TSGForOI::numOfHitsToTry_

private

How many hits to try per layer.

Definition at line 50 of file TSGForOI.h.

Referenced by makeSeedsFromHits().

const unsigned int TSGForOI::numOfLayersToTry_

private

How many layers to try.

Definition at line 47 of file TSGForOI.h.

Referenced by findSeedsOnLayer().

const unsigned int TSGForOI::numOfMaxSeedsParam_

private

Maximum number of seeds for each L2.

Definition at line 44 of file TSGForOI.h.

Referenced by produce().

const std::string TSGForOI::propagatorName_

private

Counters and flags for the implementation.

Definition at line 90 of file TSGForOI.h.

Referenced by produce().

const double TSGForOI::pT1_

private

pT, eta ranges and scale factor values

Definition at line 82 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::pT2_

private

Definition at line 82 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::pT3_

private

Definition at line 82 of file TSGForOI.h.

Referenced by calculateSFFromL2().

const double TSGForOI::SF1_

private