TSGForOIFromL2 Class Reference

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

#include <TSGForOIFromL2.h>

Inheritance diagram for TSGForOIFromL2:

Public Member Functions
void	produce (edm::StreamID sid, edm::Event &iEvent, const edm::EventSetup &iSetup) const override
	TSGForOIFromL2 (const edm::ParameterSet &iConfig)
	~TSGForOIFromL2 () override
Public Member Functions inherited from edm::global::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
EDProducer &	operator= (const EDProducer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
bool	wantsStreamLuminosityBlocks () const final
bool	wantsStreamRuns () const final
Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
	~EDProducerBase () override
Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
std::vector < edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const
	ProducerBase ()
std::vector < edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const
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
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::global::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
double	calculateSFFromL2 (const reco::TrackRef track) const
	Calculate the dynamic error SF by analysing the L2. More...
void	makeSeedsFromHits (const GeometricSearchDet &layer, const TrajectoryStateOnSurface &tsos, const Propagator &propagatorAlong, const edm::ESHandle< Chi2MeasurementEstimatorBase > &estimator, const edm::Handle< MeasurementTrackerEvent > &measurementTracker, double errorSF, unsigned int &hitSeedsMade, unsigned int &numSeedsMade, unsigned int &layerCount, std::vector< TrajectorySeed > &out) const
	Find hits on a given layer (TOB or TEC) and create seeds from updated TSOS with hit. More...
void	makeSeedsWithoutHits (const GeometricSearchDet &layer, const TrajectoryStateOnSurface &tsos, const Propagator &propagatorAlong, const edm::ESHandle< Chi2MeasurementEstimatorBase > &estimator, double errorSF, unsigned int &hitlessSeedsMade, unsigned int &numSeedsMade, std::vector< TrajectorySeed > &out) const
	Create seeds without hits on a given layer (TOB or TEC) More...
double	match_Chi2 (const TrajectoryStateOnSurface &tsos1, const TrajectoryStateOnSurface &tsos2) const
	Find compatability between two TSOSs. More...

Private Attributes
const bool	adjustErrorsDynamicallyForHitless_
const bool	adjustErrorsDynamicallyForHits_
	Whether or not to use an automatically calculated scale-factor value. More...
const std::string	estimatorName_
	Estimator used to find dets and TrajectoryMeasurements. More...
const edm::ESGetToken < Chi2MeasurementEstimatorBase, TrackingComponentsRecord >	estimatorToken_
const double	eta1_
const double	eta2_
const double	eta3_
const double	eta4_
const double	eta5_
const double	eta6_
const double	eta7_
const double	fixedErrorRescalingForHitless_
const double	fixedErrorRescalingForHits_
	Rescale L2 parameter uncertainties (fixed error vs pT, eta) More...
const edm::ESGetToken < GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	geometryToken_
const edm::ESGetToken < MagneticField, IdealMagneticFieldRecord >	magfieldToken_
const double	maxEtaForTOB_
	Maximum eta value to activate searching in the TOB. More...
const unsigned int	maxHitlessSeeds_
	Maximum number of hitless seeds for each L2. More...
const unsigned int	maxHitSeeds_
	Maximum number of hitbased seeds for each L2. More...
const unsigned int	maxSeeds_
	Maximum number of seeds for each L2. More...
const edm::EDGetTokenT < MeasurementTrackerEvent >	measurementTrackerTag_
const double	minEtaForTEC_
	Minimum eta value to activate searching in the TEC. More...
const unsigned int	numL2ValidHitsCutAllEndcap_
const unsigned int	numL2ValidHitsCutAllEta_
	L2 valid hit cuts to decide seed creation by both states. More...
const unsigned int	numOfHitsToTry_
	How many hits to try per layer. More...
const unsigned int	numOfLayersToTry_
	How many layers to try. More...
const std::string	propagatorName_
	Counters and flags for the implementation. More...
const edm::ESGetToken < Propagator, TrackingComponentsRecord >	propagatorToken_
const double	pT1_
	pT, eta ranges and scale factor values More...
const double	pT2_
const double	pT3_
const double	SF1_
const double	SF2_
const double	SF3_
const double	SF4_
const double	SF5_
const double	SF6_
const edm::ESGetToken < Propagator, TrackingComponentsRecord >	sHPOppositeToken_
const edm::EDGetTokenT < reco::TrackCollection >	src_
	Labels for input collections. More...
const std::string	theCategory_
const edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	tmpTkGeometryToken_
const double	tsosDiff1_
	Distance of L2 TSOSs before and after updated with vertex. More...
const double	tsosDiff2_
const std::unique_ptr < TrajectoryStateUpdator >	updator_
	KFUpdator defined in constructor. More...
const bool	useHitLessSeeds_

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType
Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const *, const char *, edm::ProductResolverIndex >>
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

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

Author

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

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

Definition at line 34 of file TSGForOIFromL2.h.

Constructor & Destructor Documentation

TSGForOIFromL2::TSGForOIFromL2 ( 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")),
      estimatorToken_(esConsumes(edm::ESInputTag("", estimatorName_))),
      magfieldToken_(esConsumes()),
      propagatorToken_(esConsumes(edm::ESInputTag("", propagatorName_))),
      tmpTkGeometryToken_(esConsumes()),
      geometryToken_(esConsumes()),
      sHPOppositeToken_(esConsumes(edm::ESInputTag("", "hltESPSteppingHelixPropagatorOpposite"))) {
  produces<std::vector<TrajectorySeed> >();
}

TSGForOIFromL2::~TSGForOIFromL2 ( )

override

Definition at line 63 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 439 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 508 of file TSGForOIFromL2.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("src", edm::InputTag("hltL2Muons", "UpdatedAtVtx"));
  desc.add<int>("layersToTry", 2);
  desc.add<double>("fixedErrorRescaleFactorForHitless", 2.0);
  desc.add<int>("hitsToTry", 1);
  desc.add<bool>("adjustErrorsDynamicallyForHits", false);
  desc.add<bool>("adjustErrorsDynamicallyForHitless", true);
  desc.add<edm::InputTag>("MeasurementTrackerEvent", edm::InputTag("hltSiStripClusters"));
  desc.add<bool>("UseHitLessSeeds", true);
  desc.add<std::string>("estimator", "hltESPChi2MeasurementEstimator100");
  desc.add<double>("maxEtaForTOB", 1.8);
  desc.add<double>("minEtaForTEC", 0.7);
  desc.addUntracked<bool>("debug", false);
  desc.add<double>("fixedErrorRescaleFactorForHits", 1.0);
  desc.add<unsigned int>("maxSeeds", 20);
  desc.add<unsigned int>("maxHitlessSeeds", 5);
  desc.add<unsigned int>("maxHitSeeds", 1);
  desc.add<unsigned int>("numL2ValidHitsCutAllEta", 20);
  desc.add<unsigned int>("numL2ValidHitsCutAllEndcap", 30);
  desc.add<double>("pT1", 13.0);
  desc.add<double>("pT2", 30.0);
  desc.add<double>("pT3", 70.0);
  desc.add<double>("eta1", 0.2);
  desc.add<double>("eta2", 0.3);
  desc.add<double>("eta3", 1.0);
  desc.add<double>("eta4", 1.2);
  desc.add<double>("eta5", 1.6);
  desc.add<double>("eta6", 1.4);
  desc.add<double>("eta7", 2.1);
  desc.add<double>("SF1", 3.0);
  desc.add<double>("SF2", 4.0);
  desc.add<double>("SF3", 5.0);
  desc.add<double>("SF4", 7.0);
  desc.add<double>("SF5", 10.0);
  desc.add<double>("SF6", 2.0);
  desc.add<double>("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, const edm::ESHandle< Chi2MeasurementEstimatorBase > &  estimator, const edm::Handle< MeasurementTrackerEvent > &  measurementTracker, double  errorSF, unsigned int &  hitSeedsMade, unsigned int &  numSeedsMade, unsigned int &  layerCount, std::vector< TrajectorySeed > &  out  ) const

private

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

Definition at line 362 of file TSGForOIFromL2.cc.

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

Referenced by produce().

                                                                             {
  if (layerCount > numOfLayersToTry_)
    return;

  // Error Rescaling
  TrajectoryStateOnSurface onLayer(tsos);
  onLayer.rescaleError(errorSF);

  std::vector<GeometricSearchDet::DetWithState> dets;
  layer.compatibleDetsV(onLayer, propagatorAlong, *estimator, dets);

  // Find Measurements on each DetWithState
  LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: Find measurements on each detWithState  "
                             << dets.size() << std::endl;
  std::vector<TrajectoryMeasurement> meas;
  for (std::vector<GeometricSearchDet::DetWithState>::iterator it = dets.begin(); it != dets.end(); ++it) {
    MeasurementDetWithData det = measurementTracker->idToDet(it->first->geographicalId());
    if (det.isNull())
      continue;
    if (!it->second.isValid())
      continue;  // Skip if TSOS is not valid

    std::vector<TrajectoryMeasurement> mymeas =
        det.fastMeasurements(it->second, onLayer, propagatorAlong, *estimator);  // Second TSOS is not used
    for (std::vector<TrajectoryMeasurement>::const_iterator it2 = mymeas.begin(), ed2 = mymeas.end(); it2 != ed2;
         ++it2) {
      if (it2->recHit()->isValid())
        meas.push_back(*it2);  // Only save those which are valid
    }
  }

  // Update TSOS using TMs after sorting, then create Trajectory Seed and put into vector
  LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: Update TSOS using TMs after sorting, then create "
                                "Trajectory Seed, number of TM = "
                             << meas.size() << std::endl;
  std::sort(meas.begin(), meas.end(), TrajMeasLessEstim());

  unsigned int found = 0;
  for (std::vector<TrajectoryMeasurement>::const_iterator it = meas.begin(); it != meas.end(); ++it) {
    TrajectoryStateOnSurface updatedTSOS = updator_->update(it->forwardPredictedState(), *it->recHit());
    LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: TSOS for TM " << found << std::endl;
    if (not updatedTSOS.isValid())
      continue;

    edm::OwnVector<TrackingRecHit> seedHits;
    seedHits.push_back(*it->recHit()->hit());
    PTrajectoryStateOnDet const& pstate =
        trajectoryStateTransform::persistentState(updatedTSOS, it->recHit()->geographicalId().rawId());
    LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::makeSeedsFromHits: Number of seedHits: " << seedHits.size()
                               << std::endl;
    TrajectorySeed seed(pstate, std::move(seedHits), oppositeToMomentum);
    out.push_back(seed);
    found++;
    numSeedsMade++;
    hitSeedsMade++;
    if (found == numOfHitsToTry_)
      break;
    if (hitSeedsMade > maxHitSeeds_)
      return;
  }

  if (found)
    layerCount++;
}

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

private

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

Definition at line 328 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 486 of file TSGForOIFromL2.cc.

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

                                                                                                                    {
  if (!tsos1.isValid() || !tsos2.isValid())
    return -1.;

  AlgebraicVector5 v(tsos1.localParameters().vector() - tsos2.localParameters().vector());
  AlgebraicSymMatrix55 m(tsos1.localError().matrix() + tsos2.localError().matrix());

  bool ierr = !m.Invert();

  if (ierr) {
    edm::LogInfo("TSGForOIFromL2") << "Error inverting covariance matrix";
    return -1;
  }

  double est = ROOT::Math::Similarity(v, m);

  return est;
}

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

overridevirtual

Implements edm::global::EDProducerBase.

Definition at line 68 of file TSGForOIFromL2.cc.

References funct::abs(), adjustErrorsDynamicallyForHitless_, adjustErrorsDynamicallyForHits_, alongMomentum, Plane::build(), calculateSFFromL2(), estimatorToken_, eta1_, eta7_, fixedErrorRescalingForHitless_, fixedErrorRescalingForHits_, geometryToken_, edm::Event::getByToken(), edm::EventSetup::getHandle(), trajectoryStateTransform::initialFreeState(), trajectoryStateTransform::innerStateOnSurface(), TrajectoryStateOnSurface::isValid(), LogTrace, magfieldToken_, makeSeedsFromHits(), makeSeedsWithoutHits(), maxEtaForTOB_, maxHitlessSeeds_, maxHitSeeds_, maxSeeds_, measurementTrackerTag_, minEtaForTEC_, eostools::move(), numL2ValidHitsCutAllEndcap_, numL2ValidHitsCutAllEta_, oppositeToMomentum, submitPVResolutionJobs::out, GeomDetEnumerators::P2OTEC, FreeTrajectoryState::position(), edm::ESHandle< class >::product(), HLT_FULL_cff::propagatorAlong, HLT_FULL_cff::propagatorOpposite, propagatorToken_, edm::Event::put(), mps_fire::result, SetPropagationDirection(), sHPOppositeToken_, src_, theCategory_, tmpTkGeometryToken_, 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;
  const edm::ESHandle<Chi2MeasurementEstimatorBase> estimatorH = iSetup.getHandle(estimatorToken_);
  const edm::ESHandle<MagneticField> magfieldH = iSetup.getHandle(magfieldToken_);
  const edm::ESHandle<Propagator> propagatorAlongH = iSetup.getHandle(propagatorToken_);
  const edm::ESHandle<Propagator>& propagatorOppositeH = propagatorAlongH;
  const edm::ESHandle<TrackerGeometry> tmpTkGeometryH = iSetup.getHandle(tmpTkGeometryToken_);
  const edm::ESHandle<GlobalTrackingGeometry> geometryH = iSetup.getHandle(geometryToken_);

  iEvent.getByToken(measurementTrackerTag_, measurementTrackerH);

  // Read L2 track collection
  edm::Handle<reco::TrackCollection> l2TrackCol;
  iEvent.getByToken(src_, l2TrackCol);

  // The product
  std::unique_ptr<std::vector<TrajectorySeed> > result(new std::vector<TrajectorySeed>());

  // Get vector of Detector layers
  std::vector<BarrelDetLayer const*> const& tob = measurementTrackerH->geometricSearchTracker()->tobLayers();
  std::vector<ForwardDetLayer const*> const& tecPositive =
      tmpTkGeometryH->isThere(GeomDetEnumerators::P2OTEC)
          ? measurementTrackerH->geometricSearchTracker()->posTidLayers()
          : measurementTrackerH->geometricSearchTracker()->posTecLayers();
  std::vector<ForwardDetLayer const*> const& tecNegative =
      tmpTkGeometryH->isThere(GeomDetEnumerators::P2OTEC)
          ? measurementTrackerH->geometricSearchTracker()->negTidLayers()
          : measurementTrackerH->geometricSearchTracker()->negTecLayers();

  // Get suitable propagators
  std::unique_ptr<Propagator> propagatorAlong = SetPropagationDirection(*propagatorAlongH, alongMomentum);
  std::unique_ptr<Propagator> propagatorOpposite = SetPropagationDirection(*propagatorOppositeH, oppositeToMomentum);

  // Stepping Helix Propagator for propogation from muon system to tracker
  const edm::ESHandle<Propagator> SHPOpposite = iSetup.getHandle(sHPOppositeToken_);

  // Loop over the L2's and make seeds for all of them
  LogTrace(theCategory_) << "TSGForOIFromL2::produce: Number of L2's: " << l2TrackCol->size();
  for (unsigned int l2TrackColIndex(0); l2TrackColIndex != l2TrackCol->size(); ++l2TrackColIndex) {
    const reco::TrackRef l2(l2TrackCol, l2TrackColIndex);

    // Container of Seeds
    std::vector<TrajectorySeed> out;
    LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: L2 muon pT, eta, phi --> " << l2->pt() << " , " << l2->eta()
                               << " , " << l2->phi() << std::endl;

    FreeTrajectoryState fts = trajectoryStateTransform::initialFreeState(*l2, magfieldH.product());

    dummyPlane->move(fts.position() - dummyPlane->position());
    TrajectoryStateOnSurface tsosAtIP = TrajectoryStateOnSurface(fts, *dummyPlane);
    LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: Created TSOSatIP: " << tsosAtIP << std::endl;

    // Get the TSOS on the innermost layer of the L2
    TrajectoryStateOnSurface tsosAtMuonSystem =
        trajectoryStateTransform::innerStateOnSurface(*l2, *geometryH, magfieldH.product());
    LogTrace("TSGForOIFromL2") << "TSGForOIFromL2::produce: Created TSOSatMuonSystem: " << tsosAtMuonSystem
                               << std::endl;

    LogTrace("TSGForOIFromL2")
        << "TSGForOIFromL2::produce: Check the error of the L2 parameter and use hit seeds if big errors" << std::endl;

    StateOnTrackerBound fromInside(propagatorAlong.get());
    TrajectoryStateOnSurface outerTkStateInside = fromInside(fts);

    StateOnTrackerBound fromOutside(&*SHPOpposite);
    TrajectoryStateOnSurface outerTkStateOutside = fromOutside(tsosAtMuonSystem);

    // Check if the two positions (using updated and not-updated TSOS) agree withing certain extent.
    // If both TSOSs agree, use only the one at vertex, as it uses more information. If they do not agree, search for seeds based on both.
    double L2muonEta = l2->eta();
    double absL2muonEta = std::abs(L2muonEta);
    bool useBoth = false;
    if (outerTkStateInside.isValid() && outerTkStateOutside.isValid()) {
      //following commented out variables dist1 (5 par compatibility of tsos at outertracker surface)
      //dist2 (angle between two tsos) could further be explored in combination of L2 valid hits for seeding. So kept for
      //future developers
      //auto dist1 = match_Chi2(outerTkStateInside,outerTkStateOutside);//for future developers
      //auto dist2 = deltaR(outerTkStateInside.globalMomentum(),outerTkStateOutside.globalMomentum());//for future developers
      //if ((dist1 > tsosDiff1_ || dist2 > tsosDiff2_) && l2->numberOfValidHits() < 20) useBoth = true;//for future developers
      if (l2->numberOfValidHits() < numL2ValidHitsCutAllEta_)
        useBoth = true;
      if (l2->numberOfValidHits() < numL2ValidHitsCutAllEndcap_ && absL2muonEta > eta7_)
        useBoth = true;
      if (absL2muonEta > eta1_ && absL2muonEta < eta1_)
        useBoth = true;
    }

    numSeedsMade = 0;
    hitlessSeedsMadeIP = 0;
    hitlessSeedsMadeMuS = 0;
    hitSeedsMade = 0;

    // 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 70 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 69 of file TSGForOIFromL2.h.

Referenced by produce().

const std::string TSGForOIFromL2::estimatorName_

private

Estimator used to find dets and TrajectoryMeasurements.

Definition at line 73 of file TSGForOIFromL2.h.

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

private

Definition at line 102 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::eta1_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2(), and produce().

const double TSGForOIFromL2::eta2_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta3_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta4_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta5_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta6_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::eta7_

private

Definition at line 92 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::fixedErrorRescalingForHitless_

private

Definition at line 66 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::fixedErrorRescalingForHits_

private

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

Definition at line 65 of file TSGForOIFromL2.h.

Referenced by produce().

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

private

Definition at line 106 of file TSGForOIFromL2.h.

Referenced by produce().

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

private

Definition at line 103 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::maxEtaForTOB_

private

Maximum eta value to activate searching in the TOB.

Definition at line 79 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::maxHitlessSeeds_

private

Maximum number of hitless seeds for each L2.

Definition at line 49 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::maxHitSeeds_

private

Maximum number of hitbased seeds for each L2.

Definition at line 52 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits(), and produce().

const unsigned int TSGForOIFromL2::maxSeeds_

private

Maximum number of seeds for each L2.

Definition at line 46 of file TSGForOIFromL2.h.

Referenced by produce().

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

private

Definition at line 88 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::minEtaForTEC_

private

Minimum eta value to activate searching in the TEC.

Definition at line 76 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::numL2ValidHitsCutAllEndcap_

private

Definition at line 62 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 61 of file TSGForOIFromL2.h.

Referenced by produce().

const unsigned int TSGForOIFromL2::numOfHitsToTry_

private

How many hits to try per layer.

Definition at line 58 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits().

const unsigned int TSGForOIFromL2::numOfLayersToTry_

private

How many layers to try.

Definition at line 55 of file TSGForOIFromL2.h.

Referenced by makeSeedsFromHits().

const std::string TSGForOIFromL2::propagatorName_

private

Counters and flags for the implementation.

Definition at line 100 of file TSGForOIFromL2.h.

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

private

Definition at line 104 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::pT1_

private

pT, eta ranges and scale factor values

Definition at line 91 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::pT2_

private

Definition at line 91 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::pT3_

private

Definition at line 91 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF1_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF2_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF3_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF4_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF5_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

const double TSGForOIFromL2::SF6_

private

Definition at line 93 of file TSGForOIFromL2.h.

Referenced by calculateSFFromL2().

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

private

Definition at line 107 of file TSGForOIFromL2.h.

Referenced by produce().

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

private

Labels for input collections.

Definition at line 43 of file TSGForOIFromL2.h.

Referenced by produce().

const std::string TSGForOIFromL2::theCategory_

private

Definition at line 101 of file TSGForOIFromL2.h.

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

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

private

Definition at line 105 of file TSGForOIFromL2.h.

Referenced by produce().

const double TSGForOIFromL2::tsosDiff1_

private

Distance of L2 TSOSs before and after updated with vertex.

Definition at line 96 of file TSGForOIFromL2.h.

const double TSGForOIFromL2::tsosDiff2_

private

Definition at line 97 of file TSGForOIFromL2.h.

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

private

KFUpdator defined in constructor.

Definition at line 86 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 83 of file TSGForOIFromL2.h.

Referenced by produce().