ATLAS Offline Software
Public Member Functions | Private Member Functions | Private Attributes | List of all members
Trig::TrigBtagEmulationTool Class Reference

#include <TrigBtagEmulationTool.h>

Inheritance diagram for Trig::TrigBtagEmulationTool:
Collaboration diagram for Trig::TrigBtagEmulationTool:

Public Member Functions

 TrigBtagEmulationTool (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~TrigBtagEmulationTool ()=default
 
virtual StatusCode initialize () override
 
virtual const EmulContext & populateJetManagersTriggerObjects () const override
 
virtual bool isPassed (const std::string &chain) const override
 
virtual bool isPassed (const std::string &chain, const EmulContext &) const override
 

Private Member Functions

bool isPassed (const TrigBtagEmulationChain &, const EmulContext &) const
 
bool evaluate_L1 (const TrigBtagEmulationChain &, const EmulContext &) const
 
bool evaluate_HLT (const TrigBtagEmulationChain &, const EmulContext &) const
 
bool evaluate_preselection (const TrigBtagEmulationChain &chain, const std::vector< TrigBtagEmulationJet > &preselJets) const
 
bool evaluate_dijetmass (const TrigBtagEmulationChain &chain, const std::vector< TrigBtagEmulationJet > &preselJets) const
 
void parse_preselection (const std::string &presel_part, int &presel_multiplicity, double &presel_ptcut, double &presel_eta_min, double &presel_eta_max) const
 
void parse_dijetmass (const std::string &dijetmass, double &dijet_mass, double &dijet_minjetpt, double &dijet_dphi, double &dijet_deta) const
 
bool allocate_jets_to_chainParts (const std::vector< std::vector< bool >> &chainPart_jet_matrix, const std::vector< std::string > &chainPartNames, const std::vector< int > &multiplicities) const
 
std::vector< std::vector< bool > > evaluate_HLT_chainParts (const TrigBtagEmulationChain &chain, const std::vector< TrigBtagEmulationJet > &jets, int idx_begin, int idx_end) const
 
bool isPassedBTagger (const TrigBtagEmulationJet &jet, const std::string &btagger) const
 
StatusCode addEmulatedChain (const std::string &name, const std::vector< std::string > &definition)
 
StatusCode checkInputChainExists (const std::string &) const
 
StatusCode retrieveTriggerObjects (const Trig::JetManagerTool &, EmulContext &) const
 

Private Attributes

PublicToolHandle< Trig::TrigDecisionTool > m_trigDec {this, "TrigDecisionTool", "",""}
 
Gaudi::Property< std::string > m_inputChains_PFlow {this, "InputChain", "HLT_j45_pf_subjesgsc_ftf_L1J15", ""}
 
ToolHandle< Trig::JetManagerTool > m_manager_PFlow_cnt {this, "JM_PFlow_CNT", "",""}
 
ToolHandle< Trig::JetManagerTool > m_manager_EMTopo_presel {this, "JM_EMTopo_PRESEL", "",""}
 
Gaudi::Property< std::map< std::string, double > > m_tagger_wp {this, "WorkingPoints", {}}
 
Gaudi::Property< std::map< std::string, std::string > > m_remapping {this, "FTD_Remapping", {}}
 
Gaudi::Property< std::map< std::string, std::vector< std::string > > > m_emulatedChainDefinitions {this, "EmulatedChainDefinitions", {}, ""}
 
std::unordered_map< std::string, std::unique_ptr< TrigBtagEmulationChain > > m_emulatedChains
 
std::unique_ptr< FlavorTagDiscriminants::DL2HighLevel > m_dl2
 

Detailed Description

Definition at line 25 of file TrigBtagEmulationTool.h.

Constructor & Destructor Documentation

◆ TrigBtagEmulationTool()

Trig::TrigBtagEmulationTool::TrigBtagEmulationTool ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 31 of file TrigBtagEmulationTool.cxx.

36  : m_emulatedChainDefinitions) {

◆ ~TrigBtagEmulationTool()

virtual Trig::TrigBtagEmulationTool::~TrigBtagEmulationTool ( )
virtualdefault

Member Function Documentation

◆ addEmulatedChain()

StatusCode Trig::TrigBtagEmulationTool::addEmulatedChain ( const std::string &  name,
const std::vector< std::string > &  definition 
)
private

Definition at line 534 of file TrigBtagEmulationTool.cxx.

540 {
541  if (btagger.empty()) return false;
542  if (btagger == "offperf") return true;
543 
544  const auto& itr = m_tagger_wp.find(btagger);
545  if (itr == m_tagger_wp.end()) return false;
546 

◆ allocate_jets_to_chainParts()

bool Trig::TrigBtagEmulationTool::allocate_jets_to_chainParts ( const std::vector< std::vector< bool >> &  chainPart_jet_matrix,
const std::vector< std::string > &  chainPartNames,
const std::vector< int > &  multiplicities 
) const
private

Definition at line 330 of file TrigBtagEmulationTool.cxx.

331  : chainPart_passedjets) {
332  passedJets += pass ? '1' : '0';
333  passedJets += !(passedJets.size() % 5) ? " " : "";
334  }
335  ATH_MSG_DEBUG( passedJets << " " << *(chainPartName_it++) );
336  }
337 
338  if(chainPart_jet_matrix.size() == 1) {
339  // simple single threshold chain
340  chainPart_subset_passed.push_back(false);
341  int njet_passed = 0;
342  for(bool pass: chainPart_jet_matrix[0]) {
343  if(pass) {
344  njet_passed++;
345  if(njet_passed >= multiplicities[0]) {
346  chainPart_subset_passed.back() = true;
347  break;
348  }
349  }
350  }
351  }
352  else {
353  // matrix looks something like this:
354  // chainPart0 (mult 1) | x | pass | x | x | pass | x
355  // chainPart1 (mult 2) | x | pass | pass | pass | x | x
356  // chainPart2 (mult 3) | pass | pass | pass | x | pass | pass
357  // | j0 | j1 | j2 | j3 | j4 | j5
358  //
359  // so it is easy to see that every chain _part_ passed, but not trivial to check if the _whole_ chain passed without checking all combinations
360 
361  // check for every subset in the powerset (chainPart0, ...., chainPartLast) if there are enough jets available that satisfy the subset's chainParts
362  for (int subset_bits = 1; subset_bits < (1 << chainPart_jet_matrix.size()); ++subset_bits) {
363  std::bitset<32> subset(subset_bits); // This limits the number of chain part to 32
364  std::vector<bool> subset_passedJets(chainPart_jet_matrix[0].size(), false);
365  int njets_required_subset = 0;
366 
367  std::string subset_str = "";
368  for(size_t chainPart_idx = 0; chainPart_idx < chainPart_jet_matrix.size(); ++chainPart_idx) {
369  if(subset[chainPart_idx]) {
370  subset_str += std::to_string(chainPart_idx);
371  njets_required_subset += multiplicities[chainPart_idx];
372 
373  for(size_t jet_idx = 0; jet_idx < chainPart_jet_matrix[chainPart_idx].size(); ++jet_idx) {
374  if(chainPart_jet_matrix[chainPart_idx][jet_idx]) {
375  subset_passedJets[jet_idx] = true;
376  }
377  }
378  }
379  }
380 
381  int njets_passed_subset = 0;
382  for(bool pass: subset_passedJets) {
383  if(pass) {
384  njets_passed_subset++;
385  }
386  }
387 
388  ATH_MSG_DEBUG( "Subset {" << subset_str << "} requires " << njets_required_subset << " jets, and has " << njets_passed_subset << " jets passed." );
389 
390  if(njets_passed_subset < njets_required_subset) {
391  chainPart_subset_passed.push_back(false);
392  break;
393  }
394  else {
395  chainPart_subset_passed.push_back(true);
396  }
397  }
398  }
399 
400 
401  if(chainPart_subset_passed.size() == static_cast<size_t>(1 << chainPart_jet_matrix.size()) -1 && // -1 because we don't use the empty subset
402  !chainPart_subset_passed.empty()) {
403  // all chainpart subsets were checked, the result of the last is the overall result
404  res = chainPart_subset_passed.back();
405  }
406  else {
407  ATH_MSG_DEBUG( chainPart_subset_passed.size() << " out of " << (1 << chainPart_jet_matrix.size()) -1 << " chain part subsets checked" );
408  }
409 
410  return res;
411 }
412 
413 std::vector<std::vector<bool>> TrigBtagEmulationTool::evaluate_HLT_chainParts(const TrigBtagEmulationChain& chain,
414  const std::vector<TrigBtagEmulationJet>& jets,
415  int idx_begin,
416  int idx_end) const
417 {
418  const std::vector<double>& jet_pt_vec = chain.jet_pt();
419  const std::vector<double>& jet_eta_min_vec = chain.jet_eta_min();
420  const std::vector<double>& jet_eta_max_vec = chain.jet_eta_max();
421  const std::vector<double>& jvt_vec = chain.jvt();

◆ checkInputChainExists()

StatusCode Trig::TrigBtagEmulationTool::checkInputChainExists ( const std::string &  inputChain) const
private

Definition at line 518 of file TrigBtagEmulationTool.cxx.

526 {
527  if (m_emulatedChains.find(triggerName) != m_emulatedChains.end()) {
528  ATH_MSG_ERROR("Chain " << triggerName << " has already been added in the Emulation List.");
529  return StatusCode::FAILURE;
530  }
531  auto chain = std::make_unique<TrigBtagEmulationChain>( triggerName, definition );
532  chain->setLevel(msgLevel());

◆ evaluate_dijetmass()

bool Trig::TrigBtagEmulationTool::evaluate_dijetmass ( const TrigBtagEmulationChain &  chain,
const std::vector< TrigBtagEmulationJet > &  preselJets 
) const
private

Definition at line 221 of file TrigBtagEmulationTool.cxx.

224  : preselJets ) {
225  if( (jet1.pt() / Gaudi::Units::GeV) < dijet_minjetpt ) {
226  break;
227  }
228 
229  for( const auto& jet2: preselJets ) {
230  if( (jet2.pt() / Gaudi::Units::GeV) < dijet_minjetpt ) {
231  break;
232  }
233 
234  double mass = (jet1.p4() + jet2.p4()).M(); // MeV, since PreselJet pt is in MeV too
235  double adphi = std::abs(jet1.p4().DeltaPhi(jet2.p4()));
236  double adeta = std::abs(jet1.eta() - jet2.eta());
237 
238  if((mass / Gaudi::Units::GeV) >= dijet_mass &&
239  (dijet_dphi < 0 || adphi < dijet_dphi) &&
240  (dijet_deta < 0 || adeta > dijet_deta) ) {
241  ATH_MSG_DEBUG( " - Dijet system " << (jet1.pt() / Gaudi::Units::GeV) << " and " << (jet2.pt() / Gaudi::Units::GeV) << " passed " << dijetmass );
242  res = true;
243  break;
244  }
245  }
246  }
247 
248  return res;
249 }
250 
251 void TrigBtagEmulationTool::parse_preselection(const std::string& presel_part,
252  int& presel_multiplicity,
253  double& presel_ptcut,
254  double& presel_eta_min,
255  double& presel_eta_max) const
256 {
257  char presel_etarange = '?';
258 
259  presel_multiplicity = 1;

◆ evaluate_HLT()

bool Trig::TrigBtagEmulationTool::evaluate_HLT ( const TrigBtagEmulationChain &  chain,
const EmulContext &  emulCtx 
) const
private

Definition at line 91 of file TrigBtagEmulationTool.cxx.

106  {
107  // chain uses the shared operator, we basically have two chains to check
108  std::vector<std::vector<bool>> chainPart_passedjets = evaluate_HLT_chainParts(chain, pflow_jets, 0, shared_idx);
109  std::vector<std::vector<bool>> chainPart_passedjets_btag = evaluate_HLT_chainParts(chain, pflow_jets, shared_idx, nChainParts);
110 
111  std::vector<std::string> chainPartNames_leg1(chainPartName.begin(), chainPartName.begin() + shared_idx);
112  std::vector<int> multiplicities_leg1(jet_multiplicity.begin(), jet_multiplicity.begin() + shared_idx);
113  std::vector<std::string> chainPartNames_leg2(chainPartName.begin() + shared_idx, chainPartName.end());
114  std::vector<int> multiplicities_leg2(jet_multiplicity.begin() + shared_idx, jet_multiplicity.end());
115 
116  res = allocate_jets_to_chainParts(chainPart_passedjets, chainPartNames_leg1, multiplicities_leg1) &&
117  allocate_jets_to_chainParts(chainPart_passedjets_btag, chainPartNames_leg2, multiplicities_leg2);
118  }
119  else {
120  std::vector<std::vector<bool>> chainPart_passedjets = evaluate_HLT_chainParts(chain, pflow_jets, 0, nChainParts);
121 
122  std::vector<std::string> chainPartNames(chainPartName.begin(), chainPartName.end());
123  std::vector<int> multiplicities(jet_multiplicity.begin(), jet_multiplicity.end());
124 
125  res = allocate_jets_to_chainParts(chainPart_passedjets, chainPartNames, multiplicities);
126  }
127 
128  return res;
129 }
130 
131 bool TrigBtagEmulationTool::evaluate_preselection(const TrigBtagEmulationChain& chain,
132  const std::vector<TrigBtagEmulationJet>& preselJets) const
133 {
134  const std::vector<std::string>& jet_presel = chain.jet_presel();
135  if (jet_presel.size() == 0) return true;
136 
137  int presel_multiplicity = 1;
138  double presel_ptcut = 0.;
139  double presel_eta_min = 0.;

◆ evaluate_HLT_chainParts()

std::vector< std::vector< bool > > Trig::TrigBtagEmulationTool::evaluate_HLT_chainParts ( const TrigBtagEmulationChain &  chain,
const std::vector< TrigBtagEmulationJet > &  jets,
int  idx_begin,
int  idx_end 
) const
private

Definition at line 423 of file TrigBtagEmulationTool.cxx.

427  {
428  double jet_pt = jet_pt_vec[chainPart_idx +idx_begin];
429  double jet_eta_min = jet_eta_min_vec[chainPart_idx +idx_begin];
430  double jet_eta_max = jet_eta_max_vec[chainPart_idx +idx_begin];
431  double jvtcut = jvt_vec[chainPart_idx +idx_begin];
432  std::string tagger = tagger_vec[chainPart_idx +idx_begin];
433 
434  ATH_MSG_DEBUG( ">-- " << chainPartName_vec[chainPart_idx +idx_begin] << ":" );
435  for( const auto& jet : jets ) {
436  float jvt = jet.jvt();
437  bool passedJvt = jvt > jvtcut ||
438  jet.pt() / Gaudi::Units::GeV > 120. ||
439  std::fabs(jet.eta()) > 2.5;
440 
441  if (tagger == "ewTagger") tagger = "newTagger";
442  bool is_bjet = isPassedBTagger(jet, tagger);
443 
444  if(jet.pt() > jet_pt &&
445  std::fabs(jet.eta()) > jet_eta_min &&
446  std::fabs(jet.eta()) < jet_eta_max &&
447  passedJvt &&
448  ((tagger != "") ? is_bjet : true) ) {
449  // flag jet as passing current chainPart
450  chainPart_passedjets[chainPart_idx].push_back(true);
451  }
452  else {
453  chainPart_passedjets[chainPart_idx].push_back(false);
454  }
455 
456  ATH_MSG_DEBUG( " - pt:" << (jet.pt() / Gaudi::Units::GeV)
457  << ", eta:" << jet.eta()
458  << ", jvt:" << jvt
459  << ((tagger != "") ? ", btag:" : "") << ((tagger != "") ? (is_bjet?"Y":"N") : "")
460  << ", pass:" << (chainPart_passedjets[chainPart_idx].back()?"Y":"N")
461  );
462  }
463  }
464 
465  return chainPart_passedjets;
466 }
467 
468 
469 //=================================================
470 // Utility functions
471 //=================================================
472 const EmulContext& TrigBtagEmulationTool::populateJetManagersTriggerObjects() const {
473  EmulContext *emulCtx = new EmulContext();
474 
475  // Check if input chain exists
476  if ( checkInputChainExists( m_inputChains_PFlow ).isFailure() )

◆ evaluate_L1()

bool Trig::TrigBtagEmulationTool::evaluate_L1 ( const TrigBtagEmulationChain &  chain,
const EmulContext &   
) const
private

Definition at line 81 of file TrigBtagEmulationTool.cxx.

83 {
84  for ( const auto& is_chainPart_PFlow : chain.is_PFlow() ) {
85  if ( not is_chainPart_PFlow ) {
86  ATH_MSG_ERROR( "Only PFlow jets are supported at this moment" );
87  return false;
88  }

◆ evaluate_preselection()

bool Trig::TrigBtagEmulationTool::evaluate_preselection ( const TrigBtagEmulationChain &  chain,
const std::vector< TrigBtagEmulationJet > &  preselJets 
) const
private

Definition at line 141 of file TrigBtagEmulationTool.cxx.

143  {
144  // single preselection cut
145  const std::string presel_part = jet_presel[0];
146  int preseljets_passed = 0;
147 
148  parse_preselection(presel_part, presel_multiplicity, presel_ptcut, presel_eta_min, presel_eta_max);
149 
150  for( const auto& preseljet: preselJets ) {
151  if((preseljet.pt() / Gaudi::Units::GeV) >= presel_ptcut &&
152  presel_eta_min < std::fabs(preseljet.eta()) && std::fabs(preseljet.eta()) < presel_eta_max) {
153 
154  ATH_MSG_DEBUG( " - Preselection jet pt=" << (preseljet.pt() / Gaudi::Units::GeV) << " eta=" << preseljet.eta() << " passed.");
155  preseljets_passed++;
156  }
157  else if((preseljet.pt() / Gaudi::Units::GeV) < presel_ptcut) {
158  // no more Preselection jets left with high enough pt
159  break;
160  }
161 
162  if(preseljets_passed >= presel_multiplicity) {
163  res = true;
164  break;
165  }
166  }
167  }
168  else {
169  // multi-threshold preselection
170  std::vector<std::vector<bool>> chainPart_passedjets(jet_presel.size());
171  size_t chainPart_passedjets_lenmax = 0;
172  std::vector<int> multiplicities;
173 
174  for(size_t chainPart_idx = 0; chainPart_idx < chainPart_passedjets.size(); chainPart_idx++) {
175  parse_preselection(jet_presel[chainPart_idx], presel_multiplicity, presel_ptcut, presel_eta_min, presel_eta_max);
176  multiplicities.push_back(presel_multiplicity);
177 
178  for ( const auto& preseljet : preselJets ) {
179  if((preseljet.pt() / Gaudi::Units::GeV) >= presel_ptcut &&
180  presel_eta_min < std::fabs(preseljet.eta()) && std::fabs(preseljet.eta()) < presel_eta_max) {
181  // flag jet as passed this part of preselection
182  chainPart_passedjets[chainPart_idx].push_back(true);
183  }
184  else {
185  chainPart_passedjets[chainPart_idx].push_back(false);
186  }
187 
188  if((preseljet.pt() / Gaudi::Units::GeV) < presel_ptcut) {
189  // no more Preselection jets left with high enough pt
190  if(chainPart_passedjets[chainPart_idx].size() > chainPart_passedjets_lenmax) {
191  chainPart_passedjets_lenmax = chainPart_passedjets[chainPart_idx].size();
192  }
193  break;
194  }
195  }
196  }
197 
198  for( auto& chainPart_passedjets_row : chainPart_passedjets ) {
199  // make all rows in the chainPart_jet_matrix equal length
200  while(chainPart_passedjets_row.size() < chainPart_passedjets_lenmax) {
201  chainPart_passedjets_row.push_back(false);
202  }
203  }
204 
205  res = allocate_jets_to_chainParts(chainPart_passedjets, jet_presel, multiplicities);
206  }
207 
208  return res;
209 }
210 
211 bool TrigBtagEmulationTool::evaluate_dijetmass(const TrigBtagEmulationChain& chain,
212  const std::vector<TrigBtagEmulationJet>& preselJets) const
213 {
214  const std::string& dijetmass = chain.dijetmass();
215  if ( dijetmass == "None") return true;
216 
217  double dijet_mass = 0.;
218  double dijet_minjetpt = 0.;
219  double dijet_dphi = -1.;

◆ initialize()

StatusCode Trig::TrigBtagEmulationTool::initialize ( )
overridevirtual

Definition at line 38 of file TrigBtagEmulationTool.cxx.

48 {
49  // This will re-compute everything - slow version
50  const auto& emulContext = populateJetManagersTriggerObjects();
51  return isPassed(chain, emulContext);
52 }
53 
54 bool TrigBtagEmulationTool::isPassed(const std::string& chain,
55  const EmulContext& emulCtx) const

◆ isPassed() [1/3]

bool Trig::TrigBtagEmulationTool::isPassed ( const std::string &  chain) const
overridevirtual

Definition at line 57 of file TrigBtagEmulationTool.cxx.

58  {
59  ATH_MSG_WARNING( "Chain " << chain << " requested but not in the list of emulated chains" );
60  return false;
61  }
62  return isPassed(*(itr->second.get()), emulCtx);

◆ isPassed() [2/3]

bool Trig::TrigBtagEmulationTool::isPassed ( const std::string &  chain,
const EmulContext &  emulCtx 
) const
overridevirtual

Definition at line 64 of file TrigBtagEmulationTool.cxx.

67 {
68  return evaluate_L1(chain, emulCtx) and evaluate_HLT(chain, emulCtx);
69 }
70 
71 bool TrigBtagEmulationTool::evaluate_L1(const TrigBtagEmulationChain& chain,
72  const EmulContext&) const
73 {

◆ isPassed() [3/3]

bool Trig::TrigBtagEmulationTool::isPassed ( const TrigBtagEmulationChain &  chain,
const EmulContext &  emulCtx 
) const
private

Definition at line 75 of file TrigBtagEmulationTool.cxx.

76  : " << (res ? "YES":"NO") );
77  return res;
78 }
79 

◆ isPassedBTagger()

bool Trig::TrigBtagEmulationTool::isPassedBTagger ( const TrigBtagEmulationJet &  jet,
const std::string &  btagger 
) const
private

Definition at line 548 of file TrigBtagEmulationTool.cxx.

550  { // 4 -> strlen("dl1r")
551  res = jet.satisfy("DL1r", workingPoint);
552  } else if( btagger.substr(0, 4) == "dl1d" ) { // 4 -> strlen("dl1d")
553  res = jet.satisfy("DL1d20211216", workingPoint);
554  } else if( btagger == "newTagger" ) {
555  const xAOD::BTagging *btag = jet.btag();
556  if (not btag) return false;
557  m_dl2->decorate(*btag);
558 
559  res = jet.satisfy("DL1dEMUL", workingPoint);
560  } else {
561  ATH_MSG_WARNING( "Tagger " << btagger << " not supported." );
562  }
563 
564  return res;
565 }
566 
567 }

◆ parse_dijetmass()

void Trig::TrigBtagEmulationTool::parse_dijetmass ( const std::string &  dijetmass,
double &  dijet_mass,
double &  dijet_minjetpt,
double &  dijet_dphi,
double &  dijet_deta 
) const
private

Definition at line 298 of file TrigBtagEmulationTool.cxx.

304  {
305  dijet_dphi = static_cast<double>( (std::stoi(dijetmass.substr(dijetmass.find("dphi") + 4)))) / 1e2 ; // 4 -> strlen("dphi")
306  }
307 
308  if(dijetmass.find("deta") != std::string::npos) {
309  std::string deta_str = dijetmass.substr(dijetmass.find("deta") -6);
310  dijet_deta = static_cast<double>( (std::stoi(dijetmass.substr(dijetmass.find("x") +1)))) / 1e2;
311  }
312 
313  ATH_MSG_DEBUG( "DijetMass parsing result: " << dijetmass << " ->"
314  << " m:" << dijet_mass
315  << " j:" << dijet_minjetpt
316  << " dphi:" << dijet_dphi
317  << " deta:" << dijet_deta);
318 }
319 
320 bool TrigBtagEmulationTool::allocate_jets_to_chainParts(const std::vector<std::vector<bool>>& chainPart_jet_matrix,
321  const std::vector<std::string>& chainPartNames,
322  const std::vector<int>& multiplicities) const
323 {
324  bool res = false;
325  std::vector<bool> chainPart_subset_passed;
326 
327  auto chainPartName_it = chainPartNames.begin();
328  for(const auto& chainPart_passedjets: chainPart_jet_matrix) {

◆ parse_preselection()

void Trig::TrigBtagEmulationTool::parse_preselection ( const std::string &  presel_part,
int &  presel_multiplicity,
double &  presel_ptcut,
double &  presel_eta_min,
double &  presel_eta_max 
) const
private

Definition at line 261 of file TrigBtagEmulationTool.cxx.

261  {
262  presel_multiplicity = (presel_part[0] - '0');
263  tokenizer_offset = 1;
264  }
265  presel_etarange = presel_part[tokenizer_offset];
266  presel_ptcut = static_cast<double>( std::stoi(&presel_part[1 +tokenizer_offset]) );
267 
268  switch(presel_etarange) {
269  case 'j':
270  presel_eta_max = 3.2;
271  break;
272  case 'a':
273  presel_eta_max = 4.9;
274  break;
275  case 'c':
276  presel_eta_max = 2.4;
277  break;
278  case 'f':
279  presel_eta_min = 3.2;
280  presel_eta_max = 4.9;
281  break;
282  default:
283  ATH_MSG_ERROR( "Unknown eta range in jet preselection cut." );
284  break;
285  }
286 }
287 
288 void TrigBtagEmulationTool::parse_dijetmass(const std::string& dijetmass,
289  double& dijet_mass,
290  double& dijet_minjetpt,
291  double& dijet_dphi,
292  double& dijet_deta) const
293 {
294  // 'DJMASS500j35
295  // 'DJMASS700j35
296  // 'DJMASS1000j35

◆ populateJetManagersTriggerObjects()

const EmulContext & Trig::TrigBtagEmulationTool::populateJetManagersTriggerObjects ( ) const
overridevirtual

Definition at line 482 of file TrigBtagEmulationTool.cxx.

485  {
486  ATH_MSG_ERROR("Could not retrieve trigger objects from " << m_manager_EMTopo_presel->name());
487  return *emulCtx;
488  }
489 
490  return *emulCtx;
491 }
492 
493 StatusCode TrigBtagEmulationTool::retrieveTriggerObjects(const Trig::JetManagerTool& manager,
494  EmulContext& emulCtx) const
495 {
496  const EventContext& ctx = Gaudi::Hive::currentContext();
497  ATH_CHECK(manager.retrieveByContainer(ctx, emulCtx));
498 
499  const std::string& jetContainerName = manager.jetContainerName();
500  const unsigned int jetSize = manager.getJets(emulCtx).size();
501 

◆ retrieveTriggerObjects()

StatusCode Trig::TrigBtagEmulationTool::retrieveTriggerObjects ( const Trig::JetManagerTool &  manager,
EmulContext &  emulCtx 
) const
private

Definition at line 503 of file TrigBtagEmulationTool.cxx.

509 {
510  std::vector<std::string> listOfTriggers = m_trigDec->getChainGroup( inputChain )->getListOfTriggers();
511  if ( listOfTriggers.empty() ) {
512  ATH_MSG_ERROR( "Input Chain ('" << inputChain << "') is not in the list of available triggers: {" << m_trigDec->getListOfTriggers(".*") << "}" );
513  return StatusCode::FAILURE;
514  }
515 
516  ATH_MSG_DEBUG( "Triggers in configured ChainGroup " << inputChain << ":" );

Member Data Documentation

◆ m_dl2

std::unique_ptr<FlavorTagDiscriminants::DL2HighLevel> Trig::TrigBtagEmulationTool::m_dl2
private

Definition at line 98 of file TrigBtagEmulationTool.h.

◆ m_emulatedChainDefinitions

Gaudi::Property< std::map< std::string, std::vector< std::string > > > Trig::TrigBtagEmulationTool::m_emulatedChainDefinitions {this, "EmulatedChainDefinitions", {}, ""}
private

Definition at line 95 of file TrigBtagEmulationTool.h.

◆ m_emulatedChains

std::unordered_map< std::string, std::unique_ptr<TrigBtagEmulationChain> > Trig::TrigBtagEmulationTool::m_emulatedChains
private

Definition at line 97 of file TrigBtagEmulationTool.h.

◆ m_inputChains_PFlow

Gaudi::Property< std::string > Trig::TrigBtagEmulationTool::m_inputChains_PFlow {this, "InputChain", "HLT_j45_pf_subjesgsc_ftf_L1J15", ""}
private

Definition at line 84 of file TrigBtagEmulationTool.h.

◆ m_manager_EMTopo_presel

ToolHandle< Trig::JetManagerTool > Trig::TrigBtagEmulationTool::m_manager_EMTopo_presel {this, "JM_EMTopo_PRESEL", "",""}
private

Definition at line 88 of file TrigBtagEmulationTool.h.

◆ m_manager_PFlow_cnt

ToolHandle< Trig::JetManagerTool > Trig::TrigBtagEmulationTool::m_manager_PFlow_cnt {this, "JM_PFlow_CNT", "",""}
private

Definition at line 87 of file TrigBtagEmulationTool.h.

◆ m_remapping

Gaudi::Property< std::map<std::string, std::string> > Trig::TrigBtagEmulationTool::m_remapping {this, "FTD_Remapping", {}}
private

Definition at line 92 of file TrigBtagEmulationTool.h.

◆ m_tagger_wp

Gaudi::Property< std::map<std::string, double> > Trig::TrigBtagEmulationTool::m_tagger_wp {this, "WorkingPoints", {}}
private

Definition at line 91 of file TrigBtagEmulationTool.h.

◆ m_trigDec

PublicToolHandle<Trig::TrigDecisionTool> Trig::TrigBtagEmulationTool::m_trigDec {this, "TrigDecisionTool", "",""}
private

Definition at line 81 of file TrigBtagEmulationTool.h.

The documentation for this class was generated from the following files:
Trig::TrigBtagEmulationTool::populateJetManagersTriggerObjects
virtual const EmulContext & populateJetManagersTriggerObjects() const override
Definition: TrigBtagEmulationTool.cxx:482
runLayerRecalibration.chain
chain
Definition: runLayerRecalibration.py:175
Trig::TrigBtagEmulationTool::allocate_jets_to_chainParts
bool allocate_jets_to_chainParts(const std::vector< std::vector< bool >> &chainPart_jet_matrix, const std::vector< std::string > &chainPartNames, const std::vector< int > &multiplicities) const
Definition: TrigBtagEmulationTool.cxx:330
Trig::TrigBtagEmulationTool::m_manager_EMTopo_presel
ToolHandle< Trig::JetManagerTool > m_manager_EMTopo_presel
Definition: TrigBtagEmulationTool.h:88
Trig::JetManagerTool
Definition: JetManagerTool.h:30
dqt_zlumi_pandas.mass
mass
Definition: dqt_zlumi_pandas.py:170
Trig::TrigBtagEmulationTool::m_tagger_wp
Gaudi::Property< std::map< std::string, double > > m_tagger_wp
Definition: TrigBtagEmulationTool.h:91
Trig::TrigBtagEmulationTool::parse_dijetmass
void parse_dijetmass(const std::string &dijetmass, double &dijet_mass, double &dijet_minjetpt, double &dijet_dphi, double &dijet_deta) const
Definition: TrigBtagEmulationTool.cxx:298
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
Trig::TrigBtagEmulationTool::m_emulatedChains
std::unordered_map< std::string, std::unique_ptr< TrigBtagEmulationChain > > m_emulatedChains
Definition: TrigBtagEmulationTool.h:97
Trig::TrigBtagEmulationTool::m_trigDec
PublicToolHandle< Trig::TrigDecisionTool > m_trigDec
Definition: TrigBtagEmulationTool.h:81
TRT_PAI_gasdata::NO
const int NO
Number of levels for Oxygen.
Definition: TRT_PAI_gasdata.h:297
jet
Definition: JetCalibTools_PlotJESFactors.cxx:23
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Trig::TrigBtagEmulationTool::evaluate_preselection
bool evaluate_preselection(const TrigBtagEmulationChain &chain, const std::vector< TrigBtagEmulationJet > &preselJets) const
Definition: TrigBtagEmulationTool.cxx:141
Trig::TrigBtagEmulationTool::parse_preselection
void parse_preselection(const std::string &presel_part, int &presel_multiplicity, double &presel_ptcut, double &presel_eta_min, double &presel_eta_max) const
Definition: TrigBtagEmulationTool.cxx:261
res
std::pair< std::vector< unsigned int >, bool > res
Definition: JetGroupProductTest.cxx:14
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
xAOD::BTagging_v1
Definition: BTagging_v1.h:39
Trig::TrigBtagEmulationTool::m_dl2
std::unique_ptr< FlavorTagDiscriminants::DL2HighLevel > m_dl2
Definition: TrigBtagEmulationTool.h:98
ChainNameParser::multiplicities
std::vector< int > multiplicities(const std::string &chain)
Definition: ChainNameParser.cxx:202
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
Trig::TrigBtagEmulationTool::m_inputChains_PFlow
Gaudi::Property< std::string > m_inputChains_PFlow
Definition: TrigBtagEmulationTool.h:84
Trig::TrigBtagEmulationTool::retrieveTriggerObjects
StatusCode retrieveTriggerObjects(const Trig::JetManagerTool &, EmulContext &) const
Definition: TrigBtagEmulationTool.cxx:503
Trig::TrigBtagEmulationTool::isPassedBTagger
bool isPassedBTagger(const TrigBtagEmulationJet &jet, const std::string &btagger) const
Definition: TrigBtagEmulationTool.cxx:548
Trig::TrigBtagEmulationTool::m_emulatedChainDefinitions
Gaudi::Property< std::map< std::string, std::vector< std::string > > > m_emulatedChainDefinitions
Definition: TrigBtagEmulationTool.h:95
Trig::TrigBtagEmulationTool::checkInputChainExists
StatusCode checkInputChainExists(const std::string &) const
Definition: TrigBtagEmulationTool.cxx:518
egammaEnergyPositionAllSamples::e2
double e2(const xAOD::CaloCluster &cluster)
return the uncorrected cluster energy in 2nd sampling
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
Trig::TrigBtagEmulationTool::isPassed
virtual bool isPassed(const std::string &chain) const override
Definition: TrigBtagEmulationTool.cxx:57
Trig::TrigBtagEmulationTool::evaluate_HLT_chainParts
std::vector< std::vector< bool > > evaluate_HLT_chainParts(const TrigBtagEmulationChain &chain, const std::vector< TrigBtagEmulationJet > &jets, int idx_begin, int idx_end) const
Definition: TrigBtagEmulationTool.cxx:423
defineDB.jets
list jets
Definition: JetTagCalibration/share/defineDB.py:24
python.Logging.manager
manager
Definition: PhysicsAnalysis/D3PDTools/AnaAlgorithm/python/Logging.py:92
Trig::TrigBtagEmulationTool::evaluate_L1
bool evaluate_L1(const TrigBtagEmulationChain &, const EmulContext &) const
Definition: TrigBtagEmulationTool.cxx:81
GeV
#define GeV
Definition: CaloTransverseBalanceVecMon.cxx:30
Trig::TrigBtagEmulationTool::evaluate_dijetmass
bool evaluate_dijetmass(const TrigBtagEmulationChain &chain, const std::vector< TrigBtagEmulationJet > &preselJets) const
Definition: TrigBtagEmulationTool.cxx:221
Trig::TrigBtagEmulationTool::evaluate_HLT
bool evaluate_HLT(const TrigBtagEmulationChain &, const EmulContext &) const
Definition: TrigBtagEmulationTool.cxx:91
Generated on Fri Jun 28 2024 22:29:57 for ATLAS Offline Software by   doxygen 1.8.18