PhysicsTools::MVAComputer Class Reference

Main interface class to the generic discriminator computer framework. More...

#include <MVAComputer.h>

Inheritance diagram for PhysicsTools::MVAComputer:

Classes
struct	DerivContext
struct	EvalContext
class	InputVar
	input variable configuration object More...
class	Processor
	variable processor container More...

Public Member Functions
template<typename Iterator_t >
double	deriv (Iterator_t first, Iterator_t last) const
template<typename Container_t >
double	deriv (Container_t &values) const
template<typename Iterator_t >
double	eval (Iterator_t first, Iterator_t last) const
	evaluate variables given by a range of iterators given by first and last More...
template<typename Container_t >
double	eval (const Container_t &values) const
	evaluate variables in iterable container values More...
	MVAComputer (const Calibration::MVAComputer *calib)
	construct a discriminator computer from a const calibation object More...
	MVAComputer (Calibration::MVAComputer *calib, bool owned=false)
	construct a discriminator computer from a calibation object More...
	MVAComputer (const char *filename)
	construct a discriminator computer from a calibration file More...
	MVAComputer (std::istream &is)
	construct a discriminator computer from C++ input stream More...
	~MVAComputer ()

Static Public Member Functions
static Calibration::MVAComputer *	readCalibration (const char *filename)
	read calibration object from plain file More...
static Calibration::MVAComputer *	readCalibration (std::istream &is)
	read calibration object from plain C++ input stream More...
static void	writeCalibration (const char *filename, const Calibration::MVAComputer *calib)
	write calibration object to file More...
static void	writeCalibration (std::ostream &os, const Calibration::MVAComputer *calib)
	write calibration object to pain C++ output stream More...

Private Member Functions
template<class T >
void	evalInternal (T &ctx) const
	evaluate discriminator from flattened variable array More...
int	getVariableId (AtomicId name) const
	map variable identifier name to the numerical position in the array More...
void	setup (const Calibration::MVAComputer *calib)
	construct processors from calibration and setup variables More...

Private Attributes
std::vector< InputVar >	inputVariables
	vector of input variables More...
unsigned int	nVars
	total number of variables to expect while computing discriminator More...
unsigned int	output
	index of the variable in the "conf" array to return as result More...
std::auto_ptr< Calibration::MVAComputer >	owned
	in case calibration object is owned by the MVAComputer More...
std::vector< Processor >	varProcessors
	vector of variable processors More...

Detailed Description

Main interface class to the generic discriminator computer framework.

The MVAComputer class represents an instance of the modular discriminator computer. It is constructed from a "calibration" object which contains all the required histograms, matrices and other trainina data required for computing the discriminator. The calibration data also defines the names and properties of variables that can passed to that instance of the discriminator computer. The evaluation methods then calculates the discriminator from a applicable set of input variables, i.e. vector of key-value pairs.

Definition at line 39 of file MVAComputer.h.

Constructor & Destructor Documentation

PhysicsTools::MVAComputer::MVAComputer

(

const Calibration::MVAComputer *

calib

)

construct a discriminator computer from a const calibation object

Definition at line 37 of file MVAComputer.cc.

References setup().

Referenced by deriv().

                                                            :
    nVars(0), output(0)
{
    setup(calib);
}

PhysicsTools::MVAComputer::MVAComputer	(	Calibration::MVAComputer *	calib,
		bool	owned = false
	)

construct a discriminator computer from a calibation object

Definition at line 43 of file MVAComputer.cc.

References setup().

                                                                  :
    nVars(0), output(0)
{
    if (owned)
        this->owned.reset(calib);
    setup(calib);
}

PhysicsTools::MVAComputer::~MVAComputer

(

)

Definition at line 142 of file MVAComputer.cc.

{
}

PhysicsTools::MVAComputer::MVAComputer

(

const char *

filename

)

construct a discriminator computer from a calibration file

Definition at line 51 of file MVAComputer.cc.

References owned, and setup().

                                             :
    nVars(0), output(0), owned(readCalibration(filename))
{
    setup(owned.get());
}

PhysicsTools::MVAComputer::MVAComputer

(

std::istream &

is

)

construct a discriminator computer from C++ input stream

Definition at line 57 of file MVAComputer.cc.

References owned, and setup().

                                       :
    nVars(0), output(0), owned(readCalibration(is))
{
    setup(owned.get());
}

Member Function Documentation

template<typename Iterator_t >

double PhysicsTools::MVAComputer::deriv	(	Iterator_t	first,
		Iterator_t	last
	)		const

template<typename Container_t >

double PhysicsTools::MVAComputer::deriv ( Container_t &  values ) const

inline

Definition at line 66 of file MVAComputer.h.

References corrVsCorr::filename, MVAComputer(), readCalibration(), and writeCalibration().

    {
        typedef typename Container_t::iterator Iterator_t;
        return this->template deriv<Iterator_t>(
                        values.begin(), values.end());
    }

template<typename Iterator_t >

double PhysicsTools::MVAComputer::eval	(	Iterator_t	first,
		Iterator_t	last
	)		const

evaluate variables given by a range of iterators given by first and last

Referenced by TtSemiLepJetCombMVATrainer::analyze(), PhysicsTools::MVAComputer::DerivContext::DerivContext(), evaluateTtFullHadSignalSel(), evaluateTtSemiLepSignalSel(), PhysicsTools::TreeReader::fill(), and TtSemiLepJetCombMVAComputer::produce().

template<typename Container_t >

double PhysicsTools::MVAComputer::eval ( const Container_t &  values ) const

inline

evaluate variables in iterable container values

Definition at line 58 of file MVAComputer.h.

    {
        typedef typename Container_t::const_iterator Iterator_t;
        return this->template eval<Iterator_t>(
                        values.begin(), values.end());
    }

template<class T >

template void PhysicsTools::MVAComputer::evalInternal ( T &  ctx ) const

private

evaluate discriminator from flattened variable array

Definition at line 158 of file MVAComputer.cc.

References gather_cfg::cout, mps_fire::i, inputVariables, PhysicsTools::VarProcessor::kNext, PhysicsTools::VarProcessor::kReset, PhysicsTools::VarProcessor::kSkip, PhysicsTools::VarProcessor::kStop, heppy_loop::loop, GetRecoTauVFromDQM_MC_cff::next, connectstrParser::o, PFRecoTauDiscriminationByIsolation_cfi::offset, output, mps_update::status, AlCaHLTBitMon_QueryRunRegistry::string, edm::typeDemangle(), findQualityFiles::v, and varProcessors.

Referenced by PhysicsTools::MVAComputer::DerivContext::output().

{
    
    double *output = ctx.values() + ctx.n();
    int *outConf = ctx.conf() + inputVariables.size();

#ifdef DEBUG_EVAL
    std::cout << "Input" << std::endl;
    double *v = ctx.values();
    for(int *o = ctx.conf(); o < outConf; o++) {
        std::cout << "\tVar " << (o - ctx.conf()) << std::endl;
        for(int i = o[0]; i < o[1]; i++)
            std::cout << "\t\t" << *v++ << std::endl;
    }
#endif
    std::vector<Processor>::const_iterator iter = varProcessors.begin();
    while(iter != varProcessors.end()) {
        std::vector<Processor>::const_iterator loop = iter;
        int *loopOutConf = outConf;
        int *loopStart = nullptr;
        double *loopOutput = output;
                VarProcessor::LoopCtx loopCtx;

        VarProcessor::LoopStatus status = VarProcessor::kNext;
        unsigned int offset = 0;
        while(status != VarProcessor::kStop) {
            std::vector<Processor>::const_iterator next = iter + 1;
            unsigned int nextOutput = (next != varProcessors.end())
                                      ? next->nOutput : 0;

#ifdef DEBUG_EVAL
        std::string demangledName;
        edm::typeDemangle(typeid(*iter->processor).name(), demangledName);
        std::cout << demangledName << std::endl;
#endif
            if (status != VarProcessor::kSkip)
                ctx.eval(&*iter->processor, outConf, output,
                         loopStart ? loopStart : loopOutConf,
                                         loopCtx,
                         offset, iter->nOutput);

#ifdef DEBUG_EVAL
            for(unsigned int i = 0; i < iter->nOutput;
                i++, outConf++) {
                std::cout << "\tVar " << (outConf - ctx.conf())
                          << std::endl;
                for(int j = outConf[0]; j < outConf[1]; j++)
                    std::cout << "\t\t" << *output++
                              << std::endl;
            }
#else
            int orig = *outConf;
            outConf += iter->nOutput;
            output += *outConf - orig;
#endif

            status = loop->processor->loop(output, outConf,
                                           nextOutput, loopCtx, offset);

            if (status == VarProcessor::kReset) {
                outConf = loopOutConf;
                output = loopOutput;
                loopStart = nullptr;
                offset = 0;
                iter = loop;
            } else {
                if (loop == iter)
                    loopStart = outConf;
                iter = next;
            }
        }
    }
}

int PhysicsTools::MVAComputer::getVariableId ( AtomicId  name ) const

private

map variable identifier name to the numerical position in the array

Definition at line 146 of file MVAComputer.cc.

References inputVariables, and dataset::name.

{

    std::vector<InputVar>::const_iterator pos = std::lower_bound(inputVariables.begin(), inputVariables.end(), name);

    if (pos == inputVariables.end() || pos->var.getName() != name)
        return -1;
    else
        return pos->index;
}

Calibration::MVAComputer * PhysicsTools::MVAComputer::readCalibration ( const char *  filename )

static

read calibration object from plain file

Definition at line 232 of file MVAComputer.cc.

References FrontierConditions_GlobalTag_cff::file.

Referenced by deriv(), and PhysicsTools::MVAComputerESSourceBase::produce().

{
    std::ifstream file(filename);
    return readCalibration(file);
}

Calibration::MVAComputer * PhysicsTools::MVAComputer::readCalibration ( std::istream &  is )

static

read calibration object from plain C++ input stream

Definition at line 238 of file MVAComputer.cc.

References edmScanValgrind::buffer, calib, Exception, RecoTauValidation_cfi::header, ext::basic_izstreambase< Item_t, Traits_t, Allocator_t >::rdbuf(), STANDALONE_HEADER, and AlCaHLTBitMon_QueryRunRegistry::string.

{
    if (!is.good())
        throw cms::Exception("InvalidFileState")
            << "Stream passed to MVAComputer::readCalibration "
               "has an invalid state." << std::endl;

    char header[sizeof STANDALONE_HEADER - 1] = { 0, };
    if (is.readsome(header, sizeof header) != sizeof header ||
        std::memcmp(header, STANDALONE_HEADER, sizeof header) != 0)
        throw cms::Exception("InvalidFileFormat")
            << "Stream passed to MVAComputer::readCalibration "
               "is not a valid calibration file." << std::endl;

    TClass *rootClass =
        TClass::GetClass("PhysicsTools::Calibration::MVAComputer");
    if (!rootClass)
        throw cms::Exception("DictionaryMissing")
            << "CondFormats dictionary for "
               "PhysicsTools::Calibration::MVAComputer missing"
            << std::endl;

    ext::izstream izs(&is);
    std::ostringstream ss;
    ss << izs.rdbuf();
    std::string buf = ss.str();

    TBufferFile buffer(TBuffer::kRead, buf.size(), const_cast<void*>(
            static_cast<const void*>(buf.c_str())), kFALSE);
    buffer.InitMap();

    std::auto_ptr<Calibration::MVAComputer> calib(
                    new Calibration::MVAComputer());
    buffer.StreamObject(static_cast<void*>(calib.get()), rootClass);

    return calib.release();
}

void PhysicsTools::MVAComputer::setup ( const Calibration::MVAComputer *  calib )

private

construct processors from calibration and setup variables

Definition at line 63 of file MVAComputer.cc.

References PhysicsTools::VarProcessor::ConfigCtx::begin(), calib, looper::config, PhysicsTools::VarProcessor::configure(), popcon2dropbox::copy(), PhysicsTools::ProcessRegistry< Base_t, CalibBase_t, Parent_t >::Factory::create(), PhysicsTools::VarProcessor::ConfigCtx::end(), Exception, PhysicsTools::Variable::FLAG_ALL, PhysicsTools::Variable::FLAG_MULTIPLE, flags, PhysicsTools::Calibration::MVAComputer::getProcessors(), mps_fire::i, PhysicsTools::MVAComputer::InputVar::index, PhysicsTools::TrainMVAComputerCalibration::initFlags(), PhysicsTools::Calibration::MVAComputer::inputSet, inputVariables, PhysicsTools::VarProcessor::Config::mask, PhysicsTools::MVAComputer::InputVar::multiplicity, dataset::name, nVars, PhysicsTools::VarProcessor::Config::origin, output, PhysicsTools::Calibration::MVAComputer::output, PhysicsTools::VarProcessor::ConfigCtx::size(), AlCaHLTBitMon_QueryRunRegistry::string, JetChargeProducer_cfi::var, PhysicsTools::MVAComputer::InputVar::var, objects.autophobj::variables, and varProcessors.

Referenced by MVAComputer().

{

    nVars = calib->inputSet.size();
    output = calib->output;

    std::vector<Variable::Flags> flags(nVars, Variable::FLAG_ALL);
    const TrainMVAComputerCalibration *trainCalib =
        dynamic_cast<const TrainMVAComputerCalibration*>(calib);
    if (trainCalib)
        trainCalib->initFlags(flags);

    VarProcessor::ConfigCtx config(flags);
    std::vector<Calibration::VarProcessor*> processors =
                            calib->getProcessors();

    for(std::vector<Calibration::VarProcessor*>::const_iterator iter =
                            processors.begin();
        iter != processors.end(); ++iter) {
        std::string name = (*iter)->getInstanceName();
        VarProcessor *processor =
            VarProcessor::create(name.c_str(), *iter, this);
        if (!processor)
            throw cms::Exception("UnknownProcessor")
                << name << " could not be instantiated."
                << std::endl;

        VarProcessor::ConfigCtx::iterator::difference_type pos =
                        config.end() - config.begin();
        processor->configure(config);
        unsigned int nOutput = (config.end() - config.begin()) - pos;
        if (!nOutput)
            throw cms::Exception("InvalidProcessor")
                << name << " rejected input variable "
                "configuration" << std::endl;

        varProcessors.push_back(Processor(processor, nOutput));
    }

    for(VarProcessor::ConfigCtx::iterator iter = config.begin() + nVars;
        iter != config.end(); iter++) {
        VarProcessor::Config *origin = &config[iter->origin];
        if (iter->origin >= nVars)
            iter->origin = origin->origin;

        if (iter->mask & Variable::FLAG_MULTIPLE) {
            iter->mask = (Variable::Flags)(iter->mask &
                                           origin->mask);
            config[iter->origin].origin++;
        }
    }

    nVars = config.size();

    if (output >= nVars)
            // FIXME || config[output].mask != Variable::FLAG_NONE)
        throw cms::Exception("InvalidOutput")
            << "Output variable at index " << output
            << " invalid." << std::endl;

    std::set<InputVar> variables;
    unsigned int i = 0;
    for(std::vector<Calibration::Variable>::const_iterator iter = calib->inputSet.begin(); iter != calib->inputSet.end(); ++iter, i++) {
        InputVar var;
        var.var = Variable(iter->name, config[i].mask);
        var.index = i;
        var.multiplicity = 0;
        variables.insert(var);
    }

    inputVariables.resize(i);

    std::copy(variables.begin(), variables.end(), inputVariables.begin());
    
    for(unsigned int j = 0; j < i; j++)
        inputVariables[j].multiplicity = config[j].origin;  

}

void PhysicsTools::MVAComputer::writeCalibration ( const char *  filename, const Calibration::MVAComputer *  calib  )

static

write calibration object to file

Definition at line 276 of file MVAComputer.cc.

References FrontierConditions_GlobalTag_cff::file.

Referenced by deriv(), and PhysicsTools::MVATrainerFileSave::endJob().

{
    std::ofstream file(filename);
    writeCalibration(file, calib);
}

void PhysicsTools::MVAComputer::writeCalibration ( std::ostream &  os, const Calibration::MVAComputer *  calib  )

static

write calibration object to pain C++ output stream

Definition at line 283 of file MVAComputer.cc.

References edmScanValgrind::buffer, Exception, and STANDALONE_HEADER.

{
    if (!os.good())
        throw cms::Exception("InvalidFileState")
            << "Stream passed to MVAComputer::writeCalibration "
               "has an invalid state." << std::endl;

    os << STANDALONE_HEADER;

    TClass *rootClass =
        TClass::GetClass("PhysicsTools::Calibration::MVAComputer");
    if (!rootClass)
        throw cms::Exception("DictionaryMissing")
            << "CondFormats dictionary for "
               "PhysicsTools::Calibration::MVAComputer missing"
            << std::endl;

    TBufferFile buffer(TBuffer::kWrite);
    buffer.StreamObject(const_cast<void*>(static_cast<const void*>(calib)),
                        rootClass);

    ext::ozstream ozs(&os);
    ozs.write(buffer.Buffer(), buffer.Length());
    ozs.flush();
}

Member Data Documentation

std::vector<InputVar> PhysicsTools::MVAComputer::inputVariables

private

vector of input variables

Definition at line 190 of file MVAComputer.h.

Referenced by evalInternal(), getVariableId(), and setup().

unsigned int PhysicsTools::MVAComputer::nVars

private

total number of variables to expect while computing discriminator

Definition at line 196 of file MVAComputer.h.

Referenced by setup().

unsigned int PhysicsTools::MVAComputer::output

private

index of the variable in the "conf" array to return as result

Definition at line 199 of file MVAComputer.h.

Referenced by PhysicsTools::MVAComputer::DerivContext::DerivContext(), evalInternal(), PhysicsTools::MVAComputer::EvalContext::output(), PhysicsTools::MVAComputer::DerivContext::output(), and setup().

std::auto_ptr<Calibration::MVAComputer> PhysicsTools::MVAComputer::owned

private

in case calibration object is owned by the MVAComputer

Definition at line 202 of file MVAComputer.h.

Referenced by MVAComputer().

std::vector<Processor> PhysicsTools::MVAComputer::varProcessors

private

vector of variable processors

Definition at line 193 of file MVAComputer.h.

Referenced by evalInternal(), and setup().