hpstr
The Heavy Photon Search Toolkit for Reconstruction (hpstr) provides an interface to physics data from the HPS experiment saved in the LCIO format and converts it into an ROOT based format.
Loading...
Searching...
No Matches
SimpZBiOptimizationProcessor.cxx
Go to the documentation of this file.
2
3#include <cstdlib>
4#include <fstream>
5#include <iostream>
6#include <string>
7
10 std::cout << "[SimpZBiOptimizationProcessor] Constructor()" << std::endl;
11}
12
14
16 std::cout << "[SimpZBiOptimizationProcessor] configure()" << std::endl;
17 try {
18 // Basic config
19 debug_ = parameters.getInteger("debug", debug_);
20 max_iteration_ = parameters.getInteger("max_iteration", max_iteration_);
21 year_ = parameters.getInteger("year", year_);
22 cuts_cfgFile_ = parameters.getString("cuts_cfgFile", cuts_cfgFile_);
23 outFileName_ = parameters.getString("outFileName", outFileName_);
24 cutVariables_ = parameters.getVString("cutVariables", cutVariables_);
25 min_ztail_events_ = parameters.getDouble("ztail_events", min_ztail_events_);
26 scan_zcut_ = parameters.getInteger("scan_zcut", scan_zcut_);
27 step_size_ = parameters.getDouble("step_size", step_size_);
28 eq_cfgFile_ = parameters.getString("eq_cfgFile", eq_cfgFile_);
29
30 // Background
31 bkgVtxAnaFilename_ = parameters.getString("bkgVtxAnaFilename", bkgVtxAnaFilename_);
32 bkgVtxAnaTreename_ = parameters.getString("bkgVtxAnaTreename", bkgVtxAnaTreename_);
33 background_sf_ = parameters.getDouble("background_sf", background_sf_);
34
35 // MC Signal
36 variableHistCfgFilename_ = parameters.getString("variableHistCfgFilename", variableHistCfgFilename_);
37 signalVtxAnaFilename_ = parameters.getString("signalVtxAnaFilename", signalVtxAnaFilename_);
38 signalVtxAnaTreename_ = parameters.getString("signalVtxAnaTreename", signalVtxAnaTreename_);
39 signalVtxMCSelection_ = parameters.getString("signalVtxMCSelection", signalVtxMCSelection_);
40 signalMCAnaFilename_ = parameters.getString("signalMCAnaFilename", signalMCAnaFilename_);
41 signal_pdgid_ = parameters.getString("signal_pdgid", signal_pdgid_);
42 signal_sf_ = parameters.getDouble("signal_sf", signal_sf_);
43 signal_mass_ = parameters.getDouble("signal_mass", signal_mass_);
44 mass_window_nsigma_ = parameters.getDouble("mass_window_nsigma", mass_window_nsigma_);
45 logEps2_ = parameters.getDouble("logEps2", logEps2_);
46
47 // Expected Signal Calculation
48 radFrac_ = parameters.getDouble("radFrac", radFrac_);
49 radAcc_ = parameters.getDouble("radAcc", radAcc_);
50 bkgControlRegionFilename_ = parameters.getString("bkgControlRegionFilename", bkgControlRegionFilename_);
51 bkgControlRegionTreename_ = parameters.getString("bkgControlRegionTreename", bkgControlRegionTreename_);
52 dNdm_sf_ = parameters.getDouble("dNdm_sf", dNdm_sf_);
53
54 // New Variables //
55 new_variables_ = parameters.getVString("add_new_variables", new_variables_);
56 new_variable_params_ = parameters.getVDouble("new_variable_params", new_variable_params_);
57
58 } catch (std::runtime_error& error) {
59 std::cout << error.what() << std::endl;
60 }
61}
62
63// USE JSON FILE TO LOAD IN NEW VARIABLES AND VARIABLE CONFIGURATIONS
64void SimpZBiOptimizationProcessor::addNewVariables(SimpAnaTTree* MTT, std::string variable, double param) {
65 std::cout << "[SimpZBiOptimizationProcessor]::addNewVariable " << variable << " with param " << param << std::endl;
66 if (variable == "unc_vtx_ele_zalpha") MTT->addVariable_unc_vtx_ele_zalpha(param);
67 if (variable == "unc_vtx_pos_zalpha") MTT->addVariable_unc_vtx_pos_zalpha(param);
68
69 if (variable == "unc_vtx_zalpha_max") MTT->addVariable_unc_vtx_zalpha_max(param);
70 if (variable == "unc_vtx_zalpha_min") MTT->addVariable_unc_vtx_zalpha_min(param);
71
72 if (variable == "unc_vtx_ele_iso_z0err") MTT->addVariable_unc_vtx_ele_iso_z0err();
73 if (variable == "unc_vtx_pos_iso_z0err") MTT->addVariable_unc_vtx_pos_iso_z0err();
74
75 if (variable == "unc_vtx_ele_z0_z0err") MTT->addVariable_unc_vtx_ele_z0_z0err();
76 if (variable == "unc_vtx_pos_z0_z0err") MTT->addVariable_unc_vtx_pos_z0_z0err();
77
78 if (variable == "unc_vtx_ele_isolation_cut") MTT->addVariable_unc_vtx_ele_isolation_cut();
79 if (variable == "unc_vtx_pos_isolation_cut") MTT->addVariable_unc_vtx_pos_isolation_cut();
80
81 if (variable == "unc_vtx_ele_z0tanlambda") MTT->addVariable_unc_vtx_ele_z0tanlambda();
82 if (variable == "unc_vtx_pos_z0tanlambda") MTT->addVariable_unc_vtx_pos_z0tanlambda();
83
84 if (variable == "unc_vtx_ele_z0tanlambda_right") MTT->addVariable_unc_vtx_ele_z0tanlambda_right(param);
85 if (variable == "unc_vtx_pos_z0tanlambda_right") MTT->addVariable_unc_vtx_pos_z0tanlambda_right(param);
86
87 if (variable == "unc_vtx_ele_z0tanlambda_left") MTT->addVariable_unc_vtx_ele_z0tanlambda_left(param);
88 if (variable == "unc_vtx_pos_z0tanlambda_left") MTT->addVariable_unc_vtx_pos_z0tanlambda_left(param);
89
90 if (variable == "unc_vtx_abs_delta_z0tanlambda") MTT->addVariable_unc_vtx_abs_delta_z0tanlambda();
91
92 // if(variable == "unc_vtx_proj_significance")
93 // MTT->addVariable_unc_vtx_proj_significance();
94
95 // else
96 // std::cout << "[SimpZBiOptimization]::ERROR::NEW VARIABLE " << variable << " IS NOT DEFINED IN
97 // SimpAnaTTree.cxx"
98 // <<std::endl;
99}
100
101void SimpZBiOptimizationProcessor::fillEventHistograms(std::shared_ptr<ZBiHistos> histos, SimpAnaTTree* MTT) {
102 // histos->Fill histograms for each variable defined in tree
103 std::vector<std::string> variables = MTT->getAllVariables();
104 for (std::vector<std::string>::iterator it = variables.begin(); it != variables.end(); it++) {
105 std::string var = *it;
106 histos->Fill1DHisto(var + "_h", MTT->getValue(var));
107 }
108
109 // Impact Parameter
110 histos->Fill2DHisto("z0_v_recon_z_hh", MTT->getValue("unc_vtx_z"), MTT->getValue("unc_vtx_ele_track_z0"));
111 histos->Fill2DHisto("z0_v_recon_z_hh", MTT->getValue("unc_vtx_z"), MTT->getValue("unc_vtx_pos_track_z0"));
112
113 // Inv mass
114 histos->Fill2DHisto("vtx_InvM_vtx_z_hh", MTT->getValue("unc_vtx_mass") * 1000.0, MTT->getValue("unc_vtx_z"));
115 // track z0
116 histos->Fill2DHisto("ele_track_z0_v_pos_track_z0_hh", MTT->getValue("unc_vtx_ele_track_z0"),
117 MTT->getValue("unc_vtx_pos_track_z0"));
118
119 // Zalpha
120 if (MTT->variableExists("unc_vtx_ele_zalpha")) {
121 histos->Fill2DHisto("z0_v_unc_vtx_zalpha_hh", MTT->getValue("unc_vtx_ele_zalpha"),
122 MTT->getValue("unc_vtx_ele_track_z0"));
123 }
124 if (MTT->variableExists("unc_vtx_pos_zalpha")) {
125 histos->Fill2DHisto("z0_v_unc_vtx_zalpha_hh", MTT->getValue("unc_vtx_pos_zalpha"),
126 MTT->getValue("unc_vtx_pos_track_z0"));
127 }
128 if (MTT->variableExists("unc_vtx_zalpha_max")) {
129 histos->Fill2DHisto("recon_z_v_unc_vtx_zalpha_max_hh", MTT->getValue("unc_vtx_zalpha_max"),
130 MTT->getValue("unc_vtx_z"));
131 }
132
133 // v0 projection
134 if (MTT->variableExists("unc_vtx_proj_x")) {
135 histos->Fill2DHisto("unc_vtx_proj_x_v_unc_vtx_proj_y_hh", MTT->getValue("unc_vtx_proj_x"),
136 MTT->getValue("unc_vtx_proj_y"));
137 }
138 if (MTT->variableExists("unc_vtx_proj_x_sig")) {
139 histos->Fill2DHisto("unc_vtx_proj_x_y_significance_hh", MTT->getValue("unc_vtx_proj_x_sig"),
140 MTT->getValue("unc_vtx_proj_y_sig"));
141 }
142 if (MTT->variableExists("unc_vtx_proj_sig")) {
143 histos->Fill2DHisto("recon_z_v_proj_sig_hh", MTT->getValue("unc_vtx_proj_sig"), MTT->getValue("unc_vtx_z"));
144 }
145
146 // Vertex Errors
147 if (MTT->variableExists("unc_vtx_cxx")) {
148 histos->Fill2DHisto("recon_z_v_cxx_hh", MTT->getValue("unc_vtx_cxx"), MTT->getValue("unc_vtx_z"));
149 histos->Fill2DHisto("recon_z_v_cyy_hh", MTT->getValue("unc_vtx_cyy"), MTT->getValue("unc_vtx_z"));
150 histos->Fill2DHisto("recon_z_v_czz_hh", MTT->getValue("unc_vtx_czz"), MTT->getValue("unc_vtx_z"));
151 histos->Fill2DHisto("recon_z_v_czx_hh", MTT->getValue("unc_vtx_czx"), MTT->getValue("unc_vtx_z"));
152 histos->Fill2DHisto("recon_z_v_czy_hh", MTT->getValue("unc_vtx_czy"), MTT->getValue("unc_vtx_z"));
153 histos->Fill2DHisto("recon_z_v_cyx_hh", MTT->getValue("unc_vtx_cyx"), MTT->getValue("unc_vtx_z"));
154 }
155 // Z0TanLambda
156 histos->Fill2DHisto("recon_z_v_z0tanlambda_hh",
157 MTT->getValue("unc_vtx_ele_track_z0") / MTT->getValue("unc_vtx_ele_track_tanLambda"),
158 MTT->getValue("unc_vtx_z"));
159 histos->Fill2DHisto("recon_z_v_z0tanlambda_hh",
160 MTT->getValue("unc_vtx_pos_track_z0") / MTT->getValue("unc_vtx_pos_track_tanLambda"),
161 MTT->getValue("unc_vtx_z"));
162 if (MTT->variableExists("unc_vtx_deltaZ")) {
163 histos->Fill2DHisto("recon_z_v_unc_vtx_deltaZ_hh", MTT->getValue("unc_vtx_deltaZ"), MTT->getValue("unc_vtx_z"));
164 }
165 // z0 error
166 histos->Fill2DHisto("recon_z_v_Z0err_hh", MTT->getValue("unc_vtx_ele_track_z0Err"), MTT->getValue("unc_vtx_z"));
167 histos->Fill2DHisto("recon_z_v_Z0err_hh", MTT->getValue("unc_vtx_pos_track_z0Err"), MTT->getValue("unc_vtx_z"));
168 // track time
169 histos->Fill2DHisto("recon_z_v_track_t_hh", MTT->getValue("unc_vtx_ele_track_t"), MTT->getValue("unc_vtx_z"));
170 histos->Fill2DHisto("recon_z_v_track_t_hh", MTT->getValue("unc_vtx_pos_track_t"), MTT->getValue("unc_vtx_z"));
171
172 // Track parameters
173 histos->Fill2DHisto("recon_z_v_ele_track_d0_hh", MTT->getValue("unc_vtx_ele_track_d0"), MTT->getValue("unc_vtx_z"));
174 histos->Fill2DHisto("recon_z_v_pos_track_d0_hh", MTT->getValue("unc_vtx_pos_track_d0"), MTT->getValue("unc_vtx_z"));
175 histos->Fill2DHisto("recon_z_v_ele_track_phi0_hh", MTT->getValue("unc_vtx_ele_track_phi0"),
176 MTT->getValue("unc_vtx_z"));
177 histos->Fill2DHisto("recon_z_v_pos_track_phi0_hh", MTT->getValue("unc_vtx_pos_track_phi0"),
178 MTT->getValue("unc_vtx_z"));
179 histos->Fill2DHisto("recon_z_v_ele_track_px_hh", MTT->getValue("unc_vtx_ele_track_px"), MTT->getValue("unc_vtx_z"));
180 histos->Fill2DHisto("recon_z_v_pos_track_px_hh", MTT->getValue("unc_vtx_pos_track_px"), MTT->getValue("unc_vtx_z"));
181 histos->Fill2DHisto("recon_z_v_ele_track_py_hh", MTT->getValue("unc_vtx_ele_track_py"), MTT->getValue("unc_vtx_z"));
182 histos->Fill2DHisto("recon_z_v_pos_track_py_hh", MTT->getValue("unc_vtx_pos_track_py"), MTT->getValue("unc_vtx_z"));
183 histos->Fill2DHisto("recon_z_v_ele_track_pz_hh", MTT->getValue("unc_vtx_ele_track_pz"), MTT->getValue("unc_vtx_z"));
184 histos->Fill2DHisto("recon_z_v_pos_track_pz_hh", MTT->getValue("unc_vtx_pos_track_pz"), MTT->getValue("unc_vtx_z"));
185 histos->Fill2DHisto("recon_z_v_ele_track_nhits_hh", MTT->getValue("unc_vtx_ele_track_nhits"),
186 MTT->getValue("unc_vtx_z"));
187 histos->Fill2DHisto("recon_z_v_pos_track_nhits_hh", MTT->getValue("unc_vtx_pos_track_nhits"),
188 MTT->getValue("unc_vtx_z"));
189
190 // track params vs params
191 histos->Fill2DHisto("ele_tanlambda_vs_phi0_hh", MTT->getValue("unc_vtx_ele_track_phi0"),
192 MTT->getValue("unc_vtx_ele_track_tanLambda"));
193 histos->Fill2DHisto("pos_tanlambda_vs_phi0_hh", MTT->getValue("unc_vtx_pos_track_phi0"),
194 MTT->getValue("unc_vtx_pos_track_tanLambda"));
195 histos->Fill2DHisto("ele_cluster_energy_v_track_p_hh", MTT->getValue("unc_vtx_ele_track_p"),
196 MTT->getValue("unc_vtx_ele_clust_E"));
197 histos->Fill2DHisto("pos_cluster_energy_v_track_p_hh", MTT->getValue("unc_vtx_pos_track_p"),
198 MTT->getValue("unc_vtx_pos_clust_E"));
199 histos->Fill2DHisto("ele_z0_vs_tanlambda_hh", MTT->getValue("unc_vtx_ele_track_tanLambda"),
200 MTT->getValue("unc_vtx_ele_track_z0"));
201 histos->Fill2DHisto("pos_z0_vs_tanlambda_hh", MTT->getValue("unc_vtx_pos_track_tanLambda"),
202 MTT->getValue("unc_vtx_pos_track_z0"));
203}
204
205double SimpZBiOptimizationProcessor::countControlRegionBackgroundRate(std::string inFilename, std::string tree_name,
206 double m_Ap, double Mbin, double dNdm_sf) {
207 double dNdm = 0.0;
208 TFile inFile(inFilename.c_str(), "READ");
209 TTree* tree = (TTree*)inFile.Get((tree_name + "/" + tree_name + "_tree").c_str());
210 double mass;
211 std::cout << "Counting: Ap mass is " << m_Ap << std::endl;
212 tree->SetBranchAddress("unc_vtx_mass", &mass);
213 std::cout << "N entries: " << tree->GetEntries() << std::endl;
214 for (int e = 0; e < tree->GetEntries(); e++) {
215 tree->GetEntry(e);
216 if (mass * 1000.0 > m_Ap + (Mbin / 2)) continue;
217 if (mass * 1000.0 < m_Ap - (Mbin / 2)) continue;
218 dNdm = dNdm + 1.0;
219 }
220 dNdm = dNdm / Mbin;
221 dNdm = dNdm * dNdm_sf;
222 std::cout << "Background Rate in CR: " << dNdm << std::endl;
223 inFile.Close();
224
225 return dNdm;
226}
227
228void SimpZBiOptimizationProcessor::initialize(std::string inFilename, std::string outFilename) {
229 std::cout << "[SimpZBiOptimizationProcessor] Initialize " << inFilename << std::endl;
230
231 // Load Simp Equations
233 massResolution_ = simpEqs_->massResolution(signal_mass_);
234
235 // Define Mass window
238 std::cout << "[SimpZBiOptimization]::Mass Window: " << lowMass_ << " - " << highMass_ << std::endl;
239
240 // Initialize output file
241 std::cout << "[SimpZBiOptimization]::Output File: " << outFileName_.c_str() << std::endl;
242 outFile_ = new TFile(outFileName_.c_str(), "RECREATE");
243
244 // Get the signal pretrigger simulated vertex z distribution
245 std::cout << "[SimpZBiOptimization]::Getting MC Signal pre-trigger vertex z distribution from file "
246 << signalMCAnaFilename_ << std::endl;
248 outFile_->cd();
249 signalSimZ_h_->Write();
250
251 // Read signal ana vertex tuple, and convert to mutable tuple
252 std::cout << "[SimpZBiOptimization]::Reading Signal AnaVertex Tuple from file " << signalVtxAnaFilename_.c_str()
253 << std::endl;
254 TFile* signalVtxAnaFile = new TFile(signalVtxAnaFilename_.c_str(), "READ");
255 signalMTT_ =
256 new SimpAnaTTree(signalVtxAnaFile, (signalVtxAnaTreename_ + "/" + signalVtxAnaTreename_ + "_tree").c_str());
257 signalMTT_->defineMassWindow(lowMass_, highMass_);
258
259 // Get Simp Mean Truth Energy
260 std::cout << "Get Mean Truth Energy" << std::endl;
261 TH1F* signalEnergy_h = (TH1F*)signalVtxAnaFile->Get(
262 (signalVtxMCSelection_ + "/" + signalVtxMCSelection_ + "_mc" + signal_pdgid_ + "Energy_h").c_str());
263 std::cout << "Got the histo " << std::endl;
264 if (signalEnergy_h == nullptr) std::cout << "HISTO IS NULL" << std::endl;
265 E_Vd_ = (double)signalEnergy_h->GetMean();
266 std::cout << "Mean Energy is " << E_Vd_ << std::endl;
267
268 // Read background ana vertex tuple, and convert to mutable tuple
269 std::cout << "[SimpZBiOptimization]::Reading Background AnaVertex Tuple from file " << signalVtxAnaFilename_.c_str()
270 << std::endl;
271 TFile* bkgVtxAnaFile = new TFile(bkgVtxAnaFilename_.c_str(), "READ");
272 bkgMTT_ = new SimpAnaTTree(bkgVtxAnaFile, (bkgVtxAnaTreename_ + "/" + bkgVtxAnaTreename_ + "_tree").c_str());
273 bkgMTT_->defineMassWindow(lowMass_, highMass_);
274
275 // Add new variables, as defined in SimpAnaTTree.cxx, from the processor configuration script
276 for (std::vector<std::string>::iterator it = new_variables_.begin(); it != new_variables_.end(); it++) {
277 int param_idx = std::distance(new_variables_.begin(), it);
278 std::cout << "[SimpZBiOptimization]::Attempting to add new variable " << *it << " with parameter "
279 << new_variable_params_.at(param_idx) << std::endl;
280 // signalMTT_->addVariable(*it, new_variable_params_.at(param_idx));
281 // bkgMTT_->addVariable(*it, new_variable_params_.at(param_idx));
283 addNewVariables(bkgMTT_, *it, new_variable_params_.at(param_idx));
284 }
285
286 // Finalize Initialization of New Mutable Tuples
287 std::cout << "[SimpZBiOptimization]::Finalizing Initialization of New Mutable Tuples" << std::endl;
288 signalMTT_->shiftVariable("unc_vtx_ele_track_z0", -0.07);
289 signalMTT_->shiftVariable("unc_vtx_pos_track_z0", -0.07);
290 signalMTT_->Fill();
291 bkgMTT_->Fill();
292
293 // Initialize Persistent Cut Selector. These cuts are applied to all events.
294 // Persistent Cut values are updated each iteration with the value of the best performing Test Cut in
295 // that iteration.
296 std::cout << "[SimpZBiOptimization]::Initializing Set of Persistent Cuts" << std::endl;
298 persistentCutsSelector_->LoadSelection();
299 persistentCutsPtr_ = persistentCutsSelector_->getPointerToCuts();
300 std::cout << "Persistent Cuts: " << std::endl;
301 persistentCutsSelector_->printCuts();
302
303 // initalize Test Cuts
304 std::cout << "[SimpZBiOptimization]::Initializing Set of Test Cuts" << std::endl;
306 testCutsSelector_->LoadSelection();
307 testCutsPtr_ = testCutsSelector_->getPointerToCuts();
308 testCutsSelector_->filterCuts(cutVariables_);
309 std::cout << "Test Cuts: " << std::endl;
310 testCutsSelector_->printCuts();
311
312 // Initialize signal histograms
313 std::cout << "[SimpZBiOptimization]::Initializing Signal Variable Histograms" << std::endl;
314 signalHistos_ = std::make_shared<ZBiHistos>("signal");
315 signalHistos_->debugMode(debug_);
316 signalHistos_->loadHistoConfig(variableHistCfgFilename_);
317 signalHistos_->DefineHistos();
318
320 std::cout << "[SimpZBiOptimization]::Initializing Background Variable Histograms" << std::endl;
321 bkgHistos_ = std::make_shared<ZBiHistos>("background");
322 bkgHistos_->debugMode(debug_);
323 bkgHistos_->loadHistoConfig(variableHistCfgFilename_);
324 bkgHistos_->DefineHistos();
325
326 // Initialize Test Cut histograms
327 std::cout << "[SimpZBiOptimization]::Initializing Test Cut Variable Histograms" << std::endl;
328 testCutHistos_ = std::make_shared<ZBiHistos>("testCutHistos");
329 testCutHistos_->debugMode(debug_);
330 testCutHistos_->DefineHistos();
331
332 // Add Test Cut Analysis Histograms necessary for calculating background and signal
333 std::cout << "[SimpZBiOptimization]::Initializing Test Cut Analysis Histograms" << std::endl;
334 for (cut_iter_ it = testCutsPtr_->begin(); it != testCutsPtr_->end(); it++) {
335 std::string name = it->first;
336 // Used to select true z vertex distribution given a cut in unc_vtx_z
337 testCutHistos_->addHisto2d("unc_vtx_z_vs_true_vtx_z_" + name + "_hh", "unc z_{vtx} [mm]", 1500, -50.0, 100.0,
338 "true z_{vtx} [mm]", 200, -50.3, 149.7);
339 // signalSelZ models signal selection efficiency
340 testCutHistos_->addHisto1d("signal_SelZ_" + name + "_h", "true z_{vtx} [mm]", 200, -50.3, 149.7);
341 // background_zVtx provides basis for background model, used to estimate nbackground in signal region
342 testCutHistos_->addHisto1d("background_zVtx_" + name + "_h", "unc z_{vtx} [mm]", 150, -50.0, 100.0);
343 }
344
345 // Initialize processor histograms that summarize iterative results
346 std::cout << "[SimpZBiOptimization]::Initializing Itearitve Result Histograms" << std::endl;
347 processorHistos_ = std::make_shared<ZBiHistos>("zbi_processor");
348 processorHistos_->defineZBiCutflowProcessorHistograms();
349
350 // Fill Initial Signal histograms
351 std::cout << "[SimpZBiOptimization]::Filling initial signal histograms" << std::endl;
352 for (int e = 0; e < signalMTT_->GetEntries(); e++) {
353 signalMTT_->GetEntry(e);
355 }
356
357 std::cout << "[SimpZBiOptimization]::Filling initial background histograms" << std::endl;
358 // Fill Initial Background Histograms
359 for (int e = 0; e < bkgMTT_->GetEntries(); e++) {
360 bkgMTT_->GetEntry(e);
362 }
363
364 // Count background rate in the Control Region (used to calculate total A' Rate)
365 double m_Ap = simpEqs_->getAprimeMassFromVectorMass(signal_mass_);
366 dNdm_ =
368
369 // Write initial variable histograms for signal and background
370 std::cout << "[SimpZBiOptimization]::Writing Initial Histograms" << std::endl;
371 signalHistos_->writeHistos(outFile_, "initial_signal");
372 bkgHistos_->writeHistos(outFile_, "initial_background");
373}
374
376 std::cout << "[SimpZBiOptimizationProcessor]::process()" << std::endl;
377
378 // step_size defines n% of signal distribution to cut in a given variable
379 std::cout << "step_size_ " << step_size_ << std::endl;
380 double cutFraction = step_size_;
381 if (max_iteration_ > (int)1.0 / cutFraction) max_iteration_ = (int)1.0 / cutFraction;
382
383 std::cout << "max iteration: " << max_iteration_ << std::endl;
384 // Iteratively cut n% of the signal distribution for a given Test Cut variable
385 for (int iteration = 0; iteration < max_iteration_ + 1; iteration++) {
386 double cutSignal = (double)iteration * step_size_ * 100.0;
387 cutSignal = round(cutSignal);
388 if (debug_) std::cout << "## ITERATION " << iteration << " ##" << std::endl;
389
390 // Reset histograms at the start of each iteration
391 // Histograms will change with each iteration.
392 if (debug_) std::cout << "[SimpZBiOptimization]::Resetting Histograms" << std::endl;
393 signalHistos_->resetHistograms1d();
394 signalHistos_->resetHistograms2d();
395 bkgHistos_->resetHistograms1d();
396 bkgHistos_->resetHistograms2d();
397 testCutHistos_->resetHistograms1d();
398 testCutHistos_->resetHistograms2d();
399
400 // At the start of each iteration, save the persistent cut values
401 for (cut_iter_ it = persistentCutsPtr_->begin(); it != persistentCutsPtr_->end(); it++) {
402 std::string cutname = it->first;
403 double cutvalue = persistentCutsSelector_->getCut(cutname);
404 if (debug_) {
405 std::cout << "Saving persistent cut: " << cutname << " " << cutvalue << std::endl;
406 }
407 int cutid = persistentCutsSelector_->getCutID(cutname);
408 processorHistos_->Fill2DHisto("persistent_cuts_hh", (double)cutSignal, (double)cutid, cutvalue);
409 processorHistos_->set2DHistoYlabel("persistent_cuts_hh", cutid, cutname);
410 }
411
412 // Fill signal variable distributions
413 for (int e = 0; e < signalMTT_->GetEntries(); e++) {
414 signalMTT_->GetEntry(e);
415
416 // Apply current set of persistent cuts to all events
417 if (failPersistentCuts(signalMTT_)) continue;
418
419 // Fill Signal variable distributions
421 }
422 if (iteration == max_iteration_) {
423 // Write iteration histos
424 signalHistos_->writeHistos(outFile_, "signal_pct_sig_cut_" + std::to_string(cutSignal));
425 bkgHistos_->writeHistos(outFile_, "background_pct_sig_cut_" + std::to_string(cutSignal));
426 break;
427 }
428
429 // Initialize Signal Integrals
430 if (iteration == 0) {
431 // Integrate each signal variable distribution.
432 // When iterating Test Cuts, we reference these intial integrals, cutting n% of the original distribution.
433 std::cout << "[SimpZBiOptimization]::Integrating initial Signal distributions" << std::endl;
434 for (cut_iter_ it = testCutsPtr_->begin(); it != testCutsPtr_->end(); it++) {
435 std::string cutname = it->first;
436 std::string var = testCutsSelector_->getCutVar(cutname);
437 initialIntegrals_[var] = signalHistos_->integrateHistogram1D("signal_" + var + "_h");
438 if (debug_)
439 std::cout << "Initial Integral for " << var << " is " << initialIntegrals_[var] << std::endl;
440 }
441 }
442
443 // Loop over each Test Cut. Cut n% of signal distribution in Test Cut variable
444 if (debug_) std::cout << "Looping over Signal Test Cuts" << std::endl;
445 for (cut_iter_ it = testCutsPtr_->begin(); it != testCutsPtr_->end(); it++) {
446 std::string cutname = it->first;
447 std::string cutvar = testCutsSelector_->getCutVar(cutname);
448 bool isCutGT = testCutsSelector_->isCutGreaterThan(cutname);
449 double cutvalue = signalHistos_->cutFractionOfSignalVariable(cutvar, isCutGT, iteration * cutFraction,
450 initialIntegrals_[cutvar]);
451 testCutsSelector_->setCutValue(cutname, cutvalue);
452 if (debug_) {
453 std::cout << "Test Cut " << cutname << " " << testCutsSelector_->getCut(cutname) << " cuts "
454 << cutSignal << "% of signal distribution in this variable " << std::endl;
455 }
456 }
457
458 // Fill Background Histograms corresponding to each Test Cut
459 if (debug_) std::cout << "Filling Background Variables for each Test Cut" << std::endl;
460 for (int e = 0; e < bkgMTT_->GetEntries(); e++) {
461 bkgMTT_->GetEntry(e);
462
463 // Apply persistent cuts
464 if (failPersistentCuts(bkgMTT_)) continue;
465
467
468 // Loop over each Test Cut
469 for (cut_iter_ it = testCutsPtr_->begin(); it != testCutsPtr_->end(); it++) {
470 std::string cutname = it->first;
471 std::string cutvar = testCutsSelector_->getCutVar(cutname);
472
473 // apply Test Cut
474 if (failTestCut(cutname, bkgMTT_)) continue;
475
476 // If event passes Test Cut, fill vertex z distribution.
477 // This distribution is used to build the Background Model corresponding to each Test Cut
478 testCutHistos_->Fill1DHisto("background_zVtx_" + cutname + "_h", bkgMTT_->getValue("unc_vtx_z"),
480 }
481 }
482
483 // For each Test Cut, build relationship between Signal truth z_vtx, and reconstructed z_vtx
484 // This is used to get the truth Signal Selection Efficiency F(z), given a Zcut in reconstructed z_vtx
485 if (debug_) std::cout << "Build Signal truth z vs recon z" << std::endl;
486 for (int e = 0; e < signalMTT_->GetEntries(); e++) {
487 signalMTT_->GetEntry(e);
488
489 // Apply persistent cuts
490 if (failPersistentCuts(signalMTT_)) continue;
491
492 // Loop over each Test Cut and plot unc_vtx_z vs true_vtx_z
493 for (cut_iter_ it = testCutsPtr_->begin(); it != testCutsPtr_->end(); it++) {
494 std::string cutname = it->first;
495 std::string cutvar = testCutsSelector_->getCutVar(cutname);
496 double cutvalue = testCutsSelector_->getCut(cutname);
497 // Apply Test Cut
498 if (!testCutsSelector_->passCutGTorLT(cutname, signalMTT_->getValue(cutvar))) continue;
499 testCutHistos_->Fill2DHisto("unc_vtx_z_vs_true_vtx_z_" + cutname + "_hh",
500 signalMTT_->getValue("unc_vtx_z"), signalMTT_->getValue("vd_true_vtx_z"),
501 1.0);
502 }
503 }
504
505 // Calcuate the Binomial Significance ZBi corresponding to each Test Cut
506 // Test Cut with maximum ZBi after cutting n% of signal distribution in a given variable is selected
507 // Test Cut value is added to list of Persistent Cuts, and is applied to all events in following iterations.
508
509 // Create Directory for this iteration
510 std::string iteration_subdir = "testCuts_pct_sig_cut_" + std::to_string(cutSignal);
511 TDirectory* dir{nullptr};
512 std::cout << iteration_subdir.c_str() << std::endl;
513 if (!iteration_subdir.empty()) {
514 dir = outFile_->mkdir(iteration_subdir.c_str(), "", true);
515 }
516 double best_zbi = -9999.9;
517 double best_zcut = -9999.9;
518 double best_nsig = -9999.9;
519 double best_nbkg = -9999.9;
520 std::string best_cutname;
521 double best_cutvalue;
522
523 // Loop over Test Cuts
524 if (debug_) std::cout << "Calculate ZBi for each Test Cut " << std::endl;
525 for (cut_iter_ it = testCutsPtr_->begin(); it != testCutsPtr_->end(); it++) {
526 std::string cutname = it->first;
527 double cutvalue = testCutsSelector_->getCut(cutname);
528 int cutid = testCutsSelector_->getCutID(cutname);
529 if (debug_) {
530 std::cout << "Calculating ZBi for Test Cut " << cutname << std::endl;
531 std::cout << "Test Cut ID: " << cutid << " | Test Cut Value: " << cutvalue << std::endl;
532 }
533
534 // Build Background Model, used to estimate nbkg in Signal Region
535 if (debug_) std::cout << "Build Background Model" << std::endl;
536 double start_fit = 500.0 * background_sf_;
537 TF1* bkg_model = (TF1*)testCutHistos_->fitExponentialTail("background_zVtx_" + cutname, start_fit);
538 // TF1* bkg_model = (TF1*)testCutHistos_->fitExponentialPlusConst("background_zVtx_"+cutname, start_fit);
539 if (debug_) std::cout << "END Build Background Model" << std::endl;
540
541 // Get signal unc_vtx_z vs true_vtx_z
542 TH2F* vtx_z_hh =
543 (TH2F*)testCutHistos_->get2dHisto("testCutHistos_unc_vtx_z_vs_true_vtx_z_" + cutname + "_hh");
544
545 // CD to output file to save resulting plots
546 outFile_->cd();
547
548 // Graphs track the performance of a Test Cut as a function of Zcut position
549 TGraph* zcutscan_zbi_g = new TGraph();
550 zcutscan_zbi_g->SetName(("zcut_vs_zbi_" + cutname + "_g").c_str());
551 zcutscan_zbi_g->SetTitle(("zcut_vs_zbi_" + cutname + "_g;zcut [mm];zbi").c_str());
552 zcutscan_zbi_g->SetMarkerStyle(8);
553 zcutscan_zbi_g->SetMarkerSize(2.0);
554 zcutscan_zbi_g->SetMarkerColor(2);
555
556 TGraph* zcutscan_nsig_g = new TGraph();
557 zcutscan_nsig_g->SetName(("zcut_vs_nsig_" + cutname + "_g").c_str());
558 zcutscan_nsig_g->SetTitle(("zcut_vs_nsig_" + cutname + "_g;zcut [mm];nsig").c_str());
559 zcutscan_nsig_g->SetMarkerStyle(23);
560 zcutscan_nsig_g->SetMarkerSize(2.0);
561 zcutscan_nsig_g->SetMarkerColor(57);
562
563 TGraph* zcutscan_nbkg_g = new TGraph();
564 zcutscan_nbkg_g->SetName(("zcut_vs_nbkg_" + cutname + "_g").c_str());
565 zcutscan_nbkg_g->SetTitle(("zcut_vs_nbkg_" + cutname + "_g;zcut [mm];nbkg").c_str());
566 zcutscan_nbkg_g->SetMarkerStyle(45);
567 zcutscan_nbkg_g->SetMarkerSize(2.0);
568 zcutscan_nbkg_g->SetMarkerColor(49);
569
570 TGraph* nbkg_zbi_g = new TGraph();
571 nbkg_zbi_g->SetName(("nbkg_vs_zbi_" + cutname + "_g").c_str());
572 nbkg_zbi_g->SetTitle(("nbkg_vs_zbi_" + cutname + "_g;nbkg;zbi").c_str());
573
574 TGraph* nsig_zbi_g = new TGraph();
575 nsig_zbi_g->SetName(("nsig_vs_zbi_" + cutname + "_g").c_str());
576 nsig_zbi_g->SetTitle(("nsig_vs_zbi_" + cutname + "_g;nsig;zbi").c_str());
577
578 TH2F* nsig_zcut_hh = new TH2F(("nsig_v_zcut_zbi_" + cutname + "_hh").c_str(),
579 ("nsig_v_zcut_zbi_" + cutname + "_hh; zcut [mm]; Nbkg").c_str(), 200, -50.3,
580 149.7, 3000, 0.0, 300.0);
581
582 TH2F* nbkg_zcut_hh = new TH2F(("nbkg_v_zcut_zbi_" + cutname + "_hh").c_str(),
583 ("nbkg_v_zcut_zbi_" + cutname + "_hh; zcut [mm]; Nbkg").c_str(), 200, -50.3,
584 149.7, 3000, 0.0, 300.0);
585
586 // Find maximum position of Zcut --> ZBi calculation requires non-zero background
587 // Start the Zcut position at the target
588 double zcut_step = 0.1;
589 TH1F* bkg_zVtx_h = (TH1F*)testCutHistos_->get1dHisto("testCutHistos_background_zVtx_" + cutname + "_h");
590 double max_zcut = bkg_model->GetXmin();
591 double endIntegral =
592 bkg_zVtx_h->GetBinLowEdge(bkg_zVtx_h->FindLastBinAbove(0.0)) + bkg_zVtx_h->GetBinWidth(1);
593 // double endIntegral = 100.0
594 double testIntegral = bkg_model->Integral(max_zcut, endIntegral);
595 if (debug_)
596 std::cout << "Background between " << max_zcut << "and end of histo is " << testIntegral << std::endl;
597 while (testIntegral > min_ztail_events_) {
598 max_zcut = max_zcut + zcut_step;
599 testIntegral = bkg_model->Integral(max_zcut, endIntegral);
600 if (testIntegral < min_ztail_events_) {
601 max_zcut = max_zcut - zcut_step;
602 testIntegral = bkg_model->Integral(max_zcut, endIntegral);
603 break;
604 }
605 }
606 if (debug_)
607 std::cout << "Maximum Zcut: " << max_zcut << " gives " << testIntegral << " background events"
608 << std::endl;
609
610 // If configuration does not specify scanning Zcut values, use single Zcut position at maximum position.
611 double min_zcut = bkg_model->GetXmin();
612 if (!scan_zcut_) min_zcut = max_zcut;
613 std::cout << "Minimum Zcut position: " << min_zcut << std::endl;
614
615 // Get the signal vtx z selection efficiency *before* zcut is applied
616 if (debug_) std::cout << "Get signal vtx z selection efficiency before Zcut" << std::endl;
617 TH1F* true_vtx_NoZ_h = (TH1F*)vtx_z_hh->ProjectionY((cutname + "_" + "true_vtx_z_projy").c_str(), 1,
618 vtx_z_hh->GetXaxis()->GetNbins(), "");
619
620 // Convert the truth vertex z distribution beyond Zcut into the appropriately binned Selection.
621 // Binning must match Signal pre-trigger distribution, in order to take Efficiency between them.
622 TH1F* signalSelNoZ_h =
623 (TH1F*)signalSimZ_h_->Clone(("testCutHistos_signal_SelNoZ_" + cutname + "_h").c_str());
624 for (int i = 0; i < 201; i++) {
625 signalSelNoZ_h->SetBinContent(i, true_vtx_NoZ_h->GetBinContent(i));
626 }
627 TEfficiency* effCalcNoZ_h = new TEfficiency(*signalSelNoZ_h, *signalSimZ_h_);
628
629 outFile_->cd(("testCuts_pct_sig_cut_" + std::to_string(cutSignal)).c_str());
630 signalSelNoZ_h->Write();
631 effCalcNoZ_h->Write();
632 delete effCalcNoZ_h;
633
634 // Scan Zcut position and calculate ZBi
635 double best_scan_zbi = -999.9;
636 double best_scan_zcut;
637 double best_scan_nsig;
638 double best_scan_nbkg;
639 if (debug_) std::cout << "Scanning zcut position" << std::endl;
640 for (double zcut = min_zcut; zcut < (max_zcut + zcut_step); zcut = zcut + zcut_step) {
641 double Nbkg = bkg_model->Integral(zcut, endIntegral);
642 // std::cout << "zcut: " << zcut << std::endl;
643 // std::cout << "Nbkg: " << Nbkg << std::endl;
644
645 // Get the Signal truth vertex z distribution beyond the reconstructed vertex Zcut
646 TH1F* true_vtx_z_h = (TH1F*)vtx_z_hh->ProjectionY(
647 (std::to_string(zcut) + "_" + cutname + "_" + "true_vtx_z_projy").c_str(),
648 vtx_z_hh->GetXaxis()->FindBin(zcut) + 1, vtx_z_hh->GetXaxis()->GetNbins(), "");
649
650 // Convert the truth vertex z distribution beyond Zcut into the appropriately binned Selection.
651 // Binning must match Signal pre-trigger distribution, in order to take Efficiency between them.
652 TH1F* signalSelZ_h =
653 (TH1F*)signalSimZ_h_->Clone(("testCutHistos_signal_SelZ_" + cutname + "_h").c_str());
654 for (int i = 0; i < 201; i++) {
655 signalSelZ_h->SetBinContent(i, true_vtx_z_h->GetBinContent(i));
656 }
657
658 // Get Signal Selection Efficiency, as a function of truth vertex Z, F(z)
659 // if(debug_) std::cout << "Get Signal Selection Efficiency" << std::endl;
660 TEfficiency* effCalc_h = new TEfficiency(*signalSelZ_h, *signalSimZ_h_);
661 // if(zcut == min_zcut){
662 // outFile_->cd(("testCuts_pct_sig_cut_"+std::to_string(cutSignal)).c_str());
663 // effCalc_h->Write();
664 // }
665
666 double eps2 = std::pow(10, logEps2_);
667 double eps = std::sqrt(eps2);
668
669 // Calculate expected signal for Neutral Dark Vector "rho"
670 double nSigRho = simpEqs_->expectedSignalCalculation(signal_mass_, eps, true, E_Vd_, effCalc_h, dNdm_,
671 radFrac_, radAcc_, -4.3, zcut);
672
673 // Calculate expected signal for Neutral Dark Vector "rho"
674 double nSigPhi = simpEqs_->expectedSignalCalculation(signal_mass_, eps, false, E_Vd_, effCalc_h, dNdm_,
675 radFrac_, radAcc_, -4.3, zcut);
676
677 /*
678 //Calculate expected signal for Neutral Dark Vector "rho"
679 double nSigRho = background_sf_*simpEqs_->expectedSignalCalculation(signal_mass_,
680 eps, true, false, E_Vd_, effCalc_h, -4.3, zcut);
681
682 //Calculate expected signal for Neutral Dark Vector "phi"
683 double nSigPhi = background_sf_*simpEqs_->expectedSignalCalculation(signal_mass_,
684 eps, false, true, E_Vd_, effCalc_h, -4.3, zcut);
685
686 */
687 double Nsig = nSigRho + nSigPhi;
688
689 // if(debug_){
690 // std::cout << "nSigRho: " << nSigRho << std::endl;
691 // std::cout << "nSigPhi: " << nSigPhi << std::endl;
692 // std::cout << "Nsig: " << Nsig << std::endl;
693 // }
694
695 Nsig = Nsig * signal_sf_;
696 // if(debug_) std::cout << "Nsig after scale factor: " << Nsig << std::endl;
697
698 // CLEAR POINTERS
699 delete effCalc_h;
700
701 // Round Nsig, Nbkg, and then ZBi later
702 Nsig = round(Nsig);
703 Nbkg = round(Nbkg);
704
705 // Calculate ZBi for this Test Cut using this zcut value
706 double n_on = Nsig + Nbkg;
707 double tau = 1.0;
708 double n_off = Nbkg;
709 double ZBi = calculateZBi(n_on, n_off, tau);
710 std::cout << "ZBi before rounding: " << ZBi << std::endl;
711 ZBi = round(ZBi);
712
713 /*
714 std::cout << "[SimpZBiOptimization]::Iteration Results:" << std::endl;
715 std::cout << "Zcut = " << zcut << std::endl;
716 std::cout << "Nsig = " << Nsig << std::endl;
717 std::cout << "n_bkg: " << Nbkg << std::endl;
718 std::cout << "n_on: " << n_on << std::endl;
719 std::cout << "n_off: " << n_off << std::endl;
720 std::cout << "ZBi: " << ZBi << std::endl;
721 */
722
723 // Update Test Cut with best scan values
724 if (ZBi > best_scan_zbi) {
725 best_scan_zbi = ZBi;
726 best_scan_zcut = zcut;
727 best_scan_nsig = Nsig;
728 best_scan_nbkg = Nbkg;
729 }
730
731 // Fill TGraphs
732 zcutscan_zbi_g->SetPoint(zcutscan_zbi_g->GetN(), zcut, ZBi);
733 zcutscan_nbkg_g->SetPoint(zcutscan_nbkg_g->GetN(), zcut, Nbkg);
734 zcutscan_nsig_g->SetPoint(zcutscan_nsig_g->GetN(), zcut, Nsig);
735 nbkg_zbi_g->SetPoint(nbkg_zbi_g->GetN(), Nbkg, ZBi);
736 nsig_zbi_g->SetPoint(nsig_zbi_g->GetN(), Nsig, ZBi);
737
738 nsig_zcut_hh->Fill(zcut, Nsig, ZBi);
739 nbkg_zcut_hh->Fill(zcut, Nbkg, ZBi);
740 }
741
742 // Write graph of zcut vs zbi for the Test Cut
743 writeGraph(outFile_, "testCuts_pct_sig_cut_" + std::to_string(cutSignal), zcutscan_zbi_g);
744 writeGraph(outFile_, "testCuts_pct_sig_cut_" + std::to_string(cutSignal), zcutscan_nbkg_g);
745 writeGraph(outFile_, "testCuts_pct_sig_cut_" + std::to_string(cutSignal), zcutscan_nsig_g);
746
747 // delete TGraph pointers
748 delete zcutscan_zbi_g;
749 delete zcutscan_nsig_g;
750 delete zcutscan_nbkg_g;
751 delete nbkg_zbi_g;
752 delete nsig_zbi_g;
753 delete nsig_zcut_hh;
754 delete nbkg_zcut_hh;
755
756 // Fill Summary Histograms Test Cuts at best zcutscan value
757 processorHistos_->Fill2DHisto("test_cuts_values_hh", (double)cutSignal, (double)cutid, cutvalue);
758 processorHistos_->set2DHistoYlabel("test_cuts_values_hh", cutid, cutname);
759
760 processorHistos_->Fill2DHisto("test_cuts_ZBi_hh", (double)cutSignal, (double)cutid, best_scan_zbi);
761 processorHistos_->set2DHistoYlabel("test_cuts_ZBi_hh", cutid, cutname);
762
763 processorHistos_->Fill2DHisto("test_cuts_zcut_hh", (double)cutSignal, (double)cutid, best_scan_zcut);
764 processorHistos_->set2DHistoYlabel("test_cuts_zcut_hh", cutid, cutname);
765
766 processorHistos_->Fill2DHisto("test_cuts_nsig_hh", (double)cutSignal, (double)cutid, best_scan_nsig);
767 processorHistos_->set2DHistoYlabel("test_cuts_nsig_hh", cutid, cutname);
768
769 processorHistos_->Fill2DHisto("test_cuts_nbkg_hh", (double)cutSignal, (double)cutid, best_scan_nbkg);
770 processorHistos_->set2DHistoYlabel("test_cuts_nbkg_hh", cutid, cutname);
771
772 // Check if the best cutscan zbi for this Test Cut is the best overall ZBi for all Test Cuts
773 if (best_scan_zbi > best_zbi) {
774 best_zbi = best_scan_zbi;
775 best_cutname = cutname;
776 best_cutvalue = cutvalue;
777 best_zcut = best_scan_zcut;
778 best_nsig = best_scan_nsig;
779 best_nbkg = best_scan_nbkg;
780 }
781
782 } // END LOOP OVER TEST CUTS
783
784 if (debug_) {
785 std::cout << "Iteration " << iteration << " Best Test Cut is " << best_cutname << " " << best_cutvalue
786 << " with ZBi=" << best_zbi << std::endl;
787 std::cout << "Update persistent cuts list with this best test cut..." << std::endl;
788 std::cout << "[Persistent Cuts] Before update:" << std::endl;
789 persistentCutsSelector_->printCuts();
790 }
791
792 // Find best Test Cut for iteration. Add Test Cut value to Persistent Cuts list
793 processorHistos_->Fill2DHisto("best_test_cut_ZBi_hh", (double)cutSignal, best_zbi,
794 (double)testCutsSelector_->getCutID(best_cutname));
795 processorHistos_->Fill1DHisto("best_test_cut_ZBi_h", (double)cutSignal, best_zbi);
796 processorHistos_->Fill1DHisto("best_test_cut_zcut_h", (double)cutSignal, best_zcut);
797 processorHistos_->Fill1DHisto("best_test_cut_nsig_h", (double)cutSignal, best_nsig);
798 processorHistos_->Fill1DHisto("best_test_cut_nbkg_h", (double)cutSignal, best_nbkg);
799 processorHistos_->Fill1DHisto("best_test_cut_id_h", (double)cutSignal,
800 (double)testCutsSelector_->getCutID(best_cutname));
801
802 persistentCutsSelector_->setCutValue(best_cutname, best_cutvalue);
803 if (debug_) {
804 std::cout << "[Persistent Cuts] After update:" << std::endl;
805 persistentCutsSelector_->printCuts();
806 }
807
808 // Write iteration histos
809 signalHistos_->writeHistos(outFile_, "signal_pct_sig_cut_" + std::to_string(cutSignal));
810 bkgHistos_->writeHistos(outFile_, "background_pct_sig_cut_" + std::to_string(cutSignal));
811 testCutHistos_->writeHistos(outFile_, "testCuts_pct_sig_cut_" + std::to_string(cutSignal));
812 }
813}
814
816 std::cout << "[SimpZBiOptimizationProcessor] finalize()" << std::endl;
817
818 if (debug_) {
819 std::cout << "FINAL LIST OF PERSISTENT CUTS " << std::endl;
820 persistentCutsSelector_->printCuts();
821 }
822
823 processorHistos_->saveHistos(outFile_);
824 testCutHistos_->writeGraphs(outFile_, "");
825}
826
828 bool failCuts = false;
829 for (cut_iter_ it = persistentCutsPtr_->begin(); it != persistentCutsPtr_->end(); it++) {
830 std::string cutname = it->first;
831 std::string cutvar = persistentCutsSelector_->getCutVar(cutname);
832 // If no value inside the tuple exists for this cut, do not apply the cut.
833 if (!MTT->variableExists(cutvar)) continue;
834 if (!persistentCutsSelector_->passCutGTorLT(cutname, MTT->getValue(cutvar))) {
835 failCuts = true;
836 break;
837 }
838 }
839
840 return failCuts;
841}
842
844 std::string cutvar = testCutsSelector_->getCutVar(cutname);
845 double cutvalue = testCutsSelector_->getCut(cutname);
846 // If cut variable is not found in the list of tuples, do not apply cut
847 if (!MTT->variableExists(cutvar)) return false;
848 if (!testCutsSelector_->passCutGTorLT(cutname, MTT->getValue(cutvar)))
849 return true;
850 else
851 return false;
852}
853
854void SimpZBiOptimizationProcessor::getSignalMCAnaVtxZ_h(std::string signalMCAnaFilename, std::string signal_pdgid) {
855 // Read pre-trigger Signal MCAna vertex z distribution
856 signalSimZ_h_ = new TH1F("signal_SimZ_h_", "signal_SimZ;true z_{vtx} [mm];events", 200, -50.3, 149.7);
857 TFile* signalMCAnaFile = new TFile(signalMCAnaFilename_.c_str(), "READ");
858 TH1F* mcAnaSimZ_h = (TH1F*)signalMCAnaFile->Get(("mcAna/mcAna_mc" + signal_pdgid + "Z_h").c_str());
859 for (int i = 0; i < 201; i++) {
860 signalSimZ_h_->SetBinContent(i, mcAnaSimZ_h->GetBinContent(i));
861 }
862 signalMCAnaFile->Close();
863 delete signalMCAnaFile;
864}
865
867 // float value = (int)(var * 100 + .5);
868 // return (double)value / 100;
869 return var;
870}
871
#define DECLARE_PROCESSOR(CLASS)
Macro which allows the framework to construct a producer given its name during configuration.
Definition Processor.h:139
double getValue(std::string branch_name)
Get the value of a flat tuple variable.
std::vector< std::string > getAllVariables()
Get list of all variables defined in ttree.
bool variableExists(std::string variable)
Check if a variable exists in the ttree.
double calculateZBi(double n_on, double n_off, double tau)
description
std::vector< double > new_variable_params_
std::shared_ptr< ZBiHistos > bkgHistos_
std::map< std::string, std::pair< double, int > >::iterator cut_iter_
std::vector< std::string > cutVariables_
std::vector< std::string > new_variables_
std::map< std::string, std::pair< double, int > > * persistentCutsPtr_
OptimizationProcessor(const std::string &name, Process &process)
void writeGraph(TFile *outF, std::string folder, TGraph *g)
description
std::shared_ptr< ZBiHistos > processorHistos_
std::shared_ptr< ZBiHistos > signalHistos_
std::shared_ptr< ZBiHistos > testCutHistos_
std::map< std::string, std::pair< double, int > > * testCutsPtr_
description
Read in flat TTree and create new cut variables for SIMP analysis.
void addVariable_unc_vtx_pos_zalpha(double slope)
void addVariable_unc_vtx_pos_z0tanlambda_right(double slope)
void addVariable_unc_vtx_ele_iso_z0err()
void addVariable_unc_vtx_pos_isolation_cut()
void addVariable_unc_vtx_zalpha_max(double slope)
void addVariable_unc_vtx_pos_z0tanlambda_left(double slope)
void addVariable_unc_vtx_ele_z0tanlambda_left(double slope)
void addVariable_unc_vtx_pos_z0tanlambda()
void addVariable_unc_vtx_ele_z0_z0err()
void addVariable_unc_vtx_pos_iso_z0err()
void addVariable_unc_vtx_ele_z0tanlambda_right(double slope)
void addVariable_unc_vtx_ele_isolation_cut()
void addVariable_unc_vtx_abs_delta_z0tanlambda()
void addVariable_unc_vtx_zalpha_min(double slope)
void addVariable_unc_vtx_ele_z0tanlambda()
void addVariable_unc_vtx_ele_zalpha(double slope)
New Variables.
void addVariable_unc_vtx_pos_z0_z0err()
All SIMP Equations for calculating expected signal.
Cutflow optimization tool for SIMPS.
void fillEventHistograms(std::shared_ptr< ZBiHistos > histos, SimpAnaTTree *MTT)
description
virtual void configure(const ParameterSet &parameters)
description
double countControlRegionBackgroundRate(std::string inFilename, std::string tree_name, double m_Ap, double Mbin=30.0, double dNdm_sf=1.0)
description
void getSignalMCAnaVtxZ_h(std::string signalMCAnaFilename, std::string signal_pdgid)
description
bool failTestCut(std::string cutname, SimpAnaTTree *MTT)
description
virtual void initialize(TTree *tree)
description
bool failPersistentCuts(SimpAnaTTree *MTT)
description
void addNewVariables(SimpAnaTTree *MTT, std::string variable, double param)
description
SimpZBiOptimizationProcessor(const std::string &name, Process &process)
virtual bool process(IEvent *event)
description
std::map< std::string, double > initialIntegrals_