#include <L1TrackQuality.h>

Public Types
enum	QualityAlgorithm { QualityAlgorithm::Cut, QualityAlgorithm::GBDT, QualityAlgorithm::GBDT_cpp, QualityAlgorithm::NN, QualityAlgorithm::None }

Public Member Functions
std::vector< float >	featureTransform (TTTrack< Ref_Phase2TrackerDigi_ > &aTrack, std::vector< std::string > const &featureNames)

	L1TrackQuality ()

	L1TrackQuality (const edm::ParameterSet &qualityParams)

float	runEmulatedTQ (std::vector< ap_fixed< 10, 5 >> inputFeatures)

void	setBonusFeatures (std::vector< float > bonusFeatures)

void	setCutParameters (std::string const &AlgorithmString, float maxZ0, float maxEta, float chi2dofMax, float bendchi2Max, float minPt, int nStubmin)

void	setL1TrackQuality (TTTrack< Ref_Phase2TrackerDigi_ > &aTrack)

void	setONNXModel (std::string const &AlgorithmString, edm::FileInPath const &ONNXmodel, std::string const &ONNXInputName, std::vector< std::string > const &featureNames)

	~L1TrackQuality ()=default

Private Attributes
float	bendchi2Max_

std::vector< float >	bonusFeatures_

float	chi2dofMax_

std::vector< std::string >	featureNames_

float	maxEta_

float	maxZ0_

float	minPt_

int	nStubsmin_

std::string	ONNXInputName_

edm::FileInPath	ONNXmodel_

QualityAlgorithm	qualityAlgorithm_ = QualityAlgorithm::None

std::unique_ptr< cms::Ort::ONNXRuntime >	runTime_

bool	useHPH_

Detailed Description

Definition at line 29 of file L1TrackQuality.h.

Member Enumeration Documentation

◆ QualityAlgorithm

enum L1TrackQuality::QualityAlgorithm

strong

Enumerator
Cut
GBDT
GBDT_cpp
NN
None

Definition at line 32 of file L1TrackQuality.h.

32 { Cut, GBDT, GBDT_cpp, NN, None };

mkfit::NN

constexpr Matriplex::idx_t NN

Definition: Matrix.h:43

None

Definition: APVGainStruct.h:57

Constructor & Destructor Documentation

◆ L1TrackQuality() [1/2]

L1TrackQuality::L1TrackQuality ( )

Definition at line 10 of file L1TrackQuality.cc.

10 {}

◆ L1TrackQuality() [2/2]

L1TrackQuality::L1TrackQuality ( const edm::ParameterSet & qualityParams )

Definition at line 12 of file L1TrackQuality.cc.

References edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), ONNXmodel_, runTime_, setCutParameters(), setONNXModel(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                    : useHPH_(false), bonusFeatures_() {
   std::string AlgorithmString = qualityParams.getParameter<std::string>("qualityAlgorithm");
   // Unpacks EDM parameter set itself to save unecessary processing within TrackProducers
   if (AlgorithmString == "Cut") {
     setCutParameters(AlgorithmString,
                      (float)qualityParams.getParameter<double>("maxZ0"),
                      (float)qualityParams.getParameter<double>("maxEta"),
                      (float)qualityParams.getParameter<double>("chi2dofMax"),
                      (float)qualityParams.getParameter<double>("bendchi2Max"),
                      (float)qualityParams.getParameter<double>("minPt"),
                      qualityParams.getParameter<int>("nStubsmin"));
   }
 
   else {
     setONNXModel(AlgorithmString,
                  qualityParams.getParameter<edm::FileInPath>("ONNXmodel"),
                  qualityParams.getParameter<std::string>("ONNXInputName"),
                  qualityParams.getParameter<std::vector<std::string>>("featureNames"));
     if ((AlgorithmString == "GBDT") || (AlgorithmString == "NN"))
       runTime_ = std::make_unique<cms::Ort::ONNXRuntime>(this->ONNXmodel_.fullPath());
   }
 }

◆ ~L1TrackQuality()

L1TrackQuality::~L1TrackQuality ( )

default

Member Function Documentation

◆ featureTransform()

std::vector< float > L1TrackQuality::featureTransform	(	TTTrack< Ref_Phase2TrackerDigi_ > &	aTrack,
		std::vector< std::string > const &	featureNames
	)

Definition at line 35 of file L1TrackQuality.cc.

References funct::abs(), TTTrack< T >::eta(), TrackQualityParams_cfi::featureNames, nano_mu_digi_cff::float, TTTrack_TrackWord::getBendChi2Bits(), TTTrack_TrackWord::getChi2RPhiBits(), TTTrack_TrackWord::getChi2RZBits(), TTTrack< T >::getStubRefs(), TTTrack< T >::hitPattern(), mps_fire::i, TTTrack_TrackWord::minZ0, TTTrack< T >::phi(), cmsswSequenceInfo::seq, AlCaHLTBitMon_QueryRunRegistry::string, TTTrack< T >::tanL(), and TTTrack< T >::z0().

Referenced by setL1TrackQuality().

                                                                                               {
   // List input features for MVA in proper order below, the current features options are
   // {"phi", "eta", "z0", "bendchi2_bin", "nstub", "nlaymiss_interior", "chi2rphi_bin",
   // "chi2rz_bin"}
   //
   // To use more features, they must be created here and added to feature_map below
 
   std::vector<float> transformedFeatures;
 
   // Define feature map, filled as features are generated
   std::map<std::string, float> feature_map;
 
   // -------- calculate feature variables --------
 
   // calculate number of missed interior layers from hitpattern
   int tmp_trk_hitpattern = aTrack.hitPattern();
   int nbits = floor(log2(tmp_trk_hitpattern)) + 1;
   int lay_i = 0;
   int tmp_trk_nlaymiss_interior = 0;
   bool seq = false;
   for (int i = 0; i < nbits; i++) {
     lay_i = ((1 << i) & tmp_trk_hitpattern) >> i;  //0 or 1 in ith bit (right to left)
 
     if (lay_i && !seq)
       seq = true;  //sequence starts when first 1 found
     if (!lay_i && seq)
       tmp_trk_nlaymiss_interior++;
   }
 
   // binned chi2 variables
   int tmp_trk_bendchi2_bin = aTrack.getBendChi2Bits();
   int tmp_trk_chi2rphi_bin = aTrack.getChi2RPhiBits();
   int tmp_trk_chi2rz_bin = aTrack.getChi2RZBits();
 
   // get the nstub
   std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>> stubRefs =
       aTrack.getStubRefs();
   int tmp_trk_nstub = stubRefs.size();
 
   // get other variables directly from TTTrack
   float tmp_trk_z0 = aTrack.z0();
   float tmp_trk_z0_scaled = tmp_trk_z0 / abs(aTrack.minZ0);
   float tmp_trk_phi = aTrack.phi();
   float tmp_trk_eta = aTrack.eta();
   float tmp_trk_tanl = aTrack.tanL();
 
   // -------- fill the feature map ---------
 
   feature_map["nstub"] = float(tmp_trk_nstub);
   feature_map["z0"] = tmp_trk_z0;
   feature_map["z0_scaled"] = tmp_trk_z0_scaled;
   feature_map["phi"] = tmp_trk_phi;
   feature_map["eta"] = tmp_trk_eta;
   feature_map["nlaymiss_interior"] = float(tmp_trk_nlaymiss_interior);
   feature_map["bendchi2_bin"] = tmp_trk_bendchi2_bin;
   feature_map["chi2rphi_bin"] = tmp_trk_chi2rphi_bin;
   feature_map["chi2rz_bin"] = tmp_trk_chi2rz_bin;
   feature_map["tanl"] = tmp_trk_tanl;
 
   // fill tensor with track params
   transformedFeatures.reserve(featureNames.size());
   for (const std::string& feature : featureNames)
     transformedFeatures.push_back(feature_map[feature]);
 
   return transformedFeatures;
 }

◆ runEmulatedTQ()

float L1TrackQuality::runEmulatedTQ ( std::vector< ap_fixed< 10, 5 >> inputFeatures )

Definition at line 173 of file L1TrackQuality.cc.

References edm::FileInPath::fullPath(), and ONNXmodel_.

                                                                             {
   // load in bdt
 
   conifer::BDT<ap_fixed<10, 5>, ap_fixed<10, 5>> bdt(this->ONNXmodel_.fullPath());
 
   // collect features and classify using bdt
   std::vector<ap_fixed<10, 5>> output = bdt.decision_function(inputFeatures);
   return output.at(0).to_float();  // need logistic sigmoid fcn applied to xgb output
 }

◆ setBonusFeatures()

void L1TrackQuality::setBonusFeatures ( std::vector< float > bonusFeatures )

Definition at line 218 of file L1TrackQuality.cc.

References bonusFeatures_, and useHPH_.

                                                                     {
   bonusFeatures_ = bonusFeatures;
   useHPH_ = true;
 }

◆ setCutParameters()

void L1TrackQuality::setCutParameters	(	std::string const &	AlgorithmString,
		float	maxZ0,
		float	maxEta,
		float	chi2dofMax,
		float	bendchi2Max,
		float	minPt,
		int	nStubmin
	)

Definition at line 183 of file L1TrackQuality.cc.

References L1TPhase2Offline_cfi::bendchi2Max, bendchi2Max_, L1TPhase2Offline_cfi::chi2dofMax, chi2dofMax_, Cut, razorScouting_cff::maxEta, maxEta_, L1TPhase2Offline_cfi::maxZ0, maxZ0_, PV_cfg::minPt, minPt_, nStubsmin_, and qualityAlgorithm_.

Referenced by L1TrackQuality().

                                                     {
   qualityAlgorithm_ = QualityAlgorithm::Cut;
   maxZ0_ = maxZ0;
   maxEta_ = maxEta;
   chi2dofMax_ = chi2dofMax;
   bendchi2Max_ = bendchi2Max;
   minPt_ = minPt;
   nStubsmin_ = nStubmin;
 }

◆ setL1TrackQuality()

void L1TrackQuality::setL1TrackQuality ( TTTrack< Ref_Phase2TrackerDigi_ > & aTrack )

Definition at line 103 of file L1TrackQuality.cc.

References funct::abs(), bendchi2Max_, TTTrack< T >::chi2(), chi2dofMax_, Cut, PV3DBase< T, PVType, FrameType >::eta(), JetChargeProducer_cfi::exp, featureNames_, featureTransform(), edm::FileInPath::fullPath(), GBDT, GBDT_cpp, TTTrack< T >::getStubRefs(), PixelMapPlotter::inputs, maxEta_, maxZ0_, minPt_, TTTrack< T >::momentum(), NN, nStubsmin_, ONNXInputName_, ONNXmodel_, PV3DBase< T, PVType, FrameType >::perp(), qualityAlgorithm_, runTime_, TTTrack< T >::settrkMVA1(), TTTrack< T >::stubPtConsistency(), run3scouting_cff::trk_chi2, run3scouting_cff::trk_eta, run3scouting_cff::trk_pt, and TTTrack< T >::z0().

                                                                               {
   if (this->qualityAlgorithm_ == QualityAlgorithm::Cut) {
     // Get Track parameters
     float trk_pt = aTrack.momentum().perp();
     float trk_bend_chi2 = aTrack.stubPtConsistency();
     float trk_z0 = aTrack.z0();
     float trk_eta = aTrack.momentum().eta();
     float trk_chi2 = aTrack.chi2();
     const auto& stubRefs = aTrack.getStubRefs();
     int nStubs = stubRefs.size();
 
     float classification = 0.0;  // Default classification is 0
 
     if (trk_pt >= this->minPt_ && abs(trk_z0) < this->maxZ0_ && abs(trk_eta) < this->maxEta_ &&
         trk_chi2 < this->chi2dofMax_ && trk_bend_chi2 < this->bendchi2Max_ && nStubs >= this->nStubsmin_)
       classification = 1.0;
     // Classification updated to 1 if conditions are met
 
     aTrack.settrkMVA1(classification);
   }
 
   else if (this->qualityAlgorithm_ == QualityAlgorithm::GBDT_cpp) {
     // load in bdt
     conifer::BDT<float, float> bdt(this->ONNXmodel_.fullPath());
 
     // collect features and classify using bdt
     std::vector<float> inputs = featureTransform(aTrack, this->featureNames_);
     std::vector<float> output = bdt.decision_function(inputs);
     aTrack.settrkMVA1(1. / (1. + exp(-output.at(0))));  // need logistic sigmoid fcn applied to xgb output
   }
 
   else if ((this->qualityAlgorithm_ == QualityAlgorithm::NN) || (this->qualityAlgorithm_ == QualityAlgorithm::GBDT)) {
     // Setup ONNX input and output names and arrays
     std::vector<std::string> ortinput_names;
     std::vector<std::string> ortoutput_names;
 
     cms::Ort::FloatArrays ortinput;
     cms::Ort::FloatArrays ortoutputs;
 
     std::vector<float> Transformed_features = featureTransform(aTrack, this->featureNames_);
     //    cms::Ort::ONNXRuntime runTime(this->ONNXmodel_.fullPath());  //Setup ONNX runtime
 
     ortinput_names.push_back(this->ONNXInputName_);
     ortoutput_names = runTime_->getOutputNames();
 
     //ONNX runtime recieves a vector of vectors of floats so push back the input
     // vector of float to create a 1,1,21 ortinput
     ortinput.push_back(Transformed_features);
 
     // batch_size 1 as only one set of transformed features is being processed
     int batch_size = 1;
     // Run classification
     ortoutputs = runTime_->run(ortinput_names, ortinput, {}, ortoutput_names, batch_size);
 
     if (this->qualityAlgorithm_ == QualityAlgorithm::NN) {
       aTrack.settrkMVA1(ortoutputs[0][0]);
     }
 
     else if (this->qualityAlgorithm_ == QualityAlgorithm::GBDT) {
       aTrack.settrkMVA1(ortoutputs[1][1]);
     }
     // Slight differences in the ONNX models of the GBDTs and NNs mean different
     // indices of the ortoutput need to be accessed
   }
 
   else {
     aTrack.settrkMVA1(-999);
   }
 }

◆ setONNXModel()

void L1TrackQuality::setONNXModel	(	std::string const &	AlgorithmString,
		edm::FileInPath const &	ONNXmodel,
		std::string const &	ONNXInputName,
		std::vector< std::string > const &	featureNames
	)

Definition at line 199 of file L1TrackQuality.cc.

References TrackQualityParams_cfi::featureNames, featureNames_, GBDT, GBDT_cpp, NN, None, TrackQualityParams_cfi::ONNXInputName, ONNXInputName_, TrackQualityParams_cfi::ONNXmodel, ONNXmodel_, and qualityAlgorithm_.

Referenced by L1TrackQuality().

                                                                             {
   //Convert algorithm string to Enum class for track by track comparison
   if (AlgorithmString == "NN") {
     qualityAlgorithm_ = QualityAlgorithm::NN;
   } else if (AlgorithmString == "GBDT") {
     qualityAlgorithm_ = QualityAlgorithm::GBDT;
   } else if (AlgorithmString == "GBDT_cpp") {
     qualityAlgorithm_ = QualityAlgorithm::GBDT_cpp;
   } else {
     qualityAlgorithm_ = QualityAlgorithm::None;
   }
   ONNXmodel_ = ONNXmodel;
   ONNXInputName_ = ONNXInputName;
   featureNames_ = featureNames;
 }