OutPVtrends.h

Go to the documentation of this file.

#ifndef ALIGNMENT_OFFLINEVALIDATION_OUTPVTRENDS_H_
#define ALIGNMENT_OFFLINEVALIDATION_OUTPVTRENDS_H_

#include "TArrow.h"
#include "TAxis.h"
#include "TCanvas.h"
#include "TF1.h"
#include "TFile.h"
#include "TGaxis.h"
#include "TGraph.h"
#include "TGraphAsymmErrors.h"
#include "TGraphErrors.h"
#include "TH1F.h"
#include "TH2F.h"
#include "TLatex.h"
#include "TLegend.h"
#include "TList.h"
#include "TMath.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TPad.h"
#include "TPaveText.h"
#include "TProcPool.h"
#include "TProfile.h"
#include "TROOT.h"
#include "TStyle.h"
#include "TSystem.h"
#include "TSystemDirectory.h"
#include "TSystemFile.h"
#include <TStopwatch.h>
#include <algorithm>
#include <bitset>
#include <fstream>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <sstream>
#include <vector>

typedef std::map<TString, std::vector<double> > alignmentTrend;

// auxilliary struct to store
// histogram features
struct unrolledHisto {
  double m_y_min;
  double m_y_max;
  unsigned int m_n_bins;
  std::vector<double> m_bincontents;

  unrolledHisto() {
    m_y_min = 0.;
    m_y_max = 0.;
    m_n_bins = 0;
    m_bincontents.clear();
  }  // first constructor empty

  unrolledHisto(const double &y_min,
                const double &y_max,
                const unsigned int &n_bins,
                const std::vector<double> &bincontents) {
    m_y_min = y_min;
    m_y_max = y_max;
    m_n_bins = n_bins;
    m_bincontents = bincontents;
  }  //look, a constructor

  double get_y_min() { return m_y_min; }

  double get_y_max() { return m_y_max; }

  unsigned int get_n_bins() { return m_n_bins; }

  std::vector<double> get_bin_contents() { return m_bincontents; }

  double get_integral() {
    double ret(0.);
    for (const auto &binc : m_bincontents) {
      ret += binc;
    }
    return ret;
  }
};

struct outPVtrends {
  // empty constructor
  outPVtrends() { init(); }

  int m_index;
  std::vector<double> m_runs;
  alignmentTrend m_dxyPhiMeans;
  alignmentTrend m_dxyPhiChi2;
  alignmentTrend m_dxyPhiKS;
  alignmentTrend m_dxyPhiHi;
  alignmentTrend m_dxyPhiLo;
  alignmentTrend m_dxyEtaMeans;
  alignmentTrend m_dxyEtaChi2;
  alignmentTrend m_dxyEtaKS;
  alignmentTrend m_dxyEtaHi;
  alignmentTrend m_dxyEtaLo;
  alignmentTrend m_dzPhiMeans;
  alignmentTrend m_dzPhiChi2;
  alignmentTrend m_dzPhiKS;
  alignmentTrend m_dzPhiHi;
  alignmentTrend m_dzPhiLo;
  alignmentTrend m_dzEtaMeans;
  alignmentTrend m_dzEtaChi2;
  alignmentTrend m_dzEtaKS;
  alignmentTrend m_dzEtaHi;
  alignmentTrend m_dzEtaLo;
  std::map<TString, std::vector<unrolledHisto> > m_dxyVect;
  std::map<TString, std::vector<unrolledHisto> > m_dzVect;

  void init() {
    m_index = -1;
    m_runs.clear();

    m_dxyPhiMeans.clear();
    m_dxyPhiChi2.clear();
    m_dxyPhiKS.clear();
    m_dxyPhiHi.clear();
    m_dxyPhiLo.clear();

    m_dxyEtaMeans.clear();
    m_dxyEtaChi2.clear();
    m_dxyEtaKS.clear();
    m_dxyEtaHi.clear();
    m_dxyEtaLo.clear();

    m_dzPhiMeans.clear();
    m_dzPhiChi2.clear();
    m_dzPhiKS.clear();
    m_dzPhiHi.clear();
    m_dzPhiLo.clear();

    m_dzEtaMeans.clear();
    m_dzEtaChi2.clear();
    m_dzEtaKS.clear();
    m_dzEtaHi.clear();
    m_dzEtaLo.clear();

    m_dxyVect.clear();
    m_dzVect.clear();
  }
};

#if defined(__ROOTCLING__)
#pragma link C++ class std::map < TString, std::vector < double>> + ;
#pragma link C++ class std::map < TString, std::vector < unrolledHisto>> + ;
#pragma link C++ class outPVtrends + ;
#pragma link C++ class unrolledHisto + ;

#endif

#endif  // ALIGNMENT_OFFLINEVALIDATION_OUTPVTRENDS_H_