GenericMVAComputerCache.cc

Go to the documentation of this file.

#include <string>
#include <vector>
#include <memory>

#include "CondFormats/PhysicsToolsObjects/interface/MVAComputer.h"
#include "RecoBTau/JetTagComputer/interface/GenericMVAComputer.h"
#include "RecoBTau/JetTagComputer/interface/GenericMVAComputerCache.h"
#include "FWCore/Utilities/interface/Exception.h"

using namespace PhysicsTools::Calibration;

inline GenericMVAComputerCache::IndividualComputer::IndividualComputer() {}

inline GenericMVAComputerCache::IndividualComputer::IndividualComputer(const IndividualComputer &orig)
    : label(orig.label) {}

inline GenericMVAComputerCache::IndividualComputer::~IndividualComputer() {}

GenericMVAComputerCache::GenericMVAComputerCache(const std::vector<std::string> &labels)
    : computers(labels.size()),
      cacheId(MVAComputerContainer::CacheId()),
      initialized(false),
      empty(true),
      errorUpdatingLabel() {
  std::vector<IndividualComputer>::iterator computer = computers.begin();
  for (std::vector<std::string>::const_iterator iter = labels.begin(); iter != labels.end(); iter++) {
    computer->label = *iter;
    computer->cacheId = MVAComputer::CacheId();
    computer++;
  }
}

GenericMVAComputerCache::~GenericMVAComputerCache() {}

GenericMVAComputer const *GenericMVAComputerCache::getComputer(int index) const {
  if (!errorUpdatingLabel.empty()) {
    throw cms::Exception("MVAComputerCalibration")
        << "GenericMVAComputerCache::getComputer Error occurred during update.\n"
        << "Calibration record " << errorUpdatingLabel << " not found in MVAComputerContainer." << std::endl;
  }
  return index >= 0 ? computers[index].computer.get() : nullptr;
}

bool GenericMVAComputerCache::isEmpty() const {
  if (!errorUpdatingLabel.empty()) {
    throw cms::Exception("MVAComputerCalibration")
        << "GenericMVAComputerCache::isEmpty Error occurred during update.\n"
        << "Calibration record " << errorUpdatingLabel << " not found in MVAComputerContainer." << std::endl;
  }
  return empty;
}

bool GenericMVAComputerCache::update(const MVAComputerContainer *calib) {
  // check container for changes
  if (initialized && !calib->changed(cacheId))
    return false;

  empty = true;

  bool changed = false;
  for (std::vector<IndividualComputer>::iterator iter = computers.begin(); iter != computers.end(); iter++) {
    // empty labels means we don't want a computer
    if (iter->label.empty())
      continue;

    // Delay throwing if the label cannot be found until getComputer is called
    // Sometimes this cache is updated and never used.
    if (!calib->contains(iter->label)) {
      errorUpdatingLabel = iter->label;
      continue;
    }

    const MVAComputer *computerCalib = &calib->find(iter->label);
    if (!computerCalib) {
      iter->computer.reset();
      continue;
    }

    // check container content for changes
    if (iter->computer.get() && !computerCalib->changed(iter->cacheId)) {
      empty = false;
      continue;
    }

    // drop old computer
    iter->computer.reset();

    if (!computerCalib)
      continue;

    // instantiate new MVAComputer with uptodate calibration
    iter->computer = std::unique_ptr<GenericMVAComputer>(new GenericMVAComputer(computerCalib));

    iter->cacheId = computerCalib->getCacheId();

    changed = true;
    empty = false;
  }

  cacheId = calib->getCacheId();
  initialized = true;

  return changed;
}