SimpleFlatTableProducer.h

Go to the documentation of this file.

#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Framework/interface/ConsumesCollector.h"
#include "DataFormats/Common/interface/View.h"
#include "DataFormats/Common/interface/ValueMap.h"
#include "DataFormats/NanoAOD/interface/FlatTable.h"
 
#include "CommonTools/Utils/interface/StringCutObjectSelector.h"
#include "CommonTools/Utils/interface/StringObjectFunction.h"
 
#include <vector>
#include <boost/ptr_container/ptr_vector.hpp>
 
template <typename T, typename TProd>
class SimpleFlatTableProducerBase : public edm::stream::EDProducer<> {
public:
  SimpleFlatTableProducerBase(edm::ParameterSet const &params)
      : name_(params.getParameter<std::string>("name")),
        doc_(params.existsAs<std::string>("doc") ? params.getParameter<std::string>("doc") : ""),
        extension_(params.existsAs<bool>("extension") ? params.getParameter<bool>("extension") : false),
        src_(consumes<TProd>(params.getParameter<edm::InputTag>("src"))) {
    edm::ParameterSet const &varsPSet = params.getParameter<edm::ParameterSet>("variables");
    for (const std::string &vname : varsPSet.getParameterNamesForType<edm::ParameterSet>()) {
      const auto &varPSet = varsPSet.getParameter<edm::ParameterSet>(vname);
      const std::string &type = varPSet.getParameter<std::string>("type");
      if (type == "int")
        vars_.push_back(new IntVar(vname, nanoaod::FlatTable::IntColumn, varPSet));
      else if (type == "float")
        vars_.push_back(new FloatVar(vname, nanoaod::FlatTable::FloatColumn, varPSet));
      else if (type == "uint8")
        vars_.push_back(new UInt8Var(vname, nanoaod::FlatTable::UInt8Column, varPSet));
      else if (type == "bool")
        vars_.push_back(new BoolVar(vname, nanoaod::FlatTable::BoolColumn, varPSet));
      else
        throw cms::Exception("Configuration", "unsupported type " + type + " for variable " + vname);
    }
 
    produces<nanoaod::FlatTable>();
  }
 
  ~SimpleFlatTableProducerBase() override {}
 
  // this is to be overriden by the child class
  virtual std::unique_ptr<nanoaod::FlatTable> fillTable(const edm::Event &iEvent,
                                                        const edm::Handle<TProd> &prod) const = 0;
 
  void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override {
    edm::Handle<TProd> src;
    iEvent.getByToken(src_, src);
 
    std::unique_ptr<nanoaod::FlatTable> out = fillTable(iEvent, src);
    out->setDoc(doc_);
 
    iEvent.put(std::move(out));
  }
 
protected:
  const std::string name_;
  const std::string doc_;
  const bool extension_;
  const edm::EDGetTokenT<TProd> src_;
 
  class VariableBase {
  public:
    VariableBase(const std::string &aname, nanoaod::FlatTable::ColumnType atype, const edm::ParameterSet &cfg)
        : name_(aname),
          doc_(cfg.getParameter<std::string>("doc")),
          type_(atype),
          precision_(cfg.existsAs<int>("precision") ? cfg.getParameter<int>("precision")
                                                    : (cfg.existsAs<std::string>("precision") ? -2 : -1)) {}
    virtual ~VariableBase() {}
    const std::string &name() const { return name_; }
    const nanoaod::FlatTable::ColumnType &type() const { return type_; }
 
  protected:
    std::string name_, doc_;
    nanoaod::FlatTable::ColumnType type_;
    int precision_;
  };
  class Variable : public VariableBase {
  public:
    Variable(const std::string &aname, nanoaod::FlatTable::ColumnType atype, const edm::ParameterSet &cfg)
        : VariableBase(aname, atype, cfg) {}
    virtual void fill(std::vector<const T *> selobjs, nanoaod::FlatTable &out) const = 0;
  };
  template <typename StringFunctor, typename ValType>
  class FuncVariable : public Variable {
  public:
    FuncVariable(const std::string &aname, nanoaod::FlatTable::ColumnType atype, const edm::ParameterSet &cfg)
        : Variable(aname, atype, cfg),
          func_(cfg.getParameter<std::string>("expr"), true),
          precisionFunc_(cfg.existsAs<std::string>("precision") ? cfg.getParameter<std::string>("precision") : "23",
                         true) {}
    ~FuncVariable() override {}
    void fill(std::vector<const T *> selobjs, nanoaod::FlatTable &out) const override {
      std::vector<ValType> vals(selobjs.size());
      for (unsigned int i = 0, n = vals.size(); i < n; ++i) {
        if (this->precision_ == -2) {
          vals[i] = MiniFloatConverter::reduceMantissaToNbitsRounding(func_(*selobjs[i]), precisionFunc_(*selobjs[i]));
        } else
          vals[i] = func_(*selobjs[i]);
      }
      out.template addColumn<ValType>(this->name_, vals, this->doc_, this->type_, this->precision_);
    }
 
  protected:
    StringFunctor func_;
    StringFunctor precisionFunc_;
  };
  typedef FuncVariable<StringObjectFunction<T>, int> IntVar;
  typedef FuncVariable<StringObjectFunction<T>, float> FloatVar;
  typedef FuncVariable<StringObjectFunction<T>, uint8_t> UInt8Var;
  typedef FuncVariable<StringCutObjectSelector<T>, uint8_t> BoolVar;
  boost::ptr_vector<Variable> vars_;
};
 
template <typename T>
class SimpleFlatTableProducer : public SimpleFlatTableProducerBase<T, edm::View<T>> {
public:
  typedef SimpleFlatTableProducerBase<T, edm::View<T>> base;
 
  SimpleFlatTableProducer(edm::ParameterSet const &params)
      : SimpleFlatTableProducerBase<T, edm::View<T>>(params),
        singleton_(params.getParameter<bool>("singleton")),
        maxLen_(params.existsAs<unsigned int>("maxLen") ? params.getParameter<unsigned int>("maxLen")
                                                        : std::numeric_limits<unsigned int>::max()),
        cut_(!singleton_ ? params.getParameter<std::string>("cut") : "", true) {
    if (params.existsAs<edm::ParameterSet>("externalVariables")) {
      edm::ParameterSet const &extvarsPSet = params.getParameter<edm::ParameterSet>("externalVariables");
      for (const std::string &vname : extvarsPSet.getParameterNamesForType<edm::ParameterSet>()) {
        const auto &varPSet = extvarsPSet.getParameter<edm::ParameterSet>(vname);
        const std::string &type = varPSet.getParameter<std::string>("type");
        if (type == "int")
          extvars_.push_back(new IntExtVar(vname, nanoaod::FlatTable::IntColumn, varPSet, this->consumesCollector()));
        else if (type == "float")
          extvars_.push_back(
              new FloatExtVar(vname, nanoaod::FlatTable::FloatColumn, varPSet, this->consumesCollector()));
        else if (type == "double")
          extvars_.push_back(
              new DoubleExtVar(vname, nanoaod::FlatTable::FloatColumn, varPSet, this->consumesCollector()));
        else if (type == "uint8")
          extvars_.push_back(
              new UInt8ExtVar(vname, nanoaod::FlatTable::UInt8Column, varPSet, this->consumesCollector()));
        else if (type == "bool")
          extvars_.push_back(new BoolExtVar(vname, nanoaod::FlatTable::BoolColumn, varPSet, this->consumesCollector()));
        else
          throw cms::Exception("Configuration", "unsupported type " + type + " for variable " + vname);
      }
    }
  }
 
  ~SimpleFlatTableProducer() override {}
 
  std::unique_ptr<nanoaod::FlatTable> fillTable(const edm::Event &iEvent,
                                                const edm::Handle<edm::View<T>> &prod) const override {
    std::vector<const T *> selobjs;
    std::vector<edm::Ptr<T>> selptrs;  // for external variables
    if (singleton_) {
      assert(prod->size() == 1);
      selobjs.push_back(&(*prod)[0]);
      if (!extvars_.empty())
        selptrs.emplace_back(prod->ptrAt(0));
    } else {
      for (unsigned int i = 0, n = prod->size(); i < n; ++i) {
        const auto &obj = (*prod)[i];
        if (cut_(obj)) {
          selobjs.push_back(&obj);
          if (!extvars_.empty())
            selptrs.emplace_back(prod->ptrAt(i));
        }
        if (selobjs.size() >= maxLen_)
          break;
      }
    }
    auto out = std::make_unique<nanoaod::FlatTable>(selobjs.size(), this->name_, singleton_, this->extension_);
    for (const auto &var : this->vars_)
      var.fill(selobjs, *out);
    for (const auto &var : this->extvars_)
      var.fill(iEvent, selptrs, *out);
    return out;
  }
 
protected:
  bool singleton_;
  const unsigned int maxLen_;
  const StringCutObjectSelector<T> cut_;
 
  class ExtVariable : public base::VariableBase {
  public:
    ExtVariable(const std::string &aname, nanoaod::FlatTable::ColumnType atype, const edm::ParameterSet &cfg)
        : base::VariableBase(aname, atype, cfg) {}
    virtual void fill(const edm::Event &iEvent, std::vector<edm::Ptr<T>> selptrs, nanoaod::FlatTable &out) const = 0;
  };
  template <typename TIn, typename ValType = TIn>
  class ValueMapVariable : public ExtVariable {
  public:
    ValueMapVariable(const std::string &aname,
                     nanoaod::FlatTable::ColumnType atype,
                     const edm::ParameterSet &cfg,
                     edm::ConsumesCollector &&cc)
        : ExtVariable(aname, atype, cfg),
          token_(cc.consumes<edm::ValueMap<TIn>>(cfg.getParameter<edm::InputTag>("src"))) {}
    void fill(const edm::Event &iEvent, std::vector<edm::Ptr<T>> selptrs, nanoaod::FlatTable &out) const override {
      edm::Handle<edm::ValueMap<TIn>> vmap;
      iEvent.getByToken(token_, vmap);
      std::vector<ValType> vals(selptrs.size());
      for (unsigned int i = 0, n = vals.size(); i < n; ++i) {
        vals[i] = (*vmap)[selptrs[i]];
      }
      out.template addColumn<ValType>(this->name_, vals, this->doc_, this->type_, this->precision_);
    }
 
  protected:
    edm::EDGetTokenT<edm::ValueMap<TIn>> token_;
  };
  typedef ValueMapVariable<int> IntExtVar;
  typedef ValueMapVariable<float> FloatExtVar;
  typedef ValueMapVariable<double, float> DoubleExtVar;
  typedef ValueMapVariable<bool, uint8_t> BoolExtVar;
  typedef ValueMapVariable<int, uint8_t> UInt8ExtVar;
  boost::ptr_vector<ExtVariable> extvars_;
};
 
template <typename T>
class EventSingletonSimpleFlatTableProducer : public SimpleFlatTableProducerBase<T, T> {
public:
  EventSingletonSimpleFlatTableProducer(edm::ParameterSet const &params) : SimpleFlatTableProducerBase<T, T>(params) {}
 
  ~EventSingletonSimpleFlatTableProducer() override {}
 
  std::unique_ptr<nanoaod::FlatTable> fillTable(const edm::Event &, const edm::Handle<T> &prod) const override {
    auto out = std::make_unique<nanoaod::FlatTable>(1, this->name_, true, this->extension_);
    std::vector<const T *> selobjs(1, prod.product());
    for (const auto &var : this->vars_)
      var.fill(selobjs, *out);
    return out;
  }
};
 
template <typename T>
class FirstObjectSimpleFlatTableProducer : public SimpleFlatTableProducerBase<T, edm::View<T>> {
public:
  FirstObjectSimpleFlatTableProducer(edm::ParameterSet const &params)
      : SimpleFlatTableProducerBase<T, edm::View<T>>(params) {}
 
  ~FirstObjectSimpleFlatTableProducer() override {}
 
  std::unique_ptr<nanoaod::FlatTable> fillTable(const edm::Event &iEvent,
                                                const edm::Handle<edm::View<T>> &prod) const override {
    auto out = std::make_unique<nanoaod::FlatTable>(1, this->name_, true, this->extension_);
    std::vector<const T *> selobjs(1, &(*prod)[0]);
    for (const auto &var : this->vars_)
      var.fill(selobjs, *out);
    return out;
  }
};