nanoaod::FlatTable Class Reference

#include <FlatTable.h>

Classes
struct	Column
struct	dependent_false
class	RowView

Public Types
enum	ColumnType {   ColumnType::Int8, ColumnType::UInt8, ColumnType::Int16, ColumnType::UInt16,   ColumnType::Int32, ColumnType::UInt32, ColumnType::Bool, ColumnType::Float,   ColumnType::Double }

Public Member Functions
template<typename T , typename C >
void	addColumn (const std::string &name, const C &values, const std::string &docString, int mantissaBits=-1)
template<typename T , typename C >
void	addColumnValue (const std::string &name, const C &value, const std::string &docString, int mantissaBits=-1)
void	addExtension (const FlatTable &extension)
template<typename T >
auto	columnData (unsigned int column) const
	get a column by index (const) More...
template<typename T >
auto	columnData (unsigned int column)
	get a column by index (non-const) More...
const std::string &	columnDoc (unsigned int col) const
int	columnIndex (const std::string &name) const
const std::string &	columnName (unsigned int col) const
ColumnType	columnType (unsigned int col) const
template<typename T >
const auto &	columValue (unsigned int column) const
	get a column value for singleton (const) More...
const std::string &	doc () const
bool	extension () const
	FlatTable ()
	FlatTable (unsigned int size, const std::string &name, bool singleton, bool extension=false)
double	getAnyValue (unsigned int row, unsigned int column) const
const std::string &	name () const
unsigned int	nColumns () const
unsigned int	nRows () const
RowView	row (unsigned int row) const
void	setDoc (const std::string &doc)
bool	singleton () const
unsigned int	size () const
	~FlatTable ()

Static Public Member Functions
template<typename T >
static ColumnType	defaultColumnType ()

Private Member Functions
template<typename T >
auto	beginData (unsigned int column) const
template<typename T >
auto	beginData (unsigned int column)
template<typename T >
auto const &	bigVector () const
template<typename T >
auto &	bigVector ()

Static Private Member Functions
template<typename T , class This >
static auto &	bigVectorImpl (This &table)

Private Attributes
std::vector< Column >	columns_
std::string	doc_
std::vector< double >	doubles_
bool	extension_
std::vector< float >	floats_
std::vector< int16_t >	int16s_
std::vector< int32_t >	int32s_
std::vector< int8_t >	int8s_
std::string	name_
bool	singleton_
unsigned int	size_
std::vector< uint16_t >	uint16s_
std::vector< uint32_t >	uint32s_
std::vector< uint8_t >	uint8s_

Detailed Description

Definition at line 38 of file FlatTable.h.

Member Enumeration Documentation

ColumnType

enum nanoaod::FlatTable::ColumnType

strong

Enumerator
Int8
UInt8
Int16
UInt16
Int32
UInt32
Bool
Float
Double

Definition at line 40 of file FlatTable.h.

                          {
      Int8,
      UInt8,
      Int16,
      UInt16,
      Int32,
      UInt32,
      Bool,
      Float,
      Double,
    };  // We could have other Float types with reduced mantissa, and similar

Constructor & Destructor Documentation

FlatTable() [1/2]

nanoaod::FlatTable::FlatTable ( )

inline

Definition at line 52 of file FlatTable.h.

: size_(0) {}

FlatTable() [2/2]

nanoaod::FlatTable::FlatTable ( unsigned int  size, const std::string &  name, bool  singleton, bool  extension = false  )

inline

Definition at line 53 of file FlatTable.h.

        : size_(size), name_(name), singleton_(singleton), extension_(extension) {}

~FlatTable()

nanoaod::FlatTable::~FlatTable ( )

inline

Definition at line 55 of file FlatTable.h.

{}

Member Function Documentation

addColumn()

template<typename T , typename C >

void nanoaod::FlatTable::addColumn ( const std::string &  name, const C &  values, const std::string &  docString, int  mantissaBits = -1  )

inline

Definition at line 115 of file FlatTable.h.

References columnIndex(), columns_, electrons_cff::docString, Exception, l1tHGCalConcentratorProducer_cfi::mantissaBits, name(), size(), and contentValuesCheck::values.

                                                                                                              {
      if (columnIndex(name) != -1)
        throw cms::Exception("LogicError", "Duplicated column: " + name);
      if (values.size() != size())
        throw cms::Exception("LogicError", "Mismatched size for " + name);
      auto &vec = bigVector<T>();
      columns_.emplace_back(name, docString, defaultColumnType<T>(), vec.size());
      vec.insert(vec.end(), values.begin(), values.end());
      flatTableHelper::MaybeMantissaReduce<T>(mantissaBits).bulk(columnData<T>(columns_.size() - 1));
    }

addColumnValue()

template<typename T , typename C >

void nanoaod::FlatTable::addColumnValue ( const std::string &  name, const C &  value, const std::string &  docString, int  mantissaBits = -1  )

inline

Definition at line 127 of file FlatTable.h.

References columnIndex(), columns_, electrons_cff::docString, Exception, l1tHGCalConcentratorProducer_cfi::mantissaBits, name(), SiPixelPI::one, and singleton().

                                                                                                                  {
      if (!singleton())
        throw cms::Exception("LogicError", "addColumnValue works only for singleton tables");
      if (columnIndex(name) != -1)
        throw cms::Exception("LogicError", "Duplicated column: " + name);
      auto &vec = bigVector<T>();
      columns_.emplace_back(name, docString, defaultColumnType<T>(), vec.size());
      vec.push_back(flatTableHelper::MaybeMantissaReduce<T>(mantissaBits).one(value));
    }

addExtension()

void nanoaod::FlatTable::addExtension

(

const FlatTable &

extension

)

Definition at line 11 of file FlatTable.cc.

References Exception, runGCPTkAlMap::extension, mps_fire::i, dqmiodumpmetadata::n, Skims_PA_cff::name, and trackingPlots::other.

Referenced by NanoAODDQM::analyze().

                                                                 {
  if (extension() || !other.extension() || name() != other.name() || size() != other.size())
    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::Int8:
        addColumn<int8_t>(other.columnName(i), other.columnData<int8_t>(i), other.columnDoc(i));
        break;
      case ColumnType::UInt8:
        addColumn<uint8_t>(other.columnName(i), other.columnData<uint8_t>(i), other.columnDoc(i));
        break;
      case ColumnType::Int16:
        addColumn<int16_t>(other.columnName(i), other.columnData<int16_t>(i), other.columnDoc(i));
        break;
      case ColumnType::UInt16:
        addColumn<uint16_t>(other.columnName(i), other.columnData<uint16_t>(i), other.columnDoc(i));
        break;
      case ColumnType::Int32:
        addColumn<int32_t>(other.columnName(i), other.columnData<int32_t>(i), other.columnDoc(i));
        break;
      case ColumnType::UInt32:
        addColumn<uint32_t>(other.columnName(i), other.columnData<uint32_t>(i), other.columnDoc(i));
        break;
      case ColumnType::Bool:
        addColumn<bool>(other.columnName(i), other.columnData<bool>(i), other.columnDoc(i));
        break;
      case ColumnType::Float:
        addColumn<float>(other.columnName(i), other.columnData<float>(i), other.columnDoc(i));
        break;
      case ColumnType::Double:
        addColumn<double>(other.columnName(i), other.columnData<double>(i), other.columnDoc(i));
        break;
      default:
        throw cms::Exception("LogicError", "Unsupported type");
    }
  }
}

beginData() [1/2]

template<typename T >

auto nanoaod::FlatTable::beginData ( unsigned int  column ) const

inlineprivate

Definition at line 177 of file FlatTable.h.

References columns_.

                                              {
      return bigVector<T>().cbegin() + columns_[column].firstIndex;
    }

beginData() [2/2]

template<typename T >

auto nanoaod::FlatTable::beginData ( unsigned int  column )

inlineprivate

Definition at line 181 of file FlatTable.h.

References columns_.

                                        {
      return bigVector<T>().begin() + columns_[column].firstIndex;
    }

bigVector() [1/2]

template<typename T >

auto const& nanoaod::FlatTable::bigVector ( ) const

inlineprivate

Definition at line 186 of file FlatTable.h.

                                  {
      return bigVectorImpl<T>(*this);
    }

bigVector() [2/2]

template<typename T >

auto& nanoaod::FlatTable::bigVector ( )

inlineprivate

Definition at line 190 of file FlatTable.h.

                      {
      return bigVectorImpl<T>(*this);
    }

bigVectorImpl()

template<typename T , class This >

static auto& nanoaod::FlatTable::bigVectorImpl ( This &  table )

inlinestaticprivate

Definition at line 195 of file FlatTable.h.

References TableParser::table.

                                            {
      // helper function to avoid code duplication, for the two accessor functions that differ only in const-ness
      if constexpr (std::is_same<T, int8_t>())
        return table.int8s_;
      else if constexpr (std::is_same<T, uint8_t>())
        return table.uint8s_;
      else if constexpr (std::is_same<T, int16_t>())
        return table.int16s_;
      else if constexpr (std::is_same<T, uint16_t>())
        return table.uint16s_;
      else if constexpr (std::is_same<T, int32_t>())
        return table.int32s_;
      else if constexpr (std::is_same<T, uint32_t>())
        return table.uint32s_;
      else if constexpr (std::is_same<T, bool>())
        return table.uint8s_;  // special case: bool stored as vector of uint8
      else if constexpr (std::is_same<T, float>())
        return table.floats_;
      else if constexpr (std::is_same<T, double>())
        return table.doubles_;
      else
        static_assert(dependent_false<T>::value, "unsupported type");
    }

columnData() [1/2]

template<typename T >

auto nanoaod::FlatTable::columnData ( unsigned int  column ) const

inline

get a column by index (const)

Definition at line 75 of file FlatTable.h.

References size_.

Referenced by LumiOutputBranches::fillColumn(), and TableOutputBranches::fillColumn().

                                               {
      auto begin = beginData<T>(column);
      return edm::Span(begin, begin + size_);
    }

columnData() [2/2]

template<typename T >

auto nanoaod::FlatTable::columnData ( unsigned int  column )

inline

get a column by index (non-const)

Definition at line 82 of file FlatTable.h.

References size_.

                                         {
      auto begin = beginData<T>(column);
      return edm::Span(begin, begin + size_);
    }

columnDoc()

const std::string& nanoaod::FlatTable::columnDoc ( unsigned int  col ) const

inline

Definition at line 71 of file FlatTable.h.

References cuy::col, and columns_.

Referenced by TableOutputBranches::defineBranchesFromFirstEvent(), and LumiOutputBranches::defineBranchesFromFirstEvent().

{ return columns_[col].doc; }

columnIndex()

int nanoaod::FlatTable::columnIndex

(

const std::string &

name

)

const

Definition at line 3 of file FlatTable.cc.

References columns_, mps_fire::i, dqmiodumpmetadata::n, and name().

Referenced by addColumn(), addColumnValue(), LumiOutputBranches::fillColumn(), TableOutputBranches::fillColumn(), and nanoaod::FlatTable::RowView::getAnyValue().

                                                             {
  for (unsigned int i = 0, n = columns_.size(); i < n; ++i) {
    if (columns_[i].name == name)
      return i;
  }
  return -1;
}

columnName()

const std::string& nanoaod::FlatTable::columnName ( unsigned int  col ) const

inline

Definition at line 64 of file FlatTable.h.

References cuy::col, and columns_.

Referenced by TableOutputBranches::defineBranchesFromFirstEvent(), and LumiOutputBranches::defineBranchesFromFirstEvent().

{ return columns_[col].name; }

columnType()

ColumnType nanoaod::FlatTable::columnType ( unsigned int  col ) const

inline

Definition at line 67 of file FlatTable.h.

References cuy::col, and columns_.

Referenced by TableOutputBranches::defineBranchesFromFirstEvent(), and LumiOutputBranches::defineBranchesFromFirstEvent().

{ return columns_[col].type; }

columValue()

template<typename T >

const auto& nanoaod::FlatTable::columValue ( unsigned int  column ) const

inline

get a column value for singleton (const)

Definition at line 89 of file FlatTable.h.

References Exception, and singleton().

                                                      {
      if (!singleton())
        throw cms::Exception("LogicError", "columnValue works only for singleton tables");
      return *beginData<T>(column);
    }

defaultColumnType()

template<typename T >

static ColumnType nanoaod::FlatTable::defaultColumnType ( )

inlinestatic

Definition at line 142 of file FlatTable.h.

References Bool, Double, Float, Int16, Int32, Int8, UInt16, UInt32, and UInt8.

                                          {
      if constexpr (std::is_same<T, int8_t>())
        return ColumnType::Int8;
      else if constexpr (std::is_same<T, uint8_t>())
        return ColumnType::UInt8;
      else if constexpr (std::is_same<T, int16_t>())
        return ColumnType::Int16;
      else if constexpr (std::is_same<T, uint16_t>())
        return ColumnType::UInt16;
      else if constexpr (std::is_same<T, int32_t>())
        return ColumnType::Int32;
      else if constexpr (std::is_same<T, uint32_t>())
        return ColumnType::UInt32;
      else if constexpr (std::is_same<T, bool>())
        return ColumnType::Bool;
      else if constexpr (std::is_same<T, float>())
        return ColumnType::Float;
      else if constexpr (std::is_same<T, double>())
        return ColumnType::Double;
      else
        static_assert(dependent_false<T>::value, "unsupported type");
    }

doc()

const std::string& nanoaod::FlatTable::doc ( ) const

inline

Definition at line 70 of file FlatTable.h.

References doc_.

Referenced by TableOutputBranches::fill(), LumiOutputBranches::fill(), and setDoc().

{ return doc_; }

extension()

bool nanoaod::FlatTable::extension ( ) const

inline

Definition at line 61 of file FlatTable.h.

References extension_.

Referenced by TableOutputBranches::fill(), and LumiOutputBranches::fill().

{ return extension_; }

getAnyValue()

double nanoaod::FlatTable::getAnyValue	(	unsigned int	row,
		unsigned int	column
	)		const

Definition at line 49 of file FlatTable.cc.

References Exception.

Referenced by nanoaod::FlatTable::RowView::getAnyValue().

                                                                                {
  if (column >= nColumns())
    throw cms::Exception("LogicError", "Invalid column");
  switch (columnType(column)) {
    case ColumnType::Int8:
      return *(beginData<int8_t>(column) + row);
    case ColumnType::UInt8:
      return *(beginData<uint8_t>(column) + row);
    case ColumnType::Int16:
      return *(beginData<int16_t>(column) + row);
    case ColumnType::UInt16:
      return *(beginData<uint16_t>(column) + row);
    case ColumnType::Int32:
      return *(beginData<int32_t>(column) + row);
    case ColumnType::UInt32:
      return *(beginData<uint32_t>(column) + row);
    case ColumnType::Bool:
      return *(beginData<bool>(column) + row);
    case ColumnType::Float:
      return *(beginData<float>(column) + row);
    case ColumnType::Double:
      return *(beginData<double>(column) + row);
  }
  throw cms::Exception("LogicError", "Unsupported type");
}

name()

const std::string& nanoaod::FlatTable::name ( ) const

inline

Definition at line 62 of file FlatTable.h.

References name_.

Referenced by config.CFG::__str__(), addColumn(), addColumnValue(), columnIndex(), TableOutputBranches::defineBranchesFromFirstEvent(), LumiOutputBranches::defineBranchesFromFirstEvent(), validation.Sample::digest(), TableOutputBranches::fill(), LumiOutputBranches::fill(), and VIDSelectorBase.VIDSelectorBase::initialize().

{ return name_; }

nColumns()

unsigned int nanoaod::FlatTable::nColumns ( ) const

inline

Definition at line 57 of file FlatTable.h.

References columns_.

Referenced by TableOutputBranches::defineBranchesFromFirstEvent(), and LumiOutputBranches::defineBranchesFromFirstEvent().

{ return columns_.size(); };

nRows()

unsigned int nanoaod::FlatTable::nRows ( ) const

inline

Definition at line 58 of file FlatTable.h.

References size_.

{ return size_; };

row()

RowView nanoaod::FlatTable::row ( unsigned int  row ) const

inline

Definition at line 112 of file FlatTable.h.

{ return RowView(*this, row); }

setDoc()

void nanoaod::FlatTable::setDoc ( const std::string &  doc )

inline

Definition at line 69 of file FlatTable.h.

References doc(), and doc_.

{ doc_ = doc; }

singleton()

bool nanoaod::FlatTable::singleton ( ) const

inline

Definition at line 60 of file FlatTable.h.

References singleton_.

Referenced by addColumnValue(), columValue(), TableOutputBranches::fill(), and LumiOutputBranches::fill().

{ return singleton_; }

size()

unsigned int nanoaod::FlatTable::size ( void  ) const

inline

Definition at line 59 of file FlatTable.h.

References size_.

Referenced by ntupleDataFormat._Collection::__iter__(), ntupleDataFormat._Collection::__len__(), addColumn(), TableOutputBranches::fill(), LumiOutputBranches::fill(), and TableOutputBranches::fillColumn().

{ return size_; }

Member Data Documentation

columns_

std::vector<Column> nanoaod::FlatTable::columns_

private

Definition at line 222 of file FlatTable.h.

Referenced by addColumn(), addColumnValue(), beginData(), columnDoc(), columnIndex(), columnName(), columnType(), and nColumns().

doc_

std::string nanoaod::FlatTable::doc_

private

Definition at line 220 of file FlatTable.h.

Referenced by doc(), and setDoc().

doubles_

std::vector<double> nanoaod::FlatTable::doubles_

private

Definition at line 230 of file FlatTable.h.

extension_

bool nanoaod::FlatTable::extension_

private

Definition at line 221 of file FlatTable.h.

Referenced by extension().

floats_

std::vector<float> nanoaod::FlatTable::floats_

private

Definition at line 229 of file FlatTable.h.

int16s_

std::vector<int16_t> nanoaod::FlatTable::int16s_

private

Definition at line 225 of file FlatTable.h.

int32s_

std::vector<int32_t> nanoaod::FlatTable::int32s_

private

Definition at line 227 of file FlatTable.h.

int8s_

std::vector<int8_t> nanoaod::FlatTable::int8s_

private

Definition at line 223 of file FlatTable.h.

name_

std::string nanoaod::FlatTable::name_

private

Definition at line 220 of file FlatTable.h.

Referenced by name().

singleton_

bool nanoaod::FlatTable::singleton_

private

Definition at line 221 of file FlatTable.h.

Referenced by singleton().

size_

unsigned int nanoaod::FlatTable::size_

private

Definition at line 219 of file FlatTable.h.

Referenced by columnData(), nRows(), and size().

uint16s_

std::vector<uint16_t> nanoaod::FlatTable::uint16s_

private

Definition at line 226 of file FlatTable.h.

uint32s_

std::vector<uint32_t> nanoaod::FlatTable::uint32s_

private

Definition at line 228 of file FlatTable.h.

uint8s_

std::vector<uint8_t> nanoaod::FlatTable::uint8s_

private

Definition at line 224 of file FlatTable.h.