L1TGlobalPrescalesVetosOnlineProd.cc

Go to the documentation of this file.

#include <strings.h> // strcasecmp
#include <iostream>
#include <fstream>
#include <stdexcept>
#include <unordered_map>
#include <utility>

#include "tmEventSetup/tmEventSetup.hh"
#include "tmEventSetup/esTriggerMenu.hh"
#include "tmEventSetup/esAlgorithm.hh"
#include "tmEventSetup/esCondition.hh"
#include "tmEventSetup/esObject.hh"
#include "tmEventSetup/esCut.hh"
#include "tmEventSetup/esScale.hh"
#include "tmGrammar/Algorithm.hh"

#include "CondFormats/L1TObjects/interface/L1TUtmTriggerMenu.h"

#include "CondTools/L1TriggerExt/interface/L1ConfigOnlineProdBaseExt.h"
#include "CondFormats/L1TObjects/interface/L1TGlobalPrescalesVetos.h"
#include "CondFormats/DataRecord/interface/L1TGlobalPrescalesVetosRcd.h"
#include "CondFormats/DataRecord/interface/L1TGlobalPrescalesVetosO2ORcd.h"
#include "L1Trigger/L1TGlobal/interface/PrescalesVetosHelper.h"
#include "L1Trigger/L1TCommon/interface/TriggerSystem.h"
#include "L1Trigger/L1TCommon/interface/XmlConfigParser.h"
#include "OnlineDBqueryHelper.h"

class L1TGlobalPrescalesVetosOnlineProd : public L1ConfigOnlineProdBaseExt<L1TGlobalPrescalesVetosO2ORcd,L1TGlobalPrescalesVetos> {
private:
    bool transactionSafe;
public:
    std::shared_ptr<L1TGlobalPrescalesVetos> newObject(const std::string& objectKey, const L1TGlobalPrescalesVetosO2ORcd& record) override ;

    L1TGlobalPrescalesVetosOnlineProd(const edm::ParameterSet&);
    ~L1TGlobalPrescalesVetosOnlineProd(void) override{}
};

L1TGlobalPrescalesVetosOnlineProd::L1TGlobalPrescalesVetosOnlineProd(const edm::ParameterSet& iConfig) : L1ConfigOnlineProdBaseExt<L1TGlobalPrescalesVetosO2ORcd,L1TGlobalPrescalesVetos>(iConfig) {
    transactionSafe = iConfig.getParameter<bool>("transactionSafe");
}

std::shared_ptr<L1TGlobalPrescalesVetos> L1TGlobalPrescalesVetosOnlineProd::newObject(const std::string& objectKey, const L1TGlobalPrescalesVetosO2ORcd& record) {
    using namespace edm::es;

    edm::LogInfo( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "Producing L1TGlobalPrescalesVetos with TSC:RS key = " << objectKey ;

    if( objectKey.empty() ){
        if( transactionSafe )
            throw std::runtime_error("SummaryForFunctionManager: uGTrs | Faulty  | Empty objectKey");
        else {
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
            return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
        }
    }

    unsigned int m_numberPhysTriggers = 512;

    // dictionary that maps algorithm name to it's index
    std::unordered_map<std::string, int, std::hash<std::string>> algoName2bit;

    std::string uGTtscKey = objectKey.substr(0, objectKey.find(":"));
    std::string uGTrsKey  = objectKey.substr(objectKey.find(":")+1, std::string::npos);

    std::string stage2Schema = "CMS_TRG_L1_CONF" ;

        std::string l1_menu_key;
        std::vector< std::string > queryStrings ;
        queryStrings.push_back( "L1_MENU" ) ;

        // select L1_MENU from CMS_TRG_L1_CONF.UGT_KEYS where ID = objectKey ;
        l1t::OMDSReader::QueryResults queryResult =
            m_omdsReader.basicQuery( queryStrings,
                                     stage2Schema,
                                     "UGT_KEYS",
                                     "UGT_KEYS.ID",
                                     m_omdsReader.singleAttribute(uGTtscKey)
                                   ) ;

        if( queryResult.queryFailed() || queryResult.numberRows() != 1 ){
            edm::LogError( "L1-O2O" ) << "Cannot get UGT_KEYS.L1_MENU for ID = " << uGTtscKey << " " ;
            if( transactionSafe )
                throw std::runtime_error("SummaryForFunctionManager: uGTrs | Faulty  | Broken key");
            else {
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
                return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
            }
        }

        if( !queryResult.fillVariable( "L1_MENU", l1_menu_key) ) l1_menu_key = "";

        edm::LogInfo( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "Producing L1TUtmTriggerMenu with key =" << l1_menu_key;

        if( uGTtscKey.empty() ){
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "TSC key is empty, returning";
            if( transactionSafe )
                throw std::runtime_error("SummaryForFunctionManager: uGTrs | Faulty  | Empty objectKey");
            else {
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
                return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
            }
        }

        std::vector< std::string > queryColumns;
        queryColumns.push_back( "CONF" ) ;

        queryResult =
            m_omdsReader.basicQuery( queryColumns,
                                     stage2Schema,
                                     "UGT_L1_MENU",
                                     "UGT_L1_MENU.ID",
                                     m_omdsReader.singleAttribute(l1_menu_key)
                                   ) ;

        if( queryResult.queryFailed() || queryResult.numberRows() != 1 ){
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "Cannot get UGT_L1_MENU.CONF for ID = " << l1_menu_key;
            if( transactionSafe )
                throw std::runtime_error("SummaryForFunctionManager: uGTrs | Faulty  | Broken key");
            else {
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
                return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
            }
        }

        std::string l1Menu;
        queryResult.fillVariable( "CONF", l1Menu );
        std::istringstream iss(l1Menu);

        std::shared_ptr<L1TUtmTriggerMenu> pMenu(
            const_cast<L1TUtmTriggerMenu*>(
                reinterpret_cast<const L1TUtmTriggerMenu*>(tmeventsetup::getTriggerMenu(iss))
            )
        );

        for(auto algo : pMenu->getAlgorithmMap())
           algoName2bit[algo.first] = algo.second.getIndex();




    queryColumns.clear();
    queryColumns.push_back( "ALGOBX_MASK"     ) ;
    queryColumns.push_back( "ALGO_FINOR_MASK" ) ;
    queryColumns.push_back( "ALGO_FINOR_VETO" ) ;
    queryColumns.push_back( "ALGO_PRESCALE"   ) ;

    std::string prescale_key, bxmask_key, mask_key, vetomask_key;
    std::string xmlPayload_prescale, xmlPayload_mask_algobx, xmlPayload_mask_finor, xmlPayload_mask_veto;
    try {
        std::map<std::string,std::string> subKeys = l1t::OnlineDBqueryHelper::fetch( queryColumns, "UGT_RS_KEYS", uGTrsKey, m_omdsReader );
        prescale_key = subKeys["ALGO_PRESCALE"];
        bxmask_key   = subKeys["ALGOBX_MASK"];
        mask_key     = subKeys["ALGO_FINOR_MASK"];
        vetomask_key = subKeys["ALGO_FINOR_VETO"];
        xmlPayload_prescale    = l1t::OnlineDBqueryHelper::fetch( {"CONF"}, "UGT_RS_CLOBS", prescale_key, m_omdsReader )["CONF"];
        xmlPayload_mask_algobx = l1t::OnlineDBqueryHelper::fetch( {"CONF"}, "UGT_RS_CLOBS", bxmask_key,   m_omdsReader )["CONF"];
        xmlPayload_mask_finor  = l1t::OnlineDBqueryHelper::fetch( {"CONF"}, "UGT_RS_CLOBS", mask_key,     m_omdsReader )["CONF"];
        xmlPayload_mask_veto   = l1t::OnlineDBqueryHelper::fetch( {"CONF"}, "UGT_RS_CLOBS", vetomask_key, m_omdsReader )["CONF"];
    } catch ( std::runtime_error &e ) {
        edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << e.what();
        if( transactionSafe )
            throw std::runtime_error(std::string("SummaryForFunctionManager: uGTrs | Faulty  | ") + e.what());
        else {
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
            return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
        }
    }


    // for debugging purposes dump the payloads to /tmp
    std::ofstream output1(std::string("/tmp/").append(prescale_key.substr(0,prescale_key.find("/"))).append(".xml"));
    output1<<xmlPayload_prescale;
    output1.close();
    std::ofstream output2(std::string("/tmp/").append(mask_key.substr(0,mask_key.find("/"))).append(".xml"));
    output2<<xmlPayload_mask_finor;
    output2.close();
    std::ofstream output3(std::string("/tmp/").append(bxmask_key.substr(0,bxmask_key.find("/"))).append(".xml"));
    output3<<xmlPayload_mask_algobx;
    output3.close();
    std::ofstream output4(std::string("/tmp/").append(vetomask_key.substr(0,vetomask_key.find("/"))).append(".xml"));
    output4<<xmlPayload_mask_veto;
    output4.close();


    std::vector<std::vector<int> > prescales;
    std::vector<unsigned int> triggerMasks;
    std::vector<int> triggerVetoMasks;
    std::map<int, std::vector<int> > triggerAlgoBxMaskAlgoTrig;

    // Prescales
    try {
        l1t::XmlConfigParser xmlReader_prescale;
        l1t::TriggerSystem ts_prescale;
        ts_prescale.addProcessor("uGtProcessor", "uGtProcessor","-1","-1");

        // run the parser 
        xmlReader_prescale.readDOMFromString( xmlPayload_prescale ); // initialize it
        xmlReader_prescale.readRootElement( ts_prescale, "uGT" ); // extract all of the relevant context
        ts_prescale.setConfigured();

        const std::map<std::string, l1t::Parameter> &settings_prescale = ts_prescale.getParameters("uGtProcessor");
        std::map<std::string,unsigned int> prescaleColumns = settings_prescale.at("prescales").getColumnIndices();

        unsigned int numColumns_prescale = prescaleColumns.size();
        int nPrescaleSets = numColumns_prescale - 1;
        std::vector<std::string> algoNames = settings_prescale.at("prescales").getTableColumn<std::string>("algo/prescale-index");

        if( nPrescaleSets > 0 ){
            // Fill default prescale set
            for( int iSet=0; iSet<nPrescaleSets; iSet++ ){
                prescales.push_back(std::vector<int>());
                for(unsigned int iBit = 0; iBit < m_numberPhysTriggers; ++iBit ){
                    int inputDefaultPrescale = 0; // only prescales that are set in the block below are used
                    prescales[iSet].push_back(inputDefaultPrescale);
                }
            }

            for(auto &col : prescaleColumns){
                if( col.second<1 ) continue; // we don't care for the algorithms' indicies in 0th column
                int iSet = col.second - 1;
                std::vector<unsigned int> prescalesForSet = settings_prescale.at("prescales").getTableColumn<unsigned int>(col.first.c_str());
                for(unsigned int row=0; row<prescalesForSet.size(); row++){
                    unsigned int prescale = prescalesForSet[row];
                    std::string  algoName = algoNames[row];
                    unsigned int algoBit  = algoName2bit[algoName];
                    prescales[iSet][algoBit] = prescale;
              }
            }
        }
    } catch ( std::runtime_error &e ){
        if( transactionSafe )
            throw std::runtime_error(std::string("SummaryForFunctionManager: uGTrs | Faulty  | ") + e.what());
        else {
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
            return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
        }
    }


    // finor mask
    try {
        l1t::XmlConfigParser xmlReader_mask_finor;
        l1t::TriggerSystem ts_mask_finor;
        ts_mask_finor.addProcessor("uGtProcessor", "uGtProcessor","-1","-1");

        // run the parser 
        xmlReader_mask_finor.readDOMFromString( xmlPayload_mask_finor ); // initialize it
        xmlReader_mask_finor.readRootElement( ts_mask_finor, "uGT" ); // extract all of the relevant context
        ts_mask_finor.setConfigured();

        const std::map<std::string, l1t::Parameter>& settings_mask_finor = ts_mask_finor.getParameters("uGtProcessor");

        std::vector<std::string>  algo_mask_finor = settings_mask_finor.at("finorMask").getTableColumn<std::string>("algo");
        std::vector<unsigned int> mask_mask_finor = settings_mask_finor.at("finorMask").getTableColumn<unsigned int>("mask");

        // mask (default=1 - unmask)
        unsigned int default_finor_mask = 1;
        auto default_finor_row =
            std::find_if( algo_mask_finor.cbegin(),
                          algo_mask_finor.cend(),
                          [] (const std::string &s){
                              // simpler than overweight std::tolower(s[], std::locale()) POSIX solution (thx to BA):
                              return strcasecmp("all", s.c_str()) == 0;
                          }
            );
        if( default_finor_row == algo_mask_finor.cend() ){
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
                  << "\nWarning: No default found in FinOR mask xml, use 1 (unmasked) as default"
                  << std::endl;
        } else {
            default_finor_mask = mask_mask_finor[ std::distance( algo_mask_finor.cbegin(), default_finor_row ) ];
        }

        for( unsigned int iAlg=0; iAlg < m_numberPhysTriggers; iAlg++ )
            triggerMasks.push_back(default_finor_mask);

        for(unsigned int row=0; row<algo_mask_finor.size(); row++){
            std::string  algoName = algo_mask_finor[row];
            if( strcasecmp("all", algoName.c_str()) == 0 ) continue;
            unsigned int algoBit  = algoName2bit[algoName];
            unsigned int mask     = mask_mask_finor[row];
            if( algoBit < m_numberPhysTriggers ) triggerMasks[algoBit] = mask;
        }
    } catch ( std::runtime_error &e ){
        if( transactionSafe )
            throw std::runtime_error(std::string("SummaryForFunctionManager: uGTrs | Faulty  | ") + e.what());
        else {
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
            return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
        }
    }


    // veto mask
    try {
        l1t::XmlConfigParser xmlReader_mask_veto;
        l1t::TriggerSystem ts_mask_veto;
        ts_mask_veto.addProcessor("uGtProcessor", "uGtProcessor","-1","-1");

        // run the parser 
        xmlReader_mask_veto.readDOMFromString( xmlPayload_mask_veto ); // initialize it
        xmlReader_mask_veto.readRootElement( ts_mask_veto, "uGT" ); // extract all of the relevant context
        ts_mask_veto.setConfigured();

        const std::map<std::string, l1t::Parameter>& settings_mask_veto = ts_mask_veto.getParameters("uGtProcessor");
        std::vector<std::string>  algo_mask_veto = settings_mask_veto.at("vetoMask").getTableColumn<std::string>("algo");
        std::vector<unsigned int> veto_mask_veto = settings_mask_veto.at("vetoMask").getTableColumn<unsigned int>("veto");

        // veto mask (default=0 - no veto)
        unsigned int default_veto_mask = 1;
        auto default_veto_row =
            std::find_if( algo_mask_veto.cbegin(),
                          algo_mask_veto.cend(),
                          [] (const std::string &s){
                              // simpler than overweight std::tolower(s[], std::locale()) POSIX solution (thx to BA):
                              return strcasecmp("all", s.c_str()) == 0;
                          }
            );
        if( default_veto_row == algo_mask_veto.cend() ){
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
                  << "\nWarning: No default found in Veto mask xml, use 0 (unvetoed) as default"
                  << std::endl;
        } else {
            default_veto_mask = veto_mask_veto[ std::distance( algo_mask_veto.cbegin(), default_veto_row ) ];
        }

        for( unsigned int iAlg=0; iAlg < m_numberPhysTriggers; iAlg++ )
            triggerVetoMasks.push_back(default_veto_mask);

        for(unsigned int row=0; row<algo_mask_veto.size(); row++){
            std::string  algoName = algo_mask_veto[row];
            if( strcasecmp("all", algoName.c_str()) == 0 ) continue;
            unsigned int algoBit  = algoName2bit[algoName];
            unsigned int veto    = veto_mask_veto[row];
            if( algoBit < m_numberPhysTriggers ) triggerVetoMasks[algoBit] = int(veto);
        }
    } catch ( std::runtime_error &e ){
        if( transactionSafe )
            throw std::runtime_error(std::string("SummaryForFunctionManager: uGTrs | Faulty  | ") + e.what());
        else {
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
            return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
        }
    }


    // Algo bx mask
    unsigned int m_bx_mask_default = 1;


    std::vector<std::string>  bx_algo_name;
    std::vector<std::string>  bx_range;
    std::vector<unsigned int> bx_mask;

    try {
        l1t::XmlConfigParser xmlReader_mask_algobx;
        l1t::TriggerSystem ts_mask_algobx;
        ts_mask_algobx.addProcessor("uGtProcessor", "uGtProcessor","-1","-1");

        // run the parser 
        xmlReader_mask_algobx.readDOMFromString( xmlPayload_mask_algobx ); // initialize it
        xmlReader_mask_algobx.readRootElement( ts_mask_algobx, "uGT" ); // extract all of the relevant context
        ts_mask_algobx.setConfigured();

        const std::map<std::string, l1t::Parameter>& settings_mask_algobx = ts_mask_algobx.getParameters("uGtProcessor");
        bx_algo_name = settings_mask_algobx.at("algorithmBxMask").getTableColumn<std::string>("algo");
        bx_range     = settings_mask_algobx.at("algorithmBxMask").getTableColumn<std::string>("range");
        bx_mask      = settings_mask_algobx.at("algorithmBxMask").getTableColumn<unsigned int>("mask");
    } catch ( std::runtime_error &e ){
        if( transactionSafe )
            throw std::runtime_error(std::string("SummaryForFunctionManager: uGTrs | Faulty  | ") + e.what());
        else {
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" ) << "returning empty L1TGlobalPrescalesVetos object";
            return std::make_shared< L1TGlobalPrescalesVetos >( ) ;
        }
    }

    int default_bxmask_row = -1;
    typedef std::pair<unsigned long,unsigned long> Range_t;
    // auto comp = [] (Range_t a, Range_t b){ return a.first < b.first; };
    struct RangeComp_t { bool operator()(const Range_t& a, const Range_t& b) const { return a.first < b.first; } };
    std::map<std::string, std::set<Range_t,RangeComp_t>> non_default_bx_ranges;

    for(unsigned int row = 0; row < bx_algo_name.size(); row++){
        const std::string &s1 = bx_algo_name[row];
        const std::string &s2 = bx_range[row];
        // find "all" broadcast keywords
        bool broadcastAlgo  = false;
        bool broadcastRange = false;
        if( strcasecmp("all", s1.c_str()) == 0 ) broadcastAlgo  = true;
        if( strcasecmp("all", s2.c_str()) == 0 ) broadcastRange = true;
        // ALL-ALL-default:
        if( broadcastAlgo && broadcastRange ){
            if( row != 0 ){
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
                    << "\nWarning: ALL-ALL row is not the first one, ignore it assuming 1 (unmasked) as the default"
                    << std::endl;
                continue;
            }
            if( default_bxmask_row >= 0 ){
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
                    << "\nWarning: multiple ALL-ALL rows found, using the first"
                    << std::endl;
                continue;
            }
            default_bxmask_row = row;
            m_bx_mask_default = bx_mask[row];
            continue;
        }
        // interpret the range
        unsigned long first = 0, last = 0;
        if( broadcastRange ){
            first = 0;
            last = 3563;
        } else {
            char *dash = nullptr;
            first = strtoul(s2.data(), &dash, 0);
            while( *dash != '\0' && *dash != '-' ) ++dash;
            last  = (*dash != '\0' ? strtoul(++dash, &dash, 0) : first);
            if( first == 3564 ) first = 0;
            if( last  == 3564 ) last  = 0;
            // what could possibly go wrong?
            if( *dash != '\0' ){
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
                        << "\nWarning: parsing " << s2 << " as [" << first << "," << last << "] range"
                        << std::endl;
            }
            if( first > 3563 ){
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
                        << "\nWarning: start of interval is out of range: " << s2 << ", skipping the row"
                        << std::endl;
                continue;
            }
            if( last > 3563 ){
                last = 3563;
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
                        << "\nWarning: end of interval is out of range: " << s2 << ", force [" << first << "," << last << "] range"
                        << std::endl;
            }
            if( first > last ){
                edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
                       << "\nWarning: inverse/spillover range "<< s2 << ", accounting for circular orbit as [0," << last << "] & [" << first << ",3563]"
                       << std::endl;
            }
        }
        // {algo,ALL}-{range,ALL}-{0,1}:
        std::vector<std::string> algos;
        std::vector<std::pair<unsigned long,unsigned long>> orderedRanges;
        if( first <= last ){
            if( !broadcastAlgo ){
                algos.push_back( bx_algo_name[row] );
                orderedRanges.push_back( std::make_pair(first,last) );
            } else {
                for(const auto &i: non_default_bx_ranges){
                    algos.push_back(i.first);
                    orderedRanges.push_back( std::make_pair(first,last) );
                }
            }
        } else {
            if( !broadcastAlgo ){
                algos.push_back( bx_algo_name[row] );
                algos.push_back( bx_algo_name[row] );
                orderedRanges.push_back( std::make_pair(0,last) );
                orderedRanges.push_back( std::make_pair(first,3563) );
            } else {
                for(const auto &i: non_default_bx_ranges){
                   algos.push_back(i.first);
                   algos.push_back(i.first);
                   orderedRanges.push_back( std::make_pair(0,last) );
                   orderedRanges.push_back( std::make_pair(first,3563) );
                }
            }
        }

        for(unsigned int item=0; item < algos.size(); item++){
           const std::string &algoName = algos[item];
           unsigned int first = orderedRanges[item].first;
           unsigned int last  = orderedRanges[item].second;

           std::set<Range_t,RangeComp_t> &ranges = non_default_bx_ranges[algoName];
//           .insert
//           (
//               std::pair< std::string, std::set<Range_t,RangeComp_t> >
//               (
//                   algoName,  std::set<Range_t,RangeComp_t>()
//               )
//           ).first->second; // I don't care if insert was successfull or if I've got a hold on existing range

           // current range may or may not overlap with the already present ranges
           // if end of the predecessor starts before begin of the current range and begin
           //  of the successor starts after end of the current range there is no overlap
           //  and I save this range only if it has mask different from the default
           //  otherwise modify predecessor/successor ranges accordingly
           std::set<Range_t>::iterator curr = ranges.end(); // inserted range
           std::set<Range_t>::iterator succ = ranges.lower_bound(std::make_pair(first,last)); // successor starts at current or later
           std::set<Range_t>::iterator pred = succ;
           if( pred != ranges.begin() ) pred--; else pred = ranges.end();

           if( (pred == ranges.end() || pred->second < first) &&
               (succ == ranges.end() || succ->first > last) ){
               // no overlap
               if( m_bx_mask_default != bx_mask[row] )
                   curr = ranges.insert(std::make_pair(first,last)).first;
               // do nothing if this is a default-mask interval
           } else {
               // pred/succ iterators are read-only, create intermediate adjusted copies
               Range_t newPred, newSucc;
               bool modifiedPred = false, gapInPred = false, modifiedSucc = false, dropSucc = false;
               // overlap found with predecessor range
               if( pred != ranges.end() && pred->second >= first && pred->second <= last ){
                   if( m_bx_mask_default != bx_mask[row] ){
                       if( last == pred->second ){
                           // both ranges end in the same place - nothing to do
                           modifiedPred = false;
                       } else {
                           // extend predecessor range
                           newPred.first  = pred->first;
                           newPred.second = last;
                           modifiedPred = true;
                       }
                   } else {
                       // shrink predecessor range
                       newPred.first  = pred->first;
                       newPred.second = first-1; // non-negative for the predecessor by design
                       // by design pred->first < first, so the interval above is always valid
                       modifiedPred = true;
                   }
               }
               // current range is fully contained in predecessor
               if( pred != ranges.end() && pred->second > first && pred->second > last ){
                   if( m_bx_mask_default != bx_mask[row] ){
                       // no change to the predecessor range
                       modifiedPred = false;
                   } else {
                       // make a "gap" in predecessor range
                       newPred.first  = first;
                       newPred.second = last;
                       gapInPred = true;
                       modifiedPred = true;
                   }
               }
               // overlap found with successor range
               if( succ != ranges.end() && succ->first <= last ){
                   if( m_bx_mask_default != bx_mask[row] ){
                       // extend successor range
                       newSucc.first  = first;
                       newSucc.second = succ->second;
                   } else {
                       // shrink successor range
                       newSucc.first  = last+1;
                       newSucc.second = succ->second;
                       if( newSucc.first > 3563 || newSucc.first > newSucc.second )
                           dropSucc = true;
                   }
                   modifiedSucc = true;
               }
               // overlap found with both, predecessor and successor, such that I need to merge them
               if( modifiedPred && modifiedSucc && newPred.second >= newSucc.first ){
                   // make newPred and newSucc identical just in case
                   newPred.second = newSucc.second;
                   newSucc.first  = newPred.first;
                   ranges.erase(pred,++succ);
                   curr = ranges.insert(newPred).first;
               } else {
                   // merging is not the case, but I still need to propagate the new ranges back to the source
                   if( modifiedPred ){
                       if( !gapInPred ){
                           ranges.erase(pred);
                           curr = ranges.insert(newPred).first;
                       } else {
                           // make a gap by splitting predecessor into two ranges
                           Range_t r1(pred->first, newPred.first-1); // non-negative for the predecessor by design
                           Range_t r2(newPred.second+1, pred->second);
                           ranges.erase(pred);
                           ranges.insert(r1);
                           ranges.insert(r2);
                           curr = ranges.end(); // gap cannot cover any additional ranges
                       }
                   }
                   if( modifiedSucc ){
                       ranges.erase(succ);
                       if( !dropSucc )
                           curr = ranges.insert(newSucc).first;
                   }
               }
           }
           // if current range spans over few more ranges after the successor
           //  remove those from the consideration up until the last covered range
           //  that may or may not extend beyond the current range end 
           if( curr != ranges.end() ){ // insertion took place
               std::set<Range_t,RangeComp_t>::iterator last_covered = ranges.upper_bound(std::make_pair(curr->second,0));
               if( last_covered != ranges.begin() ) last_covered--; else last_covered = ranges.end();

               if( last_covered != ranges.end() && last_covered->first != curr->first ){
                   // ranges is not empty and last_covered is not current itself (i.e. it is different)
                   if( curr->second < last_covered->second ){
                       // the range needs to be extended
                       Range_t newRange(curr->first, last_covered->second);
                       ranges.erase(curr);
                       curr = ranges.insert(newRange).first;
                   }
                   ranges.erase(++curr,last_covered);
               }
           }
        }
    }

    if( default_bxmask_row < 0 ){
        edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
              << "\nWarning: No default found in BX mask xml, used 1 (unmasked) as default"
              << std::endl;
    }

    for(const std::pair<std::string, std::set<Range_t,RangeComp_t>> &algo : non_default_bx_ranges){
        const std::string &algoName = algo.first;
        unsigned int algoBit  = algoName2bit[algoName];
        for(auto range : algo.second)
           for(unsigned int bx = range.first; bx <= range.second; bx++){
               triggerAlgoBxMaskAlgoTrig[bx].push_back(algoBit);
           }
    }


    // Set prescales to zero if masked
    for( unsigned int iSet=0; iSet < prescales.size(); iSet++ ){
        for( unsigned int iBit=0; iBit < prescales[iSet].size(); iBit++ ){
        // Add protection in case prescale table larger than trigger mask size
        if( iBit >= triggerMasks.size() ){
            edm::LogError( "L1-O2O: L1TGlobalPrescalesVetosOnlineProd" )
          << "\nWarning: algoBit in prescale table >= triggerMasks.size() "
          << "\nWarning: no information on masking bit or not, setting as unmasked "
          << std::endl;
        } else {
            prescales[iSet][iBit] *= triggerMasks[iBit];
        }
      }
    }


  l1t::PrescalesVetosHelper data_( new L1TGlobalPrescalesVetos() );

  data_.setBxMaskDefault       ( m_bx_mask_default         );
  data_.setPrescaleFactorTable ( prescales                 );
  data_.setTriggerMaskVeto     ( triggerVetoMasks          );
  data_.setTriggerAlgoBxMask   ( triggerAlgoBxMaskAlgoTrig );

  using namespace edm::es;
  std::shared_ptr<L1TGlobalPrescalesVetos> payload( std::make_shared<L1TGlobalPrescalesVetos>(*data_.getWriteInstance()) );

  edm::LogInfo( "L1-O2O: L1TCaloParamsOnlineProd" ) << "SummaryForFunctionManager: uGTrs | OK      | All looks good";

  return payload;
}

//define this as a plug-in
DEFINE_FWK_EVENTSETUP_MODULE(L1TGlobalPrescalesVetosOnlineProd);