#include <G4Scintillation.hh>

Inheritance 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

void	PreparePhysicsTable (const G4ParticleDefinition &part) override

void	Initialise ()

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)

G4double	GetScintillationYieldByParticleType (const G4Track &aTrack, const G4Step &aStep, G4double &yield1, G4double &yield2, G4double &yield3)

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

G4PhysicsTable *	GetIntegralTable1 () const

G4PhysicsTable *	GetIntegralTable2 () const

G4PhysicsTable *	GetIntegralTable3 () const

void	AddSaturation (G4EmSaturation *sat)

void	RemoveSaturation ()

G4EmSaturation *	GetSaturation () const

void	SetScintillationByParticleType (const G4bool)

G4bool	GetScintillationByParticleType () const

void	SetEnhancedTimeConstants (G4bool)

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

G4VRestDiscreteProcess &	operator= (const G4VRestDiscreteProcess &)=delete

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

G4VProcess &	operator= (const G4VProcess &)=delete

G4bool	operator== (const G4VProcess &right) const

G4bool	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

virtual void	ProcessDescription (std::ostream &outfile) 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 Attributes
G4PhysicsTable *	fIntegralTable1

G4PhysicsTable *	fIntegralTable2

G4PhysicsTable *	fIntegralTable3

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr

G4VParticleChange *	pParticleChange = nullptr

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft = -1.0

G4double	currentInteractionLength = -1.0

G4double	theInitialNumberOfInteractionLength = -1.0

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType = fNotDefined

G4int	theProcessSubType = -1

G4double	thePILfactor = 1.0

G4int	verboseLevel = 0

G4bool	enableAtRestDoIt = true

G4bool	enableAlongStepDoIt = true

G4bool	enablePostStepDoIt = true

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

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

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 78 of file G4Scintillation.hh.

Constructor & Destructor Documentation

◆ G4Scintillation()

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

explicit

Definition at line 80 of file G4Scintillation.cc.

  : G4VRestDiscreteProcess(processName, type)
  , fIntegralTable1(nullptr)
  , fIntegralTable2(nullptr)
  , fIntegralTable3(nullptr)
  , fNumPhotons(0)
  , fEmSaturation(nullptr)
{
  SetProcessSubType(fScintillation);
 
#ifdef G4DEBUG_SCINTILLATION
  ScintTrackEDep  = 0.;
  ScintTrackYield = 0.;
#endif
 
  if(verboseLevel > 0)
  {
    G4cout << GetProcessName() << " is created " << G4endl;
  }
  Initialise();
}

◆ ~G4Scintillation()

G4Scintillation::~G4Scintillation ( )

Definition at line 104 of file G4Scintillation.cc.

{
  if(fIntegralTable1 != nullptr)
  {
    fIntegralTable1->clearAndDestroy();
    delete fIntegralTable1;
  }
  if(fIntegralTable2 != nullptr)
  {
    fIntegralTable2->clearAndDestroy();
    delete fIntegralTable2;
  }
  if(fIntegralTable3 != nullptr)
  {
    fIntegralTable3->clearAndDestroy();
    delete fIntegralTable3;
  }
}

Member Function Documentation

◆ AddSaturation()

void G4Scintillation::AddSaturation ( G4EmSaturation * sat )

inline

Definition at line 335 of file G4Scintillation.hh.

{
  fEmSaturation = sat;
}

Referenced by G4OpticalPhysics::ConstructProcess().

◆ AtRestDoIt()

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

overridevirtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 319 of file G4Scintillation.cc.

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

◆ BuildPhysicsTable()

void G4Scintillation::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 153 of file G4Scintillation.cc.

{
  if(fIntegralTable1 != nullptr)
  {
    fIntegralTable1->clearAndDestroy();
    delete fIntegralTable1;
    fIntegralTable1 = nullptr;
  }
  if(fIntegralTable2 != nullptr)
  {
    fIntegralTable2->clearAndDestroy();
    delete fIntegralTable2;
    fIntegralTable2 = nullptr;
  }
  if(fIntegralTable3 != nullptr)
  {
    fIntegralTable3->clearAndDestroy();
    delete fIntegralTable3;
    fIntegralTable3 = nullptr;
  }
 
  const G4MaterialTable* materialTable = G4Material::GetMaterialTable();
  size_t numOfMaterials                = G4Material::GetNumberOfMaterials();
 
  // create new physics table
  if(!fIntegralTable1)
    fIntegralTable1 = new G4PhysicsTable(numOfMaterials);
  if(!fIntegralTable2)
    fIntegralTable2 = new G4PhysicsTable(numOfMaterials);
  if(!fIntegralTable3)
    fIntegralTable3 = new G4PhysicsTable(numOfMaterials);
 
  for(size_t i = 0; i < numOfMaterials; ++i)
  {
    G4PhysicsOrderedFreeVector* vector1 = new G4PhysicsOrderedFreeVector();
    G4PhysicsOrderedFreeVector* vector2 = new G4PhysicsOrderedFreeVector();
    G4PhysicsOrderedFreeVector* vector3 = new G4PhysicsOrderedFreeVector();
 
    // Retrieve vector of scintillation wavelength intensity for
    // the material from the material's optical properties table.
    G4MaterialPropertiesTable* MPT =
      ((*materialTable)[i])->GetMaterialPropertiesTable();
 
    if(MPT)
    {
      // integral table 1 is either FASTCOMPONENT or SCINTILLATIONCOMPONENT1
      G4MaterialPropertyVector* MPV = MPT->GetProperty(kFASTCOMPONENT);
      if(!MPV)
        MPV = MPT->GetProperty(kSCINTILLATIONCOMPONENT1);
      if(MPV)
      {
        // Retrieve the first intensity point in vector
        // of (photon energy, intensity) pairs
        G4double currentIN = (*MPV)[0];
        if(currentIN >= 0.0)
        {
          // Create first (photon energy, Scintillation Integral pair
          G4double currentPM  = MPV->Energy(0);
          G4double currentCII = 0.0;
          vector1->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 < MPV->GetVectorLength(); ++ii)
          {
            currentPM = MPV->Energy(ii);
            currentIN = (*MPV)[ii];
            currentCII =
              prevCII + 0.5 * (currentPM - prevPM) * (prevIN + currentIN);
 
            vector1->InsertValues(currentPM, currentCII);
 
            prevPM  = currentPM;
            prevCII = currentCII;
            prevIN  = currentIN;
          }
        }
      }
 
      // integral table 2 is SCINTILLATIONCOMPONENT2
      MPV = MPT->GetProperty(kSCINTILLATIONCOMPONENT2);
      if(MPV)
      {
        // Retrieve the first intensity point in vector
        // of (photon energy, intensity) pairs
        G4double currentIN = (*MPV)[0];
        if(currentIN >= 0.0)
        {
          // Create first (photon energy, Scintillation Integral pair
          G4double currentPM  = MPV->Energy(0);
          G4double currentCII = 0.0;
          vector2->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 < MPV->GetVectorLength(); ++ii)
          {
            currentPM = MPV->Energy(ii);
            currentIN = (*MPV)[ii];
            currentCII =
              prevCII + 0.5 * (currentPM - prevPM) * (prevIN + currentIN);
 
            vector2->InsertValues(currentPM, currentCII);
 
            prevPM  = currentPM;
            prevCII = currentCII;
            prevIN  = currentIN;
          }
        }
      }
      // integral table 3 is either SLOWCOMPONENT or SCINTILLATIONCOMPONENT3
      MPV = MPT->GetProperty(kSLOWCOMPONENT);
      if(!MPV)
        MPV = MPT->GetProperty(kSCINTILLATIONCOMPONENT3);
      if(MPV)
      {
        // Retrieve the first intensity point in vector
        // of (photon energy, intensity) pairs
        G4double currentIN = (*MPV)[0];
        if(currentIN >= 0.0)
        {
          // Create first (photon energy, Scintillation Integral pair
          G4double currentPM  = MPV->Energy(0);
          G4double currentCII = 0.0;
          vector3->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 < MPV->GetVectorLength(); ++ii)
          {
            currentPM = MPV->Energy(ii);
            currentIN = (*MPV)[ii];
            currentCII =
              prevCII + 0.5 * (currentPM - prevPM) * (prevIN + currentIN);
 
            vector3->InsertValues(currentPM, currentCII);
 
            prevPM  = currentPM;
            prevCII = currentCII;
            prevIN  = currentIN;
          }
        }
      }
    }
    fIntegralTable1->insertAt(i, vector1);
    fIntegralTable2->insertAt(i, vector2);
    fIntegralTable3->insertAt(i, vector3);
  }
}

◆ DumpPhysicsTable()

void G4Scintillation::DumpPhysicsTable ( ) const

Definition at line 1068 of file G4Scintillation.cc.

{
  G4PhysicsOrderedFreeVector* v;
  if(fIntegralTable1)
  {
    for(size_t i = 0; i < fIntegralTable1->entries(); ++i)
    {
      v = (G4PhysicsOrderedFreeVector*) (*fIntegralTable1)[i];
      v->DumpValues();
    }
  }
  if(fIntegralTable2)
  {
    for(size_t i = 0; i < fIntegralTable2->entries(); ++i)
    {
      v = (G4PhysicsOrderedFreeVector*) (*fIntegralTable2)[i];
      v->DumpValues();
    }
  }
  if(fIntegralTable3)
  {
    for(size_t i = 0; i < fIntegralTable3->entries(); ++i)
    {
      v = (G4PhysicsOrderedFreeVector*) (*fIntegralTable3)[i];
      v->DumpValues();
    }
  }
}

◆ GetEnhancedTimeConstants()

G4bool G4Scintillation::GetEnhancedTimeConstants ( ) const

inline

Definition at line 357 of file G4Scintillation.hh.

{
  return fEnhancedTimeConstants;
}

◆ GetFastIntegralTable()

G4PhysicsTable * G4Scintillation::GetFastIntegralTable ( ) const

inline

Definition at line 315 of file G4Scintillation.hh.

{
  return fIntegralTable1;
}

◆ GetFiniteRiseTime()

G4bool G4Scintillation::GetFiniteRiseTime ( ) const

inline

Definition at line 283 of file G4Scintillation.hh.

{
  return fFiniteRiseTime;
}

◆ GetIntegralTable1()

G4PhysicsTable * G4Scintillation::GetIntegralTable1 ( ) const

inline

Definition at line 320 of file G4Scintillation.hh.

{
  return fIntegralTable1;
}

◆ GetIntegralTable2()

G4PhysicsTable * G4Scintillation::GetIntegralTable2 ( ) const

inline

Definition at line 325 of file G4Scintillation.hh.

{
  return fIntegralTable2;
}

◆ GetIntegralTable3()

G4PhysicsTable * G4Scintillation::GetIntegralTable3 ( ) const

inline

Definition at line 330 of file G4Scintillation.hh.

{
  return fIntegralTable3;
}

◆ GetMeanFreePath()

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

overridevirtual

Implements G4VRestDiscreteProcess.

Definition at line 703 of file G4Scintillation.cc.

{
  *condition = StronglyForced;
  return DBL_MAX;
}

◆ GetMeanLifeTime()

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

overridevirtual

Implements G4VRestDiscreteProcess.

Definition at line 711 of file G4Scintillation.cc.

{
  *condition = Forced;
  return DBL_MAX;
}

◆ GetNumPhotons()

G4int G4Scintillation::GetNumPhotons ( ) const

inline

Definition at line 379 of file G4Scintillation.hh.

379{ return fNumPhotons; }

◆ GetSaturation()

G4EmSaturation * G4Scintillation::GetSaturation ( ) const

inline

Definition at line 342 of file G4Scintillation.hh.

{
  return fEmSaturation;
}

◆ GetScintillationByParticleType()

G4bool G4Scintillation::GetScintillationByParticleType ( ) const

inline

Definition at line 347 of file G4Scintillation.hh.

{
  return fScintillationByParticleType;
}

◆ GetScintillationExcitationRatio()

G4double G4Scintillation::GetScintillationExcitationRatio ( ) const

inline

Definition at line 305 of file G4Scintillation.hh.

{
  return fExcitationRatio;
}

◆ GetScintillationTrackInfo()

G4bool G4Scintillation::GetScintillationTrackInfo ( ) const

inline

Definition at line 367 of file G4Scintillation.hh.

{
  return fScintillationTrackInfo;
}

◆ GetScintillationYieldByParticleType() [1/2]

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

Definition at line 741 of file G4Scintillation.cc.

{
  // Get the G4MaterialPropertyVector containing the scintillation
  // yield as a function of the energy deposited and particle type
 
  G4ParticleDefinition* pDef = aTrack.GetDynamicParticle()->GetDefinition();
  G4MaterialPropertyVector* scintVector = nullptr;
  G4MaterialPropertiesTable* MPT =
    aTrack.GetMaterial()->GetMaterialPropertiesTable();
 
  // Protons
  if(pDef == G4Proton::ProtonDefinition())
    scintVector = MPT->GetProperty(kPROTONSCINTILLATIONYIELD);
 
  // Deuterons
  else if(pDef == G4Deuteron::DeuteronDefinition())
    scintVector = MPT->GetProperty(kDEUTERONSCINTILLATIONYIELD);
 
  // Tritons
  else if(pDef == G4Triton::TritonDefinition())
    scintVector = MPT->GetProperty(kTRITONSCINTILLATIONYIELD);
 
  // Alphas
  else if(pDef == G4Alpha::AlphaDefinition())
    scintVector = MPT->GetProperty(kALPHASCINTILLATIONYIELD);
 
  // 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())
    scintVector = MPT->GetProperty(kIONSCINTILLATIONYIELD);
 
  // Electrons (must also
  else if(pDef == G4Electron::ElectronDefinition() ||
          pDef == G4Gamma::GammaDefinition())
    scintVector = MPT->GetProperty(kELECTRONSCINTILLATIONYIELD);
 
  // Default for particles not enumerated/listed above
  // includes gamma to account for shell-binding energy
  // attributed to gamma from standard photoelectric effect)
  else
    scintVector = MPT->GetProperty(kELECTRONSCINTILLATIONYIELD);
 
  // Throw an exception if no scintillation yield vector is found
  if(!scintVector)
  {
    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 <= scintVector->GetMaxEnergy())
  {
    G4double Yield1 = scintVector->Value(PreStepKineticEnergy);
    G4double Yield2 =
      scintVector->Value(PreStepKineticEnergy - StepEnergyDeposit);
    ScintillationYield = Yield1 - Yield2;
  }
  else
  {
    G4ExceptionDescription ed;
    ed << "\nG4Scintillation::GetScintillationYieldByParticleType(): Request\n"
       << "for scintillation light yield above the available energy range\n"
       << "specified 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);
 
    // Units: [# scintillation photons]
    ScintillationYield = scintVector->GetMaxValue() /
                         scintVector->GetMaxEnergy() * 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;
}

Referenced by PostStepDoIt().

◆ GetScintillationYieldByParticleType() [2/2]

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

Definition at line 872 of file G4Scintillation.cc.

{
  // new in 10.7, allow multiple time constants with ScintByParticleType
  // Get the G4MaterialPropertyVector containing the scintillation
  // yield as a function of the energy deposited and particle type
 
  G4ParticleDefinition* pDef = aTrack.GetDynamicParticle()->GetDefinition();
  G4MaterialPropertyVector* yieldVector = nullptr;
  G4MaterialPropertiesTable* MPT =
    aTrack.GetMaterial()->GetMaterialPropertiesTable();
 
  // Protons
  if(pDef == G4Proton::ProtonDefinition())
  {
    yieldVector = MPT->GetProperty(kPROTONSCINTILLATIONYIELD);
    yield1      = MPT->ConstPropertyExists(kPROTONSCINTILLATIONYIELD1)
               ? MPT->GetConstProperty(kPROTONSCINTILLATIONYIELD1)
               : 1.;
    yield2 = MPT->ConstPropertyExists(kPROTONSCINTILLATIONYIELD2)
               ? MPT->GetConstProperty(kPROTONSCINTILLATIONYIELD2)
               : 0.;
    yield3 = MPT->ConstPropertyExists(kPROTONSCINTILLATIONYIELD3)
               ? MPT->GetConstProperty(kPROTONSCINTILLATIONYIELD3)
               : 0.;
  }
 
  // Deuterons
  else if(pDef == G4Deuteron::DeuteronDefinition())
  {
    yieldVector = MPT->GetProperty(kDEUTERONSCINTILLATIONYIELD);
    yield1      = MPT->ConstPropertyExists(kDEUTERONSCINTILLATIONYIELD1)
               ? MPT->GetConstProperty(kDEUTERONSCINTILLATIONYIELD1)
               : 1.;
    yield2 = MPT->ConstPropertyExists(kDEUTERONSCINTILLATIONYIELD2)
               ? MPT->GetConstProperty(kDEUTERONSCINTILLATIONYIELD2)
               : 0.;
    yield3 = MPT->ConstPropertyExists(kDEUTERONSCINTILLATIONYIELD3)
               ? MPT->GetConstProperty(kDEUTERONSCINTILLATIONYIELD3)
               : 0.;
  }
 
  // Tritons
  else if(pDef == G4Triton::TritonDefinition())
  {
    yieldVector = MPT->GetProperty(kTRITONSCINTILLATIONYIELD);
    yield1      = MPT->ConstPropertyExists(kTRITONSCINTILLATIONYIELD1)
               ? MPT->GetConstProperty(kTRITONSCINTILLATIONYIELD1)
               : 1.;
    yield2 = MPT->ConstPropertyExists(kTRITONSCINTILLATIONYIELD2)
               ? MPT->GetConstProperty(kTRITONSCINTILLATIONYIELD2)
               : 0.;
    yield3 = MPT->ConstPropertyExists(kTRITONSCINTILLATIONYIELD3)
               ? MPT->GetConstProperty(kTRITONSCINTILLATIONYIELD3)
               : 0.;
  }
 
  // Alphas
  else if(pDef == G4Alpha::AlphaDefinition())
  {
    yieldVector = MPT->GetProperty(kALPHASCINTILLATIONYIELD);
    yield1      = MPT->ConstPropertyExists(kALPHASCINTILLATIONYIELD1)
               ? MPT->GetConstProperty(kALPHASCINTILLATIONYIELD1)
               : 1.;
    yield2 = MPT->ConstPropertyExists(kALPHASCINTILLATIONYIELD2)
               ? MPT->GetConstProperty(kALPHASCINTILLATIONYIELD2)
               : 0.;
    yield3 = MPT->ConstPropertyExists(kALPHASCINTILLATIONYIELD3)
               ? MPT->GetConstProperty(kALPHASCINTILLATIONYIELD3)
               : 0.;
  }
 
  // 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())
  {
    yieldVector = MPT->GetProperty(kIONSCINTILLATIONYIELD);
    yield1      = MPT->ConstPropertyExists(kIONSCINTILLATIONYIELD1)
               ? MPT->GetConstProperty(kIONSCINTILLATIONYIELD1)
               : 1.;
    yield2 = MPT->ConstPropertyExists(kIONSCINTILLATIONYIELD2)
               ? MPT->GetConstProperty(kIONSCINTILLATIONYIELD2)
               : 0.;
    yield3 = MPT->ConstPropertyExists(kIONSCINTILLATIONYIELD3)
               ? MPT->GetConstProperty(kIONSCINTILLATIONYIELD3)
               : 0.;
  }
 
  // Electrons (must also account for shell-binding energy
  // attributed to gamma from standard photoelectric effect)
  // and, default for particles not enumerated/listed above
  else
  {
    yieldVector = MPT->GetProperty(kELECTRONSCINTILLATIONYIELD);
    yield1      = MPT->ConstPropertyExists(kELECTRONSCINTILLATIONYIELD1)
               ? MPT->GetConstProperty(kELECTRONSCINTILLATIONYIELD1)
               : 1.;
    yield2 = MPT->ConstPropertyExists(kELECTRONSCINTILLATIONYIELD2)
               ? MPT->GetConstProperty(kELECTRONSCINTILLATIONYIELD2)
               : 0.;
    yield3 = MPT->ConstPropertyExists(kELECTRONSCINTILLATIONYIELD3)
               ? MPT->GetConstProperty(kELECTRONSCINTILLATIONYIELD3)
               : 0.;
  }
 
  // Throw an exception if no scintillation yield vector is found
  if(!yieldVector)
  {
    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 <= yieldVector->GetMaxEnergy())
  {
    // G4double Yield1 = yieldVector->Value(PreStepKineticEnergy);
    // G4double Yield2 = yieldVector->Value(PreStepKineticEnergy -
    // StepEnergyDeposit); ScintillationYield = Yield1 - Yield2;
    ScintillationYield =
      yieldVector->Value(PreStepKineticEnergy) -
      yieldVector->Value(PreStepKineticEnergy - StepEnergyDeposit);
  }
  else
  {
    G4ExceptionDescription ed;
    ed << "\nG4Scintillation::GetScintillationYieldByParticleType(): Request\n"
       << "for scintillation light yield above the available energy range\n"
       << "specified 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);
 
    // Units: [# scintillation photons]
    ScintillationYield = yieldVector->GetMaxValue() /
                         yieldVector->GetMaxEnergy() * 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;
}

◆ GetScintillationYieldFactor()

G4double G4Scintillation::GetScintillationYieldFactor ( ) const

inline

Definition at line 294 of file G4Scintillation.hh.

{
  return fYieldFactor;
}

◆ GetSlowIntegralTable()

G4PhysicsTable * G4Scintillation::GetSlowIntegralTable ( ) const

inline

Definition at line 310 of file G4Scintillation.hh.

{
  return fIntegralTable3;
}

◆ GetStackPhotons()

G4bool G4Scintillation::GetStackPhotons ( ) const

inline

Definition at line 377 of file G4Scintillation.hh.

377{ return fStackingFlag; }

◆ GetTrackSecondariesFirst()

G4bool G4Scintillation::GetTrackSecondariesFirst ( ) const

inline

Definition at line 273 of file G4Scintillation.hh.

{
  return fTrackSecondariesFirst;
}

◆ Initialise()

void G4Scintillation::Initialise ( )

Definition at line 138 of file G4Scintillation.cc.

{
  G4OpticalParameters* params = G4OpticalParameters::Instance();
  SetTrackSecondariesFirst(params->GetScintTrackSecondariesFirst());
  SetFiniteRiseTime(params->GetScintFiniteRiseTime());
  SetScintillationYieldFactor(params->GetScintYieldFactor());
  SetScintillationExcitationRatio(params->GetScintExcitationRatio());
  SetScintillationByParticleType(params->GetScintByParticleType());
  SetEnhancedTimeConstants(params->GetScintEnhancedTimeConstants());
  SetScintillationTrackInfo(params->GetScintTrackInfo());
  SetStackPhotons(params->GetScintStackPhotons());
  SetVerboseLevel(params->GetScintVerboseLevel());
}

Referenced by G4Scintillation(), and PreparePhysicsTable().

◆ IsApplicable()

G4bool G4Scintillation::IsApplicable ( const G4ParticleDefinition & aParticleType )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 124 of file G4Scintillation.cc.

{
  return (aParticleType.GetPDGCharge() == 0.0 || aParticleType.IsShortLived())
           ? false
           : true;
}

Referenced by LBE::ConstructOp(), and G4OpticalPhysics::ConstructProcess().

◆ PostStepDoIt()

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

overridevirtual

N_timeconstants != 1 and still scnt == 0

Reimplemented from G4VRestDiscreteProcess.

Definition at line 328 of file G4Scintillation.cc.

{
  aParticleChange.Initialize(aTrack);
  fNumPhotons = 0;
 
  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* MPT = aMaterial->GetMaterialPropertiesTable();
  if(!MPT)
    return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
 
  G4int N_timeconstants = 1;
 
  // only needed for old (two time constants) version
  G4MaterialPropertyVector* Fast_Intensity = nullptr;
  G4MaterialPropertyVector* Slow_Intensity = nullptr;
 
  if(fEnhancedTimeConstants)
  {
    if(MPT->GetProperty(kSCINTILLATIONCOMPONENT3))
      N_timeconstants = 3;
    else if(MPT->GetProperty(kSCINTILLATIONCOMPONENT2))
      N_timeconstants = 2;
    else if(!(MPT->GetProperty(kSCINTILLATIONCOMPONENT1)))
    {
      // no components were specified
      return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
    }
  }
  else
  {  // OLD METHOD
    Fast_Intensity = MPT->GetProperty(kFASTCOMPONENT);
    Slow_Intensity = MPT->GetProperty(kSLOWCOMPONENT);
    if(!Fast_Intensity && !Slow_Intensity)
      return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
    if(Fast_Intensity && Slow_Intensity)
      N_timeconstants = 2;
  }
 
  G4double ResolutionScale = MPT->GetConstProperty(kRESOLUTIONSCALE);
  G4double MeanNumberOfPhotons;
 
  G4double yield1     = 0.;
  G4double yield2     = 0.;
  G4double yield3     = 0.;
  G4double sum_yields = 0.;
 
  if(!fEnhancedTimeConstants)
  {
    // Scintillation depends on particle type, energy deposited
    if(fScintillationByParticleType)
    {
      MeanNumberOfPhotons = GetScintillationYieldByParticleType(aTrack, aStep);
    }
    else
    {
      // The default linear scintillation process
      // Units: [# scintillation photons / MeV]
      MeanNumberOfPhotons =
        MPT->GetConstProperty(kSCINTILLATIONYIELD) * fYieldFactor;
      // Birk's correction via fEmSaturation and specifying scintillation by
      // by particle type are physically mutually exclusive
      if(fEmSaturation)
        MeanNumberOfPhotons *=
          (fEmSaturation->VisibleEnergyDepositionAtAStep(&aStep));
      else
        MeanNumberOfPhotons *= TotalEnergyDeposit;
    }
  }
 
  else
  {
    if(fScintillationByParticleType)
    {
      MeanNumberOfPhotons = GetScintillationYieldByParticleType(
        aTrack, aStep, yield1, yield2, yield3);
    }
    else
    {
      yield1 = MPT->ConstPropertyExists(kSCINTILLATIONYIELD1)
                 ? MPT->GetConstProperty(kSCINTILLATIONYIELD1)
                 : 1.;
      yield2 = MPT->ConstPropertyExists(kSCINTILLATIONYIELD2)
                 ? MPT->GetConstProperty(kSCINTILLATIONYIELD2)
                 : 0.;
      yield3 = MPT->ConstPropertyExists(kSCINTILLATIONYIELD3)
                 ? MPT->GetConstProperty(kSCINTILLATIONYIELD3)
                 : 0.;
      // The default linear scintillation process
      // Units: [# scintillation photons / MeV]
      MeanNumberOfPhotons =
        MPT->GetConstProperty(kSCINTILLATIONYIELD) * fYieldFactor;
      // Birk's correction via fEmSaturation and specifying scintillation by
      // by particle type are physically mutually exclusive
      if(fEmSaturation)
        MeanNumberOfPhotons *=
          (fEmSaturation->VisibleEnergyDepositionAtAStep(&aStep));
      else
        MeanNumberOfPhotons *= TotalEnergyDeposit;
    }
    sum_yields = yield1 + yield2 + yield3;
  }
 
  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
  size_t numPhot                            = fNumPhotons;
  G4double scintTime                        = 0.;
  G4double riseTime                         = 0.;
  G4PhysicsOrderedFreeVector* scintIntegral = nullptr;
  G4ScintillationType scintType             = Slow;
 
  for(G4int scnt = 0; scnt < N_timeconstants; ++scnt)
  {
    // Original method with FAST and SLOW
    if(!fEnhancedTimeConstants)
    {
      if(scnt == 0)
      {
        if(N_timeconstants == 1)
        {
          if(Fast_Intensity)
          {
            scintTime = MPT->GetConstProperty(kFASTTIMECONSTANT);
            if(fFiniteRiseTime)
            {
              riseTime = MPT->GetConstProperty(kFASTSCINTILLATIONRISETIME);
            }
            scintType = Fast;
            scintIntegral =
              (G4PhysicsOrderedFreeVector*) ((*fIntegralTable1)(materialIndex));
          }
          if(Slow_Intensity)
          {
            scintTime = MPT->GetConstProperty(kSLOWTIMECONSTANT);
            if(fFiniteRiseTime)
            {
              riseTime = MPT->GetConstProperty(kSLOWSCINTILLATIONRISETIME);
            }
            scintType = Slow;
            scintIntegral =
              (G4PhysicsOrderedFreeVector*) ((*fIntegralTable3)(materialIndex));
          }
        }
        else
        {  /// N_timeconstants != 1  and still scnt == 0
          G4double yieldRatio = MPT->GetConstProperty(kYIELDRATIO);
          if(fExcitationRatio == 1.0 || fExcitationRatio == 0.0)
          {
            numPhot = G4int(std::min(yieldRatio, 1.0) * fNumPhotons);
          }
          else
          {
            numPhot = G4int(std::min(fExcitationRatio, 1.0) * fNumPhotons);
          }
          scintTime = MPT->GetConstProperty(kFASTTIMECONSTANT);
          if(fFiniteRiseTime)
          {
            riseTime = MPT->GetConstProperty(kFASTSCINTILLATIONRISETIME);
          }
          scintType = Fast;
          scintIntegral =
            (G4PhysicsOrderedFreeVector*) ((*fIntegralTable1)(materialIndex));
        }
      }
      else
      {  // scnt != 0
        numPhot   = fNumPhotons - numPhot;
        scintTime = MPT->GetConstProperty(kSLOWTIMECONSTANT);
        if(fFiniteRiseTime)
        {
          riseTime = MPT->GetConstProperty(kSLOWSCINTILLATIONRISETIME);
        }
        scintType = Slow;
        scintIntegral =
          (G4PhysicsOrderedFreeVector*) ((*fIntegralTable3)(materialIndex));
      }
    }
    else
    {  // fEnhancedTimeConstants == true
      // in the new method, if there is 1 time constant it is #1, etc.
      // Note: fExcitationRatio is not used
      if(scnt == 0)
      {
        if(N_timeconstants == 1)
        {
          numPhot = fNumPhotons;
        }
        else
        {
          numPhot = yield1 / sum_yields * fNumPhotons;
        }
        scintTime = MPT->GetConstProperty(kSCINTILLATIONTIMECONSTANT1);
        if(fFiniteRiseTime)
        {
          riseTime = MPT->GetConstProperty(kSCINTILLATIONRISETIME1);
        }
        scintType = Fast;
        scintIntegral =
          (G4PhysicsOrderedFreeVector*) ((*fIntegralTable1)(materialIndex));
      }
      else if(scnt == 1)
      {
        // to be consistent with old version (due to double->int conversion)
        if(N_timeconstants == 2)
        {
          numPhot = fNumPhotons - numPhot;
        }
        else
        {
          numPhot = yield2 / sum_yields * fNumPhotons;
        }
        scintTime = MPT->GetConstProperty(kSCINTILLATIONTIMECONSTANT2);
        if(fFiniteRiseTime)
        {
          riseTime = MPT->GetConstProperty(kSCINTILLATIONRISETIME2);
        }
        scintType = Medium;
        scintIntegral =
          (G4PhysicsOrderedFreeVector*) ((*fIntegralTable2)(materialIndex));
      }
      else if(scnt == 2)
      {
        numPhot   = yield3 / sum_yields * fNumPhotons;
        scintTime = MPT->GetConstProperty(kSCINTILLATIONTIMECONSTANT3);
        if(fFiniteRiseTime)
        {
          riseTime = MPT->GetConstProperty(kSCINTILLATIONRISETIME3);
        }
        scintType = Slow;
        scintIntegral =
          (G4PhysicsOrderedFreeVector*) ((*fIntegralTable3)(materialIndex));
      }
    }
 
    if(!scintIntegral)
      continue;
 
    G4double CIImax = scintIntegral->GetMaxValue();
    for(size_t i = 0; i < numPhot; ++i)
    {
      // Determine photon energy
      G4double CIIvalue      = G4UniformRand() * CIImax;
      G4double sampledEnergy = scintIntegral->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);
      G4ParticleMomentum photonMomentum(sint * cosp, sint * sinp, cost);
 
      // Determine polarization of new photon
      G4ThreeVector photonPolarization(cost * cosp, cost * sinp, -sint);
      G4ThreeVector perp = photonMomentum.cross(photonPolarization);
      phi                = twopi * G4UniformRand();
      sinp               = std::sin(phi);
      cosp               = std::cos(phi);
      photonPolarization = (cosp * photonPolarization + sinp * perp).unit();
 
      // Generate a new photon:
      G4DynamicParticle* scintPhoton =
        new G4DynamicParticle(opticalphoton, photonMomentum);
      scintPhoton->SetPolarization(photonPolarization);
      scintPhoton->SetKineticEnergy(sampledEnergy);
 
      // Generate new G4Track object:
      G4double rand = G4UniformRand();
      if(aParticle->GetDefinition()->GetPDGCharge() == 0)
      {
        rand = 1.0;
      }
 
      // emission time distribution
      G4double delta = rand * aStep.GetStepLength();
      G4double deltaTime =
        delta /
        (pPreStepPoint->GetVelocity() +
         rand * (pPostStepPoint->GetVelocity() - pPreStepPoint->GetVelocity()) /
           2.);
      if(riseTime == 0.0)
      {
        deltaTime -= scintTime * std::log(G4UniformRand());
      }
      else
      {
        deltaTime += sample_time(riseTime, scintTime);
      }
 
      G4double secTime          = t0 + deltaTime;
      G4ThreeVector secPosition = x0 + rand * aStep.GetDeltaPosition();
 
      G4Track* secTrack = new G4Track(scintPhoton, secTime, secPosition);
      secTrack->SetTouchableHandle(
        aStep.GetPreStepPoint()->GetTouchableHandle());
      secTrack->SetParentID(aTrack.GetTrackID());
      if(fScintillationTrackInfo)
        secTrack->SetUserInformation(
          new G4ScintillationTrackInformation(scintType));
      aParticleChange.AddSecondary(secTrack);
    }
  }
 
  if(verboseLevel > 1)
  {
    G4cout << "\n Exiting from G4Scintillation::DoIt -- NumberOfSecondaries = "
           << aParticleChange.GetNumberOfSecondaries() << G4endl;
  }
 
  return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
}

Referenced by AtRestDoIt().

◆ PreparePhysicsTable()

void G4Scintillation::PreparePhysicsTable ( const G4ParticleDefinition & part )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 132 of file G4Scintillation.cc.

{
  Initialise();
}

◆ RemoveSaturation()

void G4Scintillation::RemoveSaturation ( )

inline

Definition at line 340 of file G4Scintillation.hh.

340{ fEmSaturation = nullptr; }

Referenced by SetScintillationByParticleType().

◆ SetEnhancedTimeConstants()

void G4Scintillation::SetEnhancedTimeConstants ( G4bool val )

inline

Definition at line 352 of file G4Scintillation.hh.

{
  fEnhancedTimeConstants = val;
}

Referenced by Initialise().

◆ SetFiniteRiseTime()

void G4Scintillation::SetFiniteRiseTime ( const G4bool state )

inline

Definition at line 278 of file G4Scintillation.hh.

{
  fFiniteRiseTime = state;
}

Referenced by Initialise().

◆ SetScintillationByParticleType()

void G4Scintillation::SetScintillationByParticleType ( const G4bool scintType )

Definition at line 689 of file G4Scintillation.cc.

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

Referenced by Initialise().

◆ SetScintillationExcitationRatio()

void G4Scintillation::SetScintillationExcitationRatio ( const G4double ratio )

inline

Definition at line 299 of file G4Scintillation.hh.

{
  fExcitationRatio = ratio;
}

Referenced by LBE::ConstructOp(), and Initialise().

◆ SetScintillationTrackInfo()

void G4Scintillation::SetScintillationTrackInfo ( const G4bool trackType )

inline

Definition at line 362 of file G4Scintillation.hh.

{
  fScintillationTrackInfo = trackType;
}

Referenced by Initialise().

◆ SetScintillationYieldFactor()

void G4Scintillation::SetScintillationYieldFactor ( const G4double yieldfactor )

inline

Definition at line 288 of file G4Scintillation.hh.

{
  fYieldFactor = yieldfactor;
}

Referenced by LBE::ConstructOp(), and Initialise().

◆ SetStackPhotons()

void G4Scintillation::SetStackPhotons ( const G4bool stackingFlag )

inline

Definition at line 372 of file G4Scintillation.hh.

{
  fStackingFlag = stackingFlag;
}

Referenced by Initialise().

◆ SetTrackSecondariesFirst()

void G4Scintillation::SetTrackSecondariesFirst ( const G4bool state )

inline

Definition at line 268 of file G4Scintillation.hh.

{
  fTrackSecondariesFirst = state;
}

Referenced by LBE::ConstructOp(), and Initialise().

Member Data Documentation

◆ fIntegralTable1

G4PhysicsTable* G4Scintillation::fIntegralTable1

protected

Definition at line 234 of file G4Scintillation.hh.

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

◆ fIntegralTable2

G4PhysicsTable* G4Scintillation::fIntegralTable2

protected

Definition at line 235 of file G4Scintillation.hh.

Referenced by BuildPhysicsTable(), DumpPhysicsTable(), GetIntegralTable2(), PostStepDoIt(), and ~G4Scintillation().

◆ fIntegralTable3

G4PhysicsTable* G4Scintillation::fIntegralTable3

protected

Definition at line 236 of file G4Scintillation.hh.

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

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

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Scintillation()

◆ ~G4Scintillation()

Member Function Documentation

◆ AddSaturation()

◆ AtRestDoIt()

◆ BuildPhysicsTable()

◆ DumpPhysicsTable()

◆ GetEnhancedTimeConstants()

◆ GetFastIntegralTable()

◆ GetFiniteRiseTime()

◆ GetIntegralTable1()

◆ GetIntegralTable2()

◆ GetIntegralTable3()

◆ GetMeanFreePath()

◆ GetMeanLifeTime()

◆ GetNumPhotons()

◆ GetSaturation()

◆ GetScintillationByParticleType()

◆ GetScintillationExcitationRatio()

◆ GetScintillationTrackInfo()

◆ GetScintillationYieldByParticleType() [1/2]

◆ GetScintillationYieldByParticleType() [2/2]

◆ GetScintillationYieldFactor()

◆ GetSlowIntegralTable()

◆ GetStackPhotons()

◆ GetTrackSecondariesFirst()

◆ Initialise()

◆ IsApplicable()

◆ PostStepDoIt()

◆ PreparePhysicsTable()

◆ RemoveSaturation()

◆ SetEnhancedTimeConstants()

◆ SetFiniteRiseTime()

◆ SetScintillationByParticleType()

◆ SetScintillationExcitationRatio()

◆ SetScintillationTrackInfo()

◆ SetScintillationYieldFactor()

◆ SetStackPhotons()

◆ SetTrackSecondariesFirst()

Member Data Documentation

◆ fIntegralTable1

◆ fIntegralTable2

◆ fIntegralTable3