|
|
@@ -2,6 +2,7 @@
|
|
|
#include <vector>
|
|
|
#include <cmath>
|
|
|
#include <numeric>
|
|
|
+#include <utility>
|
|
|
#include <TSystem.h>
|
|
|
#include <Math/VectorUtil.h>
|
|
|
|
|
|
@@ -11,6 +12,9 @@
|
|
|
|
|
|
#include "analysis/TrackingNtupleObjs.hpp"
|
|
|
|
|
|
+const double pi = 3.1415926535897932384626;
|
|
|
+const double pi2 = 2*pi;
|
|
|
+
|
|
|
typedef ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float>> Vec4;
|
|
|
|
|
|
SeedCollection seeds;
|
|
|
@@ -22,6 +26,13 @@ SuperClusterCollection scls;
|
|
|
|
|
|
std::vector<SimTrack> sim_els;
|
|
|
|
|
|
+Value<float>* truePileup;
|
|
|
+Value<int>* inTimePileup;
|
|
|
+/* Value<vector<int>>* outOfTimePileup; */
|
|
|
+
|
|
|
+/* Value<vector<unsigned int>>* totalSeedsAlgo; */
|
|
|
+Value<unsigned int>* totalSeeds;
|
|
|
+
|
|
|
void register_objects(TrackingDataSet& tds){
|
|
|
seeds.init(&tds);
|
|
|
gens.init(&tds);
|
|
|
@@ -40,13 +51,72 @@ struct {
|
|
|
Value<float>* sigma_z;
|
|
|
} bs;
|
|
|
|
|
|
-template <typename T>
|
|
|
+struct EffColl {
|
|
|
+ EfficiencyContainer<float>* pt;
|
|
|
+ EfficiencyContainer<float>* eta;
|
|
|
+ EfficiencyContainer<float>* phi;
|
|
|
+ EffColl(TrackingDataSet& tds, const std::string& pfx,
|
|
|
+ THParams pt_params, THParams eta_params, THParams phi_params,
|
|
|
+ const std::string& sfx="") {
|
|
|
+ std::string _sfx = "";
|
|
|
+ if (sfx != "") _sfx = "_"+sfx;
|
|
|
+
|
|
|
+ pt = tds.register_container<EfficiencyContainer<float>>(pfx+"_v_pt"+_sfx, pt_params);
|
|
|
+ eta = tds.register_container<EfficiencyContainer<float>>(pfx+"_v_eta"+_sfx, eta_params);
|
|
|
+ phi = tds.register_container<EfficiencyContainer<float>>(pfx+"_v_phi"+_sfx, phi_params);
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
struct KinColl {
|
|
|
- T* pt;
|
|
|
- T* eta;
|
|
|
- T* phi;
|
|
|
+ ContainerTH1<float>* pt;
|
|
|
+ ContainerTH1<float>* eta;
|
|
|
+ ContainerTH1<float>* phi;
|
|
|
+ ContainerTH2<float>* eta_phi;
|
|
|
+
|
|
|
+ KinColl(TrackingDataSet& tds, const std::string& pfx,
|
|
|
+ THParams pt_params, THParams eta_params, THParams phi_params,
|
|
|
+ const std::string& sfx="") {
|
|
|
+ std::string _sfx = "";
|
|
|
+ if (sfx != "") _sfx = "_"+sfx;
|
|
|
+
|
|
|
+ pt = tds.register_container<ContainerTH1<float>>(pfx+"_v_pt"+_sfx, pt_params);
|
|
|
+ eta = tds.register_container<ContainerTH1<float>>(pfx+"_v_eta"+_sfx, eta_params);
|
|
|
+ phi = tds.register_container<ContainerTH1<float>>(pfx+"_v_phi"+_sfx, phi_params);
|
|
|
+
|
|
|
+ THParams eta_phi_params = eta_params;
|
|
|
+ eta_phi_params.low_y = phi_params.low_x;
|
|
|
+ eta_phi_params.high_y = phi_params.high_x;
|
|
|
+ eta_phi_params.label_y = phi_params.label_x;
|
|
|
+
|
|
|
+ eta_phi = tds.register_container<ContainerTH2<float>>(pfx+"_v_eta_phi"+_sfx, eta_phi_params);
|
|
|
+ }
|
|
|
};
|
|
|
|
|
|
+template <typename T1, typename T2>
|
|
|
+struct AugKinColl {
|
|
|
+ T1* pt;
|
|
|
+ T1* eta;
|
|
|
+ T1* phi;
|
|
|
+ T2* eta_phi;
|
|
|
+};
|
|
|
+
|
|
|
+int get_n_pv() {
|
|
|
+ /* std::cout << "------------------------------------------------" << std::endl; */
|
|
|
+ int n_pv = 0;
|
|
|
+ for (const auto& sim_vertex : sim_vertices) {
|
|
|
+ if (sim_vertex.sourceSimIdx().size() == 0) {
|
|
|
+ /* std::cout << "(" */
|
|
|
+ /* << sim_vertex.x() << ", " */
|
|
|
+ /* << sim_vertex.y() << ", " */
|
|
|
+ /* << sim_vertex.z() << ") " */
|
|
|
+ /* << sim_vertex.processType() << std::endl; */
|
|
|
+ n_pv++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* std::cout << "::::: " << pileup << std::endl; */
|
|
|
+ return n_pv / 2; // for some reason, all vertices are repeated twice...
|
|
|
+}
|
|
|
+
|
|
|
bool in_lum_region(const SimVertex& vertex) {
|
|
|
/* Here approximate the luminous region as a cylinder with length 5*\sigma_z and radius
|
|
|
* sqrt(\simga_x^2 + \sigma_y^2) centered as beamspot position.
|
|
|
@@ -91,9 +161,17 @@ Vec4 scl_p4(const SuperCluster& scl) {
|
|
|
return Vec4(scl.px(), scl.py(), scl.pz(), scl.e());
|
|
|
}
|
|
|
|
|
|
+double dphi(double phi1, double phi2) {
|
|
|
+ auto spec_mod = [](double a) {
|
|
|
+ return a - floor(a/pi2)*pi2;
|
|
|
+ };
|
|
|
+ return spec_mod(phi2 - phi1 + pi) - pi;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
double deltaR(double eta1, double phi1, double eta2, double phi2) {
|
|
|
return sqrt(pow(eta1 - eta2, 2.0) +
|
|
|
- pow(phi1 - phi2, 2.0));
|
|
|
+ pow(dphi(phi1, phi2), 2.0));
|
|
|
}
|
|
|
|
|
|
void update_sim_els() {
|
|
|
@@ -211,6 +289,11 @@ void run(){
|
|
|
using namespace fv;
|
|
|
using namespace fv_root;
|
|
|
using namespace fv_util;
|
|
|
+
|
|
|
+ auto lookup = [](const std::string&& key) {
|
|
|
+ return THParams::lookup(std::forward<const std::string>(key));
|
|
|
+ };
|
|
|
+
|
|
|
auto file_list = the_config->get_source_files();
|
|
|
string output_filename = the_config->get_output_filename();
|
|
|
TrackingDataSet tds(output_filename, file_list, "trackingNtuple/tree");
|
|
|
@@ -227,6 +310,12 @@ void run(){
|
|
|
tds.track_branch<float>("bsp_sigmaz")
|
|
|
};
|
|
|
|
|
|
+ inTimePileup = tds.track_branch<int>("inTimePileup");
|
|
|
+ truePileup = tds.track_branch<float>("truePileup");
|
|
|
+
|
|
|
+
|
|
|
+ totalSeeds = tds.track_branch<unsigned int>("initsee_tot");
|
|
|
+
|
|
|
enum TMType {
|
|
|
NoMatch = 0,
|
|
|
SeedMatched = 1,
|
|
|
@@ -272,23 +361,23 @@ void run(){
|
|
|
for (int hit=1; hit<=3; hit++) {
|
|
|
for (int tm_type = NoMatch; tm_type <= SeedAndTrackMatched; tm_type++) {
|
|
|
for (int layer=1; layer<=4; layer++) {
|
|
|
- hist_params = (hit == 1) ? THParams::lookup("dRz_v_Et") : THParams::lookup("dRz_v_Et_outer_hits");
|
|
|
+ hist_params = (hit == 1) ? lookup("dRz_v_Et") : lookup("dRz_v_Et_outer_hits");
|
|
|
set_name("dRz", "BPIX", layer, hit, tm_type);
|
|
|
BPIX_residuals_dRz[make_tuple(layer, hit, tm_type)] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
set_name("dRz", "FPIX", layer, hit, tm_type);
|
|
|
FPIX_residuals_dRz[make_tuple(layer, hit, tm_type)] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
|
|
|
- hist_params = (hit == 1) ? THParams::lookup("dPhi_v_Et") : THParams::lookup("dPhi_v_Et_outer_hits");
|
|
|
+ hist_params = (hit == 1) ? lookup("dPhi_v_Et") : lookup("dPhi_v_Et_outer_hits");
|
|
|
set_name("dPhi", "BPIX", layer, hit, tm_type);
|
|
|
BPIX_residuals_dPhi[make_tuple(layer, hit, tm_type)] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
set_name("dPhi", "FPIX", layer, hit, tm_type);
|
|
|
FPIX_residuals_dPhi[make_tuple(layer, hit, tm_type)] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
}
|
|
|
- hist_params = (hit == 1) ? THParams::lookup("dRz_v_Et") : THParams::lookup("dRz_v_Et_outer_hits");
|
|
|
+ hist_params = (hit == 1) ? lookup("dRz_v_Et") : lookup("dRz_v_Et_outer_hits");
|
|
|
set_name("dRz", "ALL", 0, hit, tm_type);
|
|
|
residuals_dRz[std::make_tuple(hit, tm_type)] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
|
|
|
- hist_params = (hit == 1) ? THParams::lookup("dPhi_v_Et") : THParams::lookup("dPhi_v_Et_outer_hits");
|
|
|
+ hist_params = (hit == 1) ? lookup("dPhi_v_Et") : lookup("dPhi_v_Et_outer_hits");
|
|
|
set_name("dPhi", "ALL", 0, hit, tm_type);
|
|
|
residuals_dPhi[make_tuple(hit, tm_type)] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
}
|
|
|
@@ -317,194 +406,137 @@ void run(){
|
|
|
for (int hit=1; hit<=3; hit++) {
|
|
|
name.str("");
|
|
|
name << "dPhi_residuals_v_eta_H" << hit;
|
|
|
- hist_params = (hit==1) ? THParams::lookup("dPhi_v_eta") : THParams::lookup("dPhi_v_eta_outer_hits");
|
|
|
+ hist_params = (hit==1) ? lookup("dPhi_v_eta") : lookup("dPhi_v_eta_outer_hits");
|
|
|
dPhi_residuals_v_eta[hit] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
|
|
|
name.str("");
|
|
|
name << "dRz_residuals_v_eta_H" << hit;
|
|
|
- hist_params = (hit==1) ? THParams::lookup("dRz_v_eta") : THParams::lookup("dRz_v_eta_outer_hits");
|
|
|
+ hist_params = (hit==1) ? lookup("dRz_v_eta") : lookup("dRz_v_eta_outer_hits");
|
|
|
dRz_residuals_v_eta[hit] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
for (int region=1; region<=eta_regions[hit].size()-1; region++){
|
|
|
- hist_params = (hit==1) ? THParams::lookup("dRz_v_Et") : THParams::lookup("dRz_v_Et_outer_hits");
|
|
|
+ hist_params = (hit==1) ? lookup("dRz_v_Et") : lookup("dRz_v_Et_outer_hits");
|
|
|
name.str("");
|
|
|
name << "dRz_residuals_H" << hit << "_R" << region;
|
|
|
dRz_residuals_v_region[{hit, region}] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
|
|
|
- hist_params = (hit==1) ? THParams::lookup("dPhi_v_Et") : THParams::lookup("dPhi_v_Et_outer_hits");
|
|
|
+ hist_params = (hit==1) ? lookup("dPhi_v_Et") : lookup("dPhi_v_Et_outer_hits");
|
|
|
name.str("");
|
|
|
name << "dPhi_residuals_H" << hit << "_R" << region;
|
|
|
dPhi_residuals_v_region[{hit, region}] = tds.register_container<ContainerTH2<float>>(name.str(), hist_params);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- KinColl<ContainerTH1<float>> good_sim_kinems = {
|
|
|
- tds.register_container<ContainerTH1<float>>("good_sim_v_pt", THParams::lookup("pt_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("good_sim_v_eta", THParams::lookup("eta_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("good_sim_v_phi", THParams::lookup("phi_fine"))};
|
|
|
-
|
|
|
- KinColl<ContainerTH1<float>> gsf_kinems = {
|
|
|
- tds.register_container<ContainerTH1<float>>("gsf_track_v_pt", THParams::lookup("pt_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("gsf_track_v_eta", THParams::lookup("eta_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("gsf_track_v_phi", THParams::lookup("phi_fine"))};
|
|
|
-
|
|
|
- KinColl<ContainerTH1<float>> seed_kinems = {
|
|
|
- tds.register_container<ContainerTH1<float>>("seed_v_pt", THParams::lookup("pt_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("seed_v_eta", THParams::lookup("eta_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("seed_v_phi", THParams::lookup("phi_fine"))};
|
|
|
-
|
|
|
- KinColl<ContainerTH1<float>> scl_kinems = {
|
|
|
- tds.register_container<ContainerTH1<float>>("scl_v_pt", THParams::lookup("pt_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("scl_v_eta", THParams::lookup("eta_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("scl_v_phi", THParams::lookup("phi_fine"))};
|
|
|
-
|
|
|
- KinColl<ContainerTH1<float>> prompt_kinems = {
|
|
|
- tds.register_container<ContainerTH1<float>>("prompt_v_pt", THParams::lookup("pt_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("prompt_v_eta", THParams::lookup("eta_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("prompt_v_phi", THParams::lookup("phi_fine"))};
|
|
|
-
|
|
|
- KinColl<ContainerTH1<float>> nonprompt_kinems = {
|
|
|
- tds.register_container<ContainerTH1<float>>("nonprompt_v_pt", THParams::lookup("pt_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("nonprompt_v_eta", THParams::lookup("eta_fine")),
|
|
|
- tds.register_container<ContainerTH1<float>>("nonprompt_v_phi", THParams::lookup("phi_fine"))};
|
|
|
-
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> seed_eff = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("seed_eff_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("seed_eff_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("seed_eff_v_phi", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> seed_pur = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("seed_pur_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("seed_pur_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("seed_pur_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> tracking_eff = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_phi", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> tracking_pur = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_phi", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> prompt_eff = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_eff_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_eff_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_eff_v_phi", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> prompt_pur = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_phi", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> nonprompt_eff = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_phi", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> nonprompt_pur = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> tracking_eff_dR = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_pt_dR", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_eta_dR", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_phi_dR", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> tracking_pur_dR = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_pt_dR", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_eta_dR", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_phi_dR", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> prompt_eff_dR = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_eff_v_pt_dR", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_eff_v_eta_dR", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_eff_v_phi_dR", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> prompt_pur_dR = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_pt_dR", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_eta_dR", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("prompt_pur_v_phi_dR", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> nonprompt_eff_dR = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_pt_dR", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_eta_dR", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_eff_v_phi_dR", THParams::lookup("phi"))};
|
|
|
- KinColl<EfficiencyContainer<float>> nonprompt_pur_dR = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_pt_dR", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_eta_dR", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("nonprompt_pur_v_phi_dR", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> fake_rate = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("fake_rate_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("fake_rate_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("fake_rate_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> partial_fake_rate = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> full_fake_rate = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("full_fake_rate_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("full_fake_rate_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("full_fake_rate_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> clean_fake_rate = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> fake_rate_incl = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("fake_rate_incl_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("fake_rate_incl_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("fake_rate_incl_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> partial_fake_rate_incl = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_incl_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_incl_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("partial_fake_rate_incl_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> full_fake_rate_incl = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("full_fake_rate_incl_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("full_fake_rate_incl_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("full_fake_rate_incl_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- KinColl<EfficiencyContainer<float>> clean_fake_rate_incl = {
|
|
|
- tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_incl_v_pt", THParams::lookup("pt")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_incl_v_eta", THParams::lookup("eta")),
|
|
|
- tds.register_container<EfficiencyContainer<float>>("clean_fake_rate_incl_v_phi", THParams::lookup("phi"))};
|
|
|
-
|
|
|
- auto& hit_vs_layer_barrel = *tds.register_container<ContainerTH2<int>>("hit_vs_layer_barrel", THParams::lookup("hit_vs_layer"));
|
|
|
- auto& hit_vs_layer_forward = *tds.register_container<ContainerTH2<int>>("hit_vs_layer_forward", THParams::lookup("hit_vs_layer"));
|
|
|
-
|
|
|
- auto& gsf_tracks_nmatch_sim_tracks = *tds.register_container<ContainerTH1<size_t>>("gsf_tracks_nmatch_sim_tracks ", THParams::lookup("gsf_tracks_nmatch_sim_tracks"));
|
|
|
-
|
|
|
-
|
|
|
- auto& ecal_energy_resolution = *tds.register_container<ContainerTH1<float>>("ecal_energy_resolution ", THParams::lookup("ecal_energy_resolution"));
|
|
|
-
|
|
|
- auto& n_seeds = *tds.register_container<ContainerTH1<size_t>>("n_seeds", THParams::lookup("n_seeds"));
|
|
|
- auto& n_good_seeds = *tds.register_container<ContainerTH1<size_t>>("n_good_seeds", THParams::lookup("n_seeds"));
|
|
|
- auto& n_good_sim = *tds.register_container<ContainerTH1<size_t>>("n_good_sim", THParams::lookup("n_seeds"));
|
|
|
- auto& n_prompt = *tds.register_container<ContainerTH1<size_t>>("n_prompt", THParams::lookup("n_seeds"));
|
|
|
- auto& n_nonprompt = *tds.register_container<ContainerTH1<size_t>>("n_nonprompt", THParams::lookup("n_seeds"));
|
|
|
- auto& n_gsf_tracks = *tds.register_container<ContainerTH1<size_t>>("n_gsf_track", THParams::lookup("n_seeds"));
|
|
|
- auto& n_scl = *tds.register_container<ContainerTH1<size_t>>("n_scl", THParams::lookup("n_seeds"));
|
|
|
- auto& n_good_scl = *tds.register_container<ContainerTH1<size_t>>("n_good_scl", THParams::lookup("n_seeds"));
|
|
|
-
|
|
|
- auto& n_matched = *tds.register_container<ContainerTH1<int>>("n_matched", THParams::lookup("n_seeds"));
|
|
|
- auto& n_merged = *tds.register_container<ContainerTH1<int>>("n_merged", THParams::lookup("n_seeds"));
|
|
|
- auto& n_lost = *tds.register_container<ContainerTH1<int>>("n_lost", THParams::lookup("n_seeds"));
|
|
|
- auto& n_split = *tds.register_container<ContainerTH1<int>>("n_split", THParams::lookup("n_seeds"));
|
|
|
- auto& n_faked = *tds.register_container<ContainerTH1<int>>("n_faked", THParams::lookup("n_seeds"));
|
|
|
- auto& n_flipped = *tds.register_container<ContainerTH1<int>>("n_flipped", THParams::lookup("n_seeds"));
|
|
|
-
|
|
|
- auto& matched_dR = *tds.register_container<ContainerTH1<float>>("matched_dR", THParams::lookup("matched_dR"));
|
|
|
- auto& matched_dpT = *tds.register_container<ContainerTH1<float>>("matched_dpT", THParams::lookup("matched_dpT"));
|
|
|
-
|
|
|
- auto& n_matched_dR = *tds.register_container<ContainerTH1<int>>("n_matched_dR", THParams::lookup("n_seeds"));
|
|
|
- auto& n_merged_dR = *tds.register_container<ContainerTH1<int>>("n_merged_dR", THParams::lookup("n_seeds"));
|
|
|
- auto& n_lost_dR = *tds.register_container<ContainerTH1<int>>("n_lost_dR", THParams::lookup("n_seeds"));
|
|
|
- auto& n_split_dR = *tds.register_container<ContainerTH1<int>>("n_split_dR", THParams::lookup("n_seeds"));
|
|
|
- auto& n_faked_dR = *tds.register_container<ContainerTH1<int>>("n_faked_dR", THParams::lookup("n_seeds"));
|
|
|
- auto& n_flipped_dR = *tds.register_container<ContainerTH1<int>>("n_flipped_dR", THParams::lookup("n_seeds"));
|
|
|
-
|
|
|
- auto& matched_dR_dR = *tds.register_container<ContainerTH1<float>>("matched_dR_dR", THParams::lookup("matched_dR"));
|
|
|
- auto& matched_dpT_dR = *tds.register_container<ContainerTH1<float>>("matched_dpT_dR", THParams::lookup("matched_dpT"));
|
|
|
+
|
|
|
+ KinColl good_sim_kinems (tds, "good_sim", lookup("pt_fine"), lookup("eta_fine"), lookup("phi_fine"));
|
|
|
+ KinColl gsf_kinems (tds, "gsf", lookup("pt_fine"), lookup("eta_fine"), lookup("phi_fine"));
|
|
|
+ KinColl gsf_high_pt1_kinems(tds, "gsf_high_pt1", lookup("pt_fine"), lookup("eta_fine"), lookup("phi_fine"));
|
|
|
+ KinColl gsf_high_pt2_kinems(tds, "gsf_high_pt2", lookup("pt_fine"), lookup("eta_fine"), lookup("phi_fine"));
|
|
|
+ KinColl seed_kinems (tds, "seed", lookup("pt_fine"), lookup("eta_fine"), lookup("phi_fine"));
|
|
|
+ KinColl scl_kinems (tds, "scl", lookup("pt_fine"), lookup("eta_fine"), lookup("phi_fine"));
|
|
|
+ KinColl prompt_kinems (tds, "prompt", lookup("pt_fine"), lookup("eta_fine"), lookup("phi_fine"));
|
|
|
+ KinColl nonprompt_kinems (tds, "nonprompt", lookup("pt_fine"), lookup("eta_fine"), lookup("phi_fine"));
|
|
|
+
|
|
|
+
|
|
|
+ EffColl seed_eff(tds, "seed_eff", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl seed_pur(tds, "seed_pur", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+
|
|
|
+ EffColl tracking_eff (tds, "tracking_eff", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl tracking_pur (tds, "tracking_pur", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl prompt_eff (tds, "prompt_eff", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl prompt_pur (tds, "prompt_pur", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl nonprompt_eff(tds, "nonprompt_eff", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl nonprompt_pur(tds, "nonprompt_pur", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+
|
|
|
+ EffColl tracking_eff_dR (tds, "tracking_eff", lookup("pt"), lookup("eta"), lookup("phi"), "dR");
|
|
|
+ EffColl tracking_pur_dR (tds, "tracking_pur", lookup("pt"), lookup("eta"), lookup("phi"), "dR");
|
|
|
+ EffColl prompt_eff_dR (tds, "prompt_eff", lookup("pt"), lookup("eta"), lookup("phi"), "dR");
|
|
|
+ EffColl prompt_pur_dR (tds, "prompt_pur", lookup("pt"), lookup("eta"), lookup("phi"), "dR");
|
|
|
+ EffColl nonprompt_eff_dR(tds, "nonprompt_eff", lookup("pt"), lookup("eta"), lookup("phi"), "dR");
|
|
|
+ EffColl nonprompt_pur_dR(tds, "nonprompt_pur", lookup("pt"), lookup("eta"), lookup("phi"), "dR");
|
|
|
+
|
|
|
+ auto& tracking_eff_v_PU_dR = *tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_PU_dR", lookup("PU"));
|
|
|
+ auto& tracking_eff_v_PU_dR_inc = *tds.register_container<EfficiencyContainer<float>>("tracking_eff_v_PU_dR_inc", lookup("PU"));
|
|
|
+ auto& tracking_pur_v_PU_dR = *tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_PU_dR", lookup("PU"));
|
|
|
+ auto& tracking_pur_v_PU_dR_inc = *tds.register_container<EfficiencyContainer<float>>("tracking_pur_v_PU_dR_inc", lookup("PU"));
|
|
|
+
|
|
|
+ // Full Efficiency/Purity includes tracker-driven seeds
|
|
|
+ EffColl tracking_eff_full (tds, "tracking_eff_full", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl tracking_eff_full_dR(tds, "tracking_eff_full", lookup("pt"), lookup("eta"), lookup("phi"), "dR");
|
|
|
+ EffColl tracking_pur_full (tds, "tracking_pur_full", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl tracking_pur_full_dR(tds, "tracking_pur_full", lookup("pt"), lookup("eta"), lookup("phi"), "dR");
|
|
|
+
|
|
|
+ EffColl fake_rate (tds, "fake_rate", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl fake_rate_no_e_match(tds, "fake_rate_no_e_match", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+
|
|
|
+ auto& fake_rate_no_e_match_v_PU = *tds.register_container<EfficiencyContainer<float>>("fake_rate_no_e_match_v_PU", lookup("PU"));
|
|
|
+ auto& fake_rate_no_e_match_v_PU_inc = *tds.register_container<EfficiencyContainer<float>>("fake_rate_no_e_match_v_PU_inc", lookup("PU"));
|
|
|
+
|
|
|
+ EffColl partial_fake_rate (tds, "partial_fake_rate", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl full_fake_rate (tds, "full_fake_rate", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl clean_fake_rate (tds, "clean_fake_rate", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl fake_rate_incl (tds, "fake_rate_incl", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl fake_rate_no_e_match_incl(tds, "fake_rate_no_e_match_incl", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl partial_fake_rate_incl (tds, "partial_fake_rate_incl", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl full_fake_rate_incl (tds, "full_fake_rate_incl", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+ EffColl clean_fake_rate_incl (tds, "clean_fake_rate_incl", lookup("pt"), lookup("eta"), lookup("phi"));
|
|
|
+
|
|
|
+ auto& hit_vs_layer_barrel = *tds.register_container<ContainerTH2<int>>("hit_vs_layer_barrel", lookup("hit_vs_layer"));
|
|
|
+ auto& hit_vs_layer_forward = *tds.register_container<ContainerTH2<int>>("hit_vs_layer_forward", lookup("hit_vs_layer"));
|
|
|
+
|
|
|
+ auto& gsf_tracks_nmatch_sim_tracks = *tds.register_container<ContainerTH1<size_t>>("gsf_tracks_nmatch_sim_tracks ", lookup("gsf_tracks_nmatch_sim_tracks"));
|
|
|
+
|
|
|
+ auto& ecal_energy_resolution = *tds.register_container<ContainerTH1<float>>("ecal_energy_resolution ", lookup("ecal_energy_resolution"));
|
|
|
+
|
|
|
+ auto& n_seeds = *tds.register_container<ContainerTH1<size_t>>("n_seeds", lookup("n_seeds"));
|
|
|
+ auto& n_good_seeds = *tds.register_container<ContainerTH1<size_t>>("n_good_seeds", lookup("n_seeds"));
|
|
|
+ auto& n_good_sim = *tds.register_container<ContainerTH1<size_t>>("n_good_sim", lookup("n_seeds"));
|
|
|
+ auto& n_prompt = *tds.register_container<ContainerTH1<size_t>>("n_prompt", lookup("n_seeds"));
|
|
|
+ auto& n_nonprompt = *tds.register_container<ContainerTH1<size_t>>("n_nonprompt", lookup("n_seeds"));
|
|
|
+ auto& n_gsf_tracks = *tds.register_container<ContainerTH1<size_t>>("n_gsf_track", lookup("n_seeds"));
|
|
|
+ auto& n_scl = *tds.register_container<ContainerTH1<size_t>>("n_scl", lookup("n_seeds"));
|
|
|
+ auto& n_good_scl = *tds.register_container<ContainerTH1<size_t>>("n_good_scl", lookup("n_seeds"));
|
|
|
+
|
|
|
+ auto& n_matched = *tds.register_container<ContainerTH1<int>>("n_matched", lookup("n_seeds"));
|
|
|
+ auto& n_merged = *tds.register_container<ContainerTH1<int>>("n_merged", lookup("n_seeds"));
|
|
|
+ auto& n_lost = *tds.register_container<ContainerTH1<int>>("n_lost", lookup("n_seeds"));
|
|
|
+ auto& n_split = *tds.register_container<ContainerTH1<int>>("n_split", lookup("n_seeds"));
|
|
|
+ auto& n_faked = *tds.register_container<ContainerTH1<int>>("n_faked", lookup("n_seeds"));
|
|
|
+ auto& n_flipped = *tds.register_container<ContainerTH1<int>>("n_flipped", lookup("n_seeds"));
|
|
|
+
|
|
|
+ auto& matched_dR = *tds.register_container<ContainerTH1<float>>("matched_dR", lookup("matched_dR"));
|
|
|
+ auto& matched_dpT = *tds.register_container<ContainerTH1<float>>("matched_dpT", lookup("matched_dpT"));
|
|
|
+
|
|
|
+ auto& n_matched_dR = *tds.register_container<ContainerTH1<int>>("n_matched_dR", lookup("n_seeds"));
|
|
|
+ auto& n_merged_dR = *tds.register_container<ContainerTH1<int>>("n_merged_dR", lookup("n_seeds"));
|
|
|
+ auto& n_lost_dR = *tds.register_container<ContainerTH1<int>>("n_lost_dR", lookup("n_seeds"));
|
|
|
+ auto& n_split_dR = *tds.register_container<ContainerTH1<int>>("n_split_dR", lookup("n_seeds"));
|
|
|
+ auto& n_faked_dR = *tds.register_container<ContainerTH1<int>>("n_faked_dR", lookup("n_seeds"));
|
|
|
+ auto& n_flipped_dR = *tds.register_container<ContainerTH1<int>>("n_flipped_dR", lookup("n_seeds"));
|
|
|
+
|
|
|
+ auto& matched_dR_dR = *tds.register_container<ContainerTH1<float>>("matched_dR_dR", lookup("matched_dR"));
|
|
|
+ auto& matched_dpT_dR = *tds.register_container<ContainerTH1<float>>("matched_dpT_dR", lookup("matched_dpT"));
|
|
|
|
|
|
auto& tm_corr = *tds.register_container<ContainerTH2<int>>("tm_corr", THParams(2, -0.5, 1.5, 2, -0.5, 1.5));
|
|
|
+ auto& n_pileup = *tds.register_container<ContainerTH1<int>>("n_pileup", lookup("n_seeds"));
|
|
|
+
|
|
|
+
|
|
|
+ auto& n_seeds_v_PU = *tds.register_container<ContainerTH2<int>>("n_seeds_v_PU", lookup("n_seeds_v_PU"));
|
|
|
+ auto& n_good_seeds_v_PU = *tds.register_container<ContainerTH2<int>>("n_good_seeds_v_PU", lookup("n_seeds_v_PU"));
|
|
|
+ auto& n_tracks_v_PU = *tds.register_container<ContainerTH2<int>>("n_tracks_v_PU", lookup("n_seeds_v_PU"));
|
|
|
+ auto& n_pv_v_PU = *tds.register_container<ContainerTH2<int>>("n_pv_v_PU", lookup("n_seeds_v_PU"));
|
|
|
+
|
|
|
+ auto& n_seeds_v_tPU = *tds.register_container<ContainerTH2<float>>("n_seeds_v_tPU", lookup("n_seeds_v_PU"));
|
|
|
+ auto& n_good_seeds_v_tPU = *tds.register_container<ContainerTH2<float>>("n_good_seeds_v_tPU", lookup("n_seeds_v_PU"));
|
|
|
+ auto& n_tracks_v_tPU = *tds.register_container<ContainerTH2<float>>("n_tracks_v_tPU", lookup("n_seeds_v_PU"));
|
|
|
+ auto& n_pv_v_tPU = *tds.register_container<ContainerTH2<float>>("n_pv_v_tPU", lookup("n_seeds_v_PU"));
|
|
|
+
|
|
|
+
|
|
|
+ auto& n_seeds_v_n_scl = *tds.register_container<ContainerTH2<int>>("n_seeds_v_n_scl", lookup("n_seeds_v_PU"));
|
|
|
+ auto& n_good_seeds_v_n_scl = *tds.register_container<ContainerTH2<int>>("n_good_seeds_v_n_scl", lookup("n_seeds_v_PU"));
|
|
|
+ auto& n_good_seeds_v_n_good_scl = *tds.register_container<ContainerTH2<int>>("n_good_seeds_v_n_good_scl", lookup("n_seeds_v_PU"));
|
|
|
+
|
|
|
+ auto& n_initseeds_v_PU = *tds.register_container<ContainerTH2<int>>("n_initseeds_v_PU", lookup("n_initseeds_v_PU"));
|
|
|
+ auto& n_initseeds_v_tPU = *tds.register_container<ContainerTH2<float>>("n_initseeds_v_tPU", lookup("n_initseeds_v_PU"));
|
|
|
|
|
|
while (tds.next()) {
|
|
|
|
|
|
@@ -512,23 +544,67 @@ void run(){
|
|
|
vector<SimTrack> prompt_sims, nonprompt_sims;
|
|
|
std::tie(prompt_sims, nonprompt_sims) = get_prompt_sims();
|
|
|
|
|
|
+ int n_pv = get_n_pv();
|
|
|
+ n_pileup.fill(n_pv);
|
|
|
+ n_pv_v_PU.fill(n_pv, inTimePileup->get());
|
|
|
+ n_pv_v_tPU.fill(n_pv, truePileup->get());
|
|
|
|
|
|
size_t _n_good_seeds = 0;
|
|
|
+ /* cout << "Event: " << tds.get_current_event() << endl; */
|
|
|
+ int idx = 0;
|
|
|
for (const auto& seed : seeds) {
|
|
|
+ /* cout << idx << ") [" << seed.pt() << ", " << seed.eta() << ", " << seed.phi() << "] " << seed.sclIdx() << " "; */
|
|
|
+
|
|
|
if (is_good_seed(seed, hoe_cut)) {
|
|
|
_n_good_seeds++;
|
|
|
seed_kinems.pt->fill(seed.pt());
|
|
|
seed_kinems.eta->fill(seed.eta());
|
|
|
seed_kinems.phi->fill(seed.phi());
|
|
|
+ seed_kinems.eta_phi->fill(seed.eta(), seed.phi());
|
|
|
+ }
|
|
|
+ idx++;
|
|
|
+ }
|
|
|
+ size_t _n_good_scl = 0;
|
|
|
+ for (const auto& scl : scls) {
|
|
|
+ if (scl.hoe() < hoe_cut) {
|
|
|
+ _n_good_scl++;
|
|
|
+ scl_kinems.pt->fill(hypot(scl.px(), scl.py()));
|
|
|
+ float eta = pseudorapidity(scl.x(), scl.y(), scl.z());
|
|
|
+ float phi = atan2(scl.y(), scl.x());
|
|
|
+ scl_kinems.eta->fill(eta);
|
|
|
+ scl_kinems.phi->fill(phi);
|
|
|
+ scl_kinems.eta_phi->fill(eta, phi);
|
|
|
}
|
|
|
}
|
|
|
+ /* idx = 0; */
|
|
|
+ /* for (const auto& track : gsf_tracks) { */
|
|
|
+ /* cout << idx << ") [" << track.pt() << ", " << track.eta() << ", " << track.phi() << "] " << track.seedIdx() << endl; */
|
|
|
+ /* idx++; */
|
|
|
+ /* } */
|
|
|
+ /* string tmp; */
|
|
|
+ /* cin >> tmp; */
|
|
|
+ /* cout << "total seeds: " << totalSeeds->get() << endl; */
|
|
|
+ n_initseeds_v_PU.fill(totalSeeds->get(), inTimePileup->get());
|
|
|
+ n_initseeds_v_tPU.fill(totalSeeds->get(), truePileup->get());
|
|
|
+
|
|
|
+ n_seeds_v_n_scl.fill(seeds.size(), scls.size());
|
|
|
+ n_good_seeds_v_n_scl.fill(_n_good_seeds, scls.size());
|
|
|
+ n_good_seeds_v_n_good_scl.fill(_n_good_seeds, _n_good_scl);
|
|
|
+
|
|
|
n_seeds.fill(seeds.size());
|
|
|
n_good_seeds.fill(_n_good_seeds);
|
|
|
|
|
|
+ n_seeds_v_PU.fill(seeds.size(), inTimePileup->get());
|
|
|
+ n_good_seeds_v_PU.fill(_n_good_seeds, inTimePileup->get());
|
|
|
+
|
|
|
+ n_seeds_v_tPU.fill(seeds.size(), truePileup->get());
|
|
|
+ n_good_seeds_v_tPU.fill(_n_good_seeds, truePileup->get());
|
|
|
+
|
|
|
for (const auto& sim_track : sim_els) {
|
|
|
good_sim_kinems.pt->fill(sim_track.pt());
|
|
|
good_sim_kinems.eta->fill(sim_track.eta());
|
|
|
good_sim_kinems.phi->fill(sim_track.phi());
|
|
|
+ good_sim_kinems.eta_phi->fill(sim_track.eta(), sim_track.phi());
|
|
|
}
|
|
|
|
|
|
n_prompt.fill(prompt_sims.size());
|
|
|
@@ -536,6 +612,7 @@ void run(){
|
|
|
prompt_kinems.pt->fill(prompt.pt());
|
|
|
prompt_kinems.eta->fill(prompt.eta());
|
|
|
prompt_kinems.phi->fill(prompt.phi());
|
|
|
+ prompt_kinems.eta_phi->fill(prompt.eta(), prompt.phi());
|
|
|
}
|
|
|
|
|
|
n_nonprompt.fill(nonprompt_sims.size());
|
|
|
@@ -543,23 +620,32 @@ void run(){
|
|
|
nonprompt_kinems.pt->fill(nonprompt.pt());
|
|
|
nonprompt_kinems.eta->fill(nonprompt.eta());
|
|
|
nonprompt_kinems.phi->fill(nonprompt.phi());
|
|
|
+ nonprompt_kinems.eta_phi->fill(nonprompt.eta(), nonprompt.phi());
|
|
|
}
|
|
|
|
|
|
for (const auto& gsf_track : gsf_tracks) {
|
|
|
+ if (!is_good_seed(seeds[gsf_track.seedIdx()], hoe_cut)) continue;
|
|
|
gsf_kinems.pt->fill(gsf_track.pt());
|
|
|
gsf_kinems.eta->fill(gsf_track.eta());
|
|
|
gsf_kinems.phi->fill(gsf_track.phi());
|
|
|
- }
|
|
|
-
|
|
|
- size_t _n_good_scl = 0;
|
|
|
- for (const auto& scl : scls) {
|
|
|
- if (scl.hoe() < hoe_cut) {
|
|
|
- _n_good_scl++;
|
|
|
- scl_kinems.pt->fill(hypot(scl.px(), scl.py()));
|
|
|
- scl_kinems.eta->fill(pseudorapidity(scl.x(), scl.y(), scl.z()));
|
|
|
- scl_kinems.phi->fill(atan2(scl.y(), scl.x()));
|
|
|
+ gsf_kinems.eta_phi->fill(gsf_track.eta(), gsf_track.phi());
|
|
|
+ if (gsf_track.pt() > 10) {
|
|
|
+ gsf_high_pt1_kinems.pt->fill(gsf_track.pt());
|
|
|
+ gsf_high_pt1_kinems.eta->fill(gsf_track.eta());
|
|
|
+ gsf_high_pt1_kinems.phi->fill(gsf_track.phi());
|
|
|
+ gsf_high_pt1_kinems.eta_phi->fill(gsf_track.eta(), gsf_track.phi());
|
|
|
}
|
|
|
+ if (gsf_track.pt() > 20) {
|
|
|
+ gsf_high_pt2_kinems.pt->fill(gsf_track.pt());
|
|
|
+ gsf_high_pt2_kinems.eta->fill(gsf_track.eta());
|
|
|
+ gsf_high_pt2_kinems.phi->fill(gsf_track.phi());
|
|
|
+ gsf_high_pt2_kinems.eta_phi->fill(gsf_track.eta(), gsf_track.phi());
|
|
|
+ }
|
|
|
+
|
|
|
}
|
|
|
+ n_tracks_v_PU.fill(gsf_tracks.size(), inTimePileup->get());
|
|
|
+ n_tracks_v_tPU.fill(gsf_tracks.size(), truePileup->get());
|
|
|
+
|
|
|
n_scl.fill(scls.size());
|
|
|
n_good_scl.fill(_n_good_scl);
|
|
|
|
|
|
@@ -606,11 +692,11 @@ void run(){
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
- if (abs(sim_track.eta()) < 2.4)
|
|
|
+ if (abs(sim_track.eta()) < 2.5)
|
|
|
seed_eff.pt->fill(sim_track.pt(), matched);
|
|
|
if (sim_track.pt() > 20.0)
|
|
|
seed_eff.eta->fill(sim_track.eta(), matched);
|
|
|
- if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
|
|
|
+ if (abs(sim_track.eta()) < 2.5 and sim_track.pt() > 20)
|
|
|
seed_eff.phi->fill(sim_track.phi(), matched);
|
|
|
}
|
|
|
|
|
|
@@ -618,68 +704,89 @@ void run(){
|
|
|
for (const auto& sim_track : sim_els) {
|
|
|
if (gsf_tracks.size() == 0) continue;
|
|
|
bool matched = false;
|
|
|
+ bool matched_any = false;
|
|
|
for (const auto& track_idx : sim_track.trkIdx()) {
|
|
|
const Seed& seed = seeds[gsf_tracks[track_idx].seedIdx()];
|
|
|
if (is_good_seed(seed, hoe_cut)) {
|
|
|
- matched=true;
|
|
|
- break;
|
|
|
+ matched = true;
|
|
|
+ matched_any = true;
|
|
|
+ } else if (!seed.isECALDriven()) {
|
|
|
+ matched_any = true;
|
|
|
}
|
|
|
}
|
|
|
- if (abs(sim_track.eta()) < 2.4)
|
|
|
+ if (abs(sim_track.eta()) < 2.5) {
|
|
|
tracking_eff.pt->fill(sim_track.pt(), matched);
|
|
|
- if (sim_track.pt() > 20.0)
|
|
|
+ tracking_eff_full.pt->fill(sim_track.pt(), matched_any);
|
|
|
+ }
|
|
|
+ if (sim_track.pt() > 20.0) {
|
|
|
tracking_eff.eta->fill(sim_track.eta(), matched);
|
|
|
- if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
|
|
|
+ tracking_eff_full.eta->fill(sim_track.eta(), matched_any);
|
|
|
+ }
|
|
|
+ if (abs(sim_track.eta()) < 2.5 and sim_track.pt() > 20) {
|
|
|
tracking_eff.phi->fill(sim_track.phi(), matched);
|
|
|
+ tracking_eff_full.phi->fill(sim_track.phi(), matched_any);
|
|
|
+ }
|
|
|
|
|
|
if (std::find(prompt_sims.begin(), prompt_sims.end(), sim_track) != prompt_sims.end()) {
|
|
|
- if (abs(sim_track.eta()) < 2.4)
|
|
|
+ if (abs(sim_track.eta()) < 2.5)
|
|
|
prompt_eff.pt->fill(sim_track.pt(), matched);
|
|
|
if (sim_track.pt() > 20.0)
|
|
|
prompt_eff.eta->fill(sim_track.eta(), matched);
|
|
|
- if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
|
|
|
+ if (abs(sim_track.eta()) < 2.5 and sim_track.pt() > 20)
|
|
|
prompt_eff.phi->fill(sim_track.phi(), matched);
|
|
|
}
|
|
|
if (std::find(nonprompt_sims.begin(), nonprompt_sims.end(), sim_track) != nonprompt_sims.end()) {
|
|
|
- if (abs(sim_track.eta()) < 2.4)
|
|
|
+ if (abs(sim_track.eta()) < 2.5)
|
|
|
nonprompt_eff.pt->fill(sim_track.pt(), matched);
|
|
|
if (sim_track.pt() > 20.0)
|
|
|
nonprompt_eff.eta->fill(sim_track.eta(), matched);
|
|
|
- if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
|
|
|
+ if (abs(sim_track.eta()) < 2.5 and sim_track.pt() > 20)
|
|
|
nonprompt_eff.phi->fill(sim_track.phi(), matched);
|
|
|
}
|
|
|
|
|
|
// dR-matching
|
|
|
matched = false;
|
|
|
+ matched_any = false;
|
|
|
for (const auto& gsf_track : gsf_tracks) {
|
|
|
const Seed& seed = seeds[gsf_track.seedIdx()];
|
|
|
double dR = deltaR(sim_track.eta(), sim_track.phi(), gsf_track.eta(), gsf_track.phi());
|
|
|
if (is_good_seed(seed, hoe_cut) and dR < 0.2) {
|
|
|
matched = true;
|
|
|
- break;
|
|
|
+ matched_any = true;
|
|
|
+ } else if (!seed.isECALDriven()) {
|
|
|
+ matched_any = true;
|
|
|
}
|
|
|
}
|
|
|
- if (abs(sim_track.eta()) < 2.4)
|
|
|
+ if (abs(sim_track.eta()) < 2.5) {
|
|
|
tracking_eff_dR.pt->fill(sim_track.pt(), matched);
|
|
|
- if (sim_track.pt() > 20.0)
|
|
|
+ tracking_eff_full_dR.pt->fill(sim_track.pt(), matched_any);
|
|
|
+ }
|
|
|
+ if (sim_track.pt() > 20.0) {
|
|
|
tracking_eff_dR.eta->fill(sim_track.eta(), matched);
|
|
|
- if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
|
|
|
+ tracking_eff_full_dR.eta->fill(sim_track.eta(), matched_any);
|
|
|
+ }
|
|
|
+ if (abs(sim_track.eta()) < 2.5 and sim_track.pt() > 20) {
|
|
|
tracking_eff_dR.phi->fill(sim_track.phi(), matched);
|
|
|
+ tracking_eff_full_dR.phi->fill(sim_track.phi(), matched_any);
|
|
|
+ tracking_eff_v_PU_dR.fill(inTimePileup->get(), matched);
|
|
|
+ }
|
|
|
+
|
|
|
+ tracking_eff_v_PU_dR_inc.fill(inTimePileup->get(), matched);
|
|
|
|
|
|
if (find(prompt_sims.begin(), prompt_sims.end(), sim_track) != prompt_sims.end()) {
|
|
|
- if (abs(sim_track.eta()) < 2.4)
|
|
|
+ if (abs(sim_track.eta()) < 2.5)
|
|
|
prompt_eff_dR.pt->fill(sim_track.pt(), matched);
|
|
|
if (sim_track.pt() > 20.0)
|
|
|
prompt_eff_dR.eta->fill(sim_track.eta(), matched);
|
|
|
- if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
|
|
|
+ if (abs(sim_track.eta()) < 2.5 and sim_track.pt() > 20)
|
|
|
prompt_eff_dR.phi->fill(sim_track.phi(), matched);
|
|
|
}
|
|
|
if (find(nonprompt_sims.begin(), nonprompt_sims.end(), sim_track) != nonprompt_sims.end()) {
|
|
|
- if (abs(sim_track.eta()) < 2.4)
|
|
|
+ if (abs(sim_track.eta()) < 2.5)
|
|
|
nonprompt_eff_dR.pt->fill(sim_track.pt(), matched);
|
|
|
if (sim_track.pt() > 20.0)
|
|
|
nonprompt_eff_dR.eta->fill(sim_track.eta(), matched);
|
|
|
- if (abs(sim_track.eta()) < 2.4 and sim_track.pt() > 20)
|
|
|
+ if (abs(sim_track.eta()) < 2.5 and sim_track.pt() > 20)
|
|
|
nonprompt_eff_dR.phi->fill(sim_track.phi(), matched);
|
|
|
}
|
|
|
}
|
|
|
@@ -694,11 +801,11 @@ void run(){
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
- if (abs(seed.eta()) < 2.4)
|
|
|
+ if (abs(seed.eta()) < 2.5)
|
|
|
seed_pur.pt->fill(seed.pt(), match);
|
|
|
if (seed.pt() > 20)
|
|
|
seed_pur.eta->fill(seed.eta(), match);
|
|
|
- if (abs(seed.eta()) < 2.4 and seed.pt() > 20)
|
|
|
+ if (abs(seed.eta()) < 2.5 and seed.pt() > 20)
|
|
|
seed_pur.phi->fill(seed.phi(), match);
|
|
|
}
|
|
|
|
|
|
@@ -706,7 +813,9 @@ void run(){
|
|
|
for (const auto& gsf_track : gsf_tracks) {
|
|
|
gsf_tracks_nmatch_sim_tracks.fill(gsf_track.simTrkIdx().size());
|
|
|
const Seed& seed = seeds[gsf_track.seedIdx()];
|
|
|
- if (!is_good_seed(seed, hoe_cut)) continue;
|
|
|
+ /* if (!is_good_seed(seed, hoe_cut)) continue; */
|
|
|
+ bool good_ecal_driven_seed = is_good_seed(seed, hoe_cut);
|
|
|
+ bool good_seed = good_ecal_driven_seed or !seed.isECALDriven();
|
|
|
bool matched = false;
|
|
|
bool prompt_matched = false;
|
|
|
bool nonprompt_matched = false;
|
|
|
@@ -721,26 +830,33 @@ void run(){
|
|
|
nonprompt_matched = true;
|
|
|
}
|
|
|
}
|
|
|
- if (abs(gsf_track.eta()) < 2.4)
|
|
|
- tracking_pur.pt->fill(gsf_track.pt(), matched);
|
|
|
- if (gsf_track.pt() > 20)
|
|
|
- tracking_pur.eta->fill(gsf_track.eta(), matched);
|
|
|
- if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
|
|
|
- tracking_pur.phi->fill(gsf_track.phi(), matched);
|
|
|
|
|
|
- if (abs(gsf_track.eta()) < 2.4)
|
|
|
- prompt_pur.pt->fill(gsf_track.pt(), prompt_matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5) {
|
|
|
+ if (good_ecal_driven_seed) tracking_pur.pt->fill(gsf_track.pt(), matched);
|
|
|
+ if (good_seed) tracking_pur_full.pt->fill(gsf_track.pt(), matched);
|
|
|
+ }
|
|
|
+ if (gsf_track.pt() > 20) {
|
|
|
+ if (good_ecal_driven_seed) tracking_pur.eta->fill(gsf_track.eta(), matched);
|
|
|
+ if (good_seed) tracking_pur_full.eta->fill(gsf_track.eta(), matched);
|
|
|
+ }
|
|
|
+ if (abs(gsf_track.eta()) < 2.5 and gsf_track.pt() > 20) {
|
|
|
+ if (good_ecal_driven_seed) tracking_pur.phi->fill(gsf_track.phi(), matched);
|
|
|
+ if (good_seed) tracking_pur_full.phi->fill(gsf_track.phi(), matched);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (abs(gsf_track.eta()) < 2.5)
|
|
|
+ if (good_ecal_driven_seed) prompt_pur.pt->fill(gsf_track.pt(), prompt_matched);
|
|
|
if (gsf_track.pt() > 20)
|
|
|
- prompt_pur.eta->fill(gsf_track.eta(), prompt_matched);
|
|
|
- if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
|
|
|
- prompt_pur.phi->fill(gsf_track.phi(), prompt_matched);
|
|
|
+ if (good_ecal_driven_seed) prompt_pur.eta->fill(gsf_track.eta(), prompt_matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5 and gsf_track.pt() > 20)
|
|
|
+ if (good_ecal_driven_seed) prompt_pur.phi->fill(gsf_track.phi(), prompt_matched);
|
|
|
|
|
|
- if (abs(gsf_track.eta()) < 2.4)
|
|
|
- nonprompt_pur.pt->fill(gsf_track.pt(), nonprompt_matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5)
|
|
|
+ if (good_ecal_driven_seed) nonprompt_pur.pt->fill(gsf_track.pt(), nonprompt_matched);
|
|
|
if (gsf_track.pt() > 20)
|
|
|
- nonprompt_pur.eta->fill(gsf_track.eta(), nonprompt_matched);
|
|
|
- if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
|
|
|
- nonprompt_pur.phi->fill(gsf_track.phi(), nonprompt_matched);
|
|
|
+ if (good_ecal_driven_seed) nonprompt_pur.eta->fill(gsf_track.eta(), nonprompt_matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5 and gsf_track.pt() > 20)
|
|
|
+ if (good_ecal_driven_seed) nonprompt_pur.phi->fill(gsf_track.phi(), nonprompt_matched);
|
|
|
|
|
|
// dR-matching
|
|
|
matched = false;
|
|
|
@@ -759,26 +875,34 @@ void run(){
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- if (abs(gsf_track.eta()) < 2.4)
|
|
|
- tracking_pur_dR.pt->fill(gsf_track.pt(), matched);
|
|
|
- if (gsf_track.pt() > 20.0)
|
|
|
- tracking_pur_dR.eta->fill(gsf_track.eta(), matched);
|
|
|
- if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
|
|
|
- tracking_pur_dR.phi->fill(gsf_track.phi(), matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5) {
|
|
|
+ if (good_ecal_driven_seed) tracking_pur_dR.pt->fill(gsf_track.pt(), matched);
|
|
|
+ if (good_seed) tracking_pur_full_dR.pt->fill(gsf_track.pt(), matched);
|
|
|
+ }
|
|
|
+ if (gsf_track.pt() > 20.0) {
|
|
|
+ if (good_ecal_driven_seed) tracking_pur_dR.eta->fill(gsf_track.eta(), matched);
|
|
|
+ if (good_seed) tracking_pur_full_dR.eta->fill(gsf_track.eta(), matched);
|
|
|
+ }
|
|
|
+ if (abs(gsf_track.eta()) < 2.5 and gsf_track.pt() > 20) {
|
|
|
+ if (good_ecal_driven_seed) tracking_pur_dR.phi->fill(gsf_track.phi(), matched);
|
|
|
+ if (good_seed) tracking_pur_full_dR.phi->fill(gsf_track.phi(), matched);
|
|
|
+ if (good_ecal_driven_seed) tracking_pur_v_PU_dR.fill(inTimePileup->get(), matched);
|
|
|
+ }
|
|
|
+ tracking_pur_v_PU_dR_inc.fill(inTimePileup->get(), matched);
|
|
|
|
|
|
- if (abs(gsf_track.eta()) < 2.4)
|
|
|
- prompt_pur_dR.pt->fill(gsf_track.pt(), prompt_matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5)
|
|
|
+ if (good_ecal_driven_seed) prompt_pur_dR.pt->fill(gsf_track.pt(), prompt_matched);
|
|
|
if (gsf_track.pt() > 20)
|
|
|
- prompt_pur_dR.eta->fill(gsf_track.eta(), prompt_matched);
|
|
|
- if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
|
|
|
- prompt_pur_dR.phi->fill(gsf_track.phi(), prompt_matched);
|
|
|
+ if (good_ecal_driven_seed) prompt_pur_dR.eta->fill(gsf_track.eta(), prompt_matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5 and gsf_track.pt() > 20)
|
|
|
+ if (good_ecal_driven_seed) prompt_pur_dR.phi->fill(gsf_track.phi(), prompt_matched);
|
|
|
|
|
|
- if (abs(gsf_track.eta()) < 2.4)
|
|
|
- nonprompt_pur_dR.pt->fill(gsf_track.pt(), nonprompt_matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5)
|
|
|
+ if (good_ecal_driven_seed) nonprompt_pur_dR.pt->fill(gsf_track.pt(), nonprompt_matched);
|
|
|
if (gsf_track.pt() > 20)
|
|
|
- nonprompt_pur_dR.eta->fill(gsf_track.eta(), nonprompt_matched);
|
|
|
- if (abs(gsf_track.eta()) < 2.4 and gsf_track.pt() > 20)
|
|
|
- nonprompt_pur_dR.phi->fill(gsf_track.phi(), nonprompt_matched);
|
|
|
+ if (good_ecal_driven_seed) nonprompt_pur_dR.eta->fill(gsf_track.eta(), nonprompt_matched);
|
|
|
+ if (abs(gsf_track.eta()) < 2.5 and gsf_track.pt() > 20)
|
|
|
+ if (good_ecal_driven_seed) nonprompt_pur_dR.phi->fill(gsf_track.phi(), nonprompt_matched);
|
|
|
}
|
|
|
|
|
|
// Fake-Rate
|
|
|
@@ -795,10 +919,12 @@ void run(){
|
|
|
scl2trk[scl_idx].push_back(gsf_truth_matched);
|
|
|
}
|
|
|
std::set<size_t> tm_scls; // Set of super-clusters with well matched sim-electrons
|
|
|
+ std::set<size_t> tm_scls_no_e_match; // Set of super-clusters with well matched sim-electrons w/o energy matching
|
|
|
for (const auto &scl : scls) {
|
|
|
Vec4 p4 = scl_p4(scl);
|
|
|
for(const auto& sim_track : sim_els) {
|
|
|
if (deltaR(p4.eta(), p4.phi(), sim_track.eta(), sim_track.phi()) > 0.2) continue;
|
|
|
+ tm_scls_no_e_match.insert(scl.idx);
|
|
|
if (((p4.Et() - sim_track.pt()) / p4.Et()) > 0.1) continue;
|
|
|
tm_scls.insert(scl.idx);
|
|
|
break;
|
|
|
@@ -813,7 +939,12 @@ void run(){
|
|
|
if (scl.hoe() > hoe_cut) continue;
|
|
|
float scl_pt = hypot(scl.px(), scl.py());
|
|
|
float scl_eta = pseudorapidity(scl.x(), scl.y(), scl.z());
|
|
|
- float scl_phi = atan2(scl.py(), scl.px());
|
|
|
+ float scl_phi = atan2(scl.y(), scl.x());
|
|
|
+ float rad = hypot(scl.x(), scl.y());
|
|
|
+ /* cout << "weird phi: " << scl_phi << " (" << scl.x() << ", " << scl.y() << ") - " << rad << "\n"; */
|
|
|
+ /* if (scl_phi > 3.141592653589793238 or scl_phi < -3.141592653589793238) { */
|
|
|
+ /* cout << "weird phi: " << scl_phi << " (" << scl.x() << ", " << scl.y() << ")\n"; */
|
|
|
+ /* } */
|
|
|
|
|
|
int ntracks = scl2trk[scl.idx].size();
|
|
|
int ntmtracks = std::accumulate(scl2trk[scl.idx].begin(), scl2trk[scl.idx].end(), 0);
|
|
|
@@ -825,33 +956,45 @@ void run(){
|
|
|
partial_fake_rate_incl.pt->fill(scl_pt, partial_fake);
|
|
|
partial_fake_rate_incl.eta->fill(scl_eta, partial_fake);
|
|
|
partial_fake_rate_incl.phi->fill(scl_phi, partial_fake);
|
|
|
- if (abs(scl_eta) < 2.4) partial_fake_rate.pt->fill(scl_pt, partial_fake);
|
|
|
+ if (abs(scl_eta) < 2.5) partial_fake_rate.pt->fill(scl_pt, partial_fake);
|
|
|
if (scl_pt > 20.0) partial_fake_rate.eta->fill(scl_eta, partial_fake);
|
|
|
- if (abs(scl_eta) < 2.4 and scl_pt > 20) partial_fake_rate.phi->fill(scl_phi, partial_fake);
|
|
|
+ if (abs(scl_eta) < 2.5 and scl_pt > 20) partial_fake_rate.phi->fill(scl_phi, partial_fake);
|
|
|
|
|
|
full_fake_rate_incl.pt->fill(scl_pt, full_fake);
|
|
|
full_fake_rate_incl.eta->fill(scl_eta, full_fake);
|
|
|
full_fake_rate_incl.phi->fill(scl_phi, full_fake);
|
|
|
- if (abs(scl_eta) < 2.4) full_fake_rate.pt->fill(scl_pt, full_fake);
|
|
|
+ if (abs(scl_eta) < 2.5) full_fake_rate.pt->fill(scl_pt, full_fake);
|
|
|
if (scl_pt > 20.0) full_fake_rate.eta->fill(scl_eta, full_fake);
|
|
|
- if (abs(scl_eta) < 2.4 and scl_pt > 20) full_fake_rate.phi->fill(scl_phi, full_fake);
|
|
|
+ if (abs(scl_eta) < 2.5 and scl_pt > 20) full_fake_rate.phi->fill(scl_phi, full_fake);
|
|
|
|
|
|
if (tm_scls.count(scl.idx) == 0) {
|
|
|
clean_fake_rate_incl.pt->fill(scl_pt, full_fake);
|
|
|
clean_fake_rate_incl.eta->fill(scl_eta, full_fake);
|
|
|
clean_fake_rate_incl.phi->fill(scl_phi, full_fake);
|
|
|
- if (abs(scl_eta) < 2.4) clean_fake_rate.pt->fill(scl_pt, full_fake);
|
|
|
+ if (abs(scl_eta) < 2.5) clean_fake_rate.pt->fill(scl_pt, full_fake);
|
|
|
if (scl_pt > 20.0) clean_fake_rate.eta->fill(scl_eta, full_fake);
|
|
|
- if (abs(scl_eta) < 2.4 and scl_pt > 20) clean_fake_rate.phi->fill(scl_phi, full_fake);
|
|
|
+ if (abs(scl_eta) < 2.5 and scl_pt > 20) clean_fake_rate.phi->fill(scl_phi, full_fake);
|
|
|
}
|
|
|
}
|
|
|
if (tm_scls.count(scl.idx) == 0) {
|
|
|
fake_rate_incl.pt->fill(scl_pt, ntracks>0);
|
|
|
fake_rate_incl.eta->fill(scl_eta, ntracks>0);
|
|
|
fake_rate_incl.phi->fill(scl_phi, ntracks>0);
|
|
|
- if (abs(scl_eta) < 2.4) fake_rate.pt->fill(scl_pt, ntracks>0);
|
|
|
+ if (abs(scl_eta) < 2.5) fake_rate.pt->fill(scl_pt, ntracks>0);
|
|
|
if (scl_pt > 20.0) fake_rate.eta->fill(scl_eta, ntracks>0);
|
|
|
- if (abs(scl_eta) < 2.4 and scl_pt > 20) fake_rate.phi->fill(scl_phi, ntracks>0);
|
|
|
+ if (abs(scl_eta) < 2.5 and scl_pt > 20) fake_rate.phi->fill(scl_phi, ntracks>0);
|
|
|
+ }
|
|
|
+ if (tm_scls_no_e_match.count(scl.idx) == 0) {
|
|
|
+ fake_rate_no_e_match_incl.pt->fill(scl_pt, ntracks>0);
|
|
|
+ fake_rate_no_e_match_incl.eta->fill(scl_eta, ntracks>0);
|
|
|
+ fake_rate_no_e_match_incl.phi->fill(scl_phi, ntracks>0);
|
|
|
+ if (abs(scl_eta) < 2.5) fake_rate_no_e_match.pt->fill(scl_pt, ntracks>0);
|
|
|
+ if (scl_pt > 20.0) fake_rate_no_e_match.eta->fill(scl_eta, ntracks>0);
|
|
|
+ if (abs(scl_eta) < 2.5 and scl_pt > 20) {
|
|
|
+ fake_rate_no_e_match.phi->fill(scl_phi, ntracks>0);
|
|
|
+ fake_rate_no_e_match_v_PU.fill(inTimePileup->get(), ntracks>0);
|
|
|
+ }
|
|
|
+ fake_rate_no_e_match_v_PU_inc.fill(inTimePileup->get(), ntracks>0);
|
|
|
}
|
|
|
/* cout << endl; */
|
|
|
}
|
