GenEfficiencyAnalysis.h

Go to the documentation of this file.

#include "GENESISConfig.h"
 
#include "TFile.h"
#include "TTree.h"
#include "TH2.h"
#include "TCanvas.h"
#include "TChain.h"
#include <vector>
#include <string>
#include <map>
#include <random>
using std::vector;
using std::string;
using std::map;
#include <Eigen/Dense>
class GenEfficiencyAnalysis
{
  public:
  GenEfficiencyAnalysis();
 
  GenEfficiencyAnalysis(string a_configFileName);
  void setRNGSeed(int a_seed);
  void addConfigFile(string a_configFileName);
  void loadSimulationEvents(string a_simFileName, int a_numEvents);
  void addLYCovarianceData(string a_fileName);
  void generateResampledConfig();
  void processSimData(bool a_useExpTimeRes=false,
                      double a_timeResolution=1.,
                      bool a_useLYResolution=true,
                      bool a_resampleLYCalib=false,
                      double a_minLight=-1);
  void loadSinglesData(string a_singlesFileName, 
                        double a_countingTime, 
                        double a_minTime=0);
  void loadCoincidenceData(string a_coinFileName, 
                        double a_countingTime, 
                        double a_minTime=0);
  void loadExpGammaGammaData(string a_ggFileName);
  int loadCoincidenceTreeData(string a_coinFileName,
                                double a_countingTime);
  void prepareCoinTreeData(bool a_useADC=false);
  TH2F* getExpTOFLightHist(int a_detID);
  TH2F* getTotalCoinHist(int a_detID, string a_histNameRoot);
  double calcAverageGammaEff(int a_detID,
                            double a_minEnergyBin=1,
                            double a_maxEnergyBin=-1);
  vector<double> plotTOFCf252Comparison(int a_detNum,
                                        bool a_normalize=false);
 
  vector<TH2F*> plotEDepCf252Comparison(int a_detNum);
  void calcMeanTOF(int a_meanSigma=0);
  map<double, double> respKDE1DInt(double a_mean, 
                                    double a_sig, 
                                    double a_nbins, 
                                    double a_max);
  void calcCompEff();
 
  vector<double> plotSliceEDep(vector<TH2F*> a_hists, int a_bin, bool a_normalize=false);
  void plotSinglesComparison();
  TCanvas* plotCumulativeEDepSlice(vector<TH2F*> a_hists, int a_detNum);
  TCanvas* plotCumulativeEDepSlice(int a_detNum);
  void plotCumulativeEDepSliceAllDet(int a_simExp);
  vector<double> plotPISingles(int a_detNum, bool a_draw=false);
  map<int, std::pair<double,double>> plotSinglesComparison(int a_xAxisType);
  void plotChi2SliceEDep(vector<TH2F*> a_hists, int a_detNum);
 
  void plotExpSinglesEff(int a_xAxisType);
 
  map<double,std::pair<double,double>> plotRelativeEnergyEff(int a_detNum,
                                bool a_drawSim=true,
                                std::pair<double,double> a_singlesEffs={1.,5.});
  TH1F* interpolateCf252Spectrum(vector<double> a_binEdges,
                                vector<double> a_flux,
                                double a_numNeutrons,
                                bool a_draw=false);
  double calcWattIntegral(double a_lowerE, double a_upperE);
  TH2F* getSimHist(int a_detNum);
  map<double,std::pair<double,double>> calcUniformEfficiency(int a_detNum,
                                                      double a_lowEnergy,
                                                      double a_upperEnergy);
  TH2F* buildResponseFunction(int a_detNum);
  map<int, Eigen::MatrixXf> m_respFuncs;
private:
  GenesisConfig m_conf;
  // TTree* m_simTree;
  TChain* m_simTree;
  double m_simTime;
  double m_simLY;
  int m_simChNum;
  map<int, TH2F*> m_simHists;
  map<int, TH2F*> m_simHistsEnerLight;
  map<int, map<int, TH1*>> m_expTimeResHists;
  vector<string> m_singlesFilesNames;
  vector<string> m_coinFilesNames;
  vector<string> m_coinTreeFilesNames;
  TChain* m_expCoinTree;
  double m_expCADC;
  double m_expCEgam;
  double m_expCTOF;
  int m_expCDet;
  bool m_hasCoinTreeFile=false;
  map<int, TH2F*> m_expCoinTreeHists_tofLight;
  map<int, map<int,TH2F*>> m_expCoinTreeHists_egamLight;
  map<int, TH2F*> m_expCoinTreeBKGHists;
 
  double m_sourceStrengthFrac = .8303;//.8133;//.8551;
  double m_PSDThreshold=.135;
  long int m_numSimEvents;
 
  vector<double> m_singlesTimes;
  vector<double> m_coinsTimes;
  vector<double> m_minimumTimesCoin;
  vector<double> m_minimumTimesSingles;
 
  double m_totalSinglesTime=0.;
  double m_totalCoinsTime=0.;
  double m_totalCoinsTreeTime=0.;
 
  int m_nBins_tof = 5000;
  // int m_nBins_tof = 5;
  int m_tofMinMax = 500;
  int m_nBins_egam = 100;
  int m_egamMax = 65536;//10;
  int m_nBins_light = 4096;
  // int m_nBins_light = 8;
  int m_lightMax = 10;
 
  map<int, Eigen::MatrixXf> m_lyCovariances;
  map<int, Eigen::VectorXf> m_lyParams0;
 
  std::mt19937_64 m_randGen;
// map<int,int> m_detConv = {{0,8},{1,7},{2,6},{3,5},{4,4},{5,3},{6,2},{7,1},{8,0},{9,9},{10,10},
//                         {11,18},{13,16},{14,15},{15,14},{16,13},{17,17},{18,11},
//                         // {19,19},{20,25},{21,24},{22,23},{23,22},{24,21},{25,20},{26,26}};
//                         {19,19},{20,20},{21,21},{22,22},{23,23},{24,24},{25,25}};//,{26,26}};
 
};