Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-11-15 04:14:47

0001 #ifndef CondFormats_PhysicsToolsObjects_MVAComputer_h
0002 #define CondFormats_PhysicsToolsObjects_MVAComputer_h
0003 // -*- C++ -*-
0004 //
0005 // Package:     PhysicsToolsObjects
0006 // Class  :     MVAComputer
0007 //
0008 
0009 //
0010 // Author:  Christophe Saout <christophe.saout@cern.ch>
0011 // Created:     Sat Apr 24 15:18 CEST 2007
0012 // $Id: MVAComputer.h,v 1.15 2010/01/26 19:40:03 saout Exp $
0013 //
0014 
0015 #include "CondFormats/Serialization/interface/Serializable.h"
0016 
0017 #include <memory>
0018 #include <string>
0019 #include <vector>
0020 #include <map>
0021 
0022 #include "CondFormats/PhysicsToolsObjects/interface/Histogram.h"
0023 
0024 namespace PhysicsTools {
0025   namespace Calibration {
0026 
0027     // helper classes
0028 
0029     class BitSet {
0030     public:
0031       // help that poor ROOT to copy bitsets... (workaround)
0032       BitSet &operator=(const BitSet &other) {
0033         store = other.store;
0034         bitsInLast = other.bitsInLast;
0035         return *this;
0036       }
0037 
0038       std::vector<unsigned char> store;
0039       unsigned int bitsInLast;
0040 
0041       COND_SERIALIZABLE;
0042     };
0043 
0044     class Matrix {
0045     public:
0046       std::vector<double> elements;
0047       unsigned int rows;
0048       unsigned int columns;
0049 
0050       COND_SERIALIZABLE;
0051     };
0052 
0053     // configuration base classes
0054 
0055     class VarProcessor {
0056     public:
0057       BitSet inputVars;
0058 
0059       virtual ~VarProcessor() {}
0060       virtual std::string getInstanceName() const;
0061       virtual std::unique_ptr<VarProcessor> clone() const;
0062 
0063       COND_SERIALIZABLE;
0064     };
0065 
0066     class Variable {
0067     public:
0068       inline Variable() {}
0069       inline Variable(const std::string &name) : name(name) {}
0070       inline ~Variable() {}
0071 
0072       std::string name;
0073 
0074       COND_SERIALIZABLE;
0075     };
0076 
0077     // variable processors
0078 
0079     class ProcOptional : public VarProcessor {
0080     public:
0081       std::unique_ptr<VarProcessor> clone() const override;
0082       std::vector<double> neutralPos;
0083 
0084       COND_SERIALIZABLE;
0085     };
0086 
0087     class ProcCount : public VarProcessor {
0088     public:
0089       std::unique_ptr<VarProcessor> clone() const override;
0090       COND_SERIALIZABLE;
0091     };
0092 
0093     class ProcClassed : public VarProcessor {
0094     public:
0095       std::unique_ptr<VarProcessor> clone() const override;
0096       unsigned int nClasses;
0097 
0098       COND_SERIALIZABLE;
0099     };
0100 
0101     class ProcSplitter : public VarProcessor {
0102     public:
0103       std::unique_ptr<VarProcessor> clone() const override;
0104       unsigned int nFirst;
0105 
0106       COND_SERIALIZABLE;
0107     };
0108 
0109     class ProcForeach : public VarProcessor {
0110     public:
0111       std::unique_ptr<VarProcessor> clone() const override;
0112       unsigned int nProcs;
0113 
0114       COND_SERIALIZABLE;
0115     };
0116 
0117     class ProcSort : public VarProcessor {
0118     public:
0119       std::unique_ptr<VarProcessor> clone() const override;
0120       unsigned int sortByIndex;
0121       bool descending;
0122 
0123       COND_SERIALIZABLE;
0124     };
0125 
0126     class ProcCategory : public VarProcessor {
0127     public:
0128       std::unique_ptr<VarProcessor> clone() const override;
0129       typedef std::vector<double> BinLimits;
0130 
0131       std::vector<BinLimits> variableBinLimits;
0132       std::vector<int> categoryMapping;
0133 
0134       COND_SERIALIZABLE;
0135     };
0136 
0137     class ProcNormalize : public VarProcessor {
0138     public:
0139       std::unique_ptr<VarProcessor> clone() const override;
0140       std::vector<HistogramF> distr;
0141       int categoryIdx;
0142 
0143       COND_SERIALIZABLE;
0144     };
0145 
0146     class ProcLikelihood : public VarProcessor {
0147     public:
0148       std::unique_ptr<VarProcessor> clone() const override;
0149       class SigBkg {
0150       public:
0151         HistogramF background;
0152         HistogramF signal;
0153         bool useSplines;
0154 
0155         COND_SERIALIZABLE;
0156       };
0157 
0158       std::vector<SigBkg> pdfs;
0159       std::vector<double> bias;
0160       int categoryIdx;
0161       bool logOutput;
0162       bool individual;
0163       bool neverUndefined;
0164       bool keepEmpty;
0165 
0166       COND_SERIALIZABLE;
0167     };
0168 
0169     class ProcLinear : public VarProcessor {
0170     public:
0171       std::unique_ptr<VarProcessor> clone() const override;
0172       std::vector<double> coeffs;
0173       double offset;
0174 
0175       COND_SERIALIZABLE;
0176     };
0177 
0178     class ProcMultiply : public VarProcessor {
0179     public:
0180       std::unique_ptr<VarProcessor> clone() const override;
0181       typedef std::vector<unsigned int> Config;
0182 
0183       unsigned int in;
0184       std::vector<Config> out;
0185 
0186       COND_SERIALIZABLE;
0187     };
0188 
0189     class ProcMatrix : public VarProcessor {
0190     public:
0191       std::unique_ptr<VarProcessor> clone() const override;
0192       Matrix matrix;
0193 
0194       COND_SERIALIZABLE;
0195     };
0196 
0197     class ProcExternal : public VarProcessor {
0198     public:
0199       std::unique_ptr<VarProcessor> clone() const override;
0200       std::string getInstanceName() const override;
0201 
0202       std::string method;
0203       std::vector<unsigned char> store;
0204 
0205       COND_SERIALIZABLE;
0206     };
0207 
0208     class ProcMLP : public VarProcessor {
0209     public:
0210       std::unique_ptr<VarProcessor> clone() const override;
0211       typedef std::pair<double, std::vector<double> > Neuron;
0212       typedef std::pair<std::vector<Neuron>, bool> Layer;
0213 
0214       std::vector<Layer> layers;
0215 
0216       COND_SERIALIZABLE;
0217     };
0218 
0219     // the discriminator computer
0220 
0221     class MVAComputer {
0222     public:
0223       MVAComputer();
0224       MVAComputer(const MVAComputer &orig);
0225       virtual ~MVAComputer();
0226 
0227       MVAComputer &operator=(const MVAComputer &orig);
0228 
0229       virtual std::vector<VarProcessor *> getProcessors();
0230       virtual std::vector<const VarProcessor *> getProcessors() const;
0231       void addProcessor(const VarProcessor *proc);
0232 
0233       // cacheId stuff to detect changes
0234       typedef unsigned int CacheId;
0235       inline CacheId getCacheId() const { return cacheId; }
0236       inline bool changed(CacheId old) const { return old != cacheId; }
0237 
0238       std::vector<Variable> inputSet;
0239       unsigned int output;
0240 
0241     private:
0242       std::vector<VarProcessor *> processors;
0243 
0244       CacheId cacheId COND_TRANSIENT;  // transient
0245 
0246       COND_SERIALIZABLE;
0247     };
0248 
0249     // a collection of computers identified by name
0250 
0251     class MVAComputerContainer {
0252     public:
0253       typedef std::pair<std::string, MVAComputer> Entry;
0254 
0255       MVAComputerContainer();
0256       virtual ~MVAComputerContainer() {}
0257 
0258       MVAComputer &add(const std::string &label);
0259       virtual const MVAComputer &find(const std::string &label) const;
0260       virtual bool contains(const std::string &label) const;
0261 
0262       // cacheId stuff to detect changes
0263       typedef unsigned int CacheId;
0264       inline CacheId getCacheId() const { return cacheId; }
0265       inline bool changed(CacheId old) const { return old != cacheId; }
0266 
0267     private:
0268       std::vector<Entry> entries;
0269 
0270       CacheId cacheId COND_TRANSIENT;  // transient
0271 
0272       COND_SERIALIZABLE;
0273     };
0274 
0275   }  // namespace Calibration
0276 }  // namespace PhysicsTools
0277 
0278 #endif  // CondFormats_PhysicsToolsObjects_MVAComputer_h