#include <Doxymodules_optical.h>

Inheritance diagram for LXeDetectorConstruction:

Public Member Functions
	LXeDetectorConstruction ()

	~LXeDetectorConstruction () override

G4VPhysicalVolume *	Construct () override

void	ConstructSDandField () override

void	SetDimensions (G4ThreeVector)

void	SetHousingThickness (G4double)

void	SetNX (G4int)

void	SetNY (G4int)

void	SetNZ (G4int)

void	SetPMTRadius (G4double)

void	SetDefaults ()

void	SetSaveThreshold (G4int)

G4int	GetNX () const

G4int	GetNY () const

G4int	GetNZ () const

G4int	GetSaveThreshold () const

G4double	GetScintX () const

G4double	GetScintY () const

G4double	GetScintZ () const

G4double	GetHousingThickness () const

G4double	GetPMTRadius () const

G4double	GetSlabZ () const

void	SetSphereOn (G4bool)

void	SetHousingReflectivity (G4double)

G4double	GetHousingReflectivity () const

void	SetWLSSlabOn (G4bool b)

G4bool	GetWLSSlabOn () const

void	SetMainVolumeOn (G4bool b)

G4bool	GetMainVolumeOn () const

void	SetNFibers (G4int n)

G4int	GetNFibers () const

void	SetMainScintYield (G4double)

void	SetWLSScintYield (G4double)

Static Public Member Functions
static G4bool	GetSphereOn ()

Private Member Functions
void	DefineMaterials ()

Private Attributes
LXeDetectorMessenger *	fDetectorMessenger = nullptr

G4Box *	fExperimentalHall_box = nullptr

G4LogicalVolume *	fExperimentalHall_log = nullptr

G4VPhysicalVolume *	fExperimentalHall_phys = nullptr

G4Element *	fN = nullptr

G4Element *	fO = nullptr

G4Element *	fC = nullptr

G4Element *	fH = nullptr

G4Material *	fLXe = nullptr

G4Material *	fAl = nullptr

G4Material *	fAir = nullptr

G4Material *	fVacuum = nullptr

G4Material *	fGlass = nullptr

G4Material *	fPstyrene = nullptr

G4Material *	fPMMA = nullptr

G4Material *	fPethylene1 = nullptr

G4Material *	fPethylene2 = nullptr

G4double	fScint_x = 17.8 * CLHEP::cm

G4double	fScint_y = 17.8 * CLHEP::cm

G4double	fScint_z = 22.6 * CLHEP::cm

G4double	fD_mtl = 0.0635 * CLHEP::cm

G4int	fNx = 2

G4int	fNy = 2

G4int	fNz = 3

G4int	fSaveThreshold = 0

G4double	fOuterRadius_pmt = 2.3 * CLHEP::cm

G4int	fNfibers = 15

G4double	fRefl = 1.

G4bool	fWLSslab = false

G4bool	fMainVolumeOn = true

G4double	fSlab_z = 2.5 * CLHEP::mm

LXeMainVolume *	fMainVolume = nullptr

G4MaterialPropertiesTable *	fLXe_mt = nullptr

G4MaterialPropertiesTable *	fMPTPStyrene = nullptr

G4Cache< LXeScintSD * >	fScint_SD

G4Cache< LXePMTSD * >	fPmt_SD

Static Private Attributes
static G4bool	fSphereOn = true

Detailed Description

Definition at line 48 of file Doxymodules_optical.h.

Constructor & Destructor Documentation

◆ LXeDetectorConstruction()

LXeDetectorConstruction::LXeDetectorConstruction ( )

Definition at line 66 of file LXeDetectorConstruction.cc.

{
  SetDefaults();
  DefineMaterials();
  fDetectorMessenger = new LXeDetectorMessenger(this);
}

◆ ~LXeDetectorConstruction()

LXeDetectorConstruction::~LXeDetectorConstruction ( )

override

Definition at line 75 of file LXeDetectorConstruction.cc.

{
  delete fMainVolume;
  delete fLXe_mt;
  delete fDetectorMessenger;
  delete fMPTPStyrene;
}

Member Function Documentation

◆ Construct()

G4VPhysicalVolume * LXeDetectorConstruction::Construct ( )

override

Definition at line 218 of file LXeDetectorConstruction.cc.

{
  // The experimental hall walls are all 1m away from housing walls
  G4double expHall_x = fScint_x + fD_mtl + 1. * m;
  G4double expHall_y = fScint_y + fD_mtl + 1. * m;
  G4double expHall_z = fScint_z + fD_mtl + 1. * m;
 
  // Create experimental hall
  fExperimentalHall_box =
    new G4Box("expHall_box", expHall_x, expHall_y, expHall_z);
  fExperimentalHall_log =
    new G4LogicalVolume(fExperimentalHall_box, fVacuum, "expHall_log");
  fExperimentalHall_phys = new G4PVPlacement(nullptr,
      G4ThreeVector(), fExperimentalHall_log, "expHall", nullptr, false, 0);
 
  fExperimentalHall_log->SetVisAttributes(G4VisAttributes::GetInvisible());
 
  // Place the main volume
  if(fMainVolumeOn)
  {
    fMainVolume = new LXeMainVolume(nullptr, G4ThreeVector(),
                                    fExperimentalHall_log, false, 0, this);
  }
 
  // Place the WLS slab
  if(fWLSslab)
  {
    G4VPhysicalVolume* slab = new LXeWLSSlab(
      nullptr, G4ThreeVector(0., 0., -fScint_z / 2. - fSlab_z - 1. * cm),
      fExperimentalHall_log, false, 0, this);
 
    // Surface properties for the WLS slab
    auto scintWrap = new G4OpticalSurface("ScintWrap");
 
    new G4LogicalBorderSurface("ScintWrap", slab, fExperimentalHall_phys,
                               scintWrap);
 
    scintWrap->SetType(dielectric_metal);
    scintWrap->SetFinish(polished);
    scintWrap->SetModel(glisur);
 
    std::vector<G4double> pp           = { 2.0 * eV, 3.5 * eV };
    std::vector<G4double> reflectivity = { 1.0, 1.0 };
    std::vector<G4double> efficiency   = { 0.0, 0.0 };
 
    auto scintWrapProperty = new G4MaterialPropertiesTable();
 
    scintWrapProperty->AddProperty("REFLECTIVITY", pp, reflectivity);
    scintWrapProperty->AddProperty("EFFICIENCY", pp, efficiency);
    scintWrap->SetMaterialPropertiesTable(scintWrapProperty);
  }
 
  return fExperimentalHall_phys;
}

◆ ConstructSDandField()

void LXeDetectorConstruction::ConstructSDandField ( )

override

Definition at line 275 of file LXeDetectorConstruction.cc.

{
  if(!fMainVolume)
    return;
 
  // PMT SD
 
  LXePMTSD* pmt = fPmt_SD.Get();
  if(!pmt)
  {
    // Created here so it exists as pmts are being placed
    G4cout << "Construction /LXeDet/pmtSD" << G4endl;
    auto pmt_SD = new LXePMTSD("/LXeDet/pmtSD");
    fPmt_SD.Put(pmt_SD);
 
    pmt_SD->InitPMTs();
    pmt_SD->SetPmtPositions(fMainVolume->GetPmtPositions());
  }
  else
  {
    pmt->InitPMTs();
    pmt->SetPmtPositions(fMainVolume->GetPmtPositions());
  }
  G4SDManager::GetSDMpointer()->AddNewDetector(fPmt_SD.Get());
  // sensitive detector is not actually on the photocathode.
  // processHits gets done manually by the stepping action.
  // It is used to detect when photons hit and get absorbed & detected at the
  // boundary to the photocathode (which doesn't get done by attaching it to a
  // logical volume.
  // It does however need to be attached to something or else it doesn't get
  // reset at the begining of events
 
  SetSensitiveDetector(fMainVolume->GetLogPhotoCath(), fPmt_SD.Get());
 
  // Scint SD
 
  if(!fScint_SD.Get())
  {
    G4cout << "Construction /LXeDet/scintSD" << G4endl;
    auto scint_SD = new LXeScintSD("/LXeDet/scintSD");
    fScint_SD.Put(scint_SD);
  }
  G4SDManager::GetSDMpointer()->AddNewDetector(fScint_SD.Get());
  SetSensitiveDetector(fMainVolume->GetLogScint(), fScint_SD.Get());
}

◆ SetDimensions()

void LXeDetectorConstruction::SetDimensions ( G4ThreeVector dims )

Definition at line 323 of file LXeDetectorConstruction.cc.

{
  fScint_x = dims[0];
  fScint_y = dims[1];
  fScint_z = dims[2];
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ SetHousingThickness()

void LXeDetectorConstruction::SetHousingThickness ( G4double d_mtl )

Definition at line 333 of file LXeDetectorConstruction.cc.

{
  fD_mtl = d_mtl;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ SetNX()

void LXeDetectorConstruction::SetNX ( G4int nx )

Definition at line 341 of file LXeDetectorConstruction.cc.

{
  fNx = nx;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ SetNY()

void LXeDetectorConstruction::SetNY ( G4int ny )

Definition at line 349 of file LXeDetectorConstruction.cc.

{
  fNy = ny;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ SetNZ()

void LXeDetectorConstruction::SetNZ ( G4int nz )

Definition at line 357 of file LXeDetectorConstruction.cc.

{
  fNz = nz;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ SetPMTRadius()

void LXeDetectorConstruction::SetPMTRadius ( G4double outerRadius_pmt )

Definition at line 365 of file LXeDetectorConstruction.cc.

{
  fOuterRadius_pmt = outerRadius_pmt;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ SetDefaults()

void LXeDetectorConstruction::SetDefaults ( )

Definition at line 373 of file LXeDetectorConstruction.cc.

{
  // Resets to default values
  fD_mtl = 0.0635 * cm;
 
  fScint_x = 17.8 * cm;
  fScint_y = 17.8 * cm;
  fScint_z = 22.6 * cm;
 
  fNx = 2;
  fNy = 2;
  fNz = 3;
 
  fOuterRadius_pmt = 2.3 * cm;
 
  fSphereOn = true;
  fRefl     = 1.0;
 
  fNfibers      = 15;
  fWLSslab      = false;
  fMainVolumeOn = true;
  fMainVolume   = nullptr;
  fSlab_z       = 2.5 * mm;
 
  G4UImanager::GetUIpointer()->ApplyCommand(
    "/LXe/detector/scintYieldFactor 1.");
 
  if(fLXe_mt)
    fLXe_mt->AddConstProperty("SCINTILLATIONYIELD", 12000. / MeV);
  if(fMPTPStyrene)
    fMPTPStyrene->AddConstProperty("SCINTILLATIONYIELD", 10. / keV);
}

◆ SetSaveThreshold()

void LXeDetectorConstruction::SetSaveThreshold ( G4int save )

Definition at line 462 of file LXeDetectorConstruction.cc.

{
  // Sets the save threshold for the random number seed. If the number of
  // photons generated in an event is lower than this, then save the seed for
  // this event in a file called run###evt###.rndm
 
  fSaveThreshold = save;
  G4RunManager::GetRunManager()->SetRandomNumberStore(true);
}

◆ GetNX()

G4int LXeDetectorConstruction::GetNX ( ) const

inline

Definition at line 73 of file LXeDetectorConstruction.hh.

73{ return fNx; };

◆ GetNY()

G4int LXeDetectorConstruction::GetNY ( ) const

inline

Definition at line 74 of file LXeDetectorConstruction.hh.

74{ return fNy; };

◆ GetNZ()

G4int LXeDetectorConstruction::GetNZ ( ) const

inline

Definition at line 75 of file LXeDetectorConstruction.hh.

75{ return fNz; };

◆ GetSaveThreshold()

G4int LXeDetectorConstruction::GetSaveThreshold ( ) const

inline

Definition at line 76 of file LXeDetectorConstruction.hh.

76{ return fSaveThreshold; };

◆ GetScintX()

G4double LXeDetectorConstruction::GetScintX ( ) const

inline

Definition at line 77 of file LXeDetectorConstruction.hh.

77{ return fScint_x; }

◆ GetScintY()

G4double LXeDetectorConstruction::GetScintY ( ) const

inline

Definition at line 78 of file LXeDetectorConstruction.hh.

78{ return fScint_y; }

◆ GetScintZ()

G4double LXeDetectorConstruction::GetScintZ ( ) const

inline

Definition at line 79 of file LXeDetectorConstruction.hh.

79{ return fScint_z; }

◆ GetHousingThickness()

G4double LXeDetectorConstruction::GetHousingThickness ( ) const

inline

Definition at line 80 of file LXeDetectorConstruction.hh.

80{ return fD_mtl; }

◆ GetPMTRadius()

G4double LXeDetectorConstruction::GetPMTRadius ( ) const

inline

Definition at line 81 of file LXeDetectorConstruction.hh.

81{ return fOuterRadius_pmt; }

◆ GetSlabZ()

G4double LXeDetectorConstruction::GetSlabZ ( ) const

inline

Definition at line 82 of file LXeDetectorConstruction.hh.

82{ return fSlab_z; }

◆ SetSphereOn()

void LXeDetectorConstruction::SetSphereOn ( G4bool b )

Definition at line 408 of file LXeDetectorConstruction.cc.

{
  fSphereOn = b;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ GetSphereOn()

static G4bool LXeDetectorConstruction::GetSphereOn ( )

inlinestatic

Definition at line 85 of file LXeDetectorConstruction.hh.

85{ return fSphereOn; }

◆ SetHousingReflectivity()

void LXeDetectorConstruction::SetHousingReflectivity ( G4double r )

Definition at line 416 of file LXeDetectorConstruction.cc.

{
  fRefl = r;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ GetHousingReflectivity()

G4double LXeDetectorConstruction::GetHousingReflectivity ( ) const

inline

Definition at line 88 of file LXeDetectorConstruction.hh.

88{ return fRefl; }

◆ SetWLSSlabOn()

void LXeDetectorConstruction::SetWLSSlabOn ( G4bool b )

Definition at line 424 of file LXeDetectorConstruction.cc.

{
  fWLSslab = b;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ GetWLSSlabOn()

G4bool LXeDetectorConstruction::GetWLSSlabOn ( ) const

inline

Definition at line 91 of file LXeDetectorConstruction.hh.

91{ return fWLSslab; }

◆ SetMainVolumeOn()

void LXeDetectorConstruction::SetMainVolumeOn ( G4bool b )

Definition at line 432 of file LXeDetectorConstruction.cc.

{
  fMainVolumeOn = b;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ GetMainVolumeOn()

G4bool LXeDetectorConstruction::GetMainVolumeOn ( ) const

inline

Definition at line 94 of file LXeDetectorConstruction.hh.

94{ return fMainVolumeOn; }

◆ SetNFibers()

void LXeDetectorConstruction::SetNFibers ( G4int n )

Definition at line 440 of file LXeDetectorConstruction.cc.

{
  fNfibers = n;
  G4RunManager::GetRunManager()->ReinitializeGeometry();
}

◆ GetNFibers()

G4int LXeDetectorConstruction::GetNFibers ( ) const

inline

Definition at line 97 of file LXeDetectorConstruction.hh.

97{ return fNfibers; }

◆ SetMainScintYield()

void LXeDetectorConstruction::SetMainScintYield ( G4double y )

Definition at line 448 of file LXeDetectorConstruction.cc.

{
  fLXe_mt->AddConstProperty("SCINTILLATIONYIELD", y / MeV);
}

◆ SetWLSScintYield()

void LXeDetectorConstruction::SetWLSScintYield ( G4double y )

Definition at line 455 of file LXeDetectorConstruction.cc.

{
  fMPTPStyrene->AddConstProperty("SCINTILLATIONYIELD", y / MeV);
}

◆ DefineMaterials()

void LXeDetectorConstruction::DefineMaterials ( )

private

Definition at line 85 of file LXeDetectorConstruction.cc.

{
  G4double a;  // atomic mass
  G4double z;  // atomic number
  G4double density;
 
  G4int polyPMMA = 1;
  G4int nC_PMMA  = 3 + 2 * polyPMMA;
  G4int nH_PMMA  = 6 + 2 * polyPMMA;
 
  G4int polyeth = 1;
  G4int nC_eth  = 2 * polyeth;
  G4int nH_eth  = 4 * polyeth;
 
  //***Elements
  fH = new G4Element("H", "H", z = 1., a = 1.01 * g / mole);
  fC = new G4Element("C", "C", z = 6., a = 12.01 * g / mole);
  fN = new G4Element("N", "N", z = 7., a = 14.01 * g / mole);
  fO = new G4Element("O", "O", z = 8., a = 16.00 * g / mole);
 
  //***Materials
  // Liquid Xenon
  fLXe = new G4Material("LXe", z = 54., a = 131.29 * g / mole,
                        density = 3.020 * g / cm3);
  // Aluminum
  fAl = new G4Material("Al", z = 13., a = 26.98 * g / mole,
                       density = 2.7 * g / cm3);
  // Vacuum
  fVacuum = new G4Material("Vacuum", z = 1., a = 1.01 * g / mole,
                           density = universe_mean_density, kStateGas,
                           0.1 * kelvin, 1.e-19 * pascal);
  // Air
  fAir = new G4Material("Air", density = 1.29 * mg / cm3, 2);
  fAir->AddElement(fN, 70 * perCent);
  fAir->AddElement(fO, 30 * perCent);
  // Glass
  fGlass = new G4Material("Glass", density = 1.032 * g / cm3, 2);
  fGlass->AddElement(fC, 91.533 * perCent);
  fGlass->AddElement(fH, 8.467 * perCent);
  // Polystyrene
  fPstyrene = new G4Material("Polystyrene", density = 1.03 * g / cm3, 2);
  fPstyrene->AddElement(fC, 8);
  fPstyrene->AddElement(fH, 8);
  // Fiber(PMMA)
  fPMMA = new G4Material("PMMA", density = 1190. * kg / m3, 3);
  fPMMA->AddElement(fH, nH_PMMA);
  fPMMA->AddElement(fC, nC_PMMA);
  fPMMA->AddElement(fO, 2);
  // Cladding(polyethylene)
  fPethylene1 = new G4Material("Pethylene1", density = 1200. * kg / m3, 2);
  fPethylene1->AddElement(fH, nH_eth);
  fPethylene1->AddElement(fC, nC_eth);
  // Double cladding(flourinated polyethylene)
  fPethylene2 = new G4Material("Pethylene2", density = 1400. * kg / m3, 2);
  fPethylene2->AddElement(fH, nH_eth);
  fPethylene2->AddElement(fC, nC_eth);
 
  //***Material properties tables
 
  std::vector<G4double> lxe_Energy = { 7.0 * eV, 7.07 * eV, 7.14 * eV };
 
  std::vector<G4double> lxe_SCINT = { 0.1, 1.0, 0.1 };
  std::vector<G4double> lxe_RIND  = { 1.59, 1.57, 1.54 };
  std::vector<G4double> lxe_ABSL  = { 35. * cm, 35. * cm, 35. * cm };
  fLXe_mt = new G4MaterialPropertiesTable();
  fLXe_mt->AddProperty("SCINTILLATIONCOMPONENT1", lxe_Energy, lxe_SCINT);
  fLXe_mt->AddProperty("SCINTILLATIONCOMPONENT2", lxe_Energy, lxe_SCINT);
  fLXe_mt->AddProperty("RINDEX", lxe_Energy, lxe_RIND);
  fLXe_mt->AddProperty("ABSLENGTH", lxe_Energy, lxe_ABSL);
  fLXe_mt->AddConstProperty("SCINTILLATIONYIELD", 12000. / MeV);
  fLXe_mt->AddConstProperty("RESOLUTIONSCALE", 1.0);
  fLXe_mt->AddConstProperty("SCINTILLATIONTIMECONSTANT1", 20. * ns);
  fLXe_mt->AddConstProperty("SCINTILLATIONTIMECONSTANT2", 45. * ns);
  fLXe_mt->AddConstProperty("SCINTILLATIONYIELD1", 1.0);
  fLXe_mt->AddConstProperty("SCINTILLATIONYIELD2", 0.0);
  fLXe->SetMaterialPropertiesTable(fLXe_mt);
 
  // Set the Birks Constant for the LXe scintillator
  fLXe->GetIonisation()->SetBirksConstant(0.126 * mm / MeV);
 
  std::vector<G4double> glass_AbsLength = { 420. * cm, 420. * cm, 420. * cm };
  auto glass_mt = new G4MaterialPropertiesTable();
  glass_mt->AddProperty("ABSLENGTH", lxe_Energy, glass_AbsLength);
  glass_mt->AddProperty("RINDEX", "Fused Silica");
  fGlass->SetMaterialPropertiesTable(glass_mt);
 
  auto vacuum_mt = new G4MaterialPropertiesTable();
  vacuum_mt->AddProperty("RINDEX", "Air");
  fVacuum->SetMaterialPropertiesTable(vacuum_mt);
  fAir->SetMaterialPropertiesTable(vacuum_mt);  // Give air the same rindex
 
  std::vector<G4double> wls_Energy = { 2.00 * eV, 2.87 * eV, 2.90 * eV,
                                       3.47 * eV };
 
  std::vector<G4double> rIndexPstyrene = { 1.5, 1.5, 1.5, 1.5 };
  std::vector<G4double> absorption1    = { 2. * cm, 2. * cm, 2. * cm, 2. * cm };
  std::vector<G4double> scintilFast    = { 0.0, 0.0, 1.0, 1.0 };
  fMPTPStyrene = new G4MaterialPropertiesTable();
  fMPTPStyrene->AddProperty("RINDEX", wls_Energy, rIndexPstyrene);
  fMPTPStyrene->AddProperty("ABSLENGTH", wls_Energy, absorption1);
  fMPTPStyrene->AddProperty("SCINTILLATIONCOMPONENT1", wls_Energy, scintilFast);
  fMPTPStyrene->AddConstProperty("SCINTILLATIONYIELD", 10. / keV);
  fMPTPStyrene->AddConstProperty("RESOLUTIONSCALE", 1.0);
  fMPTPStyrene->AddConstProperty("SCINTILLATIONTIMECONSTANT1", 10. * ns);
  fPstyrene->SetMaterialPropertiesTable(fMPTPStyrene);
 
  // Set the Birks Constant for the Polystyrene scintillator
  fPstyrene->GetIonisation()->SetBirksConstant(0.126 * mm / MeV);
 
  std::vector<G4double> AbsFiber    = { 9.0 * m, 9.0 * m, 0.1 * mm, 0.1 * mm };
  std::vector<G4double> EmissionFib = { 1.0, 1.0, 0.0, 0.0 };
  auto fiberProperty = new G4MaterialPropertiesTable();
  fiberProperty->AddProperty("RINDEX", "PMMA");
  fiberProperty->AddProperty("WLSABSLENGTH", wls_Energy, AbsFiber);
  fiberProperty->AddProperty("WLSCOMPONENT", wls_Energy, EmissionFib);
  fiberProperty->AddConstProperty("WLSTIMECONSTANT", 0.5 * ns);
  fPMMA->SetMaterialPropertiesTable(fiberProperty);
 
  std::vector<G4double> RefractiveIndexClad1 = { 1.49, 1.49, 1.49, 1.49 };
  auto clad1Property = new G4MaterialPropertiesTable();
  clad1Property->AddProperty("RINDEX", wls_Energy, RefractiveIndexClad1);
  clad1Property->AddProperty("ABSLENGTH", wls_Energy, AbsFiber);
  fPethylene1->SetMaterialPropertiesTable(clad1Property);
 
  std::vector<G4double> RefractiveIndexClad2 = { 1.42, 1.42, 1.42, 1.42 };
  auto clad2Property = new G4MaterialPropertiesTable();
  clad2Property->AddProperty("RINDEX", wls_Energy, RefractiveIndexClad2);
  clad2Property->AddProperty("ABSLENGTH", wls_Energy, AbsFiber);
  fPethylene2->SetMaterialPropertiesTable(clad2Property);
}