MVAComputer.h

Go to the documentation of this file.

#ifndef PhysicsTools_MVAComputer_MVAComputer_h
#define PhysicsTools_MVAComputer_MVAComputer_h
// -*- C++ -*-
//
// Package:     MVAComputer
// Class  :     MVAComputer
//

//
// Author:  Christophe Saout <christophe.saout@cern.ch>
// Created:     Sat Apr 24 15:18 CEST 2007
//

#include <iostream>
#include <vector>
#include <memory>

#include "PhysicsTools/MVAComputer/interface/CalibrationFwd.h"
#include "PhysicsTools/MVAComputer/interface/VarProcessor.h"
#include "PhysicsTools/MVAComputer/interface/Variable.h"
#include "PhysicsTools/MVAComputer/interface/AtomicId.h"

namespace PhysicsTools {

class MVAComputer {
    public:
    MVAComputer(const Calibration::MVAComputer *calib);

    MVAComputer(Calibration::MVAComputer *calib, bool owned = false);

    ~MVAComputer();

    template<typename Iterator_t>
    double eval(Iterator_t first, Iterator_t last) const;

    template<typename Iterator_t>
    double deriv(Iterator_t first, Iterator_t last) const;

    template<typename Container_t>
    inline double eval(const Container_t &values) const
    {
        typedef typename Container_t::const_iterator Iterator_t;
        return this->template eval<Iterator_t>(
                        values.begin(), values.end());
    }

    template<typename Container_t>
    inline double deriv(Container_t &values) const
    {
        typedef typename Container_t::iterator Iterator_t;
        return this->template deriv<Iterator_t>(
                        values.begin(), values.end());
    }

    /* various methods for standalone use of calibration files */

    static Calibration::MVAComputer *readCalibration(const char *filename);

    static Calibration::MVAComputer *readCalibration(std::istream &is);

    static void writeCalibration(const char *filename,
                                 const Calibration::MVAComputer *calib);

    static void writeCalibration(std::ostream &os,
                                 const Calibration::MVAComputer *calib);

    MVAComputer(const char *filename);

    MVAComputer(std::istream &is);

    struct InputVar {
        Variable    var; 

        unsigned int    index;

        unsigned int    multiplicity;

        bool operator < (AtomicId id) const
        { return var.getName() < id; }

        bool operator < (const InputVar &other) const
        { return var.getName() < other.var.getName(); }
    };

    struct Processor {
        inline Processor(VarProcessor *processor,
                         unsigned int nOutput) :
            processor(processor), nOutput(nOutput) {}

        inline Processor(const Processor &orig)
        { processor = orig.processor; nOutput = orig.nOutput; }

        inline Processor &operator = (const Processor &orig)
        { processor = orig.processor; nOutput = orig.nOutput; return *this; }

        mutable std::auto_ptr<VarProcessor> processor;

        unsigned int                nOutput;
    };

    struct EvalContext {
        EvalContext(double *values, int *conf, unsigned int n) :
            values_(values), conf_(conf), n_(n) {}

        inline void eval(const VarProcessor *proc, int *outConf,
                         double *output, int *loop,
                                 VarProcessor::LoopCtx& ctx,
                         unsigned int offset, unsigned int out) const
                { proc->eval(values_, conf_, output, outConf, loop, ctx, offset); }

        inline double output(unsigned int output) const
        { return values_[conf_[output]]; }

        inline double *values() const { return values_; }
        inline int *conf() const { return conf_; }
        inline unsigned int n() const { return n_; }

        double      *values_;
        int     *conf_;
        unsigned int    n_;
    };

    struct DerivContext {
        DerivContext() : n_(0) {}

        void eval(const VarProcessor *proc, int *outConf,
                  double *output, int *loop, 
                          VarProcessor::LoopCtx& ctx,
                  unsigned int offset, unsigned int out) const;

        double output(unsigned int output,
                      std::vector<double> &derivs) const;

        inline double *values() const { return &values_.front(); }
        inline int *conf() const { return &conf_.front(); }
        inline unsigned int n() const { return n_; }

        mutable std::vector<double> values_;
        mutable std::vector<double> deriv_;
        mutable std::vector<int>    conf_;
        unsigned int            n_;
    };
    
    private:
    void setup(const Calibration::MVAComputer *calib);

    int getVariableId(AtomicId name) const;

    template<class T> void evalInternal(T &ctx) const;

    std::vector<InputVar>   inputVariables;

    std::vector<Processor>  varProcessors;

    unsigned int        nVars;

    unsigned int        output;

    std::auto_ptr<Calibration::MVAComputer> owned;
};

} // namespace PhysicsTools

#include "PhysicsTools/MVAComputer/interface/MVAComputer.icc"

#endif // PhysicsTools_MVAComputer_MVAComputer_h