Updates to 2017_07_17 presentation and addition of EGamma studies jupyter nb

.gitignore

@@ -4,3 +4,4 @@ data/
 build/
 
 tags
+.ipynb_checkpoints/

analysis/tracking_validation.cpp

@@ -1,5 +1,6 @@
 #include <iostream>
 #include <vector>
+#include <map>
 #include <utility>
 #include <numeric>
 #include <limits>
@@ -19,8 +20,6 @@ using namespace std;
 using namespace fv;
 using namespace fv::root;
 
-using namespace std;
-
 typedef std::tuple<Seed, PixRecHit, Track, SimHit, SimTrack> MatchedTrack;
 typedef std::pair<std::vector<float>,std::vector<float>> pair_vec;
 
@@ -30,7 +29,7 @@ typedef std::pair<std::vector<float>,std::vector<float>> pair_vec;
 
 #define PIXEL_BARREL 1
 #define PIXEL_ENDCAP 2
-vector<string> subdet_names = {"", "BPIX", "FPIX"};
+std::map<int,string> subdet_names = {{1, "BPIX"}, {2, "FPIX"}};
 
 template<typename A, typename B>
 float displacement(const A& a, const B& b){
@@ -112,12 +111,28 @@ void setup_first_hit_pairs(TrackingDataSet& tds){
             return atan2(rec_hit.x, rec_hit.y) - atan2(sim_hit.x, sim_hit.y);
         })));
 
-    tds.register_container<ContainerTH1Many<float>>("matched_hits_from_B1", "Matched Hits dPhi - B1",
+    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),
-                                                    100, -0.001, 0.001,"dPhi(rad)");
-    tds.register_container<ContainerTH1Many<float>>("matched_hits_from_B2", "Matched Hits dPhi - B2",
+                                                    "Matched Hits $\\Delta \\phi$ - B1", params);
+    tds.register_container<ContainerTH1Many<float>>("dphi_matched_hits_from_B2",
                                                     fv::map(calc_dphi, first_hits_in_B2),
-                                                    100, -0.001, 0.001,"dPhi(rad)");
+                                                    "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;
+        })));
+
+    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){
@@ -211,6 +226,8 @@ void setup_residuals(TrackingDataSet &tds){
         }))), 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;
@@ -224,31 +241,34 @@ void setup_residuals(TrackingDataSet &tds){
             }
             return std::make_pair(etas, residuals);
         })));
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_all", "Matched Track Residuals - All",
+    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_all",
                                                     fv::apply(calc_residuals_v_eta, fv::tuple(matched_tracks)),
-                                                    100, -4, 4, 100, 0, .01,"Eta","Residuals(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_B1", "Matched Track Residuals - B1",
+                                                    "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)),
-                                                    100, -4, 4, 100, 0, .01,"Eta","Residuals(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_B2", "Matched Track Residuals - B2",
+                                                    "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)),
-                                                    100, -4, 4, 100, 0, .01,"Eta","Residuals(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_B3", "Matched Track Residuals - B3",
+                                                    "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)),
-                                                    100, -4, 4, 100, 0, .01,"Eta","Residuals(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_B4", "Matched Track Residuals - B4",
+                                                    "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)),
-                                                    100, -4, 4, 100, 0, .01,"Eta","Residuals(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_F1", "Matched Track Residuals - F1",
+                                                    "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)),
-                                                    100, -4, 4, 100, 0, .01,"Eta","Residuals(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_F2", "Matched Track Residuals - F2",
+                                                    "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)),
-                                                    100, -4, 4, 100, 0, .01,"Eta","Residuals(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_residuals_v_eta_F3", "Matched Track Residuals - F3",
+                                                    "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)),
-                                                    100, -4, 4, 100, 0, .01,"Eta","Residuals(cm)");
+                                                    "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;
@@ -262,30 +282,31 @@ void setup_residuals(TrackingDataSet &tds){
             }
             return std::make_pair(etas, dphis);
         })));
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_all", "Matched Track dphis - All",
+
+    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_all",
                                                     fv::apply(calc_dphi_v_eta, fv::tuple(matched_tracks)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","Residuals(rad)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_B1",  "Matched Track dphis - B1",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dphis(rad)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_B2",  "Matched Track dphis - B2",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dphis(rad)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_B3",  "Matched Track dphis - B3",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dphis(rad)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_B4",  "Matched Track dphis - B4",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dphis(rad)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_F1",  "Matched Track dphis - F1",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dphis(rad)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_F2",  "Matched Track dphis - F2",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dphis(rad)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dphis_v_eta_F3",  "Matched Track dphis - F3",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dphis(rad)");
+                                                    "Matched Track $\\Delta \\phi$ - F3", params);
 
 
     auto& calc_dz_v_eta = func<pair_vec(vector<MatchedTrack>)>("matched_track_hit_dphis",
@@ -301,21 +322,25 @@ void setup_residuals(TrackingDataSet &tds){
             }
             return std::make_pair(etas, dzs);
         })));
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_all", "Matched Track dz - All",
+    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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dz(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_B1", "Matched Track dz - B1",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dz(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_B2", "Matched Track dz - B2",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dz(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_B3", "Matched Track dz - B3",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dz(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_dzs_v_eta_B4", "Matched Track dz - B4",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dz(cm)");
+                                                    "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;
@@ -330,17 +355,21 @@ void setup_residuals(TrackingDataSet &tds){
             }
             return std::make_pair(etas, drs);
         })));
-    tds.register_container<ContainerTH2Many<float>>("matched_track_drs_v_eta_F1", "Matched Track dz - F1",
+    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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dr(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_drs_v_eta_F2", "Matched Track dz - F2",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dr(cm)");
-    tds.register_container<ContainerTH2Many<float>>("matched_track_drs_v_eta_F3", "Matched Track dz - F3",
+                                                    "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)),
-                                                    100, -4, 4, 100, -.002, .002,"Eta","dr(cm)");
+                                                    "Matched Track $\\Delta r$ - F3", 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){

docs/presentations/2017_07_17/main.tex

@@ -8,6 +8,7 @@
 \usepackage{siunitx}
 \usepackage{subcaption}
 \usepackage{marvosym}
+\usepackage{verbatim}
 
 \newcommand{\pb}{\si{\pico\barn}}%
 \newcommand{\fb}{\si{\femto\barn}}%
@@ -18,9 +19,8 @@
 
 \begin{document}
 
-\title[e Reco. Valication]{Electron Reconstruction Validation}
-% \subtitle{Trilepton Channel ($\mu^+\mu^-e, e^+e^-\mu$) }
-\author[C. Fangmeier]{Caleb Fangmeier}
+\title[e Reco. Validation]{Offline Electron Reconstruction Validation}
+\author[C. Fangmeier]{\textbf{Caleb Fangmeier}\\ Ilya Kravchenko}
 \institute[UNL]{University of Nebraska \-- Lincoln}
 \date{\today}
 
@@ -34,42 +34,62 @@
   \titlepage%
 \end{frame}
 
-\section{Introduction}
-% \input{slides/introduction.tex}
-% \input{slides/decay_channels_rates.tex}
-
-
-
-
-% \section{Strategy}
-% \input{slides/strategy.tex}
-% \input{slides/irreducible_backgrounds.tex}
-% \input{slides/reducible_backgrounds.tex}
-
-
-
-% \section{Some Preliminary Plots}
-% \input{slides/progress_and_status.tex}
-% \input{slides/prelim_plots.tex}
-
-% \section{Timeline}
-% \input{slides/timeline.tex}
-
-% \input{slides/references.tex}
+\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.
+  \end{itemize}
+\end{frame}
 
-% \beginbackup%
-% \section{Backups}
+\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 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)
+  \end{itemize}
+\end{frame}
 
-% \begin{frame}
-%   \huge
-%   \centering
-%   Backups
-% \end{frame}
+\begin{frame}{Preliminary Results}
+  \begin{columns}
+  \begin{column}{0.49\textwidth}
+    \begin{figure}
+      \includegraphics[height=3.8cm]{figures/dphi_matched_hits_from_B1.png}
+    \end{figure}
+  \end{column}
+  \begin{column}{0.49\textwidth}
+    \begin{figure}
+      \includegraphics[height=3.8cm]{figures/dphi_matched_hits_from_B2.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}
 
-% \input{slides/production.tex}
-% \input{slides/decay_channels.tex}
-% \input{slides/previous_measurements.tex}
+\begin{frame}{Preliminary Results}
+  \begin{columns}
+  \begin{column}{0.49\textwidth}
+    \begin{figure}
+      \includegraphics[height=3.8cm]{figures/dz_matched_hits_from_B1.png}
+    \end{figure}
+  \end{column}
+  \begin{column}{0.49\textwidth}
+    \begin{figure}
+      \includegraphics[height=3.8cm]{figures/dz_matched_hits_from_B2.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}
 
-% \endbackup%
+\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?
+  \end{itemize}
+\end{frame}
 
 \end{document}

filval

@@ -1 +1 @@
-Subproject commit 8801955c960c7fa3b9e3ea5a5e06ea4655c757a6
+Subproject commit 40f53a4a6b63a4d2cd45c416ad8d1eabdbf594b0