FDsimG4Filter.cc

Go to the documentation of this file.

//#warning Preliminary implementation of filter frame. Exact geometry and material optical properties still needed.
#include "FDsimG4Filter.hh"
#include "FDsimG4DetectorConstruction.hh"
#include "FDsimG4Colours.hh"

#include "G4UnitsTable.hh"
#include "G4PVPlacement.hh"
#include "G4Box.hh"
#include "G4Tubs.hh"
#include "G4UnionSolid.hh"
#include "G4SubtractionSolid.hh"
#include "G4OpticalSurface.hh"
#include "G4LogicalBorderSurface.hh"
#include "G4LogicalSkinSurface.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
#include "G4LogicalVolume.hh"
#include "G4ThreeVector.hh"
#include "G4VisAttributes.hh"
#include "G4RunManager.hh"

#include <utl/unconfig.h>
#include <utl/config.h>

using namespace std;
using namespace TelescopeSimulatorLX;


FDsimG4Filter::FDsimG4Filter(G4VPhysicalVolume* const mother)
{
  fDetector =
    dynamic_cast<const FDsimG4DetectorConstruction*>(G4RunManager::GetRunManager()->GetUserDetectorConstruction());

  fMother = mother;
  fPosition = fDetector->fFilterPosition;
  fThickness = fDetector->fFilterThickness;
  fRadius = 0.5 * fDetector->fFilterDiameter;
  fMaterial = fDetector->fFilterMaterial;

  fFrameSize = fDetector->fFilterFrameSize;
  fFrameArmWidth = 5.0*cm;
  fFrameThickness = fDetector->fFilterFrameThickness;

  fFilter_log = nullptr;
  MakeFilter();
}


void
FDsimG4Filter::DumpInfo()
{
  G4cerr << " ================================================================\n"
            " =                    Filter parameters\n"
            " =\n"
            " =  Radius              : " << fRadius/mm    << "  mm\n"
            " =\n"
            " =  Thickness           : " << fThickness/mm << "  mm\n"
            " =\n"
            " =  Material            : " << fMaterial->GetName()
         << " =\n"
            " ================================================================" << G4endl;
}


void
FDsimG4Filter::MakeFilter()
{
  const G4double tolerance = 0.1*mm;

  MakeFrame();

  G4Tubs* const filterSolid =
    new G4Tubs("Filter", 0, fRadius, 0.5*fThickness, 0, 2*pi);

  fFilter_log = new G4LogicalVolume(filterSolid, (G4Material*)fMaterial, "Filter", 0,0,0);
  fFilter_log->SetVisAttributes(new G4VisAttributes(magenta));

  const G4ThreeVector filterPos =
    fPosition -
    G4ThreeVector(0, 0, 0.5*(fFrameThickness + fThickness) + tolerance);

  /*G4VPhysicalVolume* const filterPhys =*/
    new G4PVPlacement(0, filterPos, "UVFilter", fFilter_log, fMother, false, 0);
  G4VPhysicalVolume* const framePhys =
    new G4PVPlacement(0, fPosition, "Filter frame", fFrame_log, fMother, false, 0);

  new G4LogicalBorderSurface("Frame Surface", fMother, framePhys, fFrameOpticalSurface);

#if (G4VERSION_NUMBER >= 900)
  const G4int verbosityLevel = fDetector->fVerbosityLevel;
  if (verbosityLevel > 2) {
    filterPhys->CheckOverlaps(10000);
    framePhys->CheckOverlaps(10000);
  }
#endif
}


void
FDsimG4Filter::MakeFrame()
{
  const G4double tolerance = 0.1*mm;

  const G4double frameX = fFrameSize;
  const G4double frameY = fFrameSize;
  const G4double frameZ = fFrameThickness;

  G4Box* const frameBox = new G4Box("Frame_tmp", 0.5*frameX, 0.5*frameY, 0.5*frameZ);

  G4Tubs* const frameHole = new G4Tubs("Hole", 0, fRadius+tolerance, 10*frameZ, 0, 2*pi);

  G4Box* const frameArmBox = new G4Box("FrameArm", 0.5*fFrameArmWidth, 0.5*frameY - 0.5*(0.5*frameY - fRadius), 0.5*frameZ);

  const G4double yOffset = 0.5*frameY/3;
  // This offset is required for visualization purposes
  // see http://hypernews.slac.stanford.edu:5090/HyperNews/geant4/get/visualization/558/1.html
  const G4double zOffset = fFrameThickness;

  const G4ThreeVector frameArmPos_1 = G4ThreeVector(0, 0, zOffset);
  const G4ThreeVector frameArmPos_2 = G4ThreeVector(0, yOffset, zOffset);
  const G4ThreeVector frameArmPos_3 = G4ThreeVector(0, -yOffset, zOffset);

  G4SubtractionSolid* const frameTmp = new G4SubtractionSolid("Frame", frameBox, frameHole);

  G4RotationMatrix* const zRot90 = new G4RotationMatrix();
  zRot90->rotateZ(90*deg);

  G4UnionSolid* const frame_1 = new G4UnionSolid("Frame_1", frameTmp, frameArmBox, nullptr, frameArmPos_1);
  G4UnionSolid* const Frame_2 = new G4UnionSolid("Frame_2", frame_1, frameArmBox, zRot90, frameArmPos_2);
  G4UnionSolid* const fFrameSolid = new G4UnionSolid("Frame_3", frame_2, frameArmBox, zRot90, frameArmPos_3);

  fFrame_log = new G4LogicalVolume(fFrameSolid, G4Material::GetMaterial("Aluminum"), "Filter Frame", 0,0,0);
  fFrame_log->SetVisAttributes(new G4VisAttributes(gray));

  // Set reflection properties

  const G4String& frameReflectionType = fDetector->fFilterFrameReflectionType;
  const vector<G4double>& wavelength = fDetector->fFilterFrameWavelength;
  const vector<G4double>& reflectivity = fDetector->fFilterFrameReflectivity;

  fFrameOpticalSurface = new G4OpticalSurface("Filter frame");
  fFrameOpticalSurface->SetModel(unified);
  fFrameOpticalSurface->SetType(dielectric_metal);
  fFrameOpticalSurface->SetFinish(polished);

  G4MaterialPropertiesTable* const frameMPT = new G4MaterialPropertiesTable();
  frameMPT->AddProperty("REFLECTIVITY", new G4MaterialPropertyVector());

  for (unsigned iwl = 0, n = wavelength.size(); iwl < n; ++iwl) {
    const G4double energy = h_Planck * c_light / wavelength[iwl];
    frameMPT->AddEntry("REFLECTIVITY", energy, reflectivity[iwl]);
  }

  const G4int VerbosityLevel = fDetector->fVerbosityLevel;
  if (VerbosityLevel > 0) {
    G4cerr << "==== Filter Frame Surface properties ====\n"
              "==== Reflection type : " << FrameReflectionType << "====" << G4endl;
  }

  if (FrameReflectionType == "Diffusive") {
    const SurfaceRoughness& frameRoughness = fDetector->fFilterFrameRoughness;
    const G4double& sigma_alpha = frameRoughness.Sigma_alpha;
    const vector<G4double>& wavelengthRoughness = frameRoughness.Wavelength;
    const vector<G4double>& specularSpike = frameRoughness.SpecularSpike;
    const vector<G4double>& specularLobe = frameRoughness.SpecularLobe;
    const vector<G4double>& backscatter = frameRoughness.Backscatter;

    fFrameOpticalSurface->SetFinish(ground);
    fFrameOpticalSurface->SetSigmaAlpha(sigma_alpha);

    frameMPT->AddProperty("SPECULARSPIKECONSTANT", new G4MaterialPropertyVector());
    frameMPT->AddProperty("SPECULARLOBECONSTANT", new G4MaterialPropertyVector());
    frameMPT->AddProperty("BACKSCATTERCONSTANT", new G4MaterialPropertyVector());

    for (unsigned iwl = 0, n = wavelengthRoughness.size(); iwl < n; ++iwl) {
      const G4double energy = h_Planck * c_light / wavelengthRoughness[iwl];
      frameMPT->AddEntry("SPECULARSPIKECONSTANT", energy, specularSpike[iwl]);
      frameMPT->AddEntry("SPECULARLOBECONSTANT", energy, specularLobe[iwl]);
      frameMPT->AddEntry("BACKSCATTERCONSTANT", energy, backscatter[iwl]);
    }

    if (VerbosityLevel > 0) {
      G4cerr << "==== sigma_alpha = " << sigma_alpha/deg << " deg. ====\n"
                "==== Parameters vs wavelength (Wl (nm) \t Reflectivity \t SpecularSpike \t SpecularLobe \t Backscatter) ===="  << G4endl;

      for (unsigned i = 0, n = wavelengthRoughness.size(); i < n; ++i) {
        G4cerr << wavelengthRoughness[i]/nm << '\t'
               << reflectivity[i] << '\t'
               << specularSpike[i] << '\t'
               << specularLobe[i] << '\t'
               << backscatter[i] << G4endl;
      }
    }

  }

  fFrameOpticalSurface->SetMaterialPropertiesTable(FrameMPT);
}