/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/CondFormats/PhysicsToolsObjects/src/MVAComputer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     PhysicsToolsObjects
// Class  :     MVAComputer
// 

// Implementation:
//     getProcessor() and addProcessor() methods to add processors to
//     the discriminator computer calibration object. POOL doesn't support
//     polymorph pointers, so this is implemented using multiple containers
//     for each possible sub-class and an index array from which the
//     array of pointers can be reconstructed. In order to avoid having
//     to handle each sub-class container by hand here, the generated
//     reflex dictionary is used to find and read/write the std::vector<...>
//     containers for the individual classes in the private data members.
//     So changes can be solely done in the header files and does not leave
//     a trail elsewhere.
//
// Author:      Christophe Saout
// Created:     Sat Apr 24 15:18 CEST 2007
// $Id: MVAComputer.cc,v 1.10 2010/01/26 19:40:03 saout Exp $
//
#include <functional>
#include <algorithm>
#include <typeinfo>
#include <iostream>
#include <cstring>
#include <cstddef>

#include <boost/thread.hpp>

#include <Reflex/Reflex.h>

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

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

namespace PhysicsTools {
namespace Calibration {

std::string VarProcessor::getInstanceName() const
{
        static const char prefix[] = "PhysicsTools::Calibration::";
        std::string type = ROOT::Reflex::Tools::Demangle(typeid(*this));
        if (type.size() <= sizeof prefix - 1 ||
            type.substr(0, sizeof prefix - 1) != prefix)
                throw cms::Exception("MVAComputerCalibration")
                        << "getInstanceName failed for "
                        << typeid(*this).name() << "." << std::endl;

        return type.substr(sizeof prefix - 1);
}

std::string ProcExternal::getInstanceName() const
{
        return method;
}

static MVAComputer::CacheId getNextMVAComputerCacheId()
{
        static boost::mutex mutex;
        static MVAComputer::CacheId nextCacheId = 0;

        boost::mutex::scoped_lock scoped_lock(mutex);
        return ++nextCacheId;
}

MVAComputer::MVAComputer() :
        cacheId(getNextMVAComputerCacheId())
{
}

MVAComputer::MVAComputer(const MVAComputer &orig) :
        inputSet(orig.inputSet),
        output(orig.output),
        cacheId(orig.cacheId)
{
        for(std::vector<VarProcessor*>::const_iterator iter =
                                                orig.processors.begin();
            iter != orig.processors.end(); ++iter)
                addProcessor(*iter);
}

MVAComputer::~MVAComputer()
{
        for(std::vector<VarProcessor*>::iterator iter = processors.begin();
            iter != processors.end(); ++iter)
                delete *iter;
        processors.clear();
}

MVAComputer &MVAComputer::operator = (const MVAComputer &orig)
{
        inputSet = orig.inputSet;
        output = orig.output;
        cacheId = orig.cacheId;

        for(std::vector<VarProcessor*>::iterator iter = processors.begin();
            iter != processors.end(); ++iter)
                delete *iter;
        processors.clear();

        for(std::vector<VarProcessor*>::const_iterator iter =
                                                orig.processors.begin();
            iter != orig.processors.end(); ++iter)
                addProcessor(*iter);

        return *this;
}

std::vector<VarProcessor*> MVAComputer::getProcessors() const
{
        return processors;
}

void MVAComputer::addProcessor(const VarProcessor *proc)
{
        cacheId = getNextMVAComputerCacheId();

        ROOT::Reflex::Type baseType = ROOT::Reflex::GetType<VarProcessor>();
        ROOT::Reflex::Type type =
                                ROOT::Reflex::Type::ByTypeInfo(typeid(*proc));
        ROOT::Reflex::Type refType(type,
                                ROOT::Reflex::CONST & ROOT::Reflex::REFERENCE);
        if (!type.Name().size())
                throw cms::Exception("MVAComputerCalibration")
                        << "Calibration class " << typeid(*proc).name()
                        << " not registered with ROOT::Reflex."
                        << std::endl;

        ROOT::Reflex::Object obj =
                ROOT::Reflex::Object(baseType, const_cast<void*>(
                        static_cast<const void*>(proc))).CastObject(type);

        // find and call copy constructor
        for(ROOT::Reflex::Member_Iterator iter = type.FunctionMember_Begin();
            iter != type.FunctionMember_End(); iter++) {
                const ROOT::Reflex::Type &ctor = iter->TypeOf();
                if (!iter->IsConstructor() ||
                    ctor.FunctionParameterSize() != 1 ||
                    ctor.FunctionParameterAt(0).Id() != refType.Id())
                        continue;

                ROOT::Reflex::Object copy = type.Construct(ctor,
                        ROOT::Reflex::Tools::MakeVector<void*>(obj.Address()));

                processors.push_back(static_cast<VarProcessor*>(copy.Address()));
                return;
        }

        throw cms::Exception("MVAComputerCalibration")
                        << "Calibration class " << typeid(*proc).name()
                        << " has no copy ctor registered with ROOT::Reflex."
                        << std::endl;
}

static MVAComputerContainer::CacheId getNextMVAComputerContainerCacheId()
{
        static MVAComputerContainer::CacheId nextCacheId = 0;
        return ++nextCacheId;
}

MVAComputerContainer::MVAComputerContainer() :
        cacheId(getNextMVAComputerContainerCacheId())
{
}

MVAComputer &MVAComputerContainer::add(const std::string &label)
{
        cacheId = getNextMVAComputerContainerCacheId();

        entries.push_back(std::make_pair(label, MVAComputer()));
        return entries.back().second;
}

namespace {
        struct Comparator :
                public std::unary_function<const std::string&, bool> {

                inline Comparator(const std::string &label) : label(label) {}

                inline bool
                operator () (const MVAComputerContainer::Entry &entry) const
                { return entry.first == label; }

                const std::string &label;
        };
}

const MVAComputer &MVAComputerContainer::find(const std::string &label) const
{
        std::vector<Entry>::const_iterator pos =
                                std::find_if(entries.begin(), entries.end(),
                                             Comparator(label));

        if (pos == entries.end())
                throw cms::Exception("MVAComputerCalibration")
                        << "Calibration record " << label
                        << " not found in MVAComputerContainer." << std::endl;

        return pos->second;
}

} // namespace Calibration
} // namespace PhysicsTools