#include <WLSDetectorConstruction.hh>

Inheritance diagram for WLSDetectorConstruction:

Collaboration diagram for WLSDetectorConstruction:

Public Member Functions
	WLSDetectorConstruction ()

virtual	~WLSDetectorConstruction ()

virtual G4VPhysicalVolume *	Construct ()

G4VPhysicalVolume *	ConstructDetector ()

virtual void	ConstructSDandField ()

void	SetWorldMaterial (G4String)

void	SetWLSFiberMaterial (G4String)

void	SetCoupleMaterial (G4String)

void	SetPhotonDetGeometry (G4String)

void	SetNumberOfCladding (G4int)

void	SetWLSLength (G4double)

void	SetWLSRadius (G4double)

void	SetClad1Radius (G4double)

void	SetClad2Radius (G4double)

void	SetPhotonDetHalfLength (G4double)

void	SetGap (G4double)

void	SetPhotonDetAlignment (G4double)

void	SetXYRatio (G4double)

void	SetSurfaceRoughness (G4double)

void	SetMirrorReflectivity (G4double)

void	SetMirrorPolish (G4double)

void	SetPhotonDetReflectivity (G4double)

void	SetPhotonDetPolish (G4double)

void	SetMirror (G4bool)

void	SetBarLength (G4double)

void	SetBarBase (G4double)

void	SetHoleRadius (G4double)

void	SetCoatingThickness (G4double)

void	SetCoatingRadius (G4double)

G4double	GetWLSFiberLength ()

G4double	GetWLSFiberEnd ()

G4double	GetWLSFiberRMax ()

G4double	GetSurfaceRoughness ()

G4bool	IsPerfectFiber ()

G4double	GetBarLength ()

G4double	GetBarBase ()

G4double	GetHoleRadius ()

G4double	GetHoleLength ()

G4double	GetFiberRadius ()

G4double	GetCoatingThickness ()

G4double	GetCoatingRadius ()

G4Material *	FindMaterial (G4String)

Public Member Functions inherited from G4VUserDetectorConstruction
	G4VUserDetectorConstruction ()

virtual	~G4VUserDetectorConstruction ()

virtual void	CloneSD ()

virtual void	CloneF ()

void	RegisterParallelWorld (G4VUserParallelWorld *)

G4int	ConstructParallelGeometries ()

void	ConstructParallelSD ()

G4int	GetNumberOfParallelWorld () const

G4VUserParallelWorld *	GetParallelWorld (G4int i) const

Static Public Member Functions
static G4RotationMatrix	StringToRotationMatrix (G4String rotation)

Private Member Functions
void	ConstructFiber ()

void	UpdateGeometryParameters ()

Private Attributes
WLSMaterials *	fMaterials

G4LogicalVolume *	fLogicHole

G4LogicalVolume *	fLogicWorld

G4VPhysicalVolume *	fPhysiWorld

G4VPhysicalVolume *	fPhysiHole

G4double	fWorldSizeX

G4double	fWorldSizeY

G4double	fWorldSizeZ

G4double	fWLSfiberRX

G4double	fWLSfiberRY

G4double	fWLSfiberZ

G4double	fClad1RX

G4double	fClad1RY

G4double	fClad1Z

G4double	fClad2RX

G4double	fClad2RY

G4double	fClad2Z

G4double	fClrfiberHalfL

G4double	fClrfiberZ

G4double	fCoupleRX

G4double	fCoupleRY

G4double	fCoupleZ

G4double	fMirrorRmax

G4double	fMirrorZ

G4bool	fMirrorToggle

G4String	fMPPCShape

G4double	fMPPCHalfL

G4double	fMPPCZ

G4double	fMPPCDist

G4double	fMPPCTheta

G4double	fWLSfiberOrigin

G4double	fCoupleOrigin

G4double	fMirrorOrigin

G4double	fMPPCOriginX

G4double	fMPPCOriginZ

G4int	fNumOfCladLayers

G4double	fMirrorPolish

G4double	fMirrorReflectivity

G4double	fMPPCPolish

G4double	fMPPCReflectivity

G4double	fExtrusionPolish

G4double	fExtrusionReflectivity

G4double	fSurfaceRoughness

G4double	fXYRatio

G4double	fBarLength

G4double	fBarBase

G4double	fHoleRadius

G4double	fHoleLength

G4double	fCoatingThickness

G4double	fCoatingRadius

WLSDetectorMessenger *	fDetectorMessenger

G4Cache< WLSPhotonDetSD * >	fmppcSD

Additional Inherited Members
Protected Member Functions inherited from G4VUserDetectorConstruction
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)

void	SetSensitiveDetector (G4LogicalVolume logVol, G4VSensitiveDetector aSD)

Detailed Description

Definition at line 60 of file WLSDetectorConstruction.hh.

Constructor & Destructor Documentation

◆ WLSDetectorConstruction()

WLSDetectorConstruction::WLSDetectorConstruction ( )

Definition at line 67 of file WLSDetectorConstruction.cc.

   : fMaterials(NULL), fLogicHole(NULL), fLogicWorld(NULL),
     fPhysiWorld(NULL), fPhysiHole(NULL)
 {
   fDetectorMessenger = new WLSDetectorMessenger(this);
 
   fNumOfCladLayers = 0;
  
   fSurfaceRoughness = 1;
  
   fMirrorToggle = true;
   fMirrorPolish = 1.;
   fMirrorReflectivity = 1.;
 
   fMPPCPolish = 1.;
   fMPPCReflectivity = 0.;
 
   fExtrusionPolish = 1.;
   fExtrusionReflectivity = 1.;
  
   fXYRatio = 1.0;
 
   fWLSfiberZ     = 1.*m;
   fWLSfiberRY  = 0.5*mm;
   fWLSfiberOrigin = 0.0;
  
   fMPPCShape = "Circle";
   fMPPCHalfL = fWLSfiberRY;
   fMPPCDist  = 0.00*mm;
   fMPPCTheta = 0.0*deg;
   fMPPCZ     = 0.05*mm;
  
   fClrfiberZ  = fMPPCZ + 10.*nm;
   fMirrorZ    = 0.1*mm;
 
   fBarLength        = 1.*m;
   fBarBase          = 9.6*mm;
   fHoleRadius       = 0.9*mm;
   fHoleLength       = fBarLength;
   fCoatingThickness = 0.25*mm;
   fCoatingRadius    = 1.875*mm;
 }

◆ ~WLSDetectorConstruction()

WLSDetectorConstruction::~WLSDetectorConstruction ( )

virtual

Definition at line 112 of file WLSDetectorConstruction.cc.

 {
   if (fDetectorMessenger) delete fDetectorMessenger;
   if (fMaterials)         delete fMaterials;
 }

Member Function Documentation

◆ Construct()

G4VPhysicalVolume * WLSDetectorConstruction::Construct ( void )

virtual

Implements G4VUserDetectorConstruction.

Definition at line 120 of file WLSDetectorConstruction.cc.

 {
   if (fPhysiWorld) {
      G4GeometryManager::GetInstance()->OpenGeometry();
      G4PhysicalVolumeStore::GetInstance()->Clean();
      G4LogicalVolumeStore::GetInstance()->Clean();
      G4SolidStore::GetInstance()->Clean();
      G4LogicalSkinSurface::CleanSurfaceTable();
      G4LogicalBorderSurface::CleanSurfaceTable();
   }
 
   fMaterials = WLSMaterials::GetInstance();
 
   UpdateGeometryParameters();
 
   return ConstructDetector();
 }

Here is the call graph for this function:

◆ ConstructDetector()

G4VPhysicalVolume * WLSDetectorConstruction::ConstructDetector ( )

Definition at line 140 of file WLSDetectorConstruction.cc.

 {
   //--------------------------------------------------
   // World
   //--------------------------------------------------
 
   G4VSolid* solidWorld =
                     new G4Box("World", fWorldSizeX, fWorldSizeY, fWorldSizeZ);
 
   fLogicWorld = new G4LogicalVolume(solidWorld,
                                    FindMaterial("G4_AIR"),
                                    "World");
 
   fPhysiWorld = new G4PVPlacement(0,
                                   G4ThreeVector(),
                                   fLogicWorld,
                                   "World",
                                   0,
                                   false,
                                   0);
 
   //--------------------------------------------------
   // Extrusion
   //--------------------------------------------------
 
   G4VSolid* solidExtrusion =
         new G4Box("Extrusion",GetBarBase()/2,GetBarBase()/2,GetBarLength()/2);
 
   G4LogicalVolume* logicExtrusion =
                       new G4LogicalVolume(solidExtrusion,
                                           FindMaterial("Coating"),
                                           "Extrusion");
 
   G4OpticalSurface* TiO2Surface = new G4OpticalSurface("TiO2Surface",
                                                        glisur,
                                                        ground,
                                                        dielectric_metal,
                                                        fExtrusionPolish);
 
   G4MaterialPropertiesTable* TiO2SurfaceProperty =
                                              new G4MaterialPropertiesTable();
 
   G4double p_TiO2[] = {2.00*eV, 3.47*eV};
   const G4int nbins = sizeof(p_TiO2)/sizeof(G4double);
 
   G4double refl_TiO2[] = {fExtrusionReflectivity,fExtrusionReflectivity};
   assert(sizeof(refl_TiO2) == sizeof(p_TiO2));
   G4double effi_TiO2[] = {0, 0};
   assert(sizeof(effi_TiO2) == sizeof(p_TiO2));
 
   TiO2SurfaceProperty -> AddProperty("REFLECTIVITY",p_TiO2,refl_TiO2,nbins);
   TiO2SurfaceProperty -> AddProperty("EFFICIENCY",p_TiO2,effi_TiO2,nbins);
 
   TiO2Surface -> SetMaterialPropertiesTable(TiO2SurfaceProperty);
 
   new G4PVPlacement(0,
                     G4ThreeVector(),
                     logicExtrusion,
                     "Extrusion",
                     fLogicWorld,
                     false,
                     0);
 
   new G4LogicalSkinSurface("TiO2Surface",logicExtrusion,TiO2Surface);
 
   //--------------------------------------------------
   // Scintillator
   //--------------------------------------------------
 
   G4VSolid* solidScintillator = new G4Box("Scintillator",
                                 GetBarBase()/2-GetCoatingThickness()
                                            -GetCoatingRadius(),
                                 GetBarBase()/2-GetCoatingThickness()
                                            -GetCoatingRadius(),
                                 GetBarLength()/2);
 
   G4LogicalVolume* logicScintillator =
                              new G4LogicalVolume(solidScintillator,
                                                  FindMaterial("Polystyrene"),
                                                  "Scintillator");
 
   new G4PVPlacement(0,
                     G4ThreeVector(),
                     logicScintillator,
                     "Scintillator",
                     logicExtrusion,
                     false,
                     0);
 
   if (GetCoatingRadius() > 0.*mm) {
      G4VSolid* solidScintside = new G4Box("SideOfBar",
                                 GetBarBase()/2-GetCoatingThickness()
                                            -GetCoatingRadius(),
                                 GetCoatingRadius()/2,
                                 GetBarLength()/2);
      G4VSolid* solidScintcrnr = new G4Tubs("CrnrOfBar",
                                  0.0*cm,
                                  GetCoatingRadius(),
                                  GetBarLength()/2,
                                  0.*deg,
                                  90.*deg);
      G4LogicalVolume* logicScintSide =
                              new G4LogicalVolume(solidScintside,
                                                  FindMaterial("Polystyrene"),
                                                  "SideOfBar");
 
      G4LogicalVolume* logicScintCrnr =
                              new G4LogicalVolume(solidScintcrnr,
                                                  FindMaterial("Polystyrene"),
                                                  "CrnrOfBar");
 
      G4double x = GetBarBase()/2-GetCoatingThickness()-GetCoatingRadius()/2;
      G4double y = GetBarBase()/2-GetCoatingThickness()-GetCoatingRadius()/2;
 
      new G4PVPlacement(0,
                        G4ThreeVector(0,-y,0),
                        logicScintSide,
                        "SideOfBar",
                        logicExtrusion,
                        false,
                        0);
      new G4PVPlacement(0,
                        G4ThreeVector(0, y,0),
                        logicScintSide,
                        "SideOfBar",
                        logicExtrusion,
                        false,
                        1);
 
      G4RotationMatrix* g4rot = new G4RotationMatrix();
      *g4rot = StringToRotationMatrix("Z90");
      *g4rot = g4rot->inverse();
      if (*g4rot == G4RotationMatrix()) g4rot = NULL;
 
      new G4PVPlacement(g4rot,
                        G4ThreeVector(x,0,0),
                        logicScintSide,
                        "SideOfBar",
                        logicExtrusion,
                        false,
                        2);
      new G4PVPlacement(g4rot,
                        G4ThreeVector(-x,0,0),
                        logicScintSide,
                        "SideOfBar",
                        logicExtrusion,
                        false,
                        3);
 
      x = GetBarBase()/2-GetCoatingThickness()-GetCoatingRadius();
      y = GetBarBase()/2-GetCoatingThickness()-GetCoatingRadius();
 
      new G4PVPlacement(0,
                        G4ThreeVector(x,y,0),
                        logicScintCrnr,
                        "CrnrOfBar",
                        logicExtrusion,
                        false,
                        0);
 
      new G4PVPlacement(g4rot,
                        G4ThreeVector(-x,y,0),
                        logicScintCrnr,
                        "CrnrOfBar",
                        logicExtrusion,
                        false,
                        1);
 
      g4rot = new G4RotationMatrix();
      *g4rot = StringToRotationMatrix("Z180");
      *g4rot = g4rot->inverse();
      if (*g4rot == G4RotationMatrix()) g4rot = NULL;
 
      new G4PVPlacement(g4rot,
                        G4ThreeVector(-x,-y,0),
                        logicScintCrnr,
                        "CrnrOfBar",
                        logicExtrusion,
                        false,
                        2);
 
      g4rot = new G4RotationMatrix();
      *g4rot = StringToRotationMatrix("Z270");
      *g4rot = g4rot->inverse();
      if (*g4rot == G4RotationMatrix()) g4rot = NULL;
 
      new G4PVPlacement(g4rot,
                        G4ThreeVector(x,-y,0),
                        logicScintCrnr,
                        "CrnrOfBar",
                        logicExtrusion,
                        false,
                        3);
 
   }
 
   if (GetFiberRadius()<GetHoleRadius()) {
 
         G4VSolid* solidHole = new G4Tubs("Hole",
                                          0.0*cm,
                                          GetHoleRadius(),
                                          GetHoleLength()/2,
                                          0.*deg,
                                          360.*deg);
         fLogicHole = new G4LogicalVolume(solidHole,
                                          FindMaterial("G4_AIR"),
                                          "Hole");
 
         fPhysiHole = new G4PVPlacement(0,
                                        G4ThreeVector(),
                                        fLogicHole,
                                        "Hole",
                                        logicScintillator,
                                        false,
                                        0);
   }
 
   //--------------------------------------------------
   // Fiber
   //--------------------------------------------------
 
   ConstructFiber();
 
   //--------------------------------------------------
   // End of Construction
   //--------------------------------------------------
 
   return fPhysiWorld;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructFiber()

void WLSDetectorConstruction::ConstructFiber ( )

private

Definition at line 372 of file WLSDetectorConstruction.cc.

 {
   if (!(fLogicHole) || !(fPhysiHole) ) {
      std::ostringstream o;
      o << "The Fiber Hole has not been constructed";
      G4Exception("WLSDetectorConstruction::ConstructFiber","",
                   FatalException,o.str().c_str());
   }
 
   // Pointers to the most recently constructed volume
   G4LogicalVolume* logicPlacement = fLogicHole;
   G4VPhysicalVolume* physiPlacement = fPhysiHole;
 
   //--------------------------------------------------
   // Fiber Construction
   //-------------------------------------------------- 
 
   // Boundary Surface Properties
   G4OpticalSurface* opSurface = NULL;
  
   if (fSurfaceRoughness < 1.)
      opSurface = new G4OpticalSurface("RoughSurface",          // Surface Name
                                       glisur,                  // SetModel
                                       ground,                  // SetFinish
                                       dielectric_dielectric,   // SetType
                                       fSurfaceRoughness);      // SetPolish
 
   G4LogicalVolume   *logicClad1, *logicClad2;
   G4VPhysicalVolume *physiClad1, *physiClad2;
 
   // Determine the number of cladding layers to be built
   switch ( fNumOfCladLayers ) {
  
     case 2:
 
      //--------------------------------------------------
      // Cladding 2
      //--------------------------------------------------
 
      G4VSolid* solidClad2;
  
      if (fXYRatio == 1.)
        solidClad2 = new G4Tubs("Clad2",0.,fClad2RX,fClad2Z,0.0*rad,twopi*rad);
      else
        solidClad2 = new G4EllipticalTube("Clad2",fClad2RX,fClad2RY,fClad2Z);
 
      logicClad2  = new G4LogicalVolume(solidClad2,
                                        FindMaterial("FPethylene"),
                                        "Clad2");
 
      physiClad2 = new G4PVPlacement(0,
                                     G4ThreeVector(0.0,0.0,fWLSfiberOrigin),
                                     logicClad2,
                                     "Clad2",
                                     logicPlacement,
                                     false,
                                     0);
 
      // Place the rough surface only if needed
      if (opSurface) {
        new G4LogicalBorderSurface("surfaceClad2Out",
                                   physiClad2,
                                   physiPlacement,
                                   opSurface);
        new G4LogicalBorderSurface("surfaceClad2In",
                                   physiPlacement,
                                   physiClad2,
                                   opSurface);
      }
 
      logicPlacement = logicClad2;
      physiPlacement = physiClad2;
 
     case 1:
 
      //--------------------------------------------------
      // Cladding 1
      //--------------------------------------------------
 
      G4VSolid* solidClad1;
 
      if (fXYRatio == 1.)
        solidClad1 = new G4Tubs("Clad1",0.,fClad1RX,fClad1Z,0.0*rad,twopi*rad);
      else
        solidClad1 = new G4EllipticalTube("Clad1",fClad1RX,fClad1RY,fClad1Z);
 
      logicClad1 = new G4LogicalVolume(solidClad1,
                                       FindMaterial("Pethylene"),
                                       "Clad1");
 
      physiClad1 = new G4PVPlacement(0,
                                     G4ThreeVector(0.0,0.0,fWLSfiberOrigin),
                                     logicClad1,
                                     "Clad1",
                                     logicPlacement,
                                     false,
                                     0);
 
      // Place the rough surface only if needed
      if (opSurface) {
        new G4LogicalBorderSurface("surfaceClad1Out",
                                   physiClad1,
                                   physiPlacement,
                                   opSurface);
        new G4LogicalBorderSurface("surfaceClad1In",
                                   physiPlacement,
                                   physiClad1,
                                   opSurface);
      }
 
      logicPlacement = logicClad1;
      physiPlacement = physiClad1;
 
     default:
 
      //--------------------------------------------------
      // WLS Fiber
      //--------------------------------------------------
 
      G4VSolid* solidWLSfiber;
 
      if (fXYRatio == 1.)
        solidWLSfiber =
            new G4Tubs("WLSFiber",0.,fWLSfiberRX,fWLSfiberZ,0.0*rad,twopi*rad);
      else
        solidWLSfiber =
            new G4EllipticalTube("WLSFiber",fWLSfiberRX,fWLSfiberRY,fWLSfiberZ);
 
      G4LogicalVolume*   logicWLSfiber =
                                      new G4LogicalVolume(solidWLSfiber,
                                                          FindMaterial("PMMA"),
                                                          "WLSFiber");
 
      logicWLSfiber->SetUserLimits(new G4UserLimits(DBL_MAX,DBL_MAX,10*ms));
 
      G4VPhysicalVolume* physiWLSfiber = new G4PVPlacement(0,
                                        G4ThreeVector(0.0,0.0,fWLSfiberOrigin),
                                        logicWLSfiber,
                                        "WLSFiber",
                                        logicPlacement,
                                        false,
                                        0);
 
      // Place the rough surface only if needed
      if (opSurface) {
        new G4LogicalBorderSurface("surfaceWLSOut",
                                   physiWLSfiber,
                                   physiPlacement,
                                   opSurface);
        new G4LogicalBorderSurface("surfaceWLSIn",
                                   physiPlacement,
                                   physiWLSfiber,
                                   opSurface);
      }
   }
 
   //--------------------------------------------------
   // Mirror for reflection at one of the end
   //--------------------------------------------------
 
   // Place the mirror only if the user wants the mirror
   if (fMirrorToggle) {  
 
      G4VSolid* solidMirror = new G4Box("Mirror",
                                        fMirrorRmax,
                                        fMirrorRmax,
                                        fMirrorZ);
  
      G4LogicalVolume* logicMirror = new G4LogicalVolume(solidMirror,
                                                         FindMaterial("G4_Al"),
                                                         "Mirror");
 
      G4OpticalSurface* mirrorSurface = new G4OpticalSurface("MirrorSurface",
                                                              glisur,
                                                              ground,
                                                              dielectric_metal,
                                                              fMirrorPolish);
 
      G4MaterialPropertiesTable* mirrorSurfaceProperty =
                                               new G4MaterialPropertiesTable();
 
      G4double p_mirror[] = {2.00*eV, 3.47*eV};
      const G4int nbins = sizeof(p_mirror)/sizeof(G4double);
      G4double refl_mirror[] = {fMirrorReflectivity,fMirrorReflectivity};
      assert(sizeof(refl_mirror) == sizeof(p_mirror));
      G4double effi_mirror[] = {0, 0};
      assert(sizeof(effi_mirror) == sizeof(effi_mirror));
 
      mirrorSurfaceProperty->
                        AddProperty("REFLECTIVITY",p_mirror,refl_mirror,nbins);
      mirrorSurfaceProperty->
                        AddProperty("EFFICIENCY",p_mirror,effi_mirror,nbins);
 
      mirrorSurface -> SetMaterialPropertiesTable(mirrorSurfaceProperty);
 
      new G4PVPlacement(0,
                        G4ThreeVector(0.0,0.0,fMirrorOrigin),
                        logicMirror,
                        "Mirror",
                        fLogicWorld,
                        false,
                        0);
 
      new G4LogicalSkinSurface("MirrorSurface",logicMirror,mirrorSurface);
   }
 
   //--------------------------------------------------
   // Coupling at the read-out end
   //--------------------------------------------------
 
   // Clear Fiber (Coupling Layer)
   G4VSolid* solidCouple = new G4Box("Couple",fCoupleRX,fCoupleRY,fCoupleZ);
 
   G4LogicalVolume*   logicCouple = new G4LogicalVolume(solidCouple,
                                                        FindMaterial("G4_AIR"),
                                                        "Couple");
 
   new G4PVPlacement(0,
                     G4ThreeVector(0.0,0.0,fCoupleOrigin),
                     logicCouple,
                     "Couple",
                     fLogicWorld,
                     false,
                     0);
 
   //--------------------------------------------------
   // A logical layer in front of PhotonDet
   //--------------------------------------------------
 
   // Purpose: Preventing direct dielectric to metal contact
 
   // Check for valid placement of PhotonDet
   if (fMPPCTheta > std::atan(fMPPCDist / fMPPCHalfL)) {
 
      fMPPCTheta = 0;
      fMPPCOriginX  = std::sin(fMPPCTheta) * (fMPPCDist + fClrfiberZ);
      fMPPCOriginZ  = -fCoupleZ+std::cos(fMPPCTheta)*(fMPPCDist+fClrfiberZ);
      G4cerr << "Invalid alignment.  Alignment Reset to 0" << G4endl;
   }
  
   // Clear Fiber (Coupling Layer)
   G4VSolid* solidClrfiber;
  
   if ( fMPPCShape == "Square" )
     solidClrfiber =
        new G4Box("ClearFiber",fClrfiberHalfL,fClrfiberHalfL,fClrfiberZ);
   else
     solidClrfiber =
        new G4Tubs("ClearFiber",0.,fClrfiberHalfL,fClrfiberZ,0.0*rad,twopi*rad);
 
   G4LogicalVolume*   logicClrfiber =
                                    new G4LogicalVolume(solidClrfiber,
                                                        FindMaterial("G4_AIR"),
                                                        "ClearFiber");
 
   new G4PVPlacement(new G4RotationMatrix(CLHEP::HepRotationY(-fMPPCTheta)),
                     G4ThreeVector(fMPPCOriginX,0.0,fMPPCOriginZ),
                     logicClrfiber,
                     "ClearFiber",
                     logicCouple,
                     false,
                     0);
 
   //--------------------------------------------------
   // PhotonDet (Sensitive Detector)
   //--------------------------------------------------  
 
   // Physical Construction
   G4VSolid* solidPhotonDet;
 
   if ( fMPPCShape == "Square" )
     solidPhotonDet = new G4Box("PhotonDet",fMPPCHalfL,fMPPCHalfL,fMPPCZ);
   else
     solidPhotonDet =
                new G4Tubs("PhotonDet",0.,fMPPCHalfL,fMPPCZ,0.0*rad,twopi*rad);
 
   G4LogicalVolume*   logicPhotonDet =
                                     new G4LogicalVolume(solidPhotonDet,
                                                         FindMaterial("G4_Al"),
                                                         "PhotonDet_LV");
 
   new G4PVPlacement(0,
                     G4ThreeVector(0.0,0.0,0.0),
                     logicPhotonDet,
                     "PhotonDet",
                     logicClrfiber,
                     false,
                     0);
 
   // PhotonDet Surface Properties
   G4OpticalSurface* photonDetSurface = new G4OpticalSurface("PhotonDetSurface",
                                                        glisur,
                                                        ground,
                                                        dielectric_metal,
                                                        fMPPCPolish);
 
   G4MaterialPropertiesTable* photonDetSurfaceProperty =
                                                new G4MaterialPropertiesTable();
 
   G4double p_mppc[] = {2.00*eV, 3.47*eV};
   const G4int nbins = sizeof(p_mppc)/sizeof(G4double);
   G4double refl_mppc[] = {fMPPCReflectivity,fMPPCReflectivity};
   assert(sizeof(refl_mppc) == sizeof(p_mppc));
   G4double effi_mppc[] = {1, 1};
   assert(sizeof(effi_mppc) == sizeof(p_mppc));
  
   photonDetSurfaceProperty->AddProperty("REFLECTIVITY",p_mppc,refl_mppc,nbins);
   photonDetSurfaceProperty->AddProperty("EFFICIENCY",p_mppc,effi_mppc,nbins);
 
   photonDetSurface->SetMaterialPropertiesTable(photonDetSurfaceProperty);
 
   new G4LogicalSkinSurface("PhotonDetSurface",logicPhotonDet,photonDetSurface);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ConstructSDandField()

void WLSDetectorConstruction::ConstructSDandField ( )

virtual

Reimplemented from G4VUserDetectorConstruction.

Definition at line 688 of file WLSDetectorConstruction.cc.

 {
   if (!fmppcSD.Get()) {
      G4String mppcSDName = "WLS/PhotonDet";
      WLSPhotonDetSD* mppcSD = new WLSPhotonDetSD(mppcSDName);
      fmppcSD.Put(mppcSD);
   }
   SetSensitiveDetector("PhotonDet_LV", fmppcSD.Get(), true);
 }

Here is the call graph for this function:

◆ FindMaterial()

G4Material * WLSDetectorConstruction::FindMaterial ( G4String name )

Definition at line 1056 of file WLSDetectorConstruction.cc.

                                                                {
     G4Material* material = G4Material::GetMaterial(name,true);
     return material;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBarBase()

G4double WLSDetectorConstruction::GetBarBase ( )

Definition at line 998 of file WLSDetectorConstruction.cc.

998 { return fBarBase; }

WLSDetectorConstruction::fBarBase

G4double fBarBase

Definition: WLSDetectorConstruction.hh:197

Here is the caller graph for this function:

◆ GetBarLength()

G4double WLSDetectorConstruction::GetBarLength ( )

Definition at line 994 of file WLSDetectorConstruction.cc.

994 { return fBarLength; }

WLSDetectorConstruction::fBarLength

G4double fBarLength

Definition: WLSDetectorConstruction.hh:196

Here is the caller graph for this function:

◆ GetCoatingRadius()

G4double WLSDetectorConstruction::GetCoatingRadius ( )

Definition at line 1019 of file WLSDetectorConstruction.cc.

1019 { return fCoatingRadius; }

WLSDetectorConstruction::fCoatingRadius

G4double fCoatingRadius

Definition: WLSDetectorConstruction.hh:201

Here is the caller graph for this function:

◆ GetCoatingThickness()

G4double WLSDetectorConstruction::GetCoatingThickness ( )

Definition at line 1014 of file WLSDetectorConstruction.cc.

1015 { return fCoatingThickness; }

WLSDetectorConstruction::fCoatingThickness

G4double fCoatingThickness

Definition: WLSDetectorConstruction.hh:200

Here is the caller graph for this function:

◆ GetFiberRadius()

G4double WLSDetectorConstruction::GetFiberRadius ( )

Definition at line 1010 of file WLSDetectorConstruction.cc.

1010 { return GetWLSFiberRMax(); }

WLSDetectorConstruction::GetWLSFiberRMax

G4double GetWLSFiberRMax()

Definition: WLSDetectorConstruction.cc:1030

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetHoleLength()

G4double WLSDetectorConstruction::GetHoleLength ( )

Definition at line 1006 of file WLSDetectorConstruction.cc.

1006 { return fHoleLength; }

WLSDetectorConstruction::fHoleLength

G4double fHoleLength

Definition: WLSDetectorConstruction.hh:199

Here is the caller graph for this function:

◆ GetHoleRadius()

G4double WLSDetectorConstruction::GetHoleRadius ( )

Definition at line 1002 of file WLSDetectorConstruction.cc.

1002 { return fHoleRadius; }

WLSDetectorConstruction::fHoleRadius

G4double fHoleRadius

Definition: WLSDetectorConstruction.hh:198

Here is the caller graph for this function:

◆ GetSurfaceRoughness()

G4double WLSDetectorConstruction::GetSurfaceRoughness ( )

Definition at line 1039 of file WLSDetectorConstruction.cc.

 {
   return fSurfaceRoughness;
 }

◆ GetWLSFiberEnd()

G4double WLSDetectorConstruction::GetWLSFiberEnd ( )

Definition at line 1023 of file WLSDetectorConstruction.cc.

 {
   return fWLSfiberOrigin + fWLSfiberZ;
 }

Here is the caller graph for this function:

◆ GetWLSFiberLength()

G4double WLSDetectorConstruction::GetWLSFiberLength ( )

Definition at line 990 of file WLSDetectorConstruction.cc.

990 { return fWLSfiberZ; }

WLSDetectorConstruction::fWLSfiberZ

G4double fWLSfiberZ

Definition: WLSDetectorConstruction.hh:152

◆ GetWLSFiberRMax()

G4double WLSDetectorConstruction::GetWLSFiberRMax ( )

Definition at line 1030 of file WLSDetectorConstruction.cc.

 {
   if (fNumOfCladLayers == 2) return fClad2RY;
   if (fNumOfCladLayers == 1) return fClad1RY;
   return fWLSfiberRY;
 }

Here is the caller graph for this function:

◆ IsPerfectFiber()

G4bool WLSDetectorConstruction::IsPerfectFiber ( )

Definition at line 1047 of file WLSDetectorConstruction.cc.

 {
   return     fSurfaceRoughness == 1. && fXYRatio == 1.
              && (!fMirrorToggle    ||
              (fMirrorPolish    == 1. && fMirrorReflectivity == 1.));
 }

Here is the caller graph for this function:

◆ SetBarBase()

void WLSDetectorConstruction::SetBarBase ( G4double side )

Definition at line 954 of file WLSDetectorConstruction.cc.

 {
   fBarBase = side;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetBarLength()

void WLSDetectorConstruction::SetBarLength ( G4double length )

Definition at line 945 of file WLSDetectorConstruction.cc.

 {
   fBarLength = length;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetClad1Radius()

void WLSDetectorConstruction::SetClad1Radius ( G4double radius )

Definition at line 826 of file WLSDetectorConstruction.cc.

 {
   fClad1RY = radius;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

◆ SetClad2Radius()

void WLSDetectorConstruction::SetClad2Radius ( G4double radius )

Definition at line 835 of file WLSDetectorConstruction.cc.

 {
   fClad2RY = radius;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

◆ SetCoatingRadius()

void WLSDetectorConstruction::SetCoatingRadius ( G4double radius )

Definition at line 981 of file WLSDetectorConstruction.cc.

 {
   fCoatingRadius = radius;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCoatingThickness()

void WLSDetectorConstruction::SetCoatingThickness ( G4double thick )

Definition at line 972 of file WLSDetectorConstruction.cc.

 {
   fCoatingThickness = thick;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetCoupleMaterial()

void WLSDetectorConstruction::SetCoupleMaterial ( G4String )

◆ SetGap()

void WLSDetectorConstruction::SetGap ( G4double gap )

Definition at line 854 of file WLSDetectorConstruction.cc.

 { 
   fMPPCDist = gap;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHoleRadius()

void WLSDetectorConstruction::SetHoleRadius ( G4double radius )

Definition at line 963 of file WLSDetectorConstruction.cc.

 {
   fHoleRadius = radius;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMirror()

void WLSDetectorConstruction::SetMirror ( G4bool flag )

Definition at line 925 of file WLSDetectorConstruction.cc.

 {
   fMirrorToggle = flag;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMirrorPolish()

void WLSDetectorConstruction::SetMirrorPolish ( G4double polish )

Definition at line 885 of file WLSDetectorConstruction.cc.

 {
   fMirrorPolish = polish;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMirrorReflectivity()

void WLSDetectorConstruction::SetMirrorReflectivity ( G4double reflectivity )

Definition at line 895 of file WLSDetectorConstruction.cc.

 {
   fMirrorReflectivity = reflectivity;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

◆ SetNumberOfCladding()

void WLSDetectorConstruction::SetNumberOfCladding ( G4int num )

Definition at line 798 of file WLSDetectorConstruction.cc.

 {
   fNumOfCladLayers = num;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPhotonDetAlignment()

void WLSDetectorConstruction::SetPhotonDetAlignment ( G4double theta )

Definition at line 863 of file WLSDetectorConstruction.cc.

 {
   fMPPCTheta = theta;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

◆ SetPhotonDetGeometry()

void WLSDetectorConstruction::SetPhotonDetGeometry ( G4String shape )

Definition at line 788 of file WLSDetectorConstruction.cc.

 {
   if (shape == "Circle" || shape == "Square" ) fMPPCShape = shape;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPhotonDetHalfLength()

void WLSDetectorConstruction::SetPhotonDetHalfLength ( G4double halfL )

Definition at line 844 of file WLSDetectorConstruction.cc.

 {
   fMPPCHalfL = halfL;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

◆ SetPhotonDetPolish()

void WLSDetectorConstruction::SetPhotonDetPolish ( G4double polish )

Definition at line 905 of file WLSDetectorConstruction.cc.

 {
   fMPPCPolish = polish;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPhotonDetReflectivity()

void WLSDetectorConstruction::SetPhotonDetReflectivity ( G4double reflectivity )

Definition at line 915 of file WLSDetectorConstruction.cc.

 {
   fMPPCReflectivity = reflectivity;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

◆ SetSurfaceRoughness()

void WLSDetectorConstruction::SetSurfaceRoughness ( G4double roughness )

Definition at line 875 of file WLSDetectorConstruction.cc.

 {
   fSurfaceRoughness = roughness;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWLSFiberMaterial()

void WLSDetectorConstruction::SetWLSFiberMaterial ( G4String )

◆ SetWLSLength()

void WLSDetectorConstruction::SetWLSLength ( G4double length )

Definition at line 808 of file WLSDetectorConstruction.cc.

 {
   fWLSfiberZ = length;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWLSRadius()

void WLSDetectorConstruction::SetWLSRadius ( G4double radius )

Definition at line 817 of file WLSDetectorConstruction.cc.

 {
   fWLSfiberRY = radius;
   G4RunManager::GetRunManager()->ReinitializeGeometry();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWorldMaterial()

void WLSDetectorConstruction::SetWorldMaterial ( G4String )

◆ SetXYRatio()

void WLSDetectorConstruction::SetXYRatio ( G4double r )

Definition at line 935 of file WLSDetectorConstruction.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StringToRotationMatrix()

G4RotationMatrix WLSDetectorConstruction::StringToRotationMatrix ( G4String rotation )

static

Definition at line 733 of file WLSDetectorConstruction.cc.

 {
   // We apply successive rotations OF THE OBJECT around the FIXED
   // axes of the parent's local coordinates; rotations are applied
   // left-to-right (rotation="r1,r2,r3" => r1 then r2 then r3).
 
   G4RotationMatrix rot;
 
   unsigned int place = 0;
 
   while (place < rotation.size()) {
 
         G4double angle;
         char* p;
 
         const G4String tmpstring=rotation.substr(place+1);
 
         angle = strtod(tmpstring.c_str(),&p) * deg;
  
         if (!p || (*p != (char)',' && *p != (char)'\0')) {
            G4cerr << "Invalid rotation specification: " <<
                                                   rotation.c_str() << G4endl;
            return rot;
         }
 
         G4RotationMatrix thisRotation;
 
         switch(rotation.substr(place,1).c_str()[0]) {
               case 'X': case 'x':
                 thisRotation = G4RotationMatrix(CLHEP::HepRotationX(angle));
                 break;
               case 'Y': case 'y':
                 thisRotation = G4RotationMatrix(CLHEP::HepRotationY(angle));
                 break;
               case 'Z': case 'z':
                 thisRotation = G4RotationMatrix(CLHEP::HepRotationZ(angle));
                 break;
               default:
                 G4cerr << " Invalid rotation specification: "
                        << rotation << G4endl;
                 return rot;
         }
 
        rot = thisRotation * rot;
        place = rotation.find(',',place);
        if (place > rotation.size()) break;
        ++place;
   }
 
   return rot;
 
 }

Here is the caller graph for this function:

◆ UpdateGeometryParameters()

void WLSDetectorConstruction::UpdateGeometryParameters ( )

private

Definition at line 700 of file WLSDetectorConstruction.cc.

 {
   fWLSfiberRX  = fXYRatio * fWLSfiberRY;
 
   fClad1RX = fWLSfiberRX + 0.03*fWLSfiberRX;
   fClad1RY = fWLSfiberRY + 0.03*fWLSfiberRY;
   fClad1Z  = fWLSfiberZ;
 
   fClad2RX = fClad1RX + 0.03*fWLSfiberRX;
   fClad2RY = fClad1RY + 0.03*fWLSfiberRY;
   fClad2Z  = fWLSfiberZ;
 
   fWorldSizeX = fClad2RX   + fMPPCDist + fMPPCHalfL + 1.*cm;
   fWorldSizeY = fClad2RY   + fMPPCDist + fMPPCHalfL + 1.*cm;
   fWorldSizeZ = fWLSfiberZ + fMPPCDist + fMPPCHalfL + 1.*cm;
  
   fCoupleRX = fWorldSizeX;
   fCoupleRY = fWorldSizeY;
   fCoupleZ  = (fWorldSizeZ - fWLSfiberZ) / 2;
  
   fClrfiberHalfL = fMPPCHalfL;
  
   fMirrorRmax = fClad2RY;
  
   fCoupleOrigin = fWLSfiberOrigin + fWLSfiberZ + fCoupleZ;
   fMirrorOrigin = fWLSfiberOrigin - fWLSfiberZ - fMirrorZ;
   fMPPCOriginX  = std::sin(fMPPCTheta) * (fMPPCDist + fClrfiberZ);
   fMPPCOriginZ  = -fCoupleZ + std::cos(fMPPCTheta) * (fMPPCDist + fClrfiberZ);
 }