/home/alex/Work/Research/Km3NeT/PPM-DU/ppm-du-v2.3/histo.h

Go to the documentation of this file.

#ifndef _histo_h_
#define _histo_h_

#include <vector>

#include <TCanvas.h>
#include <TH1I.h>
#include <TH2I.h>
#include <TAxis.h>
#include <TCanvas.h>
#include <TGraph.h>

#include "signal.h"
#include "pmt.h"
#include "dom.h"
#include "event.h"
#include "triggeredSignals.h"
#include "constants.h"

class histo {
 public:

 histo(const int domId, const int index, const int pmtId)
   : fDomId(domId), fIndex(index), fPmtId(pmtId) { fAfterpulse = false; }

  const int GetDomId() const { return fDomId; }
  void SetDomId(const int id) { fDomId = id; }
  const int GetIndex() const { return fIndex; }
  void SetIndex(const int id) { fIndex = id; }
  const int GetPmtId() const { return fPmtId; }
  void SetPmtId(const int id) { fPmtId = id; }
  const int GetRunId() const { return fRunId; }
  void SetRunId(const int id) { fRunId = id; }

  void InitSignal();
  void FillSignal(const signal& sig); 
  void FillSignal(const std::vector<signal>& sigSample, long long int time);
  void DrawSignal(); 

  void InitDuration();
  void FillDuration(const std::vector<signal>& sig);
  void DrawDuration();

  void InitDurations(const std::vector<int>& vDomId);
  void FillDurations(const int domId, const std::vector<pmt>& pmtSample, double cutValues[domNb][pmtNb]);
  void FillDurations(const std::vector<dom>& domSample, double cutValues[domNb][pmtNb], const std::vector<int>& vDomId);
  void FillDurations(const std::vector<event>& eventSample, double cutValues[domNb][pmtNb], const std::vector<int>& vDomId);
  void DrawDurations();

  void InitFrequency(const std::vector<int>& vDomId);
  void FillFrequency(const int domId, const std::vector<pmt>& pmtSample, double cutValues[domNb][pmtNb]);
  void FillFrequency(const std::vector<dom>& domSample, double cutValues[domNb][pmtNb], const std::vector<int>& vDomId);
  void FillFrequency(const std::vector<event>& eventSample, double cutValues[domNb][pmtNb], const std::vector<int>& vDomId);
  void DrawFrequency();

  void DrawPmtStat(const std::vector<pmt>& pmtSample);
  void DrawPmtStats(const std::vector<dom>& domSample, const std::vector<int>& vDomId);
  void DrawPmtStats(const std::vector<event>& eventSample, const std::vector<int>& vDomId);

  void InitDeltaT(const int refID);
  void InitDeltaT(const std::vector<int>& vDomId);
  void FillDeltaT(const std::vector<triggeredSignals>& vTrigger, const int domId, const int refID);
  void FillDeltaT(const std::vector<triggeredSignals>& vTrigger);
  void DrawDeltaT(const int refID);
  void DrawDeltaT();

  void InitDomDeltaT(const std::vector<int>& vDomId);
  void FillDomDeltaT(const std::vector<triggeredSignals>& vTrigger, const std::vector<int>& vDomId);
  void DrawDomDeltaT();

  void InitCoincidenceRate(const std::vector<int>& vDomId);
  void FillCoincidenceRate(const std::vector<triggeredSignals>& vTrigger);
  void DrawCoincidenceRate();

  void InitEventPerSlice(const bool individualPmt, const std::vector<int>& vDomId);
  void FillEventPerSlice(const std::vector<dom>& domSample, const bool individualPmt, const std::vector<int>& vDomId);
  void DrawEventPerSlice(const bool individualPmt, double cutValues[domNb][pmtNb], const std::vector<int>& vDomId);

  int FindDomIndex(const int id, const std::vector<int>& vDomId);

  void InitSliceTimeSeries(const std::vector<int>& vDomId);
  void FillSliceTimeSeries(const std::vector<dom>& domSample, const std::vector<int>& vDomId);
  void DrawSliceTimeSeries();

 private:
  int fDomId;
  int fIndex;
  int fPmtId;
  int fRunId;
  TH1I* fhSignal;
  TH1I* fhDuration;
  TH1I* fhDurations[domNb][pmtNb];
  TH1D* fhDuration1peMean[domNb];
  TH1D* fhDuration1peFit[domNb];
  TCanvas* fcDurations[domNb][pmtNb];
  TCanvas* fcDuration1peMean[domNb];
  TCanvas* fcDuration1peFit[domNb];
  TH2I* fhDurationVsTime[domNb][pmtNb];
  TCanvas* fcDurationVsTime[domNb][pmtNb];
  TH1I* fhFrequency[domNb][pmtNb];
  TCanvas* fcFrequency[domNb][pmtNb];
  TH2I* fhFrequencyVsTime[domNb][pmtNb];
  TCanvas* fcFrequencyVsTime[domNb][pmtNb];
  TH1I* fhSignalSpe[domNb];
  TCanvas* fcSignalSpe[domNb];
  //TH1I* fhDeltaT[domNb][pmtCouples];
  //TCanvas* fcDeltaT[domNb][pmtCouples];
  TH1I* fhDeltaT[domNb][pmtNb][pmtNb];
  TCanvas* fcDeltaT[domNb][pmtNb][pmtNb];
  TH1I* fhDomDeltaT[domNb*(domNb - 1)/2];
  TCanvas* fcDomDeltaT[domNb*(domNb - 1)/2];
  TH1I* fhCoincRate[domNb];
  TCanvas* fcCoincRate[domNb];
  TH1D* fhEventPerSlice[domNb];
  TCanvas* fcEventPerSlice[domNb];
  TH1D* fhEventPerSlice2[domNb][pmtNb];
  TCanvas* fcEventPerSlice2[domNb][pmtNb];
  TH1D* fhSliceTimeSeries[domNb];
  TCanvas* fcSliceTimeSeries[domNb];
  double fMinEvSlice;
  double fMaxEvSlice;
  bool fAfterpulse;
};

#endif