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 }
732 }
733
734
735
736 TH1* fatjet_n_flow_nominal =
hist(
"Cutflow/fatjet_n_flow_nominal");
737
738 if(
m_slices[
"fjet"] && doFatJets ) {
742 std::string taggerKey;
743 taggerKey =
findInReg(reg, (*fatjets_nominal)[0],
"(SmoothW.*?)_.*");
744 if (!taggerKey.empty()) {
m_configDict[
"WtaggerKey"] = taggerKey; }
745 }
748 std::string taggerKey;
749 taggerKey =
findInReg(reg, (*fatjets_nominal)[0],
"(SmoothZ.*?)_.*");
750 if (!taggerKey.empty()) {
m_configDict[
"ZtaggerKey"] = taggerKey; }
751 }
754 std::string taggerKey;
755 taggerKey =
findInReg(reg, (*fatjets_nominal)[0],
"(.*Tag.*Top.*?)_.*");
756 if (!taggerKey.empty()) {
m_configDict[
"ToptaggerKey"] = taggerKey; }
757 }
762
763 m_obj_count[
"fatjet"][
"nom"] = fatjets_nominal->size();
764 for(auto fatjet : *fatjets_nominal) {
765 fatjet_n_flow_nominal->Fill(
Cut::all);
777 }
778 }
779 }
781 }
785 }
786
787
788
789 TH1* trkjet_n_flow_nominal =
hist(
"Cutflow/trkjet_n_flow_nominal");
790
791 if(
m_slices[
"tjet"] && doTrkJets ) {
792 m_obj_count[
"trkjet"][
"nom"] = trkjets_nominal->size();
793 for(auto trkjet : *trkjets_nominal) {
794 trkjet_n_flow_nominal->Fill(
Cut::all);
806 }
807 }
808 }
810 }
814 }
815
816
817
818 TH1* tau_n_flow_nominal =
hist(
"Cutflow/tau_n_flow_nominal");
819
822 for(auto tau : *taus_nominal) {
830
836 }
837 }
838 }
840 }
844 }
845
846
847
848 double base_event_weight(1.);
849 if (!isData) {
850 base_event_weight *= evtInfo->mcEventWeight();
851
855
856 ATH_MSG_DEBUG(
"Truth MET etx=" << (*met_truth)[
"NonInt"]->mpx()
857 << ", ety=" << (*met_truth)["NonInt"]->mpy()
858 << ", et=" << (*met_truth)["NonInt"]->met()
859 << ", sumet=" << (*met_truth)["NonInt"]->sumet());
861 <<
", dety=" << (*
m_metcst_nominal)[
"Final"]->mpy() - (*met_truth)[
"NonInt"]->mpy());
863 <<
", dety=" << (*
m_mettst_nominal)[
"Final"]->mpy() - (*met_truth)[
"NonInt"]->mpy());
864 }
865 }
866
867
868
869 double electrons_weight_nominal(1.);
870 double photons_weight_nominal(1.);
871 double muons_weight_nominal(1.);
872 double jets_weight_nominal(1.);
873
874
875 double btag_weight_nominal(1.);
876 double taus_weight_nominal(1.);
877 double event_weight_nominal(1.);
878 double prw_weight_nominal(1.);
879
880
881 TH1* weight_event =
hist(
"Syst/weight_event");
882 TH1* weight_electrons =
hist(
"Syst/weight_electrons");
883 TH1* weight_muons =
hist(
"Syst/weight_muons");
884 TH1* weight_photons =
hist(
"Syst/weight_photons");
885 TH1* weight_taus =
hist(
"Syst/weight_taus");
886 TH1* weight_jets =
hist(
"Syst/weight_jets");
887 TH1* weight_btags =
hist(
"Syst/weight_btags");
888
889 bool isNominal(true);
891 CP::SystematicSet
sys = sysInfo.systset;
892 if (
m_SUSYTools->applySystematicVariation(sys) != StatusCode::SUCCESS) {
893 ATH_MSG_ERROR(
"Cannot configure SUSYTools for systematic var. %s" <<
sys.name() );
894 } else {
896 }
897 if (isNominal && (sysInfo.affectsKinematics || sysInfo.affectsWeights)) {
899 return StatusCode::FAILURE;
900 }
901 if (sysInfo.affectsKinematics || sysInfo.affectsWeights) isNominal = false;
902
903 double event_weight = base_event_weight;
905
906
907
908 double prw_weight=1.;
909 if(isNominal){
910 if(!isData) prw_weight_nominal =
m_SUSYTools->GetPileupWeight();
911 event_weight *= prw_weight_nominal;
912 weight_event->SetBinContent(1, weight_event->GetBinContent(1)+event_weight);
913 }
914 else if (!syst_affectsEventWeight) {
915 event_weight *= prw_weight_nominal;
916 }
917 else {
918 if(!isData){
921 }
922 event_weight *= prw_weight;
924 if(iwbin <
m_syst_weights[
"EventWeight"].size()) { weight_event->SetBinContent(iwbin+1, weight_event->GetBinContent(iwbin+1)+event_weight); }
925 }
926
927
928
938
946
947
948
949 if (syst_affectsLRT)
950 {
952 }
953
954
955
956 if (sysInfo.affectsKinematics) {
957 if (
m_slices[
"el"] && syst_affectsElectrons) {
960 xAOD::ShallowAuxContainer* electrons_syst_aux(0);
963 }
964
965 if (
m_slices[
"pho"] && syst_affectsPhotons) {
968 xAOD::ShallowAuxContainer* photons_syst_aux(0);
970 photons = photons_syst;
971 }
972
973 if (
m_slices[
"mu"] && syst_affectsMuons) {
976 xAOD::ShallowAuxContainer* muons_syst_aux(0);
978 muons = muons_syst;
979 }
980
981 if (syst_affectsJets) {
985 xAOD::ShallowAuxContainer* jets_syst_aux(0);
988 }
989 if (
m_slices[
"fjet"] and doFatJets) {
992 xAOD::ShallowAuxContainer* fatjets_syst_aux(0);
994 fatjets = fatjets_syst;
995 }
999 xAOD::ShallowAuxContainer* trkjets_syst_aux(0);
1001 trkjets = trkjets_syst;
1002 }
1003 }
1004
1005 if (
m_slices[
"tau"] && syst_affectsTaus) {
1008 xAOD::ShallowAuxContainer* taus_syst_aux(0);
1011 }
1012
1022
1026 }
1027
1032 }
1033
1034
1036
1037
1040 float electrons_weight(1.);
1041 for ( const auto el : *electrons ) {
1042 if( !isData ){
1043 if (isNominal || syst_affectsElectrons) {
1044 if ((
ST::acc_signal(*el) == 1) && (isNominal || sysInfo.affectsWeights)) {
1045
1046 electrons_weight *=
m_SUSYTools->GetSignalElecSF(*el,
true,
true,
false,
true);
1047 }
1048 }
1049 }
1054
1055 }
1056 if (isNominal) {
1057 electrons_weight_nominal = electrons_weight;
1058 weight_electrons->SetBinContent(1, weight_electrons->GetBinContent(1)+electrons_weight);
1059 }
1060 else if (!syst_affectsElectrons) {
1061 electrons_weight = electrons_weight_nominal;
1062 }
1063 else if ( sysInfo.affectsWeights ){
1065 if(iwbin <
m_syst_weights[
"Electron"].size()) { weight_electrons->SetBinContent(iwbin+1, weight_electrons->GetBinContent(iwbin+1)+electrons_weight); }
1066 }
1067
1068 event_weight *= electrons_weight;
1069 ATH_MSG_DEBUG(
"Combined electron scale factor: " << electrons_weight);
1070 }
1071
1072
1075 float photons_weight(1.);
1076 for ( const auto ph : *photons ) {
1077 if( !isData ){
1078 if (isNominal || syst_affectsPhotons) {
1079 if ((
ST::acc_signal(*ph) == 1) && (isNominal || sysInfo.affectsWeights)) {
1080 photons_weight *=
m_SUSYTools->GetSignalPhotonSF( *ph );
1081 }
1082 }
1083 }
1088 }
1089 if (isNominal) {
1090 photons_weight_nominal = photons_weight;
1091 weight_photons->SetBinContent(1, weight_photons->GetBinContent(1)+photons_weight);
1092 }
1093 else if (!syst_affectsPhotons) {
1094 photons_weight = photons_weight_nominal;
1095 }
1096 else if ( sysInfo.affectsWeights ){
1098 if(iwbin <
m_syst_weights[
"Photon"].size()) { weight_photons->SetBinContent(iwbin+1, weight_photons->GetBinContent(iwbin+1)+photons_weight); }
1099 }
1100
1101 event_weight *= photons_weight;
1102 ATH_MSG_DEBUG(
"Combined photon scale factor: " << photons_weight);
1103 }
1104
1105
1108 float muons_weight(1.);
1109 for ( const auto mu : *muons ) {
1110 if( !isData ){
1111 if (isNominal || syst_affectsMuons) {
1112 if ((
ST::acc_signal(*mu) == 1) && (isNominal || sysInfo.affectsWeights)) {
1113 muons_weight *=
m_SUSYTools->GetSignalMuonSF(*mu);;
1114 }
1115 }
1116 }
1122 }
1123 if (isNominal) {
1124 muons_weight_nominal = muons_weight;
1125 weight_muons->SetBinContent(1, weight_muons->GetBinContent(1)+muons_weight);
1126 }
1127 else if (!syst_affectsMuons) {
1128 muons_weight = muons_weight_nominal;
1129 }
1130 else if ( sysInfo.affectsWeights ){
1132 if(iwbin <
m_syst_weights[
"Muon"].size()) { weight_muons->SetBinContent(iwbin+1, weight_muons->GetBinContent(iwbin+1)+muons_weight); }
1133 }
1134
1135 event_weight *= muons_weight;
1136 ATH_MSG_DEBUG(
"Combined muon scale factor: " << muons_weight);
1137 }
1138
1139
1142 for ( const auto jet : *jets ) {
1147 if (
m_slices[
"bjet"] && (isNominal || syst_affectsJets || syst_affectsBTag)) {
1149 }
1151 }
1152 }
1153
1154 float jet_weight(1.);
1155 float btag_weight(1.);
1156 if( !isData ) {
1157 if (isNominal) {
1158 btag_weight_nominal = btag_weight =
m_SUSYTools->BtagSF(jets);
1159 weight_btags->SetBinContent(1, weight_btags->GetBinContent(1)+btag_weight);
1160 }
1161 else if (!syst_affectsBTag){
1162 btag_weight = btag_weight_nominal;
1163 }
1164 else{
1167 if(iwbin <
m_syst_weights[
"BTag"].size()) { weight_btags->SetBinContent(iwbin+1, weight_btags->GetBinContent(iwbin+1)+btag_weight); }
1168 }
1169
1170 if(isNominal){
1173 jets_weight_nominal = jet_weight;
1174 jets_weight_nominal *=
m_SUSYTools->FJVT_SF(jets);
1175 weight_jets->SetBinContent(1, weight_jets->GetBinContent(1)+jet_weight);
1176 }
1177 else if (!syst_affectsJets || (syst_affectsJets && !sysInfo.affectsWeights)){
1178 jet_weight = jets_weight_nominal;
1179 }
1180 else if ( syst_affectsJets && sysInfo.affectsWeights ){
1184 if(iwbin <
m_syst_weights[
"Jet"].size()) { weight_jets->SetBinContent(iwbin+1, weight_jets->GetBinContent(iwbin+1)+jet_weight); }
1185 }
1186 }
1187 else{
1188 weight_jets->SetBinContent(1, 1.);
1189 weight_btags->SetBinContent(1, 1.);
1190 }
1191 event_weight *= jet_weight;
1192 event_weight *= btag_weight;
1193 ATH_MSG_DEBUG(
"Combined b-tagging scale factor: " << btag_weight);
1195 }
1196
1197
1198
1199 if(
m_slices[
"fjet"] && doFatJets ) {
1201 for ( const auto fatjet : *fatjets ) {
1205 }
1206
1207 float fatjet_weight(1.);
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223 ATH_MSG_DEBUG(
"Combined large radius jet scale factor: " << fatjet_weight);
1224 }
1225
1226
1227
1228 if(
m_slices[
"tjet"] && doTrkJets ) {
1230 for ( const auto trkjet : *trkjets ) {
1234 }
1235
1236 float trkjet_weight(1.);
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252 ATH_MSG_DEBUG(
"Combined track jet scale factor: " << trkjet_weight);
1253 }
1254
1255
1258 float taus_weight(1.);
1259 for (
const auto ta : *
taus ) {
1260 if( !isData ){
1261 if (isNominal || syst_affectsTaus) {
1262 if ((
ST::acc_signal(*ta) == 1) && (isNominal || sysInfo.affectsWeights)) {
1263 taus_weight *=
m_SUSYTools->GetSignalTauSF(*ta,
true,
false);
1264 }
1265 }
1266 }
1271 }
1272
1273 if (isNominal) {
1274 taus_weight_nominal = taus_weight;
1275 weight_taus->SetBinContent(1, weight_taus->GetBinContent(1)+taus_weight);
1276 }
1277 else if (!syst_affectsTaus) {
1278 taus_weight = taus_weight_nominal;
1279 }
1280 else if ( sysInfo.affectsWeights ){
1282 if(iwbin <
m_syst_weights[
"Tau"].size()) { weight_taus->SetBinContent(iwbin+1, weight_taus->GetBinContent(iwbin+1)+taus_weight); }
1283 }
1284
1285 event_weight *= taus_weight;
1286 }
1287
1288
1290 if (isNominal) {event_weight_nominal = event_weight;}
1291 else if (sysInfo.affectsWeights)
ATH_MSG_DEBUG(
"Difference with nominal weight: " << event_weight - event_weight_nominal);
1292
1293
1294 if (sysInfo.affectsKinematics) {
1295 delete metcst;
1296 delete mettst;
1297 delete metcst_aux;
1298 delete mettst_aux;
1299 }
1300 isNominal = false;
1301 }
1302
1306 } else {
1308 }
1310
1315
1316 return StatusCode::SUCCESS;
1317}
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
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
bool isAvailable(const T_Aux &cont, SG::auxid_t auxid)
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)
retrieve(aClass, aKey=None)
@ 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.14.0