---

ProcLinear.cc

Go to the documentation of this file.

#include <iostream>
#include <vector>
#include <memory>

#include <xercesc/dom/DOM.hpp>

#include "FWCore/Utilities/interface/Exception.h"

#include "PhysicsTools/MVAComputer/interface/AtomicId.h"

#include "PhysicsTools/MVATrainer/interface/XMLDocument.h"
#include "PhysicsTools/MVATrainer/interface/MVATrainer.h"
#include "PhysicsTools/MVATrainer/interface/TrainProcessor.h"
#include "PhysicsTools/MVATrainer/interface/LeastSquares.h"

XERCES_CPP_NAMESPACE_USE

using namespace PhysicsTools;

namespace { // anonymous

class ProcLinear : public TrainProcessor {
    public:
        typedef TrainProcessor::Registry<ProcLinear>::Type Registry;

        ProcLinear(const char *name, const AtomicId *id,
                   MVATrainer *trainer);
        virtual ~ProcLinear();

        virtual void configure(DOMElement *elem);
        virtual Calibration::VarProcessor *getCalibration() const;

        virtual void trainBegin();
        virtual void trainData(const std::vector<double> *values,
                               bool target, double weight);
        virtual void trainEnd();

        virtual bool load();
        virtual void save();

    protected:
        virtual void *requestObject(const std::string &name) const;

    private:
        enum Iteration {
                ITER_FILL,
                ITER_DONE
        } iteration;

        std::auto_ptr<LeastSquares>     ls;
        std::vector<double>             vars;
};

static ProcLinear::Registry registry("ProcLinear");

ProcLinear::ProcLinear(const char *name, const AtomicId *id,
                             MVATrainer *trainer) :
        TrainProcessor(name, id, trainer),
        iteration(ITER_FILL)
{
}

ProcLinear::~ProcLinear()
{
}

void ProcLinear::configure(DOMElement *elem)
{
        ls = std::auto_ptr<LeastSquares>(new LeastSquares(getInputs().size()));
}

Calibration::VarProcessor *ProcLinear::getCalibration() const
{
        Calibration::ProcLinear *calib = new Calibration::ProcLinear;

        calib->coeffs = ls->getWeights();
        calib->offset = ls->getConstant();

        return calib;
}

void ProcLinear::trainBegin()
{
        if (iteration == ITER_FILL)
                vars.resize(ls->getSize());
}

void ProcLinear::trainData(const std::vector<double> *values,
                           bool target, double weight)
{
        if (iteration != ITER_FILL)
                return;

        for(unsigned int i = 0; i < ls->getSize(); i++, values++)
                vars[i] = values->front();

        ls->add(vars, target, weight);
}

void ProcLinear::trainEnd()
{
        switch(iteration) {
            case ITER_FILL:
                vars.clear();
                ls->calculate();

                iteration = ITER_DONE;
                trained = true;
                break;
            default:
                /* shut up */;
        }
}

void *ProcLinear::requestObject(const std::string &name) const
{
        if (name == "linearAnalyzer")
                return static_cast<void*>(ls.get());

        return 0;
}

bool ProcLinear::load()
{
        std::string filename = trainer->trainFileName(this, "xml");
        if (!exists(filename))
                return false;

        XMLDocument xml(filename);
        DOMElement *elem = xml.getRootNode();
        if (std::strcmp(XMLSimpleStr(elem->getNodeName()), "ProcLinear") != 0)
                throw cms::Exception("ProcLinear")
                        << "XML training data file has bad root node."
                        << std::endl;

        DOMNode *node = elem->getFirstChild();
        while(node && node->getNodeType() != DOMNode::ELEMENT_NODE)
                node = node->getNextSibling();

        if (!node)
                throw cms::Exception("ProcLinear")
                        << "Train data file empty." << std::endl;

        ls->load(static_cast<DOMElement*>(node));

        node = elem->getNextSibling();
        while(node && node->getNodeType() != DOMNode::ELEMENT_NODE)
                node = node->getNextSibling();

        if (node)
                throw cms::Exception("ProcLinear")
                        << "Train data file contains superfluous tags."
                        << std::endl;

        iteration = ITER_DONE;
        trained = true;
        return true;
}

void ProcLinear::save()
{
        XMLDocument xml(trainer->trainFileName(this, "xml"), true);
        DOMDocument *doc = xml.createDocument("ProcLinear");

        xml.getRootNode()->appendChild(ls->save(doc));
}

} // anonymous namespace

---