LumiCalculator.cxx File Reference

#include "LumiCalc/LumiCalculator.h"
#include "GoodRunsLists/TGoodRunsList.h"
#include "GoodRunsLists/TGoodRunsListWriter.h"
#include "LumiCalc/CoolQuery.h"
#include "LumiCalc/LumiBlockRangeContainerConverter.h"
#include "TH1F.h"
#include "TTree.h"
#include "TFile.h"
#include "TString.h"
#include "TObjString.h"
#include "TROOT.h"
#include <memory>
#include <iomanip>
#include <iostream>
#include <set>
#include <regex.h>
#include <stdexcept>

Go to the source code of this file.

Functions
void LumiCalculator::IntegrateLumi	ATLAS_NOT_THREAD_SAFE (const xAOD::LumiBlockRangeContainer *iovc, const std::string &triggerchain)

Function Documentation

ATLAS_NOT_THREAD_SAFE()

void LumiCalculator::IntegrateLumi ATLAS_NOT_THREAD_SAFE	(	const xAOD::LumiBlockRangeContainer *	iovc,
		const std::string &	triggerchain
	)

Definition at line 314 of file LumiCalculator.cxx.

                                                                                                                                 {
 
 
  CoolQuery * cq_lumi = NULL;
  CoolQuery * cq_trigger = NULL;
  CoolQuery* cq_lar = NULL;
  CoolQuery* cq_bs = NULL;
 
  // Peek at first run in iovc to check if we want Run1 or Run2 data
  xAOD::LumiBlockRangeContainer::const_iterator it = iovc->begin();
  //  const IOVRange * iovr = (*it);
  const IOVRange* iovr = new IOVRange(IOVTime((*it)->startRunNumber(),(*it)->startLumiBlockNumber()), 
                                      IOVTime((*it)->stopRunNumber(),(*it)->stopLumiBlockNumber()));
 
  bool isrun2 = false;
  std::string onlfolder;
  std::string oflfolder;
  if (iovr->start().run() > 222222) {
    isrun2 = true;
    m_data_db="CONDBR2";
    onlfolder = "/TRIGGER/LUMI/OnlPrefLumi";
    oflfolder = "/TRIGGER/OFLLUMI/OflPrefLumi";
  } else {
    isrun2 = false;
    m_data_db="COMP200";
    onlfolder = "/TRIGGER/LUMI/LBLESTONL";
    oflfolder = "/TRIGGER/OFLLUMI/LBLESTOFL";
  }
 
  // define all connection strings
 
  // check for online DB
  if(m_onlinelumi){
    m_lumi_database = m_lumionl + m_data_db;
    m_parlumiestfolder = std::move(onlfolder);
  } else {
    m_lumi_database = m_lumioff + m_data_db;
    m_parlumiestfolder = std::move(oflfolder);
  }
 
  m_trig_database = m_trigger + m_data_db;
  m_lar_database = m_laroff + m_data_db;
  m_bs_database = m_bsonl + m_data_db;
 
 
  m_logger << Root::kINFO << "Luminosity database: " << m_lumi_database << Root::GEndl;
  m_logger << Root::kINFO << "Trigger database: " << m_trig_database << Root::GEndl;
 
  cq_lumi = new CoolQuery(m_lumi_database, triggerchain);
  if (!cq_lumi->openDbConn()) {
    delete cq_lumi;
    return;
  }
 
  cq_trigger = new CoolQuery(m_trig_database, triggerchain);
  if (!cq_trigger->openDbConn()) {
    delete cq_trigger;
    return;
  }
 
  if (m_uselar) {
    m_logger << Root::kINFO << "LAr database: " << m_lar_database << Root::GEndl;
 
    cq_lar = new CoolQuery(m_lar_database, triggerchain);
    if (!cq_lar->openDbConn()) {
      delete cq_lar;
      return;
    }
  }
 
  if (m_usebs) {
    m_logger << Root::kINFO << "Onl beamspot database: " << m_bs_database << Root::GEndl;
 
    cq_bs = new CoolQuery(m_bs_database, triggerchain);
    if (!cq_bs->openDbConn()) {
      delete cq_bs;
      return;
    }
  }
 
  // initialize
  m_lbstarttime = 0.;
  m_lbendtime = 0.;
  m_totalDelL = 0.;
  m_totalL = 0.;
  m_totalLRun = 0.;
  m_totaltime = 0.;
  m_instLumi = 0.;
  m_delLumi = 0.;
  m_intLumi = 0.;
  m_deltaT = 0.;
 
  m_totalPrescaleWLiveTime = 0.;
  m_totalPrescale = 0.;
  m_lumiWOPrescale = 0.;
  m_lumiLAr = 0.;
  m_TotaldeltaT = 0.;
  m_livefrac = 0.;
  m_livetime = 0.;
  m_lartime = 0.;
  m_larfrac = 0.;
  m_bsvalid = 0.;
  m_livetime_l1acc = 0;
  m_l1acc = 0;
  m_l2acc = 0;
  m_l3acc = 0;
  m_totall1acc = 0;
  m_livtrig_totall1acc = 0;
  m_totall2acc = 0;
  m_totall3acc = 0;
  m_l1prescale = 1.;
  m_l2prescale = 1.;
  m_l3prescale = 1.;
  m_livetime_beforeprescale = 0;
  m_livetime_afterprescale = 0;
  m_afterprescale = 0;
  m_beforeprescale = 0;
  m_totall1befpresc = 0;
  m_runnbr = 0;
  m_lbstart = 0;
  m_lbstop = 0;
  m_lbstart_prev = 0;
  m_lbstop_prev = 0;
  m_totalgoodblock = 0;
  m_totalbadblock = 0;
  m_clumiblocknbr = 0;
  m_clumiblocknbrend =0;
  m_triglevel = 0;
  m_lbcollectionname = "LumiBlocks";
  m_triggerchain = triggerchain;
  m_l1rate = 0.;
  m_l2rate = 0.;
  m_l3rate = 0.;
  m_l1ratediveffxsec = 0.;
  m_total_l1ratediveffxsec = 0.;
  m_total_l1ratediveffxsecRun = 0.;
  m_l1ratediveffxsec_recorded = 0.;
  m_total_l1ratediveffxsec_recorded = 0.;
  m_total_l1ratediveffxsecRun_recorded = 0.;
  m_runnbr_prev = 0;
 
  // Set to extreme values, to be updated below
  m_minrun = 99999999;
  m_maxrun = 0;
 
  bool firstL1Missing = true;
  bool firstHLTMissing = true;
 
  std::set<cool::ValidityKey> lbrunset;
  lbrunset.clear();
 
  // collisions xml file settings
  if (m_collsgrl!=0) { delete m_collsgrl; m_collsgrl=0; }
  if (m_makecollList) {
    m_collsgrl = new Root::TGoodRunsList();
    m_collsgrl->SetVersion("30"); // lumicalc signature
    m_collsgrl->AddMetaData("Query","Generated by LumiCalculator");
  }
 
  // Figure out trigger level  
  m_triglevel = cq_lumi->getTriggerLevel(triggerchain);
  if (m_triglevel == 0){
    // Check if on purpose, otherwise, give a warning
    if (triggerchain == "None") {
      m_logger << Root::kINFO << "No trigger specified!" << Root::GEndl;
    } else {
      m_logger << Root::kWARNING << "Invalid trigger: [" << triggerchain << "] - will proceed with no trigger defined!" << Root::GEndl;
    }
  }
 
  // Look for b-jet triggers
  regex_t regex;
  int reti = regcomp(&regex, "_[[:digit:]]?b[[:digit:]]+_", REG_EXTENDED);
  if (reti) m_logger << Root::kWARNING << "Could not compile regex!" << Root::GEndl;
 
  reti = regexec(&regex, triggerchain.c_str(), 0, NULL, 0);
  if ( !reti && !m_usebs) {
    m_logger << Root::kWARNING << "Trigger: [" << triggerchain << "] appears to be a b-jet trigger, but online beamspot validity not included in livefraction!" << Root::GEndl;
    m_logger << Root::kWARNING << "Probably need to specify --beamspot to get accurate luminosity!" << Root::GEndl;
  }
  regfree(&regex);
 
  // get lumi channel id (this never changes)
  if (m_lumimethod != "") {
    m_Lumiid = cq_lumi->getLumiChannelId(m_lumimethod, m_parlumiestfolder);
  } else {
    m_Lumiid = m_lumichannel;
  }
 
 
  // do main LumiBlock loop
  //==============================
 
  IOVData<cool::Int32> L1preObj;
  IOVData<cool::Int32> L1preOther;
  IOVData<cool::Float> L2preObj;
  IOVData<cool::Float> L3preObj;
  IOVData<cool::UInt32> LArObj;
  IOVData<cool::Int32> BSObj;
 
  std::map<cool::ValidityKey, CoolQuery::LumiFolderData> LumiDataMap;
 
  // UTC nanoseconds since 1970
  std::map<cool::ValidityKey, cool::UInt63> L1starttime_map;
  std::map<cool::ValidityKey, cool::UInt63> L1endtime_map;
 
  // Livetime maps
  std::map<cool::ValidityKey, CoolQuery::L1CountFolderData> Livetime_map;
  std::map<cool::ValidityKey, CoolQuery::L1CountFolderData> L1accept_map;
 
  for(xAOD::LumiBlockRangeContainer::const_iterator it = iovc->begin(); it != iovc->end(); ++it){
    const auto iovr = std::make_unique<IOVRange>(IOVTime((*it)->startRunNumber(),(*it)->startLumiBlockNumber()), 
                                        IOVTime((*it)->stopRunNumber(),(*it)->stopLumiBlockNumber()));
    
    // Bookkeeping temporary results
    m_t_totalDelL = 0.;
    m_t_totalL = 0.;
    m_t_totalLRun = 0.;
    m_t_totaltime = 0.;
    m_t_deltaT = 0.;
    m_t_l1acc = 0;
    m_t_l2acc = 0;
    m_t_l3acc = 0;
    m_t_totalgoodblock = 0;
    m_t_totalbadblock = 0;
    m_t_totall1befpresc = 0;    
    m_t_totalPrescaleWLiveTime = 0.;
    m_t_totalPrescale = 0.;
    m_t_lumiWOPrescale = 0. ;
    m_t_lumiLAr = 0.;
  
    m_runnbr = iovr->start().run();
    m_lbstart = iovr->start().event();
    m_lbstop = iovr->stop().event();
 
    // Look for duplicate run/LB 
    if(m_lbstart_prev == m_lbstart && m_lbstop_prev == m_lbstop && m_runnbr_prev == m_runnbr){
      m_logger << Root::kWARNING << "Skipping multiply stored IOVRange: [" << m_lbstart << "-" << m_lbstop << "]" << Root::GEndl;
      continue;
    }
 
    // new run, reset its lumi and reload the trigger channels
    if ( m_runnbr!=m_runnbr_prev ) {
 
      if (m_runnbr < m_minrun) m_minrun = m_runnbr;
      if (m_runnbr > m_maxrun) m_maxrun = m_runnbr;
 
      m_totalLRun=0.;
      m_total_l1ratediveffxsecRun=0.;
      m_total_l1ratediveffxsecRun_recorded=0.;
 
      // Set IOV range for full run
      cq_trigger->setIOVForRun (m_runnbr);
      cq_lumi->setIOVForRun(m_runnbr);
 
      // get trigger channel ids
      m_L1Valid = false;
      m_L2Valid = false;
      m_L3Valid = false;
      m_LiveValid = false;
      m_triggerlowerchains.clear();
      // These are used to resolve L1 ORs like [L1_MU20,L1_MU21]
      m_L1triggerchains.clear();
      m_L1idList.clear();
 
      std::string lowerch = "";
 
      // This is really inefficient...
      if(m_triglevel == 3){
    m_L3id = cq_trigger->getHLTChannelId(triggerchain, m_parhltmenufolder);
    m_L3Valid = cq_trigger->channelIdValid();
 
    lowerch =  cq_trigger->getHLTLowerChainName(triggerchain, m_parhltmenufolder); 
    m_triggerlowerchains.push_back(lowerch); 
    //
    m_L2id = cq_trigger->getHLTChannelId(lowerch, m_parhltmenufolder);
    if (m_L2id == UINT_MAX) { //nonsense value for getHLTChannelId
      throw std::runtime_error("LumiCalculator::IntegrateLumi : getHLTChannelId returned invalid value.");
    }
    m_L2Valid = cq_trigger->channelIdValid();
 
    lowerch = cq_trigger->getHLTLowerChainName(lowerch, m_parhltmenufolder); 
    m_triggerlowerchains.push_back(lowerch);
    //
    m_L1id = cq_trigger->getL1ChannelId(lowerch, m_parlvl1menufolder );
    m_L1Valid = cq_trigger->channelIdValid();
 
      }else if(m_triglevel == 2){  // Run2 or starting at L2 in Run1
    lowerch =  cq_trigger->getHLTLowerChainName(triggerchain, m_parhltmenufolder); 
    m_triggerlowerchains.push_back(lowerch);
    m_L2id = cq_trigger->getHLTChannelId(triggerchain, m_parhltmenufolder);
    m_L2Valid = cq_trigger->channelIdValid();
 
    ParseL1Trigger(lowerch, cq_trigger);
 
      }else if(m_triglevel == 1){
 
    ParseL1Trigger(triggerchain, cq_trigger);
      }
 
      if (firstL1Missing && (!m_L1Valid && m_triglevel > 0)) {
    firstL1Missing = false;
    cq_trigger->printL1Triggers(m_parlvl1menufolder);
      }
 
      if (firstHLTMissing && ((!m_L2Valid && m_triglevel > 1) || (!m_L3Valid && m_triglevel > 2)) ) {
    firstHLTMissing = false;
    cq_trigger->printHLTTriggers(m_parhltmenufolder);
      }
 
      // Should we check here for btag trigger and onl beamspot?
 
      // Do we use dedicated livetime trigger?
      if(m_uselivetrigger){
    m_LiveL1id = cq_trigger->getL1ChannelId(m_livetrigger, m_parlvl1menufolder);
    m_LiveValid = cq_trigger->channelIdValid();
      }else{
    // then fall back to the original trigger
    m_LiveL1id = m_L1id;
    m_LiveValid = m_L1Valid;
      }
 
      if (!m_LiveValid) {
    if (m_uselivetrigger)
      m_logger << Root::kWARNING << "Runnumber: [" << m_runnbr << "] can't find livefraction trigger [" << m_livetrigger << "]!  Livefraction won't be calculated!" << Root::GEndl;
    else
      m_logger << Root::kWARNING << "Runnumber: [" << m_runnbr << "] can't find trigger [" << triggerchain << "]!  Livefraction won't be calculated!" << Root::GEndl;
      }
 
      // Also load all deadtime counters here
 
      // Need to fix this for non-MC.  HLT counters now available, but not used here...
 
      //-------------------------
      // Load livetime information
      Livetime_map.clear();
      L1accept_map.clear();
 
      if (m_LiveValid) 
    Livetime_map = cq_trigger->getL1CountFolderData(m_parlumilvl1folder, m_LiveL1id);
 
      
      if (m_L1Valid && m_triglevel >= 1) 
    L1accept_map = cq_trigger->getL1CountFolderData(m_parlumilvl1folder, m_L1id);
 
      // UTC nanoseconds since 1970
      L1starttime_map.clear();
      L1endtime_map.clear();
      L1starttime_map = cq_trigger->getObjMapFromFolderAtChan<cool::UInt63>("StartTime", m_parlvl1lblbfolder, 0);
      L1endtime_map = cq_trigger->getObjMapFromFolderAtChan<cool::UInt63>("EndTime", m_parlvl1lblbfolder, 0);
 
      //---------------------------
      // Load LAr defects
      LArObj.clear();
 
      if (m_uselar) {
    cool::ValidityKey runstarttime = L1starttime_map.begin()->second;
    cool::ValidityKey runendtime = L1endtime_map.rbegin()->second;
 
    cq_lar->setIOV(runstarttime, runendtime); 
    LArObj = cq_lar->getIOVData<cool::UInt32>("EventVeto", m_parlareventvetofolder, 0, m_lartag);
      }
 
      //---------------------------
      // Load Onl beamspot
      BSObj.clear();
 
      if (m_usebs) {
    cq_bs->setIOVForRun(m_runnbr);
    BSObj = cq_bs->getIOVData<cool::Int32>("status", m_paronlbeamspotfolder, 0, m_bstag);
      }
 
 
      //-----------------------------
      // Load luminosity for this run
      LumiDataMap.clear();
      LumiDataMap = cq_lumi->getLumiFolderData(m_parlumiestfolder, m_lumitag, m_Lumiid); 
 
    
    } // End of new run stuff
 
    m_lbstart_prev = m_lbstart;
    m_lbstop_prev = m_lbstop;
    m_runnbr_prev = m_runnbr;
    
    // Update DB for this specific IOV range
    cq_trigger->setIOV(iovr->start().re_time(), iovr->stop().re_time());
 
    // Print this here (will be output for each contiguous LB range in XML file)
    m_logger << Root::kINFO << std::left << "-----------------------------------" << Root::GEndl;
    m_logger << Root::kINFO << "Beginning calculation for ";
    if (m_triglevel > 0) {
      m_logger << Root::kINFO << "Trigger " << m_triggerchain;
      if(m_triggerlowerchains.size() > 0){
    m_logger << Root::kINFO << "["; 
    for(std::vector<std::string>::iterator sit = m_triggerlowerchains.begin(); sit != m_triggerlowerchains.end(); ++sit){
      m_logger << Root::kINFO << "==>" << *sit;
    }
    m_logger << Root::kINFO << "], "; 
      }
    }
    m_logger << Root::kINFO << "Run " << m_runnbr << " LB [" << m_lbstart << "-" << m_lbstop << "]" << Root::GEndl;
    m_logger << Root::kINFO << std::left << "-----------------------------------" << Root::GEndl;
    
    //----------------------------
    // Load prescales for this IOV
    L1preObj.clear();
    L2preObj.clear();
    L3preObj.clear();
    L1preOther.clear();  // Used for mutliple L1 triggers
 
    if(m_L1Valid) {
      // Normal case
      if (m_L1idList.size() <= 1) {
    L1preObj = cq_trigger->getIOVData<cool::Int32>("Lvl1Prescale", m_parlvl1prescalesfolder, m_L1id);
 
      // Multiple L1 items defined
      } else {
 
    m_logger << Root::kINFO << "Resolving multiple L1 prescales:" << Root::GEndl;
 
    // Load first one
    L1preObj = cq_trigger->getIOVData<cool::Int32>("Lvl1Prescale", m_parlvl1prescalesfolder, m_L1idList[0]);
 
    // Dump prescales
    std::list< std::pair<IOVRange, cool::Int32> >::iterator it;
 
    m_logger << Root::kINFO << std::setw(10) << std::left << m_L1triggerchains[0];
    for(it = L1preObj.data.begin(); it != L1preObj.data.end(); ++it) {
      m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" ;
 
      if (it->second < 0)
        m_logger << it->second <<  ", "; 
      else
        m_logger << (0xFFFFFF / float(0x1000000 - it->second)) <<  ", "; 
    }
    m_logger << Root::kINFO << Root::GEndl;
 
    // Now loop over the remaining and replace
    for (unsigned int iid=1; iid < m_L1idList.size(); iid++) {
      L1preOther = cq_trigger->getIOVData<cool::Int32>("Lvl1Prescale", m_parlvl1prescalesfolder, m_L1idList[iid]);  
 
      // Dump prescales
      m_logger << Root::kINFO << std::setw(10) << std::left << m_L1triggerchains[iid];
      for(it = L1preOther.data.begin(); it != L1preOther.data.end(); ++it) {
        m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" ;
 
        if (it->second < 0)
          m_logger << it->second <<  ", "; 
        else
          m_logger << (0xFFFFFF / float(0x1000000 - it->second)) <<  ", "; 
      }
      m_logger << Root::kINFO << Root::GEndl;
 
      // Iterate through both lists and keep lowest non-negative prescale
      std::list< std::pair<IOVRange, cool::Int32> >::iterator it1;
      std::list< std::pair<IOVRange, cool::Int32> >::iterator it2;
      for(it1 = L1preObj.data.begin(), it2 = L1preOther.data.begin(); it1 != L1preObj.data.end(); ++it1, ++it2) {
 
        // -1 is disabled, otherwise this is the event count to prescale
        if ((it2->second > 0) && (it1->second > it2->second)) {
          // Check if they are both prescaled (this is bad)
          if ((it1->second > 1) && (it2->second > 1)) {
            m_logger << Root::kWARNING << "L1 Prescales combined with both triggers prescaled for Run " << m_runnbr << "!" << Root::GEndl;
          }
          it1->second = it2->second;// See if this works...
        }
      }
    }
 
    // OK done, lets check the result
    // Dump prescales
    m_logger << Root::kINFO << std::setw(10) << std::left << "L1 Pre:";
    for(it = L1preObj.data.begin(); it != L1preObj.data.end(); ++it) {
      m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" ;
 
      if (it->second < 0)
        m_logger << it->second <<  ", "; 
      else
        m_logger << (0xFFFFFF / float(0x1000000 - it->second)) <<  ", "; 
    }
    m_logger << Root::kINFO << Root::GEndl;
 
      }
 
    }
      
    if(m_L2Valid) {
      if (isrun2) {
    L2preObj = cq_trigger->getIOVData<cool::Float>("Prescale", m_parhltprescalesfolder, 20000 + m_L2id);
      }
      else {
    L2preObj = cq_trigger->getIOVData<cool::Float>("Prescale", m_parhltprescalesfolder, 2*m_L2id);
      }
    }    
      
    if(m_L3Valid) {
      L3preObj = cq_trigger->getIOVData<cool::Float>("Prescale", m_parhltprescalesfolder, 2*m_L3id+1);
    }
 
    // Reload the time map to get the ATLAS range
    L1starttime_map.clear();
    L1endtime_map.clear();
    L1starttime_map = cq_trigger->getObjMapFromFolderAtChan<cool::UInt63>("StartTime", m_parlvl1lblbfolder, 0);
    L1endtime_map = cq_trigger->getObjMapFromFolderAtChan<cool::UInt63>("EndTime", m_parlvl1lblbfolder, 0);
 
    // Restrict lb range if necessary based on actual ATLAS run/lb values
    if (L1starttime_map.begin()->first > iovr->start().re_time() || L1starttime_map.rbegin()->first < iovr->stop().re_time()) {
      m_lbstart = (L1starttime_map.begin()->first & 0xFFFFFFFF);
      m_lbstop = (L1starttime_map.rbegin()->first & 0xFFFFFFFF);
      m_logger << Root::kINFO << "Restricting to valid ATLAS lumi block range [" << m_lbstart << "-" << m_lbstop << "]" << Root::GEndl;
    }
 
 
    //
    // Dont assume that all lumi blocks in this range are present in the lumi DB.
    // Loop over all lumi blocks specifically and flag any missing lumi entries as bad lumi blocks.
    //
 
    // Counters to check for missing LB ranges
    int firstMissing = -1;
    int lastMissing = -1;
 
    for (cool::ValidityKey currentVK = L1starttime_map.begin()->first; currentVK <= L1starttime_map.rbegin()->first; currentVK++) {
      
      // Current IOVTime
      IOVTime curIOV;
      curIOV.setRETime(currentVK);
 
      m_clumiblocknbr = curIOV.event();
      m_clumiblocknbrend = curIOV.event()+1;
 
      // Check here for duplicate lumi blocks by explicitly keeping track of every run/lb seen
      if (lbrunset.count(curIOV.re_time()) != 0) {
    m_logger << Root::kWARNING << "Skipping duplicate [run,lumiblock]: " << curIOV << " !" << Root::GEndl;
    continue;
      } else {
    lbrunset.insert(curIOV.re_time());
      }
      
      // Not really good, just all seen
      m_totalgoodblock += 1;
      m_t_totalgoodblock += 1;
      
      // Find luminosity record
      std::map<cool::ValidityKey, CoolQuery::LumiFolderData>::iterator itOL = LumiDataMap.find(currentVK);
 
      // Check if we didn't find anything
      if (itOL == LumiDataMap.end()) {
 
    m_t_totalbadblock++;
    m_totalbadblock++;
 
    if (firstMissing < 0) {
      // Is this the first missing one?  If so, make a note of it and go on
      firstMissing = curIOV.event();
      lastMissing = firstMissing;
    } else if (int(curIOV.event()) == (lastMissing+1)) {
      // Is this a contiguous missing lumi block?
      lastMissing = curIOV.event();
    } else {
      // Not contiguous, print previous
      if (firstMissing == lastMissing) {
        m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB " << firstMissing << " !" << Root::GEndl;
      } else {
        m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB [" << firstMissing << "-" << lastMissing << "] !" << Root::GEndl;
      }
      firstMissing = curIOV.event();
      lastMissing = firstMissing;
    }
 
    // If last time through loop, print this also
    if (currentVK == L1starttime_map.rbegin()->first) {
      if (firstMissing == lastMissing) {
        m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB " << firstMissing << " !" << Root::GEndl;
      } else {
        m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB [" << firstMissing << "-" << lastMissing << "] !" << Root::GEndl;
      }
      firstMissing = -1;
      lastMissing = -1;
    }
 
    // Skip rest of this LB
    continue;
 
      } else {
 
    // Check if we had previous missing block
    if (firstMissing >= 0) {
      if (firstMissing == lastMissing) {
        m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB " << firstMissing << " !" << Root::GEndl;
      } else {
        m_logger << Root::kWARNING << "Luminosity info not found for Run " << m_runnbr << " LB [" << firstMissing << "-" << lastMissing << "] !" << Root::GEndl;
      }
 
      firstMissing = -1;
      lastMissing = -1;
    }
 
      }
 
 
      // given in units of ub^{-1} = 10^{30} cm^{-2}
      m_instLumi = (itOL->second).LBAvInstLumi;
      m_AvEvtsPerBX = (itOL->second).LBAvEvtsPerBX;
      m_Valid = (itOL->second).Valid;
      
 
      // Clear values in case trigger isn't defined
      m_l1acc = 0.;
      m_beforeprescale = 0.;
      m_afterprescale = 0.;
      m_l2acc = 0.;
      m_l3acc = 0.;
      
      // Store dummy prescale values at start
      m_l1prescale = -1.;
      m_l2prescale = -1.;
      m_l3prescale = -1.;
      
      // Some trigger is defined.  Get prescales and values here
       if(m_L1Valid && m_triglevel > 0) {
    
     // Get L1 prescale
     if (isrun2) {
       if (L1preObj.getValue(curIOV) < 0)
         m_l1prescale = L1preObj.getValue(curIOV);
       else
         m_l1prescale = 0xFFFFFF / float(0x1000000 - L1preObj.getValue(curIOV));
     }
     else {
       m_l1prescale = L1preObj.getValue(curIOV);
     }
 
    if (m_triglevel >=2) {
      if(m_L2Valid) {
 
        // Get L2 prescale
        m_l2prescale = L2preObj.getValue(curIOV);
 
      }
      // Else, prescale stays at -1.
      
    } else {
      // Force L2 'passthrough'
      m_l2prescale = 1.;
    }
    
    if(m_triglevel == 3){
      if (m_L3Valid) {
 
        // Get L3 prescale
        m_l3prescale = L3preObj.getValue(curIOV);
 
      }
      // Else, L3 prescale stays at -1.
    } else {
      // Force L3 'passthrough'
      m_l3prescale = 1.;
    }
      }
      
      //-------------------------------
      // Calculate livetime from a dedicated not rare trigger if user requested
      CoolQuery::L1CountFolderData l1count = Livetime_map.find(currentVK)->second;
 
      m_livetime_beforeprescale = l1count.BeforePrescale;
      m_livetime_afterprescale = l1count.AfterPrescale;
      m_livetime_l1acc = l1count.L1Accept;
      if(m_livetime_afterprescale > 0.){
    m_livefrac = m_livetime_l1acc/(float)m_livetime_afterprescale;
      }else{
    m_livefrac = 0.0;
      }
      
      // Hack for bad SFO in particular run
      if (m_runnbr == 286367) {
    m_livefrac *= 5./6.;
      }
 
      if (m_runnbr == 281385) {
    if (m_clumiblocknbr <= 196) {
      m_livefrac *= 4./6.;
    } else if (m_clumiblocknbr <= 374) {
      m_livefrac *= 5./6.;
    }
      }
 
      // Check for low statistics in afterprescale counts
      if(m_livetime_beforeprescale > 0 && m_livetime_afterprescale <= 0 ){
    std::string ttrig = "";
    ttrig = triggerchain;
    if(m_uselivetrigger)ttrig = m_livetrigger;
    m_logger << Root::kWARNING << "L1 counts after prescale (before veto) are 0.0 for trigger " << std::move(ttrig) << "! Livefraction set to zero!" << Root::GEndl;
    m_logger << Root::kWARNING << "Try using a high rate L1 trigger for livetime calculation: --livetrigger=<high rate L1 trigger> " << Root::GEndl;
    m_logger << Root::kINFO << m_runnbr << "[" << m_clumiblocknbr << "]: L1Acc: " << m_l1acc << ", AfterPrescale: " << m_afterprescale  << ", L1Presc: " << m_l1prescale << Root::GEndl;
      }     
 
      //------------------------
      // Calculate LAr veto time
      auto itStartTime = L1starttime_map.find(currentVK);
      auto itEndTime = L1endtime_map.find(currentVK);
      if (itStartTime == L1starttime_map.end()  or itEndTime == L1endtime_map.end()){
        throw std::runtime_error("LumiCalculator::IntegrateLumi Start or End times not found in map.");
      }
      cool::ValidityKey lbstarttime = L1starttime_map.find(currentVK)->second;
      cool::ValidityKey lbendtime = L1endtime_map.find(currentVK)->second;
 
      m_lartime = 0.; // Time to exclude in seconds
      if (m_uselar) {
 
    IOVTime lbstart, lbend;
    lbstart.setRETime(lbstarttime);
    lbend.setRETime(lbendtime);
    IOVRange range(lbstart, lbend);
 
    std::list<std::pair<IOVRange, cool::UInt32> > larlist;
    larlist = LArObj.getOverlap(range);
 
    for (std::list<std::pair<IOVRange, cool::UInt32> >::iterator it = larlist.begin(); it != larlist.end(); ++it) {
      if (it->second == 0) continue;
      float dtime = (it->first.stop().re_time() - it->first.start().re_time())/1.E9;
      m_lartime += dtime;
      if (m_verbose == true) {
        m_logger << Root::kINFO << "Found LAr veto from " << it->first.start().re_time() << " to " << it->first.stop().re_time() << " = " << dtime << " seconds" << Root::GEndl;
      }
    }
      }
 
      //------------------------
      // Check for online BS
      m_bsvalid = 1.;
      if (m_usebs) {
 
    // Read beamspot validity
    bool valid = true;
    int status = BSObj.getValue(curIOV);
    //m_logger << Root::kINFO << "Found online beamspot status = " << status << Root::GEndl;
 
    if (status != 7) valid = false;
 
    if (!valid) {
      m_bsvalid = 0.0;
      m_livefrac = 0.0;
      if(m_verbose == true){
        m_logger << Root::kINFO << m_runnbr << "[" << m_clumiblocknbr << "]: Online beamspot invalid with Lumi=" << m_instLumi << " 10^30 cm-2 s-1" << Root::GEndl;
      }
    }
      }
 
      //-------------------------------
 
      l1count = L1accept_map.find(currentVK)->second;
      m_beforeprescale = l1count.BeforePrescale;
      m_beforeprescaleof = false;
      m_afterprescale = l1count.AfterPrescale;
      m_afterprescaleof = false;
      m_l1acc = l1count.L1Accept;
      m_l1accof = false;
      
      m_deltaT = (lbendtime-lbstarttime)/1.E9;
      m_lbstarttime = lbstarttime/1.E9;
      m_lbendtime = lbendtime/1.E9;
 
      if (m_deltaT > 0.) m_larfrac = 1.-m_lartime/m_deltaT;
 
      // For online lumi database case one needs to make some changes:
      if(m_onlinelumi == true){
    // In Valid UInt32 type value some information is encoded:
    // see: https://twiki.cern.ch/twiki/bin/view/Atlas/CoolOnlineData#Folder_TRIGGER_LUMI_LBLESTONL 
    cool::UInt32 tempValid = (m_Valid & 1023);
        
    if(tempValid == 10){
      // in this bits, Value 301 and 302 means MBTS and LUCID lumi for which some care is needed
      if((m_Valid >> 22) == 301
         || (m_Valid >> 22) == 302 
         || (m_Valid >> 22) == 101
         || (m_Valid >> 22) == 102
         || (m_Valid >> 22) == 103
         || (m_Valid >> 22) == 104
         ){
        m_Valid = 0;
      }else{
        m_Valid = tempValid;
      }
    }else{
      m_Valid = tempValid;
    }
    
      } else {
    
    // For offline, we also need to strip out the preferred channel value from the validity word
    m_Valid &= 0xFFFF;
      }
 
      // Dump out debugging information
      if(m_verbose == true){
    m_logger << Root::kINFO << m_runnbr << "[" << m_clumiblocknbr << "]: L1Acc: " << m_l1acc;
    if(m_uselivetrigger) m_logger << ", Livetime trigger L1Acc: " << m_livetime_l1acc;
    m_logger << ", InstLumi: " << m_instLumi << ", deltaT: " << m_deltaT << ", AvEvtsPerBX: " << m_AvEvtsPerBX << ", BeforePrescale: " << m_beforeprescale << ", AfterPrescale: " << m_afterprescale;
    if (m_uselivetrigger) m_logger  << ", Livetime trigger BeforePrescale: " << m_livetime_beforeprescale << " Livetime trigger AfterPrescale: " << m_livetime_afterprescale;
    if (isrun2) {
      m_logger  << ", Livefrac: " << m_livefrac << ", L1Presc: " << m_l1prescale << ", HLTPresc: " << m_l2prescale <<  ", Valid: " << m_Valid;
    } else {
      m_logger  << ", Livefrac: " << m_livefrac << ", L1Presc: " << m_l1prescale << ", L2Presc: " << m_l2prescale << ", L3Presc: " << m_l3prescale <<  ", Valid: " << m_Valid;
    }
    if (m_uselar) m_logger << ", LAr ready fraction: " << m_larfrac;
    m_logger << Root::GEndl;
      }
 
      // Check if we have valid luminosity
      // Just need to check lowest digit.  10 -> BCID blind, 100 -> mu not valid
      if(m_Valid%10 != 0){
      
    // Invalid luminosity entry, call it bad
    m_instLumi = 0.0;
    m_totalbadblock += 1;
    m_t_totalbadblock += 1;
    m_logger << Root::kWARNING << "Skipping lumiblock " <<  m_runnbr << "[" << m_clumiblocknbr << "] with invalid inst. lumi. (valid=" << m_Valid << ")!" << Root::GEndl;
    
      } else if ((m_triglevel > 0) && (m_l1prescale < 0. || m_l2prescale < 0. || m_l3prescale < 0.)) {
    
    // Disabled trigger, call bad but still record delivered luminosity
    m_totalbadblock += 1;
    m_t_totalbadblock += 1;
    m_logger << Root::kWARNING << "Lumiblock " <<  m_runnbr << "[" << m_clumiblocknbr << "] has a disabled or incorrectly specified trigger.! " << Root::GEndl;
    
      }
 
      //========================================================//
      //   L U M I N O S I T Y  C A L C U L A T I O N  H E R E  //
      //========================================================//
      // The actual calculation of integrated luminosity and 
      // accumulation of some variables
      m_totalDelL += (m_deltaT*m_instLumi); // delivered lumi
      m_t_totalDelL += (m_deltaT*m_instLumi); // delivered lumi
      m_t_deltaT += m_deltaT;
      
      // Count up everything
      m_totall1acc += m_l1acc;
      m_livtrig_totall1acc += m_livetime_l1acc;
      m_t_l1acc += m_l1acc;
      m_totall1befpresc += m_beforeprescale;
      m_t_totall1befpresc += m_beforeprescale;
      m_totall2acc += m_l2acc;
      m_t_l2acc += m_l2acc;
      m_totall3acc += m_l3acc;
      m_t_l3acc += m_l3acc;
      m_livetime = m_livefrac*m_deltaT;
      m_totaltime += m_livetime;
      m_t_totaltime += m_livetime;
      
      double totalPrescale = m_l1prescale * m_l2prescale * m_l3prescale;
    
      // Check for disabled triggers
      if (m_l1prescale < 0. ) totalPrescale = 0.;
      if (m_l2prescale < 0. ) totalPrescale = 0.;
      if (m_l3prescale < 0. ) totalPrescale = 0.;
      
      // Check also for no trigger
      if (m_triglevel == 0) totalPrescale = 1.;
    
      m_intLumi = 0.;
 
      m_lumiWOPrescale += m_livetime*m_instLumi ;
      m_t_lumiWOPrescale += m_livetime*m_instLumi ;
 
      m_lumiLAr += m_livetime*m_larfrac*m_instLumi;
      m_t_lumiLAr += m_livetime*m_larfrac*m_instLumi;
 
      if (totalPrescale > 0.) {
    m_totalPrescaleWLiveTime += m_livetime/totalPrescale; 
    m_t_totalPrescaleWLiveTime += m_livetime/totalPrescale; 
    m_totalPrescale += 1./totalPrescale;
    m_t_totalPrescale += 1./totalPrescale;
    m_intLumi = m_larfrac * m_livetime * m_instLumi/totalPrescale; // <<<---  T H E  F O R M U L A
      } 
 
 
      m_totalL += m_intLumi;
      m_t_totalL += m_intLumi; 
      m_totalLRun += m_intLumi;
 
      
      // MB: trigger rates, note that livefrac drops out of ratio
      m_l1rate = ( m_livetime>0 ? m_l1acc / m_livetime : 0. );
      m_l2rate = ( m_livetime>0 ? m_l2acc / m_livetime : 0. );
      m_l3rate = ( m_livetime>0 ? m_l3acc / m_livetime : 0. );
      
      // MB: delivered lumi
      m_l1ratediveffxsec = (float)m_afterprescale/( m_deltaT*m_effxsec );
      m_total_l1ratediveffxsec += (float)m_afterprescale / m_effxsec ;
      m_total_l1ratediveffxsecRun += (float)m_afterprescale / m_effxsec ;
      
      // MB: recorded lumi
      m_l1ratediveffxsec_recorded = (float)m_l1acc /( m_deltaT*m_effxsec );
      m_total_l1ratediveffxsec_recorded += (float)m_l1acc / m_effxsec ;
      m_total_l1ratediveffxsecRun_recorded += (float)m_l1acc / m_effxsec ;
      
      if (m_collsgrl!=0) {
    if ( m_l1rate>=m_mintrigrate )
      m_collsgrl->AddRunLumiBlock(m_runnbr,m_clumiblocknbr);
      }
      
      if (m_verbose) {
    if (m_effxsec!=1.0)
      m_logger << Root::kINFO << "L1rate a/ prescale: " << m_afterprescale << ", Delivered LumiFromL1rate (/ub): " << m_l1ratediveffxsec << ", Delivered TotalLumiFromL1rate (/ub): " << m_total_l1ratediveffxsec
           << Root::GEndl;
      }
      
      if(m_LumiTree != 0)m_LumiTree->Fill();
    } // End of loop over lumi blocks
 
    // Print IOV summary
    m_logger << Root::kINFO<< std::setw(10) << std::left << ">== Trigger  : " << triggerchain << Root::GEndl;
    m_logger << Root::kINFO<< std::setw(10) << std::right << "Run" <<  std::setw(10) << std::right << "L1-Acc" << std::setw(10) << std::right << "L2-Acc" << std::setw(10) << std::right <<  "L3-Acc" << std::setw(10) << std::right <<  "LiveTime" << std::setw(18) << std::right <<  "IntL rec.(ub^-1)" << std::setw(18) << std::right <<  "IntL del.(ub^-1)" << Root::GEndl;
    m_logger << Root::kINFO<< std::setw(10) << std::right << m_runnbr << std::setw(10) << std::right << m_t_l1acc << std::setw(10) << std::right << m_t_l2acc << std::setw(10) << std::right << m_t_l3acc << std::setw(10) << std::right << m_t_totaltime << std::setw(18) << std::right << m_t_totalL << std::setw(18) << std::right << m_t_totalDelL << Root::GEndl;
    //    m_logger << Root::kINFO << std::setw(10) << std::right << "BeforePrescale" << std::setw(10) << std::right << m_totall1befpresc << std::setw(10) << std::right << "" << std::setw(10) << std::right << "" << std::setw(10) << std::right << "" << std::setw(10) << std::right << "" << std::setw(10) << std::right << "" << std::setw(10) << m_TotaldeltaT << std::setw(14) << std::right << m_totalL << Root::GEndl;
    
    m_logger << Root::kINFO<< std::setw(10) << std::left << "L1/2/3 accept: " <<  std::setw(10) << std::left << m_t_l1acc <<  std::setw(10) << std::left << m_t_l2acc <<  std::setw(10) << std::left << m_t_l3acc << Root::GEndl;
    m_logger << Root::kINFO << std::setw(10) << std::left << "L1BeforePresc: " << std::setw(10) << std::left << m_t_totall1befpresc << Root::GEndl;
    m_logger << Root::kINFO << std::setw(10) << std::left << "Livetime     : " << m_t_totaltime << Root::GEndl;
    m_logger << Root::kINFO << std::setw(10) << std::left << "Prescale Weighted Livetime: " <<  m_t_totalPrescaleWLiveTime << Root::GEndl; 
    m_logger << Root::kINFO<< std::setw(10)  << std::left << "Good LBs     : " << m_t_totalgoodblock - m_t_totalbadblock << Root::GEndl;
    m_logger << Root::kINFO<< std::setw(10)  << std::left << "Bad LBs      : " << m_t_totalbadblock << Root::GEndl;
    
    if ( m_effxsec==1.0 ) {
      m_logger << Root::kINFO << std::setw(10) << std::left << "IntL delivered (ub^-1) : " << m_t_totalDelL << Root::GEndl;
      m_logger << Root::kINFO << std::setw(10) << std::left << "IntL after livefraction (ub^-1):  " <<  m_t_lumiWOPrescale << Root::GEndl;
      if (m_uselar)
    m_logger << Root::kINFO << std::setw(10) << std::left << "IntL after LAr fraction (ub^-1):  " <<  m_t_lumiLAr << Root::GEndl;
      m_logger << Root::kINFO << std::setw(10) << std::left << "IntL recorded after prescale (ub^-1) : " << m_t_totalL << Root::GEndl;
    } else {
      m_logger << Root::kINFO << std::setw(10) << std::left << "IntL delived  (ub^-1) : " << m_total_l1ratediveffxsec << Root::GEndl;
      m_logger << Root::kINFO << std::setw(10) << std::left << "IntL recorded (ub^-1) : " << m_total_l1ratediveffxsec_recorded << Root::GEndl;
    }
 
    // Print prescales as range of actual lumi blocks these apply to
    if(m_triglevel >= 1){
      // Print L1 Prescale values:
      m_logger << Root::kINFO << std::setw(10) << std::left << "L1 Prescales: ";
 
      std::list< std::pair<IOVRange, cool::Int32> >::iterator it;
      for(it = L1preObj.data.begin(); it != L1preObj.data.end(); ++it) {
    m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" ;
    if (isrun2) {
      if (it->second < 0)
        m_logger << it->second <<  ", "; 
      else
        m_logger << (0xFFFFFF / float(0x1000000 - it->second)) <<  ", "; 
    } else {
      m_logger << it->second <<  ", "; 
    }
      }
      m_logger << Root::kINFO << Root::GEndl;
    }
    
    if(m_triglevel >= 2){
      // Print L2 Prescale values:
      if (isrun2) {
    m_logger << Root::kINFO << std::setw(10) << std::left << "HLT Prescales: ";
      } 
      else {
    m_logger << Root::kINFO << std::setw(10) << std::left << "L2 Prescales: ";
      }
 
      std::list< std::pair<IOVRange, cool::Float> >::iterator it;
      for(it = L2preObj.data.begin(); it != L2preObj.data.end(); ++it) {
    m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" << it->second <<  ", "; 
      }
      m_logger << Root::kINFO << Root::GEndl;
    }
    
    if(m_triglevel == 3){
      // Print L3 Prescale values:
      m_logger << Root::kINFO << std::setw(10) << std::left << "L3 Prescales: ";
 
      std::list< std::pair<IOVRange, cool::Float> >::iterator it;
      for(it = L3preObj.data.begin(); it != L3preObj.data.end(); ++it) {
    m_logger << Root::kINFO << std::setw(1) << std::left << "[" << it->first.start().event() << "," << it->first.stop().event()-1 << "]:" << it->second <<  ", "; 
      }
      m_logger << Root::kINFO << Root::GEndl;
    }  
 
  } // end lb collection loop
 
 
  // ------------------------------------------------------------------------------------------------
  // MB : Print total only at end of LB loop:
  m_logger << Root::kINFO << std::left << "-----------------------------------" << Root::GEndl;
  m_logger << Root::kINFO << std::left << "  LumiCalculator summary" << Root::GEndl;
  m_logger << Root::kINFO << std::left << "-----------------------------------" << Root::GEndl;
  m_logger << Root::kINFO<< std::setw(10) << std::right << "Total" <<  std::setw(10) << std::right << "L1-Acc" << std::setw(10) << std::right << "L2-Acc" << std::setw(10) << std::right <<  "L3-Acc" <<
              std::setw(10) << std::right <<  "LiveTime" << std::setw(18) << std::right <<  "IntL rec.(ub^-1)" << std::setw(18) << std::right <<  "IntL del.(ub^-1)" << Root::GEndl;
  m_logger << Root::kINFO<< std::setw(10) << std::right << "" << std::setw(10) << std::right << m_totall1acc << std::setw(10) << std::right << m_totall2acc << std::setw(10) << std::right 
           << m_totall3acc << std::setw(10) << std::right << m_totaltime << std::setw(18) << std::right << m_totalL << std::setw(18) << std::right << m_totalDelL << Root::GEndl;
  m_logger << Root::kINFO<< std::setw(10) << std::left << "Total L1/2/3 accept: " <<  std::setw(10) << std::left << m_totall1acc <<  std::setw(10) << std::left << m_totall2acc <<  std::setw(10) 
           << std::left << m_totall3acc << Root::GEndl;
  if(m_uselivetrigger)m_logger << Root::kINFO<< std::setw(10) << std::left << "Total L1 livetime trigger accept: " <<  std::setw(10) << std::left << m_livtrig_totall1acc << Root::GEndl;
 
  m_logger << Root::kINFO << std::setw(10) << std::left << "First Run: " << std::setw(10) << std::left << m_minrun << Root::GEndl;
  m_logger << Root::kINFO << std::setw(10) << std::left << "Last Run: " << std::setw(10) << std::left << m_maxrun << Root::GEndl;
  m_logger << Root::kINFO << std::setw(10) << std::left << "Total L1BeforePresc: " << std::setw(10) << std::left << m_totall1befpresc << Root::GEndl;
  m_logger << Root::kINFO<< std::setw(10) << std::left  << "Total Livetime     : " << m_totaltime << Root::GEndl;
  m_logger << Root::kINFO << std::setw(10) << std::left << "Total prescale weighted Livetime: " <<  m_totalPrescaleWLiveTime << Root::GEndl;
  m_logger << Root::kINFO<< std::setw(10) << std::left  << "Total Good LBs     : " << m_totalgoodblock - m_totalbadblock << Root::GEndl;
  m_logger << Root::kINFO<< std::setw(10) << std::left  << "Total Bad LBs     : " << m_totalbadblock << Root::GEndl;
  m_logger << Root::kINFO << std::setw(10) << std::left << "Total IntL delivered (ub^-1) : " << m_totalDelL << Root::GEndl;
  m_logger << Root::kINFO << std::setw(10) << std::left << "Total IntL after livefraction (ub^-1):  " <<  m_lumiWOPrescale << Root::GEndl;
  if (m_uselar)
    m_logger << Root::kINFO << std::setw(10) << std::left << "Total IntL after LAr fraction (ub^-1):  " <<  m_lumiLAr << Root::GEndl;
  m_logger << Root::kINFO << std::setw(10) << std::left << "Total IntL recorded (ub^-1) : " << m_totalL << Root::GEndl;
 
  // ------------------------------------------------------------------------------------------------
 
  if(m_makecollList == true){
    // store collisions xml file on demand
    if (m_collsgrl!=0) {
      TString collisionsxml = "collisions_" + m_collsgrl->GetSuggestedName() + ".xml";
      Root::TGoodRunsListWriter writer; 
      writer.SetGoodRunsList( *m_collsgrl );
      writer.SetFilename( collisionsxml.Data() );
      writer.WriteXMLFile();
      // can now delete grl
      delete m_collsgrl; m_collsgrl=0;
    }
  }
 
 
  // Creating monitoring plots on demand
  if(m_makePlots == true) { this->MakePlots(triggerchain); }
 
  delete cq_trigger;
  delete cq_lumi;
  delete cq_lar;
  delete cq_bs;
}