FDsimG4Mercedes.cc

Go to the documentation of this file.

#include "FDsimG4Mercedes.hh"
#include "FDsimG4DetectorConstruction.hh"
#include "FDsimG4MercedesSD.hh"
#include "FDsimG4Colours.hh"
#include "G4UnitsTable.hh"
#include "G4IntersectionSolid.hh"
#include "G4Box.hh"
#include "G4RunManager.hh"
#include "G4SDManager.hh"
#include "G4OpticalSurface.hh"
#include "G4LogicalBorderSurface.hh"
#include "G4LogicalSkinSurface.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4Tubs.hh"
#include "G4Cons.hh"
#include "G4Trap.hh"
#include "G4Polyhedra.hh"
#include "G4UnionSolid.hh"
#include "G4LogicalVolume.hh"
#include "G4ThreeVector.hh"
#include "G4VisAttributes.hh"
#include "G4Colour.hh"

using namespace TelescopeSimulatorLX;

FDsimG4Mercedes::FDsimG4Mercedes()
{
  const G4RunManager* runManager = G4RunManager::GetRunManager();
  const FDsimG4DetectorConstruction* DetectorConstruction =  
    dynamic_cast<const FDsimG4DetectorConstruction*>(runManager->GetUserDetectorConstruction());
  
  fMercedesBase = DetectorConstruction->fMercedesBase; 
  fMercedesHeight = DetectorConstruction->fMercedesHeight; 
  fMercedesArmLength=13.15*mm;

  fMercedesMaterial = G4Material::GetMaterial("Aluminum");
  MakeMercedesLogicalVolume();
}


FDsimG4Mercedes::~FDsimG4Mercedes()
{
}


void FDsimG4Mercedes::DumpInfo()
{
  G4cerr << " ================================================================  " << G4endl;
  G4cerr << " =                    Mercedes parameters                          " << G4endl;
  G4cerr << " =                                                                 " << G4endl;
  G4cerr << " =  Material                : " << fMercedesMaterial->GetName()      << G4endl;
  G4cerr << " =                                                                 " << G4endl;    
  G4cerr << " ================================================================  " << G4endl;

  G4cerr << fMercedesMaterial->GetMaterialPropertiesTable() << G4endl;
  if (fMercedesMaterial->GetMaterialPropertiesTable())
    {
      if(fMercedesMaterial->GetMaterialPropertiesTable()->GetProperty("ABSORPTION"))
        {
          G4cerr << "Absorption Property Vector " << G4endl; 
          G4MaterialPropertyVector *Absorption = 
            fMercedesMaterial->GetMaterialPropertiesTable()->GetProperty("ABSORPTION");
          Absorption->DumpVector();
        } 
    }
}


void FDsimG4Mercedes::MakeMercedesLogicalVolume()
{
  const G4double TOLERANCE = 0.01*mm;   
  G4double MercedesSide = sqrt(pow(fMercedesBase/2.,2.)+pow(fMercedesHeight,2.));

  G4double Dphi = 2.0*atan(fMercedesBase/2./fMercedesHeight);
  G4double phi0 = 3.0*pi/2.-Dphi/2.;

  G4int NumZplanes=2;

  G4double PosZplanes[2] = {-TOLERANCE,fMercedesArmLength};
  G4double Rin[2] = {0.,0.};
  G4double Rout[2] = {MercedesSide,MercedesSide};

  // Build 3 polyhedra 

  G4Polyhedra* MercedesArm1 = 
    new G4Polyhedra("MercedesArm1",phi0,Dphi,1,NumZplanes,PosZplanes,Rin,Rout);
  
  G4Polyhedra* MercedesArm2 = 
    new G4Polyhedra("MercedesArm2",phi0,Dphi,1,NumZplanes,PosZplanes,Rin,Rout);
  G4Polyhedra* MercedesArm3 = 
    new G4Polyhedra("MercedesArm3",phi0,Dphi,1,NumZplanes,PosZplanes,Rin,Rout);

  G4RotationMatrix* ArmRot12 = 
    new G4RotationMatrix(G4ThreeVector(0.,1.,0.),2*pi/3.0);
  G4RotationMatrix* ArmRot13 = 
    new G4RotationMatrix(G4ThreeVector(0.,1.,0.),-2*pi/3.0);

  G4ThreeVector translation = G4ThreeVector(0.,0.,0.);

  G4UnionSolid* MercedesArms12
    = new G4UnionSolid("MercedesArms12",MercedesArm1,MercedesArm2,ArmRot12,translation);
  G4UnionSolid* MercedesArms123
    = new G4UnionSolid("MercedesArms123",MercedesArms12,MercedesArm3,ArmRot13,translation);

  fMercedes_log = 
    new G4LogicalVolume(MercedesArms123,(G4Material *)fMercedesMaterial,"Mercedes",0,0,0);

  fMercedes_log->SetVisAttributes(new G4VisAttributes(cyan));
  fMercedes_log->SetOptimisation(true) ;

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

  G4bool useSD = DetectorConstruction->fUseSensitiveDetectors; 
  if (useSD) {
    G4SDManager* SDmanager = G4SDManager::GetSDMpointer();
    FDsimG4MercedesSD* MercedesSD = new FDsimG4MercedesSD("MercedesSD");
    SDmanager->AddNewDetector(MercedesSD);
    fMercedes_log->SetSensitiveDetector(MercedesSD) ;
  }

  // define mercedes - air optical surface 
  //   G4OpticalSurface * OpticalAirMercedes = new G4OpticalSurface("MercedesSurface");
  //   OpticalAirMercedes->SetModel(unified);
  //   OpticalAirMercedes->SetType(dielectric_metal);   
  //   G4MaterialPropertiesTable *MercedesMPT = new G4MaterialPropertiesTable();
  //   MercedesMPT->AddProperty("REFLECTIVITY", new G4MaterialPropertyVector()) ;
  //   MercedesMPT->AddEntry("REFLECTIVITY", 0.0*eV,0.85);
  //   MercedesMPT->AddEntry("REFLECTIVITY",10.0*eV,0.85);
  //   OpticalAirMercedes->SetMaterialPropertiesTable(MercedesMPT) ;    
  //   new G4LogicalSkinSurface("MercedesSurface",fMercedes_log,OpticalAirMercedes);

}