CamEvd.h

Go to the documentation of this file.

#ifndef CamEvd_H
#define CamEvd_H

#include <vector>

#include "RQ_OBJECT.h"
#include "TQObject.h"

#include "TMarker.h"
#include "TCanvas.h"
#include "TH2F.h"
#include "TLine.h"
#include "TPolyLine.h"

#include "CamAna.h"

class AtmosEvent;

class TGTransientFrame;
class TGCompositeFrame;
class TGNumberEntry;
class TGTextButton;
class TGCheckButton;
class TRootEmbeddedCanvas;
class TGTab;
class TGDoubleHSlider;
class TGDoubleVSlider;

class TChain;

class CamEvd : public CamAna {
RQ_OBJECT("CamEvd")
 public:
  CamEvd();
 ~CamEvd();
  bool FillEvent(const AtmosEvent* event);

  void MakeHistos();
  void MakeCanvases();

  void Reset();

  //Routines to set and get configurables
  void MakePS(bool Q); bool MakePS();
  void MakeEPS(bool Q); bool MakeEPS();
  void MakeGIF(bool Q); bool MakeGIF();
  void MakeROOT(bool Q); bool MakeROOT();
  void AutoPrint(bool Q); bool AutoPrint();
  void DoPrint();

  void DoShieldPlot(bool Q) {fDoShieldPlot=Q;}
  bool DoShieldPlot() {return fDoShieldPlot;}
  void FakeShieldData(bool Q) {fFakeShieldData=Q;}
  bool FakeShieldData() {return fFakeShieldData;}
  void DoShowerPlot(bool Q) {fDoShowerPlot=Q;}
  bool DoShowerPlot() {return fDoShowerPlot;}

  void MCTimeWin(double D); double MCTimeWin();
  void DoTimeCorr1(bool B); bool DoTimeCorr1();
  void DoTimeCorr2(bool B); bool DoTimeCorr2();
  void WlsFibreN(double D); double WlsFibreN();
  void ClearFibreN(double D); double ClearFibreN();

  void CloseWindow();
  void DoTab(int itab);
  void TabUp(bool up);
  void SetNumericOptions();
  void SetPlaneRangeUser(int MinPlane = 0, int MaxPlane = 0);
  void PlaneSlider();
  void SetUStripRangeUser(int MinStrip = -1, int MaxStrip = -1);
  void UStripSlider();
  void SetVStripRangeUser(int MinStrip = -1, int MaxStrip = -1);
  void VStripSlider();
  void SetTimeRangeUser(double MinT = -1.0, double MaxT = -1.0);
  void UnZoom();

  void AddFakeShieldData(const char* File);

private:
  int fRun, fSubRun, fSnarl;
  bool fIsMC;

  //Configurables
  bool fMakePS;
  bool fMakeEPS;
  bool fMakeGIF;
  bool fMakeROOT;
  bool fAutoPrint;

  void SetStyle();

  void MakeXYHits(const AtmosEvent* event);
  void MakeUVHits(const AtmosEvent* event);
  void MakeChargePlot(const AtmosEvent* event);
  void MakeTimingPlot(const AtmosEvent* event);
  void MakeMCPlot(const AtmosEvent* event);

  //Optional routines
  bool fDoShieldPlot;
  void MakeShieldPlot(const AtmosEvent* event);
  bool fDoShowerPlot;
  void MakeShowerPlot(const AtmosEvent* event);

  //Canvases
  TGTab *cgTab;
  std::vector<TCanvas*> AllCanvases;//Store for printing, etc.
  TCanvas *fActiveCanvas;
  TCanvas* cMainView;
  TCanvas* cSideView;
  TCanvas* cShieldView;
  TCanvas* cShowerView;
  TCanvas* cLIView;
  TCanvas* cTimingView;
  TCanvas* cMCMainView;
  TCanvas* cMCSideView;
  bool fMakeMCTrkIdView;
  TCanvas* cMCTrkIdView;

  //Option input entries
  TGNumberEntry *cgMCTimeWin;
  double fMCTimeWin;

  TGNumberEntry *cgWlsFibreN, *cgClearFibreN;
  double fWlsFibreN, fClearFibreN;

  //Time Correction and result
  bool fDoTimeCorr1, fDoTimeCorr2;
  double fMeanDEHitDT, fRMSDEHitDT;

  //Axis Histograms, not filled
  TH2F* hUZStpPlnAxis;
  TH2F* hUZLinearAxis;
  TH2F* hVZStpPlnAxis;
  TH2F* hVZLinearAxis;
  TH2F* hXYAxis;
  TH2F* hMCTZAxis;
  TH2F* hTZAxis;

  //Plane charge deposition plots
  TH1F* hRawPlaneCharge;
  TH1F* hCorrPlaneCharge;
  TH1F* hMCPlaneDE;
  TH2F* hPulserLedCharge;

  //2D Shower Histograms for lego plots
  TH2F* hUZStpPlnShw;
  TH2F* hVZStpPlnShw;

  //1D Shower Profile Histograms
  TH1* hShwPlnProfile;
  TH1* hShwPlnCosZProfile;

  //Shield Timing histograms
  TH1F* hTrkVeto[4];
  TH1F* hShwVeto[4];

  //Faked shield hits for the MC inefficiency study
  TChain *FakeShieldDataChain;
  AtmosEvent *FakeAtmosEvent;
  bool fFakeShieldData;

  //Timing histograms
  TH1F* hTiming;

  //Some Min and Max values to be shared across many histos
  TGDoubleHSlider *cgPlaneRange;
  TGDoubleVSlider *cgUStripRange, *cgVStripRange;
  int fMinPlane, fMinUStrip, fMinVStrip;
  int fMaxPlane, fMaxUStrip, fMaxVStrip;
  double fMinZ, fMinU, fMinV;
  double fMaxZ, fMaxU, fMaxV;
  double fMinT, fMaxT;

  //Marker and Line vectors
  std::vector<TMarker> fUZStpPlnHits;
  std::vector<TMarker> fUZLinearHitsT;
  std::vector<TMarker> fUZLinearHitsL;
  std::vector<TLine> fUZStpPlnLines;
  std::vector<TLine> fUZLinearLinesT;
  std::vector<TLine> fUZLinearLinesL;
  std::vector<TMarker> fVZStpPlnHits;
  std::vector<TMarker> fVZLinearHitsT;
  std::vector<TMarker> fVZLinearHitsL;
  std::vector<TLine> fVZStpPlnLines;
  std::vector<TLine> fVZLinearLinesT;
  std::vector<TLine> fVZLinearLinesL;
  std::vector<TMarker> fTZHits;

  std::vector<TMarker> fXYHits;
  std::vector<TLine> fXYLines;
  std::vector<TMarker> fKeySpots;

  std::vector<TMarker> fColorScale;

  ClassDef(CamEvd,1)
};

inline void CamEvd::MakePS(bool Q) {fMakePS = Q;}
inline bool CamEvd::MakePS() {return fMakePS;}
inline void CamEvd::MakeEPS(bool Q) {fMakeEPS = Q;}
inline bool CamEvd::MakeEPS() {return fMakeEPS;}
inline void CamEvd::MakeGIF(bool Q) {fMakeGIF = Q;}
inline bool CamEvd::MakeGIF() {return fMakeGIF;}
inline void CamEvd::MakeROOT(bool Q) {fMakeROOT = Q;}
inline bool CamEvd::MakeROOT() {return fMakeROOT;}
inline void CamEvd::AutoPrint(bool Q) {fAutoPrint = Q;}
inline bool CamEvd::AutoPrint() {return fAutoPrint;}

inline void CamEvd::MCTimeWin(double D) {fMCTimeWin = D;}
inline double CamEvd::MCTimeWin() {return fMCTimeWin;}
inline void CamEvd::WlsFibreN(double D) {fWlsFibreN = D;}
inline double CamEvd::WlsFibreN() {return fWlsFibreN;}
inline void CamEvd::ClearFibreN(double D) {fClearFibreN = D;}
inline double CamEvd::ClearFibreN() {return fClearFibreN;}

inline void CamEvd::DoTimeCorr1(bool B) {fDoTimeCorr1 = B;}
inline bool CamEvd::DoTimeCorr1() {return fDoTimeCorr1;}
inline void CamEvd::DoTimeCorr2(bool B) {fDoTimeCorr2 = B;}
inline bool CamEvd::DoTimeCorr2() {return fDoTimeCorr2;}

#endif

---