#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) override

void	BuildPhysicsTable (const G4ParticleDefinition &aParticleType) override

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

G4double	GetMeanLifeTime (const G4Track &aTrack, G4ForceCondition *) override

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

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

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

void	SetTrackSecondariesFirst (const G4bool state)

G4bool	GetTrackSecondariesFirst () const

void	SetFiniteRiseTime (const G4bool state)

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 *sat)

void	RemoveSaturation ()

G4EmSaturation *	GetSaturation () const

void	SetScintillationByParticleType (const G4bool)

G4bool	GetScintillationByParticleType () const

void	SetScintillationTrackInfo (const G4bool trackType)

G4bool	GetScintillationTrackInfo () const

void	SetStackPhotons (const G4bool)

G4bool	GetStackPhotons () const

G4int	GetNumPhotons () 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 ()

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::G4Scintillation	(	const G4String &	processName = `"Scintillation"`,
		G4ProcessType	type = `fElectromagnetic`
	)

explicit

Definition at line 111 of file G4Scintillation.cc.

                   : G4VRestDiscreteProcess(processName, type) ,
     fTrackSecondariesFirst(false),
     fFiniteRiseTime(false),
     fYieldFactor(1.0),
     fExcitationRatio(1.0),
     fScintillationByParticleType(false),
     fScintillationTrackInfo(false),
     fStackingFlag(true),
     fNumPhotons(0),
     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 ( )

Definition at line 143 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:

Member Function Documentation

void G4Scintillation::AddSaturation ( G4EmSaturation * sat )

inline

Definition at line 349 of file G4Scintillation.hh.

 {
         fEmSaturation = sat;
 }

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 179 of file G4Scintillation.cc.

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

Here is the call graph for this function:

void G4Scintillation::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 159 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:

void G4Scintillation::BuildThePhysicsTable ( )

protected

Definition at line 501 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:

void G4Scintillation::DumpPhysicsTable ( ) const

inline

Definition at line 403 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:

G4PhysicsTable * G4Scintillation::GetFastIntegralTable ( ) const

inline

Definition at line 343 of file G4Scintillation.hh.

 {
         return fFastIntegralTable;
 }

G4bool G4Scintillation::GetFiniteRiseTime ( ) const

inline

Definition at line 307 of file G4Scintillation.hh.

 {
         return fFiniteRiseTime;
 }

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

overridevirtual

Implements G4VRestDiscreteProcess.

Definition at line 668 of file G4Scintillation.cc.

 {
         *condition = StronglyForced;
 
         return DBL_MAX;
 
 }

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

overridevirtual

Implements G4VRestDiscreteProcess.

Definition at line 682 of file G4Scintillation.cc.

 {
         *condition = Forced;
 
         return DBL_MAX;
 
 }

G4int G4Scintillation::GetNumPhotons ( ) const

inline

Definition at line 397 of file G4Scintillation.hh.

 {
         return fNumPhotons;
 }

G4EmSaturation * G4Scintillation::GetSaturation ( ) const

inline

Definition at line 361 of file G4Scintillation.hh.

 {
         return fEmSaturation;
 }

G4bool G4Scintillation::GetScintillationByParticleType ( ) const

inline

Definition at line 367 of file G4Scintillation.hh.

 {
         return fScintillationByParticleType;
 }

G4double G4Scintillation::GetScintillationExcitationRatio ( ) const

inline

Definition at line 331 of file G4Scintillation.hh.

 {
         return fExcitationRatio;
 }

G4bool G4Scintillation::GetScintillationTrackInfo ( ) const

inline

Definition at line 379 of file G4Scintillation.hh.

 {
         return fScintillationTrackInfo;
 }

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

Definition at line 714 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:

G4double G4Scintillation::GetScintillationYieldFactor ( ) const

inline

Definition at line 319 of file G4Scintillation.hh.

 {
         return fYieldFactor;
 }

G4PhysicsTable * G4Scintillation::GetSlowIntegralTable ( ) const

inline

Definition at line 337 of file G4Scintillation.hh.

 {
         return fSlowIntegralTable;
 }

G4bool G4Scintillation::GetStackPhotons ( ) const

inline

Definition at line 391 of file G4Scintillation.hh.

 {
         return fStackingFlag;
 }

G4bool G4Scintillation::GetTrackSecondariesFirst ( ) const

inline

Definition at line 295 of file G4Scintillation.hh.

 {
         return fTrackSecondariesFirst;
 }

G4bool G4Scintillation::IsApplicable ( const G4ParticleDefinition & aParticleType )

inlineoverridevirtual

Reimplemented from G4VProcess.

Definition at line 280 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:

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

overridevirtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 192 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;
 
         if (MeanNumberOfPhotons > 10.)
         {
           G4double sigma = ResolutionScale * std::sqrt(MeanNumberOfPhotons);
           fNumPhotons=G4int(G4RandGauss::shoot(MeanNumberOfPhotons,sigma)+0.5);
         }
         else
         {
           fNumPhotons = G4int(G4Poisson(MeanNumberOfPhotons));
         }
 
         if ( fNumPhotons <= 0 || !fStackingFlag )
         {
            // return unchanged particle and no secondaries
 
            aParticleChange.SetNumberOfSecondaries(0);
 
            return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
         }
 
 
         aParticleChange.SetNumberOfSecondaries(fNumPhotons);
 
         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 = fNumPhotons;
 
         for (G4int scnt = 1; scnt <= nscnt; scnt++) {
 
             G4double ScintillationTime = 0.*ns;
             G4double ScintillationRiseTime = 0.*ns;
             G4PhysicsOrderedFreeVector* ScintillationIntegral = nullptr;
             G4ScintillationType ScintillationType = Slow;
 
             if (scnt == 1) {
                if (nscnt == 1) {
                  if (Fast_Intensity) {
                    ScintillationTime   = aMaterialPropertiesTable->
                                            GetConstProperty("FASTTIMECONSTANT");
                    if (fFiniteRiseTime) {
                       ScintillationRiseTime = aMaterialPropertiesTable->
                                   GetConstProperty("FASTSCINTILLATIONRISETIME");
                    }
                    ScintillationType = Fast;
                    ScintillationIntegral =
                    (G4PhysicsOrderedFreeVector*)
                                        ((*fFastIntegralTable)(materialIndex));
                  }
                  if (Slow_Intensity) {
                    ScintillationTime   = aMaterialPropertiesTable->
                                            GetConstProperty("SLOWTIMECONSTANT");
                    if (fFiniteRiseTime) {
                       ScintillationRiseTime = aMaterialPropertiesTable->
                                   GetConstProperty("SLOWSCINTILLATIONRISETIME");
                    }
                    ScintillationType = Slow;
                    ScintillationIntegral =
                    (G4PhysicsOrderedFreeVector*)
                                        ((*fSlowIntegralTable)(materialIndex));
                  }
                }
                else {
                  G4double yieldRatio = aMaterialPropertiesTable->
                                           GetConstProperty("YIELDRATIO");
                  if ( fExcitationRatio == 1.0 || fExcitationRatio == 0.0) {
                     Num = G4int (std::min(yieldRatio,1.0) * fNumPhotons);
                  }
                  else {
                     Num = G4int (std::min(fExcitationRatio,1.0) * fNumPhotons);
                  }
                  ScintillationTime   = aMaterialPropertiesTable->
                                           GetConstProperty("FASTTIMECONSTANT");
                  if (fFiniteRiseTime) {
                       ScintillationRiseTime = aMaterialPropertiesTable->
                                  GetConstProperty("FASTSCINTILLATIONRISETIME");
                  }
                  ScintillationType = Fast;
                  ScintillationIntegral =
                  (G4PhysicsOrderedFreeVector*)
                                       ((*fFastIntegralTable)(materialIndex));
                }
             }
             else {
                Num = fNumPhotons - Num;
                ScintillationTime   =   aMaterialPropertiesTable->
                                           GetConstProperty("SLOWTIMECONSTANT");
                if (fFiniteRiseTime) {
                     ScintillationRiseTime = aMaterialPropertiesTable->
                                  GetConstProperty("SLOWSCINTILLATIONRISETIME");
                }
                ScintillationType = Slow;
                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());
 
                 if (fScintillationTrackInfo) aSecondaryTrack->
                    SetUserInformation(new G4ScintillationTrackInformation(ScintillationType));
 
                 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:

void G4Scintillation::RemoveSaturation ( )

inline

Definition at line 355 of file G4Scintillation.hh.

 {
         fEmSaturation = nullptr;
 }

Here is the caller graph for this function:

void G4Scintillation::SetFiniteRiseTime ( const G4bool state )

inline

Definition at line 301 of file G4Scintillation.hh.

 {
         fFiniteRiseTime = state;
 }

Here is the caller graph for this function:

void G4Scintillation::SetScintillationByParticleType ( const G4bool scintType )

Definition at line 654 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:

void G4Scintillation::SetScintillationExcitationRatio ( const G4double ratio )

inline

Definition at line 325 of file G4Scintillation.hh.

 {
         fExcitationRatio = ratio;
 }

Here is the caller graph for this function:

void G4Scintillation::SetScintillationTrackInfo ( const G4bool trackType )

inline

Definition at line 373 of file G4Scintillation.hh.

 {
         fScintillationTrackInfo = trackType;
 }

Here is the caller graph for this function:

void G4Scintillation::SetScintillationYieldFactor ( const G4double yieldfactor )

inline

Definition at line 313 of file G4Scintillation.hh.

 {
         fYieldFactor = yieldfactor;
 }

Here is the caller graph for this function:

void G4Scintillation::SetStackPhotons ( const G4bool stackingFlag )

inline

Definition at line 385 of file G4Scintillation.hh.

 {
         fStackingFlag = stackingFlag;
 }

Here is the caller graph for this function:

void G4Scintillation::SetTrackSecondariesFirst ( const G4bool state )

inline

Definition at line 289 of file G4Scintillation.hh.

 {
         fTrackSecondariesFirst = state;
 }

Here is the caller graph for this function:

Member Data Documentation

G4PhysicsTable* G4Scintillation::fFastIntegralTable

protected

Definition at line 241 of file G4Scintillation.hh.

G4PhysicsTable* G4Scintillation::fSlowIntegralTable

protected

Definition at line 242 of file G4Scintillation.hh.

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

geant4.10.03.p01/source/processes/electromagnetic/xrays/include/G4Scintillation.hh
geant4.10.03.p01/source/processes/electromagnetic/xrays/src/G4Scintillation.cc

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

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation