BeamTuning_module.cc

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
// Class:       BeamTuning
// Plugin Type: analyzer (art v2_12_01)
// File:        BeamTuning_module.cc
//
// Generated at Tue Jun 18 11:16:43 2019 by Dung Phan using cetskelgen
// from cetlib version v3_06_00.
////////////////////////////////////////////////////////////////////////

#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"
#include "art/Framework/Principal/Handle.h"
#include "art/Framework/Services/Optional/TFileDirectory.h"
#include "art/Framework/Services/Optional/TFileService.h"
#include "art/Framework/Services/Registry/ServiceHandle.h"
#include "canvas/Persistency/Common/FindManyP.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"
#include "fhiclcpp/ParameterSet.h"

// nova
#include "BeamlineReco/CFDHitFinderAlg.h"
#include "BeamlineRecoBase/BeamlineDigit.h"
#include "BeamlineRecoBase/BeamlinePID.h"
#include "BeamlineRecoBase/MuonStackTrack.h"
#include "BeamlineRecoBase/ToF.h"
#include "BeamlineRecoBase/WCTrack.h"
#include "RawData/RawBeamline.h"
#include "BeamlineUtils/BeamlineChannelMap.h"

// ROOT
#include "TCanvas.h"
#include "TFile.h"
#include "TGraph.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TLatex.h"
#include "TLegend.h"
#include "TLine.h"
#include "TMath.h"
#include "TROOT.h"
#include "TStyle.h"
#include "TTree.h"

// stl
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

// Boost
#include <boost/algorithm/string.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/time_zone_base.hpp>
#include <boost/lexical_cast.hpp>

const uint32_t NOVA_EPOCH = 1262304000;
const uint64_t NOVA_TIME_FACTOR = 64000000;

void rootlogon() {
  TStyle* novaStyle = new TStyle("novaStyle", "NOvA Style");

  // Centre title
  novaStyle->SetTitleAlign(22);
  novaStyle->SetTitleX(.5);
  novaStyle->SetTitleY(.95);
  novaStyle->SetTitleBorderSize(0);

  // No info box
  novaStyle->SetOptStat(0);

  // set the background color to white
  novaStyle->SetFillColor(10);
  novaStyle->SetFrameFillColor(10);
  novaStyle->SetCanvasColor(10);
  novaStyle->SetPadColor(10);
  novaStyle->SetTitleFillColor(0);
  novaStyle->SetStatColor(10);

  // Don't put a colored frame around the plots
  novaStyle->SetFrameBorderMode(0);
  novaStyle->SetCanvasBorderMode(0);
  novaStyle->SetPadBorderMode(0);

  // Set the default line color for a fit function to be red
  novaStyle->SetFuncColor(kRed);

  // Marker settings
  //  novaStyle->SetMarkerStyle(kFullCircle);

  // No border on legends
  novaStyle->SetLegendBorderSize(0);

  // Axis titles
  novaStyle->SetTitleSize(.095, "xyz");
  novaStyle->SetTitleOffset(.8, "xyz");
  // More space for y-axis to avoid clashing with big numbers
  novaStyle->SetTitleOffset(.9, "y");
  // This applies the same settings to the overall plot title
  novaStyle->SetTitleSize(.055, "");
  novaStyle->SetTitleOffset(.8, "");
  // Axis labels (numbering)
  novaStyle->SetLabelSize(.095, "xyz");
  novaStyle->SetLabelOffset(.005, "xyz");

  // Prevent ROOT from occasionally automatically zero-suppressing
  novaStyle->SetHistMinimumZero();

  // Thicker lines
  novaStyle->SetHistLineWidth(2);
  novaStyle->SetFrameLineWidth(2);
  novaStyle->SetFuncWidth(2);

  // Set the number of tick marks to show
  novaStyle->SetNdivisions(506, "xyz");

  // Set the tick mark style
  novaStyle->SetPadTickX(1);
  novaStyle->SetPadTickY(1);

  // Fonts
  const int kNovaFont = 42;
  novaStyle->SetStatFont(kNovaFont);
  novaStyle->SetLabelFont(kNovaFont, "xyz");
  novaStyle->SetTitleFont(kNovaFont, "xyz");
  novaStyle->SetTitleFont(kNovaFont, "");  // Apply same setting to plot titles
  novaStyle->SetTextFont(kNovaFont);
  novaStyle->SetLegendFont(kNovaFont);

  // Get moodier colours for colz
  const Int_t NRGBs = 5;
  const Int_t NCont = 255;
  Double_t stops[NRGBs] = {0.00, 0.34, 0.61, 0.84, 1.00};
  Double_t red[NRGBs] = {0.00, 0.00, 0.87, 1.00, 0.51};
  Double_t green[NRGBs] = {0.00, 0.81, 1.00, 0.20, 0.00};
  Double_t blue[NRGBs] = {0.51, 1.00, 0.12, 0.00, 0.00};
  TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
  novaStyle->SetNumberContours(NCont);

  gROOT->SetStyle("novaStyle");
  gROOT->ForceStyle();
}

namespace novatb {
class BeamTuning;
}

class novatb::BeamTuning : public art::EDAnalyzer {
 public:
  explicit BeamTuning(fhicl::ParameterSet const& p);
  void reconfigure(const fhicl::ParameterSet& p);
  void analyze(art::Event const& e) override;
  void beginJob() override;
  void beginRun(art::Run const& r) override;
  void beginSubRun(art::SubRun const& sr) override;
  void endJob() override;
  void endRun(art::Run const& r) override;
  void endSubRun(art::SubRun const& sr) override;
  std::vector<double> findCluster(unsigned int tofIndex);
  void makeLinesAndTexts(TH1D* histogram, double ymin, double ymax,
                         std::vector<TLine*>& lines,
                         std::vector<TText*>& texts);

  void findTime(unsigned int subrunNo, int& srH, int& srM);
  bool convertNovaTimeToUnixTime(uint64_t const& inputNovaTime,
                                 struct tm& outputUnixTime);
  bool convertNovaTimeToUnixTime(uint64_t const& inputNovaTime,
                                 struct timeval& outputUnixTime);

  void decimal2binary(unsigned int decimalNumber, unsigned int* binaryNumber);

 private:
  art::InputTag _ToFInputTag;
  art::InputTag _WCInputTag;
  art::InputTag _CherenkovInputTag;
  art::InputTag _TriggerInputTag;
  art::InputTag _RawWCInputTag;

  unsigned int runNumber;

  std::string TriggerBitName[16] = {
      "WC1IGNOREME", "WC2IGNOREME", "WC3IGNOREME", "WCCOINC",
      "PAD1",        "PAD2",        "PAD3",        "PAD4",
      "TOFUS",       "SWYDGATE",    "MWPCOFF",     "DIGBUSY",
      "WCHDWR",      "TOFDS",       "TOFPrompt",   "TOFSlow"};

  std::vector<double> startTimeOfHits[12];

  std::vector<double> tof_p1_p4;
  std::vector<double> momentum;
  std::vector<bool> isElectron;

  unsigned int totalTriggersInSubrun;
  unsigned int goodTriggersInSubrun;
  unsigned int decentTriggersInSubrun;

  TH1D* hGoodTriggerRatio;
  TH1D* hDecentTriggerRatio;
  TH1D* hTotalTrigger;
  TH1D* hGoodTrigger;
  TH1D* hDecentTrigger;

  int _RunStartH;
  int _RunStartM;
  unsigned int _TimeRange;
  unsigned int _TimeInterval;
  double _RangeRatio;
  double _RangeTotal;
  double _RangeGood;
  bool _DrawLinesAndTimes;
  bool _RequireWCTrack;
  bool _Require3WCs;

  unsigned int countTriggerBit_TOFDS;
  unsigned int countTriggerBit_TOFUS;
  unsigned int countTriggerBit_TOFPrompt;
  unsigned int countTriggerBit_TOFSlow;
  unsigned int countTriggerBit_WCHDWR;
  unsigned int countTriggerBit_PAD1;
  unsigned int countTriggerBit_PAD2;
  unsigned int countTriggerBit_PAD3;
  unsigned int countTriggerBit_PAD4;

  std::ofstream TriggerBitCountFile;

  art::ServiceHandle<beamlineutil::BeamlineChannelMap> fChannelMap;
};

novatb::BeamTuning::BeamTuning(fhicl::ParameterSet const& p) : EDAnalyzer(p) {
  reconfigure(p);
}

void novatb::BeamTuning::decimal2binary(unsigned int decimalNumber,
                                        unsigned int* binaryNumber) {
  for (int index = 31; index >= 0; index--) {
    unsigned int reference = TMath::Power(2, (int)index);
    if (decimalNumber >= reference) {
      *(binaryNumber + index) = 1;
      decimalNumber = decimalNumber - reference;
    } else {
      *(binaryNumber + index) = 0;
    }
  }
}

void novatb::BeamTuning::reconfigure(const fhicl::ParameterSet& p) {
  _ToFInputTag = "cfdhitreco";
  _WCInputTag = "wctrackreco";
  _TriggerInputTag = "daq:Trigger";
  _RawWCInputTag = "daq:WC";

  _TimeRange = p.get<unsigned int>("time_range");
  _RangeTotal = p.get<double>("range_total");
  _RangeGood = p.get<double>("range_good");
  _RangeRatio = p.get<double>("range_ratio");
  _TimeInterval = p.get<unsigned int>("time_interval");
  _DrawLinesAndTimes = p.get<bool>("drawlines");
  _RequireWCTrack = p.get<bool>("requiretrack");
  _Require3WCs = p.get<bool>("require3wcs");
}

void novatb::BeamTuning::beginJob() {
  _RunStartH = -9999;
  _RunStartM = -9999;

  TriggerBitCountFile.open(Form("TriggerBitCountFile.txt"));
  TriggerBitCountFile << std::endl;

  TriggerBitCountFile << std::setw(15) << "SUBRUN"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "TOFDS"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "TOFUS"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "TOFPrompt"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "TOFSlow"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "WCHDWR"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "PAD1"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "PAD2"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "PAD3"
                      << " ";
  ;
  TriggerBitCountFile << std::setw(15) << "PAD4" << std::endl;

  hGoodTriggerRatio =
      new TH1D("hGoodTriggerRatio", ";Subrun Number;Ratio of Good Trigger (%)",
               _TimeRange - 1, 1, _TimeRange);
  hDecentTriggerRatio =
      new TH1D("hDecentTriggerRatio", ";Subrun Number;Ratio of Good Triggers (%)",
               _TimeRange - 1, 1, _TimeRange);
  hTotalTrigger = new TH1D("hTotalTrigger", ";Subrun Number;Trigger Counts",
                           _TimeRange - 1, 1, _TimeRange);
  hGoodTrigger = new TH1D("hGoodTrigger", ";Subrun Number;Good Triggers",
                          _TimeRange - 1, 1, _TimeRange);
  hDecentTrigger = new TH1D("hGoodTrigger", ";Subrun Number;Good Triggers",
                          _TimeRange - 1, 1, _TimeRange);
}

void novatb::BeamTuning::beginRun(art::Run const& r) {
  runNumber = r.id().run();
}

void novatb::BeamTuning::beginSubRun(art::SubRun const& sr) {
  totalTriggersInSubrun = 0;
  goodTriggersInSubrun = 0;
  decentTriggersInSubrun = 0;

  countTriggerBit_TOFDS = 0;
  countTriggerBit_TOFUS = 0;
  countTriggerBit_TOFPrompt = 0;
  countTriggerBit_TOFSlow = 0;
  countTriggerBit_WCHDWR = 0;
  countTriggerBit_PAD1 = 0;
  countTriggerBit_PAD2 = 0;
  countTriggerBit_PAD3 = 0;
  countTriggerBit_PAD4 = 0;
}

void novatb::BeamTuning::analyze(art::Event const& e) {
  art::Handle<std::vector<brb::BeamlineDigit> > ToFHandle;
  std::vector<art::Ptr<brb::BeamlineDigit> > ToFs;
  if (e.getByLabel(_ToFInputTag, ToFHandle))
    art::fill_ptr_vector(ToFs, ToFHandle);

  art::Handle<std::vector<brb::WCTrack> > WCHandle;
  std::vector<art::Ptr<brb::WCTrack> > WCs;
  if (e.getByLabel(_WCInputTag, WCHandle)) art::fill_ptr_vector(WCs, WCHandle);

  art::Handle<std::vector<rawdata::RawBeamlineTrigger> > TriggerHandle;
  std::vector<art::Ptr<rawdata::RawBeamlineTrigger> > Triggers;
  if (e.getByLabel(_TriggerInputTag, TriggerHandle))
    art::fill_ptr_vector(Triggers, TriggerHandle);

  art::Handle<std::vector<rawdata::RawBeamlineWC> > RawWCHandle;
  std::vector<art::Ptr<rawdata::RawBeamlineWC> > RawWCs;
  if (e.getByLabel(_RawWCInputTag, RawWCHandle))
    art::fill_ptr_vector(RawWCs, RawWCHandle);

  for (auto trigItr = Triggers.begin(); trigItr != Triggers.end(); trigItr++) {
    unsigned int pattern = (*trigItr)->Pattern();
    unsigned int binaryNumber[32];
    decimal2binary(pattern, &binaryNumber[0]);
    if (binaryNumber[13] == 1) countTriggerBit_TOFDS++;
    if (binaryNumber[8] == 1) countTriggerBit_TOFUS++;
    if (binaryNumber[14] == 1) countTriggerBit_TOFPrompt++;
    if (binaryNumber[15] == 1) countTriggerBit_TOFSlow++;
    if (binaryNumber[12] == 1) countTriggerBit_WCHDWR++;
    if (binaryNumber[4] == 1) countTriggerBit_PAD1++;
    if (binaryNumber[5] == 1) countTriggerBit_PAD2++;
    if (binaryNumber[6] == 1) countTriggerBit_PAD3++;
    if (binaryNumber[7] == 1) countTriggerBit_PAD4++;
  }

  if (e.subRun() < 20 && _RunStartH == -9999 && _RunStartM == -9999) {
    struct tm outputTime;
    if (Triggers.size() >= 1) {
      auto TriggerItr = Triggers.begin();
      uint64_t inputNovaTime = (*TriggerItr)->TDUTime();
      convertNovaTimeToUnixTime(inputNovaTime, outputTime);
    }
    bool hourBack = false;
    if (outputTime.tm_min < (int)(e.subRun() - 1)) {
      _RunStartM = outputTime.tm_min - (e.subRun() - 1) + 60;
      hourBack = true;
    } else {
      _RunStartM = outputTime.tm_min - (e.subRun() - 1);
    }
    if (hourBack) {
      _RunStartH = outputTime.tm_hour - 6 > 0 ? outputTime.tm_hour - 6
                                              : outputTime.tm_hour - 6 + 24;
    } else {
      _RunStartH = outputTime.tm_hour - 5 > 0 ? outputTime.tm_hour - 5
                                              : outputTime.tm_hour - 5 + 24;
    }
    std::cout << "_RunStartH: " << _RunStartH << std::endl;
    std::cout << "_RunStartM: " << _RunStartM << std::endl;
  }

  for (unsigned int iCh = 0; iCh < 12; iCh++) {
    startTimeOfHits[iCh].clear();
  }

  for (auto TOFitr = ToFs.begin(); TOFitr != ToFs.end(); TOFitr++) {
    unsigned int channel = fChannelMap->OnlineDigitChannel((*TOFitr)->ChannelID());
    startTimeOfHits[channel - 4].push_back((*TOFitr)->StartTimeInNanoSec());
  }

  std::vector<double> hitStartTOFUS = findCluster(0);
  std::vector<double> hitStartTOFDS = findCluster(1);
  int nHitsTOFUS = hitStartTOFUS.size();
  int nHitsTOFDS = hitStartTOFDS.size();

  bool passSelectionGoodTrack = false;
  if (nHitsTOFUS >= 1 && nHitsTOFDS >= 1) passSelectionGoodTrack = true;
  if (passSelectionGoodTrack) {
    if (_RequireWCTrack) {
      if (WCs.size() >= 1) {
        goodTriggersInSubrun++;
      }  // make sure only one and only one track is associated with this
         // trigger
    } else {
      goodTriggersInSubrun++;
    }
  }

  unsigned int foundWC[4] = {1, 1, 1, 1} ;
  for (auto RawWCitr = RawWCs.begin(); RawWCitr != RawWCs.end(); RawWCitr++) {
    unsigned int wcnumber = (*RawWCitr)->DetectorID().Detector;
    unsigned int nhitX = ((*RawWCitr)->XPulses()).size();
    unsigned int nhitY = ((*RawWCitr)->YPulses()).size();
    if (nhitX == 0 || nhitY == 0) {
      foundWC[wcnumber] = 0;
    }
  }
  unsigned int numberOfWCsHit = foundWC[0] + foundWC[1] + foundWC[2] + foundWC[3];

  bool passSelection3WCs = false;
  if (nHitsTOFUS >= 1 && nHitsTOFDS >= 1) passSelection3WCs = true;
  if (passSelection3WCs) {
    if (_Require3WCs) {
      if (numberOfWCsHit >= 3) {
        decentTriggersInSubrun++;
      }  // make sure only one and only one track is associated with this
         // trigger
    } else {
      decentTriggersInSubrun++;
    }
  }

  totalTriggersInSubrun++;
}

std::vector<double> novatb::BeamTuning::findCluster(unsigned int tofIndex) {
  std::vector<double> hitStartTOF;

  std::vector<double> TOFGroup[4];
  if (tofIndex == 0) {
    for (unsigned int iCh = 8; iCh < 12; iCh++) {
      for (unsigned int iElem = 0; iElem < startTimeOfHits[iCh - 4].size();
           iElem++) {
        TOFGroup[iCh - 8].push_back(startTimeOfHits[iCh - 4].at(iElem));
      }
    }
  } else if (tofIndex == 1) {
    for (unsigned int iCh = 12; iCh < 16; iCh++) {
      for (unsigned int iElem = 0; iElem < startTimeOfHits[iCh - 4].size();
           iElem++) {
        TOFGroup[iCh - 12].push_back(startTimeOfHits[iCh - 4].at(iElem));
      }
    }
  }

  for (unsigned int iNS = 0; iNS < 400; iNS++) {
    double coincWindowStart = (double)iNS;
    double coincWindowEnd = (double)iNS + 5.;

    bool coincidence_individual_channel[4];
    double coincidence_time_individual_channel[4];
    for (unsigned int iCh = 0; iCh < 4; iCh++) {
      coincidence_individual_channel[iCh] = false;
      coincidence_time_individual_channel[iCh] = 0.;
    }

    for (unsigned int iCh = 0; iCh < 4; iCh++) {
      for (unsigned int iElem = 0; iElem < TOFGroup[iCh].size(); iElem++) {
        if (coincWindowStart < TOFGroup[iCh].at(iElem) &&
            TOFGroup[iCh].at(iElem) < coincWindowEnd) {
          coincidence_individual_channel[iCh] = true;
          coincidence_time_individual_channel[iCh] = TOFGroup[iCh].at(iElem);
        }
      }
    }

    // check coinciden 3 out of 4 or 4 out of 4
    bool tof_conic_3in4[4];
    for (unsigned int iChNegate = 0; iChNegate < 4; iChNegate++) {
      tof_conic_3in4[iChNegate] = true;
      for (unsigned int iChCoinc = 0; iChCoinc < 4; iChCoinc++) {
        if (iChCoinc != iChNegate)
          tof_conic_3in4[iChNegate] = tof_conic_3in4[iChNegate] &&
                                      coincidence_individual_channel[iChCoinc];
      }
    }
    bool tof_conic_4in4 = true;
    for (unsigned int iChCoinc = 0; iChCoinc < 4; iChCoinc++) {
      tof_conic_4in4 =
          tof_conic_4in4 && coincidence_individual_channel[iChCoinc];
    }

    bool tof_conic = tof_conic_4in4;
    for (unsigned int iChNegate = 0; iChNegate < 4; iChNegate++) {
      tof_conic = tof_conic || tof_conic_3in4[iChNegate];
    }

    if (tof_conic) {
      double sum = 0;
      for (unsigned int iCh = 0; iCh < 4; iCh++) {
        sum += coincidence_time_individual_channel[iCh];
      }
      if (tof_conic_4in4) {
        hitStartTOF.push_back(sum / 4.);
      } else {
        hitStartTOF.push_back(sum / 3.);
      }
      iNS = (unsigned int)coincWindowEnd;
    } else
      continue;
  }  // loop over 400ns step of 1ns

  return hitStartTOF;
}

void novatb::BeamTuning::findTime(unsigned int subrunNo, int& srH, int& srM) {
  srM = _RunStartM + subrunNo - 1;
  // std::cout << "srM: " << srM << std::endl;
  int hourAdded = (int)srM / 60;
  // std::cout << "hourAdded: " << hourAdded << std::endl;
  srM = srM % 60;
  // std::cout << "srM: " << srM << std::endl;
  srH = _RunStartH + hourAdded;
  // std::cout << "srH: " << srH << std::endl;
}

void novatb::BeamTuning::endSubRun(art::SubRun const& sr) {
  // std::cout << "totalTriggersInSubrun: " << totalTriggersInSubrun << std::endl;
  // std::cout << "goodTriggersInSubrun: " << goodTriggersInSubrun << std::endl;
  // std::cout << "sr.subRun(): " << sr.subRun() << std::endl;
  hGoodTriggerRatio->SetBinContent(
      (unsigned int)sr.subRun(),
      100. * ((double)goodTriggersInSubrun) / ((double)totalTriggersInSubrun));
  hDecentTriggerRatio->SetBinContent(
      (unsigned int)sr.subRun(),
      100. * ((double)decentTriggersInSubrun) / ((double)totalTriggersInSubrun));
  hTotalTrigger->SetBinContent((unsigned int)sr.subRun(),
                               (double)totalTriggersInSubrun);
  hGoodTrigger->SetBinContent((unsigned int)sr.subRun(),
                              (double)goodTriggersInSubrun);
  hDecentTrigger->SetBinContent((unsigned int)sr.subRun(),
                              (double)decentTriggersInSubrun);

  TriggerBitCountFile << std::setw(15) << sr.id().subRun() << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_TOFDS << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_TOFUS << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_TOFPrompt << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_TOFSlow << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_WCHDWR << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_PAD1 << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_PAD2 << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_PAD3 << " ";
  TriggerBitCountFile << std::setw(15) << countTriggerBit_PAD4 << std::endl;
}

void novatb::BeamTuning::endRun(art::Run const& r) {}

bool novatb::BeamTuning::convertNovaTimeToUnixTime(
    uint64_t const& inputNovaTime, struct tm& outputUnixTime) {
  timeval outputTimeval;
  if (!convertNovaTimeToUnixTime(inputNovaTime, outputTimeval)) return false;
  outputUnixTime = *gmtime(&(outputTimeval.tv_sec));

  return true;
}

bool novatb::BeamTuning::convertNovaTimeToUnixTime(
    uint64_t const& inputNovaTime, struct timeval& outputUnixTime) {
  double doubleTime = (double)inputNovaTime / (double)NOVA_TIME_FACTOR;
  time_t time_sec = (time_t)doubleTime;
  outputUnixTime.tv_sec = NOVA_EPOCH + time_sec;
  outputUnixTime.tv_usec =
      (suseconds_t)((doubleTime - (double)time_sec) * 1000000);
  // test in chrono order
  if (outputUnixTime.tv_sec > 1341100799)  // Jun 30 23:59:59 2012 UTC
  {
    --outputUnixTime.tv_sec;
  }
  if (outputUnixTime.tv_sec > 1435708799)  // Jun 30 23:59:59 2015 UTC
  {
    --outputUnixTime.tv_sec;
  }

  if (outputUnixTime.tv_sec > 1483228799)  // Dec 31 23:59:59 2016 UTC
  {
    --outputUnixTime.tv_sec;
  }
  return true;
}

void novatb::BeamTuning::makeLinesAndTexts(TH1D* histogram, double ymin,
                                           double ymax,
                                           std::vector<TLine*>& lines,
                                           std::vector<TText*>& texts) {
  for (int i = 2; i < histogram->GetSize() - 2; i++) {
    std::string leadingZeroSr;
    std::string leadingZeroSrH;
    std::string leadingZeroSrM;

    int srH;
    int srM;
    int subrunno = (int)(histogram->GetBinCenter(i) - 0.4);
    if (subrunno % _TimeInterval == 0) {
      findTime(subrunno, srH, srM);

      std::stringstream ss;
      ss << subrunno;
      leadingZeroSr = ss.str();
      if (subrunno < 10) {
        leadingZeroSr = "00" + leadingZeroSr;
      } else if (subrunno < 100) {
        leadingZeroSr = "0" + leadingZeroSr;
      }

      std::stringstream ssh;
      ssh << srH;
      leadingZeroSrH = ssh.str();
      if (srH < 10) {
        leadingZeroSrH = "0" + leadingZeroSrH;
      }

      std::stringstream ssm;
      ssm << srM;
      leadingZeroSrM = ssm.str();
      if (srM < 10) {
        leadingZeroSrM = "0" + leadingZeroSrM;
      }

      TLine* newLine = new TLine((double)i, ymin, (double)i, ymax);
      lines.push_back(newLine);
      TText* newText = new TText(
          (double)subrunno - 0.8, ymin + 0.6 * (ymax - ymin),
          Form("%s:%s", leadingZeroSrH.c_str(), leadingZeroSrM.c_str()));
      texts.push_back(newText);
    }
  }
}

void novatb::BeamTuning::endJob() {
  // rootlogon();
  gStyle->SetOptStat(0);

  TCanvas* c = new TCanvas("c", "c", 3600, 2400);
  c->Divide(1, 2);
  hGoodTriggerRatio->SetLineWidth(1);
  hGoodTriggerRatio->SetLineColor(kRed);
  hDecentTriggerRatio->SetLineWidth(1);
  hDecentTriggerRatio->SetLineColor(kBlue);
  hTotalTrigger->SetLineWidth(1);
  hTotalTrigger->SetLineColor(kBlack);
  hGoodTrigger->SetLineWidth(1);
  hGoodTrigger->SetLineColor(kRed);
  hDecentTrigger->SetLineWidth(1);
  hDecentTrigger->SetLineColor(kBlue);

  _RangeRatio = hDecentTriggerRatio->GetBinContent(hDecentTriggerRatio->GetMaximumBin());
  _RangeTotal = hTotalTrigger->GetBinContent(hTotalTrigger->GetMaximumBin());
  _RangeGood = hDecentTrigger->GetBinContent(hDecentTrigger->GetMaximumBin());

  _RangeRatio = _RangeRatio * 1.2;
  _RangeTotal = _RangeTotal * 1.2;
  _RangeGood = _RangeGood * 1.2;

  hDecentTriggerRatio->GetYaxis()->SetRangeUser(0, _RangeRatio);
  hTotalTrigger->GetYaxis()->SetRangeUser(0, _RangeTotal);
  hDecentTrigger->GetYaxis()->SetRangeUser(0, _RangeGood);

  hGoodTriggerRatio->GetXaxis()->CenterTitle();
  hDecentTriggerRatio->GetXaxis()->CenterTitle();
  hTotalTrigger->GetXaxis()->CenterTitle();
  hGoodTrigger->GetXaxis()->CenterTitle();
  hDecentTrigger->GetXaxis()->CenterTitle();

  c->cd(1);
  TLegend* leg_ratio = new TLegend(0.75, 0.75, 0.95, 0.95);
  leg_ratio->AddEntry(hDecentTriggerRatio, "TOF & atleast 3WCs", "l");
  leg_ratio->AddEntry(hGoodTriggerRatio, "TOF & Track (4WCs)", "l");
  hDecentTriggerRatio->Draw();
  hGoodTriggerRatio->Draw("SAME");
  leg_ratio->Draw();
  std::vector<TLine*> ratiolines;
  std::vector<TText*> ratiotexts;
  makeLinesAndTexts(hDecentTriggerRatio, 0, _RangeRatio, ratiolines, ratiotexts);
  if (_DrawLinesAndTimes) {
    for (unsigned int k = 0; k < ratiolines.size(); k++) {
      ratiolines.at(k)->SetLineStyle(kDashed);
      ratiolines.at(k)->Draw();
      ratiotexts.at(k)->SetTextAngle(90);
      ratiotexts.at(k)->Draw();
    }
  }

  c->cd(2);
  TLegend* leg = new TLegend(0.75, 0.70, 0.95, 0.95);
  leg->AddEntry(hTotalTrigger, "All triggers", "l");
  leg->AddEntry(hDecentTrigger, "TOF & atleast 3WCs", "l");
  leg->AddEntry(hGoodTrigger, "TOF & Track (4WCs)", "l");
  hTotalTrigger->Draw();
  hGoodTrigger->Draw("SAME");
  hDecentTrigger->Draw("SAME");
  leg->Draw();
  std::vector<TLine*> totallines;
  std::vector<TText*> totaltexts;
  makeLinesAndTexts(hTotalTrigger, 0, _RangeTotal, totallines, totaltexts);
  if (_DrawLinesAndTimes) {
    for (unsigned int k = 0; k < totallines.size(); k++) {
      totallines.at(k)->SetLineStyle(kDashed);
      totallines.at(k)->Draw();
      totaltexts.at(k)->SetTextAngle(90);
      totaltexts.at(k)->Draw();
    }
  }

  c->SaveAs(Form("tune_run_%i.pdf", (int)runNumber));

  TriggerBitCountFile.close();
}

DEFINE_ART_MODULE(novatb::BeamTuning)