Adds non-prompt matching plots

looper/analysis/tracking_eff.cpp

@@ -66,6 +66,10 @@ bool is_good_sim(const SimTrack& sim_track) {
            abs(sim_track.eta())<3.0;         // inside ECAL acceptance
 };
 
+bool is_good_sim(const std::vector<SimTrack> prompt_sims, const SimTrack& sim_track) {
+    return find(prompt_sims.begin(), prompt_sims.end(), sim_track) != prompt_sims.end();
+};
+
 bool is_good_seed(const Seed& seed, float hoe_cut) {
     return seed.isECALDriven() and seed.hoe() < hoe_cut;
 }
@@ -101,7 +105,7 @@ void update_sim_els() {
     }
 }
 
-std::vector<SimTrack> get_prompt_sims() {
+std::tuple<std::vector<SimTrack>, std::vector<SimTrack>> get_prompt_sims() {
     /*
      * Returns sim tracks that pass is_good_sim as well as match well with a
      * prompt gen electron
@@ -128,7 +132,13 @@ std::vector<SimTrack> get_prompt_sims() {
             }
         }
     }
-    return prompt_sim;
+    std::vector<SimTrack> nonprompt_sim;
+    for (const auto& sim_el : sim_els) {
+        if (find(prompt_sim.begin(), prompt_sim.end(), sim_el) == prompt_sim.end()) {
+            nonprompt_sim.push_back(sim_el);
+        }
+    }
+    return make_tuple(prompt_sim, nonprompt_sim);
 }
 
 
@@ -328,29 +338,34 @@ void run(){
     }
 
     KinColl<ContainerTH1<float>> good_sim_kinems = {
-            tds.register_container<ContainerTH1<float>>("good_sim_v_pt",  THParams::lookup("pt")),
-            tds.register_container<ContainerTH1<float>>("good_sim_v_eta", THParams::lookup("eta")),
-            tds.register_container<ContainerTH1<float>>("good_sim_v_phi", THParams::lookup("phi"))};
+            tds.register_container<ContainerTH1<float>>("good_sim_v_pt",  THParams::lookup("pt_fine")),
+            tds.register_container<ContainerTH1<float>>("good_sim_v_eta", THParams::lookup("eta_fine")),
+            tds.register_container<ContainerTH1<float>>("good_sim_v_phi", THParams::lookup("phi_fine"))};
 
     KinColl<ContainerTH1<float>> gsf_kinems = {
-            tds.register_container<ContainerTH1<float>>("gsf_track_v_pt",  THParams::lookup("pt")),
-            tds.register_container<ContainerTH1<float>>("gsf_track_v_eta", THParams::lookup("eta")),
-            tds.register_container<ContainerTH1<float>>("gsf_track_v_phi", THParams::lookup("phi"))};
+            tds.register_container<ContainerTH1<float>>("gsf_track_v_pt",  THParams::lookup("pt_fine")),
+            tds.register_container<ContainerTH1<float>>("gsf_track_v_eta", THParams::lookup("eta_fine")),
+            tds.register_container<ContainerTH1<float>>("gsf_track_v_phi", THParams::lookup("phi_fine"))};
 
     KinColl<ContainerTH1<float>> seed_kinems = {
-            tds.register_container<ContainerTH1<float>>("seed_v_pt",  THParams::lookup("pt")),
-            tds.register_container<ContainerTH1<float>>("seed_v_eta", THParams::lookup("eta")),
-            tds.register_container<ContainerTH1<float>>("seed_v_phi", THParams::lookup("phi"))};
+            tds.register_container<ContainerTH1<float>>("seed_v_pt",  THParams::lookup("pt_fine")),
+            tds.register_container<ContainerTH1<float>>("seed_v_eta", THParams::lookup("eta_fine")),
+            tds.register_container<ContainerTH1<float>>("seed_v_phi", THParams::lookup("phi_fine"))};
 
     KinColl<ContainerTH1<float>> scl_kinems = {
-            tds.register_container<ContainerTH1<float>>("scl_v_pt",  THParams::lookup("pt")),
-            tds.register_container<ContainerTH1<float>>("scl_v_eta", THParams::lookup("eta")),
-            tds.register_container<ContainerTH1<float>>("scl_v_phi", THParams::lookup("phi"))};
+            tds.register_container<ContainerTH1<float>>("scl_v_pt",  THParams::lookup("pt_fine")),
+            tds.register_container<ContainerTH1<float>>("scl_v_eta", THParams::lookup("eta_fine")),
+            tds.register_container<ContainerTH1<float>>("scl_v_phi", THParams::lookup("phi_fine"))};
 
     KinColl<ContainerTH1<float>> prompt_kinems = {
-            tds.register_container<ContainerTH1<float>>("prompt_v_pt",  THParams::lookup("pt")),
-            tds.register_container<ContainerTH1<float>>("prompt_v_eta", THParams::lookup("eta")),
-            tds.register_container<ContainerTH1<float>>("prompt_v_phi", THParams::lookup("phi"))};
+            tds.register_container<ContainerTH1<float>>("prompt_v_pt",  THParams::lookup("pt_fine")),
+            tds.register_container<ContainerTH1<float>>("prompt_v_eta", THParams::lookup("eta_fine")),
+            tds.register_container<ContainerTH1<float>>("prompt_v_phi", THParams::lookup("phi_fine"))};
+
+    KinColl<ContainerTH1<float>> nonprompt_kinems = {
+            tds.register_container<ContainerTH1<float>>("nonprompt_v_pt",  THParams::lookup("pt_fine")),
+            tds.register_container<ContainerTH1<float>>("nonprompt_v_eta", THParams::lookup("eta_fine")),
+            tds.register_container<ContainerTH1<float>>("nonprompt_v_phi", THParams::lookup("phi_fine"))};
 
 
     KinColl<EfficiencyContainer<float>> seed_eff = {
@@ -378,6 +393,14 @@ void run(){
             tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_pt",  THParams::lookup("pt")),
             tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_eta", THParams::lookup("eta")),
             tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_phi", THParams::lookup("phi"))};
+    KinColl<EfficiencyContainer<float>> nonprompt_eff = {
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_phi", THParams::lookup("phi"))};
+    KinColl<EfficiencyContainer<float>> nonprompt_pur = {
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_phi", THParams::lookup("phi"))};
 
     KinColl<EfficiencyContainer<float>> tracking_eff_dR = {
             tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_pt_dR",  THParams::lookup("pt")),
@@ -395,6 +418,14 @@ void run(){
             tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_pt_dR",  THParams::lookup("pt")),
             tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_eta_dR", THParams::lookup("eta")),
             tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_phi_dR", THParams::lookup("phi"))};
+    KinColl<EfficiencyContainer<float>> nonprompt_eff_dR = {
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_pt_dR",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_eta_dR", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_phi_dR", THParams::lookup("phi"))};
+    KinColl<EfficiencyContainer<float>> nonprompt_pur_dR = {
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_pt_dR",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_eta_dR", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_phi_dR", THParams::lookup("phi"))};
 
     KinColl<EfficiencyContainer<float>> fake_rate = {
             tds.register_container<EfficiencyContainer<float>>("fake_rate_v_pt",  THParams::lookup("pt")),
@@ -446,9 +477,10 @@ void run(){
 
     auto& n_seeds = *tds.register_container<ContainerTH1<size_t>>("n_seeds", THParams::lookup("n_seeds"));
     auto& n_good_seeds = *tds.register_container<ContainerTH1<size_t>>("n_good_seeds", THParams::lookup("n_seeds"));
-    auto& n_good_sim = *tds.register_container<ContainerTH1<int>>("n_good_sim", THParams::lookup("n_seeds"));
-    auto& n_prompt = *tds.register_container<ContainerTH1<int>>("n_prompt", THParams::lookup("n_seeds"));
-    auto& n_gsf_tracks = *tds.register_container<ContainerTH1<int>>("n_gsf_track", THParams::lookup("n_seeds"));
+    auto& n_good_sim = *tds.register_container<ContainerTH1<size_t>>("n_good_sim", THParams::lookup("n_seeds"));
+    auto& n_prompt = *tds.register_container<ContainerTH1<size_t>>("n_prompt", THParams::lookup("n_seeds"));
+    auto& n_nonprompt = *tds.register_container<ContainerTH1<size_t>>("n_nonprompt", THParams::lookup("n_seeds"));
+    auto& n_gsf_tracks = *tds.register_container<ContainerTH1<size_t>>("n_gsf_track", THParams::lookup("n_seeds"));
     auto& n_scl = *tds.register_container<ContainerTH1<size_t>>("n_scl", THParams::lookup("n_seeds"));
     auto& n_good_scl = *tds.register_container<ContainerTH1<size_t>>("n_good_scl", THParams::lookup("n_seeds"));
 
@@ -472,21 +504,13 @@ void run(){
     auto& matched_dR_dR = *tds.register_container<ContainerTH1<float>>("matched_dR_dR", THParams::lookup("matched_dR"));
     auto& matched_dpT_dR = *tds.register_container<ContainerTH1<float>>("matched_dpT_dR", THParams::lookup("matched_dpT"));
 
-    auto& sim_pt = *tds.register_container<ContainerTH1<float>>("sim_pt", THParams::lookup("pt_fine"));
-    auto& sim_eta = *tds.register_container<ContainerTH1<float>>("sim_eta", THParams::lookup("eta_fine"));
-    auto& sim_phi = *tds.register_container<ContainerTH1<float>>("sim_phi", THParams::lookup("phi_fine"));
-
-    auto& reco_pt = *tds.register_container<ContainerTH1<float>>("reco_pt", THParams::lookup("pt_fine"));
-    auto& reco_eta = *tds.register_container<ContainerTH1<float>>("reco_eta", THParams::lookup("eta_fine"));
-    auto& reco_phi = *tds.register_container<ContainerTH1<float>>("reco_phi", THParams::lookup("phi_fine"));
-
-
     auto& tm_corr = *tds.register_container<ContainerTH2<int>>("tm_corr", THParams(2, -0.5, 1.5, 2, -0.5, 1.5));
 
     while (tds.next()) {
 
         update_sim_els();
-        vector<SimTrack> prompt_sims = get_prompt_sims();
+        vector<SimTrack> prompt_sims, nonprompt_sims;
+        std::tie(prompt_sims, nonprompt_sims) = get_prompt_sims();
 
 
         size_t _n_good_seeds = 0;
@@ -514,6 +538,13 @@ void run(){
             prompt_kinems.phi->fill(prompt.phi());
         }
 
+        n_nonprompt.fill(nonprompt_sims.size());
+        for (const auto& nonprompt : nonprompt_sims) {
+            nonprompt_kinems.pt->fill(nonprompt.pt());
+            nonprompt_kinems.eta->fill(nonprompt.eta());
+            nonprompt_kinems.phi->fill(nonprompt.phi());
+        }
+
         for (const auto& gsf_track : gsf_tracks) {
             gsf_kinems.pt->fill(gsf_track.pt());
             gsf_kinems.eta->fill(gsf_track.eta());
@@ -554,18 +585,6 @@ void run(){
         for(float dR : std::get<8>(match_stats)) matched_dR_dR.fill(dR);
         for(float dpT : std::get<9>(match_stats)) matched_dpT_dR.fill(dpT);
 
-        for (const auto& sim_track : sim_els) {
-            sim_pt.fill(sim_track.pt());
-            sim_eta.fill(sim_track.eta());
-            sim_phi.fill(sim_track.phi());
-        }
-
-        for (const auto& reco_track : gsf_tracks) {
-            reco_pt.fill(reco_track.pt());
-            reco_eta.fill(reco_track.eta());
-            reco_phi.fill(reco_track.phi());
-        }
-
         for (const auto& sim_track : sim_els) {
             if (seeds.size() == 0) continue;
             for (const auto &seed_idx : sim_track.seedIdx()) {
@@ -599,7 +618,6 @@ void run(){
         for (const auto& sim_track : sim_els) {
             if (gsf_tracks.size() == 0) continue;
             bool matched = false;
-            bool prompt_matched = false;
             for (const auto& track_idx : sim_track.trkIdx()) {
                 const Seed& seed = seeds[gsf_tracks[track_idx].seedIdx()];
                 if (is_good_seed(seed, hoe_cut)) {
@@ -622,6 +640,14 @@ void run(){
                 if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
                     prompt_eff.phi->fill(sim_track.phi(), matched);
             }
+            if (std::find(nonprompt_sims.begin(), nonprompt_sims.end(), sim_track) != nonprompt_sims.end()) {
+                if (abs(sim_track.eta()) < 2.4)
+                    nonprompt_eff.pt->fill(sim_track.pt(), matched);
+                if (sim_track.pt() > 20.0)
+                    nonprompt_eff.eta->fill(sim_track.eta(), matched);
+                if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
+                    nonprompt_eff.phi->fill(sim_track.phi(), matched);
+            }
 
             // dR-matching
             matched = false;
@@ -648,6 +674,14 @@ void run(){
                 if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
                     prompt_eff_dR.phi->fill(sim_track.phi(), matched);
             }
+            if (find(nonprompt_sims.begin(), nonprompt_sims.end(), sim_track) != nonprompt_sims.end()) {
+                if (abs(sim_track.eta()) < 2.4)
+                    nonprompt_eff_dR.pt->fill(sim_track.pt(), matched);
+                if (sim_track.pt() > 20.0)
+                    nonprompt_eff_dR.eta->fill(sim_track.eta(), matched);
+                if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
+                    nonprompt_eff_dR.phi->fill(sim_track.phi(), matched);
+            }
         }
 
         // Seeding Purity
@@ -655,7 +689,7 @@ void run(){
             if (!is_good_seed(seed, hoe_cut)) continue;
             bool match = false;
             for (const auto& sim_track_idx : seed.simTrkIdx()) {
-                if (is_good_sim(sim_tracks[sim_track_idx])) {
+                if (is_good_sim(sim_els, sim_tracks[sim_track_idx])) {
                     match = true;
                     break;
                 }
@@ -675,13 +709,17 @@ void run(){
             if (!is_good_seed(seed, hoe_cut)) continue;
             bool matched = false;
             bool prompt_matched = false;
+            bool nonprompt_matched = false;
             for (const auto& sim_track_idx : gsf_track.simTrkIdx()) {
                 const auto& sim_track = sim_tracks[sim_track_idx];
-                if (!is_good_sim(sim_track)) continue;
+                if (!is_good_sim(sim_els, sim_track)) continue;
                 matched = true;
                 if (find(prompt_sims.begin(), prompt_sims.end(), sim_track) != prompt_sims.end()) {
                     prompt_matched = true;
                 }
+                if (find(nonprompt_sims.begin(), nonprompt_sims.end(), sim_track) != nonprompt_sims.end()) {
+                    nonprompt_matched = true;
+                }
             }
             if (abs(gsf_track.eta()) < 2.4)
                 tracking_pur.pt->fill(gsf_track.pt(), matched);
@@ -697,9 +735,17 @@ void run(){
             if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
                 prompt_pur.phi->fill(gsf_track.phi(), prompt_matched);
 
+            if (abs(gsf_track.eta()) < 2.4)
+                nonprompt_pur.pt->fill(gsf_track.pt(), nonprompt_matched);
+            if (gsf_track.pt() > 20)
+                nonprompt_pur.eta->fill(gsf_track.eta(), nonprompt_matched);
+            if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
+                nonprompt_pur.phi->fill(gsf_track.phi(), nonprompt_matched);
+
             // dR-matching
             matched = false;
             prompt_matched = false;
+            nonprompt_matched = false;
             for (const auto& sim_track : sim_els) {
                 double dR = deltaR(sim_track.eta(), sim_track.phi(), gsf_track.eta(), gsf_track.phi());
                 if (dR < 0.2) {
@@ -707,8 +753,12 @@ void run(){
                     if (find(prompt_sims.begin(), prompt_sims.end(), sim_track) != prompt_sims.end()) {
                         prompt_matched = true;
                     }
+                    if (find(nonprompt_sims.begin(), nonprompt_sims.end(), sim_track) != nonprompt_sims.end()) {
+                        nonprompt_matched = true;
+                    }
                 }
             }
+
             if (abs(gsf_track.eta()) < 2.4)
                 tracking_pur_dR.pt->fill(gsf_track.pt(), matched);
             if (gsf_track.pt() > 20.0)
@@ -722,6 +772,13 @@ void run(){
                 prompt_pur_dR.eta->fill(gsf_track.eta(), prompt_matched);
             if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
                 prompt_pur_dR.phi->fill(gsf_track.phi(), prompt_matched);
+
+            if (abs(gsf_track.eta()) < 2.4)
+                nonprompt_pur_dR.pt->fill(gsf_track.pt(), nonprompt_matched);
+            if (gsf_track.pt() > 20)
+                nonprompt_pur_dR.eta->fill(gsf_track.eta(), nonprompt_matched);
+            if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
+                nonprompt_pur_dR.phi->fill(gsf_track.phi(), nonprompt_matched);
         }
 
         // Fake-Rate
@@ -729,7 +786,7 @@ void run(){
         for (const auto &gsf_track : gsf_tracks) {
             bool gsf_truth_matched = false;
             for(const auto& sim_track_idx : gsf_track.simTrkIdx()) {
-                if (is_good_sim(sim_tracks[sim_track_idx])) {
+                if (is_good_sim(sim_els, sim_tracks[sim_track_idx])) {
                     gsf_truth_matched = true;
                     break;
                 }
@@ -806,7 +863,7 @@ void run(){
             bool is_seed_sim_matched = false;
             for (const auto& sim_track_idx : seed.simTrkIdx()) {
                 const SimTrack& sim_track = sim_tracks[sim_track_idx];
-                if (is_good_sim(sim_track) and reco_energy_consistent(sim_track, seed)) {
+                if (is_good_sim(sim_els, sim_track) and reco_energy_consistent(sim_track, seed)) {
                     is_seed_sim_matched = true;
                     break;
                 }
@@ -816,7 +873,7 @@ void run(){
             const auto the_track = gsf_tracks[seed.trkIdx()];
             for (const auto& sim_track_idx : the_track.simTrkIdx()) {
                 const SimTrack& sim_track = sim_tracks[sim_track_idx];
-                if (is_good_sim(sim_track) and reco_energy_consistent(sim_track, the_track)) {
+                if (is_good_sim(sim_els, sim_track) and reco_energy_consistent(sim_track, the_track)) {
                     is_track_sim_matched = true;
                     break;
                 }