Updates to intro presentaiton and fixed calculation of hit pairs

.gitignore

@@ -2,6 +2,7 @@
 legacy/
 data/
 build/
+env/
 
 tags
 .ipynb_checkpoints/

analysis/tracking_validation.cpp

@@ -38,6 +38,11 @@ float displacement(const A& a, const B& b){
                      pow(a.x-b.x, 2));
 }
 
+template<typename T>
+float rho(const T& t){
+    return std::sqrt(pow(t.x,2)+pow(t.y,2));
+}
+
 bool in_det(const MatchedTrack &mt, int &&det, int &&layer){
     auto& hit = std::get<PixRecHit>(mt);
     return hit.det == det && hit.lay == layer;
@@ -89,23 +94,32 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
     func<vector<HitPair>(vector<Seed>,
                          vector<PixRecHit>,
                          vector<SimHit>,
+                         vector<Track>,
+                         vector<SimTrack>,
                          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 vector<Track>& tracks,
+                 const vector<SimTrack>& sim_tracks,
                  const int&& det,
-                 const int&& bpix_layer,
+                 const int&& pix_layer,
                  const int&& hit_number){
             vector<HitPair> matched_hits;
-            for(const Seed &seed : seeds){ // loop over all seeds
-                if(seed.hitIdx.size() <= hit_number) continue;
+            for(const Track &trk : tracks){ // loop over all tracks
+                const Seed &seed = seeds[trk.seedIdx];
+                if(seed.hitIdx.size() <= hit_number) continue; // looking for hit_number'th hit, which this seed doesn't have
                 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]]});
+                if(rec_hit.det == det && rec_hit.lay == pix_layer){
+                    // We have the RecHit we want to work with, now find a properly* matched SimHit
+                    if(rec_hit.simHitIdx.size() == 0) continue; // if rechit is matched to no simhits, give up.
+                    for(const int &simTrkIdx : trk.simTrkIdx){  // loop over SimTracks matched to Track
+                        for(const int& simHitIdx : sim_tracks[simTrkIdx].simHitIdx){ // loop over SimHits from SimTrack
+                            if(simHitIdx == rec_hit.simHitIdx[0]) // take first matched simhit (should be the closest one)
+                                matched_hits.push_back({rec_hit, sim_hits[rec_hit.simHitIdx[0]]});
+                        }
                     }
                 }
             }
@@ -132,24 +146,27 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
 
     // 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");
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, 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");
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, barrel_val, constant("L2", 2), first_hit), "first_hits_in_B2");
 
     // 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");
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, 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");
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, 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");
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, 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"); */
+    auto first_hits_in_F1 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, endcap_val, constant("L1", 1), first_hit), "first_hits_in_F1");
+    auto first_hits_in_F2 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, endcap_val, constant("L2", 2), first_hit), "first_hits_in_F2");
+
+    auto second_hits_in_F2 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, endcap_val, constant("L2", 2), second_hit), "second_hits_in_F2");
+    auto second_hits_in_F3 = fv::apply(find_matched_nth_hit_in_layer,
+            fv::tuple(seeds, pixrec_hits, sim_hits, tracks, sim_tracks, endcap_val, constant("L3", 3), second_hit), "second_hits_in_F3");
 
     // Even vs Odd Ladders
     auto even = constant("even", false);
@@ -165,11 +182,6 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
     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){
@@ -184,16 +196,13 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
             return std::make_pair(etas, dphis);
         })));
     TH2Params params_dphi = {"$\\eta$",       100, -4,   4,
-                             "$\\Delta \\phi$(rad)", 75,  -.0015, .0015};
+                             "$\\Delta \\phi$(rad)", 50,  -.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)),
@@ -207,12 +216,6 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
     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)),
@@ -224,6 +227,21 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
                                                     fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_B4)),
                                                     "Second Hit in BPIX-L4", params_dphi);
 
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_F1",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_F1)),
+                                                    "First Hit in FPIX-L1", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_first_hits_in_F2",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(first_hits_in_F2)),
+                                                    "First Hit in FPIX-L2", params_dphi);
+
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_second_hits_in_F2",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_F2)),
+                                                    "Second Hit in FPIX-L2", params_dphi);
+    tds.register_container<ContainerTH2Many<float>>("dphi_v_eta_second_hits_in_F3",
+                                                    fv::apply(calc_dphi_v_eta, fv::tuple(second_hits_in_F3)),
+                                                    "Second Hit in FPIX-L3", 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){
@@ -238,16 +256,13 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
             return std::make_pair(etas, dzs);
         })));
     TH2Params params_dz = {"$\\eta$",       100, -4,   4,
-                           "$\\Delta z$(rad)", 100,  -.01, .01};
+                           "$\\Delta z$(rad)", 50,  -.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)),
@@ -261,12 +276,6 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
     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)),
@@ -278,7 +287,34 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
                                                     fv::apply(calc_dz_v_eta, fv::tuple(second_hits_in_B4)),
                                                     "Second Hit in BPIX-L4", params_dz);
 
-
+    //Plots for drho of collections defined above
+    auto& calc_drho_v_eta = func<pair_vec(vector<HitPair>)>("calc_drho_v_eta",
+        FUNC(([](const vector<HitPair>& hit_pairs){
+            vector<float> drhos;
+            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);
+                drhos.push_back(rho(sim_hit) - rho(pixrec_hit));
+                etas.push_back(pseudorapidity(pixrec_hit));
+            }
+            return std::make_pair(etas, drhos);
+        })));
+    TH2Params params_drho = {"$\\eta$",       100, -4,   4,
+                             "$\\Delta \\rho$(cm)", 50,  -.01, .01};
+    tds.register_container<ContainerTH2Many<float>>("drho_v_eta_first_hits_in_F1",
+                                                    fv::apply(calc_drho_v_eta, fv::tuple(first_hits_in_F1)),
+                                                    "First Hit in FPIX-L1", params_drho);
+    tds.register_container<ContainerTH2Many<float>>("drho_v_eta_first_hits_in_F2",
+                                                    fv::apply(calc_drho_v_eta, fv::tuple(first_hits_in_F2)),
+                                                    "First Hit in FPIX-L2", params_drho);
+
+    tds.register_container<ContainerTH2Many<float>>("drho_v_eta_second_hits_in_F2",
+                                                    fv::apply(calc_drho_v_eta, fv::tuple(second_hits_in_F2)),
+                                                    "Second Hit in FPIX-L2", params_drho);
+    tds.register_container<ContainerTH2Many<float>>("drho_v_eta_second_hits_in_F3",
+                                                    fv::apply(calc_drho_v_eta, fv::tuple(second_hits_in_F3)),
+                                                    "Second Hit in FPIX-L3", params_drho);
 }
 
 void setup_matched_tracks(TrackingDataSet& tds){

docs/presentations/2017_07_17/beamerthemebjeldbak.sty

@@ -28,7 +28,7 @@
 }
 
 % \ifnum\c@framenumber=1
-\usebackgroundtemplate{\includegraphics[width=\paperwidth]{16x9_seal03.jpg}}
+\usebackgroundtemplate{\includegraphics[width=1.3\paperwidth]{16x9_seal03.jpg}}
 % \else
 % \fi%
 

docs/presentations/2017_07_17/figures

@@ -0,0 +1 @@
+../../../figures

docs/presentations/2017_07_17/main.tex

@@ -1,7 +1,7 @@
 
 % rubber: module pdftex
 
-\documentclass[english,aspectratio=169]{beamer}
+\documentclass[english,aspectratio=43]{beamer}
 \usepackage{graphicx}
 \usepackage{amssymb}
 \usepackage{booktabs}
@@ -22,7 +22,7 @@
 \title[e Reco. Validation]{Offline Electron Reconstruction Validation}
 \author[C. Fangmeier]{\textbf{Caleb Fangmeier} \\ Ilya Kravchenko,  Greg Snow}
 \institute[UNL]{University of Nebraska \-- Lincoln}
-\date{July 17, 2017}
+\date{July 21, 2017}
 
 \titlegraphic{%
 \begin{figure}
@@ -36,60 +36,108 @@
 
 \begin{frame}{Introduction}
   \begin{itemize}
-    \item Ongoing studies\footnote{\url{https://indico.cern.ch/event/613833/contributions/2646392/attachments/1486134/2307836/EGMHLT_PixelMatching_Jun30.pdf}} in HLT examine the resolution of RecHits used in GSF Tracking
-    \item In those studies, the resolution is computed by measuring the distance between the RecHits and the extrapolated paths from ECAL super-clusters (SCs).
-    \item For offline reconstruction, we compute residuals by comparing the position of RecHits and associated SimHits.
-    \item Knowing these resolutions is important in choosing the size of search windows in the k
+      \item Our goal is to study \textbf{seeding} for the \textbf{offline} gsf tracking with the \textbf{new pixel detector}.
+    \item Ongoing studies\footnote{\url{https://indico.cern.ch/event/613833/contributions/2646392/attachments/1486134/2307836/EGMHLT_PixelMatching_Jun30.pdf}} in HLT examine the resolution of RecHits used in GSF Tracking.
+    \item In those studies, the resolution is computed by measuring the distance between the \textbf{RecHits} and the extrapolated paths from ECAL \textbf{super-clusters} (SCs).
+    \item For \textbf{offline} reconstruction, we compute residuals by comparing the position of \textbf{RecHits} and associated \textbf{SimHits}.
+    \item Knowing these resolutions is important in choosing the size of search windows in the hit matching algorithm used in electron reconstruction.
   \end{itemize}
 \end{frame}
 
 \begin{frame}{Introduction}
   \begin{itemize}
-    \item We use Rafael Lopes de Sa's analysis setup\footnote{\url{https://github.com/rafaellopesdesa/cmssw/tree/ValidationGsfTracks81X}} that is derived from the standard offline tracking reconstruction tool TrackingNtuple from Validation/RecoTrack.
+    \item We use Rafael Lopes de Sa's analysis setup\footnote{\url{https://github.com/rafaellopesdesa/cmssw/tree/ValidationGsfTracks81X}} that is derived from the standard offline tracking reconstruction tool \texttt{TrackingNtuple} from \texttt{Validation/RecoTrack}.
     \item Source dataset: \\ \small \texttt{/DYJetsToLL\_M-50\_TuneCUETP8M1\_13TeV-madgraphMLM-pythia8/\\ PhaseIFall16DR-FlatPU28to62HcalNZSRAW\_81X\_upgrade2017\_realistic\_v26-v1/\\ GEN-SIM-RAW}
     \item Using Release \texttt{CMSSW\_8\_1\_0}
-    \item Figures in this talk use 10829 events (could be re-run with more)
+    \item Figures in this talk use 31790 events (could be re-run with more)
   \end{itemize}
 \end{frame}
 
-\begin{frame}{Hit Resolution \-- $\Delta \phi$}
-  \begin{columns}
-  \begin{column}{0.49\textwidth}
+\begin{frame}{Electron Seeding}
+  TODO: Say a few words about the steps in electron seeding
+\end{frame}
+
+\begin{frame}{TrackingNtuple}
+  The \texttt{TrackingNtuple} format contains (among others) the below crosslinked collections
+  \begin{center}
     \begin{figure}
-      \includegraphics[height=3.8cm]{figures/dphi_matched_hits_from_B1.png}
+      \includegraphics[width=\textwidth]{figures/TrackingNtuple.png}
     \end{figure}
-  \end{column}
-  \begin{column}{0.49\textwidth}
+  \end{center}
+\end{frame}
+
+\begin{frame}{Finding \texttt{SimHit}/\texttt{RecHit} Pairs}
+To find residuals for calculating resolutions, require a pair containing 1
+\texttt{RecHit} and 1 \texttt{SimHit}. Procedure is as follows:
+  \begin{enumerate}
+    \item For each \texttt{Track}, get it's \texttt{Seed} (unique)
+    \item For each \texttt{RecHit} in the \texttt{Seed}, require
+      \begin{itemize}
+        \item It is in the specified subdetector (e.g. BPIX Layer 1)
+        \item It is the 1st/2nd hit in the \texttt{Seed}.
+        \item It is matched to at least one \texttt{SimHit}.
+      \end{itemize}
+    \item For each \texttt{RecHit}(\textbf{B}) passing the above, take the first matched
+      \texttt{SimHit}(\textbf{A}).
+    \item Now look through all \texttt{SimHits} associated with
+      \texttt{SimTracks} associated with the original \texttt{Track}. If
+      \textbf{A} exists in this set. Make a pair of \texttt{SimHit} \textbf{A}
+      and \texttt{RecHit} \textbf{B}.
+    \item Go back to 1.
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}{BPIX Hit 1 Resolution}
     \begin{figure}
-      \includegraphics[height=3.8cm]{figures/dphi_matched_hits_from_B2.png}
+      \centering
+      \includegraphics[height=0.8\textheight]{figures/first_hits.png}
     \end{figure}
-  \end{column}
-  \end{columns}
-  \hrule \vspace{.2cm}
-  $\Delta \phi$ betwen RecHits and SimHits for innermost hits in seeds where that hit is in BPIX Layer 1/2.
 \end{frame}
 
-\begin{frame}{Hit Resolution \-- $\Delta z$}
-  \begin{columns}
-  \begin{column}{0.49\textwidth}
+\begin{frame}{BPIX Hit 1 Resolution vs. $\eta$}
     \begin{figure}
-      \includegraphics[height=3.8cm]{figures/dz_matched_hits_from_B1.png}
+      \centering
+      \includegraphics[height=0.8\textheight]{figures/first_hits_v_eta.png}
     \end{figure}
-  \end{column}
-  \begin{column}{0.49\textwidth}
+\end{frame}
+
+\begin{frame}{BPIX Hit 2 Resolution}
     \begin{figure}
-      \includegraphics[height=3.8cm]{figures/dz_matched_hits_from_B2.png}
+      \centering
+      \includegraphics[height=0.8\textheight]{figures/second_hits.png}
     \end{figure}
-  \end{column}
-  \end{columns}
-  \hrule \vspace{.2cm}
-  $\Delta z$ betwen RecHits and SimHits for innermost hits in seeds where that hit is in BPIX Layer 1/2.
 \end{frame}
 
+\begin{frame}{BPIX Hit 2 Resolution vs. $\eta$}
+    \begin{figure}
+      \centering
+      \includegraphics[height=0.8\textheight]{figures/second_hits_v_eta.png}
+    \end{figure}
+\end{frame}
+
+\begin{frame}{Resolution dependence on even/odd ladder number}
+    \begin{figure}
+      \centering
+      \includegraphics[height=0.8\textheight]{figures/delta_phi_z_v_ladder.png}
+    \end{figure}
+\end{frame}
+
+
 \begin{frame}{Conclusions}
   \begin{itemize}
-    \item Code for this analysis is here: \\ \small \begin{center}\url{https://git.fangmeier.tech/caleb/EGamma_ElectronTrackingValidation}\end{center}
-    \item What specific figures/measurements are of interest to experts?
+    \item Analysis machinery for offline electron reco studies with MC truth is in place.
+    \item Preliminary plots of $\Delta\phi_{1/2}$ and $\Delta z_{1/2}$ for BPIX
+      Layers 1/2 are shown.
+    \item Code for this analysis is here: \\ \footnotesize
+      \begin{center}\url{git.fangmeier.tech/caleb/EGamma\_ElectronTrackingValidation}\end{center}
+    \item  next to come
+      \begin{itemize}
+        \item run on larger event samples (\texttt{trackingNtuples} are generated, just need to use)
+        \item include FPIX
+        \item investigate reasons for rec hit inefficiencies
+        \item introduce triplet-based pixel matching for the seeds and repeat the studies
+      \end{itemize}
+    % \item What specific figures/measurements are of interest to experts?
   \end{itemize}
 \end{frame}
 

filval

@@ -1 +1 @@
-Subproject commit 27cc0b9b63df0c4211290cee1cb77568e88ca5c7
+Subproject commit 5b8bf13e37a627dae9373e987a22e4a9a2a5101f