~ejungwoo/geant4/OpNoviceDetectorConstruction_8cc_source.html

 //

 // ********************************************************************

 // * License and Disclaimer                                           *

 // *                                                                  *

 // * The  Geant4 software  is  copyright of the Copyright Holders  of *

 // * the Geant4 Collaboration.  It is provided  under  the terms  and *

 // * conditions of the Geant4 Software License,  included in the file *

 // * LICENSE and available at  http://cern.ch/geant4/license .  These *

 // * include a list of copyright holders.                             *

 // *                                                                  *

 // * 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.  Please see the license in the file  LICENSE  and URL above *

 // * for the full disclaimer and the limitation of liability.         *

 // *                                                                  *

 // * This  code  implementation is the result of  the  scientific and *

 // * technical work of the GEANT4 collaboration.                      *

 // * By using,  copying,  modifying or  distributing the software (or *

 // * any work based  on the software)  you  agree  to acknowledge its *

 // * use  in  resulting  scientific  publications,  and indicate your *

 // * acceptance of all terms of the Geant4 Software license.          *

 // ********************************************************************

 //

 //

 //

 //

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


 #include "OpNoviceDetectorConstruction.hh"


 #include "G4Material.hh"

 #include "G4Element.hh"

 #include "G4LogicalBorderSurface.hh"

 #include "G4LogicalSkinSurface.hh"

 #include "G4OpticalSurface.hh"

 #include "G4Box.hh"

 #include "G4LogicalVolume.hh"

 #include "G4ThreeVector.hh"

 #include "G4PVPlacement.hh"

 #include "G4SystemOfUnits.hh"


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


 OpNoviceDetectorConstruction::OpNoviceDetectorConstruction()

  : G4VUserDetectorConstruction()

 {

   fExpHall_x = fExpHall_y = fExpHall_z = 10.0*m;

   fTank_x    = fTank_y    = fTank_z    =  5.0*m;

   fBubble_x  = fBubble_y  = fBubble_z  =  0.5*m;

 }


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


 OpNoviceDetectorConstruction::~OpNoviceDetectorConstruction(){;}


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


 G4VPhysicalVolume* OpNoviceDetectorConstruction::Construct()

 {


 // ------------- Materials -------------


   G4double a, z, density;

   G4int nelements;


 // Air

 //

   G4Element* N = new G4Element("Nitrogen", "N", z=7 , a=14.01*g/mole);

   G4Element* O = new G4Element("Oxygen"  , "O", z=8 , a=16.00*g/mole);


   G4Material* air = new G4Material("Air", density=1.29*mg/cm3, nelements=2);

   air->AddElement(N, 70.*perCent);

   air->AddElement(O, 30.*perCent);


 // Water

 //

   G4Element* H = new G4Element("Hydrogen", "H", z=1 , a=1.01*g/mole);


   G4Material* water = new G4Material("Water", density= 1.0*g/cm3, nelements=2);

   water->AddElement(H, 2);

   water->AddElement(O, 1);


 //

 // ------------ Generate & Add Material Properties Table ------------

 //

   G4double photonEnergy[] =

             { 2.034*eV, 2.068*eV, 2.103*eV, 2.139*eV,

               2.177*eV, 2.216*eV, 2.256*eV, 2.298*eV,

               2.341*eV, 2.386*eV, 2.433*eV, 2.481*eV,

               2.532*eV, 2.585*eV, 2.640*eV, 2.697*eV,

               2.757*eV, 2.820*eV, 2.885*eV, 2.954*eV,

               3.026*eV, 3.102*eV, 3.181*eV, 3.265*eV,

               3.353*eV, 3.446*eV, 3.545*eV, 3.649*eV,

               3.760*eV, 3.877*eV, 4.002*eV, 4.136*eV };


   const G4int nEntries = sizeof(photonEnergy)/sizeof(G4double);


 //

 // Water

 //

   G4double refractiveIndex1[] =

             { 1.3435, 1.344,  1.3445, 1.345,  1.3455,

               1.346,  1.3465, 1.347,  1.3475, 1.348,

               1.3485, 1.3492, 1.35,   1.3505, 1.351,

               1.3518, 1.3522, 1.3530, 1.3535, 1.354,

               1.3545, 1.355,  1.3555, 1.356,  1.3568,

               1.3572, 1.358,  1.3585, 1.359,  1.3595,

               1.36,   1.3608};


   assert(sizeof(refractiveIndex1) == sizeof(photonEnergy));


   G4double absorption[] =

            {3.448*m,  4.082*m,  6.329*m,  9.174*m, 12.346*m, 13.889*m,

            15.152*m, 17.241*m, 18.868*m, 20.000*m, 26.316*m, 35.714*m,

            45.455*m, 47.619*m, 52.632*m, 52.632*m, 55.556*m, 52.632*m,

            52.632*m, 47.619*m, 45.455*m, 41.667*m, 37.037*m, 33.333*m,

            30.000*m, 28.500*m, 27.000*m, 24.500*m, 22.000*m, 19.500*m,

            17.500*m, 14.500*m };


   assert(sizeof(absorption) == sizeof(photonEnergy));


   G4double scintilFast[] =

             { 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00,

               1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00,

               1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00,

               1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00,

               1.00, 1.00, 1.00, 1.00 };


   assert(sizeof(scintilFast) == sizeof(photonEnergy));


   G4double scintilSlow[] =

             { 0.01, 1.00, 2.00, 3.00, 4.00, 5.00, 6.00,

               7.00, 8.00, 9.00, 8.00, 7.00, 6.00, 4.00,

               3.00, 2.00, 1.00, 0.01, 1.00, 2.00, 3.00,

               4.00, 5.00, 6.00, 7.00, 8.00, 9.00, 8.00,

               7.00, 6.00, 5.00, 4.00 };


   assert(sizeof(scintilSlow) == sizeof(photonEnergy));


   G4MaterialPropertiesTable* myMPT1 = new G4MaterialPropertiesTable();


   myMPT1->AddProperty("RINDEX",       photonEnergy, refractiveIndex1,nEntries)

         ->SetSpline(true);

   myMPT1->AddProperty("ABSLENGTH",    photonEnergy, absorption,     nEntries)

         ->SetSpline(true);

   myMPT1->AddProperty("FASTCOMPONENT",photonEnergy, scintilFast,     nEntries)

         ->SetSpline(true);

   myMPT1->AddProperty("SLOWCOMPONENT",photonEnergy, scintilSlow,     nEntries)

         ->SetSpline(true);


   myMPT1->AddConstProperty("SCINTILLATIONYIELD",50./MeV);

   myMPT1->AddConstProperty("RESOLUTIONSCALE",1.0);

   myMPT1->AddConstProperty("FASTTIMECONSTANT", 1.*ns);

   myMPT1->AddConstProperty("SLOWTIMECONSTANT",10.*ns);

   myMPT1->AddConstProperty("YIELDRATIO",0.8);


   G4double energy_water[] = {

      1.56962*eV, 1.58974*eV, 1.61039*eV, 1.63157*eV,

      1.65333*eV, 1.67567*eV, 1.69863*eV, 1.72222*eV,

      1.74647*eV, 1.77142*eV, 1.7971 *eV, 1.82352*eV,

      1.85074*eV, 1.87878*eV, 1.90769*eV, 1.93749*eV,

      1.96825*eV, 1.99999*eV, 2.03278*eV, 2.06666*eV,

      2.10169*eV, 2.13793*eV, 2.17543*eV, 2.21428*eV,

      2.25454*eV, 2.29629*eV, 2.33962*eV, 2.38461*eV,

      2.43137*eV, 2.47999*eV, 2.53061*eV, 2.58333*eV,

      2.63829*eV, 2.69565*eV, 2.75555*eV, 2.81817*eV,

      2.88371*eV, 2.95237*eV, 3.02438*eV, 3.09999*eV,

      3.17948*eV, 3.26315*eV, 3.35134*eV, 3.44444*eV,

      3.54285*eV, 3.64705*eV, 3.75757*eV, 3.87499*eV,

      3.99999*eV, 4.13332*eV, 4.27585*eV, 4.42856*eV,

      4.59258*eV, 4.76922*eV, 4.95999*eV, 5.16665*eV,

      5.39129*eV, 5.63635*eV, 5.90475*eV, 6.19998*eV

   };


   const G4int numentries_water = sizeof(energy_water)/sizeof(G4double);


   //assume 100 times larger than the rayleigh scattering for now.

   G4double mie_water[] = {

      167024.4*m, 158726.7*m, 150742  *m,

      143062.5*m, 135680.2*m, 128587.4*m,

      121776.3*m, 115239.5*m, 108969.5*m,

      102958.8*m, 97200.35*m, 91686.86*m,

      86411.33*m, 81366.79*m, 76546.42*m,

      71943.46*m, 67551.29*m, 63363.36*m,

      59373.25*m, 55574.61*m, 51961.24*m,

      48527.00*m, 45265.87*m, 42171.94*m,

      39239.39*m, 36462.50*m, 33835.68*m,

      31353.41*m, 29010.30*m, 26801.03*m,

      24720.42*m, 22763.36*m, 20924.88*m,

      19200.07*m, 17584.16*m, 16072.45*m,

      14660.38*m, 13343.46*m, 12117.33*m,

      10977.70*m, 9920.416*m, 8941.407*m,

      8036.711*m, 7202.470*m, 6434.927*m,

      5730.429*m, 5085.425*m, 4496.467*m,

      3960.210*m, 3473.413*m, 3032.937*m,

      2635.746*m, 2278.907*m, 1959.588*m,

      1675.064*m, 1422.710*m, 1200.004*m,

      1004.528*m, 833.9666*m, 686.1063*m

   };


   assert(sizeof(mie_water) == sizeof(energy_water));


   // gforward, gbackward, forward backward ratio

   G4double mie_water_const[3]={0.99,0.99,0.8};


   myMPT1->AddProperty("MIEHG",energy_water,mie_water,numentries_water)

         ->SetSpline(true);

   myMPT1->AddConstProperty("MIEHG_FORWARD",mie_water_const[0]);

   myMPT1->AddConstProperty("MIEHG_BACKWARD",mie_water_const[1]);

   myMPT1->AddConstProperty("MIEHG_FORWARD_RATIO",mie_water_const[2]);


   G4cout << "Water G4MaterialPropertiesTable" << G4endl;

   myMPT1->DumpTable();


   water->SetMaterialPropertiesTable(myMPT1);


   // Set the Birks Constant for the Water scintillator


   water->GetIonisation()->SetBirksConstant(0.126*mm/MeV);


 //

 // Air

 //

   G4double refractiveIndex2[] =

             { 1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00,

               1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00,

               1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00,

               1.00, 1.00, 1.00, 1.00, 1.00, 1.00, 1.00,

               1.00, 1.00, 1.00, 1.00 };


   G4MaterialPropertiesTable* myMPT2 = new G4MaterialPropertiesTable();

   myMPT2->AddProperty("RINDEX", photonEnergy, refractiveIndex2, nEntries);


   G4cout << "Air G4MaterialPropertiesTable" << G4endl;

   myMPT2->DumpTable();


   air->SetMaterialPropertiesTable(myMPT2);


 //

 // ------------- Volumes --------------


 // The experimental Hall

 //

   G4Box* expHall_box = new G4Box("World",fExpHall_x,fExpHall_y,fExpHall_z);


   G4LogicalVolume* expHall_log

     = new G4LogicalVolume(expHall_box,air,"World",0,0,0);


   G4VPhysicalVolume* expHall_phys

     = new G4PVPlacement(0,G4ThreeVector(),expHall_log,"World",0,false,0);


 // The Water Tank

 //

   G4Box* waterTank_box = new G4Box("Tank",fTank_x,fTank_y,fTank_z);


   G4LogicalVolume* waterTank_log

     = new G4LogicalVolume(waterTank_box,water,"Tank",0,0,0);


   G4VPhysicalVolume* waterTank_phys

     = new G4PVPlacement(0,G4ThreeVector(),waterTank_log,"Tank",

                         expHall_log,false,0);


 // The Air Bubble

 //

   G4Box* bubbleAir_box = new G4Box("Bubble",fBubble_x,fBubble_y,fBubble_z);


   G4LogicalVolume* bubbleAir_log

     = new G4LogicalVolume(bubbleAir_box,air,"Bubble",0,0,0);


 //G4VPhysicalVolume* bubbleAir_phys =

       new G4PVPlacement(0,G4ThreeVector(0,2.5*m,0),bubbleAir_log,"Bubble",

                         waterTank_log,false,0);


 // ------------- Surfaces --------------

 //

 // Water Tank

 //

   G4OpticalSurface* opWaterSurface = new G4OpticalSurface("WaterSurface");

 //  opWaterSurface->SetType(dielectric_dielectric);

 //  opWaterSurface->SetFinish(ground);

 //  opWaterSurface->SetModel(unified);

   opWaterSurface->SetType(dielectric_LUTDAVIS);

   opWaterSurface->SetFinish(Rough_LUT);

   opWaterSurface->SetModel(DAVIS);


   G4LogicalBorderSurface* waterSurface =

           new G4LogicalBorderSurface("WaterSurface",

                                  waterTank_phys,expHall_phys,opWaterSurface);


   G4OpticalSurface* opticalSurface = dynamic_cast <G4OpticalSurface*>

         (waterSurface->GetSurface(waterTank_phys,expHall_phys)->

                                                        GetSurfaceProperty());

   if (opticalSurface) opticalSurface->DumpInfo();


 // Air Bubble

 //

   G4OpticalSurface* opAirSurface = new G4OpticalSurface("AirSurface");

   opAirSurface->SetType(dielectric_dielectric);

   opAirSurface->SetFinish(polished);

   opAirSurface->SetModel(glisur);


   G4LogicalSkinSurface* airSurface =

           new G4LogicalSkinSurface("AirSurface", bubbleAir_log, opAirSurface);


   opticalSurface = dynamic_cast <G4OpticalSurface*>

         (airSurface->GetSurface(bubbleAir_log)->GetSurfaceProperty());

   if (opticalSurface) opticalSurface->DumpInfo();


 //

 // Generate & Add Material Properties Table attached to the optical surfaces

 //

   const G4int num = 2;

   G4double ephoton[num] = {2.034*eV, 4.136*eV};


   //OpticalWaterSurface

   G4double refractiveIndex[num] = {1.35, 1.40};

   G4double specularLobe[num]    = {0.3, 0.3};

   G4double specularSpike[num]   = {0.2, 0.2};

   G4double backScatter[num]     = {0.2, 0.2};


   G4MaterialPropertiesTable* myST1 = new G4MaterialPropertiesTable();


   myST1->AddProperty("RINDEX",                ephoton, refractiveIndex, num);

   myST1->AddProperty("SPECULARLOBECONSTANT",  ephoton, specularLobe,    num);

   myST1->AddProperty("SPECULARSPIKECONSTANT", ephoton, specularSpike,   num);

   myST1->AddProperty("BACKSCATTERCONSTANT",   ephoton, backScatter,     num);


   G4cout << "Water Surface G4MaterialPropertiesTable" << G4endl;

   myST1->DumpTable();


 //  opWaterSurface->SetMaterialPropertiesTable(myST1);


   //OpticalAirSurface

   G4double reflectivity[num] = {0.3, 0.5};

   G4double efficiency[num]   = {0.8, 1.0};


   G4MaterialPropertiesTable *myST2 = new G4MaterialPropertiesTable();


   myST2->AddProperty("REFLECTIVITY", ephoton, reflectivity, num);

   myST2->AddProperty("EFFICIENCY",   ephoton, efficiency,   num);


   G4cout << "Air Surface G4MaterialPropertiesTable" << G4endl;

   myST2->DumpTable();


   opAirSurface->SetMaterialPropertiesTable(myST2);


 //always return the physical World

   return expHall_phys;

 }


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

OpNoviceDetectorConstruction::~OpNoviceDetectorConstruction
virtual ~OpNoviceDetectorConstruction()
Definition: OpNoviceDetectorConstruction.cc:59

OpNoviceDetectorConstruction::fBubble_z
G4double fBubble_z
Definition: OpNoviceDetectorConstruction.hh:62

G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:42

OpNoviceDetectorConstruction.hh
Definition of the OpNoviceDetectorConstruction class.

a
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33

OpNoviceDetectorConstruction::Construct
virtual G4VPhysicalVolume * Construct()
Definition: OpNoviceDetectorConstruction.cc:63

MeV
static constexpr double MeV
Definition: G4SIunits.hh:214

G4Material.hh

glisur
Definition: G4OpticalSurface.hh:115

mm
static constexpr double mm
Definition: G4SIunits.hh:115

polished
Definition: G4OpticalSurface.hh:64

G4endl
#define G4endl
Definition: G4ios.hh:61

z
Double_t z
Definition: advanced/microbeam/plot.C:277

perCent
static constexpr double perCent
Definition: G4SIunits.hh:332

G4Material
Definition: G4Material.hh:121

G4MaterialPropertiesTable::AddConstProperty
void AddConstProperty(const char *key, G4double PropertyValue)

dielectric_dielectric
Definition: G4SurfaceProperty.hh:68

G4LogicalBorderSurface
Definition: G4LogicalBorderSurface.hh:55

G4LogicalBorderSurface::GetSurface
static G4LogicalBorderSurface * GetSurface(const G4VPhysicalVolume *vol1, const G4VPhysicalVolume *vol2)
Definition: G4LogicalBorderSurface.cc:141

G4OpticalSurface::SetMaterialPropertiesTable
void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT)
Definition: G4OpticalSurface.hh:196

G4IonisParamMat::SetBirksConstant
void SetBirksConstant(G4double value)
Definition: G4IonisParamMat.hh:141

DAVIS
Definition: G4OpticalSurface.hh:118

G4OpticalSurface
Definition: G4OpticalSurface.hh:128

G4LogicalSkinSurface::GetSurface
static G4LogicalSkinSurface * GetSurface(const G4LogicalVolume *vol)
Definition: G4LogicalSkinSurface.cc:135

OpNoviceDetectorConstruction::fExpHall_x
G4double fExpHall_x
Definition: OpNoviceDetectorConstruction.hh:52

OpNoviceDetectorConstruction::fExpHall_z
G4double fExpHall_z
Definition: OpNoviceDetectorConstruction.hh:54

g
static constexpr double g
Definition: G4SIunits.hh:183

m
static constexpr double m
Definition: G4SIunits.hh:129

OpNoviceDetectorConstruction::fBubble_x
G4double fBubble_x
Definition: OpNoviceDetectorConstruction.hh:60

G4double
double G4double
Definition: G4Types.hh:76

G4Material::SetMaterialPropertiesTable
void SetMaterialPropertiesTable(G4MaterialPropertiesTable *anMPT)
Definition: G4Material.cc:730

OpNoviceDetectorConstruction::fTank_x
G4double fTank_x
Definition: OpNoviceDetectorConstruction.hh:56

N
**D E S C R I P T I O N
Definition: HepMCEx01/src/HEPEvtcom.cc:77

G4OpticalSurface::SetType
void SetType(const G4SurfaceType &type)
Definition: G4OpticalSurface.cc:258

G4MaterialPropertiesTable::AddProperty
G4MaterialPropertyVector * AddProperty(const char *key, G4double *PhotonEnergies, G4double *PropertyValues, G4int NumEntries)
Definition: G4MaterialPropertiesTable.cc:247

OpNoviceDetectorConstruction::fBubble_y
G4double fBubble_y
Definition: OpNoviceDetectorConstruction.hh:61

mg
static constexpr double mg
Definition: G4SIunits.hh:184

OpNoviceDetectorConstruction::OpNoviceDetectorConstruction
OpNoviceDetectorConstruction()
Definition: OpNoviceDetectorConstruction.cc:49

OpNoviceDetectorConstruction::fExpHall_y
G4double fExpHall_y
Definition: OpNoviceDetectorConstruction.hh:53

G4Box
Definition: G4Box.hh:64

G4PhysicsVector::SetSpline
void SetSpline(G4bool)

G4SystemOfUnits.hh

G4LogicalSurface::GetSurfaceProperty
G4SurfaceProperty * GetSurfaceProperty() const

eV
static constexpr double eV
Definition: G4SIunits.hh:215

G4OpticalSurface.hh

G4MaterialPropertiesTable
Definition: G4MaterialPropertiesTable.hh:71

OpNoviceDetectorConstruction::fTank_y
G4double fTank_y
Definition: OpNoviceDetectorConstruction.hh:57

G4Box.hh

G4ThreeVector.hh

G4LogicalBorderSurface.hh

G4LogicalVolume.hh

G4PVPlacement.hh

G4PVPlacement
Definition: G4PVPlacement.hh:51

G4int
int G4int
Definition: G4Types.hh:78

Rough_LUT
Definition: G4OpticalSurface.hh:100

G4LogicalSkinSurface
Definition: G4LogicalSkinSurface.hh:54

G4Material::AddElement
void AddElement(G4Element *element, G4int nAtoms)
Definition: G4Material.cc:368

G4LogicalVolume
Definition: G4LogicalVolume.hh:190

G4Material::GetIonisation
G4IonisParamMat * GetIonisation() const
Definition: G4Material.hh:227

dielectric_LUTDAVIS
Definition: G4SurfaceProperty.hh:70

G4VPhysicalVolume
Definition: G4VPhysicalVolume.hh:82

G4LogicalSkinSurface.hh

G4cout
G4GLOB_DLL std::ostream G4cout

G4OpticalSurface::DumpInfo
void DumpInfo() const
Definition: G4OpticalSurface.cc:233

G4Element.hh

mole
static constexpr double mole
Definition: G4SIunits.hh:286

G4VUserDetectorConstruction
Definition: G4VUserDetectorConstruction.hh:50

G4MaterialPropertiesTable::DumpTable
void DumpTable()
Definition: G4MaterialPropertiesTable.cc:325

cm3
static constexpr double cm3
Definition: G4SIunits.hh:121

ns
#define ns
Definition: xmlparse.cc:614

G4Element
Definition: G4Element.hh:97

G4OpticalSurface::SetModel
void SetModel(const G4OpticalSurfaceModel model)
Definition: G4OpticalSurface.hh:177

OpNoviceDetectorConstruction::fTank_z
G4double fTank_z
Definition: OpNoviceDetectorConstruction.hh:58

G4OpticalSurface::SetFinish
void SetFinish(const G4OpticalSurfaceFinish)
Definition: G4OpticalSurface.cc:280