FlatTable.h

Go to the documentation of this file.

#ifndef DataFormats_NanoAOD_FlatTable_h
#define DataFormats_NanoAOD_FlatTable_h

#include <cstdint>
#include <vector>
#include <string>
#include <boost/range/sub_range.hpp>
#include "FWCore/Utilities/interface/Exception.h"
#include "DataFormats/Math/interface/libminifloat.h"

namespace nanoaod {

namespace flatTableHelper {
    template<typename T> struct MaybeMantissaReduce { 
        MaybeMantissaReduce(int mantissaBits) {}
        inline T one(const T &val) const  { return val; }
        inline void bulk(boost::sub_range<std::vector<T>> data) const {  }
    };
    template<> struct MaybeMantissaReduce<float> {
        int bits_; 
        MaybeMantissaReduce(int mantissaBits) : bits_(mantissaBits) {}
        inline float one(const float &val) const  { return (bits_ > 0 ? MiniFloatConverter::reduceMantissaToNbitsRounding(val, bits_) : val); }
        inline void bulk(boost::sub_range<std::vector<float>> data) const { if (bits_ > 0) MiniFloatConverter::reduceMantissaToNbitsRounding(bits_, data.begin(), data.end(), data.begin()); }
    };
}

class FlatTable {
  public:
    enum ColumnType { FloatColumn, IntColumn, UInt8Column, BoolColumn }; // We could have other Float types with reduced mantissa, and similar

    FlatTable() : size_(0) {}
    FlatTable(unsigned int size, const std::string & name, bool singleton, bool extension=false) : size_(size), name_(name), singleton_(singleton), extension_(extension)  {}
    ~FlatTable() {}

    unsigned int nColumns() const { return columns_.size(); };
    unsigned int nRows() const { return size_; };
    unsigned int size() const { return size_; }
    bool singleton() const { return singleton_; }
    bool extension() const { return extension_; }
    const std::string & name() const { return name_; }

    const std::string & columnName(unsigned int col) const { return columns_[col].name; }
    int columnIndex(const std::string & name) const ; 

    ColumnType columnType(unsigned int col) const { return columns_[col].type; }

    void setDoc(const std::string & doc) { doc_ = doc; }
    const std::string & doc() const { return doc_; }
    const std::string & columnDoc(unsigned int col) const { return columns_[col].doc; }

    template<typename T>
    boost::sub_range<const std::vector<T>> columnData(unsigned int column) const { 
         auto begin = beginData<T>(column);
         return boost::sub_range<const std::vector<T>>(begin, begin+size_);
    }

    template<typename T>
    boost::sub_range<std::vector<T>> columnData(unsigned int column) { 
         auto begin = beginData<T>(column);
         return boost::sub_range<std::vector<T>>(begin, begin+size_);
    }

    template<typename T>
    const T & columValue(unsigned int column) const {
         if (!singleton()) throw cms::Exception("LogicError", "columnValue works only for singleton tables");
         return * beginData<T>(column);
    }

    double getAnyValue(unsigned int row, unsigned int column) const ;

    class RowView {
        public:
            RowView() {}
            RowView(const FlatTable & table, unsigned int row) : table_(&table), row_(row) {}
            double getAnyValue(unsigned int column) const { return table_->getAnyValue(row_, column); }
            double getAnyValue(const std::string & column) const { return table_->getAnyValue(row_, table_->columnIndex(column)); }
            const FlatTable & table() const { return *table_; }
            unsigned int row() const { return row_; }
        private:
            const FlatTable * table_;
            unsigned int row_;
    };
    RowView row(unsigned int row) const { return RowView(*this, row); }

    template<typename T, typename C = std::vector<T>>
    void addColumn(const std::string & name, const C & values, const std::string & docString, ColumnType type = defaultColumnType<T>(),int mantissaBits=-1) {
        if (columnIndex(name) != -1) throw cms::Exception("LogicError", "Duplicated column: "+name); 
        if (values.size() != size()) throw cms::Exception("LogicError", "Mismatched size for "+name); 
        check_type<T>(type); // throws if type is wrong
        auto & vec = bigVector<T>();
        columns_.emplace_back(name,docString,type,vec.size());
        vec.insert(vec.end(), values.begin(), values.end());
        if (type == FloatColumn) {
            flatTableHelper::MaybeMantissaReduce<T>(mantissaBits).bulk(columnData<T>(columns_.size()-1));
        }
    }
    template<typename T, typename C>
    void addColumnValue(const std::string & name, const C & value, const std::string & docString, ColumnType type = defaultColumnType<T>(),int mantissaBits=-1) {
        if (!singleton()) throw cms::Exception("LogicError", "addColumnValue works only for singleton tables");
        if (columnIndex(name) != -1) throw cms::Exception("LogicError", "Duplicated column: "+name);
        check_type<T>(type); // throws if type is wrong
        auto & vec = bigVector<T>();
        columns_.emplace_back(name,docString,type,vec.size());
        if (type == FloatColumn) {
            vec.push_back( flatTableHelper::MaybeMantissaReduce<T>(mantissaBits).one(value) );
        } else {
            vec.push_back( value );
        }
    }

    void addExtension(const FlatTable & extension) ;

    template<typename T> static ColumnType defaultColumnType() { throw cms::Exception("unsupported type"); }

    // this below needs to be public for ROOT, but it is to be considered private otherwise
    struct Column {
        std::string name, doc;
        ColumnType type;
        unsigned int firstIndex;
        Column() {} // for ROOT
        Column(const std::string & aname, const std::string & docString, ColumnType atype, unsigned int anIndex) : name(aname), doc(docString), type(atype), firstIndex(anIndex) {}
    };

  private:

     template<typename T>
     typename std::vector<T>::const_iterator beginData(unsigned int column) const {
         const Column & col = columns_[column];
         check_type<T>(col.type); // throws if type is wrong
         return bigVector<T>().begin() + col.firstIndex;
     }
     template<typename T>
     typename std::vector<T>::iterator beginData(unsigned int column) {
         const Column & col = columns_[column];
         check_type<T>(col.type); // throws if type is wrong
         return bigVector<T>().begin() + col.firstIndex;
     }

     template<typename T>
     const std::vector<T> & bigVector() const { throw cms::Exception("unsupported type"); }
     template<typename T>
     std::vector<T> & bigVector() { throw cms::Exception("unsupported type"); }


     unsigned int size_;
     std::string name_, doc_;
     bool singleton_, extension_;
     std::vector<Column> columns_;
     std::vector<float> floats_;
     std::vector<int> ints_;
     std::vector<uint8_t> uint8s_;

     template<typename T> 
     static void check_type(FlatTable::ColumnType type) { throw cms::Exception("unsupported type"); }
};

template<> inline void FlatTable::check_type<float>(FlatTable::ColumnType type) {
     if (type != FlatTable::FloatColumn) throw cms::Exception("mismatched type");
}
template<> inline void FlatTable::check_type<int>(FlatTable::ColumnType type) {
     if (type != FlatTable::IntColumn) throw cms::Exception("mismatched type");
}
template<> inline void FlatTable::check_type<uint8_t>(FlatTable::ColumnType type) {
     if (type != FlatTable::UInt8Column && type != FlatTable::BoolColumn) throw cms::Exception("mismatched type");
}



template<> inline const std::vector<float>   & FlatTable::bigVector<float>()   const { return floats_; }
template<> inline const std::vector<int>     & FlatTable::bigVector<int>()     const { return ints_; }
template<> inline const std::vector<uint8_t> & FlatTable::bigVector<uint8_t>() const { return uint8s_; }
template<> inline std::vector<float>   & FlatTable::bigVector<float>()   { return floats_; }
template<> inline std::vector<int>     & FlatTable::bigVector<int>()     { return ints_; }
template<> inline std::vector<uint8_t> & FlatTable::bigVector<uint8_t>() { return uint8s_; }

} // nanoaod

#endif