eclDQM.cc

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
/* Own header. */
#include <ecl/modules/eclDQM/eclDQM.h>
 
/* ECL headers. */
#include <ecl/dataobjects/ECLCalDigit.h>
#include <ecl/dataobjects/ECLDigit.h>
#include <ecl/dataobjects/ECLDsp.h>
#include <ecl/dataobjects/ECLElementNumbers.h>
#include <ecl/dataobjects/ECLTrig.h>
#include <ecl/geometry/ECLGeometryPar.h>
#include <ecl/mapper/ECLChannelMapper.h>
 
/* Basf2 headers. */
#include <analysis/dataobjects/ParticleList.h>
#include <analysis/VariableManager/Manager.h>
#include <analysis/variables/ECLVariables.h>
#include <framework/core/HistoModule.h>
#include <framework/dataobjects/EventMetaData.h>
#include <framework/gearbox/Unit.h>
#include <framework/logging/Logger.h>
#include <mdst/dataobjects/TRGSummary.h>
 
/* Boost headers. */
#include <boost/format.hpp>
#include <boost/range/combine.hpp>
#include <boost/range/adaptor/indexed.hpp>
 
/* ROOT headers. */
#include <TDirectory.h>
#include <TH1F.h>
#include <TH2F.h>
#include <TProfile.h>
 
/* C++ headers. */
#include <iostream>
#include <iterator>
#include <cmath>
#include <stdexcept>
 
//NAMESPACE(S)
using namespace Belle2;
using namespace ECL;
 
using namespace boost::adaptors;
 
REG_MODULE(ECLDQM);
 
ECLDQMModule::ECLDQMModule()
  : HistoModule(),
    m_calibrationThrApsd("ECL_FPGA_StoreWaveform")
{
  //Set module properties.
  setDescription(
    "Primary module for ECL Data Quality Monitor.\n"
    "This module provides a large set of low-level histograms: occupancy, time distribution, number of saved waveforms, etc.");
  setPropertyFlags(c_ParallelProcessingCertified);  // specify parallel processing.
 
  m_WaveformOption = {"psd", "logic", "rand", "dphy", "other"};
 
  addParam("histogramDirectoryName", m_histogramDirectoryName,
           "histogram directory in ROOT file", std::string("ECL"));
  addParam("EnergyUpperThr", m_EnergyUpperThr, "Upper threshold of energy deposition in event, [GeV]", 20.0 * Belle2::Unit::GeV);
  addParam("HitThresholds", m_HitThresholds,
           "Thresholds to display hit occupancy, MeV. Note that it has to be consistent with m_HitNumberUpperLimits", std::vector<double> {0, 5, 10, 20, 50});
  addParam("TotalEnergyThresholds", m_TotalEnergyThresholds, "Thresholds to display total energy, MeV", std::vector<double> {0, 5, 7});
  addParam("TimingThresholds", m_TimingThresholds, "Thresholds (MeV) to display ECL timing", std::vector<double> {5, 10, 50});
  addParam("HitNumberUpperlimits", m_HitNumberUpperLimits,
           "Upper limit (# of hits) to display hit multiplicity. Note that it has to be consistent with m_HitThresholds", std::vector<double> {10000, 1000, 700, 400, 200});
  addParam("WaveformOption", m_WaveformOption, "Option (all,psd,logic,rand,dphy,other) to display waveform flow",
           m_WaveformOption);
  addParam("DPHYTTYP", m_DPHYTTYP,
           "Flag to control trigger of delayed bhabha events; 0 - select events by 'bha_delay' trigger bit, 1 - select by TTYP_DPHY", false);
  addParam("PI0PListName", m_pi0PListName, "Name of the pi0 particle list", std::string("pi0:eclDQM"));
}
 
ECLDQMModule::~ECLDQMModule()
{
}
 
 
void ECLDQMModule::defineHisto()
{
  TDirectory* oldDir = gDirectory;
 
  // Create a separate histogram directory and cd into it.
 
  TDirectory* dirDAQ = dynamic_cast<TDirectory*>(oldDir->Get(m_histogramDirectoryName.c_str()));
  if (!dirDAQ) dirDAQ = oldDir->mkdir(m_histogramDirectoryName.c_str());
  dirDAQ->cd();
 
  //1D histograms creation.
  h_evtot = new TH1F("event", "Total event bank", 1, 0, 1);
 
  h_quality = new TH1F("quality", "Fit quality flag. 0-good, 1-integer overflow, 2-low amplitude, 3-bad chi2", 4, 0, 4);
  h_quality->GetXaxis()->SetTitle("Quality flag");
  h_quality->GetYaxis()->SetTitle("ECL hits count");
  h_quality->SetFillColor(kPink - 4);
 
  h_quality_other = new TH1F("quality_other", "Fit quality flag for unexpectedly saved waveforms", 4, 0, 4);
  h_quality_other->GetXaxis()->SetTitle("Quality flag. 0-good,1-int overflow,2-low amplitude,3-bad chi2");
  h_quality_other->SetFillColor(kPink - 4);
 
  h_bad_quality = new TH1F("bad_quality", "Fraction of hits with bad chi2 (qual=3) and E > 1 GeV vs Cell ID",
                           ECLElementNumbers::c_NCrystals, 1, ECLElementNumbers::c_NCrystals + 1);
  h_bad_quality->GetXaxis()->SetTitle("Cell ID");
  h_bad_quality->GetYaxis()->SetTitle("ECL hits count");
 
  h_trigtag1 = new TH1F("trigtag1", "Consistency b/w global event number and trigger tag. 0-good, 1-DQM error", 2, 0, 2);
  h_trigtag1->GetXaxis()->SetTitle("Flag value");
  h_trigtag1->GetYaxis()->SetTitle("Events count");
  h_trigtag1->SetDrawOption("hist");
  h_trigtag1->SetFillColor(kPink - 4);
 
  h_adc_hits = new TH1F("adc_hits", "Fraction of high-energy hits (E > 50 MeV)", 1001, 0, 1.001);
  h_adc_hits->GetXaxis()->SetTitle("Fraction");
  h_adc_hits->GetYaxis()->SetTitle("Events count");
 
  h_time_crate_Thr1GeV_large = new TH1F("time_crate_Thr1GeV_large",
                                        "Number of hits with timing outside #pm 100 ns per Crate ID (E > 1 GeV)",
                                        52, 1, 53);
  h_time_crate_Thr1GeV_large->GetXaxis()->SetTitle("Crate ID (same as ECLCollector ID)");
  h_time_crate_Thr1GeV_large->GetYaxis()->SetTitle("ECL hits count");
 
  for (const auto& id : m_HitThresholds) {
    std::string h_name, h_title;
    h_name = str(boost::format("cid_Thr%1%MeV") % id);
    h_title = str(boost::format("Occupancy per Cell ID (E > %1% MeV)") % id);
    TH1F* h = new TH1F(h_name.c_str(), h_title.c_str(),
                       ECLElementNumbers::c_NCrystals, 1, ECLElementNumbers::c_NCrystals + 1);
    h->GetXaxis()->SetTitle("Cell ID");
    h->GetYaxis()->SetTitle("Occupancy (hits / events_count)");
    h_cids.push_back(h);
  }
 
  for (const auto& id : m_TotalEnergyThresholds) {
    std::string h_name, h_title;
    h_name = str(boost::format("edep_Thr%1%MeV") % id);
    h_title = str(boost::format("Total energy (thr = %1% MeV)") % id);
    TH1F* h = new TH1F(h_name.c_str(), h_title.c_str(), (int)(100 * m_EnergyUpperThr), 0, m_EnergyUpperThr);
    h->GetXaxis()->SetTitle("Energy, [GeV]");
    h_edeps.push_back(h);
  }
 
  for (const auto& id : m_TimingThresholds) {
    std::string h_bar_name, h_bar_title;
    std::string h_end_name, h_end_title;
    h_bar_name = str(boost::format("time_barrel_Thr%1%MeV") % id);
    h_bar_title = str(boost::format("Reconstructed time for ECL barrel (E > %1% MeV)") % id);
    h_end_name = str(boost::format("time_endcaps_Thr%1%MeV") % id);
    h_end_title = str(boost::format("Reconstructed time for ECL endcaps (E > %1% MeV)") % id);
    TH1F* h_time_barrel = new TH1F(h_bar_name.c_str(), h_bar_title.c_str(), 206, -1030, 1030);
    TH1F* h_time_endcap = new TH1F(h_end_name.c_str(), h_end_title.c_str(), 206, -1030, 1030);
    h_time_barrel->GetXaxis()->SetTitle("Time, [ns]");
    h_time_endcap->GetXaxis()->SetTitle("Time, [ns]");
    h_time_barrels.push_back(h_time_barrel);
    h_time_endcaps.push_back(h_time_endcap);
  }
 
  if (m_HitThresholds.size() != m_HitNumberUpperLimits.size()) {
    B2FATAL("m_HitThresholds[] and m_HitNumberUpperLimits[] have different sizes");
  }
  for (const auto& id : boost::combine(m_HitThresholds, m_HitNumberUpperLimits)) {
    double id1 = 0, id2 = 0;
    boost::tie(id1, id2) = id;
    std::string h_name, h_title;
    h_name = str(boost::format("ncev_Thr%1%MeV") % id1);
    h_title = str(boost::format("Number of hits in event (E > %1% MeV)") % id1);
    TH1F* h = new TH1F(h_name.c_str(), h_title.c_str(), id2, 0, id2);
    h->GetXaxis()->SetTitle("Number of hits");
    h_ncevs.push_back(h);
  }
 
  for (int i = 0; i < ECL_CRATES; i++) {
    int crate = i + 1;
    std::string h_name, h_title;
    h_name = str(boost::format("time_crate_%1%_Thr1GeV") % (crate));
    h_title = str(boost::format("Reconstructed time for ECL crate #%1% with E > 1 GeV") % (crate));
    TH1F* h = new TH1F(h_name.c_str(), h_title.c_str(), 400, -100, 100);
    h->GetXaxis()->SetTitle("Time [ns]");
    h_time_crate_Thr1GeV.push_back(h);
  }
 
  for (const auto& id : m_WaveformOption) {
    if (id != "all" && id != "psd" && id != "logic" && id != "rand" && id != "dphy" && id != "other")
      B2WARNING("Waveform Options are not correctly assigned. They must be 'all', 'psd', 'logic', 'rand', 'dphy', 'other'!");
    std::string h_title;
    std::string h_cell_name;
    if (id == "other") h_title = "Unexpectedly saved waveforms";
    if (id == "psd") h_title = "#frac{Saved}{Expected} waveforms for high-energy hits (E > 50 MeV)";
    if (id == "logic") h_title = "#frac{Saved}{Expected} waveforms for every 1000th event";
    if (id == "rand") h_title = "#frac{Saved}{Expected} waveforms for random trigger events";
    if (id == "dphy") h_title = "#frac{Saved}{Expected} waveforms for delayed bhabha (DPHY) events";
    if (id == "all") h_title = "#frac{Saved}{Expected} waveforms for all events";
    h_cell_name = str(boost::format("wf_cid_%1%") % (id));
    TH1F* h_cell = new TH1F(h_cell_name.c_str(), h_title.c_str(),
                            ECLElementNumbers::c_NCrystals, 1, ECLElementNumbers::c_NCrystals + 1);
    h_cell->GetXaxis()->SetTitle("Cell ID");
    if (id == "psd") {
      h_cell_psd_norm = new TH1F("psd_cid", "Normalization to psd hits for cid",
                                 ECLElementNumbers::c_NCrystals, 1, ECLElementNumbers::c_NCrystals + 1);
    }
    if (id == "logic") {
      h_evtot_logic = new TH1F("event_logic", "Event bank for logic", 1, 0, 1);
    }
    if (id == "rand") {
      h_evtot_rand = new TH1F("event_rand", "Event bank for rand", 1, 0, 1);
    }
    if (id == "dphy") {
      h_evtot_dphy = new TH1F("event_dphy", "Event bank for dphy", 1, 0, 1);
    }
    h_cells.push_back(h_cell);
  }
 
  //2D histograms creation.
 
  h_trigtag2_trigid = new TH2F("trigtag2_trigid", "Internal data consistency vs crate. 0-good, 1-data corruption",
                               52, 1, 53, 11, -1, 10);
  h_trigtag2_trigid->GetXaxis()->SetTitle("Crate ID (same as ECLCollector ID)");
  h_trigtag2_trigid->GetYaxis()->SetTitle("Data consistency flag");
 
  h_pedmean_cellid = new TProfile("pedmean_cellid", "Pedestal vs Cell ID",
                                  ECLElementNumbers::c_NCrystals, 1, ECLElementNumbers::c_NCrystals + 1);
  h_pedmean_cellid->GetXaxis()->SetTitle("Cell ID");
  h_pedmean_cellid->GetYaxis()->SetTitle("Ped. average (ADC units, #approx 0.05 MeV)");
 
  h_pedrms_cellid = new TProfile("pedrms_cellid", "Pedestal stddev vs Cell ID",
                                 ECLElementNumbers::c_NCrystals, 1, ECLElementNumbers::c_NCrystals + 1);
  h_pedrms_cellid->GetXaxis()->SetTitle("Cell ID");
  h_pedrms_cellid->GetYaxis()->SetTitle("Ped. stddev (ADC units, #approx 0.05 MeV)");
 
  h_pedrms_thetaid = new TProfile("pedrms_thetaid", "Pedestal stddev vs #theta ID",
                                  68, 0, 68);
  h_pedrms_thetaid->GetXaxis()->SetTitle("#theta ID (0-12=FWD, 59-67=BWD endcap)");
  h_pedrms_thetaid->GetYaxis()->SetTitle("Ped. stddev (ADC units, #approx 0.05 MeV)");
 
  h_trigtime_trigid = new TH2F("trigtime_trigid", "Trigger time vs Crate ID", 52, 1, 53, 145, 0, 145);
  h_trigtime_trigid->GetXaxis()->SetTitle("Crate ID (same as ECLCollector ID)");
  h_trigtime_trigid->GetYaxis()->SetTitle("Trigger time (only even, 0-142)");
 
  h_pi0_mass = new TH1F("ecl_pi0_mass", "ecl_pi0_mass", 120, 0.08, 0.20);
 
  //cd into parent directory.
 
  oldDir->cd();
}
 
void ECLDQMModule::initialize()
{
  REG_HISTOGRAM;   // required to register histograms to HistoManager.
  m_ECLDigits.isRequired();
  m_ECLCalDigits.isOptional();
  m_ECLTrigs.isOptional();
  m_ECLDsps.isOptional();
  m_l1Trigger.isOptional();
 
  if (!mapper.initFromDB()) B2FATAL("ECL DQM: Can't initialize eclChannelMapper");
 
  ecltot.resize(m_TotalEnergyThresholds.size());
  nhits.resize(m_HitNumberUpperLimits.size());
 
  m_geom = ECLGeometryPar::Instance();
 
  v_totalthrApsd.resize((m_calibrationThrApsd->getCalibVector()).size());
  for (size_t i = 0; i < v_totalthrApsd.size(); i++) v_totalthrApsd[i] = (int)(m_calibrationThrApsd->getCalibVector())[i];
}
 
void ECLDQMModule::beginRun()
{
  h_evtot->Reset();
  h_evtot_logic->Reset();
  h_evtot_rand->Reset();
  h_evtot_dphy->Reset();
  h_quality->Reset();
  h_quality_other->Reset();
  h_bad_quality->Reset();
  h_trigtag1->Reset();
  h_adc_hits->Reset();
  h_time_crate_Thr1GeV_large->Reset();
  h_cell_psd_norm->Reset();
  std::for_each(h_cids.begin(), h_cids.end(), [](auto & it) {it->Reset();});
  std::for_each(h_edeps.begin(), h_edeps.end(), [](auto & it) {it->Reset();});
  std::for_each(h_time_barrels.begin(), h_time_barrels.end(), [](auto & it) {it->Reset();});
  std::for_each(h_time_endcaps.begin(), h_time_endcaps.end(), [](auto & it) {it->Reset();});
  std::for_each(h_ncevs.begin(), h_ncevs.end(), [](auto & it) {it->Reset();});
  std::for_each(h_cells.begin(), h_cells.end(), [](auto & it) {it->Reset();});
  for (int i = 0; i < ECL_CRATES; i++) h_time_crate_Thr1GeV[i]->Reset();
  h_trigtag2_trigid->Reset();
  h_pedmean_cellid->Reset();
  h_pedrms_cellid->Reset();
  h_pedrms_thetaid->Reset();
  h_trigtime_trigid->Reset();
  h_pi0_mass->Reset();
}
 
void ECLDQMModule::event()
{
  int trigtag1 = 0;
  int NDigits = 0;
  for (auto& value : ecltot) value = 0;
  for (auto& value : nhits) value = 0;
  bool bhatrig = false;
 
  if (m_l1Trigger.isValid() && m_DPHYTTYP) bhatrig = m_l1Trigger->getTimType() == TRGSummary::ETimingType::TTYP_DPHY;
  else if (m_l1Trigger.isValid() && !m_DPHYTTYP) {
    try { bhatrig = m_l1Trigger->testInput("bha_delay"); }
    catch (const std::exception&) { bhatrig = false; }
  }
 
  m_iEvent = -1;
  if (m_eventmetadata.isValid()) {
    if (m_eventmetadata->getErrorFlag() != 0x10) {
      m_iEvent = m_eventmetadata->getEvent();
      h_evtot->Fill(0);
      for (const auto& id : m_WaveformOption) {
        if (id == "logic" && m_iEvent % 1000 == 999) h_evtot_logic->Fill(0);
        if (id == "rand" && isRandomTrigger()) h_evtot_rand->Fill(0);
        if (id == "dphy" && bhatrig) h_evtot_dphy->Fill(0);
      }
    }
  }
 
  for (auto& aECLDigit : m_ECLDigits) {
    int i = aECLDigit.getCellId() - 1;
    h_quality->Fill(aECLDigit.getQuality());  //Fit quality histogram filling.
    if (aECLDigit.getAmp() > 2.e04 && aECLDigit.getQuality() == 3) h_bad_quality->Fill(aECLDigit.getCellId());
    if (aECLDigit.getAmp() >= (v_totalthrApsd[i] / 4 * 4)) NDigits ++;
    for (const auto& id : m_WaveformOption) {
      if (id != "psd") continue;
      else if (id == "psd" && (m_iEvent % 1000 == 999 ||
                               isRandomTrigger() ||
                               bhatrig ||
                               aECLDigit.getAmp() < (v_totalthrApsd[i] / 4 * 4))) continue;
      h_cell_psd_norm->Fill(aECLDigit.getCellId());
    }
  }
 
  for (auto& aECLTrig : m_ECLTrigs) {
    double itrg = aECLTrig.getTimeTrig();
    //trigger time conversion to acceptable units in range (0, ..., 142).
    //one trigger time clock corresponds to 0.567/144*1000 = 3.93 ns
    int tg = (int)itrg - 2 * ((int)itrg / 8);
    h_trigtime_trigid->Fill(aECLTrig.getTrigId(), tg); //Trigger time histogram filling.
    trigtag1 += aECLTrig.getTrigTag();
    h_trigtag2_trigid->Fill(aECLTrig.getTrigId(), aECLTrig.getTrigTagQualityFlag()); //Data consistency histogram filling.
  }
 
  if (m_ECLTrigs.getEntries() > 0) {
    int flagtag = 1;
    trigtag1 /= m_ECLTrigs.getEntries();
    int compar = (65535 & m_iEvent);
    if (compar == trigtag1) flagtag = 0;
    h_trigtag1->Fill(flagtag);  //Trigger tag flag #1 histogram filling.
  }
 
  for (auto& aECLCalDigit : m_ECLCalDigits) {
    int cid        = aECLCalDigit.getCellId();
    double energy  = aECLCalDigit.getEnergy(); //get calibrated energy.
    double timing  = aECLCalDigit.getTime();   //get calibrated time.
 
    for (size_t i = 0; i < m_HitThresholds.size(); i++) {
      auto thrGeV = m_HitThresholds[i] / 1000.;
      if (energy > thrGeV)  {
        h_cids[i]->Fill(cid);
        nhits[i] += 1;
      }
    }
 
    for (const auto& thr : m_TotalEnergyThresholds | indexed(0)) {
      auto thrGeV = thr.value() / 1000.;
      if (energy > thrGeV) ecltot[thr.index()] += energy;
    }
 
    for (const auto& thr : m_TimingThresholds | indexed(0)) {
      auto thrGeV = thr.value() / 1000.;
      if (energy > thrGeV) {
        if (cid > ECL_FWD_CHANNELS && cid <= ECL_FWD_CHANNELS + ECL_BARREL_CHANNELS) h_time_barrels[thr.index()]->Fill(timing);
        else h_time_endcaps[thr.index()]->Fill(timing);
      }
    }
 
    if (energy > 1.000 && std::abs(timing) < 100.) h_time_crate_Thr1GeV[mapper.getCrateID(cid) - 1]->Fill(timing);
    if (energy > 1.000 && std::abs(timing) > 100.) h_time_crate_Thr1GeV_large->Fill(mapper.getCrateID(cid));
  }
 
  for (const auto& h : h_edeps | indexed(0)) {
    h.value()->Fill(ecltot[h.index()]);
  }
 
  for (const auto& h : h_ncevs | indexed(0)) {
    h.value()->Fill(nhits[h.index()]);
  }
 
  for (auto& aECLDsp : m_ECLDsps)  {
    int i = aECLDsp.getCellId() - 1; //get number of Cell ID in m_DspArray.
    aECLDsp.getDspA(m_DspArray[i]);
    m_PedestalMean[i] = 0;
    m_PedestalRms[i] = 0;
 
    for (int j = 0; j < 16; j++) m_PedestalMean[i] += m_DspArray[i][j];
    m_PedestalMean[i] /= 16;
    h_pedmean_cellid->Fill(aECLDsp.getCellId(), m_PedestalMean[i]); //Pedestal Avg histogram filling.
 
    for (int j = 0; j < 16; j++) m_PedestalRms[i] += pow(m_DspArray[i][j] - m_PedestalMean[i], 2);
    m_PedestalRms[i] = sqrt(m_PedestalRms[i] / 15.);
    h_pedrms_cellid->Fill(aECLDsp.getCellId(), m_PedestalRms[i]); //Pedestal stddev histogram filling.
    m_geom->Mapping(i);
    h_pedrms_thetaid->Fill(m_geom->GetThetaID(), m_PedestalRms[i]);
 
    ECLDigit* aECLDigit = ECLDigit::getByCellID(aECLDsp.getCellId());
 
    for (const auto& iter : m_WaveformOption | indexed(0)) {
      const auto& index  = iter.index();
      const auto& wf_opt = iter.value();
      if (wf_opt != "all" && wf_opt != "psd" && wf_opt != "logic" && wf_opt != "rand" && wf_opt != "dphy" && wf_opt != "other") continue;
      else if (wf_opt == "psd" && (m_iEvent % 1000 == 999 || isRandomTrigger() || bhatrig ||
                                   !aECLDigit || aECLDigit->getAmp() < (v_totalthrApsd[i] / 4 * 4))) continue;
      else if (wf_opt == "logic" && m_iEvent % 1000 != 999) continue;
      else if (wf_opt == "rand" && (m_iEvent % 1000 == 999 || !isRandomTrigger())) continue;
      else if (wf_opt == "dphy" && (m_iEvent % 1000 == 999 || !bhatrig)) continue;
      else if (wf_opt == "other" && (m_iEvent % 1000 == 999 || isRandomTrigger() || bhatrig ||
                                     (aECLDigit && aECLDigit->getAmp() >= (v_totalthrApsd[i] / 4 * 4)))) continue;
      h_cells[index]->Fill(aECLDsp.getCellId());
      if (wf_opt == "other" && aECLDigit) h_quality_other->Fill(aECLDigit->getQuality());
    }
  }
  if (m_ECLDigits.getEntries() > 0)
    h_adc_hits->Fill((double)NDigits / (double)m_ECLDigits.getEntries()); //Fraction of high-energy hits
 
  fillInvMassHistogram();
}
 
void ECLDQMModule::endRun()
{
}
 
 
void ECLDQMModule::terminate()
{
}
 
bool ECLDQMModule::isRandomTrigger()
{
  if (!m_l1Trigger.isValid()) return false;
  return m_l1Trigger->getTimType() == TRGSummary::ETimingType::TTYP_RAND ||
         m_l1Trigger->getTimType() == TRGSummary::ETimingType::TTYP_POIS;
}
 
bool ECLDQMModule::fillInvMassHistogram()
{
  const std::string trg_identifier = "software_trigger_cut&skim&accept_hadron";
  StoreObjPtr<SoftwareTriggerResult> result;
  if (!result.isValid()) return false;
 
  // check if trigger identifier is available
  const std::map<std::string, int>& results = result->getResults();
  if (results.find(trg_identifier) == results.end()) return false;
  // apply software trigger
  const bool accepted = (result->getResult(trg_identifier) == SoftwareTriggerCutResult::c_accept);
  if (!accepted) return false;
 
  StoreObjPtr<ParticleList> particles(m_pi0PListName);
  if (!particles.isValid()) return false;
 
  for (unsigned int i = 0; i < particles->getListSize(); i++) {
    const Particle* part = particles->getParticle(i);
    auto inv_mass = Variable::eclClusterOnlyInvariantMass(part);
    h_pi0_mass->Fill(inv_mass);
  }
 
  return true;
}