RAT Namespace Reference

Ratpac-two: RAT Namespace Reference
Ratpac-two
Classes | Typedefs | Enumerations | Functions | Variables
RAT Namespace Reference

Classes

class  CCCrossSecMessenger
 Messenger class to control cross section options. More...
 
class  CoincidenceMessenger
 
class  DBMessenger
 
class  ESCrossSecMessenger
 Messenger class to control cross section options. More...
 
class  FastNeutronMessenger
 
class  IBDgenMessenger
 
class  IsotopeMessenger
 
class  PhysicsListMessenger
 
class  ProcBlockManager
 
class  RatMessenger
 
class  ReacIBDgenMessenger
 
class  SNgenMessenger
 
class  TrackingMessenger
 
class  CountProc
 
class  EventInfo
 
class  Gsim
 
class  Log
 
class  ProcAllocator
 
class  ProcAllocatorTmpl
 
class  ProcBlock
 
class  Processor
 
class  Producer
 
class  ProducerBlock
 
class  PruneProc
 
class  PythonProc
 
class  RunManager
 
class  SignalHandler
 
class  TrackInfo
 
class  Trajectory
 
class  otext_streambuf
 
class  AfterPulseProc
 
class  Digitizer
 Digitizer. More...
 
class  ForcedTriggerProc
 
class  NoiseProc
 
class  PDFPMTCharge
 Implementation of PMTCharge using database defined charge PDFs. More...
 
class  PDFPMTTime
 
class  PMTCharge
 Pure virtual class for simulating PMT charge collection. More...
 
class  PMTPulse
 
class  PMTTime
 Pure virtual class for simulating PMT time spread and cable delay. More...
 
class  PMTWaveform
 
class  PMTWaveformGenerator
 
class  SimpleDAQProc
 
class  SplitEVDAQProc
 
class  WaveformAnalysisGaussian
 Apply Gaussian fit to digitized waveforms. More...
 
class  WaveformAnalysisLognormal
 Apply lognormal fit to digitized waveforms. More...
 
class  WaveformAnalysisLucyDDM
 Perform PMT waveform analysis using Richard-Lucy Direct Demodulation (LucyDDM). More...
 
class  WaveformAnalysisRAVEN
 Perform reverse sparse non-negative least squares fitting and NPE likelihood estimation on digitized waveforms. More...
 
class  WaveformAnalysisSinc
 Interpolate waveforms by convolution using sinc kernel. More...
 
class  WaveformAnalyzerBase
 
class  WaveformPrep
 Process the digitized waveforms. More...
 
class  DBTableKey
 
class  DB
 
class  TextLoaderError
 
class  ParseError
 
class  ProbablyJSONParseError
 
class  FileError
 
class  FileNotFoundError
 
class  FileAccessError
 
class  DBFieldCallback
 
class  DBJsonLoader
 
class  DBLink
 
class  DBTable
 
class  DBNotFoundError
 
class  DBWrongTypeError
 
class  Tokenizer
 
class  TokenizerStack
 
class  Parser
 
class  DBTextLoader
 
class  HTTPDownloader
 
class  ClassifyChargeBalance
 
class  ClassifyTimesProc
 
class  FitCentroidProc
 
class  FitDirectionCenterProc
 
struct  hit
 
class  FitPathProc
 
class  FitQuadProc
 
class  FitterInputHandler
 
class  MiniSim
 
class  FitMimirProc
 
class  AmBeGen
 
class  AmBeSource
 
class  BetaFunction
 
class  CCCrossSec
 Calculates neutrino-nucleus charged current interaction on Lithium-7. (based on ES generator). More...
 
class  CCgen
 Implements the generation of a neutrino-nucleus charged current interaction. More...
 
class  CfGen
 
class  CfSource
 
class  Coincidence_Gen
 
class  Decay0
 The Decay0 Generator for Initial Kinematics in Alpha, Beta and Double Beta Decays. More...
 
class  DecayChain
 
class  DecayChain_Gen
 
class  ESCrossSec
 Calculates neutrino-electron elastic scattering. (based on original QSNO code by F. Duncan, M. Chen and Y. Takeuchi). More...
 
class  ESgen
 Implements the generation of a neutrino-electron elastic scattering event. More...
 
class  GdGen
 
class  Gen_LED
 
class  HeGen
 
class  IBDgen
 
class  LiGen
 
class  NGen
 
class  PosGen_FillShell
 
class  PosGen_Line
 
class  PosGen_Multipoint
 
class  PosGen_Radial
 
struct  FillVolume
 
class  PosGen_RegexFill
 
class  PosGen_TriMeshSurface
 
class  PrimaryVertexInformation
 
class  ReacIBDgen
 
struct  StdHepRecord
 
class  RooTracker_Gen
 Reads in RooTracker StdHep ROOT files. More...
 
class  SNgen
 
class  VertexFile_Gen
 Reads in RAT root trees and simulates the MC event in geant. More...
 
class  VertexGen_CC
 Vertex generator for neutrino-electron elastic scattering. More...
 
class  VertexGen_CRY
 
class  VertexGen_Decay0
 
class  VertexGen_ES
 Vertex generator for neutrino-electron elastic scattering. More...
 
class  VertexGen_FastNeutron
 
class  VertexGen_IBD
 
class  VertexGen_Isotope
 
class  VertexGen_PhotonBomb
 
class  VertexGen_ReacIBD
 
class  VertexGen_SN
 
class  VertexGen_Spectrum
 
class  VertexGen_WIMP
 
class  BWVetGenericChamber
 
class  BWVetGenericChamberHit
 
class  ConeWaveguideConstruction
 
class  ConeWaveguideFactory
 
struct  CubicPMTConstructionParams
 
class  CubicPMTConstruction
 
struct  CylindricalPMTConstructionParams
 
class  CylindricalPMTConstruction
 
class  DetectorConstruction
 
class  DetectorFactory
 Pure virtual class for defining parameterized geometries. More...
 
class  GDMLMessenger
 
class  GDMLWriteStructure
 
class  GeoBoxFactory
 
class  GeoBubbleFactory
 Makes and array of water boxes. More...
 
class  GeoBuilder
 
class  GeoCalibrationStickFactory
 
class  GeoCherenkovSourceFactory
 Geometry for the Cherenkov Source being developed at Berkeley. More...
 
class  GeoConvexLensFactory
 
class  GeoCutTubeFactory
 
class  GeoEllipticalTubeFactory
 
class  GeoFactoryNotFoundError
 
class  GeoFactory
 
class  GeoFiberSensitiveDetector
 
class  GeoFiberSensitiveDetectorHit
 
class  GeoLensFactory
 
class  GeoNestedSolidArrayFactoryBase
 
class  GeoNestedTubeArrayFactory
 
struct  GeoNestedTubeConstructionParams
 
class  GeoNestedTubeConstruction
 
class  GeoPerfBoxFactory
 
class  GeoPerfSphereFactory
 
class  GeoPerfTubeFactory
 
class  GeoPolyArrayFactory
 
class  GeoPolygonFactory
 
class  GeoReflectorFactory
 
class  GeoReflectorWaveguideFactory
 
class  GeoRevArrayFactory
 
class  GeoRevolutionChimneyFactory
 Define the geometry of the a revolution solid with a chimney in the middle. More...
 
class  GeoRevolutionFactory
 
class  GeoSolidArrayFactoryBase
 
class  GeoSolidFactory
 
class  GeoSphereFactory
 
class  GeoSurfaceFactory
 Define a logical border between two solids. More...
 
class  GeoTorusFactory
 
class  GeoTubeArrayFactory
 
class  GeoTubeFactory
 
class  GeoTubeIntersectionFactory
 
class  GeoWaterBoxArrayFactory
 Makes and array of water boxes. More...
 
struct  HemisphereEncapsulationParams
 
class  HemisphereEncapsulation
 
struct  LAPPDConstructionParams
 
class  LAPPDConstruction
 
class  Materials
 
class  PMTArrayFactory
 
class  PMTConcentrator
 
class  PMTConstruction
 
class  PMTCoverageFactory
 
class  PMTEncapsulation
 
class  PMTFactoryBase
 
class  PMTInfoParser
 
struct  RevolutionPMTConstructionParams
 
class  RevolutionPMTConstruction
 
struct  ToroidalPMTConstructionParams
 
class  ToroidalPMTConstruction
 
class  WaterBoxConstruction
 
class  WaveguideFactory
 
class  WLSPCoverFactory
 
class  WLSPFactory
 
class  DSReader
 
class  DSWriter
 
class  InNetProducer
 
class  InROOTProducer
 
class  ObjDbl
 
class  ObjInt
 
class  OutNetProc
 
class  OutNtupleProc
 
class  OutROOTProc
 
class  TrackTest
 
class  TrackCursor
 
class  TrackTest_Particle
 
class  TrackNav
 
class  TrackNode
 
class  G4CerenkovProcess
 
class  OpRayleigh
 
class  PhotonThinning
 
class  PhysicsList
 Defines the physics processes active in the simulation. More...
 
class  ThinnableG4Cerenkov
 Arbitrarily thins Cherenkov photon production with no compensatory side-effects. More...
 
class  AnyParse
 
class  Rat
 
class  BoundedInterpolator
 
class  CentroidCalculator
 
class  CUDAException
 
class  AllocBase
 
class  Alloc
 
class  FactoryUnknownID
 
class  AllocTable
 
class  Factory
 
class  GlobalFactory
 
struct  pyhash
 
class  LinearInterp
 
class  discard_streambuf
 
class  ROOTInterpolator
 
class  Minimizable
 
class  SimulatedAnnealing
 

Typedefs

typedef std::map< DBTableKey, simple_ptr_nocopy< DBTable > > DBTableSet
 
typedef simple_ptr_nocopy< DBLink > DBLinkPtr
 
typedef std::map< std::string, DBLinkPtr > DBLinkGroup
 
typedef G4THitsCollection< BWVetGenericChamberHit > BWVetGenericChamberHitsCollection
 
typedef G4THitsCollection< GeoFiberSensitiveDetectorHit > GeoFiberSensitiveDetectorHitsCollection
 

Enumerations

enum  EReactions {
  iBAD = -9999 , NullParticle = -2 , DecayBeta = +1 , DecayEC = -1 ,
  DecayGamma = 0 , DecayAlpha = +2
}
 
enum  ConvertType { ParseInt , ParseDouble , ParseString }
 

Functions

Processor * construct_user_proc (std::string userProcName)
 
int get_pdgcode (const G4PrimaryParticle *p)
 
std::string to_ratdb_float_string (double value)
 
std::string to_ratdb_double_string (double value)
 
std::string escape_ratdb_string (const std::string &value)
 
omtext warn (ferr)
 
omtext info (fout)
 
void signal_handler (int signo)
 
template<>
std::string DBTable::Get< std::string > (const std::string &name) const
 
template<>
std::vector< int > RAT::DBTable::Get< std::vector< int > > (const std::string &name) const
 
template<>
std::vector< double > RAT::DBTable::Get< std::vector< double > > (const std::string &name) const
 
template<>
std::vector< std::string > RAT::DBTable::Get< std::vector< std::string > > (const std::string &name) const
 
template<>
std::vector< bool > RAT::DBTable::Get< std::vector< bool > > (const std::string &name) const
 
template<>
json::Value RAT::DBTable::Get< json::Value > (const std::string &name) const
 
std::vector< double > unpack_double (const std::string &contents)
 
std::vector< int > unpack_int (const std::string &contents)
 
std::string PickFile (std::string name, std::string enclosing_file)
 
double GetRandomNumber (double rmin=0., double rmax=1.)
 
double Nucl_Beta (int Beta, double Z, double A, double W, double W0, int N, double vMass)
 
double Nucl_Wave (int Beta, double Z, double A, double W, int k)
 
double Nucl_Size (int Beta, double Z, double W, int k)
 
double Nucl_Radius (double A)
 
double Nucl_Mass (double A, double Z)
 
double Nucl_Wave_Phase (int Beta, double Z, double A, double W, int k, int sel)
 
double Screening_Potential (double Z, double p, int Beta)
 
std::complex< double > Hyper1F1Norm (std::complex< double > A, std::complex< double > B, std::complex< double > Z)
 
double Factorial (int N)
 
double HyperGeometric_PQF (double A[], int nA, double B[], int nB, double Z)
 
double GammaLn (double xx)
 
std::complex< double > GammaLn_Complex (std::complex< double > xx)
 
long long factorial (int n)
 
double IBDTGraph2TF1 (Double_t *x, Double_t *)
 
double ESTGraph2TF1 (Double_t *x, Double_t *)
 
double CCTGraph2TF1 (Double_t *x, Double_t *)
 
double ICCTGraph2TF1 (Double_t *x, Double_t *)
 
double NCTGraph2TF1 (Double_t *x, Double_t *)
 
double NCNUTGraph2TF1 (Double_t *x, Double_t *)
 
double INCTGraph2TF1 (Double_t *x, Double_t *)
 
G4VSolid * MakeFacetSolid (const G4String &pName, std::vector< G4TwoVector > polygon, G4double scale, G4double hz, G4double angle, G4VSolid *basesolid)
 
G4VSolid * MakeFacetSphereSolid (const G4String &pName, std::vector< G4TwoVector > polygon, std::vector< G4double > angles, G4double OR, G4VSolid *basesolid)
 
G4VSolid * MakeTubeFacetSolid (const G4String &pName, std::vector< G4TwoVector > polygon, G4double scale, G4double hz, G4double angle, G4double r_max)
 
G4VSolid * MakeTubeFacetSolid (const G4String &pName, std::vector< G4TwoVector > polygon, G4double scale, G4double hz, G4double angle, G4double r_min, G4double r_max)
 
G4VSolid * MakeConeFacetSolid (const G4String &pName, std::vector< G4TwoVector > polygon, G4double scale, G4double hz, G4double angle, G4double r_max_1, G4double r_max_2)
 
G4VSolid * MakeConeFacetSolid (const G4String &pName, std::vector< G4TwoVector > polygon, G4double scale, G4double hz, G4double angle, G4double r_min_1, G4double r_max_1, G4double r_min_2, G4double r_max_2)
 
G4VSolid * MakeShellFacetSolid (const G4String &pName, std::vector< G4TwoVector > polygon, std::vector< G4double > angles, G4double IR, G4double OR, G4double dTheta)
 
G4VSolid * MakeSphereFacetSolid (const G4String &pName, std::vector< G4TwoVector > polygon, std::vector< G4double > angles, G4double OR, G4double dTheta)
 
G4VSolid * MakeUnionSolidArray (const std::string &name, const std::vector< G4VSolid * > &solids, int firstIndex=0, int length=-1)
 
bool check_intersect (G4ThreeVector newpos, std::vector< G4ThreeVector > &pos, double radius)
 
std::string ConvertIntToString (int i)
 
std::string to_string (const TSocket *socket)
 
void write_object_with_directory (TDirectory *dir, const std::string &path, TObject *obj)
 
std::string get_short_hostname ()
 
std::string get_long_hostname ()
 
Double_t GaussianRatioPDF (Double_t *x, Double_t *par)
 
template<typename T >
void deepdelete_vector (std::vector< T * > &vect)
 
template<typename T >
void deepcopy_vector (std::vector< T * > &dest, const std::vector< T * > &src)
 
template<typename T >
void endcopy_vector (std::vector< T * > &dest, const std::vector< T * > &src)
 
void mute_g4mute ()
 
void mute_g4unmute ()
 
size_t EstimateNPE (double charge, double vpe_charge, double npe_estimate_charge_width, size_t npe_estimate_max_pes)
 Estimate the number of PEs in a resolved wave packet using a gaussian single-PE charge PDF. More...
 
int CheckOrientation (std::vector< G4TwoVector > &G4Polygon)
 
double RadicalInverse (int n, int base)
 
int ReadFile (const std::string &filename, std::string &filecontents)
 
G4PhysicsOrderedFreeVector * Integrate_MPV_to_POFV (G4MaterialPropertyVector *inputVector)
 
double SimpsIntegral (const std::vector< double > &samples, double baseline, int start, int end)
 
std::string strip (const std::string &s, const std::string &stripchars)
 
std::string strip_default (const std::string &s)
 
template<typename T >
bool TimeSort (const std::pair< T, T > &firstPair, const std::pair< T, T > &secondPair)
 
void TimeSortMerge (std::vector< std::pair< int, int >> &pulseTimes)
 
void TimeSortMerge (std::vector< std::pair< double, double >> &pulseTimes)
 
TTimeStamp AddNanoseconds (const TTimeStamp &a, const long nanoseconds)
 
long TimeDifference (const TTimeStamp &a, const TTimeStamp &b)
 

Variables

omtext warn
 
omtext info
 
omtext detail
 
omtext debug
 
G4Allocator< TrackInfo > aTrackInfoAllocator
 
G4DLLIMPORT G4Allocator< Trajectory > aTrajectoryAllocator
 
const int maxServerBytes = 200000000
 
const int kNPmax = 250
 
double plog69 []
 ‍************************************************‍/ More...
 
const double DELTA = CLHEP::neutron_mass_c2 - CLHEP::proton_mass_c2
 
const double GFERMI = 1.16639e-11 / CLHEP::MeV / CLHEP::MeV
 
const double XMaxDefault = 1e-45
 
const double XcMeVtoCmsqrd = 0.389379292e-21
 
TGraph * graphIBD
 
TGraph * graphES
 
TGraph * graphCC
 
TGraph * graphICC
 
TGraph * graphNC
 
TGraph * graphINC
 
TGraph * graphNCRate
 
TFile * IBD_fe = new TFile("$RATSHARE/models/SNGen/nu_e_data_1_7.root")
 
TF1 * glum_e = (TF1 *)IBD_fe->Get("f1")
 
TF1 * gmene_e = (TF1 *)IBD_fe->Get("f3")
 
TF1 * galpha_e = (TF1 *)IBD_fe->Get("f2")
 
TFile * IBD_feb = new TFile("$RATSHARE/models/SNGen/nu_eb_data_1_7.root")
 
TF1 * glum_eb = (TF1 *)IBD_feb->Get("f1")
 
TF1 * gmene_eb = (TF1 *)IBD_feb->Get("f3")
 
TF1 * galpha_eb = (TF1 *)IBD_feb->Get("f2")
 
TFile * IBD_fx = new TFile("$RATSHARE/models/SNGen/nu_x_data_1_7_X.root")
 
TF1 * glum_x = (TF1 *)IBD_fx->Get("f1")
 
TF1 * gmene_x = (TF1 *)IBD_fx->Get("f3")
 
TF1 * galpha_x = (TF1 *)IBD_fx->Get("f2")
 
G4Allocator< BWVetGenericChamberHit > BWVetGenericChamberHitAllocator
 
G4Allocator< GeoFiberSensitiveDetectorHit > GeoFiberSensitiveDetectorHitAllocator
 
discard_streambuf discard
 
std::streambuf * g4cout_orig = G4cout.rdbuf()
 
std::streambuf * g4cerr_orig = G4cerr.rdbuf()
 
const long TIME_UTIL_BILLION = 1000000000L
 

Detailed Description

AmBeSource generates photons and neutrons from americium+beryllium interactions. Each neutron is given an energy by the AmBeNeutronSpectrum function, which the probability density of the produced neutrons as a function of neutron energy. The photons are generated by the AmBeGammaSpectrum function with a probability found in the litterature.

CfSource generates prompt photons and delayed neutrons from radioactive Californium decays. The supported isotope is 252, which is also the default isotope given ReactorConstants. The neutrons are generated with the correct multiplicity and each neutron is given an energy by the Cf252NeutronSpectrum function, which the probability density of the produced neutrons as a function of neutron energy. The prompt photons are generated by the Cf252GammaMultiplicityFit and Cf252GammaSpectrum functions.

The number and locations of the Cf sources are read in from cf252_position.txt and parsed by CfSource to yield the source vertex R, cos(theta), and phi.

23-Mar-2006 WGS: The previous paragraph is now superceded by generator structure of RAT. The cff252_position.txt file is no longe read. Multiple "sources" are now implemented via multiple RAT generators.

vertex generator that can generate the products of a inverse beta-decay reaction from a reactor anti-neutrino. The direction of the neutrino is supplied, and the energy and angle of the produced positron and neutron are drawn from the distribution produced by the differential cross-section and a reactor anti-neutrino energy spectrum.

Function Documentation

◆ CheckOrientation()

int RAT::CheckOrientation ( std::vector< G4TwoVector > &  G4Polygon)

Takes the coordinates of a polygon (in 2-D vector format) and checks the orientation. G4 seems to want polygons to be oriented in the negative z direction in a right handed sense. The function will reorder the given coordinates if necessary

◆ EstimateNPE()

size_t RAT::EstimateNPE ( double  charge,
double  vpe_charge,
double  npe_estimate_charge_width,
size_t  npe_estimate_max_pes 
)

Estimate the number of PEs in a resolved wave packet using a gaussian single-PE charge PDF.

Parameters
chargeThe measured charge of the wave packet.
vpe_chargeThe nominal charge of a single PE.
npe_estimate_charge_widthThe width of the Gaussian single-PE charge distribution.
npe_estimate_max_pesThe upper limit for the number of PEs to consider.
Returns
Estimated number of PEs.

◆ Integrate_MPV_to_POFV()

G4PhysicsOrderedFreeVector * RAT::Integrate_MPV_to_POFV ( G4MaterialPropertyVector *  inputVector)

Convert a photon spectrum in a material property vector into a cumulative distribution for random sampling.

With the resulting G4PhysicsOrderedFreeVector, the recipe for obtaining a random sample is:

G4PhysicsOrderedFreeVector *pofv = [your vector]; double integralValue = G4UniformRand()*pofv->GetMaxValue(); double sample = pofv->GetEnergy(integralValue);

◆ TimeSort()

template<typename T >
bool RAT::TimeSort ( const std::pair< T, T > &  firstPair,
const std::pair< T, T > &  secondPair 
)
inline

Function to sort time intervals.

Variable Documentation

◆ plog69

double RAT::plog69[]
Initial value:
= {-2.302585, -1.609438, -1.203973, -0.9162907, -0.6931472, -0.5108256, -0.3566750, -0.2231435,
-0.1053605, 0.0000000, 0.1823216, 0.3364722, 0.4700036, 0.5877866, 0.6931472, 0.7884574,
0.8754688, 0.9555114, 1.029619, 1.098612, 1.163151, 1.223776, 1.280934, 1.335001,
1.386294, 1.504077, 1.609438, 1.704748, 1.791759, 1.871802, 1.945910, 2.014903,
2.079442, 2.197225, 2.302585, 2.397895, 2.484907, 2.564949, 2.639057, 2.772589,
2.890372, 2.995732, 3.218876, 3.401197, 3.555348, 3.688879, 3.806663, 3.912023}

‍************************************************‍/

Generated by doxygen 1.9.1