Namespaces
	Calibration

	helper

Classes
class	AtomicId
	Cheap generic unique keyword identifier class. More...

class	BitSet
	A compact container for storing single bits. More...

class	Interceptor

class	LeastSquares

class	MLP

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

class	MVAComputerCache
	Creates and and MVAComputer from calibrations via EventSetup. More...

class	MVAComputerESSourceBase

class	MVAComputerESSourceImpl

class	MVAModuleHelper
	Template for automated variable collection and MVA computation in EDM modules. More...

class	MVAModuleHelperDefaultFiller
	Default template for MVAModuleHelper "Filler" template argument. More...

class	MVATrainer

class	MVATrainerContainer

class	MVATrainerContainerLooperImpl

class	MVATrainerContainerSave

class	MVATrainerContainerSaveImpl

class	MVATrainerFileSave

class	MVATrainerFileSaveImpl

class	MVATrainerLooper

class	MVATrainerLooperImpl

class	MVATrainerSave

class	MVATrainerSaveImpl

class	ProcessRegistry
	Generic registry template for polymorphic processor implementations. More...

class	ProcessRegistryImpl
	template to generate a registry singleton for a type. More...

class	Source

class	SourceVariable

class	SourceVariableSet

class	Spline
	A simple class for cubic splines. More...

class	TrainerMonitoring

class	TrainMVAComputerCalibration
	for internal use by MVATrainer More...

class	TrainProcessor

class	TreeReader

class	TreeTrainer

class	Variable
	Class describing an input variable. More...

class	VarProcessor
	Common base class for variable processors. More...

Functions
static std::string	escape (const std::string &in)

static IdCache &	getAtomicIdCache ()

static bool	isMagic (AtomicId id)

static void	loadMatrix (DOMElement *elem, unsigned int n, TMatrixDBase &matrix)

static void	loadVector (DOMElement *elem, unsigned int n, TVectorD &vector)

template<typename T >
static std::pair< void *, std::vector< T > >	makeMulti ()

std::ostream &	operator<< (std::ostream &os, const PhysicsTools::AtomicId &id)
	STL streaming operator. More...

static DOMElement *	saveMatrix (DOMDocument *doc, unsigned int n, const TMatrixDBase &matrix)

static DOMElement *	saveVector (DOMDocument *doc, unsigned int n, const TVectorD &vector)

static std::vector< std::string >	split (const std::string line, char delim)

static std::string	stdStringPrintf (const char *format,...)

static std::string	stdStringVPrintf (const char *format, std::va_list va)

Variables
static const AtomicId	kOutputId ("__OUTPUT__")

static Interceptor::Registry	registry ("Interceptor")

Function Documentation

static std::string PhysicsTools::escape ( const std::string & in )

static

Definition at line 405 of file MVATrainer.cc.

References query::result, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PhysicsTools::MVATrainer::MVATrainer().

 {
     std::string result("'");
     for(std::string::const_iterator iter = in.begin();
         iter != in.end(); ++iter) {
         switch(*iter) {
             case '\'':
             result += "'\\''";
             break;
             default:
             result += *iter;
         }
     }
     result += '\'';
     return result;
 }

static IdCache& PhysicsTools::getAtomicIdCache ( )

static

Definition at line 59 of file AtomicId.cc.

Referenced by PhysicsTools::AtomicId::lookup().

 {
     [[cms::thread_safe]] static IdCache atomicIdCache;
     return atomicIdCache;
 }

static bool PhysicsTools::isMagic ( AtomicId id )

static

Definition at line 398 of file MVATrainer.cc.

References kOutputId.

Referenced by PhysicsTools::MVATrainer::fillOutputVars().

 {
     return id == MVATrainer::kTargetId ||
            id == MVATrainer::kWeightId ||
            id == kOutputId;
 }

static void PhysicsTools::loadMatrix	(	DOMElement *	elem,
		unsigned int	n,
		TMatrixDBase &	matrix
	)

static

Definition at line 144 of file LeastSquares.cc.

References cuy::col, Exception, makeMuonMisalignmentScenario::matrix, and python.Node::node.

Referenced by PhysicsTools::LeastSquares::load(), and FWGeometry::loadMap().

 {
     if (std::strcmp(XMLSimpleStr(elem->getNodeName()),
                                  "matrix") != 0)
         throw cms::Exception("LeastSquares")
             << "Expected matrix in data file."
             << std::endl;
 
     unsigned int row = 0;
     for(DOMNode *node = elem->getFirstChild();
         node; node = node->getNextSibling()) {
         if (node->getNodeType() != DOMNode::ELEMENT_NODE)
             continue;
 
         if (std::strcmp(XMLSimpleStr(node->getNodeName()),
                                      "row") != 0)
             throw cms::Exception("LeastSquares")
                 << "Expected row tag in data file."
                 << std::endl;
 
         if (row >= n)
             throw cms::Exception("LeastSquares")
                 << "Too many rows in data file." << std::endl;
 
         elem = static_cast<DOMElement*>(node);
 
         unsigned int col = 0;
         for(DOMNode *subNode = elem->getFirstChild();
             subNode; subNode = subNode->getNextSibling()) {
             if (subNode->getNodeType() != DOMNode::ELEMENT_NODE)
                 continue;
 
             if (std::strcmp(XMLSimpleStr(subNode->getNodeName()),
                                          "value") != 0)
             throw cms::Exception("LeastSquares")
                 << "Expected value tag in data file."
                 << std::endl;
 
             if (col >= n)
                 throw cms::Exception("LeastSquares")
                     << "Too many columns in data file."
                     << std::endl;
 
             matrix(row, col) =
                 XMLDocument::readContent<double>(subNode);
             col++;
         }
 
         if (col != n)
             throw cms::Exception("LeastSquares")
                 << "Missing columns in data file."
                 << std::endl;
         row++;
     }
 
     if (row != n)
         throw cms::Exception("LeastSquares")
             << "Missing rows in data file."
             << std::endl;
 }

static void PhysicsTools::loadVector	(	DOMElement *	elem,
		unsigned int	n,
		TVectorD &	vector
	)

static

Definition at line 205 of file LeastSquares.cc.

References cuy::col, Exception, and python.Node::node.

Referenced by PhysicsTools::LeastSquares::load().

 {
     if (std::strcmp(XMLSimpleStr(elem->getNodeName()),
                                  "vector") != 0)
         throw cms::Exception("LeastSquares")
             << "Expected matrix in data file."
             << std::endl;
 
     unsigned int col = 0;
     for(DOMNode *node = elem->getFirstChild();
         node; node = node->getNextSibling()) {
         if (node->getNodeType() != DOMNode::ELEMENT_NODE)
             continue;
 
         if (std::strcmp(XMLSimpleStr(node->getNodeName()),
                                      "value") != 0)
         throw cms::Exception("LeastSquares")
             << "Expected value tag in data file."
             << std::endl;
 
         if (col >= n)
             throw cms::Exception("LeastSquares")
                 << "Too many columns in data file."
                 << std::endl;
 
         vector(col) = XMLDocument::readContent<double>(node);
         col++;
     }
 
     if (col != n)
         throw cms::Exception("LeastSquares")
             << "Missing columns in data file."
             << std::endl;
 }

template<typename T >

static std::pair<void*, std::vector<T> > PhysicsTools::makeMulti ( )

static

Definition at line 196 of file TreeReader.cc.

197 { return std::pair<void*, std::vector<T> >(0, std::vector<T>()); }

std::ostream& PhysicsTools::operator<<	(	std::ostream &	os,
		const PhysicsTools::AtomicId &	id
	)

inline

STL streaming operator.

Definition at line 72 of file AtomicId.h.

73 { return os << (const char*)id; }

static DOMElement* PhysicsTools::saveMatrix	(	DOMDocument *	doc,
		unsigned int	n,
		const TMatrixDBase &	matrix
	)

static

Definition at line 240 of file LeastSquares.cc.

References i, j, makeMuonMisalignmentScenario::matrix, gen::n, dbtoconf::root, and relativeConstraints::value.

Referenced by PhysicsTools::LeastSquares::save().

 {
     DOMElement *root = doc->createElement(XMLUniStr("matrix"));
     XMLDocument::writeAttribute<unsigned int>(root, "size", n);
 
     for(unsigned int i = 0; i < n; i++) {
         DOMElement *row = doc->createElement(XMLUniStr("row"));
         root->appendChild(row);
 
         for(unsigned int j = 0; j < n; j++) {
             DOMElement *value =
                 doc->createElement(XMLUniStr("value"));
             row->appendChild(value);
 
             XMLDocument::writeContent<double>(value, doc,
                                               matrix(i, j));
         }
     }
 
     return root;
 }

static DOMElement* PhysicsTools::saveVector	(	DOMDocument *	doc,
		unsigned int	n,
		const TVectorD &	vector
	)

static

Definition at line 263 of file LeastSquares.cc.

References i, gen::n, dbtoconf::root, and relativeConstraints::value.

Referenced by PhysicsTools::LeastSquares::save().

 {
     DOMElement *root = doc->createElement(XMLUniStr("vector"));
     XMLDocument::writeAttribute<unsigned int>(root, "size", n);
 
     for(unsigned int i = 0; i < n; i++) {
         DOMElement *value =
             doc->createElement(XMLUniStr("value"));
         root->appendChild(value);
 
         XMLDocument::writeContent<double>(value, doc, vector(i));
     }
 
     return root;
 }

static std::vector<std::string> PhysicsTools::split	(	const std::string	line,
		char	delim
	)

static

Definition at line 18 of file MLP.cc.

References AlCaHLTBitMon_ParallelJobs::p, lumiQueryAPI::q, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PhysicsTools::MLP::MLP(), and PhysicsTools::MVATrainer::setCrossValidation().

 {
     const char *str = line.c_str();
     const char *p = str;
 
     std::vector<std::string> tokens;
 
     if (line[0] == '\0')
         return tokens;
 
     while(p) {
         const char *q = std::strchr(p, delim);
 
         if (!q) {
             tokens.push_back(std::string(p));
             p = 0;
         } else {
             tokens.push_back(std::string(p, q - p));
             p = q + 1;
         }
     }
 
     return tokens;
 }

static std::string PhysicsTools::stdStringPrintf	(	const char *	format,
			...
	)

static

Definition at line 183 of file MVATrainer.cc.

References query::result, stdStringVPrintf(), and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by PhysicsTools::MVATrainer::bookMonitor(), and PhysicsTools::MVATrainer::trainFileName().

 {
     std::va_list va;
     va_start(va, format);
     std::string result = stdStringVPrintf(format, va);
     va_end(va);
     return result;
 }

static std::string PhysicsTools::stdStringVPrintf	(	const char *	format,
		std::va_list	va
	)

static

Definition at line 160 of file MVATrainer.cc.

References gen::n, query::result, findQualityFiles::size, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by stdStringPrintf().

 {
     unsigned int size = std::min<unsigned int>(128, std::strlen(format));
     char *buffer = new char[size];
     for(;;) {
         int n = std::vsnprintf(buffer, size, format, va);
         if (n >= 0 && (unsigned int)n < size)
             break;
 
         if (n >= 0)
             size = n + 1;
         else
             size *= 2;
 
         delete[] buffer;
         buffer = new char[size];
     }
 
     std::string result(buffer);
     delete[] buffer;
     return result;
 }

Variable Documentation

const AtomicId PhysicsTools::kOutputId("__OUTPUT__")

static

Referenced by PhysicsTools::MVATrainer::findUntrainedComputers(), isMagic(), and PhysicsTools::MVATrainer::makeTrainCalibration().

Interceptor::Registry PhysicsTools::registry("Interceptor")

static

Referenced by ProvenanceDumper::addAncestors(), edm::RootFile::readEntryDescriptionTree(), edm::RootFile::readParentageTree(), and ProvenanceDumper::work_().

Namespaces

Classes

Functions

Variables

Function Documentation

Variable Documentation