diff --git a/dqm/scripts/daqdqm/commondqm.py b/dqm/scripts/daqdqm/commondqm.py index 47241725b5..3435bb4bf5 100644 --- a/dqm/scripts/daqdqm/commondqm.py +++ b/dqm/scripts/daqdqm/commondqm.py @@ -192,13 +192,17 @@ def read_lines(category): path.add_module( "SoftwareTriggerHLTDQM", cutResultIdentifiers=cutResultIdentifiers, - l1Identifiers=["fff", "ffo", "lml0", "ffb", "fp"], + l1Identifiers=["fff", "ffo", "lml0", "ffb", "fp", "passive_veto"], additionalL1Identifiers=additionalL1Identifiers, createHLTUnitHistograms=create_hlt_unit_histograms, cutResultIdentifiersPerUnit=hlt_trigger_lines_per_unit_in_plot, pathLocation="after filter", ) + path.add_module("StatisticsTimingHLTDQM", + histogramDirectoryName="timing_statistics_after_filter" + ).set_name("StatisticsTimingHLTDQM_after_filter") + path.add_module("TrackingAbortDQM") path.add_module("DetectorOccupanciesDQM") diff --git a/hlt/softwaretrigger/modules/dqm/SConscript b/hlt/softwaretrigger/modules/dqm/SConscript index 4e3f0c4929..2309c87dcd 100644 --- a/hlt/softwaretrigger/modules/dqm/SConscript +++ b/hlt/softwaretrigger/modules/dqm/SConscript @@ -10,7 +10,8 @@ env['LIBS'] = [ 'hlt_softwaretrigger_dataobjects', 'hlt', 'klm_dataobjects', - 'ecl_dataobjects' + 'ecl_dataobjects', + 'svd_dataobjects' ] Return('env') diff --git a/hlt/softwaretrigger/modules/dqm/include/StatisticsTimingHLTDQMModule.h b/hlt/softwaretrigger/modules/dqm/include/StatisticsTimingHLTDQMModule.h index 0d77262f92..1bf65ad706 100644 --- a/hlt/softwaretrigger/modules/dqm/include/StatisticsTimingHLTDQMModule.h +++ b/hlt/softwaretrigger/modules/dqm/include/StatisticsTimingHLTDQMModule.h @@ -8,10 +8,17 @@ #pragma once #include +#include +#include +#include +#include +#include +#include #include #include class TH1F; +class TH2F; namespace Belle2 { namespace SoftwareTrigger { @@ -73,6 +80,30 @@ namespace Belle2 { /// Number of processes per unit TH1F* m_processesPerUnitHistogram; + /// Processing time distribution of events passing passive injection veto + TH1F* m_processingTimePassiveVeto; + + /// Processing time distribution of events not passing passive injection veto + TH1F* m_processingTimeNotPassiveVeto; + + /// Processing time vs nSVDShaperDigits distribution of events passing passive injection veto + TH2F* m_procTimeVsnSVDShaperDigitsPassiveVeto; + + /// Processing time vs nSVDShaperDigits distribution of events not passing passive injection veto + TH2F* m_procTimeVsnSVDShaperDigitsNotPassiveVeto; + + /// Processing time vs nCDCHits distribution of events passing passive injection veto + TH2F* m_procTimeVsnCDCHitsPassiveVeto; + + /// Processing time vs nCDCHits distribution of events not passing passive injection veto + TH2F* m_procTimeVsnCDCHitsNotPassiveVeto; + + /// Processing time vs nECLDigits distribution of events passing passive injection veto + TH2F* m_procTimeVsnECLDigitsPassiveVeto; + + /// Processing time vs nECLDigits distribution of events not passing passive injection veto + TH2F* m_procTimeVsnECLDigitsNotPassiveVeto; + /// Storage for the last full time sum double m_lastFullTimeSum = 0; @@ -120,6 +151,36 @@ namespace Belle2 { /// Number of bins for the histograms of fullMemory const double m_fullMemoryNBins = 100; + + /// Maximum for the histograms of nSVDShaperDigits + const double m_nSVDShaperDigitsMax = 20000; + + /// Number of bins for the histograms of nSVDShaperDigits + const double m_nSVDShaperDigitsNBins = 100; + + /// Maximum for the histograms of nCDCHits + const double m_nCDCHitsMax = 10000; + + /// Number of bins for the histograms of nCDCHits + const double m_nCDCHitsNBins = 100; + + /// Maximum for the histograms of nECLDigits + const double m_nECLDigitsMax = 10000; + + /// Number of bins for the histograms of nECLDigits + const double m_nECLDigitsNBins = 100; + + /// TRG Summary + StoreObjPtr m_trgSummary; + + /// SVD strips + StoreArray m_svdShaperDigits; + + /// CDC Hits + StoreArray m_cdcHits; + + /// ECL Digits + StoreArray m_eclDigits; }; } diff --git a/hlt/softwaretrigger/modules/dqm/src/SoftwareTriggerHLTDQMModule.cc b/hlt/softwaretrigger/modules/dqm/src/SoftwareTriggerHLTDQMModule.cc index 85d80c737a..9c69b37045 100644 --- a/hlt/softwaretrigger/modules/dqm/src/SoftwareTriggerHLTDQMModule.cc +++ b/hlt/softwaretrigger/modules/dqm/src/SoftwareTriggerHLTDQMModule.cc @@ -101,6 +101,32 @@ void SoftwareTriggerHLTDQMModule::defineHisto() m_triggerVariablesHistograms[variable]->SetXTitle(("SoftwareTriggerVariable " + variable).c_str()); } + for (const std::string& trigger : m_param_l1Identifiers) { + m_l1Histograms.emplace(trigger, new TH1F(trigger.c_str(), ("Events triggered in L1 " + trigger).c_str(), 150, 0, 150)); + m_l1Histograms[trigger]->SetXTitle("HLT line"); + m_l1Histograms[trigger]->SetOption("hist"); + m_l1Histograms[trigger]->SetStats(false); + m_l1Histograms[trigger]->SetMinimum(0); + + float index = 0; + for (auto const& cutIdentifier : m_param_cutResultIdentifiers) { + const std::string& title = cutIdentifier.first; + const auto& mapVal = *(m_param_cutResultIdentifiers[title].begin()); + const std::string& baseIdentifier = mapVal.first; + const auto& cuts = mapVal.second; + + if (title == baseIdentifier) { + for (const std::string& cutTitle : cuts) { + index++; + m_l1Histograms[trigger]->GetXaxis()->SetBinLabel(index, cutTitle.c_str()); + } + } + } + index++; + m_l1Histograms[trigger]->GetXaxis()->SetBinLabel(index, "hlt_result"); + m_l1Histograms[trigger]->LabelsDeflate(); + } + for (const auto& cutIdentifier : m_param_cutResultIdentifiers) { const std::string& title = cutIdentifier.first; @@ -154,18 +180,7 @@ void SoftwareTriggerHLTDQMModule::defineHisto() m_cutResultHistograms["total_result"]->SetOption("hist"); m_cutResultHistograms["total_result"]->SetStats(false); m_cutResultHistograms["total_result"]->SetMinimum(0); - } - for (const std::string& trigger : m_param_l1Identifiers) { - m_l1Histograms.emplace(trigger, new TH1F(trigger.c_str(), ("Events triggered in L1 " + trigger).c_str(), 1, 0, 0)); - m_l1Histograms[trigger]->SetXTitle(""); - m_l1Histograms[trigger]->SetOption("hist"); - m_l1Histograms[trigger]->SetStats(false); - m_l1Histograms[trigger]->SetMinimum(0); - } - - // And also one for the total numbers - if (m_param_create_total_result_histograms) { m_l1Histograms.emplace("l1_total_result", new TH1F("l1_total_result", "Events triggered in L1 (total results)", 1, 0, 0)); m_l1Histograms["l1_total_result"]->SetXTitle("Total L1 Cut Result"); @@ -351,21 +366,19 @@ void SoftwareTriggerHLTDQMModule::event() } } - if (m_l1TriggerResult.isValid() and m_l1NameLookup.isValid()) { + if (m_l1TriggerResult.isValid()) { float l1Index = 0; for (const std::string& l1Trigger : m_param_l1Identifiers) { l1Index++; - const int triggerBit = m_l1NameLookup->getoutbitnum(l1Trigger.c_str()); - if (triggerBit < 0) { - B2WARNING("Could not find" - << LogVar("L1 trigger line", l1Trigger)); - continue; - } bool triggerResult; try { - triggerResult = m_l1TriggerResult->testPsnm(triggerBit); + triggerResult = m_l1TriggerResult->testPsnm(l1Trigger.c_str()); } catch (const std::exception&) { - triggerResult = false; + try { + triggerResult = m_l1TriggerResult->testInput(l1Trigger.c_str()); + } catch (const std::exception&) { + triggerResult = false; + } } if (m_param_create_total_result_histograms) { if (triggerResult) { @@ -377,6 +390,7 @@ void SoftwareTriggerHLTDQMModule::event() continue; } + float index = 0; for (auto const& cutIdentifier : m_param_cutResultIdentifiers) { const std::string& title = cutIdentifier.first; const auto& mapVal = *(m_param_cutResultIdentifiers[title].begin()); @@ -385,6 +399,7 @@ void SoftwareTriggerHLTDQMModule::event() if (title == baseIdentifier) { for (const std::string& cutTitle : cuts) { + index++; const std::string& cutName = cutTitle.substr(0, cutTitle.find("\\")); const std::string& fullCutIdentifier = SoftwareTriggerDBHandler::makeFullCutName(baseIdentifier, cutName); @@ -393,30 +408,32 @@ void SoftwareTriggerHLTDQMModule::event() if (cutEntry != results.end()) { const int cutResult = cutEntry->second; - m_l1Histograms[l1Trigger]->Fill(cutTitle.c_str(), cutResult > 0); + if (cutResult > 0) { + m_l1Histograms[l1Trigger]->Fill(index - 0.5); + } } } } } + index++; const bool totalResult = FinalTriggerDecisionCalculator::getFinalTriggerDecision(*m_triggerResult); - m_l1Histograms[l1Trigger]->Fill("hlt_result", totalResult > 0); - m_l1Histograms[l1Trigger]->LabelsDeflate("X"); + if (totalResult > 0) { + m_l1Histograms[l1Trigger]->Fill(index - 0.5); + } } if (m_param_create_total_result_histograms) { for (const std::string& l1Trigger : m_param_additionalL1Identifiers) { l1Index++; - const int triggerBit = m_l1NameLookup->getoutbitnum(l1Trigger.c_str()); - if (triggerBit < 0) { - B2WARNING("Could not find" - << LogVar("L1 trigger line", l1Trigger)); - continue; - } bool triggerResult; try { - triggerResult = m_l1TriggerResult->testPsnm(triggerBit); + triggerResult = m_l1TriggerResult->testPsnm(l1Trigger.c_str()); } catch (const std::exception&) { - triggerResult = false; + try { + triggerResult = m_l1TriggerResult->testInput(l1Trigger.c_str()); + } catch (const std::exception&) { + triggerResult = false; + } } if (triggerResult) { m_l1Histograms["l1_total_result"]->Fill(l1Index - 0.5); diff --git a/hlt/softwaretrigger/modules/dqm/src/StatisticsTimingHLTDQMModule.cc b/hlt/softwaretrigger/modules/dqm/src/StatisticsTimingHLTDQMModule.cc index 78c0bcf872..7812e89922 100644 --- a/hlt/softwaretrigger/modules/dqm/src/StatisticsTimingHLTDQMModule.cc +++ b/hlt/softwaretrigger/modules/dqm/src/StatisticsTimingHLTDQMModule.cc @@ -17,6 +17,7 @@ #include #include +#include #include @@ -111,6 +112,57 @@ void StatisticsTimingHLTDQMModule::defineHisto() HLTUnits::max_hlt_units + 1); m_processesPerUnitHistogram->SetXTitle("HLT unit number"); } + m_processingTimePassiveVeto = new TH1F("processingTimePassiveVeto", "Processing Time of events passing passive veto [ms]", + m_processingTimeNBins, 0, + m_processingTimeMax); + m_processingTimePassiveVeto->StatOverflows(true); + m_processingTimeNotPassiveVeto = new TH1F("processingTimeNotPassiveVeto", "Processing Time of events not passing passive veto [ms]", + m_processingTimeNBins, 0, + m_processingTimeMax); + m_processingTimeNotPassiveVeto->StatOverflows(true); + + m_procTimeVsnSVDShaperDigitsPassiveVeto = new TH2F("procTimeVsnSVDShaperDigitsPassiveVeto", + "Processing time [ms] vs nSVDShaperDigits of events passing passive veto", + m_nSVDShaperDigitsNBins, 0, m_nSVDShaperDigitsMax, + m_processingTimeNBins, 0, m_processingTimeMax); + m_procTimeVsnSVDShaperDigitsPassiveVeto->StatOverflows(true); + m_procTimeVsnSVDShaperDigitsPassiveVeto->SetXTitle("nSVDShaperDigits"); + m_procTimeVsnSVDShaperDigitsPassiveVeto->SetYTitle("Processing time [ms]"); + m_procTimeVsnSVDShaperDigitsNotPassiveVeto = new TH2F("procTimeVsnSVDShaperDigitsNotPassiveVeto", + "Processing time [ms] vs nSVDShaperDigits of events not passing passive veto", + m_nSVDShaperDigitsNBins, 0, m_nSVDShaperDigitsMax, + m_processingTimeNBins, 0, m_processingTimeMax); + m_procTimeVsnSVDShaperDigitsNotPassiveVeto->StatOverflows(true); + m_procTimeVsnSVDShaperDigitsNotPassiveVeto->SetXTitle("nSVDShaperDigits"); + m_procTimeVsnSVDShaperDigitsNotPassiveVeto->SetYTitle("Processing time [ms]"); + m_procTimeVsnCDCHitsPassiveVeto = new TH2F("procTimeVsnCDCHitsPassiveVeto", + "Processing time [ms] vs nCDCHits of events passing passive veto", + m_nCDCHitsNBins, 0, m_nCDCHitsMax, + m_processingTimeNBins, 0, m_processingTimeMax); + m_procTimeVsnCDCHitsPassiveVeto->StatOverflows(true); + m_procTimeVsnCDCHitsPassiveVeto->SetXTitle("nCDCHits"); + m_procTimeVsnCDCHitsPassiveVeto->SetYTitle("Processing time [ms]"); + m_procTimeVsnCDCHitsNotPassiveVeto = new TH2F("procTimeVsnCDCHitsNotPassiveVeto", + "Processing time [ms] vs nCDCHits of events not passing passive veto", + m_nCDCHitsNBins, 0, m_nCDCHitsMax, + m_processingTimeNBins, 0, m_processingTimeMax); + m_procTimeVsnCDCHitsNotPassiveVeto->StatOverflows(true); + m_procTimeVsnCDCHitsNotPassiveVeto->SetXTitle("nCDCHits"); + m_procTimeVsnCDCHitsNotPassiveVeto->SetYTitle("Processing time [ms]"); + m_procTimeVsnECLDigitsPassiveVeto = new TH2F("procTimeVsnECLDigitsPassiveVeto", + "Processing time [ms] vs nECLDigits of events passing passive veto", + m_nECLDigitsNBins, 0, m_nECLDigitsMax, + m_processingTimeNBins, 0, m_processingTimeMax); + m_procTimeVsnECLDigitsPassiveVeto->StatOverflows(true); + m_procTimeVsnECLDigitsPassiveVeto->SetXTitle("nECLDigits"); + m_procTimeVsnECLDigitsPassiveVeto->SetYTitle("Processing time [ms]"); + m_procTimeVsnECLDigitsNotPassiveVeto = new TH2F("procTimeVsnECLDigitsNotPassiveVeto", + "Processing time [ms] vs nECLDigits of events not passing passive veto", + m_nECLDigitsNBins, 0, m_nECLDigitsMax, + m_processingTimeNBins, 0, m_processingTimeMax); + m_procTimeVsnECLDigitsNotPassiveVeto->StatOverflows(true); + m_procTimeVsnECLDigitsNotPassiveVeto->SetXTitle("nECLDigits"); + m_procTimeVsnECLDigitsNotPassiveVeto->SetYTitle("Processing time [ms]"); if (oldDirectory) { oldDirectory->cd(); @@ -120,6 +172,11 @@ void StatisticsTimingHLTDQMModule::defineHisto() void StatisticsTimingHLTDQMModule::initialize() { + m_trgSummary.isOptional(); + m_svdShaperDigits.isOptional(); + m_cdcHits.isOptional(); + m_eclDigits.isOptional(); + // Register histograms (calls back defineHisto) REG_HISTOGRAM @@ -201,7 +258,6 @@ void StatisticsTimingHLTDQMModule::event() processingTimeMean += moduleStatistics.getTimeMean(ModuleStatistics::EStatisticCounters::c_Event) / Unit::ms; } m_processingTimeHistogram->Fill(processingTimeSum - m_lastProcessingTimeSum); - m_lastProcessingTimeSum = processingTimeSum; const ModuleStatistics& fullStatistics = stats->getGlobal(); const double fullTimeSum = fullStatistics.getTimeSum(ModuleStatistics::EStatisticCounters::c_Event) / Unit::ms; @@ -226,6 +282,32 @@ void StatisticsTimingHLTDQMModule::event() m_fullMemoryPerUnitHistograms[m_hlt_unit]->Fill(fullMemorySum); } } + + const uint32_t nCDCHits = m_cdcHits.isOptional() ? m_cdcHits.getEntries() : 0; + const uint32_t nSVDShaperDigits = m_svdShaperDigits.isOptional() ? m_svdShaperDigits.getEntries() : 0; + const uint32_t nECLDigits = m_eclDigits.isOptional() ? m_eclDigits.getEntries() : 0; + if (!m_trgSummary.isValid()) { + return; + } + try { + if (m_trgSummary->testInput("passive_veto") == 0) { // These events would stay even with just passive veto + m_processingTimePassiveVeto->Fill(processingTimeSum - m_lastProcessingTimeSum); + + m_procTimeVsnSVDShaperDigitsPassiveVeto->Fill(nSVDShaperDigits, processingTimeSum - m_lastProcessingTimeSum); + m_procTimeVsnCDCHitsPassiveVeto->Fill(nCDCHits, processingTimeSum - m_lastProcessingTimeSum); + m_procTimeVsnECLDigitsPassiveVeto->Fill(nECLDigits, processingTimeSum - m_lastProcessingTimeSum); + } else { + m_processingTimeNotPassiveVeto->Fill(processingTimeSum - m_lastProcessingTimeSum); + + m_procTimeVsnSVDShaperDigitsNotPassiveVeto->Fill(nSVDShaperDigits, processingTimeSum - m_lastProcessingTimeSum); + m_procTimeVsnCDCHitsNotPassiveVeto->Fill(nCDCHits, processingTimeSum - m_lastProcessingTimeSum); + m_procTimeVsnECLDigitsNotPassiveVeto->Fill(nECLDigits, processingTimeSum - m_lastProcessingTimeSum); + } + } catch (const std::exception&) { + return; + } + + m_lastProcessingTimeSum = processingTimeSum; } void StatisticsTimingHLTDQMModule::beginRun()