.. _program_listing_file_Root_HelperClasses.cxx:

Program Listing for File HelperClasses.cxx
==========================================

|exhale_lsh| :ref:`Return to documentation for file <file_Root_HelperClasses.cxx>` (``Root/HelperClasses.cxx``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #include "xAODAnaHelpers/HelperClasses.h"
   #include "xAODPrimitives/IsolationType.h"
   #include "xAODMuon/Muon.h"
   #include "ElectronPhotonSelectorTools/AsgElectronLikelihoodTool.h"
   #include "ElectronPhotonSelectorTools/egammaPIDdefs.h"
   #include "ElectronPhotonSelectorTools/LikelihoodEnums.h"
   #include "xAODTau/TauDefs.h"
   
   namespace HelperClasses{
   
     /* parser for electron isolation enum */
     template <>
     EnumParser<xAOD::Iso::IsolationType>::EnumParser()
     {
       std::string etcone20("etcone20");         enumMap.insert(std::make_pair(etcone20,      xAOD::Iso::etcone20));
       std::string etcone30("etcone30");         enumMap.insert(std::make_pair(etcone30,      xAOD::Iso::etcone30));
       std::string etcone40("etcone40");         enumMap.insert(std::make_pair(etcone40,      xAOD::Iso::etcone40));
       std::string topoetcone20("topoetcone20"); enumMap.insert(std::make_pair(topoetcone20,  xAOD::Iso::topoetcone20));
       std::string topoetcone30("topoetcone30"); enumMap.insert(std::make_pair(topoetcone30,  xAOD::Iso::topoetcone30));
       std::string topoetcone40("topoetcone40"); enumMap.insert(std::make_pair(topoetcone40,  xAOD::Iso::topoetcone40));
       std::string ptcone20("ptcone20");         enumMap.insert(std::make_pair(ptcone20,      xAOD::Iso::ptcone20));
       std::string ptcone30("ptcone30");         enumMap.insert(std::make_pair(ptcone30,      xAOD::Iso::ptcone30));
       std::string ptcone40("ptcone40");         enumMap.insert(std::make_pair(ptcone40,      xAOD::Iso::ptcone40));
       std::string ptcone50("ptcone50");         enumMap.insert(std::make_pair(ptcone50,      xAOD::Iso::ptcone50));
       std::string ptvarcone20("ptvarcone20");   enumMap.insert(std::make_pair(ptvarcone20,   xAOD::Iso::ptvarcone20));
       std::string ptvarcone30("ptvarcone30");   enumMap.insert(std::make_pair(ptvarcone30,   xAOD::Iso::ptvarcone30));
       std::string ptvarcone40("ptvarcone40");   enumMap.insert(std::make_pair(ptvarcone40,   xAOD::Iso::ptvarcone40));
       std::string neflowisol20("neflowisol20"); enumMap.insert(std::make_pair(neflowisol20,  xAOD::Iso::neflowisol20));
       std::string ptcone20_Nonprompt_All_MaxWeightTTVA_pt500 ("ptcone20_Nonprompt_All_MaxWeightTTVA_pt500");                      enumMap.insert(std::make_pair(ptcone20_Nonprompt_All_MaxWeightTTVA_pt500,             xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt500));
       std::string ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000("ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000");                     enumMap.insert(std::make_pair(ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000,            xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000));
       std::string ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500 ("ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500");                      enumMap.insert(std::make_pair(ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500,             xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500));
       std::string ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000("ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000");                     enumMap.insert(std::make_pair(ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000,            xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000));
       std::string ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500 ("ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500");          enumMap.insert(std::make_pair(ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500,       xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt500));
       std::string ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000("ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000");         enumMap.insert(std::make_pair(ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000,      xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVALooseCone_pt1000));
       std::string ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500 ("ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500");    enumMap.insert(std::make_pair(ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500,    xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt500));
       std::string ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000("ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000");   enumMap.insert(std::make_pair(ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000,   xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVALooseCone_pt1000));
     }
   
     /* parser for electron likelihood PID enum */
     template <>
     EnumParser<LikeEnum::Menu>::EnumParser()
     {
       std::string VeryLoose("VeryLoose");                       enumMap.insert(std::make_pair(VeryLoose            , LikeEnum::VeryLoose));
       std::string Loose("Loose");                               enumMap.insert(std::make_pair(Loose                , LikeEnum::Loose));
       std::string LooseBL("LooseBL");                           enumMap.insert(std::make_pair(LooseBL              , LikeEnum::LooseBL));
       std::string Medium("Medium");                             enumMap.insert(std::make_pair(Medium               , LikeEnum::Medium));
       std::string Tight("Tight");                               enumMap.insert(std::make_pair(Tight                , LikeEnum::Tight));
       std::string VeryTight("VeryTight");                       enumMap.insert(std::make_pair(VeryTight            , LikeEnum::VeryTight));
       std::string LooseRelaxed("LooseRelaxed");                 enumMap.insert(std::make_pair(LooseRelaxed         , LikeEnum::Tight));
       std::string CustomOperatingPoint("CustomOperatingPoint"); enumMap.insert(std::make_pair(CustomOperatingPoint , LikeEnum::Tight));
       std::string VeryLooseLLP("VeryLooseLLP");                 enumMap.insert(std::make_pair(VeryLooseLLP         , LikeEnum::VeryLooseLLP));
       std::string LooseLLP("LooseLLP");                         enumMap.insert(std::make_pair(LooseLLP             , LikeEnum::LooseLLP));
       std::string MediumLLP("MediumLLP");                       enumMap.insert(std::make_pair(MediumLLP            , LikeEnum::MediumLLP));
       std::string TightLLP("TightLLP");                         enumMap.insert(std::make_pair(TightLLP             , LikeEnum::TightLLP));
     }
   
     /* parser for electron cut-based PID enum */
     /* Apparently this won't be useful for non-Athena users...  */
     template <>
     EnumParser<egammaPID::egammaIDQuality>::EnumParser()
     {
       std::string ElectronIDLoose("ElectronIDLoose");           enumMap.insert(std::make_pair(ElectronIDLoose    , egammaPID::ElectronIDLoose));
       std::string ElectronIDMedium("ElectronIDMedum");          enumMap.insert(std::make_pair(ElectronIDMedium   , egammaPID::ElectronIDMedium));
       std::string ElectronIDTight("ElectronIDTight");           enumMap.insert(std::make_pair(ElectronIDTight    , egammaPID::ElectronIDTight));
       std::string ElectronIDLoosePP("ElectronIDLoosePP");       enumMap.insert(std::make_pair(ElectronIDLoosePP  , egammaPID::ElectronIDLoosePP));
       std::string ElectronIDLoose1("ElectronIDLoose1");         enumMap.insert(std::make_pair(ElectronIDLoose1   , egammaPID::ElectronIDLoose1));
       std::string ElectronIDLooseHLT("ElectronIDLooseHLT");     enumMap.insert(std::make_pair(ElectronIDLooseHLT , egammaPID::ElectronIDLooseHLT));
       std::string ElectronIDMediumPP("ElectronIDMediumPP");     enumMap.insert(std::make_pair(ElectronIDMediumPP , egammaPID::ElectronIDMediumPP));
       std::string ElectronIDMedium1("ElectronIDMedium1");       enumMap.insert(std::make_pair(ElectronIDMedium1  , egammaPID::ElectronIDMedium1));
       std::string ElectronIDMediumHLT("ElectronIDMediumHLT");   enumMap.insert(std::make_pair(ElectronIDMediumHLT, egammaPID::ElectronIDMediumHLT));
       std::string ElectronIDTightPP("ElectronIDTightPP");       enumMap.insert(std::make_pair(ElectronIDTightPP  , egammaPID::ElectronIDTightPP));
       std::string ElectronIDTight1("ElectronIDTight1");         enumMap.insert(std::make_pair(ElectronIDTight1   , egammaPID::ElectronIDTight1));
       std::string ElectronIDTightHLT("ElectronIDTightHLT");     enumMap.insert(std::make_pair(ElectronIDTightHLT , egammaPID::ElectronIDTightHLT));
     }
   //  template <>
   //  EnumParser<egammaPID::PID>::EnumParser()
   //  {
   //    std::string IsEMLoose("IsEMLoose");     enumMap.insert(std::make_pair( IsEMLoose , egammaPID::IsEMLoose));
   //    std::string IsEMMedium("IsEMMedium");   enumMap.insert(std::make_pair( IsEMMedium, egammaPID::IsEMMedium));
   //    std::string IsEMTight("IsEMTight");     enumMap.insert(std::make_pair( IsEMTight , egammaPID::IsEMTight));
   //  }
   
   
     /* parser for Tau RNN ID enum */
     /* Apparently this won't be useful for non-Athena users...  */
   
     template <>
     EnumParser<xAOD::TauJetParameters::IsTauFlag>::EnumParser()
     {
       std::string TauIDVeryLoose("TauIDVeryLoose"); enumMap.insert(std::make_pair(TauIDVeryLoose , xAOD::TauJetParameters::JetRNNSigVeryLoose));
       std::string TauIDLoose("TauIDLoose");         enumMap.insert(std::make_pair(TauIDLoose     , xAOD::TauJetParameters::JetRNNSigLoose));
       std::string TauIDMedium("TauIDMedium");       enumMap.insert(std::make_pair(TauIDMedium    , xAOD::TauJetParameters::JetRNNSigMedium));
       std::string TauIDTight("TauIDTight");         enumMap.insert(std::make_pair(TauIDTight     , xAOD::TauJetParameters::JetRNNSigTight));
     }
   
     /* parser for muon quality enum */
     template <>
     EnumParser<xAOD::Muon::Quality>::EnumParser()
     {
       std::string VeryLoose("VeryLoose");       enumMap.insert(std::make_pair(VeryLoose    , xAOD::Muon::VeryLoose));
       std::string Loose("Loose");               enumMap.insert(std::make_pair(Loose        , xAOD::Muon::Loose));
       std::string Medium("Medium");             enumMap.insert(std::make_pair(Medium       , xAOD::Muon::Medium));
       std::string Tight("Tight");               enumMap.insert(std::make_pair(Tight        , xAOD::Muon::Tight));
     }
   
     /* parser for muon type enum */
     template <>
     EnumParser<xAOD::Muon::MuonType>::EnumParser()
     {
       std::string Combined("Combined");                               enumMap.insert(std::make_pair(Combined                , xAOD::Muon::Combined));
       std::string MuonStandAlone("MuonStandAlone");                           enumMap.insert(std::make_pair(MuonStandAlone                  , xAOD::Muon::MuonStandAlone));
       std::string SegmentTagged("SegmentTagged");                             enumMap.insert(std::make_pair(SegmentTagged               , xAOD::Muon::SegmentTagged));
       std::string CaloTagged("CaloTagged");                                       enumMap.insert(std::make_pair(CaloTagged                  , xAOD::Muon::CaloTagged));
       std::string SiliconAssociatedForwardMuon("SiliconAssociatedForwardMuon");   enumMap.insert(std::make_pair(SiliconAssociatedForwardMuon , xAOD::Muon::SiliconAssociatedForwardMuon));
     }
   
     std::string InfoSwitch::get_working_point(const std::string flag) {
       for (auto configDetail : m_configDetails) {
         if (configDetail.compare(0, flag.size(), flag) == 0) {
           return configDetail.substr(flag.size(), std::string::npos);
         }
       }
       return "";
     }
   
     std::vector<std::string>InfoSwitch::get_working_points(const std::string flag) {
       std::vector<std::string> wps;
       for (auto configDetail : m_configDetails) {
         if (configDetail.compare(0, flag.size(), flag) == 0) {
           wps.push_back(configDetail.substr(flag.size(), std::string::npos));
         }
       }
       return wps;
     }
   
     /*
               !!!!!!!!!!!!!WARNING!!!!!!!!!!!!!
                 If you change the string here,
                   please update the relevant
               documentation in the header file.
               !!!!!!!!!!!!!WARNING!!!!!!!!!!!!!
     */
   
     void EventInfoSwitch::initialize(){
       m_noDataInfo    = has_exact("noDataInfo");
       m_pileup        = has_exact("pileup");
       m_pileupsys     = has_exact("pileupsys");
       m_eventCleaning = has_exact("eventCleaning");
       m_bcidInfo      = has_exact("bcidInfo");
       m_shapeEM       = has_exact("shapeEM");
       m_shapeEMPFLOW  = has_exact("shapeEMPFLOW");
       m_shapeLC       = has_exact("shapeLC");
       m_truth         = has_exact("truth");
       m_caloClus      = has_exact("caloClusters");
       m_weightsSys    = has_exact("weightsSys");
       m_beamspotweight= has_exact("beamspotweight");
     }
   
     void TriggerInfoSwitch::initialize(){
       m_basic             = has_exact("basic");
       m_menuKeys          = has_exact("menuKeys");
       m_passTriggers      = has_exact("passTriggers");
       m_passTrigBits      = has_exact("passTrigBits");
       m_prescales         = has_exact("prescales");
       m_prescalesLumi     = has_exact("prescalesLumi");
     }
   
     void IParticleInfoSwitch::initialize(){
       m_noMultiplicity= has_exact("noMultiplicity");
       m_kinematic     = has_exact("kinematic");
   
       m_numLeading    = 0;
       for(auto configDetail : m_configDetails)
         {
       if( configDetail.compare(0,8,"NLeading")==0)
         {
           m_numLeading = std::atoi( configDetail.substr(8, std::string::npos).c_str() );
           break;
         }
         }
   
       m_useTheS   = has_exact("useTheS");
     }
   
     void MuonInfoSwitch::initialize(){
       m_trigger       = has_exact("trigger");
       m_isolation     = has_exact("isolation");
       m_isolationKinematics = has_exact("isolationKinematics");
       m_quality       = has_exact("quality");
       m_trackparams   = has_exact("trackparams");
       m_trackhitcont  = has_exact("trackhitcont");
       m_effSF         = has_exact("effSF");
       m_energyLoss    = has_exact("energyLoss");
       m_promptlepton  = has_exact("promptlepton");
   
       // working points combinations for trigger corrections
       std::string token;
       std::string reco_keyword = "RECO_";
       std::string isol_keyword = "ISOL_";
       std::string trig_keyword = "TRIG_";
   
       std::istringstream ss(m_configStr);
       while ( std::getline(ss, token, ' ') ) {
         auto reco_substr = token.find(reco_keyword);
         auto isol_substr = token.find(isol_keyword);
         auto trig_substr = token.find(trig_keyword);
         if( reco_substr != std::string::npos ){
           m_recoWPs.push_back(token.substr(5));
         } else if(isol_substr != std::string::npos){
           if(token.substr(5) == "NONE" || token == isol_keyword) m_isolWPs.push_back("");
           else m_isolWPs.push_back(token.substr(5));
         } else if(trig_substr != std::string::npos){
           m_trigWPs.push_back(token.substr(5));
         }
       }
   
       // passSel
       m_passSel = has_exact("passSel");
       // passOR
       m_passOR = has_exact("passOR");
   
       m_recoEff_sysNames = has_exact("recoEff_sysNames");
       m_isoEff_sysNames  = has_exact("isoEff_sysNames");
       m_trigEff_sysNames = has_exact("trigEff_sysNames");
       m_ttvaEff_sysNames = has_exact("ttvaEff_sysNames");
   
       m_doLRT = has_exact("doLRT");
       m_closeByCorr = has_exact("IsolCloseByCorr");
   
     }
   
     void ElectronInfoSwitch::initialize(){
       m_trigger       = has_exact("trigger");
       m_isolation     = has_exact("isolation");
       m_isolationKinematics = has_exact("isolationKinematics");
       m_quality       = has_exact("quality");
       if (m_quality) {
           std::cerr << "WARNING! The 'quality' option is deprecated in ElectronInfoSwitch. Use 'PID' instead." << std::endl;
       }
       m_PID           = has_exact("PID");
       m_recoparams    = has_exact("recoparams");
       m_trackparams   = has_exact("trackparams");
       m_trackhitcont  = has_exact("trackhitcont");
       m_effSF         = has_exact("effSF");
       m_promptlepton  = has_exact("promptlepton");
       // working points for scale-factors
   
       // working points combinations for trigger corrections
       std::string token;
       std::string pid_keyword = "PID_";
       std::string pidsf_keyword = "PIDSF_";
       std::string isol_keyword = "ISOL_";
       std::string trig_keyword = "TRIG_";
   
       std::istringstream ss(m_configStr);
       while ( std::getline(ss, token, ' ') ) {
         auto pid_substr = token.find(pid_keyword);
         auto pidsf_substr = token.find(pidsf_keyword);
         auto isol_substr = token.find(isol_keyword);
         auto trig_substr = token.find(trig_keyword);
         if( pid_substr != std::string::npos ){
           m_PIDWPs.push_back(token.substr(4));
         } else if( pidsf_substr != std::string::npos ){
           m_PIDSFWPs.push_back(token.substr(6));
         } else if(isol_substr != std::string::npos){
           if(token.substr(5) == "NONE" || token == isol_keyword) m_isolWPs.push_back("");
           else m_isolWPs.push_back(token.substr(5));
         } else if(trig_substr != std::string::npos){
           m_trigWPs.push_back(token.substr(5));
         }
       }
   
       // passSel
       m_passSel = has_exact("passSel");
       // passOR
       m_passOR = has_exact("passOR");
       //Add LRT flag
       m_doLRT = has_exact("doLRT");
   
       m_closeByCorr = has_exact("IsolCloseByCorr");
     }
   
     void PhotonInfoSwitch::initialize(){
       m_isolation     = has_exact("isolation");
       m_PID           = has_exact("PID");
       m_purity        = has_exact("purity");
       m_effSF         = has_exact("effSF");
       m_trigger       = has_exact("trigger");
       m_isoCones      = get_working_points("isoCone");
     }
   
     void ClusterInfoSwitch::initialize(){
     }
   
     void JetInfoSwitch::initialize(){
       std::string tmpConfigStr; // temporary config string used to extract multiple values
   
       m_trigger       = has_exact("trigger");
       m_substructure  = has_exact("substructure");
       m_ntrimsubjets  = has_exact("ntrimsubjets");
       m_bosonCount    = has_exact("bosonCount");
       m_VTags         = has_exact("VTags");
       m_rapidity      = has_exact("rapidity");
       m_clean         = has_exact("clean");
       m_cleanLight    = has_exact("cleanLight");
       m_cleanTrig     = has_exact("cleanTrig");
       m_cleanLLP      = has_exact("cleanLLP");
       m_timing        = has_exact("timing");
       m_energy        = has_exact("energy");
       m_energyLight   = has_exact("energyLight");
       m_scales        = has_exact("scales");
       m_constscaleEta = has_exact("constscaleEta");
       m_detectorEta   = has_exact("detectorEta");
       m_resolution    = has_exact("resolution");
       m_truth         = has_exact("truth");
       m_truthDetails  = has_exact("truth_details");
       m_layer         = has_exact("layer");
       m_fJvt          = has_exact("fJvt");
       m_trackPV       = has_exact("trackPV");
       m_trackAll      = has_exact("trackAll");
       m_chargedPFOPV  = has_exact("chargedPFOPV");
       m_jvt           = has_exact("JVT");
       m_NNJvt         = has_exact("NNJvt");
       m_allTrack      = has_exact("allTrack");
       m_allTrackPVSel = has_exact("allTrackPVSel");
       m_allTrackDetail= has_exact("allTrackDetail");
       m_muonCorrection= has_exact("muonCorrection");
   
       if( m_allTrackDetail ) {
         m_allTrackPVSel = m_allTrackPVSel || has_exact("allTrackDetailPVSel") ;
       }
       m_constituent       = has_exact("constituent");
       m_constituentAll    = has_exact("constituentAll");
       m_flavorTag         = has_exact("flavorTag");
       m_flavorTagHLT      = has_exact("flavorTagHLT");
       m_flavorTagTLA      = has_exact("flavorTagTLA");
       m_btag_jettrk       = has_exact("btag_jettrk");
       m_jetFitterDetails  = has_exact("jetFitterDetails");
       m_svDetails         = has_exact("svDetails");
       m_ipDetails         = has_exact("ipDetails");
   
       if(has_match("tracksInJet")){
         m_tracksInJet       = true;
         std::string input(m_configStr);
         // erase everything before the interesting string
         input.erase( 0, input.find("tracksInJet_") );
         // erase everything after the interesting string
         // only if there is something after the string
         if( input.find(" ") != std::string::npos ) {
           input.erase( input.find_first_of(" "), input.size() );
         }
         // remove tracksInJet_ to just leave the tack name
         input.erase(0,12);
   
         m_trackName = input;
       }else{
         m_tracksInJet       = false;
         m_trackName         = "";
       }
   
   
       m_trackJetNames.clear();
       if(has_match("trackJetName")){
         std::string input(m_configStr);
         // erase everything before the interesting string
         input.erase( 0, input.find("trackJetName") );
         if(input.find(" ")!=std::string::npos) input.erase( input.find(" "), std::string::npos );
         input.erase( 0, 13 );
   
         std::stringstream ss(input);
         std::string s;
         while(std::getline(ss, s, '_'))
       m_trackJetNames.push_back(s);
       }
   
   
       m_hltVtxComp          = has_exact("hltVtxComp");
       m_onlineBS            = has_exact("onlineBS");
       m_onlineBSTool        = has_exact("onlineBSTool");
   
       m_passSel             = has_exact("passSel");
       m_passOR              = has_exact("passOR");
   
       m_charge              = has_exact("charge");
       m_etaPhiMap           = has_exact("etaPhiMap");
       m_byAverageMu         = has_exact("byAverageMu");
       m_byEta               = has_exact("byEta");
       m_vsLumiBlock         = has_exact("vsLumiBlock");
       m_vsActualMu          = has_exact("vsActualMu");
       m_lumiB_runN          = has_exact("lumiB_runN");
   
       m_sfJVTName           = get_working_point("sfJVT");
       m_sffJVTName          = get_working_point("sffJVT");
   
       m_jetBTag.clear();
       m_jetBTagCts.clear();
       tmpConfigStr=std::string(m_configStr);
       while( tmpConfigStr.find("jetBTag") != std::string::npos ) { // jetBTag
         // erase everything before the interesting string
         tmpConfigStr.erase( 0, tmpConfigStr.find("jetBTag") );
         // extract interesting string
         std::size_t pos  =tmpConfigStr.find(" ");
         std::string input=tmpConfigStr.substr(0,pos);
         // remove interesting string from configStr being processed
         tmpConfigStr.erase(0,pos);
         // extracted the tagger and numbers
         std::stringstream ss(input);
         std::string s;
         uint idx=0;
         std::string tagger;
         std::string type;
         std::vector<uint> wps;
         while(std::getline(ss, s, '_')) {
       switch(idx)
         {
         case 0: // jetBTag
           break;
         case 1: // tagger
           tagger=s;
           break;
         case 2: // efficiency type
           type=s;
           break;
         case 3: // list of efficiency working points
           uint size( s.size()/2 );
           for(uint i=0;i<size;i++) {
             std::string number = s.substr(0,2);
             wps.push_back( atoi( number.c_str() ) );
             s.erase(0,2);
           }
         }
       idx++;
         }
         if(m_jetBTag.find(tagger)==m_jetBTag.end()) m_jetBTag[tagger]=std::vector<std::pair<std::string,uint>>();
         for(auto wp : wps)
       m_jetBTag[tagger].push_back(std::make_pair(type,wp));
   
         // Add the continuous tagger if this was the one that was passed
         if(type.find("Continuous")!=std::string::npos)
           m_jetBTagCts.push_back(tagger);
   
       } // jetBTag
   
       m_area          = has_exact("area");
       m_JVC           = has_exact("JVC");
     }
   
     void TruthInfoSwitch::initialize(){
       m_type          = has_exact("type");
       m_bVtx          = has_exact("bVtx");
       m_parents       = has_exact("parents");
       m_children      = has_exact("children");
       m_dressed       = has_exact("dressed");
       m_origin        = has_exact("origin");
       m_particleType  = has_exact("particleType");
       m_pdgIdOnly     = has_exact("pdgIdOnly");
     }
   
     void TrackInfoSwitch::initialize(){
       m_noMultiplicity= has_exact("noMultiplicity");
       m_kinematic     = has_exact("kinematic");
       m_fitpars       = has_exact("fitpars");
       m_numbers       = has_exact("numbers");
       m_vertex        = has_exact("vertex");
       m_useTheS       = has_exact("useTheS");
     }
   
     void TauInfoSwitch::initialize(){
       m_trigger           = has_exact("trigger");
       m_JetID             = has_exact("JetID");
       m_EleVeto           = has_exact("EleVeto");
       m_trackAll          = has_exact("trackAll");
       m_xahTauJetMatching = has_exact("xahTauJetMatching");
       m_effSF             = has_exact("effSF");
       m_trackparams       = has_exact("trackparams");
       m_trackhitcont      = has_exact("trackhitcont");
   
       // working points combinations for trigger corrections
       std::string token;
       std::string taueff_keyword = "TAUEFF_";
       std::string trig_keyword  = "TRIG_";
   
       std::istringstream ss(m_configStr);
       while ( std::getline(ss, token, ' ') ) {
         auto taueff_substr = token.find(taueff_keyword);
         auto trig_substr = token.find(trig_keyword);
         if( taueff_substr != std::string::npos ){
           m_tauEffWPs.push_back(token.substr(7));
         } else if(trig_substr != std::string::npos){
           m_trigWPs.push_back(token.substr(5));
         }
       }
   
     }
   
     void METInfoSwitch::initialize(){
       m_metClus   = has_exact("metClus");
       m_metTrk    = has_exact("metTrk");
       m_sigClus   = has_exact("sigClus")  || has_exact("all");
       m_sigTrk    = has_exact("sigTrk")   || has_exact("all");
       m_sigResolutionClus = has_exact("sigResolutionClus") || has_exact("all");
       m_sigResolutionTrk  = has_exact("sigResolutionTrk")  || has_exact("all");
       m_refEle    = has_exact("refEle")   || has_exact("all");
       m_refGamma  = has_exact("refGamma") || has_exact("all");
       m_refTau    = has_exact("refTau")   || has_exact("all");
       m_refMuons  = has_exact("refMuons") || has_exact("all");
       m_refJet    = has_exact("refJet")   || has_exact("all");
       m_refJetTrk = has_exact("refJetTrk"); // take this one *only* if requested by user explicitly
       m_softClus  = has_exact("softClus") || has_exact("all");
       m_softTrk   = has_exact("softTrk")  || has_exact("all");
       m_noExtra   = has_exact("noExtra");
       if(!m_metClus && !m_metTrk && !m_noExtra){ // to maintain backward compatibility which turned on metClus and metTrk if both were false
         m_metClus = true;
         m_metTrk  = true;
       }
     }
   
   } // close namespace HelperClasses