Gabriele Cosmo
281 lines
8.4 KiB
C++
281 lines
8.4 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. *
|
|
// ********************************************************************
|
|
//
|
|
// -------------------------------------------------------------------
|
|
//
|
|
// GEANT4 Class header file
|
|
//
|
|
// File name: G4OpticalParameters
|
|
//
|
|
// Author: Daren Sawkey based on G4EmParameters
|
|
//
|
|
// Creation date: 14.07.2020
|
|
//
|
|
// Modifications:
|
|
//
|
|
//
|
|
// Class Description:
|
|
//
|
|
// A utility static class, responsable for keeping parameters
|
|
// for all optical physics processes and models.
|
|
//
|
|
// It is initialized by the master thread but can be updated
|
|
// at any moment. Parameters may be used in run time or at
|
|
// initialisation
|
|
//
|
|
// -------------------------------------------------------------------
|
|
//
|
|
|
|
#ifndef G4OpticalParameters_h
|
|
#define G4OpticalParameters_h 1
|
|
|
|
#include "globals.hh"
|
|
#include "G4ios.hh"
|
|
#include "G4ThreeVector.hh"
|
|
#include "G4Threading.hh"
|
|
#include <vector>
|
|
#include <memory>
|
|
|
|
class G4OpticalParametersMessenger;
|
|
class G4StateManager;
|
|
|
|
enum G4OpticalProcessIndex
|
|
{
|
|
kCerenkov, ///< Cerenkov process index
|
|
kScintillation, ///< Scintillation process index
|
|
kAbsorption, ///< Absorption process index
|
|
kRayleigh, ///< Rayleigh scattering process index
|
|
kMieHG, ///< Mie scattering process index
|
|
kBoundary, ///< Boundary process index
|
|
kWLS, ///< Wave Length Shifting process index
|
|
kWLS2, ///< Second Wave Length Shifting process index
|
|
kNoProcess ///< Number of processes, no selected process
|
|
};
|
|
|
|
enum G4XRayModelType
|
|
{
|
|
kCerenkovDefault = 0, // default model
|
|
kScintillationDefault, // default model
|
|
};
|
|
|
|
/// Return the name for a given optical process index
|
|
G4String G4OpticalProcessName(G4int);
|
|
|
|
inline G4String G4OpticalProcessName(G4int processNumber)
|
|
{
|
|
switch(processNumber)
|
|
{
|
|
case kCerenkov:
|
|
return "Cerenkov";
|
|
case kScintillation:
|
|
return "Scintillation";
|
|
case kAbsorption:
|
|
return "OpAbsorption";
|
|
case kRayleigh:
|
|
return "OpRayleigh";
|
|
case kMieHG:
|
|
return "OpMieHG";
|
|
case kBoundary:
|
|
return "OpBoundary";
|
|
case kWLS:
|
|
return "OpWLS";
|
|
case kWLS2:
|
|
return "OpWLS2";
|
|
default:
|
|
return "NoProcess";
|
|
}
|
|
}
|
|
|
|
class G4OpticalParameters
|
|
{
|
|
public:
|
|
static G4OpticalParameters* Instance();
|
|
|
|
~G4OpticalParameters();
|
|
|
|
void SetDefaults();
|
|
|
|
// printing
|
|
void StreamInfo(std::ostream& os) const;
|
|
void Dump() const;
|
|
friend std::ostream& operator<<(std::ostream& os, const G4OpticalParameters&);
|
|
|
|
void SetVerboseLevel(G4int);
|
|
G4int GetVerboseLevel() const;
|
|
|
|
void SetProcessActivation(const G4String&, G4bool);
|
|
G4bool GetProcessActivation(const G4String&) const;
|
|
|
|
// Cerenkov
|
|
void SetCerenkovMaxPhotonsPerStep(G4int);
|
|
G4int GetCerenkovMaxPhotonsPerStep() const;
|
|
void SetCerenkovVerboseLevel(G4int);
|
|
G4int GetCerenkovVerboseLevel() const;
|
|
void SetCerenkovMaxBetaChange(G4double);
|
|
G4double GetCerenkovMaxBetaChange() const;
|
|
void SetCerenkovTrackSecondariesFirst(G4bool);
|
|
G4bool GetCerenkovTrackSecondariesFirst() const;
|
|
void SetCerenkovStackPhotons(G4bool);
|
|
G4bool GetCerenkovStackPhotons() const;
|
|
void SetCerenkovOffloadPhotons(G4bool);
|
|
G4bool GetCerenkovOffloadPhotons() const;
|
|
void EnableCerenkovGeneral(G4bool);
|
|
G4bool CerenkovGeneral() const;
|
|
|
|
// Scintillation
|
|
void SetScintByParticleType(G4bool);
|
|
G4bool GetScintByParticleType() const;
|
|
void SetScintTrackInfo(G4bool);
|
|
G4bool GetScintTrackInfo() const;
|
|
void SetScintTrackSecondariesFirst(G4bool);
|
|
G4bool GetScintTrackSecondariesFirst() const;
|
|
void SetScintFiniteRiseTime(G4bool);
|
|
G4bool GetScintFiniteRiseTime() const;
|
|
void SetScintStackPhotons(G4bool);
|
|
G4bool GetScintStackPhotons() const;
|
|
void SetScintVerboseLevel(G4int);
|
|
G4int GetScintVerboseLevel() const;
|
|
void SetScintOffloadPhotons(G4bool);
|
|
G4bool GetScintOffloadPhotons() const;
|
|
|
|
// WLS
|
|
void SetWLSTimeProfile(const G4String&);
|
|
G4String GetWLSTimeProfile() const;
|
|
void SetWLSVerboseLevel(G4int);
|
|
G4int GetWLSVerboseLevel() const;
|
|
|
|
// WLS2
|
|
void SetWLS2TimeProfile(const G4String&);
|
|
G4String GetWLS2TimeProfile() const;
|
|
void SetWLS2VerboseLevel(G4int);
|
|
G4int GetWLS2VerboseLevel() const;
|
|
|
|
// boundary
|
|
void SetBoundaryVerboseLevel(G4int);
|
|
G4int GetBoundaryVerboseLevel() const;
|
|
void SetBoundaryInvokeSD(G4bool);
|
|
G4bool GetBoundaryInvokeSD() const;
|
|
|
|
// absorption
|
|
void SetAbsorptionVerboseLevel(G4int);
|
|
G4int GetAbsorptionVerboseLevel() const;
|
|
|
|
// rayleigh
|
|
void SetRayleighVerboseLevel(G4int);
|
|
G4int GetRayleighVerboseLevel() const;
|
|
|
|
// mie
|
|
void SetMieVerboseLevel(G4int);
|
|
G4int GetMieVerboseLevel() const;
|
|
|
|
// active volumes
|
|
const std::vector<std::pair<G4XRayModelType, const G4String> >&
|
|
ActiveVolumes() const;
|
|
void SetActiveVolume(const G4String& name, G4XRayModelType type);
|
|
|
|
private:
|
|
G4OpticalParameters();
|
|
void Initialise();
|
|
G4bool IsLocked() const;
|
|
void PrintWarning(G4ExceptionDescription& ed) const;
|
|
|
|
static G4OpticalParameters* theInstance;
|
|
|
|
G4OpticalParametersMessenger* theMessenger;
|
|
G4StateManager* fStateManager;
|
|
|
|
G4int verboseLevel;
|
|
|
|
// Whether to activate each process
|
|
std::map<G4String, G4bool> processActivation;
|
|
|
|
// cerenkov/////////////////
|
|
G4bool cerenkovStackPhotons;
|
|
G4bool cerenkovTrackSecondariesFirst;
|
|
G4bool cerenkovOffloadPhotons;
|
|
G4bool cerenkovGeneral;
|
|
G4int cerenkovVerboseLevel;
|
|
G4int cerenkovMaxPhotons;
|
|
G4double cerenkovMaxBetaChange;
|
|
|
|
// scintillation /////////////////
|
|
|
|
/// option to set a finite rise-time; Note: the G4Scintillation
|
|
/// process expects the user to have set the constant material
|
|
/// property SCINTILLATIONRISETIME{1,2,3}
|
|
G4bool scintFiniteRiseTime;
|
|
|
|
/// option to allow for the light yield to be a function of
|
|
/// particle type and deposited energy in case of non-linear
|
|
/// light emission in scintillators
|
|
G4bool scintByParticleType;
|
|
|
|
/// option to allow for G4ScintillationTrackInformation
|
|
/// to be attached to a scintillation photon's track
|
|
G4bool scintTrackInfo;
|
|
|
|
/// option to allow stacking of secondary scintillation photons
|
|
G4bool scintStackPhotons;
|
|
|
|
/// option to enable offloading of secondary scintillation photons
|
|
G4bool scintOffloadPhotons;
|
|
|
|
G4int scintVerboseLevel;
|
|
G4bool scintTrackSecondariesFirst;
|
|
|
|
///////////////// WLS
|
|
G4String wlsTimeProfileName;
|
|
G4int wlsVerboseLevel;
|
|
|
|
///////////////// WLS2
|
|
G4String wls2TimeProfileName;
|
|
G4int wls2VerboseLevel;
|
|
|
|
//////////////// absorption
|
|
G4int absorptionVerboseLevel;
|
|
|
|
//////////////// rayleigh
|
|
G4int rayleighVerboseLevel;
|
|
|
|
//////////////// mie
|
|
G4int mieVerboseLevel;
|
|
|
|
//////////////// boundary
|
|
/// G4OpBoundaryProcess to call InvokeSD method
|
|
G4bool boundaryInvokeSD;
|
|
G4int boundaryVerboseLevel;
|
|
|
|
//////////////// active volumes
|
|
std::vector<std::pair<G4XRayModelType, const G4String> > xrayVolumes;
|
|
|
|
#ifdef G4MULTITHREADED
|
|
static G4Mutex opticalParametersMutex;
|
|
#endif
|
|
};
|
|
|
|
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
|
|
|
|
#endif
|