lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.6.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2019-06-28 11:59:04 +02:00
parent 28a70706e0
commit d0f911957d
1056 changed files with 95168 additions and 78160 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/optical/include/G4OpAbsorption.hh
+21 -40
View File
@@ -66,53 +66,34 @@
// Class inherits publicly from G4VDiscreteProcess
// Class Description - End:
/////////////////////
// Class Definition
/////////////////////
class G4OpAbsorption : public G4VDiscreteProcess
class G4OpAbsorption : public G4VDiscreteProcess
{
public:
////////////////////////////////
// Constructors and Destructor
////////////////////////////////
explicit G4OpAbsorption(const G4String& processName = "OpAbsorption",
G4ProcessType type = fOptical);
virtual ~G4OpAbsorption();
G4OpAbsorption(const G4String& processName = "OpAbsorption",
G4ProcessType type = fOptical);
~G4OpAbsorption();
virtual G4bool IsApplicable(const G4ParticleDefinition& aParticleType) override;
// Returns true -> 'is applicable' only for an optical photon.
virtual G4double GetMeanFreePath(const G4Track& aTrack,
G4double ,
G4ForceCondition*) override;
// Returns the absorption length for bulk absorption of optical
// photons in media with a specified attenuation length.
virtual G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// This is the method implementing bulk absorption of optical
// photons.
private:
G4OpAbsorption(const G4OpAbsorption &right);
//////////////
// Operators
//////////////
G4OpAbsorption& operator=(const G4OpAbsorption &right);
public:
////////////
// Methods
////////////
G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
// Returns true -> 'is applicable' only for an optical photon.
G4double GetMeanFreePath(const G4Track& aTrack,
G4double ,
G4ForceCondition* );
// Returns the absorption length for bulk absorption of optical
// photons in media with a specified attenuation length.
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep);
// This is the method implementing bulk absorption of optical
// photons.
G4OpAbsorption(const G4OpAbsorption &right) = delete;
G4OpAbsorption& operator=(const G4OpAbsorption &right) = delete;
};
////////////////////
@@ -122,7 +103,7 @@ public:
inline
G4bool G4OpAbsorption::IsApplicable(const G4ParticleDefinition& aParticleType)
{
return ( &aParticleType == G4OpticalPhoton::OpticalPhoton() );
return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
}
#endif /* G4OpAbsorption_h */
source/processes/optical/include/G4OpBoundaryProcess.hh
+125 -166
View File
@@ -65,10 +65,6 @@
#ifndef G4OpBoundaryProcess_h
#define G4OpBoundaryProcess_h 1
/////////////
// Includes
/////////////
#include "globals.hh"
#include "templates.hh"
#include "geomdefs.hh"
@@ -92,10 +88,6 @@
// Class inherits publicly from G4VDiscreteProcess.
// Class Description - End:
/////////////////////
// Class Definition
/////////////////////
enum G4OpBoundaryProcessStatus { Undefined,
Transmission, FresnelRefraction,
FresnelReflection, TotalInternalReflection,
@@ -134,136 +126,114 @@ class G4OpBoundaryProcess : public G4VDiscreteProcess
public:
////////////////////////////////
// Constructors and Destructor
////////////////////////////////
explicit G4OpBoundaryProcess(const G4String& processName = "OpBoundary",
G4ProcessType type = fOptical);
virtual ~G4OpBoundaryProcess();
G4OpBoundaryProcess(const G4String& processName = "OpBoundary",
G4ProcessType type = fOptical);
~G4OpBoundaryProcess();
virtual G4bool IsApplicable(const G4ParticleDefinition& aParticleType) override;
// Returns true -> 'is applicable' only for an optical photon.
virtual G4double GetMeanFreePath(const G4Track&, G4double, G4ForceCondition* condition) override;
// Returns infinity; i. e. the process does not limit the step,
// but sets the 'Forced' condition for the DoIt to be invoked at
// every step. However, only at a boundary will any action be
// taken.
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// This is the method implementing boundary processes.
virtual G4OpBoundaryProcessStatus GetStatus() const;
// Returns the current status.
virtual void SetInvokeSD(G4bool);
// Set flag for call to InvokeSD method.
private:
G4OpBoundaryProcess(const G4OpBoundaryProcess &right);
G4OpBoundaryProcess(const G4OpBoundaryProcess &right) = delete;
G4OpBoundaryProcess& operator=(const G4OpBoundaryProcess &right) = delete;
//////////////
// Operators
//////////////
G4bool G4BooleanRand(const G4double prob) const;
G4OpBoundaryProcess& operator=(const G4OpBoundaryProcess &right);
G4ThreeVector GetFacetNormal(const G4ThreeVector& Momentum,
const G4ThreeVector& Normal) const;
public:
void DielectricMetal();
void DielectricDielectric();
////////////
// Methods
////////////
void DielectricLUT();
void DielectricLUTDAVIS();
G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
// Returns true -> 'is applicable' only for an optical photon.
void DielectricDichroic();
G4double GetMeanFreePath(const G4Track& ,
G4double ,
G4ForceCondition* condition);
// Returns infinity; i. e. the process does not limit the step,
// but sets the 'Forced' condition for the DoIt to be invoked at
// every step. However, only at a boundary will any action be
// taken.
void ChooseReflection();
void DoAbsorption();
void DoReflection();
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep);
// This is the method implementing boundary processes.
G4double GetIncidentAngle();
// Returns the incident angle of optical photon
G4OpBoundaryProcessStatus GetStatus() const;
// Returns the current status.
G4double GetReflectivity(G4double E1_perp,
G4double E1_parl,
G4double incidentangle,
G4double RealRindex,
G4double ImaginaryRindex);
// Returns the Reflectivity on a metalic surface
void SetInvokeSD(G4bool );
// Set flag for call to InvokeSD method.
void CalculateReflectivity(void);
private:
void BoundaryProcessVerbose(void) const;
G4bool G4BooleanRand(const G4double prob) const;
// Invoke SD for post step point if the photon is 'detected'
G4bool InvokeSD(const G4Step* step);
G4ThreeVector GetFacetNormal(const G4ThreeVector& Momentum,
const G4ThreeVector& Normal) const;
G4double thePhotonMomentum;
void DielectricMetal();
void DielectricDielectric();
G4ThreeVector OldMomentum;
G4ThreeVector OldPolarization;
void DielectricLUT();
void DielectricLUTDAVIS();
G4ThreeVector NewMomentum;
G4ThreeVector NewPolarization;
void DielectricDichroic();
G4ThreeVector theGlobalNormal;
G4ThreeVector theFacetNormal;
void ChooseReflection();
void DoAbsorption();
void DoReflection();
G4Material* Material1;
G4Material* Material2;
G4double GetIncidentAngle();
// Returns the incident angle of optical photon
G4OpticalSurface* OpticalSurface;
G4double GetReflectivity(G4double E1_perp,
G4double E1_parl,
G4double incidentangle,
G4double RealRindex,
G4double ImaginaryRindex);
// Returns the Reflectivity on a metalic surface
G4MaterialPropertyVector* fRealRIndexMPV;
G4MaterialPropertyVector* fImagRIndexMPV;
void CalculateReflectivity(void);
G4double Rindex1;
G4double Rindex2;
void BoundaryProcessVerbose(void) const;
G4double cost1, cost2, sint1, sint2;
// Invoke SD for post step point if the photon is 'detected'
G4bool InvokeSD(const G4Step* step);
G4OpBoundaryProcessStatus theStatus;
private:
G4OpticalSurfaceModel theModel;
G4double thePhotonMomentum;
G4OpticalSurfaceFinish theFinish;
G4ThreeVector OldMomentum;
G4ThreeVector OldPolarization;
G4double theReflectivity;
G4double theEfficiency;
G4double theTransmittance;
G4ThreeVector NewMomentum;
G4ThreeVector NewPolarization;
G4double theSurfaceRoughness;
G4ThreeVector theGlobalNormal;
G4ThreeVector theFacetNormal;
G4double prob_sl, prob_ss, prob_bs;
G4Material* Material1;
G4Material* Material2;
G4int iTE, iTM;
G4OpticalSurface* OpticalSurface;
G4double kCarTolerance;
G4MaterialPropertyVector* PropertyPointer;
G4MaterialPropertyVector* PropertyPointer1;
G4MaterialPropertyVector* PropertyPointer2;
size_t idx, idy;
G4Physics2DVector* DichroicVector;
G4double Rindex1;
G4double Rindex2;
G4double cost1, cost2, sint1, sint2;
G4OpBoundaryProcessStatus theStatus;
G4OpticalSurfaceModel theModel;
G4OpticalSurfaceFinish theFinish;
G4double theReflectivity;
G4double theEfficiency;
G4double theTransmittance;
G4double theSurfaceRoughness;
G4double prob_sl, prob_ss, prob_bs;
G4int iTE, iTM;
G4double kCarTolerance;
size_t idx, idy;
G4Physics2DVector* DichroicVector;
G4bool fInvokeSD;
G4bool fInvokeSD;
};
////////////////////
@@ -274,21 +244,20 @@ inline
G4bool G4OpBoundaryProcess::G4BooleanRand(const G4double prob) const
{
/* Returns a random boolean variable with the specified probability */
return (G4UniformRand() < prob);
}
inline
G4bool G4OpBoundaryProcess::IsApplicable(const G4ParticleDefinition&
G4bool G4OpBoundaryProcess::IsApplicable(const G4ParticleDefinition&
aParticleType)
{
return ( &aParticleType == G4OpticalPhoton::OpticalPhoton() );
return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
}
inline
G4OpBoundaryProcessStatus G4OpBoundaryProcess::GetStatus() const
{
return theStatus;
return theStatus;
}
inline
@@ -300,77 +269,67 @@ void G4OpBoundaryProcess::SetInvokeSD(G4bool flag)
inline
void G4OpBoundaryProcess::ChooseReflection()
{
G4double rand = G4UniformRand();
if ( rand >= 0.0 && rand < prob_ss ) {
theStatus = SpikeReflection;
theFacetNormal = theGlobalNormal;
}
else if ( rand >= prob_ss &&
rand <= prob_ss+prob_sl) {
theStatus = LobeReflection;
}
else if ( rand > prob_ss+prob_sl &&
rand < prob_ss+prob_sl+prob_bs ) {
theStatus = BackScattering;
}
else {
theStatus = LambertianReflection;
}
G4double rand = G4UniformRand();
if (rand >= 0.0 && rand < prob_ss) {
theStatus = SpikeReflection;
theFacetNormal = theGlobalNormal;
}
else if ( rand >= prob_ss && rand <= prob_ss+prob_sl) {
theStatus = LobeReflection;
}
else if ( rand > prob_ss+prob_sl && rand < prob_ss+prob_sl+prob_bs ) {
theStatus = BackScattering;
}
else {
theStatus = LambertianReflection;
}
}
inline
void G4OpBoundaryProcess::DoAbsorption()
{
theStatus = Absorption;
theStatus = Absorption;
if ( G4BooleanRand(theEfficiency) ) {
if (G4BooleanRand(theEfficiency)) {
// EnergyDeposited =/= 0 means: photon has been detected
theStatus = Detection;
aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
}
else {
aParticleChange.ProposeLocalEnergyDeposit(0.0);
}
// EnergyDeposited =/= 0 means: photon has been detected
theStatus = Detection;
aParticleChange.ProposeLocalEnergyDeposit(thePhotonMomentum);
}
else {
aParticleChange.ProposeLocalEnergyDeposit(0.0);
}
NewMomentum = OldMomentum;
NewPolarization = OldPolarization;
NewMomentum = OldMomentum;
NewPolarization = OldPolarization;
// aParticleChange.ProposeEnergy(0.0);
aParticleChange.ProposeTrackStatus(fStopAndKill);
aParticleChange.ProposeTrackStatus(fStopAndKill);
}
inline
void G4OpBoundaryProcess::DoReflection()
{
if ( theStatus == LambertianReflection ) {
NewMomentum = G4LambertianRand(theGlobalNormal);
theFacetNormal = (NewMomentum - OldMomentum).unit();
}
else if ( theFinish == ground ) {
theStatus = LobeReflection;
if ( PropertyPointer1 && PropertyPointer2 ){
} else {
theFacetNormal =
GetFacetNormal(OldMomentum,theGlobalNormal);
}
G4double PdotN = OldMomentum * theFacetNormal;
NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
}
else {
theStatus = SpikeReflection;
theFacetNormal = theGlobalNormal;
G4double PdotN = OldMomentum * theFacetNormal;
NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
}
G4double EdotN = OldPolarization * theFacetNormal;
NewPolarization = -OldPolarization + (2.*EdotN)*theFacetNormal;
if (theStatus == LambertianReflection) {
NewMomentum = G4LambertianRand(theGlobalNormal);
theFacetNormal = (NewMomentum - OldMomentum).unit();
}
else if (theFinish == ground) {
theStatus = LobeReflection;
if (fRealRIndexMPV && fImagRIndexMPV) {
//
} else {
theFacetNormal = GetFacetNormal(OldMomentum,theGlobalNormal);
}
G4double PdotN = OldMomentum * theFacetNormal;
NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
}
else {
theStatus = SpikeReflection;
theFacetNormal = theGlobalNormal;
G4double PdotN = OldMomentum * theFacetNormal;
NewMomentum = OldMomentum - (2.*PdotN)*theFacetNormal;
}
G4double EdotN = OldPolarization * theFacetNormal;
NewPolarization = -OldPolarization + (2.*EdotN)*theFacetNormal;
}
#endif /* G4OpBoundaryProcess_h */
source/processes/optical/include/G4OpMieHG.hh
+17 -30
View File
@@ -50,48 +50,35 @@ class G4OpMieHG : public G4VDiscreteProcess
public:
////////////////////////////////
// Constructors and Destructor
////////////////////////////////
G4OpMieHG(const G4String& processName = "OpMieHG",
explicit G4OpMieHG(const G4String& processName = "OpMieHG",
G4ProcessType type = fOptical);
~G4OpMieHG();
private:
G4OpMieHG(const G4OpMieHG &right);
//////////////
// Operators
//////////////
G4OpMieHG& operator=(const G4OpMieHG &right);
virtual ~G4OpMieHG();
public:
////////////
// Methods
////////////
virtual G4bool IsApplicable(const G4ParticleDefinition& aParticleType) override;
// Returns true -> 'is applicable' only for an optical photon.
G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
// Returns true -> 'is applicable' only for an optical photon.
virtual G4double GetMeanFreePath(const G4Track& aTrack,
G4double,
G4ForceCondition*) override;
// Return the mean free path of Mie scattering
G4double GetMeanFreePath(const G4Track& aTrack,
G4double,
G4ForceCondition* );
// Return the mean free path of Mie scattering
virtual G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// This is the method implementing Mie scattering.
private:
G4OpMieHG(const G4OpMieHG &right) = delete;
G4OpMieHG& operator=(const G4OpMieHG &right) = delete;
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep);
// This is the method implementing Mie scattering.
};
inline
G4bool G4OpMieHG::IsApplicable(const G4ParticleDefinition& aParticleType)
{
return ( &aParticleType == G4OpticalPhoton::OpticalPhoton() );
return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
}
#endif /* G4OpMieHG_h */
source/processes/optical/include/G4OpRayleigh.hh
+38 -77
View File
@@ -47,10 +47,6 @@
#ifndef G4OpRayleigh_h
#define G4OpRayleigh_h 1
/////////////
// Includes
/////////////
#include "globals.hh"
#include "templates.hh"
#include "Randomize.hh"
@@ -69,87 +65,54 @@
// Class inherits publicly from G4VDiscreteProcess.
// Class Description - End:
/////////////////////
// Class Definition
/////////////////////
class G4OpRayleigh : public G4VDiscreteProcess
class G4OpRayleigh : public G4VDiscreteProcess
{
public:
////////////////////////////////
// Constructors and Destructor
////////////////////////////////
G4OpRayleigh(const G4String& processName = "OpRayleigh",
explicit G4OpRayleigh(const G4String& processName = "OpRayleigh",
G4ProcessType type = fOptical);
~G4OpRayleigh();
private:
G4OpRayleigh(const G4OpRayleigh &right);
//////////////
// Operators
//////////////
G4OpRayleigh& operator=(const G4OpRayleigh &right);
virtual ~G4OpRayleigh();
public:
////////////
// Methods
////////////
virtual G4bool IsApplicable(const G4ParticleDefinition& aParticleType) override;
// Returns true -> 'is applicable' only for an optical photon.
G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
// Returns true -> 'is applicable' only for an optical photon.
virtual void BuildPhysicsTable(const G4ParticleDefinition& aParticleType) override;
// Build thePhysicsTable at a right time
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);
// Build thePhysicsTable at a right time
virtual G4double GetMeanFreePath(const G4Track& aTrack,
G4double,
G4ForceCondition*) override;
// Returns the mean free path for Rayleigh scattering
G4double GetMeanFreePath(const G4Track& aTrack,
G4double ,
G4ForceCondition* );
// Returns the mean free path for Rayleigh scattering in water.
// --- Not yet implemented for other materials! ---
virtual G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// This is the method implementing Rayleigh scattering.
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep);
// This is the method implementing Rayleigh scattering.
virtual G4PhysicsTable* GetPhysicsTable() const;
// Returns the address of the physics table.
G4PhysicsTable* GetPhysicsTable() const;
// Returns the address of the physics table.
void DumpPhysicsTable() const;
// Prints the physics table.
private:
/////////////////////
// Helper Functions
/////////////////////
/// Calculates the mean free paths for a material as a function of
/// photon energy
///
/// @param[in] material information
/// @return the mean free path vector
G4PhysicsOrderedFreeVector*
CalculateRayleighMeanFreePaths( const G4Material* material ) const;
///////////////////////
// Class Data Members
///////////////////////
virtual void DumpPhysicsTable() const;
// Prints the physics table.
protected:
G4PhysicsTable* thePhysicsTable;
// A Physics Table can be either a cross-sections table or
// an energy table (or can be used for other specific
// purposes).
G4PhysicsTable* thePhysicsTable;
// A Physics Table can be either a cross-sections table or
// an energy table (or can be used for other specific
// purposes).
private:
G4OpRayleigh(const G4OpRayleigh &right) = delete;
G4OpRayleigh& operator=(const G4OpRayleigh &right) = delete;
/// Calculates the mean free paths for a material as a function of
/// photon energy
G4PhysicsOrderedFreeVector*
CalculateRayleighMeanFreePaths( const G4Material* material ) const;
};
////////////////////
@@ -159,21 +122,20 @@ private:
inline
G4bool G4OpRayleigh::IsApplicable(const G4ParticleDefinition& aParticleType)
{
return ( &aParticleType == G4OpticalPhoton::OpticalPhoton() );
return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
}
inline
void G4OpRayleigh::DumpPhysicsTable() const
{
G4int PhysicsTableSize = thePhysicsTable->entries();
G4PhysicsOrderedFreeVector *v;
G4int PhysicsTableSize = thePhysicsTable->entries();
G4PhysicsOrderedFreeVector *v;
for (G4int i = 0 ; i < PhysicsTableSize ; i++ )
{
v = (G4PhysicsOrderedFreeVector*)(*thePhysicsTable)[i];
v->DumpValues();
}
for (G4int i = 0; i < PhysicsTableSize; ++i)
{
v = (G4PhysicsOrderedFreeVector*)(*thePhysicsTable)[i];
v->DumpValues();
}
}
inline G4PhysicsTable* G4OpRayleigh::GetPhysicsTable() const
@@ -181,5 +143,4 @@ inline G4PhysicsTable* G4OpRayleigh::GetPhysicsTable() const
return thePhysicsTable;
}
#endif /* G4OpRayleigh_h */
source/processes/optical/include/G4OpWLS.hh
+36 -60
View File
@@ -45,10 +45,6 @@
#ifndef G4OpWLS_h
#define G4OpWLS_h 1
/////////////
// Includes
/////////////
#include "globals.hh"
#include "templates.hh"
#include "Randomize.hh"
@@ -70,72 +66,52 @@
// Class inherits publicly from G4VDiscreteProcess
// Class Description - End:
/////////////////////
// Class Definition
/////////////////////
class G4VWLSTimeGeneratorProfile;
class G4OpWLS : public G4VDiscreteProcess
class G4OpWLS : public G4VDiscreteProcess
{
public:
////////////////////////////////
// Constructors and Destructor
////////////////////////////////
explicit G4OpWLS(const G4String& processName = "OpWLS",
G4ProcessType type = fOptical);
virtual ~G4OpWLS();
G4OpWLS(const G4String& processName = "OpWLS",
G4ProcessType type = fOptical);
~G4OpWLS();
virtual G4bool IsApplicable(const G4ParticleDefinition& aParticleType) override;
// Returns true -> 'is applicable' only for an optical photon.
private:
virtual void BuildPhysicsTable(const G4ParticleDefinition& aParticleType) override;
// Build the WLS integral table at the right time
G4OpWLS(const G4OpWLS &right);
virtual G4double GetMeanFreePath(const G4Track& aTrack,
G4double,
G4ForceCondition*) override;
// Returns the absorption length for bulk absorption of optical
// photons in media with a specified attenuation length.
//////////////
// Operators
//////////////
virtual G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// This is the method implementing bulk absorption of optical
// photons.
G4OpWLS& operator=(const G4OpWLS &right);
virtual G4PhysicsTable* GetIntegralTable() const;
// Returns the address of the WLS integral table.
public:
virtual void DumpPhysicsTable() const;
// Prints the WLS integral table.
////////////
// Methods
////////////
G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
// Returns true -> 'is applicable' only for an optical photon.
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);
// Build the WLS integral table at the right time
G4double GetMeanFreePath(const G4Track& aTrack,
G4double ,
G4ForceCondition* );
// Returns the absorption length for bulk absorption of optical
// photons in media with a specified attenuation length.
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep);
// This is the method implementing bulk absorption of optical
// photons.
G4PhysicsTable* GetIntegralTable() const;
// Returns the address of the WLS integral table.
void DumpPhysicsTable() const;
// Prints the WLS integral table.
void UseTimeProfile(const G4String name);
// Selects the time profile generator
void UseTimeProfile(const G4String name);
// Selects the time profile generator
protected:
G4VWLSTimeGeneratorProfile* WLSTimeGeneratorProfile;
G4PhysicsTable* theIntegralTable;
G4VWLSTimeGeneratorProfile* WLSTimeGeneratorProfile;
G4PhysicsTable* theIntegralTable;
private:
G4OpWLS(const G4OpWLS &right) = delete;
G4OpWLS& operator=(const G4OpWLS &right) = delete;
};
////////////////////
@@ -145,7 +121,7 @@ protected:
inline
G4bool G4OpWLS::IsApplicable(const G4ParticleDefinition& aParticleType)
{
return ( &aParticleType == G4OpticalPhoton::OpticalPhoton() );
return (&aParticleType == G4OpticalPhoton::OpticalPhoton());
}
inline
@@ -159,12 +135,12 @@ void G4OpWLS::DumpPhysicsTable() const
{
G4int PhysicsTableSize = theIntegralTable->entries();
G4PhysicsOrderedFreeVector *v;
for (G4int i = 0 ; i < PhysicsTableSize ; i++ )
{
v = (G4PhysicsOrderedFreeVector*)(*theIntegralTable)[i];
v->DumpValues();
}
for (G4int i = 0; i < PhysicsTableSize; i++)
{
v = (G4PhysicsOrderedFreeVector*)(*theIntegralTable)[i];
v->DumpValues();
}
}
#endif /* G4OpWLS_h */
source/processes/optical/include/G4VWLSTimeGeneratorProfile.hh
+4 -6
View File
@@ -52,7 +52,7 @@
#include "globals.hh"
#include "G4MaterialPropertiesTable.hh"
class G4VWLSTimeGeneratorProfile
class G4VWLSTimeGeneratorProfile
{
public:
@@ -64,15 +64,13 @@ public:
virtual G4double GenerateTime(const G4double time_constant) = 0;
virtual G4double GenerateTime(const G4MaterialPropertiesTable*) = 0;
protected:
private:
// hide assignment operator
G4VWLSTimeGeneratorProfile & operator=
(const G4VWLSTimeGeneratorProfile &right);
G4VWLSTimeGeneratorProfile(const G4VWLSTimeGeneratorProfile&);
G4VWLSTimeGeneratorProfile & operator=
(const G4VWLSTimeGeneratorProfile &right) = delete;
G4VWLSTimeGeneratorProfile(const G4VWLSTimeGeneratorProfile&) = delete;
};
source/processes/optical/include/G4WLSTimeGeneratorProfileDelta.hh
+8 -8
View File
@@ -52,23 +52,23 @@ class G4WLSTimeGeneratorProfileDelta : public G4VWLSTimeGeneratorProfile
public:
G4WLSTimeGeneratorProfileDelta(const G4String& name);
explicit G4WLSTimeGeneratorProfileDelta(const G4String& name);
~G4WLSTimeGeneratorProfileDelta();
virtual ~G4WLSTimeGeneratorProfileDelta();
G4double GenerateTime(const G4double time_constant);
virtual G4double GenerateTime(const G4double time_constant) override;
G4double GenerateTime(const G4MaterialPropertiesTable*);
virtual G4double GenerateTime(const G4MaterialPropertiesTable*) override;
protected:
private:
// hide assignment operator
G4WLSTimeGeneratorProfileDelta & operator=
(const G4WLSTimeGeneratorProfileDelta &right);
G4WLSTimeGeneratorProfileDelta(const G4WLSTimeGeneratorProfileDelta&);
G4WLSTimeGeneratorProfileDelta & operator=
(const G4WLSTimeGeneratorProfileDelta &right) = delete;
G4WLSTimeGeneratorProfileDelta(const G4WLSTimeGeneratorProfileDelta&) = delete;
};
source/processes/optical/include/G4WLSTimeGeneratorProfileExponential.hh
+8 -8
View File
@@ -53,23 +53,23 @@ class G4WLSTimeGeneratorProfileExponential : public G4VWLSTimeGeneratorProfile
public:
G4WLSTimeGeneratorProfileExponential(const G4String& name);
explicit G4WLSTimeGeneratorProfileExponential(const G4String& name);
~G4WLSTimeGeneratorProfileExponential();
virtual ~G4WLSTimeGeneratorProfileExponential();
G4double GenerateTime(const G4double time_constant);
virtual G4double GenerateTime(const G4double time_constant) override;
G4double GenerateTime(const G4MaterialPropertiesTable*);
virtual G4double GenerateTime(const G4MaterialPropertiesTable*) override;
protected:
private:
// hide assignment operator
G4WLSTimeGeneratorProfileExponential & operator=
(const G4WLSTimeGeneratorProfileExponential &right);
G4WLSTimeGeneratorProfileExponential(const G4WLSTimeGeneratorProfileExponential&);
G4WLSTimeGeneratorProfileExponential & operator=
(const G4WLSTimeGeneratorProfileExponential &right) = delete;
G4WLSTimeGeneratorProfileExponential(const G4WLSTimeGeneratorProfileExponential&) = delete;
};