StorableInterpolationFunctor.h

Go to the documentation of this file.

#ifndef NPSTAT_STORABLEINTERPOLATIONFUNCTOR_HH_
#define NPSTAT_STORABLEINTERPOLATIONFUNCTOR_HH_
 
#include "JetMETCorrections/InterpolationTables/interface/StorableMultivariateFunctor.h"
#include "JetMETCorrections/InterpolationTables/interface/LinInterpolatedTableND.h"
#include "JetMETCorrections/InterpolationTables/interface/SimpleFunctors.h"
 
namespace npstat {
  template <class Numeric, class Axis = UniformAxis, class Converter = Same<Numeric> >
  class StorableInterpolationFunctor : public StorableMultivariateFunctor {
    template <typename Num2, typename Axis2, typename Conv2>
    friend class StorableInterpolationFunctor;
 
  public:
    typedef LinInterpolatedTableND<Numeric, Axis> Table;
 
 
    template <class Num2>
    inline StorableInterpolationFunctor(const LinInterpolatedTableND<Num2, Axis>& table)
        : StorableMultivariateFunctor(), table_(table) {}
 
    template <class Num2>
    inline StorableInterpolationFunctor(const LinInterpolatedTableND<Num2, Axis>& table, const std::string& descr)
        : StorableMultivariateFunctor(descr), table_(table) {}
 
    template <class Num2, class Conv2>
    inline StorableInterpolationFunctor(const StorableInterpolationFunctor<Num2, Axis, Conv2>& tab)
        : StorableMultivariateFunctor(tab.description()), table_(tab.table_) {}
 
 
    inline StorableInterpolationFunctor(const std::vector<Axis>& axes,
                                        const std::vector<std::pair<bool, bool> >& interpolationType,
                                        const char* functionLabel = nullptr)
        : StorableMultivariateFunctor(), table_(axes, interpolationType, functionLabel) {}
 
    inline StorableInterpolationFunctor(const Axis& xAxis, bool leftX, bool rightX, const char* functionLabel = nullptr)
        : StorableMultivariateFunctor(), table_(xAxis, leftX, rightX, functionLabel) {}
 
    inline StorableInterpolationFunctor(const Axis& xAxis,
                                        bool leftX,
                                        bool rightX,
                                        const Axis& yAxis,
                                        bool leftY,
                                        bool rightY,
                                        const char* functionLabel = nullptr)
        : StorableMultivariateFunctor(), table_(xAxis, leftX, rightX, yAxis, leftY, rightY, functionLabel) {}
 
    inline StorableInterpolationFunctor(const Axis& xAxis,
                                        bool leftX,
                                        bool rightX,
                                        const Axis& yAxis,
                                        bool leftY,
                                        bool rightY,
                                        const Axis& zAxis,
                                        bool leftZ,
                                        bool rightZ,
                                        const char* functionLabel = nullptr)
        : StorableMultivariateFunctor(),
          table_(xAxis, leftX, rightX, yAxis, leftY, rightY, zAxis, leftZ, rightZ, functionLabel) {}
 
    inline StorableInterpolationFunctor(const Axis& xAxis,
                                        bool leftX,
                                        bool rightX,
                                        const Axis& yAxis,
                                        bool leftY,
                                        bool rightY,
                                        const Axis& zAxis,
                                        bool leftZ,
                                        bool rightZ,
                                        const Axis& tAxis,
                                        bool leftT,
                                        bool rightT,
                                        const char* functionLabel = nullptr)
        : StorableMultivariateFunctor(),
          table_(
              xAxis, leftX, rightX, yAxis, leftY, rightY, zAxis, leftZ, rightZ, tAxis, leftT, rightT, functionLabel) {}
 
    inline StorableInterpolationFunctor(const Axis& xAxis,
                                        bool leftX,
                                        bool rightX,
                                        const Axis& yAxis,
                                        bool leftY,
                                        bool rightY,
                                        const Axis& zAxis,
                                        bool leftZ,
                                        bool rightZ,
                                        const Axis& tAxis,
                                        bool leftT,
                                        bool rightT,
                                        const Axis& vAxis,
                                        bool leftV,
                                        bool rightV,
                                        const char* functionLabel = nullptr)
        : StorableMultivariateFunctor(),
          table_(xAxis,
                 leftX,
                 rightX,
                 yAxis,
                 leftY,
                 rightY,
                 zAxis,
                 leftZ,
                 rightZ,
                 tAxis,
                 leftT,
                 rightT,
                 vAxis,
                 leftV,
                 rightV,
                 functionLabel) {}
 
    ~StorableInterpolationFunctor() override {}
 
    unsigned minDim() const override { return table_.dim(); };
 
    double operator()(const double* point, unsigned dim) const override { return conv_(table_(point, dim)); }
 
 
    inline Table& interpolator() { return table_; }
    inline const Table& interpolator() const { return table_; }
 
 
    inline ArrayND<Numeric>& table() { return table_.table(); }
    inline const ArrayND<Numeric>& table() const { return table_.table(); }
 
    inline void setConverter(const Converter& conv) { conv_ = conv; }
 
    // Method related to "geners" I/O
    gs::ClassId classId() const override { return gs::ClassId(*this); }
    bool write(std::ostream& of) const override;
 
    // I/O methods needed for reading
    static inline const char* classname();
    static inline unsigned version() { return 1; }
    static StorableInterpolationFunctor* read(const gs::ClassId& id, std::istream& in);
 
  protected:
    bool isEqual(const StorableMultivariateFunctor& other) const override {
      // Note the use of static_cast rather than dynamic_cast below.
      // static_cast works faster and it is guaranteed to succeed here.
      const StorableInterpolationFunctor& r = static_cast<const StorableInterpolationFunctor&>(other);
      return table_ == r.table_ && this->description() == other.description();
    }
 
  private:
    StorableInterpolationFunctor() = delete;
 
    Table table_;
    Converter conv_;
  };
}  // namespace npstat
 
#include "Alignment/Geners/interface/binaryIO.hh"
#include "Alignment/Geners/interface/CPP11_auto_ptr.hh"
#include "Alignment/Geners/interface/IOException.hh"
 
namespace npstat {
  template <typename Numeric, class Axis, class Converter>
  const char* StorableInterpolationFunctor<Numeric, Axis, Converter>::classname() {
    static const std::string myClass(gs::template_class_name<Numeric, Axis>("npstat::StorableInterpolationFunctor"));
    return myClass.c_str();
  }
 
  template <typename Numeric, class Axis, class Converter>
  bool StorableInterpolationFunctor<Numeric, Axis, Converter>::write(std::ostream& of) const {
    gs::write_pod(of, this->description());
    return table_.classId().write(of) && table_.write(of);
  }
 
  template <typename Numeric, class Axis, class Converter>
  StorableInterpolationFunctor<Numeric, Axis, Converter>* StorableInterpolationFunctor<Numeric, Axis, Converter>::read(
      const gs::ClassId& id, std::istream& in) {
    static const gs::ClassId current(gs::ClassId::makeId<StorableInterpolationFunctor<Numeric, Axis> >());
    current.ensureSameId(id);
 
    std::string descr;
    gs::read_pod(in, &descr);
    gs::ClassId tabid(in, 1);
    if (in.fail())
      throw gs::IOReadFailure(
          "In npstat::StorableInterpolationFunctor::read: "
          "input stream failure");
    CPP11_auto_ptr<Table> tab(Table::read(tabid, in));
    return new StorableInterpolationFunctor(*tab, descr);
  }
}  // namespace npstat
 
#endif  // NPSTAT_STORABLEINTERPOLATIONFUNCTOR_HH_