FDsimG4DetectorConstruction.cc

Go to the documentation of this file.

//
// Description: DetectorConstruction for FDsimG4 application
//              

#include <string>
#include "FDsimG4DetectorConstruction.hh"
#include "FDsimG4Materials.hh"
#include "FDsimG4FilterSD.hh"
#include "FDsimG4Filter.hh"
#include "FDsimG4Camera.hh"
#include "FDsimG4Mirror.hh"
#include "FDsimG4MirrorSpherical.hh"
#include "FDsimG4MirrorSegment.hh"
#include "FDsimG4CorrectorRing.hh"
#include "FDsimG4CorrectorRingKG.hh"
#include "FDsimG4CorrectorRingUpperLimit.hh"
#include "FDsimG4CorrectorRingLowerLimit.hh"
#include "FDsimG4LensSD.hh"
#include "FDsimG4XMLManager.hh"
#include "FDsimG4Colours.hh"
#include "FDsimG4Defs.hh"

#include "G4SDManager.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4Element.hh"
#include "G4ElementTable.hh"
#include "G4UserLimits.hh"
#include "G4Box.hh"
#include "G4Trap.hh"
#include "G4Tubs.hh"
#include "G4Sphere.hh"
#include "G4Orb.hh"
#include "G4UnionSolid.hh"
#include "G4SubtractionSolid.hh"
#include "G4LogicalVolume.hh"
#include "G4AssemblyVolume.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
#include "G4Transform3D.hh"
#include "G4PVPlacement.hh"
#include "G4VisAttributes.hh"
#include "G4Colour.hh"
#include "G4RunManager.hh"

#include <unconfig.h>
#include <utl/config.h>
#include <utl/ErrorLogger.h>
#include <det/Detector.h>
#include <fdet/FDetector.h>
#include <fdet/Eye.h>
#include <fdet/Telescope.h>
#include <fdet/Corrector.h>
#include <fdet/Diaphragm.h>
#include <fdet/Camera.h>

#include "G4Version.hh"

#undef __G4_V9__
#if (G4VERSION_NUMBER>=900)
#define __G4_V9__ 
#include "G4GeometryTolerance.hh"
#endif

using namespace TelescopeSimulatorLX;

const G4double FDsimG4DetectorConstruction::fgTOLERANCE=0.1*CLHEP::mm;

FDsimG4DetectorConstruction::FDsimG4DetectorConstruction(const G4String& name, 
                                                         const FDsimG4XMLManager XMLManager) :  
  fTelescopeName(name), 
  fXMLManager(XMLManager), 
  fVerbosityLevel(0),
  fWorld_phys(NULL),
  fTelescopeMother_phys(NULL),
  fLensFilterMother_phys(NULL), 
  fFilter(NULL),
  fCorrectorRing(NULL),
  fHasCorrectorRing(false),
  fCorrectorRingInnerRadius(0.0*mm),
  fCorrectorRingOuterRadius(0.0*mm),
  fMirror(NULL),
  fCamera(NULL),
  fUseSensitiveDetectors(false)
{
}


FDsimG4DetectorConstruction::~FDsimG4DetectorConstruction()
{
  delete fMaterials;
  delete fWorld_phys;
  delete fTelescopeMother_phys;
  delete fLensFilterMother_phys;
  delete fFilter;
  delete fCorrectorRing;
  delete fMirror;
  delete fCamera;
}
   
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....

G4VPhysicalVolume* 
FDsimG4DetectorConstruction::Construct()
{
  Init(); // Initialize detector geometry and material properties.
  fWorld_phys = ConstructWorld();
  fTelescopeMother_phys = ConstructTelescopeMother(); 
  ConstructHousing();

  fFilter = ConstructFilter(); 
  if (fHasCorrectorRing) 
    fCorrectorRing = ConstructCorrectorRing(); 
  fMirror = ConstructMirror();
  fCamera = ConstructCamera();

  if (fVerbosityLevel > 0) {
    G4cerr << "#                                                               #" << G4endl;  
    G4cerr << "#                      Done geometry                            #" << G4endl;  
    G4cerr << "#                                                               #" << G4endl;
  }

  // Visualization attributes

  G4VisAttributes* UniverseVisAtt = new G4VisAttributes(G4Colour(1.0,1.0,1.0));
  UniverseVisAtt->SetVisibility(false);
  fWorld_phys->GetLogicalVolume()->SetVisAttributes(UniverseVisAtt);

  if (fVerbosityLevel > 0) {
    G4cerr << *(G4Material::GetMaterialTable()) << G4endl; 
    G4cerr << "Tree of Sensitive Detectors: " << G4endl;
    (G4SDManager::GetSDMpointer())->ListTree();
  }
  
  return fWorld_phys;
}


G4VPhysicalVolume* 
FDsimG4DetectorConstruction::ConstructWorld()
{
  //    The World
  //    ---------
  G4Box * World_box
    = new G4Box("World",fWorld_x/2.0,fWorld_y/2.0,fWorld_z/2.0);
  
  G4LogicalVolume * World_log
    = new G4LogicalVolume(World_box,fWorldMaterial,"World",0,0,0);

  return new G4PVPlacement(0,G4ThreeVector(),"World",World_log,0,false,0);
}


G4VPhysicalVolume* 
FDsimG4DetectorConstruction::ConstructTelescopeMother()
{
  // Telescope mother 
  G4Box * TelMotherBox = new G4Box("TelMother",fWorld_x/4.0,fWorld_y/4.0,fWorld_z/4.0);

  G4LogicalVolume * TelMother_log
    = new G4LogicalVolume(TelMotherBox,fWorldMaterial,"TelMother",0,0,0,true);

  TelMother_log->SetSmartless(50);

  G4ThreeVector     TelMotherPos  = G4ThreeVector(0.0*mm,0.0*mm,0.0*mm); 
  G4RotationMatrix *TelMotherRot = new G4RotationMatrix();

  // OZ points from the mirror to the corrector ring   

  TelMotherRot->rotateZ(pi/2.);

  {
    G4VisAttributes* tmpVisAtt = new G4VisAttributes();
    tmpVisAtt->SetVisibility(false);
    TelMother_log->SetVisAttributes(tmpVisAtt);
  }

  G4VPhysicalVolume* telMother_phys = 
    new G4PVPlacement(TelMotherRot,TelMotherPos,"TelescopeMother",TelMother_log,fWorld_phys,false,0);  
#if (G4VERSION_NUMBER>=800)
  if (fVerbosityLevel > 2)
    telMother_phys ->CheckOverlaps(10000);
#endif
 
  G4double xSize = fFilterFrameSize + fgTOLERANCE;
  G4double ySize = fFilterFrameSize + fgTOLERANCE;
  G4double zSize = 2.0*(fFilterPosition.z() +
                    2.0*fFilterFrameThickness + 
                    2.0*fCorrectorRingFrameThickness + 
                    fgTOLERANCE); 

  G4Box* LensFilterSolid = 
    new G4Box("LensFilterMother",xSize/2.0,ySize/2.0,zSize/2.0);
 
  G4LogicalVolume * LensFilterMother_log
    = new G4LogicalVolume(LensFilterSolid,fWorldMaterial,"LensFilterMother",0,0,0,true);

  LensFilterMother_log->SetSmartless(50);

  fLensFilterMother_phys = 
    new G4PVPlacement(0,fCorrectorRingPosition,"LensFilterMother",LensFilterMother_log,telMother_phys,false,0);

#if (G4VERSION_NUMBER>=800)
  if (fVerbosityLevel > 2)
    fLensFilterMother_phys ->CheckOverlaps(10000);
#endif

  {
    G4VisAttributes* VisAtt = new G4VisAttributes(yellow);
    VisAtt->SetVisibility(false);
    LensFilterMother_log->SetVisAttributes(VisAtt); 
  }

  return telMother_phys;
}


FDsimG4Filter* FDsimG4DetectorConstruction::ConstructFilter()
{
  FDsimG4Filter *Filter = new FDsimG4Filter(fLensFilterMother_phys); 

  if (fVerbosityLevel > 0)
    Filter->DumpInfo();

  G4LogicalVolume * Filter_log = Filter->GetLogicalVolume();

  if (!Filter_log)
    G4Exception("Error !!! Filter logical volume does not exhist !!!");
  

  // Filter sensitive detector
  if (fUseSensitiveDetectors) {
    G4double FilterSDThick = 0.1*mm;

    G4double inRadius = 0.0*mm;
    G4double ouRadius = fFilterRadius;
    G4double dZ = FilterSDThick;
    G4double sPhi = 0.0*deg;
    G4double dPhi = 360.0*deg;


    G4Tubs* FilterSDTubs = new G4Tubs("FilterSD",inRadius,ouRadius,dZ/2.0,sPhi,dPhi); 
    G4LogicalVolume * FilterSD_log =  
      new G4LogicalVolume(FilterSDTubs,fWorldMaterial,"FilterSD",0,0,0);

    G4ThreeVector FilterSDPos = 
      fFilterPosition - G4ThreeVector(0.,0.,fFilterThickness/2.+FilterSDThick/2.+fgTOLERANCE);

    G4PVPlacement* filterSD_phys = 
      new G4PVPlacement(0,FilterSDPos,"FilterSD",FilterSD_log,fLensFilterMother_phys,false,0);
        
    // Set sensitive detector

    FDsimG4FilterSD* FilterSD = new FDsimG4FilterSD("FilterSD");
    (G4SDManager::GetSDMpointer())->AddNewDetector(FilterSD);
    FilterSD_log->SetSensitiveDetector(FilterSD);

#if (G4VERSION_NUMBER>=800)
  if (fVerbosityLevel > 2)
    filterSD_phys->CheckOverlaps(10000);
#endif

    {
      G4VisAttributes* tmpVisAtt = new G4VisAttributes(yellow);
      tmpVisAtt->SetVisibility(false);
      FilterSD_log ->SetVisAttributes(tmpVisAtt);
    }
  }

  return Filter;
}

FDsimG4Camera* 
FDsimG4DetectorConstruction::ConstructCamera()
{
#ifdef __G4_V9__
  const double kAngTolerance = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
#endif

  G4double inRadius = 1000.0*mm;
  G4double ouRadius = 2900.0*mm;
  G4double sPhi = -50.*deg;
  G4double dPhi = 100.*deg-kAngTolerance;
  G4double sTheta = 50.*deg;
  G4double dTheta = 80.0*deg-kAngTolerance;

  G4Sphere *cameraSphere = 
    new G4Sphere("CameraMother",inRadius,ouRadius,sPhi,dPhi,sTheta,dTheta);

  G4LogicalVolume* mother_log
    = new G4LogicalVolume(cameraSphere,fWorldMaterial,"CameraMother",0,0,0,true);

  mother_log->SetSmartless(50);

  G4ThreeVector motherPos(0.0*mm,0.0*mm,0.0*mm); 
  G4RotationMatrix* motherRot = new G4RotationMatrix();

  motherRot->rotateY(-pi/2.0);

  G4PVPlacement* mother_phys = 
    new G4PVPlacement(motherRot,motherPos,"CameraMother",mother_log,fTelescopeMother_phys,false,0);
  
  {
    G4VisAttributes* tmpVisAtt = new G4VisAttributes();
    tmpVisAtt->SetVisibility(false);
    mother_log->SetVisAttributes(tmpVisAtt);
  }

  FDsimG4Camera * Camera = new FDsimG4Camera(mother_phys);

#if (G4VERSION_NUMBER>=800)
  if (fVerbosityLevel > 2)
    mother_phys->CheckOverlaps(10000);
#endif

  return  Camera; 
}


FDsimG4Mirror* 
FDsimG4DetectorConstruction::ConstructMirror()
{
  G4bool kUseOptimization = true;

  G4RotationMatrix *MirrorRot = new G4RotationMatrix();
  MirrorRot->rotateY(-pi/2.0);

#ifdef __G4_V9__
  const double kAngTolerance = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
#endif

  G4double inRadius = 3000.0*mm;
  G4double ouRadius = 3500.0*mm;
  G4double sPhi = -40.*deg;
  G4double dPhi = 80.*deg-kAngTolerance;
  G4double sTheta = 50.*deg;
  G4double dTheta = 80.0*deg-kAngTolerance;

  G4Sphere* mirrorSphere = new G4Sphere("MirrorMother",
                                        inRadius,ouRadius,sPhi,dPhi,sTheta,dTheta);

  G4LogicalVolume* mirrorMother_log = 
    new G4LogicalVolume(mirrorSphere,fWorldMaterial,"MirrorMother",0,0,0);
    
  mirrorMother_log -> SetOptimisation(kUseOptimization);

  if (kUseOptimization){
    mirrorMother_log->SetSmartless(50);
  }

  G4VPhysicalVolume* mirrorMother_phys = 
    new G4PVPlacement(MirrorRot, G4ThreeVector(), "MirrorMother", mirrorMother_log,
                      fTelescopeMother_phys,false, 0);
     
  {
    G4VisAttributes* tmpVisAtt =  new G4VisAttributes(yellow); 
    tmpVisAtt->SetVisibility(false);
    mirrorMother_log->SetVisAttributes(tmpVisAtt);
  }

  FDsimG4Mirror* Mirror = new FDsimG4Mirror(fTelescopeName,fMirrorDataFile,mirrorMother_phys);

#if (G4VERSION_NUMBER>=800)
  if (fVerbosityLevel > 2)
    mirrorMother_phys->CheckOverlaps(10000);
#endif

  return Mirror; 
}


FDsimG4VCorrectorRing* 
FDsimG4DetectorConstruction::ConstructCorrectorRing()
{
  FDsimG4VCorrectorRing *CorrectorRing = NULL;

  G4double inRadius = fCorrectorRingInnerRadius;
  G4double ouRadius = fCorrectorRingOuterRadius;
  G4double sPhi = -fCorrectorRingPetalSize/2.;
  G4double dPhi = fCorrectorRingPetalSize;
  G4double thick = fCorrectorRingThickness;
  G4Material* material = fCorrectorRingMaterial;
  const G4int kNumPoints = 1000;

  if (fCorrectorRingProfile == "KG"){
    CorrectorRing = 
      new FDsimG4CorrectorRingKG(inRadius,ouRadius,sPhi,dPhi,thick,material,kNumPoints); 
  }
  else if(fCorrectorRingProfile == "Circular"){
    CorrectorRing = 
      new FDsimG4CorrectorRing(inRadius,ouRadius,sPhi,dPhi,thick,material,kNumPoints); 

  }
  else if(fCorrectorRingProfile == "UpperLimit"){
    CorrectorRing = 
      new FDsimG4CorrectorRingUpperLimit(inRadius,ouRadius,sPhi,dPhi,thick,material,kNumPoints); 

  }
  else if(fCorrectorRingProfile == "LowerLimit"){
    CorrectorRing = 
      new FDsimG4CorrectorRingLowerLimit(inRadius,ouRadius,sPhi,dPhi,thick,material,kNumPoints); 
  }
  else{
    G4Exception("Error in FDsimG4DetectorConstruction::ConstructCorrectorRing: unknown profile !!!"); 
  }
  G4LogicalVolume *ring_log = CorrectorRing->GetLogicalVolume();
  G4PVPlacement * Lens_phys = NULL;

  G4String name; 

  for (G4int ii=0 ; ii < fCorrectorRingNumPetals ; ii++) {
    G4RotationMatrix * Rotation = new G4RotationMatrix();
    G4double angle = 2.0*pi/fCorrectorRingNumPetals * ii; 

    Rotation->rotateZ(angle);

    Lens_phys = new G4PVPlacement(Rotation,G4ThreeVector(),"CorrectorRing",ring_log,
                                  fLensFilterMother_phys,false,ii);

#if (G4VERSION_NUMBER>=800)
    if (fVerbosityLevel > 2)
      Lens_phys->CheckOverlaps(10000);
#endif
  }

  // Construct lens Sensitive detector 
  if (fUseSensitiveDetectors)
    ConstructLensSD(); 

  return CorrectorRing; 
}


void 
FDsimG4DetectorConstruction::ConstructLensSD()
{
  // Build the Corrector Ring Sensitive Detector

  G4double LensSDThick = 0.1*mm;

  G4double inRadius = 0.0*mm;
  G4double ouRadius = fCorrectorRingOuterRadius; 
  G4double dZ = LensSDThick;
  G4double sPhi = 0.0*deg;
  G4double dPhi = 360.0*deg;

  G4Tubs* LensSDTubs = new G4Tubs("LensSD",inRadius,ouRadius,dZ/2.0,sPhi,dPhi);

  G4LogicalVolume* LensSD_log = new G4LogicalVolume(LensSDTubs,fWorldMaterial,"LensSD",0,0,0);

  G4ThreeVector LensSDPos = 
    fCorrectorRingPosition - G4ThreeVector(0.,0.,fCorrectorRingThickness+1.*mm+LensSDThick/2.+0.001*mm);

  G4PVPlacement* LensSD_phys = 
    new G4PVPlacement(0,LensSDPos,"LensSD",LensSD_log,fLensFilterMother_phys,false,0);

#if (G4VERSION_NUMBER>=800)
  if (fVerbosityLevel > 2)
    LensSD_phys->CheckOverlaps(10000);
#endif

  // Define sensitive detector
  FDsimG4LensSD* LensSD = new FDsimG4LensSD("LensSD");
  (G4SDManager::GetSDMpointer())->AddNewDetector(LensSD);
  LensSD_log->SetSensitiveDetector(LensSD);
  
  G4VisAttributes* tmpVisAtt = new G4VisAttributes(yellow);
  tmpVisAtt->SetVisibility(false);
  LensSD_log ->SetVisAttributes(tmpVisAtt);
}


void 
FDsimG4DetectorConstruction::ConstructHousing()
{
  // Definition of the Telescope Dome
  G4double DomeThick = 20.0*cm;
  G4ThreeVector DomeSize(5000.0*mm,5000.0*mm,5000.0*mm);
  G4ThreeVector DomeInnerSize = 
    DomeSize-G4ThreeVector(2.0*DomeThick,2.0*DomeThick,2.0*DomeThick); 

  G4Box* DomeOuterBox = 
    new G4Box("TelDome",DomeSize.x()/2.,DomeSize.y()/2.,DomeSize.z()/2.);

  G4double DomeHoleSide = fFilterFrameSize + fgTOLERANCE; 
  G4Box* DomeHole = 
    new G4Box("Hole",DomeHoleSide/2.0,DomeHoleSide/2.0,DomeThick/2.0 + 1.0*mm);

  G4ThreeVector FilterHolePosition(0.0*mm,0.0*mm,DomeInnerSize.z()/2+DomeThick/2.0);
  G4Box* DomeInnerBox = 
    new G4Box("TelDomeIn",DomeInnerSize.x()/2.0,DomeInnerSize.y()/2.0,DomeInnerSize.z()/2.0);

  G4UnionSolid* DomeVoid = 
    new G4UnionSolid("TelescopeDomeVoid",DomeInnerBox,DomeHole,0,FilterHolePosition);
  G4SubtractionSolid* DomeBox = 
    new G4SubtractionSolid("TelescopeDome",DomeOuterBox,DomeVoid);

  G4Material* material = G4Material::GetMaterial("Aluminum");
  G4LogicalVolume* Dome_log = new G4LogicalVolume(DomeBox,material,"TelescopeDome",0,0,0,true);

  {
    G4VisAttributes* DomeVisAtt = new G4VisAttributes(yellow);
    DomeVisAtt->SetVisibility(false);
    Dome_log->SetVisAttributes(DomeVisAtt); 
  }

  G4double domePosX = 0.0*mm;
  G4double domePosY = 0.0*mm;
  G4double domePosZ = -DomeSize.z()/2. + DomeThick/2.0 + fFilterPosition.z();
  G4ThreeVector DomePosition(domePosX,domePosY,domePosZ);

  G4PVPlacement* Dome_phys = 
    new G4PVPlacement(0,DomePosition,"TelescopeDome",Dome_log,fTelescopeMother_phys,false,0); 

#if (G4VERSION_NUMBER>=800)
  if (fVerbosityLevel > 2)
    Dome_phys->CheckOverlaps(10000);
#endif

  // Construct lens supporting frame
  G4double LensFrameX = fCorrectorRingFrameSize-fgTOLERANCE;
  G4double LensFrameY = fCorrectorRingFrameSize-fgTOLERANCE;
  G4double LensFrameZ = fCorrectorRingFrameThickness;
  G4Box* LensFrameTemp = new G4Box("LensSupport",
                                   LensFrameX/2.0,LensFrameY/2.0,LensFrameZ/2.0);

  // Diaphragm 
  G4double inRadius = 0.0*mm;
  G4double ouRadius = fDiaphragmRadius + fgTOLERANCE;
  G4double dZ = fCorrectorRingFrameThickness + fCorrectorRingThickness + fgTOLERANCE;
  G4double sPhi = 0.0*deg;
  G4double dPhi = 360.0*deg;
  G4Tubs* LensFrameHole = new G4Tubs("LensHole",inRadius,ouRadius,dZ/2.0,sPhi,dPhi);

  G4SubtractionSolid* LensFrameSolid = 
    new G4SubtractionSolid("LensFrame",LensFrameTemp,LensFrameHole);

  material = G4Material::GetMaterial("Aluminum");
  G4LogicalVolume* LensFrame_log = 
    new G4LogicalVolume(LensFrameSolid,material,"LensFrame",0,0,0,true);
  G4PVPlacement* LensFrame_phys = 
    new G4PVPlacement(0,G4ThreeVector(),"LensFrame",LensFrame_log,fLensFilterMother_phys,false,0); 
#if (G4VERSION_NUMBER>=800)
    if (fVerbosityLevel > 2)
      LensFrame_phys->CheckOverlaps(10000);
#endif
    
  G4VisAttributes* LensVisAtt = new G4VisAttributes(gray);
  LensVisAtt->SetVisibility(true);
  LensFrame_log ->SetVisAttributes(LensVisAtt);
}


void
FDsimG4DetectorConstruction::Init()
{
// Initialize detector geometry and material properties.

  string name = fTelescopeName.substr(0,2);
  string eyeName;
  if (name == "LL") eyeName = "Los Leones";
  else
    if (name == "LM") eyeName = "Los Morados";
  else
    if (name == "LA") eyeName = "Loma Amarilla";
  else
    if (name == "CO") eyeName = "Coihueco";

  istringstream buffer(fTelescopeName.substr(2,1));
  int telID;
  buffer >> telID;

  det::Detector& detector = det::Detector::GetInstance();

  const fdet::FDetector& detFD = detector.GetFDetector();
  const fdet::Eye& eye = detFD.GetEye(eyeName);
  const fdet::Telescope& telescope = eye.GetTelescope(telID);
  const fdet::Corrector& corrector = telescope.GetCorrector();
  const fdet::Diaphragm& diaphragm = telescope.GetDiaphragm();
  const fdet::Camera& camera = telescope.GetCamera();

  fMaterials = new FDsimG4Materials(telescope);

  // Make the Geant4 world

  fWorld_x = 100.*CLHEP::m;
  fWorld_y = 100.*CLHEP::m;
  fWorld_z = 100.*CLHEP::m;
  fWorldMaterial = G4Material::GetMaterial("Atmosphere"); 

  // We keep hardcoded the parameters of the telescope geometry for which no data 
  // seems to exhist in the Offline/FModelConfig

  fFilterRadius = 1100.0*CLHEP::mm;
  fFilterDiameter = 2.0*fFilterRadius; 
  fFilterThickness = 3.25*CLHEP::mm;

  G4double posX = 0.0*CLHEP::mm;
  G4double posY = 0.0*CLHEP::mm;
  G4double posZ = 100.0*CLHEP::mm;

  fFilterPosition = G4ThreeVector(posX,posY,posZ);
  fFilterMaterial = G4Material::GetMaterial("M-UG6");

  fFilterFrameSize = 2300.0*CLHEP::mm;
  fFilterFrameThickness = 10.0*CLHEP::mm;

  fDiaphragmRadius = diaphragm.GetRadius()/utl::mm*CLHEP::mm;

  fHasCorrectorRing = telescope.HasCorrectorRing();
  fCorrectorRingInnerRadius = corrector.GetInnerRadius()/utl::mm*CLHEP::mm;
  fCorrectorRingOuterRadius = corrector.GetOuterRadius()/utl::mm*CLHEP::mm; 
  fCorrectorRingThickness = corrector.GetMeanLensThickness()/utl::mm*CLHEP::mm;
  fCorrectorRingFrameSize = fFilterFrameSize; 
  fCorrectorRingFrameThickness = fCorrectorRingThickness + 10.0*CLHEP::mm; 
  fCorrectorRingPosition = G4ThreeVector(0.0*CLHEP::mm,0.0*CLHEP::mm,0.0*CLHEP::mm); 

  fCorrectorRingMaterial = G4Material::GetMaterial("BK7"); 

  fCameraRadiusCurvature = camera.GetRadiusFocal()/utl::mm*CLHEP::mm;
  fCameraNCols = telescope.GetLastColumn() - telescope.GetFirstColumn()+1; // 20
  fCameraNRows = telescope.GetLastRow() - telescope.GetFirstRow()+1;       // 22

  fMercedesHeight = camera.GetMercedesHeight()/utl::mm*CLHEP::mm;
  fMercedesBase = 2.0*camera.GetMercedesBase()/utl::mm*CLHEP::mm;
  fMercedesEfficiency = camera.GetMercedesEfficiency();

//   cout << fCameraRadiusCurvature/mm << " " 
//        << fMercedesHeight/mm << " " 
//        << fMercedesBase/mm << " " 
//        << fMercedesEfficiency << endl;

#ifdef __TELESCOPE_SIMULATOR_LX_USE_ROOT__
  fUseSensitiveDetectors = true; 
#endif

  string profile = "KG";
  fXMLManager.GetData(profile,"profile","lens");
  fCorrectorRingProfile = profile;

  int numPetals = 1;
  fXMLManager.GetData(numPetals,"numPetals","lens");
  fCorrectorRingNumPetals = numPetals;

  double PetalSize = 360.0*utl::degree; 
  fXMLManager.GetData(PetalSize,"petalSize","lens");
  fCorrectorRingPetalSize = PetalSize/utl::degree * CLHEP::deg; 

  string MirrorDataFile;
  if (!fXMLManager.GetData(MirrorDataFile,"mirrorDataFile","mirror"))
      G4Exception ("Name of mirror data file not found in configuration file !");
  
  fMirrorDataFile = MirrorDataFile;

  double MirrorSegmentTiltSigma = 0.0*utl::degree;
  fXMLManager.GetData(MirrorSegmentTiltSigma,"segmentTiltSigma","mirror");
  fMirrorSegmentTiltSigma = MirrorSegmentTiltSigma/utl::degree * CLHEP::deg;

  string MirrorReflectionType = "Specular";
  fXMLManager.GetData(MirrorReflectionType,"reflectionType","mirror");
  fMirrorReflectionType = MirrorReflectionType;

  if (fMirrorReflectionType == "Diffusive"){

    double sigma_alpha = 0.0*utl::degree;
    vector<double> wavelength;
    vector<double> SpecularLobe;
    vector<double> SpecularSpike;
    vector<double> Backscatter;
    vector<double> Reflectivity;

    FDsimG4XMLManager::Status status = FDsimG4XMLManager::eFound;

    if (!fXMLManager.GetData(sigma_alpha,"sigma_alpha","mirror")) 
      status = FDsimG4XMLManager::eNotFound;
    if (!fXMLManager.GetData(wavelength,"wavelength","mirror"))
      status = FDsimG4XMLManager::eNotFound;
    if (!fXMLManager.GetData(SpecularSpike,"specularspike","mirror"))
      status = FDsimG4XMLManager::eNotFound;
    if (!fXMLManager.GetData(SpecularLobe,"specularlobe","mirror"))
      status = FDsimG4XMLManager::eNotFound;
    if (!fXMLManager.GetData(Backscatter,"backscatter","mirror"))
      status = FDsimG4XMLManager::eNotFound;
    
    if (status == FDsimG4XMLManager::eNotFound)
      G4Exception ("Mirror diffusive surface required but one or several parameters are missing.");

    fMirrorRoughness.Sigma_alpha = sigma_alpha/utl::degree * CLHEP::deg;
  
    unsigned size = wavelength.size(); 
    fMirrorRoughness.Wavelength    = vector<G4double>(size);
    fMirrorRoughness.SpecularSpike = vector<G4double>(size);
    fMirrorRoughness.SpecularLobe  = vector<G4double>(size); 
    fMirrorRoughness.Backscatter   = vector<G4double>(size); 
    
    for (unsigned i = 0 ; i < size ; i++) {
      fMirrorRoughness.Wavelength[i] = 
        (wavelength[i]/utl::nanometer)*CLHEP::nm;
      fMirrorRoughness.SpecularSpike[i] = SpecularSpike[i];
      fMirrorRoughness.SpecularLobe[i]  = SpecularLobe[i];
      fMirrorRoughness.Backscatter[i]   = Backscatter[i];
    }
  }


  // Read filter frame surface parameters

  vector<double> wavelength;
  vector<double> Reflectivity;

  FDsimG4XMLManager::Status status = FDsimG4XMLManager::eFound;

  fXMLManager.GetData(Reflectivity,"reflectivity","filterframe");
  fXMLManager.GetData(wavelength,"wavelength","filterframe");
  
  unsigned size = wavelength.size();
  
  fFilterFrameWavelength     = vector<G4double>(size);
  fFilterFrameReflectivity   = vector<G4double>(size); 
  for (unsigned i = 0 ; i < size ; i++) {
    fFilterFrameWavelength[i] = 
      (wavelength[i]/utl::nanometer)*CLHEP::nm;
    fFilterFrameReflectivity[i] = Reflectivity[i];
  }
  
  string FilterFrameReflectionType = "Specular";
  fXMLManager.GetData(FilterFrameReflectionType,"reflectionType","filterframe");
  fFilterFrameReflectionType = FilterFrameReflectionType;

  if (fFilterFrameReflectionType == "Diffusive") {
    double sigma_alpha = 0.0*utl::degree;
    vector<double> wavelength;
    vector<double> SpecularLobe;
    vector<double> SpecularSpike;
    vector<double> Backscatter;

    status = FDsimG4XMLManager::eFound;

    if (!fXMLManager.GetData(sigma_alpha,"sigma_alpha","filterframe")) 
      status = FDsimG4XMLManager::eNotFound;
    if (!fXMLManager.GetData(wavelength,"wavelength","filterframe"))
      status = FDsimG4XMLManager::eNotFound;
    if (!fXMLManager.GetData(SpecularSpike,"specularspike","filterframe"))
      status = FDsimG4XMLManager::eNotFound;
    if (!fXMLManager.GetData(SpecularLobe,"specularlobe","filterframe"))
      status = FDsimG4XMLManager::eNotFound;
    if (!fXMLManager.GetData(Backscatter,"backscatter","filterframe"))
      status = FDsimG4XMLManager::eNotFound;
        
    if (status == FDsimG4XMLManager::eNotFound)
      G4Exception("Diffusive surface for filter frame required but one or several parameters are missing.");

    fFilterFrameRoughness.Sigma_alpha = sigma_alpha/utl::degree * CLHEP::deg;
    
    size = wavelength.size(); 
    fFilterFrameRoughness.Wavelength = vector<G4double>(size);
    fFilterFrameRoughness.SpecularSpike = vector<G4double>(size);
    fFilterFrameRoughness.SpecularLobe  = vector<G4double>(size); 
    fFilterFrameRoughness.Backscatter   = vector<G4double>(size); 
    
    for (unsigned i = 0 ; i < size ; i++) {
      fFilterFrameRoughness.Wavelength[i] = 
        (wavelength[i]/utl::nanometer)*CLHEP::nm;
      fFilterFrameRoughness.SpecularSpike[i] = SpecularSpike[i];
      fFilterFrameRoughness.SpecularLobe[i]  = SpecularLobe[i];
      fFilterFrameRoughness.Backscatter[i]   = Backscatter[i];
    }
  }
  
  // Read photocathode parameters
  {
    string photocathodeMode = "reflectivity";
    vector<double> wavelength;
    vector<double> reflectivity;
    vector<double> reRindex;
    vector<double> imRindex;
    double thickness = 0.0*utl::nanometer;
    
    fPhotocathodeUseReflectivity = false;
    fPhotocathodeUseComplexRindex = false;
    fPhotocathodeUseThinFilm = false;
    
    fXMLManager.GetData(photocathodeMode,"mode","photocathode");

    if (photocathodeMode == "RefractiveIndex") {
      fPhotocathodeUseComplexRindex = true;
    }
    else 
      fPhotocathodeUseReflectivity = true;

    if (fPhotocathodeUseComplexRindex) {
      if (!fXMLManager.GetData(wavelength,"wavelength","photocathode") ||
          !fXMLManager.GetData(reRindex,"realRindex","photocathode") ||
          !fXMLManager.GetData(imRindex,"imaginaryRindex","photocathode")) 
        
        G4Exception("RefractiveIndex mode chosen for photocathode but one or several parameters are missing.");
      if (fXMLManager.GetData(thickness,"thickness","photocathode"))
        fPhotocathodeUseThinFilm = true;
      
    }
     
    if (fPhotocathodeUseReflectivity) {
      if (!fXMLManager.GetData(reflectivity,"reflectivity","photocathode") ||
          !fXMLManager.GetData(wavelength,"wavelength","photocathode")) 
        G4Exception("Reflectivity mode chosen for photocathode but one or several parameters are missing.");
    }
    
    unsigned size = wavelength.size();
    fPhotocathodeWavelength = vector<G4double>(size);
    if (fPhotocathodeUseComplexRindex) {
      fPhotocathodeThickness = (thickness/utl::nanometer)*CLHEP::nm;
      fPhotocathodeReRindex = vector<G4double>(size); 
      fPhotocathodeImRindex = vector<G4double>(size);
      
      for (unsigned i = 0 ; i < size ; i++) {
        fPhotocathodeWavelength[i] = (wavelength[i]/utl::nanometer)*CLHEP::nm;
        fPhotocathodeReRindex[i] = reRindex[i]; 
        fPhotocathodeImRindex[i] = imRindex[i]; 
      }
    }
    else {
      fPhotocathodeReflectivity = vector<G4double>(size); 
      for (unsigned i = 0 ; i < size ; i++) {
        fPhotocathodeWavelength[i] = (wavelength[i]/utl::nanometer)*CLHEP::nm;
        fPhotocathodeReflectivity[i] = reflectivity[i];
      }
    }
  }
}