ProcForeach.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     MVAComputer
// Class  :     ProcForeach
// 

// Implementation:
//     Loops over a specified amount of VarProcessors and passes each
//     instance of a set of variables individually per iteration.
//
// Author:      Christophe Saout
// Created:     Sat Apr 24 15:18 CEST 2007
//

#include <algorithm>

#include "FWCore/Utilities/interface/Exception.h"

#include "PhysicsTools/MVAComputer/interface/Variable.h"
#include "PhysicsTools/MVAComputer/interface/VarProcessor.h"
#include "PhysicsTools/MVAComputer/interface/Calibration.h"

using namespace PhysicsTools;

namespace { // anonymous

class ProcForeach : public VarProcessor {
    public:
    typedef VarProcessor::Registry::Registry<ProcForeach,
                    Calibration::ProcForeach> Registry;

    ProcForeach(const char *name,
                 const Calibration::ProcForeach *calib,
                 const MVAComputer *computer);
    ~ProcForeach() override {}

    void configure(ConfIterator iter, unsigned int n) override;
    ConfigCtx::Context *
    configureLoop(ConfigCtx::Context *ctx, ConfigCtx::iterator begin,
                  ConfigCtx::iterator cur, ConfigCtx::iterator end) override;

    void eval(ValueIterator iter, unsigned int n) const override;
    std::vector<double> deriv(
                ValueIterator iter, unsigned int n) const override;
    LoopStatus loop(double *output, int *conf,
                            unsigned int nOutput,
                                LoopCtx& ctx,
                            unsigned int &nOffset) const override;

    private:
    struct ConfContext : public VarProcessor::ConfigCtx::Context {
        ConfContext(unsigned int origin, unsigned int count) :
            origin(origin), count(count) {}
        ~ConfContext() override {}

        unsigned int origin;
        unsigned int count;
    };

    unsigned int        count;
};

ProcForeach::Registry registry("ProcForeach");

ProcForeach::ProcForeach(const char *name,
                         const Calibration::ProcForeach *calib,
                         const MVAComputer *computer) :
    VarProcessor(name, calib, computer),
    count(calib->nProcs)
{
}

void ProcForeach::configure(ConfIterator iter, unsigned int n)
{
    iter << Variable::FLAG_NONE;
    while(iter)
        iter << iter++(Variable::FLAG_MULTIPLE);
}

VarProcessor::ConfigCtx::Context *
ProcForeach::configureLoop(ConfigCtx::Context *ctx_, ConfigCtx::iterator begin,
                           ConfigCtx::iterator cur, ConfigCtx::iterator end)
{
    ConfContext *ctx = dynamic_cast<ConfContext*>(ctx_);
    if (!ctx)
        return new ConfContext(cur - begin + 1, count);

    for(ConfigCtx::iterator iter = cur; iter != end; iter++) {
        iter->mask = Variable::FLAG_ALL;
        iter->origin = ctx->origin;
    }

    if (--ctx->count)
        return ctx;
    else
        return nullptr;
}

void ProcForeach::eval(ValueIterator iter, unsigned int n) const
{
        auto const offset = iter.loopCtx().offset();
    iter(offset);

        auto& loopSize = iter.loopCtx().size();
    while(iter) {
        unsigned int size = iter.size();
        if (!loopSize)
            loopSize = size;

        double value = iter[offset];
        iter(value);
        iter++;
    }
}

std::vector<double> ProcForeach::deriv(
                ValueIterator iter, unsigned int n) const
{
        auto const offset = iter.loopCtx().offset();
    std::vector<unsigned int> offsets;
    unsigned int in = 0, out = 0;
    while(iter) {
        offsets.push_back(in + offset);
        in += (iter++).size();
        out++;
    }

    std::vector<double> result((out + 1) * in, 0.0);
    for(unsigned int i = 0; i < out; i++)
        result[(i + 1) * in + offsets[i]] = 1.0;

    return result;
}

VarProcessor::LoopStatus
ProcForeach::loop(double *output, int *conf,
                  unsigned int nOutput, LoopCtx& ctx, unsigned int &nOffset) const
{
        auto& index = ctx.index();
    bool endIteration = false;
    if (index++ == count) {
        index = 0;
        endIteration = true;
    }
        auto& offset = ctx.offset();
        auto& size = ctx.size();

    if (offset == 0 && !endIteration) {
        for(int cur = *conf + size; nOutput--; cur += size)
            *++conf = cur;
    }

    if (endIteration) {
        if (++offset >= size) {
            return kStop;
        } else
            return kReset;
    } else if (offset > size) {
        return kSkip;
    } else {
        nOffset = offset;
        return kNext;
    }
}

} // anonymous namespace