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