PMT analogue signal processor. More...

#include <JPMTAnalogueSignalProcessor.hh>

Inheritance diagram for JDETECTOR::JPMTAnalogueSignalProcessor:

Public Types
enum	JThresholdDomain { BELOW_THRESHOLD = -1 , THRESHOLDBAND = 0 , ABOVE_THRESHOLD = 2 }
	Threshold domain specifiers. More...

enum class	JAmplificationMode { Nominal , Mixed , UnderAmplified }
	Amplification mode specifiers. More...

enum class	JAnaloguePulseDomain { Gaussian , Exponential , Linear }
	Analogue pulse domain specifiers. More...

Public Member Functions
	JPMTAnalogueSignalProcessor (const JPMTParameters &parameters=JPMTParameters())
	Constructor.

void	configure ()
	Configure internal parameters.

double	getDecayTime () const
	Get decay time.

double	getT1 () const
	Get time at transition point from Gaussian to exponential.

double	getY1 () const
	Get amplitude at transition point from Gaussian to exponential.

double	getStartOfLinearisation () const
	Get transition point from a model-dependent to linear relation between time-over-threshold and number of photo-electrons.

double	getAmplitude (const double t1_ns) const
	Get amplitude at given time for a one photo-electron pulse.

double	getRiseTime (const double npe, const double th) const
	Get time to pass from threshold to top of analogue pulse.

double	getDecayTime (const double npe, const double th) const
	Get time to pass from top of analogue pulse to threshold.

double	applySaturation (const double tot_ns) const
	Get time-over-threshold with saturation.

double	removeSaturation (const double tot_ns) const
	Get time-over-threshold without saturation.

double	getDerivativeOfSaturation (const double tot_ns) const
	Get derivative of saturation factor.

double	getGain (int NPE) const
	Get gain.

double	getGainSpread () const
	Get gain spread for given number of photo-electrons.

double	getGainSpread (int NPE) const
	Get gain spread for given number of photo-electrons.

double	getUnderamplifiedGain () const
	Get gain of underamplified pulses.

double	getUnderamplifiedGain (int NPE) const
	Get gain of underamplified pulses.

double	getUnderamplifiedGainSpread () const
	Get gain spread of underamplified pulses.

double	getUnderamplifiedGainSpread (int NPE) const
	Get gain spread of underamplified pulses.

void	setPMTParameters (const JPMTParameters &parameters)
	Set PMT parameters.

JThresholdDomain	getThresholdDomain (const double npe) const
	Get threshold domain.

JAmplificationMode	getAmplificationMode () const
	Get amplification mode.

JAnaloguePulseDomain	getChargeDomain (const double npe) const
	Get charge domain.

JAnaloguePulseDomain	getToTDomain (const double tot_ns) const
	Get time-over-threshold domain.

virtual bool	applyQE () const override
	Apply relative QE.

virtual double	getRandomTime (const double t_ns) const override
	Get randomised time according transit-time distribution.

virtual bool	compare (const JPhotoElectron &first, const JPhotoElectron &second) const override
	Compare arrival times of photo-electrons.

virtual double	getRandomCharge (const int NPE) const override
	Get randomised charge according to gain and gain spread.

double	getRandomChargeNominal (const int NPE) const
	Get randomised charge according to gain and gain spread with a nominal amplification mode.

double	getRandomChargeMixed (const int NPE) const
	Get randomised charge according to gain and gain spread with a mixed amplification mode.

double	getRandomChargeUnderAmplified (const int NPE) const
	Get randomised charge according to gain and gain spread with an underamplified amplification mode.

virtual double	getChargeProbability (const double npe, const int NPE) const override
	Get probability density for given charge.

double	getChargeProbabilityNominal (const double npe, const int NPE) const
	Get probability density for given charge with a Nominal amplification mode.

double	getChargeProbabilityMixed (const double npe, const double NPE) const
	Get probability density for given charge with a mixed amplification mode.

double	getChargeProbabilityUnderAmplified (const double npe, const int NPE) const
	Get probability density for given charge with an underamplified amplification mode.

double	getIntegralOfChargeProbability (const double xmin, const double xmax, const int NPE) const
	Get integral of probability.

double	getIntegralOfChargeProbabilityNominal (const double xmin, const double xmax, const int NPE) const
	Get integral of probability with a nominal amplification mode.

double	getIntegralOfChargeProbabilityMixed (const double xmin, const double xmax, const int NPE) const
	Get integral of probability with a mixed amplification mode.

double	getIntegralOfChargeProbabilityUnderAmplified (const double xmin, const double xmax, const int NPE) const
	Get integral of probability with an underamplified amplification mode.

double	getIntegralOfChargeProbability (const JThresholdDomain domain, const int NPE) const
	Get integral of probability in specific threshold domain.

virtual bool	applyThreshold (const double npe) const override
	Apply threshold.

virtual double	getRiseTime (const double npe) const override
	Get time to reach threshold.

virtual double	getTimeOverThreshold (const double npe) const override
	Get time-over-threshold.

virtual double	getDerivative (const double npe) const override
	Get derivative of number of photo-electrons to time-over-threshold with saturation.

virtual double	getSurvivalProbability (const int NPE) const override
	Probability that a hit survives the simulation of the PMT.

virtual double	getThresholdProbability (const int NPE) const override
	Probability that a hit survives the threshold of the PMT.

double	getThresholdProbabilityNominal (const int NPE) const
	Probability that a hit survives the threshold of the PMT with a nominal amplification mode.

double	getThresholdProbabilityMixed (const int NPE) const
	Probability that a hit survives the threshold of the PMT with a mixed amplification mode.

double	getThresholdProbabilityUnderAmplified (const int NPE) const
	Probability that a hit survives the threshold of the PMT with an underamplified amplification mode.

virtual double	getNPE (const double tot_ns) const override
	Get number of photo-electrons.

double	getTimeOverThresholdProbability (const double tot_ns, const int NPE) const
	Get probability of having a pulse with specific time-over-threshold.

double	getIntegralOfTimeOverThresholdProbability (const double Tmin, const double Tmax, const int NPE) const
	Get cumulative probability of time-over-threshold distribution.

void	operator() (const JCalibration &calibration, const JPMTData< JPMTSignal > &input, JPMTData< JPMTPulse > &output) const
	Process hits.

virtual void	merge (JPMTData< JPMTPulse > &data) const
	Merging of PMT hits.

const JPMTParameters &	getPMTParameters () const
	Get PMT parameters.

bool	is_valid () const
	Check validity of PMT parameters.

int	getType () const
	Get type for for time-slewing correction.

JProperties	getProperties (const JEquationParameters &equation=JPMTParameters::getEquationParameters())
	Get properties of this class.

JProperties	getProperties (const JEquationParameters &equation=JPMTParameters::getEquationParameters()) const
	Get properties of this class.

Static Public Member Functions
static double	getMaximalRiseTime (const double th)
	Get maximal rise time for given threshold.

static double	getTH0 ()
	Get lower threshold for rise time evaluation.

static double	getTH1 ()
	Get upper threshold for rise time evaluation.

static double	getTmin ()
	Get two photo-electron resolution for time-over-threshold.

static double	getQmin ()
	Get width of charge distribution.

static JEquationParameters &	getEquationParameters ()
	Get equation parameters.

static void	setEquationParameters (const JEquationParameters &equation)
	Set equation parameters.

Public Attributes
double	QE
	relative quantum efficiency

double	gain
	gain [unit]

double	gainSpread
	gain spread [unit]

double	riseTime_ns
	rise time of analogue pulse [ns]

double	TTS_ns
	transition time spread [ns]

double	threshold
	threshold [npe]

double	PunderAmplified
	probability of underamplified hit

double	thresholdBand
	threshold-band [npe]

double	mean_ns
	mean time-over-threshold of threshold-band hits [ns]

double	sigma_ns
	time-over-threshold standard deviation of threshold-band hits [ns]

double	slope
	slope [ns/npe]

double	saturation
	saturation [ns]

bool	slewing
	time slewing of analogue signal

Protected Attributes
double	decayTime_ns
	decay time [ns]

double	t1
	time at match point [ns]

double	y1
	amplitude at match point [npe]

double	x1
	Transition point from a logarithmic to a linear relation between time-over-threshold and number of photo-electrons.

Friends
std::istream &	operator>> (std::istream &in, JPMTAnalogueSignalProcessor &object)
	Read PMT signal from input.

Detailed Description

PMT analogue signal processor.

This class provides for an implementation of the JDETECTOR::JPMTSignalProcessorInterface using a specific model for the analogue pulse of the PMT.
In this, the leading edge of the analogue pulse from the PMT is assumed to be a Gaussian and the tail an exponential.
The width of the Gaussian is referred to as the rise time and the inverse slope of the exponential to the decay time.
The two functions are matched at a point where the values and first derivatives are identical.
Note that the decay time is related to the rise time via the specification JDETECTOR::TIME_OVER_THRESHOLD_NS.

The charge distribution is assumed to be a Gaussian which is centered at the specified gain and truncated by the specified threshold.

The transit times are generated according the specified spread as follows.

If the specified transit-time spread (TTS) is negative, the transit times are generated according to measurements (see method JDETECTOR::getTransitTime).
In this, the negated integral value of the TTS corresponds to the option which in turn corresponds to the detector identifier of the measurements.
If the specified TTS is positive, the transit times are generated according a Gaussian with a sigma equals to the given TTS.
If the TTS is zero, the transit times are generated without any spread.

Definition at line 53 of file JPMTAnalogueSignalProcessor.hh.

Member Enumeration Documentation

◆ JThresholdDomain

enum JDETECTOR::JPMTAnalogueSignalProcessor::JThresholdDomain

Threshold domain specifiers.

Enumerator
BELOW_THRESHOLD	below threshold
THRESHOLDBAND	inside threshold band
ABOVE_THRESHOLD	above threshold

Definition at line 60 of file JPMTAnalogueSignalProcessor.hh.

                          {
      BELOW_THRESHOLD  = -1,     //!< below  threshold
      THRESHOLDBAND    =  0,     //!< inside threshold band
      ABOVE_THRESHOLD  =  2      //!< above  threshold
    };

◆ JAmplificationMode

enum class JDETECTOR::JPMTAnalogueSignalProcessor::JAmplificationMode

strong

Amplification mode specifiers.

Enumerator
Nominal
Mixed
UnderAmplified

Definition at line 70 of file JPMTAnalogueSignalProcessor.hh.

                                  {
      Nominal,                  // no underamplification
      Mixed,                    // underamplification
      UnderAmplified            // complete underamplification
    };

◆ JAnaloguePulseDomain

enum class JDETECTOR::JPMTAnalogueSignalProcessor::JAnaloguePulseDomain

strong

Analogue pulse domain specifiers.

Enumerator
Gaussian
Exponential
Linear

Definition at line 80 of file JPMTAnalogueSignalProcessor.hh.

                                    {
      Gaussian,                 // Gaussian
      Exponential,              // Gaussian + exponential
      Linear                    // Gaussian + exponential + linear
    };

Constructor & Destructor Documentation

◆ JPMTAnalogueSignalProcessor()

JDETECTOR::JPMTAnalogueSignalProcessor::JPMTAnalogueSignalProcessor ( const JPMTParameters & parameters = JPMTParameters() )

inline

Constructor.

Parameters

parameters PMT parameters

Definition at line 92 of file JPMTAnalogueSignalProcessor.hh.

                                                                                     :
      JPMTSignalProcessorInterface(),
      JPMTParameters(parameters),
      decayTime_ns(0.0),
      t1(0.0),
      y1(0.0),
      x1(std::numeric_limits<double>::max())
    {
      configure();
    }

Member Function Documentation

◆ configure()

void JDETECTOR::JPMTAnalogueSignalProcessor::configure ( )

inline

Configure internal parameters.

This method provides the implementations for

matching of the leading edge of the analogue pulse (Gaussian) and the tail (exponential); and
determination of number of photo-electrons above which the time-over-threshold linearly depends on the number of photo-electrons (apart from saturation).

Note that this method will throw an error if the value of the rise time (i.e. width of the Gaussian) is too large with respect to the specification JDETECTOR::TIME_OVER_THRESHOLD_NS.

Definition at line 115 of file JPMTAnalogueSignalProcessor.hh.

    {
      static const int    N         = 100;
      static const double precision = 1.0e-4;
 
      // check thresholdband
 
      if (threshold - thresholdBand < getTH0()) {
        THROW(JValueOutOfRange, "JPMTAnalogueSignalProcessor::configure(): Invalid thresholdband [npe] " << thresholdBand);
      }
 
      // check rise time      
 
      if (riseTime_ns > getMaximalRiseTime(threshold)) {
        THROW(JValueOutOfRange, "JPMTAnalogueSignalProcessor::configure(): Invalid rise time [ns] " << riseTime_ns);
      } 
 
      // check probability for under-amplified signal
 
      if (PunderAmplified < 0.0) {
        THROW(JValueOutOfRange, "JPMTAnalogueSignalProcessor::configure(): Invalid probability of under-amplification " << PunderAmplified);
      }
 
      // decay time
 
      const double y  = -log(threshold);
 
      const double a  =  y;
      const double b  =  riseTime_ns * sqrt(2.0*y) - TIME_OVER_THRESHOLD_NS;
      const double c  =  0.5*riseTime_ns*riseTime_ns;
      const double Q  =  b*b - 4.0*a*c;
 
      if (Q > 0.0) 
        decayTime_ns = (-b + sqrt(Q)) / (2.0*a);
      else
        decayTime_ns =  -b / (2.0*a);
 
      // fix matching of Gaussian and exponential
 
      const double x  =  riseTime_ns / decayTime_ns;
 
      t1 = riseTime_ns*x;
      y1 = exp(-0.5*x*x);
 
      // determine transition point to linear dependence of time-over-threshold as a function of number of photo-electrons
      
      const double xs = saturation;              // disable saturation
 
      saturation = 1.0e50;
 
      x1 = std::numeric_limits<double>::max();   // disable linearisation
 
      double xmin = 1.0;
      double xmax = 1.0 / (getDerivative(1.0) * slope);
 
      for (int i = 0; i != N; ++i) {
 
        const double x = 0.5 * (xmin + xmax);
        const double u = getDerivative(x) * slope;
 
        if (fabs(1.0 - u) < precision) {
          break;
        }
 
        if (u < 1.0)
          xmin = x;
        else
          xmax = x;
      }
 
      x1 = 0.5 * (xmin + xmax);
 
      saturation = xs;                           // restore saturation
    }

◆ getDecayTime() [1/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getDecayTime ( ) const

inline

Get decay time.

Returns: decay time [ns]

Definition at line 196 of file JPMTAnalogueSignalProcessor.hh.

    {
      return decayTime_ns;
    }

◆ getT1()

double JDETECTOR::JPMTAnalogueSignalProcessor::getT1 ( ) const

inline

Get time at transition point from Gaussian to exponential.

Returns: time [ns]

Definition at line 207 of file JPMTAnalogueSignalProcessor.hh.

    {
      return t1;
    }

◆ getY1()

double JDETECTOR::JPMTAnalogueSignalProcessor::getY1 ( ) const

inline

Get amplitude at transition point from Gaussian to exponential.

Returns: amplitude [npe]

Definition at line 218 of file JPMTAnalogueSignalProcessor.hh.

    {
      return y1;
    }

◆ getStartOfLinearisation()

double JDETECTOR::JPMTAnalogueSignalProcessor::getStartOfLinearisation ( ) const

inline

Get transition point from a model-dependent to linear relation between time-over-threshold and number of photo-electrons.

Returns: number of photo-electrons [npe]

Definition at line 229 of file JPMTAnalogueSignalProcessor.hh.

    {
      return x1;
    }

◆ getAmplitude()

double JDETECTOR::JPMTAnalogueSignalProcessor::getAmplitude ( const double t1_ns ) const

inline

Get amplitude at given time for a one photo-electron pulse.

Parameters

t1_ns time [ns]

Returns: amplitude [npe]

Definition at line 241 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (t1_ns < t1) {
 
        const double x = t1_ns / riseTime_ns;
        
        return exp(-0.5*x*x);                                // Gaussian
 
      } else {
 
        const double x = t1_ns / decayTime_ns;
 
        return exp(-x) / y1;                                 // exponential
      }
    }

◆ getRiseTime() [1/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getRiseTime	(	const double	npe,
		const double	th ) const

inline

Get time to pass from threshold to top of analogue pulse.

In this, the leading edge of the analogue pulse is assumed to be Gaussian.

Parameters

npe	number of photo-electrons
th	threshold [npe]

Returns: time [ns]

Definition at line 266 of file JPMTAnalogueSignalProcessor.hh.

    {
      return riseTime_ns * sqrt(2.0*log(npe/th));            // Gaussian
    }

◆ getDecayTime() [2/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getDecayTime	(	const double	npe,
		const double	th ) const

inline

Get time to pass from top of analogue pulse to threshold.

In this, the trailing edge of the analogue pulse is assumed to be exponential.

Parameters

npe	number of photo-electrons
th	threshold [npe]

Returns: time [ns]

Definition at line 280 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (npe*y1 > th)
        return decayTime_ns * (log(npe/th) - log(y1));       // exponential
      else
        return getRiseTime(npe, th);                         // Gaussian
    }

◆ getMaximalRiseTime()

static double JDETECTOR::JPMTAnalogueSignalProcessor::getMaximalRiseTime ( const double th )

inlinestatic

Get maximal rise time for given threshold.

Note that the rise time is entirely constrained by the specification JDETECTOR::TIME_OVER_THRESHOLD_NS.

Parameters

th	threshold [npe]

Returns: rise time [ns]

Definition at line 297 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (th > 0.0 && th < 1.0)
        return 0.5 * TIME_OVER_THRESHOLD_NS / sqrt(-2.0*log(th));
      else
        THROW(JValueOutOfRange, "JPMTAnalogueSignalProcessor::getMaximalRiseTime(): Invalid threshold " << th);
    }

◆ applySaturation()

double JDETECTOR::JPMTAnalogueSignalProcessor::applySaturation ( const double tot_ns ) const

inline

Get time-over-threshold with saturation.

Parameters

tot_ns time-over-threshold without saturation

Returns: time-over-threshold with saturation

Definition at line 312 of file JPMTAnalogueSignalProcessor.hh.

    {
      return saturation / sqrt(tot_ns*tot_ns + saturation*saturation) * tot_ns;
    }

◆ removeSaturation()

double JDETECTOR::JPMTAnalogueSignalProcessor::removeSaturation ( const double tot_ns ) const

inline

Get time-over-threshold without saturation.

Parameters

tot_ns time-over-threshold with saturation

Returns: time-over-threshold without saturation

Definition at line 324 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (tot_ns < saturation)
        return saturation / sqrt(saturation*saturation - tot_ns*tot_ns) * tot_ns;
      else
        return std::numeric_limits<double>::max();
    }

◆ getDerivativeOfSaturation()

double JDETECTOR::JPMTAnalogueSignalProcessor::getDerivativeOfSaturation ( const double tot_ns ) const

inline

Get derivative of saturation factor.

Parameters

tot_ns time-over-threshold without saturation

Returns: derivative of saturation factor

Definition at line 339 of file JPMTAnalogueSignalProcessor.hh.

    {
      return saturation * saturation * saturation / ((saturation*saturation + tot_ns*tot_ns) * sqrt(saturation*saturation + tot_ns*tot_ns));
    }

◆ getGain()

double JDETECTOR::JPMTAnalogueSignalProcessor::getGain ( int NPE ) const

inline

Get gain.

Parameters

NPE	number of photo-electrons

Returns: gain

Definition at line 351 of file JPMTAnalogueSignalProcessor.hh.

    {
      return ((double) NPE) * gain;
    }

◆ getGainSpread() [1/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getGainSpread ( ) const

inline

Get gain spread for given number of photo-electrons.

Returns: gain spread

Definition at line 362 of file JPMTAnalogueSignalProcessor.hh.

    {
      return sqrt(gain) * gainSpread;
    }

◆ getGainSpread() [2/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getGainSpread ( int NPE ) const

inline

Get gain spread for given number of photo-electrons.

Parameters

NPE	number of photo-electrons

Returns: gain spread

Definition at line 374 of file JPMTAnalogueSignalProcessor.hh.

    {
      return sqrt((double) NPE) * getGainSpread();
    }

◆ getUnderamplifiedGain() [1/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getUnderamplifiedGain ( ) const

inline

Get gain of underamplified pulses.

Returns: gain of underamplified pulses

Definition at line 385 of file JPMTAnalogueSignalProcessor.hh.

    {
      return gain * gainSpread * gainSpread;
    }

◆ getUnderamplifiedGain() [2/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getUnderamplifiedGain ( int NPE ) const

inline

Get gain of underamplified pulses.

Parameters

NPE	number of photo-electrons

Returns: gain of underamplified pulses

Definition at line 397 of file JPMTAnalogueSignalProcessor.hh.

    {
      return ((double) NPE) * getUnderamplifiedGain();
    }

◆ getUnderamplifiedGainSpread() [1/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getUnderamplifiedGainSpread ( ) const

inline

Get gain spread of underamplified pulses.

Returns: gain spread of underamplified pulses

Definition at line 408 of file JPMTAnalogueSignalProcessor.hh.

    {
      return sqrt(gain) * gainSpread * gainSpread;
    }

◆ getUnderamplifiedGainSpread() [2/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getUnderamplifiedGainSpread ( int NPE ) const

inline

Get gain spread of underamplified pulses.

Parameters

NPE	number of photo-electrons

Returns: gain spread of underamplified pulses

Definition at line 420 of file JPMTAnalogueSignalProcessor.hh.

    {
      return sqrt((double) NPE) * getUnderamplifiedGainSpread();
    }

◆ setPMTParameters()

void JDETECTOR::JPMTAnalogueSignalProcessor::setPMTParameters ( const JPMTParameters & parameters )

inline

Set PMT parameters.

Parameters

parameters PMT parameters

Definition at line 431 of file JPMTAnalogueSignalProcessor.hh.

    {
      static_cast<JPMTParameters&>(*this).setPMTParameters(parameters);
 
      configure();
    }

◆ getThresholdDomain()

JThresholdDomain JDETECTOR::JPMTAnalogueSignalProcessor::getThresholdDomain ( const double npe ) const

inline

Get threshold domain.

Parameters

npe	number of photo-electrons

Returns: threshold domain

Definition at line 462 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (npe > threshold) {
 
        return ABOVE_THRESHOLD;
        
      } else if (npe > threshold - thresholdBand) {
 
        return THRESHOLDBAND;
        
      } else {
 
        return BELOW_THRESHOLD;
      }
    }

◆ getAmplificationMode()

JAmplificationMode JDETECTOR::JPMTAnalogueSignalProcessor::getAmplificationMode ( ) const

inline

Get amplification mode.

Returns: amplification mode

Definition at line 484 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (PunderAmplified <= 0.0) {
 
        return JAmplificationMode::Nominal;
 
      } else if (PunderAmplified < 1.0) {
 
        return JAmplificationMode::Mixed;
 
      } else {
 
        return JAmplificationMode::UnderAmplified;
      }
    }

◆ getChargeDomain()

JAnaloguePulseDomain JDETECTOR::JPMTAnalogueSignalProcessor::getChargeDomain ( const double npe ) const

inline

Get charge domain.

Parameters

npe	observed number of photo-electrons

Definition at line 506 of file JPMTAnalogueSignalProcessor.hh.

    {
      if        (npe*y1 <= threshold) {
 
        return JAnaloguePulseDomain::Gaussian;
      
      } else if (npe <= getStartOfLinearisation()) {
 
        return JAnaloguePulseDomain::Exponential;
      
      } else {
 
        return JAnaloguePulseDomain::Linear;
      }
    }

◆ getToTDomain()

JAnaloguePulseDomain JDETECTOR::JPMTAnalogueSignalProcessor::getToTDomain ( const double tot_ns ) const

inline

Get time-over-threshold domain.

Parameters

tot_ns time-over-threshold (with saturation) [ns]

Definition at line 528 of file JPMTAnalogueSignalProcessor.hh.

    {
      const double tot =  removeSaturation(tot_ns);
      const double TOT = (getRiseTime (getStartOfLinearisation(), threshold)  + 
                          getDecayTime(getStartOfLinearisation(), threshold));
      
      if        (tot <= 2*getRiseTime(threshold/y1,threshold)) {  // Gaussian + Gaussian
        
        return JAnaloguePulseDomain::Gaussian;
        
      } else if (tot <= TOT) {                                    // Gaussian + Exponential
 
        return JAnaloguePulseDomain::Exponential;
        
      } else {                                                                                  // linear
          
        return JAnaloguePulseDomain::Linear;
      }
    }

◆ applyQE()

virtual bool JDETECTOR::JPMTAnalogueSignalProcessor::applyQE ( ) const

inlineoverridevirtual

Apply relative QE.

Returns: true if accepted; false if rejected

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 554 of file JPMTAnalogueSignalProcessor.hh.

    {
      if      (QE <= 0.0)
        return false;
      else if (QE <  1.0)
        return gRandom->Rndm() < QE;
      else
        return true;
    }

◆ getRandomTime()

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getRandomTime ( const double t_ns ) const

inlineoverridevirtual

Get randomised time according transit-time distribution.

Parameters

t_ns time [ns]

Returns: time [ns]

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 571 of file JPMTAnalogueSignalProcessor.hh.

    {
      if      (TTS_ns < 0.0)
        return t_ns + getTransitTime(gRandom->Rndm(), getType());
      else if (TTS_ns > 0.0)
        return gRandom->Gaus(t_ns, TTS_ns);
      else
        return t_ns;
    }

◆ compare()

virtual bool JDETECTOR::JPMTAnalogueSignalProcessor::compare	(	const JPhotoElectron &	first,
		const JPhotoElectron &	second ) const

inlineoverridevirtual

Compare arrival times of photo-electrons.

This implementation uses the internal rise time as two photo-electron resolution.

Two (or more) photo-electrons are merged if they are comparable.

Parameters

first	first photo-electron
second	second photo-electron

Returns: true if arrival times of photo-electrons are within two photo-electron resolution; else false

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 592 of file JPMTAnalogueSignalProcessor.hh.

    {
      return second.t_ns < first.t_ns + riseTime_ns;
    }

◆ getRandomCharge()

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getRandomCharge ( const int NPE ) const

inlineoverridevirtual

Get randomised charge according to gain and gain spread.

Parameters

NPE	number of photo-electrons

Returns: number of photo-electrons

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 604 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (NPE > 0) {
 
        if (gainSpread > 0.0) {
 
          switch (getAmplificationMode()) {
 
          case JAmplificationMode::Nominal:
            return getRandomChargeNominal(NPE);
 
          case JAmplificationMode::Mixed:
            return getRandomChargeMixed(NPE);
 
          case JAmplificationMode::UnderAmplified:
            return getRandomChargeUnderAmplified(NPE);
 
          default:
            return 0.0;
          }
        
        } else {
 
          return getGain(NPE);
        }
 
      } else {
 
        return 0.0;
      }
    }

◆ getRandomChargeNominal()

double JDETECTOR::JPMTAnalogueSignalProcessor::getRandomChargeNominal ( const int NPE ) const

inline

Get randomised charge according to gain and gain spread with a nominal amplification mode.

Parameters

NPE	number of photo-electrons

Returns: number of photo-electrons

Definition at line 643 of file JPMTAnalogueSignalProcessor.hh.

    {
      double q;
 
      do {
 
        const double mu    = getGain(NPE);
        const double sigma = getGainSpread(NPE);
 
        q = gRandom->Gaus(mu, sigma);
 
      } while (q < 0.0);
      
      return q;
    }

◆ getRandomChargeMixed()

double JDETECTOR::JPMTAnalogueSignalProcessor::getRandomChargeMixed ( const int NPE ) const

inline

Get randomised charge according to gain and gain spread with a mixed amplification mode.

Parameters

NPE	number of photo-electrons

Returns: number of photo-electrons

Definition at line 666 of file JPMTAnalogueSignalProcessor.hh.

    {
 
      double q;
 
      do {
        // Determine which contribution to sample from
        // Method uses inverse transform sampling for a binomial distribution
 
        const double X = gRandom->Uniform();
        double sum_p   = 0.0;
        double weight  = pow(1-PunderAmplified, NPE);
        int k          = 0;  // k underamplified photo-electrons
  
        for (; k <= NPE; ++k) {
      
          sum_p += weight;
          if (sum_p > X) { break; }
      
          weight *= ((double) (NPE-k) / ((double) (k+1)))  *  PunderAmplified / (1.0 - PunderAmplified);
        }
 
        // Sample from chosen contribution
        const double mu    = (NPE-k) * gain  +  (k) * getUnderamplifiedGain();
        const double sigma = gainSpread * sqrt(mu);
 
        q = gRandom->Gaus(mu, sigma);
 
      } while (q < 0.0);
      
      return q;
    }

◆ getRandomChargeUnderAmplified()

double JDETECTOR::JPMTAnalogueSignalProcessor::getRandomChargeUnderAmplified ( const int NPE ) const

inline

Get randomised charge according to gain and gain spread with an underamplified amplification mode.

Parameters

NPE	number of photo-electrons

Returns: number of photo-electrons

Definition at line 706 of file JPMTAnalogueSignalProcessor.hh.

    {
      double q;
 
      do {
 
        const double mu    = getUnderamplifiedGain(NPE);
        const double sigma = getUnderamplifiedGainSpread(NPE);
 
        q = gRandom->Gaus(mu, sigma);
 
      } while (q < 0.0);
      
      return q;
    }

◆ getChargeProbability()

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getChargeProbability	(	const double	npe,
		const int	NPE ) const

inlineoverridevirtual

Get probability density for given charge.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

npe	observed number of photo-electrons
NPE	true number of photo-electrons

Returns: probability [npe^-1]

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 731 of file JPMTAnalogueSignalProcessor.hh.

    {
      if ((NPE > 0) && (getThresholdDomain(npe) > BELOW_THRESHOLD)) {
 
        switch (getAmplificationMode()) {
 
        case JAmplificationMode::Nominal:
          return getChargeProbabilityNominal(npe, NPE);
 
        case JAmplificationMode::Mixed:
          return getChargeProbabilityMixed(npe, NPE);
 
        case JAmplificationMode::UnderAmplified:
          return getChargeProbabilityUnderAmplified(npe, NPE);
 
        default:
          return 0.0;
        }
 
      } else {
 
        return 0.0;
      }
    }

◆ getChargeProbabilityNominal()

double JDETECTOR::JPMTAnalogueSignalProcessor::getChargeProbabilityNominal	(	const double	npe,
		const int	NPE ) const

inline

Get probability density for given charge with a Nominal amplification mode.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

npe	observed number of photo-electrons
NPE	true number of photo-electrons

Returns: probability [npe^-1]

Definition at line 764 of file JPMTAnalogueSignalProcessor.hh.

    {
      const double mu    = getGain(NPE);
      const double sigma = getGainSpread(NPE);
 
      if (sigma > 0.0) {
 
        JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
 
        const double prob = gauss.getValue(npe);
 
        const double normLowerLimit = threshold - thresholdBand;
        const double normUpperLimit = std::numeric_limits<double>::infinity();
        const double norm           = gauss.getIntegral(normLowerLimit, normUpperLimit);
 
        return prob / norm;
      
      } else if (std::fabs(npe - mu) <= 0.0001 * mu) {
 
        return 1.0;
      
      } else {
 
        return 0.0;
      }
    }

◆ getChargeProbabilityMixed()

double JDETECTOR::JPMTAnalogueSignalProcessor::getChargeProbabilityMixed	(	const double	npe,
		const double	NPE ) const

inline

Get probability density for given charge with a mixed amplification mode.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

npe	observed number of photo-electrons
NPE	true number of photo-electrons

Returns: probability [npe^-1]

Definition at line 800 of file JPMTAnalogueSignalProcessor.hh.

    {
      double norm   = 0.0;
      double prob   = 0.0;
      double weight = pow(1-PunderAmplified, NPE);
 
      for (int k = 0; k <= NPE; ++k) {  // k underamplified photo-electrons
  
        const double mu    = (NPE-k) * gain  +  (k) * getUnderamplifiedGain();
        const double sigma = gainSpread * sqrt(mu);
 
        if (sigma > 0.0) {
 
          JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
 
          prob += weight * gauss.getValue(npe);
 
          const double normLowerLimit  = threshold - thresholdBand;
          const double normUpperLimit  = std::numeric_limits<double>::infinity();
          
          norm += weight * gauss.getIntegral(normLowerLimit, normUpperLimit);
        
        } else if (std::fabs(npe - mu) <= 0.0001 * mu) {
 
          prob += weight;
          norm += weight;
        
        } else {
 
          return 0.0;
        }
  
        weight *= ((double) (NPE-k) / ((double) (k+1)))  *  PunderAmplified / (1.0 - PunderAmplified);
      }
 
      return prob / norm;
    }

◆ getChargeProbabilityUnderAmplified()

double JDETECTOR::JPMTAnalogueSignalProcessor::getChargeProbabilityUnderAmplified	(	const double	npe,
		const int	NPE ) const

inline

Get probability density for given charge with an underamplified amplification mode.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

npe	observed number of photo-electrons
NPE	true number of photo-electrons

Returns: probability [npe^-1]

Definition at line 847 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (gainSpread > 0.0) {
 
        const double mu    = getUnderamplifiedGain(NPE);
        const double sigma = getUnderamplifiedGainSpread(NPE);
        
        JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
 
        const double prob = gauss.getValue(npe);
 
        const double normLowerLimit = threshold - thresholdBand;
        const double normUpperLimit = std::numeric_limits<double>::infinity();
        const double norm           = gauss.getIntegral(normLowerLimit, normUpperLimit);
 
        return prob / norm;
      
      } else {
 
        return 0.0;
      }
    }

◆ getIntegralOfChargeProbability() [1/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getIntegralOfChargeProbability	(	const double	xmin,
		const double	xmax,
		const int	NPE ) const

inline

Get integral of probability.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

xmin	minimum number of photo-electrons
xmax	maximum number of photo-electrons
NPE	true number of photo-electrons

Returns: probability

Definition at line 880 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (NPE > 0) {
 
        double zmin = xmin;
        double zmax = xmax;
 
        const double th = threshold - thresholdBand;
 
        if (zmin < th) { zmin = th; }
        if (zmax < th) { zmax = th; }
 
        switch (getAmplificationMode()) {
 
        case JAmplificationMode::Nominal:
          return getIntegralOfChargeProbabilityNominal(zmin, zmax, NPE);
 
        case JAmplificationMode::Mixed:
          return getIntegralOfChargeProbabilityMixed(zmin, zmax, NPE);
 
        case JAmplificationMode::UnderAmplified:
          return getIntegralOfChargeProbabilityUnderAmplified(zmin, zmax, NPE);
 
        default:
          return 0.0;
        }
 
      } else {
 
        return 0.0;
      }
    }

◆ getIntegralOfChargeProbabilityNominal()

double JDETECTOR::JPMTAnalogueSignalProcessor::getIntegralOfChargeProbabilityNominal	(	const double	xmin,
		const double	xmax,
		const int	NPE ) const

inline

Get integral of probability with a nominal amplification mode.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

xmin	minimum number of photo-electrons
xmax	maximum number of photo-electrons
NPE	true number of photo-electrons

Returns: probability

Definition at line 923 of file JPMTAnalogueSignalProcessor.hh.

    {
      const double mu    = getGain(NPE);
      const double sigma = getGainSpread(NPE);
 
      if (sigma > 0.0) {
 
        JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
        
        const double cumulP = gauss.getIntegral(xmin, xmax);
 
        const double normLowerLimit = threshold - thresholdBand;
        const double normUpperLimit = std::numeric_limits<double>::infinity();
        const double norm           = gauss.getIntegral(normLowerLimit, normUpperLimit);
 
        return cumulP / norm;
 
      } else if ((mu >= xmin) && (mu <= xmax)) {
 
        return 1.0;
      
      } else {
 
        return 0.0;
      }
    }

◆ getIntegralOfChargeProbabilityMixed()

double JDETECTOR::JPMTAnalogueSignalProcessor::getIntegralOfChargeProbabilityMixed	(	const double	xmin,
		const double	xmax,
		const int	NPE ) const

inline

Get integral of probability with a mixed amplification mode.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

xmin	minimum number of photo-electrons
xmax	maximum number of photo-electrons
NPE	true number of photo-electrons

Returns: probability

Definition at line 960 of file JPMTAnalogueSignalProcessor.hh.

    {
      double cumulP = 0.0;
      double norm   = 0.0;
      double weight = pow(1.0 - PunderAmplified, NPE);
 
      for (int k = 0; k <= NPE; ++k) {  // k underamplified photo-electrons
 
        const double mu    = (NPE-k) * gain  +  (k) * getUnderamplifiedGain();
        const double sigma = gainSpread * sqrt(mu);
 
        if (sigma > 0.0) {
 
          JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
 
          const double normLowerLimit = threshold - thresholdBand;
          const double normUpperLimit = std::numeric_limits<double>::infinity();
 
          cumulP += weight * gauss.getIntegral(xmin, xmax);
          norm   += weight * gauss.getIntegral(normLowerLimit, normUpperLimit);
        
        } else if ((mu >= xmin) && (mu <= xmax)) {
 
          cumulP += weight;
          norm   += weight;
        
        } else {
 
          return 0.0;
        }
 
        weight *= ((double) (NPE-k) / ((double) (k+1)))  *  PunderAmplified / (1.0 - PunderAmplified);
      }
 
      return cumulP / norm;
    }

◆ getIntegralOfChargeProbabilityUnderAmplified()

double JDETECTOR::JPMTAnalogueSignalProcessor::getIntegralOfChargeProbabilityUnderAmplified	(	const double	xmin,
		const double	xmax,
		const int	NPE ) const

inline

Get integral of probability with an underamplified amplification mode.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

xmin	minimum number of photo-electrons
xmax	maximum number of photo-electrons
NPE	true number of photo-electrons

Returns: probability

Definition at line 1007 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (gainSpread > 0.0) {
 
        const double mu    = getUnderamplifiedGain(NPE);
        const double sigma = getUnderamplifiedGainSpread(NPE);
 
        JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
 
        const double cumulP = gauss.getIntegral(xmin, xmax);
 
        const double normLowerLimit = threshold - thresholdBand;
        const double normUpperLimit = std::numeric_limits<double>::infinity();
        const double norm           = gauss.getIntegral(normLowerLimit, normUpperLimit);
 
        return cumulP / norm;
      
      } else {
 
        return 0.0;
      }
    }

◆ getIntegralOfChargeProbability() [2/2]

double JDETECTOR::JPMTAnalogueSignalProcessor::getIntegralOfChargeProbability	(	const JThresholdDomain	domain,
		const int	NPE ) const

inline

Get integral of probability in specific threshold domain.

The normalisation is from (threshold-thresholdband) to infinity.

Parameters

domain	threshold domain
NPE	true number of photo-electrons

Returns: probability

Definition at line 1039 of file JPMTAnalogueSignalProcessor.hh.

    {
      switch (domain) {
 
      case ABOVE_THRESHOLD:
        return getIntegralOfChargeProbability(threshold, std::numeric_limits<double>::infinity(), NPE);
 
      case THRESHOLDBAND:
        return getIntegralOfChargeProbability(threshold-thresholdBand, threshold, NPE);
 
      default:
        return 0.0;
      }
    }

◆ applyThreshold()

virtual bool JDETECTOR::JPMTAnalogueSignalProcessor::applyThreshold ( const double npe ) const

inlineoverridevirtual

Apply threshold.

Parameters

npe	number of photo-electrons

Returns: true if pass; else false

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 1061 of file JPMTAnalogueSignalProcessor.hh.

    {
      return getThresholdDomain(npe) > BELOW_THRESHOLD;
    }

◆ getRiseTime() [2/2]

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getRiseTime ( const double npe ) const

inlineoverridevirtual

Get time to reach threshold.

Note that the rise time is defined to be zero for a one photo-electron signal.

Parameters

npe	number of photo-electrons

Returns: time [ns]

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 1075 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (slewing) {
 
        switch (getThresholdDomain(npe)) {
 
        case THRESHOLDBAND:
          return ((getRiseTime(npe, getTH0()) - getRiseTime(npe, threshold-thresholdBand)) -
                  (getRiseTime(1.0, getTH0()) - getRiseTime(1.0, threshold-thresholdBand))) + this->mean_ns;
 
        case ABOVE_THRESHOLD: 
          return ((getRiseTime(npe, getTH0()) - getRiseTime(npe, threshold)) -
                  (getRiseTime(1.0, getTH0()) - getRiseTime(1.0, threshold)));
 
        default:
          THROW(JValueOutOfRange, "JPMTAnalogueSignalProcessor::getRiseTime: Invalid charge " << npe);
        }
 
      } else {
 
        return 0.0;
      }
    }

◆ getTimeOverThreshold()

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getTimeOverThreshold ( const double npe ) const

inlineoverridevirtual

Get time-over-threshold.

Parameters

npe	number of photo-electrons

Returns: time-over-threshold (with saturation) [ns]

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 1106 of file JPMTAnalogueSignalProcessor.hh.

    {
      switch (getThresholdDomain(npe)) {
 
      case THRESHOLDBAND:
        return gRandom->Gaus(mean_ns, sigma_ns);
 
      case ABOVE_THRESHOLD: {
    
        double tot = 0.0;
 
        switch (getChargeDomain(npe)) {
 
        case JAnaloguePulseDomain::Gaussian:
          tot += getRiseTime(npe, threshold);                           // Gaussian
          tot += getRiseTime(npe, threshold);                           // Gaussian
          break;
 
        case JAnaloguePulseDomain::Exponential:
          tot += getRiseTime (npe, threshold);                          // Gaussian
          tot += getDecayTime(npe, threshold);                          // exponential
          break;
 
        case JAnaloguePulseDomain::Linear:
          tot += getRiseTime (getStartOfLinearisation(), threshold);    // Gaussian
          tot += getDecayTime(getStartOfLinearisation(), threshold);    // exponential
    
          tot += slope * (npe - getStartOfLinearisation());                 // linear
          break;
        }
        
        return applySaturation(tot);
      }
        
      default:
        THROW(JValueOutOfRange, "JPMTAnalogueSignalProcessor::getTimeOverThreshold: Invalid charge " << npe);
      }
    }

◆ getDerivative()

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getDerivative ( const double npe ) const

inlineoverridevirtual

Get derivative of number of photo-electrons to time-over-threshold with saturation.

Parameters

npe	number of photo-electrons

Returns: dnpe/dToT [ns^-1]

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 1152 of file JPMTAnalogueSignalProcessor.hh.

    {
      switch (getThresholdDomain(npe)) {
 
      case ABOVE_THRESHOLD: {
 
        const double tot_ns = getTimeOverThreshold(npe);
 
        if (tot_ns < saturation) {
 
          const double z  = riseTime_ns / sqrt(2.0 * log(npe/threshold));
 
          double y = 0.0;
 
          switch (getChargeDomain(npe)) {
 
          case JAnaloguePulseDomain::Gaussian:
            y += npe / (2.0 * z);
            break;
 
          case JAnaloguePulseDomain::Exponential:
            y += npe / (z + decayTime_ns);
            break;
 
          case JAnaloguePulseDomain::Linear:
            y += 1.0 / slope;
            break;
          }
 
          return y / getDerivativeOfSaturation(removeSaturation(tot_ns));
        
        } else {
 
          return 0.0;
        }
      }
 
      default:
        return 0.0;
      }
    }

◆ getSurvivalProbability()

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getSurvivalProbability ( const int NPE ) const

inlineoverridevirtual

Probability that a hit survives the simulation of the PMT.

The survival probability takes into account the number of photo-electrons, the analogue signal of the PMT and the threshold of the discriminator.

Parameters

NPE	number of photo-electrons

Returns: probability

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 1202 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (NPE > 0) {
 
        if        (QE <= 0.0) {
 
          return 0.0;
 
        } else if (QE <  1.0) {
 
          double P = 0.0;
    
          for (int i = 1; i <= NPE; ++i) {                                             // i corresponds to number of photo-electrons passing relative QE
 
            const double p = JMATH::binomial(NPE, i) * pow(QE, i) * pow(1.0 - QE, NPE - i);
 
            P += p * getThresholdProbability(NPE);
          }
 
          return P;
 
        } else {
 
          return getThresholdProbability(NPE);
        }
 
      } else {
 
        return 0.0;
      }
    }

◆ getThresholdProbability()

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getThresholdProbability ( const int NPE ) const

inlineoverridevirtual

Probability that a hit survives the threshold of the PMT.

Parameters

NPE	number of photo-electrons

Returns: probability

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 1241 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (NPE > 0) {
 
        switch (getAmplificationMode()) {
 
        case JAmplificationMode::Nominal:
          return getThresholdProbabilityNominal(NPE);
 
        case JAmplificationMode::Mixed:
          return getThresholdProbabilityMixed(NPE);
 
        case JAmplificationMode::UnderAmplified:
          return getThresholdProbabilityUnderAmplified(NPE);
 
        default:
          return 0.0;
        }
 
      } else {
 
        return 0.0;
      }
    }

◆ getThresholdProbabilityNominal()

double JDETECTOR::JPMTAnalogueSignalProcessor::getThresholdProbabilityNominal ( const int NPE ) const

inline

Probability that a hit survives the threshold of the PMT with a nominal amplification mode.

Parameters

NPE	true number of photo-electrons

Returns: probability

Definition at line 1273 of file JPMTAnalogueSignalProcessor.hh.

    {
      const double mu    = getGain(NPE);
      const double sigma = getGainSpread(NPE);
 
      if (sigma > 0.0) {
 
        JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
        
        const double probLowerLimit = threshold - thresholdBand;
        const double probUpperLimit = std::numeric_limits<double>::infinity();
        const double cumulP         = gauss.getIntegral(probLowerLimit, probUpperLimit);
 
        const double normLowerLimit = 0.0;
        const double normUpperLimit = std::numeric_limits<double>::infinity();
        const double norm           = gauss.getIntegral(normLowerLimit, normUpperLimit);
 
        return cumulP / norm;
 
      } else if (mu >= threshold - thresholdBand) {
 
        return 1.0;
      
      } else {
 
        return 0.0;
      }
    }

◆ getThresholdProbabilityMixed()

double JDETECTOR::JPMTAnalogueSignalProcessor::getThresholdProbabilityMixed ( const int NPE ) const

inline

Probability that a hit survives the threshold of the PMT with a mixed amplification mode.

Parameters

NPE	true number of photo-electrons

Returns: probability

Definition at line 1309 of file JPMTAnalogueSignalProcessor.hh.

    {
      double cumulP = 0.0;
      double norm   = 0.0;
      double weight = pow(1.0 - PunderAmplified, NPE);
 
      for (int k = 0; k <= NPE; ++k) {  // k underamplified photo-electrons
 
        const double mu    = (NPE-k) * gain  +  (k) * getUnderamplifiedGain();
        const double sigma = gainSpread * sqrt(mu);
 
        if (sigma > 0.0) {
 
          JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
 
          const double probLowerLimit = threshold - thresholdBand;
          const double probUpperLimit = std::numeric_limits<double>::infinity();
          
          cumulP += weight * gauss.getIntegral(probLowerLimit, probUpperLimit);
 
          const double normLowerLimit = 0.0;
          const double normUpperLimit = std::numeric_limits<double>::infinity();
 
          norm   += weight * gauss.getIntegral(normLowerLimit, normUpperLimit);
        
        } else if (mu >= threshold - thresholdBand) {
 
          cumulP += weight;
          norm   += weight;
        
        } else {
 
          return 0.0;
        }
 
        weight *= ((double) (NPE-k) / ((double) (k+1)))  *  PunderAmplified / (1.0 - PunderAmplified);
      }
 
      return cumulP / norm;
    }

◆ getThresholdProbabilityUnderAmplified()

double JDETECTOR::JPMTAnalogueSignalProcessor::getThresholdProbabilityUnderAmplified ( const int NPE ) const

inline

Probability that a hit survives the threshold of the PMT with an underamplified amplification mode.

Parameters

NPE	true number of photo-electrons

Returns: probability

Definition at line 1357 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (gainSpread > 0.0) {
 
        const double mu    = getUnderamplifiedGain(NPE);
        const double sigma = getUnderamplifiedGainSpread(NPE);
 
        JMATH::JGauss gauss = JMATH::JGauss(mu, sigma);
 
        const double probLowerLimit = threshold - thresholdBand;
        const double probUpperLimit = std::numeric_limits<double>::infinity();
        const double cumulP         = gauss.getIntegral(probLowerLimit, probUpperLimit);
 
        const double normLowerLimit = 0.0;
        const double normUpperLimit = std::numeric_limits<double>::infinity();
        const double norm           = gauss.getIntegral(normLowerLimit, normUpperLimit);
 
        return cumulP / norm;
      
      } else {
 
        return 0.0;
      }
    }

◆ getNPE()

virtual double JDETECTOR::JPMTAnalogueSignalProcessor::getNPE ( const double tot_ns ) const

inlineoverridevirtual

Get number of photo-electrons.

Parameters

tot_ns time-over-threshold (with saturation) [ns]

Returns: number of photo-electrons

Reimplemented from JDETECTOR::JPMTSignalProcessorInterface.

Definition at line 1389 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (tot_ns >= saturation) {
        return std::numeric_limits<double>::max();
      }
 
      const double tot =  removeSaturation(tot_ns);
      const double TOT = (getRiseTime (getStartOfLinearisation(), threshold)  + 
                          getDecayTime(getStartOfLinearisation(), threshold));
      
      switch (getToTDomain(tot_ns)) {
      
      case JAnaloguePulseDomain::Gaussian:
        return threshold * exp(tot*tot/riseTime_ns/riseTime_ns/8.0);
        
      case JAnaloguePulseDomain::Exponential: {
 
        const double a = decayTime_ns;
        const double b = sqrt(2.0) * riseTime_ns;
        const double c = -(decayTime_ns*log(y1) + tot);
        const double z = (-b + sqrt(b*b - 4*a*c)) / (2*a);
 
        return threshold * exp(z*z);
      }
        
      case JAnaloguePulseDomain::Linear:
        return getStartOfLinearisation() + (tot - TOT) / slope;
 
      default:
        return 0.0;
      }
    }

◆ getTimeOverThresholdProbability()

double JDETECTOR::JPMTAnalogueSignalProcessor::getTimeOverThresholdProbability	(	const double	tot_ns,
		const int	NPE ) const

inline

Get probability of having a pulse with specific time-over-threshold.

Parameters

tot_ns	time-over-threshold (with saturation) [ns]
NPE	true number of photo-electrons

Returns: probability [ns^-1]

Definition at line 1430 of file JPMTAnalogueSignalProcessor.hh.

    {
      if (tot_ns < saturation) {
 
        const double npe      = getNPE(tot_ns);
        const double y        = getChargeProbability(npe, NPE);
        const double v        = getDerivative(npe);
        const double RaboveTh = y * v;
        
        const double w         = getIntegralOfChargeProbability(ABOVE_THRESHOLD, NPE);
        JMATH::JGauss gauss    = JMATH::JGauss(mean_ns, sigma_ns);
        const double gaussProb = gauss.getValue(tot_ns);
        const double gaussNorm = gauss.getIntegral(0, saturation);
        const double gaussDist = gaussProb / gaussNorm;
        const double RthBand   = (1-w) * gaussDist;
 
        return RaboveTh + RthBand;
 
      } else {
 
        return 0.0;
      }
    }

◆ getIntegralOfTimeOverThresholdProbability()

double JDETECTOR::JPMTAnalogueSignalProcessor::getIntegralOfTimeOverThresholdProbability	(	const double	Tmin,
		const double	Tmax,
		const int	NPE ) const

inline

Get cumulative probability of time-over-threshold distribution.

Parameters

Tmin	minimum time-over-threshold (with saturation) [ns]
Tmax	maximum time-over-threshold (with saturation) [ns]
NPE	true number of photo-electrons

Returns: probability [ns^-1]

Definition at line 1463 of file JPMTAnalogueSignalProcessor.hh.

    {
      double Xmin = Tmin;
      double Xmax = Tmax;
 
      if (Tmin > saturation) {Xmin = saturation;}
      if (Tmax > saturation) {Xmax = saturation;}
 
      const double IaboveTh = getIntegralOfChargeProbability(getNPE(Xmin), getNPE(Xmax), NPE);
 
      const double w           = getIntegralOfChargeProbability(ABOVE_THRESHOLD, NPE);
      JMATH::JGauss gauss      = JMATH::JGauss(mean_ns, sigma_ns);
      const double gaussCumulP = gauss.getIntegral(Xmin, Xmax);
      const double gaussNorm   = gauss.getIntegral(0, saturation);
      const double gaussDist   = gaussCumulP / gaussNorm;
      const double IthBand     = (1-w) * gaussDist;
 
      return IaboveTh + IthBand;
    }

◆ getTH0()

static double JDETECTOR::JPMTAnalogueSignalProcessor::getTH0 ( )

inlinestatic

Get lower threshold for rise time evaluation.

Returns: threshold [npe]

Definition at line 1489 of file JPMTAnalogueSignalProcessor.hh.

    {
      return 0.1;
    }

◆ getTH1()

static double JDETECTOR::JPMTAnalogueSignalProcessor::getTH1 ( )

inlinestatic

Get upper threshold for rise time evaluation.

Returns: threshold [npe]

Definition at line 1500 of file JPMTAnalogueSignalProcessor.hh.

    {
      return 0.9;
    }

◆ operator()()

void JDETECTOR::JPMTSignalProcessorInterface::operator()	(	const JCalibration &	calibration,
		const JPMTData< JPMTSignal > &	input,
		JPMTData< JPMTPulse > &	output ) const

inlineinherited

Process hits.

Two (or more) photo-electrons are combined if they are comparable according method compare.
Two (or more) consecutive hits hits maybe merged (according method merge).
A PMT signal with negative number of photo-electrons is not subjected to the quantum efficiency and transit-time distribution.
This feature is used to simulate the singles rate of a PMT when the measured QE is zero.

Parameters

calibration	PMT calibration
input	PMT signals
output	PMT hits

Definition at line 91 of file JPMTSignalProcessorInterface.hh.

    {
      // apply transition time distribution to each photo-electron.
 
      JPMTData<JPhotoElectron> buffer;
      
      for (JPMTData<JPMTSignal>::const_iterator hit = input.begin(); hit != input.end(); ++hit) {
 
        for (int i = 0; i < hit->npe; ++i) {
          if (applyQE()) {
            buffer.push_back(JPhotoElectron(getRandomTime(hit->t_ns)));
          }
        }
 
        for (int i = 0; i > hit->npe; --i) {
          buffer.push_back(JPhotoElectron(hit->t_ns));
        }
      }
 
      if (!buffer.empty()) {
      
        buffer.push_back(JPhotoElectron::getEndMarker());
      
        buffer.sort();
      
      
        // generate PMT hits from time sequence of photo-electrons.
        
        for (JPMTData<JPhotoElectron>::const_iterator q = buffer.begin(), p = q++; q != buffer.end(); ++q) {
          
          while (compare(*p,*q)) {
            ++q;
          }
          
          const double npe = getRandomCharge(distance(p,q));
 
          if (applyThreshold(npe)) {
            output.push_back(JPMTPulse(putTime(p->t_ns + getRiseTime(npe), calibration), getTimeOverThreshold(npe)));
          }
 
          p = q;
        }
        
        // merge overlapping PMT hits.
      
        merge(output);
      }
    }

◆ merge()

virtual void JDETECTOR::JPMTSignalProcessorInterface::merge ( JPMTData< JPMTPulse > & data ) const

inlinevirtualinherited

Merging of PMT hits.

Hits with overlapping time-over-threshold signals should -de facto- be combined. In this, the leading edge is maintained and the time-over-threshold is set to the difference between the overall trailing and leading edges. As a result, the number of PMT hits may be reduced.

Parameters

data	PMT hits (I/O)

Definition at line 311 of file JPMTSignalProcessorInterface.hh.

    {
      using namespace std;
      
      JPMTData<JPMTPulse>::iterator out = data.begin();
      
      for (JPMTData<JPMTPulse>::iterator i = data.begin(); i != data.end(); ) {
        
        double t1 = i->t_ns;
        double t2 = i->t_ns + i->tot_ns;
        
        while (++i != data.end() && i->t_ns < t2 + getTmin()) {
          t2 = max(t2, i->t_ns + i->tot_ns);
        }
        
        out->t_ns   = t1;
        out->tot_ns = t2 - t1;
        
        ++out;
      }
      
      data.resize(distance(data.begin(), out));
    }

◆ getTmin()

static double JDETECTOR::JPMTSignalProcessorInterface::getTmin ( )

inlinestaticinherited

Get two photo-electron resolution for time-over-threshold.

Returns: minimal time [ns]

Definition at line 341 of file JPMTSignalProcessorInterface.hh.

    {
      return 1.0;
    }

◆ getQmin()

static double JDETECTOR::JPMTSignalProcessorInterface::getQmin ( )

inlinestaticinherited

Get width of charge distribution.

Returns: width charge distribution [npe]

Definition at line 352 of file JPMTSignalProcessorInterface.hh.

    {
      return 1.0e-3;
    }

◆ getPMTParameters()

const JPMTParameters & JDETECTOR::JPMTParameters::getPMTParameters ( ) const

inlineinherited

Get PMT parameters.

Returns: PMT parameters

Definition at line 112 of file JPMTParameters.hh.

    {
      return static_cast<const JPMTParameters&>(*this);
    }

◆ is_valid()

bool JDETECTOR::JPMTParameters::is_valid ( ) const

inlineinherited

Check validity of PMT parameters.

Returns: true if valid; else false

Definition at line 134 of file JPMTParameters.hh.

    {
      if (this->QE                 < 0.0 ||
          this->gain               < 0.0 ||
          this->gainSpread         < 0.0 ||
          this->threshold      < 0.0 ||
          this->thresholdBand  < 0.0) {
        return false;
      } 
 
      return true;
    }

◆ getType()

int JDETECTOR::JPMTParameters::getType ( ) const

inlineinherited

Get type for for time-slewing correction.

Returns: type

Definition at line 153 of file JPMTParameters.hh.

    {
      if (this->TTS_ns < 0.0)
        return -lrint(this->TTS_ns);
      else
        return 0;
    }

◆ getEquationParameters()

static JEquationParameters & JDETECTOR::JPMTParameters::getEquationParameters ( )

inlinestaticinherited

Get equation parameters.

Returns: equation parameters

Definition at line 209 of file JPMTParameters.hh.

    {
      static JEquationParameters equation("=", ",", "./", "#");
 
      return equation;
    }

◆ setEquationParameters()

static void JDETECTOR::JPMTParameters::setEquationParameters ( const JEquationParameters & equation )

inlinestaticinherited

Set equation parameters.

Parameters

equation equation parameters

Definition at line 222 of file JPMTParameters.hh.

    {
      getEquationParameters() = equation;
    }

◆ getProperties() [1/2]

JProperties JDETECTOR::JPMTParameters::getProperties ( const JEquationParameters & equation = JPMTParameters::getEquationParameters() )

inlineinherited

Get properties of this class.

Parameters

equation equation parameters

Definition at line 233 of file JPMTParameters.hh.

    {
      return JPMTParametersHelper(*this, equation);
    }

◆ getProperties() [2/2]

JProperties JDETECTOR::JPMTParameters::getProperties ( const JEquationParameters & equation = JPMTParameters::getEquationParameters() ) const

inlineinherited

Get properties of this class.

Parameters

equation equation parameters

Definition at line 244 of file JPMTParameters.hh.

    {
      return JPMTParametersHelper(*this, equation);
    }

Friends And Related Symbol Documentation

◆ operator>>

std::istream & operator>>	(	std::istream &	in,
		JPMTAnalogueSignalProcessor &	object )

friend

Read PMT signal from input.

Parameters

in	input stream
object	PMT signal

Returns: input stream

Definition at line 446 of file JPMTAnalogueSignalProcessor.hh.

    {
      in >> static_cast<JPMTParameters&>(object);
      
      object.configure();
 
      return in;
    }

Member Data Documentation

◆ decayTime_ns

double JDETECTOR::JPMTAnalogueSignalProcessor::decayTime_ns

protected

decay time [ns]

Definition at line 1507 of file JPMTAnalogueSignalProcessor.hh.

◆ t1

double JDETECTOR::JPMTAnalogueSignalProcessor::t1

protected

time at match point [ns]

Definition at line 1508 of file JPMTAnalogueSignalProcessor.hh.

◆ y1

double JDETECTOR::JPMTAnalogueSignalProcessor::y1

protected

amplitude at match point [npe]

Definition at line 1509 of file JPMTAnalogueSignalProcessor.hh.

◆ x1

double JDETECTOR::JPMTAnalogueSignalProcessor::x1

protected

Transition point from a logarithmic to a linear relation between time-over-threshold and number of photo-electrons.

Measurements by B. Schermer and R. Bruijn at Nikhef.

Definition at line 1515 of file JPMTAnalogueSignalProcessor.hh.

◆ QE

double JDETECTOR::JPMTParameters::QE

inherited

relative quantum efficiency

Definition at line 250 of file JPMTParameters.hh.

◆ gain

double JDETECTOR::JPMTParameters::gain

inherited

gain [unit]

Definition at line 251 of file JPMTParameters.hh.

◆ gainSpread

double JDETECTOR::JPMTParameters::gainSpread

inherited

gain spread [unit]

Definition at line 252 of file JPMTParameters.hh.

◆ riseTime_ns

double JDETECTOR::JPMTParameters::riseTime_ns

inherited

rise time of analogue pulse [ns]

Definition at line 253 of file JPMTParameters.hh.

◆ TTS_ns

double JDETECTOR::JPMTParameters::TTS_ns

inherited

transition time spread [ns]

Definition at line 254 of file JPMTParameters.hh.

◆ threshold

double JDETECTOR::JPMTParameters::threshold

inherited

threshold [npe]

Definition at line 255 of file JPMTParameters.hh.

◆ PunderAmplified

double JDETECTOR::JPMTParameters::PunderAmplified

inherited

probability of underamplified hit

Definition at line 256 of file JPMTParameters.hh.

◆ thresholdBand

double JDETECTOR::JPMTParameters::thresholdBand

inherited

threshold-band [npe]

Definition at line 257 of file JPMTParameters.hh.

◆ mean_ns

double JDETECTOR::JPMTParameters::mean_ns

inherited

mean time-over-threshold of threshold-band hits [ns]

Definition at line 258 of file JPMTParameters.hh.

◆ sigma_ns

double JDETECTOR::JPMTParameters::sigma_ns

inherited

time-over-threshold standard deviation of threshold-band hits [ns]

Definition at line 259 of file JPMTParameters.hh.

◆ slope

double JDETECTOR::JPMTParameters::slope

inherited

slope [ns/npe]

Definition at line 260 of file JPMTParameters.hh.

◆ saturation

double JDETECTOR::JPMTParameters::saturation

inherited

saturation [ns]

Definition at line 261 of file JPMTParameters.hh.

◆ slewing

bool JDETECTOR::JPMTParameters::slewing

inherited

time slewing of analogue signal

Definition at line 262 of file JPMTParameters.hh.

The documentation for this struct was generated from the following file:

JPMTAnalogueSignalProcessor.hh

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Attributes

Friends

Detailed Description

Member Enumeration Documentation

◆ JThresholdDomain

◆ JAmplificationMode

◆ JAnaloguePulseDomain

Constructor & Destructor Documentation

◆ JPMTAnalogueSignalProcessor()

Member Function Documentation

◆ configure()

◆ getDecayTime() [1/2]

◆ getT1()

◆ getY1()

◆ getStartOfLinearisation()

◆ getAmplitude()

◆ getRiseTime() [1/2]

◆ getDecayTime() [2/2]

◆ getMaximalRiseTime()

◆ applySaturation()

◆ removeSaturation()

◆ getDerivativeOfSaturation()

◆ getGain()

◆ getGainSpread() [1/2]

◆ getGainSpread() [2/2]

◆ getUnderamplifiedGain() [1/2]

◆ getUnderamplifiedGain() [2/2]

◆ getUnderamplifiedGainSpread() [1/2]

◆ getUnderamplifiedGainSpread() [2/2]

◆ setPMTParameters()

◆ getThresholdDomain()

◆ getAmplificationMode()

◆ getChargeDomain()

◆ getToTDomain()

◆ applyQE()

◆ getRandomTime()

◆ compare()

◆ getRandomCharge()

◆ getRandomChargeNominal()

◆ getRandomChargeMixed()

◆ getRandomChargeUnderAmplified()

◆ getChargeProbability()

◆ getChargeProbabilityNominal()

◆ getChargeProbabilityMixed()

◆ getChargeProbabilityUnderAmplified()

◆ getIntegralOfChargeProbability() [1/2]

◆ getIntegralOfChargeProbabilityNominal()

◆ getIntegralOfChargeProbabilityMixed()

◆ getIntegralOfChargeProbabilityUnderAmplified()

◆ getIntegralOfChargeProbability() [2/2]

◆ applyThreshold()

◆ getRiseTime() [2/2]

◆ getTimeOverThreshold()

◆ getDerivative()

◆ getSurvivalProbability()

◆ getThresholdProbability()

◆ getThresholdProbabilityNominal()

◆ getThresholdProbabilityMixed()

◆ getThresholdProbabilityUnderAmplified()

◆ getNPE()

◆ getTimeOverThresholdProbability()

◆ getIntegralOfTimeOverThresholdProbability()

◆ getTH0()

◆ getTH1()

◆ operator()()

◆ merge()

◆ getTmin()

◆ getQmin()

◆ getPMTParameters()

◆ is_valid()

◆ getType()

◆ getEquationParameters()

◆ setEquationParameters()

◆ getProperties() [1/2]

◆ getProperties() [2/2]

Friends And Related Symbol Documentation