updates to plotting routines in filval and adds dr computation for rec/sim hits

.flake8

@@ -0,0 +1 @@
+filval/python/.flake8

analysis/EGamma_TrackingValidation.py

@@ -0,0 +1,179 @@
+
+# coding: utf-8
+
+import sys
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+
+sys.path.append("filval/python/")
+from utils import ResultSet
+from plotter import plot_histogram, plot_histogram2d
+mpl.rc('text', usetex=True)
+mpl.rc('savefig', dpi=180)
+mpl.rc('savefig', transparent=True)
+
+# First create a ResultSet object which loads all of the objects from output.root
+# into memory and makes them available as attributes
+rs = ResultSet("DY2LL",  "/home/caleb/Sources/EGamma/build/output.root")
+
+
+scale = 0.85
+plt.figure(figsize=(scale*10, scale*10))
+
+plt.subplot(321)
+plot_histogram2d(rs.dphi_v_eta_first_hits_in_B1,
+                 ylabel="$\\Delta \\phi_1$(rad)",
+                 title="BPIX - Layer 1")
+
+plt.subplot(322)
+plot_histogram2d(rs.dphi_v_eta_first_hits_in_B2,
+                 title="BPIX - Layer 2")
+
+plt.subplot(323)
+plot_histogram2d(rs.dz_v_eta_first_hits_in_B1,
+                 ylabel="$\\Delta \\textrm{z}_1$(cm)")
+
+plt.subplot(324)
+plot_histogram2d(rs.dz_v_eta_first_hits_in_B2)
+
+plt.subplot(325)
+plot_histogram2d(rs.dr_v_eta_first_hits_in_B1,
+                 ylabel="$\\Delta r_1$(cm)",
+                 xlabel="$\\eta$")
+
+plt.subplot(326)
+plot_histogram2d(rs.dr_v_eta_first_hits_in_B2,
+                 xlabel="$\\eta$")
+
+plt.tight_layout()
+plt.savefig("figures/first_hits_v_eta.png")
+
+
+plt.clf()
+plt.subplot(321)
+plot_histogram2d(rs.dphi_v_eta_second_hits_in_B2,
+                 ylabel="$\\Delta \\phi_2$(rad)",
+                 title="BPIX - Layer 2")
+
+plt.subplot(322)
+plot_histogram2d(rs.dphi_v_eta_second_hits_in_B3,
+                 title="BPIX - Layer 3")
+
+plt.subplot(323)
+plot_histogram2d(rs.dz_v_eta_second_hits_in_B2,
+                 ylabel="$\\Delta \\textrm{z}_2$(cm)")
+
+plt.subplot(324)
+plot_histogram2d(rs.dz_v_eta_second_hits_in_B3)
+
+plt.subplot(325)
+plot_histogram2d(rs.dr_v_eta_second_hits_in_B2,
+                 ylabel="$\\Delta r_2$(cm)",
+                 xlabel="$\\eta$")
+
+plt.subplot(326)
+plot_histogram2d(rs.dr_v_eta_second_hits_in_B3,
+                 xlabel="$\\eta$")
+
+plt.tight_layout()
+plt.savefig("figures/second_hits_v_eta.png")
+
+
+plt.clf()
+plt.subplot(321)
+plot_histogram(rs.dphi_v_eta_first_hits_in_B1.ProjectionY(),
+               include_errors=True, xlabel="$\\Delta \\phi_1$(rad)",
+               title="BPIX - Layer 1")
+
+plt.subplot(322)
+plot_histogram(rs.dphi_v_eta_first_hits_in_B2.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta \\phi_1$(rad)",
+               title="BPIX - Layer 2")
+
+plt.subplot(323)
+plot_histogram(rs.dz_v_eta_first_hits_in_B1.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta z_1$(cm)")
+
+plt.subplot(324)
+plot_histogram(rs.dz_v_eta_first_hits_in_B2.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta z_1$(cm)")
+
+plt.subplot(325)
+plot_histogram(rs.dr_v_eta_first_hits_in_B1.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta r_1$(cm)")
+
+plt.subplot(326)
+plot_histogram(rs.dr_v_eta_first_hits_in_B2.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta r_1$(cm)")
+
+plt.tight_layout()
+plt.savefig("figures/first_hits.png")
+
+
+plt.clf()
+plt.subplot(321)
+plot_histogram(rs.dphi_v_eta_second_hits_in_B2.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta \\phi_2$(rad)",
+               title="BPIX - Layer 2")
+
+plt.subplot(322)
+plot_histogram(rs.dphi_v_eta_second_hits_in_B3.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta \\phi_2$(rad)",
+               title="BPIX - Layer 3")
+
+plt.subplot(323)
+plot_histogram(rs.dz_v_eta_second_hits_in_B2.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta z_2$(cm)")
+
+plt.subplot(324)
+plot_histogram(rs.dz_v_eta_second_hits_in_B3.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta z_2$(cm)")
+
+plt.subplot(325)
+plot_histogram(rs.dr_v_eta_second_hits_in_B2.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta r_2$(cm)")
+
+plt.subplot(326)
+plot_histogram(rs.dr_v_eta_second_hits_in_B3.ProjectionY(), include_errors=True,
+               xlabel="$\\Delta r_2$(cm)")
+
+plt.tight_layout()
+plt.savefig("figures/second_hits.png")
+
+
+def even_odd_plot(even, odd, var, scale, unit, **kwargs):
+    even_dist = even.ProjectionY()
+    odd_dist = odd.ProjectionY()
+    plot_histogram(even_dist, include_errors=True, label="even ladders")
+    plot_histogram(odd_dist, include_errors=True, color='r', label="odd ladders",
+                   **kwargs)
+
+    even_mean = even_dist.GetMean()*scale
+    odd_mean = odd_dist.GetMean()*scale
+    axes = plt.gca()
+    txt = r"$ \hat{{\Delta {0} }}_{{1,\textrm{{ {1} }} }}={2:4.2g}${3}"
+    axes.text(0.05, .7, txt.format(var, "odd",  odd_mean, unit), transform=axes.transAxes)
+    axes.text(0.05, .6, txt.format(var, "even", even_mean, unit), transform=axes.transAxes)
+
+
+plt.clf()
+
+plt.subplot(221)
+even_odd_plot(rs.dphi_v_eta_first_hits_in_B1_even_ladder, rs.dphi_v_eta_first_hits_in_B1_odd_ladder,
+              r"\phi", 10**6, "urad", xlabel=r"$\Delta \phi_1$(rad)", title="BPIX - Layer 1")
+
+plt.subplot(222)
+even_odd_plot(rs.dphi_v_eta_first_hits_in_B2_even_ladder, rs.dphi_v_eta_first_hits_in_B2_odd_ladder,
+              r"\phi", 10**6, "urad", xlabel=r"$\Delta \phi_1$(rad)", title="BPIX - Layer 2")
+plt.legend()
+
+plt.subplot(223)
+even_odd_plot(rs.dz_v_eta_first_hits_in_B1_even_ladder, rs.dz_v_eta_first_hits_in_B1_odd_ladder,
+              "z", 10**4, "um", xlabel=r"$\Delta z_1$(cm)")
+
+plt.subplot(224)
+even_odd_plot(rs.dz_v_eta_first_hits_in_B2_even_ladder, rs.dz_v_eta_first_hits_in_B2_odd_ladder,
+              "z", 10**4, "um", xlabel=r"$\Delta z_1$(cm)")
+
+plt.tight_layout()
+plt.savefig("figures/delta_phi_z_v_ladder.png")

analysis/obj_types.cpp

@@ -493,7 +493,7 @@ register_seeds(TrackingDataSet &tds){
 //=======================TRACK================================================
 //============================================================================
 struct Track{
-    unsigned int   idx;
+    unsigned int  idx;
     float         px;
     float         py;
     float         pz;

analysis/tracking_validation.cpp

@@ -34,8 +34,8 @@ std::map<int,string> subdet_names = {{1, "BPIX"}, {2, "FPIX"}};
 template<typename A, typename B>
 float displacement(const A& a, const B& b){
     return std::sqrt(pow(a.x-b.x, 2) +
-                     pow(a.x-b.x, 2) +
-                     pow(a.x-b.x, 2));
+                     pow(a.y-b.y, 2) +
+                     pow(a.z-b.z, 2));
 }
 
 template<typename T>
@@ -126,19 +126,6 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
             return matched_hits;
         })));
 
-    auto& select_even_odd_ladder_blade_hit_pairs =
-    func<vector<HitPair>(vector<HitPair>, bool)>("select_even_odd_ladder_blade_hit_pairs",
-        FUNC(([](const vector<HitPair>& hit_pairs,
-                 const bool &&odd){
-            vector<HitPair> even_pairs;
-            for(const HitPair &hit_pair : hit_pairs){ // loop over all seeds
-                if(std::get<PixRecHit>(hit_pair).ladder_blade % 2 == odd){
-                    even_pairs.push_back(hit_pair);
-                }
-            }
-            return even_pairs;
-        })));
-
     auto barrel_val = constant("PIXEL_BARREL", PIXEL_BARREL);
     auto endcap_val = constant("PIXEL_ENDCAP", PIXEL_ENDCAP);
     auto first_hit  = constant("1st", 0);
@@ -172,6 +159,19 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
     auto even = constant("even", false);
     auto odd = constant("odd", true);
 
+    auto& select_even_odd_ladder_blade_hit_pairs =
+    func<vector<HitPair>(vector<HitPair>, bool)>("select_even_odd_ladder_blade_hit_pairs",
+        FUNC(([](const vector<HitPair>& hit_pairs,
+                 const bool &&odd){
+            vector<HitPair> even_pairs;
+            for(const HitPair &hit_pair : hit_pairs){ // loop over all seeds
+                if(std::get<PixRecHit>(hit_pair).ladder_blade % 2 == odd){
+                    even_pairs.push_back(hit_pair);
+                }
+            }
+            return even_pairs;
+        })));
+
     auto first_hits_in_B1_even_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
             fv::tuple(first_hits_in_B1, even), "first_hits_in_B1_even_ladder");
     auto first_hits_in_B1_odd_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
@@ -241,6 +241,65 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
                                                     fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_F3)),
                                                     "Second Hit in FPIX-L3", params_dphi);
 
+    //Plots for dr of collections defined above
+    auto& calc_dr_v_eta = func<pair_vec(vector<HitPair>)>("calc_dr_v_eta",
+        FUNC(([](const vector<HitPair>& hit_pairs){
+            vector<float> drs;
+            vector<float> etas;
+            for(auto hit_pair : hit_pairs){
+                auto& pixrec_hit = std::get<PixRecHit>(hit_pair);
+                auto& sim_hit = std::get<SimHit>(hit_pair);
+                drs.push_back(displacement(pixrec_hit, sim_hit));
+                etas.push_back(pseudorapidity(pixrec_hit));
+            }
+            return std::make_pair(etas, drs);
+        })));
+    TH2Params params_dr = {"$\\eta$",       100, -4,   4,
+                           "$\\Delta \\r$(rad)", 50, 0, .006};
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_first_hits_in_B1",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(first_hits_in_B1)),
+                                                    "First Hit in BPIX-L1", params_dr);
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_first_hits_in_B2",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(first_hits_in_B2)),
+                                                    "First Hit in BPIX-L2", params_dr);
+
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_first_hits_in_B1_even_ladder",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(first_hits_in_B1_even_ladder)),
+                                                    "First Hit in BPIX-L1 - Even Ladders", params_dr);
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_first_hits_in_B1_odd_ladder",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(first_hits_in_B1_odd_ladder)),
+                                                    "First Hit in BPIX-L1 - Odd Ladders", params_dr);
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_first_hits_in_B2_even_ladder",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(first_hits_in_B2_even_ladder)),
+                                                    "First Hit in BPIX-L2 - Even Ladders", params_dr);
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_first_hits_in_B2_odd_ladder",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(first_hits_in_B2_odd_ladder)),
+                                                    "First Hit in BPIX-L2 - Odd Ladders", params_dr);
+
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_second_hits_in_B2",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(second_hits_in_B2)),
+                                                    "Second Hit in BPIX-L2", params_dr);
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_second_hits_in_B3",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(second_hits_in_B3)),
+                                                    "Second Hit in BPIX-L3", params_dr);
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_second_hits_in_B4",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(second_hits_in_B4)),
+                                                    "Second Hit in BPIX-L4", params_dr);
+
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_first_hits_in_F1",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(first_hits_in_F1)),
+                                                    "First Hit in FPIX-L1", params_dr);
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_first_hits_in_F2",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(first_hits_in_F2)),
+                                                    "First Hit in FPIX-L2", params_dr);
+
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_second_hits_in_F2",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(second_hits_in_F2)),
+                                                    "Second Hit in FPIX-L2", params_dr);
+    tds.register_container<ContainerTH2Many<float>>("dr_v_eta_second_hits_in_F3",
+                                                    fv::apply(calc_dr_v_eta, fv::tuple(second_hits_in_F3)),
+                                                    "Second Hit in FPIX-L3", params_dr);
+
 
     //Plots for dz of collections defined above
     auto& calc_dz_v_eta = func<pair_vec(vector<HitPair>)>("calc_dz_v_eta",
@@ -317,271 +376,6 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
                                                     "Second Hit in FPIX-L3", params_drho);
 }
 
-void setup_matched_tracks(TrackingDataSet& tds){
-    // Finds sets of (seed, rechit, track, simhit sim_track) where the cycle
-    // track->seed->rec_hit->sim_hit->sim_track->track
-    // is closed
-    auto& find_matched_tracks =
-    func<vector<MatchedTrack>(vector<Seed>,
-                              vector<PixRecHit>,
-                              vector<Track>,
-                              vector<SimHit>,
-                              vector<SimTrack>)>("find_matched_tracks",
-        FUNC(([](const vector<Seed>& seeds,
-                 const vector<PixRecHit> pixrec_hits,
-                 const vector<Track>& tracks,
-                 const vector<SimHit> sim_hits,
-                 const vector<SimTrack> sim_tracks){
-            INFO("New event");
-            INFO(boost::format("Number of tracks is %d, number of seeds is %d, number of hits %d, number of simhits %d")
-                    % tracks.size() % seeds.size() % pixrec_hits.size() % sim_hits.size());
-            vector<MatchedTrack> matched_tracks;
-            for(const Track &track : tracks){
-                const Seed& seed = seeds[track.seedIdx];
-                if( seed.algoOriginal < 0 || seed.algoOriginal >= seedTypes.size()) continue;
-                INFO(boost::format("       seed indx= %d   algorithm= %d   type %s\n")
-                        % track.seedIdx % seed.algoOriginal % seedTypes[seed.algoOriginal]);
-                for(auto tup : boost::combine(seed.hitIdx, seed.hitType)){ //for hits in track's seed
-                    int hitIdx, hitType;
-                    boost::tie(hitIdx, hitType) = tup;
-                    if(hitType != HIT_TYPE_PIXEL) continue; // take only pixel hits for now
-                    const PixRecHit &rec_hit = pixrec_hits[hitIdx];
-
-                    TVector3 recoHitPoint;
-                    recoHitPoint.SetXYZ( rec_hit.x, rec_hit.y, rec_hit.z);
-                    float Rreco = recoHitPoint.Perp();
-                    INFO(boost::format("            hit= %d is in %s-L%d at radius= %f\n")
-                                       % hitIdx % subdet_names[rec_hit.det] % rec_hit.lay % Rreco);
-
-                    for(const int& simHitIdx : rec_hit.simHitIdx){ // for sim-hits matching rec-hit
-                        const SimHit &sim_hit = sim_hits[simHitIdx];
-                        const SimTrack &sim_track = sim_tracks[sim_hit.simTrkIdx];
-                        for(const int &trkIdx : sim_track.trkIdx){ // for tracks matched to this sim_track
-                            if(trkIdx == track.idx){  // sim_track matches with our original track
-                                matched_tracks.push_back({seed, rec_hit, track, sim_hit, sim_track});
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-            return matched_tracks;
-        })));
-
-    fv::apply(find_matched_tracks, fv::tuple(seeds, pixrec_hits, tracks, sim_hits, sim_tracks), "matched_tracks");
-}
-
-void setup_residuals(TrackingDataSet &tds){
-
-    auto matched_tracks = lookup<vector<MatchedTrack>>("matched_tracks");
-
-    // Break matched_tracks into catagories based on Barrel/Endcap and layer
-    auto matched_tracks_B1 = filter(func<bool(MatchedTrack)>("matched_tracks_B1",
-        FUNC(([](const MatchedTrack& matched_track){
-            return in_det(matched_track, PIXEL_BARREL, 1);
-        }))), matched_tracks);
-    auto matched_tracks_B2 = filter(func<bool(MatchedTrack)>("matched_tracks_B2",
-        FUNC(([](const MatchedTrack& matched_track){
-            return in_det(matched_track, PIXEL_BARREL, 2);
-        }))), matched_tracks);
-    auto matched_tracks_B3 = filter(func<bool(MatchedTrack)>("matched_tracks_B3",
-        FUNC(([](const MatchedTrack& matched_track){
-            return in_det(matched_track, PIXEL_BARREL, 3);
-        }))), matched_tracks);
-    auto matched_tracks_B4 = filter(func<bool(MatchedTrack)>("matched_tracks_B4",
-        FUNC(([](const MatchedTrack& matched_track){
-            return in_det(matched_track, PIXEL_BARREL, 4);
-        }))), matched_tracks);
-
-    auto matched_tracks_F1 = filter(func<bool(MatchedTrack)>("matched_tracks_F1",
-        FUNC(([](const MatchedTrack& matched_track){
-            return in_det(matched_track, PIXEL_ENDCAP, 1);
-        }))), matched_tracks);
-    auto matched_tracks_F2 = filter(func<bool(MatchedTrack)>("matched_tracks_F2",
-        FUNC(([](const MatchedTrack& matched_track){
-            return in_det(matched_track, PIXEL_ENDCAP, 2);
-        }))), matched_tracks);
-    auto matched_tracks_F3 = filter(func<bool(MatchedTrack)>("matched_tracks_F3",
-        FUNC(([](const MatchedTrack& matched_track){
-            return in_det(matched_track, PIXEL_ENDCAP, 3);
-        }))), matched_tracks);
-
-
-    TH2Params params = {"$\\eta$",       100, -4,   4,
-                        "Residuals(cm)", 100,  0, .01};
-    auto& calc_residuals_v_eta = func<pair_vec(vector<MatchedTrack>)>("matched_track_hit_residuals",
-        FUNC(([](const vector<MatchedTrack>& matched_tracks){
-            vector<float> residuals;
-            vector<float> etas;
-            for(auto matched_track : matched_tracks){
-                auto& pixrec_hit = std::get<PixRecHit>(matched_track);
-                auto& sim_hit = std::get<SimHit>(matched_track);
-                auto& sim_track = std::get<SimTrack>(matched_track);
-                residuals.push_back(displacement(pixrec_hit, sim_hit));
-                etas.push_back(sim_track.eta);
-            }
-            return std::make_pair(etas, residuals);
-        })));
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_all",
-                                                    fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks)),
-                                                    "Matched Track Residuals - All", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_B1",
-                                                    fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks_B1)),
-                                                    "Matched Track Residuals - B1", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_B2",
-                                                    fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks_B2)),
-                                                    "Matched Track Residuals - B2", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_B3",
-                                                    fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks_B3)),
-                                                    "Matched Track Residuals - B3", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_B4",
-                                                    fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks_B4)),
-                                                    "Matched Track Residuals - B4", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_F1",
-                                                    fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks_F1)),
-                                                    "Matched Track Residuals - F1", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_F2",
-                                                    fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks_F2)),
-                                                    "Matched Track Residuals - F2", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_F3",
-                                                    fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks_F3)),
-                                                    "Matched Track Residuals - F3", params);
-
-
-    params = {"$\\eta$",        100,    -4,    4,
-              "$\\Delta \\phi$(rad)", 100, -.002, .002};
-    auto& calc_dphi_v_eta = func<pair_vec(vector<MatchedTrack>)>("matched_track_hit_dphis",
-        FUNC(([](const vector<MatchedTrack>& matched_tracks){
-            vector<float> dphis;
-            vector<float> etas;
-            for(auto matched_track : matched_tracks){
-                auto& pixrec_hit = std::get<PixRecHit>(matched_track);
-                auto& sim_hit = std::get<SimHit>(matched_track);
-                auto& sim_track = std::get<SimTrack>(matched_track);
-                dphis.push_back(atan2(sim_hit.x, sim_hit.y) - atan2(pixrec_hit.x, pixrec_hit.y));
-                etas.push_back(sim_track.eta);
-            }
-            return std::make_pair(etas, dphis);
-        })));
-
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_all",
-                                                    fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks)),
-                                                    "Matched Track $\\Delta \\phi$ - All", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_B1",
-                                                    fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks_B1)),
-                                                    "Matched Track $\\Delta \\phi$ - B1", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_B2",
-                                                    fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks_B2)),
-                                                    "Matched Track $\\Delta \\phi$ - B2", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_B3",
-                                                    fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks_B3)),
-                                                    "Matched Track $\\Delta \\phi$ - B3", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_B4",
-                                                    fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks_B4)),
-                                                    "Matched Track $\\Delta \\phi$ - B4", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_F1",
-                                                    fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks_F1)),
-                                                    "Matched Track $\\Delta \\phi$ - F1", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_F2",
-                                                    fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks_F2)),
-                                                    "Matched Track $\\Delta \\phi$ - F2", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_F3",
-                                                    fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks_F3)),
-                                                    "Matched Track $\\Delta \\phi$ - F3", params);
-
-
-    auto& calc_dz_v_eta = func<pair_vec(vector<MatchedTrack>)>("matched_track_hit_dphis",
-        FUNC(([](const vector<MatchedTrack>& matched_tracks){
-            vector<float> dzs;
-            vector<float> etas;
-            for(auto matched_track : matched_tracks){
-                auto& pixrec_hit = std::get<PixRecHit>(matched_track);
-                auto& sim_hit = std::get<SimHit>(matched_track);
-                auto& sim_track = std::get<SimTrack>(matched_track);
-                dzs.push_back(sim_hit.z - pixrec_hit.z);
-                etas.push_back(sim_track.eta);
-            }
-            return std::make_pair(etas, dzs);
-        })));
-    params = {"$\\eta$",         100,    -4,    4,
-              "$\\Delta z$(cm)", 100, -.002, .002};
-
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_all",
-                                                    fv::apply(calc_dz_v_eta, fv::tuple(matched_tracks)),
-                                                    "Matched Track $\\Delta z$ - All", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_B1",
-                                                    fv::apply(calc_dz_v_eta, fv::tuple(matched_tracks_B1)),
-                                                    "Matched Track $\\Delta z$ - B1", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_B2",
-                                                    fv::apply(calc_dz_v_eta, fv::tuple(matched_tracks_B2)),
-                                                    "Matched Track $\\Delta z$ - B2", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_B3",
-                                                    fv::apply(calc_dz_v_eta, fv::tuple(matched_tracks_B3)),
-                                                    "Matched Track $\\Delta z$ - B3", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_B4",
-                                                    fv::apply(calc_dz_v_eta, fv::tuple(matched_tracks_B4)),
-                                                    "Matched Track $\\Delta z$ - B4", params);
-
-    auto& calc_dr_v_eta = func<pair_vec(vector<MatchedTrack>)>("matched_track_hit_drs",
-        FUNC(([](const vector<MatchedTrack>& matched_tracks){
-            vector<float> drs;
-            vector<float> etas;
-            for(auto matched_track : matched_tracks){
-                auto& rec_hit = std::get<PixRecHit>(matched_track);
-                auto& sim_hit = std::get<SimHit>(matched_track);
-                float sim_hit_r = sqrt(pow(sim_hit.x, 2) + pow(sim_hit.y, 2));
-                float rec_hit_r = sqrt(pow(rec_hit.x, 2) + pow(rec_hit.y, 2));
-                drs.push_back(sim_hit_r - rec_hit_r);
-                etas.push_back(std::get<SimTrack>(matched_track).eta);
-            }
-            return std::make_pair(etas, drs);
-        })));
-    params = {"$\\eta$",         100,    -4,    4,
-              "$\\Delta r$(cm)", 100, -.002, .002};
-    tds.register_container<ContainerTH2Many<float>>("matched_track_drs_v_eta_F1",
-                                                    fv::apply(calc_dr_v_eta, fv::tuple(matched_tracks_F1)),
-                                                    "Matched Track $\\Delta r$ - F1", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_drs_v_eta_F2",
-                                                    fv::apply(calc_dr_v_eta, fv::tuple(matched_tracks_F2)),
-                                                    "Matched Track $\\Delta r$ - F2", params);
-    tds.register_container<ContainerTH2Many<float>>("matched_track_drs_v_eta_F3",
-                                                    fv::apply(calc_dr_v_eta, fv::tuple(matched_tracks_F3)),
-                                                    "Matched Track $\\Delta r$ - F3", params);
-
-}
-
-void setup_ladder_vs_phi(TrackingDataSet& tds){
-    auto& calc_phi_vs_ladder =
-    func<pair_vec(vector<PixRecHit>, int)>("calc_phi_vs_ladder",
-        FUNC(([](const vector<PixRecHit>& pixrec_hits, int layer){
-            std::vector<float> phis;
-            std::vector<float> ladders;
-            for(const PixRecHit &pixrec_hit : pixrec_hits){
-                if(pixrec_hit.det == PIXEL_BARREL && pixrec_hit.lay == layer){
-                    float phi = pixrec_hit.phi();
-                    unsigned short ladder = pixrec_hit.ladder_blade;
-                    phis.push_back(phi);
-                    ladders.push_back(ladder);
-                    INFO(boost::format("Hit Phi: %7.3f , Hit detID: %8x, Ladder: %d")
-                            % phi % pixrec_hit.detId % ladder);
-                }
-            }
-            return std::make_pair(phis, ladders);
-        })));
-
-    TH2Params params = {"$\\phi$",         100,    -3.14159,    3.14159,
-                        "Ladder Number", 50, 0, 50};
-    tds.register_container<ContainerTH2Many<float>>("rechit_phi_vs_ladder_l1",
-                                                    fv::apply(calc_phi_vs_ladder, fv::tuple(pixrec_hits, constant<int>("1",1))),
-                                                    "phi vs ladder number - Layer 1", params);
-    tds.register_container<ContainerTH2Many<float>>("rechit_phi_vs_ladder_l2",
-                                                    fv::apply(calc_phi_vs_ladder, fv::tuple(pixrec_hits, constant<int>("2",2))),
-                                                    "phi vs ladder number - Layer 2", params);
-    tds.register_container<ContainerTH2Many<float>>("rechit_phi_vs_ladder_l3",
-                                                    fv::apply(calc_phi_vs_ladder, fv::tuple(pixrec_hits, constant<int>("3",3))),
-                                                    "phi vs ladder number - Layer 3", params);
-}
-
 void run_analysis(const vector<fv::util::DataFileDescriptor>& dfds, const string output_filename, bool silent){
     gSystem->Load("libfilval.so");
     auto replace_suffix = [](const std::string& input, const std::string& new_suffix){
@@ -595,11 +389,8 @@ void run_analysis(const vector<fv::util::DataFileDescriptor>& dfds, const string
     /* tds.set_max_events(10); */
     register_objects(tds);
 
-    /* setup_matched_tracks(tds); */
-    /* setup_residuals(tds); */
     setup_first_hit_pairs(tds);
 
-    /* setup_ladder_vs_phi(tds); */
 
     tds.process(silent);
     tds.save_all();
@@ -621,4 +412,5 @@ int main(int argc, char * argv[]){
         cout << "Usage: ./tracking_validation (-s) {-o output_filename} -F datafiles.txt" << endl;
         cout << "       ./tracking_validation (-s) {-l DATA_LABEL} {-o output_filename} -f treefile.root" << endl;
     }
+    return 0;
 }

cmake/FindJupyter.cmake

@@ -6,11 +6,11 @@ SET(JUPYTER_FOUND False)
 IF(NOT ${JUPYTER_EXECUTABLE} MATCHES "JUPYTER_EXECUTABLE-NOTFOUND")
     SET(JUPYTER_FOUND True)
     MESSAGE("-- Found Jupyter: " ${JUPYTER_EXECUTABLE})
-ENDIF(NOT ${JUPYTER_EXECUTABLE} MATCHES "JUPYTER_EXECUTABLE-NOTFOUND")
+ENDIF()
 
 FIND_PROGRAM(NBCONVERT_EXECUTABLE NAMES jupyter-nbconvert)
 SET(NBCONVERT_FOUND False)
 IF(NOT ${NBCONVERT_EXECUTABLE} MATCHES "NBCONVERT_EXECUTABLE-NOTFOUND")
     SET(NBCONVERT_FOUND True)
     MESSAGE("-- Found nbconvert: " ${NBCONVERT_EXECUTABLE})
-ENDIF(NOT ${NBCONVERT_EXECUTABLE} MATCHES "NBCONVERT_EXECUTABLE-NOTFOUND")
+ENDIF()

filval

@@ -1 +1 @@
-Subproject commit 5b8bf13e37a627dae9373e987a22e4a9a2a5101f
+Subproject commit 42affe120ee467f4191ace525f906438d3a296e0