#include <ScintTimeXeDoping.h>

Inheritance diagram for phot::ScintTimeXeDoping:

Public Member Functions
	ScintTimeXeDoping (fhicl::ParameterSet const &pset)

void	GenScintTime (bool is_fast, CLHEP::HepRandomEngine &engine)

Public Member Functions inherited from phot::ScintTime
	ScintTime ()

virtual	~ScintTime ()=default

double	GetScintTime () const

Private Member Functions
double	exp_diff (double t, double tau1, double tau2) const

double	singlet_distro (double t) const

double	triplet_distro (double t) const

Private Attributes
double	fXeConcentration

double	fArSingletTime

double	fArTripletTime

double	fXe150nmTime

double	fTauAX

double	fTauXX

double	fTauN2

double	fTauTAs

double	fTauTAt

double	fTauTX

double	fMaxProbs

double	fMaxProbt

double	fMaxTs

double	fMaxTt

Additional Inherited Members
Protected Attributes inherited from phot::ScintTime
double	timing

Detailed Description

Definition at line 22 of file ScintTimeXeDoping.h.

Constructor & Destructor Documentation

phot::ScintTimeXeDoping::ScintTimeXeDoping ( fhicl::ParameterSet const & pset )

explicit

Definition at line 16 of file ScintTimeXeDoping_tool.cc.

     : ScintTime()
     , fXeConcentration{pset.get<double>("XeConcentration")}
     , fArSingletTime  {pset.get<double>("ArSingletTime")}
     , fArTripletTime  {pset.get<double>("ArTripletTime")}
     , fXe150nmTime    {pset.get<double>("Xe150nmTime")}
     , fTauAX          {pset.get<double>("TauAX")}
     , fTauXX          {pset.get<double>("TauXX")}
     , fTauN2          {pset.get<double>("TauN2", 0)}
     {
         double invTauN2 = 0;
         if (fTauN2 > 0) invTauN2 = 1./fTauN2;
 
         // Calculations from D. Totani, Feb. 2021
         fTauTAs = 1./(1./fArSingletTime + 4*fXeConcentration/fTauAX);
         fTauTAt = 1./(1./fArTripletTime +   fXeConcentration/fTauAX + invTauN2);
         fTauTX  = 1./(1./fXe150nmTime   +   fXeConcentration/fTauXX + invTauN2);
 
         double step = 0.1; //ns
 
         fMaxProbs = 0;
         fMaxTs = 0;
         double integral = 0;
         while (integral < 0.999) {
             double val = singlet_distro(fMaxTs);
             if (val > fMaxProbs) fMaxProbs = val;
             integral += val*step;
             fMaxTs += step;
         }
 
         fMaxProbt = 0;
         fMaxTt = 0;
         integral = 0;
         while (integral < 0.999) {
             double val = triplet_distro(fMaxTt);
             if (val > fMaxProbt) fMaxProbt = val;
             integral += val*step;
             fMaxTt += step;
         }
 
         mf::LogInfo("ScintTimeXeDoping")
             << "Configured:" << "\n"
             << "  XeConcentration: " << fXeConcentration << " ppm\n"
             << "  ArTripletTime:   " << fArTripletTime << " ns\n"
             << "  Xe150nmTime:     " << fXe150nmTime << " ns\n"
             << "  TauAX:           " << fTauAX << " ns\n"
             << "  TauXX:           " << fTauXX << " ns\n"
             << "Calculated:" << "\n"
             << "  TauTA singlet:   " << fTauTAs << " ns\n"
             << "  TauTA triplet:   " << fTauTAt << " ns\n"
             << "  TauTX:           " << fTauTX  << " ns\n"
             << "  MaxTime Singlet: " << fMaxTs  << " ns\n"
             << "  MaxTime Triplet: " << fMaxTt  << " ns\n";
     }

Member Function Documentation

double phot::ScintTimeXeDoping::exp_diff	(	double	t,
		double	tau1,
		double	tau2
	)		const

private

Definition at line 72 of file ScintTimeXeDoping_tool.cc.

     {
         using std::exp;
         return ( exp(-t/tau1) - exp(-t/tau2) ) / (tau1 - tau2);
     }

void phot::ScintTimeXeDoping::GenScintTime	(	bool	is_fast,
		CLHEP::HepRandomEngine &	engine
	)

virtual

Implements phot::ScintTime.

Definition at line 81 of file ScintTimeXeDoping_tool.cc.

     {
         CLHEP::RandFlat randflatscinttime{engine};
 
         //ran1, ran2 = random numbers for the algorithm        
         while (1)
         {
             double ran1 = randflatscinttime();
             double ran2 = randflatscinttime();
 
             // Use ran1 to pick a proposal time
             // uniformly within the allowed range
             double t = ran1 * (is_fast ? fMaxTs 
                                        : fMaxTt);
 
             // Rejection prob for this point
             auto p = (is_fast ? singlet_distro(t) / fMaxProbs
                               : triplet_distro(t) / fMaxProbt);
 
             // Keep the point if ran2 below p
             // (larger value of scint_distro -> more likely to sample)
             if (ran2 < p) {
                 timing = t;
                 return;
             }
         }
     }