DetectorConstruction.cc

Go to the documentation of this file.

#include "DetectorConstruction.hh"

DetectorConstruction::DetectorConstruction()
:ScintillatorMaterial(0),GapMaterial(0),defaultMaterial(0), ShieldingMaterial(0), BeamBlockerMaterial(0), 
solidWorld(0),logicWorld(0),physiWorld(0), GeDetectorShellMaterial(0),
solidScintillatorBox(0),logicScintillatorBox(0),physiScintillatorBox(0), 
solidSlot(0),logicSlot(0),physiSlot(0),
solidScintillator(0),logicScintillator(0),physiScintillator(0),
solidGap (0),logicGap (0),physiGap (0),
solidShielding(0), logicShielding(0), physiShielding(0),
solidTopShielding(0), logicTopShielding(0), physiTopShielding(0),
solidBetaDetector(0), logicBetaDetector(0), physiUpperBetaDetector(0), physiLowerBetaDetector(0),
solidFrontScintillatorPlate(0), logicFrontScintillatorPlate(0), physiUpperFrontScintillatorPlate(0), physiLowerFrontScintillatorPlate(0),
solidBackScintillatorPlate(0), logicBackScintillatorPlate(0), physiBackScintillatorPlate(0),

solidSlowdown(0), logicSlowdown(0), physiUpperSlowdown(0), physiLowerSlowdown(0), SlowdownMaterial(0),
solidGermaniumDetector(0), logicGermaniumDetector(0), physiGermaniumDetector(0),
solidGeDetectorShell(0), logicGeDetectorShell(0), physiGeDetectorShell(0),
solidGeDetectorContainer(0), logicGeDetectorContainer(0), physiGeDetectorContainer(0),
solidBeamBlocker(0), logicBeamBlocker(0), physiBeamBlocker(0)
{
  
  DefineMaterials();
  SetDefaultDetectorParameters();
  
  detectorMessenger = new DetectorMessenger(this);
}

void DetectorConstruction::SetDefaultDetectorParameters()
{
  //Default dimensions of different stuff.
  ScintillatorDiameter                   = 10.*mm;
  ScintillatorShieldingGapThickness      =  1.*mm;
  NumberOfScintillatorsPerBox            = 10;
  NumberOfScintillatorBoxes              = 2;
  ScintillatorLength                     = 10.*cm;
  ScintillatorPlateThickness             = 1*mm;
  ShieldingThickness                     = 10.*mm;
  TopShieldingThickness                  = ShieldingThickness;
  
  // default values for the germaniumdetector
  GeDetectorRadius              = 2.3*cm;
  GeDetectorShellLength         = 12.*cm;
  GeDetectorLength              = 5.*cm;
  GeDetectorShellInnerRadius    = 2.6*cm;
  GeDetectorShellOuterRadius    = 3.0*cm;

  BeamBlockerThickness          = 10.*cm;
  ShieldingBeamBlockerThickness = 3.*cm;
  
  // default values for the slowdown
  SlowdownThickness             = 40*cm; 
  SlowdownLength                = 50*cm;
  EffectiveSlowdownThickness    = 30*cm;
  PlateShieldingSpacing         = 0.5*cm;

  
  FlipBeta = false;

  //Some parameters are dependent of the other, compute the value of these.
  ComputeDependentDetectorParameters();

  //Set default materials.
  SetScintillatorMaterial("Plastic");  
  SetGapMaterial(defaultMaterial->GetName());  // "Air");   //
  SetShieldingMaterial("quartz");
  SetGeDetectorShellMaterial("Aluminium");
  SetGermaniumDetectorMaterial("Germanium");//("SodiumIodide");                         
  SetBeamBlockerMaterial("Lead");
  SetSlowdownMaterial("Aluminium");
  SetShieldingBeamBlockerMaterial(defaultMaterial->GetName());
}


DetectorConstruction::~DetectorConstruction()
{ delete detectorMessenger;}

G4VPhysicalVolume* DetectorConstruction::Construct()
{
 return ConstructDetector();
}

void DetectorConstruction::DefineMaterials()
{

G4String symbol;             //a=mass of a mole;
G4double a, z, density;      //z=mean number of protons;  
G4int iz, n;                 //iz=number of protons  in an isotope;
                             // n=number of nucleons in an isotope;

G4int ncomponents, natoms;
G4double abundance, fractionmass;

// define Elements
G4Element* H  = new G4Element("Hydrogen" ,symbol="H"  , z= 1.,  a= 1.01*g/mole);
G4Element* C  = new G4Element("Carbon"   ,symbol="C"  , z= 6.,  a= 12.01*g/mole);
G4Element* N  = new G4Element("Nitrogen" ,symbol="N"  , z= 7.,  a= 14.01*g/mole);
G4Element* O  = new G4Element("Oxygen"   ,symbol="O"  , z= 8.,  a= 16.00*g/mole);
G4Element* Si = new G4Element("Silicon"  ,symbol="Si" , z= 14., a= 28.09*g/mole);
G4Element* Pb = new G4Element("Lead"     ,symbol="Pb" , z= 82., a= 207.19*g/mole);
G4Element* W  = new G4Element("Tungsten" ,symbol="W"  , z= 74., a= 183.84*g/mole);
G4Element* Na = new G4Element("Sodium"   ,symbol="Na" , z= 11., a= 22.98976928*g/mole);
G4Element* I  = new G4Element("Iodine"   ,symbol="I"  , z= 53., a= 126.90447*g/mole);

// define an Element from isotopes, by relative abundance
G4Isotope* U5 = new G4Isotope("U235", iz=92, n=235, a=235.01*g/mole);
G4Isotope* U8 = new G4Isotope("U238", iz=92, n=238, a=238.03*g/mole);

G4Element* U  = new G4Element("enriched Uranium",symbol="U",ncomponents=2);
U->AddIsotope(U5, abundance= 90.*perCent);
U->AddIsotope(U8, abundance= 10.*perCent);

// define simple materials
 new G4Material("Aluminium"  , z=13., a=26.98*g/mole,   density= 2.700*g/cm3);
 new G4Material("liquidArgon", z=18., a= 39.95*g/mole,  density= 1.390*g/cm3);
 new G4Material("Lead"       , z=82., a= 207.19*g/mole, density= 11.35*g/cm3);
 new G4Material("Germanium"  , z=32., a= 72.64*g/mole,  density= 5.323*g/cm3);
 new G4Material("Iron", z=26., a=55.85*g/mole, density=7.874*g/cm3);


// define a material from elements.   case 1: chemical molecule
G4Material* SodiumIodide = new G4Material("SodiumIodide", density= 3.67*g/cm3, ncomponents=2);
SodiumIodide->AddElement(Na, natoms=1);
SodiumIodide->AddElement(I, natoms=1);

G4Material* Plastic = new G4Material("Plastic", density= 1.032*g/cm3, ncomponents=2);
Plastic->AddElement(C, natoms=9);
Plastic->AddElement(H, natoms=10);

G4Material* LeadTungstate =
new G4Material("Lead Tungstate", density= 8.235*g/cm3, ncomponents=3);
LeadTungstate->AddElement(Pb, natoms=1);
LeadTungstate->AddElement(W, natoms= 1);
LeadTungstate->AddElement(O, natoms= 4);

G4Material* H2O =
new G4Material("Water", density= 1.000*g/cm3, ncomponents=2);
H2O->AddElement(H, natoms=2);
H2O->AddElement(O, natoms=1);
// overwrite computed meanExcitationEnergy with ICRU recommended value
H2O->GetIonisation()->SetMeanExcitationEnergy(75.0*eV);

G4Material* Sci =
new G4Material("Scintillator", density= 1.032*g/cm3, ncomponents=2);
Sci->AddElement(C, natoms=9);
Sci->AddElement(H, natoms=10);

G4Material* Myl =
new G4Material("Mylar", density= 1.397*g/cm3, ncomponents=3);
Myl->AddElement(C, natoms=10);
Myl->AddElement(H, natoms= 8);
Myl->AddElement(O, natoms= 4);

G4Material* SiO2 =
new G4Material("quartz",density= 2.200*g/cm3, ncomponents=2);
SiO2->AddElement(Si, natoms=1);
SiO2->AddElement(O , natoms=2);

// define a material from elements.   case 2: mixture by fractional mass
G4Material* Air =
new G4Material("Air"  , density= 1.290*mg/cm3, ncomponents=2);
Air->AddElement(N, fractionmass=0.7);
Air->AddElement(O, fractionmass=0.3);

// define a material from elements and/or others materials (mixture of mixtures)
G4Material* Aerog =
new G4Material("Aerogel", density= 0.200*g/cm3, ncomponents=3);
Aerog->AddMaterial(SiO2, fractionmass=62.5*perCent);
Aerog->AddMaterial(H2O , fractionmass=37.4*perCent);
Aerog->AddElement (C   , fractionmass= 0.1*perCent);

// examples of gas in non STP conditions
G4Material* CO2 =
new G4Material("CarbonicGas", density= 1.842*mg/cm3, ncomponents=2,
                             kStateGas, 325.*kelvin, 50.*atmosphere);
CO2->AddElement(C, natoms=1);
CO2->AddElement(O, natoms=2);

G4Material* steam =
new G4Material("WaterSteam", density= 0.3*mg/cm3, ncomponents=1,
                            kStateGas, 500.*kelvin, 2.*atmosphere);
steam->AddMaterial(H2O, fractionmass=1.);

// examples of vacuum
G4Material* Vacuum =
new G4Material("Galactic", z=1., a=1.01*g/mole,density= universe_mean_density,
                          kStateGas, 2.73*kelvin, 3.e-18*pascal);

G4Material* beam =
new G4Material("Beam", density= 1.e-5*g/cm3, ncomponents=1,
                      kStateGas, STP_Temperature, 2.e-2*bar);
beam->AddMaterial(Air, fractionmass=1.);

//If desire to print the material table, we can do that here.
//G4cout << *(G4Material::GetMaterialTable()) << G4endl;

//default materials of the World, vacuum.
defaultMaterial  = Vacuum;
}


void DetectorConstruction::ConstructWorld()
{
  solidWorld = new G4Box("World",                //its name
                         WorldSizeX/2,
                         WorldSizeY/2,
                         WorldSizeZ/2);    //its size
  
  logicWorld = new G4LogicalVolume(solidWorld,        //its solid
                                   GapMaterial,    //its material
                                   "World");        //its name
  
  physiWorld = new G4PVPlacement(0,            //no rotation
                                 G4ThreeVector(),    //at (0,0,0)
                                 logicWorld,        //its logical volume                
                                 "World",        //its name
                                 0,            //its mother  volume
                                 false,            //no boolean operation
                                 0);            //copy number
}

void DetectorConstruction::ConstructBetaDetector()
{
  solidBetaDetector=0; logicBetaDetector=0; physiUpperBetaDetector=0; physiLowerBetaDetector=0;
  
  solidBetaDetector = new G4Box("BetaDetector",        //its name
                                ScintillatorBoxSizeX/2,
                                NumberOfScintillatorBoxes*ScintillatorBoxSizeY/2,
                                ScintillatorBoxSizeZ/2);   //size
  
  logicBetaDetector = new G4LogicalVolume(solidBetaDetector,    //its solid
                                          GapMaterial,    //its material
                                          "BetaDetector");    //its name
  
  // Upper beta detector
  G4RotationMatrix* rmUpperBetaDetector = new G4RotationMatrix();
  if(!FlipBeta)
    rmUpperBetaDetector->rotateX(180*degree); //Upper and lower beta detectors are rotation symmetric.
  
  physiUpperBetaDetector = new G4PVPlacement(rmUpperBetaDetector,            
                                             G4ThreeVector(-ShieldingBeamBlockerThickness/2, BetaDetectorPositionY, 0),
                                             logicBetaDetector,    //its logical volume
                                             "UpperBetaDetector",    //its name
                                             logicWorld,    //its mother  volume
                                            false,        //no boolean operation
                                             0);        //copy number
  

G4RotationMatrix* rmLowerBetaDetector = new G4RotationMatrix();
if(FlipBeta)
    rmLowerBetaDetector->rotateX(180*degree); //Upper and lower beta detectors are rotation symmetric.
 // LowerBetaDetector                          
  physiLowerBetaDetector = new G4PVPlacement(rmLowerBetaDetector,            //no rotation
                                             G4ThreeVector(-ShieldingBeamBlockerThickness/2, -BetaDetectorPositionY, 0),    //at (0,0,0)
                                             logicBetaDetector,    //its logical volume
                                            "LowerBetaDetector",    //its name
                                             logicWorld,    //its mother  volume
                                             false,        //no boolean operation
                                             0);        //copy number
}





void DetectorConstruction::ConstructScintillatorBox()
{
  // ScintillatorBox
  solidScintillatorBox=0; logicScintillatorBox=0; physiScintillatorBox=0;
  solidSlot=0; logicSlot=0; physiSlot=0;
  
  solidScintillatorBox = new G4Box("ScintillatorBox",        //its name
                                   ScintillatorBoxSizeX/2,ScintillatorBoxSizeY/2,ScintillatorBoxSizeZ/2);//size
  
 logicScintillatorBox = new G4LogicalVolume(solidScintillatorBox,    //its solid
                                            GapMaterial,    //its material
                                            "ScintillatorBox");    //its name
 
 physiScintillatorBox = new G4PVReplica("ScintillatorBox",        //its name
                                        logicScintillatorBox,    //its logical volume
                                        logicBetaDetector,    //its mother
                                        kYAxis,        //axis of replication
                                        NumberOfScintillatorBoxes,    //number of replica
                                        SlotWidthY);    //witdth of replica
 
}


void DetectorConstruction::ConstructScintillatorSlot()
{
  // Slot
  solidSlot = new G4Box("Slot",            //its name
                        ScintillatorBoxSizeX/2,
                        SlotWidthY/2,
                        SlotWidthZ/2); //size
  
  logicSlot = new G4LogicalVolume(solidSlot,    //its solid
                                  defaultMaterial,    //its material
                                  "Slot");    //its name
  
  if (NumberOfScintillatorsPerBox > 1)                                      
    physiSlot = new G4PVReplica("Slot",        //its name
                                logicSlot,    //its logical volume
                                logicScintillatorBox,    //its mother
                                kZAxis,        //axis of replication
                                NumberOfScintillatorsPerBox,    //number of replica
                                SlotWidthZ);    //witdth of replica
  else
    physiSlot = new G4PVPlacement(0,        //no rotation
                                  G4ThreeVector(),    //at (0,0,0)
                                  logicSlot,    //its logical volume                     
                                  "Slot",        //its name
                                  logicScintillatorBox,    //its mother  volume
                                  false,        //no boolean operation
                                  0);        //copy number                                   
}

void DetectorConstruction::ConstructScintillator()
{
  // Scintillator
  solidScintillator=0; logicScintillator=0; physiScintillator=0;  
  
  if (ScintillatorThickness > 0.)
    { 
      solidScintillator = new G4Tubs("Scintillator", 
                                     0*cm, 
                                     ScintillatorDiameter/2, 
                                     ScintillatorLength/2, 
                                     0*degree, 
                                     360*degree);
      
      logicScintillator = new G4LogicalVolume(solidScintillator,    //its solid
                                              ScintillatorMaterial, //its material
                                              ScintillatorMaterial->GetName()); //name
      
      G4RotationMatrix * rmScintillator = new G4RotationMatrix();
      rmScintillator->rotateY(90*degree);
      
      physiScintillator = new G4PVPlacement(rmScintillator,           //rotation
                                            G4ThreeVector(ScintillatorPositionX, ScintillatorPositionY, ScintillatorPositionZ),  //its position
                                            logicScintillator,     //its logical volume            
                                            ScintillatorMaterial->GetName(), //its name
                                            logicSlot,        //its mother
                                            false,             //no boolean operat
                                            0);                //copy number
      
    } 
}

void DetectorConstruction::ConstructShielding()
{
  // Shielding
  solidShielding=0; logicShielding=0; physiShielding=0;
  
  solidShielding = new G4Box("Shielding",
                             ScintillatorLength/2,
                             SlotWidthY/2,
                             ShieldingThickness/2);
  
  logicShielding = new G4LogicalVolume(solidShielding,
                                       ShieldingMaterial,
                                       ShieldingMaterial->GetName());
  
  physiShielding = new G4PVPlacement(0,                      //no rotation
                                     G4ThreeVector(ShieldingPositionX, ShieldingPositionY, ShieldingPositionZ),
                                     logicShielding,               //its logical volume           
                                     ShieldingMaterial->GetName(), //its name
                                     logicSlot,             //its mother
                                     false,                  //no boulean operat
                                     0);                     //copy number
  
  // TopShielding
  solidTopShielding=0; logicTopShielding=0; physiTopShielding=0;
  
  solidTopShielding = new G4Box("TopShielding",
                                ScintillatorLength/2,
                                TopShieldingThickness/2,
                                (SlotWidthZ-ShieldingThickness)/2);
  
  logicTopShielding = new G4LogicalVolume(solidTopShielding,
                                          ShieldingMaterial,
                                          ShieldingMaterial->GetName());
  
  physiTopShielding = new G4PVPlacement(0,                              //no rotation
                                        G4ThreeVector(TopShieldingPositionX,TopShieldingPositionY,TopShieldingPositionZ),   //its position
                                        logicTopShielding,                      //its logical volume           
                                        ShieldingMaterial->GetName(),   //its name
                                        logicSlot,                      //its mother
                                        false,                          //no boolean operator
                                        0);                             //copy number
}


void DetectorConstruction::ConstructBeamBlocker()
{  
  // Beam blocker
  solidBeamBlocker=0; logicBeamBlocker=0; physiBeamBlocker=0;
  solidBeamBlocker = new G4Box("BeamBlocker", 
                               BeamBlockerThickness/2, 
                               BeamBlockerYWidth/2,
                               BeamBlockerZWidth/2
                               ); 
  logicBeamBlocker = new G4LogicalVolume(solidBeamBlocker,    //its solid
                                         BeamBlockerMaterial,    //its material
                                         "BeamBlocker");    //its name

 physiBeamBlocker = new G4PVPlacement(0,            //no rotation
                                      G4ThreeVector(-(GeDetectorContainerSizeX/2-BeamBlockerThickness/2), 0, 0),
                                      logicBeamBlocker,    //its logical volume              
                                      "BeamBlocker",    //its name
                                      logicGeDetectorContainer,    //its mother  volume
                                      false,        //no boolean operation
                                      0);        //copy number
}

void DetectorConstruction::ConstructShieldingBeamBlocker()
{
  // Shielding
  solidShieldingBeamBlocker=0; logicShieldingBeamBlocker=0; physiShieldingBeamBlocker=0;
  
  solidShieldingBeamBlocker = new G4Box("ShieldingBeamBlocker" ,
                             ShieldingBeamBlockerThickness/2,
                             SlotWidthY/2,
                             ShieldingThickness/2);
  
  logicShieldingBeamBlocker = new G4LogicalVolume(solidShieldingBeamBlocker,
                                       ShieldingBeamBlockerMaterial,
                                       ShieldingBeamBlockerMaterial->GetName());
  
  physiShieldingBeamBlocker = new G4PVPlacement(0,                      //no rotation
                                                G4ThreeVector(ShieldingBeamBlockerPositionX,ShieldingPositionY, ShieldingPositionZ),
                                                logicShieldingBeamBlocker,               //its logical volume           
                                                ShieldingBeamBlockerMaterial->GetName(), //its name
                                                logicSlot,             //its mother
                                                false,                  //no boulean operat
                                                0);                     //copy number
  
  // TopShielding
  solidTopShieldingBeamBlocker=0; logicTopShieldingBeamBlocker=0; physiTopShieldingBeamBlocker=0;
  
  solidTopShieldingBeamBlocker = new G4Box("TopShieldingBeamBlocker",
                                           ShieldingBeamBlockerThickness/2,
                                           TopShieldingThickness/2,
                                           (SlotWidthZ-ShieldingThickness)/2);
  
  logicTopShieldingBeamBlocker = new G4LogicalVolume(solidTopShieldingBeamBlocker,
                                                     ShieldingBeamBlockerMaterial,
                                                     ShieldingBeamBlockerMaterial->GetName());
  
  physiTopShieldingBeamBlocker = new G4PVPlacement(0,                           //no rotation
                                                   G4ThreeVector(ShieldingBeamBlockerPositionX,TopShieldingPositionY, TopShieldingPositionZ),   //its position
                                                   logicTopShieldingBeamBlocker,                //its logical volume           
                                                   ShieldingBeamBlockerMaterial->GetName(),     //its name
                                                   logicSlot,                           //its mother
                                                   false,                       //no boulean operat
                                                   0);                          //copy number
}














void DetectorConstruction::ConstructScintillatorPlates()
{
  // FrontPlateLogicalVolume
  solidFrontScintillatorPlate=0; logicFrontScintillatorPlate=0; physiUpperFrontScintillatorPlate=0; physiLowerFrontScintillatorPlate=0;
  
  solidFrontScintillatorPlate = new G4Box("FrontScintillatorPlate", ScintillatorPlateThickness/2,FrontScintillatorPlateSizeY/2,ScintillatorBoxSizeZ/2); 
  
  logicFrontScintillatorPlate = new G4LogicalVolume(solidFrontScintillatorPlate,        //its solid
                                                    ScintillatorMaterial,       //its material
                                                    "FrontScintillatorPlate");          //its name
  G4double displacement = TopShieldingThickness;
  if(FlipBeta)
    displacement = -displacement;
  //UpperFrontScintillatorPlate
  physiUpperFrontScintillatorPlate = new G4PVPlacement(0,                       //no rotation
                                                       G4ThreeVector(-ScintillatorBoxSizeX/2 - ShieldingBeamBlockerThickness/2 - ScintillatorPlateThickness - PlateShieldingSpacing, 1.1*GeDetectorShellOuterRadius+(NumberOfScintillatorBoxes*ScintillatorBoxSizeY+displacement)/2, 0), // -(ScintillatorBoxSizeX+ScintillatorPlateThickness)/2
                                                       logicFrontScintillatorPlate,     //its logical volume              
                                                       "UpperFrontScintillatorPlate",           //its name
                                                       logicWorld,                              //its mother  volume
                                                       false,                                   //no boolean operation
                                                       0);                                      //copy number
  
  //LowerFrontScintillatorPlate
  physiLowerFrontScintillatorPlate = new G4PVPlacement(0,            //no rotation
                                                       G4ThreeVector(-ScintillatorBoxSizeX/2 - ShieldingBeamBlockerThickness/2 - ScintillatorPlateThickness -PlateShieldingSpacing, -(1.1*GeDetectorShellOuterRadius+(NumberOfScintillatorBoxes*ScintillatorBoxSizeY+displacement)/2), 0),   //-(ScintillatorBoxSizeX+ScintillatorPlateThickness)/2
                                                       logicFrontScintillatorPlate,    //its logical volume              
                                                       "LowerFrontScintillatorPlate",    //its name
                                                       logicWorld,    //its mother  volume
                                                       false,        //no boolean operation
                                                       0);        //copy number
  
  
  //BackScintillatorPlate
  solidBackScintillatorPlate=0; logicBackScintillatorPlate=0; physiBackScintillatorPlate=0;
  
  solidBackScintillatorPlate = new G4Box("BackScintillatorPlate", ScintillatorPlateThickness/2, BackScintillatorPlateSizeY/2, ScintillatorBoxSizeZ/2); 
  
  logicBackScintillatorPlate = new G4LogicalVolume(solidBackScintillatorPlate,    //its solid
                                                   ScintillatorMaterial,    //its material
                                                   "BackScintillatorPlate");    //its name
  
  physiBackScintillatorPlate = new G4PVPlacement(0,            //no rotation
                                                 G4ThreeVector((GeDetectorContainerSizeX+ScintillatorPlateThickness)/2, 0, 0),
                                                 logicBackScintillatorPlate,    //its logical volume              
                                                 "BackScintillatorPlate",    //its name
                                                 logicWorld,    //its mother  volume
                                                 false,        //no boolean operation
                                                 0);        //copy number
  
}

void DetectorConstruction::ConstructSlowdown() //Wedges.
{
  solidSlowdown=0; logicSlowdown=0; physiUpperSlowdown=0; physiLowerSlowdown=0;
  solidSlowdown = new G4Trap("Slowdown",                        
                             ScintillatorBoxSizeZ,
                             SlowdownThickness,
                             SlowdownLength,
                             .0001*cm); // Just keep it low ok...                  
  
  
  
  logicSlowdown = new G4LogicalVolume(solidSlowdown,    //its solid
                                      SlowdownMaterial,    //its material
                                      "Slowdown");    //its name
  
  //UpperSlowdown
  G4RotationMatrix * rmUpperSlowdown = new G4RotationMatrix();
  rmUpperSlowdown->rotateZ(90*degree);
  G4ThreeVector placementUpperSlowdown(-(GeDetectorContainerSizeX/2+BeamBlockerThickness/2+SlowdownThickness/2+1*cm), SlowdownLength/4 + SlowdownHeightGap/2, 0);
  
  physiUpperSlowdown = new G4PVPlacement(rmUpperSlowdown,            //+ 90 degree rotation about z axis.
                                         placementUpperSlowdown,
                                         logicSlowdown,    //its logical volume              
                                         "UpperSlowdown",    //its name
                                         logicWorld,    //its mother  volume
                                         false,        //no boolean operation
                                         0);        //copy number
  
  //LowerSlowdown
  G4RotationMatrix * rmLowerSlowdown = new G4RotationMatrix();
  rmLowerSlowdown->rotateZ(-90*degree);
  
  G4ThreeVector placementLowerSlowdown( -(GeDetectorContainerSizeX/2+BeamBlockerThickness/2+SlowdownThickness/2+1*cm), -SlowdownLength/4 - SlowdownHeightGap/2, 0);
  
  physiLowerSlowdown = new G4PVPlacement(rmLowerSlowdown,            //-90 degree rotation about the Z-axis
                                         placementLowerSlowdown,
                                         logicSlowdown,    //its logical volume              
                                         "LowerSlowdown",    //its name
                                         logicWorld,    //its mother  volume
                                         false,        //no boolean operation
                                         0);        //copy number
}

void DetectorConstruction::ConstructGermaniumDetector()
{
  // Germanium detector container
  solidGeDetectorContainer=0; logicGeDetectorContainer=0; physiGeDetectorContainer=0;
  
  solidGeDetectorContainer = new G4Box("GermaniumDetectorContainer", GeDetectorContainerSizeX/2, 1.1*GeDetectorShellOuterRadius, 1.1*GeDetectorShellLength/2); 
  
  logicGeDetectorContainer = new G4LogicalVolume(solidGeDetectorContainer,      //its solid
                                                 defaultMaterial,               //its material
                                                 "GermaniumDetectorContainer");         //its name
  
  physiGeDetectorContainer = new G4PVPlacement(0,                       //no rotation
                                               G4ThreeVector(-BeamBlockerThickness/2, 0, 0),
                                               logicGeDetectorContainer,        //its logical volume              
                                               "GermaniumDetectorContainer",    //its name
                                               logicWorld,              //its mother  volume
                                               false,                   //no boolean operation
                                               0);                              //copy number
  
  
  // Germanium detector shell
  solidGeDetectorShell=0; logicGeDetectorShell=0; physiGeDetectorShell=0;
  
  solidGeDetectorShell = new G4Tubs("GeDetectorShell", GeDetectorShellInnerRadius, GeDetectorShellOuterRadius, GeDetectorShellLength/2, 0*degree, 360*degree); 
  
  logicGeDetectorShell = new G4LogicalVolume(solidGeDetectorShell,    //its solid
                                             GeDetectorShellMaterial,    //its material
                                             "GeDetectorShell");    //its name
  
  physiGeDetectorShell = new G4PVPlacement(0,            //no rotation
                                           G4ThreeVector(BeamBlockerThickness/2,0,0),    
                                           logicGeDetectorShell,    //its logical volume 
                                           "GeDetectorShell",    //its name
                                           logicGeDetectorContainer,    //its mother  volume
                                           false,        //no boolean operation
                                           0);        //copy number
  
  solidGeDetectorShellTop=0; logicGeDetectorShellTop=0; physiGeDetectorShellTop=0;
  
  solidGeDetectorShellTop = new G4Tubs("GeDetectorShellTop", 0, GeDetectorShellInnerRadius, (GeDetectorShellOuterRadius-GeDetectorShellInnerRadius)/2, 0*degree, 360*degree); 
  
  logicGeDetectorShellTop = new G4LogicalVolume(solidGeDetectorShellTop,    //its solid
                                                GeDetectorShellMaterial,    //its material
                                                "GeDetectorShellTop");    //its name
  
  physiGeDetectorShellTop = new G4PVPlacement(0,            //no rotation
                                              G4ThreeVector(BeamBlockerThickness/2, 0, GeDetectorShellLength/2-(GeDetectorShellOuterRadius-GeDetectorShellInnerRadius)/2),   
                                              logicGeDetectorShellTop,    //its logical volume 
                                              "GeDetectorShellTop",    //its name
                                              logicGeDetectorContainer,    //its mother  volume
                                              false,        //no boolean operation
                                              0);        //copy number
  
  
  
  solidGeDetectorShellBottom=0; logicGeDetectorShellBottom=0; physiGeDetectorShellBottom=0;
  
  solidGeDetectorShellBottom = new G4Tubs("GeDetectorShellBottom", 0, GeDetectorShellInnerRadius, (GeDetectorShellOuterRadius-GeDetectorShellInnerRadius)/2, 0*degree, 360*degree); 
  
  logicGeDetectorShellBottom = new G4LogicalVolume(solidGeDetectorShellBottom,    //its solid
                                                   GeDetectorShellMaterial,    //its material
                                                   "GeDetectorShellBottom");    //its name
  
  physiGeDetectorShellBottom = new G4PVPlacement(0,            //no rotation
                                                 G4ThreeVector(BeamBlockerThickness/2, 0, -GeDetectorShellLength/2+(GeDetectorShellOuterRadius-GeDetectorShellInnerRadius)/2),    //at (0,0,0)
                                                 logicGeDetectorShellBottom,    //its logical volume 
                                                 "GeDetectorShellBottom",    //its name
                                                 logicGeDetectorContainer,    //its mother  volume
                                                 false,        //no boolean operation
                                                 0);        //copy number
  
  // Germanium detectors
  solidGermaniumDetector = new G4Tubs("GermaniumDetector", 0*cm, GeDetectorRadius, GeDetectorLength/2, 0*degree, 360*degree);
  
  logicGermaniumDetector = new G4LogicalVolume(solidGermaniumDetector,    //its solid
                                               GermaniumDetectorMaterial,    //its material
                                               "GermaniumDetector");    //its name                                    
  physiGermaniumDetector = new G4PVReplica("GermaniumDetector",        //its name
                                           logicGermaniumDetector,    //its logical volume
                                           logicGeDetectorShell,    //its mother
                                           kZAxis,        //axis of replication
                                           2,    //number of replica
                                           GeDetectorLength+1.*cm);    //width of replica
  
}

void DetectorConstruction::SetVisualizationAttributes()
{  
  // Visualization attributes 
  logicWorld->SetVisAttributes (G4VisAttributes::Invisible);
  logicBetaDetector ->SetVisAttributes (G4VisAttributes::Invisible);
  logicScintillatorBox ->SetVisAttributes (G4VisAttributes::Invisible);
  logicGeDetectorContainer ->SetVisAttributes (G4VisAttributes::Invisible);
  logicSlot ->SetVisAttributes (G4VisAttributes::Invisible);
  //logicGap ->SetVisAttributes (G4VisAttributes::Invisible);
  
  
  // G4VisAttributes* simpleBoxVisAtt= new G4VisAttributes(G4Colour(1.0,0.5,1.0));
  // simpleBoxVisAtt->SetVisibility(true);
  // logicScintillatorBox->SetVisAttributes(simpleBoxVisAtt);
  
 //Scintillator tube Colour
  G4VisAttributes* simpleBoxVisAttScintillator = new G4VisAttributes(G4Colour(0.0,1.0,1.0));

  simpleBoxVisAttScintillator->SetVisibility(true);
  simpleBoxVisAttScintillator->G4VisAttributes::SetForceSolid(true);

  delete logicScintillator->GetVisAttributes();
  logicScintillator->SetVisAttributes(simpleBoxVisAttScintillator);
  
  simpleBoxVisAttScintillator->G4VisAttributes::SetForceAuxEdgeVisible(true);

  //Scintillator plate color
  G4VisAttributes* simpleBoxVisAttPlate = new G4VisAttributes(G4Color(0.2, 0.8, 0.5));
  simpleBoxVisAttPlate->SetVisibility(true);
  simpleBoxVisAttPlate->G4VisAttributes::SetForceSolid(true);
  simpleBoxVisAttPlate->SetColor(0.2, 0.8, 0.5, 0.4);
  
  
  delete logicBackScintillatorPlate->GetVisAttributes();
  logicBackScintillatorPlate->SetVisAttributes(simpleBoxVisAttPlate);
  
  delete logicFrontScintillatorPlate->GetVisAttributes();
  logicFrontScintillatorPlate->SetVisAttributes(simpleBoxVisAttPlate);
  
  //Shielding Colour
  G4VisAttributes* simpleBoxVisAttShielding= new G4VisAttributes(G4Colour(1.0,0.0,0.0));
  simpleBoxVisAttShielding->SetVisibility(true);
  //simpleBoxVisAttShielding->G4VisAttributes::SetForceAuxEdgeVisible(true);
  simpleBoxVisAttShielding->G4VisAttributes::SetForceSolid(true);
  delete logicShielding->GetVisAttributes();
  logicShielding->SetVisAttributes(simpleBoxVisAttShielding);
  
  delete logicTopShielding->GetVisAttributes();
  logicTopShielding->SetVisAttributes(simpleBoxVisAttShielding);
  
  //Germanium Detector (germanium) Colour
  G4VisAttributes* simpleBoxVisAttGermaniumDetector= new G4VisAttributes(G4Colour(1.0,1.0,1.0));
  simpleBoxVisAttGermaniumDetector->SetVisibility(true);
  //simpleBoxVisAttGermaniumDetector->G4VisAttributes::SetForceAuxEdgeVisible(true);
  simpleBoxVisAttGermaniumDetector->G4VisAttributes::SetForceSolid(true);
  delete logicGermaniumDetector->GetVisAttributes();
  logicGermaniumDetector->SetVisAttributes(simpleBoxVisAttGermaniumDetector);
  
  //Beam Blocker (lead) Colour
  G4VisAttributes* simpleBoxVisAttBeamBlocker= new G4VisAttributes(G4Colour(0.8,0.2,0.3));
  simpleBoxVisAttBeamBlocker->SetColor(0.8, 0.2, 0.3, 0.1);
  simpleBoxVisAttBeamBlocker->SetVisibility(true);
  simpleBoxVisAttBeamBlocker->G4VisAttributes::SetForceWireframe(true);//SetForceSolid(true);//SetForceAuxEdgeVisible(true);
  //simpleBoxVisAttBeamBlocker->G4VisAttributes::SetForceSolid(true);
  delete logicBeamBlocker->GetVisAttributes();
  logicBeamBlocker->SetVisAttributes(simpleBoxVisAttBeamBlocker);


  G4VisAttributes* simpleBoxVisAttBeamBlockerB= new G4VisAttributes(G4Colour(0.8,0.7,0.5));
  simpleBoxVisAttBeamBlockerB->SetColor(0.8, 0.7, 0.5, 0.15);
  simpleBoxVisAttBeamBlockerB->SetVisibility(false);
  simpleBoxVisAttBeamBlockerB->G4VisAttributes::SetForceWireframe(true);

  delete logicShieldingBeamBlocker->GetVisAttributes();
  logicShieldingBeamBlocker->SetVisAttributes(simpleBoxVisAttBeamBlockerB);



  G4VisAttributes* simpleBoxVisAttBeamBlockerC= new G4VisAttributes(G4Colour(0.8,0.7,0.5));
  simpleBoxVisAttBeamBlockerC->SetColor(0.8, 0.7, 0.5, 0.15);
  simpleBoxVisAttBeamBlockerC->SetVisibility(false);
  simpleBoxVisAttBeamBlockerC->G4VisAttributes::SetForceWireframe(true);

  delete logicTopShieldingBeamBlocker->GetVisAttributes();
  logicTopShieldingBeamBlocker->SetVisAttributes(simpleBoxVisAttBeamBlockerC);


  
   
  //Slowdown/Ge Detector Shell (Aluminium) Colour
  
  G4VisAttributes* simpleBoxVisAttSlowdown= new G4VisAttributes(G4Colour(0.55,0.55,0.55));
  simpleBoxVisAttSlowdown->SetVisibility(true);
  simpleBoxVisAttSlowdown->G4VisAttributes::SetForceAuxEdgeVisible(true);
  //simpleBoxVisAttSlowdown->G4VisAttributes::SetForceSolid(true);
  delete logicSlowdown->GetVisAttributes();
  logicSlowdown->SetVisAttributes(simpleBoxVisAttSlowdown);
  
  delete logicGeDetectorShell->GetVisAttributes();
  logicGeDetectorShell->SetVisAttributes(simpleBoxVisAttSlowdown);
  
  delete logicGeDetectorShellTop->GetVisAttributes();
  logicGeDetectorShellTop->SetVisAttributes(simpleBoxVisAttSlowdown);
  
  delete logicGeDetectorShellBottom->GetVisAttributes();
  logicGeDetectorShellBottom->SetVisAttributes(simpleBoxVisAttSlowdown);
}

G4VPhysicalVolume* DetectorConstruction::ConstructDetector()
{
  // Clean old geometry, if any
 G4GeometryManager::GetInstance()->OpenGeometry();
 G4PhysicalVolumeStore::GetInstance()->Clean();
 G4LogicalVolumeStore::GetInstance()->Clean();
 G4SolidStore::GetInstance()->Clean();

 // complete the detector parameters.
 ComputeDependentDetectorParameters();

 ConstructWorld();
 ConstructBetaDetector();
 ConstructScintillatorBox();
 ConstructScintillatorSlot();
 ConstructScintillator();
 ConstructShielding();
 ConstructShieldingBeamBlocker();
 ConstructScintillatorPlates();
 ConstructSlowdown();
 ConstructGermaniumDetector();
 ConstructBeamBlocker();

 SetVisualizationAttributes();
 //Always return the physical world.
 return physiWorld;
}

void DetectorConstruction::SetScintillatorMaterial(G4String materialChoice)
{
 // search the material by its name   
 G4Material* pttoMaterial = G4Material::GetMaterial(materialChoice);     
 if (pttoMaterial) ScintillatorMaterial = pttoMaterial;
}

void DetectorConstruction::SetSlowdownMaterial(G4String materialChoice)
{
 // search the material by its name   
 G4Material* pttoMaterial = G4Material::GetMaterial(materialChoice);     
 if (pttoMaterial) SlowdownMaterial = pttoMaterial;
}

void DetectorConstruction::SetEffectiveSlowdownThickness(G4double thickness)
{
  EffectiveSlowdownThickness = thickness;
  
}

void DetectorConstruction::SetSlowdownLength(G4double length)
{
  SlowdownLength = length;
}

void DetectorConstruction::SetSlowdownThickness(G4double thickness)
{
  SlowdownThickness = thickness;
}

void DetectorConstruction::SetGapMaterial(G4String materialChoice)
{
 // search the material by its name
 G4Material* pttoMaterial = G4Material::GetMaterial(materialChoice);
 if (pttoMaterial) GapMaterial = pttoMaterial;
}

void DetectorConstruction::SetGeDetectorShellMaterial(G4String materialChoice)
{
 // search the material by its name
 G4Material* pttoMaterial = G4Material::GetMaterial(materialChoice);
 if (pttoMaterial) GeDetectorShellMaterial = pttoMaterial;
}

void DetectorConstruction::SetShieldingMaterial(G4String materialChoice)
{
 // search the material by its name
 G4Material* pttoMaterial = G4Material::GetMaterial(materialChoice);
 if (pttoMaterial) ShieldingMaterial = pttoMaterial;
}

void DetectorConstruction::SetBeamBlockerMaterial(G4String materialChoice)
{
 // search the material by its name
 G4Material* pttoMaterial = G4Material::GetMaterial(materialChoice);
 if (pttoMaterial) BeamBlockerMaterial = pttoMaterial;
}


void DetectorConstruction::SetShieldingBeamBlockerMaterial(G4String materialChoice)
{
  G4Material* pttoMaterial = G4Material::GetMaterial(materialChoice);
  if (pttoMaterial) ShieldingBeamBlockerMaterial = pttoMaterial;
}

void DetectorConstruction::SetGermaniumDetectorMaterial(G4String materialChoice)
{
 // search the material by its name
 G4Material* pttoMaterial = G4Material::GetMaterial(materialChoice);
 if (pttoMaterial) GermaniumDetectorMaterial = pttoMaterial;
}

void DetectorConstruction::SetScintillatorDiameter(G4double val)
{
 // change Absorber thickness and recompute the calorimeter parameters
 ScintillatorDiameter = val;
}

void DetectorConstruction::SetScintillatorShieldingGapThickness(G4double val)
{
 // change Gap thickness and recompute the calorimeter parameters
 ScintillatorShieldingGapThickness = val;
}

void DetectorConstruction::SetBeamBlockerThickness(G4double thickness)
{
  BeamBlockerThickness = thickness;
}

void DetectorConstruction::SetShieldingBeamBlockerThickness(G4double thickness)
{
  ShieldingBeamBlockerThickness = thickness;
}

void DetectorConstruction::SetShieldingThickness(G4double thickness)
{
  ShieldingThickness = thickness;
}


void DetectorConstruction::SetTopShieldingThickness(G4double thickness)
{
  TopShieldingThickness = thickness;
}


void DetectorConstruction::SetGeDetectorRadius(G4double radius)
{
  GeDetectorRadius = radius;
}

void DetectorConstruction::SetGeDetectorShellLength(G4double length)
{
  GeDetectorShellLength = length;
}

void DetectorConstruction::SetGeDetectorLength(G4double length)
{
  GeDetectorLength = length;
}

void DetectorConstruction::SetGeDetectorShellInnerRadius(G4double radius)
{
  GeDetectorShellInnerRadius = radius;
}

void DetectorConstruction::SetGeDetectorShellOuterRadius(G4double radius)
{
  GeDetectorShellOuterRadius = radius;
}


void DetectorConstruction::SetNumberOfScintillatorsPerBox(G4int val)
{
 NumberOfScintillatorsPerBox = val;
}

void DetectorConstruction::SetNumberOfScintillatorBoxes(G4int val)
{
  NumberOfScintillatorBoxes = val;
}


void DetectorConstruction::SetBetaFlipping(G4bool flip)
{
  FlipBeta = flip;
}


void DetectorConstruction::UpdateGeometry()
{
 G4RunManager::GetRunManager()->DefineWorldVolume(ConstructDetector());
}