#include <G4Scintillation.hh>

Inheritance diagram for G4Scintillation:

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

	~G4Scintillation ()

G4bool	IsApplicable (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)

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 excitationratio)

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	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 G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0

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

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 G4bool	IsApplicable (const G4ParticleDefinition &)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

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

Protected Member Functions
void	BuildThePhysicsTable ()

virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)=0

virtual G4double	GetMeanLifeTime (const G4Track &aTrack, G4ForceCondition *condition)=0

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

Definition at line 96 of file G4Scintillation.cc.

                  : G4VRestDiscreteProcess(processName, type)
{
        SetProcessSubType(fScintillation);
 
        fTrackSecondariesFirst = false;
        fFiniteRiseTime = false;
 
        YieldFactor = 1.0;
        ExcitationRatio = 1.0;
 
        scintillationByParticleType = false;
 
        theFastIntegralTable = NULL;
        theSlowIntegralTable = NULL;
 
        if (verboseLevel>0) {
           G4cout << GetProcessName() << " is created " << G4endl;
        }
 
        BuildThePhysicsTable();
 
        emSaturation = NULL;
}

◆ ~G4Scintillation()

G4Scintillation::~G4Scintillation ( )

Definition at line 126 of file G4Scintillation.cc.

{
    if (theFastIntegralTable != NULL) {
           theFastIntegralTable->clearAndDestroy();
           delete theFastIntegralTable;
        }
        if (theSlowIntegralTable != NULL) {
           theSlowIntegralTable->clearAndDestroy();
           delete theSlowIntegralTable;
        }
}

Member Function Documentation

◆ AddSaturation()

void G4Scintillation::AddSaturation ( G4EmSaturation * sat )

inline

Definition at line 183 of file G4Scintillation.hh.

183{ emSaturation = sat; }

Referenced by G4OpticalPhysics::AddScintillationSaturation(), and G4OpticalPhysics::ConstructProcess().

◆ AtRestDoIt()

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

virtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 146 of file G4Scintillation.cc.

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

◆ BuildThePhysicsTable()

void G4Scintillation::BuildThePhysicsTable ( )

protected

Definition at line 537 of file G4Scintillation.cc.

{
        if (theFastIntegralTable && theSlowIntegralTable) return;
 
        const G4MaterialTable* theMaterialTable = 
                               G4Material::GetMaterialTable();
        G4int numOfMaterials = G4Material::GetNumberOfMaterials();
 
        // create new physics table
    
        if(!theFastIntegralTable)theFastIntegralTable = new G4PhysicsTable(numOfMaterials);
        if(!theSlowIntegralTable)theSlowIntegralTable = 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.
 
        theFastIntegralTable->insertAt(i,aPhysicsOrderedFreeVector);
        theSlowIntegralTable->insertAt(i,bPhysicsOrderedFreeVector);
 
        }
}

Referenced by G4Scintillation().

◆ DumpPhysicsTable()

void G4Scintillation::DumpPhysicsTable ( ) const

inline

Definition at line 312 of file G4Scintillation.hh.

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

◆ GetFastIntegralTable()

G4PhysicsTable * G4Scintillation::GetFastIntegralTable ( ) const

inline

Definition at line 306 of file G4Scintillation.hh.

{
        return theFastIntegralTable;
}

◆ GetFiniteRiseTime()

G4bool G4Scintillation::GetFiniteRiseTime ( ) const

inline

Definition at line 270 of file G4Scintillation.hh.

{
        return fFiniteRiseTime;
}

◆ GetMeanFreePath()

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

virtual

Implements G4VRestDiscreteProcess.

Definition at line 705 of file G4Scintillation.cc.

{
        *condition = StronglyForced;
 
        return DBL_MAX;
 
}

◆ GetMeanLifeTime()

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

virtual

Implements G4VRestDiscreteProcess.

Definition at line 719 of file G4Scintillation.cc.

{
        *condition = Forced;
 
        return DBL_MAX;
 
}

◆ GetSaturation()

G4EmSaturation * G4Scintillation::GetSaturation ( ) const

inline

Definition at line 189 of file G4Scintillation.hh.

189{ return emSaturation; }

◆ GetScintillationByParticleType()

G4bool G4Scintillation::GetScintillationByParticleType ( ) const

inline

Definition at line 196 of file G4Scintillation.hh.

197 { return scintillationByParticleType; }

◆ GetScintillationExcitationRatio()

G4double G4Scintillation::GetScintillationExcitationRatio ( ) const

inline

Definition at line 294 of file G4Scintillation.hh.

{
        return ExcitationRatio;
}

◆ GetScintillationYieldFactor()

G4double G4Scintillation::GetScintillationYieldFactor ( ) const

inline

Definition at line 282 of file G4Scintillation.hh.

{
        return YieldFactor;
}

◆ GetSlowIntegralTable()

G4PhysicsTable * G4Scintillation::GetSlowIntegralTable ( ) const

inline

Definition at line 300 of file G4Scintillation.hh.

{
        return theSlowIntegralTable;
}

◆ GetTrackSecondariesFirst()

G4bool G4Scintillation::GetTrackSecondariesFirst ( ) const

inline

Definition at line 264 of file G4Scintillation.hh.

{
        return fTrackSecondariesFirst;
}

◆ IsApplicable()

G4bool G4Scintillation::IsApplicable ( const G4ParticleDefinition & aParticleType )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 243 of file G4Scintillation.hh.

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

Referenced by G4OpticalPhysics::ConstructProcess().

◆ PostStepDoIt()

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

virtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 159 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.;
 
        if (scintillationByParticleType) {
           // The scintillation response is a function of the energy
           // deposited by particle types.
 
           // Get the definition of the current particle
           G4ParticleDefinition *pDef = aParticle->GetDefinition();
           G4MaterialPropertyVector *Scint_Yield_Vector = NULL;
 
           // Obtain the G4MaterialPropertyVectory containing the
           // scintillation light yield as a function of the deposited
           // energy for the current 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 tracking 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 PhotoElectricEffect)
           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 not specified yields for (p,d,t,a,carbon)
           // then these unspecified particles will default to the 
           // electron's scintillation yield
           if(!Scint_Yield_Vector){
             Scint_Yield_Vector = aMaterialPropertiesTable->
               GetProperty("ELECTRONSCINTILLATIONYIELD");
           }
 
           // Throw an exception if no scintillation yield is found
           if (!Scint_Yield_Vector) {
              G4ExceptionDescription ed;
              ed << "\nG4Scintillation::PostStepDoIt(): "
                     << "Request for scintillation yield for energy deposit and particle type without correct entry in MaterialPropertiesTable\n"
                     << "ScintillationByParticleType requires at minimum that 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);
             return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
           }
 
           if (verboseLevel>1) {
             G4cout << "\n"
                    << "Particle = " << pDef->GetParticleName() << "\n"
                    << "Energy Dep. = " << TotalEnergyDeposit/MeV << "\n"
                    << "Yield = " 
                    << Scint_Yield_Vector->Value(TotalEnergyDeposit) 
                    << "\n" << G4endl;
           }
 
           // Obtain the scintillation yield using the total energy
           // deposited by the particle in this step.
 
           // Units: [# scintillation photons]
           ScintillationYield = Scint_Yield_Vector->
                                            Value(TotalEnergyDeposit);
        } else {
           // The default linear scintillation process
           ScintillationYield = aMaterialPropertiesTable->
                                      GetConstProperty("SCINTILLATIONYIELD");
 
           // Units: [# scintillation photons / MeV]
           ScintillationYield *= YieldFactor;
        }
 
        G4double ResolutionScale    = aMaterialPropertiesTable->
                                      GetConstProperty("RESOLUTIONSCALE");
 
        // Birks law saturation:
 
        //G4double constBirks = 0.0;
 
        //constBirks = aMaterial->GetIonisation()->GetBirksConstant();
 
        G4double MeanNumberOfPhotons;
 
        // Birk's correction via emSaturation and specifying scintillation by
        // by particle type are physically mutually exclusive
 
        if (scintillationByParticleType)
           MeanNumberOfPhotons = ScintillationYield;
        else if (emSaturation)
           MeanNumberOfPhotons = ScintillationYield*
                              (emSaturation->VisibleEnergyDeposition(&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 = NULL;
 
            if (scnt == 1) {
               if (nscnt == 1) {
                 if(Fast_Intensity){
                   ScintillationTime   = aMaterialPropertiesTable->
                                           GetConstProperty("FASTTIMECONSTANT");
                   if (fFiniteRiseTime) {
                      ScintillationRiseTime = aMaterialPropertiesTable->
                                  GetConstProperty("FASTSCINTILLATIONRISETIME");
                   }
                   ScintillationIntegral =
                   (G4PhysicsOrderedFreeVector*)((*theFastIntegralTable)(materialIndex));
                 }
                 if(Slow_Intensity){
                   ScintillationTime   = aMaterialPropertiesTable->
                                           GetConstProperty("SLOWTIMECONSTANT");
                   if (fFiniteRiseTime) {
                      ScintillationRiseTime = aMaterialPropertiesTable->
                                  GetConstProperty("SLOWSCINTILLATIONRISETIME");
                   }
                   ScintillationIntegral =
                   (G4PhysicsOrderedFreeVector*)((*theSlowIntegralTable)(materialIndex));
                 }
               }
               else {
                 G4double YieldRatio = aMaterialPropertiesTable->
                                          GetConstProperty("YIELDRATIO");
                 if ( ExcitationRatio == 1.0 ) {
                    Num = G4int (std::min(YieldRatio,1.0) * NumPhotons);
                 }
                 else {
                    Num = G4int (std::min(ExcitationRatio,1.0) * NumPhotons);
                 }
                 ScintillationTime   = aMaterialPropertiesTable->
                                          GetConstProperty("FASTTIMECONSTANT");
                 if (fFiniteRiseTime) {
                      ScintillationRiseTime = aMaterialPropertiesTable->
                                 GetConstProperty("FASTSCINTILLATIONRISETIME");
                 }
                 ScintillationIntegral =
                  (G4PhysicsOrderedFreeVector*)((*theFastIntegralTable)(materialIndex));
               }
            }
            else {
               Num = NumPhotons - Num;
               ScintillationTime   =   aMaterialPropertiesTable->
                                          GetConstProperty("SLOWTIMECONSTANT");
               if (fFiniteRiseTime) {
                    ScintillationRiseTime = aMaterialPropertiesTable->
                                 GetConstProperty("SLOWSCINTILLATIONRISETIME");
               }
               ScintillationIntegral =
                  (G4PhysicsOrderedFreeVector*)((*theSlowIntegralTable)(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()+
                         pPostStepPoint->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);
}

Referenced by AtRestDoIt().

◆ RemoveSaturation()

void G4Scintillation::RemoveSaturation ( )

inline

Definition at line 186 of file G4Scintillation.hh.

186{ emSaturation = NULL; }

Referenced by SetScintillationByParticleType().

◆ SetFiniteRiseTime()

void G4Scintillation::SetFiniteRiseTime ( const G4bool state )

inline

Definition at line 258 of file G4Scintillation.hh.

{
        fFiniteRiseTime = state;
}

Referenced by G4OpticalPhysics::ConstructProcess(), and G4OpticalPhysics::SetFiniteRiseTime().

◆ SetScintillationByParticleType()

void G4Scintillation::SetScintillationByParticleType ( const G4bool scintType )

Definition at line 691 of file G4Scintillation.cc.

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

Referenced by G4OpticalPhysics::ConstructProcess(), and G4OpticalPhysics::SetScintillationByParticleType().

◆ SetScintillationExcitationRatio()

void G4Scintillation::SetScintillationExcitationRatio ( const G4double excitationratio )

inline

Definition at line 288 of file G4Scintillation.hh.

{
        ExcitationRatio = excitationratio;
}

Referenced by G4OpticalPhysics::ConstructProcess(), and G4OpticalPhysics::SetScintillationExcitationRatio().

◆ SetScintillationYieldFactor()

void G4Scintillation::SetScintillationYieldFactor ( const G4double yieldfactor )

inline

Definition at line 276 of file G4Scintillation.hh.

{
        YieldFactor = yieldfactor;
}

Referenced by G4OpticalPhysics::ConstructProcess(), and G4OpticalPhysics::SetScintillationYieldFactor().

◆ SetTrackSecondariesFirst()

void G4Scintillation::SetTrackSecondariesFirst ( const G4bool state )

inline

Definition at line 252 of file G4Scintillation.hh.

{
    fTrackSecondariesFirst = state;
}

Referenced by G4OpticalPhysics::SetTrackSecondariesFirst().

Member Data Documentation

◆ ExcitationRatio

G4double G4Scintillation::ExcitationRatio

protected

Definition at line 222 of file G4Scintillation.hh.

Referenced by G4Scintillation(), GetScintillationExcitationRatio(), PostStepDoIt(), and SetScintillationExcitationRatio().

◆ fFiniteRiseTime

G4bool G4Scintillation::fFiniteRiseTime

protected

Definition at line 218 of file G4Scintillation.hh.

Referenced by G4Scintillation(), GetFiniteRiseTime(), PostStepDoIt(), and SetFiniteRiseTime().

◆ fTrackSecondariesFirst

G4bool G4Scintillation::fTrackSecondariesFirst

protected

Definition at line 217 of file G4Scintillation.hh.

Referenced by G4Scintillation(), GetTrackSecondariesFirst(), PostStepDoIt(), and SetTrackSecondariesFirst().

◆ scintillationByParticleType

G4bool G4Scintillation::scintillationByParticleType

protected

Definition at line 224 of file G4Scintillation.hh.

Referenced by G4Scintillation(), GetScintillationByParticleType(), PostStepDoIt(), and SetScintillationByParticleType().

◆ theFastIntegralTable

G4PhysicsTable* G4Scintillation::theFastIntegralTable

protected

Definition at line 215 of file G4Scintillation.hh.

Referenced by BuildThePhysicsTable(), DumpPhysicsTable(), G4Scintillation(), GetFastIntegralTable(), PostStepDoIt(), and ~G4Scintillation().

◆ theSlowIntegralTable

G4PhysicsTable* G4Scintillation::theSlowIntegralTable

protected

Definition at line 214 of file G4Scintillation.hh.

Referenced by BuildThePhysicsTable(), DumpPhysicsTable(), G4Scintillation(), GetSlowIntegralTable(), PostStepDoIt(), and ~G4Scintillation().

◆ YieldFactor

G4double G4Scintillation::YieldFactor

protected

Definition at line 220 of file G4Scintillation.hh.

Referenced by G4Scintillation(), GetScintillationYieldFactor(), PostStepDoIt(), and SetScintillationYieldFactor().

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

Protected Attributes
G4PhysicsTable *	theSlowIntegralTable

G4PhysicsTable *	theFastIntegralTable

G4bool	fTrackSecondariesFirst

G4bool	fFiniteRiseTime

G4double	YieldFactor

G4double	ExcitationRatio

G4bool	scintillationByParticleType

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

◆ G4Scintillation()

◆ ~G4Scintillation()

Member Function Documentation

◆ AddSaturation()

◆ AtRestDoIt()

◆ BuildThePhysicsTable()

◆ DumpPhysicsTable()

◆ GetFastIntegralTable()

◆ GetFiniteRiseTime()

◆ GetMeanFreePath()

◆ GetMeanLifeTime()

◆ GetSaturation()

◆ GetScintillationByParticleType()

◆ GetScintillationExcitationRatio()

◆ GetScintillationYieldFactor()

◆ GetSlowIntegralTable()

◆ GetTrackSecondariesFirst()

◆ IsApplicable()

◆ PostStepDoIt()

◆ RemoveSaturation()

◆ SetFiniteRiseTime()

◆ SetScintillationByParticleType()

◆ SetScintillationExcitationRatio()

◆ SetScintillationYieldFactor()

◆ SetTrackSecondariesFirst()

Member Data Documentation

◆ ExcitationRatio

◆ fFiniteRiseTime

◆ fTrackSecondariesFirst

◆ scintillationByParticleType

◆ theFastIntegralTable

◆ theSlowIntegralTable

◆ YieldFactor