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 Container_t >
double	deriv (Container_t &values) const
template<typename Iterator_t >
double	deriv (Iterator_t first, Iterator_t last) const
template<typename Container_t >
double	eval (const Container_t &values) const
	evaluate variables in iterable container values More...
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...
	MVAComputer (Calibration::MVAComputer *calib, bool owned=false)
	construct a discriminator computer from a calibation object More...
	MVAComputer (const Calibration::MVAComputer *calib)
	construct a discriminator computer from a const 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::unique_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

MVAComputer() [1/4]

PhysicsTools::MVAComputer::MVAComputer

(

const Calibration::MVAComputer *

calib

)

construct a discriminator computer from a const calibation object

Definition at line 37 of file MVAComputer.cc.

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

References setup().

MVAComputer() [2/4]

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

construct a discriminator computer from a calibation object

Definition at line 39 of file MVAComputer.cc.

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

References owned, and setup().

~MVAComputer()

PhysicsTools::MVAComputer::~MVAComputer

(

)

Definition at line 119 of file MVAComputer.cc.

{}

MVAComputer() [3/4]

PhysicsTools::MVAComputer::MVAComputer

(

const char *

filename

)

construct a discriminator computer from a calibration file

Definition at line 45 of file MVAComputer.cc.

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

References owned, and setup().

MVAComputer() [4/4]

PhysicsTools::MVAComputer::MVAComputer

(

std::istream &

is

)

construct a discriminator computer from C++ input stream

Definition at line 49 of file MVAComputer.cc.

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

References owned, and setup().

Member Function Documentation

deriv() [1/2]

template<typename Container_t >

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

inline

Definition at line 64 of file MVAComputer.h.

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

References contentValuesCheck::values.

deriv() [2/2]

template<typename Iterator_t >

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

eval() [1/2]

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

References contentValuesCheck::values.

eval() [2/2]

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 evaluateTtFullHadSignalSel(), evaluateTtSemiLepSignalSel(), and TtSemiLepJetCombMVAComputer::produce().

evalInternal()

template<class T >

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

private

evaluate discriminator from flattened variable array

Definition at line 131 of file MVAComputer.cc.

                                             {
    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;
        }
      }
    }
  }

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

getVariableId()

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

private

map variable identifier name to the numerical position in the array

Definition at line 121 of file MVAComputer.cc.

                                                    {
    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;
  }

References inputVariables, cuda_std::lower_bound(), and Skims_PA_cff::name.

readCalibration() [1/2]

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

static

read calibration object from plain file

Definition at line 196 of file MVAComputer.cc.

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

References FrontierConditions_GlobalTag_cff::file, and corrVsCorr::filename.

Referenced by PhysicsTools::MVAComputerESSourceBase::produce().

readCalibration() [2/2]

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

static

read calibration object from plain C++ input stream

Definition at line 201 of file MVAComputer.cc.

                                                                     {
    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::unique_ptr<Calibration::MVAComputer> calib(new Calibration::MVAComputer());
    buffer.StreamObject(static_cast<void *>(calib.get()), rootClass);
 
    return calib.release();
  }

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

setup()

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

private

construct processors from calibration and setup variables

Definition at line 51 of file MVAComputer.cc.

                                                             {
    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;
  }

References looper::config, PhysicsTools::VarProcessor::configure(), filterCSVwithJSON::copy, PhysicsTools::ProcessRegistry< Base_t, CalibBase_t, Parent_t >::Factory::create(), Exception, PhysicsTools::Variable::FLAG_ALL, PhysicsTools::Variable::FLAG_MULTIPLE, HLT_2018_cff::flags, mps_fire::i, PhysicsTools::TrainMVAComputerCalibration::initFlags(), inputVariables, dqmiolumiharvest::j, PhysicsTools::VarProcessor::Config::mask, Skims_PA_cff::name, nVars, PhysicsTools::VarProcessor::Config::origin, output, AlCaHLTBitMon_QueryRunRegistry::string, trigObjTnPSource_cfi::var, L1TEGammaDiff_cfi::variables, and varProcessors.

Referenced by MVAComputer().

writeCalibration() [1/2]

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

static

write calibration object to file

Definition at line 236 of file MVAComputer.cc.

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

References FrontierConditions_GlobalTag_cff::file, and corrVsCorr::filename.

writeCalibration() [2/2]

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

static

write calibration object to pain C++ output stream

Definition at line 241 of file MVAComputer.cc.

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

References edmScanValgrind::buffer, Exception, and STANDALONE_HEADER.

Member Data Documentation

inputVariables

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().

nVars

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().

output

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::EvalContext::eval(), evalInternal(), PhysicsTools::MVAComputer::DerivContext::output(), and setup().

owned

std::unique_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().

varProcessors

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

private

vector of variable processors

Definition at line 193 of file MVAComputer.h.

Referenced by evalInternal(), and setup().