Import Geant4 6.2.0 source tree

This commit is contained in:
Gabriele Cosmo
2016-06-09 10:56:29 +02:00
parent 1d812b78b1
commit e083ffb441
1415 changed files with 111223 additions and 21207 deletions
@@ -0,0 +1,146 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeDetectorConstruction_H
#define LXeDetectorConstruction_H 1
class G4LogicalVolume;
class G4VPhysicalVolume;
class G4Box;
class G4Tubs;
class LXePMTSD;
class LXeScintSD;
class G4Sphere;
#include "G4Material.hh"
#include "LXeDetectorMessenger.hh"
#include "G4VisAttributes.hh"
#include "G4RotationMatrix.hh"
#include "G4VUserDetectorConstruction.hh"
class LXeDetectorConstruction : public G4VUserDetectorConstruction
{
public:
LXeDetectorConstruction();
~LXeDetectorConstruction();
G4VPhysicalVolume* Construct();
//Functions to modify the geometry
void SetDimensions(G4ThreeVector dims);
void SetHousingThickness(G4double d_mtl);
void SetNX(G4int nx);
void SetNY(G4int ny);
void SetNZ(G4int nz);
void SetPMTRadius(G4double outerRadius_pmt);
void SetDefaults();
//Get values
G4double GetScintX(){return scint_x;}
G4double GetScintY(){return scint_y;}
G4double GetScintZ(){return scint_z;}
G4double GetHousingThickness(){return d_mtl;}
G4int GetNX(){return nx;}
G4int GetNY(){return ny;}
G4int GetNZ(){return nz;}
G4double GetPMTRadius(){return outerRadius_pmt;}
G4double GetSlabZ(){return slab_z;}
//rebuild the geometry based on changes. must be called
void UpdateGeometry();
G4bool GetUpdated(){return updated;}
void SetSphereOn(G4bool b){sphereOn=b;updated=true;}
static G4bool GetSphereOn(){return sphereOn;}
void SetHousingReflectivity(G4double r){refl=r;updated=true;}
G4double GetHousingReflectivity(){return refl;}
void SetWLSSlabOn(G4bool b){WLSslab=b;updated=true;}
G4bool GetWLSSlabOn(){return WLSslab;}
void SetMainVolumeOn(G4bool b){mainVolume=b;updated=true;}
G4bool GetMainVolumeOn(){return mainVolume;}
void SetNFibers(G4int n){nfibers=n;updated=true;}
G4int GetNFibers(){return nfibers;}
void SetMainScintYield(G4double y);
void SetWLSScintYield(G4double y);
private:
void DefineMaterials();
G4VPhysicalVolume* ConstructDetector();
LXeDetectorMessenger* detectorMessenger;
G4bool updated;
G4Box* experimentalHall_box;
G4LogicalVolume* experimentalHall_log;
G4VPhysicalVolume* experimentalHall_phys;
//Materials & Elements
G4Material* LXe;
G4Material* Al;
G4Element* N;
G4Element* O;
G4Material* Air;
G4Material* Vacuum;
G4Element* C;
G4Element* H;
G4Material* Glass;
G4Material* Pstyrene;
G4Material* PMMA;
G4Material* Pethylene;
G4Material* fPethylene;
//Geometry
G4double scint_x;
G4double scint_y;
G4double scint_z;
G4double d_mtl;
G4int nx;
G4int ny;
G4int nz;
G4double outerRadius_pmt;
G4int nfibers;
static G4bool sphereOn;
G4double refl;
G4bool WLSslab;
G4bool mainVolume;
G4double slab_z;
G4MaterialPropertiesTable* LXe_mt;
G4MaterialPropertiesTable* MPTPStyrene;
};
#endif
@@ -0,0 +1,69 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeDetectorMessenger_h
#define LXeDetectorMessenger_h 1
#include "G4UImessenger.hh"
#include "globals.hh"
class LXeDetectorConstruction;
class G4UIdirectory;
class G4UIcmdWithADoubleAndUnit;
class G4UIcmdWith3VectorAndUnit;
class G4UIcmdWithAnInteger;
class G4UIcommand;
class G4UIcmdWithABool;
class G4UIcmdWithADouble;
class LXeDetectorMessenger: public G4UImessenger
{
public:
LXeDetectorMessenger(LXeDetectorConstruction*);
~LXeDetectorMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
LXeDetectorConstruction* LXeDetector;
G4UIdirectory* detectorDir;
G4UIdirectory* volumesDir;
G4UIcmdWith3VectorAndUnit* dimensionsCmd;
G4UIcmdWithADoubleAndUnit* housingThicknessCmd;
G4UIcmdWithADoubleAndUnit* pmtRadiusCmd;
G4UIcmdWithAnInteger* nxCmd;
G4UIcmdWithAnInteger* nyCmd;
G4UIcmdWithAnInteger* nzCmd;
G4UIcmdWithABool* sphereCmd;
G4UIcmdWithADouble* reflectivityCmd;
G4UIcmdWithABool* wlsCmd;
G4UIcmdWithABool* lxeCmd;
G4UIcmdWithAnInteger* nFibersCmd;
G4UIcommand* updateCmd;
G4UIcommand* defaultsCmd;
G4UIcmdWithADouble* MainScintYield;
G4UIcmdWithADouble* WLSScintYield;
};
#endif
@@ -0,0 +1,79 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeEMPhysics_h
#define LXeEMPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4MultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
class LXeEMPhysics : public G4VPhysicsConstructor
{
public:
LXeEMPhysics(const G4String& name ="EM");
virtual ~LXeEMPhysics();
public:
// This method will be invoked in the Construct() method.
// each particle type will be instantiated
virtual void ConstructParticle();
// 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
virtual void ConstructProcess();
protected:
// Gamma physics
G4PhotoElectricEffect* thePhotoEffect;
G4ComptonScattering* theComptonEffect;
G4GammaConversion* thePairProduction;
// Electron physics
G4MultipleScattering* theElectronMultipleScattering;
G4eIonisation* theElectronIonisation;
G4eBremsstrahlung* theElectronBremsStrahlung;
//Positron physics
G4MultipleScattering* thePositronMultipleScattering;
G4eIonisation* thePositronIonisation;
G4eBremsstrahlung* thePositronBremsStrahlung;
G4eplusAnnihilation* theAnnihilation;
};
#endif
@@ -0,0 +1,74 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeEventAction_h
#define LXeEventAction_h 1
#include "LXeEventMessenger.hh"
#include "G4UserEventAction.hh"
#include "globals.hh"
#include "G4ThreeVector.hh"
class G4Event;
class RecorderBase;
class LXeEventAction : public G4UserEventAction
{
public:
LXeEventAction(RecorderBase*);
~LXeEventAction();
public:
void BeginOfEventAction(const G4Event*);
void EndOfEventAction(const G4Event*);
void SetSaveThreshold(G4int save);
void SetEventVerbose(G4int v){verbose=v;}
void SetPMTThreshold(G4int t){pmtThreshold=t;}
void SetForceDrawPhotons(G4bool b){forcedrawphotons=b;}
void SetForceDrawNoPhotons(G4bool b){forcenophotons=b;}
private:
RecorderBase* recorder;
LXeEventMessenger* eventMessenger;
G4int saveThreshold;
G4int scintCollID;
G4int pmtCollID;
G4int verbose;
G4int pmtThreshold;
G4bool forcedrawphotons;
G4bool forcenophotons;
};
#endif
@@ -0,0 +1,52 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeEventMessenger_h
#define LXeEventMessenger_h 1
#include "G4UImessenger.hh"
#include "globals.hh"
class LXeEventAction;
class G4UIcmdWithAnInteger;
class G4UIcmdWithABool;
class LXeEventMessenger: public G4UImessenger
{
public:
LXeEventMessenger(LXeEventAction*);
~LXeEventMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
LXeEventAction* LXeEvent;
G4UIcmdWithAnInteger* saveThresholdCmd;
G4UIcmdWithAnInteger* verboseCmd;
G4UIcmdWithAnInteger* pmtThresholdCmd;
G4UIcmdWithABool* forceDrawPhotonsCmd;
G4UIcmdWithABool* forceDrawNoPhotonsCmd;
};
#endif
@@ -0,0 +1,63 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeGeneralPhysics_h
#define LXeGeneralPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4Decay.hh"
class LXeGeneralPhysics : public G4VPhysicsConstructor
{
public:
LXeGeneralPhysics(const G4String& name = "general");
virtual ~LXeGeneralPhysics();
public:
// This method will be invoked in the Construct() method.
// each particle type will be instantiated
virtual void ConstructParticle();
// 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
virtual void ConstructProcess();
protected:
G4Decay* fDecayProcess;
};
#endif
@@ -0,0 +1,102 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeMainVolume_H
#define LXeMainVolume_H 1
#include "G4PVPlacement.hh"
#include "G4Box.hh"
#include "G4Tubs.hh"
#include "G4Sphere.hh"
#include "G4Material.hh"
#include "G4LogicalVolume.hh"
#include "G4OpticalSurface.hh"
#include "LXeDetectorConstruction.hh"
class LXeMainVolume : public G4PVPlacement
{
public:
LXeMainVolume(G4RotationMatrix *pRot,
const G4ThreeVector &tlate,
G4LogicalVolume *pMotherLogical,
G4bool pMany,
G4int pCopyNo,
LXeDetectorConstruction* c);
private:
void VisAttributes();
void SurfaceProperties();
void PlacePMTs(G4LogicalVolume* pmt_Log,
G4RotationMatrix* rot, G4double &a, G4double &b, G4double da,
G4double db, G4double amin, G4double bmin, G4int na, G4int nb,
G4double &x, G4double &y, G4double &z, G4int &k,LXePMTSD* sd);
void CopyValues();
G4bool updated;
LXeDetectorConstruction* constructor;
G4double scint_x;
G4double scint_y;
G4double scint_z;
G4double d_mtl;
G4int nx;
G4int ny;
G4int nz;
G4double outerRadius_pmt;
G4bool sphereOn;
G4double refl;
//Basic Volumes
//
G4Box* scint_box;
G4Box* housing_box;
G4Tubs* pmt;
G4Tubs* photocath;
G4Sphere* sphere;
// Logical volumes
//
G4LogicalVolume* scint_log;
static G4LogicalVolume* housing_log;
G4LogicalVolume* pmt_log;
G4LogicalVolume* photocath_log;
G4LogicalVolume* sphere_log;
// Physical volumes
//
G4VPhysicalVolume* scint_phys;
//keeping pointers to these is pointless really since there are many of them
//but I'm doing it to be consistent
G4VPhysicalVolume* pmt_phys;
G4VPhysicalVolume* photocath_phys;
G4VPhysicalVolume* sphere_phys;
//Sensitive Detectors
static LXeScintSD* scint_SD;
static LXePMTSD* pmt_SD;
};
#endif
@@ -0,0 +1,72 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeMuonPhysics_h
#define LXeMuonPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4MultipleScattering.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4MuIonisation.hh"
#include "G4hIonisation.hh"
#include "G4MuonMinusCaptureAtRest.hh"
class LXeMuonPhysics : public G4VPhysicsConstructor
{
public:
LXeMuonPhysics(const G4String& name="muon");
virtual ~LXeMuonPhysics();
public:
// This method will be invoked in the Construct() method.
// each particle type will be instantiated
virtual void ConstructParticle();
// 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
virtual void ConstructProcess();
protected:
// Muon physics
G4MuIonisation* fMuPlusIonisation;
G4MultipleScattering* fMuPlusMultipleScattering;
G4MuBremsstrahlung* fMuPlusBremsstrahlung ;
G4MuPairProduction* fMuPlusPairProduction;
G4MuIonisation* fMuMinusIonisation;
G4MultipleScattering* fMuMinusMultipleScattering;
G4MuBremsstrahlung* fMuMinusBremsstrahlung ;
G4MuPairProduction* fMuMinusPairProduction;
G4MuonMinusCaptureAtRest* fMuMinusCaptureAtRest;
};
#endif
@@ -0,0 +1,50 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeOpPhysMessenger_h
#define LXeOpPhysMessenger_h 1
#include "G4UImessenger.hh"
#include "globals.hh"
class LXeOpticalPhysics;
class G4UIcmdWithADouble;
class LXeOpPhysMessenger: public G4UImessenger
{
public:
LXeOpPhysMessenger(LXeOpticalPhysics*);
~LXeOpPhysMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
LXeOpticalPhysics* OpPhys;
G4UIcmdWithADouble* yieldCmd;
};
#endif
@@ -0,0 +1,73 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeOpticalPhysics_h
#define LXeOpticalPhysics_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4Scintillation.hh"
#include "G4Cerenkov.hh"
#include "G4OpAbsorption.hh"
#include "G4OpRayleigh.hh"
#include "G4OpBoundaryProcess.hh"
#include "G4OpWLS.hh"
class LXeOpticalPhysics : public G4VPhysicsConstructor
{
public:
LXeOpticalPhysics(const G4String& name ="optical");
virtual ~LXeOpticalPhysics();
public:
// This method will be invoked in the Construct() method.
// each particle type will be instantiated
virtual void ConstructParticle();
// 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
virtual void ConstructProcess();
void SetScintYieldFactor(G4double yf);
protected:
G4Scintillation* theScintProcess;
G4Cerenkov* theCerenkovProcess;
G4OpAbsorption* theAbsorptionProcess;
G4OpRayleigh* theRayleighScattering;
G4OpBoundaryProcess* theBoundaryProcess;
G4OpWLS* theWLSProcess;
};
#endif
@@ -0,0 +1,98 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXePMTHit_h
#define LXePMTHit_h 1
#include "G4VHit.hh"
#include "G4THitsCollection.hh"
#include "G4Allocator.hh"
#include "G4ThreeVector.hh"
#include "G4LogicalVolume.hh"
#include "G4Transform3D.hh"
#include "G4RotationMatrix.hh"
#include "G4VPhysicalVolume.hh"
class G4VTouchable;
class LXePMTHit : public G4VHit
{
public:
LXePMTHit();
~LXePMTHit();
LXePMTHit(const LXePMTHit &right);
const LXePMTHit& operator=(const LXePMTHit &right);
G4int operator==(const LXePMTHit &right) const;
inline void *operator new(size_t);
inline void operator delete(void *aHit);
void Draw();
void Print();
inline void SetDrawit(G4bool b){drawit=b;}
inline G4bool GetDrawit(){return drawit;}
inline void IncPhotonCount(){photons++;}
inline G4int GetPhotonCount(){return photons;}
inline void SetPMTNumber(G4int n) { pmtNumber = n; }
inline G4int GetPMTNumber() { return pmtNumber; }
inline void SetPMTPhysVol(G4VPhysicalVolume* physVol){this->physVol=physVol;}
inline G4VPhysicalVolume* GetPMTPhysVol(){return physVol;}
inline void SetPMTPos(G4double x,G4double y,G4double z){
pos=G4ThreeVector(x,y,z);
}
inline G4ThreeVector GetPMTPos(){return pos;}
private:
G4int pmtNumber;
G4int photons;
G4ThreeVector pos;
G4VPhysicalVolume* physVol;
G4bool drawit;
};
typedef G4THitsCollection<LXePMTHit> LXePMTHitsCollection;
extern G4Allocator<LXePMTHit> LXePMTHitAllocator;
inline void* LXePMTHit::operator new(size_t){
void *aHit;
aHit = (void *) LXePMTHitAllocator.MallocSingle();
return aHit;
}
inline void LXePMTHit::operator delete(void *aHit){
LXePMTHitAllocator.FreeSingle((LXePMTHit*) aHit);
}
#endif
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXePMTSD_h
#define LXePMTSD_h 1
#include "G4DataVector.hh"
#include "G4VSensitiveDetector.hh"
#include "LXePMTHit.hh"
class G4Step;
class G4HCofThisEvent;
class LXePMTSD : public G4VSensitiveDetector
{
public:
LXePMTSD(G4String name);
~LXePMTSD();
void Initialize(G4HCofThisEvent* HCE);
G4bool ProcessHits(G4Step* aStep, G4TouchableHistory* ROhist);
//A version of processHits that keeps aStep constant
G4bool ProcessHits_constStep(const G4Step* aStep,
G4TouchableHistory* ROhist);
void EndOfEvent(G4HCofThisEvent* HCE);
void clear();
void DrawAll();
void PrintAll();
//Initialize the arrays to store pmt possitions
inline void InitPMTs(G4int nPMTs){
if(pmtPositionsX)delete pmtPositionsX;
if(pmtPositionsY)delete pmtPositionsY;
if(pmtPositionsZ)delete pmtPositionsZ;
pmtPositionsX=new G4DataVector(nPMTs);
pmtPositionsY=new G4DataVector(nPMTs);
pmtPositionsZ=new G4DataVector(nPMTs);
}
//Store a pmt position
inline void SetPMTPos(G4int n,G4double x,G4double y,G4double z){
if(pmtPositionsX)pmtPositionsX->insertAt(n,x);
if(pmtPositionsY)pmtPositionsY->insertAt(n,y);
if(pmtPositionsZ)pmtPositionsZ->insertAt(n,z);
}
private:
LXePMTHitsCollection* pmtHitCollection;
G4DataVector* pmtPositionsX;
G4DataVector* pmtPositionsY;
G4DataVector* pmtPositionsZ;
};
#endif
@@ -0,0 +1,47 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXePhysicsList_h
#define LXePhysicsList_h 1
#include "G4VModularPhysicsList.hh"
#include "globals.hh"
class LXePhysicsList: public G4VModularPhysicsList
{
public:
LXePhysicsList();
virtual ~LXePhysicsList();
public:
// SetCuts()
virtual void SetCuts();
};
#endif
@@ -0,0 +1,48 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXePrimaryGeneratorAction_h
#define LXePrimaryGeneratorAction_h 1
#include "G4GeneralParticleSource.hh"
#include "G4VUserPrimaryGeneratorAction.hh"
class G4ParticleGun;
class G4Event;
class LXePrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction
{
public:
LXePrimaryGeneratorAction();
~LXePrimaryGeneratorAction();
public:
void GeneratePrimaries(G4Event* anEvent);
private:
G4ParticleGun* particleGun;
};
#endif
@@ -0,0 +1,43 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4UserRunAction.hh"
#ifndef LXeRunAction_h
#define LXeRunAction_h 1
class RecorderBase;
class LXeRunAction : public G4UserRunAction
{
public:
LXeRunAction(RecorderBase*);
~LXeRunAction();
void BeginOfRunAction(const G4Run*);
void EndOfRunAction(const G4Run*);
private:
RecorderBase* recorder;
};
#endif
@@ -0,0 +1,87 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeScintHit_h
#define LXeScintHit_h 1
#include "G4VHit.hh"
#include "G4THitsCollection.hh"
#include "G4Allocator.hh"
#include "G4ThreeVector.hh"
#include "G4LogicalVolume.hh"
#include "G4Transform3D.hh"
#include "G4RotationMatrix.hh"
#include "G4VPhysicalVolume.hh"
class LXeScintHit : public G4VHit
{
public:
LXeScintHit();
LXeScintHit(G4VPhysicalVolume* pVol);
~LXeScintHit();
LXeScintHit(const LXeScintHit &right);
const LXeScintHit& operator=(const LXeScintHit &right);
G4int operator==(const LXeScintHit &right) const;
inline void *operator new(size_t);
inline void operator delete(void *aHit);
void Draw();
void Print();
inline void SetEdep(G4double de) { edep = de; }
inline void AddEdep(G4double de) { edep += de; }
inline G4double GetEdep() { return edep; }
inline void SetPos(G4ThreeVector xyz) { pos = xyz; }
inline G4ThreeVector GetPos() { return pos; }
inline const G4VPhysicalVolume * GetPhysV() { return physVol; }
private:
G4double edep;
G4ThreeVector pos;
const G4VPhysicalVolume* physVol;
};
typedef G4THitsCollection<LXeScintHit> LXeScintHitsCollection;
extern G4Allocator<LXeScintHit> LXeScintHitAllocator;
inline void* LXeScintHit::operator new(size_t)
{
void *aHit;
aHit = (void *) LXeScintHitAllocator.MallocSingle();
return aHit;
}
inline void LXeScintHit::operator delete(void *aHit)
{
LXeScintHitAllocator.FreeSingle((LXeScintHit*) aHit);
}
#endif
@@ -0,0 +1,52 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeScintSD_h
#define LXeScintSD_h 1
#include "LXeScintHit.hh"
#include "G4VSensitiveDetector.hh"
class G4Step;
class G4HCofThisEvent;
class LXeScintSD : public G4VSensitiveDetector
{
public:
LXeScintSD(G4String name);
~LXeScintSD();
void Initialize(G4HCofThisEvent* HCE);
G4bool ProcessHits(G4Step* aStep, G4TouchableHistory* ROhist);
void EndOfEvent(G4HCofThisEvent* HCE);
void clear();
void DrawAll();
void PrintAll();
private:
LXeScintHitsCollection* scintCollection;
};
#endif
@@ -0,0 +1,42 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeStackingAction_H
#define LXeStackingAction_H 1
#include "globals.hh"
#include "G4UserStackingAction.hh"
class LXeStackingAction : public G4UserStackingAction
{
public:
LXeStackingAction();
~LXeStackingAction();
virtual G4ClassificationOfNewTrack ClassifyNewTrack(const G4Track* aTrack);
virtual void NewStage();
virtual void PrepareNewEvent();
private:
};
#endif
@@ -0,0 +1,50 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeSteppingAction_H
#define LXeSteppingACtion_H 1
#include "globals.hh"
#include "G4UserSteppingAction.hh"
class RecorderBase;
class LXeEventAction;
class LXeTrackingAction;
class LXeSteppingMessenger;
class LXeSteppingAction : public G4UserSteppingAction
{
public:
LXeSteppingAction(RecorderBase*);
~LXeSteppingAction();
virtual void UserSteppingAction(const G4Step*);
void SetOneStepPrimaries(G4bool b){oneStepPrimaries=b;}
G4bool GetOneStepPrimaries(){return oneStepPrimaries;}
private:
RecorderBase* recorder;
G4bool oneStepPrimaries;
LXeSteppingMessenger* steppingMessenger;
};
#endif
@@ -0,0 +1,48 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeSteppingMessenger_h
#define LXeSteppingMessenger_h 1
#include "G4UImessenger.hh"
#include "globals.hh"
class LXeSteppingAction;
class G4UIcmdWithABool;
class LXeSteppingMessenger: public G4UImessenger
{
public:
LXeSteppingMessenger(LXeSteppingAction*);
~LXeSteppingMessenger();
void SetNewValue(G4UIcommand*, G4String);
private:
LXeSteppingAction* stepping;
G4UIcmdWithABool* oneStepPrimariesCmd;
};
#endif
@@ -0,0 +1,46 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
class LXeSteppingVerbose;
#ifndef LXeSteppingVerbose_h
#define LXeSteppingVerbose_h 1
#include "G4SteppingVerbose.hh"
class LXeSteppingVerbose : public G4SteppingVerbose
{
public:
LXeSteppingVerbose();
~LXeSteppingVerbose();
void StepInfo();
void TrackingStarted();
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
@@ -0,0 +1,46 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeTrackingAction_h
#define LXeTrackingAction_h 1
#include "G4UserTrackingAction.hh"
#include "globals.hh"
class RecorderBase;
class LXeTrackingAction : public G4UserTrackingAction {
public:
LXeTrackingAction(RecorderBase*);
~LXeTrackingAction() {};
void PreUserTrackingAction(const G4Track*);
void PostUserTrackingAction(const G4Track*);
private:
RecorderBase* recorder;
};
#endif
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeTrajectory_h
#define LXeTrajectory_h 1
#include "G4Trajectory.hh"
#include "G4Allocator.hh"
#include "G4ios.hh"
#include "globals.hh"
#include "G4ParticleDefinition.hh"
#include "G4TrajectoryPoint.hh"
#include "G4Track.hh"
#include "G4Step.hh"
class G4Polyline; // Forward declaration.
class LXeTrajectory : public G4Trajectory
{
public:
LXeTrajectory();
LXeTrajectory(const G4Track* aTrack);
LXeTrajectory(LXeTrajectory &);
virtual ~LXeTrajectory();
virtual void DrawTrajectory(G4int i_mode=0) const;
inline void* operator new(size_t);
inline void operator delete(void*);
void SetDrawTrajectory(G4bool b){drawit=b;}
void WLS(){wls=true;}
void SetForceDrawTrajectory(G4bool b){forceDraw=b;}
void SetForceNoDrawTrajectory(G4bool b){forceNoDraw=b;}
private:
G4bool wls;
G4bool drawit;
G4bool forceNoDraw;
G4bool forceDraw;
G4ParticleDefinition* particleDefinition;
};
extern G4Allocator<LXeTrajectory> LXeTrajectoryAllocator;
inline void* LXeTrajectory::operator new(size_t)
{
void* aTrajectory;
aTrajectory = (void*)LXeTrajectoryAllocator.MallocSingle();
return aTrajectory;
}
inline void LXeTrajectory::operator delete(void* aTrajectory)
{
LXeTrajectoryAllocator.FreeSingle((LXeTrajectory*)aTrajectory);
}
#endif
@@ -0,0 +1,98 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4VUserEventInformation.hh"
#include "G4ThreeVector.hh"
#include "globals.hh"
#ifndef LXeUserEventInformation_h
#define LXeUserEventInformation_h 1
class LXeUserEventInformation : public G4VUserEventInformation
{
public:
LXeUserEventInformation();
~LXeUserEventInformation();
inline void Print()const{};
void IncPhotonCount_Scint(){photonCount_Scint++;}
void IncPhotonCount_Ceren(){photonCount_Ceren++;}
void IncEDep(G4double dep){totE+=dep;}
void IncAbsorption(){absorptionCount++;}
void IncBoundaryAbsorption(){boundaryAbsorptionCount++;}
void IncHitCount(G4int i=1){hitCount+=i;}
void SetEWeightPos(const G4ThreeVector& p){eWeightPos=p;}
void SetReconPos(const G4ThreeVector& p){reconPos=p;}
void SetConvPos(const G4ThreeVector& p){convPos=p;convPosSet=true;}
void SetPosMax(const G4ThreeVector& p,G4double edep){posMax=p;edepMax=edep;}
G4int GetPhotonCount_Scint()const {return photonCount_Scint;}
G4int GetPhotonCount_Ceren()const {return photonCount_Ceren;}
G4int GetHitCount()const {return hitCount;}
G4double GetEDep()const {return totE;}
G4int GetAbsorptionCount()const {return absorptionCount;}
G4int GetBoundaryAbsorptionCount() const {return boundaryAbsorptionCount;}
G4ThreeVector GetEWeightPos(){return eWeightPos;}
G4ThreeVector GetReconPos(){return reconPos;}
G4ThreeVector GetConvPos(){return convPos;}
G4ThreeVector GetPosMax(){return posMax;}
G4double GetEDepMax(){return edepMax;}
G4double IsConvPosSet(){return convPosSet;}
//Gets the total photon count produced
G4int GetPhotonCount(){return photonCount_Scint+photonCount_Ceren;}
void IncPMTSAboveThreshold(){pmtsAboveThreshold++;}
G4int GetPMTSAboveThreshold(){return pmtsAboveThreshold;}
private:
G4int hitCount;
G4int photonCount_Scint;
G4int photonCount_Ceren;
G4int absorptionCount;
G4int boundaryAbsorptionCount;
G4double totE;
//These only have meaning if totE > 0
//If totE = 0 then these wont be set by EndOfEventAction
G4ThreeVector eWeightPos;
G4ThreeVector reconPos; //Also relies on hitCount>0
G4ThreeVector convPos;//true (initial) converstion position
G4bool convPosSet;
G4ThreeVector posMax;
G4double edepMax;
G4int pmtsAboveThreshold;
};
#endif
@@ -0,0 +1,70 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4VUserTrackInformation.hh"
#include "globals.hh"
#ifndef LXeUserTrackInformation_h
#define LXeUserTrackInformation_h 1
enum LXeTrackStatus { active=1, hitPMT=2, absorbed=4, boundaryAbsorbed=8,
hitSphere=16, inactive=14};
/*LXeTrackStatus:
active: still being tracked
hitPMT: stopped by being detected in a PMT
absorbed: stopped by being absorbed with G4OpAbsorbtion
boundaryAbsorbed: stopped by being aborbed with G4OpAbsorbtion
hitSphere: track hit the sphere at some point
inactive: track is stopped for some reason
-This is the sum of all stopped flags so can be used to remove stopped flags
*/
class LXeUserTrackInformation : public G4VUserTrackInformation
{
public:
LXeUserTrackInformation();
~LXeUserTrackInformation();
//Sets the track status to s (does not check validity of flags)
void SetTrackStatusFlags(int s){status=s;}
//Does a smart add of track status flags (disabling old flags that conflict)
//If s conflicts with itself it will not be detected
void AddTrackStatusFlag(int s);
int GetTrackStatus()const {return status;}
void IncReflections(){reflections++;}
G4int GetReflectionCount()const {return reflections;}
void SetForceDrawTrajectory(G4bool b){forcedraw=b;}
G4bool GetForceDrawTrajectory(){return forcedraw;}
inline void Print()const{};
private:
int status;
G4int reflections;
G4bool forcedraw;
};
#endif
@@ -0,0 +1,44 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeVisManager_h
#define LXeVisManager_h 1
#ifdef G4VIS_USE
#include "G4VisManager.hh"
class LXeVisManager: public G4VisManager
{
public:
LXeVisManager ();
private:
void RegisterGraphicsSystems ();
};
#endif
#endif
@@ -0,0 +1,74 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeMainVolume_H
#define LXeMainVolume_H 1
#include "G4PVPlacement.hh"
#include "G4Box.hh"
#include "G4Tubs.hh"
#include "G4Sphere.hh"
#include "G4Material.hh"
#include "G4LogicalVolume.hh"
#include "G4OpticalSurface.hh"
#include "LXeDetectorConstruction.hh"
class LXeWLSFiber : public G4PVPlacement
{
public:
LXeWLSFiber(G4RotationMatrix *pRot,
const G4ThreeVector &tlate,
G4LogicalVolume *pMotherLogical,
G4bool pMany,
G4int pCopyNo,
LXeDetectorConstruction* c);
private:
void CopyValues();
static G4LogicalVolume* clad2_log;
G4bool updated; //does the fiber need to be rebuilt
G4double fiber_rmin;
G4double fiber_rmax;
G4double fiber_z;
G4double fiber_sphi;
G4double fiber_ephi;
G4double clad1_rmin;
G4double clad1_rmax;
G4double clad1_z;
G4double clad1_sphi;
G4double clad1_ephi;
G4double clad2_rmin;
G4double clad2_rmax;
G4double clad2_z;
G4double clad2_sphi;
G4double clad2_ephi;
LXeDetectorConstruction* constructor;
};
#endif
@@ -0,0 +1,60 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#ifndef LXeWLSSlab_H
#define LXeWLSSlab_H 1
#include "G4PVPlacement.hh"
#include "G4Box.hh"
#include "G4Tubs.hh"
#include "G4Material.hh"
#include "G4LogicalVolume.hh"
#include "G4OpticalSurface.hh"
#include "LXeDetectorConstruction.hh"
class LXeWLSSlab : public G4PVPlacement
{
public:
LXeWLSSlab(G4RotationMatrix *pRot,
const G4ThreeVector &tlate,
G4LogicalVolume *pMotherLogical,
G4bool pMany,
G4int pCopyNo,
LXeDetectorConstruction* c);
private:
void CopyValues();
LXeDetectorConstruction* constructor;
G4bool updated;
static G4LogicalVolume* ScintSlab_log;
G4int nfibers;
G4double scint_x;
G4double scint_y;
G4double scint_z;
G4double slab_z;
};
#endif
@@ -0,0 +1,87 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// RecorderBase.hh
// 1-Sep-1999 Bill Seligman
// This is an abstract base class to be used with Geant 4.0.1 (and
// possibly higher, if the User classes don't change).
// The concept of a Recorder object is that it records the activities of
// Geant in a manner that is useful to a physicist. Perhaps this record
// takes the form of histograms, or ntuples, or entries in an Objectivity
// database. This class does not care HOW the information is recorded; it
// abstracts the behavior of a generalized recorder of Geant variables.
// No object should be instantiated from the Recorder class (in fact, any such
// object won't do anything). The user must define a new class (say, a class
// that creates histograms) and overload the methods of this class.
// Why do this? First of all, it keeps all record-keeping in a single class:
// the class that inherits Recorder. The original Geant documentation suggests
// that recording activities should be split among many different classes
// (initialization in G4UserRunAction, recording in G4UserSteppingAction, etc.).
// If you use a Recorder class, than all the record-keeping details are kept in
// a single class instead of being spread out among many different classes.
// Secondly, by using an abstract Recorder class, you hide the implementation
// details from the rest of Geant. If you change a couple of histograms, only
// the Recorder-derived class and main() re-compile. No other class knows or
// cares what or how you record.
// The only time this class (i.e., this header file) changes is if new
// user action classes are added to Geant.
#ifndef RECORDER_BASE_H_
#define RECORDER_BASE_H_
// The following objects are the arguments to the methods
// invoked in the user action classes. In other words, they
// contain the variables that we are normally able to record
// in Geant.
#include "G4Run.hh"
#include "G4Event.hh"
#include "G4Track.hh"
#include "G4Step.hh"
class RecorderBase {
public:
virtual ~RecorderBase() {};
// The following a list of methods that correspond to the available
// user action classes in Geant 4.0.1. In this base class, the
// methods are defined to do nothing.
virtual void RecordBeginOfRun(const G4Run*) = 0;
virtual void RecordEndOfRun(const G4Run*) = 0;
virtual void RecordBeginOfEvent(const G4Event*) {};
virtual void RecordEndOfEvent(const G4Event*) {};
virtual void RecordTrack(const G4Track*) {};
virtual void RecordStep(const G4Step*) {};
};
#endif