FDsimG4Camera.cc

Go to the documentation of this file.

#include "FDsimG4Camera.hh"
#include "FDsimG4CameraSupport.hh"
#include "FDsimG4CameraFoot.hh"
#include "FDsimG4Colours.hh"

#include "FDsimG4Mercedes.hh"
#include "FDsimG4PMT.hh"
#include "FDsimG4PMT_SD.hh"
#include "FDsimG4FocalSurfaceSD.hh"
#include "FDsimG4DetectorConstruction.hh"

#include "G4RunManager.hh"
#include "G4UnitsTable.hh"
#include "G4IntersectionSolid.hh"
#include "G4Box.hh"
#include "G4Sphere.hh"

#include "G4LogicalSkinSurface.hh"
#include "G4SDManager.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4Polyhedra.hh"
#include "G4BREPSolidPolyhedra.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4OpticalSurface.hh"
#include "G4LogicalBorderSurface.hh"
#include "G4ThreeVector.hh"
#include "G4VisAttributes.hh"

#include <unconfig.h>
#include <utl/config.h>
#include "G4Version.hh"


using namespace TelescopeSimulatorLX;
using namespace std;


FDsimG4Camera::FDsimG4Camera(G4VPhysicalVolume* mother)
{
  const G4RunManager* runManager = G4RunManager::GetRunManager();
  const FDsimG4DetectorConstruction* DetectorConstruction =  
    dynamic_cast<const FDsimG4DetectorConstruction*>(runManager->GetUserDetectorConstruction());
  
  fCurvRadius = DetectorConstruction->fCameraRadiusCurvature; 
  fNumCols = DetectorConstruction->fCameraNCols; 
  fNumRows = DetectorConstruction->fCameraNRows; 
  fMercedesEfficiency = DetectorConstruction->fMercedesEfficiency; 
  fMERCEDESCOUNT=966;
  fMotherPhysicalVolume = mother;
  fVerbosity = DetectorConstruction->fVerbosityLevel;

  CheckParameters();
  BuildCamera();
}


FDsimG4Camera::~FDsimG4Camera()
{
}


void FDsimG4Camera::CheckParameters()
{
}


void FDsimG4Camera::DumpInfo()
{
}


void FDsimG4Camera::BuildCamera()
{
  const G4int nMercedes_col = 42;
  const G4double deltaAz = 1.5*pi/180.;
  const G4double deltaEl = 1.5*pi/180.*cos(pi/6.);

  G4double TOLERANCE = FDsimG4DetectorConstruction::fgTOLERANCE;
  G4double offsetAz = 10.*deltaAz;
  //        G4double offsetEl=(-28.6*pi/180./2.)-deltaEl;
  G4double offsetEl = -(11.*deltaEl)-deltaEl-deltaEl/3;

  G4int i = 0;
  G4int j = 0;
  char mercedesname[32];
  char pmtname[32];
  G4double elevation,azimuth;
  G4int numOfCopy = 0;

  G4ThreeVector PMTPos;
  G4double PMT_thick = 0.0;
  G4VPhysicalVolume* PMT_phys;
  G4RotationMatrix* PMTRot;
  FDsimG4PMT_SD* PMT_SD = NULL;
  G4int colPMT;
  G4int rowPMT;
  G4int PMT_id;

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

  if(!PMT_SD){
    PMT_SD = new FDsimG4PMT_SD("PMTSD");
    SDmanager->AddNewDetector(PMT_SD);
  }               

  FDsimG4Mercedes* Mercedes = new FDsimG4Mercedes();
  G4LogicalVolume* Mercedes_log = Mercedes->GetMercedesLogicalVolume();
  G4double Mercedes_height = Mercedes->GetMercedesHeight();
  G4PVPlacement* Mercedes_phys = NULL;
        
  // define mercedes - air optical surface 

  G4OpticalSurface* OpticalAirMercedes = new G4OpticalSurface("MercedesSurface");
  OpticalAirMercedes->SetModel(unified);
  OpticalAirMercedes->SetType(dielectric_metal);        

  G4MaterialPropertiesTable* MercedesMPT = new G4MaterialPropertiesTable();
  G4double Efficiency = fMercedesEfficiency;
  MercedesMPT->AddProperty("REFLECTIVITY", new G4MaterialPropertyVector());
  MercedesMPT->AddEntry("REFLECTIVITY", 0.0*eV,Efficiency);
  MercedesMPT->AddEntry("REFLECTIVITY",10.0*eV,Efficiency);

  OpticalAirMercedes->SetMaterialPropertiesTable(MercedesMPT);  

  G4ThreeVector MercedesPos;
  G4RotationMatrix* MercedesRot;
  for(i=0; i<fMERCEDESCOUNT; i++){
    sprintf(mercedesname,"Mercedes_%03i",i);            

    // place Mercedes stars

    MercedesRot=new G4RotationMatrix();            
    MercedesRot->rotateZ(pi/2.0);        
               
    G4int row = (G4int)floor((double)i/nMercedes_col);
    G4int col= i%nMercedes_col;

    if(col == 0) offsetEl=offsetEl+deltaEl;  // start new row
    azimuth = col*deltaAz/2.;
    if ((row%2 == 0 && col%2 == 0) || (row%2 != 0 && col%2 != 0))
      {
        elevation=offsetEl;
        MercedesRot->rotateY(3.0*pi/2.0); // inverted mercedes : Y
        // place Mercedes tangent to camera plane
        MercedesRot->rotateZ(((-offsetAz)+azimuth));  
        MercedesRot->rotateX(elevation);  
      }
    else
      {
        elevation=offsetEl+deltaEl/3.;
        MercedesRot->rotateY(pi/2.0);   // mercedes 
        // place Mercedes tangent to camera plane
        MercedesRot->rotateZ(offsetAz-azimuth); 
        MercedesRot->rotateX(-elevation);                   
      }
    
    MercedesPos.setRThetaPhi(fCurvRadius,(pi/2.-offsetAz)+azimuth,elevation);
    Mercedes_phys = 
      new G4PVPlacement(MercedesRot,MercedesPos,mercedesname,
                        Mercedes_log,fMotherPhysicalVolume,false,numOfCopy++);

#if (G4VERSION_NUMBER>=800)
    if (fVerbosity > 2 && Mercedes_phys)
      Mercedes_phys->CheckOverlaps(10000);
#endif

    if (Mercedes_phys) 
      new G4LogicalBorderSurface("MercedesSurface",
                                 fMotherPhysicalVolume,Mercedes_phys,OpticalAirMercedes);

    // place PMTs

    if (row != 22 && col < 40) {
      if ((row%2 != 0 && col%2 ==0) ||  (row%2 ==0 && col%2!=0)){
          j=j+1;

          // colPMT and rowPMT start at 0

          if (row%2 != 0) 
            colPMT = col;
          else
            colPMT = col-1; 

          colPMT = G4int(colPMT/2.);
          rowPMT = row;

          PMT_id = fNumRows*(colPMT)+rowPMT+1; 
          sprintf(pmtname,"PMT_%03i",PMT_id);           

          FDsimG4PMT* PMT = new FDsimG4PMT(pmtname);
          G4LogicalVolume* PMT_log = PMT->GetPMTLogicalVolume();
          PMT_thick = PMT->GetThickness();

          PMTRot = new G4RotationMatrix();            
          PMTRot->rotateY(pi/2.0);  
          PMTRot->rotateZ(pi/2.0);  
          // place PMT tangent to camera plane
          PMTRot->rotateX((-offsetAz)+azimuth+deltaAz/2.);  
          PMTRot->rotateY(-offsetEl-2*deltaEl/3.);

          PMTPos.setRThetaPhi(fCurvRadius-Mercedes_height-PMT_thick/2.- 1.0*mm,
                              (pi/2.-offsetAz)+azimuth+deltaAz/2.,
                              offsetEl+2*deltaEl/3.);
          PMT_phys =
            new G4PVPlacement(PMTRot,PMTPos,pmtname,PMT_log,fMotherPhysicalVolume,false,PMT_id);
#if (G4VERSION_NUMBER>=800)
          if (fVerbosity > 2 && PMT_phys)
            PMT_phys->CheckOverlaps(10000);
#endif
          if (PMT_log && PMT_SD) PMT_log->SetSensitiveDetector(PMT_SD);
          if (PMT_log){
            PMT_log->SetVisAttributes(new G4VisAttributes(yellow));
            if(j==1) 
              PMT_log->SetVisAttributes(new G4VisAttributes(magenta)); 
          }
          delete PMT;  
        } 
    }
  } // end of loop on mercedes
 
  delete Mercedes;

  G4VPhysicalVolume* Support_phys = NULL; 
  G4VPhysicalVolume* Foot1_phys = NULL;
  G4VPhysicalVolume* Foot2_phys = NULL;
  G4VPhysicalVolume* Electronics_phys = NULL;

  // Place camera support
       
  G4double SupportPlaceX = fCurvRadius-Mercedes_height-PMT_thick - 1.0*mm;

  FDsimG4CameraSupport* Support = 
    new FDsimG4CameraSupport(SupportPlaceX-TOLERANCE*5.);
  G4LogicalVolume* Support_log = 
    Support->GetCameraSupportLogicalVolume();        
  G4RotationMatrix* SupportRot = 
    new G4RotationMatrix(G4ThreeVector(0.,0.,1.),pi/2.0);

  Support_phys = 
    new G4PVPlacement(SupportRot,G4ThreeVector(),"CameraSupport",Support_log,
                      fMotherPhysicalVolume,false,0);
        
  // Place camera feet

  FDsimG4CameraFoot* Foot = new FDsimG4CameraFoot();
  G4LogicalVolume* Foot_log  = Foot->GetCameraFootLogicalVolume();        

  G4double dx=
    SupportPlaceX-(Support->GetThickness())-(Foot->GetFootSide())/2.;

  G4double angle = std::atan((Support->GetHside())/2./fCurvRadius);
  G4double FromCamera=22.58*cm;
  dx = dx - FromCamera*std::cos(angle);

  G4double dz = (Support->GetHside())/2.;
  dz = dz - FromCamera*std::sin(angle);
              
  G4ThreeVector FootPlace1 = G4ThreeVector(dx,0.,dz);
  G4ThreeVector FootPlace2 = G4ThreeVector(dx,0.,-dz);

  G4RotationMatrix* rot1 = new G4RotationMatrix(G4ThreeVector(1.,0.,0.),pi);
  G4RotationMatrix* rot2 = new G4RotationMatrix(G4ThreeVector(1.,0.,0.),pi);

  Foot1_phys = new G4PVPlacement(rot1,FootPlace1,"CameraFoot1",Foot_log,
                                 fMotherPhysicalVolume,false,0);
  Foot2_phys = new G4PVPlacement(rot2,FootPlace2,"CameraFoot2",Foot_log,
                                 fMotherPhysicalVolume,false,1);

  // Place electronics box

  G4double dxEl = Foot->GetFootSide()+20*cm;
  G4double dyEl = Foot->GetTopSide();
  G4double dzEl = 2.0*((Support->GetHside())/2. - 
                       FromCamera*std::sin(angle)-Foot->GetFootThick());

  G4Box* Electronics = new G4Box("Top",dxEl/2.,dyEl/2.,dzEl/2.);

  const G4Material* ElectronicsMaterial = G4Material::GetMaterial("Aluminum");

  G4LogicalVolume* Electronics_log =  
    new G4LogicalVolume(Electronics,(G4Material*)ElectronicsMaterial,"CameraElectronics",0,0,0);
  
  Electronics_log->SetVisAttributes(new G4VisAttributes(gray));

  // surface proprieties
  G4OpticalSurface* OpticalAirCameraElect= new G4OpticalSurface("CameraElectSurface");
  OpticalAirCameraElect->SetModel(unified);
  OpticalAirCameraElect->SetType(dielectric_metal);     

  G4MaterialPropertiesTable* CameraElectMPT = new G4MaterialPropertiesTable();
  CameraElectMPT->AddProperty("REFLECTIVITY", new G4MaterialPropertyVector());
  CameraElectMPT->AddEntry("REFLECTIVITY", 0.0*eV,0.);
  CameraElectMPT->AddEntry("REFLECTIVITY",10.0*eV,0.);
  OpticalAirCameraElect->SetMaterialPropertiesTable(CameraElectMPT);    

  new G4LogicalSkinSurface("CameraElectSurface",Electronics_log,OpticalAirCameraElect);
  G4ThreeVector ElPlace=G4ThreeVector(dx,0.,0.);
  Electronics_phys = 
    new G4PVPlacement(0,ElPlace,"CameraElectronics",Electronics_log,
                      fMotherPhysicalVolume,false,0);

#if (G4VERSION_NUMBER>=800)
  if (fVerbosity > 2){
    if (Support_phys) Support_phys->CheckOverlaps(10000);
    if (Foot1_phys) Foot1_phys->CheckOverlaps(10000);
    if (Foot2_phys) Foot2_phys->CheckOverlaps(10000);
    if (Electronics_phys) Electronics_phys->CheckOverlaps(10000);
  }
#endif



  G4bool useSD = 
    (dynamic_cast<const FDsimG4DetectorConstruction*>((G4RunManager::GetRunManager())->GetUserDetectorConstruction()))->fUseSensitiveDetectors;

  if(useSD){
    // Define a virtual focal surface
    G4double rMax = fCurvRadius + 0.5*mm;
    G4double rMin = rMax - 0.1*mm;
    G4double ThetaMin = Support->GetThetaMin();
    G4double ThetaMax = Support->GetThetaMax(); 
    G4double PhiMin   = Support->GetPhiMin(); 
    G4double PhiMax   = Support->GetPhiMax(); 
 
    G4Material* Material = fMotherPhysicalVolume->GetLogicalVolume()->GetMaterial();
    G4Sphere* FocalSurf = 
      new G4Sphere("sphere",rMin,rMax,ThetaMin,ThetaMax,PhiMin,PhiMax); 

    G4LogicalVolume* FocalSurface_log = 
      new G4LogicalVolume(FocalSurf,Material,"VirtualFocalSurface",0,0,0);

    G4VPhysicalVolume* FocalSurface_phys = NULL;
    FocalSurface_phys = 
      new G4PVPlacement(SupportRot,G4ThreeVector(),"VirtualFocalSurface",
                        FocalSurface_log, fMotherPhysicalVolume,false,0);

    FocalSurface_log->SetVisAttributes(new G4VisAttributes(yellow));
    FDsimG4FocalSurfaceSD* FocalSurfaceSD = new FDsimG4FocalSurfaceSD("FocalSurfaceSD");
    SDmanager->AddNewDetector(FocalSurfaceSD);
    FocalSurface_log->SetSensitiveDetector(FocalSurfaceSD);

#if (G4VERSION_NUMBER>=800)
  if (fVerbosity > 2 && FocalSurface_phys)
    FocalSurface_phys->CheckOverlaps(10000);
#endif

  }


}