/data/refman/pasoursint/CMSSW_4_2_9_HLT1_bphpatch4/src/PhysicsTools/MVATrainer/src/MVATrainerLooper.cc

Go to the documentation of this file.

#include <assert.h>
#include <algorithm>
#include <string>
#include <memory>

#include <boost/shared_ptr.hpp>

#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/Utilities/interface/EDMException.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ParameterSet/interface/FileInPath.h"

#include "CondFormats/PhysicsToolsObjects/interface/MVAComputer.h"

#include "PhysicsTools/MVATrainer/interface/MVATrainer.h"
#include "PhysicsTools/MVATrainer/interface/MVATrainerLooper.h"

namespace PhysicsTools {

namespace {
        template<typename T>
        struct deleter : public std::unary_function<T*, void> {
                inline void operator() (T *ptr) const { delete ptr; }
        };
}

// MVATrainerLooper::Trainer implementation

MVATrainerLooper::Trainer::Trainer(const edm::ParameterSet &params)
{
        const edm::Entry *entry = params.retrieveUntracked("trainDescription");
        if (!entry)
                throw edm::Exception(edm::errors::Configuration,
                                     "MissingParameter:")
                        << "The required parameter 'trainDescription' "
                           "was not specified." << std::endl;;
        std::string trainDescription;
        if (entry->typeCode() == 'F')
                trainDescription = entry->getFileInPath().fullPath();
        else
                trainDescription = entry->getString();

        bool useXSLT = params.getUntrackedParameter<bool>("useXSLT", false);
        bool doLoad = params.getUntrackedParameter<bool>("loadState", false);
        bool doSave = params.getUntrackedParameter<bool>("saveState", false);
        bool doMonitoring = params.getUntrackedParameter<bool>("monitoring", false);

        trainer.reset(new MVATrainer(trainDescription, useXSLT));

        if (doLoad)
                trainer->loadState();

        trainer->setAutoSave(doSave);
        trainer->setCleanup(!doSave);
        trainer->setMonitoring(doMonitoring);
}

// MVATrainerLooper::MVATrainerContainer implementation

MVATrainerLooper::TrainerContainer::~TrainerContainer()
{
        clear();
}

void MVATrainerLooper::TrainerContainer::clear()
{
        std::for_each(begin(), end(), deleter<Trainer>());
        content.clear();
}

// MVATrainerLooper implementation

MVATrainerLooper::MVATrainerLooper(const edm::ParameterSet& iConfig)
{
}

MVATrainerLooper::~MVATrainerLooper()
{
}

void MVATrainerLooper::startingNewLoop(unsigned int iteration)
{
        for(TrainerContainer::const_iterator iter = trainers.begin();
            iter != trainers.end(); iter++) {
                Trainer *trainer = *iter;

                trainer->trainCalib =
                        TrainObject(trainer->trainer->getTrainCalibration());
        }
}

edm::EDLooper::Status
MVATrainerLooper::duringLoop(const edm::Event &event,
                                   const edm::EventSetup &es)
{
        if (trainers.empty())
                return kStop;

        for(TrainerContainer::const_iterator iter = trainers.begin();
            iter != trainers.end(); iter++)
                if ((*iter)->getCalibration())
                        return kContinue;

        trainers.clear();
        return kStop;
}

edm::EDLooper::Status MVATrainerLooper::endOfLoop(const edm::EventSetup &es,
                                                  unsigned int iteration)
{
        if (trainers.empty())
                return kStop;

        for(TrainerContainer::const_iterator iter = trainers.begin();
            iter != trainers.end(); iter++) {
                Trainer *trainer = *iter;

                if (trainer->trainCalib)
                        trainer->trainer->doneTraining(
                                                trainer->trainCalib.get());

                trainer->trainCalib.reset();
        }

        return kContinue;
}

} // namespace PhysicsTools