00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014 #include "TLorentzVector.h"
00015
00016
00017 #include "GaudiKernel/AlgFactory.h"
00018 #include "GaudiKernel/IToolSvc.h"
00019
00020
00021 #include "ElectronPhotonIDEvent/PhotonContainer.h"
00022 #include "ElectronPhotonIDEvent/ElectronContainer.h"
00023 #include "MuonIDEvent/MuonContainer.h"
00024 #include "JetTagEvent/ParticleJetContainer.h"
00025 #include "TauIDEvent/TauJetContainer.h"
00026 #include "MissingETEvent/MissingET.h"
00027 #include "TrigSteeringEvent/TriggerDecision.h"
00028 #include "AnalysisTriggerEvent/LVL1_ROI.h"
00029 #include "TrigCaloEvent/TrigMissingET.h"
00030 #include "TrigMuonEvent/CombinedMuonFeature.h"
00031 #include "TrigMuonEvent/TrigMuonEFContainer.h"
00032 #include "VxVertex/VxContainer.h"
00033 #include "Particle/TrackParticleContainer.h"
00034
00035 #include "HiggsAnalysis/MyTruthTrackJetInfoContainer.h"
00036
00037
00038
00039
00040 #include "JetUtils/JetCollectionHelper.h"
00041
00042
00043
00044
00045
00046 #include "HepMC/GenVertex.h"
00047
00048
00049
00050
00051 #include "JetTagInfo/TruthInfo.h"
00052 #include "JetTagEvent/TrackConstituents.h"
00053
00054
00055 #include "HiggsAnalysis/HiggsAnalysisNtupleWriter.h"
00056
00057
00058
00059
00060
00061 using namespace std;
00062
00063
00064
00065
00066
00067
00068
00069 HiggsAnalysisNtupleWriter::HiggsAnalysisNtupleWriter(const std::string & name,
00070 ISvcLocator * pSvcLocator) :
00071 CBNT_AthenaAwareBase(name, pSvcLocator) {
00072
00073
00074 declareProperty("electronContainer", m_electron_container);
00075
00076 m_trigger_decision_container = string("MyTriggerDecision");
00077 declareProperty("triggerDecisionContainer", m_trigger_decision_container);
00078
00079 m_trigger_mu_lvl1_container = string("LVL1_ROI");
00080 declareProperty("triggerMuonLVL1Container", m_trigger_mu_lvl1_container);
00081
00082 m_trigger_mu_lvl2_container = string("CombinedMuonFeature");
00083 declareProperty("triggerMuonLVL2Container", m_trigger_mu_lvl2_container);
00084
00085 m_trigger_mu_ef_container = string("TrigMuonEFContainer");
00086 declareProperty("triggerMuonEFContainer", m_trigger_mu_ef_container);
00087
00088 m_trigger_met_container = string("TrigMissingET");
00089 declareProperty("triggerMissingEtContainer", m_trigger_met_container);
00090
00091 m_photon_container = string("AtlfastPhotonCollection");
00092 declareProperty("photonContainer", m_photon_container);
00093
00094
00095 m_muon_container = vector<string>(1,"AtlfastMuonCollection");
00096 declareProperty("muonContainer", m_muon_container);
00097
00098 m_jet_container = string("AtlfastParticleJetContainer");
00099 declareProperty("jetContainer", m_jet_container);
00100
00101 m_taujet_container = string("AtlfastTauJetContainer");
00102 declareProperty("taujetContainer", m_taujet_container);
00103
00104 m_truthjet_container = string("ConeTruthParticleJets");
00105 declareProperty("truthjetContainer", m_truthjet_container);
00106
00107 m_truthmissingEt_container = string("MET_Truth");
00108 declareProperty("truthmissingEtContainer", m_truthmissingEt_container);
00109
00110 m_truthparticle_container = string("SpclMC");
00111 declareProperty("truthparticleContainer", m_truthparticle_container);
00112
00113 m_AtlFastFlag = false;
00114 declareProperty("AtlFastFlag", m_AtlFastFlag);
00115
00116 m_doAODFix1mm = false;
00117 declareProperty("doAODFix1mm", m_doAODFix1mm);
00118
00119 m_doEventWeight = true;
00120 declareProperty("doEventWeight", m_doEventWeight);
00121
00122 m_truthparticleMaximumLeptonBarcode = 100000;
00123 declareProperty("truthparticleMaximumLeptonBarcode", m_truthparticleMaximumLeptonBarcode);
00124
00125 m_truthparticleNoPDGAbove100 = false;
00126 declareProperty("truthparticleNoPDGAbove100", m_truthparticleNoPDGAbove100);
00127
00128 m_vert_coll_svc_name = string("MPIHiggsAnalysis::VertexCollectionSvc");
00129 declareProperty("VertexCollectionSvc", m_vert_coll_svc_name);
00130
00131 m_track_jet_container = string("Cone4TrackJets");
00132 declareProperty("jetTrackContainer", m_track_jet_container);
00133
00134 m_truth_track_jet_container = string("Cone4TruthTrackJets");
00135 declareProperty("jetTruthTrackContainer", m_truth_track_jet_container);
00136
00137 m_track_particle_container = string("TrackParticleCandidate");
00138 declareProperty("TrackParticleContainer", m_track_particle_container);
00139
00140 m_doTrigger = true;
00141 declareProperty("doTrigger", m_doTrigger);
00142 m_doMissingEt = true;
00143 declareProperty("doMissingEt", m_doMissingEt);
00144 m_doTrackParticles = false;
00145 declareProperty("doTrackParticles", m_doTrackParticles);
00146 m_doElectrons = true;
00147 declareProperty("doElectrons", m_doElectrons);
00148 m_doPhotons = true;
00149 declareProperty("doPhotons", m_doPhotons);
00150 m_doMuons = true;
00151 declareProperty("doMuons", m_doMuons);
00152 m_doJets = true;
00153 declareProperty("doJets", m_doJets);
00154 m_doTauJets = true;
00155 declareProperty("doTauJets", m_doTauJets);
00156 m_doTruthJets = true;
00157 declareProperty("doTruthJets", m_doTruthJets);
00158 m_doTruthParticles = true;
00159 declareProperty("doTruthParticles", m_doTruthParticles);
00160 m_doTrackJets = false;
00161 declareProperty("doTrackJets", m_doTrackJets);
00162 m_doVertices = false;
00163 declareProperty("doVertices", m_doVertices);
00164
00165
00166 declareProperty("release", m_release="");
00167 declareProperty("svnversion", m_svnversion="");
00168 declareProperty("date", m_date="");
00169
00170
00171
00172
00173 declareProperty("AOD_files", v_string_aod_files);
00174
00175
00176 declareProperty("missingEtContainerCollection", v_string_met_container);
00177
00178
00179
00180 m_storeGate = NULL;
00181 m_log = NULL;
00182 m_vert_coll = NULL;
00183 m_toolSvc = NULL;
00184 tmp_trackIsolationTool = NULL;
00185 m_trackIsolationTool = NULL;
00186
00187
00188 m_trigger_keys_l1 = static_cast< vector<std::string> *>(0);
00189 m_trigger_keys_status_l1 = NULL;
00190 m_trigger_keys_l2 = static_cast< vector<std::string> *>(0);
00191 m_trigger_keys_status_l2 = NULL;
00192 m_trigger_keys_ef = static_cast< vector<std::string> *>(0);
00193 m_trigger_keys_status_ef = NULL;
00194
00195
00196 m_trigger_mu_lvl1_eta = NULL;
00197 m_trigger_mu_lvl1_phi = NULL;
00198 m_trigger_mu_lvl1_threshold_value = NULL;
00199 m_trigger_mu_lvl1_threshold_name = NULL;
00200 m_trigger_mu_lvl1_threshold_number= NULL;
00201 m_trigger_mu_lvl1_roiword = NULL;
00202
00203
00204 m_trigger_mu_lvl2_eta = NULL;
00205 m_trigger_mu_lvl2_phi = NULL;
00206 m_trigger_mu_lvl2_pt = NULL;
00207 m_trigger_mu_lvl2_sigma_pt = NULL;
00208
00209
00210 m_trigger_mu_ef_eta = NULL;
00211 m_trigger_mu_ef_phi = NULL;
00212 m_trigger_mu_ef_pt = NULL;
00213 m_trigger_mu_ef_charge1 = NULL;
00214 m_trigger_mu_ef_charge2 = NULL;
00215 m_trigger_mu_ef_code = NULL;
00216
00217
00218 m_track_p_x = NULL;
00219 m_track_p_y = NULL;
00220 m_track_p_z = NULL;
00221 m_track_E = NULL;
00222 m_track_charge = NULL;
00223 m_track_vertex_index = NULL;
00224 m_track_SCThit = NULL;
00225 m_track_Phit = NULL;
00226 m_track_BLayerhit = NULL;
00227 m_track_TRThit = NULL;
00228 m_track_MDThit = NULL;
00229 m_track_CSChit_eta = NULL;
00230 m_track_TGChit_eta = NULL;
00231 m_track_RPChit_eta = NULL;
00232 m_track_CSChit_phi = NULL;
00233 m_track_TGChit_phi = NULL;
00234 m_track_RPChit_phi = NULL;
00235 m_track_d0 = NULL;
00236 m_track_z0 = NULL;
00237 m_track_chi2 = NULL;
00238 m_track_nDoF = NULL;
00239 m_track_trackIsolationEnergy_s = NULL;
00240 m_track_trackIsolationEnergy_0 = NULL;
00241 m_track_trackIsolationEnergy_1 = NULL;
00242 m_track_trackIsolationEnergy_2 = NULL;
00243 m_track_trackIsolationEnergy_3 = NULL;
00244
00245
00246
00247 m_e_p_x = NULL;
00248 m_e_p_y = NULL;
00249 m_e_p_z = NULL;
00250 m_e_E = NULL;
00251 m_e_calo_p_x = NULL;
00252 m_e_calo_p_y = NULL;
00253 m_e_calo_p_z = NULL;
00254 m_e_calo_E = NULL;
00255 m_e_charge = NULL;
00256 m_e_isEM = NULL;
00257 m_e_NeuralNet = NULL;
00258 m_e_egamma_flag = NULL;
00259 m_e_softe_flag = NULL;
00260 m_e_E_over_p = NULL;
00261 m_e_TRTHighThresholdHits = NULL;
00262 m_e_TRTHits = NULL;
00263 m_e_ethad1 = NULL;
00264 m_e_Et_in_cone_0 = NULL;
00265 m_e_Et_in_cone_1 = NULL;
00266 m_e_Et_in_cone_2 = NULL;
00267 m_e_Et_in_cone_3 = NULL;
00268 m_e_vertex_index = NULL;
00269 m_e_track_Et_in_cone_0 = NULL;
00270 m_e_track_Et_in_cone_1 = NULL;
00271 m_e_track_Et_in_cone_2 = NULL;
00272 m_e_track_Et_in_cone_3 = NULL;
00273 m_e_trackIsolationEnergy_s = NULL;
00274 m_e_trackIsolationEnergy_0 = NULL;
00275 m_e_trackIsolationEnergy_1 = NULL;
00276 m_e_trackIsolationEnergy_2 = NULL;
00277 m_e_trackIsolationEnergy_3 = NULL;
00278 m_e_track_d0 = NULL;
00279 m_e_track_d0err = NULL;
00280
00281
00282 m_p_calo_p_x = NULL;
00283 m_p_calo_p_y = NULL;
00284 m_p_calo_p_z = NULL;
00285 m_p_calo_E = NULL;
00286 m_p_charge = NULL;
00287 m_p_isEM = NULL;
00288 m_p_NeuralNet = NULL;
00289 m_p_egamma_flag = NULL;
00290 m_p_Et_in_cone_0 = NULL;
00291 m_p_Et_in_cone_1 = NULL;
00292 m_p_Et_in_cone_2 = NULL;
00293 m_p_Et_in_cone_3 = NULL;
00294
00295
00296
00297
00298 m_mu_alg_flag = NULL;
00299 m_mu_p_x = NULL;
00300 m_mu_p_y = NULL;
00301 m_mu_p_z = NULL;
00302 m_mu_E = NULL;
00303 m_mu_charge = NULL;
00304 m_mu_fitChi2 = NULL;
00305 m_mu_fitNumberDoF = NULL;
00306 m_mu_fitChi2OverDoF = NULL;
00307 m_mu_matchChi2 = NULL;
00308 m_mu_matchNumberDoF = NULL;
00309 m_mu_matchChi2OverDoF = NULL;
00310 m_mu_flag = NULL;
00311 m_mu_Et_in_cone_0 = NULL;
00312 m_mu_Et_in_cone_1 = NULL;
00313 m_mu_Et_in_cone_2 = NULL;
00314 m_mu_Et_in_cone_3 = NULL;
00315 m_mu_Et_in_cone_4 = NULL;
00316 m_mu_Et_in_cone_5 = NULL;
00317 m_mu_Et_in_cone_6 = NULL;
00318 m_mu_Et_in_cone_7 = NULL;
00319 m_mu_nb_tracks_cone_0 = NULL;
00320 m_mu_nb_tracks_cone_1 = NULL;
00321 m_mu_nb_tracks_cone_2 = NULL;
00322 m_mu_nb_tracks_cone_3 = NULL;
00323 m_mu_nb_tracks_cone_4 = NULL;
00324 m_mu_nb_tracks_cone_5 = NULL;
00325 m_mu_nb_tracks_cone_6 = NULL;
00326 m_mu_nb_tracks_cone_7 = NULL;
00327 m_mu_vertex_index = NULL;
00328 m_mu_track_Et_in_cone_0 = NULL;
00329 m_mu_track_Et_in_cone_1 = NULL;
00330 m_mu_track_Et_in_cone_2 = NULL;
00331 m_mu_track_Et_in_cone_3 = NULL;
00332 m_mu_track_Et_in_cone_4 = NULL;
00333 m_mu_track_Et_in_cone_5 = NULL;
00334 m_mu_track_Et_in_cone_6 = NULL;
00335 m_mu_track_Et_in_cone_7 = NULL;
00336 m_mu_trackIsolationEnergy_s = NULL;
00337 m_mu_trackIsolationEnergy_0 = NULL;
00338 m_mu_trackIsolationEnergy_1 = NULL;
00339 m_mu_trackIsolationEnergy_2 = NULL;
00340 m_mu_trackIsolationEnergy_3 = NULL;
00341 m_mu_trackIsolationEnergy_4 = NULL;
00342 m_mu_trackIsolationEnergy_5 = NULL;
00343 m_mu_trackIsolationEnergy_6 = NULL;
00344 m_mu_trackIsolationEnergy_7 = NULL;
00345 m_mu_track_d0 = NULL;
00346 m_mu_track_d0err = NULL;
00347
00348
00349 m_jet_p_x = NULL;
00350 m_jet_p_y = NULL;
00351 m_jet_p_z = NULL;
00352 m_jet_E = NULL;
00353 m_jet_flag = NULL;
00354 m_jet_btag_weight = NULL;
00355 m_jet_truthflavor = NULL;
00356 m_jet_nb_tracks = NULL;
00357 m_jet_tracks_charge = NULL;
00358 m_jet_tracks_p_x = NULL;
00359 m_jet_tracks_p_y = NULL;
00360 m_jet_tracks_p_z = NULL;
00361 m_jet_tracks_E = NULL;
00362 m_jet_tracks_vertex_index = NULL;
00363
00364
00365 m_taujet_p_x = NULL;
00366 m_taujet_p_y = NULL;
00367 m_taujet_p_z = NULL;
00368 m_taujet_E = NULL;
00369 m_taujet_flag = NULL;
00370 m_taujet_charge = NULL;
00371 m_taujet_etHadCalib = NULL;
00372 m_taujet_etEMCalib = NULL;
00373 m_taujet_emRadius = NULL;
00374 m_taujet_isolationFraction = NULL;
00375 m_taujet_centralityFraction = NULL;
00376 m_taujet_stripWidth2 = NULL;
00377 m_taujet_nStripCells = NULL;
00378 m_taujet_llh = NULL;
00379 m_taujet_lowPtTauEleDiscriminant = NULL;
00380 m_taujet_tauENeuralNetwork = NULL;
00381 m_taujet_tauJetNeuralnetwork = NULL;
00382 m_taujet_nb_tracks = NULL;
00383 m_taujet_track_px_1 = NULL;
00384 m_taujet_track_py_1 = NULL;
00385 m_taujet_track_pz_1 = NULL;
00386 m_taujet_track_e_1 = NULL;
00387 m_taujet_track_TRTHighThresholdHits_1 = NULL;
00388 m_taujet_track_TRTHits_1 = NULL;
00389 m_taujet_track_px_2 = NULL;
00390 m_taujet_track_py_2 = NULL;
00391 m_taujet_track_pz_2 = NULL;
00392 m_taujet_track_e_2 = NULL;
00393 m_taujet_track_TRTHighThresholdHits_2 = NULL;
00394 m_taujet_track_TRTHits_2 = NULL;
00395 m_taujet_track_px_3 = NULL;
00396 m_taujet_track_py_3 = NULL;
00397 m_taujet_track_pz_3 = NULL;
00398 m_taujet_track_e_3 = NULL;
00399 m_taujet_track_TRTHighThresholdHits_3 = NULL;
00400 m_taujet_track_TRTHits_3 = NULL;
00401
00402
00403 m_truthjet_p_x = NULL;
00404 m_truthjet_p_y = NULL;
00405 m_truthjet_p_z = NULL;
00406 m_truthjet_E = NULL;
00407 m_truthjet_flag = NULL;
00408 m_truthjet_btag_weight = NULL;
00409
00410
00411 m_truth_particle_pt = NULL;
00412 m_truth_particle_status = NULL;
00413 m_truth_particle_barcode = NULL;
00414 m_truth_particle_pdgId = NULL;
00415 m_truth_particle_nDaughters = NULL;
00416 m_truth_particle_p_x = NULL;
00417 m_truth_particle_p_y = NULL;
00418 m_truth_particle_p_z = NULL;
00419 m_truth_particle_E = NULL;
00420 m_truth_particle_charge = NULL;
00421 m_truth_particle_nParents = NULL;
00422 m_truth_particle_mother0_barcode= NULL;
00423 m_truth_particle_mother0_pdgId = NULL;
00424 m_truth_particle_vertex_index = NULL;
00425 m_truth_particle_Et_in_cone_0 = NULL;
00426 m_truth_particle_Et_in_cone_1 = NULL;
00427 m_truth_particle_Et_in_cone_2 = NULL;
00428 m_truth_particle_Et_in_cone_3 = NULL;
00429 m_truth_particle_Et_in_cone_4 = NULL;
00430
00431
00432 m_met_obj_name = NULL;
00433 m_missing_Etx = NULL;
00434 m_missing_Ety = NULL;
00435 m_missing_Et = NULL;
00436 m_missing_Etsum = NULL;
00437
00438
00439 m_vertex_position_x = NULL;
00440 m_vertex_position_y = NULL;
00441 m_vertex_position_y = NULL;
00442 m_vertex_pos_error_x = NULL;
00443 m_vertex_pos_error_y = NULL;
00444 m_vertex_pos_error_z = NULL;
00445 m_vertex_chi2 = NULL;
00446 m_vertex_ndof = NULL;
00447 m_vertex_Et = NULL;
00448 m_vertex_nb_tracks = NULL;
00449
00450
00451 m_truth_vertex_position_x = NULL;
00452 m_truth_vertex_position_y = NULL;
00453 m_truth_vertex_position_y = NULL;
00454 m_truth_vertex_Et = NULL;
00455 m_truth_vertex_nb_tracks = NULL;
00456
00457
00458 m_track_jet_p_x = NULL;
00459 m_track_jet_p_y = NULL;
00460 m_track_jet_p_z = NULL;
00461 m_track_jet_E = NULL;
00462
00463
00464 m_truth_track_jet_p_x = NULL;
00465 m_truth_track_jet_p_y = NULL;
00466 m_truth_track_jet_p_z = NULL;
00467 m_truth_track_jet_E = NULL;
00468
00469 return;
00470
00471 }
00472
00473
00474
00475
00476
00477
00478
00479 HiggsAnalysisNtupleWriter::~HiggsAnalysisNtupleWriter(void) {
00480 }
00481
00482
00483
00484
00485
00486
00487
00488 StatusCode HiggsAnalysisNtupleWriter::CBNT_initialize(void) {
00489
00491
00493
00494
00495 m_log = new MsgStream(messageService(), name());
00496
00497 *m_log << MSG::INFO
00498 << "Initializing HiggsAnalysisNtupleWriter..."
00499 << endreq;
00500
00501
00502 StatusCode sc = service("StoreGateSvc", m_storeGate);
00503
00504 if (sc.isFailure()) {
00505 *m_log << MSG::ERROR
00506 << "Unable to retrieve a pointer to StoreGateSvc!"
00507 << endreq;
00508 return sc;
00509 }
00510
00511
00512 sc = service(m_vert_coll_svc_name, m_vert_coll);
00513 if (!sc.isSuccess()) {
00514 *m_log << MSG::FATAL << "Cannot retrieve "
00515 << m_vert_coll_svc_name
00516 << "!"
00517 << endreq;
00518 return sc;
00519 }
00520
00521
00522 sc = service("ToolSvc", m_toolSvc);
00523 if (sc.isFailure()) {
00524 *m_log << MSG::ERROR
00525 << "Unable to retrieve a pointer to ToolsSvc!"
00526 << endreq;
00527 return sc;
00528 }
00529 sc = m_toolSvc->retrieveTool("TrackIsolationTool",tmp_trackIsolationTool);
00530 if (StatusCode::SUCCESS != sc) {
00531 *m_log << MSG::ERROR << "Can't get handle on analysis tools" << endreq;
00532 return StatusCode::FAILURE;
00533 }
00534 m_trackIsolationTool=dynamic_cast<TrackIsolationTool*>(tmp_trackIsolationTool);
00535
00536
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547 nEvents =0;
00548
00549
00550
00551
00552
00553
00554 m_nt->Branch("trigger_l1_defined", &m_trigger_l1_defined,
00555 "trigger_l1_defined/O");
00556 m_nt->Branch("trigger_l2_defined", &m_trigger_l2_defined,
00557 "trigger_l2_defined/O");
00558 m_nt->Branch("trigger_ef_defined", &m_trigger_ef_defined,
00559 "trigger_ef_defined/O");
00560 addBranch("trigger_keys_l1", m_trigger_keys_l1);
00561 addBranch("trigger_keys_status_l1", m_trigger_keys_status_l1);
00562 addBranch("trigger_keys_l2", m_trigger_keys_l2);
00563 addBranch("trigger_keys_status_l2", m_trigger_keys_status_l2);
00564 addBranch("trigger_keys_ef", m_trigger_keys_ef);
00565 addBranch("trigger_keys_status_ef", m_trigger_keys_status_ef);
00566
00567
00568
00569 m_nt->Branch("nb_trigger_mu_lvl1", &m_nb_trigger_mu_lvl1,
00570 "nb_trigger_mu_lvl1/I");
00571 addBranch("trigger_mu_lvl1_eta", m_trigger_mu_lvl1_eta);
00572 addBranch("trigger_mu_lvl1_phi", m_trigger_mu_lvl1_phi);
00573 addBranch("trigger_mu_lvl1_threshold_number", m_trigger_mu_lvl1_threshold_number);
00574 addBranch("trigger_mu_lvl1_threshold_name", m_trigger_mu_lvl1_threshold_name);
00575 addBranch("trigger_mu_lvl1_threshold_value", m_trigger_mu_lvl1_threshold_value);
00576 addBranch("trigger_mu_lvl1_roiword", m_trigger_mu_lvl1_roiword);
00577 addBranch("trigger_mu_lvl1_confirmed", m_trigger_mu_lvl1_confirmed);
00578
00579
00580 m_nt->Branch("nb_trigger_mu_lvl2", &m_nb_trigger_mu_lvl2,
00581 "nb_trigger_mu_lvl2/I");
00582 addBranch("trigger_mu_lvl2_eta", m_trigger_mu_lvl2_eta);
00583 addBranch("trigger_mu_lvl2_phi", m_trigger_mu_lvl2_phi);
00584 addBranch("trigger_mu_lvl2_pt", m_trigger_mu_lvl2_pt);
00585 addBranch("trigger_mu_lvl2_sigma_pt", m_trigger_mu_lvl2_sigma_pt);
00586
00587
00588 m_nt->Branch("nb_trigger_mu_ef", &m_nb_trigger_mu_ef,
00589 "nb_trigger_mu_ef/I");
00590 addBranch("trigger_mu_ef_eta", m_trigger_mu_ef_eta);
00591 addBranch("trigger_mu_ef_phi", m_trigger_mu_ef_phi);
00592 addBranch("trigger_mu_ef_pt", m_trigger_mu_ef_pt);
00593 addBranch("trigger_mu_ef_code", m_trigger_mu_ef_code);
00594 addBranch("trigger_mu_ef_charge1", m_trigger_mu_ef_charge1);
00595 addBranch("trigger_mu_ef_charge2", m_trigger_mu_ef_charge2);
00596
00597
00598 m_nt->Branch("trigger_met_ex", &m_trigger_met_ex, "trigger_met_ex/D");
00599 m_nt->Branch("trigger_met_ey", &m_trigger_met_ey, "trigger_met_ey/D");
00600 m_nt->Branch("trigger_met_et", &m_trigger_met_et, "trigger_met_et/D");
00601 m_nt->Branch("trigger_met_sumEt", &m_trigger_met_et, "trigger_met_sumEt/D");
00602 m_nt->Branch("trigger_met_RoIword", &m_trigger_met_RoIword, "trigger_met_RoIword/L");
00603
00604
00605 m_nt->Branch("nb_rec_tracks", &m_nb_rec_tracks,
00606 "nb_rec_tracks/I");
00607 addBranch("track_p_x",m_track_p_x);
00608 addBranch("track_p_y",m_track_p_y);
00609 addBranch("track_p_z",m_track_p_z);
00610 addBranch("track_E",m_track_E);
00611 addBranch("track_charge",m_track_charge);
00612 addBranch("track_vertex_index",m_track_vertex_index);
00613 addBranch("track_SCThit",m_track_SCThit);
00614 addBranch("track_Phit",m_track_Phit);
00615 addBranch("track_BLayerhit",m_track_BLayerhit);
00616 addBranch("track_TRThit",m_track_TRThit);
00617 addBranch("track_MDThit",m_track_MDThit);
00618 addBranch("track_CSChit_eta",m_track_CSChit_eta);
00619 addBranch("track_TGChit_eta",m_track_TGChit_eta);
00620 addBranch("track_RPChit_eta",m_track_RPChit_eta);
00621 addBranch("track_CSChit_phi",m_track_CSChit_phi);
00622 addBranch("track_TGChit_phi",m_track_TGChit_phi);
00623 addBranch("track_RPChit_phi",m_track_RPChit_phi);
00624 addBranch("track_d0",m_track_d0);
00625 addBranch("track_z0",m_track_z0);
00626 addBranch("track_chi2",m_track_chi2);
00627 addBranch("track_nDoF",m_track_nDoF);
00628 addBranch("track_trackIsolationEnergy_s", m_track_trackIsolationEnergy_s);
00629 addBranch("track_trackIsolationEnergy_0", m_track_trackIsolationEnergy_0);
00630 addBranch("track_trackIsolationEnergy_1", m_track_trackIsolationEnergy_1);
00631 addBranch("track_trackIsolationEnergy_2", m_track_trackIsolationEnergy_2);
00632 addBranch("track_trackIsolationEnergy_3", m_track_trackIsolationEnergy_3);
00633
00634
00635
00636
00637 m_nt->Branch("nb_rec_electrons", &m_nb_rec_electrons,
00638 "nb_rec_electrons/I");
00639 addBranch("e_p_x", m_e_p_x);
00640 addBranch("e_p_y", m_e_p_y);
00641 addBranch("e_p_z", m_e_p_z);
00642 addBranch("e_E", m_e_E);
00643 addBranch("e_calo_p_x", m_e_calo_p_x);
00644 addBranch("e_calo_p_y", m_e_calo_p_y);
00645 addBranch("e_calo_p_z", m_e_calo_p_z);
00646 addBranch("e_calo_E", m_e_calo_E);
00647 addBranch("e_charge", m_e_charge);
00648 addBranch("e_NeuralNet", m_e_NeuralNet);
00649 addBranch("e_isEM", m_e_isEM);
00650 addBranch("e_egamma_flag", m_e_egamma_flag);
00651 addBranch("e_softe_flag", m_e_softe_flag);
00652 addBranch("e_E_over_p", m_e_E_over_p);
00653 addBranch("e_TRTHighThresholdHits", m_e_TRTHighThresholdHits);
00654 addBranch("e_TRTHits", m_e_TRTHits);
00655 addBranch("e_ethad1", m_e_ethad1);
00656 addBranch("e_Et_in_cone_0", m_e_Et_in_cone_0);
00657 addBranch("e_Et_in_cone_1", m_e_Et_in_cone_1);
00658 addBranch("e_Et_in_cone_2", m_e_Et_in_cone_2);
00659 addBranch("e_Et_in_cone_3", m_e_Et_in_cone_3);
00660 addBranch("e_vertex_index", m_e_vertex_index);
00661 addBranch("e_track_Et_in_cone_0", m_e_track_Et_in_cone_0);
00662 addBranch("e_track_Et_in_cone_1", m_e_track_Et_in_cone_1);
00663 addBranch("e_track_Et_in_cone_2", m_e_track_Et_in_cone_2);
00664 addBranch("e_track_Et_in_cone_3", m_e_track_Et_in_cone_3);
00665 addBranch("e_trackIsolationEnergy_s", m_e_trackIsolationEnergy_s);
00666 addBranch("e_trackIsolationEnergy_0", m_e_trackIsolationEnergy_0);
00667 addBranch("e_trackIsolationEnergy_1", m_e_trackIsolationEnergy_1);
00668 addBranch("e_trackIsolationEnergy_2", m_e_trackIsolationEnergy_2);
00669 addBranch("e_trackIsolationEnergy_3", m_e_trackIsolationEnergy_3);
00670 addBranch("e_track_d0", m_e_track_d0);
00671 addBranch("e_track_d0err", m_e_track_d0err);
00672
00673
00674 m_nt->Branch("nb_rec_photons", &m_nb_rec_photons,
00675 "nb_rec_photons/I");
00676 addBranch("p_calo_p_x", m_p_calo_p_x);
00677 addBranch("p_calo_p_y", m_p_calo_p_y);
00678 addBranch("p_calo_p_z", m_p_calo_p_z);
00679 addBranch("p_calo_E", m_p_calo_E);
00680 addBranch("p_charge", m_p_charge);
00681 addBranch("p_NeuralNet", m_p_NeuralNet);
00682 addBranch("p_isEM", m_p_isEM);
00683 addBranch("p_egamma_flag", m_p_egamma_flag);
00684 addBranch("p_Et_in_cone_0", m_p_Et_in_cone_0);
00685 addBranch("p_Et_in_cone_1", m_p_Et_in_cone_1);
00686 addBranch("p_Et_in_cone_2", m_p_Et_in_cone_2);
00687 addBranch("p_Et_in_cone_3", m_p_Et_in_cone_3);
00688
00689
00690 m_nt->Branch("nb_rec_muons", &m_nb_rec_muons, "nb_rec_muons/I");
00691 addBranch("mu_alg_flag", m_mu_alg_flag);
00692 addBranch("mu_p_x", m_mu_p_x);
00693 addBranch("mu_p_y", m_mu_p_y);
00694 addBranch("mu_p_z", m_mu_p_z);
00695 addBranch("mu_E", m_mu_E);
00696 addBranch("mu_charge", m_mu_charge);
00697 addBranch("mu_fitChi2", m_mu_fitChi2);
00698 addBranch("mu_fitNumberDoF", m_mu_fitNumberDoF);
00699 addBranch("mu_fitChi2OverDoF", m_mu_fitChi2OverDoF);
00700 addBranch("mu_matchChi2", m_mu_matchChi2);
00701 addBranch("mu_matchNumberDoF", m_mu_matchNumberDoF);
00702 addBranch("mu_matchChi2OverDoF", m_mu_matchChi2OverDoF);
00703 addBranch("mu_rec_flag", m_mu_flag);
00704 addBranch("mu_hasCombinedMuonTrackParticle", m_mu_hasCombinedMuonTrackParticle);
00705 addBranch("mu_Et_in_cone_0", m_mu_Et_in_cone_0);
00706 addBranch("mu_Et_in_cone_1", m_mu_Et_in_cone_1);
00707 addBranch("mu_Et_in_cone_2", m_mu_Et_in_cone_2);
00708 addBranch("mu_Et_in_cone_3", m_mu_Et_in_cone_3);
00709 addBranch("mu_Et_in_cone_4", m_mu_Et_in_cone_4);
00710 addBranch("mu_Et_in_cone_5", m_mu_Et_in_cone_5);
00711 addBranch("mu_Et_in_cone_6", m_mu_Et_in_cone_6);
00712 addBranch("mu_Et_in_cone_7", m_mu_Et_in_cone_7);
00713 addBranch("mu_nb_tracks_in_cone_0", m_mu_nb_tracks_cone_0);
00714 addBranch("mu_nb_tracks_in_cone_1", m_mu_nb_tracks_cone_1);
00715 addBranch("mu_nb_tracks_in_cone_2", m_mu_nb_tracks_cone_2);
00716 addBranch("mu_nb_tracks_in_cone_3", m_mu_nb_tracks_cone_3);
00717 addBranch("mu_nb_tracks_in_cone_4", m_mu_nb_tracks_cone_4);
00718 addBranch("mu_nb_tracks_in_cone_5", m_mu_nb_tracks_cone_5);
00719 addBranch("mu_nb_tracks_in_cone_6", m_mu_nb_tracks_cone_6);
00720 addBranch("mu_nb_tracks_in_cone_7", m_mu_nb_tracks_cone_7);
00721 addBranch("mu_author" , m_mu_author);
00722 addBranch("mu_bestmatch", m_mu_bestmatch);
00723 addBranch("mu_vertex_index", m_mu_vertex_index);
00724 addBranch("mu_track_Et_in_cone_0", m_mu_track_Et_in_cone_0);
00725 addBranch("mu_track_Et_in_cone_1", m_mu_track_Et_in_cone_1);
00726 addBranch("mu_track_Et_in_cone_2", m_mu_track_Et_in_cone_2);
00727 addBranch("mu_track_Et_in_cone_3", m_mu_track_Et_in_cone_3);
00728 addBranch("mu_track_Et_in_cone_4", m_mu_track_Et_in_cone_4);
00729 addBranch("mu_track_Et_in_cone_5", m_mu_track_Et_in_cone_5);
00730 addBranch("mu_track_Et_in_cone_6", m_mu_track_Et_in_cone_6);
00731 addBranch("mu_track_Et_in_cone_7", m_mu_track_Et_in_cone_7);
00732 addBranch("mu_trackIsolationEnergy_s", m_mu_trackIsolationEnergy_s);
00733 addBranch("mu_trackIsolationEnergy_0", m_mu_trackIsolationEnergy_0);
00734 addBranch("mu_trackIsolationEnergy_1", m_mu_trackIsolationEnergy_1);
00735 addBranch("mu_trackIsolationEnergy_2", m_mu_trackIsolationEnergy_2);
00736 addBranch("mu_trackIsolationEnergy_3", m_mu_trackIsolationEnergy_3);
00737 addBranch("mu_trackIsolationEnergy_4", m_mu_trackIsolationEnergy_4);
00738 addBranch("mu_trackIsolationEnergy_5", m_mu_trackIsolationEnergy_5);
00739 addBranch("mu_trackIsolationEnergy_6", m_mu_trackIsolationEnergy_6);
00740 addBranch("mu_trackIsolationEnergy_7", m_mu_trackIsolationEnergy_7);
00741 addBranch("mu_track_d0", m_mu_track_d0);
00742 addBranch("mu_track_d0err", m_mu_track_d0err);
00743
00744
00745 m_nt->Branch("nb_rec_jets", &m_nb_rec_jets, "nb_rec_jets/I");
00746 addBranch("jet_p_x", m_jet_p_x);
00747 addBranch("jet_p_y", m_jet_p_y);
00748 addBranch("jet_p_z", m_jet_p_z);
00749 addBranch("jet_E", m_jet_E);
00750 addBranch("jet_flag", m_jet_flag);
00751 addBranch("jet_btag_weight", m_jet_btag_weight);
00752 addBranch("jet_truthflavor", m_jet_truthflavor);
00753 addBranch("jet_nb_tracks", m_jet_nb_tracks);
00754 addBranch("jet_tracks_charge", m_jet_tracks_charge);
00755 addBranch("jet_tracks_p_x", m_jet_tracks_p_x);
00756 addBranch("jet_tracks_p_y", m_jet_tracks_p_y);
00757 addBranch("jet_tracks_p_z", m_jet_tracks_p_z);
00758 addBranch("jet_tracks_E", m_jet_tracks_E);
00759 addBranch("jet_tracks_vertex_index", m_jet_tracks_vertex_index);
00760
00761
00762
00763 m_nt->Branch("nb_tau_jets", &m_nb_tau_jets, "nb_tau_jets/I");
00764 addBranch("taujet_p_x", m_taujet_p_x);
00765 addBranch("taujet_p_y", m_taujet_p_y);
00766 addBranch("taujet_p_z", m_taujet_p_z);
00767 addBranch("taujet_E", m_taujet_E);
00768 addBranch("taujet_flag", m_taujet_flag);
00769 addBranch("taujet_charge", m_taujet_charge);
00770 addBranch("taujet_etHadCalib", m_taujet_etHadCalib);
00771 addBranch("taujet_etEMCalib", m_taujet_etEMCalib);
00772 addBranch("taujet_emRadius", m_taujet_emRadius);
00773 addBranch("taujet_isolationFraction", m_taujet_isolationFraction);
00774 addBranch("taujet_centralityFraction", m_taujet_centralityFraction);
00775 addBranch("taujet_stripWidth2", m_taujet_stripWidth2);
00776 addBranch("taujet_nStripCells", m_taujet_nStripCells);
00777 addBranch("taujet_llh", m_taujet_llh);
00778 addBranch("taujet_lowPtTauEleDiscriminant", m_taujet_lowPtTauEleDiscriminant);
00779 addBranch("taujet_tauENeuralNetwork", m_taujet_tauENeuralNetwork);
00780 addBranch("taujet_tauJetNeuralnetwork", m_taujet_tauJetNeuralnetwork);
00781 addBranch("taujet_nb_tracks", m_taujet_nb_tracks);
00782 addBranch("taujet_track_px_1", m_taujet_track_px_1);
00783 addBranch("taujet_track_py_1", m_taujet_track_py_1);
00784 addBranch("taujet_track_pz_1", m_taujet_track_pz_1);
00785 addBranch("taujet_track_e_1", m_taujet_track_e_1);
00786 addBranch("taujet_track_TRTHighThresholdHits_1", m_taujet_track_TRTHighThresholdHits_1);
00787 addBranch("taujet_track_TRTHits_1", m_taujet_track_TRTHits_1);
00788 addBranch("taujet_track_px_2", m_taujet_track_px_2);
00789 addBranch("taujet_track_py_2", m_taujet_track_py_2);
00790 addBranch("taujet_track_pz_2", m_taujet_track_pz_2);
00791 addBranch("taujet_track_e_2", m_taujet_track_e_2);
00792 addBranch("taujet_track_TRTHighThresholdHits_2", m_taujet_track_TRTHighThresholdHits_2);
00793 addBranch("taujet_track_TRTHits_2", m_taujet_track_TRTHits_2);
00794 addBranch("taujet_track_px_3", m_taujet_track_px_3);
00795 addBranch("taujet_track_py_3", m_taujet_track_py_3);
00796 addBranch("taujet_track_pz_3", m_taujet_track_pz_3);
00797 addBranch("taujet_track_e_3", m_taujet_track_e_3);
00798 addBranch("taujet_track_TRTHighThresholdHits_3", m_taujet_track_TRTHighThresholdHits_3);
00799 addBranch("taujet_track_TRTHits_3", m_taujet_track_TRTHits_3);
00800
00801
00802 m_nt->Branch("nb_truth_jets", &m_nb_truth_jets, "nb_truth_jets/I");
00803 addBranch("truth_jet_p_x", m_truthjet_p_x);
00804 addBranch("truth_jet_p_y", m_truthjet_p_y);
00805 addBranch("truth_jet_p_z", m_truthjet_p_z);
00806 addBranch("truth_jet_E", m_truthjet_E);
00807 addBranch("truth_jet_flag", m_truthjet_flag);
00808 addBranch("truth_jet_btag_weight", m_truthjet_btag_weight);
00809
00810
00811 addBranch("missing_Et_object", m_met_obj_name);
00812 addBranch("missing_Etx", m_missing_Etx);
00813 addBranch("missing_Ety", m_missing_Ety);
00814 addBranch("missing_Et", m_missing_Et);
00815 addBranch("missing_Etsum", m_missing_Etsum);
00816
00817
00818 m_nt->Branch("nb_truth_particle_all", &m_nb_truth_particle_all, "nb_truth_particle_all/I");
00819 m_nt->Branch("nb_truth_particle", &m_nb_truth_particle, "nb_truth_particle/I");
00820
00821 addBranch("truth_particle_pt", m_truth_particle_pt);
00822 addBranch("truth_particle_status", m_truth_particle_status);
00823 addBranch("truth_particle_barcode", m_truth_particle_barcode);
00824 addBranch("truth_particle_pdgId", m_truth_particle_pdgId);
00825 addBranch("truth_particle_nDaughters", m_truth_particle_nDaughters);
00826 addBranch("truth_particle_p_x", m_truth_particle_p_x);
00827 addBranch("truth_particle_p_y", m_truth_particle_p_y);
00828 addBranch("truth_particle_p_z", m_truth_particle_p_z);
00829 addBranch("truth_particle_E", m_truth_particle_E);
00830 addBranch("truth_particle_charge", m_truth_particle_charge);
00831 addBranch("truth_particle_nParents", m_truth_particle_nParents);
00832 addBranch("truth_particle_mother0_barcode", m_truth_particle_mother0_barcode);
00833 addBranch("truth_particle_mother0_pdgId", m_truth_particle_mother0_pdgId);
00834 addBranch("truth_particle_vertex_index", m_truth_particle_vertex_index);
00835 addBranch("truth_particle_Et_in_cone_0", m_truth_particle_Et_in_cone_0);
00836 addBranch("truth_particle_Et_in_cone_1", m_truth_particle_Et_in_cone_1);
00837 addBranch("truth_particle_Et_in_cone_2", m_truth_particle_Et_in_cone_2);
00838 addBranch("truth_particle_Et_in_cone_3", m_truth_particle_Et_in_cone_3);
00839 addBranch("truth_particle_Et_in_cone_4", m_truth_particle_Et_in_cone_4);
00840
00841
00842 m_nt->Branch("event_weight", &m_event_weight, "event_weight/D");
00843
00844
00845 m_nt->Branch("nb_vertices", &m_nb_vertices, "nb_vertices/I");
00846 addBranch("vertex_position_x", m_vertex_position_x);
00847 addBranch("vertex_position_y", m_vertex_position_y);
00848 addBranch("vertex_position_z", m_vertex_position_z);
00849 addBranch("vertex_pos_error_x", m_vertex_pos_error_x);
00850 addBranch("vertex_pos_error_y", m_vertex_pos_error_y);
00851 addBranch("vertex_pos_error_z", m_vertex_pos_error_z);
00852 addBranch("vertex_chi2", m_vertex_chi2);
00853 addBranch("vertex_ndof", m_vertex_ndof);
00854 addBranch("vertex_Et", m_vertex_Et);
00855 addBranch("vertex_nb_tracks", m_vertex_nb_tracks);
00856
00857
00858 m_nt->Branch("nb_truth_vertices", &m_nb_truth_vertices, "nb_truth_vertices/I");
00859 addBranch("truth_vertex_position_x", m_truth_vertex_position_x);
00860 addBranch("truth_vertex_position_y", m_truth_vertex_position_y);
00861 addBranch("truth_vertex_position_z", m_truth_vertex_position_z);
00862 addBranch("truth_vertex_Et", m_truth_vertex_Et);
00863 addBranch("truth_vertex_nb_tracks", m_truth_vertex_nb_tracks);
00864
00865
00866 m_nt->Branch("nb_track_jets", &m_nb_track_jets, "nb_track_jets/I");
00867 addBranch("track_jet_p_x", m_track_jet_p_x);
00868 addBranch("track_jet_p_y", m_track_jet_p_y);
00869 addBranch("track_jet_p_z", m_track_jet_p_z);
00870 addBranch("track_jet_E", m_track_jet_E);
00871
00872
00873 m_nt->Branch("nb_truth_track_jets", &m_nb_truth_track_jets,
00874 "nb_truth_track_jets/I");
00875 addBranch("truth_track_jet_p_x", m_truth_track_jet_p_x);
00876 addBranch("truth_track_jet_p_y", m_truth_track_jet_p_y);
00877 addBranch("truth_track_jet_p_z", m_truth_track_jet_p_z);
00878 addBranch("truth_track_jet_E", m_truth_track_jet_E);
00879
00880
00881
00882
00883
00884
00885
00886
00887 m_nt->GetDirectory()->cd();
00888
00889 string str_helper;
00890
00891
00892
00893
00894
00895 tree_aod_file_collection = new TTree("aod_file_collection","aod_file_collection");
00896 tree_aod_file_collection->Branch("aod_files", &char_array_aod_file, "aod_files/C");
00897 if(v_string_aod_files.size()==0){
00898 v_string_aod_files.push_back("not specified in Job Options");
00899 }
00900 for(unsigned int k=0; k<v_string_aod_files.size(); k++){
00901 str_helper=v_string_aod_files[k];
00902 strcpy(char_array_aod_file,str_helper.c_str());
00903 tree_aod_file_collection->Fill();
00904 }
00905
00906
00907
00908
00909 tree_aod_container_keys = new TTree("aod_container_keys","aod_container_keys");
00910
00911 strcpy(aodkey_trigger_decision_container ,m_trigger_decision_container.c_str());
00912 tree_aod_container_keys->Branch("trigger_decision_container", &aodkey_trigger_decision_container,
00913 "trigger_decision_container/C");
00914
00915 strcpy(aodkey_trigger_mu_lvl1_container ,m_trigger_mu_lvl1_container.c_str());
00916 tree_aod_container_keys->Branch("trigger_mu_lvl1_container",&aodkey_trigger_mu_lvl1_container,
00917 "trigger_mu_lvl1_container/C");
00918
00919 strcpy(aodkey_trigger_mu_lvl2_container ,m_trigger_mu_lvl2_container.c_str());
00920 tree_aod_container_keys->Branch("trigger_mu_lvl2_container",&aodkey_trigger_mu_lvl2_container,
00921 "trigger_mu_lvl2_container/C");
00922
00923 strcpy(aodkey_trigger_mu_ef_container ,m_trigger_mu_ef_container.c_str());
00924 tree_aod_container_keys->Branch("trigger_mu_ef_container",&aodkey_trigger_mu_ef_container,
00925 "trigger_mu_ef_container/C");
00926
00927 strcpy(aodkey_trigger_met_container ,m_trigger_met_container.c_str());
00928 tree_aod_container_keys->Branch("trigger_met_container",&aodkey_trigger_met_container,
00929 "trigger_met_container/C");
00930
00931 strcpy(aodkey_electron_container ,m_electron_container.c_str());
00932 tree_aod_container_keys->Branch("electron_container",&aodkey_electron_container,
00933 "electron_container/C");
00934 strcpy(aodkey_photon_container ,m_photon_container.c_str());
00935 tree_aod_container_keys->Branch("photon_container",&aodkey_photon_container,
00936 "photon_container/C");
00937
00938 string m_muon_container_string;
00939 for(unsigned int k=0; k<m_muon_container.size(); k++){
00940 if(k!=0) m_muon_container_string += ", ";
00941 m_muon_container_string += m_muon_container[k];
00942 }
00943
00944 strcpy(aodkey_muon_container ,m_muon_container_string.c_str());
00945 tree_aod_container_keys->Branch("muon_container",&aodkey_muon_container,
00946 "muon_container/C");
00947
00948 string m_met_container_string;
00949 for(unsigned int k=0; k<v_string_met_container.size(); k++){
00950 if(k!=0) m_met_container_string += ", ";
00951 m_met_container_string += v_string_met_container.at(k);
00952 }
00953
00954 strcpy(aodkey_met_container ,m_met_container_string.c_str());
00955 tree_aod_container_keys->Branch("met_container",&aodkey_met_container,
00956 "met_container/C");
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968 strcpy(aodkey_jet_container ,m_jet_container.c_str());
00969 tree_aod_container_keys->Branch("jet_container",&aodkey_jet_container,
00970 "jet_container/C");
00971 strcpy(aodkey_taujet_container ,m_taujet_container.c_str());
00972 tree_aod_container_keys->Branch("taujet_container",&aodkey_taujet_container,
00973 "taujet_container/C");
00974 strcpy(aodkey_truthjet_container ,m_truthjet_container.c_str());
00975 tree_aod_container_keys->Branch("truthjet_container",&aodkey_truthjet_container,
00976 "truthjet_container/C");
00977 strcpy(aodkey_truthmissingEt_container ,m_truthmissingEt_container.c_str());
00978 tree_aod_container_keys->Branch("truthmissingEt_container",&aodkey_truthmissingEt_container,
00979 "truthmissingEt_container/C");
00980 strcpy(aodkey_truthparticle_container ,m_truthparticle_container.c_str());
00981 tree_aod_container_keys->Branch("truthparticle_container",&aodkey_truthparticle_container,
00982 "truthparticle_container/C");
00983
00984 aodkey_AtlFastFlag = m_AtlFastFlag;
00985 tree_aod_container_keys->Branch("AtlFastFlag",&aodkey_AtlFastFlag,
00986 "AtlFastFlag/O");
00987
00988 aodkey_doAODFix1mm = m_doAODFix1mm;
00989 tree_aod_container_keys->Branch("doAODFix1mm",&aodkey_doAODFix1mm,
00990 "doAODFix1mm/O");
00991
00992 aodkey_doTrackJets = m_doTrackJets;
00993 tree_aod_container_keys->Branch("doTrackJets",&aodkey_doTrackJets,
00994 "doTrackJets/O");
00995 aodkey_doVertices = m_doVertices;
00996 tree_aod_container_keys->Branch("doVertices",&aodkey_doVertices,
00997 "doVertices/O");
00998
00999 aodkey_truthparticleMaximumLeptonBarcode = m_truthparticleMaximumLeptonBarcode;
01000 tree_aod_container_keys->Branch("truthparticleMaximumLeptonBarcode",&aodkey_truthparticleMaximumLeptonBarcode,
01001 "truthparticleMaximumLeptonBarcode/I");
01002
01003 aodkey_truthparticleNoPDGAbove100 = m_truthparticleNoPDGAbove100;
01004 tree_aod_container_keys->Branch("truthparticleNoPDGAbove100",&aodkey_truthparticleNoPDGAbove100,
01005 "truthparticleNoPDGAbove100/O");
01006
01007 strcpy(aodkey_primary_vertex_container ,m_primary_vertex_container.c_str());
01008 tree_aod_container_keys->Branch("primary_vertex_container",
01009 &aodkey_primary_vertex_container,
01010 "primary_vertex_container/C");
01011
01012 strcpy(aodkey_track_jet_container ,m_track_jet_container.c_str());
01013 tree_aod_container_keys->Branch("track_jet_container",
01014 &aodkey_track_jet_container,
01015 "track_jet_container/C");
01016 strcpy(aodkey_truth_track_jet_container,
01017 m_truth_track_jet_container.c_str());
01018 tree_aod_container_keys->Branch("truth_track_jet_container",
01019 &aodkey_truth_track_jet_container,
01020 "truth_track_jet_container/C");
01021 strcpy(aodkey_track_particle_container ,m_track_particle_container.c_str());
01022 tree_aod_container_keys->Branch("track_particle_container",
01023 &aodkey_track_particle_container,
01024 "track_particle_container/C");
01025
01026
01027 strcpy(aodkey_release,m_release.c_str());
01028 tree_aod_container_keys->Branch("release", &aodkey_release, "release/C");
01029
01030 strcpy(aodkey_svnversion,m_svnversion.c_str());
01031 tree_aod_container_keys->Branch("svnversion", &aodkey_svnversion, "svnversion/C");
01032
01033 strcpy(aodkey_date,m_date.c_str());
01034 tree_aod_container_keys->Branch("date", &aodkey_date, "date/C");
01035
01036
01037 tree_aod_container_keys->Fill();
01038
01040
01042
01043 if (m_doTrackJets && m_AtlFastFlag) {
01044 *m_log << MSG::WARNING
01045 << "No track jets are reconstructed on ATLFAST data!"
01046 << endreq;
01047 m_doTrackJets = false;
01048 m_doVertices = false;
01049 }
01050
01051
01052 return StatusCode::SUCCESS;
01053
01054 }
01055
01056
01057
01058
01059
01060
01061
01062 StatusCode
01063 HiggsAnalysisNtupleWriter::CBNT_finalize(void) {
01064
01065 *m_log << MSG::INFO
01066 << "Finilizing HiggsAnalysisNtupleWriter..."
01067 << endreq;
01068
01069 return StatusCode::SUCCESS;
01070
01071 }
01072
01073
01074
01075
01076
01077
01078
01079 StatusCode HiggsAnalysisNtupleWriter::CBNT_execute(void) {
01080
01081
01082 nEvents++;
01083 if(nEvents%2000==0) cout << "Event: " << nEvents << endl;
01084
01085 if (m_doTrigger) {
01086
01087
01088 if (!get_trigger_data()) {
01089 *m_log << MSG::ERROR
01090 << "Problems in retrieving trigger decision data!"
01091 << endreq;
01092 return StatusCode::FAILURE;
01093 }
01094
01095 if(!m_AtlFastFlag){
01096
01097 if (!get_trigger_muon_lvl1_data()) {
01098 *m_log << MSG::ERROR
01099 << "Problems in retrieving trigger muon lvl1 data!"
01100 << endreq;
01101 return StatusCode::FAILURE;
01102 }
01103 }
01104 if(!m_AtlFastFlag && m_nb_trigger_mu_lvl1>0){
01105
01106 if (!get_trigger_muon_lvl2_data()) {
01107 *m_log << MSG::ERROR
01108 << "Problems in retrieving trigger muon lvl2 data!"
01109 << endreq;
01110 return StatusCode::FAILURE;
01111 }
01112 }
01113 if(!m_AtlFastFlag && m_nb_trigger_mu_lvl1>0&&m_nb_trigger_mu_lvl2>0){
01114
01115 if (!get_trigger_muon_ef_data()) {
01116 *m_log << MSG::ERROR
01117 << "Problems in retrieving trigger muon ef data!"
01118 << endreq;
01119 return StatusCode::FAILURE;
01120 }
01121 }
01122 if(!m_AtlFastFlag){
01123
01124 if (!get_trigger_met_data()) {
01125 *m_log << MSG::ERROR
01126 << "Problems in retrieving trigger met data!"
01127 << endreq;
01128 return StatusCode::FAILURE;
01129 }
01130 }
01131 }
01132
01133 if (m_doTrackParticles) {
01134 if (!get_trackparticle_data()) {
01135 *m_log << MSG::ERROR
01136 << "Problems in retrieving data of reconstructed track particles!"
01137 << endreq;
01138 return StatusCode::FAILURE;
01139 }
01140 }
01141
01142 if (m_doElectrons) {
01143 if (!get_electron_data()) {
01144 *m_log << MSG::ERROR
01145 << "Problems in retrieving data of reconstructed electrons!"
01146 << endreq;
01147 return StatusCode::FAILURE;
01148 }
01149 }
01150
01151
01152 if (m_doPhotons) {
01153 if (!get_photon_data()) {
01154 *m_log << MSG::ERROR
01155 << "Problems in retrieving data of reconstructed photons!"
01156 << endreq;
01157 return StatusCode::FAILURE;
01158 }
01159 }
01160
01161
01162
01163 if (m_doMuons) {
01164 if (!get_muon_data()) {
01165 *m_log << MSG::ERROR
01166 << "Problems in retrieving data of reconstructed muons!"
01167 << endreq;
01168 return StatusCode::FAILURE;
01169 }
01170 }
01171
01172
01173
01174 if (m_doJets) {
01175 if (!get_jet_data()) {
01176 *m_log << MSG::ERROR
01177 << "Problems in retrieving data of reconstructed jets!"
01178 << endreq;
01179 return StatusCode::FAILURE;
01180 }
01181 }
01182
01183
01184 if (m_doTauJets) {
01185 if (!get_taujet_data()) {
01186 *m_log << MSG::ERROR
01187 << "Problems in retrieving data of tau jets!"
01188 << endreq;
01189 return StatusCode::FAILURE;
01190 }
01191 }
01192
01193
01194 if (m_doMissingEt) {
01195 if (!get_missingEt_data()) {
01196 *m_log << MSG::ERROR
01197 << "Problems in retrieving data of missing Et!"
01198 << endreq;
01199 return StatusCode::FAILURE;
01200 }
01201 }
01202
01203
01204 if (m_doTruthParticles) {
01205 if (!get_truthparticle_data()) {
01206 *m_log << MSG::ERROR
01207 << "Problems in retrieving data of truth particles!"
01208 << endreq;
01209 return StatusCode::FAILURE;
01210 }
01211 }
01212
01213
01214
01215
01216
01217 if (m_doTruthJets) {
01218 if (!get_truthjet_data()) {
01219 *m_log << MSG::ERROR
01220 << "Problems in retrieving data of truth jets!"
01221 << endreq;
01222 return StatusCode::FAILURE;
01223 }
01224 }
01225
01226
01227 if (m_doMissingEt) {
01228 if (!get_truthmissingEt_data()) {
01229 *m_log << MSG::ERROR
01230 << "Problems in retrieving data of truth missing Et!"
01231 << endreq;
01232 return StatusCode::FAILURE;
01233 }
01234 }
01235
01236
01237
01238 if (!get_eventweight_data()) {
01239 *m_log << MSG::ERROR
01240 << "Problems in retrieving data of weights!"
01241 << endreq;
01242 return StatusCode::FAILURE;
01243 }
01244
01245
01246 if (m_doVertices && !m_AtlFastFlag) {
01247
01248 if (!get_vertex_data()) {
01249 *m_log << MSG::ERROR
01250 << "Problems in retrieving data of vertices!"
01251 << endreq;
01252 return StatusCode::FAILURE;
01253 }
01254
01255
01256 if (!get_truth_vertex_data()) {
01257 *m_log << MSG::ERROR
01258 << "Problems in retrieving data of truth vertices!"
01259 << endreq;
01260 return StatusCode::FAILURE;
01261 }
01262
01263 }
01264
01265 if (m_doTrackJets && !m_AtlFastFlag) {
01266
01267 if (!get_track_jet_data()) {
01268 *m_log << MSG::ERROR
01269 << "Problems in retrieving data of track jets!"
01270 << endreq;
01271 return StatusCode::FAILURE;
01272 }
01273
01274
01275 if (!get_truth_track_jet_data()) {
01276 *m_log << MSG::ERROR
01277 << "Problems in retrieving data of truth track jets!"
01278 << endreq;
01279 return StatusCode::FAILURE;
01280 }
01281 }
01282
01283
01284 return StatusCode::SUCCESS;
01285
01286 }
01287
01288
01289
01290
01291
01292
01293
01294 StatusCode HiggsAnalysisNtupleWriter::CBNT_clear(void) {
01295
01296
01298
01300
01301
01302
01303
01304 m_trigger_l1_defined=false;
01305 m_trigger_l2_defined=false;
01306 m_trigger_ef_defined=false;
01307 m_trigger_keys_l1->clear();
01308 m_trigger_keys_status_l1->clear();
01309 m_trigger_keys_l2 ->clear();
01310 m_trigger_keys_status_l2->clear();
01311 m_trigger_keys_ef ->clear();
01312 m_trigger_keys_status_ef->clear();
01313
01314
01315 m_nb_trigger_mu_lvl1 =0;
01316 m_trigger_mu_lvl1_phi ->clear();
01317 m_trigger_mu_lvl1_eta ->clear();
01318 m_trigger_mu_lvl1_threshold_name ->clear();
01319 m_trigger_mu_lvl1_threshold_number ->clear();
01320 m_trigger_mu_lvl1_threshold_value ->clear();
01321 m_trigger_mu_lvl1_roiword ->clear();
01322 m_trigger_mu_lvl1_confirmed ->clear();
01323
01324
01325 m_nb_trigger_mu_lvl2 =0;
01326 m_trigger_mu_lvl2_phi ->clear();
01327 m_trigger_mu_lvl2_eta ->clear();
01328 m_trigger_mu_lvl2_pt ->clear();
01329 m_trigger_mu_lvl2_sigma_pt ->clear();
01330
01331
01332 m_nb_trigger_mu_ef =0;
01333 m_trigger_mu_ef_phi ->clear();
01334 m_trigger_mu_ef_eta ->clear();
01335 m_trigger_mu_ef_pt ->clear();
01336 m_trigger_mu_ef_code ->clear();
01337 m_trigger_mu_ef_charge1 ->clear();
01338 m_trigger_mu_ef_charge2 ->clear();
01339
01340
01341 m_trigger_met_ex = 0;
01342 m_trigger_met_ey = 0;
01343 m_trigger_met_et = 0;
01344 m_trigger_met_sumEt = 0;
01345 m_trigger_met_RoIword = 0;
01346
01347
01348 m_nb_rec_tracks = 0;
01349 m_track_p_x ->clear();
01350 m_track_p_y ->clear();
01351 m_track_p_z ->clear();
01352 m_track_E ->clear();
01353 m_track_charge ->clear();
01354 m_track_vertex_index ->clear();
01355 m_track_SCThit ->clear();
01356 m_track_Phit ->clear();
01357 m_track_BLayerhit ->clear();
01358 m_track_TRThit ->clear();
01359 m_track_MDThit ->clear();
01360 m_track_CSChit_eta ->clear();
01361 m_track_TGChit_eta ->clear();
01362 m_track_RPChit_eta ->clear();
01363 m_track_CSChit_phi ->clear();
01364 m_track_TGChit_phi ->clear();
01365 m_track_RPChit_phi ->clear();
01366 m_track_d0 ->clear();
01367 m_track_z0 ->clear();
01368 m_track_chi2 ->clear();
01369 m_track_nDoF ->clear();
01370 m_track_trackIsolationEnergy_s ->clear();
01371 m_track_trackIsolationEnergy_0 ->clear();
01372 m_track_trackIsolationEnergy_1 ->clear();
01373 m_track_trackIsolationEnergy_2 ->clear();
01374 m_track_trackIsolationEnergy_3 ->clear();
01375
01376
01377
01378 m_nb_rec_electrons = 0;
01379 m_e_p_x ->clear();
01380 m_e_p_y ->clear();
01381 m_e_p_z ->clear();
01382 m_e_E ->clear();
01383 m_e_calo_p_x ->clear();
01384 m_e_calo_p_y ->clear();
01385 m_e_calo_p_z ->clear();
01386 m_e_calo_E ->clear();
01387 m_e_charge ->clear();
01388 m_e_isEM ->clear();
01389 m_e_NeuralNet ->clear();
01390 m_e_egamma_flag ->clear();
01391 m_e_softe_flag ->clear();
01392 m_e_E_over_p ->clear();
01393 m_e_TRTHighThresholdHits ->clear();
01394 m_e_TRTHits ->clear();
01395 m_e_ethad1 ->clear();
01396 m_e_Et_in_cone_0 ->clear();
01397 m_e_Et_in_cone_1 ->clear();
01398 m_e_Et_in_cone_2 ->clear();
01399 m_e_Et_in_cone_3 ->clear();
01400 m_e_vertex_index ->clear();
01401 m_e_track_Et_in_cone_0 ->clear();
01402 m_e_track_Et_in_cone_1 ->clear();
01403 m_e_track_Et_in_cone_2 ->clear();
01404 m_e_track_Et_in_cone_3 ->clear();
01405 m_e_trackIsolationEnergy_s ->clear();
01406 m_e_trackIsolationEnergy_0 ->clear();
01407 m_e_trackIsolationEnergy_1 ->clear();
01408 m_e_trackIsolationEnergy_2 ->clear();
01409 m_e_trackIsolationEnergy_3 ->clear();
01410 m_e_track_d0 ->clear();
01411 m_e_track_d0err ->clear();
01412
01413
01414 m_nb_rec_photons = 0;
01415 m_p_calo_p_x ->clear();
01416 m_p_calo_p_y ->clear();
01417 m_p_calo_p_z ->clear();
01418 m_p_calo_E ->clear();
01419 m_p_charge ->clear();
01420 m_p_isEM ->clear();
01421 m_p_NeuralNet ->clear();
01422 m_p_egamma_flag ->clear();
01423 m_p_Et_in_cone_0 ->clear();
01424 m_p_Et_in_cone_1 ->clear();
01425 m_p_Et_in_cone_2 ->clear();
01426 m_p_Et_in_cone_3 ->clear();
01427
01428
01429 m_nb_rec_muons = 0;
01430 m_mu_alg_flag ->clear();
01431 m_mu_p_x ->clear();
01432 m_mu_p_y ->clear();
01433 m_mu_p_z ->clear();
01434 m_mu_E ->clear();
01435 m_mu_charge ->clear();
01436 m_mu_fitChi2 ->clear();
01437 m_mu_fitNumberDoF ->clear();
01438 m_mu_fitChi2OverDoF ->clear();
01439 m_mu_matchChi2 ->clear();
01440 m_mu_matchNumberDoF ->clear();
01441 m_mu_matchChi2OverDoF ->clear();
01442 m_mu_flag ->clear();
01443 m_mu_hasCombinedMuonTrackParticle->clear();
01444 m_mu_Et_in_cone_0 ->clear();
01445 m_mu_Et_in_cone_1 ->clear();
01446 m_mu_Et_in_cone_2 ->clear();
01447 m_mu_Et_in_cone_3 ->clear();
01448 m_mu_Et_in_cone_4 ->clear();
01449 m_mu_Et_in_cone_5 ->clear();
01450 m_mu_Et_in_cone_6 ->clear();
01451 m_mu_Et_in_cone_7 ->clear();
01452 m_mu_nb_tracks_cone_0 ->clear();
01453 m_mu_nb_tracks_cone_1 ->clear();
01454 m_mu_nb_tracks_cone_2 ->clear();
01455 m_mu_nb_tracks_cone_3 ->clear();
01456 m_mu_nb_tracks_cone_4 ->clear();
01457 m_mu_nb_tracks_cone_5 ->clear();
01458 m_mu_nb_tracks_cone_6 ->clear();
01459 m_mu_nb_tracks_cone_7 ->clear();
01460 m_mu_author ->clear();
01461 m_mu_bestmatch ->clear();
01462 m_mu_vertex_index ->clear();
01463 m_mu_track_Et_in_cone_0 ->clear();
01464 m_mu_track_Et_in_cone_1 ->clear();
01465 m_mu_track_Et_in_cone_2 ->clear();
01466 m_mu_track_Et_in_cone_3 ->clear();
01467 m_mu_track_Et_in_cone_4 ->clear();
01468 m_mu_track_Et_in_cone_5 ->clear();
01469 m_mu_track_Et_in_cone_6 ->clear();
01470 m_mu_track_Et_in_cone_7 ->clear();
01471 m_mu_trackIsolationEnergy_s ->clear();
01472 m_mu_trackIsolationEnergy_0 ->clear();
01473 m_mu_trackIsolationEnergy_1 ->clear();
01474 m_mu_trackIsolationEnergy_2 ->clear();
01475 m_mu_trackIsolationEnergy_3 ->clear();
01476 m_mu_trackIsolationEnergy_4 ->clear();
01477 m_mu_trackIsolationEnergy_5 ->clear();
01478 m_mu_trackIsolationEnergy_6 ->clear();
01479 m_mu_trackIsolationEnergy_7 ->clear();
01480 m_mu_track_d0 ->clear();
01481 m_mu_track_d0err ->clear();
01482
01483
01484 m_nb_rec_jets = 0;
01485 m_jet_p_x ->clear();
01486 m_jet_p_y ->clear();
01487 m_jet_p_z ->clear();
01488 m_jet_E ->clear();
01489 m_jet_flag ->clear();
01490 m_jet_btag_weight ->clear();
01491 m_jet_truthflavor ->clear();
01492 m_jet_nb_tracks ->clear();
01493 m_jet_tracks_charge ->clear();
01494 m_jet_tracks_p_x ->clear();
01495 m_jet_tracks_p_y ->clear();
01496 m_jet_tracks_p_z ->clear();
01497 m_jet_tracks_E ->clear();
01498 m_jet_tracks_vertex_index ->clear();
01499
01500
01501 m_nb_tau_jets = 0;
01502 m_taujet_p_x ->clear();
01503 m_taujet_p_y ->clear();
01504 m_taujet_p_z ->clear();
01505 m_taujet_E ->clear();
01506 m_taujet_flag ->clear();
01507 m_taujet_charge ->clear();
01508 m_taujet_etHadCalib ->clear();
01509 m_taujet_etEMCalib ->clear();
01510 m_taujet_emRadius ->clear();
01511 m_taujet_isolationFraction ->clear();
01512 m_taujet_centralityFraction ->clear();
01513 m_taujet_stripWidth2 ->clear();
01514 m_taujet_nStripCells ->clear();
01515 m_taujet_llh ->clear();
01516 m_taujet_lowPtTauEleDiscriminant ->clear();
01517 m_taujet_tauENeuralNetwork ->clear();
01518 m_taujet_tauJetNeuralnetwork ->clear();
01519 m_taujet_nb_tracks ->clear();
01520 m_taujet_track_px_1 ->clear();
01521 m_taujet_track_py_1 ->clear();
01522 m_taujet_track_pz_1 ->clear();
01523 m_taujet_track_e_1 ->clear();
01524 m_taujet_track_TRTHighThresholdHits_1->clear();
01525 m_taujet_track_TRTHits_1 ->clear();
01526 m_taujet_track_px_2 ->clear();
01527 m_taujet_track_py_2 ->clear();
01528 m_taujet_track_pz_2 ->clear();
01529 m_taujet_track_e_2 ->clear();
01530 m_taujet_track_TRTHighThresholdHits_2->clear();
01531 m_taujet_track_TRTHits_2 ->clear();
01532 m_taujet_track_px_3 ->clear();
01533 m_taujet_track_py_3 ->clear();
01534 m_taujet_track_pz_3 ->clear();
01535 m_taujet_track_e_3 ->clear();
01536 m_taujet_track_TRTHighThresholdHits_3->clear();
01537 m_taujet_track_TRTHits_3 ->clear();
01538
01539
01540 m_nb_truth_jets = 0;
01541 m_truthjet_p_x ->clear();
01542 m_truthjet_p_y ->clear();
01543 m_truthjet_p_z ->clear();
01544 m_truthjet_E ->clear();
01545 m_truthjet_flag ->clear();
01546 m_truthjet_btag_weight ->clear();
01547
01548
01549 m_met_obj_name ->clear();
01550 m_missing_Etx ->clear();
01551 m_missing_Ety ->clear();
01552 m_missing_Et ->clear();
01553 m_missing_Etsum ->clear();
01554
01555
01556 m_nb_truth_particle_all = 0;
01557 m_nb_truth_particle = 0;
01558 m_truth_particle_pt ->clear();
01559 m_truth_particle_status ->clear();
01560 m_truth_particle_barcode ->clear();
01561 m_truth_particle_pdgId ->clear();
01562 m_truth_particle_nDaughters ->clear();
01563 m_truth_particle_p_x ->clear();
01564 m_truth_particle_p_y ->clear();
01565 m_truth_particle_p_z ->clear();
01566 m_truth_particle_E ->clear();
01567 m_truth_particle_charge ->clear();
01568 m_truth_particle_nParents ->clear();
01569 m_truth_particle_mother0_barcode->clear();
01570 m_truth_particle_mother0_pdgId ->clear();
01571 m_truth_particle_vertex_index ->clear();
01572 m_truth_particle_Et_in_cone_0 ->clear();
01573 m_truth_particle_Et_in_cone_1 ->clear();
01574 m_truth_particle_Et_in_cone_2 ->clear();
01575 m_truth_particle_Et_in_cone_3 ->clear();
01576 m_truth_particle_Et_in_cone_4 ->clear();
01577
01578
01579 m_event_weight = 0;
01580
01581
01582 m_nb_vertices = 0;
01583 m_vertex_position_x ->clear();
01584 m_vertex_position_y ->clear();
01585 m_vertex_position_z ->clear();
01586 m_vertex_pos_error_x ->clear();
01587 m_vertex_pos_error_y ->clear();
01588 m_vertex_pos_error_z ->clear();
01589 m_vertex_chi2 ->clear();
01590 m_vertex_ndof ->clear();
01591 m_vertex_Et ->clear();
01592 m_vertex_nb_tracks ->clear();
01593
01594
01595 m_nb_truth_vertices = 0;
01596 m_truth_vertex_position_x ->clear();
01597 m_truth_vertex_position_y ->clear();
01598 m_truth_vertex_position_z ->clear();
01599 m_truth_vertex_Et ->clear();
01600 m_truth_vertex_nb_tracks ->clear();
01601
01602
01603 m_nb_track_jets = 0;
01604 m_track_jet_p_x ->clear();
01605 m_track_jet_p_y ->clear();
01606 m_track_jet_p_z ->clear();
01607 m_track_jet_E ->clear();
01608
01609
01610 m_nb_truth_track_jets = 0;
01611 m_truth_track_jet_p_x ->clear();
01612 m_truth_track_jet_p_y ->clear();
01613 m_truth_track_jet_p_z ->clear();
01614 m_truth_track_jet_E ->clear();
01615
01616 return StatusCode::SUCCESS;
01617
01618 }
01619
01620
01621
01622
01623
01624
01625
01626 bool HiggsAnalysisNtupleWriter::get_trigger_muon_lvl1_data(void) {
01627
01628 *m_log << MSG::DEBUG << "in get_trigger_muon_lvl1_data()" << endreq;
01629 StatusCode sc = StatusCode::SUCCESS;
01630 m_nb_trigger_mu_lvl1=0;
01631 const LVL1_ROI* lvl1ROI=0;
01632 sc = m_storeGate->retrieve(lvl1ROI);
01633
01634 if(sc.isFailure()) {
01635 *m_log << MSG::ERROR << "Can't retrieve the Muon lvl1" << endreq;
01636 return false;
01637 }
01638
01639
01640
01641 if ( lvl1ROI != 0 ) {
01642 for( LVL1_ROI::muons_type::const_iterator it = (lvl1ROI->getMuonROIs()).begin();
01643 it != (lvl1ROI->getMuonROIs()).end(); ++it ) {
01644 m_nb_trigger_mu_lvl1++;
01645 double phi = (*it)->getPhi();
01646 if (phi>TMath::Pi()) phi = phi - 2.*TMath::Pi();
01647 m_trigger_mu_lvl1_phi->push_back(phi);
01648 m_trigger_mu_lvl1_eta->push_back((*it)->getEta());
01649 m_trigger_mu_lvl1_threshold_value->push_back((*it)->getThrValue());
01650 m_trigger_mu_lvl1_threshold_name->push_back((*it)->getThrName());
01651 m_trigger_mu_lvl1_threshold_number->push_back((*it)->getThrNumber());
01652 m_trigger_mu_lvl1_roiword->push_back((*it)->getROIWord());
01653 m_trigger_mu_lvl1_confirmed->push_back(false);
01654 }
01655 }
01656 return true;
01657 }
01658
01659
01660
01661
01662
01663
01664
01665 bool HiggsAnalysisNtupleWriter::get_trigger_muon_lvl2_data(void) {
01666
01667 *m_log << MSG::DEBUG << "in get_trigger_muon_lvl2_data()" << endreq;
01668 StatusCode sc = StatusCode::SUCCESS;
01669 m_nb_trigger_mu_lvl2=0;
01670 const DataHandle<CombinedMuonFeature> combMuonFeatureIt;
01671 const DataHandle<CombinedMuonFeature> combMuonFeatureItEnd;
01672 sc = m_storeGate->retrieve(combMuonFeatureIt,combMuonFeatureItEnd);
01673 if (sc != StatusCode::SUCCESS) {
01674 *m_log << MSG::ERROR << "Can't retrieve the Muon lvl2" << endreq;
01675 return true;
01676 }
01677 for ( ; combMuonFeatureIt != combMuonFeatureItEnd ; ++combMuonFeatureIt ) {
01678 bool matchFound = false;
01679 double dRmin = 10000.;
01680 double phi_l2=combMuonFeatureIt->phi();
01681 if (phi_l2>TMath::Pi()) phi_l2 = phi_l2-2.*TMath::Pi();
01682 for (int l1=0 ; l1<m_nb_trigger_mu_lvl1 ; ++l1) {
01683 double deltaEta = combMuonFeatureIt->eta()-(*m_trigger_mu_lvl1_eta)[l1];
01684 double deltaPhi = phi_l2-(*m_trigger_mu_lvl1_phi)[l1];
01685 deltaPhi=TMath::Abs(deltaPhi);
01686 if (deltaPhi>TMath::Pi()) deltaPhi=2.*TMath::Pi()-deltaPhi;
01687 double deltaR = sqrt(deltaEta*deltaEta+deltaPhi*deltaPhi);
01688 if (deltaR<dRmin) {
01689 (*m_trigger_mu_lvl1_confirmed)[l1]=true;
01690 dRmin = deltaR;
01691 }
01692 }
01693 if (dRmin<0.15) {
01694 matchFound=true;
01695 }
01696
01697 if (matchFound) {
01698 m_nb_trigger_mu_lvl2++;
01699 m_trigger_mu_lvl2_eta->push_back(combMuonFeatureIt->eta());
01700 m_trigger_mu_lvl2_phi->push_back(phi_l2);
01701 m_trigger_mu_lvl2_pt->push_back(combMuonFeatureIt->pt());
01702 m_trigger_mu_lvl2_sigma_pt->push_back(combMuonFeatureIt->sigma_pt());
01703 }
01704 }
01705
01706
01707 return true;
01708 }
01709
01710
01711
01712
01713
01714
01715
01716 bool HiggsAnalysisNtupleWriter::get_trigger_muon_ef_data(void) {
01717
01718 *m_log << MSG::DEBUG << "in get_trigger_muon_ef_data()" << endreq;
01719
01720 StatusCode sc = StatusCode::SUCCESS;
01721
01722 const DataHandle<TrigMuonEFContainer> trigEcontIt;
01723 const DataHandle<TrigMuonEFContainer> trigEcontEnd;
01724 m_nb_trigger_mu_ef=0;
01725 sc = m_storeGate->retrieve(trigEcontIt,trigEcontEnd);
01726 if (sc != StatusCode::SUCCESS) {
01727 *m_log << MSG::ERROR << "Can't retrieve the Muon ef" << endreq;
01728 return true;
01729 }
01730
01731 for (;trigEcontIt != trigEcontEnd; ++trigEcontIt) {
01732 string contName = trigEcontIt.key();
01733 if( contName.find("_HLTAutoKey") != string::npos) {
01734 TrigMuonEFContainer::const_iterator trigmuItr = trigEcontIt->begin();
01735 TrigMuonEFContainer::const_iterator trigmuItrE = trigEcontIt->end();
01736 for(; trigmuItr != trigmuItrE; ++trigmuItr) {
01737 bool matchFound = false;
01738 double dRmin = 10000.;
01739 double phi_ef=(*trigmuItr)->phi();
01740 if (phi_ef>TMath::Pi()) phi_ef = phi_ef-2.*TMath::Pi();
01741 for (int l2=0 ; l2<m_nb_trigger_mu_lvl2 ; ++l2) {
01742 double deltaEta = (*trigmuItr)->eta()-(*m_trigger_mu_lvl2_eta)[l2];
01743 double deltaPhi = phi_ef-(*m_trigger_mu_lvl2_phi)[l2];
01744 deltaPhi=TMath::Abs(deltaPhi);
01745 if (deltaPhi>TMath::Pi()) deltaPhi=2.*TMath::Pi()-deltaPhi;
01746 double deltaR = sqrt(deltaEta*deltaEta+deltaPhi*deltaPhi);
01747 if (deltaR<dRmin) {
01748 dRmin = deltaR;
01749 }
01750 }
01751 if (dRmin<0.15) {
01752 matchFound=true;
01753 }
01754 if (matchFound) {
01755 m_nb_trigger_mu_ef++;
01756 m_trigger_mu_ef_code->push_back((*trigmuItr)->MuonCode());
01757 m_trigger_mu_ef_eta->push_back((*trigmuItr)->eta());
01758 m_trigger_mu_ef_phi->push_back(phi_ef);
01759 m_trigger_mu_ef_pt->push_back((*trigmuItr)->pt());
01760 m_trigger_mu_ef_charge1->push_back((*trigmuItr)->charge());
01761 m_trigger_mu_ef_charge2->push_back((*trigmuItr)->Charge());
01762 }
01763 }
01764 }
01765 }
01766 return true;
01767 }
01768
01769
01770
01771
01772
01773
01774
01775 bool HiggsAnalysisNtupleWriter::get_trigger_met_data(void) {
01776
01777 *m_log << MSG::DEBUG << "in get_trigger_met_data()" << endreq;
01778
01779 StatusCode sc = StatusCode::SUCCESS;
01780
01781 const TrigMissingET *trigger_met_container = NULL;
01782 sc =m_storeGate->retrieve(trigger_met_container,m_trigger_met_container);
01783 if(sc.isFailure() || trigger_met_container==0) {
01784 *m_log << MSG::WARNING
01785 << "No trigger met container found in the store gate!"
01786 << endreq;
01787 return true;
01788 }
01789 *m_log << MSG::DEBUG << "trigger met container retrieved successfully!"
01790 << endreq;
01791
01792
01793
01794 m_trigger_met_ex=trigger_met_container->ex();
01795 m_trigger_met_ey=trigger_met_container->ey();
01796 m_trigger_met_et=trigger_met_container->et();
01797 m_trigger_met_sumEt=trigger_met_container->sumEt();
01798 m_trigger_met_RoIword=trigger_met_container->RoIword();
01799
01800
01801 return true;
01802 }
01803
01804
01805
01806
01807
01808
01809
01810 bool HiggsAnalysisNtupleWriter::get_trigger_data(void) {
01811 bool trigger_exists;
01812 trigger_exists = false;
01813
01814 *m_log << MSG::DEBUG << "in get_trigger_data()" << endreq;
01815
01816 StatusCode sc = StatusCode::SUCCESS;
01817
01818
01819 if (m_storeGate->contains<TriggerDecision>( m_trigger_decision_container )) {
01820 *m_log << MSG::INFO << "TriggerDecision with container name "
01821 << m_trigger_decision_container
01822 << " found in StoreGate" << endreq;
01823 trigger_exists = true;
01824 }
01825 else{
01826 *m_log << MSG::INFO << "TriggerDecision with container name "
01827 << m_trigger_decision_container
01828 << " NOT found in StoreGate" << endreq;
01829 trigger_exists = false;
01830 }
01831
01832
01833 if(trigger_exists == false){
01834 m_trigger_l1_defined = false;
01835 m_trigger_l2_defined = false;
01836 m_trigger_ef_defined = false;
01837 }
01838 if(trigger_exists == true){
01839 m_trigger_l1_defined = false;
01840 m_trigger_l2_defined = false;
01841 m_trigger_ef_defined = false;
01842 const TriggerDecision* trigger_container;
01843 sc = m_storeGate->retrieve(trigger_container, m_trigger_decision_container);
01844 if(sc.isFailure() || trigger_container==0) {
01845 *m_log << MSG::WARNING
01846 << "No trigger container found in the store gate!"
01847 << endreq;
01848 return false;
01849 }
01850
01851
01852
01853 if ( trigger_container->isDefinedL1() ) {
01854 m_trigger_l1_defined = true;
01855
01856 map<string, bool> l1sig = trigger_container->L1map();
01857 map<string, bool>::iterator it=l1sig.begin();
01858 for (; it != l1sig.end(); ++it) {
01859 *m_log << MSG::INFO << " * Signature name=" << it->first
01860 << "; result=" << (it->second ? "passed" : "failed") << endreq;
01861 m_trigger_keys_l1->push_back(it->first );
01862 m_trigger_keys_status_l1->push_back((int)it->second );
01863 }
01864 if(m_trigger_keys_l1->size()!=m_trigger_keys_status_l1->size()){
01865 *m_log << MSG::ERROR <<"Unequal vector size! "<<endl
01866 <<"Key-vector size: "<<m_trigger_keys_l1->size()<<endl
01867 <<"Status-vector size: "<<m_trigger_keys_status_l1->size()<<endl;
01868 }
01869 }
01870
01871
01872
01873 if ( trigger_container->isDefinedL2() ) {
01874 m_trigger_l2_defined = true;
01875
01876 map<string, bool> l2sig = trigger_container->L2map();
01877 map<string, bool>::iterator it=l2sig.begin();
01878 for (; it != l2sig.end(); ++it) {
01879 *m_log << MSG::INFO << " * Signature name=" << it->first
01880 << "; result=" << (it->second ? "passed" : "failed") << endreq;
01881 m_trigger_keys_l2->push_back(it->first );
01882 m_trigger_keys_status_l2->push_back((int)it->second );
01883 }
01884 if(m_trigger_keys_l2->size()!=m_trigger_keys_status_l2->size()){
01885 *m_log << MSG::ERROR <<"Unequal vector size! "<<endl
01886 <<"Key-vector size: "<<m_trigger_keys_l2->size()<<endl
01887 <<"Status-vector size: "<<m_trigger_keys_status_l2->size()<<endl;
01888 }
01889
01890 }
01891
01892
01893 if ( trigger_container->isDefinedEF() ) {
01894 m_trigger_ef_defined = true;
01895
01896 map<string, bool> efsig = trigger_container->EFmap();
01897 map<string, bool>::iterator it=efsig.begin();
01898 for (; it != efsig.end(); ++it) {
01899 *m_log << MSG::INFO << " * Signature name=" << it->first
01900 << "; result=" << (it->second ? "passed" : "failed") << endreq;
01901 m_trigger_keys_ef->push_back(it->first );
01902 m_trigger_keys_status_ef->push_back((int)it->second );
01903 }
01904 if(m_trigger_keys_ef->size()!=m_trigger_keys_status_ef->size()){
01905 *m_log << MSG::ERROR <<"Unequal vector size! "<<endl
01906 <<"Key-vector size: "<<m_trigger_keys_ef->size()<<endl
01907 <<"Status-vector size: "<<m_trigger_keys_status_ef->size()<<endl;
01908 }
01909 }
01910
01911
01912 }
01913
01914 return true;
01915 }
01916
01917
01918
01919
01920
01921
01922
01923 bool HiggsAnalysisNtupleWriter::get_trackparticle_data(void) {
01924
01926
01928
01929 const Rec::TrackParticleContainer *track_particle_container(0);
01930
01931
01932
01934
01936
01937 StatusCode sc(m_storeGate->retrieve(track_particle_container,
01938 m_track_particle_container));
01939 if(sc.isFailure() || track_particle_container==0) {
01940 *m_log << MSG::WARNING
01941 << "No track particle container found in the store gate!"
01942 << endreq;
01943 return false;
01944 }
01945 *m_log << MSG::DEBUG << "track particle container retrieved successfully!"
01946 << endreq;
01947
01949
01951
01952
01953 for (unsigned int k=0; k<track_particle_container->size(); k++) {
01954
01955
01956
01957
01958
01959
01960 m_nb_rec_tracks++;
01961
01962
01963
01964 m_track_p_x->push_back( (*track_particle_container)[k]->px() );
01965 m_track_p_y->push_back( (*track_particle_container)[k]->py() );
01966 m_track_p_z->push_back( (*track_particle_container)[k]->pz() );
01967 m_track_E->push_back( (*track_particle_container)[k]->e() );
01968
01969
01970 m_track_charge->push_back( static_cast<int>( (*track_particle_container)[k]->charge()) );
01971
01972
01973 if (!m_AtlFastFlag && m_doVertices) {
01974
01975 if ((*track_particle_container)[k]->reconstructedVertex()==NULL) {
01976 m_track_vertex_index->push_back(-1);
01977 } else {
01978 m_track_vertex_index
01979 ->push_back(find_vertex((*track_particle_container)[k]->reconstructedVertex()));
01980 }
01981 }
01982 else{
01983 m_track_vertex_index->push_back(-1);
01984 }
01985
01986 if (!m_AtlFastFlag){
01987 m_track_chi2->push_back(((*track_particle_container)[k]->fitQuality())->chiSquared());
01988 m_track_nDoF->push_back(((*track_particle_container)[k]->fitQuality())->numberDoF());
01989 const Trk::TrackSummary* trksumy=(*track_particle_container)[k]->trackSummary();
01990 m_track_SCThit->push_back(trksumy->get(Trk::numberOfSCTHits));
01991 m_track_Phit->push_back(trksumy->get(Trk::numberOfPixelHits));
01992 m_track_BLayerhit->push_back(trksumy->get(Trk::numberOfBLayerHits));
01993 m_track_TRThit->push_back(trksumy->get(Trk::numberOfTRTHits));
01994 m_track_MDThit->push_back(trksumy->get(Trk::numberOfMdtHits));
01995 m_track_CSChit_eta->push_back(trksumy->get(Trk::numberOfCscEtaHits));
01996 m_track_TGChit_eta->push_back(trksumy->get(Trk::numberOfTgcEtaHits));
01997 m_track_RPChit_eta->push_back(trksumy->get(Trk::numberOfRpcEtaHits));
01998 m_track_CSChit_phi->push_back(trksumy->get(Trk::numberOfCscPhiHits));
01999 m_track_TGChit_phi->push_back(trksumy->get(Trk::numberOfTgcPhiHits));
02000 m_track_RPChit_phi->push_back(trksumy->get(Trk::numberOfRpcPhiHits));
02001 const Trk::MeasuredPerigee* trkperi=(*track_particle_container)[k]->measuredPerigee();
02002 m_track_d0->push_back(trkperi->parameters()[Trk::d0]);
02003 m_track_z0->push_back(trkperi->parameters()[Trk::z0]);
02004 }
02005 else{
02006 m_track_chi2->push_back(-9);
02007 m_track_nDoF->push_back(-9);
02008 m_track_SCThit->push_back(-9);
02009 m_track_Phit->push_back(-9);
02010 m_track_BLayerhit->push_back(-9);
02011 m_track_TRThit->push_back(-9);
02012 m_track_MDThit->push_back(-9);
02013 m_track_CSChit_eta->push_back(-9);
02014 m_track_TGChit_eta->push_back(-9);
02015 m_track_RPChit_eta->push_back(-9);
02016 m_track_CSChit_phi->push_back(-9);
02017 m_track_TGChit_phi->push_back(-9);
02018 m_track_RPChit_phi->push_back(-9);
02019 m_track_d0->push_back(-9);
02020 m_track_z0->push_back(-9);
02021 }
02022
02023 if (!m_AtlFastFlag) {
02024 m_track_trackIsolationEnergy_s->push_back(
02025 m_trackIsolationTool->trackIsolationEnergy((*track_particle_container)[k],0.01));
02026 m_track_trackIsolationEnergy_0->push_back(
02027 m_trackIsolationTool->trackIsolationEnergy((*track_particle_container)[k],0.2));
02028 m_track_trackIsolationEnergy_1->push_back(
02029 m_trackIsolationTool->trackIsolationEnergy((*track_particle_container)[k],0.3));
02030 m_track_trackIsolationEnergy_2->push_back(
02031 m_trackIsolationTool->trackIsolationEnergy((*track_particle_container)[k],0.4));
02032 m_track_trackIsolationEnergy_3->push_back(
02033 m_trackIsolationTool->trackIsolationEnergy((*track_particle_container)[k],0.45));
02034 }
02035 else {
02036 m_track_trackIsolationEnergy_s->push_back(-999);
02037 m_track_trackIsolationEnergy_0->push_back(-999);
02038 m_track_trackIsolationEnergy_1->push_back(-999);
02039 m_track_trackIsolationEnergy_2->push_back(-999);
02040 m_track_trackIsolationEnergy_3->push_back(-999);
02041 }
02042
02043
02044
02045 }
02046
02047 return true;
02048
02049 }
02050
02051
02052
02053
02054
02055
02056
02057
02058 bool HiggsAnalysisNtupleWriter::get_photon_data(void) {
02059
02061
02063
02064 const PhotonContainer *photon_container(0);
02065
02066
02068
02070
02071 StatusCode sc(m_storeGate->retrieve(photon_container,
02072 m_photon_container));
02073 if(sc.isFailure() || photon_container==0) {
02074 *m_log << MSG::WARNING
02075 << "No photon container found in the store gate!"
02076 << endreq;
02077 return false;
02078 }
02079 *m_log << MSG::DEBUG << "photon container retrieved successfully!"
02080 << endreq;
02081
02083
02085
02086
02087 for (unsigned int k=0; k<photon_container->size(); k++) {
02088
02089
02090
02091 if (m_photon_container!=string("AtlfastPhotonCollection")
02092 && ((*photon_container)[k]->author()!=
02093 PhotonParameters::AuthorEgamma )) {
02094 continue;
02095 }
02096
02097
02098
02099 m_nb_rec_photons++;
02100
02101
02102
02103
02104
02105
02106 m_p_calo_p_x->push_back(
02107 (*photon_container)[k]->px() );
02108 m_p_calo_p_y->push_back(
02109 (*photon_container)[k]->py() );
02110 m_p_calo_p_z->push_back(
02111 (*photon_container)[k]->pz() );
02112 m_p_calo_E->push_back(
02113 (*photon_container)[k]->e() );
02114
02115
02116
02117
02118 m_p_charge->push_back( static_cast<int>(
02119 (*photon_container)[k]->charge()) );
02120
02121
02122 if (m_photon_container!=string("AtlfastPhotonCollection")) {
02123 m_p_egamma_flag->push_back(
02124 ((*photon_container)[k]->author()==
02125 PhotonParameters::AuthorEgamma) &&
02126 ((*photon_container)[k]->isEM()%16==0) );
02127 } else {
02128 m_p_egamma_flag->push_back( 1 );
02129 }
02130
02131 m_p_isEM->push_back((*photon_container)[k]->isEM() );
02132 m_p_NeuralNet->push_back((*photon_container)[k]->photonID(
02133 egammaPID::NeuralNet) );
02134
02135
02136
02137
02138 m_p_Et_in_cone_0->push_back(
02139 (*photon_container)[k]->parameter(PhotonParameters::etcone20) );
02140 m_p_Et_in_cone_1->push_back(
02141 (*photon_container)[k]->parameter(PhotonParameters::etcone30) );
02142 m_p_Et_in_cone_2->push_back(
02143 (*photon_container)[k]->parameter(PhotonParameters::etcone40) );
02144 m_p_Et_in_cone_3->push_back(
02145 (*photon_container)[k]->parameter(PhotonParameters::etcone) );
02146
02147
02148 }
02149
02150 return true;
02151
02152 }
02153
02154
02155
02156
02157
02158
02159 bool HiggsAnalysisNtupleWriter::get_electron_data(void) {
02160
02162
02164
02165 const ElectronContainer *electron_container(0);
02166
02167
02168
02170
02172
02173 StatusCode sc(m_storeGate->retrieve(electron_container,
02174 m_electron_container));
02175 if(sc.isFailure() || electron_container==0) {
02176 *m_log << MSG::WARNING
02177 << "No electron container found in the store gate!"
02178 << endreq;
02179 return false;
02180 }
02181 *m_log << MSG::DEBUG << "Electron container retrieved successfully!"
02182 << endreq;
02183
02185
02187
02188
02189 for (unsigned int k=0; k<electron_container->size(); k++) {
02190
02191
02192
02193 if (m_electron_container!=string("AtlfastElectronCollection")
02194 && ((*electron_container)[k]->author()!=
02195 ElectronParameters::AuthorEgamma &&
02196 (*electron_container)[k]->author()!=
02197 ElectronParameters::AuthorEgammaSofte)) {
02198 continue;
02199 }
02200
02201
02202 if (m_electron_container!=string("AtlfastElectronCollection") &&
02203 !(*electron_container)[k]->hasTrack()) {
02204 continue;
02205 }
02206
02207
02208
02209
02210 m_nb_rec_electrons++;
02211
02212
02213
02214 if (m_electron_container!=string("AtlfastElectronCollection")) {
02215 m_e_p_x->push_back(
02216 (*electron_container)[k]->track()->px() );
02217 m_e_p_y->push_back(
02218 (*electron_container)[k]->track()->py() );
02219 m_e_p_z->push_back(
02220 (*electron_container)[k]->track()->pz() );
02221 m_e_E->push_back(
02222 (*electron_container)[k]->track()->e() );
02223 } else {
02224 m_e_p_x->push_back(
02225 (*electron_container)[k]->px() );
02226 m_e_p_y->push_back(
02227 (*electron_container)[k]->py() );
02228 m_e_p_z->push_back(
02229 (*electron_container)[k]->pz() );
02230 m_e_E->push_back(
02231 (*electron_container)[k]->e() );
02232 }
02233
02234
02235
02236 m_e_calo_p_x->push_back(
02237 (*electron_container)[k]->px() );
02238 m_e_calo_p_y->push_back(
02239 (*electron_container)[k]->py() );
02240 m_e_calo_p_z->push_back(
02241 (*electron_container)[k]->pz() );
02242 m_e_calo_E->push_back(
02243 (*electron_container)[k]->e() );
02244
02245
02246
02247 m_e_charge->push_back( static_cast<int>(
02248 (*electron_container)[k]->charge()) );
02249
02250
02251 if (m_electron_container!=string("AtlfastElectronCollection")) {
02252 m_e_egamma_flag->push_back(
02253 ((*electron_container)[k]->author()==
02254 ElectronParameters::AuthorEgamma) &&
02255 ((*electron_container)[k]->isEM()%16==0) );
02256 m_e_softe_flag->push_back(
02257 ((*electron_container)[k]->author()==
02258 ElectronParameters::AuthorEgammaSofte) &&
02259 ((*electron_container)[k]->isEM()%16==0) );
02260 m_e_isEM->push_back((*electron_container)[k]->isEM() );
02261 m_e_NeuralNet->push_back((*electron_container)[k]->electronID(egammaPID::NeuralNet));
02262 m_e_E_over_p->push_back(
02263 (*electron_container)[k]->parameter(ElectronParameters::EoverP));
02264 m_e_TRTHighThresholdHits->push_back(
02265 (*electron_container)[k]->numberOfTRTHighThresholdHits());
02266 m_e_TRTHits->push_back((*electron_container)[k]->numberOfTRTHits());
02267 m_e_ethad1->push_back((*electron_container)[k]->parameter(ElectronParameters::ethad1));
02268 } else {
02269 m_e_egamma_flag->push_back( 1 );
02270 m_e_softe_flag->push_back( 0 );
02271 m_e_isEM->push_back(0);
02272 m_e_NeuralNet->push_back(99.0);
02273 m_e_E_over_p->push_back(1.0);
02274 m_e_TRTHighThresholdHits->push_back(10);
02275 m_e_TRTHits->push_back(10);
02276 m_e_ethad1->push_back(0.0);
02277 }
02278
02279
02280
02281 m_e_Et_in_cone_0->push_back((*electron_container)[k]
02282 ->parameter(ElectronParameters::etcone20) );
02283 m_e_Et_in_cone_1->push_back((*electron_container)[k]
02284 ->parameter(ElectronParameters::etcone30) );
02285 m_e_Et_in_cone_2->push_back((*electron_container)[k]
02286 ->parameter(ElectronParameters::etcone40) );
02287 m_e_Et_in_cone_3->push_back((*electron_container)[k]
02288 ->parameter(ElectronParameters::etcone) );
02289 if (!m_AtlFastFlag) {
02290 m_e_trackIsolationEnergy_s->push_back(
02291 m_trackIsolationTool->trackIsolationEnergy(((*electron_container)[k])->track(),0.01));
02292 m_e_trackIsolationEnergy_0->push_back(
02293 m_trackIsolationTool->trackIsolationEnergy(((*electron_container)[k])->track(),0.2));
02294 m_e_trackIsolationEnergy_1->push_back(
02295 m_trackIsolationTool->trackIsolationEnergy(((*electron_container)[k])->track(),0.3));
02296 m_e_trackIsolationEnergy_2->push_back(
02297 m_trackIsolationTool->trackIsolationEnergy(((*electron_container)[k])->track(),0.4));
02298 m_e_trackIsolationEnergy_3->push_back(
02299 m_trackIsolationTool->trackIsolationEnergy(((*electron_container)[k])->track(),0.45));
02300 }
02301 else {
02302 m_e_trackIsolationEnergy_s->push_back(-999);
02303 m_e_trackIsolationEnergy_0->push_back(-999);
02304 m_e_trackIsolationEnergy_1->push_back(-999);
02305 m_e_trackIsolationEnergy_2->push_back(-999);
02306 m_e_trackIsolationEnergy_3->push_back(-999);
02307 }
02308
02309
02310 if (!m_AtlFastFlag && m_doVertices) {
02311
02312 if ((*electron_container)[k]->track()->reconstructedVertex()==NULL) {
02313 m_e_vertex_index->push_back(-1);
02314 } else {
02315 m_e_vertex_index
02316 ->push_back(find_vertex((*electron_container)[k]
02317 ->track()->reconstructedVertex()));
02318 }
02319 }
02320 else{
02321 m_e_vertex_index->push_back(-1);
02322 }
02323
02324
02325 Hep3Vector vertex(0.,0.,0.);
02326
02327 if(!m_AtlFastFlag && m_doVertices){
02328
02329 if((*electron_container)[k]->track()->reconstructedVertex()!=NULL){
02330 vertex = (*electron_container)[k]
02331 ->track()->reconstructedVertex()->position();
02332 }
02333 }
02334
02335
02336
02337
02338 HepLorentzVector tmp_tlv;
02339 if(!m_AtlFastFlag){
02340 tmp_tlv = HepLorentzVector( (*electron_container)[k]->track()->px(),
02341 (*electron_container)[k]->track()->py(),
02342 (*electron_container)[k]->track()->pz(),
02343 (*electron_container)[k]->track()->e());
02344 }
02345 else{
02346 tmp_tlv = HepLorentzVector( (*electron_container)[k]->px(),
02347 (*electron_container)[k]->py(),
02348 (*electron_container)[k]->pz(),
02349 (*electron_container)[k]->e());
02350 }
02351
02352 if (m_doVertices && (*m_e_vertex_index)[m_e_vertex_index->size()-1]==-1 ) {
02353
02354 m_e_track_Et_in_cone_0->push_back(-1.0);
02355 m_e_track_Et_in_cone_1->push_back(-1.0);
02356 m_e_track_Et_in_cone_2->push_back(-1.0);
02357 m_e_track_Et_in_cone_3->push_back(-1.0);
02358
02359 }else{
02360
02361 m_e_track_Et_in_cone_0->push_back( get_energy_in_cone(0.20, tmp_tlv, vertex) );
02362 m_e_track_Et_in_cone_1->push_back( get_energy_in_cone(0.30, tmp_tlv, vertex) );
02363 m_e_track_Et_in_cone_2->push_back( get_energy_in_cone(0.40, tmp_tlv, vertex) );
02364 m_e_track_Et_in_cone_3->push_back( get_energy_in_cone(0.45, tmp_tlv, vertex) );
02365 }
02366
02367
02368
02369 double d0(0.), d0err(0.);
02370
02371 if(!m_AtlFastFlag &&(*electron_container)[k]->hasTrack() ){
02372
02373 const Rec::TrackParticle* track = (*electron_container)[k]->track();
02374 const Trk::MeasuredPerigee* measPerigee = track->measuredPerigee();
02375
02376 d0 = measPerigee->parameters()[Trk::d0];
02377
02378
02379 const Trk::ErrorMatrix errorMatrix = measPerigee->localErrorMatrix();
02380 d0err = errorMatrix.error(Trk::d0);
02381 }
02382
02383 m_e_track_d0->push_back(d0);
02384 m_e_track_d0err->push_back(d0err);
02385
02386
02387
02388
02389
02390
02391
02392
02393
02394
02395
02396
02397
02398
02399
02400
02401
02402
02403
02404
02405
02406
02407
02408
02409
02410
02411
02412
02413
02414
02415
02416
02417
02418
02419
02420
02421
02422
02423
02424
02425
02426
02427
02428
02429
02430
02431
02432
02433
02434
02435
02436
02437
02438
02439
02440
02441
02442
02443
02444
02445
02446
02447
02448
02449
02450
02451
02452
02453
02454
02455
02456
02457
02458
02459
02460
02461
02462
02463
02464
02465
02466
02467
02468
02469
02470
02471
02472
02473
02474 }
02475
02476
02477
02478
02479 return true;
02480
02481 }
02482
02483
02484
02485
02486
02487
02488
02489 bool HiggsAnalysisNtupleWriter::get_muon_data(void) {
02490
02492
02494
02495 const MuonContainer *muon_container(0);
02496
02497
02499
02501
02502 for (unsigned int i_cont=0; i_cont<m_muon_container.size(); i_cont++) {
02503 StatusCode sc(m_storeGate->retrieve(muon_container, m_muon_container[i_cont]));
02504 if(sc.isFailure() || muon_container==0) {
02505 *m_log << MSG::WARNING
02506 << "No muon container found in the store gate!"
02507 << endreq;
02508 return false;
02509 }
02510 *m_log << MSG::DEBUG << "Muon container retrieved successfully!"
02511 << endreq;
02512
02514
02516
02517
02518 for (unsigned int k=0; k<muon_container->size(); k++) {
02519
02520
02521 m_nb_rec_muons++;
02522
02523
02524
02525
02526
02527
02528
02529
02530
02531
02532
02533
02534
02535
02536
02537
02538
02539
02540
02541
02542
02543
02544
02545
02546
02547
02548
02549
02550
02551
02552
02553
02554
02555
02556
02557
02558
02559
02560
02561
02562
02563
02564
02565
02566
02567
02568
02569
02570
02571
02572
02573
02574
02575
02576 int mu_alg_flag = 0;
02577 if(m_muon_container[i_cont]=="AtlfastMuonCollection"){
02578 mu_alg_flag = 1;
02579 }
02580 else if(m_muon_container[i_cont]=="MuidMuonCollection"){
02581 mu_alg_flag = 2;
02582 }
02583 else if (m_muon_container[i_cont]=="StacoMuonCollection"){
02584 mu_alg_flag = 3;
02585 }
02586 m_mu_alg_flag->push_back(mu_alg_flag);
02587
02588
02589
02590
02591 m_mu_p_x->push_back( (*muon_container)[k]->px() );
02592 m_mu_p_y->push_back( (*muon_container)[k]->py() );
02593 m_mu_p_z->push_back( (*muon_container)[k]->pz() );
02594 m_mu_E->push_back( (*muon_container)[k]->e() );
02595
02596
02597
02598 m_mu_charge->push_back( static_cast<int>(
02599 (*muon_container)[k]->charge()) );
02600
02601
02602 if (!m_AtlFastFlag){
02603 m_mu_fitChi2->push_back( (*muon_container)[k]->fitChi2() );
02604 m_mu_fitNumberDoF->push_back( (*muon_container)[k]->fitNumberDoF() );
02605 m_mu_fitChi2OverDoF->push_back( (*muon_container)[k]->fitChi2OverDoF() );
02606 m_mu_matchChi2->push_back( (*muon_container)[k]->matchChi2() );
02607 m_mu_matchNumberDoF->push_back( (*muon_container)[k]->matchNumberDoF() );
02608 m_mu_matchChi2OverDoF->push_back( (*muon_container)[k]->matchChi2OverDoF() );
02609 }
02610 else {
02611 m_mu_fitChi2->push_back(50.0);
02612 m_mu_fitNumberDoF->push_back(50);
02613 m_mu_fitChi2OverDoF->push_back(1.0);
02614 m_mu_matchChi2->push_back(50.0);
02615 m_mu_matchNumberDoF->push_back(50);
02616 m_mu_matchChi2OverDoF->push_back(1.0);
02617 }
02618
02619
02620 if (!m_AtlFastFlag){
02621 if ((*muon_container)[k]->hasCombinedMuonTrackParticle() && (*muon_container)[k]->isHighPt()) {
02622 if ((*muon_container)[k]->bestMatch()) {
02623 m_mu_flag->push_back( 1 );
02624 } else {
02625 m_mu_flag->push_back( -1 );
02626 }
02627 }
02628 else if ((*muon_container)[k]->isStandAloneMuon()) {
02629 m_mu_flag->push_back( 2 );
02630 }
02631 else if ((*muon_container)[k]->isLowPtReconstructedMuon()) {
02632 m_mu_flag->push_back( 3 );
02633 }
02634 else{
02635 m_mu_flag->push_back( 0 );
02636 }
02637
02638
02639 m_mu_hasCombinedMuonTrackParticle->push_back((int)
02640 (*muon_container)[k]->hasCombinedMuonTrackParticle());
02641
02642
02643 m_mu_author->push_back( (*muon_container)[k]->author() );
02644
02645
02646 if ((*muon_container)[k]->bestMatch()){
02647 m_mu_bestmatch->push_back( 1 );
02648 }else {
02649 m_mu_bestmatch->push_back( -1 );
02650 }
02651 }
02652 else {
02653 m_mu_flag->push_back( 1 );
02654 m_mu_hasCombinedMuonTrackParticle->push_back(1);
02655 m_mu_author->push_back( 1 );
02656 m_mu_bestmatch->push_back( 1 );
02657 }
02658
02659
02660 m_mu_Et_in_cone_0->push_back(
02661 (*muon_container)[k]->parameter(MuonParameters::etcone10) );
02662 m_mu_Et_in_cone_1->push_back(
02663 (*muon_container)[k]->parameter(MuonParameters::etcone20) );
02664 m_mu_Et_in_cone_2->push_back(
02665 (*muon_container)[k]->parameter(MuonParameters::etcone30) );
02666 m_mu_Et_in_cone_3->push_back(
02667 (*muon_container)[k]->parameter(MuonParameters::etcone40) );
02668 m_mu_Et_in_cone_4->push_back(
02669 (*muon_container)[k]->parameter(MuonParameters::etcone) );
02670 m_mu_Et_in_cone_5->push_back(
02671 (*muon_container)[k]->parameter(MuonParameters::etcone50) );
02672 m_mu_Et_in_cone_6->push_back(
02673 (*muon_container)[k]->parameter(MuonParameters::etcone60) );
02674 m_mu_Et_in_cone_7->push_back(
02675 (*muon_container)[k]->parameter(MuonParameters::etcone70) );
02676 if (!m_AtlFastFlag) {
02677 m_mu_trackIsolationEnergy_s->push_back(
02678 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.01));
02679 m_mu_trackIsolationEnergy_0->push_back(
02680 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.1));
02681 m_mu_trackIsolationEnergy_1->push_back(
02682 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.2));
02683 m_mu_trackIsolationEnergy_2->push_back(
02684 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.3));
02685 m_mu_trackIsolationEnergy_3->push_back(
02686 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.4));
02687 m_mu_trackIsolationEnergy_4->push_back(
02688 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.45));
02689 m_mu_trackIsolationEnergy_5->push_back(
02690 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.5));
02691 m_mu_trackIsolationEnergy_6->push_back(
02692 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.6));
02693 m_mu_trackIsolationEnergy_7->push_back(
02694 m_trackIsolationTool->trackIsolationEnergy(((*muon_container)[k])->track(),0.7));
02695 }
02696 else {
02697 m_mu_trackIsolationEnergy_s->push_back(-999);
02698 m_mu_trackIsolationEnergy_0->push_back(-999);
02699 m_mu_trackIsolationEnergy_1->push_back(-999);
02700 m_mu_trackIsolationEnergy_2->push_back(-999);
02701 m_mu_trackIsolationEnergy_3->push_back(-999);
02702 m_mu_trackIsolationEnergy_4->push_back(-999);
02703 m_mu_trackIsolationEnergy_5->push_back(-999);
02704 m_mu_trackIsolationEnergy_6->push_back(-999);
02705 m_mu_trackIsolationEnergy_7->push_back(-999);
02706 }
02707
02708
02709 m_mu_nb_tracks_cone_0->push_back(static_cast<int>
02710 ((*muon_container)[k]->parameter(MuonParameters::nucone10)) );
02711 m_mu_nb_tracks_cone_1->push_back(static_cast<int>
02712 ((*muon_container)[k]->parameter(MuonParameters::nucone20)) );
02713 m_mu_nb_tracks_cone_2->push_back(static_cast<int>
02714 ((*muon_container)[k]->parameter(MuonParameters::nucone30)) );
02715 m_mu_nb_tracks_cone_3->push_back(static_cast<int>
02716 ((*muon_container)[k]->parameter(MuonParameters::nucone40)) );
02717 m_mu_nb_tracks_cone_4->push_back(static_cast<int>
02718 ((*muon_container)[k]->parameter(MuonParameters::nucone)) );
02719 m_mu_nb_tracks_cone_5->push_back(static_cast<int>
02720 ((*muon_container)[k]->parameter(MuonParameters::nucone50)) );
02721 m_mu_nb_tracks_cone_6->push_back(static_cast<int>
02722 ((*muon_container)[k]->parameter(MuonParameters::nucone60)) );
02723 m_mu_nb_tracks_cone_7->push_back(static_cast<int>
02724 ((*muon_container)[k]->parameter(MuonParameters::nucone70)) );
02725
02726
02727 if (!m_AtlFastFlag && m_doVertices) {
02728 if ((*muon_container)[k]->track()->reconstructedVertex()==NULL) {
02729 m_mu_vertex_index->push_back(-1);
02730 } else {
02731 m_mu_vertex_index
02732 ->push_back( find_vertex((*muon_container)[k]
02733 ->track()->reconstructedVertex()));
02734 }
02735 }else{
02736 m_mu_vertex_index->push_back(-1);
02737 }
02738
02739 Hep3Vector vertex(0.,0.,0.);
02740
02741 if(m_doVertices){
02742
02743 if((*muon_container)[k]->track()->reconstructedVertex()!=NULL){
02744 vertex = (*muon_container)[k]
02745 ->track()->reconstructedVertex()->position();
02746 }
02747 }
02748
02749
02750 HepLorentzVector tmp_tlv((*muon_container)[k]->px(),
02751 (*muon_container)[k]->py(),
02752 (*muon_container)[k]->pz(),
02753 (*muon_container)[k]->e());
02754
02755
02756
02757
02758 if (m_doVertices && (*m_mu_vertex_index)[m_mu_vertex_index->size()-1]==-1 ) {
02759
02760 m_mu_track_Et_in_cone_0->push_back(-1.0);
02761 m_mu_track_Et_in_cone_1->push_back(-1.0);
02762 m_mu_track_Et_in_cone_2->push_back(-1.0);
02763 m_mu_track_Et_in_cone_3->push_back(-1.0);
02764 m_mu_track_Et_in_cone_4->push_back(-1.0);
02765 m_mu_track_Et_in_cone_5->push_back(-1.0);
02766 m_mu_track_Et_in_cone_6->push_back(-1.0);
02767 m_mu_track_Et_in_cone_7->push_back(-1.0);
02768
02769 }else{
02770 m_mu_track_Et_in_cone_0->push_back( get_energy_in_cone(0.1, tmp_tlv, vertex) );
02771 m_mu_track_Et_in_cone_1->push_back( get_energy_in_cone(0.2, tmp_tlv, vertex) );
02772 m_mu_track_Et_in_cone_2->push_back( get_energy_in_cone(0.3, tmp_tlv, vertex) );
02773 m_mu_track_Et_in_cone_3->push_back( get_energy_in_cone(0.4, tmp_tlv, vertex) );
02774 m_mu_track_Et_in_cone_4->push_back( get_energy_in_cone(0.45,tmp_tlv, vertex) );
02775 m_mu_track_Et_in_cone_5->push_back( get_energy_in_cone(0.5, tmp_tlv, vertex) );
02776 m_mu_track_Et_in_cone_6->push_back( get_energy_in_cone(0.6, tmp_tlv, vertex) );
02777 m_mu_track_Et_in_cone_7->push_back( get_energy_in_cone(0.7, tmp_tlv, vertex) );
02778 }
02779
02780
02781
02782 double d0(0.), d0err(0.);
02783
02784 if(!m_AtlFastFlag &&(*muon_container)[k]->hasInDetTrackParticle() ){
02785
02786 const Rec::TrackParticle* track = (*muon_container)[k]->inDetTrackParticle();
02787 const Trk::MeasuredPerigee* measPerigee = track->measuredPerigee();
02788
02789 d0 = measPerigee->parameters()[Trk::d0];
02790
02791
02792 const Trk::ErrorMatrix errorMatrix = measPerigee->localErrorMatrix();
02793 d0err = errorMatrix.error(Trk::d0);
02794 }
02795
02796 m_mu_track_d0->push_back(d0);
02797 m_mu_track_d0err->push_back(d0err);
02798
02799
02800
02801
02802
02803
02804
02805
02806
02807
02808
02809
02810
02811
02812
02813
02814
02815
02816
02817
02818
02819
02820
02821
02822
02823
02824
02825
02826
02827
02828
02829
02830
02831
02832
02833
02834
02835
02836
02837
02838
02839
02840
02841
02842
02843
02844
02845
02846
02847
02848
02849
02850
02851
02852
02853
02854
02855
02856
02857
02858 }
02859 }
02860
02861 return true;
02862
02863 }
02864
02865
02866
02867
02868
02869
02870 bool HiggsAnalysisNtupleWriter::get_jet_data(void) {
02871
02873
02875
02876 const ParticleJetContainer *jet_container(0);
02877
02878
02880
02882
02883 StatusCode sc(m_storeGate->retrieve(jet_container, m_jet_container));
02884 if(sc.isFailure() || jet_container==0) {
02885 *m_log << MSG::WARNING
02886 << "No jet container found in the store gate!"
02887 << endreq;
02888 return false;
02889 }
02890 *m_log << MSG::DEBUG << "Jet container retrieved successfully!"
02891 << endreq;
02892
02894
02896
02897
02898 for (unsigned int k=0; k<jet_container->size(); k++) {
02899
02900
02901 m_nb_rec_jets++;
02902
02903
02904 m_jet_p_x->push_back( (*jet_container)[k]->px() );
02905 m_jet_p_y->push_back( (*jet_container)[k]->py() );
02906 m_jet_p_z->push_back( (*jet_container)[k]->pz() );
02907 m_jet_E->push_back( (*jet_container)[k]->e() );
02908
02909
02910
02911
02912
02913
02914
02915 ParticleJet myjet(*(*jet_container)[k]);
02916
02917
02918 m_jet_flag->push_back( myjet.author() );
02919
02920
02921 m_jet_btag_weight->push_back( (*jet_container)[k]->weight() );
02922
02923
02924
02925
02926
02927 std::string label("N/A");
02928 const Analysis::TruthInfo* mcinfo =
02929 (*jet_container)[k]->tagInfo<Analysis::TruthInfo>("TruthInfo");
02930 if(mcinfo) {
02931 label = mcinfo->jetTruthLabel();
02932 } else {
02933 *m_log << MSG::WARNING << "could not find TruthInfo for matching jet" << endreq;
02934 }
02935 int iflav(0);
02936 if(label=="B") iflav = 5;
02937 else if(label=="C") iflav = 4;
02938 else if(label=="T") iflav = 15;
02939 else if(label=="N/A") iflav = 0;
02940 else iflav = -1;
02941 m_jet_truthflavor->push_back( iflav );
02942
02943
02944
02945
02946
02947
02948 if (!m_AtlFastFlag){
02949
02950 const Analysis::TrackConstituents *tpc =
02951 (*jet_container)[k]->constituent<Analysis::TrackConstituents>("Tracks");
02952
02953 std::vector<const Rec::TrackParticle*> *jettracks = tpc->tracks();
02954
02955 m_jet_nb_tracks->push_back(jettracks->size());
02956
02957 for (unsigned int i=0;i<jettracks->size();i++){
02958 m_jet_tracks_charge->push_back((*jettracks)[i]->charge());
02959 m_jet_tracks_p_x->push_back((*jettracks)[i]->px());
02960 m_jet_tracks_p_y->push_back((*jettracks)[i]->py());
02961 m_jet_tracks_p_z->push_back((*jettracks)[i]->pz());
02962 m_jet_tracks_E->push_back((*jettracks)[i]->e());
02963
02964
02965 if(m_doVertices){
02966
02967 if ((*jettracks)[i]->reconstructedVertex()==NULL) {
02968 m_jet_tracks_vertex_index->push_back(-1);
02969 } else {
02970 m_jet_tracks_vertex_index
02971 ->push_back( find_vertex((*jettracks)[i]->reconstructedVertex()) );
02972 }
02973 }
02974 else{
02975 m_jet_tracks_vertex_index->push_back(-1);
02976 }
02977
02978 }
02979
02980 }
02981 else{
02982 m_jet_nb_tracks->push_back(0);
02983 }
02984
02985 }
02986
02987 return true;
02988 }
02989
02990
02991
02992
02993
02994
02995 bool HiggsAnalysisNtupleWriter::get_taujet_data(void) {
02996
02998
03000
03001 const TauJetContainer *taujet_container(0);
03002
03003
03005
03007
03008 StatusCode sc(m_storeGate->retrieve(taujet_container, m_taujet_container));
03009 if(sc.isFailure() || taujet_container==0) {
03010 *m_log << MSG::WARNING
03011 << "No taujet container found in the store gate!"
03012 << endreq;
03013 return false;
03014 }
03015 *m_log << MSG::DEBUG << "Taujet container retrieved successfully!"
03016 << endreq;
03017
03019
03021
03022
03023 for (unsigned int k=0; k<taujet_container->size(); k++) {
03024
03025
03026 m_nb_tau_jets++;
03027
03028
03029 m_taujet_p_x->push_back( (*taujet_container)[k]->px() );
03030 m_taujet_p_y->push_back( (*taujet_container)[k]->py() );
03031 m_taujet_p_z->push_back( (*taujet_container)[k]->pz() );
03032 m_taujet_E->push_back( (*taujet_container)[k]->e() );
03033
03034
03035 TauJet mytaujet(*(*taujet_container)[k]);
03036
03037
03038 m_taujet_flag->push_back( mytaujet.author() );
03039
03040
03041 if (!m_AtlFastFlag){
03042
03043
03044 m_taujet_charge->push_back( static_cast<int>(
03045 (*taujet_container)[k]->charge()) );
03046
03047
03048 m_taujet_etHadCalib->push_back(
03049 (*taujet_container)[k]->parameter(TauJetParameters::etHadCalib) );
03050
03051
03052 m_taujet_etEMCalib->push_back(
03053 (*taujet_container)[k]->parameter(TauJetParameters::etEMCalib) );
03054
03055
03056 m_taujet_emRadius->push_back(
03057 (*taujet_container)[k]->parameter(TauJetParameters::emRadius) );
03058
03059
03060 m_taujet_isolationFraction->push_back(
03061 (*taujet_container)[k]->parameter(TauJetParameters::isolationFraction) );
03062
03063
03064 m_taujet_centralityFraction->push_back(
03065 (*taujet_container)[k]->parameter(TauJetParameters::centralityFraction) );
03066
03067
03068 m_taujet_stripWidth2->push_back(
03069 (*taujet_container)[k]->parameter(TauJetParameters::stripWidth2) );
03070
03071
03072 m_taujet_nStripCells->push_back(
03073 (*taujet_container)[k]->parameter(TauJetParameters::nStripCells) );
03074
03075
03076 m_taujet_llh->push_back( (*taujet_container)[k]->parameter(TauJetParameters::logLikelihoodRatio) );
03077
03078 m_taujet_lowPtTauEleDiscriminant->push_back( (*taujet_container)[k]->parameter(TauJetParameters::lowPtTauEleDiscriminant) );
03079 m_taujet_tauENeuralNetwork->push_back( (*taujet_container)[k]->parameter(TauJetParameters::tauENeuralNetwork) );
03080 m_taujet_tauJetNeuralnetwork->push_back( (*taujet_container)[k]->parameter(TauJetParameters::tauJetNeuralnetwork) );
03081
03082
03083 }
03084
03085 else {
03086 if ((*taujet_container)[k]->pdgId()==1) m_taujet_charge->push_back(-1.);
03087 else if ((*taujet_container)[k]->pdgId()==-1) m_taujet_charge->push_back(1.);
03088 else if ((*taujet_container)[k]->pdgId()==2) m_taujet_charge->push_back(1.);
03089 else if ((*taujet_container)[k]->pdgId()==-2) m_taujet_charge->push_back(-1.);
03090 else if ((*taujet_container)[k]->pdgId()==3) m_taujet_charge->push_back(-1.);
03091 else if ((*taujet_container)[k]->pdgId()==-3) m_taujet_charge->push_back(1.);
03092 else if ((*taujet_container)[k]->pdgId()==4) m_taujet_charge->push_back(1.);
03093 else if ((*taujet_container)[k]->pdgId()==-4) m_taujet_charge->push_back(-1.);
03094 else if ((*taujet_container)[k]->pdgId()==5) m_taujet_charge->push_back(-1.);
03095 else if ((*taujet_container)[k]->pdgId()==-5) m_taujet_charge->push_back(1.);
03096 else if ((*taujet_container)[k]->pdgId()==6) m_taujet_charge->push_back(1.);
03097 else if ((*taujet_container)[k]->pdgId()==-6) m_taujet_charge->push_back(-1.);
03098 else if ((*taujet_container)[k]->pdgId()==11) m_taujet_charge->push_back(-1.);
03099 else if ((*taujet_container)[k]->pdgId()==-11) m_taujet_charge->push_back(1.);
03100 else if ((*taujet_container)[k]->pdgId()==13) m_taujet_charge->push_back(-1.);
03101 else if ((*taujet_container)[k]->pdgId()==-13) m_taujet_charge->push_back(1.);
03102 else if ((*taujet_container)[k]->pdgId()==15) m_taujet_charge->push_back(-1.);
03103 else if ((*taujet_container)[k]->pdgId()==-15) m_taujet_charge->push_back(1.);
03104 else m_taujet_charge->push_back((*taujet_container)[k]->pdgId());
03105 m_taujet_etHadCalib->push_back(0);
03106 m_taujet_etEMCalib->push_back(0);
03107 m_taujet_emRadius->push_back(0);
03108 m_taujet_isolationFraction->push_back(0);
03109 m_taujet_centralityFraction->push_back(0);
03110 m_taujet_stripWidth2->push_back(0);
03111 m_taujet_nStripCells->push_back(0);
03112 m_taujet_llh->push_back(20);
03113 m_taujet_lowPtTauEleDiscriminant->push_back(1);
03114 m_taujet_tauENeuralNetwork->push_back(1);
03115 m_taujet_tauJetNeuralnetwork->push_back(1);
03116 }
03117
03118
03119
03120 m_taujet_nb_tracks->push_back((*taujet_container)[k]->numTrack());
03121
03122 if ((*taujet_container)[k]->numTrack()>0){
03123 m_taujet_track_px_1->push_back((*taujet_container)[k]->track(0)->px());
03124 m_taujet_track_py_1->push_back((*taujet_container)[k]->track(0)->py());
03125 m_taujet_track_pz_1->push_back((*taujet_container)[k]->track(0)->pz());
03126 m_taujet_track_e_1->push_back((*taujet_container)[k]->track(0)->e());
03127 m_taujet_track_TRTHighThresholdHits_1->push_back((*taujet_container)[k]->track(0)
03128 ->trackSummary()->get(Trk::numberOfTRTHighThresholdHits));
03129 m_taujet_track_TRTHits_1->push_back((*taujet_container)[k]->track(0)
03130 ->trackSummary()->get(Trk::numberOfTRTHits));
03131 }
03132 else {
03133 m_taujet_track_px_1->push_back(0.0);
03134 m_taujet_track_py_1->push_back(0.0);
03135 m_taujet_track_pz_1->push_back(0.0);
03136 m_taujet_track_e_1->push_back(0.0);
03137 m_taujet_track_TRTHighThresholdHits_1->push_back(10);
03138 m_taujet_track_TRTHits_1->push_back(10);
03139 }
03140 if ((*taujet_container)[k]->numTrack()>1){
03141 m_taujet_track_px_2->push_back((*taujet_container)[k]->track(1)->px());
03142 m_taujet_track_py_2->push_back((*taujet_container)[k]->track(1)->py());
03143 m_taujet_track_pz_2->push_back((*taujet_container)[k]->track(1)->pz());
03144 m_taujet_track_e_2->push_back((*taujet_container)[k]->track(1)->e());
03145 m_taujet_track_TRTHighThresholdHits_2->push_back((*taujet_container)[k]->track(1)
03146 ->trackSummary()->get(Trk::numberOfTRTHighThresholdHits));
03147 m_taujet_track_TRTHits_2->push_back((*taujet_container)[k]->track(1)
03148 ->trackSummary()->get(Trk::numberOfTRTHits));
03149 }
03150 else {
03151 m_taujet_track_px_2->push_back(0.0);
03152 m_taujet_track_py_2->push_back(0.0);
03153 m_taujet_track_pz_2->push_back(0.0);
03154 m_taujet_track_e_2->push_back(0.0);
03155 m_taujet_track_TRTHighThresholdHits_2->push_back(10);
03156 m_taujet_track_TRTHits_2->push_back(10);
03157 }
03158 if ((*taujet_container)[k]->numTrack()>2) {
03159 m_taujet_track_px_3->push_back((*taujet_container)[k]->track(2)->px());
03160 m_taujet_track_py_3->push_back((*taujet_container)[k]->track(2)->py());
03161 m_taujet_track_pz_3->push_back((*taujet_container)[k]->track(2)->pz());
03162 m_taujet_track_e_3->push_back((*taujet_container)[k]->track(2)->e());
03163 m_taujet_track_TRTHighThresholdHits_3->push_back((*taujet_container)[k]->track(2)
03164 ->trackSummary()->get(Trk::numberOfTRTHighThresholdHits));
03165 m_taujet_track_TRTHits_3->push_back((*taujet_container)[k]->track(2)
03166 ->trackSummary()->get(Trk::numberOfTRTHits));
03167 }
03168 else {
03169 m_taujet_track_px_3->push_back(0.0);
03170 m_taujet_track_py_3->push_back(0.0);
03171 m_taujet_track_pz_3->push_back(0.0);
03172 m_taujet_track_e_3->push_back(0.0);
03173 m_taujet_track_TRTHighThresholdHits_3->push_back(10);
03174 m_taujet_track_TRTHits_3->push_back(10);
03175 }
03176
03177 }
03178
03179 return true;
03180
03181 }
03182
03183
03184
03185
03186
03187
03188 bool HiggsAnalysisNtupleWriter::get_truthjet_data(void) {
03189
03191
03193
03194 const ParticleJetContainer *truthjet_container(0);
03195
03196
03198
03200
03201 StatusCode sc(m_storeGate->retrieve(truthjet_container, m_truthjet_container));
03202 if(sc.isFailure() || truthjet_container==0) {
03203 *m_log << MSG::WARNING
03204 << "No truthjet container found in the store gate!"
03205 << endreq;
03206 return false;
03207 }
03208 *m_log << MSG::DEBUG << "TruthJet container retrieved successfully!"
03209 << endreq;
03210
03212
03214
03215
03216 for (unsigned int k=0; k<truthjet_container->size(); k++) {
03217
03218 m_nb_truth_jets++;
03219
03220
03221 m_truthjet_p_x->push_back( (*truthjet_container)[k]->px() );
03222 m_truthjet_p_y->push_back( (*truthjet_container)[k]->py() );
03223 m_truthjet_p_z->push_back( (*truthjet_container)[k]->pz() );
03224 m_truthjet_E->push_back( (*truthjet_container)[k]->e() );
03225
03226
03227 ParticleJet mytruthjet(*(*truthjet_container)[k]);
03228
03229
03230 m_truthjet_flag->push_back( mytruthjet.author() );
03231
03232
03233 m_truthjet_btag_weight->push_back( (*truthjet_container)[k]->weight() );
03234
03235
03236
03237
03238
03239
03240
03241
03242
03243
03244
03245
03246
03247
03248
03249
03250
03251
03252
03253
03254
03255 }
03256
03257 return true;
03258
03259 }
03260
03261
03262
03263
03264
03265
03266 bool HiggsAnalysisNtupleWriter::get_missingEt_data(void)
03267 {
03268 const MissingET *missingEt_container(0);
03269
03270 missingEt_container=0;
03271
03272 vector<string> met_container;
03273
03274 met_container=v_string_met_container;
03275
03276
03277 for(unsigned int i_met_cont=0; i_met_cont<met_container.size(); i_met_cont++){
03278
03279
03280
03281
03282 if(!m_doAODFix1mm && (met_container.at(i_met_cont)=="MET_RefFinal_1mmCorrection")){
03283 m_met_obj_name->push_back( (met_container.at(i_met_cont)).c_str() );
03284 m_missing_Etx->push_back(0.0);
03285 m_missing_Ety->push_back(0.0);
03286 m_missing_Et->push_back(0.0);
03287 m_missing_Etsum->push_back(0.0);
03288 continue;
03289 }
03290
03292
03294 StatusCode sc = StatusCode(m_storeGate->retrieve(missingEt_container,
03295 (met_container.at(i_met_cont)).c_str()));
03296 if(sc.isFailure() || missingEt_container==0) {
03297 *m_log << MSG::WARNING<< "No missingEt container "<<met_container.at(i_met_cont)
03298 <<" found in the store gate!"<< endreq;
03299 return false;
03300 }
03301 *m_log << MSG::DEBUG << "MissingEt container "<<met_container.at(i_met_cont)
03302 <<" retrieved successfully!"<< endreq;
03303 m_met_obj_name->push_back( (met_container.at(i_met_cont)).c_str() );
03304 m_missing_Etx->push_back(missingEt_container->etx());
03305 m_missing_Ety->push_back(missingEt_container->ety());
03306 m_missing_Et->push_back(missingEt_container->et());
03307 m_missing_Etsum->push_back(missingEt_container->sumet());
03308
03309
03310 missingEt_container=0;
03311 }
03312 return true;
03313
03314 }
03315
03316
03317
03318
03319
03320
03321 bool HiggsAnalysisNtupleWriter::get_truthmissingEt_data(void)
03322 {
03323
03324
03326
03328
03329 const MissingET *truthmissingEt_container(0);
03330
03331
03333
03335
03336 StatusCode sc(m_storeGate->retrieve(truthmissingEt_container, m_truthmissingEt_container));
03337 if(sc.isFailure() || truthmissingEt_container==0) {
03338 *m_log << MSG::WARNING
03339 << "No truthmissingEt container found in the store gate!"
03340 << endreq;
03341 return false;
03342 }
03343 *m_log << MSG::DEBUG << "TruthMissingEt container retrieved successfully!"
03344 << endreq;
03345
03346
03348
03350
03351 MissingEtTruth::TruthIndex tidx;
03352 double etx, ety;
03353
03354 tidx = MissingEtTruth::Int;
03355 etx = ((MissingEtTruth*)truthmissingEt_container)->exTruth(tidx);
03356 ety = ((MissingEtTruth*)truthmissingEt_container)->eyTruth(tidx);
03357 m_met_obj_name->push_back( "TruthMET_Int" );
03358 m_missing_Etx->push_back(etx);
03359 m_missing_Ety->push_back(ety);
03360 m_missing_Et->push_back(sqrt((etx*etx)+(ety*ety)));
03361 m_missing_Etsum->push_back(((MissingEtTruth*)truthmissingEt_container)->etSumTruth(tidx));
03362
03363
03364 tidx = MissingEtTruth::NonInt;
03365 etx = ((MissingEtTruth*)truthmissingEt_container)->exTruth(tidx);
03366 ety = ((MissingEtTruth*)truthmissingEt_container)->eyTruth(tidx);
03367 m_met_obj_name->push_back( "TruthMET_NonInt" );
03368 m_missing_Etx->push_back(etx);
03369 m_missing_Ety->push_back(ety);
03370 m_missing_Et->push_back(sqrt((etx*etx)+(ety*ety)));
03371 m_missing_Etsum->push_back(((MissingEtTruth*)truthmissingEt_container)->etSumTruth(tidx));
03372
03373
03374 tidx = MissingEtTruth::IntCentral;
03375 etx = ((MissingEtTruth*)truthmissingEt_container)->exTruth(tidx);
03376 ety = ((MissingEtTruth*)truthmissingEt_container)->eyTruth(tidx);
03377 m_met_obj_name->push_back( "TruthMET_IntCentral" );
03378 m_missing_Etx->push_back(etx);
03379 m_missing_Ety->push_back(ety);
03380 m_missing_Et->push_back(sqrt((etx*etx)+(ety*ety)));
03381 m_missing_Etsum->push_back(((MissingEtTruth*)truthmissingEt_container)->etSumTruth(tidx));
03382
03383
03384 tidx = MissingEtTruth::IntFwd;
03385 etx = ((MissingEtTruth*)truthmissingEt_container)->exTruth(tidx);
03386 ety = ((MissingEtTruth*)truthmissingEt_container)->eyTruth(tidx);
03387 m_met_obj_name->push_back( "TruthMET_IntFwd" );
03388 m_missing_Etx->push_back(etx);
03389 m_missing_Ety->push_back(ety);
03390 m_missing_Et->push_back(sqrt((etx*etx)+(ety*ety)));
03391 m_missing_Etsum->push_back(((MissingEtTruth*)truthmissingEt_container)->etSumTruth(tidx));
03392
03393
03394 tidx = MissingEtTruth::IntOutCover;
03395 etx = ((MissingEtTruth*)truthmissingEt_container)->exTruth(tidx);
03396 ety = ((MissingEtTruth*)truthmissingEt_container)->eyTruth(tidx);
03397 m_met_obj_name->push_back( "TruthMET_IntOutCover" );
03398 m_missing_Etx->push_back(etx);
03399 m_missing_Ety->push_back(ety);
03400 m_missing_Et->push_back(sqrt((etx*etx)+(ety*ety)));
03401 m_missing_Etsum->push_back(((MissingEtTruth*)truthmissingEt_container)->etSumTruth(tidx));
03402
03403
03404 tidx = MissingEtTruth::Muons;
03405 etx = ((MissingEtTruth*)truthmissingEt_container)->exTruth(tidx);
03406 ety = ((MissingEtTruth*)truthmissingEt_container)->eyTruth(tidx);
03407 m_met_obj_name->push_back( "TruthMET_Muons" );
03408 m_missing_Etx->push_back(etx);
03409 m_missing_Ety->push_back(ety);
03410 m_missing_Et->push_back(sqrt((etx*etx)+(ety*ety)));
03411 m_missing_Etsum->push_back(((MissingEtTruth*)truthmissingEt_container)->etSumTruth(tidx));
03412
03413 return true;
03414
03415 }
03416
03417
03418
03419
03420
03421
03422 bool HiggsAnalysisNtupleWriter::get_truthparticle_data(void)
03423 {
03424
03425
03427
03429
03430 const TruthParticleContainer *truthparticle_container(0);
03431
03432 const float pt_cut_value_leptons(0);
03433 const float pt_cut_value(1000);
03434
03435
03436
03437 const int barcode_cut_value(m_truthparticleMaximumLeptonBarcode);
03438
03439
03440
03441
03442 unsigned int abs_particle_pdgId(0);
03443
03444
03446
03448
03449 StatusCode sc(m_storeGate->retrieve(truthparticle_container, m_truthparticle_container));
03450 if(sc.isFailure() || truthparticle_container==0) {
03451 *m_log << MSG::WARNING
03452 << "No truthparticle container found in the store gate!"
03453 << endreq;
03454 return false;
03455 }
03456 *m_log << MSG::DEBUG << "TruthParticle container retrieved successfully!"
03457 << endreq;
03458
03459
03460
03462
03464
03465 for ( unsigned int i=0; i<truthparticle_container->size(); i++) {
03466
03467
03468 if ((*truthparticle_container)[i]->barcode()>barcode_cut_value){
03469 continue;
03470 }
03471
03472
03473
03474 if ((*truthparticle_container)[i]->hasPdgId()){
03475 if(TMath::Abs( (*truthparticle_container)[i]->pdgId())==11 ||
03476 TMath::Abs( (*truthparticle_container)[i]->pdgId())==12 ||
03477 TMath::Abs( (*truthparticle_container)[i]->pdgId())==13 ||
03478 TMath::Abs( (*truthparticle_container)[i]->pdgId())==14 ||
03479 TMath::Abs( (*truthparticle_container)[i]->pdgId())==15 ||
03480 TMath::Abs( (*truthparticle_container)[i]->pdgId())==16 )
03481 {
03482 if ((*truthparticle_container)[i]->pt()<pt_cut_value_leptons) continue;
03483 }
03484
03485 else if ((*truthparticle_container)[i]->pt() < pt_cut_value &&
03486 (*truthparticle_container)[i]->barcode()>100){
03487 continue;
03488 }
03489 }
03490
03491 if (!(*truthparticle_container)[i]->hasPdgId()){
03492 *m_log << MSG::WARNING
03493 << "particle has no pdgId"
03494 << endreq;
03495 abs_particle_pdgId=0;
03496 }
03497 else{
03498 abs_particle_pdgId=TMath::Abs( (*truthparticle_container)[i]->pdgId() );
03499 }
03500
03501
03502 if (abs_particle_pdgId>80 && abs_particle_pdgId<101){
03503 continue;
03504 }
03505
03506 if (abs_particle_pdgId==21){
03507 continue;
03508 }
03509
03510
03511 if (abs_particle_pdgId>100 && m_truthparticleNoPDGAbove100){
03512 continue;
03513 }
03514
03515
03516 fill_truthparticle_data((*truthparticle_container)[i]);
03517
03518 }
03519
03520 return true;
03521 }
03522
03523
03524
03525
03526
03527
03528
03529 void HiggsAnalysisNtupleWriter::fill_truthparticle_data(const TruthParticle *m_TruthParticle)
03530 {
03531
03533
03535
03536
03537
03538 for( int k=0; k < m_nb_truth_particle; k++ ){
03539 if( m_TruthParticle->getGenParticle()->barcode() == m_truth_particle_barcode->at(k) ){
03540 std::cout<<"particle already stored"<<std::endl;
03541 return;
03542 }
03543 }
03544
03545
03546
03547 m_nb_truth_particle++;
03548
03549 m_truth_particle_pt->push_back( m_TruthParticle->pt());
03550 m_truth_particle_status->push_back( m_TruthParticle->getGenParticle()->status());
03551 m_truth_particle_barcode->push_back( m_TruthParticle->getGenParticle()->barcode());
03552 m_truth_particle_pdgId->push_back( m_TruthParticle->pdgId());
03553 m_truth_particle_nDaughters->push_back( m_TruthParticle->nDecay());
03554 m_truth_particle_p_x->push_back( m_TruthParticle->px() );
03555 m_truth_particle_p_y->push_back( m_TruthParticle->py() );
03556 m_truth_particle_p_z->push_back( m_TruthParticle->pz() );
03557 m_truth_particle_E->push_back( m_TruthParticle->e() );
03558
03559 m_truth_particle_charge->push_back( m_TruthParticle->charge());
03560 m_truth_particle_nParents->push_back( m_TruthParticle->nParents());
03561
03562 if (m_TruthParticle->nParents()>0){
03563 m_truth_particle_mother0_barcode->push_back( m_TruthParticle->mother(0)->barcode());
03564 m_truth_particle_mother0_pdgId->push_back( m_TruthParticle->mother(0)->pdgId());
03565 }
03566 else{
03567 m_truth_particle_mother0_barcode->push_back(0);
03568 m_truth_particle_mother0_pdgId->push_back(0);
03569 }
03570
03571 m_truth_particle_Et_in_cone_0
03572 ->push_back(m_TruthParticle->etIsol(TruthParticleParameters::etcone10));
03573 m_truth_particle_Et_in_cone_1
03574 ->push_back(m_TruthParticle->etIsol(TruthParticleParameters::etcone20));
03575 m_truth_particle_Et_in_cone_2
03576 ->push_back(m_TruthParticle->etIsol(TruthParticleParameters::etcone30));
03577 m_truth_particle_Et_in_cone_3
03578 ->push_back(m_TruthParticle->etIsol(TruthParticleParameters::etcone40));
03579 m_truth_particle_Et_in_cone_4
03580 ->push_back(m_TruthParticle->etIsol(TruthParticleParameters::etcone));
03581
03582
03583 if(m_doVertices){
03584
03585 if( TMath::Abs(m_TruthParticle->pdgId())==11 ||
03586 TMath::Abs(m_TruthParticle->pdgId())==13 ){
03587
03588 m_truth_particle_vertex_index
03589 ->push_back( find_truth_vertex( m_TruthParticle
03590 ->getGenParticle()->production_vertex())
03591 );
03592 }
03593 else{
03594 m_truth_particle_vertex_index->push_back(-1);
03595 }
03596 }else{
03597 m_truth_particle_vertex_index->push_back(-1);
03598 }
03599
03600 return;
03601
03602 }
03603
03604
03605
03606
03607
03608
03609
03610 bool HiggsAnalysisNtupleWriter::get_eventweight_data(void) {
03611
03612 if(m_doEventWeight){
03613
03615 MsgStream mLog(messageService(), name());
03616 m_event_weight = 1234;
03617 const McEventCollection* mcCollPtr ;
03618 if ( m_storeGate->retrieve(mcCollPtr, "GEN_AOD").isFailure() ) {
03619 mLog << MSG::ERROR << "Could not retrieve McEventCollection" << endreq;
03620 return false;
03621 }
03622 McEventCollection::const_iterator evt = mcCollPtr->begin() ;
03623 const HepMC::GenEvent* ge = (*evt) ;
03624 const HepMC::WeightContainer& wc = ge->weights() ;
03625 m_event_weight = wc.front() ;
03626
03627 *m_log << MSG::DEBUG << "Events Weights retrieved successfully!"
03628 << endreq;
03629 }
03630 else{
03631 m_event_weight = 1;
03632 }
03633
03634 return true;
03635 }
03636
03637
03638
03639
03640
03641
03642
03643 bool HiggsAnalysisNtupleWriter::get_vertex_data(void) {
03644
03646
03648
03649
03650 vector<MPIHiggsAnalysis::Vertex> vertices(m_vert_coll->getVertices());
03651
03652
03653
03654
03655 for (unsigned int k=0; k<vertices.size(); k++) {
03656
03657
03658 m_nb_vertices++;
03659
03660
03661 m_vertex_position_x->push_back(vertices[k].position().x());
03662 m_vertex_position_y->push_back(vertices[k].position().y());
03663 m_vertex_position_z->push_back(vertices[k].position().z());
03664
03665
03666 m_vertex_pos_error_x->push_back(vertices[k].positionError().x());
03667 m_vertex_pos_error_y->push_back(vertices[k].positionError().y());
03668 m_vertex_pos_error_z->push_back(vertices[k].positionError().z());
03669
03670
03671 m_vertex_chi2->push_back(vertices[k].chi2());
03672 m_vertex_ndof->push_back(vertices[k].numberOfDegreesOfFreedom());
03673
03674
03675 m_vertex_Et->push_back(vertices[k].Et());
03676
03677
03678 m_vertex_nb_tracks->push_back(vertices[k].numberOfTracks());
03679
03680 }
03681
03682 return true;
03683
03684 }
03685
03686
03687
03688
03689
03690
03691
03692 bool HiggsAnalysisNtupleWriter::get_truth_vertex_data(void) {
03693
03695
03697
03698 MyTruthTrackJetInfoContainer
03699 *container(MyTruthTrackJetInfoContainer::getTruthTrackJetInfoContainer());
03700
03702
03704
03705 std::vector<MPIHiggsAnalysis::Vertex> vertices = container->getVertices();
03706
03707 m_nb_truth_vertices = vertices.size();
03708
03709
03710 for (unsigned int k=0; k<vertices.size(); k++) {
03711
03712 m_truth_vertex_position_x->push_back(vertices[k].position().x());
03713 m_truth_vertex_position_y->push_back(vertices[k].position().y());
03714 m_truth_vertex_position_z->push_back(vertices[k].position().z());
03715
03716 m_truth_vertex_Et->push_back(vertices[k].Et());
03717
03718 m_truth_vertex_nb_tracks->push_back(vertices[k].numberOfTracks());
03719
03720 }
03721
03722
03723
03724
03725
03726
03727
03728
03729
03730
03731
03732
03733
03734
03735
03736
03737 return true;
03738
03739 }
03740
03741
03742
03743
03744
03745
03746
03747 bool HiggsAnalysisNtupleWriter::get_track_jet_data(void) {
03748
03750
03752
03753 const INavigable4MomentumCollection *jet_container(0);
03754
03755
03757
03759
03760 StatusCode sc(m_storeGate->retrieve(jet_container,m_track_jet_container));
03761
03762 if(sc.isFailure() || jet_container==0) {
03763 *m_log << MSG::WARNING
03764 << "No track jet container "
03765 << m_track_jet_container
03766 << " found in the store gate!"
03767 << endreq;
03768 return false;
03769 }
03770
03771 *m_log << MSG::DEBUG
03772 << "Track jet container "
03773 << m_track_jet_container
03774 << " retrieved successfully!"
03775 << endreq;
03776
03778
03780
03781
03782 for (unsigned int k=0; k<jet_container->size(); k++) {
03783
03784
03785 m_nb_track_jets++;
03786
03787
03788 m_track_jet_p_x->push_back( (*jet_container)[k]->px() );
03789 m_track_jet_p_y->push_back( (*jet_container)[k]->py() );
03790 m_track_jet_p_z->push_back( (*jet_container)[k]->pz() );
03791 m_track_jet_E->push_back( (*jet_container)[k]->e() );
03792
03793 }
03794
03795 return true;
03796
03797 }
03798
03799
03800
03801
03802
03803
03804
03805 bool HiggsAnalysisNtupleWriter::get_truth_track_jet_data(void) {
03806
03808
03810
03811 const INavigable4MomentumCollection *jet_container(0);
03812
03813
03815
03817
03818 StatusCode sc(m_storeGate->retrieve(jet_container,m_truth_track_jet_container));
03819
03820 if(sc.isFailure() || jet_container==0) {
03821 *m_log << MSG::WARNING
03822 << "No truth track jet container "
03823 << m_truth_track_jet_container
03824 << " found in the store gate!"
03825 << endreq;
03826 return false;
03827 }
03828
03829 *m_log << MSG::DEBUG
03830 << "Truth track jet container "
03831 << m_truth_track_jet_container
03832 << " retrieved successfully!"
03833 << endreq;
03834
03836
03838
03839
03840 for (unsigned int k=0; k<jet_container->size(); k++) {
03841
03842
03843 m_nb_truth_track_jets++;
03844
03845
03846 m_truth_track_jet_p_x->push_back( (*jet_container)[k]->px() );
03847 m_truth_track_jet_p_y->push_back( (*jet_container)[k]->py() );
03848 m_truth_track_jet_p_z->push_back( (*jet_container)[k]->pz() );
03849 m_truth_track_jet_E->push_back( (*jet_container)[k]->e() );
03850
03851 }
03852
03853 return true;
03854
03855 }
03856
03857
03858
03859
03860
03861
03862
03863 int
03864 HiggsAnalysisNtupleWriter::find_vertex(const Trk::RecVertex * vertex) const {
03865
03866
03867 vector<MPIHiggsAnalysis::Vertex> vertices(m_vert_coll->getVertices());
03868
03869 for (unsigned int k=0; k<vertices.size(); k++) {
03870 if (vertex->position() == vertices[k].position()) {
03871 return k;
03872 }
03873 }
03874
03875 *m_log << MSG::WARNING
03876 << "No vertex found!"
03877 << endreq;
03878
03879 return -2;
03880
03881 }
03882
03883
03884
03885
03886
03887
03888
03889 int
03890 HiggsAnalysisNtupleWriter::find_truth_vertex(const HepMC::GenVertex * vertex) const {
03891
03892 if(vertex==NULL){
03893 return -1;
03894 }
03895
03896 MyTruthTrackJetInfoContainer
03897 *container(MyTruthTrackJetInfoContainer::getTruthTrackJetInfoContainer());
03898
03899 std::vector<MPIHiggsAnalysis::Vertex> vertices = container->getVertices();
03900
03901 for (unsigned int k=0; k<vertices.size(); k++) {
03902
03903 Hep3Vector delta( vertex->position().vect() - vertices[k].position() );
03904
03905 if (delta.mag() < container->getVertexCut()) {
03906 return k;
03907 }
03908 }
03909
03910
03911
03912
03913
03914 return -2;
03915
03916 }
03917
03918
03919
03920
03921
03922
03923
03924
03925 double
03926 HiggsAnalysisNtupleWriter::get_energy_in_cone(const double & cone,
03927 const HepLorentzVector & p,
03928 const Hep3Vector & vertex) {
03929
03931
03933
03934 double ET(0.);
03935 const Rec::TrackParticleContainer *track_particle_container(0);
03936
03937
03939
03941
03942 StatusCode sc(m_storeGate->retrieve(track_particle_container,
03943 m_track_particle_container));
03944 if (sc.isFailure() || track_particle_container==0) {
03945 *m_log << MSG::WARNING
03946 << "No track particle container found in store gate!"
03947 << endreq;
03948 return sc;
03949 }
03950 *m_log << MSG::DEBUG
03951 << "Track particle container retrieved successfully!"
03952 << endreq;
03953
03955
03957
03958 for (unsigned int k=0; k<track_particle_container->size(); k++) {
03959
03960 if(m_doVertices){
03961
03962 if( vertex == Hep3Vector(0.,0.,0.) ){
03963 continue;
03964 }
03965
03966 if ((*track_particle_container)[k]->reconstructedVertex()==NULL){
03967 continue;
03968 }
03969
03970 if ((*track_particle_container)[k]
03971 ->reconstructedVertex()->position()!=vertex){
03972 continue;
03973 }
03974 }
03975
03976 if ( p.deltaR((*track_particle_container)[k]->hlv()) < cone &&
03977 p.deltaR((*track_particle_container)[k]->hlv()) > 0.01) {
03978
03979 ET += (*track_particle_container)[k]->hlv().et();
03980 }
03981
03982 }
03983
03984 return ET;
03985
03986 }
