#include <G4Scintillation.hh>

Inheritance diagram for G4Scintillation:

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

	~G4Scintillation ()

G4bool	IsApplicable (const G4ParticleDefinition &aParticleType)

void	BuildPhysicsTable (const G4ParticleDefinition &aParticleType)

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

G4double	GetMeanLifeTime (const G4Track &aTrack, G4ForceCondition *)

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

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

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

G4bool	GetTrackSecondariesFirst () const

G4bool	GetFiniteRiseTime () const

G4double	GetScintillationYieldFactor () const

G4double	GetScintillationExcitationRatio () const

G4PhysicsTable *	GetFastIntegralTable () const

G4PhysicsTable *	GetSlowIntegralTable () const

G4EmSaturation *	GetSaturation () const

G4bool	GetScintillationByParticleType () const

void	DumpPhysicsTable () const

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

	G4VRestDiscreteProcess (G4VRestDiscreteProcess &)

virtual	~G4VRestDiscreteProcess ()

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

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

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

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

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

G4int	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

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

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

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

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

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

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

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

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

virtual void	DumpInfo () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Static Public Member Functions
static void	SetTrackSecondariesFirst (const G4bool state)

static void	SetFiniteRiseTime (const G4bool state)

static void	SetScintillationYieldFactor (const G4double yieldfactor)

static void	SetScintillationExcitationRatio (const G4double ratio)

static void	AddSaturation (G4EmSaturation *)

static void	RemoveSaturation ()

static void	SetScintillationByParticleType (const G4bool)

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

Protected Member Functions
void	BuildThePhysicsTable ()

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

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 88 of file G4Scintillation.hh.

Constructor & Destructor Documentation

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

Definition at line 108 of file G4Scintillation.cc.

References fFastIntegralTable, fScintillation, fSlowIntegralTable, G4cout, G4endl, G4VProcess::GetProcessName(), G4VProcess::SetProcessSubType(), and G4VProcess::verboseLevel.

                   : G4VRestDiscreteProcess(processName, type)
 {
         SetProcessSubType(fScintillation);
 
 #ifdef G4DEBUG_SCINTILLATION
     ScintTrackEDep = 0.;
     ScintTrackYield = 0.;
 #endif
 
         fFastIntegralTable = NULL;
         fSlowIntegralTable = NULL;
 
         if (verboseLevel>0) {
            G4cout << GetProcessName() << " is created " << G4endl;
         }
 }

G4Scintillation::~G4Scintillation ( )

Definition at line 131 of file G4Scintillation.cc.

References G4PhysicsTable::clearAndDestroy(), fFastIntegralTable, and fSlowIntegralTable.

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

Member Function Documentation

void G4Scintillation::AddSaturation ( G4EmSaturation * sat )

static

Definition at line 658 of file G4Scintillation.cc.

Referenced by G4OpticalPhysics::AddScintillationSaturation(), OpNovicePhysicsList::ConstructOp(), WLSOpticalPhysics::ConstructProcess(), and G4OpticalPhysics::ConstructProcess().

 {
         fEmSaturation = sat;
 }

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

virtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 157 of file G4Scintillation.cc.

References PostStepDoIt().

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

void G4Scintillation::BuildPhysicsTable ( const G4ParticleDefinition & aParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 147 of file G4Scintillation.cc.

References BuildThePhysicsTable(), fFastIntegralTable, and fSlowIntegralTable.

 {
    if (!fFastIntegralTable || !fSlowIntegralTable) BuildThePhysicsTable();
 }

void G4Scintillation::BuildThePhysicsTable ( )

protected

Definition at line 473 of file G4Scintillation.cc.

References G4PhysicsVector::Energy(), fFastIntegralTable, fSlowIntegralTable, G4Material::GetMaterialPropertiesTable(), G4Material::GetMaterialTable(), G4Material::GetNumberOfMaterials(), G4MaterialPropertiesTable::GetProperty(), G4PhysicsVector::GetVectorLength(), and G4PhysicsTable::insertAt().

Referenced by BuildPhysicsTable().

 {
         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);
 
         }
 }

void G4Scintillation::DumpPhysicsTable ( ) const

inline

Definition at line 301 of file G4Scintillation.hh.

References G4PhysicsOrderedFreeVector::DumpValues(), G4PhysicsTable::entries(), fFastIntegralTable, fSlowIntegralTable, and test::v.

 {
         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();
            }
          }
 }

G4PhysicsTable * G4Scintillation::GetFastIntegralTable ( ) const

inline

Definition at line 295 of file G4Scintillation.hh.

References fFastIntegralTable.

 {
         return fFastIntegralTable;
 }

G4bool G4Scintillation::GetFiniteRiseTime ( ) const

inline

Definition at line 271 of file G4Scintillation.hh.

 {
         return fFiniteRiseTime;
 }

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

virtual

Implements G4VRestDiscreteProcess.

Definition at line 672 of file G4Scintillation.cc.

References DBL_MAX, and StronglyForced.

 {
         *condition = StronglyForced;
 
         return DBL_MAX;
 
 }

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

virtual

Implements G4VRestDiscreteProcess.

Definition at line 686 of file G4Scintillation.cc.

References DBL_MAX, and Forced.

 {
         *condition = Forced;
 
         return DBL_MAX;
 
 }

G4EmSaturation* G4Scintillation::GetSaturation ( ) const

inline

Definition at line 198 of file G4Scintillation.hh.

198 { return fEmSaturation; }

G4bool G4Scintillation::GetScintillationByParticleType ( ) const

inline

Definition at line 205 of file G4Scintillation.hh.

206 { return fScintillationByParticleType; }

G4double G4Scintillation::GetScintillationExcitationRatio ( ) const

inline

Definition at line 283 of file G4Scintillation.hh.

 {
         return fExcitationRatio;
 }

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

Definition at line 717 of file G4Scintillation.cc.

References G4Alpha::AlphaDefinition(), G4Deuteron::DeuteronDefinition(), G4Electron::ElectronDefinition(), FatalException, fGeomBoundary, fStopButAlive, G4cout, G4endl, G4Exception(), G4Gamma::GammaDefinition(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4StepPoint::GetKineticEnergy(), G4Track::GetKineticEnergy(), G4Track::GetMaterial(), G4Material::GetMaterialPropertiesTable(), G4PhysicsVector::GetMaxEnergy(), G4PhysicsOrderedFreeVector::GetMaxValue(), G4Track::GetParentID(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4StepPoint::GetStepStatus(), G4Step::GetTotalEnergyDeposit(), G4Track::GetTrackID(), G4Track::GetTrackStatus(), G4Track::GetVertexKineticEnergy(), JustWarning, python.hepunit::MeV, G4Neutron::NeutronDefinition(), G4Proton::ProtonDefinition(), G4Triton::TritonDefinition(), and G4PhysicsVector::Value().

Referenced by PostStepDoIt().

 {
   ////////////////////////////////////////
   // Get the scintillation yield vector //
   ////////////////////////////////////////
 
   G4ParticleDefinition *pDef = aTrack.GetDynamicParticle()->GetDefinition();
 
   G4MaterialPropertyVector *Scint_Yield_Vector = NULL;
 
   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;
 }

G4double G4Scintillation::GetScintillationYieldFactor ( ) const

inline

Definition at line 277 of file G4Scintillation.hh.

 {
         return fYieldFactor;
 }

G4PhysicsTable * G4Scintillation::GetSlowIntegralTable ( ) const

inline

Definition at line 289 of file G4Scintillation.hh.

References fSlowIntegralTable.

 {
         return fSlowIntegralTable;
 }

G4bool G4Scintillation::GetTrackSecondariesFirst ( ) const

inline

Definition at line 265 of file G4Scintillation.hh.

 {
         return fTrackSecondariesFirst;
 }

G4bool G4Scintillation::IsApplicable ( const G4ParticleDefinition & aParticleType )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 256 of file G4Scintillation.hh.

References G4ParticleDefinition::GetParticleName(), and G4ParticleDefinition::IsShortLived().

Referenced by OpNovicePhysicsList::ConstructOp(), DMXPhysicsList::ConstructOp(), F04OpticalPhysics::ConstructProcess(), WLSOpticalPhysics::ConstructProcess(), and G4OpticalPhysics::ConstructProcess().

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

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

virtual

Reimplemented from G4VRestDiscreteProcess.

Definition at line 170 of file G4Scintillation.cc.

References G4ParticleChange::AddSecondary(), G4VProcess::aParticleChange, CLHEP::Hep3Vector::cross(), fAlive, fFastIntegralTable, fSlowIntegralTable, fSuspend, G4cout, G4endl, G4Poisson(), G4UniformRand, G4DynamicParticle::GetDefinition(), G4Step::GetDeltaPosition(), G4Track::GetDynamicParticle(), G4PhysicsOrderedFreeVector::GetEnergy(), G4StepPoint::GetGlobalTime(), G4Material::GetIndex(), G4Track::GetMaterial(), G4Material::GetMaterialPropertiesTable(), G4PhysicsOrderedFreeVector::GetMaxValue(), G4VParticleChange::GetNumberOfSecondaries(), G4ParticleDefinition::GetPDGCharge(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4MaterialPropertiesTable::GetProperty(), GetScintillationYieldByParticleType(), G4Step::GetStepLength(), G4Step::GetTotalEnergyDeposit(), G4StepPoint::GetTouchableHandle(), G4Track::GetTrackID(), G4Track::GetTrackStatus(), G4StepPoint::GetVelocity(), G4ParticleChange::Initialize(), G4INCL::Math::min(), ns, G4OpticalPhoton::OpticalPhoton(), G4VRestDiscreteProcess::PostStepDoIt(), G4VParticleChange::ProposeTrackStatus(), G4DynamicParticle::SetKineticEnergy(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetParentID(), G4DynamicParticle::SetPolarization(), G4Track::SetTouchableHandle(), G4INCL::DeJongSpin::shoot(), python.hepunit::twopi, CLHEP::Hep3Vector::unit(), G4VProcess::verboseLevel, G4EmSaturation::VisibleEnergyDeposition(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by AtRestDoIt().

 {
         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->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*)
                                        ((*fFastIntegralTable)(materialIndex));
                  }
                  if (Slow_Intensity) {
                    ScintillationTime   = aMaterialPropertiesTable->
                                            GetConstProperty("SLOWTIMECONSTANT");
                    if (fFiniteRiseTime) {
                       ScintillationRiseTime = aMaterialPropertiesTable->
                                   GetConstProperty("SLOWSCINTILLATIONRISETIME");
                    }
                    ScintillationIntegral =
                    (G4PhysicsOrderedFreeVector*)
                                        ((*fSlowIntegralTable)(materialIndex));
                  }
                }
                else {
                  G4double yieldRatio = aMaterialPropertiesTable->
                                           GetConstProperty("YIELDRATIO");
                  if ( fExcitationRatio == 1.0 || fExcitationRatio == 0.0) {
                     Num = G4int (std::min(yieldRatio,1.0) * NumPhotons);
                  }
                  else {
                     Num = G4int (std::min(fExcitationRatio,1.0) * NumPhotons);
                  }
                  ScintillationTime   = aMaterialPropertiesTable->
                                           GetConstProperty("FASTTIMECONSTANT");
                  if (fFiniteRiseTime) {
                       ScintillationRiseTime = aMaterialPropertiesTable->
                                  GetConstProperty("FASTSCINTILLATIONRISETIME");
                  }
                  ScintillationIntegral =
                  (G4PhysicsOrderedFreeVector*)
                                       ((*fFastIntegralTable)(materialIndex));
                }
             }
             else {
                Num = NumPhotons - Num;
                ScintillationTime   =   aMaterialPropertiesTable->
                                           GetConstProperty("SLOWTIMECONSTANT");
                if (fFiniteRiseTime) {
                     ScintillationRiseTime = aMaterialPropertiesTable->
                                  GetConstProperty("SLOWSCINTILLATIONRISETIME");
                }
                ScintillationIntegral =
                (G4PhysicsOrderedFreeVector*)
                                       ((*fSlowIntegralTable)(materialIndex));
             }
 
             if (!ScintillationIntegral) continue;
 
             // Max Scintillation Integral
  
             G4double CIImax = ScintillationIntegral->GetMaxValue();
 
             for (G4int i = 0; i < Num; i++) {
 
                 // Determine photon energy
 
                 G4double CIIvalue = G4UniformRand()*CIImax;
                 G4double sampledEnergy =
                               ScintillationIntegral->GetEnergy(CIIvalue);
 
                 if (verboseLevel>1) {
                    G4cout << "sampledEnergy = " << sampledEnergy << G4endl;
                    G4cout << "CIIvalue =        " << CIIvalue << G4endl;
                 }
 
                 // Generate random photon direction
 
                 G4double cost = 1. - 2.*G4UniformRand();
                 G4double sint = std::sqrt((1.-cost)*(1.+cost));
 
                 G4double phi = twopi*G4UniformRand();
                 G4double sinp = std::sin(phi);
                 G4double cosp = std::cos(phi);
 
                 G4double px = sint*cosp;
                 G4double py = sint*sinp;
                 G4double pz = cost;
 
                 // Create photon momentum direction vector
 
                 G4ParticleMomentum photonMomentum(px, py, pz);
 
                 // Determine polarization of new photon
 
                 G4double sx = cost*cosp;
                 G4double sy = cost*sinp;
                 G4double sz = -sint;
 
                 G4ThreeVector photonPolarization(sx, sy, sz);
 
                 G4ThreeVector perp = photonMomentum.cross(photonPolarization);
 
                 phi = twopi*G4UniformRand();
                 sinp = std::sin(phi);
                 cosp = std::cos(phi);
 
                 photonPolarization = cosp * photonPolarization + sinp * perp;
 
                 photonPolarization = photonPolarization.unit();
 
                 // Generate a new photon:
 
                 G4DynamicParticle* aScintillationPhoton =
                   new G4DynamicParticle(G4OpticalPhoton::OpticalPhoton(),
                                                          photonMomentum);
                 aScintillationPhoton->SetPolarization
                                      (photonPolarization.x(),
                                       photonPolarization.y(),
                                       photonPolarization.z());
 
                 aScintillationPhoton->SetKineticEnergy(sampledEnergy);
 
                 // Generate new G4Track object:
 
                 G4double rand;
 
                 if (aParticle->GetDefinition()->GetPDGCharge() != 0) {
                    rand = G4UniformRand();
                 } else {
                    rand = 1.0;
                 }
 
                 G4double delta = rand * aStep.GetStepLength();
         G4double deltaTime = delta /
                        ((pPreStepPoint->GetVelocity()+
                          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);
 }

void G4Scintillation::RemoveSaturation ( )

static

Definition at line 663 of file G4Scintillation.cc.

Referenced by SetScintillationByParticleType().

 {
         fEmSaturation = NULL;
 }

void G4Scintillation::SetFiniteRiseTime ( const G4bool state )

static

Definition at line 631 of file G4Scintillation.cc.

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

 {
         fFiniteRiseTime = state;
 }

void G4Scintillation::SetScintillationByParticleType ( const G4bool scintType )

static

Definition at line 648 of file G4Scintillation.cc.

References G4Exception(), JustWarning, and RemoveSaturation().

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

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

void G4Scintillation::SetScintillationExcitationRatio ( const G4double ratio )

static

Definition at line 641 of file G4Scintillation.cc.

Referenced by DMXPhysicsList::ConstructOp(), F04OpticalPhysics::ConstructProcess(), WLSOpticalPhysics::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), and G4OpticalPhysics::SetScintillationExcitationRatio().

                                                                                     {
         fExcitationRatio = excitationratio;
 }

void G4Scintillation::SetScintillationYieldFactor ( const G4double yieldfactor )

static

Definition at line 636 of file G4Scintillation.cc.

Referenced by DMXPhysicsList::ConstructOp(), F04OpticalPhysics::ConstructProcess(), WLSOpticalPhysics::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), OpNovicePhysicsList::OpNovicePhysicsList(), and G4OpticalPhysics::SetScintillationYieldFactor().

 {
         fYieldFactor = yieldfactor;
 }

void G4Scintillation::SetTrackSecondariesFirst ( const G4bool state )

static

Definition at line 626 of file G4Scintillation.cc.

Referenced by DMXPhysicsList::ConstructOp(), F04OpticalPhysics::ConstructProcess(), WLSOpticalPhysics::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), OpNovicePhysicsList::OpNovicePhysicsList(), and G4OpticalPhysics::SetTrackSecondariesFirst().

 {
         fTrackSecondariesFirst = state;
 }

Field Documentation

G4PhysicsTable* G4Scintillation::fFastIntegralTable

protected

Definition at line 223 of file G4Scintillation.hh.

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

G4PhysicsTable* G4Scintillation::fSlowIntegralTable

protected

Definition at line 224 of file G4Scintillation.hh.

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

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

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

Static Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation