Skip to content
Snippets Groups Projects
Commit a2f0d515 authored by Jean Yves Beaucamp's avatar Jean Yves Beaucamp Committed by Jiri Masik
Browse files

Update to TrigTauMonitoring 

Update to TrigTauMonitoring
parent ff05beae
No related branches found
No related tags found
3 merge requests!756432024-11-06: merge of 24.0 into main,!75556Update to TrigTauMonitoring,!75127Draft: Seeder types rebase2 grid fix
Hide whitespace changes
Inline Side-by-side
Showing
with 234 additions and 62 deletions
Trigger/TrigMonitoring/TrigTauMonitoring/Root/TrigTauInfo.cxx
+ 22
− 0
View file @ a2f0d515
......@@ -54,6 +54,7 @@ void TrigTauInfo::parseTriggerString(bool remove_L1_phase1_thresholds)
std::vector<std::regex*> all_regexes = {&tau_rgx, &elec_rgx, &muon_rgx, &gamma_rgx, &jet_rgx, &met_rgx, &l1_rgx};
std::regex tau_type_rgx("^(ptonly|tracktwoMVA|tracktwoMVABDT|tracktwoLLP|trackLRT)$");
std::regex tau_ID_rgx("^(perf|idperf|veryloose.*|loose.*|medium.*|tight.*)$");
std::smatch match;
std::regex_token_iterator<std::string::iterator> rend;
......@@ -69,12 +70,33 @@ void TrigTauInfo::parseTriggerString(bool remove_L1_phase1_thresholds)
if(std::regex_match(leg[0], match, tau_rgx)) {
size_t multiplicity = match[1].str() == "" ? 1 : std::stoi(match[1].str());
unsigned int threshold = std::stoi(match[2].str());
// HLT Tau sequence
auto itr = find_if(leg.begin(), leg.end(), [tau_type_rgx](const std::string& s) { return std::regex_match(s, tau_type_rgx); });
std::string type = itr != leg.end() ? *itr : "";
// HLT Tau ID
itr = find_if(leg.begin(), leg.end(), [tau_ID_rgx](const std::string& s) { return std::regex_match(s, tau_ID_rgx); });
std::string tau_id = itr != leg.end() ? *itr : "";
if(boost::starts_with(tau_id, "veryloose")) tau_id = tau_id.substr(9);
else if(boost::starts_with(tau_id, "loose")) tau_id = tau_id.substr(5);
else if(boost::starts_with(tau_id, "medium")) tau_id = tau_id.substr(6);
else if(boost::starts_with(tau_id, "tight")) tau_id = tau_id.substr(5);
// Override for the old trigger names
if(tau_id == "RNN") {
if(type == "tracktwoMVA") tau_id = "DeepSet";
if(type == "tracktwoLLP" || type == "trackLRT") tau_id = "RNNLLP";
}
// Replacements (this is temprary, the entire TrigTauInfo class will be removed soon, and all this will be handled centrally in Python using the already available infrastructure)
if(tau_id == "DS") tau_id = "DeepSet";
else if(tau_id == "GNT") tau_id = "GNTau";
for(size_t j = 0; j < multiplicity; j++) {
m_HLTThr.push_back(threshold);
m_HLTTauTypes.push_back(type);
m_HLTTauIDs.push_back(tau_id);
}
} else if(std::regex_match(leg[0], match, elec_rgx)) {
size_t multiplicity = match[1].str() == "" ? 1 : std::stoi(match[1].str());
......
Trigger/TrigMonitoring/TrigTauMonitoring/TrigTauMonitoring/TrigTauInfo.h
+ 3
− 0
View file @ a2f0d515
......@@ -27,6 +27,8 @@ public:
inline const std::vector<float>& getHLTTauThresholds() const { return m_HLTThr; }
inline const std::string getHLTTauType() const { return m_HLTTauTypes.size() ? m_HLTTauTypes[0] : ""; } // Returns the main HLT tau leg type
inline const std::vector<std::string>& getHLTTauTypes() const { return m_HLTTauTypes; }
inline const std::string getHLTTauID() const { return m_HLTTauIDs.size() ? m_HLTTauIDs[0] : ""; } // Returns the main HLT tau leg ID algorithm
inline const std::vector<std::string>& getHLTTauIDs() const { return m_HLTTauIDs; }
inline const std::string& getTriggerL1Name() const { return m_L1Item; }
inline const std::vector<std::string>& getTriggerL1Items() const { return m_L1Items; }
......@@ -71,6 +73,7 @@ private:
bool m_isStreamer; // Is a streamer HLT trigger
std::vector<float> m_HLTThr; // List of all tau thresholds
std::vector<std::string> m_HLTTauTypes; // Type for each tau leg (e.g. tracktwoMVA, trackwoLLP, etc...)
std::vector<std::string> m_HLTTauIDs; // Tau ID algorithm for each tau leg (e.g. DeepSet, RNNLLP, GNTau, etc...)
std::string m_L1Item; // full L1 trigger string (e.g. L1eTAU20, or L1eTAU80_2eTAU60)
std::vector<std::string> m_L1Items; // full L1 trigger items
......
Trigger/TrigMonitoring/TrigTauMonitoring/python/TrigTauMonitoringConfig.py
+ 70
− 18
View file @ a2f0d515
......@@ -30,6 +30,27 @@ class TrigTauMonAlgBuilder:
do_duplicate_var_plots_without_offline_taus = True # Duplicate variable distribution plots without the requirement of at least 1 offline good-quality tau (regardless of p_T) on ALL events (except in the Truth monitoring).
#=============================================
# TauID monitoring
#=============================================
hlt_tauid_scores = {
'tracktwoMVA': {
'DeepSet': ('RNNJetScore', 'RNNJetScoreSigTrans'),
},
'tracktwoLLP': {
'RNNLLP': ('RNNJetScore', 'RNNJetScoreSigTrans'),
},
'trackLRT': {
'RNNLLP': ('RNNJetScore', 'RNNJetScoreSigTrans'),
},
# Archive:
'tracktwoMVABDT': { 'RNN': ('RNNJetScore', 'RNNJetScoreSigTrans') }, # Deprecated
}
offline_tauid_scores = {
'RNN': ('RNNJetScore', 'RNNJetScoreSigTrans'),
}
#=============================================
# Setup for L1Calo monitoring
#=============================================
......@@ -230,6 +251,8 @@ class TrigTauMonAlgBuilder:
self.mon_alg_single.TriggerList = self.HLT_single_items
self.mon_alg_single.DoTotalEfficiency = self.do_total_efficiency
self.mon_alg_single.RequireOfflineTaus = self.require_offline_taus
self.mon_alg_single.HLTTauIDScores = self.hlt_tauid_scores
self.mon_alg_single.OfflineTauIDScores = self.offline_tauid_scores
self.logger.info(' |- Booking all histograms')
for trigger in self.HLT_single_items:
......@@ -240,16 +263,18 @@ class TrigTauMonAlgBuilder:
# Online distributions
for p in ('0P', '1P', 'MP'):
self.bookBasicVars(self.mon_alg_single, self.base_path, trigger, n_prong=p, online=True)
self.bookRNNInputScalar(self.mon_alg_single, self.base_path, trigger, n_prong=p, online=True)
self.bookRNNInputTrack(self.mon_alg_single, self.base_path, trigger, online=True)
self.bookRNNInputCluster(self.mon_alg_single, self.base_path, trigger, online=True)
self.bookIDScores(self.mon_alg_single, self.base_path, trigger, n_prong=p, online=True)
self.bookIDInputScalar(self.mon_alg_single, self.base_path, trigger, n_prong=p, online=True)
self.bookIDInputTrack(self.mon_alg_single, self.base_path, trigger, online=True)
self.bookIDInputCluster(self.mon_alg_single, self.base_path, trigger, online=True)
# Offline distributions
for p in ('1P', '3P'):
self.bookBasicVars(self.mon_alg_single, self.base_path, trigger, p, online=False)
self.bookRNNInputScalar(self.mon_alg_single, self.base_path, trigger, n_prong=p, online=False)
self.bookRNNInputTrack(self.mon_alg_single, self.base_path, trigger, online=False)
self.bookRNNInputCluster(self.mon_alg_single, self.base_path, trigger, online=False)
self.bookIDScores(self.mon_alg_single, self.base_path, trigger, p, online=False)
self.bookIDInputScalar(self.mon_alg_single, self.base_path, trigger, n_prong=p, online=False)
self.bookIDInputTrack(self.mon_alg_single, self.base_path, trigger, online=False)
self.bookIDInputCluster(self.mon_alg_single, self.base_path, trigger, online=False)
if self.do_duplicate_var_plots_without_offline_taus:
self.mon_alg_single_no_offline = self._configureAlgorithm(CompFactory.TrigTauMonitorSingleAlgorithm, 'TrigTauMonAlgSingleNoOffline')
......@@ -257,15 +282,17 @@ class TrigTauMonAlgBuilder:
self.mon_alg_single_no_offline.RequireOfflineTaus = False
self.mon_alg_single_no_offline.DoOfflineTausDistributions = False
self.mon_alg_single_no_offline.DoEfficiencyPlots = False
self.mon_alg_single_no_offline.HLTTauIDScores = self.hlt_tauid_scores
self.logger.info(' |- Booking all histograms')
path = f'{self.base_path}/OnlineOnlyVars'
for trigger in self.HLT_single_items:
for p in ('0P', '1P', 'MP'):
self.bookBasicVars(self.mon_alg_single_no_offline, path, trigger, n_prong=p, online=True)
self.bookRNNInputScalar(self.mon_alg_single_no_offline, path, trigger, n_prong=p, online=True)
self.bookRNNInputTrack(self.mon_alg_single_no_offline, path, trigger, online=True)
self.bookRNNInputCluster(self.mon_alg_single_no_offline, path, trigger, online=True)
self.bookIDScores(self.mon_alg_single_no_offline, path, trigger, n_prong=p, online=True)
self.bookIDInputScalar(self.mon_alg_single_no_offline, path, trigger, n_prong=p, online=True)
self.bookIDInputTrack(self.mon_alg_single_no_offline, path, trigger, online=True)
self.bookIDInputCluster(self.mon_alg_single_no_offline, path, trigger, online=True)
def configureAlgorithmDiTau(self):
......@@ -386,9 +413,9 @@ class TrigTauMonAlgBuilder:
treedef='tauPt/F:tauEta/F:tauPhi/F:averageMu/F:HLT_pass/I')
def bookRNNInputScalar(self, mon_alg, base_path, trigger, n_prong, online):
def bookIDInputScalar(self, mon_alg, base_path, trigger, n_prong, online):
type_str = 'HLT' if online else 'Offline'
mon_group_name = f'{trigger}_RNN_{type_str}_InputScalar_{n_prong}'
mon_group_name = f'{trigger}_ID_{type_str}_InputScalar_{n_prong}'
mon_group_path = f'{base_path}/RNNVars/InputScalar_{n_prong}/{trigger}/{type_str}'
mon_group = self.helper.addGroup(mon_alg, mon_group_name, mon_group_path)
......@@ -406,9 +433,9 @@ class TrigTauMonAlgBuilder:
mon_group.defineHistogram('trFlightPathSig', title=f'trFlightPathSig ({n_prong}); trFlightPathSig; Events', xbins=100, xmin=-20, xmax=40, opt='kAlwaysCreate')
def bookRNNInputTrack(self, mon_alg, base_path, trigger, online):
def bookIDInputTrack(self, mon_alg, base_path, trigger, online):
type_str = 'HLT' if online else 'Offline'
mon_group_name = f'{trigger}_RNN_{type_str}_InputTrack'
mon_group_name = f'{trigger}_ID_{type_str}_InputTrack'
mon_group_path = f'{base_path}/RNNVars/InputTrack/{trigger}/{type_str}'
mon_group = self.helper.addGroup(mon_alg, mon_group_name, mon_group_path)
......@@ -428,9 +455,9 @@ class TrigTauMonAlgBuilder:
mon_group.defineHistogram('track_dEta,track_dPhi', type='TH2F', title='Track #Delta#eta vs #Delta#phi; #Delta#eta; #Delta#phi', xbins=100, xmin=-0.5, xmax=0.5, ybins=100, ymin=-0.5, ymax=0.5, opt='kAlwaysCreate')
def bookRNNInputCluster(self, mon_alg, base_path, trigger, online):
def bookIDInputCluster(self, mon_alg, base_path, trigger, online):
type_str = 'HLT' if online else 'Offline'
mon_group_name = f'{trigger}_RNN_{type_str}_InputCluster'
mon_group_name = f'{trigger}_ID_{type_str}_InputCluster'
mon_group_path = f'{base_path}/RNNVars/InputCluster/{trigger}/{type_str}'
mon_group = self.helper.addGroup(mon_alg, mon_group_name, mon_group_path)
......@@ -448,6 +475,33 @@ class TrigTauMonAlgBuilder:
mon_group.defineHistogram('cluster_dEta,cluster_dPhi', type='TH2F', title='Cluster #Delta#eta vs #Delta#phi; #Delta#eta; #Delta#phi', xbins=100, xmin=-0.5, xmax=0.5, ybins=100, ymin=-0.5, ymax=0.5, opt='kAlwaysCreate')
def bookIDScores(self, mon_alg, base_path, trigger, n_prong, online):
info = self.getTriggerInfo(trigger)
store_all = info.getHLTTauID() in ['idperf', 'perf']
if online:
if info.getHLTTauType() not in self.hlt_tauid_scores: return
variables = {
tau_id: p
for tau_id, p in self.hlt_tauid_scores[info.getHLTTauType()].items()
if tau_id == info.getHLTTauID() or store_all
}
else:
variables = self.offline_tauid_scores
type_str = 'HLT' if online else 'Offline'
mon_group_name = f'{trigger}_{type_str}_IDScores_{n_prong}'
mon_group_path = f'{base_path}/basicVars/{trigger}/{type_str}_{n_prong}'
mon_group = self.helper.addGroup(mon_alg, mon_group_name, mon_group_path)
for tau_id, (score, score_sig_trans) in variables.items():
if tau_id in ['RNN', 'DeepSet', 'RNNLLP']: xbins, xmax = 20, 1
else: xbins, xmax = 100, 5
mon_group.defineHistogram(f'{tau_id}_TauIDScore;RNNScore', title=f'{type_str} {tau_id} TauID score; TauID score; Events', xbins=xbins, xmin=0, xmax=xmax, opt='kAlwaysCreate')
mon_group.defineHistogram(f'{tau_id}_TauIDScoreSigTrans;RNNScoreSigTrans', title=f'{type_str} {tau_id} TauID score sig. transformed; TauID score sig. transformed; Events', xbins=xbins, xmin=0, xmax=xmax, opt='kAlwaysCreate')
def bookBasicVars(self, mon_alg, base_path, trigger, n_prong, online):
type_str = 'HLT' if online else 'Offline'
mon_group_name = f'{trigger}_{type_str}_basicVars_{n_prong}'
......@@ -463,9 +517,7 @@ class TrigTauMonAlgBuilder:
mon_group.defineHistogram('Eta,Phi', type='TH2F', title=f'{type_str} #eta vs #phi; #eta; #phi', xbins=26, xmin=-2.6, xmax=2.6, ybins=16, ymin=-3.2, ymax=3.2, opt='kAlwaysCreate')
mon_group.defineHistogram('Pt,Phi', type='TH2F', title=f'{type_str} p_{{T}} vs #phi; p_{{T}} [GeV]; #phi', xbins=binning, ybins=16, ymin=-3.2, ymax=3.2, opt='kAlwaysCreate')
mon_group.defineHistogram('Pt,Eta', type='TH2F', title=f'{type_str} p_{{T}} vs #eta; p_{{T}} [GeV]; #eta', xbins=binning, ybins=26, ymin=-2.6, ymax=2.6, opt='kAlwaysCreate')
mon_group.defineHistogram('nWideTrack', title=f'{type_str} Number of wide tracks; N_{{track}}^{{wide}}; Events', xbins=10, xmin=0, xmax=10, opt='kAlwaysCreate')
mon_group.defineHistogram('RNNScore', title=f'{type_str} RNN score; RNN score; Events', xbins=20, xmin=0, xmax=1, opt='kAlwaysCreate')
mon_group.defineHistogram('RNNScoreSigTrans', title=f'{type_str} RNN Sig Trans score; RNN Sig Trans score; Events', xbins=20, xmin=0, xmax=1, opt='kAlwaysCreate')
mon_group.defineHistogram('nIsoTrack;nWideTrack', title=f'{type_str} Number of isolation tracks; N_{{track}}^{{iso}}; Events', xbins=10, xmin=0, xmax=10, opt='kAlwaysCreate')
mon_group.defineHistogram('averageMu', title=f'{type_str} Average #mu; #LT#mu$GT; Events', xbins=20, xmin=0, xmax=80, opt='kAlwaysCreate')
mon_group.defineHistogram('TauVertexX', title=f'{type_str} Tau Vertex X; x [mm]; Events', xbins=100, xmin=-1, xmax=1, opt='kAlwaysCreate')
mon_group.defineHistogram('TauVertexY', title=f'{type_str} Tau Vertex Y; y [mm]; Events', xbins=100, xmin=-2, xmax=0, opt='kAlwaysCreate')
......
Trigger/TrigMonitoring/TrigTauMonitoring/src/TrigTauMonitorSingleAlgorithm.cxx
+ 124
− 41
View file @ a2f0d515
......@@ -10,6 +10,47 @@ TrigTauMonitorSingleAlgorithm::TrigTauMonitorSingleAlgorithm(const std::string&
{}
StatusCode TrigTauMonitorSingleAlgorithm::initialize()
{
ATH_CHECK( TrigTauMonitorBaseAlgorithm::initialize() );
// Create the "cache" of TauID score accessors for the Monitoring...
for(const auto& [seq_name, m] : m_monitoredHLTIdScores) {
for(const auto& [key, p] : m) {
if(p.first.empty() || p.second.empty()) {
ATH_MSG_WARNING("Invalid HLT TauID score variable names; skipping this entry for the monitoring!");
continue;
}
m_monitoredHLTIdAccessors[seq_name].emplace(
key,
std::make_pair(
SG::AuxElement::ConstAccessor<float>(p.first),
SG::AuxElement::ConstAccessor<float>(p.second)
)
);
}
}
for(const auto& [key, p] : m_monitoredOfflineIdScores) {
if(p.first.empty() || p.second.empty()) {
ATH_MSG_WARNING("Invalid Offline TauID score variable names; skipping this entry for the monitoring!");
continue;
}
m_monitoredOfflineIdAccessors.emplace(
key,
std::make_pair(
SG::AuxElement::ConstAccessor<float>(p.first),
SG::AuxElement::ConstAccessor<float>(p.second)
)
);
}
return StatusCode::SUCCESS;
}
StatusCode TrigTauMonitorSingleAlgorithm::processEvent(const EventContext& ctx) const
{
constexpr float threshold_offset = 10.0;
......@@ -43,45 +84,50 @@ StatusCode TrigTauMonitorSingleAlgorithm::processEvent(const EventContext& ctx)
std::vector<const xAOD::TauJet*> hlt_taus_1p = std::get<1>(hlt_taus);
std::vector<const xAOD::TauJet*> hlt_taus_mp = std::get<2>(hlt_taus);
if(m_do_variable_plots) {
if(m_do_variable_plots) {
// Offline variables:
if(m_doOfflineTausDistributions && !offline_taus_1p.empty()) {
fillBasicVars(ctx, trigger, offline_taus_1p, "1P", false);
fillRNNInputVars(trigger, offline_taus_1p, "1P", false);
fillRNNTrack(trigger, offline_taus_1p, false);
fillRNNCluster(trigger, offline_taus_1p, false);
fillIDScores(trigger, offline_taus_1p, "1P", false);
fillIDInputVars(trigger, offline_taus_1p, "1P", false);
fillIDTrack(trigger, offline_taus_1p, false);
fillIDCluster(trigger, offline_taus_1p, false);
}
if(m_doOfflineTausDistributions && !offline_taus_3p.empty()) {
fillBasicVars(ctx, trigger, offline_taus_3p, "3P", false);
fillRNNInputVars(trigger, offline_taus_3p, "3P", false);
fillRNNTrack(trigger, offline_taus_3p, false);
fillRNNCluster(trigger, offline_taus_3p, false);
fillIDScores(trigger, offline_taus_3p, "3P", false);
fillIDInputVars(trigger, offline_taus_3p, "3P", false);
fillIDTrack(trigger, offline_taus_3p, false);
fillIDCluster(trigger, offline_taus_3p, false);
}
// Fill information for online 0 prong taus
if(!hlt_taus_0p.empty()) {
fillBasicVars(ctx, trigger, hlt_taus_0p, "0P", true);
fillRNNInputVars(trigger, hlt_taus_0p, "0P", true);
fillRNNTrack(trigger, hlt_taus_0p, true);
fillRNNCluster(trigger, hlt_taus_0p, true);
fillIDScores(trigger, hlt_taus_0p, "0P", true);
fillIDInputVars(trigger, hlt_taus_0p, "0P", true);
fillIDTrack(trigger, hlt_taus_0p, true);
fillIDCluster(trigger, hlt_taus_0p, true);
}
// Fill information for online 1 prong taus
if(!hlt_taus_1p.empty()) {
fillBasicVars(ctx, trigger, hlt_taus_1p, "1P", true);
fillRNNInputVars(trigger, hlt_taus_1p, "1P", true);
fillRNNTrack(trigger, hlt_taus_1p, true);
fillRNNCluster(trigger, hlt_taus_1p, true);
fillIDScores(trigger, hlt_taus_1p, "1P", true);
fillIDInputVars(trigger, hlt_taus_1p, "1P", true);
fillIDTrack(trigger, hlt_taus_1p, true);
fillIDCluster(trigger, hlt_taus_1p, true);
}
// Fill information for online multiprong prong taus
if(!hlt_taus_mp.empty()) {
fillBasicVars(ctx, trigger, hlt_taus_mp, "MP", true);
fillRNNInputVars(trigger, hlt_taus_mp, "MP", true);
fillRNNTrack(trigger, hlt_taus_mp, true);
fillRNNCluster(trigger, hlt_taus_mp, true);
fillIDScores(trigger, hlt_taus_mp, "MP", true);
fillIDInputVars(trigger, hlt_taus_mp, "MP", true);
fillIDTrack(trigger, hlt_taus_mp, true);
fillIDCluster(trigger, hlt_taus_mp, true);
}
}
}
if(m_do_efficiency_plots && hlt_not_prescaled_flag) {
fillHLTEfficiencies(ctx, trigger, l1_accept_flag, offline_taus_1p, hlt_taus_all, "1P");
......@@ -162,11 +208,11 @@ void TrigTauMonitorSingleAlgorithm::fillHLTEfficiencies(const EventContext& ctx,
}
void TrigTauMonitorSingleAlgorithm::fillRNNInputVars(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec,const std::string& nProng, bool online) const
void TrigTauMonitorSingleAlgorithm::fillIDInputVars(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec,const std::string& nProng, bool online) const
{
ATH_MSG_DEBUG("Fill RNN input variables: " << trigger);
ATH_MSG_DEBUG("Fill ID input variables: " << trigger);
auto monGroup = getGroup(trigger+"_RNN_"+(online ? "HLT" : "Offline")+"_InputScalar_"+nProng);
auto monGroup = getGroup(trigger+"_ID_"+(online ? "HLT" : "Offline")+"_InputScalar_"+nProng);
auto centFrac = Monitored::Collection("centFrac", tau_vec, [](const xAOD::TauJet* tau){
float detail = -999;
......@@ -227,22 +273,22 @@ void TrigTauMonitorSingleAlgorithm::fillRNNInputVars(const std::string& trigger,
fill(monGroup, centFrac, etOverPtLeadTrk, dRmax, absipSigLeadTrk, sumPtTrkFrac, emPOverTrkSysP, ptRatioEflowApprox, mEflowApprox, ptDetectorAxis, massTrkSys, trFlightPathSig);
ATH_MSG_DEBUG("After fill RNN input variables: " << trigger);
ATH_MSG_DEBUG("After fill ID input variables: " << trigger);
}
void TrigTauMonitorSingleAlgorithm::fillRNNTrack(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const
void TrigTauMonitorSingleAlgorithm::fillIDTrack(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const
{
ATH_MSG_DEBUG("Fill RNN input Track: " << trigger);
ATH_MSG_DEBUG("Fill ID input Track: " << trigger);
auto monGroup = getGroup(trigger+"_RNN_"+(online ? "HLT" : "Offline")+"_InputTrack");
auto monGroup = getGroup(trigger+"_ID_"+(online ? "HLT" : "Offline")+"_InputTrack");
auto track_pt_jetseed_log = Monitored::Collection("track_pt_jetseed_log", tau_vec, [](const xAOD::TauJet* tau){ return std::log10(tau->ptJetSeed()); });
fill(monGroup, track_pt_jetseed_log);
for(const auto *tau : tau_vec) {
// Don't call ->allTracks() unless the element links are valid
const SG::AuxElement::ConstAccessor< std::vector<ElementLink<xAOD::TauTrackContainer>> > tauTrackAcc("tauTrackLinks");
static const SG::AuxElement::ConstAccessor< std::vector<ElementLink<xAOD::TauTrackContainer>> > tauTrackAcc("tauTrackLinks");
bool linksValid = true;
for(const ElementLink<xAOD::TauTrackContainer>& trackEL : tauTrackAcc(*tau)) {
if(!trackEL.isValid()) {
......@@ -250,7 +296,6 @@ void TrigTauMonitorSingleAlgorithm::fillRNNTrack(const std::string& trigger, con
break;
}
}
if(!linksValid) {
ATH_MSG_WARNING("Invalid track element links from TauJet in " << trigger);
continue;
......@@ -259,16 +304,18 @@ void TrigTauMonitorSingleAlgorithm::fillRNNTrack(const std::string& trigger, con
auto tracks = tau->allTracks();
std::sort(tracks.begin(), tracks.end(), [](const xAOD::TauTrack* lhs, const xAOD::TauTrack* rhs){ return lhs->pt() > rhs->pt(); });
auto n_track = Monitored::Scalar<int>("n_track",0);
n_track = tracks.size();
auto n_track = Monitored::Scalar<int>("n_track", tracks.size());
auto track_pt_log = Monitored::Collection("track_pt_log", tracks, [](const xAOD::TauTrack *track){ return std::log10(track->pt()); });
auto track_eta = Monitored::Collection("track_eta", tracks, [](const xAOD::TauTrack *track){ return track->eta(); });
auto track_phi = Monitored::Collection("track_phi", tracks, [](const xAOD::TauTrack *track){ return track->phi(); });
auto track_dEta = Monitored::Collection("track_dEta", tracks, [&tau](const xAOD::TauTrack *track){ return track->eta() - tau->eta(); });
auto track_dPhi = Monitored::Collection("track_dPhi", tracks, [&tau](const xAOD::TauTrack *track){ return track->p4().DeltaPhi(tau->p4()); });
auto track_z0sinthetaTJVA_abs_log = Monitored::Collection("track_z0sinthetaTJVA_abs_log", tracks, [](const xAOD::TauTrack *track){return track->z0sinthetaTJVA(); });
auto track_d0_abs_log = Monitored::Collection("track_d0_abs_log", tracks, [](const xAOD::TauTrack *track){ return std::log10(std::abs(track->track()->d0()) + 1e-6); });
auto track_nIBLHitsAndExp = Monitored::Collection("track_nIBLHitsAndExp", tracks, [](const xAOD::TauTrack *track){
uint8_t inner_pixel_hits, inner_pixel_exp;
const auto success1_innerPixel_hits = track->track()->summaryValue(inner_pixel_hits, xAOD::numberOfInnermostPixelLayerHits);
......@@ -297,15 +344,15 @@ void TrigTauMonitorSingleAlgorithm::fillRNNTrack(const std::string& trigger, con
fill(monGroup, n_track, track_pt_log, track_eta, track_phi, track_dEta, track_dPhi, track_z0sinthetaTJVA_abs_log, track_d0_abs_log, track_nIBLHitsAndExp, track_nPixelHitsPlusDeadSensors, track_nSCTHitsPlusDeadSensors);
}
ATH_MSG_DEBUG("After fill RNN input Track: " << trigger);
ATH_MSG_DEBUG("After fill ID input Track: " << trigger);
}
void TrigTauMonitorSingleAlgorithm::fillRNNCluster(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const
void TrigTauMonitorSingleAlgorithm::fillIDCluster(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const
{
ATH_MSG_DEBUG("Fill RNN input Cluster: " << trigger << " for online/offline " << online);
ATH_MSG_DEBUG("Fill ID input Cluster: " << trigger << " for online/offline " << online);
auto monGroup = getGroup(trigger+"_RNN_"+(online ? "HLT" : "Offline")+"_InputCluster");
auto monGroup = getGroup(trigger+"_ID_"+(online ? "HLT" : "Offline")+"_InputCluster");
for(const auto *tau : tau_vec){
auto cluster_pt_jetseed_log = Monitored::Collection("cluster_pt_jetseed_log", tau_vec, [](const xAOD::TauJet* tau){ return std::log10(tau->ptJetSeed()); });
......@@ -349,7 +396,7 @@ void TrigTauMonitorSingleAlgorithm::fillRNNCluster(const std::string& trigger, c
fill(monGroup, n_cluster, cluster_pt_jetseed_log, cluster_et_log, cluster_eta, cluster_phi, cluster_dEta, cluster_dPhi, cluster_SECOND_R_log10, cluster_SECOND_LAMBDA_log10, cluster_CENTER_LAMBDA_log10);
}
ATH_MSG_DEBUG("After fill RNN input Cluster: " << trigger);
ATH_MSG_DEBUG("After fill ID input Cluster: " << trigger);
}
......@@ -361,17 +408,14 @@ void TrigTauMonitorSingleAlgorithm::fillBasicVars(const EventContext& ctx, const
auto Pt = Monitored::Collection("Pt", tau_vec, [](const xAOD::TauJet* tau){ return tau->pt()/Gaudi::Units::GeV; });
auto Eta = Monitored::Collection("Eta", tau_vec, [](const xAOD::TauJet* tau){ return tau->eta(); });
auto Phi = Monitored::Collection("Phi", tau_vec, [](const xAOD::TauJet* tau){ return tau->phi(); });
auto nTrack = Monitored::Collection("nTrack", tau_vec, [](const xAOD::TauJet* tau){
int nTrack = -1;
tau->detail(xAOD::TauJetParameters::nChargedTracks, nTrack);
return nTrack;
});
auto nWideTrack = Monitored::Collection("nWideTrack", tau_vec, [](const xAOD::TauJet* tau){ return tau->nTracksIsolation(); });
auto RNNScore = Monitored::Collection("RNNScore", tau_vec, [](const xAOD::TauJet* tau){ return tau->discriminant(xAOD::TauJetParameters::RNNJetScore); });
auto RNNScoreSigTrans = Monitored::Collection("RNNScoreSigTrans", tau_vec, [](const xAOD::TauJet* tau){ return tau->discriminant(xAOD::TauJetParameters::RNNJetScoreSigTrans); });
auto nIsoTrack = Monitored::Collection("nIsoTrack", tau_vec, [](const xAOD::TauJet* tau){ return tau->nTracksIsolation(); });
auto averageMu = Monitored::Scalar<float>("averageMu", 0.0);
averageMu = lbAverageInteractionsPerCrossing(ctx);
......@@ -381,25 +425,64 @@ void TrigTauMonitorSingleAlgorithm::fillBasicVars(const EventContext& ctx, const
if(tau->vertex() != nullptr) vtx = tau->vertex()->x();
return vtx;
});
auto TauVertexY = Monitored::Collection("TauVertexY", tau_vec, [](const xAOD::TauJet* tau){
double vty = -999;
if(tau->vertex() != nullptr) vty = tau->vertex()->y();
return vty;
});
auto TauVertexZ = Monitored::Collection("TauVertexZ", tau_vec, [](const xAOD::TauJet* tau){
double vtz = -999;
if(tau->vertex() != nullptr) vtz = tau->vertex()->z();
return vtz;
});
fill(monGroup, Pt, Eta, Phi, nTrack, nWideTrack, RNNScore, RNNScoreSigTrans, averageMu, TauVertexX, TauVertexY, TauVertexZ);
fill(monGroup, Pt, Eta, Phi, nTrack, nIsoTrack, averageMu, TauVertexX, TauVertexY, TauVertexZ);
ATH_MSG_DEBUG("After fill Basic variables: " << trigger);
}
void TrigTauMonitorSingleAlgorithm::fillIDScores(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, const std::string& nProng, bool online) const
{
ATH_MSG_DEBUG("Fill TauID Scores: " << trigger);
const TrigTauInfo& info = getTrigInfo(trigger);
const std::string tau_id = info.getHLTTauID();
bool store_all = tau_id == "idperf" || tau_id == "perf";
if(online) {
if(m_monitoredHLTIdAccessors.find(info.getHLTTauType()) == m_monitoredHLTIdAccessors.end()) return;
} else {
if(m_monitoredOfflineIdAccessors.size() == 0) return;
}
const auto& idAccessors = online ? m_monitoredHLTIdAccessors.at(info.getHLTTauType()) : m_monitoredOfflineIdAccessors;
// This has to be down here, because otherwise we crash on unmonitored chains
auto monGroup = getGroup(trigger+"_"+(online ? "HLT" : "Offline")+"_IDScores_"+nProng);
for(const auto& [key, p] : idAccessors) {
// We will either store the TauID scores indicated in the chain name, or all of them in case of (id)perf chains
if(online && !store_all && tau_id != key) continue;
std::vector<float> score, score_sig_trans;
for(const xAOD::TauJet* tau : tau_vec) {
// Skip if both the Score and ScoreSigTrans aren't available
if(!p.first.isAvailable(*tau) || !p.second.isAvailable(*tau)) continue;
score.push_back(p.first(*tau));
score_sig_trans.push_back(p.second(*tau));
}
auto IDScore = Monitored::Collection(key + "_TauIDScore", score);
auto IDScoreSigTrans = Monitored::Collection(key + "_TauIDScoreSigTrans", score_sig_trans);
fill(monGroup, IDScore, IDScoreSigTrans);
}
ATH_MSG_DEBUG("After fill TauID Scores: " << trigger);
}
std::vector<TLorentzVector> TrigTauMonitorSingleAlgorithm::getRoIsVector(const EventContext& ctx, const std::string& trigger) const
{
std::vector<TLorentzVector> ret;
......
Trigger/TrigMonitoring/TrigTauMonitoring/src/TrigTauMonitorSingleAlgorithm.h
+ 15
− 3
View file @ a2f0d515
......@@ -5,11 +5,14 @@
#ifndef TRIGTAUMONITORING_TRIGTAUMONITORSINGLEALGORITHM_H
#define TRIGTAUMONITORING_TRIGTAUMONITORSINGLEALGORITHM_H
#include "Gaudi/Parsers/Factory.h"
#include "TrigTauMonitorBaseAlgorithm.h"
class TrigTauMonitorSingleAlgorithm : public TrigTauMonitorBaseAlgorithm {
public:
TrigTauMonitorSingleAlgorithm(const std::string& name, ISvcLocator* pSvcLocator);
virtual StatusCode initialize() override;
private:
// Enable total efficiency histograms
......@@ -23,13 +26,22 @@ private:
// Do offline taus variable distributions
Gaudi::Property<bool> m_doOfflineTausDistributions{this, "DoOfflineTausDistributions", true};
// HLT TauID score monitoring
Gaudi::Property<std::map<std::string, std::map<std::string, std::pair<std::string, std::string>>>> m_monitoredHLTIdScores {this, "HLTTauIDScores", {}, "Pairs of the TauID score and signal-transformed scores for each HLT TauID algorithm to be monitored, for each reconstruction sequence (type, e.g. tracktwoMVA, tracktwoLLP, etc...)"};
std::map<std::string, std::map<std::string, std::pair<SG::AuxElement::ConstAccessor<float>, SG::AuxElement::ConstAccessor<float>>>> m_monitoredHLTIdAccessors;
// Offline TauID score monitoring
Gaudi::Property<std::map<std::string, std::pair<std::string, std::string>>> m_monitoredOfflineIdScores {this, "OfflineTauIDScores", {}, "Pairs of the TauID score and signal-transformed scores for each Offline TauID algorithm to be monitored"};
std::map<std::string, std::pair<SG::AuxElement::ConstAccessor<float>, SG::AuxElement::ConstAccessor<float>>> m_monitoredOfflineIdAccessors;
virtual StatusCode processEvent(const EventContext& ctx) const override;
void fillHLTEfficiencies(const EventContext& ctx,const std::string& trigger, const bool l1_accept_flag, const std::vector<const xAOD::TauJet*>& offline_tau_vec, const std::vector<const xAOD::TauJet*>& online_tau_vec, const std::string& nProng) const;
void fillRNNInputVars(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec,const std::string& nProng, bool online) const;
void fillRNNTrack(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const;
void fillRNNCluster(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const;
void fillIDInputVars(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec,const std::string& nProng, bool online) const;
void fillIDTrack(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const;
void fillIDCluster(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, bool online) const;
void fillBasicVars(const EventContext& ctx, const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, const std::string& nProng, bool online) const;
void fillIDScores(const std::string& trigger, const std::vector<const xAOD::TauJet*>& tau_vec, const std::string& nProng, bool online) const;
std::vector<TLorentzVector> getRoIsVector(const EventContext& ctx, const std::string& trigger) const;
};
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment