JDETECTOR::JK40DefaultSimulatorInterface Class Reference

Default K40 simulator interface. More...

#include <JK40DefaultSimulatorInterface.hh>

Inheritance diagram for JDETECTOR::JK40DefaultSimulatorInterface:

Classes
struct	pair_type
	PMT pair. More...

Public Member Functions
virtual double	getSinglesRate (const JPMTIdentifier &pmt) const =0
	Get singles rate as a function of PMT. More...
virtual double	getMultiplesRate (const JModuleIdentifier &module, const int M) const =0
	Get multiples rate as a function of optical module. More...
virtual double	getProbability (const double ct) const =0
	Get probability of coincidence. More...
virtual void	generateHits (const JModule &module, const JTimeRange &period, JModuleData &output) const
	Generate hits. More...

Static Public Member Functions
static double	getSigma ()
	Get intrinsic time smearing of K40 coincidences. More...
static void	setSigma (const double sigma)
	Set intrinsic time smearing of K40 coincidences. More...

Protected Member Functions
	JK40DefaultSimulatorInterface ()
	Default constructor. More...

Static Private Member Functions
static double &	get_sigma ()
	Get intrinsic time smearing of K40 coincidences. More...

Private Attributes
	probabilityL1
std::vector< double >	rateL1_Hz
	Multiples rate as a function of the multiplicity. More...

Detailed Description

Default K40 simulator interface.

This class provides for a default implementation of the JK40Simulator interface which is based on a set of virtual methods. These methods constitute a user interface to the K40 background simulation.

Definition at line 39 of file JK40DefaultSimulatorInterface.hh.

Constructor & Destructor Documentation

JK40DefaultSimulatorInterface()

JDETECTOR::JK40DefaultSimulatorInterface::JK40DefaultSimulatorInterface ( )

inlineprotected

Default constructor.

Definition at line 94 of file JK40DefaultSimulatorInterface.hh.

    {}

Member Function Documentation

getSinglesRate()

virtual double JDETECTOR::JK40DefaultSimulatorInterface::getSinglesRate ( const JPMTIdentifier &  pmt ) const

pure virtual

Get singles rate as a function of PMT.

Parameters

pmt	PMT identifier

Returns

rate [Hz]

Implemented in JTRIGGER::JK40RunByRunSimulator, and JDETECTOR::JK40DefaultSimulator.

getMultiplesRate()

virtual double JDETECTOR::JK40DefaultSimulatorInterface::getMultiplesRate ( const JModuleIdentifier &  module, const int  M  ) const

pure virtual

Get multiples rate as a function of optical module.

Parameters

module	optical module identifier
M	multiplicity (M >= 2)

Returns

rate [Hz]

Implemented in JDETECTOR::JK40DefaultSimulator.

getProbability()

virtual double JDETECTOR::JK40DefaultSimulatorInterface::getProbability ( const double  ct ) const

pure virtual

Get probability of coincidence.

Parameters

ct	cosine space angle between PMT axes

Returns

probability

Implemented in JDETECTOR::JK40DefaultSimulator.

generateHits()

virtual void JDETECTOR::JK40DefaultSimulatorInterface::generateHits ( const JModule &  module, const JTimeRange &  period, JModuleData &  output  ) const

inlinevirtual

Generate hits.

Parameters

module	module
period	time window [ns]
output	background data

Implements JDETECTOR::JK40Simulator.

Definition at line 134 of file JK40DefaultSimulatorInterface.hh.

    {
      using namespace std;
      using namespace JPP;
      
 
      // resize internal buffers
      
      const size_t N = module.size();
      const size_t M = (N * (N - 1)) / 2;
 
      rateL1_Hz    .resize(N);
      probabilityL1.resize(M + 1);
 
 
      // generate singles
 
      for (size_t pmt = 0; pmt != N; ++pmt) {
 
        const double rateL0_Hz = getSinglesRate(JPMTIdentifier(module.getID(), pmt));
 
        if (rateL0_Hz > 0.0) {
              
          const double t_ns = 1.0e9 / rateL0_Hz;          // [ns]
              
          for (double t1 = period.getLowerLimit() + gRandom->Exp(t_ns); t1 < period.getUpperLimit(); t1 += gRandom->Exp(t_ns)) {
            output[pmt].push_back(JPMTSignal(t1, 1));
          }
        }
      }
 
 
      // generate coincidences
 
      double totalRateL1_Hz = 0.0;
 
      for (size_t i = 0; i != N; ++i) {
        totalRateL1_Hz += rateL1_Hz[i] = getMultiplesRate(module.getID(), i + 2);
      }
 
      if (totalRateL1_Hz > 0.0) {
 
        const double t_ns = 1.0e9 / totalRateL1_Hz;       // [ns]
 
        double t1 = period.getLowerLimit() + gRandom->Exp(t_ns);
 
        if (t1 < period.getUpperLimit()) {
 
          // configure pair-wise propabilities
 
          probabilityL1[0] = { N, N, 0.0};
 
          size_t i = 0;
          double P = 0.0;
 
          for (size_t pmt1 = 0; pmt1 != N; ++pmt1) {
            for (size_t pmt2 = 0; pmt2 != pmt1; ++pmt2) {
 
              const double ct = getDot(module[pmt1].getDirection(), module[pmt2].getDirection());
              const double p  = getProbability(ct);
 
              i += 1;
              P += p;
 
              probabilityL1[i] = { pmt1, pmt2, P};
            }
          }
          
          for ( ; t1 < period.getUpperLimit(); t1 += gRandom->Exp(t_ns)) {
 
            try {
 
              // generate two-fold coincidence
 
              const pair_type& pair = probabilityL1(gRandom->Rndm());
 
              output[pair.pmt1].insert(JPMTSignal(gRandom->Gaus(t1, getSigma()), 1));
              output[pair.pmt2].insert(JPMTSignal(gRandom->Gaus(t1, getSigma()), 1));
              
              // generate larger than two-fold coincidences, if any
 
              size_t M = 0;
 
              for (double R = totalRateL1_Hz * gRandom->Rndm(); M != N && (R -= rateL1_Hz[M]) > 0.0; ++M) {}
 
              if (M != 0) {
 
                set<size_t> buffer = { pair.pmt1, pair.pmt2 };   // hit PMTs
 
                for ( ; M != 0; --M) {
 
                  vector<double> probability1D(N, 1.0);
 
                  double P = 0.0;
                  
                  for (size_t i = 0; i != N; ++i) {
                    
                    if (buffer.count(i) == 0) {
 
                      for (set<size_t>::const_iterator pmt = buffer.begin(); pmt != buffer.end(); ++pmt) {
 
                        const double ct = getDot(module[i].getDirection(), module[*pmt].getDirection());
 
                        probability1D[i] *= getProbability(ct);
                      }
 
                      P += probability1D[i];
 
                    } else {
 
                      probability1D[i] = 0.0;
                    }
                  }
 
                  if (P > 0.0) {
 
                    size_t pmt = 0;
 
                    for (P *= gRandom->Rndm(); pmt != N && (P -= probability1D[pmt]) > 0.0; ++pmt) {}
 
                    if (pmt != N) {
 
                      output[pmt].insert(JPMTSignal(gRandom->Gaus(t1, getSigma()), 1));
 
                      buffer.insert(pmt);
                    }
 
                  } else {
 
                    break;
                  }
                }
              }
            }
            catch (const JNumericalPrecision&) {}
          }
        }
      }
    }

getSigma()

static double JDETECTOR::JK40DefaultSimulatorInterface::getSigma ( )

inlinestatic

Get intrinsic time smearing of K40 coincidences.

Returns

sigma [ns]

Definition at line 282 of file JK40DefaultSimulatorInterface.hh.

    {
      return get_sigma();
    }

setSigma()

static void JDETECTOR::JK40DefaultSimulatorInterface::setSigma ( const double  sigma )

inlinestatic

Set intrinsic time smearing of K40 coincidences.

Parameters

sigma

sigma [ns]

Definition at line 293 of file JK40DefaultSimulatorInterface.hh.

    {
      get_sigma() = sigma;
    }

get_sigma()

static double& JDETECTOR::JK40DefaultSimulatorInterface::get_sigma ( )

inlinestaticprivate

Get intrinsic time smearing of K40 coincidences.

Returns

sigma [ns]

Definition at line 304 of file JK40DefaultSimulatorInterface.hh.

    {
      static double sigma = 0.5;
 
      return sigma;
    }

Member Data Documentation

probabilityL1

JDETECTOR::JK40DefaultSimulatorInterface::probabilityL1

private

rateL1_Hz

std::vector<double> JDETECTOR::JK40DefaultSimulatorInterface::rateL1_Hz

mutableprivate

Multiples rate as a function of the multiplicity.

The index i corresponds to multiplicity M = i + 2.

Definition at line 316 of file JK40DefaultSimulatorInterface.hh.

---

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

• JK40DefaultSimulatorInterface.hh