g4-tankresponse C++ API Reference

template<typename T>
class Delaunay
#include <delaunay.h>

Public Functions

const std::vector<Triangle<T>> &triangulate(std::vector<Vector2<T>> &vertices)
inline const std::vector<Triangle<T>> &getTriangles() const
inline const std::vector<Edge<T>> &getEdges() const

Private Members

std::vector<Triangle<T>> _triangles
std::vector<Edge<T>> _edges
template<typename T>
class Edge
#include <edge.h>

Public Functions

inline Edge(const Vector2<T> &p1, const Vector2<T> &p2)
inline Edge(const Edge &e)

Public Members

Vector2<T> p1
Vector2<T> p2
class G4Delaunay
#include <G4Delaunay.h>

Encapsulates the creation of a Delaunay triangulation for the snow surface.

The snow volume is created using the BuildSolid method, which takes a non-const pointer to a G4TessellatedSolid. Prior to doing this, one has to add all the points that define a Delaunay triangulation of the surface. Each of the tiles in the tessellated solid correspond to a triangle in the triangulation.

Public Functions

G4Delaunay()
~G4Delaunay()
void AddPoint(double x, double y, double z)
void BuildSolid(G4TessellatedSolid *solid, double margin, double spaceing)
inline const G4ThreeVector &GetOrigin() const
inline const double GetXmin() const
inline const double GetXmax() const
inline const double GetYmin() const
inline const double GetYmax() const
inline const double GetZmin() const
inline const double GetZmax() const

Private Functions

void CalcOrigin()
void ComputeBorderPoints(double margin, double spaceing)
double GetZValue(const std::vector<G4ThreeVector> &plist, double x, double y)
void CreateSurfaceTriangles(G4TessellatedSolid *solid)
void CreateBorderTriangles(const std::vector<int32_t> &border, G4TessellatedSolid *solid)
void CreateBottomFacet(G4TessellatedSolid *solid)
SET_LOGGER ("G4Delaunay")

Private Members

double xmin_
double xmax_
double ymin_
double ymax_
double zmin_
double zmax_
G4ThreeVector origin_
std::vector<G4ThreeVector> pointList_
std::vector<int32_t> border1_
std::vector<int32_t> border2_
std::vector<int32_t> border3_
std::vector<int32_t> border4_
class G4IceScintStation
#include <G4IceScintStation.h>

This class constructs the physical volume of single scintillator panel.

The sensitive detectors is not the SiPM. Instead, the scintillator plastic itself is the sensitive detector through G4ScintIceSD.

In this way, time is saved by not tracking photons.

Public Functions

G4IceScintStation(const ScintKey &scintKey, const I3Geometry &geometry, bool applyTimeCut)
~G4IceScintStation()
inline const G4ThreeVector &GetPos() const
I3Position GetPos_I3()

Position of center of the tank.

double GetX_I3()
double GetY_I3()
double GetZ_I3()
inline const G4ThreeVector &GetDelaunayPoint1() const

Delaunay points around tank.

inline const G4ThreeVector &GetDelaunayPoint2() const
inline const G4ThreeVector &GetDelaunayPoint3() const
bool IfToAdd()
double GetNumPhotonScintillator(const ScintKey &scintKey)
G4double GetEDep_G4(const ScintKey &scintKey)

Energy deposit for a given ScintKey, in Geant4 units (from G4ScintSD)

G4double GetTime_G4(const ScintKey &scintKey)

Emission time for a given ScintKey, in Geant4 units (from G4ScintSD)

double GetEDep_I3(const ScintKey &scintKey)

Energy deposit for a given ScintKey, in Geant4 units (from G4ScintSD)

double GetTime_I3(const ScintKey &scintKey)

Emission time for a given ScintKey, in Geant4 units (from G4ScintSD)

G4VPhysicalVolume *InstallStation(G4VPhysicalVolume *mother, const G4ThreeVector &origin)

Method to call when constructing detector.

Private Functions

SET_LOGGER ("G4IceScintTank")

Private Members

G4ThreeVector position_
G4double orientation_
G4ThreeVector delaunayPoint1_
G4ThreeVector delaunayPoint2_
G4ThreeVector delaunayPoint3_
std::map<ScintKey, G4ThreeVector> scintOMPositions_
G4LogicalVolume *scintLog_
G4ScintSD *scintSD_
const ScintKey &scintKey_
const I3Geometry &geometry_
bool applyTimeCut_
class G4IceTopDetectorConstruction : public G4VUserDetectorConstruction
#include <G4IceTopDetectorConstruction.h>

The implementation of Geant4’s G4VUserDetectorConstruction. It creates all materials and top-level volumes. It uses G4IceTopTank and G4Delaunay to build the basic elements in the geometry.

The snow surface is a Delaunay triangulation defined by taking three points around each tank. The points are defined by G4IceTopTank.

Public Functions

G4IceTopDetectorConstruction(bool triangulatedSnow = true, bool useScintillator = false)
~G4IceTopDetectorConstruction()
G4VPhysicalVolume *Construct()
inline void SetVerboseLevel(G4int level)
inline void InstallTank(G4IceTopTank *tank)
inline void InstallStation(G4IceScintStation *scint)
inline const G4ThreeVector &GetWorldOrigin() const

Private Functions

void CreateMaterials()
void CreateAir()
void CreateIce()
void CreateSnow()
void CreateWater()
void CreatePlastic()
void CreateTyvek()
void CreatePerlite()
void CreateGlassSphere()
void CreateEffectiveDOMMaterial()
void CreateScintillatorMaterial()
void CreateStyrofoam()
void CreateWood()
void CreateAluminium()

Private Members

G4ThreeVector origin_
G4int verboseLevel_
std::vector<G4IceTopTank*> tankList_
std::vector<G4IceScintStation*> scintList_
bool triangulatedSnow_
bool useScintillator_
class G4IceTopEMPhysics : public G4VPhysicsConstructor
#include <G4IceTopEMPhysics.h>

Electromagnetic physics. Used only if Geant4 version is earlier than 4.10.

This class implements the electromagnetic interactions

  • Photoelectric effect

  • Compton scattering

  • Gamma conversion

  • Multiple scattering

  • Ionisation/Bremsstrahlung for electrons

  • Positron annihilation

Public Functions

G4IceTopEMPhysics()
~G4IceTopEMPhysics()
void ConstructParticle()
void ConstructProcess()

Private Members

G4PhotoElectricEffect photoEffect
G4ComptonScattering comptonEffect
G4GammaConversion pairProduction
G4eMultipleScattering electronMultipleScattering
G4eIonisation electronIonisation
G4eBremsstrahlung electronBremsStrahlung
G4eMultipleScattering positronMultipleScattering
G4eIonisation positronIonisation
G4eBremsstrahlung positronBremsStrahlung
G4eplusAnnihilation annihilation
class G4IceTopGeneralPhysics : public G4VPhysicsConstructor
#include <G4IceTopGeneralPhysics.h>

Implementation of G4VPhysicsConstructor for decay processes and geantino.

Public Functions

G4IceTopGeneralPhysics()
virtual ~G4IceTopGeneralPhysics()
void ConstructParticle()
void ConstructProcess()

Private Members

G4Decay decay
class G4IceTopHadronPhysics : public G4VPhysicsConstructor
#include <G4IceTopHadronPhysics.h>

Hadron physics. Used only if Geant4 version is earlier than 4.10.

Many processes. You’re encouraged to check the source.

Author

GEANT4/Peter Niessen

Date

Sat Jul 24 23:53:47 EDT 2004

Public Functions

G4IceTopHadronPhysics()

The constructor

virtual ~G4IceTopHadronPhysics()

The virtual destructor

virtual void ConstructParticle()

This method will be invoked in the Construct() method. each particle type will be instantiated

virtual void ConstructProcess()

This method will be invoked in the Construct() method. each physics process will be instantiated and registered to the process manager of each particle type

Protected Attributes

G4HadronElasticProcess elasticProcess_
G4LElastic *elasticModel_
G4PionPlusInelasticProcess pionPlusInelastic_
G4LEPionPlusInelastic *lePionPlusModel_
G4hMultipleScattering pionPlusMult_
G4hIonisation pionPlusIonisation_
G4PionMinusInelasticProcess pionMinusInelastic_
G4LEPionMinusInelastic *lePionMinusModel_
G4hMultipleScattering pionMinusMult_
G4hIonisation pionMinusIonisation_
G4PiMinusAbsorptionAtRest pionMinusAbsorption_
G4TheoFSGenerator theoModel_
G4ExcitationHandler excitationHandler_
G4PreCompoundModel *preEquilib_
G4GeneratorPrecompoundInterface cascade_
G4QGSModel<G4QGSParticipants> stringModel_
G4QGSMFragmentation fragmentation_
G4ExcitedStringDecay *stringDecay_
G4KaonPlusInelasticProcess kaonPlusInelastic_
G4LEKaonPlusInelastic *leKaonPlusModel_
G4HEKaonPlusInelastic *heKaonPlusModel_
G4hMultipleScattering kaonPlusMult_
G4hIonisation kaonPlusIonisation_
G4KaonMinusInelasticProcess kaonMinusInelastic_
G4LEKaonMinusInelastic *leKaonMinusModel_
G4HEKaonMinusInelastic *heKaonMinusModel_
G4hMultipleScattering kaonMinusMult_
G4hIonisation kaonMinusIonisation_
G4PiMinusAbsorptionAtRest kaonMinusAbsorption_
G4KaonZeroLInelasticProcess kaonZeroLInelastic_
G4LEKaonZeroLInelastic *leKaonZeroLModel_
G4HEKaonZeroInelastic *heKaonZeroLModel_
G4KaonZeroSInelasticProcess kaonZeroSInelastic_
G4LEKaonZeroSInelastic *leKaonZeroSModel_
G4HEKaonZeroInelastic *heKaonZeroSModel_
G4ProtonInelasticProcess protonInelastic_
G4LEProtonInelastic *leProtonModel_
G4HEProtonInelastic *heProtonModel_
G4hMultipleScattering protonMult_
G4hIonisation protonIonisation_
G4AntiProtonInelasticProcess antiProtonInelastic_
G4LEAntiProtonInelastic *leAntiProtonModel_
G4HEAntiProtonInelastic *heAntiProtonModel_
G4hMultipleScattering antiProtonMult_
G4hIonisation antiProtonIonisation_
G4AntiProtonAnnihilationAtRest antiProtonAnnihilation_
G4NeutronInelasticProcess neutronInelastic_
G4LENeutronInelastic *leNeutronModel_
G4HENeutronInelastic *heNeutronModel_
G4HadronFissionProcess neutronFission_
G4LFission *neutronFissionModel_
G4HadronCaptureProcess neutronCapture_
G4LCapture *neutronCaptureModel_
G4AntiNeutronInelasticProcess antiNeutronInelastic_
G4LEAntiNeutronInelastic *leAntiNeutronModel_
G4HEAntiNeutronInelastic *heAntiNeutronModel_
G4AntiNeutronAnnihilationAtRest antiNeutronAnnihilation_
G4LambdaInelasticProcess lambdaInelastic_
G4LELambdaInelastic *leLambdaModel_
G4HELambdaInelastic *heLambdaModel_
G4AntiLambdaInelasticProcess antiLambdaInelastic_
G4LEAntiLambdaInelastic *leAntiLambdaModel_
G4HEAntiLambdaInelastic *heAntiLambdaModel_
G4SigmaMinusInelasticProcess sigmaMinusInelastic_
G4LESigmaMinusInelastic *leSigmaMinusModel_
G4HESigmaMinusInelastic *heSigmaMinusModel_
G4hMultipleScattering sigmaMinusMult_
G4hIonisation sigmaMinusIonisation_
G4AntiSigmaMinusInelasticProcess antiSigmaMinusInelastic_
G4LEAntiSigmaMinusInelastic *leAntiSigmaMinusModel_
G4HEAntiSigmaMinusInelastic *heAntiSigmaMinusModel_
G4hMultipleScattering antiSigmaMinusMult_
G4hIonisation antiSigmaMinusIonisation_
G4SigmaPlusInelasticProcess sigmaPlusInelastic_
G4LESigmaPlusInelastic *leSigmaPlusModel_
G4HESigmaPlusInelastic *heSigmaPlusModel_
G4hMultipleScattering sigmaPlusMult_
G4hIonisation sigmaPlusIonisation_
G4AntiSigmaPlusInelasticProcess antiSigmaPlusInelastic_
G4LEAntiSigmaPlusInelastic *leAntiSigmaPlusModel_
G4HEAntiSigmaPlusInelastic *heAntiSigmaPlusModel_
G4hMultipleScattering antiSigmaPlusMult_
G4hIonisation antiSigmaPlusIonisation_
G4XiZeroInelasticProcess xiZeroInelastic_
G4LEXiZeroInelastic *leXiZeroModel_
G4HEXiZeroInelastic *heXiZeroModel_
G4AntiXiZeroInelasticProcess antiXiZeroInelastic_
G4LEAntiXiZeroInelastic *leAntiXiZeroModel_
G4HEAntiXiZeroInelastic *heAntiXiZeroModel_
G4XiMinusInelasticProcess xiMinusInelastic_
G4LEXiMinusInelastic *leXiMinusModel_
G4HEXiMinusInelastic *heXiMinusModel_
G4hMultipleScattering xiMinusMult_
G4hIonisation xiMinusIonisation_
G4AntiXiMinusInelasticProcess antiXiMinusInelastic_
G4LEAntiXiMinusInelastic *leAntiXiMinusModel_
G4HEAntiXiMinusInelastic *heAntiXiMinusModel_
G4hMultipleScattering antiXiMinusMult_
G4hIonisation antiXiMinusIonisation_
G4OmegaMinusInelasticProcess omegaMinusInelastic_
G4LEOmegaMinusInelastic *leOmegaMinusModel_
G4HEOmegaMinusInelastic *heOmegaMinusModel_
G4hMultipleScattering omegaMinusMult_
G4hIonisation omegaMinusIonisation_
G4AntiOmegaMinusInelasticProcess antiOmegaMinusInelastic_
G4LEAntiOmegaMinusInelastic *leAntiOmegaMinusModel_
G4HEAntiOmegaMinusInelastic *heAntiOmegaMinusModel_
G4hMultipleScattering antiOmegaMinusMult_
G4hIonisation antiOmegaMinusIonisation_
class G4IceTopIonPhysics : public G4VPhysicsConstructor
#include <G4IceTopIonPhysics.h>

Ion physics. Used only if Geant4 version is earlier than 4.10.

The ion physics. Check the source for details.

Author

GEANT4/Peter Niessen

Date

Sun Jul 25 00:24:42 EDT 2004

Public Functions

G4IceTopIonPhysics()

The constructor

virtual ~G4IceTopIonPhysics()

The virtual destructor

virtual void ConstructParticle()

This method will be invoked in the Construct() method. each particle type will be instantiated

virtual void ConstructProcess()

This method will be invoked in the Construct() method. each physics process will be instantiated and registered to the process manager of each particle type

Protected Attributes

G4HadronElasticProcess elasticProcess_
G4LElastic *elasticModel_
G4hMultipleScattering ionMultipleScattering_
G4ionIonisation ionIonisation_
G4hMultipleScattering deuteronMultipleScattering_
G4hIonisation deuteronIonisation_
G4DeuteronInelasticProcess deuteronProcess_
G4LEDeuteronInelastic *deuteronModel_
G4hMultipleScattering tritonMultipleScattering_
G4hIonisation tritonIonisation_
G4TritonInelasticProcess tritonProcess_
G4LETritonInelastic *tritonModel_
G4hMultipleScattering alphaMultipleScattering_
G4hIonisation alphaIonisation_
G4AlphaInelasticProcess alphaProcess_
G4LEAlphaInelastic *alphaModel_
G4hMultipleScattering he3MultipleScattering_
G4hIonisation he3Ionisation_
class G4IceTopMuonPhysics : public G4VPhysicsConstructor
#include <G4IceTopMuonPhysics.h>

Muon/tau Physics. Used only if Geant4 version is earlier than 4.10.

This class implements the physics processes for the muons. For muons, it contains

  • Ionisation

  • Multiple scattering

  • Bremsstrahlung

  • Pair production

  • Capture at rest (mu-) For taus, it does

  • Multiple scattering

  • Ionisation

Public Functions

G4IceTopMuonPhysics()
~G4IceTopMuonPhysics()
void ConstructParticle()
void ConstructProcess()

Private Members

G4MuIonisation muPlusIonisation_
G4MuMultipleScattering muPlusMultipleScattering_
G4MuBremsstrahlung muPlusBremsstrahlung_
G4MuPairProduction muPlusPairProduction_
G4MuIonisation muMinusIonisation_
G4MuMultipleScattering muMinusMultipleScattering_
G4MuBremsstrahlung muMinusBremsstrahlung_
G4MuPairProduction muMinusPairProduction_
G4MuonMinusCaptureAtRest muMinusCaptureAtRest_
G4MuMultipleScattering tauPlusMultipleScattering_
G4hIonisation tauPlusIonisation_
G4MuMultipleScattering tauMinusMultipleScattering_
G4hIonisation tauMinusIonisation_
class G4IceTopPhysicsList : public G4VModularPhysicsList
#include <G4IceTopPhysicsList.h>

Implementation of G4VModularPhysicsList. The top-level physics list. It combines all the other physics lists:

Public Functions

G4IceTopPhysicsList(bool useScintillator)
~G4IceTopPhysicsList()

Private Functions

void SetCuts()

Private Members

bool useScintillator_
class G4IceTopRunManager : public G4RunManager
#include <G4IceTopRunManager.h>

Implementation of G4RunManager

Public Functions

G4IceTopRunManager()
void BeamOn(G4int n_event, const char *macroFile = 0, G4int n_select = -1)
void InitializeRun()
void InjectParticle(G4ParticleGun *particleGun)
void TerminateRun()

Public Static Functions

static inline G4IceTopRunManager *GetIceTopRunManager()

Protected Functions

G4Event *GenerateEvent(G4int i_event)

Private Functions

void Update_Scoring()
class G4IceTopTank
#include <G4IceTopTank.h>

This class constructs the physical volume of single tanks, serves as bridge to the sensitive detector in the tank, and computes the location of the point that define the snow surface. It also stores the basic tank dimensions (height, radius, snow).

The sensitive detectors are not PMTs. Instead, the ice itself is the sensitive detector through G4TankIceSD. In this way, time is saved by not tracking photons.

The points that are used to interpolate the snow surface are chosen so the snow surface is essentially flat on top of the tanks. This is done by determining the three vertices of a 10-meter equilateral triangle centered at the tank. The orientation of the triangle depends on whether the tank is part of a station with one or two tanks (if there are more tanks in a station, a fatal error occurs). In the single-tank case, the first vertex lies along the line pointing toward the first DOM. In the two-tank case, it lies along the line pointing toward it’s neighboring tank.

Public Functions

G4IceTopTank(const TankKey &tankKey, const I3Geometry &geometry, bool applyTimeCut)
~G4IceTopTank()
inline const G4ThreeVector &GetPos() const
I3Position GetPos_I3()

Position of center of the tank.

double GetX_I3()
double GetY_I3()
double GetZ_I3()
inline const G4ThreeVector &GetDelaunayPoint1() const

Delaunay points around tank.

inline const G4ThreeVector &GetDelaunayPoint2() const
inline const G4ThreeVector &GetDelaunayPoint3() const
inline G4double GetTankHeight_G4()

Tank dimensions in Geant4 units.

inline G4double GetTankRadius_G4()
inline G4double GetSnowHeight_G4()
double GetTankHeight_I3()

Tank dimensions in IceCube units and reference system.

double GetTankRadius_I3()
double GetSnowHeight_I3()
G4double GetEDep_G4(const OMKey &omKey)

Energy deposit for a given OM, in Geant4 units (from G4TankIceSD)

G4double GetTime_G4(const OMKey &omKey)

Emission time for a given OM, in Geant4 units (from G4TankIceSD)

double GetEDep_I3(const OMKey &omKey)

Energy deposit for a given OM, in Geant4 units (from G4TankIceSD)

double GetTime_I3(const OMKey &omKey)

Emission time for a given OM, in Geant4 units (from G4TankIceSD)

double GetNumCherenkov(const OMKey &omKey)

Number of Cherenkovs for a given OM (from G4TankIceSD)

double GetNumCherenkovWeight(const OMKey &omKey)

Number of Cherenkovs weighted by emission point (from G4TankIceSD)

inline const TankKey &GetTankKey() const
G4VPhysicalVolume *InstallTank(G4VPhysicalVolume *mother, const G4ThreeVector &origin)

Method to call when constructing detector.

Private Functions

SET_LOGGER ("G4IceTopTank")

Private Members

G4double tankThickness_
G4double tankHeight_
G4double fillHeight_
G4double innerRadius_
G4double outerRadius_
G4double snowHeight_
G4double perliteHeight_
G4double glassOuterRadius_
G4double glassThickness_
G4ThreeVector position_
G4ThreeVector delaunayPoint1_
G4ThreeVector delaunayPoint2_
G4ThreeVector delaunayPoint3_
std::map<OMKey, G4ThreeVector> relDomPositions_
G4LogicalVolume *tankLog_
G4TankIceSD *iceSD_
const TankKey &tankKey_
const I3Geometry &geometry_
bool applyTimeCut_
class G4IceTopUserSteppingAction : public G4UserSteppingAction
#include <G4IceTopUserSteppingAction.h>

Implementation of G4UserSteppingAction. This class kills gammas below threshold (set by G4IceTopTank).

Public Functions

G4IceTopUserSteppingAction()
inline ~G4IceTopUserSteppingAction()
void UserSteppingAction(const G4Step*)
class G4IceTopUserTrackingAction : public G4UserTrackingAction
#include <G4IceTopUserTrackingAction.h>

Implementation of G4UserTrackingAction. This class kills gammas below threshold (set by G4IceTopTank).

Public Functions

G4IceTopUserTrackingAction()
inline ~G4IceTopUserTrackingAction()
void PreUserTrackingAction(const G4Track*)
void PostUserTrackingAction(const G4Track*)
class G4Interface
#include <G4Interface.h>

Top-level class to handle Geant4. All global things are initialized here (run manager, visualization manager, detector construction, physics list and user actions).

Public Functions

G4Interface(const std::string &visMacro = "", bool triangulatedSnow = true, bool useScintillator = false)
~G4Interface()
void InstallTank(G4IceTopTank *tank)

Add a tank to the geometry. Should not be called after initialized.

void InstallScintillator(G4IceScintStation *scint)

Add a scintillator to the geometry. Should not be called after initialized.

void InitializeEvent()

Initialize event. Most Geant4 global things are initialized the first time this is called.

void TerminateEvent()

To be called after simulating each IceTray event.

void InjectParticle(const I3Particle &particle)

Simulate a single particle (InitializeEvent must be called first)

Public Static Functions

static inline G4Interface *GetInstance()

Private Functions

void Initialize()
SET_LOGGER ("G4Interface")

Private Members

G4IceTopRunManager runManager_
G4IceTopDetectorConstruction *detector_
bool initialized_
bool eventInitialized_
std::string visMacro_
bool triangulatedSnow_
bool useScintillator_

Private Static Attributes

static G4Interface *g4Interface_ = NULL
class G4ScintSD : public G4VSensitiveDetector
#include <G4ScintSD.h>

An “scintillator sensitive detector”. This sensitive detector is meant to be associated with the plastic bars logical volume in a scintillator panel.

This class keeps track of the energy losses and number photons produced in the scintillator of each panel.

Public Functions

G4ScintSD(G4String name, const std::map<ScintKey, G4ThreeVector> &scPositions, G4double orientation, G4bool applyTimeCut)
~G4ScintSD()
void Initialize(G4HCofThisEvent *HCE)

Methods called by Geant4 framework.

G4bool ProcessHits(G4Step *aStep, G4TouchableHistory *ROhist)
void EndOfEvent(G4HCofThisEvent *HCE)
inline G4double GetEDep(const ScintKey &scintKey)

Get total energy deposit for a given OM.

inline G4double GetTime(const ScintKey &scintKey)

Get average emission time weighted by deposited energy.

inline G4double GetNumPhotonScintillator(const ScintKey &scintKey)

Private Functions

G4double GetScintillationPhotons(G4Step *aStep, G4double deposit_energy)

Private Members

const std::map<ScintKey, G4ThreeVector> scPositions_
G4double orientation_
G4bool applyTimeCut_
std::map<ScintKey, G4double> sumEdep_
std::map<ScintKey, G4double> cogTime_
std::map<ScintKey, G4double> scintillatorCounter_
class G4TankIceSD : public G4VSensitiveDetector
#include <G4TankIceSD.h>

An “ice sensitive detector”. This sensitive detector is meant to be associated with the ice logical volume in a tank.

This class keeps track of the energy losses and number Cherenkov photons produced in the ice of each tank. The Cherenkov photons are counted in two ways. One is a simple count and the other is a weighted count where the weight depends on the distance from the photon emission point an the OM.

Public Functions

G4TankIceSD(G4String name, const std::map<OMKey, G4ThreeVector> &domPositions, G4bool applyTimeCut)
~G4TankIceSD()
void Initialize(G4HCofThisEvent *HCE)

Methods called by Geant4 framework.

G4bool ProcessHits(G4Step *aStep, G4TouchableHistory *ROhist)
void EndOfEvent(G4HCofThisEvent *HCE)
inline G4double GetEDep(const OMKey &omKey)

Get total energy deposit for a given OM (same for both OMs in a tank)

inline G4double GetTime(const OMKey &omKey)

Get average emission time weighted by deposited energy (same for both OMs in a tank)

inline G4double GetNumCherenkov(const OMKey &omKey)

Get number of Cherenkov photons for a given OM (same for both OMs in a tank)

inline G4double GetNumCherenkovWeight(const OMKey &omKey)

Get number of Cherenkov photons for a given OM weighted relative to emission point.

Private Functions

G4double GetCerenkovNumber(G4Step *aStep)

Cherenkov production. See technical note.

G4double GetProbability(G4double radius, G4double height)

Private Members

const std::map<OMKey, G4ThreeVector> domPositions_
G4bool applyTimeCut_
std::map<OMKey, G4double> sumEdep_
std::map<OMKey, G4double> cogTime_
std::map<OMKey, G4double> cherenkovCounter_
std::map<OMKey, G4double> cherenkovCounterWeight_
class I3G4TankResponse : public I3TankResponse
#include <I3G4TankResponse.h>

THE one and only service… implementation of topsimulator’s I3TankResponse. The top level from a user’s point of view. It delegates all Geant4 interaction to G4Interface.

Public Functions

I3G4TankResponse(I3Configuration &config, const I3Context &context, const TankKey &tankKey, const ScintKey &scintKey)
~I3G4TankResponse()
void Initialize(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status)
void Initialize_Scintillator(const I3Geometry &geometry, const I3Calibration &calib, const I3DetectorStatus &status)
void Configure()
double GetX() const
double GetY() const
double GetZ() const
double GetTankRadius() const
double GetTankHeight() const
double GetSnowHeight() const
inline double GetVirtualTankRadius() const
inline double GetVirtualTankHeight() const
template<class PEPerVEM_iter, class PEPerVEMType>
bool CalculateNPE(PEPerVEM_iter pePerVEM_iter, PEPerVEMType pePerVEM, ExtendedI3Particle particle, HitHistoCollection &hitHC, HitHistoCollection &hitHC_extra, bool istank)
bool TrackParticle(const ExtendedI3Particle &particle, HitHistoCollection &hitHC, HitHistoCollection &cherHitCollection, HitHistoCollection &scintHitCollection)
void BeginEvent(const I3Particle &primary)

Called at the beginning of I3TopSimulator::DAQ.

void EndEvent(HitHistoCollection &hitHC, HitHistoCollection &cherHitCollection, HitHistoCollection &scintHitCollection)

Called at the end of I3TopSimulator::DAQ.

Private Functions

bool IntersectTank(const I3Particle &particle, double margin)
void GenerateHits(int32_t npe, const ExtendedI3Particle &particle, HitHisto &hitHisto)
SET_LOGGER ("I3G4TankResponse")

Private Members

double tauZirco_
double tauTyvek_
double decayTime_
double safetyMargin_
double pseudoScintTankHeight_
double pseudoScintTankRadius_
double chargeScale_
bool cherenkovMethod_
bool cherenkovWeighting_
int32_t particlesBeforeThreshold_
int32_t particlesAfterThreshold_
double vemCounter_
double scintvemCounter_
std::string visMacroFile_
std::map<OMKey, double> pePerVEM_
std::map<ScintKey, double> scint_pePerVEM_
std::string randomServiceName_
I3RandomServicePtr randomService_
bool triangulatedSnow_
bool useScintillator_
G4Interface *g4Interface_
G4IceTopTank *g4Tank_
G4IceScintStation *g4Scint_
bool applyTimeCut_

Private Static Attributes

static const double PHOTONS_PER_VEM = 32880.
static const double WEIGHTED_PHOTONS_PER_VEM = 1435.
static const double MEV_PER_VEM = 186.6 * I3Units::MeV
static const double VEM_THRESHOLD = 2000.0
static const double SCINT_MEV_PER_VEM = 1.61 * I3Units::MeV
static const double SCINT_PHOTONS_PER_VEM = 14234.0
template<typename T>
class Triangle
#include <triangle.h>

Public Functions

Triangle(const Vector2<T> &_p1, const Vector2<T> &_p2, const Vector2<T> &_p3)
bool containsVertex(const Vector2<T> &v)
bool circumCircleContains(const Vector2<T> &v)

Public Members

Vector2<T> p1
Vector2<T> p2
Vector2<T> p3
Edge<T> e1
Edge<T> e2
Edge<T> e3
struct triangulateio
#include <triangle.h>

Public Members

REAL *pointlist
REAL *pointattributelist
int *pointmarkerlist
int numberofpoints
int numberofpointattributes
int *trianglelist
REAL *triangleattributelist
REAL *trianglearealist
int *neighborlist
int numberoftriangles
int numberofcorners
int numberoftriangleattributes
int *segmentlist
int *segmentmarkerlist
int numberofsegments
REAL *holelist
int numberofholes
REAL *regionlist
int numberofregions
int *edgelist
int *edgemarkerlist
REAL *normlist
int numberofedges
template<typename T>
class Vector2
#include <vector2.h>

Public Functions

inline Vector2()
inline Vector2(T _x, T _y, size_t _id = 0)
inline Vector2(const Vector2 &v)
inline void set(const Vector2 &v)
inline T dist2(const Vector2 &v)
inline float dist(const Vector2 &v)

Public Members

T x
T y
size_t id
namespace std

STL namespace.

file delaunay.cpp
#include “delaunay.h”
#include <algorithm>
file delaunay.h
#include “vector2.h”
#include “triangle.h”
#include <vector>
file edge.h
#include “vector2.h”

Functions

template<typename T>
inline std::ostream &operator<<(std::ostream &str, Edge<T> const &e)
template<typename T>
inline bool operator==(const Edge<T> &e1, const Edge<T> &e2)
file G4Delaunay.cxx
#include <g4-tankresponse/g4classes/G4Delaunay.h>
#include <G4TessellatedSolid.hh>
#include <G4TriangularFacet.hh>
#include <G4QuadrangularFacet.hh>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <boost/foreach.hpp>
#include <g4-tankresponse/bowyer/delaunay.h>
file G4Delaunay.h
#include <icetray/I3Logging.h>
#include <G4TessellatedSolid.hh>
#include <G4ThreeVector.hh>
#include <vector>
file G4IceScintStation.cxx
#include <g4-tankresponse/g4classes/G4IceScintStation.h>
#include <g4-tankresponse/g4classes/G4ScintSD.h>
#include <icetray/I3Units.h>
#include <dataclasses/ScintKey.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/geometry/I3TankGeo.h>
#include <dataclasses/geometry/I3Geometry.h>
#include “dataclasses/geometry/I3ScintGeo.h”
#include <dataclasses/I3Position.h>
#include <G4LogicalVolume.hh>
#include <G4PVPlacement.hh>
#include <G4Material.hh>
#include <G4Tubs.hh>
#include <G4Sphere.hh>
#include <G4Box.hh>
#include <G4SDManager.hh>
#include <G4ThreeVector.hh>
#include <G4TransportationManager.hh>
#include <G4Navigator.hh>
#include <G4VisAttributes.hh>
#include <G4UserLimits.hh>
#include <boost/foreach.hpp>

Defines

ATTRIBUTE_UNUSED
file G4IceScintStation.h
#include <G4Types.hh>
#include <G4ThreeVector.hh>
#include <map>
#include “dataclasses/geometry/I3ScintGeo.h”
#include <icetray/I3Logging.h>
file G4IceTopDetectorConstruction.cxx
#include <g4-tankresponse/g4classes/G4IceTopDetectorConstruction.h>
#include <g4-tankresponse/g4classes/G4IceTopTank.h>
#include <g4-tankresponse/g4classes/G4IceScintStation.h>
#include <G4NistManager.hh>
#include <G4Material.hh>
#include “G4Version.hh”
#include <G4LogicalVolume.hh>
#include <G4PVPlacement.hh>
#include <G4Box.hh>
#include <g4-tankresponse/g4classes/G4Delaunay.h>
#include <G4TriangularFacet.hh>
#include <G4QuadrangularFacet.hh>
#include <G4TessellatedSolid.hh>
#include <G4VisAttributes.hh>
#include <G4UserLimits.hh>
#include <boost/foreach.hpp>

Defines

ATTRIBUTE_UNUSED
file G4IceTopDetectorConstruction.h
#include <G4VUserDetectorConstruction.hh>
#include <G4ThreeVector.hh>
file G4IceTopEMPhysics.cxx
#include <globals.hh>
#include <G4ParticleDefinition.hh>
#include <G4ParticleTable.hh>
#include <G4Gamma.hh>
#include <G4Electron.hh>
#include <G4Positron.hh>
#include <G4NeutrinoE.hh>
#include <G4AntiNeutrinoE.hh>
#include <G4ProcessManager.hh>
#include “G4IceTopEMPhysics.h”
file G4IceTopEMPhysics.h
#include <globals.hh>
#include <G4VPhysicsConstructor.hh>
#include <G4PhotoElectricEffect.hh>
#include <G4ComptonScattering.hh>
#include <G4GammaConversion.hh>
#include <G4eMultipleScattering.hh>
#include <G4eIonisation.hh>
#include <G4eBremsstrahlung.hh>
#include <G4eplusAnnihilation.hh>
file G4IceTopGeneralPhysics.cxx
#include “G4IceTopGeneralPhysics.h”
#include <iomanip>
#include <globals.hh>
#include <G4ios.hh>
#include <G4ParticleDefinition.hh>
#include <G4ProcessManager.hh>
#include <G4ChargedGeantino.hh>
#include <G4Geantino.hh>
#include <G4Version.hh>
file G4IceTopGeneralPhysics.h
#include <globals.hh>
#include <G4VPhysicsConstructor.hh>
#include <G4Decay.hh>
file G4IceTopHadronPhysics.cxx
#include <iomanip>
#include <globals.hh>
#include <G4ios.hh>
#include <G4ParticleDefinition.hh>
#include <G4ParticleTable.hh>
#include <G4MesonConstructor.hh>
#include <G4BaryonConstructor.hh>
#include <G4ShortLivedConstructor.hh>
#include <G4ProcessManager.hh>
#include “G4IceTopHadronPhysics.h”
file G4IceTopHadronPhysics.h
#include <vector>
#include <globals.hh>
#include <G4VPhysicsConstructor.hh>
#include <G4hMultipleScattering.hh>
#include <G4hIonisation.hh>
#include <G4HadronElasticProcess.hh>
#include <G4HadronFissionProcess.hh>
#include <G4HadronCaptureProcess.hh>
#include <G4PionPlusInelasticProcess.hh>
#include <G4PionMinusInelasticProcess.hh>
#include <G4KaonPlusInelasticProcess.hh>
#include <G4KaonZeroSInelasticProcess.hh>
#include <G4KaonZeroLInelasticProcess.hh>
#include <G4KaonMinusInelasticProcess.hh>
#include <G4ProtonInelasticProcess.hh>
#include <G4AntiProtonInelasticProcess.hh>
#include <G4NeutronInelasticProcess.hh>
#include <G4AntiNeutronInelasticProcess.hh>
#include <G4LambdaInelasticProcess.hh>
#include <G4AntiLambdaInelasticProcess.hh>
#include <G4SigmaPlusInelasticProcess.hh>
#include <G4SigmaMinusInelasticProcess.hh>
#include <G4AntiSigmaPlusInelasticProcess.hh>
#include <G4AntiSigmaMinusInelasticProcess.hh>
#include <G4XiZeroInelasticProcess.hh>
#include <G4XiMinusInelasticProcess.hh>
#include <G4AntiXiZeroInelasticProcess.hh>
#include <G4AntiXiMinusInelasticProcess.hh>
#include <G4DeuteronInelasticProcess.hh>
#include <G4TritonInelasticProcess.hh>
#include <G4AlphaInelasticProcess.hh>
#include <G4OmegaMinusInelasticProcess.hh>
#include <G4AntiOmegaMinusInelasticProcess.hh>
#include <G4LElastic.hh>
#include <G4LFission.hh>
#include <G4LCapture.hh>
#include <G4LEPionPlusInelastic.hh>
#include <G4LEPionMinusInelastic.hh>
#include <G4LEKaonPlusInelastic.hh>
#include <G4LEKaonZeroSInelastic.hh>
#include <G4LEKaonZeroLInelastic.hh>
#include <G4LEKaonMinusInelastic.hh>
#include <G4LEProtonInelastic.hh>
#include <G4LEAntiProtonInelastic.hh>
#include <G4LENeutronInelastic.hh>
#include <G4LEAntiNeutronInelastic.hh>
#include <G4LELambdaInelastic.hh>
#include <G4LEAntiLambdaInelastic.hh>
#include <G4LESigmaPlusInelastic.hh>
#include <G4LESigmaMinusInelastic.hh>
#include <G4LEAntiSigmaPlusInelastic.hh>
#include <G4LEAntiSigmaMinusInelastic.hh>
#include <G4LEXiZeroInelastic.hh>
#include <G4LEXiMinusInelastic.hh>
#include <G4LEAntiXiZeroInelastic.hh>
#include <G4LEAntiXiMinusInelastic.hh>
#include <G4LEDeuteronInelastic.hh>
#include <G4LETritonInelastic.hh>
#include <G4LEAlphaInelastic.hh>
#include <G4LEOmegaMinusInelastic.hh>
#include <G4LEAntiOmegaMinusInelastic.hh>
#include <G4HEPionPlusInelastic.hh>
#include <G4HEPionMinusInelastic.hh>
#include <G4HEKaonPlusInelastic.hh>
#include <G4HEKaonZeroInelastic.hh>
#include <G4HEKaonMinusInelastic.hh>
#include <G4HEProtonInelastic.hh>
#include <G4HEAntiProtonInelastic.hh>
#include <G4HENeutronInelastic.hh>
#include <G4HEAntiNeutronInelastic.hh>
#include <G4HELambdaInelastic.hh>
#include <G4HEAntiLambdaInelastic.hh>
#include <G4HESigmaPlusInelastic.hh>
#include <G4HESigmaMinusInelastic.hh>
#include <G4HEAntiSigmaPlusInelastic.hh>
#include <G4HEAntiSigmaMinusInelastic.hh>
#include <G4HEXiZeroInelastic.hh>
#include <G4HEXiMinusInelastic.hh>
#include <G4HEAntiXiZeroInelastic.hh>
#include <G4HEAntiXiMinusInelastic.hh>
#include <G4HEOmegaMinusInelastic.hh>
#include <G4HEAntiOmegaMinusInelastic.hh>
#include <G4AntiProtonAnnihilationAtRest.hh>
#include <G4AntiNeutronAnnihilationAtRest.hh>
#include <G4PiMinusAbsorptionAtRest.hh>
#include <G4KaonMinusAbsorptionAtRest.hh>
#include <G4TheoFSGenerator.hh>
#include <G4ExcitationHandler.hh>
#include <G4PreCompoundModel.hh>
#include <G4GeneratorPrecompoundInterface.hh>
#include <G4QGSModel.hh>
#include <G4QGSParticipants.hh>
#include <G4QGSMFragmentation.hh>
#include <G4ExcitedStringDecay.hh>
file G4IceTopIonPhysics.cxx
#include <iomanip>
#include <globals.hh>
#include <G4ios.hh>
#include <G4ParticleDefinition.hh>
#include <G4ParticleTable.hh>
#include <G4IonConstructor.hh>
#include <G4ProcessManager.hh>
#include “G4IceTopIonPhysics.h”
file G4IceTopIonPhysics.h
#include <globals.hh>
#include <G4ios.hh>
#include <G4VPhysicsConstructor.hh>
#include <G4HadronElasticProcess.hh>
#include <G4LElastic.hh>
#include <G4DeuteronInelasticProcess.hh>
#include <G4LEDeuteronInelastic.hh>
#include <G4TritonInelasticProcess.hh>
#include <G4LETritonInelastic.hh>
#include <G4AlphaInelasticProcess.hh>
#include <G4LEAlphaInelastic.hh>
#include <G4hIonisation.hh>
#include <G4ionIonisation.hh>
#include <G4hMultipleScattering.hh>
file G4IceTopMuonPhysics.cxx
#include <globals.hh>
#include <G4ParticleDefinition.hh>
#include <G4ParticleTable.hh>
#include <G4MuonPlus.hh>
#include <G4MuonMinus.hh>
#include <G4TauMinus.hh>
#include <G4TauPlus.hh>
#include <G4NeutrinoTau.hh>
#include <G4AntiNeutrinoTau.hh>
#include <G4NeutrinoMu.hh>
#include <G4AntiNeutrinoMu.hh>
#include <G4ProcessManager.hh>
#include “G4IceTopMuonPhysics.h”
file G4IceTopMuonPhysics.h
#include <globals.hh>
#include <G4VPhysicsConstructor.hh>
#include <G4MuMultipleScattering.hh>
#include <G4MuBremsstrahlung.hh>
#include <G4MuPairProduction.hh>
#include <G4MuIonisation.hh>
#include <G4hIonisation.hh>
#include <G4MuonMinusCaptureAtRest.hh>
file G4IceTopPhysicsList.cxx
#include <globals.hh>
#include <G4Version.hh>
#include “G4IceTopPhysicsList.h”
#include “G4IceTopGeneralPhysics.h”
#include “G4IceTopEMPhysics.h”
#include “G4IceTopMuonPhysics.h”
#include “G4IceTopHadronPhysics.h”
#include “G4IceTopIonPhysics.h”
#include <G4ProcessManager.hh>
#include <G4ParticleTypes.hh>
#include <G4UserSpecialCuts.hh>
file G4IceTopPhysicsList.h
#include <G4VModularPhysicsList.hh>
file G4IceTopRunManager.cxx
#include “G4Timer.hh”
#include <g4-tankresponse/g4classes/G4IceTopRunManager.h>
#include <G4ParticleGun.hh>
#include <G4Run.hh>
#include <G4ScoringManager.hh>
#include <G4HCofThisEvent.hh>
#include <G4VHitsCollection.hh>
file G4IceTopRunManager.h
#include <G4RunManager.hh>
file G4IceTopTank.cxx
#include <g4-tankresponse/g4classes/G4IceTopTank.h>
#include <g4-tankresponse/g4classes/G4TankIceSD.h>
#include <icetray/I3Units.h>
#include <icetray/OMKey.h>
#include <dataclasses/TankKey.h>
#include <dataclasses/geometry/I3TankGeo.h>
#include <dataclasses/geometry/I3Geometry.h>
#include <dataclasses/I3Position.h>
#include <G4LogicalVolume.hh>
#include <G4PVPlacement.hh>
#include <G4Material.hh>
#include <G4Tubs.hh>
#include <G4Sphere.hh>
#include <G4Box.hh>
#include <G4SDManager.hh>
#include <G4ThreeVector.hh>
#include <G4VisAttributes.hh>
#include <G4UserLimits.hh>
#include <boost/foreach.hpp>

Defines

ATTRIBUTE_UNUSED
file G4IceTopTank.h
#include <G4Types.hh>
#include <G4ThreeVector.hh>
#include <map>
#include <icetray/I3Logging.h>
file G4IceTopUserSteppingAction.cxx
#include <g4-tankresponse/g4classes/G4IceTopUserSteppingAction.h>
#include “G4Step.hh”
#include “G4Track.hh”
#include “G4LogicalVolume.hh”
#include “G4UserLimits.hh”
#include “G4SteppingManager.hh”
file G4IceTopUserSteppingAction.h
#include “G4UserSteppingAction.hh”
file G4IceTopUserTrackingAction.cxx
#include <g4-tankresponse/g4classes/G4IceTopUserTrackingAction.h>
#include “G4Track.hh”
#include “G4UserLimits.hh”
#include “G4TrackVector.hh”
#include “G4TrackingManager.hh”
file G4IceTopUserTrackingAction.h
#include “G4UserTrackingAction.hh”
file G4Interface.cxx
#include <dataclasses/physics/I3Particle.h>
#include <g4-tankresponse/g4classes/G4Interface.h>
#include <g4-tankresponse/g4classes/G4IceTopDetectorConstruction.h>
#include <g4-tankresponse/g4classes/G4IceTopPhysicsList.h>
#include <g4-tankresponse/g4classes/G4IceTopUserTrackingAction.h>
#include <g4-tankresponse/g4classes/G4IceTopUserSteppingAction.h>
#include <icetray/I3Logging.h>
#include <G4ParticleGun.hh>
#include <G4ParticleTable.hh>
#include <G4ParticleDefinition.hh>
#include <G4UImanager.hh>
file G4Interface.h
#include <g4-tankresponse/g4classes/G4IceTopRunManager.h>
#include <icetray/I3Logging.h>
file G4ScintSD.cxx
#include <g4-tankresponse/g4classes/G4ScintSD.h>
#include <g4-tankresponse/g4classes/G4IceScintStation.h>
#include <G4Step.hh>
#include <G4HCofThisEvent.hh>
#include <G4TouchableHistory.hh>
#include <G4ios.hh>
#include <iostream>
#include <ios>
#include <fstream>
#include <G4VProcess.hh>
#include <G4OpticalPhoton.hh>
#include “G4Poisson.hh”
#include <icetray/I3Units.h>
#include “G4Version.hh”
file G4ScintSD.h
#include <icetray/OMKey.h>
#include <dataclasses/ScintKey.h>
#include <G4VSensitiveDetector.hh>
#include <G4ThreeVector.hh>
#include <map>
file G4TankIceSD.cxx
#include <g4-tankresponse/g4classes/G4TankIceSD.h>
#include <g4-tankresponse/g4classes/G4IceTopTank.h>
#include <G4Step.hh>
#include <G4HCofThisEvent.hh>
#include <G4TouchableHistory.hh>
#include <G4ios.hh>
#include <iostream>
#include <ios>
#include <fstream>
#include <G4VProcess.hh>
#include <G4OpticalPhoton.hh>
#include “G4Poisson.hh”
#include <icetray/I3Units.h>
#include “G4Version.hh”
file G4TankIceSD.h
#include <icetray/OMKey.h>
#include <G4VSensitiveDetector.hh>
#include <G4ThreeVector.hh>
#include <map>
file I3G4TankResponse.cxx
#include <topsimulator/interface/I3IceTopResponseFactory.h>
#include <topsimulator/GeoFunctions.h>
#include <g4-tankresponse/g4classes/G4IceTopTank.h>
#include <g4-tankresponse/g4classes/G4IceScintStation.h>
#include <g4-tankresponse/g4classes/G4Interface.h>
#include <g4-tankresponse/I3G4TankResponse.h>
#include <phys-services/I3GSLRandomService.h>
#include <dataclasses/physics/I3Particle.h>
#include <dataclasses/I3Direction.h>
#include <simclasses/I3MCPE.h>
#include <cmath>

Typedefs

typedef boost::variant<OMKey, ScintKey> Key

Functions

I3_SERVICE_FACTORY(I3IceTopResponseFactory<I3G4TankResponse>)
file I3G4TankResponse.h
#include <topsimulator/interface/I3TankResponse.h>
#include <icetray/I3Configuration.h>
#include <icetray/I3Logging.h>

Defines

MEAN_NORMALIZED_PE

This parameter needs to be updated whenever the charge distribution constants change. This should be caught in the tests.

Functions

I3_FORWARD_DECLARATION(I3RandomService)
I3_POINTER_TYPEDEFS(I3G4TankResponse)
file triangle.cpp
#include “triangle.h”
#include <assert.h>
#include <math.h>
#include “delaunay.h”
file bowyer/triangle.h
#include “vector2.h”
#include “edge.h”

Functions

template<typename T>
inline std::ostream &operator<<(std::ostream &str, const Triangle<T> &t)
template<typename T>
inline bool operator==(const Triangle<T> &t1, const Triangle<T> &t2)
file triangle/triangle.h

Functions

void triangulate()
void trifree()
file vector2.h
#include <iostream>
#include <cmath>

Functions

template<typename T>
std::ostream &operator<<(std::ostream &str, Vector2<T> const &point)
template<typename T>
bool operator==(Vector2<T> v1, Vector2<T> v2)
dir bowyer
dir g4-tankresponse
dir g4-tankresponse
dir g4-tankresponse
dir g4classes
dir icetray
dir private
dir public
dir triangle