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

Inheritance diagram for L1TrackVertexAssociationProducer:

Classes
struct	NNTrackWordSelector

struct	TTTrackDeltaZMaxSelector

struct	TTTrackWordDeltaZMaxSelector

struct	TTTrackWordLinkLimitSelector

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

	~L1TrackVertexAssociationProducer () 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 noexcept final

bool	wantsGlobalRuns () const noexcept final

bool	wantsInputProcessBlocks () const noexcept final

bool	wantsProcessBlocks () const noexcept final

bool	wantsStreamLuminosityBlocks () const noexcept final

bool	wantsStreamRuns () const noexcept 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

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

std::vector< ESResolverIndex > 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

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProductResolverIndices 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
enum	TrackBitWidths { kPtSize = TTTrack_TrackWord::TrackBitWidths::kRinvSize - 1, kPtMagSize = 9, kEtaSize = TTTrack_TrackWord::TrackBitWidths::kTanlSize, kEtaMagSize = 3 }

typedef edm::Handle< TTTrackCollectionType >	TTTrackCollectionHandle

typedef std::vector< TTTrackType >	TTTrackCollectionType

typedef edm::RefVector< TTTrackCollectionType >	TTTrackRefCollectionType

typedef std::unique_ptr< TTTrackRefCollectionType >	TTTrackRefCollectionUPtr

typedef TTTrack< Ref_Phase2TrackerDigi_ >	TTTrackType

Private Member Functions
void	printDebugInfo (const edm::Handle< TTTrackRefCollectionType > &l1SelectedTracksHandle, const edm::Handle< TTTrackRefCollectionType > &l1SelectedTracksEmulationHandle, const TTTrackRefCollectionUPtr &vTTTrackAssociatedOutput, const TTTrackRefCollectionUPtr &vTTTrackAssociatedEmulationOutput) const

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

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

Private Attributes
tensorflow::GraphDef *	associationGraph_

edm::FileInPath	associationGraphPath_

std::vector< double >	associationNetworkEtaBounds_

std::vector< double >	associationNetworkZ0binning_

std::vector< double >	associationNetworkZ0ResBins_

tensorflow::Session *	associationSesh_

const double	associationThreshold_

const edm::ParameterSet	cutSet_

int	debug_

std::vector< double >	deltaZMax_

std::vector< double >	deltaZMaxEtaBounds_

const unsigned int	fwNTrackSetsTVA_

const edm::EDGetTokenT< TTTrackRefCollectionType >	l1SelectedTracksEmulationToken_

const edm::EDGetTokenT< TTTrackRefCollectionType >	l1SelectedTracksToken_

const edm::EDGetTokenT< TTTrackCollectionType >	l1TracksToken_

const edm::EDGetTokenT< l1t::VertexWordCollection >	l1VerticesEmulationToken_

const edm::EDGetTokenT< l1t::VertexCollection >	l1VerticesToken_

const std::string	outputCollectionName_

const bool	processEmulatedTracks_

const bool	processSimulatedTracks_

bool	useAssociationNetwork_

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 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<TTTrackRef> - A collection of TTTrack Refs selected from cuts on the TTTrack properties std::vector<TTTrackRef> - A collection of TTTrack Refs selected from cuts on the TTTrack_TrackWord properties

Definition at line 73 of file L1TrackVertexAssociationProducer.cc.

Member Typedef Documentation

◆ TTTrackCollectionHandle

typedef edm::Handle<TTTrackCollectionType> L1TrackVertexAssociationProducer::TTTrackCollectionHandle

private

Definition at line 92 of file L1TrackVertexAssociationProducer.cc.

◆ TTTrackCollectionType

typedef std::vector<TTTrackType> L1TrackVertexAssociationProducer::TTTrackCollectionType

private

Definition at line 91 of file L1TrackVertexAssociationProducer.cc.

◆ TTTrackRefCollectionType

typedef edm::RefVector<TTTrackCollectionType> L1TrackVertexAssociationProducer::TTTrackRefCollectionType

private

Definition at line 93 of file L1TrackVertexAssociationProducer.cc.

◆ TTTrackRefCollectionUPtr

typedef std::unique_ptr<TTTrackRefCollectionType> L1TrackVertexAssociationProducer::TTTrackRefCollectionUPtr

private

Definition at line 94 of file L1TrackVertexAssociationProducer.cc.

◆ TTTrackType

typedef TTTrack<Ref_Phase2TrackerDigi_> L1TrackVertexAssociationProducer::TTTrackType

private

Definition at line 90 of file L1TrackVertexAssociationProducer.cc.

Member Enumeration Documentation

◆ TrackBitWidths

enum L1TrackVertexAssociationProducer::TrackBitWidths

private

Enumerator
kPtSize
kPtMagSize
kEtaSize
kEtaMagSize

Definition at line 83 of file L1TrackVertexAssociationProducer.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

◆ L1TrackVertexAssociationProducer()

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

explicit

Definition at line 299 of file L1TrackVertexAssociationProducer.cc.

References associationGraph_, associationGraphPath_, associationSesh_, tensorflow::createSession(), deltaZMax_, deltaZMaxEtaBounds_, Exception, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), tensorflow::loadGraphDef(), outputCollectionName_, processEmulatedTracks_, processSimulatedTracks_, useAssociationNetwork_, and useDisplacedTracksDeltaZOverride_.

     : processSimulatedTracks_(iConfig.getParameter<bool>("processSimulatedTracks")),
       processEmulatedTracks_(iConfig.getParameter<bool>("processEmulatedTracks")),
       l1TracksToken_(consumes<TTTrackCollectionType>(iConfig.getParameter<edm::InputTag>("l1TracksInputTag"))),
       l1VerticesToken_(processSimulatedTracks_
                            ? consumes<l1t::VertexCollection>(iConfig.getParameter<edm::InputTag>("l1VerticesInputTag"))
                            : edm::EDGetTokenT<l1t::VertexCollection>()),
       l1SelectedTracksToken_(
           processSimulatedTracks_
               ? consumes<TTTrackRefCollectionType>(iConfig.getParameter<edm::InputTag>("l1SelectedTracksInputTag"))
               : edm::EDGetTokenT<TTTrackRefCollectionType>()),
       l1VerticesEmulationToken_(
           processEmulatedTracks_
               ? consumes<l1t::VertexWordCollection>(iConfig.getParameter<edm::InputTag>("l1VerticesEmulationInputTag"))
               : edm::EDGetTokenT<l1t::VertexWordCollection>()),
       l1SelectedTracksEmulationToken_(processEmulatedTracks_
                                           ? consumes<TTTrackRefCollectionType>(iConfig.getParameter<edm::InputTag>(
                                                 "l1SelectedTracksEmulationInputTag"))
                                           : edm::EDGetTokenT<TTTrackRefCollectionType>()),
       outputCollectionName_(iConfig.getParameter<std::string>("outputCollectionName")),
       cutSet_(iConfig.getParameter<edm::ParameterSet>("cutSet")),
 
       deltaZMaxEtaBounds_(cutSet_.getParameter<std::vector<double>>("deltaZMaxEtaBounds")),
       deltaZMax_(cutSet_.getParameter<std::vector<double>>("deltaZMax")),
       useDisplacedTracksDeltaZOverride_(iConfig.getParameter<double>("useDisplacedTracksDeltaZOverride")),
       fwNTrackSetsTVA_(iConfig.getParameter<unsigned int>("fwNTrackSetsTVA")),
       associationThreshold_(iConfig.getParameter<double>("associationThreshold")),
       useAssociationNetwork_(iConfig.getParameter<bool>("useAssociationNetwork")),
       associationNetworkZ0binning_(iConfig.getParameter<std::vector<double>>("associationNetworkZ0binning")),
       associationNetworkEtaBounds_(iConfig.getParameter<std::vector<double>>("associationNetworkEtaBounds")),
       associationNetworkZ0ResBins_(iConfig.getParameter<std::vector<double>>("associationNetworkZ0ResBins")),
       debug_(iConfig.getParameter<int>("debug")) {
   if (useAssociationNetwork_) {
     associationGraphPath_ = iConfig.getParameter<edm::FileInPath>("associationGraph");
     associationGraph_ = tensorflow::loadGraphDef(associationGraphPath_.fullPath());
     associationSesh_ = tensorflow::createSession(associationGraph_);
   }
   // 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
   if (processSimulatedTracks_)
     produces<TTTrackRefCollectionType>(outputCollectionName_);
   if (processEmulatedTracks_)
     produces<TTTrackRefCollectionType>(outputCollectionName_ + "Emulation");
 }

◆ ~L1TrackVertexAssociationProducer()

L1TrackVertexAssociationProducer::~L1TrackVertexAssociationProducer ( )

override

Definition at line 356 of file L1TrackVertexAssociationProducer.cc.

356 {}

Member Function Documentation

◆ fillDescriptions()

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

static

Definition at line 585 of file L1TrackVertexAssociationProducer.cc.

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

                                                                                                   {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("l1TracksInputTag", edm::InputTag("l1tGTTInputProducer", "Level1TTTracksConverted"));
   desc.add<edm::InputTag>("l1SelectedTracksInputTag",
                           edm::InputTag("l1tTrackSelectionProducer", "Level1TTTracksSelected"));
   desc.add<edm::InputTag>("l1SelectedTracksEmulationInputTag",
                           edm::InputTag("l1tTrackSelectionProducer", "Level1TTTracksSelectedEmulation"));
   desc.add<edm::InputTag>("l1VerticesInputTag", edm::InputTag("l1tVertexFinder", "L1Vertices"));
   desc.add<edm::InputTag>("l1VerticesEmulationInputTag",
                           edm::InputTag("l1tVertexFinderEmulator", "L1VerticesEmulation"));
   desc.add<std::string>("outputCollectionName", "Level1TTTracksSelectedAssociated");
   {
     edm::ParameterSetDescription descCutSet;
     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<unsigned int>("fwNTrackSetsTVA", 94)->setComment("firmware limit on processed tracks per GTT input link");
   desc.add<bool>("useAssociationNetwork", false)->setComment("Enable Association Network");
   desc.add<double>("associationThreshold", 0)->setComment("Association Network threshold for PV tracks");
   desc.addOptional<edm::FileInPath>("associationGraph")->setComment("Location of Association Network model file");
   desc.add<std::vector<double>>("associationNetworkZ0binning", {})
       ->setComment("z0 binning used for setting the input feature digitisation");
   desc.add<std::vector<double>>("associationNetworkEtaBounds", {})
       ->setComment("Eta bounds used to set z0 resolution input feature");
   desc.add<std::vector<double>>("associationNetworkZ0ResBins", {})->setComment("z0 resolution input feature bins");
 
   desc.add<int>("debug", 0)->setComment("Verbosity levels: 0, 1, 2, 3");
   descriptions.addWithDefaultLabel(desc);
 }

◆ printDebugInfo()

void L1TrackVertexAssociationProducer::printDebugInfo	(	const edm::Handle< TTTrackRefCollectionType > &	l1SelectedTracksHandle,
		const edm::Handle< TTTrackRefCollectionType > &	l1SelectedTracksEmulationHandle,
		const TTTrackRefCollectionUPtr &	vTTTrackAssociatedOutput,
		const TTTrackRefCollectionUPtr &	vTTTrackAssociatedEmulationOutput
	)		const

private

Definition at line 362 of file L1TrackVertexAssociationProducer.cc.

References edm::RefVector< C, T, F >::begin(), debug_, edm::RefVector< C, T, F >::end(), CrabHelper::log, printTrackInfo(), processEmulatedTracks_, processSimulatedTracks_, DBoxMetadataHelper::set_difference(), and HLT_2024v14_cff::track.

Referenced by produce().

                                                                              {
   edm::LogInfo log("L1TrackVertexAssociationProducer");
   if (processSimulatedTracks_) {
     log << "The original selected track collection (pt, eta, phi, nstub, bendchi2, chi2rz, chi2rphi, z0) values are "
            "... \n";
     for (const auto& track : *l1SelectedTracksHandle) {
       printTrackInfo(log, *track, debug_ >= 4);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << l1SelectedTracksHandle->size() << "\n\n";
   }
   if (processEmulatedTracks_) {
     log << "The original selected emulated track collection (pt, eta, phi, nstub, bendchi2, chi2rz, chi2rphi, z0) "
            "values are ... \n";
     for (const auto& track : *l1SelectedTracksEmulationHandle) {
       printTrackInfo(log, *track, debug_ >= 4);
     }
     log << "\t---\n\tNumber of tracks in this selection = " << l1SelectedTracksEmulationHandle->size() << "\n\n";
   }
   if (processSimulatedTracks_ && processEmulatedTracks_) {
     TTTrackRefCollectionType inSimButNotEmu;
     TTTrackRefCollectionType inEmuButNotSim;
     std::set_difference(l1SelectedTracksHandle->begin(),
                         l1SelectedTracksHandle->end(),
                         l1SelectedTracksEmulationHandle->begin(),
                         l1SelectedTracksEmulationHandle->end(),
                         std::back_inserter(inSimButNotEmu));
     std::set_difference(l1SelectedTracksEmulationHandle->begin(),
                         l1SelectedTracksEmulationHandle->end(),
                         l1SelectedTracksHandle->begin(),
                         l1SelectedTracksHandle->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_) {
     TTTrackRefCollectionType inSimButNotEmu;
     TTTrackRefCollectionType 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 vertex associated 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 vertex associated 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 L1TrackVertexAssociationProducer::printTrackInfo	(	edm::LogInfo &	log,
		const TTTrackType &	track,
		bool	printEmulation = `false`
	)		const

private

Definition at line 457 of file L1TrackVertexAssociationProducer.cc.

References CrabHelper::log, TTTrack_TrackWord::stepPhi0, TTTrack_TrackWord::stepZ0, and HLT_2024v14_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();
     double floatTkZ0 = track.undigitizeSignedValue(
         track.getZ0Bits(), TTTrack_TrackWord::TrackBitWidths::kZ0Size, TTTrack_TrackWord::stepZ0, 0.0);
     double floatTkPhi = track.undigitizeSignedValue(
         track.getPhiBits(), TTTrack_TrackWord::TrackBitWidths::kPhiSize, TTTrack_TrackWord::stepPhi0, 0.0);
     log << "\t\t(" << ptEmulation.to_double() << ", " << etaEmulation.to_double() << ", " << floatTkPhi << ", "
         << track.getNStubs() << ", " << track.getBendChi2() << ", " << track.getChi2RZ() << ", " << track.getChi2RPhi()
         << ", " << floatTkZ0 << ")\n";
   }
 }

◆ produce()

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

overrideprivatevirtual

Implements edm::global::EDProducerBase.

Definition at line 483 of file L1TrackVertexAssociationProducer.cc.

References associationNetworkEtaBounds_, associationNetworkZ0binning_, associationNetworkZ0ResBins_, associationSesh_, associationThreshold_, edm::RefVector< C, T, F >::begin(), debug_, deltaZMax_, deltaZMaxEtaBounds_, edm::RefVector< C, T, F >::end(), fwNTrackSetsTVA_, mps_fire::i, iEvent, l1SelectedTracksEmulationToken_, l1SelectedTracksToken_, l1TracksToken_, l1VerticesEmulationToken_, l1VerticesToken_, L1TrackVertexAssociationProducer::TTTrackWordLinkLimitSelector::log(), eostools::move(), outputCollectionName_, printDebugInfo(), processEmulatedTracks_, processSimulatedTracks_, HLT_2024v14_cff::track, useAssociationNetwork_, l1t::Vertex::z0(), and l1t::VertexWord::z0().

                                                                                                                {
   auto vTTTrackAssociatedOutput = std::make_unique<TTTrackRefCollectionType>();
   auto vTTTrackAssociatedEmulationOutput = std::make_unique<TTTrackRefCollectionType>();
 
   TTTrackCollectionHandle l1TracksHandle;
   edm::Handle<TTTrackRefCollectionType> l1SelectedTracksHandle;
   edm::Handle<TTTrackRefCollectionType> l1SelectedTracksEmulationHandle;
   edm::Handle<l1t::VertexCollection> l1VerticesHandle;
   edm::Handle<l1t::VertexWordCollection> l1VerticesEmulationHandle;
 
   l1t::Vertex leadingVertex;
   l1t::VertexWord leadingEmulationVertex;
 
   TTTrackWordLinkLimitSelector linkLimitSel(fwNTrackSetsTVA_);     //stateful functor for simulated tracks
   TTTrackWordLinkLimitSelector linkLimitSelEmu(fwNTrackSetsTVA_);  //stateful functor for emulated tracks
 
   TTTrackDeltaZMaxSelector deltaZSel(deltaZMaxEtaBounds_, deltaZMax_);
   TTTrackWordDeltaZMaxSelector deltaZSelEmu(deltaZMaxEtaBounds_, deltaZMax_);
 
   NNTrackWordSelector TTTrackNetworkSelector(associationSesh_,
                                              associationThreshold_,
                                              associationNetworkZ0binning_,
                                              associationNetworkEtaBounds_,
                                              associationNetworkZ0ResBins_);
 
   iEvent.getByToken(l1TracksToken_, l1TracksHandle);
   size_t nOutputApproximate = l1TracksHandle->size();
 
   if (processSimulatedTracks_) {
     iEvent.getByToken(l1SelectedTracksToken_, l1SelectedTracksHandle);
     iEvent.getByToken(l1VerticesToken_, l1VerticesHandle);
     leadingVertex = l1VerticesHandle->at(0);
     if (debug_ >= 2) {
       edm::LogInfo("L1TrackVertexAssociationProducer") << "leading vertex z0 = " << leadingVertex.z0();
     }
     vTTTrackAssociatedOutput->reserve(nOutputApproximate);
   }
   if (processEmulatedTracks_) {
     iEvent.getByToken(l1SelectedTracksEmulationToken_, l1SelectedTracksEmulationHandle);
     iEvent.getByToken(l1VerticesEmulationToken_, l1VerticesEmulationHandle);
     leadingEmulationVertex = l1VerticesEmulationHandle->at(0);
     if (debug_ >= 2) {
       edm::LogInfo("L1TrackVertexAssociationProducer")
           << "leading emulation vertex z0 = " << leadingEmulationVertex.z0();
     }
     vTTTrackAssociatedEmulationOutput->reserve(nOutputApproximate);
   }
   for (size_t i = 0; i < nOutputApproximate; i++) {
     const auto& track = l1TracksHandle->at(i);
     if (processSimulatedTracks_) {
       // Limit the number of processed tracks according to the firmware capability: must be run on non-selected tracks (i.e. GTTConverted tracks)
       bool passLinkLimit = linkLimitSel(track);
       // Only match Selected tracks, by testing that the track is in the SelectedTracks collection
       auto itr = std::find_if(l1SelectedTracksHandle->begin(), l1SelectedTracksHandle->end(), [track](const auto& ref) {
         return (*ref).getTrackWord() == track.getTrackWord();
       });
       bool passSelection = (itr != l1SelectedTracksHandle->end());
       // Associate tracks based on the simulation delta Z
       if (passLinkLimit && passSelection && deltaZSel(track, leadingVertex)) {
         vTTTrackAssociatedOutput->push_back(TTTrackRef(l1TracksHandle, i));
       }
     }  //end if (processSimulatedTracks_)
     if (processEmulatedTracks_) {
       // Limit the number of processed tracks according to the firmware capability: must be run on non-selected tracks (i.e. GTTConverted tracks)
       bool passLinkLimitEmu = linkLimitSelEmu(track);
       // Only match Selected tracks, by testing that the track is in the SelectedTracks collection
       auto itrEmu = std::find_if(l1SelectedTracksEmulationHandle->begin(),
                                  l1SelectedTracksEmulationHandle->end(),
                                  [track](const auto& ref) { return (*ref).getTrackWord() == track.getTrackWord(); });
       bool passSelectionEmu = (itrEmu != l1SelectedTracksEmulationHandle->end());
       // Associated tracks based on the bitwise accurate TTTrack_TrackWord
       if (useAssociationNetwork_) {
         if (passLinkLimitEmu && passSelectionEmu && TTTrackNetworkSelector(track, l1VerticesEmulationHandle->at(0))) {
           vTTTrackAssociatedEmulationOutput->push_back(TTTrackRef(l1TracksHandle, i));
         }
       } else {
         if (passLinkLimitEmu && passSelectionEmu && deltaZSelEmu(track, l1VerticesEmulationHandle->at(0))) {
           vTTTrackAssociatedEmulationOutput->push_back(TTTrackRef(l1TracksHandle, i));
         }  //end block for satisfying LinkLimitEmu and SelectionEmu criteria
       }  //end if use track association NN
     }  //end if (processEmulatedTracks_)
   }  //end loop over input converted tracks
 
   if (processSimulatedTracks_ && processEmulatedTracks_ && debug_ >= 2) {
     printDebugInfo(l1SelectedTracksHandle,
                    l1SelectedTracksEmulationHandle,
                    vTTTrackAssociatedOutput,
                    vTTTrackAssociatedEmulationOutput);
   }
 
   if (processSimulatedTracks_) {
     iEvent.put(std::move(vTTTrackAssociatedOutput), outputCollectionName_);
   }
 
   if (processEmulatedTracks_) {
     iEvent.put(std::move(vTTTrackAssociatedEmulationOutput), outputCollectionName_ + "Emulation");
     if (debug_ >= 2)
       linkLimitSelEmu.log();
   }
 }