FDsimG4PMT.cc

Go to the documentation of this file.

#include "FDsimG4Defs.hh"
#include "FDsimG4PMT.hh"
#include "FDsimG4DetectorConstruction.hh"
#include "FDsimG4Colours.hh"
#include "G4RunManager.hh"
#include "G4UnitsTable.hh"
#include "G4SDManager.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4Polyhedra.hh"
#include "G4BREPSolidPolyhedra.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4ThreeVector.hh"
#include "G4VisAttributes.hh"
#include "G4LogicalSkinSurface.hh"
#include "G4OpticalSurface.hh"

using namespace TelescopeSimulatorLX ;
using namespace std;

FDsimG4PMT::FDsimG4PMT(G4String PMTname)
{
  // Data from Photonis XP3062 data sheet

  fWindowSide = 21.9*mm;       // Size of the hexagonal window side               
  fPhotocathodeSide = 36.0*mm/2.0*(2.0/std::sqrt(3.0));  // Size of the photocathode hexagonal side
  fThickness =  1.*mm;
  fWindowMaterial = G4Material::GetMaterial("LimeGlass");

  fPMT_name=PMTname;

  // Sensitive Detector Manager
  SDmanager = G4SDManager::GetSDMpointer();

  fPMT_log = NULL; 
  fPhotocathode_log = NULL; 

  CheckParameters();
  MakeLogicalVolume();
}


FDsimG4PMT::~FDsimG4PMT(){;}


void FDsimG4PMT::CheckParameters()
{
  if (!fWindowMaterial)
    G4Exception("Error in FDsimG4PMT constructor: G4Material of window of PMT not specified !!!");


  if ( fWindowSide < fPhotocathodeSide ) 
    G4Exception("Error in FDsimG4PMT constructor: Photocathode size > PMT size !!!");

}


void FDsimG4PMT::DumpInfo() const
{
  G4cerr << " ===================================================================  " << G4endl ;
  G4cerr << " =                            PMT parameters                          " << G4endl ;
  G4cerr << " =                                                                    " << G4endl ;
  G4cerr << " =  PMT window side       : " << fWindowSide/mm           << " (mm)   " << G4endl ;
  G4cerr << " =  Photocathode side     : " << fPhotocathodeSide/mm     << " (mm)   " << G4endl ;
  G4cerr << " =  PMT thickness         : " << fThickness/mm            << " (mm)   " << G4endl ;
  G4cerr << " =                                                                    " << G4endl ;
  G4cerr << " =  Window Material       : " << fWindowMaterial->GetName()              << G4endl ;
  G4cerr << " =                                                                    " << G4endl ;    
  G4cerr << " ===================================================================  " << G4endl ;
}


void FDsimG4PMT::MakeLogicalVolume()
{
  const G4int numSides = 6;
  const G4int numZplanes = 2;

  // Planar surfaces cases
  G4double rMinVec[numZplanes] = {0.0, 0.0}; 
  G4double rMaxVec[numZplanes] = {fWindowSide,fWindowSide}; // This is the radius of the hexagon corners
  G4double zVec[numZplanes] = {-fThickness/2.0, fThickness/2.0};

  G4Polyhedra* PMT_solid
    = new G4Polyhedra("PMT",0.,2.0*pi,numSides,numZplanes,zVec,rMinVec,rMaxVec);


  fPMT_log 
    = new G4LogicalVolume(PMT_solid,(G4Material*)fWindowMaterial,"PMT",0,0,0);


  fPMT_log->SetVisAttributes(new G4VisAttributes(yellow));

  // Build photocathode
  G4double rPhotocathMinVec[numZplanes] = {0.0, 0.0}; 
  G4double rPhotocathMaxVec[numZplanes] = {fPhotocathodeSide,fPhotocathodeSide}; // This is the radius of the hexagon corners
  G4double zPhotocathVec[numZplanes] = {0.9*(fThickness/2.0), 0.95*(fThickness/2.0)};

  G4Polyhedra* Photocathode_solid
    = new G4Polyhedra("Photocathode",0.,2.0*pi,numSides,numZplanes,zPhotocathVec,rPhotocathMinVec,rPhotocathMaxVec);

  fPhotocathode_log 
    = new G4LogicalVolume(Photocathode_solid,(G4Material*)fWindowMaterial,"Photocathode",0,0,0);

  G4String name = "Photocathode_" + fPMT_name;
  new G4PVPlacement(0,G4ThreeVector(),fPhotocathode_log,name,fPMT_log,false,0);

  fPhotocathode_log->SetVisAttributes(new G4VisAttributes(red));

  // Photocathode surface proprieties

  G4OpticalSurface* OpticalPhotocathode = new G4OpticalSurface("PhotocathodeSurface");
  OpticalPhotocathode->SetModel(unified);
  OpticalPhotocathode->SetType(dielectric_metal);       
  OpticalPhotocathode->SetFinish(polished);

  G4MaterialPropertiesTable* PhotocathodeMPT = new G4MaterialPropertiesTable();

  const G4RunManager* runManager = G4RunManager::GetRunManager();
  const FDsimG4DetectorConstruction* DetectorConstruction =  
    dynamic_cast<const FDsimG4DetectorConstruction*>(runManager->GetUserDetectorConstruction());

  const G4bool& useComplexRindex = DetectorConstruction->fPhotocathodeUseComplexRindex;
  const G4bool& useThinFilm = DetectorConstruction->fPhotocathodeUseThinFilm;
  const vector<G4double>& wavelength = DetectorConstruction->fPhotocathodeWavelength;
    
  if (useComplexRindex) {
    const vector<G4double>& reRindex = DetectorConstruction->fPhotocathodeReRindex;
    const vector<G4double>& imRindex = DetectorConstruction->fPhotocathodeImRindex;

    if (useThinFilm) {
      const G4double& thickness = DetectorConstruction->fPhotocathodeThickness;
      PhotocathodeMPT->AddConstProperty("THICKNESS",thickness) ;
    }

    PhotocathodeMPT->AddProperty("REALRINDEX", new G4MaterialPropertyVector()) ;
    PhotocathodeMPT->AddProperty("IMAGINARYRINDEX", new G4MaterialPropertyVector()) ;
    
    G4double energy;
    unsigned nEntries = wavelength.size();
    for (unsigned i=0; i < nEntries; i++) {
      energy = h_Planck*c_light/wavelength[i] ;
      PhotocathodeMPT->AddEntry("REALRINDEX",energy,reRindex[i]);
      PhotocathodeMPT->AddEntry("IMAGINARYRINDEX",energy,imRindex[i]);
    }
  }
  else {
    const vector<G4double>& reflectivity = DetectorConstruction->fPhotocathodeReflectivity;
    PhotocathodeMPT->AddProperty("REFLECTIVITY", new G4MaterialPropertyVector()) ;

    G4double energy;
    unsigned nEntries = wavelength.size();
    for (unsigned i=0; i < nEntries; i++) {
      energy = h_Planck*c_light/wavelength[i];
      PhotocathodeMPT->AddEntry("REFLECTIVITY",energy,reflectivity[i]);
    }
  }
  
  PhotocathodeMPT->AddProperty("EFFICIENCY", new G4MaterialPropertyVector()) ;
  PhotocathodeMPT->AddEntry("EFFICIENCY", 0.0*eV,1.);
  PhotocathodeMPT->AddEntry("EFFICIENCY",10.0*eV,1.);

  OpticalPhotocathode->SetMaterialPropertiesTable(PhotocathodeMPT);     

  new G4LogicalSkinSurface("PhotocathodeSurface",fPhotocathode_log,OpticalPhotocathode);

 const G4int VerbosityLevel = DetectorConstruction->fVerbosityLevel;
 if (VerbosityLevel > 0) {
   static G4int ifirst = 1;
   if (ifirst) {
     G4cerr << "Material properties table for photocathode" << G4endl;
     PhotocathodeMPT->DumpTable();
     ifirst = 0;
   }
 }
}