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