JDETECTOR::JK40DefaultSimulatorInterface Class Reference

Default K40 simulator interface. More...

#include <JK40DefaultSimulatorInterface.hh>

Inheritance diagram for JDETECTOR::JK40DefaultSimulatorInterface:

Classes
struct	cdf_type
	Auxiliary data structure for selecting values according associated probabilities. More...
struct	probability_type
	Auxiliary data structure for value with associated probability. More...

Public Member Functions
virtual double	getSinglesRate (const JPMTIdentifier &pmt) const =0
	Get singles rate as a function of PMT.
virtual double	getMultiplesRate (const JModuleIdentifier &module, const int M) const =0
	Get multiples rate as a function of optical module.
virtual double	getProbability (const double ct) const =0
	Get probability of coincidence.
virtual double	getL01Rate () const =0
	Get mixed L0 (lower module) and L1 (upper module) rate [Hz].
virtual double	getL10Rate () const =0
	Get mixed L1 (lower module) and L0 (upper module) rate [Hz].
virtual void	generateHits (const JModule &module, const JTimeRange &period, JModuleData &output) const override
	Generate hits.
virtual void	generateHits (const module_pair &input, const JTimeRange &period, const module_data &output) const override
	Generate mixed-L1/L0 hits.

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

Protected Member Functions
	JK40DefaultSimulatorInterface ()
	Default constructor.

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

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 42 of file JK40DefaultSimulatorInterface.hh.

Constructor & Destructor Documentation

JK40DefaultSimulatorInterface()

JDETECTOR::JK40DefaultSimulatorInterface::JK40DefaultSimulatorInterface ( )

inlineprotected

Default constructor.

Definition at line 113 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 JDETECTOR::JK40DefaultSimulator, and JTRIGGER::JK40RunByRunSimulator.

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.

getL01Rate()

virtual double JDETECTOR::JK40DefaultSimulatorInterface::getL01Rate ( ) const

pure virtual

Get mixed L0 (lower module) and L1 (upper module) rate [Hz].

Returns

rate [Hz]

Implemented in JDETECTOR::JK40DefaultSimulator.

getL10Rate()

virtual double JDETECTOR::JK40DefaultSimulatorInterface::getL10Rate ( ) const

pure virtual

Get mixed L1 (lower module) and L0 (upper module) rate [Hz].

Returns

rate [Hz]

Implemented in JDETECTOR::JK40DefaultSimulator.

generateHits() [1/2]

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

inlineoverridevirtual

Generate hits.

Parameters

module	module
period	time window [ns]
output	background data

Implements JDETECTOR::JK40Simulator.

Definition at line 169 of file JK40DefaultSimulatorInterface.hh.

    {
      using namespace std;
      using namespace JPP;
      
      const size_t N = module.size();
 
 
      // 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 bool   asap = (output[pmt].size() != 0);  // sort as soon as possible
 
          const double t_ns = 1.0e9 / rateL0_Hz;          // interval period [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));    // see JPMTSignalProcessorInterface::operator()
          }
 
          if (asap) {
            output[pmt].sort();
          }
        }
      }
 
 
      // generate coincidences
 
      double totalRateL1_Hz = 0.0;
 
      // multiples rate as a function of the multiplicity - index i corresponds to multiplicity M = i + 2
 
      vector<double> rateL1_Hz(N, 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) {
 
        typedef pair<size_t,size_t>  pair_type;
      
        cdf_type<pair_type> probablityL1;
 
        const double t_ns = 1.0e9 / totalRateL1_Hz;       // interval period [ns]
 
        double t1 = period.getLowerLimit() + gRandom->Exp(t_ns);
 
        if (t1 < period.getUpperLimit()) {
 
          // configure pair-wise propabilities
 
          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);
 
              probablityL1.put({pmt1, pmt2}, p);
            }
          }
          
          for ( ; t1 < period.getUpperLimit(); t1 += gRandom->Exp(t_ns)) {
 
            try {
 
              // generate two-fold coincidence
 
              const pair_type& pair = probablityL1(gRandom->Rndm());
 
              output[pair.first ].insert(JPMTSignal(gRandom->Gaus(t1, getSigma()), 1));
              output[pair.second].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.first , pair.second };   // 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&) {}
          }
        }
      }
    }

generateHits() [2/2]

virtual void JDETECTOR::JK40DefaultSimulatorInterface::generateHits ( const module_pair & input, const JTimeRange & period, const module_data & output ) const

inlineoverridevirtual

Generate mixed-L1/L0 hits.

Parameters

input	module pair
period	time window [ns]
output	background data

Implements JDETECTOR::JK40Simulator.

Definition at line 318 of file JK40DefaultSimulatorInterface.hh.

    {
      using namespace JPP;
 
      const double rate_Hz = getL01Rate() + getL10Rate();
 
      if (rate_Hz > 0.0) {
 
        if (!input.first.empty() && !input.second.empty()) {
 
          if (neighbours(input.first, input.second)) {
 
            // locate decay in between modules
 
            const double ts = 0.8 * fabs(input.first.getZ() - input.second.getZ()) * getInverseSpeedOfLight() * getIndexOfRefraction();
 
            const JModule&   input_lower  = (input.first.getFloor() == input.second.getFloor() - 1 ? input.first  : input.second);
            const JModule&   input_upper  = (input.first.getFloor() == input.second.getFloor() + 1 ? input.first  : input.second);
 
            JModuleData&     output_lower = (input.first.getFloor() == input.second.getFloor() - 1 ? output.first : output.second);
            JModuleData&     output_upper = (input.first.getFloor() == input.second.getFloor() + 1 ? output.first : output.second);
 
            cdf_type<size_t> probability_lower;
            cdf_type<size_t> probability_upper;
 
            // use angular dependence of coincidence rate with respect to z-axis
 
            for (size_t i = 0; i != input_lower.size(); ++i) { probability_lower.put(i, this->getProbability(+1.0 * input_lower[i].getDZ())); }
            for (size_t i = 0; i != input_upper.size(); ++i) { probability_upper.put(i, this->getProbability(-1.0 * input_upper[i].getDZ())); }
              
            const double t_ns = 1.0e9 / rate_Hz;          // interval period [ns]
 
            for (double t1 = period.getLowerLimit() + gRandom->Exp(t_ns); t1 < period.getUpperLimit(); t1 += gRandom->Exp(t_ns)) {
 
              const bool L01 = gRandom->Uniform(0.0, rate_Hz) < getL01Rate();
 
              JModuleData&      output_L1      = (L01 ? output_upper      : output_lower);
              JModuleData&      output_L0      = (L01 ? output_lower      : output_upper);
 
              cdf_type<size_t>& probability_L1 = (L01 ? probability_upper : probability_lower);
              cdf_type<size_t>& probability_L0 = (L01 ? probability_lower : probability_upper);
 
              output_L1[probability_L1(gRandom->Rndm())].insert(JPMTSignal(gRandom->Gaus(t1, getSigma()), 1));
              output_L1[probability_L1(gRandom->Rndm())].insert(JPMTSignal(gRandom->Gaus(t1, getSigma()), 1));
 
              output_L0[probability_L0(gRandom->Rndm())].insert(JPMTSignal(gRandom->Gaus(t1 + ts, getSigma()), 1));
            }
          }
        }
      }
    }

getSigma()

static double JDETECTOR::JK40DefaultSimulatorInterface::getSigma ( )

inlinestatic

Get intrinsic time smearing of K40 coincidences.

Returns

sigma [ns]

Definition at line 378 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 389 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 400 of file JK40DefaultSimulatorInterface.hh.

    {
      static double sigma = 0.5;
 
      return sigma;
    }

---

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

• JK40DefaultSimulatorInterface.hh