Merge branch 'master' of git.fangmeier.tech:caleb/EGamma_ElectronTrackingValidation

looper/CMakeLists.txt

@@ -16,7 +16,7 @@ ADD_EXECUTABLE(tracking_eff analysis/tracking_eff.cpp)
 TARGET_LINK_LIBRARIES(tracking_eff yaml-cpp ${ROOT_LIBRARIES})
 TARGET_INCLUDE_DIRECTORIES(tracking_eff PUBLIC ${ROOT_INCLUDE_DIR} ${CMAKE_SOURCE_DIR} filval/include/ filval/root/include/ filval/yaml-cpp/include/)
 
-
-ADD_EXECUTABLE(sim_track_viz analysis/sim_track_viz.cpp)
-TARGET_LINK_LIBRARIES(sim_track_viz yaml-cpp ${ROOT_LIBRARIES})
-TARGET_INCLUDE_DIRECTORIES(sim_track_viz PUBLIC ${ROOT_INCLUDE_DIR} ${CMAKE_SOURCE_DIR} filval/include/ filval/root/include/ filval/yaml-cpp/include/)
+ADD_EXECUTABLE(dump_good_sim analysis/dump_good_sim.cpp)
+# TARGET_LINK_LIBRARIES(dump_good_sim filval yaml-cpp ${ROOT_LIBRARIES})
+TARGET_LINK_LIBRARIES(dump_good_sim yaml-cpp ${ROOT_LIBRARIES})
+TARGET_INCLUDE_DIRECTORIES(dump_good_sim PUBLIC ${ROOT_INCLUDE_DIR} ${CMAKE_SOURCE_DIR} filval/include/ filval/root/include/ filval/yaml-cpp/include/)

looper/analysis/config.yaml

@@ -6,53 +6,23 @@ source-file-key: test_file
 
 hoe_cut: 0.15
 
-test_file:
-    files: /home/caleb/trackingNtuple_1.root
+zee-new-default:
+    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/ZToEE_NNPDF30_13TeV-powheg_M_120_200/EGamma_18-04-26_trackingNtuple_narrow-eg/180426_232815/0000/trackingNtuple_*.root
 
-extra-narrow-window:
-    files: ../data/EGamma_18-03-07_trackingNtuple_extra-narrow/180307_215057/0000/trackingNtuple_*.root
+zee-new-wide:
+    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/ZToEE_NNPDF30_13TeV-powheg_M_120_200/EGamma_18-04-26_trackingNtuple_wide-eg/180426_232942/0000/trackingNtuple_*.root
 
-narrow-window:
-    files: ../data/EGamma_18-03-07_trackingNtuple_narrow/180307_215909/0000/trackingNtuple_*.root
+zee-old-default:
+    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/ZToEE_NNPDF30_13TeV-powheg_M_120_200/EGamma_18-04-26_trackingNtuple_old-seeding-eg/180426_233131/0000/trackingNtuple_*.root
 
-wide-window:
-    files: ../data/EGamma_18-03-07_trackingNtuple_wide/180307_220112/0000/trackingNtuple_*.root
+tt-new-default:
+    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/EGamma_18-04-26_trackingNtuple_narrow-ttbar/180426_232215/0000/trackingNtuple_*.root
 
-extra-wide-window:
-    files: ../data/EGamma_18-03-07_trackingNtuple_extra-wide/180307_220241/0000/trackingNtuple_*.root
+tt-new-wide:
+    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/EGamma_18-04-26_trackingNtuple_wide-ttbar/180426_232354/0000/trackingNtuple_*.root
 
-old-seeding:
-    files: ../data/EGamma_18-03-08_trackingNtuple_old-seeding/180308_171441/0000/trackingNtuple_*.root
-
-eg-extra-narrow-window-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/ZToEE_NNPDF30_13TeV-powheg_M_120_200/EGamma_18-03-07_trackingNtuple_extra-narrow/180307_215057/0000/trackingNtuple_*.root
-
-eg-narrow-window-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/ZToEE_NNPDF30_13TeV-powheg_M_120_200/EGamma_18-03-07_trackingNtuple_narrow/180307_215909/0000/trackingNtuple_*.root
-
-eg-wide-window-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/ZToEE_NNPDF30_13TeV-powheg_M_120_200/EGamma_18-03-07_trackingNtuple_wide/180307_220112/0000/trackingNtuple_*.root
-
-eg-extra-wide-window-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/ZToEE_NNPDF30_13TeV-powheg_M_120_200/EGamma_18-03-07_trackingNtuple_extra-wide/180307_220241/0000/trackingNtuple_*.root
-
-eg-old-seeding-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/ZToEE_NNPDF30_13TeV-powheg_M_120_200/EGamma_18-03-08_trackingNtuple_old-seeding/180308_171441/0000/trackingNtuple_*.root
-
-ttbar-old-seeding-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/EGamma_18-03-22_trackingNtuple_old-seeding-ttbar/180322_190640/0000/trackingNtuple_*.root
-
-ttbar-extra-narrow-window-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/EGamma_18-03-22_trackingNtuple_extra-narrow-ttbar/180324_014232/0000/trackingNtuple_*.root
-
-ttbar-narrow-window-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/EGamma_18-03-22_trackingNtuple_narrow-ttbar/180324_014406/0000/trackingNtuple_*.root
-
-ttbar-wide-window-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/EGamma_18-03-22_trackingNtuple_wide-ttbar/180322_191158/0000/trackingNtuple_*.root
-
-ttbar-extra-wide-window-t3:
-    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/EGamma_18-03-22_trackingNtuple_extra-wide-ttbar/180324_014050/0000/trackingNtuple_*.root
+tt-old-default:
+    files: /mnt/hadoop/user/uscms01/pnfs/unl.edu/data4/cms/store/user/cfangmei/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/EGamma_18-04-26_trackingNtuple_old-seeding-ttbar/180426_232526/0000/trackingNtuple_*.root
 
 hist-params:
 
@@ -136,51 +106,29 @@ hist-params:
         low_y: 0
         high_y: 3.0
 
-    eff_v_pt:
-        label_x: "eff_v_pt"
+    pt:
         nbins_x: 30
         low_x: 0
         high_x: 300
-    eff_v_eta:
-        label_x: "eff_v_eta"
+    eta:
         nbins_x: 30
         low_x: -3.0
         high_x: 3.0
-    eff_v_phi:
-        label_x: "eff_v_phi"
+    phi:
         nbins_x: 30
         low_x: -3.2
         high_x: 3.2
 
-    pur_v_pt:
-        label_x: "pur_v_pt"
-        nbins_x: 30
+    pt_fine:
+        nbins_x: 300
         low_x: 0
         high_x: 300
-    pur_v_eta:
-        label_x: "pur_v_eta"
-        nbins_x: 30
+    eta_fine:
+        nbins_x: 300
         low_x: -3.0
         high_x: 3.0
-    pur_v_phi:
-        label_x: "pur_v_phi"
-        nbins_x: 30
-        low_x: -3.2
-        high_x: 3.2
-
-    fake_rate_v_pt:
-        label_x: "fake_rate_v_pt"
-        nbins_x: 30
-        low_x: 0
-        high_x: 300
-    fake_rate_v_eta:
-        label_x: "fake_rate_v_eta"
-        nbins_x: 30
-        low_x: -3.0
-        high_x: 3.0
-    fake_rate_v_phi:
-        label_x: "fake_rate_v_phi"
-        nbins_x: 30
+    phi_fine:
+        nbins_x: 300
         low_x: -3.2
         high_x: 3.2
 
@@ -217,7 +165,16 @@ hist-params:
         high_x: 1
 
     n_seeds:
-        label_x: "Number of Seeds in Event"
         nbins_x: 201
         low_x: -0.5
         high_x: 200.5
+
+    matched_dR:
+        nbins_x: 300
+        low_x: 0
+        high_x: .1
+
+    matched_dpT:
+        nbins_x: 2000
+        low_x: -10
+        high_x: 10

looper/analysis/dump_good_sim.cpp

@@ -0,0 +1,140 @@
+#include <iostream>
+#include <vector>
+#include <cmath>
+#include <numeric>
+#include <TSystem.h>
+#include <Math/VectorUtil.h>
+
+#include "filval.hpp"
+#include "root_filval.hpp"
+#include "common.hpp"
+
+#include "analysis/TrackingNtupleObjs.hpp"
+
+typedef ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float>> Vec4;
+
+SeedCollection seeds;
+SimTrackCollection sim_tracks;
+SimVertexCollection sim_vertices;
+TrackCollection gsf_tracks;
+SuperClusterCollection scls;
+
+void register_objects(TrackingDataSet& tds){
+    /* seeds.init(tds); */
+    sim_tracks.init(tds);
+    sim_vertices.init(tds);
+    /* gsf_tracks.init(tds); */
+    /* scls.init(tds); */
+}
+
+struct {
+    Value<float>* x;
+    Value<float>* y;
+    Value<float>* z;
+    Value<float>* sigma_x;
+    Value<float>* sigma_y;
+    Value<float>* sigma_z;
+} bs;
+
+template <typename T>
+struct KinColl {
+    T* pt;
+    T* eta;
+    T* phi;
+};
+
+
+bool in_lum_region(const SimVertex& vertex) {
+    /* Here approximate the luminous region as a cylinder with length 5*\sigma_z and radius
+     * sqrt(\simga_x^2 + \sigma_y^2) centered as beamspot position.
+     */
+    float dx = vertex.x() - bs.x->get();
+    float dy = vertex.y() - bs.y->get();
+    float dz = vertex.z() - bs.z->get();
+    auto radius = static_cast<float>(5 * sqrt(pow(bs.sigma_x->get(), 2) + pow(bs.sigma_y->get(), 2)));
+    float half_len = 5*bs.sigma_z->get();
+    return sqrt(dx*dx + dy*dy) < radius and abs(dz) < half_len;
+};
+
+bool is_good_sim(const SimTrack& sim_track) {
+    const auto& vertex = sim_vertices[sim_track.parentVtxIdx()];
+    return abs(sim_track.pdgId()) == 11 and in_lum_region(vertex);
+};
+
+
+template <typename T>
+std::ostream& operator<< (std::ostream& out, const std::vector<T>& v) {
+  if ( !v.empty() ) {
+    out << '[';
+    std::copy (v.begin(), v.end(), std::ostream_iterator<T>(out, ", "));
+    out << "\b\b]";
+  }
+  return out;
+}
+
+void run(){
+    using namespace std;
+    using namespace fv;
+    using namespace fv_root;
+    using namespace fv_util;
+    auto file_list = the_config->get_source_files();
+    string output_filename = the_config->get_output_filename();
+    TrackingDataSet tds(output_filename, file_list, "trackingNtuple/tree");
+    register_objects(tds);
+
+    // Declare TTree
+
+    bs = {
+        tds.track_branch<float>("bsp_x"),
+        tds.track_branch<float>("bsp_y"),
+        tds.track_branch<float>("bsp_z"),
+        tds.track_branch<float>("bsp_sigmax"),
+        tds.track_branch<float>("bsp_sigmay"),
+        tds.track_branch<float>("bsp_sigmaz")
+    };
+
+    while (tds.next()) {
+
+        cout << "Event: " << tds.get_current_event() << endl;
+        for (const auto& sim_track : sim_tracks) {
+            if (!is_good_sim(sim_track)) continue;
+            /* SimVertex parentvtx = sim_vertices[sim_track.parentVtxIdx()]; */
+            /* SimVertex parentvtx = sim_vertices[sim_track.parentVtxIdx()]; */
+            cout << "\t" << sim_track.pdgId() << " "
+                 << sim_track.pt() << " "
+                 << sim_track.eta() << " "
+                 << sim_track.phi() << " "
+                 << sim_track.parentVtxIdx() << " "
+                 << sim_track.decayVtxIdx() << " ";
+            if (sim_track.decayVtxIdx().size() > 0) {
+                cout << sim_tracks[sim_vertices[sim_track.decayVtxIdx()[0]].daughterSimIdx()[0]].pdgId();
+            }
+
+
+            cout << endl;
+            // Log Sim Track
+        }
+    }
+    tds.save_all();
+}
+
+int main(int argc, char * argv[]){
+    using namespace fv_util;
+    ArgParser args(argc, argv);
+    if(args.cmd_option_exists("-c")) {
+        init_config(args.get_cmd_option("-c"));
+        args.update_config();
+        if (args.cmd_option_exists("-s")) {
+            the_config->update_key("silent", true);
+        }
+        if (args.cmd_option_exists("-b")) {
+            the_config->update_key("batch", true);
+        }
+        init_log(LogPriority::kLogInfo);
+//        gSystem->Load("libfilval.so");
+        run();
+    } else {
+        cout << "Usage: ./" << argv[0] << " (-s) (-b) -c config_file.yaml" << endl;
+    }
+    return 0;
+}

looper/analysis/tracking_eff.cpp

@@ -1,7 +1,9 @@
 #include <iostream>
 #include <vector>
 #include <cmath>
+#include <numeric>
 #include <TSystem.h>
+#include <Math/VectorUtil.h>
 
 #include "filval.hpp"
 #include "root_filval.hpp"
@@ -9,6 +11,8 @@
 
 #include "analysis/TrackingNtupleObjs.hpp"
 
+typedef ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float>> Vec4;
+
 SeedCollection seeds;
 SimTrackCollection sim_tracks;
 SimVertexCollection sim_vertices;
@@ -39,7 +43,6 @@ struct KinColl {
     T* phi;
 };
 
-
 bool in_lum_region(const SimVertex& vertex) {
     /* Here approximate the luminous region as a cylinder with length 5*\sigma_z and radius
      * sqrt(\simga_x^2 + \sigma_y^2) centered as beamspot position.
@@ -54,7 +57,9 @@ bool in_lum_region(const SimVertex& vertex) {
 
 bool is_good_sim(const SimTrack& sim_track) {
     const auto& vertex = sim_vertices[sim_track.parentVtxIdx()];
-    return abs(sim_track.pdgId()) == 11 and in_lum_region(vertex);
+    return abs(sim_track.pdgId()) == 11 and  // electrons
+           in_lum_region(vertex) and  // from luminous region
+           abs(sim_track.eta())<3.0;  // inside ECAL acceptance
 };
 
 //bool is_good_fake(const SimTrack& sim_track) {
@@ -79,11 +84,82 @@ bool reco_energy_consistent(const SimTrack& sim_track, const TrackOrSeed& track,
     return fabs(reco_energy_rel_err(sim_track, track)) < consistency_cut;
 }
 
+Vec4 scl_p4(const SuperCluster& scl) {
+    return Vec4(scl.px(), scl.py(), scl.pz(), scl.e());
+}
+
+double deltaR(float scl_eta, float scl_phi, const SimTrack& sim_track) {
+    return sqrt(pow(sim_track.eta() - scl_eta, 2.0) +
+                pow(sim_track.phi() - scl_phi, 2.0));
+}
+
 double deltaR(const SimTrack& sim_track, const Track& gsf_track) {
     return sqrt(pow(sim_track.eta() - gsf_track.eta(), 2.0) +
                 pow(sim_track.phi() - gsf_track.phi(), 2.0));
 }
 
+
+auto get_match_stats(bool dRMatch) {
+    int nSimTrack = 0;
+    int nGSFTrack = 0;
+    int nMatched = 0;  // 1-to-1
+    int nMerged = 0; // n-to-1
+    int nLost = 0;   // 1-to-0
+    int nSplit = 0;  // 1-to-n
+    int nFaked = 0;   // 0-to-1
+    int nFlipped = 0;
+    vector<float> matched_dR;
+    vector<float> matched_dpT;
+    std::map<int, std::vector<int>> sim_matches;
+    std::map<int, std::vector<int>> gsf_matches;
+    for(const auto& sim_track : sim_tracks)
+        if (is_good_sim(sim_track)) sim_matches[sim_track.idx] = {};
+    for(const auto& gsf_track : gsf_tracks)
+        gsf_matches[gsf_track.idx] = {};
+
+    nSimTrack = sim_matches.size();
+    nGSFTrack = gsf_matches.size();
+
+    for (const auto& sim_track : sim_tracks) {
+        if (!is_good_sim(sim_track)) continue;
+        if (dRMatch) {
+            for (const auto& gsf_track : gsf_tracks) {
+                float dR = deltaR(sim_track, gsf_track);
+                if (dR < 0.2) {
+                    sim_matches[sim_track.idx].push_back(gsf_track.idx);
+                    gsf_matches[gsf_track.idx].push_back(sim_track.idx);
+                    matched_dR.push_back(dR);
+                    matched_dpT.push_back((sim_track.pt() - gsf_track.pt())/sim_track.pt());
+                    if (gsf_track.q() != sim_track.q()) nFlipped++;
+                }
+            }
+        } else {
+            for (const auto& gsfIdx : sim_track.trkIdx()) {
+                const Track& gsf_track = gsf_tracks[gsfIdx];
+                float dR = deltaR(sim_track, gsf_track);
+                sim_matches[sim_track.idx].push_back(gsf_track.idx);
+                gsf_matches[gsf_track.idx].push_back(sim_track.idx);
+                matched_dR.push_back(dR);
+                matched_dpT.push_back((sim_track.pt() - gsf_track.pt())/sim_track.pt());
+                if (gsf_track.q() != sim_track.q()) nFlipped++;
+            }
+        }
+    }
+
+    for (const auto& p : sim_matches) {
+        const auto& matches = p.second;
+        if (matches.size() == 0) nLost++;
+        if (matches.size() == 1 and gsf_matches[matches[0]].size() == 1) nMatched++;
+        if (matches.size() > 1) nSplit++;
+    }
+    for (const auto& p : gsf_matches) {
+        const auto& matches = p.second;
+        if (matches.size() == 0) nFaked++;
+        if (matches.size() > 1) nMerged++;
+    }
+    return std::make_tuple(nSimTrack, nGSFTrack, nMatched, nMerged, nLost, nSplit, nFaked, nFlipped, matched_dR, matched_dpT);
+}
+
 void run(){
     using namespace std;
     using namespace fv;
@@ -216,35 +292,45 @@ void run(){
     }
 
     KinColl<EfficiencyContainer<float>> seed_eff = {
-            tds.register_container<EfficiencyContainer<float>>("seed_eff_v_pt",  THParams::lookup("eff_v_pt")),
-            tds.register_container<EfficiencyContainer<float>>("seed_eff_v_eta", THParams::lookup("eff_v_eta")),
-            tds.register_container<EfficiencyContainer<float>>("seed_eff_v_phi", THParams::lookup("eff_v_phi"))};
+            tds.register_container<EfficiencyContainer<float>>("seed_eff_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("seed_eff_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("seed_eff_v_phi", THParams::lookup("phi"))};
     KinColl<EfficiencyContainer<float>> seed_pur = {
-            tds.register_container<EfficiencyContainer<float>>("seed_pur_v_pt",  THParams::lookup("pur_v_pt")),
-            tds.register_container<EfficiencyContainer<float>>("seed_pur_v_eta", THParams::lookup("pur_v_eta")),
-            tds.register_container<EfficiencyContainer<float>>("seed_pur_v_phi", THParams::lookup("pur_v_phi"))};
+            tds.register_container<EfficiencyContainer<float>>("seed_pur_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("seed_pur_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("seed_pur_v_phi", THParams::lookup("phi"))};
     KinColl<EfficiencyContainer<float>> tracking_eff = {
-            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_pt",  THParams::lookup("eff_v_pt")),
-            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_eta", THParams::lookup("eff_v_eta")),
-            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_phi", THParams::lookup("eff_v_phi"))};
+            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_phi", THParams::lookup("phi"))};
     KinColl<EfficiencyContainer<float>> tracking_pur = {
-            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_pt",  THParams::lookup("pur_v_pt")),
-            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_eta", THParams::lookup("pur_v_eta")),
-            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_phi", THParams::lookup("pur_v_phi"))};
+            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_phi", THParams::lookup("phi"))};
 
     KinColl<EfficiencyContainer<float>> tracking_eff_dR = {
-            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_pt_dR",  THParams::lookup("eff_v_pt")),
-            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_eta_dR", THParams::lookup("eff_v_eta")),
-            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_phi_dR", THParams::lookup("eff_v_phi"))};
+            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_pt_dR",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_eta_dR", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_phi_dR", THParams::lookup("phi"))};
     KinColl<EfficiencyContainer<float>> tracking_pur_dR = {
-            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_pt_dR",  THParams::lookup("pur_v_pt")),
-            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_eta_dR", THParams::lookup("pur_v_eta")),
-            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_phi_dR", THParams::lookup("pur_v_phi"))};
+            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_pt_dR",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_eta_dR", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_phi_dR", THParams::lookup("phi"))};
 
-    KinColl<EfficiencyContainer<float>> fake_rate = {
-            tds.register_container<EfficiencyContainer<float>>("fake_rate_v_pt",  THParams::lookup("eff_v_pt")),
-            tds.register_container<EfficiencyContainer<float>>("fake_rate_v_eta", THParams::lookup("eff_v_eta")),
-            tds.register_container<EfficiencyContainer<float>>("fake_rate_v_phi", THParams::lookup("pur_v_phi"))};
+    KinColl<EfficiencyContainer<float>> partial_fake_rate = {
+            tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_v_phi", THParams::lookup("phi"))};
+
+    KinColl<EfficiencyContainer<float>> full_fake_rate = {
+            tds.register_container<EfficiencyContainer<float>>("full_fake_rate_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("full_fake_rate_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("full_fake_rate_v_phi", THParams::lookup("phi"))};
+
+    KinColl<EfficiencyContainer<float>> clean_fake_rate = {
+            tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_v_pt",  THParams::lookup("pt")),
+            tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_v_eta", THParams::lookup("eta")),
+            tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_v_phi", THParams::lookup("phi"))};
 
     auto& hit_vs_layer_barrel = *tds.register_container<ContainerTH2<int>>("hit_vs_layer_barrel", THParams::lookup("hit_vs_layer"));
     auto& hit_vs_layer_forward = *tds.register_container<ContainerTH2<int>>("hit_vs_layer_forward", THParams::lookup("hit_vs_layer"));
@@ -255,9 +341,75 @@ void run(){
     auto& ecal_energy_resolution = *tds.register_container<ContainerTH1<float>>("ecal_energy_resolution ", THParams::lookup("ecal_energy_resolution"));
 
     auto& n_seeds = *tds.register_container<ContainerTH1<size_t>>("n_seeds", THParams::lookup("n_seeds"));
+    auto& n_good_sim = *tds.register_container<ContainerTH1<int>>("n_good_sim", THParams::lookup("n_seeds"));
+    auto& n_gsf_tracks = *tds.register_container<ContainerTH1<int>>("n_gsf_track", THParams::lookup("n_seeds"));
+
+    auto& n_matched = *tds.register_container<ContainerTH1<int>>("n_matched", THParams::lookup("n_seeds"));
+    auto& n_merged = *tds.register_container<ContainerTH1<int>>("n_merged", THParams::lookup("n_seeds"));
+    auto& n_lost = *tds.register_container<ContainerTH1<int>>("n_lost", THParams::lookup("n_seeds"));
+    auto& n_split = *tds.register_container<ContainerTH1<int>>("n_split", THParams::lookup("n_seeds"));
+    auto& n_faked = *tds.register_container<ContainerTH1<int>>("n_faked", THParams::lookup("n_seeds"));
+    auto& n_flipped = *tds.register_container<ContainerTH1<int>>("n_flipped", THParams::lookup("n_seeds"));
+
+    auto& matched_dR = *tds.register_container<ContainerTH1<float>>("matched_dR", THParams::lookup("matched_dR"));
+    auto& matched_dpT = *tds.register_container<ContainerTH1<float>>("matched_dpT", THParams::lookup("matched_dpT"));
+
+    auto& n_matched_dR = *tds.register_container<ContainerTH1<int>>("n_matched_dR", THParams::lookup("n_seeds"));
+    auto& n_merged_dR = *tds.register_container<ContainerTH1<int>>("n_merged_dR", THParams::lookup("n_seeds"));
+    auto& n_lost_dR = *tds.register_container<ContainerTH1<int>>("n_lost_dR", THParams::lookup("n_seeds"));
+    auto& n_split_dR = *tds.register_container<ContainerTH1<int>>("n_split_dR", THParams::lookup("n_seeds"));
+    auto& n_faked_dR = *tds.register_container<ContainerTH1<int>>("n_faked_dR", THParams::lookup("n_seeds"));
+    auto& n_flipped_dR = *tds.register_container<ContainerTH1<int>>("n_flipped_dR", THParams::lookup("n_seeds"));
+
+    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"));
 
     while (tds.next()) {
 
+        n_seeds.fill(seeds.size());
+        auto match_stats =  get_match_stats(false);
+        n_good_sim.fill(std::get<0>(match_stats));
+        n_gsf_tracks.fill(std::get<1>(match_stats));
+        n_matched.fill(std::get<2>(match_stats));
+        n_merged.fill(std::get<3>(match_stats));
+        n_lost.fill(std::get<4>(match_stats));
+        n_split.fill(std::get<5>(match_stats));
+        n_faked.fill(std::get<6>(match_stats));
+        n_flipped.fill(std::get<7>(match_stats));
+        for(float dR : std::get<8>(match_stats)) matched_dR.fill(dR);
+        for(float dpT : std::get<9>(match_stats)) matched_dpT.fill(dpT);
+
+        match_stats =  get_match_stats(true);
+        n_matched_dR.fill(std::get<2>(match_stats));
+        n_merged_dR.fill(std::get<3>(match_stats));
+        n_lost_dR.fill(std::get<4>(match_stats));
+        n_split_dR.fill(std::get<5>(match_stats));
+        n_faked_dR.fill(std::get<6>(match_stats));
+        n_flipped_dR.fill(std::get<7>(match_stats));
+        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_tracks) {
+            if (!is_good_sim(sim_track)) continue;
+            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_tracks) {
             if (!is_good_sim(sim_track)) continue;
             if (seeds.size() == 0) continue;
@@ -363,7 +515,6 @@ void run(){
             if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
                 tracking_pur.phi->fill(gsf_track.phi(), matched);
 
-
             // dR-matching
             matched = false;
             for (const auto& sim_track : sim_tracks) {
@@ -381,22 +532,64 @@ void run(){
                 tracking_pur_dR.phi->fill(gsf_track.phi(), matched);
         }
 
-        // Fake Rate (#SC w/ 1 or more gsf-tracks / #SC) all w/ SC HOE>0.15
-        std::map<size_t, size_t> scl2track;
-        for (const auto &trk : gsf_tracks) {
-            int seed_idx = trk.seedIdx();
-            scl2track[seeds[seed_idx].sclIdx()] = trk.idx;
+        // Fake-Rate
+        std::map<size_t, std::vector<int>> scl2trk; // Maps superclusters to tm-status of matched gsf-tracks
+        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])) {
+                    gsf_truth_matched = true;
+                    break;
+                }
+            }
+            int scl_idx = seeds[gsf_track.seedIdx()].sclIdx();
+            scl2trk[scl_idx].push_back(gsf_truth_matched);
         }
+        std::set<size_t> tm_scls; // Set of super-clusters with well matched sim-electrons
+        for (const auto &scl : scls) {
+            Vec4 p4 = scl_p4(scl);
+            for(const auto& sim_track : sim_tracks) {
+                if (!is_good_sim(sim_track)) continue;
+                if (deltaR(p4.eta(), p4.phi(), sim_track) > 0.2) continue;
+                if (((p4.Et() - sim_track.pt()) / p4.Et()) > 0.1) continue;
+                tm_scls.insert(scl.idx);
+                break;
+            }
+        }
+        /* cout << "scls: "; */
+        /* for (const auto& scl: scls) cout << scl.idx << ", "; */
+        /* cout << endl << "tm_scls: "; */
+        /* for (const auto& idx: tm_scls) cout << idx << ", "; */
+        /* cout << endl; */
         for (const auto &scl : scls) {
             if (scl.hoe() > hoe_cut) continue;
             float scl_pt = hypot(scl.px(), scl.py());
             float scl_eta = pseudorapidity(scl.x(), scl.y(), scl.z());
             float scl_phi = atan2(scl.py(), scl.px());
 
-            bool has_track = scl2track.count(scl.idx) == 1;
-            fake_rate.pt->fill(scl_pt, has_track);
-            fake_rate.eta->fill(scl_eta, has_track);
-            fake_rate.phi->fill(scl_phi, has_track);
+            int ntracks = scl2trk[scl.idx].size();
+            int ntmtracks = std::accumulate(scl2trk[scl.idx].begin(), scl2trk[scl.idx].end(), 0);
+            bool partial_fake = ntmtracks > 0 and ntracks > ntmtracks;
+            bool full_fake = ntmtracks == 0 and ntracks > 0;
+            /* cout << "ntracks: " << ntracks << " "; */
+            /* cout << "count: " << tm_scls.count(scl.idx); */
+            if (ntracks > 0) {
+                partial_fake_rate.pt->fill(scl_pt, partial_fake);
+                partial_fake_rate.eta->fill(scl_eta, partial_fake);
+                partial_fake_rate.phi->fill(scl_phi, partial_fake);
+
+                full_fake_rate.pt->fill(scl_pt, full_fake);
+                full_fake_rate.eta->fill(scl_eta, full_fake);
+                full_fake_rate.phi->fill(scl_phi, full_fake);
+
+                if (tm_scls.count(scl.idx) == 0) {
+                    /* cout << "Filling clean_fake_rate" << endl; */
+                    clean_fake_rate.pt->fill(scl_pt, full_fake);
+                    clean_fake_rate.eta->fill(scl_eta, full_fake);
+                    clean_fake_rate.phi->fill(scl_phi, full_fake);
+                }
+            }
+            /* cout << endl; */
         }
 
         // Hit Residuals
@@ -486,7 +679,6 @@ void run(){
                 }
             }
         }
-        n_seeds.fill(seeds.size());
     }
 
     tds.save_all();

looper/filval

@@ -1 +1 @@
-Subproject commit a227be04fcce25f0beb72116839bbf59af36a85e
+Subproject commit a83921cf4b2033e4278b43fa69f7059cd76a0bf1

looper/run_all.condor

@@ -10,14 +10,10 @@ output     = condor_logs/out.$(Process)
 log        = condor_logs/foo.log
 
 queue arguments from (
-    eg-extra-narrow-window-t3
-    eg-narrow-window-t3
-    eg-wide-window-t3
-    eg-extra-wide-window-t3
-    eg-old-seeding-t3
-    ttbar-extra-narrow-window-t3
-    ttbar-narrow-window-t3
-    ttbar-wide-window-t3
-    ttbar-extra-wide-window-t3
-    ttbar-old-seeding-t3
+    zee-new-default
+    zee-new-wide
+    zee-old-default
+    tt-new-default
+    tt-new-wide
+    tt-old-default
 )

looper/run_all.sh

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 
+echo "starting run at " $(date)
 pwd
 ls -la