.. _program_listing_file_Root_MuonContainer.cxx: Program Listing for File MuonContainer.cxx ========================================== |exhale_lsh| :ref:`Return to documentation for file ` (``Root/MuonContainer.cxx``) .. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS .. code-block:: cpp #include "xAODAnaHelpers/MuonContainer.h" #include using namespace xAH; using std::vector; using std::string; MuonContainer::MuonContainer(const std::string& name, const std::string& detailStr, float units, bool mc, bool storeSystSFs) : ParticleContainer(name, detailStr, units, mc, true, storeSystSFs) { if ( m_infoSwitch.m_kinematic ) { m_charge = new std::vector (); } // trigger if ( m_infoSwitch.m_trigger ) { m_isTrigMatched = new vector (); m_isTrigMatchedToChain = new vector > (); m_listTrigChains = new vector >(); } // isolation if ( m_infoSwitch.m_isolation ) { m_isIsolated = new std::map< std::string, std::vector< int >* >(); for (auto& isol : m_infoSwitch.m_isolWPs) { if (!isol.empty()) { (*m_isIsolated)[ isol ] = new std::vector< int >; } } } if ( m_infoSwitch.m_isolationKinematics ) { m_topoetcone20 = new vector (); m_neflowisol20 = new vector (); m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt500 = new vector (); m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000 = new vector (); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500 = new vector (); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000 = new vector (); } if (m_infoSwitch.m_closeByCorr) { m_topoetcone20_CloseByCorr = new vector (); m_neflowisol20_CloseByCorr = new vector (); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr = new vector (); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr = new vector (); //not available for LRT } // quality if ( m_infoSwitch.m_quality ) { m_quality = new std::map< std::string, std::vector< int >* >(); for (auto& quality : m_infoSwitch.m_recoWPs) { if (!quality.empty()) { (*m_quality)[ quality ] = new std::vector< int >; } } } // scale factors w/ sys // per object if ( m_infoSwitch.m_effSF && m_mc ) { m_RecoEff_SF = new std::map< std::string, std::vector< std::vector< float > >* >(); m_IsoEff_SF = new std::map< std::string, std::vector< std::vector< float > >* >(); m_TrigEff_SF = new std::map< std::string, std::vector< std::vector< float > >* >(); m_TrigMCEff = new std::map< std::string, std::vector< std::vector< float > >* >(); for (auto& reco : m_infoSwitch.m_recoWPs) { (*m_RecoEff_SF)[ reco ] = new std::vector< std::vector< float > >; for (auto& trig : m_infoSwitch.m_trigWPs) { (*m_TrigEff_SF)[ trig+reco ] = new std::vector< std::vector< float > >; (*m_TrigMCEff)[ trig+reco ] = new std::vector< std::vector< float > >; } } for (auto& isol : m_infoSwitch.m_isolWPs) { (*m_IsoEff_SF)[ isol ] = new std::vector< std::vector< float > >; } m_TTVAEff_SF = new vector< vector< float > > (); } // track parameters if ( m_infoSwitch.m_trackparams ) { m_trkd0 = new vector (); m_trkd0sig = new vector (); m_trkz0 = new vector (); m_trkz0sintheta = new vector (); m_trkphi0 = new vector (); m_trktheta = new vector (); m_trkcharge = new vector (); m_trkqOverP = new vector (); } // track hit content if ( m_infoSwitch.m_trackhitcont ) { m_trknSiHits = new vector (); m_trknPixHits = new vector (); m_trknPixHoles = new vector (); m_trknSCTHits = new vector (); m_trknSCTHoles = new vector (); m_trknTRTHits = new vector (); m_trknTRTHoles = new vector (); m_trknBLayerHits = new vector (); m_trknInnermostPixLayHits = new vector (); // not available in DC14 m_trkPixdEdX = new vector (); // not available in DC14 } if ( m_infoSwitch.m_energyLoss ) { m_EnergyLoss = new vector (); m_EnergyLossSigma = new vector (); m_energyLossType = new vector (); m_MeasEnergyLoss = new vector (); m_MeasEnergyLossSigma = new vector (); m_ParamEnergyLoss = new vector (); m_ParamEnergyLossSigmaMinus = new vector (); m_ParamEnergyLossSigmaPlus = new vector (); } if ( m_infoSwitch.m_promptlepton ) { m_PromptLeptonInput_DL1mu = new std::vector (); m_PromptLeptonInput_DRlj = new std::vector (); m_PromptLeptonInput_LepJetPtFrac = new std::vector (); m_PromptLeptonInput_PtFrac = new std::vector (); m_PromptLeptonInput_PtRel = new std::vector (); m_PromptLeptonInput_TrackJetNTrack = new std::vector (); m_PromptLeptonInput_ip2 = new std::vector (); m_PromptLeptonInput_ip3 = new std::vector (); m_PromptLeptonInput_rnnip = new std::vector (); m_PromptLeptonInput_sv1_jf_ntrkv = new std::vector (); m_PromptLeptonIso = new std::vector (); m_PromptLeptonVeto = new std::vector (); } if ( m_infoSwitch.m_doLRT ){ m_isLRT = new std::vector(); m_passIDcuts = new std::vector(); } if ( m_infoSwitch.m_passSel ) { m_passSel = new std::vector(); } if ( m_infoSwitch.m_passOR ) { m_passOR = new std::vector(); } } MuonContainer::~MuonContainer() { if ( m_infoSwitch.m_kinematic ) { delete m_charge; } // trigger if ( m_infoSwitch.m_trigger ) { delete m_isTrigMatched ; delete m_isTrigMatchedToChain ; delete m_listTrigChains ; } // isolation if ( m_infoSwitch.m_isolation ) { for (auto& isol : m_infoSwitch.m_isolWPs) { if (!isol.empty()) { delete (*m_isIsolated)[ isol ]; } } delete m_isIsolated; } if ( m_infoSwitch.m_isolationKinematics ) { delete m_topoetcone20 ; delete m_neflowisol20 ; delete m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt500 ; delete m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000; delete m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500 ; delete m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000; } if (m_infoSwitch.m_closeByCorr) { delete m_topoetcone20_CloseByCorr ; delete m_neflowisol20_CloseByCorr ; delete m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr ; delete m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr ; //not available for LRT } // quality if ( m_infoSwitch.m_quality ) { for (auto& quality : m_infoSwitch.m_recoWPs) { if (!quality.empty()) { delete (*m_quality)[ quality ]; } } delete m_quality; } // scale factors w/ sys // per object if ( m_infoSwitch.m_effSF && m_mc ) { for (auto& reco : m_infoSwitch.m_recoWPs) { delete (*m_RecoEff_SF)[ reco ]; for (auto& trig : m_infoSwitch.m_trigWPs) { delete (*m_TrigEff_SF)[ trig+reco ]; delete (*m_TrigMCEff)[ trig+reco ]; } } for (auto& isol : m_infoSwitch.m_isolWPs) { delete (*m_IsoEff_SF)[ isol ]; } delete m_RecoEff_SF ; delete m_IsoEff_SF ; delete m_TrigEff_SF ; delete m_TrigMCEff ; delete m_TTVAEff_SF ; } // track parameters if ( m_infoSwitch.m_trackparams ) { delete m_trkd0 ; delete m_trkd0sig ; delete m_trkz0 ; delete m_trkz0sintheta ; delete m_trkphi0 ; delete m_trktheta ; delete m_trkcharge ; delete m_trkqOverP ; } // track hit content if ( m_infoSwitch.m_trackhitcont ) { delete m_trknSiHits ; delete m_trknPixHits ; delete m_trknPixHoles ; delete m_trknSCTHits ; delete m_trknSCTHoles ; delete m_trknTRTHits ; delete m_trknTRTHoles ; delete m_trknBLayerHits ; delete m_trknInnermostPixLayHits ; // not available in DC14 delete m_trkPixdEdX ; // not available in DC14 } if ( m_infoSwitch.m_energyLoss ) { delete m_EnergyLoss ; delete m_EnergyLossSigma ; delete m_energyLossType ; delete m_MeasEnergyLoss ; delete m_MeasEnergyLossSigma ; delete m_ParamEnergyLoss ; delete m_ParamEnergyLossSigmaMinus ; delete m_ParamEnergyLossSigmaPlus ; } if ( m_infoSwitch.m_promptlepton ) { delete m_PromptLeptonInput_DL1mu ; delete m_PromptLeptonInput_DRlj ; delete m_PromptLeptonInput_LepJetPtFrac ; delete m_PromptLeptonInput_PtFrac ; delete m_PromptLeptonInput_PtRel ; delete m_PromptLeptonInput_TrackJetNTrack ; delete m_PromptLeptonInput_ip2 ; delete m_PromptLeptonInput_ip3 ; delete m_PromptLeptonInput_rnnip ; delete m_PromptLeptonInput_sv1_jf_ntrkv ; delete m_PromptLeptonIso ; delete m_PromptLeptonVeto ; } if ( m_infoSwitch.m_doLRT ){ delete m_isLRT; delete m_passIDcuts; } if ( m_infoSwitch.m_passSel ) { delete m_passSel; } if ( m_infoSwitch.m_passOR ) { delete m_passOR; } } void MuonContainer::setTree(TTree *tree) { // // Connect branches ParticleContainer::setTree(tree); if ( m_infoSwitch.m_kinematic ) { connectBranch(tree, "charge", &m_charge); } if ( m_infoSwitch.m_trigger ){ connectBranch (tree, "isTrigMatched", &m_isTrigMatched); connectBranch >(tree, "isTrigMatchedToChain", &m_isTrigMatchedToChain ); connectBranch >(tree, "listTrigChains", &m_listTrigChains ); } if ( m_infoSwitch.m_isolation ) { for (auto& isol : m_infoSwitch.m_isolWPs) { if (!isol.empty()) { tree->SetBranchStatus ( (m_name + "_isIsolated_" + isol).c_str() , 1); tree->SetBranchAddress( (m_name + "_isIsolated_" + isol).c_str() , & (*m_isIsolated)[ isol ] ); } } } if ( m_infoSwitch.m_isolationKinematics ) { connectBranch(tree,"topoetcone20", &m_topoetcone20); connectBranch(tree,"neflowisol20", &m_neflowisol20); connectBranch(tree,"ptcone20_Nonprompt_All_MaxWeightTTVA_pt500", &m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt500); connectBranch(tree,"ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000", &m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000); connectBranch(tree,"ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500", &m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500); connectBranch(tree,"ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000", &m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000); } if (m_infoSwitch.m_closeByCorr) { connectBranch(tree,"topoetcone20_CloseByCorr", &m_topoetcone20_CloseByCorr ); connectBranch(tree,"neflowisol20_CloseByCorr", &m_neflowisol20_CloseByCorr ); connectBranch(tree,"ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr", &m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr ); connectBranch(tree,"ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr", &m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr); //not available for LRT } if ( m_infoSwitch.m_effSF && m_mc ) { for (auto& reco : m_infoSwitch.m_recoWPs) { tree->SetBranchStatus ( (m_name + "_RecoEff_SF_Reco" + reco).c_str() , 1); tree->SetBranchAddress( (m_name + "_RecoEff_SF_Reco" + reco).c_str() , & (*m_RecoEff_SF)[ reco ] ); for (auto& trig : m_infoSwitch.m_trigWPs) { tree->SetBranchStatus ( (m_name + "_TrigEff_SF_" + trig + "_Reco" + reco).c_str() , 1 ); tree->SetBranchAddress( (m_name + "_TrigEff_SF_" + trig + "_Reco" + reco).c_str() , & (*m_TrigEff_SF)[ trig+reco ] ); tree->SetBranchStatus ( (m_name + "_TrigMCEff_" + trig + "_Reco" + reco).c_str() , 1 ); tree->SetBranchAddress( (m_name + "_TrigMCEff_" + trig + "_Reco" + reco).c_str() , & (*m_TrigMCEff) [ trig+reco ] ); } } for (auto& isol : m_infoSwitch.m_isolWPs) { if (!isol.empty()) { tree->SetBranchStatus ( (m_name + "_IsoEff_SF_Iso" + isol).c_str() , 1); tree->SetBranchAddress( (m_name + "_IsoEff_SF_Iso" + isol).c_str() , & (*m_IsoEff_SF)[ isol ] ); } } connectBranch >(tree,"TTVAEff_SF", &m_TTVAEff_SF); } if ( m_infoSwitch.m_quality ) { for (auto& quality : m_infoSwitch.m_recoWPs) { if (!quality.empty()) { tree->SetBranchStatus ( (m_name + "_is" + quality).c_str() , 1); tree->SetBranchAddress( (m_name + "_is" + quality).c_str() , & (*m_quality)[ quality ] ); } } } if ( m_infoSwitch.m_trackparams ) { connectBranch(tree,"trkd0", &m_trkd0); connectBranch(tree,"trkd0sig", &m_trkd0sig); connectBranch(tree,"trkz0", &m_trkz0); connectBranch(tree,"trkz0sintheta", &m_trkz0sintheta); connectBranch(tree,"trkphi0", &m_trkphi0); connectBranch(tree,"trktheta", &m_trktheta); connectBranch(tree,"trkcharge", &m_trkcharge); connectBranch(tree,"trkqOverP", &m_trkqOverP); } if ( m_infoSwitch.m_trackhitcont ) { connectBranch(tree,"trknSiHits", &m_trknSiHits); connectBranch(tree,"trknPixHits", &m_trknPixHits); connectBranch(tree,"trknPixHoles", &m_trknPixHoles); connectBranch(tree,"trknSCTHits", &m_trknSCTHits); connectBranch(tree,"trknSCTHoles", &m_trknSCTHoles); connectBranch(tree,"trknTRTHits", &m_trknTRTHits); connectBranch(tree,"trknTRTHoles", &m_trknTRTHoles); connectBranch(tree,"trknBLayerHits",&m_trknBLayerHits); connectBranch(tree,"trknInnermostPixLayHits", &m_trknInnermostPixLayHits); connectBranch(tree,"trkPixdEdX", &m_trkPixdEdX); } if(m_infoSwitch.m_energyLoss ) { connectBranch(tree,"EnergyLoss" , &m_EnergyLoss ); connectBranch(tree,"EnergyLossSigma" , &m_EnergyLossSigma ); connectBranch(tree,"energyLossType" , &m_energyLossType ); connectBranch(tree,"MeasEnergyLoss" , &m_MeasEnergyLoss ); connectBranch(tree,"MeasEnergyLossSigma" , &m_MeasEnergyLossSigma ); connectBranch(tree,"ParamEnergyLoss" , &m_ParamEnergyLoss ); connectBranch(tree,"ParamEnergyLossSigmaMinus" , &m_ParamEnergyLossSigmaMinus); connectBranch(tree,"ParamEnergyLossSigmaPlus" , &m_ParamEnergyLossSigmaPlus ); } if ( m_infoSwitch.m_promptlepton ) { connectBranch(tree, "PromptLeptonInput_DL1mu", &m_PromptLeptonInput_DL1mu); connectBranch(tree, "PromptLeptonInput_DRlj", &m_PromptLeptonInput_DRlj); connectBranch(tree, "PromptLeptonInput_LepJetPtFrac", &m_PromptLeptonInput_LepJetPtFrac); connectBranch(tree, "PromptLeptonInput_PtFrac", &m_PromptLeptonInput_PtFrac); connectBranch(tree, "PromptLeptonInput_PtRel", &m_PromptLeptonInput_PtRel); connectBranch (tree, "PromptLeptonInput_TrackJetNTrack", &m_PromptLeptonInput_TrackJetNTrack); connectBranch(tree, "PromptLeptonInput_ip2", &m_PromptLeptonInput_ip2); connectBranch(tree, "PromptLeptonInput_ip3", &m_PromptLeptonInput_ip3); connectBranch(tree, "PromptLeptonInput_rnnip", &m_PromptLeptonInput_rnnip); connectBranch (tree, "PromptLeptonInput_sv1_jf_ntrkv", &m_PromptLeptonInput_sv1_jf_ntrkv); connectBranch(tree, "PromptLeptonIso", &m_PromptLeptonIso); connectBranch(tree, "PromptLeptonVeto", &m_PromptLeptonVeto); } if ( m_infoSwitch.m_doLRT ){ connectBranch(tree,"isLRT",&m_isLRT); connectBranch(tree,"passIDcuts",&m_passIDcuts); } if(m_infoSwitch.m_passSel) connectBranch(tree,"passSel",&m_passSel); if(m_infoSwitch.m_passOR) connectBranch(tree,"passOR",&m_passOR); } void MuonContainer::updateParticle(uint idx, Muon& muon) { ParticleContainer::updateParticle(idx,muon); if ( m_infoSwitch.m_kinematic ) { muon.charge = m_charge->at(idx); } // trigger if ( m_infoSwitch.m_trigger ) { muon.isTrigMatched = m_isTrigMatched ->at(idx); muon.isTrigMatchedToChain = m_isTrigMatchedToChain ->at(idx); muon.listTrigChains = m_listTrigChains ->at(idx); } // isolation if ( m_infoSwitch.m_isolation ) { for (auto& isol : m_infoSwitch.m_isolWPs) { if (!isol.empty()) { muon.isIsolated[isol] = (*m_isIsolated)[ isol ]->at(idx); } } } if ( m_infoSwitch.m_isolationKinematics ) { muon.topoetcone20 = m_topoetcone20 ->at(idx); muon.neflowisol20 = m_neflowisol20 ->at(idx); muon.ptcone20_Nonprompt_All_MaxWeightTTVA_pt500 = m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt500 -> at(idx); muon.ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000 = m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000 -> at(idx); muon.ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500 = m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500 -> at(idx); muon.ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000 = m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000 -> at(idx); } if (m_infoSwitch.m_closeByCorr) { muon.topoetcone20_CloseByCorr = m_topoetcone20_CloseByCorr ->at(idx); muon.neflowisol20_CloseByCorr = m_neflowisol20_CloseByCorr ->at(idx); muon.ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr = m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr ->at(idx); muon.ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr = m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr ->at(idx); //not available for LRT } // quality if ( m_infoSwitch.m_quality ) { for (auto& quality : m_infoSwitch.m_recoWPs) { if (!quality.empty()) { muon.quality[quality] = (*m_quality)[ quality ]->at(idx); } } } // scale factors w/ sys // per object if ( m_infoSwitch.m_effSF && m_mc ) { for (auto& reco : m_infoSwitch.m_recoWPs) { muon.RecoEff_SF[ reco ] = (*m_RecoEff_SF)[ reco ]->at(idx); for (auto& trig : m_infoSwitch.m_trigWPs) { muon.TrigEff_SF[ trig+reco ] = (*m_TrigEff_SF)[ trig+reco ]->at(idx); muon.TrigMCEff [ trig+reco ] = (*m_TrigMCEff )[ trig+reco ]->at(idx); } } for (auto& isol : m_infoSwitch.m_isolWPs) { muon.IsoEff_SF[ isol ] = (*m_IsoEff_SF)[ isol ]->at(idx); } muon.TTVAEff_SF = m_TTVAEff_SF -> at(idx); } // track parameters if ( m_infoSwitch.m_trackparams ) { muon.trkd0 = m_trkd0 ->at(idx); muon.trkd0sig = m_trkd0sig ->at(idx); muon.trkz0 = m_trkz0 ->at(idx); muon.trkz0sintheta = m_trkz0sintheta ->at(idx); muon.trkphi0 = m_trkphi0 ->at(idx); muon.trktheta = m_trktheta ->at(idx); muon.trkcharge = m_trkcharge ->at(idx); muon.trkqOverP = m_trkqOverP ->at(idx); } // track hit content if ( m_infoSwitch.m_trackhitcont ) { muon.trknSiHits = m_trknSiHits ->at(idx); muon.trknPixHits = m_trknPixHits ->at(idx); muon.trknPixHoles = m_trknPixHoles ->at(idx); muon.trknSCTHits = m_trknSCTHits ->at(idx); muon.trknSCTHoles = m_trknSCTHoles ->at(idx); muon.trknTRTHits = m_trknTRTHits ->at(idx); muon.trknTRTHoles = m_trknTRTHoles ->at(idx); muon.trknBLayerHits = m_trknBLayerHits ->at(idx); muon.trknInnermostPixLayHits = m_trknInnermostPixLayHits ->at(idx); // not available in DC14 muon.trkPixdEdX = m_trkPixdEdX ->at(idx); // not available in DC14 } if ( m_infoSwitch.m_energyLoss ) { muon.EnergyLoss = m_EnergyLoss ->at(idx); muon.EnergyLossSigma = m_EnergyLossSigma ->at(idx); muon.energyLossType = m_energyLossType ->at(idx); muon.MeasEnergyLoss = m_MeasEnergyLoss ->at(idx); muon.MeasEnergyLossSigma = m_MeasEnergyLossSigma ->at(idx); muon.ParamEnergyLoss = m_ParamEnergyLoss ->at(idx); muon.ParamEnergyLossSigmaMinus = m_ParamEnergyLossSigmaMinus ->at(idx); muon.ParamEnergyLossSigmaPlus = m_ParamEnergyLossSigmaPlus ->at(idx); } // prompt lepton if ( m_infoSwitch.m_promptlepton ) { muon.PromptLeptonInput_DL1mu = m_PromptLeptonInput_DL1mu ->at(idx); muon.PromptLeptonInput_DRlj = m_PromptLeptonInput_DRlj ->at(idx); muon.PromptLeptonInput_LepJetPtFrac = m_PromptLeptonInput_LepJetPtFrac ->at(idx); muon.PromptLeptonInput_PtFrac = m_PromptLeptonInput_PtFrac ->at(idx); muon.PromptLeptonInput_PtRel = m_PromptLeptonInput_PtRel ->at(idx); muon.PromptLeptonInput_TrackJetNTrack = m_PromptLeptonInput_TrackJetNTrack ->at(idx); muon.PromptLeptonInput_ip2 = m_PromptLeptonInput_ip2 ->at(idx); muon.PromptLeptonInput_ip3 = m_PromptLeptonInput_ip3 ->at(idx); muon.PromptLeptonInput_rnnip = m_PromptLeptonInput_rnnip ->at(idx); muon.PromptLeptonInput_sv1_jf_ntrkv = m_PromptLeptonInput_sv1_jf_ntrkv ->at(idx); muon.PromptLeptonIso = m_PromptLeptonIso ->at(idx); muon.PromptLeptonVeto = m_PromptLeptonVeto ->at(idx); } if ( m_infoSwitch.m_doLRT ){ muon.isLRT = m_isLRT->at(idx); muon.passIDcuts = m_passIDcuts->at(idx); } // passSel if(m_infoSwitch.m_passSel) muon.passSel = m_passSel->at(idx); // passOR if(m_infoSwitch.m_passOR) muon.passOR = m_passOR->at(idx); } void MuonContainer::setBranches(TTree *tree) { ParticleContainer::setBranches(tree); if ( m_infoSwitch.m_kinematic ) { setBranch(tree, "charge", m_charge); } if ( m_infoSwitch.m_trigger ){ // this is true if there's a match for at least one trigger chain setBranch(tree,"isTrigMatched", m_isTrigMatched); // a vector of trigger match decision for each muon trigger chain setBranch >(tree,"isTrigMatchedToChain", m_isTrigMatchedToChain ); // a vector of strings for each muon trigger chain - 1:1 correspondence w/ vector above setBranch >(tree, "listTrigChains", m_listTrigChains ); } if ( m_infoSwitch.m_isolation ) { for (auto& isol : m_infoSwitch.m_isolWPs) { if (!isol.empty()) { setBranch(tree, "isIsolated_" + isol, (*m_isIsolated)[isol]); } } } if ( m_infoSwitch.m_isolationKinematics ) { setBranch(tree,"topoetcone20", m_topoetcone20); setBranch(tree,"neflowisol20", m_neflowisol20); setBranch(tree,"ptcone20_Nonprompt_All_MaxWeightTTVA_pt500", m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt500); setBranch(tree,"ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000", m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000); setBranch(tree,"ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500", m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500); setBranch(tree,"ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000", m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000); } if (m_infoSwitch.m_closeByCorr) { setBranch(tree,"topoetcone20_CloseByCorr", m_topoetcone20_CloseByCorr ); setBranch(tree,"neflowisol20_CloseByCorr", m_neflowisol20_CloseByCorr ); setBranch(tree,"ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr", m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr ); setBranch(tree,"ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr", m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr ); //not available for LRT } if ( m_infoSwitch.m_effSF && m_mc ) { for (auto& reco : m_infoSwitch.m_recoWPs) { tree->Branch( (m_name + "_RecoEff_SF_Reco" + reco).c_str() , (*m_RecoEff_SF)[ reco ] ); for (auto& trig : m_infoSwitch.m_trigWPs) { tree->Branch( (m_name + "_TrigEff_SF_" + trig + "_Reco" + reco).c_str() , (*m_TrigEff_SF)[ trig+reco ] ); tree->Branch( (m_name + "_TrigMCEff_" + trig + "_Reco" + reco).c_str() , (*m_TrigMCEff)[ trig+reco ] ); } } for (auto& isol : m_infoSwitch.m_isolWPs) { tree->Branch( (m_name + "_IsoEff_SF_Iso" + isol).c_str() , (*m_IsoEff_SF)[ isol ] ); } setBranch >(tree,"TTVAEff_SF", m_TTVAEff_SF); } if ( m_infoSwitch.m_quality ) { for (auto& quality : m_infoSwitch.m_recoWPs) { if (!quality.empty()) { setBranch(tree, "is" + quality, (*m_quality)[quality]); } } } if ( m_infoSwitch.m_trackparams ) { setBranch(tree,"trkd0", m_trkd0); setBranch(tree,"trkd0sig", m_trkd0sig); setBranch(tree,"trkz0", m_trkz0); setBranch(tree,"trkz0sintheta", m_trkz0sintheta); setBranch(tree,"trkphi0", m_trkphi0); setBranch(tree,"trktheta", m_trktheta); setBranch(tree,"trkcharge", m_trkcharge); setBranch(tree,"trkqOverP", m_trkqOverP); } if ( m_infoSwitch.m_trackhitcont ) { setBranch(tree,"trknSiHits", m_trknSiHits); setBranch(tree,"trknPixHits", m_trknPixHits); setBranch(tree,"trknPixHoles", m_trknPixHoles); setBranch(tree,"trknSCTHits", m_trknSCTHits); setBranch(tree,"trknSCTHoles", m_trknSCTHoles); setBranch(tree,"trknTRTHits", m_trknTRTHits); setBranch(tree,"trknTRTHoles", m_trknTRTHoles); setBranch(tree,"trknBLayerHits",m_trknBLayerHits); setBranch(tree,"trknInnermostPixLayHits", m_trknInnermostPixLayHits); setBranch(tree,"trkPixdEdX", m_trkPixdEdX); } if( m_infoSwitch.m_energyLoss ) { setBranch(tree,"EnergyLoss" , m_EnergyLoss ); setBranch(tree,"EnergyLossSigma" , m_EnergyLossSigma ); setBranch(tree,"energyLossType" , m_energyLossType ); setBranch(tree,"MeasEnergyLoss" , m_MeasEnergyLoss ); setBranch(tree,"MeasEnergyLossSigma" , m_MeasEnergyLossSigma ); setBranch(tree,"ParamEnergyLoss" , m_ParamEnergyLoss ); setBranch(tree,"ParamEnergyLossSigmaMinus" , m_ParamEnergyLossSigmaMinus); setBranch(tree,"ParamEnergyLossSigmaPlus" , m_ParamEnergyLossSigmaPlus ); } if ( m_infoSwitch.m_promptlepton ) { setBranch(tree, "PromptLeptonInput_DL1mu", m_PromptLeptonInput_DL1mu); setBranch(tree, "PromptLeptonInput_DRlj", m_PromptLeptonInput_DRlj); setBranch(tree, "PromptLeptonInput_LepJetPtFrac", m_PromptLeptonInput_LepJetPtFrac); setBranch(tree, "PromptLeptonInput_PtFrac", m_PromptLeptonInput_PtFrac); setBranch(tree, "PromptLeptonInput_PtRel", m_PromptLeptonInput_PtRel); setBranch (tree, "PromptLeptonInput_TrackJetNTrack", m_PromptLeptonInput_TrackJetNTrack); setBranch(tree, "PromptLeptonInput_ip2", m_PromptLeptonInput_ip2); setBranch(tree, "PromptLeptonInput_ip3", m_PromptLeptonInput_ip3); setBranch(tree, "PromptLeptonInput_rnnip", m_PromptLeptonInput_rnnip); setBranch (tree, "PromptLeptonInput_sv1_jf_ntrkv", m_PromptLeptonInput_sv1_jf_ntrkv); setBranch(tree, "PromptLeptonIso", m_PromptLeptonIso); setBranch(tree, "PromptLeptonVeto", m_PromptLeptonVeto); } if ( m_infoSwitch.m_doLRT ){ setBranch(tree,"isLRT",m_isLRT); setBranch(tree,"passIDcuts",m_passIDcuts); } if ( m_infoSwitch.m_passSel ) { setBranch(tree,"passSel",m_passSel); } if ( m_infoSwitch.m_passOR ) { setBranch(tree,"passOR",m_passOR); } return; } void MuonContainer::clear() { ParticleContainer::clear(); if ( m_infoSwitch.m_kinematic ) { m_charge->clear(); } if ( m_infoSwitch.m_trigger ) { m_isTrigMatched->clear(); m_isTrigMatchedToChain->clear(); m_listTrigChains->clear(); } if ( m_infoSwitch.m_isolation ) { for (auto& isol : m_infoSwitch.m_isolWPs) { (*m_isIsolated)[ isol ]->clear(); } } if ( m_infoSwitch.m_isolationKinematics ) { m_topoetcone20->clear(); m_neflowisol20->clear(); m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt500->clear(); m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000->clear(); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500->clear(); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000->clear(); } if (m_infoSwitch.m_closeByCorr) { m_topoetcone20_CloseByCorr ->clear(); m_neflowisol20_CloseByCorr ->clear(); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr ->clear(); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr->clear(); //not available for LRT } if ( m_infoSwitch.m_quality ) { for (auto& quality : m_infoSwitch.m_recoWPs) { (*m_quality)[ quality ]->clear(); } } if ( m_infoSwitch.m_trackparams ) { m_trkd0->clear(); m_trkd0sig->clear(); m_trkz0->clear(); m_trkz0sintheta->clear(); m_trkphi0->clear(); m_trktheta->clear(); m_trkcharge->clear(); m_trkqOverP->clear(); } if ( m_infoSwitch.m_trackhitcont ) { m_trknSiHits->clear(); m_trknPixHits->clear(); m_trknPixHoles->clear(); m_trknSCTHits->clear(); m_trknSCTHoles->clear(); m_trknTRTHits->clear(); m_trknTRTHoles->clear(); m_trknBLayerHits->clear(); m_trknInnermostPixLayHits->clear(); m_trkPixdEdX->clear(); } if ( m_infoSwitch.m_promptlepton ) { m_PromptLeptonInput_DL1mu -> clear(); m_PromptLeptonInput_DRlj -> clear(); m_PromptLeptonInput_LepJetPtFrac -> clear(); m_PromptLeptonInput_PtFrac -> clear(); m_PromptLeptonInput_PtRel -> clear(); m_PromptLeptonInput_TrackJetNTrack -> clear(); m_PromptLeptonInput_ip2 -> clear(); m_PromptLeptonInput_ip3 -> clear(); m_PromptLeptonInput_rnnip -> clear(); m_PromptLeptonInput_sv1_jf_ntrkv -> clear(); m_PromptLeptonIso -> clear(); m_PromptLeptonVeto -> clear(); } if ( m_infoSwitch.m_effSF && m_mc ) { for (auto& reco : m_infoSwitch.m_recoWPs) { (*m_RecoEff_SF)[ reco ]->clear(); for (auto& trig : m_infoSwitch.m_trigWPs) { (*m_TrigEff_SF)[ trig+reco ]->clear(); (*m_TrigMCEff)[ trig+reco ]->clear(); } } for (auto& isol : m_infoSwitch.m_isolWPs) { (*m_IsoEff_SF)[ isol ]->clear(); } m_TTVAEff_SF->clear(); } if ( m_infoSwitch.m_energyLoss ) { m_EnergyLoss->clear(); m_EnergyLossSigma->clear(); m_energyLossType->clear(); m_MeasEnergyLoss->clear(); m_MeasEnergyLossSigma->clear(); m_ParamEnergyLoss->clear(); m_ParamEnergyLossSigmaMinus->clear(); m_ParamEnergyLossSigmaPlus->clear(); } if ( m_infoSwitch.m_doLRT ){ m_isLRT->clear(); m_passIDcuts->clear(); } if(m_infoSwitch.m_passSel){ m_passSel->clear(); } if(m_infoSwitch.m_passOR){ m_passOR->clear(); } } void MuonContainer::FillMuon( const xAOD::Muon* muon, const xAOD::Vertex* primaryVertex ){ return FillMuon(static_cast(muon), primaryVertex); } void MuonContainer::FillMuon( const xAOD::IParticle* particle, const xAOD::Vertex* primaryVertex ) { ParticleContainer::FillParticle(particle); const xAOD::Muon* muon=dynamic_cast(particle); if ( m_infoSwitch.m_kinematic ) { m_charge->push_back( muon->charge() ); } if ( m_infoSwitch.m_trigger ) { // retrieve map w/ // static SG::AuxElement::Accessor< std::map > isTrigMatchedMapMuAcc("isTrigMatchedMapMu"); std::vector matches; std::vector trigChains; if ( isTrigMatchedMapMuAcc.isAvailable( *muon ) ) { // loop over map and fill branches // for ( auto const &it : (isTrigMatchedMapMuAcc( *muon )) ) { matches.push_back( static_cast(it.second) ); trigChains.push_back( static_cast(it.first) ); } } else { matches.push_back( -1 ); trigChains.push_back("NONE"); } m_isTrigMatchedToChain->push_back(matches); m_listTrigChains->push_back(trigChains); // if at least one match among the chains is found, say this muon is trigger matched if ( std::find(matches.begin(), matches.end(), 1) != matches.end() ) { m_isTrigMatched->push_back(1); } else { m_isTrigMatched->push_back(0); } } if ( m_infoSwitch.m_isolation ) { static std::map< std::string, SG::AuxElement::Accessor > accIsol; for (auto& isol : m_infoSwitch.m_isolWPs) { if (!isol.empty()) { std::string isolWP = "isIsolated_" + isol; accIsol.insert( std::pair > ( isol , SG::AuxElement::Accessor( isolWP ) ) ); safeFill( muon, accIsol.at( isol ), m_isIsolated->at( isol ), -1 ); } } } if ( m_infoSwitch.m_isolationKinematics ) { m_topoetcone20->push_back( muon->isolation( xAOD::Iso::topoetcone20 )/m_units ); m_neflowisol20->push_back( muon->isolation( xAOD::Iso::neflowisol20 )/m_units ); m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt500 ->push_back( muon->isolation( xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt500 ) /m_units ); m_ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000->push_back( muon->isolation( xAOD::Iso::ptcone20_Nonprompt_All_MaxWeightTTVA_pt1000 )/m_units ); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500 ->push_back( muon->isolation( xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500 ) /m_units ); m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000->push_back( muon->isolation( xAOD::Iso::ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000 )/m_units ); } if (m_infoSwitch.m_closeByCorr) { SG::AuxElement::Accessor acc_topoetcone20_CloseByCorr ("topoetcone20_CloseByCorr"); SG::AuxElement::Accessor acc_neflowisol20_CloseByCorr ("neflowisol20_CloseByCorr"); SG::AuxElement::Accessor acc_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr ("ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr"); SG::AuxElement::Accessor acc_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr ("ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr"); safeFill(muon, acc_topoetcone20_CloseByCorr, m_topoetcone20_CloseByCorr, -1, m_units); safeFill(muon, acc_neflowisol20_CloseByCorr, m_neflowisol20_CloseByCorr, -1, m_units); safeFill(muon, acc_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr, m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt500_CloseByCorr, -1, m_units); if (m_infoSwitch.m_doLRT) m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr ->push_back(-1.); else safeFill(muon, acc_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr, m_ptvarcone30_Nonprompt_All_MaxWeightTTVA_pt1000_CloseByCorr, -1, m_units); } if ( m_infoSwitch.m_quality ) { static std::map< std::string, SG::AuxElement::Accessor > accQuality; for (auto& quality : m_infoSwitch.m_recoWPs) { if (!quality.empty()) { accQuality.insert( std::pair > ( quality , SG::AuxElement::Accessor( "is" + quality + "Q" ) ) ); safeFill( muon, accQuality.at( quality ), m_quality->at( quality ), -1 ); } } } const xAOD::TrackParticle* trk = muon->primaryTrackParticle(); if ( m_infoSwitch.m_trackparams ) { if ( trk ) { // // NB.: // All track parameters are calculated at the perigee, i.e., the point of closest approach to the origin of some r.f. (which in RunII is NOT the ATLAS detector r.f!). // The reference frame is chosen to be a system centered in the beamspot position, with z axis parallel to the beam line. // Remember that the beamspot size ( of O(10 micrometers) in the transverse plane) is << average vertex transverse position resolution ( O(60-80 micrometers) ) // The coordinates of this r.f. wrt. the ATLAS system origin are returned by means of vx(), vy(), vz() // m_trkd0->push_back( trk->d0() ); static SG::AuxElement::Accessor d0SigAcc ("d0sig"); float d0_significance = ( d0SigAcc.isAvailable( *muon ) ) ? d0SigAcc( *muon ) : -1.0; m_trkd0sig->push_back( d0_significance ); if (primaryVertex) m_trkz0->push_back( trk->z0() - ( primaryVertex->z() - trk->vz() ) ); else m_trkz0->push_back( -999.0 ); static SG::AuxElement::Accessor z0sinthetaAcc("z0sintheta"); float z0sintheta = ( z0sinthetaAcc.isAvailable( *muon ) ) ? z0sinthetaAcc( *muon ) : -999.0; m_trkz0sintheta->push_back( z0sintheta ); m_trkphi0 ->push_back( trk->phi0() ); m_trktheta ->push_back( trk->theta() ); m_trkcharge->push_back( trk->charge() ); m_trkqOverP->push_back( trk->qOverP() ); } else { m_trkd0 -> push_back( -999.0 ); m_trkd0sig -> push_back( -999.0 ); m_trkz0 -> push_back( -999.0 ); m_trkz0sintheta -> push_back( -999.0 ); m_trkphi0 -> push_back( -999.0 ); m_trktheta -> push_back( -999.0 ); m_trkcharge -> push_back( -999.0 ); m_trkqOverP -> push_back( -999.0 ); } } if ( m_infoSwitch.m_trackhitcont ) { uint8_t nPixHits(-1), nPixHoles(-1), nSCTHits(-1), nSCTHoles(-1), nTRTHits(-1), nTRTHoles(-1), nBLayerHits(-1), nInnermostPixLayHits(-1); float pixdEdX(-1.0); if ( trk ) { trk->summaryValue( nPixHits, xAOD::numberOfPixelHits ); trk->summaryValue( nPixHoles, xAOD::numberOfPixelHoles ); trk->summaryValue( nSCTHits, xAOD::numberOfSCTHits ); trk->summaryValue( nSCTHoles, xAOD::numberOfSCTHoles ); trk->summaryValue( nTRTHits, xAOD::numberOfTRTHits ); trk->summaryValue( nTRTHoles, xAOD::numberOfTRTHoles ); trk->summaryValue( nBLayerHits, xAOD::numberOfBLayerHits ); trk->summaryValue( nInnermostPixLayHits, xAOD::numberOfInnermostPixelLayerHits ); trk->summaryValue( pixdEdX, xAOD::pixeldEdx); } m_trknSiHits -> push_back( nPixHits + nSCTHits ); m_trknPixHits -> push_back( nPixHits ); m_trknPixHoles -> push_back( nPixHoles ); m_trknSCTHits -> push_back( nSCTHits ); m_trknSCTHoles -> push_back( nSCTHoles ); m_trknTRTHits -> push_back( nTRTHits ); m_trknTRTHoles -> push_back( nTRTHoles ); m_trknBLayerHits -> push_back( nBLayerHits ); m_trknInnermostPixLayHits -> push_back( nInnermostPixLayHits ); m_trkPixdEdX -> push_back( pixdEdX ); } if ( m_infoSwitch.m_promptlepton ) { SG::AuxElement::ConstAccessor acc_DL1mu ("PromptLeptonInput_DL1mu"); SG::AuxElement::ConstAccessor acc_DRlj ("PromptLeptonInput_DRlj"); SG::AuxElement::ConstAccessor acc_LepJetPtFrac ("PromptLeptonInput_LepJetPtFrac"); SG::AuxElement::ConstAccessor acc_PtFrac ("PromptLeptonInput_PtFrac"); SG::AuxElement::ConstAccessor acc_PtRel ("PromptLeptonInput_PtRel"); SG::AuxElement::ConstAccessor acc_TrackJetNTrack ("PromptLeptonInput_TrackJetNTrack"); SG::AuxElement::ConstAccessor acc_ip2 ("PromptLeptonInput_ip2"); SG::AuxElement::ConstAccessor acc_ip3 ("PromptLeptonInput_ip3"); SG::AuxElement::ConstAccessor acc_rnnip ("PromptLeptonInput_rnnip"); SG::AuxElement::ConstAccessor acc_sv1_jf_ntrkv ("PromptLeptonInput_sv1_jf_ntrkv"); SG::AuxElement::ConstAccessor acc_Iso ("PromptLeptonIso"); SG::AuxElement::ConstAccessor acc_Veto ("PromptLeptonVeto"); m_PromptLeptonInput_DL1mu ->push_back( acc_DL1mu .isAvailable(*muon) ? acc_DL1mu(*muon) : -100); m_PromptLeptonInput_DRlj ->push_back( acc_DRlj .isAvailable(*muon) ? acc_DRlj(*muon) : -100); m_PromptLeptonInput_LepJetPtFrac ->push_back( acc_LepJetPtFrac .isAvailable(*muon) ? acc_LepJetPtFrac(*muon) : -100); m_PromptLeptonInput_PtFrac ->push_back( acc_PtFrac .isAvailable(*muon) ? acc_PtFrac(*muon) : -100); m_PromptLeptonInput_PtRel ->push_back( acc_PtRel .isAvailable(*muon) ? acc_PtRel(*muon) : -100); m_PromptLeptonInput_TrackJetNTrack ->push_back( acc_TrackJetNTrack .isAvailable(*muon) ? acc_TrackJetNTrack(*muon) : -100); m_PromptLeptonInput_ip2 ->push_back( acc_ip2 .isAvailable(*muon) ? acc_ip2(*muon) : -100); m_PromptLeptonInput_ip3 ->push_back( acc_ip3 .isAvailable(*muon) ? acc_ip3(*muon) : -100); m_PromptLeptonInput_rnnip ->push_back( acc_rnnip .isAvailable(*muon) ? acc_rnnip(*muon) : -100); m_PromptLeptonInput_sv1_jf_ntrkv ->push_back( acc_sv1_jf_ntrkv .isAvailable(*muon) ? acc_sv1_jf_ntrkv(*muon) : -100); m_PromptLeptonIso ->push_back( acc_Iso .isAvailable(*muon) ? acc_Iso(*muon) : -100); m_PromptLeptonVeto ->push_back( acc_Veto .isAvailable(*muon) ? acc_Veto(*muon) : -100); } if ( m_infoSwitch.m_effSF && m_mc ) { std::vector junkSF(1,-1.0); std::vector junkEff(1,-1.0); static std::map< std::string, SG::AuxElement::Accessor< std::vector< float > > > accRecoSF; static std::map< std::string, SG::AuxElement::Accessor< std::vector< float > > > accTrigSF; static std::map< std::string, SG::AuxElement::Accessor< std::vector< float > > > accTrigEFF; for (auto& reco : m_infoSwitch.m_recoWPs) { std::string recoEffSF = "MuRecoEff_SF_syst_Reco" + reco; accRecoSF.insert( std::pair > > ( reco , SG::AuxElement::Accessor< std::vector< float > >( recoEffSF ) ) ); safeSFVecFill( muon, accRecoSF.at( reco ), m_RecoEff_SF->at( reco ), junkSF ); for (auto& trig : m_infoSwitch.m_trigWPs) { std::string trigEffSF = "MuTrigEff_SF_syst_" + trig + "_Reco" + reco; accTrigSF.insert( std::pair > > ( trig+reco , SG::AuxElement::Accessor< std::vector< float > >( trigEffSF ) ) ); safeSFVecFill( muon, accTrigSF.at( trig+reco ), m_TrigEff_SF->at( trig+reco ), junkSF ); std::string trigMCEff = "MuTrigMCEff_syst_" + trig + "_Reco" + reco; accTrigEFF.insert( std::pair > > ( trig+reco , SG::AuxElement::Accessor< std::vector< float > >( trigMCEff ) ) ); safeSFVecFill( muon, accTrigEFF.at( trig+reco ), m_TrigMCEff->at( trig+reco ), junkEff ); } } static std::map< std::string, SG::AuxElement::Accessor< std::vector< float > > > accIsoSF; for (auto& isol : m_infoSwitch.m_isolWPs) { std::string isolEffSF = "MuIsoEff_SF_syst_Iso" + isol; accIsoSF.insert( std::pair > > ( isol , SG::AuxElement::Accessor< std::vector< float > >( isolEffSF ) ) ); safeSFVecFill( muon, accIsoSF.at( isol ), m_IsoEff_SF->at( isol ), junkSF ); } static SG::AuxElement::Accessor< std::vector< float > > accTTVASF("MuTTVAEff_SF_syst_TTVA"); safeSFVecFill( muon, accTTVASF, m_TTVAEff_SF, junkSF ); } if(m_infoSwitch.m_energyLoss ) { static SG::AuxElement::Accessor< float > accMuon_EnergyLoss ("EnergyLoss"); safeFill(muon, accMuon_EnergyLoss, m_EnergyLoss, -1); static SG::AuxElement::Accessor< float > accMuon_EnergyLossSigma ("EnergyLossSigma"); safeFill(muon, accMuon_EnergyLossSigma, m_EnergyLossSigma, -1); static SG::AuxElement::Accessor< unsigned char > accMuon_energyLossType ("energyLossType"); safeFill(muon, accMuon_energyLossType, m_energyLossType, -1); static SG::AuxElement::Accessor< float > accMuon_MeasEnergyLoss ("MeasEnergyLoss"); safeFill(muon, accMuon_MeasEnergyLoss, m_MeasEnergyLoss, -1); static SG::AuxElement::Accessor< float > accMuon_MeasEnergyLossSigma ("MeasEnergyLossSigma"); safeFill(muon, accMuon_MeasEnergyLossSigma, m_MeasEnergyLossSigma, -1); static SG::AuxElement::Accessor< float > accMuon_ParamEnergyLoss ("ParamEnergyLoss"); safeFill(muon, accMuon_ParamEnergyLoss, m_ParamEnergyLoss, -1); static SG::AuxElement::Accessor< float > accMuon_ParamEnergyLossSigmaMinus ("ParamEnergyLossSigmaMinus"); safeFill(muon, accMuon_ParamEnergyLossSigmaMinus, m_ParamEnergyLossSigmaMinus, -1); static SG::AuxElement::Accessor< float > accMuon_ParamEnergyLossSigmaPlus ("ParamEnergyLossSigmaPlus"); safeFill(muon, accMuon_ParamEnergyLossSigmaPlus, m_ParamEnergyLossSigmaPlus, -1); } if ( m_infoSwitch.m_doLRT ){ static SG::AuxElement::Accessor accMuon_isLRT( "isLRT" ); safeFill(muon, accMuon_isLRT, m_isLRT, -1); static SG::AuxElement::Accessor accMuon_passIDcuts( "passIDcuts" ); safeFill(muon, accMuon_passIDcuts, m_passIDcuts, -1); } if ( m_infoSwitch.m_passSel ) { static SG::AuxElement::Accessor accMuon_passSel( "passSel" ); safeFill(muon, accMuon_passSel, m_passSel, -99); } if ( m_infoSwitch.m_passOR ) { static SG::AuxElement::Accessor accMuon_passOR( "passOR" ); safeFill(muon, accMuon_passOR, m_passOR, -99); } return; }