#include <L1Trigger/L1TTrackMatch/plugins/L1TrackSelectionProducer.cc>

Inheritance diagram for L1TrackSelectionProducer:

Classes
struct	TTTrackAbsEtaMaxSelector

struct	TTTrackAbsZ0MaxSelector

struct	TTTrackBendChi2MaxSelector

struct	TTTrackChi2RPhiMaxSelector

struct	TTTrackChi2RZMaxSelector

struct	TTTrackDeltaZMaxSelector

struct	TTTrackNPSStubsMinSelector

struct	TTTrackNStubsMinSelector

struct	TTTrackPtMinSelector

struct	TTTrackWordAbsEtaMaxSelector

struct	TTTrackWordAbsZ0MaxSelector

struct	TTTrackWordBendChi2MaxSelector

struct	TTTrackWordChi2RPhiMaxSelector

struct	TTTrackWordChi2RZMaxSelector

struct	TTTrackWordDeltaZMaxSelector

struct	TTTrackWordNStubsMinSelector

struct	TTTrackWordPtMinSelector

Public Member Functions
	L1TrackSelectionProducer (const edm::ParameterSet &)

	~L1TrackSelectionProducer () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

EDProducer &	operator= (const EDProducer &)=delete

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

bool	wantsInputProcessBlocks () const final

bool	wantsProcessBlocks () const final

bool	wantsStreamLuminosityBlocks () const final

bool	wantsStreamRuns () const final

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

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const

std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const > , NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
typedef TTTrack< Ref_Phase2TrackerDigi_ >	L1Track

enum	TrackBitWidths { kPtSize = TTTrack_TrackWord::TrackBitWidths::kRinvSize - 1, kPtMagSize = 9, kEtaSize = TTTrack_TrackWord::TrackBitWidths::kTanlSize, kEtaMagSize = 3 }

typedef AndSelector< TTTrackBendChi2MaxSelector, TTTrackChi2RZMaxSelector, TTTrackChi2RPhiMaxSelector >	TTTrackBendChi2Chi2RZChi2RPhiMaxSelector

typedef std::vector< L1Track >	TTTrackCollection

typedef edm::Handle< TTTrackCollection >	TTTrackCollectionHandle

typedef AndSelector< TTTrackPtMinSelector, TTTrackAbsEtaMaxSelector, TTTrackAbsZ0MaxSelector, TTTrackNStubsMinSelector >	TTTrackPtMinEtaMaxZ0MaxNStubsMinSelector

typedef edm::Ref< TTTrackCollection >	TTTrackRef

typedef edm::RefVector< TTTrackCollection >	TTTrackRefCollection

typedef std::unique_ptr< TTTrackRefCollection >	TTTrackRefCollectionUPtr

typedef AndSelector< TTTrackWordBendChi2MaxSelector, TTTrackWordChi2RZMaxSelector, TTTrackWordChi2RPhiMaxSelector >	TTTrackWordBendChi2Chi2RZChi2RPhiMaxSelector

typedef AndSelector< TTTrackWordPtMinSelector, TTTrackWordAbsEtaMaxSelector, TTTrackWordAbsZ0MaxSelector, TTTrackWordNStubsMinSelector >	TTTrackWordPtMinEtaMaxZ0MaxNStubsMinSelector

Private Member Functions
void	printDebugInfo (const TTTrackCollectionHandle &l1TracksHandle, const TTTrackRefCollectionUPtr &vTTTrackOutput, const TTTrackRefCollectionUPtr &vTTTrackEmulationOutput, const TTTrackRefCollectionUPtr &vTTTrackAssociatedOutput, const TTTrackRefCollectionUPtr &vTTTrackAssociatedEmulationOutput) const

void	printTrackInfo (edm::LogInfo &log, const L1Track &track, bool printEmulation=false) const

void	produce (edm::StreamID, edm::Event &, const edm::EventSetup &) const override

Private Attributes
const double	absEtaMax_

const double	absZ0Max_

const double	bendChi2Max_

const edm::ParameterSet	cutSet_

int	debug_

std::vector< double >	deltaZMax_

std::vector< double >	deltaZMaxEtaBounds_

bool	doDeltaZCutEmu_

bool	doDeltaZCutSim_

const edm::EDGetTokenT< TTTrackCollection >	l1TracksToken_

edm::EDGetTokenT< l1t::VertexWordCollection >	l1VerticesEmulationToken_

edm::EDGetTokenT< l1t::VertexCollection >	l1VerticesToken_

const int	nPSStubsMin_

const int	nStubsMin_

const std::string	outputCollectionName_

bool	processEmulatedTracks_

bool	processSimulatedTracks_

const double	ptMin_

const double	reducedChi2RPhiMax_

const double	reducedChi2RZMax_

edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	tTopoToken_

const double	useDisplacedTracksDeltaZOverride_

Additional Inherited Members
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
template<typename T >
using	BranchAliasSetterT = ProductRegistryHelper::BranchAliasSetterT< T >

using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
template<Transition Tr = Transition::Event>
auto	produces (std::string instanceName) noexcept
	declare what type of product will make and with which optional label More...

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

template<Transition Tr = Transition::Event>
auto	produces () noexcept

ProducesCollector	producesCollector ()

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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

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

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

void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: Selects a set of L1Tracks based on a set of predefined criteria.

Implementation: Inputs: std::vector<TTTrack> - Each floating point TTTrack inside this collection inherits from a bit-accurate TTTrack_TrackWord, used for emulation purposes. Outputs: std::vector<TTTrack> - A collection of TTTracks selected from cuts on the TTTrack properties std::vector<TTTrack> - A collection of TTTracks selected from cuts on the TTTrack_TrackWord properties

Definition at line 65 of file L1TrackSelectionProducer.cc.

Member Typedef Documentation

◆ L1Track

typedef TTTrack<Ref_Phase2TrackerDigi_> L1TrackSelectionProducer::L1Track

private

Definition at line 82 of file L1TrackSelectionProducer.cc.

◆ TTTrackBendChi2Chi2RZChi2RPhiMaxSelector

typedef AndSelector<TTTrackBendChi2MaxSelector, TTTrackChi2RZMaxSelector, TTTrackChi2RPhiMaxSelector> L1TrackSelectionProducer::TTTrackBendChi2Chi2RZChi2RPhiMaxSelector

private

Definition at line 305 of file L1TrackSelectionProducer.cc.

◆ TTTrackCollection

typedef std::vector<L1Track> L1TrackSelectionProducer::TTTrackCollection

private

Definition at line 83 of file L1TrackSelectionProducer.cc.

◆ TTTrackCollectionHandle

typedef edm::Handle<TTTrackCollection> L1TrackSelectionProducer::TTTrackCollectionHandle

private

Definition at line 84 of file L1TrackSelectionProducer.cc.

◆ TTTrackPtMinEtaMaxZ0MaxNStubsMinSelector

typedef AndSelector<TTTrackPtMinSelector, TTTrackAbsEtaMaxSelector, TTTrackAbsZ0MaxSelector, TTTrackNStubsMinSelector> L1TrackSelectionProducer::TTTrackPtMinEtaMaxZ0MaxNStubsMinSelector

private

Definition at line 298 of file L1TrackSelectionProducer.cc.

◆ TTTrackRef

typedef edm::Ref<TTTrackCollection> L1TrackSelectionProducer::TTTrackRef

private

Definition at line 85 of file L1TrackSelectionProducer.cc.

◆ TTTrackRefCollection

typedef edm::RefVector<TTTrackCollection> L1TrackSelectionProducer::TTTrackRefCollection

private

Definition at line 86 of file L1TrackSelectionProducer.cc.

◆ TTTrackRefCollectionUPtr

typedef std::unique_ptr<TTTrackRefCollection> L1TrackSelectionProducer::TTTrackRefCollectionUPtr

private

Definition at line 87 of file L1TrackSelectionProducer.cc.

◆ TTTrackWordBendChi2Chi2RZChi2RPhiMaxSelector

typedef AndSelector<TTTrackWordBendChi2MaxSelector, TTTrackWordChi2RZMaxSelector, TTTrackWordChi2RPhiMaxSelector> L1TrackSelectionProducer::TTTrackWordBendChi2Chi2RZChi2RPhiMaxSelector

private

Definition at line 307 of file L1TrackSelectionProducer.cc.

◆ TTTrackWordPtMinEtaMaxZ0MaxNStubsMinSelector

typedef AndSelector<TTTrackWordPtMinSelector, TTTrackWordAbsEtaMaxSelector, TTTrackWordAbsZ0MaxSelector, TTTrackWordNStubsMinSelector> L1TrackSelectionProducer::TTTrackWordPtMinEtaMaxZ0MaxNStubsMinSelector

private

Definition at line 303 of file L1TrackSelectionProducer.cc.

Member Enumeration Documentation

◆ TrackBitWidths

enum L1TrackSelectionProducer::TrackBitWidths

private

Enumerator
kPtSize
kPtMagSize
kEtaSize
kEtaMagSize

Definition at line 75 of file L1TrackSelectionProducer.cc.

                       {
     kPtSize = TTTrack_TrackWord::TrackBitWidths::kRinvSize - 1,  // Width of pt
     kPtMagSize = 9,                                              // Width of pt magnitude (unsigned)
     kEtaSize = TTTrack_TrackWord::TrackBitWidths::kTanlSize,     // Width of eta
     kEtaMagSize = 3,                                             // Width of eta magnitude (signed)
   };

Constructor & Destructor Documentation

◆ L1TrackSelectionProducer()

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

explicit

Definition at line 327 of file L1TrackSelectionProducer.cc.

References deltaZMax_, deltaZMaxEtaBounds_, doDeltaZCutEmu_, doDeltaZCutSim_, Exception, edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), l1VerticesEmulationToken_, l1VerticesToken_, outputCollectionName_, processEmulatedTracks_, processSimulatedTracks_, and useDisplacedTracksDeltaZOverride_.

     : l1TracksToken_(consumes<TTTrackCollection>(iConfig.getParameter<edm::InputTag>("l1TracksInputTag"))),
       tTopoToken_(esConsumes<TrackerTopology, TrackerTopologyRcd>(edm::ESInputTag("", ""))),
       outputCollectionName_(iConfig.getParameter<std::string>("outputCollectionName")),
       cutSet_(iConfig.getParameter<edm::ParameterSet>("cutSet")),
 
       ptMin_(cutSet_.getParameter<double>("ptMin")),
       absEtaMax_(cutSet_.getParameter<double>("absEtaMax")),
       absZ0Max_(cutSet_.getParameter<double>("absZ0Max")),
       bendChi2Max_(cutSet_.getParameter<double>("reducedBendChi2Max")),
       reducedChi2RZMax_(cutSet_.getParameter<double>("reducedChi2RZMax")),
       reducedChi2RPhiMax_(cutSet_.getParameter<double>("reducedChi2RPhiMax")),
       nStubsMin_(cutSet_.getParameter<int>("nStubsMin")),
       nPSStubsMin_(cutSet_.getParameter<int>("nPSStubsMin")),
       deltaZMaxEtaBounds_(cutSet_.getParameter<std::vector<double>>("deltaZMaxEtaBounds")),
       deltaZMax_(cutSet_.getParameter<std::vector<double>>("deltaZMax")),
 
       useDisplacedTracksDeltaZOverride_(iConfig.getParameter<double>("useDisplacedTracksDeltaZOverride")),
       processSimulatedTracks_(iConfig.getParameter<bool>("processSimulatedTracks")),
       processEmulatedTracks_(iConfig.getParameter<bool>("processEmulatedTracks")),
       debug_(iConfig.getParameter<int>("debug")) {
   // Confirm the the configuration makes sense
   if (!processSimulatedTracks_ && !processEmulatedTracks_) {
     throw cms::Exception("You must process at least one of the track collections (simulated or emulated).");
   }
 
   if (deltaZMax_.size() != deltaZMaxEtaBounds_.size() - 1) {
     throw cms::Exception("The number of deltaZ cuts does not match the number of eta bins!");
   }
 
   if (useDisplacedTracksDeltaZOverride_ >= 0) {
     deltaZMax_ = std::vector<double>(deltaZMax_.size(), useDisplacedTracksDeltaZOverride_);
   }
 
   // Get additional input tags and define the EDM output based on the previous configuration parameters
   doDeltaZCutSim_ = false;
   doDeltaZCutEmu_ = false;
   if (processSimulatedTracks_) {
     produces<TTTrackRefCollection>(outputCollectionName_);
     if (iConfig.exists("l1VerticesInputTag")) {
       l1VerticesToken_ = consumes<l1t::VertexCollection>(iConfig.getParameter<edm::InputTag>("l1VerticesInputTag"));
       doDeltaZCutSim_ = true;
       produces<TTTrackRefCollection>(outputCollectionName_ + "Associated");
     }
   }
   if (processEmulatedTracks_) {
     produces<TTTrackRefCollection>(outputCollectionName_ + "Emulation");
     if (iConfig.exists("l1VerticesEmulationInputTag")) {
       l1VerticesEmulationToken_ =
           consumes<l1t::VertexWordCollection>(iConfig.getParameter<edm::InputTag>("l1VerticesEmulationInputTag"));
       doDeltaZCutEmu_ = true;
       produces<TTTrackRefCollection>(outputCollectionName_ + "AssociatedEmulation");
     }
   }
 }

◆ ~L1TrackSelectionProducer()

L1TrackSelectionProducer::~L1TrackSelectionProducer ( )

override

Definition at line 383 of file L1TrackSelectionProducer.cc.

383 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 599 of file L1TrackSelectionProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, HLT_2022v15_cff::InputTag, edm::ParameterDescriptionNode::setComment(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           {
   //L1TrackSelectionProducer
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("l1TracksInputTag", edm::InputTag("l1tTTTracksFromTrackletEmulation", "Level1TTTracks"));
   desc.addOptional<edm::InputTag>("l1VerticesInputTag", edm::InputTag("l1tVertexFinder", "l1vertices"));
   desc.addOptional<edm::InputTag>("l1VerticesEmulationInputTag",
                                   edm::InputTag("l1tVertexFinderEmulator", "l1verticesEmulation"));
   desc.add<std::string>("outputCollectionName", "Level1TTTracksSelected");
   {
     edm::ParameterSetDescription descCutSet;
     descCutSet.add<double>("ptMin", 2.0)->setComment("pt must be greater than this value, [GeV]");
     descCutSet.add<double>("absEtaMax", 2.4)->setComment("absolute value of eta must be less than this value");
     descCutSet.add<double>("absZ0Max", 15.0)->setComment("z0 must be less than this value, [cm]");
     descCutSet.add<int>("nStubsMin", 4)->setComment("number of stubs must be greater than or equal to this value");
     descCutSet.add<int>("nPSStubsMin", 0)
         ->setComment("number of stubs in the PS Modules must be greater than or equal to this value");
 
     descCutSet.add<double>("reducedBendChi2Max", 2.25)->setComment("bend chi2 must be less than this value");
     descCutSet.add<double>("reducedChi2RZMax", 5.0)->setComment("chi2rz/dof must be less than this value");
     descCutSet.add<double>("reducedChi2RPhiMax", 20.0)->setComment("chi2rphi/dof must be less than this value");
 
     descCutSet.add<std::vector<double>>("deltaZMaxEtaBounds", {0.0, 0.7, 1.0, 1.2, 1.6, 2.0, 2.4})
         ->setComment("these values define the bin boundaries in |eta|");
     descCutSet.add<std::vector<double>>("deltaZMax", {0.37, 0.50, 0.60, 0.75, 1.00, 1.60})
         ->setComment(
             "delta z must be less than these values, there will be one less value here than in deltaZMaxEtaBounds, "
             "[cm]");
     desc.add<edm::ParameterSetDescription>("cutSet", descCutSet);
   }
   desc.add<double>("useDisplacedTracksDeltaZOverride", -1.0)
       ->setComment("override the deltaZ cut value for displaced tracks");
   desc.add<bool>("processSimulatedTracks", true)
       ->setComment("return selected tracks after cutting on the floating point values");
   desc.add<bool>("processEmulatedTracks", true)
       ->setComment("return selected tracks after cutting on the bitwise emulated values");
   desc.add<int>("debug", 0)->setComment("Verbosity levels: 0, 1, 2, 3");
   descriptions.addWithDefaultLabel(desc);
 }

◆ printDebugInfo()

void L1TrackSelectionProducer::printDebugInfo	(	const TTTrackCollectionHandle &	l1TracksHandle,
		const TTTrackRefCollectionUPtr &	vTTTrackOutput,
		const TTTrackRefCollectionUPtr &	vTTTrackEmulationOutput,
		const TTTrackRefCollectionUPtr &	vTTTrackAssociatedOutput,
		const TTTrackRefCollectionUPtr &	vTTTrackAssociatedEmulationOutput
	)		const

private

Definition at line 389 of file L1TrackSelectionProducer.cc.

References debug_, dqm-mbProfile::log, printTrackInfo(), processEmulatedTracks_, processSimulatedTracks_, DBoxMetadataHelper::set_difference(), and HLT_2022v15_cff::track.

Referenced by produce().

                                                                                                                        {
   edm::LogInfo log("L1TrackSelectionProducer");
   log << "The original track collection (pt, eta, phi, nstub, bendchi2, chi2rz, chi2rphi, z0) values are ... \n";
   for (const auto& track : *l1TracksHandle) {
     printTrackInfo(log, track, debug_ >= 4);
   }
   log << "\t---\n\tNumber of tracks in this selection = " << l1TracksHandle->size() << "\n\n";
   if (processSimulatedTracks_) {
     log << "The selected track collection (pt, eta, phi, nstub, bendchi2, chi2rz, chi2rphi, z0) values are ... \n";
     for (const auto& track : *vTTTrackOutput) {
       printTrackInfo(log, *track, debug_ >= 4);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << vTTTrackOutput->size() << "\n\n";
   }
   if (processEmulatedTracks_) {
     log << "The emulation selected track collection (pt, eta, phi, nstub, bendchi2, chi2rz, chi2rphi, z0) values are "
            "... \n";
     for (const auto& track : *vTTTrackEmulationOutput) {
       printTrackInfo(log, *track, debug_ >= 4);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << vTTTrackEmulationOutput->size() << "\n\n";
   }
   if (processSimulatedTracks_ && processEmulatedTracks_) {
     TTTrackRefCollection inSimButNotEmu;
     TTTrackRefCollection inEmuButNotSim;
     std::set_difference(vTTTrackOutput->begin(),
                         vTTTrackOutput->end(),
                         vTTTrackEmulationOutput->begin(),
                         vTTTrackEmulationOutput->end(),
                         std::back_inserter(inSimButNotEmu));
     std::set_difference(vTTTrackEmulationOutput->begin(),
                         vTTTrackEmulationOutput->end(),
                         vTTTrackOutput->begin(),
                         vTTTrackOutput->end(),
                         std::back_inserter(inEmuButNotSim));
     log << "The set of tracks selected via cuts on the simulated values which are not in the set of tracks selected "
            "by cutting on the emulated values ... \n";
     for (const auto& track : inSimButNotEmu) {
       printTrackInfo(log, *track, debug_ >= 3);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << inSimButNotEmu.size() << "\n\n"
         << "The set of tracks selected via cuts on the emulated values which are not in the set of tracks selected "
            "by cutting on the simulated values ... \n";
     for (const auto& track : inEmuButNotSim) {
       printTrackInfo(log, *track, debug_ >= 3);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << inEmuButNotSim.size() << "\n\n";
   }
   if (processSimulatedTracks_) {
     log << "The selected and leading vertex associated track collection (pt, eta, phi, nstub, bendchi2, chi2rz, "
            "chi2rphi, z0) values are ... \n";
     for (const auto& track : *vTTTrackAssociatedOutput) {
       printTrackInfo(log, *track, debug_ >= 4);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << vTTTrackAssociatedOutput->size() << "\n\n";
   }
   if (processEmulatedTracks_) {
     log << "The emulation selected and leading vertex associated track collection (pt, eta, phi, nstub, bendchi2, "
            "chi2rz, chi2rphi, z0) values are "
            "... \n";
     for (const auto& track : *vTTTrackAssociatedEmulationOutput) {
       printTrackInfo(log, *track, debug_ >= 4);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << vTTTrackAssociatedEmulationOutput->size() << "\n\n";
   }
   if (processSimulatedTracks_ && processEmulatedTracks_) {
     TTTrackRefCollection inSimButNotEmu;
     TTTrackRefCollection inEmuButNotSim;
     std::set_difference(vTTTrackAssociatedOutput->begin(),
                         vTTTrackAssociatedOutput->end(),
                         vTTTrackAssociatedEmulationOutput->begin(),
                         vTTTrackAssociatedEmulationOutput->end(),
                         std::back_inserter(inSimButNotEmu));
     std::set_difference(vTTTrackAssociatedEmulationOutput->begin(),
                         vTTTrackAssociatedEmulationOutput->end(),
                         vTTTrackAssociatedOutput->begin(),
                         vTTTrackAssociatedOutput->end(),
                         std::back_inserter(inEmuButNotSim));
     log << "The set of tracks selected via cuts on the simulated values which are not in the set of tracks selected "
            "by cutting on the emulated values ... \n";
     for (const auto& track : inSimButNotEmu) {
       printTrackInfo(log, *track, debug_ >= 3);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << inSimButNotEmu.size() << "\n\n"
         << "The set of tracks selected via cuts on the emulated values which are not in the set of tracks selected "
            "by cutting on the simulated values ... \n";
     for (const auto& track : inEmuButNotSim) {
       printTrackInfo(log, *track, debug_ >= 3);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << inEmuButNotSim.size() << "\n\n";
   }
 }

◆ printTrackInfo()

void L1TrackSelectionProducer::printTrackInfo	(	edm::LogInfo &	log,
		const L1Track &	track,
		bool	printEmulation = `false`
	)		const

private

Definition at line 486 of file L1TrackSelectionProducer.cc.

References dqm-mbProfile::log, and HLT_2022v15_cff::track.

Referenced by printDebugInfo().

                                                                                                               {
   log << "\t(" << track.momentum().perp() << ", " << track.momentum().eta() << ", " << track.momentum().phi() << ", "
       << track.getStubRefs().size() << ", " << track.stubPtConsistency() << ", " << track.chi2ZRed() << ", "
       << track.chi2XYRed() << ", " << track.z0() << ")\n";
 
   if (printEmulation) {
     ap_uint<TrackBitWidths::kPtSize> ptEmulationBits = track.getTrackWord()(
         TTTrack_TrackWord::TrackBitLocations::kRinvMSB - 1, TTTrack_TrackWord::TrackBitLocations::kRinvLSB);
     ap_ufixed<TrackBitWidths::kPtSize, TrackBitWidths::kPtMagSize> ptEmulation;
     ptEmulation.V = ptEmulationBits.range();
     TTTrack_TrackWord::tanl_t etaEmulationBits = track.getTanlWord();
     ap_fixed<TrackBitWidths::kEtaSize, TrackBitWidths::kEtaMagSize> etaEmulation;
     etaEmulation.V = etaEmulationBits.range();
     log << "\t\t(" << ptEmulation.to_double() << ", " << etaEmulation.to_double() << ", " << track.getPhi() << ", "
         << track.getNStubs() << ", " << track.getBendChi2() << ", " << track.getChi2RZ() << ", " << track.getChi2RPhi()
         << ", " << track.getZ0() << ")\n";
   }
 }

◆ produce()

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

overrideprivatevirtual

Implements edm::global::EDProducerBase.

Definition at line 506 of file L1TrackSelectionProducer.cc.

References absEtaMax_, absZ0Max_, bendChi2Max_, debug_, deltaZMax_, deltaZMaxEtaBounds_, doDeltaZCutEmu_, doDeltaZCutSim_, edm::EventSetup::getData(), mps_fire::i, iEvent, l1TracksToken_, l1VerticesEmulationToken_, l1VerticesToken_, eostools::move(), nPSStubsMin_, nStubsMin_, outputCollectionName_, printDebugInfo(), processEmulatedTracks_, processSimulatedTracks_, ptMin_, reducedChi2RPhiMax_, reducedChi2RZMax_, HLT_2022v15_cff::track, tTopoToken_, l1t::Vertex::z0(), and l1t::VertexWord::z0().

                                                                                                        {
   auto vTTTrackOutput = std::make_unique<TTTrackRefCollection>();
   auto vTTTrackAssociatedOutput = std::make_unique<TTTrackRefCollection>();
   auto vTTTrackEmulationOutput = std::make_unique<TTTrackRefCollection>();
   auto vTTTrackAssociatedEmulationOutput = std::make_unique<TTTrackRefCollection>();
 
   // Tracker Topology
   const TrackerTopology& tTopo = iSetup.getData(tTopoToken_);
 
   TTTrackCollectionHandle l1TracksHandle;
   edm::Handle<l1t::VertexCollection> l1VerticesHandle;
   edm::Handle<l1t::VertexWordCollection> l1VerticesEmulationHandle;
 
   l1t::Vertex leadingVertex;
   l1t::VertexWord leadingEmulationVertex;
 
   iEvent.getByToken(l1TracksToken_, l1TracksHandle);
   size_t nOutputApproximate = l1TracksHandle->size();
   if (processSimulatedTracks_) {
     if (doDeltaZCutSim_) {
       iEvent.getByToken(l1VerticesToken_, l1VerticesHandle);
       leadingVertex = l1VerticesHandle->at(0);
       if (debug_ >= 2) {
         edm::LogInfo("L1TrackSelectionProducer") << "leading vertex z0 = " << leadingVertex.z0();
       }
     }
     vTTTrackOutput->reserve(nOutputApproximate);
     vTTTrackAssociatedOutput->reserve(nOutputApproximate);
   }
   if (processEmulatedTracks_) {
     if (doDeltaZCutEmu_) {
       iEvent.getByToken(l1VerticesEmulationToken_, l1VerticesEmulationHandle);
       leadingEmulationVertex = l1VerticesEmulationHandle->at(0);
       if (debug_ >= 2) {
         edm::LogInfo("L1TrackSelectionProducer") << "leading emulation vertex z0 = " << leadingEmulationVertex.z0();
       }
     }
     vTTTrackEmulationOutput->reserve(nOutputApproximate);
     vTTTrackAssociatedEmulationOutput->reserve(nOutputApproximate);
   }
 
   TTTrackPtMinEtaMaxZ0MaxNStubsMinSelector kinSel(ptMin_, absEtaMax_, absZ0Max_, nStubsMin_);
   TTTrackWordPtMinEtaMaxZ0MaxNStubsMinSelector kinSelEmu(ptMin_, absEtaMax_, absZ0Max_, nStubsMin_);
   TTTrackBendChi2Chi2RZChi2RPhiMaxSelector chi2Sel(bendChi2Max_, reducedChi2RZMax_, reducedChi2RPhiMax_);
   TTTrackWordBendChi2Chi2RZChi2RPhiMaxSelector chi2SelEmu(bendChi2Max_, reducedChi2RZMax_, reducedChi2RPhiMax_);
   TTTrackDeltaZMaxSelector deltaZSel(deltaZMaxEtaBounds_, deltaZMax_);
   TTTrackWordDeltaZMaxSelector deltaZSelEmu(deltaZMaxEtaBounds_, deltaZMax_);
   TTTrackNPSStubsMinSelector nPSStubsSel(nPSStubsMin_, tTopo);
 
   for (size_t i = 0; i < nOutputApproximate; i++) {
     const auto& track = l1TracksHandle->at(i);
 
     // Select tracks based on the floating point TTTrack
     if (processSimulatedTracks_ && kinSel(track) && nPSStubsSel(track) && chi2Sel(track)) {
       vTTTrackOutput->push_back(TTTrackRef(l1TracksHandle, i));
       if (doDeltaZCutSim_ && deltaZSel(track, leadingVertex)) {
         vTTTrackAssociatedOutput->push_back(TTTrackRef(l1TracksHandle, i));
       }
     }
 
     // Select tracks based on the bitwise accurate TTTrack_TrackWord
     if (processEmulatedTracks_ && kinSelEmu(track) && chi2SelEmu(track)) {
       vTTTrackEmulationOutput->push_back(TTTrackRef(l1TracksHandle, i));
       if (doDeltaZCutEmu_ && deltaZSelEmu(track, leadingEmulationVertex)) {
         vTTTrackAssociatedEmulationOutput->push_back(TTTrackRef(l1TracksHandle, i));
       }
     }
   }
 
   if (debug_ >= 2) {
     printDebugInfo(l1TracksHandle,
                    vTTTrackOutput,
                    vTTTrackEmulationOutput,
                    vTTTrackAssociatedOutput,
                    vTTTrackAssociatedEmulationOutput);
   }
 
   // Put the outputs into the event
   if (processSimulatedTracks_) {
     iEvent.put(std::move(vTTTrackOutput), outputCollectionName_);
     if (doDeltaZCutSim_) {
       iEvent.put(std::move(vTTTrackAssociatedOutput), outputCollectionName_ + "Associated");
     }
   }
   if (processEmulatedTracks_) {
     iEvent.put(std::move(vTTTrackEmulationOutput), outputCollectionName_ + "Emulation");
     if (doDeltaZCutEmu_) {
       iEvent.put(std::move(vTTTrackAssociatedEmulationOutput), outputCollectionName_ + "AssociatedEmulation");
     }
   }
 }