/data/refman/pasoursint/CMSSW_6_1_1/src/PhysicsTools/MVAComputer/interface/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
// $Id: VarProcessor.h,v 1.9 2009/06/03 09:50:14 saout Exp $
//

#include <algorithm>
#include <vector>

#include "FWCore/PluginManager/interface/PluginFactory.h"

#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(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;
        };

        virtual ~VarProcessor();

        void configure(ConfigCtx &config);

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

        void deriv(double *input, int *conf, double *output, int *outConf,
                   int *loop, 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,
                                unsigned int &nOffset) const
        { return kStop; }

        struct Dummy {};
        typedef edmplugin::PluginFactory<Dummy*()> PluginFactory;

    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; }

                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, unsigned int offset) :
                        cur(cur), 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;
                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

#define MVA_COMPUTER_DEFINE_PLUGIN(T) \
        DEFINE_EDM_PLUGIN(::PhysicsTools::VarProcessor::PluginFactory, \
                          ::PhysicsTools::VarProcessor::Dummy, \
                          "VarProcessor/" #T)

#endif // PhysicsTools_MVAComputer_VarProcessor_h