Gabriele Cosmo
183 lines
7.7 KiB
C++
183 lines
7.7 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
// gpaterno, October 2025
|
|
//
|
|
/// \file DetectorConstruction.hh
|
|
/// \brief Description of the DetectorConstruction class
|
|
//
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
|
|
|
|
#ifndef DetectorConstruction_h
|
|
#define DetectorConstruction_h 1
|
|
|
|
#include "G4VUserDetectorConstruction.hh"
|
|
#include "G4ios.hh"
|
|
#include "globals.hh"
|
|
#include "G4SystemOfUnits.hh"
|
|
#include <vector>
|
|
|
|
#include "G4Region.hh"
|
|
#include "G4PVPlacement.hh"
|
|
|
|
#include "DetectorConstructionMessenger.hh"
|
|
#include "G4ChannelingFastSimModel.hh"
|
|
|
|
#define NSpheresMax 10000
|
|
|
|
class G4VPhysicalVolume;
|
|
class G4LogicalVolume;
|
|
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
|
|
|
|
/// Detector construction class to define materials and geometry.
|
|
|
|
class DetectorConstruction : public G4VUserDetectorConstruction
|
|
{
|
|
public:
|
|
DetectorConstruction();
|
|
~DetectorConstruction() override = default;
|
|
|
|
G4VPhysicalVolume* Construct() override;
|
|
void ConstructSDandField() override;
|
|
|
|
//method to get the scoring volumes
|
|
std::vector<G4LogicalVolume*> GetScoringVolume() const {
|
|
return fScoringVolume;}
|
|
|
|
//method to set if it is a hybrid source or not
|
|
void SetHybridSource(G4bool val) {fHybridSource = val;}
|
|
|
|
//methods to set the Crystal (Radiator) features
|
|
void SetCrystalMaterial(G4String val) {fCrystalMaterialStr = val;}
|
|
void SetCrystalSize(G4ThreeVector val) {fCrystalSize = val;}
|
|
void SetCrystalBendingAngle(G4double val) {fBendingAngle = val;}
|
|
void SetCrystalLattice(G4String val) {fLattice = val;}
|
|
void SetCrystalAngleX(G4double val) {fAngleX = val;}
|
|
void SetCrystalAngleY(G4double val) {fAngleY = val;}
|
|
G4double GetCrystalZ() const {return fCrystalZ;}
|
|
void SetRadiationModel(G4bool val) {fActivateRadiationModel = val;}
|
|
void SetOCeffects(G4bool val) {fActivateOCeffects = val;}
|
|
G4bool GetOCeffects() const {return fActivateOCeffects;}
|
|
G4LogicalVolume* GetCrystalVolume() const {return fCrystalLogic;}
|
|
void SetPotentialPath(const G4String path){fPotentialPath = path;}
|
|
|
|
//method to set/get the Converter (Target) features
|
|
void SetRadiatorConverterSepDistance(G4double val) {
|
|
fRadiatorConverterSepDistance = val;}
|
|
G4double GetRadiatorConverterSepDistance() const {
|
|
return fRadiatorConverterSepDistance;}
|
|
void SetConverterSize(G4ThreeVector val) {fConverterSize = val;}
|
|
void SetConverterMaterial(G4String val) {fConverterMaterialStr = val;}
|
|
void SetGranularConverter(G4bool val) {fGranularConverter = val;}
|
|
void SetSphereRadius(G4double val) {fSphereRadius = val;}
|
|
G4int GetNSpheres() const {return fNSpheres;}
|
|
G4LogicalVolume* GetConverterVolume() const {return fConverterLogic;}
|
|
|
|
//methods to set the Magnetic field features
|
|
void SetMagneticField(G4bool val) {fSetMagneticField = val;}
|
|
void SetFieldValue(G4double val) {fFieldValue = val;}
|
|
void SetFieldRegionLength(G4double val) {fFieldRegionLength = val;}
|
|
|
|
//methods to set the Collimator features
|
|
void SetCollimator(G4bool val) {fSetCollimator = val;}
|
|
void SetCollimatorHole(G4String val) {fCollimatorHole = val;}
|
|
void SetCollimatorAperture(G4double val) {fCollimatorAperture = val;}
|
|
void SetCollimatorThickness(G4double val) {fCollimatorThickness = val;}
|
|
void SetCollimatorSide(G4double val) {fCollimatorSide = val;}
|
|
void SetRadiatorCollimatorSepDistance(G4double val) {
|
|
fRadiatorCollimatorSepDistance = val;}
|
|
G4double GetRadiatorCollimatorSepDistance() const {
|
|
return fRadiatorCollimatorSepDistance;}
|
|
|
|
//methods to set/Get the Virtual Detector features
|
|
void SetVirtualDetectorSize(G4ThreeVector val) {fVirtualDetectorSize = val;}
|
|
std::vector<G4ThreeVector> GetVirtualDetectorPositionVector() const {
|
|
return fVirtualDetectorPositionVector;}
|
|
|
|
//methods to set and get ScoreCrystalExit (27/09/2024)
|
|
void SetScoringCrystalExit(G4bool bval) {fScoringCrystalExit = bval;}
|
|
G4bool GetScoringCrystalExit() const {return fScoringCrystalExit;}
|
|
|
|
protected:
|
|
std::vector<G4LogicalVolume*> fScoringVolume; //for spheres only
|
|
|
|
private:
|
|
DetectorConstructionMessenger* fMessenger;
|
|
|
|
G4bool fHybridSource = true;
|
|
|
|
G4Region* fCrystalRegion{nullptr};
|
|
G4LogicalVolume* fCrystalLogic{nullptr};
|
|
G4String fCrystalMaterialStr = "W";
|
|
G4Material* fCrystalMaterial{nullptr};
|
|
G4ThreeVector fCrystalSize = G4ThreeVector(7.*mm, 7.*mm, 2.*mm);
|
|
G4double fBendingAngle = 0.e-6; //rad
|
|
G4String fLattice = "<111>";
|
|
G4double fAngleX = 0.e-6; //rad
|
|
G4double fAngleY = 0.e-6; //rad
|
|
G4double fCrystalZ = 0.;
|
|
G4bool fActivateRadiationModel = true;
|
|
G4bool fActivateOCeffects = true;
|
|
G4String fPotentialPath = "";
|
|
|
|
G4double fRadiatorConverterSepDistance = 60.*cm;
|
|
G4ThreeVector fConverterSize = G4ThreeVector(199.75*mm, 199.75*mm, 11.6*mm);
|
|
G4double fConverterZ = 0.;
|
|
G4LogicalVolume* fConverterLogic{nullptr};
|
|
G4bool fGranularConverter = false;
|
|
G4String fConverterMaterialStr = "W";
|
|
G4Material* fConverterMaterial{nullptr};
|
|
G4double fSphereRadius = 1.1*mm;
|
|
G4LogicalVolume* fSphereLogic[NSpheresMax];
|
|
G4int fNSpheres = 0;
|
|
G4bool fConverter = true;
|
|
|
|
G4bool fSetMagneticField = false;
|
|
G4double fFieldValue = 100.*tesla;
|
|
G4double fFieldRegionLength = 90.*cm;
|
|
G4LogicalVolume* fMFlogic{nullptr};
|
|
|
|
G4bool fSetCollimator = false;
|
|
G4double fCollimatorAperture = 2.*mm;
|
|
G4String fCollimatorHole = "squared";
|
|
G4double fCollimatorThickness = 50.*cm;
|
|
G4double fCollimatorSide = 2.5*m;
|
|
G4double fRadiatorCollimatorSepDistance = 5.*cm;
|
|
G4LogicalVolume* fCollimatorLogic{nullptr};
|
|
|
|
G4ThreeVector fVirtualDetectorSize = G4ThreeVector(40.*cm, 40.*cm, 0.01*mm);
|
|
std::vector<G4ThreeVector> fVirtualDetectorPositionVector;
|
|
G4LogicalVolume* fVirtualDetectorLogic0{nullptr};
|
|
G4LogicalVolume* fVirtualDetectorLogic1{nullptr};
|
|
G4LogicalVolume* fVirtualDetectorLogic2{nullptr};
|
|
|
|
G4bool fScoringCrystalExit = false;
|
|
};
|
|
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
|
|
|
|
#endif
|