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

#include <TSGForOI.h>

Inheritance diagram for TSGForOI:

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

	TSGForOI (const edm::ParameterSet &iConfig)

virtual	~TSGForOI ()

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

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
double	calculateSFFromL2 (const GeometricSearchDet &layer, const TrajectoryStateOnSurface &tsosAtMuonSystem, const TrajectoryStateOnSurface &tsosOnLayer, const Propagator &propagatorOpposite, const reco::TrackRef track)
	Function used to calculate the dynamic error SF by analysing the L2. More...

void	findSeedsOnLayer (const GeometricSearchDet &layer, const TrajectoryStateOnSurface &tsosAtIP, const TrajectoryStateOnSurface &tsosAtMuonSystem, const Propagator &propagatorAlong, const Propagator &propagatorOpposite, const reco::TrackRef l2, std::auto_ptr< std::vector< TrajectorySeed > > &seeds)
	Function to find seeds on a given layer. More...

int	makeSeedsFromHits (const GeometricSearchDet &layer, const TrajectoryStateOnSurface &state, std::vector< TrajectorySeed > &out, const Propagator &propagatorAlong, const MeasurementTrackerEvent &mte, double errorSF)
	Function to find hits on layers and create seeds from updated TSOS. More...

Private Attributes
const bool	adjustErrorsDyanmicallyForHitless_

const bool	adjustErrorsDyanmicallyForHits_
	Whether or not to use an automatically calculated SF value. More...

bool	analysedL2_

Plane::PlanePointer	dummyPlane_
	Surface used to make a TSOS at the PCA to the beamline. More...

edm::ESHandle < Chi2MeasurementEstimatorBase >	estimator_

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 STA for fixed option. More...

bool	foundCompatibleDet_
	Counters and flags for the implementation. More...

edm::ESHandle < GlobalTrackingGeometry >	geometry_

unsigned int	layerCount_

edm::ESHandle< MagneticField >	magfield_

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

edm::Handle < MeasurementTrackerEvent >	measurementTracker_

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 on same layer. More...

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

unsigned int	numOfMaxSeeds_
	Maximum number of seeds for each L2. More...

unsigned int	numSeedsMade_

edm::ESHandle< Propagator >	propagatorAlong_

edm::ESHandle< Propagator >	propagatorOpposite_

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

std::string	theCategory

const double	tsosDiffDeltaR_
	Difference in deltaR of TSOSs to trigger using hits in hybrid. More...

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

const bool	useHitlessSeeds_
	Switch to use hitless seeds or not. More...

bool	useHitsInHybrid_

const bool	useHybridSeeds_
	Switch to use hitless + hits for seeds depending on the L2 properties. More...

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

Detailed Description

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

Author: Benjamin Radburn-Smith

Definition at line 34 of file TSGForOI.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 10 of file TSGForOI.cc.

References foundCompatibleDet_, edm::ParameterSet::getParameter(), numOfMaxSeeds_, numSeedsMade_, and theCategory.

                                                   :
             src_(consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("src"))),
             numOfLayersToTry_(iConfig.getParameter<int32_t>("layersToTry")),
             numOfHitsToTry_(iConfig.getParameter<int32_t>("hitsToTry")),
             fixedErrorRescalingForHits_(iConfig.getParameter<double>("fixedErrorRescaleFactorForHits")),
             fixedErrorRescalingForHitless_(iConfig.getParameter<double>("fixedErrorRescaleFactorForHitless")),
             adjustErrorsDyanmicallyForHits_(iConfig.getParameter<bool>("adjustErrorsDyanmicallyForHits")),
             adjustErrorsDyanmicallyForHitless_(iConfig.getParameter<bool>("adjustErrorsDyanmicallyForHitless")),
             estimatorName_(iConfig.getParameter<std::string>("estimator")),
             measurementTrackerTag_(consumes<MeasurementTrackerEvent>(iConfig.getParameter<edm::InputTag>("MeasurementTrackerEvent"))),
             minEtaForTEC_(iConfig.getParameter<double>("minEtaForTEC")),
             maxEtaForTOB_(iConfig.getParameter<double>("maxEtaForTOB")),
             useHitlessSeeds_(iConfig.getParameter<bool>("UseHitlessSeeds")),
             useHybridSeeds_(iConfig.getParameter<bool>("UseHybridSeeds")),
             dummyPlane_(Plane::build(Plane::PositionType(), Plane::RotationType())),
             updator_(new KFUpdator()),
             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")),
             tsosDiffDeltaR_(iConfig.getParameter<double>("tsosDiffDeltaR"))
             {
     numOfMaxSeeds_=iConfig.getParameter<uint32_t>("maxSeeds");
     produces<std::vector<TrajectorySeed> >();
     foundCompatibleDet_=false;
     numSeedsMade_=0;
     theCategory = "Muon|RecoMuon|TSGForOI";
 }

TSGForOI::~TSGForOI ( )

virtual

Definition at line 46 of file TSGForOI.cc.

46 {

47 }

Member Function Documentation

double TSGForOI::calculateSFFromL2	(	const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	tsosAtMuonSystem,
		const TrajectoryStateOnSurface &	tsosOnLayer,
		const Propagator &	propagatorOpposite,
		const reco::TrackRef	track
	)

private

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

Definition at line 208 of file TSGForOI.cc.

References funct::abs(), eta1_, eta2_, 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
     if (track->pt()<=pT1_) theSF=SF1_;
     if (track->pt()>pT1_ && track->pt()<=pT2_){
         if (std::abs(track->eta())<=eta1_) theSF=SF3_;
         if (std::abs(track->eta())>eta1_ && std::abs(track->eta())<=eta2_) theSF=SF2_;
         if (std::abs(track->eta())>eta2_) theSF=SF3_;
     }
     if (track->pt()>pT2_ && track->pt()<=pT3_){
         if (std::abs(track->eta())<=eta1_) theSF=SF5_;
         if (std::abs(track->eta())>eta1_ && std::abs(track->eta())<=eta2_) theSF=SF4_;
         if (std::abs(track->eta())>eta2_) theSF=SF5_;
     }
     if (track->pt()>pT3_) theSF=SF5_;
 
     edm::LogInfo(theCategory) << "TSGForOI::calculateSFFromL2: SF has been calculated as: " << theSF;
     return theSF;
 }

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

static

Definition at line 283 of file TSGForOI.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), HLT_25ns10e33_v2_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>("adjustErrorsDyanmicallyForHits",false);
   desc.add<bool>("adjustErrorsDyanmicallyForHitless",false);
   desc.add<edm::InputTag>("MeasurementTrackerEvent",edm::InputTag("hltSiStripClusters"));
   desc.add<bool>("UseHitlessSeeds",true);
   desc.add<bool>("UseHybridSeeds",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>("tsosDiffDeltaR",0.03);
   descriptions.add("TSGForOI",desc);
 }

void TSGForOI::findSeedsOnLayer	(	const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	tsosAtIP,
		const TrajectoryStateOnSurface &	tsosAtMuonSystem,
		const Propagator &	propagatorAlong,
		const Propagator &	propagatorOpposite,
		const reco::TrackRef	l2,
		std::auto_ptr< std::vector< TrajectorySeed > > &	seeds
	)

private

Function to find seeds on a given layer.

Definition at line 149 of file TSGForOI.cc.

References adjustErrorsDyanmicallyForHitless_, adjustErrorsDyanmicallyForHits_, analysedL2_, calculateSFFromL2(), GeometricSearchDet::compatibleDetsV(), estimator_, fixedErrorRescalingForHitless_, fixedErrorRescalingForHits_, foundCompatibleDet_, layerCount_, makeSeedsFromHits(), measurementTracker_, numOfLayersToTry_, numOfMaxSeeds_, numSeedsMade_, oppositeToMomentum, GenerateHcalLaserBadRunList::out, trajectoryStateTransform::persistentState(), theCategory, useHitlessSeeds_, and useHybridSeeds_.

Referenced by produce().

                                                       {
 
     if (numSeedsMade_<numOfMaxSeeds_){
         double errorSFHits_=1.0;
         double errorSFHitless_=1.0;
         if (!adjustErrorsDyanmicallyForHits_) errorSFHits_ = fixedErrorRescalingForHits_;
         if (!adjustErrorsDyanmicallyForHitless_) errorSFHitless_ = fixedErrorRescalingForHitless_;
 
 //      Hitless:
         std::vector< GeometricSearchDet::DetWithState > dets;
         layer.compatibleDetsV(tsosAtIP, propagatorAlong, *estimator_, dets);
         if (dets.size()>0){
             auto const& detOnLayer = dets.front().first;
             auto const& tsosOnLayer = dets.front().second;
             // See if we need to adjust the Error Scale Factors:
             if (!analysedL2_ && adjustErrorsDyanmicallyForHitless_){
                 if (!tsosOnLayer.isValid()){
                     edm::LogInfo(theCategory) << "ERROR!: TSOS for SF is not valid!";
                 }
                 else{
                     errorSFHitless_=calculateSFFromL2(layer,tsosAtMuonSystem,tsosOnLayer,propagatorOpposite,l2);
                     analysedL2_=true;
                 }
             }
             if (useHitlessSeeds_ || useHybridSeeds_){
                 // Fill first seed from L2 using only state information:
                 if (!foundCompatibleDet_){
                     if (!tsosOnLayer.isValid()){
                         edm::LogInfo(theCategory) << "ERROR!: Hitless TSOS is not valid!";
                     }
                     else{
                         dets.front().second.rescaleError(errorSFHitless_);
                         PTrajectoryStateOnDet const& PTSOD = trajectoryStateTransform::persistentState(tsosOnLayer,detOnLayer->geographicalId().rawId());
                         TrajectorySeed::recHitContainer rHC;
                         out->push_back(TrajectorySeed(PTSOD,rHC,oppositeToMomentum));
                         foundCompatibleDet_=true;
                     }
                 }
                 numSeedsMade_=out->size();
             }
         }
 
 //      Hits:
         if (numSeedsMade_<numOfMaxSeeds_ && layerCount_<numOfLayersToTry_){
             if (makeSeedsFromHits(layer, tsosAtIP, *out, propagatorAlong, *measurementTracker_, errorSFHits_)) {
                 ++layerCount_; //Sucessfully made seeds from hits using this layer
             }
         }
         numSeedsMade_=out->size();
     }
 
 }

int TSGForOI::makeSeedsFromHits	(	const GeometricSearchDet &	layer,
		const TrajectoryStateOnSurface &	state,
		std::vector< TrajectorySeed > &	out,
		const Propagator &	propagatorAlong,
		const MeasurementTrackerEvent &	mte,
		double	errorSF
	)

private

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

Definition at line 236 of file TSGForOI.cc.

References GeometricSearchDet::compatibleDetsV(), estimator_, MeasurementDetWithData::fastMeasurements(), newFWLiteAna::found, MeasurementTrackerEvent::idToDet(), MeasurementDetWithData::isNull(), TrajectoryStateOnSurface::isValid(), eostools::move(), numOfHitsToTry_, oppositeToMomentum, trajectoryStateTransform::persistentState(), edm::OwnVector< T, P >::push_back(), fileCollector::seed, and updator_.

Referenced by findSeedsOnLayer().

                               {
 
     std::vector< GeometricSearchDet::DetWithState > dets;
     layer.compatibleDetsV(tsosAtIP, propagatorAlong, *estimator_, dets);
 
 //  Find Measurements on each DetWithState:
     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
 
 //      Error Rescaling:
         it->second.rescaleError(errorSF);
 
         std::vector < TrajectoryMeasurement > mymeas = det.fastMeasurements(it->second, tsosAtIP, 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:
     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());
         if (updatedTSOS.isValid()) {
             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);
             out.push_back(seed);
             found++;
             if (found == numOfHitsToTry_) break;
         }
     }
     return found;
 }

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 50 of file TSGForOI.cc.

References funct::abs(), alongMomentum, analysedL2_, deltaR(), dummyPlane_, estimator_, estimatorName_, findSeedsOnLayer(), foundCompatibleDet_, geometry_, edm::EventSetup::get(), edm::Event::getByToken(), TrajectoryStateOnSurface::globalMomentum(), trajectoryStateTransform::initialFreeState(), trajectoryStateTransform::innerFreeState(), TrajectoryStateOnSurface::isValid(), layerCount_, magfield_, maxEtaForTOB_, measurementTracker_, measurementTrackerTag_, minEtaForTEC_, numOfMaxSeeds_, numSeedsMade_, oppositeToMomentum, GenerateHcalLaserBadRunList::out, FreeTrajectoryState::position(), edm::ESHandle< class >::product(), HLT_25ns10e33_v2_cff::propagatorAlong, propagatorAlong_, HLT_25ns10e33_v2_cff::propagatorOpposite, propagatorOpposite_, edm::Event::put(), mps_fire::result, SetPropagationDirection(), src_, theCategory, tsosDiffDeltaR_, and useHybridSeeds_.

                                                                     {
     iSetup.get<IdealMagneticFieldRecord>().get(magfield_);
     iSetup.get<TrackingComponentsRecord>().get("PropagatorWithMaterial", propagatorOpposite_);
     iSetup.get<TrackingComponentsRecord>().get("PropagatorWithMaterial", propagatorAlong_);
     iSetup.get<GlobalTrackingGeometryRecord>().get(geometry_);
     iSetup.get<TrackingComponentsRecord>().get(estimatorName_,estimator_);
     iEvent.getByToken(measurementTrackerTag_, measurementTracker_);
     edm::Handle<reco::TrackCollection> l2TrackCol;                  iEvent.getByToken(src_, l2TrackCol);
 
 //  The product:
     std::auto_ptr<std::vector<TrajectorySeed> > result(new std::vector<TrajectorySeed>());
 
 //  Get vector of Detector layers once:
     std::vector<BarrelDetLayer const*> const& tob = measurementTracker_->geometricSearchTracker()->tobLayers();
     std::vector<ForwardDetLayer const*> const& tecPositive = measurementTracker_->geometricSearchTracker()->posTecLayers();
     std::vector<ForwardDetLayer const*> const& tecNegative = measurementTracker_->geometricSearchTracker()->negTecLayers();
 
 //  Get the suitable propagators:
     std::unique_ptr<Propagator> propagatorAlong = SetPropagationDirection(*propagatorAlong_,alongMomentum);
     std::unique_ptr<Propagator> propagatorOpposite = SetPropagationDirection(*propagatorOpposite_,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 making seeds for all of them:
     edm::LogInfo(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::auto_ptr<std::vector<TrajectorySeed> > out(new std::vector<TrajectorySeed>());
 
         FreeTrajectoryState fts = trajectoryStateTransform::initialFreeState(*l2, magfield_.product());
         dummyPlane_->move(fts.position() - dummyPlane_->position());
         TrajectoryStateOnSurface tsosAtIP = TrajectoryStateOnSurface(fts, *dummyPlane_);
 
         FreeTrajectoryState notUpdatedFts = trajectoryStateTransform::innerFreeState(*l2,magfield_.product());
         dummyPlane_->move(notUpdatedFts.position() - dummyPlane_->position());
         TrajectoryStateOnSurface tsosAtMuonSystem = TrajectoryStateOnSurface(notUpdatedFts, *dummyPlane_);
 
         if (useHybridSeeds_){
             StateOnTrackerBound fromInside(propagatorAlong.get());
             TrajectoryStateOnSurface outerTkStateInside = fromInside(fts);
             StateOnTrackerBound fromOutside(&*SmartOpposite);
             TrajectoryStateOnSurface outerTkStateOutside = fromOutside(notUpdatedFts);
 
             auto diffDeltaR=0.0;
             if (outerTkStateInside.isValid() && outerTkStateOutside.isValid()){
                 diffDeltaR = deltaR(outerTkStateInside.globalMomentum(),outerTkStateOutside.globalMomentum());
             }
             if (diffDeltaR>tsosDiffDeltaR_){
                 // Switch on hybrid: add a hit-based seed:
                 ++numOfMaxSeeds_;
             }
         } //Hybrid
 
         numSeedsMade_=0;
         foundCompatibleDet_=false;
         analysedL2_ = false;
 
 //      BARREL
         if (std::abs(l2->eta()) < maxEtaForTOB_) {
             layerCount_ = 0;
             for (auto it=tob.rbegin(); it!=tob.rend(); ++it) {  //This goes from outermost to innermost layer
                 findSeedsOnLayer(**it, tsosAtIP, tsosAtMuonSystem, *(propagatorAlong.get()), *(propagatorOpposite.get()), l2, 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) {
                 findSeedsOnLayer(**it, tsosAtIP, tsosAtMuonSystem, *(propagatorAlong.get()), *(propagatorOpposite.get()), l2, out);
             }
         }
 
 //      ENDCAP-
         if (l2->eta() < -minEtaForTEC_) {
             layerCount_ = 0;
             for (auto it=tecNegative.rbegin(); it!=tecNegative.rend(); ++it) {
                 findSeedsOnLayer(**it, tsosAtIP, tsosAtMuonSystem, *(propagatorAlong.get()), *(propagatorOpposite.get()), l2, 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(result);
 }