l1t::AXOL1TLCondition Class Reference

#include <AXOL1TLCondition.h>

Inheritance diagram for l1t::AXOL1TLCondition:

Public Member Functions
	AXOL1TLCondition ()
	AXOL1TLCondition (const GlobalCondition *, const GlobalBoard *)
	from base template condition (from event setup usually) More...
	AXOL1TLCondition (const AXOL1TLCondition &)
const bool	evaluateCondition (const int bxEval) const override
	the core function to check if the condition matches More...
const AXOL1TLTemplate *	gtAXOL1TLTemplate () const
	get / set the pointer to a Condition More...
const GlobalBoard *	gtGTB () const
	get / set the pointer to GTL More...
AXOL1TLCondition &	operator= (const AXOL1TLCondition &)
void	print (std::ostream &myCout) const override
	print condition More...
void	setGtAXOL1TLTemplate (const AXOL1TLTemplate *)
void	setuGtB (const GlobalBoard *)
	set the pointer to uGT GlobalBoard More...
	~AXOL1TLCondition () override
Public Member Functions inherited from l1t::ConditionEvaluation
	ConditionEvaluation ()
	constructor More...
bool	condLastResult () const
	get the latest result for the condition More...
int	condMaxNumberObjects () const
void	evaluateConditionStoreResult (const int bxEval)
	call evaluateCondition and save last result More...
CombinationsInCond const &	getCombinationsInCond () const
	get all the object combinations evaluated to true in the condition More...
virtual std::string	getNumericExpression () const
	get numeric expression More...
void	setCondMaxNumberObjects (int condMaxNumberObjectsValue)
void	setVerbosity (const int verbosity)
virtual	~ConditionEvaluation ()
	destructor More...

Private Member Functions
void	copy (const AXOL1TLCondition &cp)
	copy function for copy constructor and operator= More...

Private Attributes
const AXOL1TLTemplate *	m_gtAXOL1TLTemplate
	pointer to a AXOL1TLTemplate More...
const GlobalBoard *	m_gtGTB
	pointer to uGt GlobalBoard, to be able to get the trigger objects More...

Additional Inherited Members
Protected Member Functions inherited from l1t::ConditionEvaluation
template<class Type1 >
const bool	checkBit (const Type1 &mask, const unsigned int bitNumber) const
	check if a bit with a given number is set in a mask More...
template<class Type1 , class Type2 >
const bool	checkCut (const Type1 &cutL, const Type2 &value, bool condGEqValue) const
template<class Type1 >
const bool	checkIndex (const Type1 &indexLo, const Type1 &indexHi, const unsigned int index) const
	check if a index is in a given range More...
template<class Type1 >
const bool	checkRangeDeltaEta (const unsigned int obj1Eta, const unsigned int obj2Eta, const Type1 &lowerR, const Type1 &upperR, const unsigned int nEtaBits) const
	check if a value is in a given deltaEta range More...
template<class Type1 >
const bool	checkRangeDeltaPhi (const unsigned int obj1Phi, const unsigned int obj2Phi, const Type1 &lowerR, const Type1 &upperR) const
	check if a value is in a given deltaPhi range More...
template<class Type1 >
const bool	checkRangeEta (const unsigned int bitNumber, const std::vector< Type1 > &windows, const unsigned int nEtaBits) const
template<class Type1 >
const bool	checkRangePhi (const unsigned int bitNumber, const Type1 &W1beginR, const Type1 &W1endR, const Type1 &W2beginR, const Type1 &W2endR) const
	check if a value is in a given phi range and outside of a veto range More...
template<class Type1 >
const bool	checkRangeTfMuonIndex (const unsigned int bitNumber, const std::vector< Type1 > &windows) const
	check if a value is in a given muon track finder index range More...
template<class Type1 , class Type2 >
const bool	checkThreshold (const Type1 &thresholdL, const Type1 &thresholdH, const Type2 &value, bool condGEqValue) const
template<class Type1 , class Type2 >
const bool	checkUnconstrainedPt (const Type1 &thresholdL, const Type1 &thresholdH, const Type2 &value, bool condGEqValue) const
CombinationsInCond &	combinationsInCond () const
	get all the object combinations (to fill it...) More...
Protected Attributes inherited from l1t::ConditionEvaluation
CombinationsInCond	m_combinationsInCond
	store all the object combinations evaluated to true in the condition More...
bool	m_condLastResult
	the last result of evaluateCondition() More...
int	m_condMaxNumberObjects
int	m_verbosity
	verbosity level More...

Detailed Description

Definition at line 29 of file AXOL1TLCondition.h.

Constructor & Destructor Documentation

AXOL1TLCondition() [1/3]

AXOL1TLCondition::AXOL1TLCondition

(

)

constructors default

Definition at line 47 of file AXOL1TLCondition.cc.

                                      : ConditionEvaluation() {
  // empty
}

AXOL1TLCondition() [2/3]

AXOL1TLCondition::AXOL1TLCondition	(	const GlobalCondition *	axol1tlTemplate,
		const GlobalBoard *	ptrGTB
	)

from base template condition (from event setup usually)

Definition at line 52 of file AXOL1TLCondition.cc.

    : ConditionEvaluation(),
      m_gtAXOL1TLTemplate(static_cast<const AXOL1TLTemplate*>(axol1tlTemplate)),
      m_gtGTB(ptrGTB) {}

AXOL1TLCondition() [3/3]

AXOL1TLCondition::AXOL1TLCondition

(

const AXOL1TLCondition &

cp

)

Definition at line 69 of file AXOL1TLCondition.cc.

References copy().

: ConditionEvaluation() { copy(cp); }

~AXOL1TLCondition()

AXOL1TLCondition::~AXOL1TLCondition ( )

override

Definition at line 72 of file AXOL1TLCondition.cc.

                                       {
  // empty
}

Member Function Documentation

copy()

void AXOL1TLCondition::copy ( const AXOL1TLCondition &  cp )

private

copy function for copy constructor and operator=

Definition at line 58 of file AXOL1TLCondition.cc.

Referenced by AXOL1TLCondition().

                                                            {
  m_gtAXOL1TLTemplate = cp.gtAXOL1TLTemplate();
  m_gtGTB = cp.gtGTB();

  m_condMaxNumberObjects = cp.condMaxNumberObjects();
  m_condLastResult = cp.condLastResult();
  m_combinationsInCond = cp.getCombinationsInCond();

  m_verbosity = cp.m_verbosity;
}

evaluateCondition()

const bool AXOL1TLCondition::evaluateCondition ( const int  bxEval ) const

overridevirtual

the core function to check if the condition matches

Implements l1t::ConditionEvaluation.

Definition at line 88 of file AXOL1TLCondition.cc.

References BXVector< T >::at(), MillePedeFileConverter_cfg::e, Exception, ntuplemaker::fill, l1trig_cff::hwEta, l1trig_cff::hwPhi, l1trig_cff::hwPt, L1Analysis::kMissingEt, web.browse_db::loader, AXOL1TLTemplate::ObjectParameter::minAXOL1TLThreshold, ReggeGribovPartonMC_EposLHC_2760GeV_PbPb_cfi::model, mps_fire::result, offlineSlimmedPrimaryVertices_cfi::score, BXVector< T >::size(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                        {
  bool condResult = false;
  int useBx = bxEval + m_gtAXOL1TLTemplate->condRelativeBx();

  //HLS4ML stuff
  std::string AXOL1TLmodelversion = "GTADModel_" + m_gtAXOL1TLTemplate->modelVersion();  //loading from menu/template

  //otherwise load model (if possible) and run inference
  hls4mlEmulator::ModelLoader loader(AXOL1TLmodelversion);
  std::shared_ptr<hls4mlEmulator::Model> model;

  try {
    model = loader.load_model();
  } catch (std::runtime_error& e) {
    // for stopping with exception if model version cannot be loaded
    throw cms::Exception("ModelError")
        << " ERROR: failed to load AXOL1TL model version \"" << AXOL1TLmodelversion
        << "\" that was specified in menu. Model version not found in cms-hls4ml externals.";
  }

  // //pointers to objects
  const BXVector<const l1t::Muon*>* candMuVec = m_gtGTB->getCandL1Mu();
  const BXVector<const l1t::L1Candidate*>* candJetVec = m_gtGTB->getCandL1Jet();
  const BXVector<const l1t::L1Candidate*>* candEGVec = m_gtGTB->getCandL1EG();
  const BXVector<const l1t::EtSum*>* candEtSumVec = m_gtGTB->getCandL1EtSum();

  const int NMuons = 4;
  const int NJets = 10;
  const int NEgammas = 4;
  //const int NEtSums = 1;

  //number of indices in vector is #objects * 3 for et, eta, phi
  const int MuVecSize = 12;    //NMuons * 3;      //so 12
  const int JVecSize = 30;     //NJets * 3;        //so 30
  const int EGVecSize = 12;    //NEgammas * 3;    //so 12
  const int EtSumVecSize = 3;  //NEtSums * 3;    //so 3

  //total # inputs in vector is (4+10+4+1)*3 = 57
  const int NInputs = 57;

  //types of inputs and outputs
  typedef ap_fixed<18, 13> inputtype;
  typedef std::array<ap_fixed<10, 7, AP_RND_CONV, AP_SAT>, 8> resulttype;  //v3
  typedef ap_ufixed<18, 14> losstype;
  typedef std::pair<resulttype, losstype> pairtype;
  // typedef std::array<ap_fixed<10, 7>, 13> resulttype;  //deprecated v1 type:

  //define zero
  inputtype fillzero = 0.0;

  //AD vector declaration, will fill later
  inputtype ADModelInput[NInputs] = {};

  //initializing vector by type for my sanity
  inputtype MuInput[MuVecSize];
  inputtype JetInput[JVecSize];
  inputtype EgammaInput[EGVecSize];
  inputtype EtSumInput[EtSumVecSize];

  //declare result vectors +score
  resulttype result;
  losstype loss;
  pairtype ADModelResult;  //model outputs a pair of the (result vector, loss)
  float score = -1.0;      //not sure what the best default is hm??

  //check number of input objects we actually have (muons, jets etc)
  int NCandMu = candMuVec->size(useBx);
  int NCandJet = candJetVec->size(useBx);
  int NCandEG = candEGVec->size(useBx);
  int NCandEtSum = candEtSumVec->size(useBx);

  //initialize arrays to zero (std::fill(first, last, value);)
  std::fill(EtSumInput, EtSumInput + EtSumVecSize, fillzero);
  std::fill(MuInput, MuInput + MuVecSize, fillzero);
  std::fill(JetInput, JetInput + JVecSize, fillzero);
  std::fill(EgammaInput, EgammaInput + EGVecSize, fillzero);
  std::fill(ADModelInput, ADModelInput + NInputs, fillzero);

  //then fill the object vectors
  //NOTE assume candidates are already sorted by pt
  //loop over EtSums first, easy because there is max 1 of them
  if (NCandEtSum > 0) {  //check if not empty
    for (int iEtSum = 0; iEtSum < NCandEtSum; iEtSum++) {
      if ((candEtSumVec->at(useBx, iEtSum))->getType() == l1t::EtSum::EtSumType::kMissingEt) {
        EtSumInput[0] =
            ((candEtSumVec->at(useBx, iEtSum))->hwPt()) / 2;  //have to do hwPt/2 in order to match original et inputs
        // EtSumInput[1] = (candEtSumVec->at(useBx, iEtSum))->hwEta(); //this one is zero, so leave it zero
        EtSumInput[2] = (candEtSumVec->at(useBx, iEtSum))->hwPhi();
      }
    }
  }

  //next egammas
  if (NCandEG > 0) {  //check if not empty
    for (int iEG = 0; iEG < NCandEG; iEG++) {
      if (iEG < NEgammas) {  //stop if fill the Nobjects we need
        EgammaInput[0 + (3 * iEG)] = ((candEGVec->at(useBx, iEG))->hwPt()) /
                                     2;  //index 0,3,6,9 //have to do hwPt/2 in order to match original et inputs
        EgammaInput[1 + (3 * iEG)] = (candEGVec->at(useBx, iEG))->hwEta();  //index 1,4,7,10
        EgammaInput[2 + (3 * iEG)] = (candEGVec->at(useBx, iEG))->hwPhi();  //index 2,5,8,11
      }
    }
  }

  //next muons
  if (NCandMu > 0) {  //check if not empty
    for (int iMu = 0; iMu < NCandMu; iMu++) {
      if (iMu < NMuons) {  //stop if fill the Nobjects we need
        MuInput[0 + (3 * iMu)] = ((candMuVec->at(useBx, iMu))->hwPt()) /
                                 2;  //index 0,3,6,9 //have to do hwPt/2 in order to match original et inputs
        MuInput[1 + (3 * iMu)] = (candMuVec->at(useBx, iMu))->hwEta();  //index 1,4,7,10
        MuInput[2 + (3 * iMu)] = (candMuVec->at(useBx, iMu))->hwPhi();  //index 2,5,8,11
      }
    }
  }

  //next jets
  if (NCandJet > 0) {  //check if not empty
    for (int iJet = 0; iJet < NCandJet; iJet++) {
      if (iJet < NJets) {  //stop if fill the Nobjects we need
        JetInput[0 + (3 * iJet)] = ((candJetVec->at(useBx, iJet))->hwPt()) /
                                   2;  //index 0,3,6,9...27 //have to do hwPt/2 in order to match original et inputs
        JetInput[1 + (3 * iJet)] = (candJetVec->at(useBx, iJet))->hwEta();  //index 1,4,7,10...28
        JetInput[2 + (3 * iJet)] = (candJetVec->at(useBx, iJet))->hwPhi();  //index 2,5,8,11...29
      }
    }
  }

  //now put it all together-> EtSum+EGamma+Muon+Jet into ADModelInput
  int index = 0;
  for (int idET = 0; idET < EtSumVecSize; idET++) {
    ADModelInput[index++] = EtSumInput[idET];
  }
  for (int idEG = 0; idEG < EGVecSize; idEG++) {
    ADModelInput[index++] = EgammaInput[idEG];
  }
  for (int idMu = 0; idMu < MuVecSize; idMu++) {
    ADModelInput[index++] = MuInput[idMu];
  }
  for (int idJ = 0; idJ < JVecSize; idJ++) {
    ADModelInput[index++] = JetInput[idJ];
  }

  //now run the inference
  model->prepare_input(ADModelInput);  //scaling internal here
  model->predict();
  model->read_result(&ADModelResult);  // this should be the square sum model result

  result = ADModelResult.first;
  loss = ADModelResult.second;
  score = ((loss).to_float()) * 16.0;  //scaling to match threshold

  //number of objects/thrsholds to check
  int iCondition = 0;  // number of conditions: there is only one
  int nObjInCond = m_gtAXOL1TLTemplate->nrObjects();

  if (iCondition >= nObjInCond || iCondition < 0) {
    return false;
  }

  const AXOL1TLTemplate::ObjectParameter objPar = (*(m_gtAXOL1TLTemplate->objectParameter()))[iCondition];

  // condGEqVal indicates the operator used for the condition (>=, =): true for >=
  bool condGEqVal = m_gtAXOL1TLTemplate->condGEq();
  bool passCondition = false;

  passCondition = checkCut(objPar.minAXOL1TLThreshold, score, condGEqVal);

  condResult |= passCondition;  //condresult true if passCondition true else it is false

  //return result
  return condResult;
}

gtAXOL1TLTemplate()

const AXOL1TLTemplate* l1t::AXOL1TLCondition::gtAXOL1TLTemplate ( ) const

inline

get / set the pointer to a Condition

Definition at line 53 of file AXOL1TLCondition.h.

References m_gtAXOL1TLTemplate.

{ return m_gtAXOL1TLTemplate; }

gtGTB()

const GlobalBoard* l1t::AXOL1TLCondition::gtGTB ( ) const

inline

get / set the pointer to GTL

Definition at line 58 of file AXOL1TLCondition.h.

References m_gtGTB.

{ return m_gtGTB; }

operator=()

l1t::AXOL1TLCondition & AXOL1TLCondition::operator=

(

const AXOL1TLCondition &

cp

)

Definition at line 77 of file AXOL1TLCondition.cc.

References filterCSVwithJSON::copy.

                                                                                 {
  copy(cp);
  return *this;
}

print()

void AXOL1TLCondition::print ( std::ostream &  myCout ) const

overridevirtual

print condition

Reimplemented from l1t::ConditionEvaluation.

Definition at line 262 of file AXOL1TLCondition.cc.

References l1t::ConditionEvaluation::print().

Referenced by l1t::GlobalBoard::runGTL().

                                                        {
  myCout << "Dummy Print for AXOL1TLCondition" << std::endl;
  m_gtAXOL1TLTemplate->print(myCout);

  ConditionEvaluation::print(myCout);
}

setGtAXOL1TLTemplate()

void AXOL1TLCondition::setGtAXOL1TLTemplate

(

const AXOL1TLTemplate *

caloTempl

)

Definition at line 83 of file AXOL1TLCondition.cc.

{ m_gtAXOL1TLTemplate = caloTempl; }

setuGtB()

void AXOL1TLCondition::setuGtB

(

const GlobalBoard *

ptrGTB

)

set the pointer to uGT GlobalBoard

Definition at line 86 of file AXOL1TLCondition.cc.

{ m_gtGTB = ptrGTB; }

Member Data Documentation

m_gtAXOL1TLTemplate

const AXOL1TLTemplate* l1t::AXOL1TLCondition::m_gtAXOL1TLTemplate

private

pointer to a AXOL1TLTemplate

Definition at line 67 of file AXOL1TLCondition.h.

Referenced by gtAXOL1TLTemplate().

m_gtGTB

const GlobalBoard* l1t::AXOL1TLCondition::m_gtGTB

private

pointer to uGt GlobalBoard, to be able to get the trigger objects

Definition at line 70 of file AXOL1TLCondition.h.

Referenced by gtGTB().