MergeableCounterTable.h

Go to the documentation of this file.

#ifndef DataFormats_NanoAOD_MergeableCounterTable_h
#define DataFormats_NanoAOD_MergeableCounterTable_h

#include "FWCore/Utilities/interface/Exception.h"
#include <vector>
#include <string>

namespace nanoaod {

class MergeableCounterTable {
    public:
        MergeableCounterTable() {}
        typedef long long int_accumulator; // we accumulate in long long int, to avoid overflow
        typedef double float_accumulator; // we accumulate in double, to preserve precision

        template<typename T>
        struct SingleColumn {
            typedef T value_type;
            SingleColumn() {}
            SingleColumn(const std::string & aname, const std::string & adoc, T avalue = T()) : name(aname), doc(adoc), value(avalue) {}
            std::string name, doc;
            T value;
            void operator+=(const SingleColumn<T> & other) {
                //if (name != other.name) throw cms::Exception("LogicError", "Trying to merge "+name+" with "+other.name+"\n");
                value += other.value;
            }
            bool compatible(const SingleColumn<T> & other) {
                return name == other.name;  // we don't check the doc, not needed
            }
        };
        typedef SingleColumn<float_accumulator> FloatColumn; 
        typedef SingleColumn<int_accumulator> IntColumn;  
       
        template<typename T>
        struct VectorColumn {
            typedef T element_type;
            VectorColumn() {}
            VectorColumn(const std::string & aname, const std::string & adoc, unsigned int size) : name(aname), doc(adoc), values(size, T()) {}
            VectorColumn(const std::string & aname, const std::string & adoc, const std::vector<T> & somevalues) : name(aname), doc(adoc), values(somevalues) {}
            std::string name, doc;
            std::vector<T> values;
            void operator+=(const VectorColumn<T> & other) {
                //if (name != other.name) throw cms::Exception("LogicError", "Trying to merge "+name+" with "+other.name+"\n");
                //if (values.size() != other.values.size()) throw cms::Exception("LogicError", "Trying to merge "+name+" with different number of values!\n");
                for (unsigned int i = 0, n = values.size(); i < n; ++i) {
                    values[i] += other.values[i];
                }
            }
            bool compatible(const VectorColumn<T> & other) {
                return name == other.name && values.size() == other.values.size(); // we don't check the doc, not needed
            }
        };
        typedef VectorColumn<float_accumulator> VFloatColumn; 
        typedef VectorColumn<int_accumulator> VIntColumn;
 
        const std::vector<FloatColumn> & floatCols() const { return floatCols_; }
        const std::vector<VFloatColumn> & vfloatCols() const { return vfloatCols_; }
        const std::vector<IntColumn> & intCols() const { return intCols_; }
        const std::vector<VIntColumn> & vintCols() const { return vintCols_; }
       
        template<typename F>
        void addFloat(const std::string & name, const std::string & doc, F value) { floatCols_.push_back(FloatColumn(name, doc, value)); } 

        template<typename I>
        void addInt(const std::string & name, const std::string & doc, I value) { intCols_.push_back(IntColumn(name, doc, value)); } 

        template<typename F>
        void addVFloat(const std::string & name, const std::string & doc, const std::vector<F> values) { 
            vfloatCols_.push_back(VFloatColumn(name, doc, values.size())); 
            std::copy(values.begin(), values.end(), vfloatCols_.back().values.begin());
        } 

        template<typename I>
        void addVInt(const std::string & name, const std::string & doc, const std::vector<I> values) { 
            vintCols_.push_back(VIntColumn(name, doc, values.size())); 
            std::copy(values.begin(), values.end(), vintCols_.back().values.begin());
        } 


        bool mergeProduct(const MergeableCounterTable & other) {
            if (!tryMerge(intCols_, other.intCols_)) return false;
            if (!tryMerge(vintCols_, other.vintCols_)) return false;
            if (!tryMerge(floatCols_, other.floatCols_)) return false;
            if (!tryMerge(vfloatCols_, other.vfloatCols_)) return false;
            return true; 
        }

        void swap(MergeableCounterTable& iOther) {
          floatCols_.swap(iOther.floatCols_);
          vfloatCols_.swap(iOther.vfloatCols_);
          intCols_.swap(iOther.intCols_);
          vintCols_.swap(iOther.vintCols_);
        }

   private:
        std::vector<FloatColumn> floatCols_;
        std::vector<VFloatColumn> vfloatCols_;
        std::vector<IntColumn> intCols_;
        std::vector<VIntColumn> vintCols_;

        template<typename T>
        bool tryMerge(std::vector<T> & one, const std::vector<T> & two) {
            if (one.size() != two.size()) return false;
            for (unsigned int i = 0, n = one.size(); i < n; ++i) {
                if (!one[i].compatible(two[i])) return false;
                one[i] += two[i];
            }
            return true;
        }
};

} // namespace nanoaod

#endif