This gets called once on every event and is where the bulk of the processing ought to be happening.
302 {
303
305
310
311 if (
m_SUSYTools->resetSystematics() != StatusCode::SUCCESS) {
313 }
314
315
316
319 return StatusCode::SUCCESS;
320 }
321
322
324
325
329
330
331 if (
m_maxEvts>=-1 && (evtInfo->lumiBlock() != (
unsigned int)
m_lbfilter))
return StatusCode::SUCCESS;
332
333
336#ifdef ROOTCORE
337
339 if (!
evtStore()->
event()->retrieveMetaInput(completeCBC,
"CutBookkeepers").isSuccess()) {
340 ATH_MSG_ERROR(
"Failed to retrieve CutBookkeepers from MetaData! Exiting.");
341 }
342 std::string cbkname;
343 for ( const auto *cbk : *completeCBC ) {
344 cbkname = cbk->name();
345 stream = cbk->inputStream();
346 ATH_MSG_INFO(
"cbkname: " << cbkname <<
", stream: " << stream);
347 if (cbkname.find(
"PHYSVAL")!=std::string::npos)
m_kernel=
"PHYSVAL";
348 else if (cbkname.find(
"PHYSLITE")!=std::string::npos)
m_kernel=
"PHYSLITE";
349 else if (cbkname.find(
"PHYS")!=std::string::npos)
m_kernel=
"PHYS";
352 }
353#else
354
358 if (
stream.find(
"PHYSVAL")!=std::string::npos)
m_kernel=
"PHYSVAL";
359 else if (
stream.find(
"PHYSLITE")!=std::string::npos)
m_kernel=
"PHYSLITE";
363 }
364#endif
366 }
367
369 if (
m_Nevts==0 || (
m_Nevts % period == 99))
ATH_MSG_INFO(
"===>>> start processing event #" << evtInfo->eventNumber() <<
", run #" << evtInfo->runNumber() <<
" | " <<
m_Nevts <<
" events processed so far <<<===");
370
371
372
373 TH1* info_runNo =
hist(
"EventInfo/info_runNo");
374 TH1* info_evtNo =
hist(
"EventInfo/info_evtNo");
375 TH1* info_lumiBlock =
hist(
"EventInfo/info_lumiBlock");
376 info_runNo->Fill(evtInfo->runNumber());
377 info_evtNo->Fill(evtInfo->eventNumber());
378 info_lumiBlock->Fill(evtInfo->lumiBlock());
379
380
381
382
383
385 xAOD::ShallowAuxContainer* electrons_nominal_aux(0);
388 ATH_MSG_DEBUG(
"Number of electrons: " << electrons_nominal->size() );
389 }
390
392 xAOD::ShallowAuxContainer* photons_nominal_aux(0);
395 ATH_MSG_DEBUG(
"Number of photons: " << photons_nominal->size() );
396 }
397
399 xAOD::ShallowAuxContainer* muons_nominal_aux(0);
402 ATH_MSG_DEBUG(
"Number of muons: " << muons_nominal->size() );
403 }
404
406 xAOD::ShallowAuxContainer* jets_nominal_aux(0);
410 }
411
412 static std::atomic<bool> doFatJets = true;
416 xAOD::ShallowAuxContainer* fatjets_nominal_aux(0);
420 return StatusCode::FAILURE;
421 } else {
423 ATH_MSG_DEBUG(
"Number of Large Radius jets: " << fatjets_nominal->size() );
424 }
425 }
else if(
m_slices[
"jet"] && doFatJets) {
427 doFatJets=false;
428 }
429
430 static std::atomic<bool> doTrkJets = true;
434 xAOD::ShallowAuxContainer* trkjets_nominal_aux(0);
438 return StatusCode::FAILURE;
439 } else {
441 ATH_MSG_DEBUG(
"Number of track jets: " << trkjets_nominal->size() );
442 }
443 }
else if(
m_slices[
"jet"] && doTrkJets) {
445 doTrkJets=false;
446 }
447
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
479 xAOD::ShallowAuxContainer* taus_nominal_aux(0);
483 for(const auto tau : *taus_gettruth) {
485 }
486 }
489 }
490
499
500 double metsig_cst(0.);
501 double metsig_tst(0.);
503
511
519
528
529
530 hist(
"MET/met_significance")->Fill( metsig_tst );
531 }
532
533
534 ATH_CHECK(
m_SUSYTools->OverlapRemoval(electrons_nominal, muons_nominal, jets_nominal, photons_nominal, taus_nominal) );
535
536
537 bool isRun3Trig = false;
538 if (
m_mcCampaign.find(
"mc21") != std::string::npos ||
m_mcCampaign.find(
"mc23") != std::string::npos) isRun3Trig =
true;
539
540 hist(
"Trigger/isMETTrigPassed")->Fill(
double(
m_SUSYTools->IsMETTrigPassed()) );
541
542
544
545
546
547 TH1* el_n_flow_nominal =
hist(
"Cutflow/el_n_flow_nominal");
548 TH1* el_trigmatch_eff_nominal =
hist(
"Trigger/el_trigmatch_eff_nominal");
549
552 m_obj_count[
"el"][
"nom"] = electrons_nominal->size();
553 for(auto el : *electrons_nominal) {
559
566
567 bool passTM=false;
571 bool passit = ((isRun3Trig||
t.find(
"_L1")==std::string::npos) ?
m_SUSYTools->IsTrigMatched(el, t) :
false);
572 passTM |= passit;
573 if(passit) el_trigmatch_eff_nominal->SetBinContent(idx, el_trigmatch_eff_nominal->GetBinContent(idx)+1);
574 #ifdef XAOD_STANDALONE
575 m_heffs[
"Trigger/el_pt_"+
t]->Fill(passit,
el->pt()/1000.);
576 m_heffs[
"Trigger/el_eta_"+
t]->Fill(passit,
el->eta());
577 m_heffs[
"Trigger/el_phi_"+
t]->Fill(passit,
el->phi());
578 #endif
580 }
582 }
583 }
584 }
586 }
590 }
591
592
593
594 TH1* ph_n_flow_nominal =
hist(
"Cutflow/ph_n_flow_nominal");
595 TH1* ph_trigmatch_eff_nominal =
hist(
"Trigger/ph_trigmatch_eff_nominal");
596
599 m_obj_count[
"ph"][
"nom"] = photons_nominal->size();
600 for(auto ph : *photons_nominal) {
612
613 bool passTM=false;
616 bool passit = ((isRun3Trig||
t.find(
"_L1")==std::string::npos) ?
m_SUSYTools->IsTrigMatched(ph, t) :
false);
617 passTM |= passit;
618 if(passit) ph_trigmatch_eff_nominal->SetBinContent(idx, ph_trigmatch_eff_nominal->GetBinContent(idx)+1);
619 #ifdef XAOD_STANDALONE
620 m_heffs[
"Trigger/ph_pt_"+
t]->Fill(passit,ph->pt()/1000.);
621 m_heffs[
"Trigger/ph_eta_"+
t]->Fill(passit,ph->eta());
622 m_heffs[
"Trigger/ph_phi_"+
t]->Fill(passit,ph->phi());
623 #endif
625 }
627 }
628 }
629 }
631 }
635 }
636
637
638
639 TH1* mu_n_flow_nominal =
hist(
"Cutflow/mu_n_flow_nominal");
640 TH1* mu_trigmatch_eff_nominal =
hist(
"Trigger/mu_trigmatch_eff_nominal");
641
645 for(auto mu : *muons_nominal) {
657
658 bool passTM=false;
661 bool passit = ((isRun3Trig||
t.find(
"_L1")==std::string::npos) ?
m_SUSYTools->IsTrigMatched(mu, t) :
false);
662 passTM |= passit;
663 if(passit) mu_trigmatch_eff_nominal->SetBinContent(idx, mu_trigmatch_eff_nominal->GetBinContent(idx)+1);
664 #ifdef XAOD_STANDALONE
665 m_heffs[
"Trigger/mu_pt_"+
t]->Fill(passit,
mu->pt()/1000.);
666 m_heffs[
"Trigger/mu_eta_"+
t]->Fill(passit,
mu->eta());
667 m_heffs[
"Trigger/mu_phi_"+
t]->Fill(passit,
mu->phi());
668 #endif
670 }
672 }
673 }
674 }
676 }
680 }
681
682
683
684 TH1* jet_n_flow_nominal =
hist(
"Cutflow/jet_n_flow_nominal");
685 TH1* bjet_n_flow_nominal =
hist(
"Cutflow/bjet_n_flow_nominal");
687
690 for(auto jet : *jets_nominal) {
695 if (bjet) bjet_n_flow_nominal->Fill(
Cut::all);
696
699 if (bjet) {
703 }
706
713 if (bjet) {
718 }
721 }
722 }
723 }
724 if (bjet) {
726 }
728 }
735 }
736
737
738
739 TH1* fatjet_n_flow_nominal =
hist(
"Cutflow/fatjet_n_flow_nominal");
740
741 if(
m_slices[
"fjet"] && doFatJets ) {
745 std::string taggerKey;
746 taggerKey =
findInReg(reg, (*fatjets_nominal)[0],
"(SmoothW.*?)_.*");
747 if (!taggerKey.empty()) {
m_configDict[
"WtaggerKey"] = taggerKey; }
748 }
751 std::string taggerKey;
752 taggerKey =
findInReg(reg, (*fatjets_nominal)[0],
"(SmoothZ.*?)_.*");
753 if (!taggerKey.empty()) {
m_configDict[
"ZtaggerKey"] = taggerKey; }
754 }
757 std::string taggerKey;
758 taggerKey =
findInReg(reg, (*fatjets_nominal)[0],
"(.*Tag.*Top.*?)_.*");
759 if (!taggerKey.empty()) {
m_configDict[
"ToptaggerKey"] = taggerKey; }
760 }
765
766 m_obj_count[
"fatjet"][
"nom"] = fatjets_nominal->size();
767 for(auto fatjet : *fatjets_nominal) {
768 fatjet_n_flow_nominal->Fill(
Cut::all);
780 }
781 }
782 }
784 }
788 }
789
790
791
792 TH1* trkjet_n_flow_nominal =
hist(
"Cutflow/trkjet_n_flow_nominal");
793
794 if(
m_slices[
"tjet"] && doTrkJets ) {
795 m_obj_count[
"trkjet"][
"nom"] = trkjets_nominal->size();
796 for(auto trkjet : *trkjets_nominal) {
797 trkjet_n_flow_nominal->Fill(
Cut::all);
809 }
810 }
811 }
813 }
817 }
818
819
820
821 TH1* tau_n_flow_nominal =
hist(
"Cutflow/tau_n_flow_nominal");
822
825 for(auto tau : *taus_nominal) {
833
839 }
840 }
841 }
843 }
847 }
848
849
850
851 double base_event_weight(1.);
852 if (!isData) {
853 base_event_weight *= evtInfo->mcEventWeight();
854
858
859 ATH_MSG_DEBUG(
"Truth MET etx=" << (*met_truth)[
"NonInt"]->mpx()
860 << ", ety=" << (*met_truth)["NonInt"]->mpy()
861 << ", et=" << (*met_truth)["NonInt"]->met()
862 << ", sumet=" << (*met_truth)["NonInt"]->sumet());
864 <<
", dety=" << (*
m_metcst_nominal)[
"Final"]->mpy() - (*met_truth)[
"NonInt"]->mpy());
866 <<
", dety=" << (*
m_mettst_nominal)[
"Final"]->mpy() - (*met_truth)[
"NonInt"]->mpy());
867 }
868 }
869
870
871
872 double electrons_weight_nominal(1.);
873 double photons_weight_nominal(1.);
874 double muons_weight_nominal(1.);
875 double jets_weight_nominal(1.);
876
877
878 double btag_weight_nominal(1.);
879 double taus_weight_nominal(1.);
880 double event_weight_nominal(1.);
881 double prw_weight_nominal(1.);
882
883
884 TH1* weight_event =
hist(
"Syst/weight_event");
885 TH1* weight_electrons =
hist(
"Syst/weight_electrons");
886 TH1* weight_muons =
hist(
"Syst/weight_muons");
887 TH1* weight_photons =
hist(
"Syst/weight_photons");
888 TH1* weight_taus =
hist(
"Syst/weight_taus");
889 TH1* weight_jets =
hist(
"Syst/weight_jets");
890 TH1* weight_btags =
hist(
"Syst/weight_btags");
891
892 bool isNominal(true);
894 CP::SystematicSet
sys = sysInfo.systset;
895 if (
m_SUSYTools->applySystematicVariation(sys) != StatusCode::SUCCESS) {
896 ATH_MSG_ERROR(
"Cannot configure SUSYTools for systematic var. %s" <<
sys.name() );
897 } else {
899 }
900 if (isNominal && (sysInfo.affectsKinematics || sysInfo.affectsWeights)) {
902 return StatusCode::FAILURE;
903 }
904 if (sysInfo.affectsKinematics || sysInfo.affectsWeights) isNominal = false;
905
906 double event_weight = base_event_weight;
908
909
910
911 double prw_weight=1.;
912 if(isNominal){
913 if(!isData) prw_weight_nominal =
m_SUSYTools->GetPileupWeight();
914 event_weight *= prw_weight_nominal;
915 weight_event->SetBinContent(1, weight_event->GetBinContent(1)+event_weight);
916 }
917 else if (!syst_affectsEventWeight) {
918 event_weight *= prw_weight_nominal;
919 }
920 else {
921 if(!isData){
924 }
925 event_weight *= prw_weight;
927 if(iwbin <
m_syst_weights[
"EventWeight"].
size()) { weight_event->SetBinContent(iwbin+1, weight_event->GetBinContent(iwbin+1)+event_weight); }
928 }
929
930
931
941
949
950
951
952 if (syst_affectsLRT)
953 {
955 }
956
957
958
959 if (sysInfo.affectsKinematics) {
960 if (
m_slices[
"el"] && syst_affectsElectrons) {
963 xAOD::ShallowAuxContainer* electrons_syst_aux(0);
966 }
967
968 if (
m_slices[
"pho"] && syst_affectsPhotons) {
971 xAOD::ShallowAuxContainer* photons_syst_aux(0);
973 photons = photons_syst;
974 }
975
976 if (
m_slices[
"mu"] && syst_affectsMuons) {
979 xAOD::ShallowAuxContainer* muons_syst_aux(0);
981 muons = muons_syst;
982 }
983
984 if (syst_affectsJets) {
988 xAOD::ShallowAuxContainer* jets_syst_aux(0);
991 }
992 if (
m_slices[
"fjet"] and doFatJets) {
995 xAOD::ShallowAuxContainer* fatjets_syst_aux(0);
997 fatjets = fatjets_syst;
998 }
1002 xAOD::ShallowAuxContainer* trkjets_syst_aux(0);
1004 trkjets = trkjets_syst;
1005 }
1006 }
1007
1008 if (
m_slices[
"tau"] && syst_affectsTaus) {
1011 xAOD::ShallowAuxContainer* taus_syst_aux(0);
1014 }
1015
1025
1029 }
1030
1035 }
1036
1037
1039
1040
1043 float electrons_weight(1.);
1044 for ( const auto el : *electrons ) {
1045 if( !isData ){
1046 if (isNominal || syst_affectsElectrons) {
1047 if ((
ST::acc_signal(*el) == 1) && (isNominal || sysInfo.affectsWeights)) {
1048
1049 electrons_weight *=
m_SUSYTools->GetSignalElecSF(*el,
true,
true,
false,
true);
1050 }
1051 }
1052 }
1057
1058 }
1059 if (isNominal) {
1060 electrons_weight_nominal = electrons_weight;
1061 weight_electrons->SetBinContent(1, weight_electrons->GetBinContent(1)+electrons_weight);
1062 }
1063 else if (!syst_affectsElectrons) {
1064 electrons_weight = electrons_weight_nominal;
1065 }
1066 else if ( sysInfo.affectsWeights ){
1068 if(iwbin <
m_syst_weights[
"Electron"].
size()) { weight_electrons->SetBinContent(iwbin+1, weight_electrons->GetBinContent(iwbin+1)+electrons_weight); }
1069 }
1070
1071 event_weight *= electrons_weight;
1072 ATH_MSG_DEBUG(
"Combined electron scale factor: " << electrons_weight);
1073 }
1074
1075
1078 float photons_weight(1.);
1079 for ( const auto ph : *photons ) {
1080 if( !isData ){
1081 if (isNominal || syst_affectsPhotons) {
1082 if ((
ST::acc_signal(*ph) == 1) && (isNominal || sysInfo.affectsWeights)) {
1083 photons_weight *=
m_SUSYTools->GetSignalPhotonSF( *ph );
1084 }
1085 }
1086 }
1091 }
1092 if (isNominal) {
1093 photons_weight_nominal = photons_weight;
1094 weight_photons->SetBinContent(1, weight_photons->GetBinContent(1)+photons_weight);
1095 }
1096 else if (!syst_affectsPhotons) {
1097 photons_weight = photons_weight_nominal;
1098 }
1099 else if ( sysInfo.affectsWeights ){
1101 if(iwbin <
m_syst_weights[
"Photon"].
size()) { weight_photons->SetBinContent(iwbin+1, weight_photons->GetBinContent(iwbin+1)+photons_weight); }
1102 }
1103
1104 event_weight *= photons_weight;
1105 ATH_MSG_DEBUG(
"Combined photon scale factor: " << photons_weight);
1106 }
1107
1108
1111 float muons_weight(1.);
1112 for ( const auto mu : *muons ) {
1113 if( !isData ){
1114 if (isNominal || syst_affectsMuons) {
1115 if ((
ST::acc_signal(*mu) == 1) && (isNominal || sysInfo.affectsWeights)) {
1116 muons_weight *=
m_SUSYTools->GetSignalMuonSF(*mu);;
1117 }
1118 }
1119 }
1125 }
1126 if (isNominal) {
1127 muons_weight_nominal = muons_weight;
1128 weight_muons->SetBinContent(1, weight_muons->GetBinContent(1)+muons_weight);
1129 }
1130 else if (!syst_affectsMuons) {
1131 muons_weight = muons_weight_nominal;
1132 }
1133 else if ( sysInfo.affectsWeights ){
1135 if(iwbin <
m_syst_weights[
"Muon"].
size()) { weight_muons->SetBinContent(iwbin+1, weight_muons->GetBinContent(iwbin+1)+muons_weight); }
1136 }
1137
1138 event_weight *= muons_weight;
1139 ATH_MSG_DEBUG(
"Combined muon scale factor: " << muons_weight);
1140 }
1141
1142
1145 for ( const auto jet : *jets ) {
1150 if (
m_slices[
"bjet"] && (isNominal || syst_affectsJets || syst_affectsBTag)) {
1152 }
1154 }
1155 }
1156
1157 float jet_weight(1.);
1158 float btag_weight(1.);
1159 if( !isData ) {
1160 if (isNominal) {
1161 btag_weight_nominal = btag_weight =
m_SUSYTools->BtagSF(jets);
1162 weight_btags->SetBinContent(1, weight_btags->GetBinContent(1)+btag_weight);
1163 }
1164 else if (!syst_affectsBTag){
1165 btag_weight = btag_weight_nominal;
1166 }
1167 else{
1170 if(iwbin <
m_syst_weights[
"BTag"].
size()) { weight_btags->SetBinContent(iwbin+1, weight_btags->GetBinContent(iwbin+1)+btag_weight); }
1171 }
1172
1173 if(isNominal){
1176 jets_weight_nominal = jet_weight;
1177 jets_weight_nominal *=
m_SUSYTools->FJVT_SF(jets);
1178 weight_jets->SetBinContent(1, weight_jets->GetBinContent(1)+jet_weight);
1179 }
1180 else if (!syst_affectsJets || (syst_affectsJets && !sysInfo.affectsWeights)){
1181 jet_weight = jets_weight_nominal;
1182 }
1183 else if ( syst_affectsJets && sysInfo.affectsWeights ){
1187 if(iwbin <
m_syst_weights[
"Jet"].
size()) { weight_jets->SetBinContent(iwbin+1, weight_jets->GetBinContent(iwbin+1)+jet_weight); }
1188 }
1189 }
1190 else{
1191 weight_jets->SetBinContent(1, 1.);
1192 weight_btags->SetBinContent(1, 1.);
1193 }
1194 event_weight *= jet_weight;
1195 event_weight *= btag_weight;
1196 ATH_MSG_DEBUG(
"Combined b-tagging scale factor: " << btag_weight);
1198 }
1199
1200
1201
1202 if(
m_slices[
"fjet"] && doFatJets ) {
1204 for ( const auto fatjet : *fatjets ) {
1208 }
1209
1210 float fatjet_weight(1.);
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226 ATH_MSG_DEBUG(
"Combined large radius jet scale factor: " << fatjet_weight);
1227 }
1228
1229
1230
1231 if(
m_slices[
"tjet"] && doTrkJets ) {
1233 for ( const auto trkjet : *trkjets ) {
1237 }
1238
1239 float trkjet_weight(1.);
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255 ATH_MSG_DEBUG(
"Combined track jet scale factor: " << trkjet_weight);
1256 }
1257
1258
1261 float taus_weight(1.);
1262 for (
const auto ta : *
taus ) {
1263 if( !isData ){
1264 if (isNominal || syst_affectsTaus) {
1265 if ((
ST::acc_signal(*ta) == 1) && (isNominal || sysInfo.affectsWeights)) {
1266 taus_weight *=
m_SUSYTools->GetSignalTauSF(*ta,
true,
false);
1267 }
1268 }
1269 }
1274 }
1275
1276 if (isNominal) {
1277 taus_weight_nominal = taus_weight;
1278 weight_taus->SetBinContent(1, weight_taus->GetBinContent(1)+taus_weight);
1279 }
1280 else if (!syst_affectsTaus) {
1281 taus_weight = taus_weight_nominal;
1282 }
1283 else if ( sysInfo.affectsWeights ){
1285 if(iwbin <
m_syst_weights[
"Tau"].
size()) { weight_taus->SetBinContent(iwbin+1, weight_taus->GetBinContent(iwbin+1)+taus_weight); }
1286 }
1287
1288 event_weight *= taus_weight;
1289 }
1290
1291
1293 if (isNominal) {event_weight_nominal = event_weight;}
1294 else if (sysInfo.affectsWeights)
ATH_MSG_DEBUG(
"Difference with nominal weight: " << event_weight - event_weight_nominal);
1295
1296
1297 if (sysInfo.affectsKinematics) {
1298 delete metcst;
1299 delete mettst;
1300 delete metcst_aux;
1301 delete mettst_aux;
1302 }
1303 isNominal = false;
1304 }
1305
1309 } else {
1311 }
1313
1318
1319 return StatusCode::SUCCESS;
1320}
Scalar phi() const
phi method
#define ATH_MSG_VERBOSE(x)
#define ATH_MSG_WARNING(x)
#define CHECK(...)
Evaluate an expression and check for errors.
Athena::TPCnvVers::Old Athena::TPCnvVers::Current EventStreamInfo
size_t size() const
Number of registered mappings.
ServiceHandle< StoreGateSvc > & evtStore()
ConstMetaStorePtr_t inputMetaStore() const
const std::set< std::string > & getProcessingTags() const
static AuxTypeRegistry & instance()
Return the singleton registry instance.
bool contains(const std::string &s, const std::string ®x)
does a string contain the substring
std::string find(const std::string &s)
return a remapped string
XAOD_AUXDATA_DEPRECATED bool isAvailable(const std::string &name, const std::string &clsname="") const
Check if an aux variable is available for reading.
static const SG::ConstAccessor< double > acc_effscalefact("effscalefact")
static const SG::ConstAccessor< char > acc_bad("bad")
static const SG::ConstAccessor< char > acc_signal("signal")
static const SG::ConstAccessor< char > acc_baseline("baseline")
static bool testAffectsObject(xAOD::Type::ObjectType type, unsigned int test)
static const SG::ConstAccessor< char > acc_bjet("bjet")
static const SG::ConstAccessor< char > acc_cosmic("cosmic")
static const SG::ConstAccessor< char > acc_passOR("passOR")
AthConfigFlags bjet(AthConfigFlags flags, str instanceName, str recoMode)
@ Jet
The object is a jet.
@ Photon
The object is a photon.
@ Muon
The object is a muon.
@ BTag
The object is a b-tagging object.
@ Electron
The object is an electron.
@ Tau
The object is a tau (jet).
PhotonContainer_v1 PhotonContainer
Definition of the current "photon container version".
ElectronContainer_v1 ElectronContainer
Definition of the current "electron container version".
EventInfo_v1 EventInfo
Definition of the latest event info version.
MissingETContainer_v1 MissingETContainer
MissingETAuxContainer_v1 MissingETAuxContainer
JetContainer_v1 JetContainer
Definition of the current "jet container version".
TauJetContainer_v3 TauJetContainer
Definition of the current "taujet container version".
MuonContainer_v1 MuonContainer
Definition of the current "Muon container version".
CutBookkeeperContainer_v1 CutBookkeeperContainer
Define the latest version of the CutBookkeeperContainer class.
1.16.1