VarProcessor.h

Go to the documentation of this file.

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

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

#include <algorithm>
#include <vector>

#include "PhysicsTools/MVAComputer/interface/ProcessRegistry.h"
#include "PhysicsTools/MVAComputer/interface/CalibrationFwd.h"
#include "PhysicsTools/MVAComputer/interface/Variable.h"
#include "PhysicsTools/MVAComputer/interface/BitSet.h"

namespace PhysicsTools {

// forward declaration
class MVAComputer;

class VarProcessor :
    public ProcessRegistry<VarProcessor,
                           Calibration::VarProcessor,
                           const MVAComputer>::Factory {
    public:
    struct Config {
        inline Config() : mask(Variable::FLAG_NONE), origin(0) {}
        inline Config(Variable::Flags mask, unsigned int origin) :
            mask(mask), origin(origin) {}

        Variable::Flags mask;
        unsigned int    origin;
    };

    class ConfigCtx {
        public:
        typedef std::vector<Config>     Config_t;

        typedef Config_t::value_type        value_type;
        typedef Config_t::size_type     size_type;
        typedef Config_t::iterator      iterator;
        typedef Config_t::const_iterator    const_iterator;

        struct Context { virtual ~Context() {} };

        ConfigCtx(const std::vector<Variable::Flags>& flags);
        ~ConfigCtx() { delete ctx; }

        inline size_type size() const { return configs.size(); }
        inline const_iterator begin() const { return configs.begin(); }
        inline iterator begin() { return configs.begin(); }
        inline const_iterator end() const { return configs.end(); }
        inline iterator end() { return configs.end(); }
        inline void push_back(const Config &config) { configs.push_back(config); }
        inline Config &operator [] (size_type i) { return configs[i]; }

        private:        
        friend class VarProcessor;

        Config_t    configs;
        VarProcessor    *loop;
        Context     *ctx;
    };

        
        class LoopCtx {
           public:
               LoopCtx(): index_(0), offset_(0), size_(0) {}
               inline unsigned int& index() { return index_;}
               inline unsigned int& offset() { return offset_;}
               inline unsigned int& size() { return size_;}
           private:
               unsigned int index_;
               unsigned int offset_;
               unsigned int size_ ;
        };

    virtual ~VarProcessor();

    void configure(ConfigCtx &config);

    inline void
    eval(double *input, int *conf, double *output, int *outConf,
         int *loop, LoopCtx& loopCtx, unsigned int offset) const
    {
        ValueIterator iter(inputVars.iter(), input, conf,
                           output, outConf, loop, loopCtx, offset);
        eval(iter, nInputVars);
    }

    void deriv(double *input, int *conf, double *output, int *outConf,
               int *loop, LoopCtx& ctx, unsigned int offset, unsigned int in,
               unsigned int out, std::vector<double> &deriv) const;

    enum LoopStatus { kStop, kNext, kReset, kSkip };

    virtual LoopStatus loop(double *output, int *outConf,
                            unsigned int nOutput,
                                LoopCtx& ctx,
                            unsigned int &nOffset) const
    { return kStop; }

   //used to create a PluginFactory
    struct Dummy {};
   typedef Dummy* PluginFunctionPrototype();

    protected:
    struct ConfIterator {
        public:
        ConfIterator &operator () (Variable::Flags mask)
        {
            config[cur()].mask =
                (Variable::Flags)(config[cur()].mask & mask);
            return *this;
        }

        ConfIterator &operator << (Config config_)
        { config.push_back(config_); return *this; }

        ConfIterator &operator << (Variable::Flags mask)
        { return *this << Config(mask, 0); }

        ConfIterator &operator << (const ConfIterator &origin)
        { return *this << Config(config[origin.cur()].mask, origin.cur()); }

        Variable::Flags operator * () const
        { return config[cur()].mask; }

        inline operator bool() const { return cur; }

        ConfIterator &operator ++ () { ++cur; return *this; }

        inline ConfIterator operator ++ (int dummy)
        { ConfIterator orig = *this; operator ++ (); return orig; }

        protected:
        friend class VarProcessor;

        ConfIterator(BitSet::Iterator cur, ConfigCtx &config) :
            cur(cur), config(config) {}

        private:
        BitSet::Iterator    cur;
        ConfigCtx       &config;
    };

    struct ValueIterator {
        public:
        inline unsigned int size() const
        { return loop ? (conf[1] - conf[0]) : 1; }

        inline double *begin() const { return values; }

        inline double *end() const { return values + size(); }

        inline bool empty() const { return begin() == end(); }

        inline double operator * ()
        { return *values; }

        inline double operator [] (unsigned int idx)
        { return values[idx]; }

        inline ValueIterator &operator << (double value)
        { *output++ = value; return *this; }

        inline void operator () ()
        {
            int pos = output - start;
            if (*++outConf > pos)
                output = start + *outConf;
            else
                *outConf = pos;
        }

        inline void operator () (double value)
        { *this << value; (*this)(); }

        inline operator bool() const { return cur; }

                inline LoopCtx& loopCtx() { return ctx;}

        ValueIterator &operator ++ ()
        {
            BitSet::size_t orig = cur();
            if (++cur) {
                unsigned int prev = *conf;
                conf += cur() - orig; 
                values += *conf - prev;
                if (loop && conf >= loop) {
                    values += offset;
                    loop = 0;
                }
            }
            return *this;
        }

        inline ValueIterator operator ++ (int dummy)
        { ValueIterator orig = *this; operator ++ (); return orig; }

        protected:
        friend class VarProcessor;

        ValueIterator(BitSet::Iterator cur, double *values,
                      int *conf, double *output, int *outConf,
                      int *loop, LoopCtx& ctx, unsigned int offset) :
                        cur(cur), ctx(ctx), offset(offset), start(values + offset),
            values(values), conf(conf), loop(loop),
            output(output + offset), outConf(outConf)
        {
            this->conf += cur();
            this->values += *this->conf;
            if (loop && this->conf >= loop) {
                this->values += offset;
                this->loop = 0;
            }
        }

        private:
        BitSet::Iterator    cur;
                LoopCtx&                ctx;
        const unsigned int  offset;
        double          *const start;
        double          *values;
        const int       *conf;
        const int       *loop;
        double          *output;
        int         *outConf;
    };

    typedef ProcessRegistry<VarProcessor,
                        Calibration::VarProcessor,
                        const MVAComputer> Registry;

    VarProcessor(const char *name, const Calibration::VarProcessor *calib,
                 const MVAComputer *computer);

    virtual void configure(ConfIterator iter, unsigned int n) = 0;

    virtual ConfigCtx::Context *
    configureLoop(ConfigCtx::Context *ctx, ConfigCtx::iterator begin,
                  ConfigCtx::iterator cur, ConfigCtx::iterator end);

    virtual void eval(ValueIterator iter, unsigned int n) const = 0;

    virtual std::vector<double> deriv(ValueIterator iter,
                                      unsigned int n) const
    { return std::vector<double>(); }

    protected:
    const MVAComputer   *computer;

    private:
    BitSet          inputVars;
    unsigned int        nInputVars;
};

template<>
VarProcessor *ProcessRegistry<VarProcessor, Calibration::VarProcessor,
                              const MVAComputer>::Factory::create(
    const char*, const Calibration::VarProcessor*, const MVAComputer*);

} // namespace PhysicsTools


#endif // PhysicsTools_MVAComputer_VarProcessor_h