AlgorithmCalibration.h

Go to the documentation of this file.

#ifndef ALGORITHM_CALIBRATION_H
#define ALGORITHM_CALIBRATION_H
 
#include <map>
#include <string>
#include <vector>
#include <xercesc/dom/DOM.hpp>
#include <xercesc/dom/DOMElement.hpp>
#include <xercesc/util/XMLString.hpp>
#include <string>
#include <list>
#include <iostream>
 
#include "CalibrationXML.h"
//#include "CondFormats/BTagObjects/interface/CalibrationInterface.h"
//#include "RecoBTag/TrackProbability/interface/CalibrationInterface.h"
#include "RecoBTag/XMLCalibration/interface/CalibrationInterface.h"
 
namespace XERCES_CPP_NAMESPACE {
  class DOMNode;
}
 
//template <class T,class CO> class   CalibrationInterface;
template <class T, class CO>
class AlgorithmCalibration : public CalibrationInterface<T, CO> {
  // friend class CalibrationInterface<T,CO>;
public:
  typedef XERCES_CPP_NAMESPACE::DOMElement DOMElement;
  typedef XERCES_CPP_NAMESPACE::DOMNode DOMNode;
 
  AlgorithmCalibration(const std::string &fileName);
 
  ~AlgorithmCalibration();
 
  void startCalibration();
 
  void updateCalibration(const typename T::Input &calibrationInput);
  template <class CI>
  void updateCalibration(const typename T::Input &calibrationInputForCategory, const CI &inputForCalibration);
 
  void saveCalibration(const std::string &fileName);
 
protected:
  CO *readObject(DOMNode *);
  bool readCategories();
 
protected:
  DOMElement *dom() {
    if (m_xml == nullptr) {
      m_xml = new CalibrationXML();
      m_xml->openFile(m_filename);
    }
    return m_xml->calibrationDOM();
  }
 
private:
  std::string m_filename;
  CalibrationXML *m_xml;
};
 
template <class T, class CO>
AlgorithmCalibration<T, CO>::AlgorithmCalibration(const std::string &filename) : m_filename(filename), m_xml(nullptr) {
  readCategories();
  if (m_xml) {
    m_xml->closeFile();
  }
}
 
template <class T, class CO>
AlgorithmCalibration<T, CO>::~AlgorithmCalibration() {
  if (m_xml)
    delete m_xml;
}
 
template <class T, class CO>
bool AlgorithmCalibration<T, CO>::readCategories() {
  if (dom() == nullptr)
    return false;
 
  DOMNode *n1 = dom()->getFirstChild();
  while (n1) {
    if (n1->getNodeType() == DOMNode::ELEMENT_NODE) {
      T *cat = new T();
      cat->readFromDOM((DOMElement *)n1);
      CO *obj = readObject(n1->getFirstChild());
      if (obj) {
        this->addEntry(*cat, *obj);
        delete obj;
      }
      delete cat;
    }
    n1 = n1->getNextSibling();
  }
 
  return true;
}
template <class T, class CO>
CO *AlgorithmCalibration<T, CO>::readObject(DOMNode *dom) {
  DOMNode *n1 = dom;
  while (n1) {
    if (n1->getNodeType() == DOMNode::ELEMENT_NODE)
      break;
    n1 = n1->getNextSibling();
  }
 
  if (n1 == nullptr)
    return nullptr;  //Cannot find any calibrated objects
 
  CO *co = new CO();
  co->read((DOMElement *)n1);
  return co;
}
 
#endif