DetectorConstruction.hh

Go to the documentation of this file.

#ifndef DetectorConstruction_h
#define DetectorConstruction_h 1//!<Inclusion guard

#include "G4VUserDetectorConstruction.hh" 
#include "globals.hh"
#include "G4FieldManager.hh"
#include "G4TransportationManager.hh"
#include "G4RunManager.hh"
#include "DetectorMessenger.hh"

#include "G4Material.hh"
#include "G4Tubs.hh"
#include "G4Trap.hh"
#include "G4Box.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4PVReplica.hh"

#include "G4GeometryManager.hh"
#include "G4PhysicalVolumeStore.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4SolidStore.hh"

#include "G4VisAttributes.hh"
#include "G4Colour.hh"




class G4Trap;
class G4Tubs;
class G4Box;
class G4LogicalVolume;
class G4VPhysicalVolume;
class G4Material;
class G4UniformMagField;
class DetectorMessenger;


class DetectorConstruction : public G4VUserDetectorConstruction
{
  public:
  DetectorConstruction(); 
  ~DetectorConstruction(); 

  void SetDefaultDetectorParameters();

  //CHANGE A MATERIAL: INVOKED FROM MESSENGER CLASS
  void SetScintillatorMaterial (G4String 
                                ); 

  void SetScintillatorDiameter(G4double 
                               ); 
  
  void SetShieldingMaterial(G4String 
                            ); 
  
  void SetGeDetectorShellMaterial(G4String
                                     ); 

  void SetBeamBlockerMaterial(G4String 
                                 ); 

  void SetShieldingBeamBlockerMaterial(G4String 
                                       ); 

  void SetGermaniumDetectorMaterial(G4String 
                                       ); 

  void SetEffectiveSlowdownThickness(G4double thickness 
                                     ); 

  void SetSlowdownLength(G4double length 
                                               ); 
  
  void SetSlowdownThickness(G4double thickness 
                                                  ); 

void SetShieldingThickness(G4double thickness 
                                                  ); 

void SetTopShieldingThickness(G4double thickness 
                                                  ); 
  
  void SetBeamBlockerThickness(G4double thickness 
                               ); 

  void SetShieldingBeamBlockerThickness(G4double thickness 
                                        );


  void SetGeDetectorRadius(G4double radius 
                                                 ); 
  void SetGeDetectorShellLength(G4double length 
                                                      ); 

  void SetGeDetectorLength(G4double length 
                                                 ); 

  void SetGeDetectorShellInnerRadius(G4double radius 
                                                           ); 

  void SetGeDetectorShellOuterRadius(G4double radius 
                                                           ); 

  void SetGapMaterial (G4String 
                          ); 

  void SetScintillatorShieldingGapThickness(G4double 
                          ); 

  void SetSlowdownMaterial(G4String 
                              ); 

  
  void SetSlowdownHeightGap(G4double 
                               ); 

  void SetNumberOfScintillatorBoxes(G4int 
                                    ); 

  void SetNumberOfScintillatorsPerBox (G4int 
                         ); 

  void SetBetaFlipping(G4bool 
                       ); 
      
  G4VPhysicalVolume* Construct(); 
  
  void UpdateGeometry(); 
  
  G4double GetWorldSizeX() {return WorldSizeX;};
  G4double GetWorldSizeY() {return WorldSizeY;}; 
  G4double GetWorldSizeZ() {return WorldSizeZ;}; 



  G4double GetScintillatorBoxSizeX() {return ScintillatorBoxSizeX;};
  G4double GetScintillatorBoxSizeY() {return ScintillatorBoxSizeY;};
  G4double GetScintillatorBoxSizeZ() {return ScintillatorBoxSizeZ;};

  G4double GetBackScintillatorPlateSizeY(){ return BackScintillatorPlateSizeY;}
  
  G4int    GetNumberOfScintillatorBoxes() {return NumberOfScintillatorBoxes;};
  G4int    GetNumberOfScintillatorsPerBox() {return NumberOfScintillatorsPerBox;}; 
  

  G4Material* GetScintillatorMaterial() {return ScintillatorMaterial;};
  G4double    GetScintillatorDiameter() {return ScintillatorDiameter;};      
  G4Material* GetGapMaterial() {return GapMaterial;};
  G4double    GetScintillatorShieldingGapThickness() {return ScintillatorShieldingGapThickness;};
  const G4VPhysicalVolume* GetphysiWorld() {return physiWorld;};           
  const G4VPhysicalVolume* GetAbsorber()  {return physiScintillator;};
  const G4VPhysicalVolume* GetGap() {return physiGap;};
  const G4VPhysicalVolume* GetScintillator() {return physiScintillator;};
  const G4VPhysicalVolume* GetUpperBetaDetector() {return physiUpperBetaDetector;};
  const G4VPhysicalVolume* GetLowerBetaDetector() {return physiLowerBetaDetector;};
  const G4VPhysicalVolume* GetGermaniumDetector() {return physiGermaniumDetector;};
  const G4VPhysicalVolume* GetUpperFrontScintillatorPlate() {return physiUpperFrontScintillatorPlate;};
  const G4VPhysicalVolume* GetLowerFrontScintillatorPlate() {return physiLowerFrontScintillatorPlate;};
  const G4VPhysicalVolume* GetBackScintillatorPlate() {return physiBackScintillatorPlate;};

private:
  
  G4Material*        ScintillatorMaterial;     
  G4double           ScintillatorThickness;    
  
  G4Material*        GapMaterial;             
  G4double           ScintillatorShieldingGapThickness;            
  
  G4int              NumberOfScintillatorsPerBox;              
  G4int         NumberOfScintillatorBoxes;   
  
  G4double              ScintillatorBoxSizeX;    
  G4double           ScintillatorBoxSizeY;    
  G4double           ScintillatorBoxSizeZ;    
  G4double              SlotWidthY;    
  G4double           SlotWidthZ;     
 
  G4double              ScintillatorDiameter;    
  G4double              ScintillatorLength;      
  
  G4double           ScintillatorPlateThickness;    
  G4double           FrontScintillatorPlateSizeY;    
  G4double           FrontScintillatorPlateSizeZ;    
  G4double           BackScintillatorPlateSizeY;    
  
  G4double              GeDetectorRadius;              
  G4double              GeDetectorLength;              
  G4double              GeDetectorShellLength;         
  G4double              GeDetectorShellInnerRadius;    
  G4double              GeDetectorShellOuterRadius;    
  G4double              BeamBlockerThickness;          

  G4double              ShieldingBeamBlockerThickness; 

  G4double              GeDetectorContainerSizeX;      
  
  G4Material*        defaultMaterial;   
  G4double              WorldSizeZ;        
  G4double           WorldSizeY;        
  G4double           WorldSizeX;        
  
  G4Material*   ShieldingMaterial;        
  G4double              ShieldingThickness;       
  G4double              TopShieldingThickness;    
  
  G4Material*        BeamBlockerMaterial; 

  G4Material*        ShieldingBeamBlockerMaterial; 
  
  G4Box*             solidWorld;    
  G4LogicalVolume*   logicWorld;    
  G4VPhysicalVolume* physiWorld;    
  
  G4Material*        GeDetectorShellMaterial; 
  G4Material*        GermaniumDetectorMaterial; 
  
  
  G4Box*             solidScintillatorBox;    
  G4LogicalVolume*   logicScintillatorBox;    
  G4VPhysicalVolume* physiScintillatorBox;    
  
  
  
  
  
  
  G4Box*             solidSlot;    
  G4LogicalVolume*   logicSlot;    
  G4VPhysicalVolume* physiSlot;    
  
  G4Tubs*            solidScintillator; 
  G4LogicalVolume*   logicScintillator; 
  G4VPhysicalVolume* physiScintillator; 
  
  G4Box*             solidGap;      
  G4LogicalVolume*   logicGap;      
  G4VPhysicalVolume* physiGap;      
  
  
  
  
  G4Box*             solidShielding;    
  G4LogicalVolume*   logicShielding;    
  G4VPhysicalVolume* physiShielding;    
  
  
  G4Box*             solidTopShielding;    
  G4LogicalVolume*   logicTopShielding;    
  G4VPhysicalVolume* physiTopShielding;    


  G4Box*             solidShieldingBeamBlocker;    
  G4LogicalVolume*   logicShieldingBeamBlocker;    
  G4VPhysicalVolume* physiShieldingBeamBlocker;    
  
  
  G4Box*             solidTopShieldingBeamBlocker;    
  G4LogicalVolume*   logicTopShieldingBeamBlocker;    
  G4VPhysicalVolume* physiTopShieldingBeamBlocker;    



  
  G4Box*             solidBetaDetector;    
  G4LogicalVolume*   logicBetaDetector;    
  G4VPhysicalVolume* physiUpperBetaDetector;    
  
  G4Box*             solidLowerBetaDetector;    
  G4LogicalVolume*   logicLowerBetaDetector;    
  G4VPhysicalVolume* physiLowerBetaDetector;    
  
  
  
  DetectorMessenger* detectorMessenger;  
  
  
  G4Box*             solidFrontScintillatorPlate;      
  G4LogicalVolume*   logicFrontScintillatorPlate;      
  G4VPhysicalVolume* physiUpperFrontScintillatorPlate;      
  G4VPhysicalVolume* physiLowerFrontScintillatorPlate;      
  
  G4Box*             solidBackScintillatorPlate;      
  G4LogicalVolume*   logicBackScintillatorPlate;      
  G4VPhysicalVolume* physiBackScintillatorPlate;      
  
  
  
  
  
  
  G4double SlowdownThickness;                 
  G4double SlowdownLength;                    
  G4double SlowdownHeightGap;                 
  G4double EffectiveSlowdownThickness;           
  
  G4Trap*            solidSlowdown;              
  G4LogicalVolume*   logicSlowdown;              
  G4VPhysicalVolume* physiUpperSlowdown;      
  G4VPhysicalVolume* physiLowerSlowdown;      
  
  G4Material*        SlowdownMaterial; 
  
  
  
  
  G4Tubs*            solidGermaniumDetector; 
  G4LogicalVolume*   logicGermaniumDetector; 
  G4VPhysicalVolume* physiGermaniumDetector; 
  
  
  G4Tubs*            solidGeDetectorShell; 
  G4LogicalVolume*   logicGeDetectorShell; 
  G4VPhysicalVolume* physiGeDetectorShell; 
  
  G4Box*            solidGeDetectorContainer; 
  G4LogicalVolume*   logicGeDetectorContainer; 
  G4VPhysicalVolume* physiGeDetectorContainer; 
  
  
  
  
  
  G4Tubs*            solidGeDetectorShellTop; 
  G4LogicalVolume*   logicGeDetectorShellTop; 
  G4VPhysicalVolume* physiGeDetectorShellTop; 
  
  G4Tubs*            solidGeDetectorShellBottom; 
  G4LogicalVolume*   logicGeDetectorShellBottom; 
  G4VPhysicalVolume* physiGeDetectorShellBottom; 
  
  G4Box*            solidBeamBlocker;  
  G4LogicalVolume*   logicBeamBlocker; 
  G4VPhysicalVolume* physiBeamBlocker; 
  
  
  G4double BetaDetectorPositionY; 
  G4double BeamBlockerYWidth; 
  G4double BeamBlockerZWidth; 
  G4double BeamBlockerXPosition; 
  G4double ScintillatorPositionX;
  G4double ScintillatorPositionY;
  G4double ScintillatorPositionZ;

  G4double ShieldingPositionX;
  G4double ShieldingPositionY;
  G4double ShieldingPositionZ;

  G4double TopShieldingPositionX;
  G4double TopShieldingPositionY;
  G4double TopShieldingPositionZ;

  G4double PlateShieldingSpacing;

  G4double ShieldingBeamBlockerPositionX;

  G4bool FlipBeta;

private:
  
  void ConstructWorld();
  void ConstructBetaDetector();
  void ConstructScintillatorBox();
  void ConstructScintillatorSlot();
  void ConstructScintillator();
  void ConstructShielding();
  void ConstructBeamBlocker();
  void ConstructScintillatorPlates();
  void ConstructSlowdown();
  void ConstructGermaniumDetector();
  void ConstructShieldingBeamBlocker();
  void SetVisualizationAttributes();
 
    
  void DefineMaterials(); 
  void ComputeDependentDetectorParameters(); 
  G4VPhysicalVolume* ConstructDetector(); 
};

inline void DetectorConstruction::ComputeDependentDetectorParameters()
{
  // Compute derived parameters of the scintillators
  SlotWidthY = ScintillatorDiameter + 2*ScintillatorShieldingGapThickness + TopShieldingThickness; //Width of one scintillator slot in Y direction.
  SlotWidthZ = ScintillatorDiameter + 2*ScintillatorShieldingGapThickness + ShieldingThickness;   //Width of one scintillator slot in Z direction.


  ScintillatorBoxSizeX  = ScintillatorLength + ShieldingBeamBlockerThickness;
  ScintillatorBoxSizeY = SlotWidthY;   //The scintillator box has the same Y width as the slot.
  ScintillatorBoxSizeZ = NumberOfScintillatorsPerBox*SlotWidthZ;   //The scintillator box has the sum of the slotwidths of the individual scintillators as width.

  GeDetectorContainerSizeX = 1.*GeDetectorShellOuterRadius+ScintillatorLength+BeamBlockerThickness;    //Calculating GeDetectorContainerSizeX.
  
  FrontScintillatorPlateSizeY = (NumberOfScintillatorBoxes*ScintillatorBoxSizeY-TopShieldingThickness);
  BackScintillatorPlateSizeY = 2*ScintillatorBoxSizeY*NumberOfScintillatorBoxes + 1.1*2*GeDetectorShellOuterRadius; //3*1.2*GeDetectorShellOuterRadius+ScintillatorDiameter;
  
  SlowdownHeightGap = (SlowdownThickness - EffectiveSlowdownThickness)*(SlowdownLength/SlowdownThickness);     //Calculating SlowdownHeightGap.
  
  BetaDetectorPositionY = ScintillatorBoxSizeY*NumberOfScintillatorBoxes/2+1.1*GeDetectorShellOuterRadius;
  

  ShieldingBeamBlockerPositionX = -ScintillatorLength/2;

  ScintillatorPositionX = ShieldingBeamBlockerThickness/2;
  ScintillatorPositionY = -TopShieldingThickness/2;
  ScintillatorPositionZ = -ShieldingThickness/2;

  ShieldingPositionX = ScintillatorPositionX;
  ShieldingPositionY = 0;
  ShieldingPositionZ = (SlotWidthZ-ShieldingThickness)/2;   //its position

  TopShieldingPositionX = ScintillatorPositionX;
  TopShieldingPositionY = (SlotWidthY-TopShieldingThickness)/2;
  TopShieldingPositionZ = -ShieldingThickness/2;

  BeamBlockerYWidth = 2*1.1*GeDetectorShellOuterRadius;
  BeamBlockerZWidth = 1.1*GeDetectorShellLength;
  BeamBlockerXPosition = -(GeDetectorContainerSizeX-BeamBlockerThickness)/2;
  
  // X and Z expression aren't completely general, unfortunately.
  WorldSizeX = 1.5*2*(1.2*ScintillatorBoxSizeX + SlowdownThickness*1.2); 
  WorldSizeY = std::max(2*1.2*SlowdownLength, NumberOfScintillatorBoxes*2*1.2*ScintillatorBoxSizeY + 2.*GeDetectorShellOuterRadius); 
  WorldSizeZ = std::max(2*1.2*ScintillatorBoxSizeZ,1.1*GeDetectorShellLength*1.2);
}

#endif