From 845cedd8855ae624d11c26c4e04221fb682ebc4a Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Wed, 7 Dec 2022 15:27:51 +0100 Subject: [PATCH 01/10] use signed integer for table size counter branches --- PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc | 14 ++++++++++---- PhysicsTools/NanoAOD/plugins/LumiOutputBranches.h | 3 ++- .../NanoAOD/plugins/SummaryTableOutputBranches.cc | 4 ++-- .../NanoAOD/plugins/TableOutputBranches.cc | 13 ++++++++++--- PhysicsTools/NanoAOD/plugins/TableOutputBranches.h | 3 ++- 5 files changed, 26 insertions(+), 11 deletions(-) diff --git a/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc b/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc index 181eac081f4e1..5fd18bb155875 100644 --- a/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc +++ b/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc @@ -16,7 +16,7 @@ void LumiOutputBranches::defineBranchesFromFirstEvent(const nanoaod::FlatTable & case nanoaod::FlatTable::ColumnType::Float: m_floatBranches.emplace_back(var, tab.columnDoc(i), "F"); break; - case nanoaod::FlatTable::ColumnType::Int: + case nanoaod::FlatTable::ColumnType::Int32: m_intBranches.emplace_back(var, tab.columnDoc(i), "I"); break; case nanoaod::FlatTable::ColumnType::UInt8: @@ -44,7 +44,7 @@ void LumiOutputBranches::branch(TTree &tree) { if (tree.FindBranch(("n" + m_baseName).c_str()) != nullptr) { throw cms::Exception("LogicError", "Trying to save multiple main tables for " + m_baseName + "\n"); } - m_counterBranch = tree.Branch(("n" + m_baseName).c_str(), &m_counter, ("n" + m_baseName + "/i").c_str()); + m_counterBranch = tree.Branch(("n" + m_baseName).c_str(), &m_counter, ("n" + m_baseName + "/I").c_str()); m_counterBranch->SetTitle(m_doc.c_str()); } } @@ -68,7 +68,13 @@ void LumiOutputBranches::fill(const edm::LuminosityBlockForOutput &iLumi, TTree edm::Handle handle; iLumi.getByToken(m_token, handle); const nanoaod::FlatTable &tab = *handle; - m_counter = tab.size(); + auto size = tab.size(); + // ROOT native array size branches may only be signed integers, + // until this is changed we need to make sure the vector sizes do not exceed that + if (size > std::numeric_limits::max()) { + throw cms::Exception("Table " + tab.name() + " size is " + std::to_string(size) + ", is too large for ROOT native array branch"); + } + m_counter = size; m_singleton = tab.singleton(); if (!m_branchesBooked) { m_extension = tab.extension() ? IsExtension : IsMain; @@ -80,7 +86,7 @@ void LumiOutputBranches::fill(const edm::LuminosityBlockForOutput &iLumi, TTree branch(tree); } if (!m_singleton && m_extension == IsExtension) { - if (m_counter != *reinterpret_cast(m_counterBranch->GetAddress())) { + if (m_counter != *reinterpret_cast(m_counterBranch->GetAddress())) { throw cms::Exception("LogicError", "Mismatch in number of entries between extension and main table for " + tab.name()); } diff --git a/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.h b/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.h index 532fe7f6e2d94..9bd7a52a7f8a4 100644 --- a/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.h +++ b/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.h @@ -30,7 +30,8 @@ class LumiOutputBranches { bool m_singleton; enum { IsMain = 0, IsExtension = 1, DontKnowYetIfMainOrExtension = 2 } m_extension; std::string m_doc; - UInt_t m_counter; + typedef Int_t CounterType; + CounterType m_counter; struct NamedBranchPtr { std::string name, title, rootTypeCode; TBranch *branch; diff --git a/PhysicsTools/NanoAOD/plugins/SummaryTableOutputBranches.cc b/PhysicsTools/NanoAOD/plugins/SummaryTableOutputBranches.cc index 378e7a30165ec..33273a71862a4 100644 --- a/PhysicsTools/NanoAOD/plugins/SummaryTableOutputBranches.cc +++ b/PhysicsTools/NanoAOD/plugins/SummaryTableOutputBranches.cc @@ -28,8 +28,8 @@ void SummaryTableOutputBranches::makeVectorBranches(const std::vector &tabc if (std::find_if(branches.begin(), branches.end(), [&col](const NamedBranchPtr &x) { return x.name == col.name; }) == branches.end()) { - unsigned int backFillValue = 0; - auto *cbr = tree.Branch(("n" + col.name).c_str(), &backFillValue, ("n" + col.name + "/i").c_str()); + int backFillValue = 0; + auto *cbr = tree.Branch(("n" + col.name).c_str(), &backFillValue, ("n" + col.name + "/I").c_str()); auto *vbr = tree.Branch(col.name.c_str(), (void *)nullptr, (col.name + "[n" + col.name + "]/" + rootType).c_str()); cbr->SetTitle(("Number of entries in " + col.name).c_str()); diff --git a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc index 291a6af13cda9..c1bcab3e6cb4c 100644 --- a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc +++ b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc @@ -1,6 +1,7 @@ #include "PhysicsTools/NanoAOD/plugins/TableOutputBranches.h" #include +#include namespace { std::string makeBranchName(const std::string &baseName, const std::string &leafName) { @@ -53,7 +54,7 @@ void TableOutputBranches::branch(TTree &tree) { if (tree.FindBranch(("n" + m_baseName).c_str()) != nullptr) { throw cms::Exception("LogicError", "Trying to save multiple main tables for " + m_baseName + "\n"); } - m_counterBranch = tree.Branch(("n" + m_baseName).c_str(), &m_counter, ("n" + m_baseName + "/i").c_str()); + m_counterBranch = tree.Branch(("n" + m_baseName).c_str(), &m_counter, ("n" + m_baseName + "/I").c_str()); m_counterBranch->SetTitle(m_doc.c_str()); } } @@ -78,7 +79,13 @@ void TableOutputBranches::fill(const edm::OccurrenceForOutput &iWhatever, TTree edm::Handle handle; iWhatever.getByToken(m_token, handle); const nanoaod::FlatTable &tab = *handle; - m_counter = tab.size(); + auto size = tab.size(); + // ROOT native array size branches may only be signed integers, + // until this is changed we need to make sure the vector sizes do not exceed that + if (size > std::numeric_limits::max()) { + throw cms::Exception("Table " + tab.name() + " size is " + std::to_string(size) + ", is too large for ROOT native array branch"); + } + m_counter = size; m_singleton = tab.singleton(); if (!m_branchesBooked) { m_extension = tab.extension() ? IsExtension : IsMain; @@ -90,7 +97,7 @@ void TableOutputBranches::fill(const edm::OccurrenceForOutput &iWhatever, TTree branch(tree); } if (!m_singleton && m_extension == IsExtension) { - if (m_counter != *reinterpret_cast(m_counterBranch->GetAddress())) { + if (m_counter != *reinterpret_cast(m_counterBranch->GetAddress())) { throw cms::Exception("LogicError", "Mismatch in number of entries between extension and main table for " + tab.name()); } diff --git a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.h b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.h index f408e65759e38..4a551f83cad73 100644 --- a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.h +++ b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.h @@ -30,7 +30,8 @@ class TableOutputBranches { bool m_singleton = false; enum { IsMain = 0, IsExtension = 1, DontKnowYetIfMainOrExtension = 2 } m_extension; std::string m_doc; - UInt_t m_counter; + typedef Int_t CounterType; + CounterType m_counter; struct NamedBranchPtr { std::string name, title, rootTypeCode; TBranch *branch; From ac3d20d898112ee6df1e08aaebfaca0f158ec7ba Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Wed, 7 Dec 2022 16:30:06 +0100 Subject: [PATCH 02/10] add support for 16-bit integers in nanoAOD --- DataFormats/NanoAOD/interface/FlatTable.h | 58 +++++++++++-------- DataFormats/NanoAOD/src/FlatTable.cc | 42 +++++++++----- .../interface/SimpleFlatTableProducer.h | 16 ++++- PhysicsTools/NanoAOD/plugins/NanoAODDQM.cc | 24 ++++++-- .../NanoAOD/plugins/TableOutputBranches.cc | 45 +++++++++----- .../NanoAOD/plugins/TableOutputBranches.h | 6 +- 6 files changed, 130 insertions(+), 61 deletions(-) diff --git a/DataFormats/NanoAOD/interface/FlatTable.h b/DataFormats/NanoAOD/interface/FlatTable.h index 8a0638e07cd75..1b2f791c6f9e2 100644 --- a/DataFormats/NanoAOD/interface/FlatTable.h +++ b/DataFormats/NanoAOD/interface/FlatTable.h @@ -38,13 +38,15 @@ namespace nanoaod { class FlatTable { public: enum class ColumnType { - Float, - Int, + Int8, UInt8, - Bool, + Int16, + UInt16, + Int32, UInt32, + Bool, + Float, Double, - Int8 }; // We could have other Float types with reduced mantissa, and similar FlatTable() : size_(0) {} @@ -138,18 +140,22 @@ namespace nanoaod { struct dependent_false : std::false_type {}; template static ColumnType defaultColumnType() { - if constexpr (std::is_same()) - return ColumnType::Float; - else if constexpr (std::is_same()) - return ColumnType::Int; + if constexpr (std::is_same()) + return ColumnType::Int8; else if constexpr (std::is_same()) return ColumnType::UInt8; - else if constexpr (std::is_same()) - return ColumnType::Int8; - else if constexpr (std::is_same()) - return ColumnType::Bool; + else if constexpr (std::is_same()) + return ColumnType::Int16; + else if constexpr (std::is_same()) + return ColumnType::UInt16; + else if constexpr (std::is_same()) + return ColumnType::Int32; else if constexpr (std::is_same()) return ColumnType::UInt32; + else if constexpr (std::is_same()) + return ColumnType::Bool; + else if constexpr (std::is_same()) + return ColumnType::Float; else if constexpr (std::is_same()) return ColumnType::Double; else @@ -188,18 +194,22 @@ namespace nanoaod { template static auto &bigVectorImpl(This &table) { // helper function to avoid code duplication, for the two accessor functions that differ only in const-ness - if constexpr (std::is_same()) - return table.floats_; - else if constexpr (std::is_same()) - return table.ints_; - else if constexpr (std::is_same()) - return table.uint8s_; - else if constexpr (std::is_same()) + if constexpr (std::is_same()) return table.int8s_; - else if constexpr (std::is_same()) + else if constexpr (std::is_same()) return table.uint8s_; + else if constexpr (std::is_same()) + return table.int16s_; + else if constexpr (std::is_same()) + return table.uint16s_; + else if constexpr (std::is_same()) + return table.int32s_; else if constexpr (std::is_same()) return table.uint32s_; + else if constexpr (std::is_same()) + return table.uint8s_; // special case: bool stored as vector of uint8 + else if constexpr (std::is_same()) + return table.floats_; else if constexpr (std::is_same()) return table.doubles_; else @@ -210,11 +220,13 @@ namespace nanoaod { std::string name_, doc_; bool singleton_, extension_; std::vector columns_; - std::vector floats_; - std::vector ints_; - std::vector uint8s_; std::vector int8s_; + std::vector uint8s_; + std::vector int16s_; + std::vector uint16s_; + std::vector int32s_; std::vector uint32s_; + std::vector floats_; std::vector doubles_; }; diff --git a/DataFormats/NanoAOD/src/FlatTable.cc b/DataFormats/NanoAOD/src/FlatTable.cc index 4b8b212c43a44..1565040b86b28 100644 --- a/DataFormats/NanoAOD/src/FlatTable.cc +++ b/DataFormats/NanoAOD/src/FlatTable.cc @@ -13,24 +13,30 @@ void nanoaod::FlatTable::addExtension(const nanoaod::FlatTable& other) { throw cms::Exception("LogicError", "Mismatch in adding extension"); for (unsigned int i = 0, n = other.nColumns(); i < n; ++i) { switch (other.columnType(i)) { - case ColumnType::Float: - addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); - break; - case ColumnType::Int: - addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); - break; case ColumnType::Int8: - addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); - break; - case ColumnType::Bool: - addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); + addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); break; case ColumnType::UInt8: addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); break; + case ColumnType::Int16: + addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); + break; + case ColumnType::UInt16: + addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); + break; + case ColumnType::Int32: + addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); + break; case ColumnType::UInt32: addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); break; + case ColumnType::Bool: + addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); + break; + case ColumnType::Float: + addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); + break; case ColumnType::Double: addColumn(other.columnName(i), other.columnData(i), other.columnDoc(i)); break; @@ -44,18 +50,22 @@ double nanoaod::FlatTable::getAnyValue(unsigned int row, unsigned int column) co if (column >= nColumns()) throw cms::Exception("LogicError", "Invalid column"); switch (columnType(column)) { - case ColumnType::Float: - return *(beginData(column) + row); - case ColumnType::Int: - return *(beginData(column) + row); case ColumnType::Int8: return *(beginData(column) + row); - case ColumnType::Bool: - return *(beginData(column) + row); case ColumnType::UInt8: return *(beginData(column) + row); + case ColumnType::Int16: + return *(beginData(column) + row); + case ColumnType::UInt16: + return *(beginData(column) + row); + case ColumnType::Int32: + return *(beginData(column) + row); case ColumnType::UInt32: return *(beginData(column) + row); + case ColumnType::Bool: + return *(beginData(column) + row); + case ColumnType::Float: + return *(beginData(column) + row); case ColumnType::Double: return *(beginData(column) + row); } diff --git a/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h b/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h index 0446563b610b2..36cc7a79d9c6a 100644 --- a/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h +++ b/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h @@ -135,6 +135,10 @@ class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> { vars_.push_back(std::make_unique(vname, varPSet)); else if (type == "uint8") vars_.push_back(std::make_unique(vname, varPSet)); + else if (type == "int16") + vars_.push_back(std::make_unique(vname, varPSet)); + else if (type == "uint16") + vars_.push_back(std::make_unique(vname, varPSet)); else if (type == "bool") vars_.push_back(std::make_unique(vname, varPSet)); else @@ -203,6 +207,8 @@ class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> { typedef FuncVariable, float> FloatVar; typedef FuncVariable, int8_t> Int8Var; typedef FuncVariable, uint8_t> UInt8Var; + typedef FuncVariable, int8_t> Int16Var; + typedef FuncVariable, uint8_t> UInt16Var; typedef FuncVariable, bool> BoolVar; std::vector>> vars_; }; @@ -236,6 +242,12 @@ class SimpleFlatTableProducer : public SimpleFlatTableProducerBase(vname, varPSet, this->consumesCollector(), this->skipNonExistingSrc_)); + else if (type == "int16") + extvars_.push_back( + std::make_unique(vname, varPSet, this->consumesCollector(), this->skipNonExistingSrc_)); + else if (type == "uint16") + extvars_.push_back( + std::make_unique(vname, varPSet, this->consumesCollector(), this->skipNonExistingSrc_)); else if (type == "bool") extvars_.push_back( std::make_unique(vname, varPSet, this->consumesCollector(), this->skipNonExistingSrc_)); @@ -263,7 +275,7 @@ class SimpleFlatTableProducer : public SimpleFlatTableProducerBase("doc")->setComment("few words description of the branch content"); extvariable.ifValue(edm::ParameterDescription( "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), - edm::allowedValues("int", "unit", "float", "int8", "uint8", "bool")); + edm::allowedValues("int", "unit", "float", "int8", "uint8", "int16", "uint16", "bool")); extvariable.addOptionalNode( edm::ParameterDescription( "precision", true, edm::Comment("the precision with which to store the value in the flat table")) xor @@ -322,6 +334,8 @@ class SimpleFlatTableProducer : public SimpleFlatTableProducerBase BoolExtVar; typedef ValueMapVariable Int8ExtVar; typedef ValueMapVariable UInt8ExtVar; + typedef ValueMapVariable Int16ExtVar; + typedef ValueMapVariable UInt16ExtVar; std::vector>> extvars_; }; diff --git a/PhysicsTools/NanoAOD/plugins/NanoAODDQM.cc b/PhysicsTools/NanoAOD/plugins/NanoAODDQM.cc index 03da48f7ce8f5..796325e9e3499 100644 --- a/PhysicsTools/NanoAOD/plugins/NanoAODDQM.cc +++ b/PhysicsTools/NanoAOD/plugins/NanoAODDQM.cc @@ -97,21 +97,33 @@ class NanoAODDQM : public DQMEDAnalyzer { if (icol == -1) return; // columns may be missing (e.g. mc-only) switch (table.columnType(icol)) { - case FlatTable::ColumnType::Float: - vfill(table, icol, rowsel); - break; - case FlatTable::ColumnType::Int: - vfill(table, icol, rowsel); - break; case FlatTable::ColumnType::Int8: vfill(table, icol, rowsel); break; case FlatTable::ColumnType::UInt8: vfill(table, icol, rowsel); break; + case FlatTable::ColumnType::Int16: + vfill(table, icol, rowsel); + break; + case FlatTable::ColumnType::UInt16: + vfill(table, icol, rowsel); + break; + case FlatTable::ColumnType::Int32: + vfill(table, icol, rowsel); + break; + case FlatTable::ColumnType::UInt32: + vfill(table, icol, rowsel); + break; case FlatTable::ColumnType::Bool: vfill(table, icol, rowsel); break; + case FlatTable::ColumnType::Float: + vfill(table, icol, rowsel); + break; + case FlatTable::ColumnType::Double: + vfill(table, icol, rowsel); + break; default: throw cms::Exception("LogicError", "Unsupported type"); } diff --git a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc index c1bcab3e6cb4c..639628e26fe5a 100644 --- a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc +++ b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc @@ -14,24 +14,30 @@ void TableOutputBranches::defineBranchesFromFirstEvent(const nanoaod::FlatTable for (size_t i = 0; i < tab.nColumns(); i++) { const std::string &var = tab.columnName(i); switch (tab.columnType(i)) { - case nanoaod::FlatTable::ColumnType::Float: - m_floatBranches.emplace_back(var, tab.columnDoc(i), "F"); - break; - case nanoaod::FlatTable::ColumnType::Int: - m_intBranches.emplace_back(var, tab.columnDoc(i), "I"); - break; case nanoaod::FlatTable::ColumnType::Int8: m_int8Branches.emplace_back(var, tab.columnDoc(i), "B"); break; case nanoaod::FlatTable::ColumnType::UInt8: m_uint8Branches.emplace_back(var, tab.columnDoc(i), "b"); break; - case nanoaod::FlatTable::ColumnType::Bool: - m_uint8Branches.emplace_back(var, tab.columnDoc(i), "O"); + case nanoaod::FlatTable::ColumnType::Int16: + m_int16Branches.emplace_back(var, tab.columnDoc(i), "S"); + break; + case nanoaod::FlatTable::ColumnType::UInt16: + m_uint16Branches.emplace_back(var, tab.columnDoc(i), "s"); + break; + case nanoaod::FlatTable::ColumnType::Int32: + m_int32Branches.emplace_back(var, tab.columnDoc(i), "I"); break; case nanoaod::FlatTable::ColumnType::UInt32: m_uint32Branches.emplace_back(var, tab.columnDoc(i), "i"); break; + case nanoaod::FlatTable::ColumnType::Bool: + m_uint8Branches.emplace_back(var, tab.columnDoc(i), "O"); + break; + case nanoaod::FlatTable::ColumnType::Float: + m_floatBranches.emplace_back(var, tab.columnDoc(i), "F"); + break; case nanoaod::FlatTable::ColumnType::Double: m_doubleBranches.emplace_back(var, tab.columnDoc(i), "D"); break; @@ -60,7 +66,16 @@ void TableOutputBranches::branch(TTree &tree) { } std::string varsize = m_singleton ? "" : "[n" + m_baseName + "]"; for (std::vector *branches : - {&m_floatBranches, &m_intBranches, &m_int8Branches, &m_uint8Branches, &m_uint32Branches, &m_doubleBranches}) { + { + &m_int8Branches, + &m_uint8Branches, + &m_int16Branches, + &m_uint16Branches, + &m_int32Branches, + &m_uint32Branches, + &m_floatBranches, + &m_doubleBranches + }) { for (auto &pair : *branches) { std::string branchName = makeBranchName(m_baseName, pair.name); pair.branch = @@ -102,16 +117,20 @@ void TableOutputBranches::fill(const edm::OccurrenceForOutput &iWhatever, TTree "Mismatch in number of entries between extension and main table for " + tab.name()); } } - for (auto &pair : m_floatBranches) - fillColumn(pair, tab); - for (auto &pair : m_intBranches) - fillColumn(pair, tab); for (auto &pair : m_int8Branches) fillColumn(pair, tab); for (auto &pair : m_uint8Branches) fillColumn(pair, tab); + for (auto &pair : m_int16Branches) + fillColumn(pair, tab); + for (auto &pair : m_uint16Branches) + fillColumn(pair, tab); + for (auto &pair : m_int32Branches) + fillColumn(pair, tab); for (auto &pair : m_uint32Branches) fillColumn(pair, tab); + for (auto &pair : m_floatBranches) + fillColumn(pair, tab); for (auto &pair : m_doubleBranches) fillColumn(pair, tab); } diff --git a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.h b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.h index 4a551f83cad73..f610559428781 100644 --- a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.h +++ b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.h @@ -42,11 +42,13 @@ class TableOutputBranches { : name(aname), title(atitle), rootTypeCode(rootType), branch(branchptr) {} }; TBranch *m_counterBranch = nullptr; - std::vector m_floatBranches; - std::vector m_intBranches; std::vector m_int8Branches; std::vector m_uint8Branches; + std::vector m_int16Branches; + std::vector m_uint16Branches; + std::vector m_int32Branches; std::vector m_uint32Branches; + std::vector m_floatBranches; std::vector m_doubleBranches; bool m_branchesBooked; From fe8431eb8eae62a3b1ca738750a5f7fc609311db Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Wed, 7 Dec 2022 20:06:00 +0100 Subject: [PATCH 03/10] update flattable class version --- DataFormats/NanoAOD/src/classes_def.xml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/DataFormats/NanoAOD/src/classes_def.xml b/DataFormats/NanoAOD/src/classes_def.xml index e6c1551b8fc89..582d353813d4d 100644 --- a/DataFormats/NanoAOD/src/classes_def.xml +++ b/DataFormats/NanoAOD/src/classes_def.xml @@ -3,7 +3,8 @@ - + + From 49026ddc236cba30a7ef245d6effe8887d242cb5 Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Thu, 8 Dec 2022 11:07:05 +0100 Subject: [PATCH 04/10] some more types in flat table producer --- .../interface/SimpleFlatTableProducer.h | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h b/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h index 36cc7a79d9c6a..44af0e12cab9c 100644 --- a/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h +++ b/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h @@ -165,7 +165,7 @@ class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> { variable.add("doc")->setComment("few words description of the branch content"); variable.ifValue(edm::ParameterDescription( "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), - edm::allowedValues("int", "unit", "float", "int8", "uint8", "bool")); + edm::allowedValues("int", "uint", "float", "int8", "uint8", "int16", "uint16", "bool")); variable.addOptionalNode( edm::ParameterDescription( "precision", true, edm::Comment("the precision with which to store the value in the flat table")) xor @@ -202,13 +202,13 @@ class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> { const bool skipNonExistingSrc_; const edm::EDGetTokenT src_; - typedef FuncVariable, int> IntVar; - typedef FuncVariable, unsigned int> UIntVar; + typedef FuncVariable, int32_t> IntVar; + typedef FuncVariable, uint32_t> UIntVar; typedef FuncVariable, float> FloatVar; typedef FuncVariable, int8_t> Int8Var; typedef FuncVariable, uint8_t> UInt8Var; - typedef FuncVariable, int8_t> Int16Var; - typedef FuncVariable, uint8_t> UInt16Var; + typedef FuncVariable, int16_t> Int16Var; + typedef FuncVariable, uint16_t> UInt16Var; typedef FuncVariable, bool> BoolVar; std::vector>> vars_; }; @@ -230,6 +230,9 @@ class SimpleFlatTableProducer : public SimpleFlatTableProducerBase(vname, varPSet, this->consumesCollector(), this->skipNonExistingSrc_)); + else if (type == "uint") + extvars_.push_back( + std::make_unique(vname, varPSet, this->consumesCollector(), this->skipNonExistingSrc_)); else if (type == "float") extvars_.push_back( std::make_unique(vname, varPSet, this->consumesCollector(), this->skipNonExistingSrc_)); @@ -275,7 +278,7 @@ class SimpleFlatTableProducer : public SimpleFlatTableProducerBase("doc")->setComment("few words description of the branch content"); extvariable.ifValue(edm::ParameterDescription( "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), - edm::allowedValues("int", "unit", "float", "int8", "uint8", "int16", "uint16", "bool")); + edm::allowedValues("int", "uint", "float", "int8", "uint8", "int16", "uint16", "bool")); extvariable.addOptionalNode( edm::ParameterDescription( "precision", true, edm::Comment("the precision with which to store the value in the flat table")) xor @@ -328,7 +331,8 @@ class SimpleFlatTableProducer : public SimpleFlatTableProducerBase cut_; - typedef ValueMapVariable IntExtVar; + typedef ValueMapVariable IntExtVar; + typedef ValueMapVariable UIntExtVar; typedef ValueMapVariable FloatExtVar; typedef ValueMapVariable DoubleExtVar; typedef ValueMapVariable BoolExtVar; From d5cd2f858d54eda2242d435ba1d11dc4b6666c42 Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Wed, 11 Jan 2023 15:40:58 +0100 Subject: [PATCH 05/10] use 8 or 16 bit integers where relevant --- .../plugins/CandMCMatchTableProducer.cc | 5 +++-- .../plugins/GenJetFlavourTableProducer.cc | 4 ++-- .../plugins/TriggerObjectTableProducer.cc | 8 ++++--- .../NanoAOD/plugins/VertexTableProducer.cc | 8 +++---- .../NanoAOD/python/boostedTaus_cff.py | 6 ++--- PhysicsTools/NanoAOD/python/electrons_cff.py | 20 ++++++++--------- PhysicsTools/NanoAOD/python/fsrPhotons_cff.py | 4 ++-- .../NanoAOD/python/genparticles_cff.py | 4 ++-- PhysicsTools/NanoAOD/python/isotracks_cff.py | 4 ++-- PhysicsTools/NanoAOD/python/jetMC_cff.py | 12 +++++----- .../NanoAOD/python/jetsAK4_CHS_cff.py | 22 +++++++++---------- .../NanoAOD/python/jetsAK4_Puppi_cff.py | 20 ++++++++--------- PhysicsTools/NanoAOD/python/jetsAK8_cff.py | 10 ++++----- .../NanoAOD/python/lowPtElectrons_cff.py | 6 ++--- PhysicsTools/NanoAOD/python/muons_cff.py | 12 +++++----- PhysicsTools/NanoAOD/python/photons_cff.py | 8 +++---- PhysicsTools/NanoAOD/python/protons_cff.py | 4 ++-- PhysicsTools/NanoAOD/python/taus_cff.py | 22 +++++++++---------- 18 files changed, 91 insertions(+), 88 deletions(-) diff --git a/PhysicsTools/NanoAOD/plugins/CandMCMatchTableProducer.cc b/PhysicsTools/NanoAOD/plugins/CandMCMatchTableProducer.cc index 0bf7e9341bea4..510461b6771a8 100644 --- a/PhysicsTools/NanoAOD/plugins/CandMCMatchTableProducer.cc +++ b/PhysicsTools/NanoAOD/plugins/CandMCMatchTableProducer.cc @@ -98,7 +98,8 @@ class CandMCMatchTableProducer : public edm::global::EDProducer<> { iEvent.getByToken(genPartsToken_, genParts); } - std::vector key(ncand, -1), flav(ncand, 0); + std::vector key(ncand, -1); + std::vector flav(ncand, 0); for (unsigned int i = 0; i < ncand; ++i) { //std::cout << "cand #" << i << ": pT = " << cands->ptrAt(i)->pt() << ", eta = " << cands->ptrAt(i)->eta() << ", phi = " << cands->ptrAt(i)->phi() << std::endl; const auto& cand = candProd.ptrAt(i); @@ -192,7 +193,7 @@ class CandMCMatchTableProducer : public edm::global::EDProducer<> { }; } - tab->addColumn(branchName_ + "Idx", key, "Index into genParticle list for " + doc_); + tab->addColumn(branchName_ + "Idx", key, "Index into genParticle list for " + doc_); tab->addColumn(branchName_ + "Flav", flav, "Flavour of genParticle (DressedLeptons for electrons) for " + doc_ + ": " + flavDoc_); diff --git a/PhysicsTools/NanoAOD/plugins/GenJetFlavourTableProducer.cc b/PhysicsTools/NanoAOD/plugins/GenJetFlavourTableProducer.cc index a7c6c53d665f4..c977ea22ec854 100644 --- a/PhysicsTools/NanoAOD/plugins/GenJetFlavourTableProducer.cc +++ b/PhysicsTools/NanoAOD/plugins/GenJetFlavourTableProducer.cc @@ -61,7 +61,7 @@ void GenJetFlavourTableProducer::produce(edm::Event& iEvent, const edm::EventSet const auto& jetFlavourInfosProd = iEvent.get(jetFlavourInfosToken_); unsigned int ncand = 0; - std::vector partonFlavour; + std::vector partonFlavour; std::vector hadronFlavour; for (const reco::GenJet& jet : jetsProd) { @@ -84,7 +84,7 @@ void GenJetFlavourTableProducer::produce(edm::Event& iEvent, const edm::EventSet } auto tab = std::make_unique(ncand, name_, false, true); - tab->addColumn("partonFlavour", partonFlavour, "flavour from parton matching"); + tab->addColumn("partonFlavour", partonFlavour, "flavour from parton matching"); tab->addColumn("hadronFlavour", hadronFlavour, "flavour from hadron ghost clustering"); iEvent.put(std::move(tab)); diff --git a/PhysicsTools/NanoAOD/plugins/TriggerObjectTableProducer.cc b/PhysicsTools/NanoAOD/plugins/TriggerObjectTableProducer.cc index 41113f50f57e4..a352f36fa5472 100644 --- a/PhysicsTools/NanoAOD/plugins/TriggerObjectTableProducer.cc +++ b/PhysicsTools/NanoAOD/plugins/TriggerObjectTableProducer.cc @@ -268,7 +268,9 @@ void TriggerObjectTableProducer::produce(edm::Event &iEvent, const edm::EventSet unsigned int nobj = selected.size(); std::vector pt(nobj, 0), eta(nobj, 0), phi(nobj, 0), l1pt(nobj, 0), l1pt_2(nobj, 0), l2pt(nobj, 0); - std::vector id(nobj, 0), bits(nobj, 0), l1iso(nobj, 0), l1charge(nobj, 0); + std::vector l1charge(nobj, 0); + std::vector id(nobj, 0); + std::vector bits(nobj, 0), l1iso(nobj, 0); for (unsigned int i = 0; i < nobj; ++i) { const auto &obj = *selected[i].first; const auto &sel = *selected[i].second; @@ -314,13 +316,13 @@ void TriggerObjectTableProducer::produce(edm::Event &iEvent, const edm::EventSet } auto tab = std::make_unique(nobj, name_, false, false); - tab->addColumn("id", id, idDoc_); + tab->addColumn("id", id, idDoc_); tab->addColumn("pt", pt, "pt", 12); tab->addColumn("eta", eta, "eta", 12); tab->addColumn("phi", phi, "phi", 12); tab->addColumn("l1pt", l1pt, "pt of associated L1 seed", 8); tab->addColumn("l1iso", l1iso, "iso of associated L1 seed"); - tab->addColumn("l1charge", l1charge, "charge of associated L1 seed"); + tab->addColumn("l1charge", l1charge, "charge of associated L1 seed"); tab->addColumn("l1pt_2", l1pt_2, "pt of associated secondary L1 seed", 8); tab->addColumn("l2pt", l2pt, "pt of associated 'L2' seed (i.e. HLT before tracking/PF)", 10); tab->addColumn("filterBits", bits, "extra bits of associated information: " + bitsDoc_); diff --git a/PhysicsTools/NanoAOD/plugins/VertexTableProducer.cc b/PhysicsTools/NanoAOD/plugins/VertexTableProducer.cc index 4478e4a91fbf3..e79ecf40450c8 100644 --- a/PhysicsTools/NanoAOD/plugins/VertexTableProducer.cc +++ b/PhysicsTools/NanoAOD/plugins/VertexTableProducer.cc @@ -125,8 +125,8 @@ void VertexTableProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSe for (const auto& pv : *pvsIn) if (goodPvCut_(pv)) goodPVs++; - pvTable->addColumnValue("npvs", pvsIn->size(), "total number of reconstructed primary vertices"); - pvTable->addColumnValue( + pvTable->addColumnValue("npvs", pvsIn->size(), "total number of reconstructed primary vertices"); + pvTable->addColumnValue( "npvsGood", goodPVs, "number of good reconstructed primary vertices. selection:" + goodPvCutString_); pvTable->addColumnValue( "score", pvsScoreProd.get(pvsIn.id(), 0), "main primary vertex score, i.e. sum pt2 of clustered objects", 8); @@ -145,7 +145,7 @@ void VertexTableProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSe const auto& svsProd = iEvent.get(svs_); auto selCandSv = std::make_unique>(); std::vector dlen, dlenSig, pAngle, dxy, dxySig; - std::vector charge; + std::vector charge; VertexDistance3D vdist; VertexDistanceXY vdistXY; @@ -187,7 +187,7 @@ void VertexTableProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSe svsTable->addColumn("dxy", dxy, "2D decay length in cm", 10); svsTable->addColumn("dxySig", dxySig, "2D decay length significance", 10); svsTable->addColumn("pAngle", pAngle, "pointing angle, i.e. acos(p_SV * (SV - PV)) ", 10); - svsTable->addColumn("charge", charge, "sum of the charge of the SV tracks", 10); + svsTable->addColumn("charge", charge, "sum of the charge of the SV tracks", 10); iEvent.put(std::move(pvTable), "pv"); iEvent.put(std::move(otherPVsTable), "otherPVs"); diff --git a/PhysicsTools/NanoAOD/python/boostedTaus_cff.py b/PhysicsTools/NanoAOD/python/boostedTaus_cff.py index 409c028082026..ee56b4936c5cc 100644 --- a/PhysicsTools/NanoAOD/python/boostedTaus_cff.py +++ b/PhysicsTools/NanoAOD/python/boostedTaus_cff.py @@ -26,7 +26,7 @@ ) _boostedTauVarsBase = cms.PSet(P4Vars, charge = Var("charge", int, doc="electric charge"), - jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", int, doc="index of the associated jet (-1 if none)"), + jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", "uint16", doc="index of the associated jet (-1 if none)"), decayMode = Var("decayMode()",int), leadTkPtOverTauPt = Var("leadChargedHadrCand.pt/pt ",float, doc="pt of the leading track divided by tau pt",precision=10), leadTkDeltaEta = Var("leadChargedHadrCand.eta - eta ",float, doc="eta of the leading track, minus tau eta",precision=8), @@ -55,7 +55,7 @@ #AntiEle MVA 2018 variables _boostedTauVarsAntiEleMVA = cms.PSet( rawAntiEle2018 = Var("tauID('againstElectronMVA6Raw')", float, doc= "Anti-electron MVA discriminator V6 raw output discriminator (2018)", precision=10), - rawAntiEleCat2018 = Var("tauID('againstElectronMVA6category')", int, doc="Anti-electron MVA discriminator V6 category (2018)"), + rawAntiEleCat2018 = Var("tauID('againstElectronMVA6category')", "int8", doc="Anti-electron MVA discriminator V6 category (2018)"), idAntiEle2018 = _tauIdWPMask("againstElectron%sMVA6", choices=("VLoose","Loose","Medium","Tight","VTight"), doc= "Anti-electron MVA discriminator V6 (2018)") ) @@ -80,7 +80,7 @@ idMVAnewDM2017v2 = _tauIdWPMask("by%sIsolationMVArun2017v2DBnewDMwLT2017", choices=("VVLoose","VLoose","Loose","Medium","Tight","VTight","VVTight"),doc="IsolationMVArun2DBnewDMwLT ID working point (2017v2)"), idMVAoldDM2017v2 = _tauIdWPMask("by%sIsolationMVArun2017v2DBoldDMwLT2017",choices=("VVLoose","VLoose","Loose","Medium","Tight","VTight","VVTight"),doc="IsolationMVArun2DBoldDMwLT ID working point (2017v2)"), rawAntiEle2018 = Var("tauID('againstElectronMVA6Raw2018')", float, doc= "Anti-electron MVA discriminator V6 raw output discriminator (2018)", precision=10), - rawAntiEleCat2018 = Var("tauID('againstElectronMVA6category2018')", int, doc="Anti-electron MVA discriminator V6 category (2018)"), + rawAntiEleCat2018 = Var("tauID('againstElectronMVA6category2018')", "int8", doc="Anti-electron MVA discriminator V6 category (2018)"), idAntiEle2018 = _tauIdWPMask("againstElectron%sMVA62018", choices=("VLoose","Loose","Medium","Tight","VTight"), doc= "Anti-electron MVA discriminator V6 (2018)") ) diff --git a/PhysicsTools/NanoAOD/python/electrons_cff.py b/PhysicsTools/NanoAOD/python/electrons_cff.py index 8ad7d28c917ba..de8390b0e2298 100644 --- a/PhysicsTools/NanoAOD/python/electrons_cff.py +++ b/PhysicsTools/NanoAOD/python/electrons_cff.py @@ -294,9 +294,9 @@ def _get_bitmapVIDForEle_docstring(modules,WorkingPoints): name= cms.string("Electron"), doc = cms.string("slimmedElectrons after basic selection (" + finalElectrons.cut.value()+")"), variables = cms.PSet(CandVars, - jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", int, doc="index of the associated jet (-1 if none)"), - photonIdx = Var("?overlaps('photons').size()>0?overlaps('photons')[0].key():-1", int, doc="index of the first associated photon (-1 if none)"), - svIdx = Var("?hasUserCand('vertex')?userCand('vertex').key():-1", int, doc="index of matching secondary vertex"), + jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", "int16", doc="index of the associated jet (-1 if none)"), + photonIdx = Var("?overlaps('photons').size()>0?overlaps('photons')[0].key():-1", "int16", doc="index of the first associated photon (-1 if none)"), + svIdx = Var("?hasUserCand('vertex')?userCand('vertex').key():-1", "int16", doc="index of matching secondary vertex"), energyErr = Var("p4Error('P4_COMBINATION')",float,doc="energy error of the cluster-track combination",precision=6), dz = Var("dB('PVDZ')",float,doc="dz (with sign) wrt first PV, in cm",precision=10), dzErr = Var("abs(edB('PVDZ'))",float,doc="dz uncertainty, in cm",precision=6), @@ -326,11 +326,11 @@ def _get_bitmapVIDForEle_docstring(modules,WorkingPoints): mvaNoIso_Fall17V2_WPL = Var("userInt('mvaNoIso_Fall17V2_WPL')",bool,doc="MVA noIso ID loose WP, Fall17V2"), mvaHZZIso = Var("userFloat('mvaHZZIso')", float,doc="HZZ MVA Iso ID score"), - cutBased = Var("userInt('cutBasedID_veto')+userInt('cutBasedID_loose')+userInt('cutBasedID_medium')+userInt('cutBasedID_tight')",int,doc="cut-based ID RunIII Winter22 (0:fail, 1:veto, 2:loose, 3:medium, 4:tight)"), - cutBased_Fall17V2 = Var("userInt('cutBasedID_Fall17V2_veto')+userInt('cutBasedID_Fall17V2_loose')+userInt('cutBasedID_Fall17V2_medium')+userInt('cutBasedID_Fall17V2_tight')",int,doc="cut-based ID Fall17V2 (0:fail, 1:veto, 2:loose, 3:medium, 4:tight)"), - vidNestedWPBitmap = Var("userInt('VIDNestedWPBitmap')",int,doc=_bitmapVIDForEle_docstring), - vidNestedWPBitmap_Fall17V2 = Var("userInt('VIDNestedWPBitmap_Fall17V2')",int,doc=_bitmapVIDForEleFall17V2_docstring), - vidNestedWPBitmapHEEP = Var("userInt('VIDNestedWPBitmapHEEP')",int,doc=_bitmapVIDForEleHEEP_docstring), + cutBased = Var("userInt('cutBasedID_veto')+userInt('cutBasedID_loose')+userInt('cutBasedID_medium')+userInt('cutBasedID_tight')", "uint8", doc="cut-based ID RunIII Winter22 (0:fail, 1:veto, 2:loose, 3:medium, 4:tight)"), + cutBased_Fall17V2 = Var("userInt('cutBasedID_Fall17V2_veto')+userInt('cutBasedID_Fall17V2_loose')+userInt('cutBasedID_Fall17V2_medium')+userInt('cutBasedID_Fall17V2_tight')", "uint8", doc="cut-based ID Fall17V2 (0:fail, 1:veto, 2:loose, 3:medium, 4:tight)"), + vidNestedWPBitmap = Var("userInt('VIDNestedWPBitmap')", int, doc=_bitmapVIDForEle_docstring), + vidNestedWPBitmap_Fall17V2 = Var("userInt('VIDNestedWPBitmap_Fall17V2')", int, doc=_bitmapVIDForEleFall17V2_docstring), + vidNestedWPBitmapHEEP = Var("userInt('VIDNestedWPBitmapHEEP')", int, doc=_bitmapVIDForEleHEEP_docstring), cutBased_HEEP = Var("userInt('cutBasedID_HEEP')",bool,doc="cut-based HEEP ID"), miniPFRelIso_chg = Var("userFloat('miniIsoChg')/pt",float,doc="mini PF relative isolation, charged component"), miniPFRelIso_all = Var("userFloat('miniIsoAll')/pt",float,doc="mini PF relative isolation, total (with scaled rho*EA PU Winter22V1 corrections)"), @@ -348,7 +348,7 @@ def _get_bitmapVIDForEle_docstring(modules,WorkingPoints): dr03EcalRecHitSumEt = Var("?pt>35?dr03EcalRecHitSumEt():0",float,doc="Non-PF Ecal isolation within a delta R cone of 0.3 with electron pt > 35 GeV",precision=8), dr03HcalDepth1TowerSumEt = Var("?pt>35?dr03HcalTowerSumEt(1):0",float,doc="Non-PF Hcal isolation within a delta R cone of 0.3 with electron pt > 35 GeV",precision=8), hoe = Var("hadronicOverEm()",float,doc="H over E",precision=8), - tightCharge = Var("isGsfCtfScPixChargeConsistent() + isGsfScPixChargeConsistent()",int,doc="Tight charge criteria (0:none, 1:isGsfScPixChargeConsistent, 2:isGsfCtfScPixChargeConsistent)"), + tightCharge = Var("isGsfCtfScPixChargeConsistent() + isGsfScPixChargeConsistent()", "uint8", doc="Tight charge criteria (0:none, 1:isGsfScPixChargeConsistent, 2:isGsfCtfScPixChargeConsistent)"), convVeto = Var("passConversionVeto()",bool,doc="pass conversion veto"), lostHits = Var("gsfTrack.hitPattern.numberOfLostHits('MISSING_INNER_HITS')","uint8",doc="number of missing inner hits"), isPFcand = Var("pfCandidateRef().isNonnull()",bool,doc="electron is PF candidate"), @@ -357,7 +357,7 @@ def _get_bitmapVIDForEle_docstring(modules,WorkingPoints): ), externalVariables = cms.PSet( mvaTTH = ExtVar(cms.InputTag("electronMVATTH"),float, doc="TTH MVA lepton ID score",precision=14), - fsrPhotonIdx = ExtVar(cms.InputTag("leptonFSRphotons:eleFsrIndex"),int, doc="Index of the lowest-dR/ET2 among associated FSR photons"), + fsrPhotonIdx = ExtVar(cms.InputTag("leptonFSRphotons:eleFsrIndex"), "int16", doc="Index of the lowest-dR/ET2 among associated FSR photons"), ), ) diff --git a/PhysicsTools/NanoAOD/python/fsrPhotons_cff.py b/PhysicsTools/NanoAOD/python/fsrPhotons_cff.py index c8b07447d9c4f..dc30306db1dbd 100644 --- a/PhysicsTools/NanoAOD/python/fsrPhotons_cff.py +++ b/PhysicsTools/NanoAOD/python/fsrPhotons_cff.py @@ -17,8 +17,8 @@ variables = cms.PSet(P3Vars, relIso03 = Var("userFloat('relIso03')",float,doc="relative isolation in a 0.3 cone without CHS"), dROverEt2 = Var("userFloat('dROverEt2')",float,doc="deltaR to associated muon divided by photon et2"), - muonIdx = Var("?hasUserCand('associatedMuon')?userCand('associatedMuon').key():-1",int, doc="index of associated muon"), - electronIdx = Var("?hasUserCand('associatedElectron')?userCand('associatedElectron').key():-1",int, doc="index of associated electron") + muonIdx = Var("?hasUserCand('associatedMuon')?userCand('associatedMuon').key():-1", "int16", doc="index of associated muon"), + electronIdx = Var("?hasUserCand('associatedElectron')?userCand('associatedElectron').key():-1", "int16", doc="index of associated electron") ) ) diff --git a/PhysicsTools/NanoAOD/python/genparticles_cff.py b/PhysicsTools/NanoAOD/python/genparticles_cff.py index d3b0533db15bb..c4423a42c61f3 100644 --- a/PhysicsTools/NanoAOD/python/genparticles_cff.py +++ b/PhysicsTools/NanoAOD/python/genparticles_cff.py @@ -40,7 +40,7 @@ mass = Var("?!((abs(pdgId)>=1 && abs(pdgId)<=5) || (abs(pdgId)>=11 && abs(pdgId)<=16) || pdgId==21 || pdgId==111 || abs(pdgId)==211 || abs(pdgId)==421 || abs(pdgId)==411 || (pdgId==22 && mass<1))?mass:0", float,precision="?((abs(pdgId)==6 || abs(pdgId)>1000000) && statusFlags().isLastCopy())?20:8",doc="Mass stored for all particles with the exception of quarks (except top), leptons/neutrinos, photons with mass < 1 GeV, gluons, pi0(111), pi+(211), D0(421), and D+(411). For these particles, you can lookup the value from PDG."), pdgId = Var("pdgId", int, doc="PDG id"), status = Var("status", int, doc="Particle status. 1=stable"), - genPartIdxMother = Var("?numberOfMothers>0?motherRef(0).key():-1", int, doc="index of the mother particle"), + genPartIdxMother = Var("?numberOfMothers>0?motherRef(0).key():-1", "int16", doc="index of the mother particle"), statusFlags = (Var( "statusFlags().isLastCopyBeforeFSR() * 16384 +" "statusFlags().isLastCopy() * 8192 +" @@ -57,7 +57,7 @@ "statusFlags().isTauDecayProduct() * 4 +" "statusFlags().isDecayedLeptonHadron() * 2 +" "statusFlags().isPrompt() * 1 ", - int, doc=("gen status flags stored bitwise, bits are: " + "uint8", doc=("gen status flags stored bitwise, bits are: " "0 : isPrompt, " "1 : isDecayedLeptonHadron, " "2 : isTauDecayProduct, " diff --git a/PhysicsTools/NanoAOD/python/isotracks_cff.py b/PhysicsTools/NanoAOD/python/isotracks_cff.py index 76553de6c0c77..f043527fcca76 100644 --- a/PhysicsTools/NanoAOD/python/isotracks_cff.py +++ b/PhysicsTools/NanoAOD/python/isotracks_cff.py @@ -33,10 +33,10 @@ pfRelIso03_chg = Var("pfIsolationDR03().chargedHadronIso/pt",float,doc="PF relative isolation dR=0.3, charged component",precision=10), pfRelIso03_all = Var("(pfIsolationDR03().chargedHadronIso + max(pfIsolationDR03().neutralHadronIso + pfIsolationDR03().photonIso - pfIsolationDR03().puChargedHadronIso/2,0.0))/pt",float,doc="PF relative isolation dR=0.3, total (deltaBeta corrections)",precision=10), isPFcand = Var("packedCandRef().isNonnull()",bool,doc="if isolated track is a PF candidate"), - fromPV = Var("fromPV", int, doc="isolated track comes from PV"), + fromPV = Var("fromPV", "int16", doc="isolated track comes from PV"), pdgId = Var("pdgId",int,doc="PDG id of PF cand"), isHighPurityTrack = Var("isHighPurityTrack",bool,doc="track is high purity"), - charge = Var("charge", int, doc="electric charge"), + charge = Var("charge", "int16", doc="electric charge"), ), externalVariables = cms.PSet( miniPFRelIso_chg = ExtVar("isoForIsoTk:miniIsoChg",float,doc="mini PF relative isolation, charged component",precision=10), diff --git a/PhysicsTools/NanoAOD/python/jetMC_cff.py b/PhysicsTools/NanoAOD/python/jetMC_cff.py index c9fb130ac1e66..736b68afb6850 100644 --- a/PhysicsTools/NanoAOD/python/jetMC_cff.py +++ b/PhysicsTools/NanoAOD/python/jetMC_cff.py @@ -10,9 +10,9 @@ name = cms.string("Jet"), extension = cms.bool(True), # this is an extension table for the jets variables = cms.PSet( - partonFlavour = Var("partonFlavour()", int, doc="flavour from parton matching"), - hadronFlavour = Var("hadronFlavour()", int, doc="flavour from hadron ghost clustering"), - genJetIdx = Var("?genJetFwdRef().backRef().isNonnull()?genJetFwdRef().backRef().key():-1", int, doc="index of matched gen jet"), + partonFlavour = Var("partonFlavour()", "int16", doc="flavour from parton matching"), + hadronFlavour = Var("hadronFlavour()", "uint8", doc="flavour from hadron ghost clustering"), + genJetIdx = Var("?genJetFwdRef().backRef().isNonnull()?genJetFwdRef().backRef().key():-1", "int16", doc="index of matched gen jet"), ) ) genJetTable = simpleCandidateFlatTableProducer.clone( @@ -89,8 +89,8 @@ variables = cms.PSet( nBHadrons = Var("jetFlavourInfo().getbHadrons().size()", "uint8", doc="number of b-hadrons"), nCHadrons = Var("jetFlavourInfo().getcHadrons().size()", "uint8", doc="number of c-hadrons"), - hadronFlavour = Var("hadronFlavour()", int, doc="flavour from hadron ghost clustering"), - genJetAK8Idx = Var("?genJetFwdRef().backRef().isNonnull() && genJetFwdRef().backRef().pt() > 100.?genJetFwdRef().backRef().key():-1", int, doc="index of matched gen AK8 jet"), + hadronFlavour = Var("hadronFlavour()", "uint8", doc="flavour from hadron ghost clustering"), + genJetAK8Idx = Var("?genJetFwdRef().backRef().isNonnull() && genJetFwdRef().backRef().pt() > 100.?genJetFwdRef().backRef().key():-1", "int16", doc="index of matched gen AK8 jet"), ) ) @@ -110,7 +110,7 @@ variables = cms.PSet( nBHadrons = Var("jetFlavourInfo().getbHadrons().size()", "uint8", doc="number of b-hadrons"), nCHadrons = Var("jetFlavourInfo().getcHadrons().size()", "uint8", doc="number of c-hadrons"), - hadronFlavour = Var("hadronFlavour()", int, doc="flavour from hadron ghost clustering"), + hadronFlavour = Var("hadronFlavour()", "uint8", doc="flavour from hadron ghost clustering"), ) ) diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index 6c2dd9195438b..cf81c8c02c157 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -113,15 +113,15 @@ ), variables = cms.PSet(P4Vars, area = Var("jetArea()", float, doc="jet catchment area, for JECs",precision=10), - nMuons = Var("?hasOverlaps('muons')?overlaps('muons').size():0", int, doc="number of muons in the jet"), - muonIdx1 = Var("?overlaps('muons').size()>0?overlaps('muons')[0].key():-1", int, doc="index of first matching muon"), - muonIdx2 = Var("?overlaps('muons').size()>1?overlaps('muons')[1].key():-1", int, doc="index of second matching muon"), - electronIdx1 = Var("?overlaps('electrons').size()>0?overlaps('electrons')[0].key():-1", int, doc="index of first matching electron"), - electronIdx2 = Var("?overlaps('electrons').size()>1?overlaps('electrons')[1].key():-1", int, doc="index of second matching electron"), - nElectrons = Var("?hasOverlaps('electrons')?overlaps('electrons').size():0", int, doc="number of electrons in the jet"), - svIdx1 = Var("?overlaps('vertices').size()>0?overlaps('vertices')[0].key():-1", int, doc="index of first matching secondary vertex"), - svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", int, doc="index of second matching secondary vertex"), - nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", int, doc="number of secondary vertices in the jet"), + nMuons = Var("?hasOverlaps('muons')?overlaps('muons').size():0", "uint8", doc="number of muons in the jet"), + muonIdx1 = Var("?overlaps('muons').size()>0?overlaps('muons')[0].key():-1", "int16", doc="index of first matching muon"), + muonIdx2 = Var("?overlaps('muons').size()>1?overlaps('muons')[1].key():-1", "int16", doc="index of second matching muon"), + electronIdx1 = Var("?overlaps('electrons').size()>0?overlaps('electrons')[0].key():-1", "int16", doc="index of first matching electron"), + electronIdx2 = Var("?overlaps('electrons').size()>1?overlaps('electrons')[1].key():-1", "int16", doc="index of second matching electron"), + nElectrons = Var("?hasOverlaps('electrons')?overlaps('electrons').size():0", "uint8", doc="number of electrons in the jet"), + svIdx1 = Var("?overlaps('vertices').size()>0?overlaps('vertices')[0].key():-1", "int16", doc="index of first matching secondary vertex"), + svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", "int16", doc="index of second matching secondary vertex"), + nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", "uint8", doc="number of secondary vertices in the jet"), btagDeepB = Var("?(bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), btagDeepFlavB = Var("bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10), @@ -131,8 +131,8 @@ btagDeepFlavCvB = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), puIdDisc = Var("userFloat('puIdNanoDisc')", float,doc="Pileup ID discriminant with 106X (2018) training",precision=10), - puId = Var("userInt('puIdNanoId')", int,doc="Pileup ID flags with 106X (2018) training"), - jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')",int,doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"), + puId = Var("userInt('puIdNanoId')", "uint8", doc="Pileup ID flags with 106X (2018) training"), + jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8", doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"), qgl = Var("?userFloat('qgl')>0?userFloat('qgl'):-1",float,doc="Quark vs Gluon likelihood discriminator",precision=10), hfsigmaEtaEta = Var("userFloat('hfJetShowerShape:sigmaEtaEta')",float,doc="sigmaEtaEta for HF jets (noise discriminating variable)",precision=10), hfsigmaPhiPhi = Var("userFloat('hfJetShowerShape:sigmaPhiPhi')",float,doc="sigmaPhiPhi for HF jets (noise discriminating variable)",precision=10), diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index 41dce3c9a7c36..a206194a8a30f 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -71,15 +71,15 @@ externalVariables = cms.PSet(), variables = cms.PSet(P4Vars, area = Var("jetArea()", float, doc="jet catchment area, for JECs",precision=10), - nMuons = Var("?hasOverlaps('muons')?overlaps('muons').size():0", int, doc="number of muons in the jet"), - muonIdx1 = Var("?overlaps('muons').size()>0?overlaps('muons')[0].key():-1", int, doc="index of first matching muon"), - muonIdx2 = Var("?overlaps('muons').size()>1?overlaps('muons')[1].key():-1", int, doc="index of second matching muon"), - electronIdx1 = Var("?overlaps('electrons').size()>0?overlaps('electrons')[0].key():-1", int, doc="index of first matching electron"), - electronIdx2 = Var("?overlaps('electrons').size()>1?overlaps('electrons')[1].key():-1", int, doc="index of second matching electron"), - nElectrons = Var("?hasOverlaps('electrons')?overlaps('electrons').size():0", int, doc="number of electrons in the jet"), - svIdx1 = Var("?overlaps('vertices').size()>0?overlaps('vertices')[0].key():-1", int, doc="index of first matching secondary vertex"), - svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", int, doc="index of second matching secondary vertex"), - nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", int, doc="number of secondary vertices in the jet"), + nMuons = Var("?hasOverlaps('muons')?overlaps('muons').size():0", "uint8", doc="number of muons in the jet"), + muonIdx1 = Var("?overlaps('muons').size()>0?overlaps('muons')[0].key():-1", "int16", doc="index of first matching muon"), + muonIdx2 = Var("?overlaps('muons').size()>1?overlaps('muons')[1].key():-1", "int16", doc="index of second matching muon"), + electronIdx1 = Var("?overlaps('electrons').size()>0?overlaps('electrons')[0].key():-1", "int16", doc="index of first matching electron"), + electronIdx2 = Var("?overlaps('electrons').size()>1?overlaps('electrons')[1].key():-1", "int16", doc="index of second matching electron"), + nElectrons = Var("?hasOverlaps('electrons')?overlaps('electrons').size():0", "uint8", doc="number of electrons in the jet"), + svIdx1 = Var("?overlaps('vertices').size()>0?overlaps('vertices')[0].key():-1", "int16", doc="index of first matching secondary vertex"), + svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", "int16", doc="index of second matching secondary vertex"), + nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", "uint8", doc="number of secondary vertices in the jet"), btagDeepB = Var("?(bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'))>=0?bDiscriminator('pfDeepCSVJetTags:probb')+bDiscriminator('pfDeepCSVJetTags:probbb'):-1",float,doc="DeepCSV b+bb tag discriminator",precision=10), btagDeepFlavB = Var("bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), btagCSVV2 = Var("bDiscriminator('pfCombinedInclusiveSecondaryVertexV2BJetTags')",float,doc=" pfCombinedInclusiveSecondaryVertexV2 b-tag discriminator (aka CSVV2)",precision=10), @@ -88,7 +88,7 @@ btagDeepFlavCvL = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), btagDeepFlavCvB = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), - jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')",int,doc="Jet ID flag: bit2 is tight, bit3 is tightLepVeto"), + jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8",doc="Jet ID flag: bit2 is tight, bit3 is tightLepVeto"), hfsigmaEtaEta = Var("userFloat('hfsigmaEtaEta')",float,doc="sigmaEtaEta for HF jets (noise discriminating variable)",precision=10), hfsigmaPhiPhi = Var("userFloat('hfsigmaPhiPhi')",float,doc="sigmaPhiPhi for HF jets (noise discriminating variable)",precision=10), hfcentralEtaStripSize = Var("userInt('hfcentralEtaStripSize')", int, doc="eta size of the central tower strip in HF (noise discriminating variable)"), diff --git a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py index c97b6c4f68203..9331b076c0074 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK8_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK8_cff.py @@ -81,7 +81,7 @@ name = cms.string("FatJet"), doc = cms.string("slimmedJetsAK8, i.e. ak8 fat jets for boosted analysis"), variables = cms.PSet(P4Vars, - jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')",int,doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"), + jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8",doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"), area = Var("jetArea()", float, doc="jet catchment area, for JECs",precision=10), rawFactor = Var("1.-jecFactor('Uncorrected')",float,doc="1 - Factor to get back to raw pT",precision=6), tau1 = Var("userFloat('NjettinessAK8Puppi:tau1')",float, doc="Nsubjettiness (1 axis)",precision=10), @@ -125,16 +125,16 @@ particleNetMD_Xcc = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probXcc')",float,doc="Mass-decorrelated ParticleNet tagger raw X->cc score. For X->cc vs QCD tagging, use Xcc/(Xcc+QCD)",precision=10), particleNetMD_Xqq = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probXqq')",float,doc="Mass-decorrelated ParticleNet tagger raw X->qq (uds) score. For X->qq vs QCD tagging, use Xqq/(Xqq+QCD). For W vs QCD tagging, use (Xcc+Xqq)/(Xcc+Xqq+QCD)",precision=10), particleNetMD_QCD = Var("bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDbb')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDcc')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDb')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDc')+bDiscriminator('pfMassDecorrelatedParticleNetJetTags:probQCDothers')",float,doc="Mass-decorrelated ParticleNet tagger raw QCD score",precision=10), - subJetIdx1 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>0?subjets('SoftDropPuppi')[0].key():-1", int, + subJetIdx1 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>0?subjets('SoftDropPuppi')[0].key():-1", "int16", doc="index of first subjet"), - subJetIdx2 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>1?subjets('SoftDropPuppi')[1].key():-1", int, + subJetIdx2 = Var("?nSubjetCollections()>0 && subjets('SoftDropPuppi').size()>1?subjets('SoftDropPuppi')[1].key():-1", "int16", doc="index of second subjet"), nConstituents = Var("numberOfDaughters()","uint8",doc="Number of particles in the jet"), ), externalVariables = cms.PSet( lsf3 = ExtVar(cms.InputTag("lepInAK8JetVars:lsf3"),float, doc="Lepton Subjet Fraction (3 subjets)",precision=10), - muonIdx3SJ = ExtVar(cms.InputTag("lepInAK8JetVars:muIdx3SJ"),int, doc="index of muon matched to jet"), - electronIdx3SJ = ExtVar(cms.InputTag("lepInAK8JetVars:eleIdx3SJ"),int,doc="index of electron matched to jet"), + muonIdx3SJ = ExtVar(cms.InputTag("lepInAK8JetVars:muIdx3SJ"),"int16", doc="index of muon matched to jet"), + electronIdx3SJ = ExtVar(cms.InputTag("lepInAK8JetVars:eleIdx3SJ"),"int16",doc="index of electron matched to jet"), ) ) diff --git a/PhysicsTools/NanoAOD/python/lowPtElectrons_cff.py b/PhysicsTools/NanoAOD/python/lowPtElectrons_cff.py index c6dc53ac78175..76d72f5e8410d 100644 --- a/PhysicsTools/NanoAOD/python/lowPtElectrons_cff.py +++ b/PhysicsTools/NanoAOD/python/lowPtElectrons_cff.py @@ -68,8 +68,8 @@ # Basic variables CandVars, # Overlaps with PF electron and photon - electronIdx = Var("?overlaps('electrons').size()>0?overlaps('electrons')[0].key():-1", int, doc="index of the overlapping PF electron (-1 if none)"), - photonIdx = Var("?overlaps('photons').size()>0?overlaps('photons')[0].key():-1", int, doc="index of the first associated photon (-1 if none)"), + electronIdx = Var("?overlaps('electrons').size()>0?overlaps('electrons')[0].key():-1", "int16", doc="index of the overlapping PF electron (-1 if none)"), + photonIdx = Var("?overlaps('photons').size()>0?overlaps('photons')[0].key():-1", "int16", doc="index of the first associated photon (-1 if none)"), # BDT scores and WPs ID = Var("electronID('ID')",float,doc="ID, BDT (raw) score"), unbiased = Var("electronID('unbiased')",float,doc="ElectronSeed, pT- and dxy- agnostic BDT (raw) score"), @@ -82,7 +82,7 @@ # Conversions convVeto = Var("passConversionVeto()",bool,doc="pass conversion veto"), convWP = Var("userInt('convOpen')*1 + userInt('convLoose')*2 + userInt('convTight')*4", - int,doc="conversion flag bit map: 1=Veto, 2=Loose, 3=Tight"), + "uint8", doc="conversion flag bit map: 1=Veto, 2=Loose, 3=Tight"), convVtxRadius = Var("userFloat('convVtxRadius')",float,doc="conversion vertex radius (cm)",precision=7), # Tracking lostHits = Var("gsfTrack.hitPattern.numberOfLostHits('MISSING_INNER_HITS')","uint8",doc="number of missing inner hits"), diff --git a/PhysicsTools/NanoAOD/python/muons_cff.py b/PhysicsTools/NanoAOD/python/muons_cff.py index 28ae0184feeac..23cfb633c79a4 100644 --- a/PhysicsTools/NanoAOD/python/muons_cff.py +++ b/PhysicsTools/NanoAOD/python/muons_cff.py @@ -134,11 +134,11 @@ ip3d = Var("abs(dB('PV3D'))",float,doc="3D impact parameter wrt first PV, in cm",precision=10), sip3d = Var("abs(dB('PV3D')/edB('PV3D'))",float,doc="3D impact parameter significance wrt first PV",precision=10), segmentComp = Var("segmentCompatibility()", float, doc = "muon segment compatibility", precision=14), # keep higher precision since people have cuts with 3 digits on this - nStations = Var("numberOfMatchedStations", int, doc = "number of matched stations with default arbitration (segment & track)"), - nTrackerLayers = Var("?track.isNonnull?innerTrack().hitPattern().trackerLayersWithMeasurement():0", int, doc = "number of layers in the tracker"), + nStations = Var("numberOfMatchedStations", "uint8", doc = "number of matched stations with default arbitration (segment & track)"), + nTrackerLayers = Var("?track.isNonnull?innerTrack().hitPattern().trackerLayersWithMeasurement():0", "uint8", doc = "number of layers in the tracker"), highPurity = Var("?track.isNonnull?innerTrack().quality('highPurity'):0", bool, doc = "inner track is high purity"), - jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", int, doc="index of the associated jet (-1 if none)"), - svIdx = Var("?hasUserCand('vertex')?userCand('vertex').key():-1", int, doc="index of matching secondary vertex"), + jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", "int16", doc="index of the associated jet (-1 if none)"), + svIdx = Var("?hasUserCand('vertex')?userCand('vertex').key():-1", "int16", doc="index of matching secondary vertex"), tkRelIso = Var("isolationR03().sumPt/tunePMuonBestTrack().pt",float,doc="Tracker-based relative isolation dR=0.3 for highPt, trkIso/tunePpt",precision=6), miniPFRelIso_chg = Var("userFloat('miniIsoChg')/pt",float,doc="mini PF relative isolation, charged component"), miniPFRelIso_all = Var("userFloat('miniIsoAll')/pt",float,doc="mini PF relative isolation, total (with scaled rho*EA PU corrections)"), @@ -147,7 +147,7 @@ pfRelIso04_all = Var("(pfIsolationR04().sumChargedHadronPt + max(pfIsolationR04().sumNeutralHadronEt + pfIsolationR04().sumPhotonEt - pfIsolationR04().sumPUPt/2,0.0))/pt",float,doc="PF relative isolation dR=0.4, total (deltaBeta corrections)"), jetRelIso = Var("?userCand('jetForLepJetVar').isNonnull()?(1./userFloat('ptRatio'))-1.:(pfIsolationR04().sumChargedHadronPt + max(pfIsolationR04().sumNeutralHadronEt + pfIsolationR04().sumPhotonEt - pfIsolationR04().sumPUPt/2,0.0))/pt",float,doc="Relative isolation in matched jet (1/ptRatio-1, pfRelIso04_all if no matched jet)",precision=8), jetPtRelv2 = Var("?userCand('jetForLepJetVar').isNonnull()?userFloat('ptRel'):0",float,doc="Relative momentum of the lepton with respect to the closest jet after subtracting the lepton",precision=8), - tightCharge = Var("?(muonBestTrack().ptError()/muonBestTrack().pt() < 0.2)?2:0",int,doc="Tight charge criterion using pterr/pt of muonBestTrack (0:fail, 2:pass)"), + tightCharge = Var("?(muonBestTrack().ptError()/muonBestTrack().pt() < 0.2)?2:0", "uint8", doc="Tight charge criterion using pterr/pt of muonBestTrack (0:fail, 2:pass)"), looseId = Var("passed('CutBasedIdLoose')",bool, doc="muon is loose muon"), isPFcand = Var("isPFMuon",bool,doc="muon is PF candidate"), isGlobal = Var("isGlobalMuon",bool,doc="muon is global muon"), @@ -176,7 +176,7 @@ externalVariables = cms.PSet( mvaTTH = ExtVar(cms.InputTag("muonMVATTH"),float, doc="TTH MVA lepton ID score",precision=14), mvaLowPt = ExtVar(cms.InputTag("muonMVALowPt"),float, doc="Low pt muon ID score",precision=14), - fsrPhotonIdx = ExtVar(cms.InputTag("leptonFSRphotons:muFsrIndex"),int, doc="Index of the lowest-dR/ET2 among associated FSR photons"), + fsrPhotonIdx = ExtVar(cms.InputTag("leptonFSRphotons:muFsrIndex"), "int16", doc="Index of the lowest-dR/ET2 among associated FSR photons"), ), ) diff --git a/PhysicsTools/NanoAOD/python/photons_cff.py b/PhysicsTools/NanoAOD/python/photons_cff.py index ac261304f2906..54c6a6e31d5a2 100644 --- a/PhysicsTools/NanoAOD/python/photons_cff.py +++ b/PhysicsTools/NanoAOD/python/photons_cff.py @@ -188,8 +188,8 @@ def make_bitmapVID_docstring(id_modules_working_points_pset): name= cms.string("Photon"), doc = cms.string("slimmedPhotons after basic selection (" + finalPhotons.cut.value()+")"), variables = cms.PSet(P3Vars, - jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", int, doc="index of the associated jet (-1 if none)"), - electronIdx = Var("?hasUserCand('electron')?userCand('electron').key():-1", int, doc="index of the associated electron (-1 if none)"), + jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", "int16", doc="index of the associated jet (-1 if none)"), + electronIdx = Var("?hasUserCand('electron')?userCand('electron').key():-1", "int16", doc="index of the associated electron (-1 if none)"), energyErr = Var("getCorrectedEnergyError('regression2')",float,doc="energy error of the cluster from regression",precision=6), energyRaw = Var("superCluster().rawEnergy()",float,doc="raw energy of photon supercluster", precision=10), r9 = Var("full5x5_r9()",float,doc="R9 of the supercluster, calculated with full 5x5 region",precision=8), @@ -201,12 +201,12 @@ def make_bitmapVID_docstring(id_modules_working_points_pset): phiWidth = Var("superCluster().phiWidth()",float,doc="Width of the photon supercluster in phi", precision=8), cutBased = Var( "userInt('cutBasedID_loose')+userInt('cutBasedID_medium')+userInt('cutBasedID_tight')", - int, + "uint8", doc="cut-based ID bitmap, RunIIIWinter22V1, (0:fail, 1:loose, 2:medium, 3:tight)", ), cutBased_Fall17V2 = Var( "userInt('cutBasedID_Fall17V2_loose')+userInt('cutBasedID_Fall17V2_medium')+userInt('cutBasedID_Fall17V2_tight')", - int, + "uint8", doc="cut-based ID bitmap, Fall17V2, (0:fail, 1:loose, 2:medium, 3:tight)", ), vidNestedWPBitmap = Var( diff --git a/PhysicsTools/NanoAOD/python/protons_cff.py b/PhysicsTools/NanoAOD/python/protons_cff.py index 6da77f0bfbddc..d52ae961d7766 100644 --- a/PhysicsTools/NanoAOD/python/protons_cff.py +++ b/PhysicsTools/NanoAOD/python/protons_cff.py @@ -26,7 +26,7 @@ timeUnc = Var("timeError",float,doc="time uncertainty",precision=13), ), externalVariables = cms.PSet( - arm = ExtVar("protonTable:arm",int,doc="0 = sector45, 1 = sector56"), + arm = ExtVar("protonTable:arm", "uint8", doc="0 = sector45, 1 = sector56"), ), ) @@ -40,7 +40,7 @@ thetaY = Var("thetaY",float,doc="th y",precision=10), ), externalVariables = cms.PSet( - decRPId = ExtVar("protonTable:protonRPId",int,doc="Detector ID",precision=8), + decRPId = ExtVar("protonTable:protonRPId", "int16",doc="Detector ID"), ), ) diff --git a/PhysicsTools/NanoAOD/python/taus_cff.py b/PhysicsTools/NanoAOD/python/taus_cff.py index b78b58c49e3ec..8aa3f8077d7ba 100644 --- a/PhysicsTools/NanoAOD/python/taus_cff.py +++ b/PhysicsTools/NanoAOD/python/taus_cff.py @@ -52,14 +52,14 @@ def _tauIdWPMask(pattern, choices, doc="", from_raw=False, wp_thrs=None): ) _tauVarsBase = cms.PSet(P4Vars, - charge = Var("charge", int, doc="electric charge"), - jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", int, doc="index of the associated jet (-1 if none)"), - eleIdx = Var("?overlaps('electrons').size()>0?overlaps('electrons')[0].key():-1", int, doc="index of first matching electron"), - muIdx = Var("?overlaps('muons').size()>0?overlaps('muons')[0].key():-1", int, doc="index of first matching muon"), - svIdx1 = Var("?overlaps('vertices').size()>0?overlaps('vertices')[0].key():-1", int, doc="index of first matching secondary vertex"), - svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", int, doc="index of second matching secondary vertex"), - nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", int, doc="number of secondary vertices in the tau"), - decayMode = Var("decayMode()",int), + charge = Var("charge", "int16", doc="electric charge"), + jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", "int16", doc="index of the associated jet (-1 if none)"), + eleIdx = Var("?overlaps('electrons').size()>0?overlaps('electrons')[0].key():-1", "int16", doc="index of first matching electron"), + muIdx = Var("?overlaps('muons').size()>0?overlaps('muons')[0].key():-1", "int16", doc="index of first matching muon"), + svIdx1 = Var("?overlaps('vertices').size()>0?overlaps('vertices')[0].key():-1", "int16", doc="index of first matching secondary vertex"), + svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", "int16", doc="index of second matching secondary vertex"), + nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", "uint8", doc="number of secondary vertices in the tau"), + decayMode = Var("decayMode()", "uint8"), idDecayModeOldDMs = Var("tauID('decayModeFinding')", bool), leadTkPtOverTauPt = Var("leadChargedHadrCand.pt/pt ",float, doc="pt of the leading track divided by tau pt",precision=10), @@ -160,9 +160,9 @@ def _tauIdWPMask(pattern, choices, doc="", from_raw=False, wp_thrs=None): phi = Var("phi", float,precision=8), eta = Var("eta", float,precision=8), mass = Var("mass", float,precision=8), - charge = Var("charge", int), - status = Var("status", int, doc="Hadronic tau decay mode. 0=OneProng0PiZero, 1=OneProng1PiZero, 2=OneProng2PiZero, 10=ThreeProng0PiZero, 11=ThreeProng1PiZero, 15=Other"), - genPartIdxMother = Var("?numberOfMothers>0?motherRef(0).key():-1", int, doc="index of the mother particle"), + charge = Var("charge", "int16"), + status = Var("status", "uint8", doc="Hadronic tau decay mode. 0=OneProng0PiZero, 1=OneProng1PiZero, 2=OneProng2PiZero, 10=ThreeProng0PiZero, 11=ThreeProng1PiZero, 15=Other"), + genPartIdxMother = Var("?numberOfMothers>0?motherRef(0).key():-1", "int16", doc="index of the mother particle"), ) ) From 8dae4bc640473442e098bf00686e15540e10e60e Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Wed, 11 Jan 2023 15:49:01 +0100 Subject: [PATCH 06/10] fix inconsistent double variable usage in flat table --- PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h b/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h index 44af0e12cab9c..ebfd12dc637d8 100644 --- a/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h +++ b/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h @@ -131,6 +131,8 @@ class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> { vars_.push_back(std::make_unique(vname, varPSet)); else if (type == "float") vars_.push_back(std::make_unique(vname, varPSet)); + else if (type == "double") + vars_.push_back(std::make_unique(vname, varPSet)); else if (type == "int8") vars_.push_back(std::make_unique(vname, varPSet)); else if (type == "uint8") @@ -165,7 +167,7 @@ class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> { variable.add("doc")->setComment("few words description of the branch content"); variable.ifValue(edm::ParameterDescription( "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), - edm::allowedValues("int", "uint", "float", "int8", "uint8", "int16", "uint16", "bool")); + edm::allowedValues("int", "uint", "float", "double", "int8", "uint8", "int16", "uint16", "bool")); variable.addOptionalNode( edm::ParameterDescription( "precision", true, edm::Comment("the precision with which to store the value in the flat table")) xor @@ -205,6 +207,7 @@ class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> { typedef FuncVariable, int32_t> IntVar; typedef FuncVariable, uint32_t> UIntVar; typedef FuncVariable, float> FloatVar; + typedef FuncVariable, double> DoubleVar; typedef FuncVariable, int8_t> Int8Var; typedef FuncVariable, uint8_t> UInt8Var; typedef FuncVariable, int16_t> Int16Var; @@ -278,7 +281,7 @@ class SimpleFlatTableProducer : public SimpleFlatTableProducerBase("doc")->setComment("few words description of the branch content"); extvariable.ifValue(edm::ParameterDescription( "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), - edm::allowedValues("int", "uint", "float", "int8", "uint8", "int16", "uint16", "bool")); + edm::allowedValues("int", "uint", "float", "double", "int8", "uint8", "int16", "uint16", "bool")); extvariable.addOptionalNode( edm::ParameterDescription( "precision", true, edm::Comment("the precision with which to store the value in the flat table")) xor From c2ff4e131370025f565752e71771acf3744d6e55 Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Wed, 11 Jan 2023 16:19:59 +0100 Subject: [PATCH 07/10] code format --- .../interface/SimpleFlatTableProducer.h | 14 +++++++----- .../NanoAOD/plugins/LumiOutputBranches.cc | 3 ++- .../NanoAOD/plugins/TableOutputBranches.cc | 22 +++++++++---------- 3 files changed, 20 insertions(+), 19 deletions(-) diff --git a/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h b/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h index ebfd12dc637d8..d8b55ff52e9cc 100644 --- a/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h +++ b/PhysicsTools/NanoAOD/interface/SimpleFlatTableProducer.h @@ -165,9 +165,10 @@ class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> { edm::ParameterSetDescription variable; variable.add("expr")->setComment("a function to define the content of the branch in the flat table"); variable.add("doc")->setComment("few words description of the branch content"); - variable.ifValue(edm::ParameterDescription( - "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), - edm::allowedValues("int", "uint", "float", "double", "int8", "uint8", "int16", "uint16", "bool")); + variable.ifValue( + edm::ParameterDescription( + "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), + edm::allowedValues("int", "uint", "float", "double", "int8", "uint8", "int16", "uint16", "bool")); variable.addOptionalNode( edm::ParameterDescription( "precision", true, edm::Comment("the precision with which to store the value in the flat table")) xor @@ -279,9 +280,10 @@ class SimpleFlatTableProducer : public SimpleFlatTableProducerBase("src")->setComment("valuemap input collection to fill the flat table"); extvariable.add("doc")->setComment("few words description of the branch content"); - extvariable.ifValue(edm::ParameterDescription( - "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), - edm::allowedValues("int", "uint", "float", "double", "int8", "uint8", "int16", "uint16", "bool")); + extvariable.ifValue( + edm::ParameterDescription( + "type", "int", true, edm::Comment("the c++ type of the branch in the flat table")), + edm::allowedValues("int", "uint", "float", "double", "int8", "uint8", "int16", "uint16", "bool")); extvariable.addOptionalNode( edm::ParameterDescription( "precision", true, edm::Comment("the precision with which to store the value in the flat table")) xor diff --git a/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc b/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc index 5fd18bb155875..f87b2e0e8bd38 100644 --- a/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc +++ b/PhysicsTools/NanoAOD/plugins/LumiOutputBranches.cc @@ -72,7 +72,8 @@ void LumiOutputBranches::fill(const edm::LuminosityBlockForOutput &iLumi, TTree // ROOT native array size branches may only be signed integers, // until this is changed we need to make sure the vector sizes do not exceed that if (size > std::numeric_limits::max()) { - throw cms::Exception("Table " + tab.name() + " size is " + std::to_string(size) + ", is too large for ROOT native array branch"); + throw cms::Exception("Table " + tab.name() + " size is " + std::to_string(size) + + ", is too large for ROOT native array branch"); } m_counter = size; m_singleton = tab.singleton(); diff --git a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc index 639628e26fe5a..784f89ae8b9ac 100644 --- a/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc +++ b/PhysicsTools/NanoAOD/plugins/TableOutputBranches.cc @@ -65,17 +65,14 @@ void TableOutputBranches::branch(TTree &tree) { } } std::string varsize = m_singleton ? "" : "[n" + m_baseName + "]"; - for (std::vector *branches : - { - &m_int8Branches, - &m_uint8Branches, - &m_int16Branches, - &m_uint16Branches, - &m_int32Branches, - &m_uint32Branches, - &m_floatBranches, - &m_doubleBranches - }) { + for (std::vector *branches : {&m_int8Branches, + &m_uint8Branches, + &m_int16Branches, + &m_uint16Branches, + &m_int32Branches, + &m_uint32Branches, + &m_floatBranches, + &m_doubleBranches}) { for (auto &pair : *branches) { std::string branchName = makeBranchName(m_baseName, pair.name); pair.branch = @@ -98,7 +95,8 @@ void TableOutputBranches::fill(const edm::OccurrenceForOutput &iWhatever, TTree // ROOT native array size branches may only be signed integers, // until this is changed we need to make sure the vector sizes do not exceed that if (size > std::numeric_limits::max()) { - throw cms::Exception("Table " + tab.name() + " size is " + std::to_string(size) + ", is too large for ROOT native array branch"); + throw cms::Exception("Table " + tab.name() + " size is " + std::to_string(size) + + ", is too large for ROOT native array branch"); } m_counter = size; m_singleton = tab.singleton(); From d6396af972e6f376fd99569675c87009d766c0ff Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Wed, 11 Jan 2023 20:27:40 +0100 Subject: [PATCH 08/10] genPart status needs 15 bits --- PhysicsTools/NanoAOD/python/genparticles_cff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PhysicsTools/NanoAOD/python/genparticles_cff.py b/PhysicsTools/NanoAOD/python/genparticles_cff.py index c4423a42c61f3..d5191f14cf290 100644 --- a/PhysicsTools/NanoAOD/python/genparticles_cff.py +++ b/PhysicsTools/NanoAOD/python/genparticles_cff.py @@ -57,7 +57,7 @@ "statusFlags().isTauDecayProduct() * 4 +" "statusFlags().isDecayedLeptonHadron() * 2 +" "statusFlags().isPrompt() * 1 ", - "uint8", doc=("gen status flags stored bitwise, bits are: " + "uint16", doc=("gen status flags stored bitwise, bits are: " "0 : isPrompt, " "1 : isDecayedLeptonHadron, " "2 : isTauDecayProduct, " From 872b54472959f9adf0ae116f0c74f4033af51d64 Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Thu, 12 Jan 2023 09:22:58 +0100 Subject: [PATCH 09/10] use int16 for boostedTau category --- PhysicsTools/NanoAOD/python/boostedTaus_cff.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/PhysicsTools/NanoAOD/python/boostedTaus_cff.py b/PhysicsTools/NanoAOD/python/boostedTaus_cff.py index ee56b4936c5cc..67e012639782b 100644 --- a/PhysicsTools/NanoAOD/python/boostedTaus_cff.py +++ b/PhysicsTools/NanoAOD/python/boostedTaus_cff.py @@ -55,7 +55,7 @@ #AntiEle MVA 2018 variables _boostedTauVarsAntiEleMVA = cms.PSet( rawAntiEle2018 = Var("tauID('againstElectronMVA6Raw')", float, doc= "Anti-electron MVA discriminator V6 raw output discriminator (2018)", precision=10), - rawAntiEleCat2018 = Var("tauID('againstElectronMVA6category')", "int8", doc="Anti-electron MVA discriminator V6 category (2018)"), + rawAntiEleCat2018 = Var("tauID('againstElectronMVA6category')", "int16", doc="Anti-electron MVA discriminator V6 category (2018)"), idAntiEle2018 = _tauIdWPMask("againstElectron%sMVA6", choices=("VLoose","Loose","Medium","Tight","VTight"), doc= "Anti-electron MVA discriminator V6 (2018)") ) @@ -80,7 +80,7 @@ idMVAnewDM2017v2 = _tauIdWPMask("by%sIsolationMVArun2017v2DBnewDMwLT2017", choices=("VVLoose","VLoose","Loose","Medium","Tight","VTight","VVTight"),doc="IsolationMVArun2DBnewDMwLT ID working point (2017v2)"), idMVAoldDM2017v2 = _tauIdWPMask("by%sIsolationMVArun2017v2DBoldDMwLT2017",choices=("VVLoose","VLoose","Loose","Medium","Tight","VTight","VVTight"),doc="IsolationMVArun2DBoldDMwLT ID working point (2017v2)"), rawAntiEle2018 = Var("tauID('againstElectronMVA6Raw2018')", float, doc= "Anti-electron MVA discriminator V6 raw output discriminator (2018)", precision=10), - rawAntiEleCat2018 = Var("tauID('againstElectronMVA6category2018')", "int8", doc="Anti-electron MVA discriminator V6 category (2018)"), + rawAntiEleCat2018 = Var("tauID('againstElectronMVA6category2018')", "int16", doc="Anti-electron MVA discriminator V6 category (2018)"), idAntiEle2018 = _tauIdWPMask("againstElectron%sMVA62018", choices=("VLoose","Loose","Medium","Tight","VTight"), doc= "Anti-electron MVA discriminator V6 (2018)") ) From cc491f1a5d986cfe6f18bf6a20cdc36a6ab5ef50 Mon Sep 17 00:00:00 2001 From: Sebastien Wertz Date: Thu, 12 Jan 2023 19:44:58 +0100 Subject: [PATCH 10/10] fix boosted tau jetIdx, should be signed --- PhysicsTools/NanoAOD/python/boostedTaus_cff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/PhysicsTools/NanoAOD/python/boostedTaus_cff.py b/PhysicsTools/NanoAOD/python/boostedTaus_cff.py index 67e012639782b..cf214b3c184e5 100644 --- a/PhysicsTools/NanoAOD/python/boostedTaus_cff.py +++ b/PhysicsTools/NanoAOD/python/boostedTaus_cff.py @@ -26,7 +26,7 @@ ) _boostedTauVarsBase = cms.PSet(P4Vars, charge = Var("charge", int, doc="electric charge"), - jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", "uint16", doc="index of the associated jet (-1 if none)"), + jetIdx = Var("?hasUserCand('jet')?userCand('jet').key():-1", "int16", doc="index of the associated jet (-1 if none)"), decayMode = Var("decayMode()",int), leadTkPtOverTauPt = Var("leadChargedHadrCand.pt/pt ",float, doc="pt of the leading track divided by tau pt",precision=10), leadTkDeltaEta = Var("leadChargedHadrCand.eta - eta ",float, doc="eta of the leading track, minus tau eta",precision=8),