#include <G4Scintillation.hh>

Inheritance diagram for G4Scintillation:

Collaboration diagram for G4Scintillation:

Public Member Functions
	G4Scintillation (const G4String &processName="Scintillation", G4ProcessType type=fElectromagnetic)

	~G4Scintillation ()

G4bool	IsApplicable (const G4ParticleDefinition &aParticleType)

void	BuildPhysicsTable (const G4ParticleDefinition &aParticleType)

G4double	GetMeanFreePath (const G4Track &aTrack, G4double, G4ForceCondition *)

G4double	GetMeanLifeTime (const G4Track &aTrack, G4ForceCondition *)

G4VParticleChange *	PostStepDoIt (const G4Track &aTrack, const G4Step &aStep)

G4VParticleChange *	AtRestDoIt (const G4Track &aTrack, const G4Step &aStep)

G4double	GetScintillationYieldByParticleType (const G4Track &aTrack, const G4Step &aStep)

void	SetTrackSecondariesFirst (const G4bool state)

void	SetFiniteRiseTime (const G4bool state)

G4bool	GetTrackSecondariesFirst () const

G4bool	GetFiniteRiseTime () const

void	SetScintillationYieldFactor (const G4double yieldfactor)

G4double	GetScintillationYieldFactor () const

void	SetScintillationExcitationRatio (const G4double ratio)

G4double	GetScintillationExcitationRatio () const

G4PhysicsTable *	GetFastIntegralTable () const

G4PhysicsTable *	GetSlowIntegralTable () const

void	AddSaturation (G4EmSaturation *)

void	RemoveSaturation ()

G4EmSaturation *	GetSaturation () const

void	SetScintillationByParticleType (const G4bool)

G4bool	GetScintillationByParticleType () const

void	DumpPhysicsTable () const

Public Member Functions inherited from G4VRestDiscreteProcess
	G4VRestDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)

	G4VRestDiscreteProcess (G4VRestDiscreteProcess &)

virtual	~G4VRestDiscreteProcess ()

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Member Functions
void	BuildThePhysicsTable ()

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4PhysicsTable *	fFastIntegralTable

G4PhysicsTable *	fSlowIntegralTable

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

Private Member Functions
	G4Scintillation (const G4Scintillation &right)

G4Scintillation &	operator= (const G4Scintillation &right)

G4double	single_exp (G4double t, G4double tau2)

G4double	bi_exp (G4double t, G4double tau1, G4double tau2)

G4double	sample_time (G4double tau1, G4double tau2)

Private Attributes
G4bool	fTrackSecondariesFirst

G4bool	fFiniteRiseTime

G4double	fYieldFactor

G4double	fExcitationRatio

G4bool	fScintillationByParticleType

G4EmSaturation *	fEmSaturation

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Detailed Description

Definition at line 88 of file G4Scintillation.hh.

Constructor & Destructor Documentation

◆ G4Scintillation() [1/2]

G4Scintillation::G4Scintillation	(	const G4String &	processName = `"Scintillation"`,
		G4ProcessType	type = `fElectromagnetic`
	)

Definition at line 108 of file G4Scintillation.cc.

                   : G4VRestDiscreteProcess(processName, type) ,
     fTrackSecondariesFirst(false),
     fFiniteRiseTime(false),
     fYieldFactor(1.0),
     fExcitationRatio(1.0),
     fScintillationByParticleType(false),
     fEmSaturation(nullptr)
 {
         SetProcessSubType(fScintillation);
 
 #ifdef G4DEBUG_SCINTILLATION
     ScintTrackEDep = 0.;
     ScintTrackYield = 0.;
 #endif
 
         fFastIntegralTable = nullptr;
         fSlowIntegralTable = nullptr;
 
         if (verboseLevel>0) {
            G4cout << GetProcessName() << " is created " << G4endl;
         }
 }

Here is the call graph for this function:

◆ ~G4Scintillation()

G4Scintillation::~G4Scintillation ( )

Definition at line 137 of file G4Scintillation.cc.

 {
     if (fFastIntegralTable != nullptr) {
            fFastIntegralTable->clearAndDestroy();
            delete fFastIntegralTable;
         }
         if (fSlowIntegralTable != nullptr) {
            fSlowIntegralTable->clearAndDestroy();
            delete fSlowIntegralTable;
         }
 }

Here is the call graph for this function:

◆ G4Scintillation() [2/2]

G4Scintillation::G4Scintillation ( const G4Scintillation & right )

private

Member Function Documentation

◆ AddSaturation()

void G4Scintillation::AddSaturation ( G4EmSaturation * sat )

Definition at line 674 of file G4Scintillation.cc.

 {
         fEmSaturation = sat;
 }

Here is the caller graph for this function:

◆ AtRestDoIt()

G4VParticleChange * G4Scintillation::AtRestDoIt	(	const G4Track &	aTrack,
		const G4Step &	aStep
	)

virtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 173 of file G4Scintillation.cc.

 {
         return G4Scintillation::PostStepDoIt(aTrack, aStep);
 }

Here is the call graph for this function:

◆ bi_exp()

G4double G4Scintillation::bi_exp	(	G4double	t,
		G4double	tau1,
		G4double	tau2
	)

inlineprivate

Definition at line 333 of file G4Scintillation.hh.

 {
          return std::exp(-1.0*t/tau2)*(1-std::exp(-1.0*t/tau1))/tau2/tau2*(tau1+tau2);
 }

Here is the caller graph for this function:

◆ BuildPhysicsTable()

void G4Scintillation::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 153 of file G4Scintillation.cc.

 {
     if (fFastIntegralTable != nullptr) {
        fFastIntegralTable->clearAndDestroy();
        delete fFastIntegralTable;
        fFastIntegralTable = nullptr;
     }
     if (fSlowIntegralTable != nullptr) {
        fSlowIntegralTable->clearAndDestroy();
        delete fSlowIntegralTable;
        fSlowIntegralTable = nullptr;
     }
     BuildThePhysicsTable();
 }

Here is the call graph for this function:

◆ BuildThePhysicsTable()

void G4Scintillation::BuildThePhysicsTable ( )

protected

Definition at line 489 of file G4Scintillation.cc.

 {
         if (fFastIntegralTable && fSlowIntegralTable) return;
 
         const G4MaterialTable* theMaterialTable =
                                G4Material::GetMaterialTable();
         G4int numOfMaterials = G4Material::GetNumberOfMaterials();
 
         // create new physics table
     
         if(!fFastIntegralTable)fFastIntegralTable =
                                             new G4PhysicsTable(numOfMaterials);
         if(!fSlowIntegralTable)fSlowIntegralTable =
                                             new G4PhysicsTable(numOfMaterials);
 
         // loop for materials
 
         for (G4int i=0 ; i < numOfMaterials; i++)
         {
                 G4PhysicsOrderedFreeVector* aPhysicsOrderedFreeVector =
                     new G4PhysicsOrderedFreeVector();
                 G4PhysicsOrderedFreeVector* bPhysicsOrderedFreeVector =
                                         new G4PhysicsOrderedFreeVector();
 
                 // Retrieve vector of scintillation wavelength intensity for
                 // the material from the material's optical properties table.
 
                 G4Material* aMaterial = (*theMaterialTable)[i];
 
                 G4MaterialPropertiesTable* aMaterialPropertiesTable =
                                 aMaterial->GetMaterialPropertiesTable();
 
                 if (aMaterialPropertiesTable) {
 
                    G4MaterialPropertyVector* theFastLightVector =
                    aMaterialPropertiesTable->GetProperty("FASTCOMPONENT");
 
                    if (theFastLightVector) {
 
                       // Retrieve the first intensity point in vector
                       // of (photon energy, intensity) pairs
 
                       G4double currentIN = (*theFastLightVector)[0];
 
                       if (currentIN >= 0.0) {
 
                          // Create first (photon energy, Scintillation
                          // Integral pair
 
                          G4double currentPM = theFastLightVector->Energy(0);
 
                          G4double currentCII = 0.0;
 
                          aPhysicsOrderedFreeVector->
                                  InsertValues(currentPM , currentCII);
 
                          // Set previous values to current ones prior to loop
 
                          G4double prevPM  = currentPM;
                          G4double prevCII = currentCII;
                          G4double prevIN  = currentIN;
 
                          // loop over all (photon energy, intensity)
                          // pairs stored for this material
 
                          for (size_t ii = 1;
                               ii < theFastLightVector->GetVectorLength();
                               ++ii)
                          {
                                 currentPM = theFastLightVector->Energy(ii);
                                 currentIN = (*theFastLightVector)[ii];
 
                                 currentCII = 0.5 * (prevIN + currentIN);
 
                                 currentCII = prevCII +
                                              (currentPM - prevPM) * currentCII;
 
                                 aPhysicsOrderedFreeVector->
                                     InsertValues(currentPM, currentCII);
 
                                 prevPM  = currentPM;
                                 prevCII = currentCII;
                                 prevIN  = currentIN;
                          }
 
                       }
                    }
 
                    G4MaterialPropertyVector* theSlowLightVector =
                    aMaterialPropertiesTable->GetProperty("SLOWCOMPONENT");
 
                    if (theSlowLightVector) {
 
                       // Retrieve the first intensity point in vector
                       // of (photon energy, intensity) pairs
 
                       G4double currentIN = (*theSlowLightVector)[0];
 
                       if (currentIN >= 0.0) {
 
                          // Create first (photon energy, Scintillation
                          // Integral pair
 
                          G4double currentPM = theSlowLightVector->Energy(0);
 
                          G4double currentCII = 0.0;
 
                          bPhysicsOrderedFreeVector->
                                  InsertValues(currentPM , currentCII);
 
                          // Set previous values to current ones prior to loop
 
                          G4double prevPM  = currentPM;
                          G4double prevCII = currentCII;
                          G4double prevIN  = currentIN;
 
                          // loop over all (photon energy, intensity)
                          // pairs stored for this material
 
                          for (size_t ii = 1;
                               ii < theSlowLightVector->GetVectorLength();
                               ++ii)
                          {
                                 currentPM = theSlowLightVector->Energy(ii);
                                 currentIN = (*theSlowLightVector)[ii];
 
                                 currentCII = 0.5 * (prevIN + currentIN);
 
                                 currentCII = prevCII +
                                              (currentPM - prevPM) * currentCII;
 
                                 bPhysicsOrderedFreeVector->
                                     InsertValues(currentPM, currentCII);
 
                                 prevPM  = currentPM;
                                 prevCII = currentCII;
                                 prevIN  = currentIN;
                          }
 
                       }
                    }
                 }
 
         // The scintillation integral(s) for a given material
         // will be inserted in the table(s) according to the
         // position of the material in the material table.
 
         fFastIntegralTable->insertAt(i,aPhysicsOrderedFreeVector);
         fSlowIntegralTable->insertAt(i,bPhysicsOrderedFreeVector);
 
         }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DumpPhysicsTable()

void G4Scintillation::DumpPhysicsTable ( ) const

inline

Definition at line 301 of file G4Scintillation.hh.

 {
         if (fFastIntegralTable) {
            G4int PhysicsTableSize = fFastIntegralTable->entries();
            G4PhysicsOrderedFreeVector *v;
 
            for (G4int i = 0 ; i < PhysicsTableSize ; i++ )
            {
             v = (G4PhysicsOrderedFreeVector*)(*fFastIntegralTable)[i];
             v->DumpValues();
            }
          }
 
         if (fSlowIntegralTable) {
            G4int PhysicsTableSize = fSlowIntegralTable->entries();
            G4PhysicsOrderedFreeVector *v;
 
            for (G4int i = 0 ; i < PhysicsTableSize ; i++ )
            {
                 v = (G4PhysicsOrderedFreeVector*)(*fSlowIntegralTable)[i];
                 v->DumpValues();
            }
          }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetFastIntegralTable()

G4PhysicsTable * G4Scintillation::GetFastIntegralTable ( ) const

inline

Definition at line 295 of file G4Scintillation.hh.

 {
         return fFastIntegralTable;
 }

◆ GetFiniteRiseTime()

G4bool G4Scintillation::GetFiniteRiseTime ( ) const

inline

Definition at line 271 of file G4Scintillation.hh.

 {
         return fFiniteRiseTime;
 }

◆ GetMeanFreePath()

G4double G4Scintillation::GetMeanFreePath	(	const G4Track &	aTrack,
		G4double	,
		G4ForceCondition *	condition
	)

virtual

Implements G4VRestDiscreteProcess.

Definition at line 688 of file G4Scintillation.cc.

 {
         *condition = StronglyForced;
 
         return DBL_MAX;
 
 }

◆ GetMeanLifeTime()

G4double G4Scintillation::GetMeanLifeTime	(	const G4Track &	aTrack,
		G4ForceCondition *	condition
	)

virtual

Implements G4VRestDiscreteProcess.

Definition at line 702 of file G4Scintillation.cc.

 {
         *condition = Forced;
 
         return DBL_MAX;
 
 }

◆ GetSaturation()

G4EmSaturation* G4Scintillation::GetSaturation ( ) const

inline

Definition at line 198 of file G4Scintillation.hh.

198 { return fEmSaturation; }

G4Scintillation::fEmSaturation

G4EmSaturation * fEmSaturation

Definition: G4Scintillation.hh:247

Here is the call graph for this function:

◆ GetScintillationByParticleType()

G4bool G4Scintillation::GetScintillationByParticleType ( ) const

inline

Definition at line 205 of file G4Scintillation.hh.

206 { return fScintillationByParticleType; }

G4Scintillation::fScintillationByParticleType

G4bool fScintillationByParticleType

Definition: G4Scintillation.hh:235

Here is the call graph for this function:

◆ GetScintillationExcitationRatio()

G4double G4Scintillation::GetScintillationExcitationRatio ( ) const

inline

Definition at line 283 of file G4Scintillation.hh.

 {
         return fExcitationRatio;
 }

◆ GetScintillationYieldByParticleType()

G4double G4Scintillation::GetScintillationYieldByParticleType	(	const G4Track &	aTrack,
		const G4Step &	aStep
	)

Definition at line 734 of file G4Scintillation.cc.

 {
   // Get the scintillation yield vector //
 
   G4ParticleDefinition *pDef = aTrack.GetDynamicParticle()->GetDefinition();
 
   G4MaterialPropertyVector *Scint_Yield_Vector = nullptr;
 
   G4MaterialPropertiesTable *aMaterialPropertiesTable
     = aTrack.GetMaterial()->GetMaterialPropertiesTable();
 
   // Get the G4MaterialPropertyVector containing the scintillation
   // yield as a function of the energy deposited and particle type
 
   // Protons
   if(pDef==G4Proton::ProtonDefinition())
     Scint_Yield_Vector = aMaterialPropertiesTable->
       GetProperty("PROTONSCINTILLATIONYIELD");
 
   // Deuterons
   else if(pDef==G4Deuteron::DeuteronDefinition())
     Scint_Yield_Vector = aMaterialPropertiesTable->
       GetProperty("DEUTERONSCINTILLATIONYIELD");
 
   // Tritons
   else if(pDef==G4Triton::TritonDefinition())
     Scint_Yield_Vector = aMaterialPropertiesTable->
       GetProperty("TRITONSCINTILLATIONYIELD");
 
   // Alphas
   else if(pDef==G4Alpha::AlphaDefinition())
     Scint_Yield_Vector = aMaterialPropertiesTable->
       GetProperty("ALPHASCINTILLATIONYIELD");
 
   // Ions (particles derived from G4VIon and G4Ions) and recoil ions
   // below the production cut from neutrons after hElastic
   else if(pDef->GetParticleType()== "nucleus" ||
       pDef==G4Neutron::NeutronDefinition())
     Scint_Yield_Vector = aMaterialPropertiesTable->
       GetProperty("IONSCINTILLATIONYIELD");
 
   // Electrons (must also account for shell-binding energy
   // attributed to gamma from standard photoelectric effect)
   else if(pDef==G4Electron::ElectronDefinition() ||
       pDef==G4Gamma::GammaDefinition())
     Scint_Yield_Vector = aMaterialPropertiesTable->
       GetProperty("ELECTRONSCINTILLATIONYIELD");
 
   // Default for particles not enumerated/listed above
   else
     Scint_Yield_Vector = aMaterialPropertiesTable->
       GetProperty("ELECTRONSCINTILLATIONYIELD");
 
   // If the user has specified none of the above particles then the
   // default is the electron scintillation yield
   if(!Scint_Yield_Vector)
     Scint_Yield_Vector = aMaterialPropertiesTable->
       GetProperty("ELECTRONSCINTILLATIONYIELD");
 
   // Throw an exception if no scintillation yield vector is found
   if (!Scint_Yield_Vector) {
     G4ExceptionDescription ed;
     ed << "\nG4Scintillation::PostStepDoIt(): "
        << "Request for scintillation yield for energy deposit and particle\n"
        << "type without correct entry in MaterialPropertiesTable.\n"
        << "ScintillationByParticleType requires at minimum that \n"
        << "ELECTRONSCINTILLATIONYIELD is set by the user\n"
        << G4endl;
     G4String comments = "Missing MaterialPropertiesTable entry - No correct entry in MaterialPropertiesTable";
     G4Exception("G4Scintillation::PostStepDoIt","Scint01",
         FatalException,ed,comments);
   }
 
   // Calculate the scintillation light //
   // To account for potential nonlinearity and scintillation photon
   // density along the track, light (L) is produced according to:
   //
   // L_currentStep = L(PreStepKE) - L(PreStepKE - EDep)
 
   G4double ScintillationYield = 0.;
 
   G4double StepEnergyDeposit = aStep.GetTotalEnergyDeposit();
   G4double PreStepKineticEnergy = aStep.GetPreStepPoint()->GetKineticEnergy();
 
   if(PreStepKineticEnergy <= Scint_Yield_Vector->GetMaxEnergy()){
     G4double Yield1 = Scint_Yield_Vector->Value(PreStepKineticEnergy);
     G4double Yield2 = Scint_Yield_Vector->
                                Value(PreStepKineticEnergy - StepEnergyDeposit);
     ScintillationYield = Yield1 - Yield2;
   } else {
     G4ExceptionDescription ed;
     ed << "\nG4Scintillation::GetScintillationYieldByParticleType(): Request\n"
        <<   "for scintillation light yield above the available energy range\n"
        <<   "specifed in G4MaterialPropertiesTable. A linear interpolation\n"
        <<   "will be performed to compute the scintillation light yield using\n"
        <<   "(L_max / E_max) as the photon yield per unit energy."
        << G4endl;
     G4String cmt = "\nScintillation yield may be unphysical!\n";
     G4Exception("G4Scintillation::GetScintillationYieldByParticleType()",
         "Scint03", JustWarning, ed, cmt);
 
     G4double LinearYield = Scint_Yield_Vector->GetMaxValue()
                                          / Scint_Yield_Vector->GetMaxEnergy();
 
     // Units: [# scintillation photons]
     ScintillationYield = LinearYield * StepEnergyDeposit;
   }
 
 #ifdef G4DEBUG_SCINTILLATION
 
   // Increment track aggregators
   ScintTrackYield += ScintillationYield;
   ScintTrackEDep += StepEnergyDeposit;
 
   G4cout << "\n--- G4Scintillation::GetScintillationYieldByParticleType() ---\n"
      <<   "--\n"
      <<   "--  Name         =  " << aTrack.GetParticleDefinition()->GetParticleName() << "\n"
      <<   "--  TrackID      =  " << aTrack.GetTrackID() << "\n"
      <<   "--  ParentID     =  " << aTrack.GetParentID() << "\n"
      <<   "--  Current KE   =  " << aTrack.GetKineticEnergy()/MeV << " MeV\n"
      <<   "--  Step EDep    =  " << aStep.GetTotalEnergyDeposit()/MeV << " MeV\n"
      <<   "--  Track EDep   =  " << ScintTrackEDep/MeV << " MeV\n"
      <<   "--  Vertex KE    =  " << aTrack.GetVertexKineticEnergy()/MeV << " MeV\n"
      <<   "--  Step yield   =  " << ScintillationYield << " photons\n"
      <<   "--  Track yield  =  " << ScintTrackYield << " photons\n"
      << G4endl;
 
   // The track has terminated within or has left the scintillator volume
   if( (aTrack.GetTrackStatus() == fStopButAlive) or
       (aStep.GetPostStepPoint()->GetStepStatus() == fGeomBoundary) ){
 
     // Reset aggregators for the next track
     ScintTrackEDep = 0.;
     ScintTrackYield = 0.;
   }
 
 #endif
 
   return ScintillationYield;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetScintillationYieldFactor()

G4double G4Scintillation::GetScintillationYieldFactor ( ) const

inline

Definition at line 277 of file G4Scintillation.hh.

 {
         return fYieldFactor;
 }

◆ GetSlowIntegralTable()

G4PhysicsTable * G4Scintillation::GetSlowIntegralTable ( ) const

inline

Definition at line 289 of file G4Scintillation.hh.

 {
         return fSlowIntegralTable;
 }

◆ GetTrackSecondariesFirst()

G4bool G4Scintillation::GetTrackSecondariesFirst ( ) const

inline

Definition at line 265 of file G4Scintillation.hh.

 {
         return fTrackSecondariesFirst;
 }

◆ IsApplicable()

G4bool G4Scintillation::IsApplicable ( const G4ParticleDefinition & aParticleType )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 256 of file G4Scintillation.hh.

 {
        if (aParticleType.GetParticleName() == "opticalphoton") return false;
        if (aParticleType.IsShortLived()) return false;
 
        return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

G4Scintillation& G4Scintillation::operator= ( const G4Scintillation & right )

private

◆ PostStepDoIt()

G4VParticleChange * G4Scintillation::PostStepDoIt	(	const G4Track &	aTrack,
		const G4Step &	aStep
	)

virtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 186 of file G4Scintillation.cc.

 {
         aParticleChange.Initialize(aTrack);
 
         const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
         const G4Material* aMaterial = aTrack.GetMaterial();
 
         G4StepPoint* pPreStepPoint  = aStep.GetPreStepPoint();
         G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();
 
         G4ThreeVector x0 = pPreStepPoint->GetPosition();
         G4ThreeVector p0 = aStep.GetDeltaPosition().unit();
         G4double      t0 = pPreStepPoint->GetGlobalTime();
 
         G4double TotalEnergyDeposit = aStep.GetTotalEnergyDeposit();
 
         G4MaterialPropertiesTable* aMaterialPropertiesTable =
                                aMaterial->GetMaterialPropertiesTable();
         if (!aMaterialPropertiesTable)
              return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
 
         G4MaterialPropertyVector* Fast_Intensity =
                 aMaterialPropertiesTable->GetProperty("FASTCOMPONENT");
         G4MaterialPropertyVector* Slow_Intensity =
                 aMaterialPropertiesTable->GetProperty("SLOWCOMPONENT");
 
         if (!Fast_Intensity && !Slow_Intensity )
              return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
 
         G4int nscnt = 1;
         if (Fast_Intensity && Slow_Intensity) nscnt = 2;
 
         G4double ScintillationYield = 0.;
 
     // Scintillation depends on particle type, energy deposited
         if (fScintillationByParticleType) {
 
            ScintillationYield =
                           GetScintillationYieldByParticleType(aTrack, aStep);
 
            // The default linear scintillation process
         } else {
 
            ScintillationYield = aMaterialPropertiesTable->
                                       GetConstProperty("SCINTILLATIONYIELD");
 
            // Units: [# scintillation photons / MeV]
            ScintillationYield *= fYieldFactor;
         }
 
         G4double ResolutionScale    = aMaterialPropertiesTable->
                                       GetConstProperty("RESOLUTIONSCALE");
 
         // Birks law saturation:
 
         //G4double constBirks = 0.0;
 
         //constBirks = aMaterial->GetIonisation()->GetBirksConstant();
 
         G4double MeanNumberOfPhotons;
 
         // Birk's correction via fEmSaturation and specifying scintillation by
         // by particle type are physically mutually exclusive
 
         if (fScintillationByParticleType)
            MeanNumberOfPhotons = ScintillationYield;
         else if (fEmSaturation)
            MeanNumberOfPhotons = ScintillationYield*
              (fEmSaturation->VisibleEnergyDepositionAtAStep(&aStep));
         else
            MeanNumberOfPhotons = ScintillationYield*TotalEnergyDeposit;
 
         G4int NumPhotons;
 
         if (MeanNumberOfPhotons > 10.)
         {
           G4double sigma = ResolutionScale * std::sqrt(MeanNumberOfPhotons);
           NumPhotons = G4int(G4RandGauss::shoot(MeanNumberOfPhotons,sigma)+0.5);
         }
         else
         {
           NumPhotons = G4int(G4Poisson(MeanNumberOfPhotons));
         }
 
         if (NumPhotons <= 0)
         {
            // return unchanged particle and no secondaries
 
            aParticleChange.SetNumberOfSecondaries(0);
 
            return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
         }
 
 
         aParticleChange.SetNumberOfSecondaries(NumPhotons);
 
         if (fTrackSecondariesFirst) {
            if (aTrack.GetTrackStatus() == fAlive )
                   aParticleChange.ProposeTrackStatus(fSuspend);
         }
 
 
         G4int materialIndex = aMaterial->GetIndex();
 
         // Retrieve the Scintillation Integral for this material
         // new G4PhysicsOrderedFreeVector allocated to hold CII's
 
         G4int Num = NumPhotons;
 
         for (G4int scnt = 1; scnt <= nscnt; scnt++) {
 
             G4double ScintillationTime = 0.*ns;
             G4double ScintillationRiseTime = 0.*ns;
             G4PhysicsOrderedFreeVector* ScintillationIntegral = nullptr;
 
             if (scnt == 1) {
                if (nscnt == 1) {
                  if (Fast_Intensity) {
                    ScintillationTime   = aMaterialPropertiesTable->
                                            GetConstProperty("FASTTIMECONSTANT");
                    if (fFiniteRiseTime) {
                       ScintillationRiseTime = aMaterialPropertiesTable->
                                   GetConstProperty("FASTSCINTILLATIONRISETIME");
                    }
                    ScintillationIntegral =
                    (G4PhysicsOrderedFreeVector*)
                                        ((*fFastIntegralTable)(materialIndex));
                  }
                  if (Slow_Intensity) {
                    ScintillationTime   = aMaterialPropertiesTable->
                                            GetConstProperty("SLOWTIMECONSTANT");
                    if (fFiniteRiseTime) {
                       ScintillationRiseTime = aMaterialPropertiesTable->
                                   GetConstProperty("SLOWSCINTILLATIONRISETIME");
                    }
                    ScintillationIntegral =
                    (G4PhysicsOrderedFreeVector*)
                                        ((*fSlowIntegralTable)(materialIndex));
                  }
                }
                else {
                  G4double yieldRatio = aMaterialPropertiesTable->
                                           GetConstProperty("YIELDRATIO");
                  if ( fExcitationRatio == 1.0 || fExcitationRatio == 0.0) {
                     Num = G4int (std::min(yieldRatio,1.0) * NumPhotons);
                  }
                  else {
                     Num = G4int (std::min(fExcitationRatio,1.0) * NumPhotons);
                  }
                  ScintillationTime   = aMaterialPropertiesTable->
                                           GetConstProperty("FASTTIMECONSTANT");
                  if (fFiniteRiseTime) {
                       ScintillationRiseTime = aMaterialPropertiesTable->
                                  GetConstProperty("FASTSCINTILLATIONRISETIME");
                  }
                  ScintillationIntegral =
                  (G4PhysicsOrderedFreeVector*)
                                       ((*fFastIntegralTable)(materialIndex));
                }
             }
             else {
                Num = NumPhotons - Num;
                ScintillationTime   =   aMaterialPropertiesTable->
                                           GetConstProperty("SLOWTIMECONSTANT");
                if (fFiniteRiseTime) {
                     ScintillationRiseTime = aMaterialPropertiesTable->
                                  GetConstProperty("SLOWSCINTILLATIONRISETIME");
                }
                ScintillationIntegral =
                (G4PhysicsOrderedFreeVector*)
                                       ((*fSlowIntegralTable)(materialIndex));
             }
 
             if (!ScintillationIntegral) continue;
 
             // Max Scintillation Integral
  
             G4double CIImax = ScintillationIntegral->GetMaxValue();
 
             for (G4int i = 0; i < Num; i++) {
 
                 // Determine photon energy
 
                 G4double CIIvalue = G4UniformRand()*CIImax;
                 G4double sampledEnergy =
                               ScintillationIntegral->GetEnergy(CIIvalue);
 
                 if (verboseLevel>1) {
                    G4cout << "sampledEnergy = " << sampledEnergy << G4endl;
                    G4cout << "CIIvalue =        " << CIIvalue << G4endl;
                 }
 
                 // Generate random photon direction
 
                 G4double cost = 1. - 2.*G4UniformRand();
                 G4double sint = std::sqrt((1.-cost)*(1.+cost));
 
                 G4double phi = twopi*G4UniformRand();
                 G4double sinp = std::sin(phi);
                 G4double cosp = std::cos(phi);
 
                 G4double px = sint*cosp;
                 G4double py = sint*sinp;
                 G4double pz = cost;
 
                 // Create photon momentum direction vector
 
                 G4ParticleMomentum photonMomentum(px, py, pz);
 
                 // Determine polarization of new photon
 
                 G4double sx = cost*cosp;
                 G4double sy = cost*sinp;
                 G4double sz = -sint;
 
                 G4ThreeVector photonPolarization(sx, sy, sz);
 
                 G4ThreeVector perp = photonMomentum.cross(photonPolarization);
 
                 phi = twopi*G4UniformRand();
                 sinp = std::sin(phi);
                 cosp = std::cos(phi);
 
                 photonPolarization = cosp * photonPolarization + sinp * perp;
 
                 photonPolarization = photonPolarization.unit();
 
                 // Generate a new photon:
 
                 G4DynamicParticle* aScintillationPhoton =
                   new G4DynamicParticle(G4OpticalPhoton::OpticalPhoton(),
                                                          photonMomentum);
                 aScintillationPhoton->SetPolarization
                                      (photonPolarization.x(),
                                       photonPolarization.y(),
                                       photonPolarization.z());
 
                 aScintillationPhoton->SetKineticEnergy(sampledEnergy);
 
                 // Generate new G4Track object:
 
                 G4double rand;
 
                 if (aParticle->GetDefinition()->GetPDGCharge() != 0) {
                    rand = G4UniformRand();
                 } else {
                    rand = 1.0;
                 }
 
                 G4double delta = rand * aStep.GetStepLength();
                 G4double deltaTime = delta / (pPreStepPoint->GetVelocity()+
                                       rand*(pPostStepPoint->GetVelocity()-
                                             pPreStepPoint->GetVelocity())/2.);
 
                 // emission time distribution
                 if (ScintillationRiseTime==0.0) {
                    deltaTime = deltaTime -
                           ScintillationTime * std::log( G4UniformRand() );
                 } else {
                    deltaTime = deltaTime +
                           sample_time(ScintillationRiseTime, ScintillationTime);
                 }
 
                 G4double aSecondaryTime = t0 + deltaTime;
 
                 G4ThreeVector aSecondaryPosition =
                                     x0 + rand * aStep.GetDeltaPosition();
 
                 G4Track* aSecondaryTrack = new G4Track(aScintillationPhoton,
                                                        aSecondaryTime,
                                                        aSecondaryPosition);
 
                 aSecondaryTrack->SetTouchableHandle(
                                  aStep.GetPreStepPoint()->GetTouchableHandle());
                 // aSecondaryTrack->SetTouchableHandle((G4VTouchable*)0);
 
                 aSecondaryTrack->SetParentID(aTrack.GetTrackID());
 
                 aParticleChange.AddSecondary(aSecondaryTrack);
 
             }
         }
 
         if (verboseLevel>0) {
         G4cout << "\n Exiting from G4Scintillation::DoIt -- NumberOfSecondaries = "
                << aParticleChange.GetNumberOfSecondaries() << G4endl;
         }
 
         return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveSaturation()

void G4Scintillation::RemoveSaturation ( )

Definition at line 679 of file G4Scintillation.cc.

 {
         fEmSaturation = nullptr;
 }

Here is the caller graph for this function:

◆ sample_time()

G4double G4Scintillation::sample_time	(	G4double	tau1,
		G4double	tau2
	)

private

Definition at line 711 of file G4Scintillation.cc.

 {
 // tau1: rise time and tau2: decay time
 
     // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
         while(1) {
           // two random numbers
           G4double ran1 = G4UniformRand();
           G4double ran2 = G4UniformRand();
           //
           // exponential distribution as envelope function: very efficient
           //
           G4double d = (tau1+tau2)/tau2;
           // make sure the envelope function is
           // always larger than the bi-exponential
           G4double t = -1.0*tau2*std::log(1-ran1);
           G4double gg = d*single_exp(t,tau2);
           if (ran2 <= bi_exp(t,tau1,tau2)/gg) return t;
         }
         return -1.0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetFiniteRiseTime()

void G4Scintillation::SetFiniteRiseTime ( const G4bool state )

Definition at line 647 of file G4Scintillation.cc.

 {
         fFiniteRiseTime = state;
 }

Here is the caller graph for this function:

◆ SetScintillationByParticleType()

void G4Scintillation::SetScintillationByParticleType ( const G4bool scintType )

Definition at line 664 of file G4Scintillation.cc.

 {
         if (fEmSaturation) {
            G4Exception("G4Scintillation::SetScintillationByParticleType", "Scint02",
                        JustWarning, "Redefinition: Birks Saturation is replaced by ScintillationByParticleType!");
            RemoveSaturation();
         }
         fScintillationByParticleType = scintType;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetScintillationExcitationRatio()

void G4Scintillation::SetScintillationExcitationRatio ( const G4double ratio )

Definition at line 657 of file G4Scintillation.cc.

                                                                                     {
         fExcitationRatio = excitationratio;
 }

Here is the caller graph for this function:

◆ SetScintillationYieldFactor()

void G4Scintillation::SetScintillationYieldFactor ( const G4double yieldfactor )

Definition at line 652 of file G4Scintillation.cc.

 {
         fYieldFactor = yieldfactor;
 }

Here is the caller graph for this function:

◆ SetTrackSecondariesFirst()

void G4Scintillation::SetTrackSecondariesFirst ( const G4bool state )

Definition at line 642 of file G4Scintillation.cc.

 {
         fTrackSecondariesFirst = state;
 }

Here is the caller graph for this function:

◆ single_exp()

G4double G4Scintillation::single_exp	(	G4double	t,
		G4double	tau2
	)

inlineprivate

Definition at line 327 of file G4Scintillation.hh.

 {
          return std::exp(-1.0*t/tau2)/tau2;
 }

Here is the caller graph for this function:

Member Data Documentation

◆ fEmSaturation

G4EmSaturation* G4Scintillation::fEmSaturation

private

Definition at line 247 of file G4Scintillation.hh.

◆ fExcitationRatio

G4double G4Scintillation::fExcitationRatio

private

Definition at line 233 of file G4Scintillation.hh.

◆ fFastIntegralTable

G4PhysicsTable* G4Scintillation::fFastIntegralTable

protected

Definition at line 223 of file G4Scintillation.hh.

◆ fFiniteRiseTime

G4bool G4Scintillation::fFiniteRiseTime

private

Definition at line 229 of file G4Scintillation.hh.

◆ fScintillationByParticleType

G4bool G4Scintillation::fScintillationByParticleType

private

Definition at line 235 of file G4Scintillation.hh.

◆ fSlowIntegralTable

G4PhysicsTable* G4Scintillation::fSlowIntegralTable

protected

Definition at line 224 of file G4Scintillation.hh.

◆ fTrackSecondariesFirst

G4bool G4Scintillation::fTrackSecondariesFirst

private

Definition at line 228 of file G4Scintillation.hh.

◆ fYieldFactor

G4double G4Scintillation::fYieldFactor

private

Definition at line 231 of file G4Scintillation.hh.

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Scintillation() [1/2]

◆ ~G4Scintillation()

◆ G4Scintillation() [2/2]

Member Function Documentation

◆ AddSaturation()

◆ AtRestDoIt()

◆ bi_exp()

◆ BuildPhysicsTable()

◆ BuildThePhysicsTable()

◆ DumpPhysicsTable()

◆ GetFastIntegralTable()

◆ GetFiniteRiseTime()

◆ GetMeanFreePath()

◆ GetMeanLifeTime()

◆ GetSaturation()

◆ GetScintillationByParticleType()

◆ GetScintillationExcitationRatio()

◆ GetScintillationYieldByParticleType()

◆ GetScintillationYieldFactor()

◆ GetSlowIntegralTable()

◆ GetTrackSecondariesFirst()

◆ IsApplicable()

◆ operator=()

◆ PostStepDoIt()

◆ RemoveSaturation()

◆ sample_time()

◆ SetFiniteRiseTime()

◆ SetScintillationByParticleType()

◆ SetScintillationExcitationRatio()

◆ SetScintillationYieldFactor()

◆ SetTrackSecondariesFirst()

◆ single_exp()

Member Data Documentation

◆ fEmSaturation

◆ fExcitationRatio

◆ fFastIntegralTable

◆ fFiniteRiseTime

◆ fScintillationByParticleType

◆ fSlowIntegralTable

◆ fTrackSecondariesFirst

◆ fYieldFactor