/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_13_patch3/src/RecoBTau/JetTagComputer/src/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"

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)
{
        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()
{
}

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;

                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::auto_ptr<GenericMVAComputer>(
                                        new GenericMVAComputer(computerCalib));

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

                changed = true;
                empty = false;
        }

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

        return changed;
}