Adds updates TrackingNtuple which now contains ladder/blade information

on rechits. New plots demonstrating this.

CMakeLists.txt

@@ -23,7 +23,7 @@ SET (CMAKE_CXX_COMPILER             "/usr/bin/clang++")
 SET (CMAKE_CXX_FLAGS                "-Wall")
 SET (CMAKE_CXX_FLAGS_DEBUG          "-g")
 SET (CMAKE_CXX_FLAGS_MINSIZEREL     "-Os -DNDEBUG")
-SET (CMAKE_CXX_FLAGS_RELEASE        "-O3 -DNDEBUG")
+SET (CMAKE_CXX_FLAGS_RELEASE        "-Ofast -DNDEBUG")
 SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g")
 
 SET (CMAKE_AR      "/usr/bin/llvm-ar")

analysis/TrackingNtuple.h

@@ -110,6 +110,7 @@ public :
    vector<short>   *pix_isBarrel;
    vector<unsigned short> *pix_det;
    vector<unsigned short> *pix_lay;
+   vector<unsigned short> *pix_ladder_blade;
    vector<unsigned int> *pix_detId;
    vector<vector<int> > *pix_trkIdx;
    vector<vector<int> > *pix_seeIdx;
@@ -378,6 +379,7 @@ public :
    TBranch        *b_pix_isBarrel;   //!
    TBranch        *b_pix_det;   //!
    TBranch        *b_pix_lay;   //!
+   TBranch        *b_pix_ladder_blade;   //!
    TBranch        *b_pix_detId;   //!
    TBranch        *b_pix_trkIdx;   //!
    TBranch        *b_pix_seeIdx;   //!
@@ -704,6 +706,7 @@ void TrackingNtuple::Init(TTree *tree)
    pix_isBarrel = 0;
    pix_det = 0;
    pix_lay = 0;
+   pix_ladder_blade = 0;
    pix_detId = 0;
    pix_trkIdx = 0;
    pix_seeIdx = 0;
@@ -970,6 +973,7 @@ void TrackingNtuple::Init(TTree *tree)
    fChain->SetBranchAddress("pix_isBarrel", &pix_isBarrel, &b_pix_isBarrel);
    fChain->SetBranchAddress("pix_det", &pix_det, &b_pix_det);
    fChain->SetBranchAddress("pix_lay", &pix_lay, &b_pix_lay);
+   fChain->SetBranchAddress("pix_ladder_blade", &pix_ladder_blade, &b_pix_ladder_blade);
    fChain->SetBranchAddress("pix_detId", &pix_detId, &b_pix_detId);
    fChain->SetBranchAddress("pix_trkIdx", &pix_trkIdx, &b_pix_trkIdx);
    fChain->SetBranchAddress("pix_seeIdx", &pix_seeIdx, &b_pix_seeIdx);

analysis/obj_types.cpp

@@ -1,6 +1,8 @@
 #include "filval/filval.hpp"
 #include "filval/root/filval.hpp"
 
+#include<cmath>
+
 #include "TrackingNtuple.h"
 
 using namespace std;
@@ -18,6 +20,7 @@ struct PixRecHit {
     unsigned int   idx;
     unsigned short det;
     unsigned short lay;
+    unsigned short ladder_blade;
     unsigned int   detId;
     unsigned short simType;
     float          x;
@@ -35,11 +38,16 @@ struct PixRecHit {
     vector<int>    seeIdx;
     vector<int>    simHitIdx;
     vector<float>  chargeFraction;
+
+    float phi() const {
+        return atan2(x, y);
+    }
 };
 
 Value<vector<PixRecHit>>*
 register_pixrec_hits(TrackingDataSet &tds){
     auto& builder = func<std::vector<PixRecHit>(vector<unsigned short>,
+                                                vector<unsigned short>,
                                                 vector<unsigned short>,
                                                 vector<unsigned int>,
                                                 vector<unsigned short>,
@@ -60,6 +68,7 @@ register_pixrec_hits(TrackingDataSet &tds){
                                                 vector<vector<float>>)>("build_pixrec_hits",
         FUNC(([](const vector<unsigned short>& det,
                  const vector<unsigned short>& lay,
+                 const vector<unsigned short>& ladder_blade,
                  const vector<unsigned int>&   detId,
                  const vector<unsigned short>& simType,
                  const vector<float>& x,
@@ -82,6 +91,7 @@ register_pixrec_hits(TrackingDataSet &tds){
                 pixrec_hits.push_back({i,
                                        det[i],
                                        lay[i],
+                                       ladder_blade[i],
                                        detId[i],
                                        simType[i],
                                        x[i],
@@ -107,6 +117,7 @@ register_pixrec_hits(TrackingDataSet &tds){
     return apply(builder,
         fv::tuple(tds.track_branch_obj<vector<unsigned short>>("pix_det"),
                   tds.track_branch_obj<vector<unsigned short>>("pix_lay"),
+                  tds.track_branch_obj<vector<unsigned short>>("pix_ladder_blade"),
                   tds.track_branch_obj<vector<unsigned int>>("pix_detId"),
                   tds.track_branch_obj<vector<unsigned short>>("pix_simType"),
                   tds.track_branch_obj<vector<float>>("pix_x"),

analysis/tracking_validation.cpp

@@ -43,6 +43,18 @@ bool in_det(const MatchedTrack &mt, int &&det, int &&layer){
     return hit.det == det && hit.lay == layer;
 };
 
+float pseudorapidity(float z, float r){
+    float theta = atan2(r, z);
+    return -log(tan(theta/2.0));
+}
+float pseudorapidity(float x, float y, float z){
+    float r = sqrt(x*x + y*y);
+    return pseudorapidity(z, r);
+}
+template<typename T>
+float pseudorapidity(const T &t){
+    return pseudorapidity(t.x, t.y, t.z);
+}
 
 
 vector<string> seedTypes =
@@ -71,68 +83,202 @@ void register_objects(TrackingDataSet& tds){
 }
 
 void setup_first_hit_pairs(TrackingDataSet& tds){
-    // Finds pairs of (rechit, simhit) where the rechit is the innermost hit on
-    // a seed in a particular barrel layer.
     typedef std::tuple<PixRecHit, SimHit> HitPair;
-    auto& matched_hits_in_layer =
+
+    auto& find_matched_nth_hit_in_layer =
     func<vector<HitPair>(vector<Seed>,
                          vector<PixRecHit>,
-                         vector<SimHit>, int)>("find_matched_innermost_hits_in_layer",
+                         vector<SimHit>,
+                         int, int, int)>("find_matched_nth_hit_in_layer",
         FUNC(([](const vector<Seed>& seeds,
                  const vector<PixRecHit>& pixrec_hits,
                  const vector<SimHit>& sim_hits,
-                 const int&& bpix_layer){
+                 const int&& det,
+                 const int&& bpix_layer,
+                 const int&& hit_number){
             vector<HitPair> matched_hits;
-            for(const Seed &seed : seeds){
-                if( seed.algoOriginal < 0 || seed.algoOriginal >= seedTypes.size()) continue;
-                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];
-                    if(rec_hit.det == PIXEL_BARREL && rec_hit.lay == bpix_layer){
-                        if(rec_hit.simHitIdx.size() > 0){
-                            matched_hits.push_back({rec_hit, sim_hits[rec_hit.simHitIdx[0]]});
-                        }
+            for(const Seed &seed : seeds){ // loop over all seeds
+                if(seed.hitIdx.size() <= hit_number) continue;
+                if(seed.algoOriginal < 0 || seed.algoOriginal >= seedTypes.size()) continue;
+                if(seed.hitType[hit_number] != HIT_TYPE_PIXEL) continue; // take only pixel hits for now
+                const PixRecHit &rec_hit = pixrec_hits[seed.hitIdx[hit_number]];
+                if(rec_hit.det == det && rec_hit.lay == bpix_layer){
+                    if(rec_hit.simHitIdx.size() > 0){
+                        // take first matched simhit (should be the closest one)
+                        matched_hits.push_back({rec_hit, sim_hits[rec_hit.simHitIdx[0]]});
                     }
-                    break;
                 }
             }
             return matched_hits;
         })));
 
-    auto first_hits_in_B1 = fv::apply(matched_hits_in_layer, fv::tuple(seeds, pixrec_hits, sim_hits, constant("1", 1)), "first_hits_in_B1");
-    auto first_hits_in_B2 = fv::apply(matched_hits_in_layer, fv::tuple(seeds, pixrec_hits, sim_hits, constant("2", 2)), "first_hits_in_B2");
-
-    auto& calc_dphi = func<float(HitPair)>("calc_dphi",
-        FUNC(([](const HitPair& hit_pair){
-            const auto &rec_hit = std::get<PixRecHit>(hit_pair);
-            const auto &sim_hit = std::get<SimHit>(hit_pair);
-            return atan2(rec_hit.x, rec_hit.y) - atan2(sim_hit.x, sim_hit.y);
+    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;
         })));
 
-    TH1Params params = {"$\\Delta \\phi$(rad)", 50, -0.001, 0.001, ""};
-    tds.register_container<ContainerTH1Many<float>>("dphi_matched_hits_from_B1",
-                                                    fv::map(calc_dphi, first_hits_in_B1),
-                                                    "Matched Hits $\\Delta \\phi$ - B1", params);
-    tds.register_container<ContainerTH1Many<float>>("dphi_matched_hits_from_B2",
-                                                    fv::map(calc_dphi, first_hits_in_B2),
-                                                    "Matched Hits $\\Delta \\phi$ - B2", params);
-
-    auto& calc_dz = func<float(HitPair)>("calc_dz",
-        FUNC(([](const HitPair& hit_pair){
-            const auto &rec_hit = std::get<PixRecHit>(hit_pair);
-            const auto &sim_hit = std::get<SimHit>(hit_pair);
-            return rec_hit.z - sim_hit.z;
+    auto barrel_val = constant("PIXEL_BARREL", PIXEL_BARREL);
+    auto endcap_val = constant("PIXEL_ENDCAP", PIXEL_ENDCAP);
+    auto first_hit  = constant("1st", 0);
+    auto second_hit = constant("2nd", 1);
+
+    // First hits on inner three bpix layers
+    auto first_hits_in_B1 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L1", 1), first_hit), "first_hits_in_B1");
+    auto first_hits_in_B2 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L2", 2), first_hit), "first_hits_in_B2");
+    auto first_hits_in_B3 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L3", 3), first_hit), "first_hits_in_B3");
+
+    // Second hits on outer three bpix layers
+    auto second_hits_in_B2 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L2", 2), second_hit), "second_hits_in_B2");
+    auto second_hits_in_B3 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L3", 3), second_hit), "second_hits_in_B3");
+    auto second_hits_in_B4 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, barrel_val, constant("L4", 4), second_hit), "second_hits_in_B4");
+
+    /* auto first_hits_in_F1 = fv::apply(find_matched_nth_hit_in_layer, */
+    /*         fv::tuple(seeds, pixrec_hits, sim_hits, endcap_val, constant("1", 1)), "first_hits_in_F1"); */
+    /* auto first_hits_in_F2 = fv::apply(find_matched_nth_hit_in_layer, */
+    /*         fv::tuple(seeds, pixrec_hits, sim_hits, endcap_val, constant("2", 2)), "first_hits_in_F2"); */
+
+    // Even vs Odd Ladders
+    auto even = constant("even", false);
+    auto odd = constant("odd", true);
+
+    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,
+            fv::tuple(first_hits_in_B1, odd), "first_hits_in_B1_odd_ladder");
+
+    auto first_hits_in_B2_even_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
+            fv::tuple(first_hits_in_B2, even), "first_hits_in_B2_even_ladder");
+    auto first_hits_in_B2_odd_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
+            fv::tuple(first_hits_in_B2, odd), "first_hits_in_B2_odd_ladder");
+
+    auto first_hits_in_B3_even_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
+            fv::tuple(first_hits_in_B3, even), "first_hits_in_B3_even_ladder");
+    auto first_hits_in_B3_odd_ladder = fv::apply(select_even_odd_ladder_blade_hit_pairs,
+            fv::tuple(first_hits_in_B3, odd), "first_hits_in_B3_odd_ladder");
+
+    //Plots for dPhi of collections defined above
+    auto& calc_dphi_v_eta = func<pair_vec(vector<HitPair>)>("calc_dphi_v_eta",
+        FUNC(([](const vector<HitPair>& hit_pairs){
+            vector<float> dphis;
+            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);
+                dphis.push_back(atan2(sim_hit.x, sim_hit.y) - atan2(pixrec_hit.x, pixrec_hit.y));
+                etas.push_back(pseudorapidity(pixrec_hit));
+            }
+            return std::make_pair(etas, dphis);
+        })));
+    TH2Params params_dphi = {"$\\eta$",       100, -4,   4,
+                             "$\\Delta \\phi$(rad)", 75,  -.0015, .0015};
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B1",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B1)),
+                                                    "First Hit in BPIX-L1", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B2",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B2)),
+                                                    "First Hit in BPIX-L2", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B3",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B3)),
+                                                    "First Hit in BPIX-L3", params_dphi);
+
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B1_even_ladder",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B1_even_ladder)),
+                                                    "First Hit in BPIX-L1 - Even Ladders", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B1_odd_ladder",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B1_odd_ladder)),
+                                                    "First Hit in BPIX-L1 - Odd Ladders", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B2_even_ladder",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B2_even_ladder)),
+                                                    "First Hit in BPIX-L2 - Even Ladders", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B2_odd_ladder",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B2_odd_ladder)),
+                                                    "First Hit in BPIX-L2 - Odd Ladders", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B3_even_ladder",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B3_even_ladder)),
+                                                    "First Hit in BPIX-L3 - Even Ladders", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_B3_odd_ladder",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_B3_odd_ladder)),
+                                                    "First Hit in BPIX-L3 - Odd Ladders", params_dphi);
+
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_second_hits_in_B2",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_B2)),
+                                                    "Second Hit in BPIX-L2", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_second_hits_in_B3",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_B3)),
+                                                    "Second Hit in BPIX-L3", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_second_hits_in_B4",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_B4)),
+                                                    "Second Hit in BPIX-L4", params_dphi);
+
+    //Plots for dz of collections defined above
+    auto& calc_dz_v_eta = func<pair_vec(vector<HitPair>)>("calc_dz_v_eta",
+        FUNC(([](const vector<HitPair>& hit_pairs){
+            vector<float> dzs;
+            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);
+                dzs.push_back(sim_hit.z - pixrec_hit.z);
+                etas.push_back(pseudorapidity(pixrec_hit));
+            }
+            return std::make_pair(etas, dzs);
         })));
+    TH2Params params_dz = {"$\\eta$",       100, -4,   4,
+                           "$\\Delta z$(rad)", 100,  -.01, .01};
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B1",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B1)),
+                                                    "First Hit in BPIX-L1", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B2",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B2)),
+                                                    "First Hit in BPIX-L2", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B3",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B3)),
+                                                    "First Hit in BPIX-L3", params_dz);
+
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B1_even_ladder",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B1_even_ladder)),
+                                                    "First Hit in BPIX-L1 - Even Ladders", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B1_odd_ladder",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B1_odd_ladder)),
+                                                    "First Hit in BPIX-L1 - Odd Ladders", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B2_even_ladder",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B2_even_ladder)),
+                                                    "First Hit in BPIX-L2 - Even Ladders", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B2_odd_ladder",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B2_odd_ladder)),
+                                                    "First Hit in BPIX-L2 - Odd Ladders", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B3_even_ladder",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B3_even_ladder)),
+                                                    "First Hit in BPIX-L3 - Even Ladders", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_first_hits_in_B3_odd_ladder",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(first_hits_in_B3_odd_ladder)),
+                                                    "First Hit in BPIX-L3 - Odd Ladders", params_dz);
+
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_second_hits_in_B2",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(second_hits_in_B2)),
+                                                    "Second Hit in BPIX-L2", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_second_hits_in_B3",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(second_hits_in_B3)),
+                                                    "Second Hit in BPIX-L3", params_dz);
+    tds.register_container<ContainerTH2Many<float>>("dz_v_eta_second_hits_in_B4",
+                                                    fv::apply(calc_dz_v_eta, fv::tuple(second_hits_in_B4)),
+                                                    "Second Hit in BPIX-L4", params_dz);
+
 
-    params = {"$\\Delta z$", 50, -0.01, 0.01, ""};
-    tds.register_container<ContainerTH1Many<float>>("dz_matched_hits_from_B1",
-                                                    fv::map(calc_dz, first_hits_in_B1),
-                                                    "Matched Hits $\\Delta z$ - B1", params);
-    tds.register_container<ContainerTH1Many<float>>("dz_matched_hits_from_B2",
-                                                    fv::map(calc_dz, first_hits_in_B2),
-                                                    "Matched Hits $\\Delta z$ - B2", params);
 }
 
 void setup_matched_tracks(TrackingDataSet& tds){
@@ -191,7 +337,6 @@ void setup_matched_tracks(TrackingDataSet& tds){
 
 void setup_residuals(TrackingDataSet &tds){
 
-
     auto matched_tracks = lookup<vector<MatchedTrack>>("matched_tracks");
 
     // Break matched_tracks into catagories based on Barrel/Endcap and layer
@@ -369,6 +514,37 @@ void setup_residuals(TrackingDataSet &tds){
 
 }
 
+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");
@@ -377,16 +553,18 @@ void run_analysis(const vector<fv::util::DataFileDescriptor>& dfds, const string
     };
 
     string log_filename = replace_suffix(output_filename, ".log");
-    fv::util::Log::init_logger(log_filename, fv::util::LogPriority::kLogDebug);
+    fv::util::Log::init_logger(log_filename, fv::util::LogPriority::kLogInfo);
 
     TrackingDataSet tds(output_filename, dfds, "trackingNtuple/tree");
     /* tds.set_max_events(10); */
     register_objects(tds);
 
-    setup_matched_tracks(tds);
-    setup_residuals(tds);
+    /* setup_matched_tracks(tds); */
+    /* setup_residuals(tds); */
     setup_first_hit_pairs(tds);
 
+    /* setup_ladder_vs_phi(tds); */
+
     tds.process(silent);
     tds.save_all();
 }

docs/presentations/2017_07_17/main.tex

@@ -20,7 +20,7 @@
 \begin{document}
 
 \title[e Reco. Validation]{Offline Electron Reconstruction Validation}
-\author[C. Fangmeier]{\textbf{Caleb Fangmeier}\\ Ilya Kravchenko}
+\author[C. Fangmeier]{\textbf{Caleb Fangmeier} \\ Ilya Kravchenko,  Greg Snow}
 \institute[UNL]{University of Nebraska \-- Lincoln}
 \date{July 17, 2017}
 
@@ -52,7 +52,7 @@
   \end{itemize}
 \end{frame}
 
-\begin{frame}{Preliminary Results}
+\begin{frame}{Hit Resolution \-- $\Delta \phi$}
   \begin{columns}
   \begin{column}{0.49\textwidth}
     \begin{figure}
@@ -69,7 +69,7 @@
   $\Delta \phi$ betwen RecHits and SimHits for innermost hits in seeds where that hit is in BPIX Layer 1/2.
 \end{frame}
 
-\begin{frame}{Preliminary Results}
+\begin{frame}{Hit Resolution \-- $\Delta z$}
   \begin{columns}
   \begin{column}{0.49\textwidth}
     \begin{figure}

filval

@@ -1 +1 @@
-Subproject commit 40f53a4a6b63a4d2cd45c416ad8d1eabdbf594b0
+Subproject commit 27cc0b9b63df0c4211290cee1cb77568e88ca5c7