STOFAna.h

Go to the documentation of this file.

#ifndef _STOF_ANA_
#define _STOF_ANA_
//project 
#include "PostProcBase.h"
#include "STOFEvent.h"
#include "STOFConfig.h"
#include "CutManager.h"
#include "CutBuilder.h"
//external inputs
#include "json.hpp"
//root
#include "TH1.h"
#include "TH2.h"
//c++
#include <string>
#include <map>
#include <random>
#include <fstream>
class STOFAna : public PostProcBase<STOFEvent>
{
public:
  STOFAna();
  STOFAna(std::string a_configFile);
  void readConf(std::string a_configFile);
  std::vector<TH2*> makeOutgoingTOFVAmpHists(bool a_applyCalib=false,
                                             bool a_applyCuts = false
                                             );
  std::vector<TH2*> makeOutgoingTOFVTargetAmpHists(bool a_applyCalib=false,
                                             bool a_applyCuts = false
                                             );
  std::vector<TH2*> makeIncomingTOFVTargetAmpHists(bool a_applyCalib=false,
                                             bool a_applyCuts = false
                                             );
  std::vector<TH2*> makeEnETOFVTargetAmpHists(bool a_applyCalib=false,
                                             bool a_applyCuts = false
                                             );
  std::vector<TH2*> makeEnITOFVTargetAmpHists(bool a_applyCalib=false,
                                             bool a_applyCuts = false
                                             );
  std::vector<TH2*> makeEnITOFVTargetAmpHistsBG(bool a_applyCalib=false,
                                             bool a_applyCuts = false
                                             );
  std::vector<TH2*> makeEnITOFVEnETOF(bool a_applyCalib=false,
                                      bool a_applyCuts = false
                                     );
  std::vector<TH2*> makeEffEnVTargetAmpHists(bool a_applyCalib,
                                             bool a_applyCuts,
                                             bool a_exitTOFBinning = false
                                            );
  std::vector<TH2*> makeNeutronEneDist(bool a_applyCuts,
                                       bool a_exitTOF = false
                                       );
  void makePlotFile(std::string a_outFileName="stofResults.root",
                    bool a_applyCalib=false,
                    bool a_applyCuts = false
                    );
  void loadIncTOFGammaFlashHist(TH1* a_histogram);
 
  std::vector<TH1*> getScatterPulseHeight(double a_minET, 
                                          double a_maxET
                                          );
  std::vector<TH1*> getTargetPulseHeight(double a_minTOF,
                                         double a_maxTOF,
                                         bool a_incTOF 
                                        );
 
  
 
 
  void setIsSim(bool a_isSim);
  void setSmearExitTime(bool a_smearExitTime);
  void setExitTres(double a_exitTres);
  void setSmearIncTime(bool a_smearIncTime);
  void setIncTres(double a_incTres);
 
  //used for setting up histograms
  //number of amplitude bins to setup
  void setnAmpBins(int a_nAmpBins);
  //the maximum recoreded amplitude
  void setmaxAmp(double a_maxAmp);
  void seteTOFMax(double a_eTOFMax);
  void seteTOFMin(double a_eTOFMin);
  void setexitTBinWidth(double a_exitTBinWidth);
 
  void setSmearLight(bool a_smearLight);
  void setMaxEn(double a_maxEn);
  void setMinEn(double a_minEn);
  void setConfig(STOFConfig a_config);
 
  //getters
  bool getIsSim();
  bool getSmearExitTime();
  double getExitTres();
  bool getSmearIncTime();
  double getIncTres();
  int getnAmpBins();
  //the maximum recoreded amplitude
  double getmaxAmp();
  double geteTOFMax();
  double geteTOFMin();
  double getexitTBinWidth();
  bool getSmearLight();
  double getMaxEn();
  double getMinEn();
  TTree* getTree();
  STOFEvent* getEvent();
  CutManager& getCutManager();
  void clearHists();
 
  std::map<string, bool> m_cutState;
 
  ~STOFAna();
private:
  STOFConfig m_config;
  CutManager m_cutManager;
  bool passesCuts(STOFEvent* a_event);
  //these are used to functionalize the templated base class
  void setTreeName();
  void setBranchName();
  //used to store histograms from various routines
  std::map<std::string , TH1*> m_hists;
  //used to control simulation smearing and histogram generation
  bool   m_isSim;
  bool   m_smearExitTime;
  double m_exitTres;
  bool   m_smearIncTime;
  double m_incTres;
  bool   m_smearLight;
 
  //used for setting up histograms
  //number of amplitude bins to setup
  int m_nAmpBins;
  //the maximum recoreded amplitude
  double m_maxAmp;
  double m_eTOFMax;
  double m_eTOFMin;
  double m_exitTBinWidth;
  double m_iTOFMin;
  double m_iTOFMax;
  double m_iTOFBinWidth;
  double m_minEn;
  double m_maxEn;
 
  bool m_hasGammaFlashHist;
  TH1* m_incGammaFlashHist;
 
  //used to make a simulated event offset by the current settings for the 
  //the experimental uncertainties
  void createUncertainEv();
  //used to store a simulation event modified by the experimental uncertainties
  STOFEvent m_smrdEv;
  std::vector<double> getEnBinsETOF();
  std::vector<double> getEnBinsITOF();
    //set up random generator
  std::default_random_engine m_generator;
 
};
 
 
#endif