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::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.

References setup().

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

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.

References owned, and setup().

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

~MVAComputer()

PhysicsTools::MVAComputer::~MVAComputer

(

)

Definition at line 118 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.

References owned, and setup().

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

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.

References owned, and setup().

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

Member Function Documentation

deriv() [1/2]

template<typename Iterator_t >

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

deriv() [2/2]

template<typename Container_t >

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

inline

Definition at line 64 of file MVAComputer.h.

References contentValuesCheck::values.

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

eval() [1/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().

eval() [2/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.

References contentValuesCheck::values.

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

evalInternal()

template<class T >

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

private

evaluate discriminator from flattened variable array

Definition at line 130 of file MVAComputer.cc.

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.

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

getVariableId()

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

private

map variable identifier name to the numerical position in the array

Definition at line 120 of file MVAComputer.cc.

References inputVariables, pfDeepBoostedJetPreprocessParams_cfi::lower_bound, and Skims_PA_cff::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;
  }

readCalibration() [1/2]

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

static

read calibration object from plain file

Definition at line 195 of file MVAComputer.cc.

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

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

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

readCalibration() [2/2]

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

static

read calibration object from plain C++ input stream

Definition at line 200 of file MVAComputer.cc.

References visDQMUpload::buf, edmScanValgrind::buffer, l1tEGammaCrystalsEmulatorProducer_cfi::calib, Exception, RecoTauValidation_cfi::header, ext::basic_izstreambase< Item_t, Traits_t, Allocator_t >::rdbuf(), contentValuesCheck::ss, 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::unique_ptr<Calibration::MVAComputer> calib(new Calibration::MVAComputer());
    buffer.StreamObject(static_cast<void *>(calib.get()), rootClass);

    return calib.release();
  }

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.

References l1tEGammaCrystalsEmulatorProducer_cfi::calib, DiMuonV_cfg::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_2024v10_cff::flags, mps_fire::i, PhysicsTools::TrainMVAComputerCalibration::initFlags(), inputVariables, dqmiolumiharvest::j, PhysicsTools::VarProcessor::Config::mask, Skims_PA_cff::name, nVars, PhysicsTools::VarProcessor::Config::origin, AlCaHLTBitMon_QueryRunRegistry::string, trigObjTnPSource_cfi::var, hcalRecHitTable_cff::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<const Calibration::VarProcessor *> processors = calib->getProcessors();

    for (const auto *calibProc : processors) {
      std::string name = calibProc->getInstanceName();
      VarProcessor *processor = VarProcessor::create(name.c_str(), calibProc, 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;
  }

writeCalibration() [1/2]

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

static

write calibration object to file

Definition at line 235 of file MVAComputer.cc.

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

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

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 240 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

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 collectionMerger.collectionMerger::analyze(), evalInternal(), and PhysicsTools::MVAComputer::DerivContext::output().

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