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