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

Import Geant4 10.3.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-30 14:12:05 +02:00
parent a654a7ab1f
commit 4ec577e5c4
2021 changed files with 100995 additions and 78277 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/xrays/include/G4Cerenkov.hh
+105 -113
View File
@@ -24,14 +24,14 @@
// ********************************************************************
//
//
// $Id: G4Cerenkov.hh 85355 2014-10-28 09:58:59Z gcosmo $
// $Id: G4Cerenkov.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
//
////////////////////////////////////////////////////////////////////////
// Cerenkov Radiation Class Definition
// Cerenkov Radiation Class Definition
////////////////////////////////////////////////////////////////////////
//
// File: G4Cerenkov.hh
// File: G4Cerenkov.hh
// Description: Discrete Process - Generation of Cerenkov Photons
// Version: 2.0
// Created: 1996-02-21
@@ -63,7 +63,7 @@
#include "G4VProcess.hh"
#include "G4OpticalPhoton.hh"
#include "G4DynamicParticle.hh"
#include "G4Material.hh"
#include "G4Material.hh"
#include "G4PhysicsTable.hh"
#include "G4MaterialPropertyVector.hh"
#include "G4MaterialPropertiesTable.hh"
@@ -83,175 +83,167 @@ class G4Cerenkov : public G4VProcess
public:
////////////////////////////////
// Constructors and Destructor
////////////////////////////////
////////////////////////////////
// Constructors and Destructor
////////////////////////////////
G4Cerenkov(const G4String& processName = "Cerenkov",
G4ProcessType type = fElectromagnetic);
~G4Cerenkov();
explicit G4Cerenkov(const G4String& processName = "Cerenkov",
G4ProcessType type = fElectromagnetic);
~G4Cerenkov();
G4Cerenkov(const G4Cerenkov &right);
explicit G4Cerenkov(const G4Cerenkov &right);
private:
//////////////
// Operators
//////////////
//////////////
// Operators
//////////////
G4Cerenkov& operator=(const G4Cerenkov &right);
G4Cerenkov& operator=(const G4Cerenkov &right) = delete;
public:
////////////
// Methods
////////////
////////////
// Methods
////////////
G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
// Returns true -> 'is applicable', for all charged particles
// except short-lived particles.
G4bool IsApplicable(const G4ParticleDefinition& aParticleType) override;
// Returns true -> 'is applicable', for all charged particles
// except short-lived particles.
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);
// Build table at a right time
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType) override;
// Build table at a right time
G4double GetMeanFreePath(const G4Track& aTrack,
G4double ,
G4ForceCondition* );
// Returns the discrete step limit and sets the 'StronglyForced'
// condition for the DoIt to be invoked at every step.
G4double GetMeanFreePath(const G4Track& aTrack,
G4double, G4ForceCondition* );
// Returns the discrete step limit and sets the 'StronglyForced'
// condition for the DoIt to be invoked at every step.
G4double PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double ,
G4ForceCondition* );
// Returns the discrete step limit and sets the 'StronglyForced'
// condition for the DoIt to be invoked at every step.
G4double PostStepGetPhysicalInteractionLength(const G4Track& aTrack,
G4double ,
G4ForceCondition* ) override;
// Returns the discrete step limit and sets the 'StronglyForced'
// condition for the DoIt to be invoked at every step.
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep);
// This is the method implementing the Cerenkov process.
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// This is the method implementing the Cerenkov process.
// no operation in AtRestDoIt and AlongStepDoIt
virtual G4double AlongStepGetPhysicalInteractionLength(
const G4Track&,
G4double ,
G4double ,
G4double& ,
G4GPILSelection*
) { return -1.0; };
// no operation in AtRestDoIt and AlongStepDoIt
virtual G4double AlongStepGetPhysicalInteractionLength(const G4Track&,
G4double ,
G4double ,
G4double& ,
G4GPILSelection*
) override { return -1.0; };
virtual G4double AtRestGetPhysicalInteractionLength(
const G4Track& ,
G4ForceCondition*
) { return -1.0; };
virtual G4double AtRestGetPhysicalInteractionLength(const G4Track& ,
G4ForceCondition*
) override { return -1.0; };
// no operation in AtRestDoIt and AlongStepDoIt
virtual G4VParticleChange* AtRestDoIt(
const G4Track& ,
const G4Step&
) {return 0;};
// no operation in AtRestDoIt and AlongStepDoIt
virtual G4VParticleChange* AtRestDoIt(const G4Track& , const G4Step& )
override {return nullptr;};
virtual G4VParticleChange* AlongStepDoIt(
const G4Track& ,
const G4Step&
) {return 0;};
virtual G4VParticleChange* AlongStepDoIt(const G4Track& , const G4Step&)
override {return nullptr;};
void SetTrackSecondariesFirst(const G4bool state);
// If set, the primary particle tracking is interrupted and any
// produced Cerenkov photons are tracked next. When all have
// been tracked, the tracking of the primary resumes.
void SetTrackSecondariesFirst(const G4bool state);
// If set, the primary particle tracking is interrupted and any
// produced Cerenkov photons are tracked next. When all have
// been tracked, the tracking of the primary resumes.
G4bool GetTrackSecondariesFirst() const;
// Returns the boolean flag for tracking secondaries first.
G4bool GetTrackSecondariesFirst() const;
// Returns the boolean flag for tracking secondaries first.
void SetMaxBetaChangePerStep(const G4double d);
// Set the maximum allowed change in beta = v/c in % (perCent)
// per step.
void SetMaxBetaChangePerStep(const G4double d);
// Set the maximum allowed change in beta = v/c in % (perCent)
// per step.
G4double GetMaxBetaChangePerStep() const;
// Returns the maximum allowed change in beta = v/c in % (perCent)
G4double GetMaxBetaChangePerStep() const;
// Returns the maximum allowed change in beta = v/c in % (perCent)
void SetMaxNumPhotonsPerStep(const G4int NumPhotons);
// Set the maximum number of Cerenkov photons allowed to be
// generated during a tracking step. This is an average ONLY;
// the actual number will vary around this average. If invoked,
// the maximum photon stack will roughly be of the size set.
// If not called, the step is not limited by the number of
// photons generated.
void SetMaxNumPhotonsPerStep(const G4int NumPhotons);
// Set the maximum number of Cerenkov photons allowed to be
// generated during a tracking step. This is an average ONLY;
// the actual number will vary around this average. If invoked,
// the maximum photon stack will roughly be of the size set.
// If not called, the step is not limited by the number of
// photons generated.
G4int GetMaxNumPhotonsPerStep() const;
// Returns the maximum number of Cerenkov photons allowed to be
// generated during a tracking step.
G4int GetMaxNumPhotonsPerStep() const;
// Returns the maximum number of Cerenkov photons allowed to be
// generated during a tracking step.
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.
void DumpPhysicsTable() const;
// Prints the physics table.
private:
void BuildThePhysicsTable();
void BuildThePhysicsTable();
/////////////////////
// Helper Functions
/////////////////////
/////////////////////
// Helper Functions
/////////////////////
G4double GetAverageNumberOfPhotons(const G4double charge,
const G4double beta,
const G4Material *aMaterial,
G4MaterialPropertyVector* Rindex) const;
G4double GetAverageNumberOfPhotons(const G4double charge,
const G4double beta,
const G4Material *aMaterial,
G4MaterialPropertyVector* Rindex) const;
///////////////////////
// Class Data Members
///////////////////////
///////////////////////
// Class Data Members
///////////////////////
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:
G4bool fTrackSecondariesFirst;
G4double fMaxBetaChange;
G4int fMaxPhotons;
G4bool fTrackSecondariesFirst;
G4double fMaxBetaChange;
G4int fMaxPhotons;
};
////////////////////
// Inline methods
////////////////////
////////////////////
// Inline methods
////////////////////
inline
G4bool G4Cerenkov::GetTrackSecondariesFirst() const
{
return fTrackSecondariesFirst;
return fTrackSecondariesFirst;
}
inline
G4double G4Cerenkov::GetMaxBetaChangePerStep() const
{
return fMaxBetaChange;
return fMaxBetaChange;
}
inline
G4int G4Cerenkov::GetMaxNumPhotonsPerStep() const
{
return fMaxPhotons;
return fMaxPhotons;
}
inline
void G4Cerenkov::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
source/processes/electromagnetic/xrays/include/G4ForwardXrayTR.hh
+9 -9
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4ForwardXrayTR.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4ForwardXrayTR.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
// G4ForwardXrayTR
//
@@ -69,11 +69,11 @@ public:
// Constructors
G4ForwardXrayTR( const G4String& matName1, // G4Material* pMat1,
explicit G4ForwardXrayTR( const G4String& matName1, // G4Material* pMat1,
const G4String& matName2, // G4Material* pMat2,
const G4String& processName="XrayTR" );
G4ForwardXrayTR( const G4String& processName="XrayTR" );
explicit G4ForwardXrayTR( const G4String& processName="XrayTR" );
// Destructor // virtual
@@ -84,10 +84,10 @@ public:
void BuildXrayTRtables();
G4double GetMeanFreePath(const G4Track&, G4double,
G4ForceCondition* condition);
G4ForceCondition* condition) override;
G4VParticleChange* PostStepDoIt( const G4Track& aTrack,
const G4Step& aStep );
G4VParticleChange* PostStepDoIt( const G4Track& aTrack,
const G4Step& aStep ) override;
G4double GetEnergyTR(G4int iMat, G4int jMat, G4int iTkin) const;
@@ -98,7 +98,7 @@ public:
//
G4double SpectralAngleTRdensity( G4double energy,
G4double varAngle ) const;
G4double varAngle ) const override;
G4double AngleDensity( G4double energy,
G4double varAngle ) const;
@@ -176,9 +176,9 @@ G4double fSigma2; // plasma energy Sq of matter2
private:
// Operators
G4ForwardXrayTR(const G4ForwardXrayTR& right) ;
G4ForwardXrayTR(const G4ForwardXrayTR& right) = delete;
G4ForwardXrayTR& operator=(const G4ForwardXrayTR& right);
G4ForwardXrayTR& operator=(const G4ForwardXrayTR& right) = delete;
// G4int operator==(const G4ForwardXrayTR& right)const;
// G4int operator!=(const G4ForwardXrayTR& right)const;
source/processes/electromagnetic/xrays/include/G4GammaXTRadiator.hh
+4 -3
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4GammaXTRadiator.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4GammaXTRadiator.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
//
///////////////////////////////////////////////////////////////////////////
@@ -58,7 +58,7 @@ class G4GammaXTRadiator : public G4VXTRenergyLoss
{
public:
G4GammaXTRadiator (G4LogicalVolume *anEnvelope,
explicit G4GammaXTRadiator (G4LogicalVolume *anEnvelope,
G4double,G4double,
G4Material*,G4Material*,
G4double,G4double,G4int,
@@ -67,7 +67,8 @@ public:
// Pure virtual function from base class
G4double GetStackFactor( G4double energy, G4double gamma, G4double varAngle);
G4double GetStackFactor( G4double energy, G4double gamma,
G4double varAngle) override;
private:
source/processes/electromagnetic/xrays/include/G4RegularXTRadiator.hh
+6 -4
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4RegularXTRadiator.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4RegularXTRadiator.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
//
///////////////////////////////////////////////////////////////////////////
@@ -51,16 +51,18 @@ class G4RegularXTRadiator : public G4VXTRenergyLoss
{
public:
G4RegularXTRadiator (G4LogicalVolume *anEnvelope,G4Material*,G4Material*,
explicit G4RegularXTRadiator (G4LogicalVolume *anEnvelope,
G4Material*,G4Material*,
G4double,G4double,G4int,
const G4String & processName = "XTRegularRadiator");
~G4RegularXTRadiator ();
G4double SpectralXTRdEdx(G4double energy);
G4double SpectralXTRdEdx(G4double energy) override;
// Pure virtual function from base class
G4double GetStackFactor( G4double energy, G4double gamma, G4double varAngle);
G4double GetStackFactor( G4double energy, G4double gamma,
G4double varAngle) override;
};
#endif
source/processes/electromagnetic/xrays/include/G4Scintillation.hh
+91 -20
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4Scintillation.hh 85355 2014-10-28 09:58:59Z gcosmo $
// $Id: G4Scintillation.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
//
////////////////////////////////////////////////////////////////////////
@@ -94,19 +94,19 @@ public:
// Constructors and Destructor
////////////////////////////////
G4Scintillation(const G4String& processName = "Scintillation",
explicit G4Scintillation(const G4String& processName = "Scintillation",
G4ProcessType type = fElectromagnetic);
~G4Scintillation();
private:
G4Scintillation(const G4Scintillation &right);
G4Scintillation(const G4Scintillation &right) = delete;
//////////////
// Operators
//////////////
G4Scintillation& operator=(const G4Scintillation &right);
G4Scintillation& operator=(const G4Scintillation &right) = delete;
public:
@@ -118,30 +118,32 @@ public:
// deposition of particles in flight) and AtRestDoIt (for energy
// given to the medium by particles at rest)
G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
G4bool IsApplicable(
const G4ParticleDefinition& aParticleType) override;
// Returns true -> 'is applicable', for any particle type except
// for an 'opticalphoton' and for short-lived particles
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);
void BuildPhysicsTable(
const G4ParticleDefinition& aParticleType) override;
// Build table at the right time
G4double GetMeanFreePath(const G4Track& aTrack,
G4double ,
G4ForceCondition* );
G4double GetMeanFreePath(const G4Track& aTrack,
G4double ,
G4ForceCondition* ) override;
// Returns infinity; i. e. the process does not limit the step,
// but sets the 'StronglyForced' condition for the DoIt to be
// invoked at every step.
G4double GetMeanLifeTime(const G4Track& aTrack,
G4ForceCondition* );
G4ForceCondition* ) override;
// Returns infinity; i. e. the process does not limit the time,
// but sets the 'StronglyForced' condition for the DoIt to be
// invoked at every step.
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep);
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
G4VParticleChange* AtRestDoIt (const G4Track& aTrack,
const G4Step& aStep);
const G4Step& aStep) override;
G4double GetScintillationYieldByParticleType(const G4Track &aTrack,
const G4Step &aStep);
@@ -156,13 +158,13 @@ public:
// produced scintillation photons are tracked next. When all
// have been tracked, the tracking of the primary resumes.
G4bool GetTrackSecondariesFirst() const;
// Returns the boolean flag for tracking secondaries first.
void SetFiniteRiseTime(const G4bool state);
// If set, the G4Scintillation process expects the user to have
// set the constant material property FAST/SLOWSCINTILLATIONRISETIME.
G4bool GetTrackSecondariesFirst() const;
// Returns the boolean flag for tracking secondaries first.
G4bool GetFiniteRiseTime() const;
// Returns the boolean flag for a finite scintillation rise time.
@@ -189,24 +191,31 @@ public:
G4PhysicsTable* GetSlowIntegralTable() const;
// Returns the address of the slow scintillation integral table.
void AddSaturation(G4EmSaturation* );
void AddSaturation(G4EmSaturation* sat);
// Adds Birks Saturation to the process.
void RemoveSaturation();
// Removes the Birks Saturation from the process.
G4EmSaturation* GetSaturation() const { return fEmSaturation; }
G4EmSaturation* GetSaturation() const;
// Returns the Birks Saturation.
void SetScintillationByParticleType(const G4bool );
// Called by the user to set the scintillation yield as a function
// of energy deposited by particle type
G4bool GetScintillationByParticleType() const
{ return fScintillationByParticleType; }
G4bool GetScintillationByParticleType() const;
// Return the boolean that determines the method of scintillation
// production
void SetScintillationTrackInfo(const G4bool trackType);
// Call by the user to set the G4ScintillationTrackInformation
// to scintillation photon track
G4bool GetScintillationTrackInfo() const;
// Return the boolean for whether or not the
// G4ScintillationTrackInformation is set to the scint. photon track
void DumpPhysicsTable() const;
// Prints the fast and slow scintillation integral tables.
@@ -234,6 +243,8 @@ private:
G4bool fScintillationByParticleType;
G4bool fScintillationTrackInfo;
#ifdef G4DEBUG_SCINTILLATION
G4double ScintTrackEDep, ScintTrackYield;
#endif
@@ -261,24 +272,48 @@ G4bool G4Scintillation::IsApplicable(const G4ParticleDefinition& aParticleType)
return true;
}
inline
void G4Scintillation::SetTrackSecondariesFirst(const G4bool state)
{
fTrackSecondariesFirst = state;
}
inline
G4bool G4Scintillation::GetTrackSecondariesFirst() const
{
return fTrackSecondariesFirst;
}
inline
void G4Scintillation::SetFiniteRiseTime(const G4bool state)
{
fFiniteRiseTime = state;
}
inline
G4bool G4Scintillation::GetFiniteRiseTime() const
{
return fFiniteRiseTime;
}
inline
void G4Scintillation::SetScintillationYieldFactor(const G4double yieldfactor)
{
fYieldFactor = yieldfactor;
}
inline
G4double G4Scintillation::GetScintillationYieldFactor() const
{
return fYieldFactor;
}
inline
void G4Scintillation::SetScintillationExcitationRatio(const G4double ratio)
{
fExcitationRatio = ratio;
}
inline
G4double G4Scintillation::GetScintillationExcitationRatio() const
{
@@ -297,6 +332,42 @@ G4PhysicsTable* G4Scintillation::GetFastIntegralTable() const
return fFastIntegralTable;
}
inline
void G4Scintillation::AddSaturation(G4EmSaturation* sat)
{
fEmSaturation = sat;
}
inline
void G4Scintillation::RemoveSaturation()
{
fEmSaturation = nullptr;
}
inline
G4EmSaturation* G4Scintillation::GetSaturation() const
{
return fEmSaturation;
}
inline
G4bool G4Scintillation::GetScintillationByParticleType() const
{
return fScintillationByParticleType;
}
inline
void G4Scintillation::SetScintillationTrackInfo(const G4bool trackType)
{
fScintillationTrackInfo = trackType;
}
inline
G4bool G4Scintillation::GetScintillationTrackInfo() const
{
return fScintillationTrackInfo;
}
inline
void G4Scintillation::DumpPhysicsTable() const
{
source/processes/electromagnetic/xrays/include/G4ScintillationTrackInformation.hh
+107
View File
@@ -0,0 +1,107 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// $Id: G4ScintillationTrackInformation.hh ????? 2016-01-21 ??:??:??? ?????? $
//
// Author : Valentin Libioulle valentin.libioulle@usherbrooke.ca (3IT - GRAMS)
//
//---------------------------------------------------------------
//
// G4ScintillationTrackInformation
//
// Class Description:
//
// Concrete class of G4VUserTrackInformation used to store information
// linked to the track generated in a scintillation process.
//
#ifndef G4SCINTILLATIONTRACKINFORMATION_H
#define G4SCINTILLATIONTRACKINFORMATION_H
#include "G4VUserTrackInformation.hh"
// Represents the scintillation type used to create the track (opticalphoton).
enum G4ScintillationType {Fast, Slow};
class G4ScintillationTrackInformation : public G4VUserTrackInformation
{
public:
explicit G4ScintillationTrackInformation(const G4ScintillationType& aType = Slow);
virtual ~G4ScintillationTrackInformation();
// Required by G4VUserTrackInformation
void *operator new(size_t);
void operator delete(void *aScintillationTI);
// Copy Constructor/instruction
G4ScintillationTrackInformation(const G4ScintillationTrackInformation&);
G4ScintillationTrackInformation& operator=(const G4ScintillationTrackInformation&);
virtual void Print() const override;
const G4ScintillationType& GetScintillationType() const {return scintillationType;}
// Static class allowing to check if a G4VUserTrackInformation is a
// G4ScintillationTrackInformation and cast it without changing the
// pointer of the pointed data.
static G4bool IsScintillationTrackInformation(const G4VUserTrackInformation* const);
static G4ScintillationTrackInformation* Cast(const G4VUserTrackInformation* const);
private:
G4ScintillationType scintillationType;
// String given to G4VUserTrackInformation to identify this concrete class
static const G4String BaseType;
};
///
// Inline methods
///
#include "G4Allocator.hh"
// Forward declaration for the Allocator
class G4ScintillationTrackInformation;
#if defined G4EM_ALLOC_EXPORT
extern G4DLLEXPORT G4ThreadLocal G4Allocator<G4ScintillationTrackInformation> *aScintillationTIAllocator;
#else
extern G4DLLIMPORT G4ThreadLocal G4Allocator<G4ScintillationTrackInformation> *aScintillationTIAllocator;
#endif
inline void* G4ScintillationTrackInformation::operator new(size_t)
{
if (!aScintillationTIAllocator) aScintillationTIAllocator = new G4Allocator<G4ScintillationTrackInformation>;
return (void *) aScintillationTIAllocator->MallocSingle();
}
inline void G4ScintillationTrackInformation::operator delete(void *aScintillationTI)
{
aScintillationTIAllocator->FreeSingle((G4ScintillationTrackInformation *) aScintillationTI);
}
#endif // G4SCINTILLATIONTRACKINFORMATION_H
source/processes/electromagnetic/xrays/include/G4StrawTubeXTRadiator.hh
+6 -5
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4StrawTubeXTRadiator.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4StrawTubeXTRadiator.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
//
///////////////////////////////////////////////////////////////////////////
@@ -54,9 +54,9 @@ class G4StrawTubeXTRadiator : public G4VXTRenergyLoss
{
public:
G4StrawTubeXTRadiator (G4LogicalVolume* anEnvelope, G4Material*, G4Material*,
G4double,G4double,G4Material*,G4bool unishut = false,
const G4String & processName = "StrawTubeXTRadiator");
explicit G4StrawTubeXTRadiator (G4LogicalVolume* anEnvelope, G4Material*,
G4Material*, G4double,G4double,G4Material*,G4bool unishut = false,
const G4String & processName = "StrawTubeXTRadiator");
virtual ~G4StrawTubeXTRadiator ();
// Auxiliary functions for plate/gas material parameters
@@ -67,7 +67,8 @@ public:
G4complex GetMediumComplexFZ(G4double,G4double,G4double) ;
// Pure virtual function from base class
G4double GetStackFactor( G4double energy, G4double gamma, G4double varAngle);
G4double GetStackFactor(G4double energy, G4double gamma,
G4double varAngle) override;
protected:
source/processes/electromagnetic/xrays/include/G4SynchrotronRadiation.hh
+10 -9
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4SynchrotronRadiation.hh 83424 2014-08-21 15:39:44Z gcosmo $
// $Id: G4SynchrotronRadiation.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
// ------------------------------------------------------------
// GEANT 4 class header file
@@ -65,17 +65,17 @@ class G4SynchrotronRadiation : public G4VDiscreteProcess
{
public:
G4SynchrotronRadiation(const G4String& pName = "SynRad",
explicit G4SynchrotronRadiation(const G4String& pName = "SynRad",
G4ProcessType type = fElectromagnetic);
virtual ~G4SynchrotronRadiation();
virtual G4double GetMeanFreePath( const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition );
G4ForceCondition* condition ) override;
virtual G4VParticleChange *PostStepDoIt( const G4Track& track,
const G4Step& Step );
const G4Step& Step ) override;
G4double GetPhotonEnergy( const G4Track& trackData,
const G4Step& stepData );
@@ -86,16 +86,17 @@ public:
G4double Chebyshev(G4double a,G4double b,const G4double c[],
G4int n, G4double x);
virtual G4bool IsApplicable(const G4ParticleDefinition&);
virtual void BuildPhysicsTable(const G4ParticleDefinition& );
virtual G4bool IsApplicable(const G4ParticleDefinition&) override;
virtual void BuildPhysicsTable(const G4ParticleDefinition& ) override;
virtual void PrintInfoDefinition();
void SetAngularGenerator(G4VEmAngularDistribution* p);
private:
G4SynchrotronRadiation & operator=(const G4SynchrotronRadiation &right);
G4SynchrotronRadiation(const G4SynchrotronRadiation&);
G4SynchrotronRadiation &
operator=(const G4SynchrotronRadiation &right) = delete;
G4SynchrotronRadiation(const G4SynchrotronRadiation&) = delete;
G4VEmAngularDistribution* genAngle;
@@ -114,7 +115,7 @@ G4SynchrotronRadiation::Chebyshev(G4double a, G4double b, const G4double c[],
{
G4double y;
G4double y2=2.0*(y=(2.0*x-a-b)/(b-a)); // Change of variable.
G4double d=0,dd=0;
G4double d=0.,dd=0.;
for (G4int j=n-1;j>=1;--j) // Clenshaw's recurrence.
{ G4double sv=d;
d=y2*d-dd+c[j];
source/processes/electromagnetic/xrays/include/G4SynchrotronRadiationInMat.hh
+15 -14
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4SynchrotronRadiationInMat.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4SynchrotronRadiationInMat.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
// ------------------------------------------------------------
// GEANT 4 class header file
@@ -69,7 +69,7 @@ class G4SynchrotronRadiationInMat : public G4VDiscreteProcess
{
public:
G4SynchrotronRadiationInMat(const G4String& processName =
explicit G4SynchrotronRadiationInMat(const G4String& processName =
"SynchrotronRadiation",
G4ProcessType type = fElectromagnetic);
@@ -77,17 +77,18 @@ public:
private:
G4SynchrotronRadiationInMat & operator=(const G4SynchrotronRadiationInMat &right);
G4SynchrotronRadiationInMat(const G4SynchrotronRadiationInMat&);
G4SynchrotronRadiationInMat &
operator=(const G4SynchrotronRadiationInMat &right) = delete;
G4SynchrotronRadiationInMat(const G4SynchrotronRadiationInMat&) = delete;
public: ///////////////// Post Step functions //////////////////////////
G4double GetMeanFreePath( const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition );
G4ForceCondition* condition ) override;
G4VParticleChange *PostStepDoIt( const G4Track& track,
const G4Step& Step );
const G4Step& Step ) override;
G4double GetPhotonEnergy( const G4Track& trackData,
const G4Step& stepData );
@@ -104,7 +105,7 @@ public: ///////////////// Post Step functions //////////////////////////
G4double GetAngleK( G4double );
G4double GetAngleNumberAtGammaKsi( G4double );
G4bool IsApplicable(const G4ParticleDefinition&);
G4bool IsApplicable(const G4ParticleDefinition&) override;
static G4double GetLambdaConst(){ return fLambdaConst; };
static G4double GetEnergyConst(){ return fEnergyConst; };
@@ -127,10 +128,10 @@ private:
const G4double
LowestKineticEnergy; // low energy limit of the cross-section formula
const G4double
HighestKineticEnergy; // high energy limit of the cross-section formula
//const G4double
//HighestKineticEnergy; // high energy limit of the cross-section formula
G4int TotBin; // number of bins in the tables
//G4int TotBin; // number of bins in the tables
G4double CutInRange;
@@ -138,10 +139,10 @@ private:
const G4ParticleDefinition* theElectron;
const G4ParticleDefinition* thePositron;
const G4double* GammaCutInKineticEnergy;
const G4double* ElectronCutInKineticEnergy;
const G4double* PositronCutInKineticEnergy;
const G4double* ParticleCutInKineticEnergy;
//const G4double* GammaCutInKineticEnergy;
//const G4double* ElectronCutInKineticEnergy;
//const G4double* PositronCutInKineticEnergy;
//const G4double* ParticleCutInKineticEnergy;
G4double GammaCutInKineticEnergyNow;
source/processes/electromagnetic/xrays/include/G4TransitionRadiation.hh
+10 -8
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4TransitionRadiation.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4TransitionRadiation.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
// G4TransitionRadiation -- header file
//
@@ -58,19 +58,20 @@ class G4TransitionRadiation : public G4VDiscreteProcess
{
public:
G4TransitionRadiation( const G4String& processName = "TR",
explicit G4TransitionRadiation( const G4String& processName = "TR",
G4ProcessType type = fElectromagnetic) ;
virtual ~G4TransitionRadiation() ;
// Methods
G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
G4bool IsApplicable(const G4ParticleDefinition& aParticleType) override;
G4double GetMeanFreePath(const G4Track&, G4double,
G4ForceCondition* condition);
virtual G4double GetMeanFreePath(const G4Track&, G4double,
G4ForceCondition* condition) override;
G4VParticleChange* PostStepDoIt(const G4Track&, const G4Step&);
virtual G4VParticleChange* PostStepDoIt(const G4Track&,
const G4Step&) override;
virtual
G4double SpectralAngleTRdensity( G4double energy,
@@ -120,8 +121,9 @@ protected :
private:
// Operators
G4TransitionRadiation(const G4TransitionRadiation& right) ;
G4TransitionRadiation& operator=(const G4TransitionRadiation& right) ;
G4TransitionRadiation(const G4TransitionRadiation& right) = delete;
G4TransitionRadiation&
operator=(const G4TransitionRadiation& right) = delete;
};
source/processes/electromagnetic/xrays/include/G4TransparentRegXTRadiator.hh
+5 -5
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4TransparentRegXTRadiator.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4TransparentRegXTRadiator.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
//
///////////////////////////////////////////////////////////////////////////
@@ -52,18 +52,18 @@ class G4TransparentRegXTRadiator : public G4VXTRenergyLoss
{
public:
G4TransparentRegXTRadiator (G4LogicalVolume *anEnvelope,G4Material*,G4Material*,
G4double,G4double,G4int,
explicit G4TransparentRegXTRadiator (G4LogicalVolume *anEnvelope,
G4Material*,G4Material*, G4double,G4double,G4int,
const G4String & processName = "TransparentRegXTRadiator");
~G4TransparentRegXTRadiator ();
// reimplementation of base class function in analytical way
G4double SpectralXTRdEdx(G4double energy);
G4double SpectralXTRdEdx(G4double energy) override;
// Pure virtual function from base class
G4double GetStackFactor( G4double energy, G4double gamma, G4double varAngle);
G4double GetStackFactor( G4double energy, G4double gamma, G4double varAngle) override;
};
#endif
source/processes/electromagnetic/xrays/include/G4VTRModel.hh
+4 -4
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4VTRModel.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4VTRModel.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
// G4VTRModel -- header file
//
@@ -53,7 +53,7 @@ public:
// Constructors
G4VTRModel( const G4String& modelName) {fName = modelName;};
explicit G4VTRModel( const G4String& modelName) {fName = modelName;};
// Destructor
@@ -74,8 +74,8 @@ public:
// hide assignment operator
G4VTRModel & operator=(const G4VTRModel &right);
G4VTRModel(const G4VTRModel&);
G4VTRModel & operator=(const G4VTRModel &right) = delete;
G4VTRModel(const G4VTRModel&) = delete;
protected:
source/processes/electromagnetic/xrays/include/G4VTransitionRadiation.hh
+9 -7
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4VTransitionRadiation.hh 68037 2013-03-13 14:15:08Z gcosmo $
// $Id: G4VTransitionRadiation.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
// G4VTransitionRadiation -- header file
//
@@ -54,20 +54,21 @@ class G4VTransitionRadiation : public G4VDiscreteProcess
public:
// Constructors
G4VTransitionRadiation( const G4String& processName = "TR",
explicit G4VTransitionRadiation( const G4String& processName = "TR",
G4ProcessType type = fElectromagnetic);
// Destructor
virtual ~G4VTransitionRadiation() ;
virtual G4bool IsApplicable(const G4ParticleDefinition& aParticleType);
virtual G4bool
IsApplicable(const G4ParticleDefinition& aParticleType) override;
virtual G4double GetMeanFreePath(const G4Track& track, G4double,
G4ForceCondition* condition);
G4ForceCondition* condition) override;
virtual G4VParticleChange* PostStepDoIt(const G4Track& track,
const G4Step& step);
const G4Step& step) override;
virtual void PrintInfoDefinition();
// Print out of the class parameters
@@ -81,8 +82,9 @@ public:
void Clear();
// hide assignment operator
G4VTransitionRadiation & operator=(const G4VTransitionRadiation &right);
G4VTransitionRadiation(const G4VTransitionRadiation&);
G4VTransitionRadiation &
operator=(const G4VTransitionRadiation &right) = delete;
G4VTransitionRadiation(const G4VTransitionRadiation&) = delete;
std::vector<const G4Material*> materials;
std::vector<G4double> steps;
source/processes/electromagnetic/xrays/include/G4VXTRenergyLoss.hh
+11 -11
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4VXTRenergyLoss.hh 83661 2014-09-08 09:58:34Z gcosmo $
// $Id: G4VXTRenergyLoss.hh 97385 2016-06-02 09:59:53Z gcosmo $
//
//
///////////////////////////////////////////////////////////////////////////
@@ -75,8 +75,8 @@ class G4VXTRenergyLoss : public G4VDiscreteProcess // G4VContinuousProcess
{
public:
G4VXTRenergyLoss (G4LogicalVolume *anEnvelope,G4Material*,G4Material*,
G4double,G4double,G4int,
explicit G4VXTRenergyLoss (G4LogicalVolume *anEnvelope,G4Material*,
G4Material*, G4double,G4double,G4int,
const G4String & processName = "XTRenergyLoss",
G4ProcessType type = fElectromagnetic);
virtual ~G4VXTRenergyLoss ();
@@ -86,16 +86,16 @@ public:
virtual G4double GetStackFactor( G4double energy, G4double gamma,
G4double varAngle );
G4bool IsApplicable(const G4ParticleDefinition&);
virtual G4bool IsApplicable(const G4ParticleDefinition&) override;
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep);
virtual G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
G4double GetMeanFreePath(const G4Track& aTrack,
virtual G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
G4ForceCondition* condition) override;
void BuildPhysicsTable(const G4ParticleDefinition&);
virtual void BuildPhysicsTable(const G4ParticleDefinition&) override;
void BuildEnergyTable() ;
void BuildAngleForEnergyBank() ;
@@ -237,8 +237,8 @@ protected:
private:
// copy constructor and hide assignment operator
G4VXTRenergyLoss(G4VXTRenergyLoss &);
G4VXTRenergyLoss & operator=(const G4VXTRenergyLoss &right);
G4VXTRenergyLoss(G4VXTRenergyLoss &) = delete;
G4VXTRenergyLoss & operator=(const G4VXTRenergyLoss &right) = delete;
};
source/processes/electromagnetic/xrays/include/G4XTRGammaRadModel.hh
+3 -2
View File
@@ -57,7 +57,7 @@ class G4XTRGammaRadModel : public G4VXTRenergyLoss
{
public:
G4XTRGammaRadModel (G4LogicalVolume *anEnvelope,
explicit G4XTRGammaRadModel (G4LogicalVolume *anEnvelope,
G4double,G4double,
G4Material*,G4Material*,
G4double,G4double,G4int,
@@ -66,7 +66,8 @@ public:
// Pure virtual function from base class
G4double GetStackFactor( G4double energy, G4double gamma, G4double varAngle);
G4double GetStackFactor(G4double energy, G4double gamma,
G4double varAngle) override;
private:
source/processes/electromagnetic/xrays/include/G4XTRRegularRadModel.hh
+5 -4
View File
@@ -50,16 +50,17 @@ class G4XTRRegularRadModel : public G4VXTRenergyLoss
{
public:
G4XTRRegularRadModel (G4LogicalVolume *anEnvelope,G4Material*,G4Material*,
G4double,G4double,G4int,
explicit G4XTRRegularRadModel (G4LogicalVolume *anEnvelope,G4Material*,
G4Material*, G4double,G4double,G4int,
const G4String & processName = "XTRegularModel");
virtual ~G4XTRRegularRadModel ();
G4double SpectralXTRdEdx(G4double energy);
G4double SpectralXTRdEdx(G4double energy) override;
// Pure virtual function from base class
G4double GetStackFactor( G4double energy, G4double gamma, G4double varAngle);
G4double GetStackFactor(G4double energy, G4double gamma,
G4double varAngle) override;
};
#endif
source/processes/electromagnetic/xrays/include/G4XTRTransparentRegRadModel.hh
+5 -4
View File
@@ -49,18 +49,19 @@ class G4XTRTransparentRegRadModel : public G4VXTRenergyLoss
{
public:
G4XTRTransparentRegRadModel (G4LogicalVolume *anEnvelope,G4Material*,G4Material*,
G4double,G4double,G4int,
explicit G4XTRTransparentRegRadModel (G4LogicalVolume *anEnvelope,G4Material*,
G4Material*, G4double,G4double,G4int,
const G4String & processName = "XTRTransparentRegRadModel");
~G4XTRTransparentRegRadModel ();
// reimplementation of base class function in analytical way
G4double SpectralXTRdEdx(G4double energy);
G4double SpectralXTRdEdx(G4double energy) override;
// Pure virtual function from base class
G4double GetStackFactor( G4double energy, G4double gamma, G4double varAngle);
G4double GetStackFactor(G4double energy, G4double gamma,
G4double varAngle) override;
};
#endif