G4hMultipleScattering Class Reference

#include <G4hMultipleScattering.hh>

Inheritance diagram for G4hMultipleScattering:

Public Member Functions
void	AddEmModel (G4int order, G4VEmModel *, const G4Region *region=nullptr)
G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &) override
G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4double currentMinimalStep, G4double &currentSafety, G4GPILSelection *selection) override
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
void	BuildPhysicsTable (const G4ParticleDefinition &) override
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
G4double	ContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimalStep, G4double &currentSafety)
virtual void	DumpInfo () const
G4VMscModel *	EmModel (size_t index=0) const
virtual void	EndTracking ()
const G4ParticleDefinition *	FirstParticle () const
	G4hMultipleScattering (const G4hMultipleScattering &)=delete
	G4hMultipleScattering (const G4String &processName="msc")
G4double	GeomFactor () const
G4double	GetCurrentInteractionLength () const
const G4VProcess *	GetMasterProcess () const
G4VMscModel *	GetModelByIndex (G4int idx=0, G4bool ver=false) const
G4double	GetNumberOfInteractionLengthLeft () const
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
G4double	GetPILfactor () const
virtual const G4ProcessManager *	GetProcessManager ()
const G4String &	GetProcessName () const
G4int	GetProcessSubType () const
G4ProcessType	GetProcessType () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4int	GetVerboseLevel () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	IsApplicable (const G4ParticleDefinition &p) final
G4bool	isAtRestDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
G4bool	LateralDisplasmentFlag () const
G4double	LowestKinEnergy () const
G4int	NumberOfModels () const
G4bool	operator!= (const G4VProcess &right) const
G4hMultipleScattering &	operator= (const G4hMultipleScattering &right)=delete
G4bool	operator== (const G4VProcess &right) const
G4double	PolarAngleLimit () const
G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &) override
G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4ForceCondition *condition) override
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
void	PreparePhysicsTable (const G4ParticleDefinition &) override
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)
void	ProcessDescription (std::ostream &) const override
G4double	RangeFactor () const
virtual void	ResetNumberOfInteractionLengthLeft ()
G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii) override
G4VEmModel *	SelectModel (G4double kinEnergy, size_t idx)
void	SetEmModel (G4VMscModel *, G4int idx=0)
void	SetIonisation (G4VEnergyLossProcess *)
void	SetLowestKinEnergy (G4double val)
virtual void	SetMasterProcess (G4VProcess *masterP)
void	SetPILfactor (G4double value)
virtual void	SetProcessManager (const G4ProcessManager *)
void	SetProcessSubType (G4int)
void	SetProcessType (G4ProcessType)
void	SetStepLimitType (G4MscStepLimitType val)
void	SetVerboseLevel (G4int value)
G4double	Skin () const
void	StartTracking (G4Track *) override
G4MscStepLimitType	StepLimitType () const
G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false) override
G4bool	UseBaseMaterial () const
	~G4hMultipleScattering () override

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

Protected Member Functions
void	ClearNumberOfInteractionLengthLeft ()
G4double	GetContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimalStep, G4double &currentSafety) override
G4GPILSelection	GetGPILSelection () const
G4double	GetMeanFreePath (const G4Track &track, G4double, G4ForceCondition *condition) override
void	InitialiseProcess (const G4ParticleDefinition *) override
void	SetGPILSelection (G4GPILSelection selection)
void	StreamProcessInfo (std::ostream &outFile) const override
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Protected Attributes
G4ParticleChange	aParticleChange
const G4ProcessManager *	aProcessManager = nullptr
G4double	currentInteractionLength = -1.0
G4bool	enableAlongStepDoIt = true
G4bool	enableAtRestDoIt = true
G4bool	enablePostStepDoIt = true
G4ParticleChangeForMSC	fParticleChange
G4VParticleChange *	pParticleChange = nullptr
G4double	theInitialNumberOfInteractionLength = -1.0
G4double	theNumberOfInteractionLengthLeft = -1.0
G4String	thePhysicsTableFileName
G4double	thePILfactor = 1.0
G4String	theProcessName
G4int	theProcessSubType = -1
G4ProcessType	theProcessType = fNotDefined
G4int	verboseLevel = 0

Private Member Functions
void	StreamInfo (std::ostream &outFile, const G4ParticleDefinition &, G4bool rst=false) const

Private Attributes
G4bool	baseMat = false
G4VMscModel *	currentModel = nullptr
const G4ParticleDefinition *	currParticle = nullptr
G4LossTableManager *	emManager
G4double	facrange = 0.04
G4VEnergyLossProcess *	fIonisation = nullptr
const G4ParticleDefinition *	firstParticle = nullptr
G4ThreeVector	fNewDirection
G4ThreeVector	fNewPosition
G4bool	fPositionChanged = false
G4ProcessTable *	fProcessTable = nullptr
G4double	geomMin
G4double	gPathLength = 0.0
G4bool	isActive = false
G4bool	isInitialized
G4bool	isIon = false
G4bool	latDisplacement = true
G4double	lowestKinEnergy
G4VProcess *	masterProcessShadow = nullptr
G4double	minDisplacement2
G4EmModelManager *	modelManager
std::vector< G4VMscModel * >	mscModels
G4int	numberOfModels = 0
G4double	physStepLimit = 0.0
G4SafetyHelper *	safetyHelper = nullptr
G4MscStepLimitType	stepLimit = fUseSafety
G4EmParameters *	theParameters
G4double	tPathLength = 0.0
G4GPILSelection	valueGPILSelection = CandidateForSelection

Detailed Description

Definition at line 61 of file G4hMultipleScattering.hh.

Constructor & Destructor Documentation

G4hMultipleScattering() [1/2]

G4hMultipleScattering::G4hMultipleScattering ( const G4String &  processName = "msc" )

explicit

Definition at line 54 of file G4hMultipleScattering.cc.

  : G4VMultipleScattering(processName)
{
  isInitialized = false;  
}

References isInitialized.

~G4hMultipleScattering()

G4hMultipleScattering::~G4hMultipleScattering ( )

override

Definition at line 62 of file G4hMultipleScattering.cc.

{}

G4hMultipleScattering() [2/2]

G4hMultipleScattering::G4hMultipleScattering ( const G4hMultipleScattering &  )

delete

Member Function Documentation

AddEmModel()

void G4VMultipleScattering::AddEmModel ( G4int  order, G4VEmModel *  ptr, const G4Region *  region = nullptr  )

inherited

Definition at line 117 of file G4VMultipleScattering.cc.

{
  if(nullptr == ptr) { return; }
  G4VEmFluctuationModel* fm = nullptr;
  modelManager->AddEmModel(order, ptr, fm, region);
  ptr->SetParticleChange(pParticleChange);
}

References G4EmModelManager::AddEmModel(), G4VMultipleScattering::modelManager, G4VProcess::pParticleChange, and G4VEmModel::SetParticleChange().

Referenced by G4AdjointhMultipleScattering::InitialiseProcess(), G4eAdjointMultipleScattering::InitialiseProcess(), G4MuMultipleScattering::InitialiseProcess(), G4eMultipleScattering::InitialiseProcess(), InitialiseProcess(), G4EmConfigurator::PrepareModels(), and G4EmConfigurator::SetModelForRegion().

AlongStepDoIt()

G4VParticleChange * G4VMultipleScattering::AlongStepDoIt ( const G4Track &  track, const G4Step &  step  )

overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 401 of file G4VMultipleScattering.cc.

{
  fParticleChange.ProposeMomentumDirection(
    step.GetPostStepPoint()->GetMomentumDirection());
  fNewPosition = step.GetPostStepPoint()->GetPosition();
  fParticleChange.ProposePosition(fNewPosition);
  fPositionChanged = false;
 
  G4double geomLength = step.GetStepLength();
 
  // very small step - no msc
  if(!isActive) {
    tPathLength = geomLength;
 
    // sample msc
  } else {
    G4double range = 
      currentModel->GetRange(currParticle,track.GetKineticEnergy(),
                             track.GetMaterialCutsCouple());
 
    tPathLength = currentModel->ComputeTrueStepLength(geomLength);
  
    /*    
    if(currParticle->GetPDGMass() > 0.9*GeV)    
    G4cout << "G4VMsc::AlongStepDoIt: GeomLength= " 
           << geomLength 
           << " tPathLength= " << tPathLength
           << " physStepLimit= " << physStepLimit
           << " dr= " << range - tPathLength
           << " ekin= " << track.GetKineticEnergy() << G4endl;
    */
    // protection against wrong t->g->t conversion
    tPathLength = std::min(tPathLength, physStepLimit);
 
    // do not sample scattering at the last or at a small step
    if(tPathLength < range && tPathLength > geomMin) {
 
      static const G4double minSafety = 1.20*CLHEP::nm;
      static const G4double sFact = 0.99;
 
      G4ThreeVector displacement = currentModel->SampleScattering(
        step.GetPostStepPoint()->GetMomentumDirection(),minSafety);
 
      G4double r2 = displacement.mag2();
      //G4cout << "    R= " << sqrt(r2) << " Rmin= " << sqrt(minDisplacement2)
      //     << " flag= " << fDispBeyondSafety << G4endl;
      if(r2 > minDisplacement2) {
 
        fPositionChanged = true;
        G4double dispR = std::sqrt(r2);
        G4double postSafety = 
          sFact*safetyHelper->ComputeSafety(fNewPosition, dispR); 
        //G4cout<<"    R= "<< dispR<<" postSafety= "<<postSafety<<G4endl;
 
        // far away from geometry boundary
        if(postSafety > 0.0 && dispR <= postSafety) {
          fNewPosition += displacement;
 
          //near the boundary
        } else {
          // displaced point is definitely within the volume
          //G4cout<<"    R= "<<dispR<<" postSafety= "<<postSafety<<G4endl;
          if(dispR < postSafety) {
            fNewPosition += displacement;
 
            // reduced displacement
          } else if(postSafety > geomMin) {
            fNewPosition += displacement*(postSafety/dispR); 
 
            // very small postSafety
          } else {
            fPositionChanged = false;
          }
        }
        if(fPositionChanged) { 
          safetyHelper->ReLocateWithinVolume(fNewPosition);
          fParticleChange.ProposePosition(fNewPosition); 
        }
      }
    }
  }
  fParticleChange.ProposeTrueStepLength(tPathLength);
  return &fParticleChange;
}

References G4SafetyHelper::ComputeSafety(), G4VMscModel::ComputeTrueStepLength(), G4VMultipleScattering::currentModel, G4VMultipleScattering::currParticle, G4VMultipleScattering::fNewPosition, G4VMultipleScattering::fParticleChange, G4VMultipleScattering::fPositionChanged, G4VMultipleScattering::geomMin, G4Track::GetKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4StepPoint::GetMomentumDirection(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), G4VMscModel::GetRange(), G4Step::GetStepLength(), G4VMultipleScattering::isActive, CLHEP::Hep3Vector::mag2(), G4INCL::Math::min(), G4VMultipleScattering::minDisplacement2, CLHEP::nm, G4VMultipleScattering::physStepLimit, G4ParticleChangeForMSC::ProposeMomentumDirection(), G4ParticleChangeForMSC::ProposePosition(), G4VParticleChange::ProposeTrueStepLength(), G4SafetyHelper::ReLocateWithinVolume(), G4VMultipleScattering::safetyHelper, G4VMscModel::SampleScattering(), and G4VMultipleScattering::tPathLength.

AlongStepGetPhysicalInteractionLength()

G4double G4VMultipleScattering::AlongStepGetPhysicalInteractionLength ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimalStep, G4double &  currentSafety, G4GPILSelection *  selection  )

overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 334 of file G4VMultipleScattering.cc.

{
  // get Step limit proposed by the process
  *selection = NotCandidateForSelection;
  physStepLimit = gPathLength = tPathLength = currentMinimalStep;
 
  G4double ekin = track.GetKineticEnergy();
  /*
  G4cout << "MSC::AlongStepGPIL: Ekin= " << ekin
         << "  " << currParticle->GetParticleName() 
         << " currMod " << currentModel 
         << G4endl;
  */
  // isIon flag is used only to select a model
  if(isIon) { 
    ekin *= proton_mass_c2/track.GetParticleDefinition()->GetPDGMass(); 
  }
  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();
  
  // select new model
  if(1 < numberOfModels) {
    currentModel = static_cast<G4VMscModel*>(SelectModel(ekin,couple->GetIndex()));
  }
  currentModel->SetCurrentCouple(couple);
  // msc is active is model is active, energy above the limit,
  // and step size is above the limit;
  // if it is active msc may limit the step
  if(currentModel->IsActive(ekin) && tPathLength > geomMin
     && ekin >= lowestKinEnergy) {
    isActive = true;
    tPathLength = 
      currentModel->ComputeTruePathLengthLimit(track, gPathLength);
    if (tPathLength < physStepLimit) { 
      *selection = CandidateForSelection; 
    }
  } else { isActive = false; }
  
  //if(currParticle->GetPDGMass() > GeV)    
  /*
  G4cout << "MSC::AlongStepGPIL: Ekin= " << ekin
         << "  " << currParticle->GetParticleName()
         << " gPathLength= " << gPathLength
         << " tPathLength= " << tPathLength
         << " currentMinimalStep= " << currentMinimalStep
         << " isActive " << isActive << G4endl;
  */
  return gPathLength;
}

References CandidateForSelection, G4VMscModel::ComputeTruePathLengthLimit(), G4VMultipleScattering::currentModel, G4VMultipleScattering::geomMin, G4MaterialCutsCouple::GetIndex(), G4Track::GetKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4Track::GetParticleDefinition(), G4ParticleDefinition::GetPDGMass(), G4VMultipleScattering::gPathLength, G4VEmModel::IsActive(), G4VMultipleScattering::isActive, G4VMultipleScattering::isIon, G4VMultipleScattering::lowestKinEnergy, NotCandidateForSelection, G4VMultipleScattering::numberOfModels, G4VMultipleScattering::physStepLimit, source.hepunit::proton_mass_c2, G4VMultipleScattering::SelectModel(), G4VEmModel::SetCurrentCouple(), and G4VMultipleScattering::tPathLength.

Referenced by G4VMultipleScattering::GetContinuousStepLimit().

AlongStepGPIL()

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

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

AtRestDoIt()

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

inlinevirtualinherited

Implements G4VProcess.

Definition at line 87 of file G4VContinuousDiscreteProcess.hh.

                              { return 0; }

AtRestGetPhysicalInteractionLength()

virtual G4double G4VContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength ( const G4Track &  , G4ForceCondition *    )

inlinevirtualinherited

Implements G4VProcess.

Definition at line 81 of file G4VContinuousDiscreteProcess.hh.

                              { return -1.0; }

AtRestGPIL()

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

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

BuildPhysicsTable()

void G4VMultipleScattering::BuildPhysicsTable ( const G4ParticleDefinition &  part )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 223 of file G4VMultipleScattering.cc.

{
  const G4String& num = part.GetParticleName();
  G4bool master = emManager->IsMaster();
  if(1 < verboseLevel) {
    G4cout << "### G4VMultipleScattering::BuildPhysicsTable() for "
           << GetProcessName()
           << " and particle " << num << " isIon: " << isIon
       << " IsMaster: " << master << G4endl;
  }
  const G4VMultipleScattering* masterProcess = 
    static_cast<const G4VMultipleScattering*>(GetMasterProcess());
 
  if(firstParticle == &part) { 
    /*
    std::cout << "### G4VMultipleScattering::BuildPhysicsTable() for "
              << GetProcessName() << " and particle " << num
          << " IsMaster= " << G4LossTableManager::Instance()->IsMaster()
          << "  " << this << std::endl;
    */
    emManager->BuildPhysicsTable(firstParticle);
 
    if(!master) {
      // initialisation of models
      /*
      std::cout << "### G4VMultipleScattering::BuildPhysicsTable() for "
                << GetProcessName() << " and particle " << num
        << " Nmod= " << mscModels.size() << " NOT master" << std::endl;
      */
      baseMat = masterProcess->UseBaseMaterial();
      for(G4int i=0; i<numberOfModels; ++i) {
    G4VMscModel* msc = GetModelByIndex(i);
    if(nullptr == msc) { continue; }
        G4VMscModel* msc0 = masterProcess->GetModelByIndex(i);
        msc->SetUseBaseMaterials(baseMat);
        msc->SetCrossSectionTable(msc0->GetCrossSectionTable(), false);
        msc->InitialiseLocal(firstParticle, msc0);
      }
    }
  }
  // protection against double printout
  if(theParameters->IsPrintLocked()) { return; }
 
  // explicitly defined printout by particle name
  if(1 < verboseLevel || 
     (0 < verboseLevel && (num == "e-" || 
                           num == "e+"    || num == "mu+" || 
                           num == "mu-"   || num == "proton"|| 
                           num == "pi+"   || num == "pi-" || 
                           num == "kaon+" || num == "kaon-" || 
                           num == "alpha" || num == "anti_proton" || 
                           num == "GenericIon" || num == "alpha+" || 
                           num == "alpha++" )))
    { 
      StreamInfo(G4cout, part);
    }
 
  if(1 < verboseLevel) {
    G4cout << "### G4VMultipleScattering::BuildPhysicsTable() done for "
           << GetProcessName()
           << " and particle " << num << G4endl;
  }
}

References G4VMultipleScattering::baseMat, G4LossTableManager::BuildPhysicsTable(), G4VMultipleScattering::emManager, G4VMultipleScattering::firstParticle, G4cout, G4endl, G4VEmModel::GetCrossSectionTable(), G4VProcess::GetMasterProcess(), G4VMultipleScattering::GetModelByIndex(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VEmModel::InitialiseLocal(), G4VMultipleScattering::isIon, G4LossTableManager::IsMaster(), G4EmParameters::IsPrintLocked(), G4VMultipleScattering::numberOfModels, G4VEmModel::SetCrossSectionTable(), G4VEmModel::SetUseBaseMaterials(), G4VMultipleScattering::StreamInfo(), G4VMultipleScattering::theParameters, G4VMultipleScattering::UseBaseMaterial(), and G4VProcess::verboseLevel.

BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4RadioactiveDecay::DecayAnalog(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4Radioactivation::DecayIt(), G4RadioactiveDecay::DecayIt(), G4MuonicAtomDecay::DecayIt(), G4Decay::EndTracking(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4VAdjointReverseReaction::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

ContinuousStepLimit()

G4double G4VMultipleScattering::ContinuousStepLimit ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimalStep, G4double &  currentSafety  )

inherited

Definition at line 513 of file G4VMultipleScattering.cc.

{
  return GetContinuousStepLimit(track,previousStepSize,currentMinimalStep,
                                currentSafety);
}

References G4VMultipleScattering::GetContinuousStepLimit().

DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

{
  G4cout << "Process Name " << theProcessName ;
  G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
  G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
}

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

EmModel()

G4VMscModel * G4VMultipleScattering::EmModel ( size_t  index = 0 ) const

inlineinherited

Definition at line 373 of file G4VMultipleScattering.hh.

{
  return (index < mscModels.size()) ? mscModels[index] : nullptr;
}

References G4VMultipleScattering::mscModels.

Referenced by G4eAdjointMultipleScattering::InitialiseProcess(), G4MuMultipleScattering::InitialiseProcess(), G4eMultipleScattering::InitialiseProcess(), and InitialiseProcess().

EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

FirstParticle()

const G4ParticleDefinition * G4VMultipleScattering::FirstParticle ( ) const

inlineinherited

Definition at line 366 of file G4VMultipleScattering.hh.

{
  return firstParticle;
}

References G4VMultipleScattering::firstParticle.

GeomFactor()

G4double G4VMultipleScattering::GeomFactor ( ) const

inlineinherited

Definition at line 324 of file G4VMultipleScattering.hh.

{
  return theParameters->MscGeomFactor();
}

References G4EmParameters::MscGeomFactor(), and G4VMultipleScattering::theParameters.

Referenced by G4eAdjointMultipleScattering::StreamProcessInfo(), G4eMultipleScattering::StreamProcessInfo(), and StreamProcessInfo().

GetContinuousStepLimit()

G4double G4VMultipleScattering::GetContinuousStepLimit ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimalStep, G4double &  currentSafety  )

overrideprotectedvirtualinherited

Implements G4VContinuousDiscreteProcess.

Definition at line 497 of file G4VMultipleScattering.cc.

{
  G4GPILSelection selection = NotCandidateForSelection;
  G4double x = AlongStepGetPhysicalInteractionLength(track,previousStepSize,
                                                     currentMinimalStep,
                                                     currentSafety, 
                                                     &selection);
  return x;
}

References G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), and NotCandidateForSelection.

Referenced by G4VMultipleScattering::ContinuousStepLimit().

GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

GetGPILSelection()

G4GPILSelection G4VContinuousDiscreteProcess::GetGPILSelection ( ) const

inlineprotectedinherited

Definition at line 109 of file G4VContinuousDiscreteProcess.hh.

      { return valueGPILSelection; }

References G4VContinuousDiscreteProcess::valueGPILSelection.

GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

GetMeanFreePath()

G4double G4VMultipleScattering::GetMeanFreePath ( const G4Track &  track, G4double  , G4ForceCondition *  condition  )

overrideprotectedvirtualinherited

Implements G4VContinuousDiscreteProcess.

Definition at line 525 of file G4VMultipleScattering.cc.

{
  *condition = Forced;
  return DBL_MAX;
}

References condition(), DBL_MAX, and Forced.

GetModelByIndex()

G4VMscModel * G4VMultipleScattering::GetModelByIndex ( G4int  idx = 0, G4bool  ver = false  ) const

inlineinherited

Definition at line 388 of file G4VMultipleScattering.hh.

{
  return static_cast<G4VMscModel*>(modelManager->GetModel(idx, ver));
}

References G4EmModelManager::GetModel(), and G4VMultipleScattering::modelManager.

Referenced by G4VMultipleScattering::BuildPhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), and G4VMultipleScattering::StartTracking().

GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

GetPhysicsTableFileName()

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

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4ProcessManager::ActivateProcess(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4ProcessManager::AddProcess(), G4ProcessPlacer::AddProcessAs(), G4ITSteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), G4ITSteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4BOptnLeadingParticle::ApplyFinalStateBiasing(), G4ITSteppingVerbose::AtRestDoItInvoked(), G4SteppingVerbose::AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4ITSteppingVerbose::AtRestDoItOneByOne(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4HadronicProcess::BiasCrossSectionByFactor(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VEnergyLossProcess::BuildDEDXTable(), G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4VEmProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4ProcessManager::CheckOrderingParameters(), G4HadronicProcess::CheckResult(), G4StackChecker::ClassifyNewTrack(), G4BOptrForceCollision::ConfigureForWorker(), G4RunManagerKernel::ConfirmCoupledTransportation(), G4FastSimulationPhysics::ConstructProcess(), G4GenericBiasingPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4LossTableManager::CopyTables(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4VPhononProcess::CreateSecondary(), G4EmExtraParameters::DefineRegParamForEM(), G4EmExtraParameters::DefineRegParamForLoss(), G4HadronicProcessStore::DeRegisterExtraProcess(), G4ITSteppingVerbose::DPSLAlongStep(), G4SteppingVerbose::DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), G4ITSteppingVerbose::DPSLPostStep(), G4SteppingVerbose::DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), G4HadronicProcessStore::Dump(), G4HadronicProcess::DumpState(), G4MuonicAtomDecay::DumpState(), G4ExceptionHandler::DumpTrackInfo(), export_G4VProcess(), G4EmCalculator::FindEmModel(), G4VEmProcess::FindLambdaMax(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4HadronicProcess::GetElementCrossSection(), G4VEmProcess::GetEmProcess(), G4GammaGeneralProcess::GetEmProcess(), G4WeightWindowProcess::GetName(), G4ProcessManager::GetProcess(), G4ProcessManager::GetProcessVectorIndex(), G4GammaGeneralProcess::GetSubProcessName(), G4ProcessManager::InActivateProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4ProcessTable::Insert(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAtRestDoItProcs(), G4SteppingManager::InvokePSDIP(), G4LossTableManager::LocalPhysicsTables(), G4ErrorPropagator::MakeOneStep(), G4VEmProcess::PostStepDoIt(), G4ITSteppingVerbose::PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), G4ITSteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4ITSteppingVerbose::PostStepVerbose(), G4EmConfigurator::PrepareModels(), G4HadronStoppingProcess::PreparePhysicsTable(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4HadronicProcessStore::PrintHtml(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4hImpactIonisation::PrintInfoDefinition(), G4ProcessPlacer::PrintProcVec(), G4VEnergyLossProcess::PrintWarning(), G4VEmProcess::PrintWarning(), G4SynchrotronRadiation::ProcessDescription(), G4Decay::ProcessDescription(), G4DecayWithSpin::ProcessDescription(), G4PionDecayMakeSpin::ProcessDescription(), G4UnknownDecay::ProcessDescription(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), G4StackManager::PushOneTrack(), G4HadronicProcessStore::Register(), G4LossTableManager::Register(), G4LossTableManager::RegisterExtraParticle(), G4HadronicProcessStore::RegisterExtraProcess(), G4HadronicProcessStore::RegisterParticle(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTable::Remove(), G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(), G4ProcessManager::RemoveProcess(), G4ProcessPlacer::RemoveProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::SetLambdaTable(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessManager::SetProcessOrderingToSecond(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4FastSimulationManagerProcess::SetWorldVolume(), G4ITSteppingVerbose::ShowStep(), G4SteppingVerbose::ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), G4ChannelingOptrChangeCrossSection::StartRun(), G4ITSteppingVerbose::StepInfo(), G4SteppingVerbose::StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), G4ITSteppingVerbose::StepInfoForLeadingTrack(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4EmCalculator::UpdateParticle(), G4ParallelWorldScoringProcess::Verbose(), G4ScoreSplittingProcess::Verbose(), G4ITSteppingVerbose::VerboseTrack(), G4SteppingVerbose::VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType  aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

References fDecay, fElectromagnetic, fGeneral, fHadronic, fNotDefined, fOptical, fParameterisation, fPhonon, fPhotolepton_hadron, fTransportation, fUserDefined, anonymous_namespace{G4VProcess.cc}::noType, anonymous_namespace{G4VProcess.cc}::typeDecay, anonymous_namespace{G4VProcess.cc}::typeElectromagnetic, anonymous_namespace{G4VProcess.cc}::typeGeneral, anonymous_namespace{G4VProcess.cc}::typeHadronic, anonymous_namespace{G4VProcess.cc}::typeNotDefined, anonymous_namespace{G4VProcess.cc}::typeOptical, anonymous_namespace{G4VProcess.cc}::typeParameterisation, anonymous_namespace{G4VProcess.cc}::typePhonon, anonymous_namespace{G4VProcess.cc}::typePhotolepton_hadron, anonymous_namespace{G4VProcess.cc}::typeTransportation, and anonymous_namespace{G4VProcess.cc}::typeUserDefined.

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const

inlineinherited

Definition at line 418 of file G4VProcess.hh.

{
  return  verboseLevel;
}

References G4VProcess::verboseLevel.

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Decay::G4Decay(), G4UnknownDecay::G4UnknownDecay(), G4Decay::GetMeanFreePath(), G4Decay::GetMeanLifeTime(), and G4DecayWithSpin::Spin_Precession().

InitialiseProcess()

void G4hMultipleScattering::InitialiseProcess ( const G4ParticleDefinition *  )

overrideprotectedvirtual

Implements G4VMultipleScattering.

Definition at line 74 of file G4hMultipleScattering.cc.

{
  if(isInitialized) { return; }
  if(nullptr == EmModel(0)) { SetEmModel( new G4UrbanMscModel() ); }
  AddEmModel(1, EmModel(0));
  isInitialized = true;
}

References G4VMultipleScattering::AddEmModel(), G4VMultipleScattering::EmModel(), isInitialized, and G4VMultipleScattering::SetEmModel().

isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

IsApplicable()

G4bool G4hMultipleScattering::IsApplicable ( const G4ParticleDefinition &  p )

finalvirtual

Reimplemented from G4VProcess.

Definition at line 67 of file G4hMultipleScattering.cc.

{
  return (p.GetPDGCharge() != 0.0);
}

References G4ParticleDefinition::GetPDGCharge().

isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

LateralDisplasmentFlag()

G4bool G4VMultipleScattering::LateralDisplasmentFlag ( ) const

inlineinherited

Definition at line 303 of file G4VMultipleScattering.hh.

{
  return latDisplacement;
}

References G4VMultipleScattering::latDisplacement.

Referenced by G4AdjointhMultipleScattering::StreamProcessInfo(), G4eAdjointMultipleScattering::StreamProcessInfo(), G4MuMultipleScattering::StreamProcessInfo(), G4eMultipleScattering::StreamProcessInfo(), and StreamProcessInfo().

LowestKinEnergy()

G4double G4VMultipleScattering::LowestKinEnergy ( ) const

inlineinherited

Definition at line 352 of file G4VMultipleScattering.hh.

{
  return lowestKinEnergy;
}

References G4VMultipleScattering::lowestKinEnergy.

NumberOfModels()

G4int G4VMultipleScattering::NumberOfModels ( ) const

inlineinherited

Definition at line 380 of file G4VMultipleScattering.hh.

{
  return numberOfModels;
}

References G4VMultipleScattering::numberOfModels.

operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess &  right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

operator=()

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

delete

operator==()

G4bool G4VProcess::operator== ( const G4VProcess &  right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

PolarAngleLimit()

G4double G4VMultipleScattering::PolarAngleLimit ( ) const

inlineinherited

Definition at line 331 of file G4VMultipleScattering.hh.

{
  return theParameters->MscThetaLimit();
}

References G4EmParameters::MscThetaLimit(), and G4VMultipleScattering::theParameters.

Referenced by G4MuMultipleScattering::StreamProcessInfo().

PostStepDoIt()

G4VParticleChange * G4VMultipleScattering::PostStepDoIt ( const G4Track &  track, const G4Step &    )

overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 489 of file G4VMultipleScattering.cc.

{
  fParticleChange.Initialize(track);
  return &fParticleChange;
}

References G4VMultipleScattering::fParticleChange, and G4ParticleChangeForMSC::Initialize().

PostStepGetPhysicalInteractionLength()

G4double G4VMultipleScattering::PostStepGetPhysicalInteractionLength ( const G4Track &  , G4double  previousStepSize, G4ForceCondition *  condition  )

overridevirtualinherited

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 391 of file G4VMultipleScattering.cc.

{
  *condition = NotForced;
  return DBL_MAX;
}

References condition(), DBL_MAX, and NotForced.

PostStepGPIL()

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

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

PreparePhysicsTable()

void G4VMultipleScattering::PreparePhysicsTable ( const G4ParticleDefinition &  part )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 140 of file G4VMultipleScattering.cc.

{
  if(1 < verboseLevel) {
    G4cout << "### G4VMultipleScattering::PrepearPhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << G4endl;
  }
  G4bool master = emManager->IsMaster();
 
  if(nullptr == firstParticle) { firstParticle = &part; }
  if(part.GetPDGMass() > CLHEP::GeV) {
    // flag declears that mass scaling is applied
    isIon = true;
  }
 
  emManager->PreparePhysicsTable(&part, this, master);
  currParticle = nullptr;
 
  if(1 < verboseLevel) {
    G4cout << "### G4VMultipleScattering::PrepearPhysicsTable() for "
           << GetProcessName()
           << " and particle " << part.GetParticleName()
           << " local particle " << firstParticle->GetParticleName()
           << " isIon: " << isIon << " isMaster: " << master
       << G4endl;
  }
 
  if(firstParticle == &part) {
 
    // initialise process
    InitialiseProcess(firstParticle);
 
    // heavy particles 
    if(part.GetPDGMass() > CLHEP::MeV) {
      stepLimit = theParameters->MscMuHadStepLimitType(); 
      facrange = theParameters->MscMuHadRangeFactor(); 
      latDisplacement = theParameters->MuHadLateralDisplacement();
    } else {
      stepLimit = theParameters->MscStepLimitType(); 
      facrange = theParameters->MscRangeFactor(); 
      latDisplacement = theParameters->LateralDisplacement();
    }
    if(master) { SetVerboseLevel(theParameters->Verbose()); }
    else {  SetVerboseLevel(theParameters->WorkerVerbose()); }
 
    // initialisation of models
    numberOfModels = modelManager->NumberOfModels();
    /*     
    std::cout << "### G4VMultipleScattering::PreparePhysicsTable() for "
          << GetProcessName()
          << " and particle " << part.GetParticleName()
          << " Nmodels= " << mscModels.size() << "  " << this << std::endl;
    */
    G4LossTableBuilder* bld = emManager->GetTableBuilder();
    baseMat = bld->GetBaseMaterialFlag();
 
    for(G4int i=0; i<numberOfModels; ++i) {
      G4VMscModel* msc = GetModelByIndex(i);
      if(nullptr == msc) { continue; }
      if(nullptr == currentModel) { currentModel = msc; }
      msc->SetIonisation(nullptr, firstParticle);
      msc->SetMasterThread(master);
      msc->SetPolarAngleLimit(theParameters->MscThetaLimit());
      G4double emax = 
        std::min(msc->HighEnergyLimit(),theParameters->MaxKinEnergy());
      msc->SetHighEnergyLimit(emax);
      msc->SetUseBaseMaterials(baseMat);
    }
 
    modelManager->Initialise(firstParticle, G4Electron::Electron(), 
                             1.0, verboseLevel);
 
    if(nullptr == safetyHelper) {
      safetyHelper = G4TransportationManager::GetTransportationManager()
        ->GetSafetyHelper();
      safetyHelper->InitialiseHelper();
    }
  }
}

References G4VMultipleScattering::baseMat, G4VMultipleScattering::currentModel, G4VMultipleScattering::currParticle, G4Electron::Electron(), emax, G4VMultipleScattering::emManager, G4VMultipleScattering::facrange, G4VMultipleScattering::firstParticle, G4cout, G4endl, G4LossTableBuilder::GetBaseMaterialFlag(), G4VMultipleScattering::GetModelByIndex(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4VProcess::GetProcessName(), G4TransportationManager::GetSafetyHelper(), G4LossTableManager::GetTableBuilder(), G4TransportationManager::GetTransportationManager(), CLHEP::GeV, G4VEmModel::HighEnergyLimit(), G4EmModelManager::Initialise(), G4SafetyHelper::InitialiseHelper(), G4VMultipleScattering::InitialiseProcess(), G4VMultipleScattering::isIon, G4LossTableManager::IsMaster(), G4VMultipleScattering::latDisplacement, G4EmParameters::LateralDisplacement(), G4EmParameters::MaxKinEnergy(), CLHEP::MeV, G4INCL::Math::min(), G4VMultipleScattering::modelManager, G4EmParameters::MscMuHadRangeFactor(), G4EmParameters::MscMuHadStepLimitType(), G4EmParameters::MscRangeFactor(), G4EmParameters::MscStepLimitType(), G4EmParameters::MscThetaLimit(), G4EmParameters::MuHadLateralDisplacement(), G4EmModelManager::NumberOfModels(), G4VMultipleScattering::numberOfModels, G4LossTableManager::PreparePhysicsTable(), G4VMultipleScattering::safetyHelper, G4VEmModel::SetHighEnergyLimit(), G4VMscModel::SetIonisation(), G4VEmModel::SetMasterThread(), G4VEmModel::SetPolarAngleLimit(), G4VEmModel::SetUseBaseMaterials(), G4VProcess::SetVerboseLevel(), G4VMultipleScattering::stepLimit, G4VMultipleScattering::theParameters, G4EmParameters::Verbose(), G4VProcess::verboseLevel, and G4EmParameters::WorkerVerbose().

PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

ProcessDescription()

void G4hMultipleScattering::ProcessDescription ( std::ostream &  out ) const

overridevirtual

Reimplemented from G4VProcess.

Definition at line 97 of file G4hMultipleScattering.cc.

{
  out << 
  "  Hadron multiple scattering. Simulates combined effects of elastic \n" <<
  "    scattering at the end of the step, to save computing time. May\n"<<
  "    be combined with Coulomb scattering in a 'mixed' scattering algorithm.";
  G4VMultipleScattering::ProcessDescription(out);
}

References G4VMultipleScattering::ProcessDescription().

RangeFactor()

G4double G4VMultipleScattering::RangeFactor ( ) const

inlineinherited

Definition at line 317 of file G4VMultipleScattering.hh.

{
  return facrange;
}

References G4VMultipleScattering::facrange.

Referenced by G4AdjointhMultipleScattering::StreamProcessInfo(), G4eAdjointMultipleScattering::StreamProcessInfo(), G4MuMultipleScattering::StreamProcessInfo(), G4eMultipleScattering::StreamProcessInfo(), and StreamProcessInfo().

ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft(), G4WrapperProcess::ResetNumberOfInteractionLengthLeft(), G4AdjointProcessEquivalentToDirectProcess::ResetNumberOfInteractionLengthLeft(), and G4Decay::StartTracking().

RetrievePhysicsTable()

G4bool G4VMultipleScattering::RetrievePhysicsTable ( const G4ParticleDefinition *  , const G4String &  directory, G4bool  ascii  )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 580 of file G4VMultipleScattering.cc.

{
  return true;
}

SelectModel()

G4VEmModel * G4VMultipleScattering::SelectModel ( G4double  kinEnergy, size_t  idx  )

inlineinherited

Definition at line 296 of file G4VMultipleScattering.hh.

{
  return modelManager->SelectModel(kinEnergy, coupleIndex);
}

References G4VMultipleScattering::modelManager, and G4EmModelManager::SelectModel().

Referenced by G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), G4EmCalculator::FindEmModel(), and G4EmCalculator::FindLambdaTable().

SetEmModel()

void G4VMultipleScattering::SetEmModel ( G4VMscModel *  ptr, G4int  idx = 0  )

inherited

Definition at line 128 of file G4VMultipleScattering.cc.

{
  if(nullptr == ptr) { return; }
  if(!mscModels.empty()) { 
    for(auto & msc : mscModels) { if(msc == ptr) { return; } } 
  }
  mscModels.push_back(ptr);
}

References G4VMultipleScattering::mscModels.

Referenced by G4EmBuilder::ConstructCharged(), G4EmBuilder::ConstructLightHadrons(), G4EmDNAPhysics_option1::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), G4EmStandardPhysicsWVI::ConstructProcess(), G4eAdjointMultipleScattering::InitialiseProcess(), G4MuMultipleScattering::InitialiseProcess(), G4eMultipleScattering::InitialiseProcess(), and InitialiseProcess().

SetGPILSelection()

void G4VContinuousDiscreteProcess::SetGPILSelection ( G4GPILSelection  selection )

inlineprotectedinherited

Definition at line 106 of file G4VContinuousDiscreteProcess.hh.

      { valueGPILSelection = selection; }

References G4VContinuousDiscreteProcess::valueGPILSelection.

SetIonisation()

void G4VMultipleScattering::SetIonisation ( G4VEnergyLossProcess *  p )

inherited

Definition at line 589 of file G4VMultipleScattering.cc.

{
  for(auto & msc : mscModels) {
    if(nullptr != msc) { msc->SetIonisation(p, firstParticle); }
  }
}

References G4VMultipleScattering::firstParticle, and G4VMultipleScattering::mscModels.

SetLowestKinEnergy()

void G4VMultipleScattering::SetLowestKinEnergy ( G4double  val )

inlineinherited

Definition at line 359 of file G4VMultipleScattering.hh.

{
  lowestKinEnergy = val;
}

References G4VMultipleScattering::lowestKinEnergy.

SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess *  masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

SetPILfactor()

void G4VProcess::SetPILfactor ( G4double  value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager *  procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int  value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType  aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

SetStepLimitType()

void G4VMultipleScattering::SetStepLimitType ( G4MscStepLimitType  val )

inlineinherited

Definition at line 345 of file G4VMultipleScattering.hh.

{
  theParameters->SetMscStepLimitType(val);
}

References G4EmParameters::SetMscStepLimitType(), and G4VMultipleScattering::theParameters.

Referenced by LBE::ConstructEM(), G4EmDNAPhysics_option1::ConstructProcess(), G4EmDNAPhysics_option2::ConstructProcess(), G4EmDNAPhysics_option3::ConstructProcess(), G4EmDNAPhysics_option4::ConstructProcess(), G4EmDNAPhysics_option5::ConstructProcess(), G4EmDNAPhysics_option6::ConstructProcess(), G4EmDNAPhysics_option7::ConstructProcess(), G4EmDNAPhysics_option8::ConstructProcess(), G4EmDNAPhysics_stationary_option2::ConstructProcess(), G4EmDNAPhysics_stationary_option4::ConstructProcess(), and G4EmDNAPhysics_stationary_option6::ConstructProcess().

SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int  value )

inlineinherited

Definition at line 412 of file G4VProcess.hh.

{
  verboseLevel = value;
}

References G4VProcess::verboseLevel.

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4hhIonisation::G4hhIonisation(), G4mplIonisation::G4mplIonisation(), G4Transportation::G4Transportation(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

Skin()

G4double G4VMultipleScattering::Skin ( ) const

inlineinherited

Definition at line 310 of file G4VMultipleScattering.hh.

{
  return theParameters->MscSkin();
}

References G4EmParameters::MscSkin(), and G4VMultipleScattering::theParameters.

Referenced by G4AdjointhMultipleScattering::StreamProcessInfo(), G4eAdjointMultipleScattering::StreamProcessInfo(), G4eMultipleScattering::StreamProcessInfo(), and StreamProcessInfo().

StartTracking()

void G4VMultipleScattering::StartTracking ( G4Track *  track )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 301 of file G4VMultipleScattering.cc.

{
  G4VEnergyLossProcess* eloss = nullptr;
  if(track->GetParticleDefinition() != currParticle) {
    currParticle = track->GetParticleDefinition();
    fIonisation = emManager->GetEnergyLossProcess(currParticle);
    eloss = fIonisation;
  }
  /*
  G4cout << "G4VMultipleScattering::StartTracking Nmod= " << numberOfModels
         << "  " << currParticle->GetParticleName() 
         << " E(MeV)= " << track->GetKineticEnergy()
         << "  Ion= " << fIonisation << " IsMaster= " 
         << G4LossTableManager::Instance()->IsMaster() 
         << G4endl;
  */
  for(G4int i=0; i<numberOfModels; ++i) {
    G4VMscModel* msc = GetModelByIndex(i);
    /*
      G4cout << "Next model " << msc 
      << " Emin= " << msc->LowEnergyLimit() 
      << " Emax= " << msc->HighEnergyLimit() 
      << " Eact= " << msc->LowEnergyActivationLimit() << G4endl;
    */
    msc->StartTracking(track);
    if(nullptr != eloss) {
      msc->SetIonisation(eloss, currParticle);
    }
  }
}

References G4VMultipleScattering::currParticle, G4VMultipleScattering::emManager, G4VMultipleScattering::fIonisation, G4LossTableManager::GetEnergyLossProcess(), G4VMultipleScattering::GetModelByIndex(), G4Track::GetParticleDefinition(), G4VMultipleScattering::numberOfModels, G4VMscModel::SetIonisation(), and G4VEmModel::StartTracking().

Referenced by G4eAdjointMultipleScattering::StartTracking().

StepLimitType()

G4MscStepLimitType G4VMultipleScattering::StepLimitType ( ) const

inlineinherited

Definition at line 338 of file G4VMultipleScattering.hh.

{
  return theParameters->MscStepLimitType();
}

References G4EmParameters::MscStepLimitType(), and G4VMultipleScattering::theParameters.

Referenced by G4AdjointhMultipleScattering::StreamProcessInfo(), G4eAdjointMultipleScattering::StreamProcessInfo(), G4MuMultipleScattering::StreamProcessInfo(), G4eMultipleScattering::StreamProcessInfo(), and StreamProcessInfo().

StorePhysicsTable()

G4bool G4VMultipleScattering::StorePhysicsTable ( const G4ParticleDefinition *  part, const G4String &  directory, G4bool  ascii = false  )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 535 of file G4VMultipleScattering.cc.

{
  G4bool yes = true;
  if(part != firstParticle) { return yes; }
  const G4VMultipleScattering* masterProcess = 
    static_cast<const G4VMultipleScattering*>(GetMasterProcess()); 
  if(nullptr != masterProcess && masterProcess != this) { return yes; }
 
  G4int nmod = modelManager->NumberOfModels();
  static const G4String ss[4] = {"1","2","3","4"};
  for(G4int i=0; i<nmod; ++i) {
    G4VEmModel* msc = modelManager->GetModel(i);
    if(nullptr == msc) { continue; }
    yes = true;
    G4PhysicsTable* table = msc->GetCrossSectionTable();
    if (nullptr != table) {
      G4int j = std::min(i,3); 
      G4String name = 
        GetPhysicsTableFileName(part,directory,"LambdaMod"+ss[j],ascii);
      yes = table->StorePhysicsTable(name,ascii);
 
      if ( yes ) {
        if ( verboseLevel>0 ) {
          G4cout << "Physics table are stored for " 
                 << part->GetParticleName()
                 << " and process " << GetProcessName()
                 << " with a name <" << name << "> " << G4endl;
        }
      } else {
        G4cout << "Fail to store Physics Table for " 
               << part->GetParticleName()
               << " and process " << GetProcessName()
               << " in the directory <" << directory
               << "> " << G4endl;
      }
    }
  }
  return yes;
}

References G4VMultipleScattering::firstParticle, G4cout, G4endl, G4VEmModel::GetCrossSectionTable(), G4VProcess::GetMasterProcess(), G4EmModelManager::GetModel(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4INCL::Math::min(), G4VMultipleScattering::modelManager, G4InuclParticleNames::name(), G4EmModelManager::NumberOfModels(), G4PhysicsTable::StorePhysicsTable(), and G4VProcess::verboseLevel.

StreamInfo()

void G4VMultipleScattering::StreamInfo ( std::ostream &  outFile, const G4ParticleDefinition &  part, G4bool  rst = false  ) const

privateinherited

Definition at line 289 of file G4VMultipleScattering.cc.

{
  G4String indent = (rst ? "  " : "");
  outFile << G4endl << indent << GetProcessName() << ": ";
  if (!rst) outFile << " for " << part.GetParticleName();
  outFile  << "  SubType= " << GetProcessSubType() << G4endl;
  modelManager->DumpModelList(outFile, verboseLevel);
}

References G4EmModelManager::DumpModelList(), G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4VMultipleScattering::modelManager, and G4VProcess::verboseLevel.

Referenced by G4VMultipleScattering::BuildPhysicsTable(), and G4VMultipleScattering::ProcessDescription().

StreamProcessInfo()

void G4hMultipleScattering::StreamProcessInfo ( std::ostream &  outFile ) const

overrideprotectedvirtual

Reimplemented from G4VMultipleScattering.

Definition at line 84 of file G4hMultipleScattering.cc.

{
  out << "      RangeFactor= " << RangeFactor()
      << ", stepLimType: " << StepLimitType()
      << ", latDisp: " << LateralDisplasmentFlag();
  if(StepLimitType() == fUseDistanceToBoundary) {
    out  << ", skin= " << Skin() << ", geomFactor= " << GeomFactor();
  }  
  out << G4endl;
}

References fUseDistanceToBoundary, G4endl, G4VMultipleScattering::GeomFactor(), G4VMultipleScattering::LateralDisplasmentFlag(), G4VMultipleScattering::RangeFactor(), G4VMultipleScattering::Skin(), and G4VMultipleScattering::StepLimitType().

SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double  prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

UseBaseMaterial()

G4bool G4VMultipleScattering::UseBaseMaterial ( ) const

inlineinherited

Definition at line 395 of file G4VMultipleScattering.hh.

{
  return baseMat;
}

References G4VMultipleScattering::baseMat.

Referenced by G4VMultipleScattering::BuildPhysicsTable().

Field Documentation

aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4ErrorEnergyLoss::AlongStepDoIt(), G4hImpactIonisation::AlongStepDoIt(), G4DNAMolecularDissociation::DecayIt(), G4OpBoundaryProcess::DoAbsorption(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4VProcess::G4VProcess(), G4PhononDownconversion::MakeLTSecondaries(), G4PhononDownconversion::MakeTTSecondaries(), G4SpecialCuts::PostStepDoIt(), G4Channeling::PostStepDoIt(), G4PhononDownconversion::PostStepDoIt(), G4PhononReflection::PostStepDoIt(), G4PhononScattering::PostStepDoIt(), G4StepLimiter::PostStepDoIt(), G4UserSpecialCuts::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4AnnihiToMuPair::PostStepDoIt(), G4GammaConversionToMuons::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4ForwardXrayTR::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4hImpactIonisation::PostStepDoIt(), G4SynchrotronRadiation::PostStepDoIt(), and G4SynchrotronRadiationInMat::PostStepDoIt().

aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

baseMat

G4bool G4VMultipleScattering::baseMat = false

privateinherited

Definition at line 288 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::BuildPhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), and G4VMultipleScattering::UseBaseMaterial().

currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

Referenced by G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VProcess::EndTracking(), G4Decay::EndTracking(), G4VProcess::GetCurrentInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::StartTracking(), G4Decay::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

currentModel

G4VMscModel* G4VMultipleScattering::currentModel = nullptr

privateinherited

Definition at line 272 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), and G4VMultipleScattering::PreparePhysicsTable().

currParticle

const G4ParticleDefinition* G4VMultipleScattering::currParticle = nullptr

privateinherited

Definition at line 254 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), G4VMultipleScattering::PreparePhysicsTable(), and G4VMultipleScattering::StartTracking().

emManager

G4LossTableManager* G4VMultipleScattering::emManager

privateinherited

Definition at line 247 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::BuildPhysicsTable(), G4VMultipleScattering::G4VMultipleScattering(), G4VMultipleScattering::PreparePhysicsTable(), G4VMultipleScattering::StartTracking(), and G4VMultipleScattering::~G4VMultipleScattering().

enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

facrange

G4double G4VMultipleScattering::facrange = 0.04

privateinherited

Definition at line 258 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::PreparePhysicsTable(), and G4VMultipleScattering::RangeFactor().

fIonisation

G4VEnergyLossProcess* G4VMultipleScattering::fIonisation = nullptr

privateinherited

Definition at line 273 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::StartTracking().

firstParticle

const G4ParticleDefinition* G4VMultipleScattering::firstParticle = nullptr

privateinherited

Definition at line 253 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::BuildPhysicsTable(), G4VMultipleScattering::FirstParticle(), G4VMultipleScattering::PreparePhysicsTable(), G4VMultipleScattering::ProcessDescription(), G4VMultipleScattering::SetIonisation(), and G4VMultipleScattering::StorePhysicsTable().

fNewDirection

G4ThreeVector G4VMultipleScattering::fNewDirection

privateinherited

Definition at line 270 of file G4VMultipleScattering.hh.

fNewPosition

G4ThreeVector G4VMultipleScattering::fNewPosition

privateinherited

Definition at line 269 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt().

fParticleChange

G4ParticleChangeForMSC G4VMultipleScattering::fParticleChange

protectedinherited

Definition at line 265 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), G4VMultipleScattering::G4VMultipleScattering(), and G4VMultipleScattering::PostStepDoIt().

fPositionChanged

G4bool G4VMultipleScattering::fPositionChanged = false

privateinherited

Definition at line 286 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt().

fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

geomMin

G4double G4VMultipleScattering::geomMin

privateinherited

Definition at line 275 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), and G4VMultipleScattering::G4VMultipleScattering().

gPathLength

G4double G4VMultipleScattering::gPathLength = 0.0

privateinherited

Definition at line 279 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepGetPhysicalInteractionLength().

isActive

G4bool G4VMultipleScattering::isActive = false

privateinherited

Definition at line 287 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), and G4VMultipleScattering::AlongStepGetPhysicalInteractionLength().

isInitialized

G4bool G4hMultipleScattering::isInitialized

private

Definition at line 90 of file G4hMultipleScattering.hh.

Referenced by G4hMultipleScattering(), and InitialiseProcess().

isIon

G4bool G4VMultipleScattering::isIon = false

privateinherited

Definition at line 285 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), G4VMultipleScattering::BuildPhysicsTable(), and G4VMultipleScattering::PreparePhysicsTable().

latDisplacement

G4bool G4VMultipleScattering::latDisplacement = true

privateinherited

Definition at line 284 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::LateralDisplasmentFlag(), and G4VMultipleScattering::PreparePhysicsTable().

lowestKinEnergy

G4double G4VMultipleScattering::lowestKinEnergy

privateinherited

Definition at line 259 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), G4VMultipleScattering::G4VMultipleScattering(), G4VMultipleScattering::LowestKinEnergy(), and G4VMultipleScattering::SetLowestKinEnergy().

masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

minDisplacement2

G4double G4VMultipleScattering::minDisplacement2

privateinherited

Definition at line 276 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), and G4VMultipleScattering::G4VMultipleScattering().

modelManager

G4EmModelManager* G4VMultipleScattering::modelManager

privateinherited

Definition at line 246 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AddEmModel(), G4VMultipleScattering::G4VMultipleScattering(), G4VMultipleScattering::GetModelByIndex(), G4VMultipleScattering::PreparePhysicsTable(), G4VMultipleScattering::SelectModel(), G4VMultipleScattering::StorePhysicsTable(), G4VMultipleScattering::StreamInfo(), and G4VMultipleScattering::~G4VMultipleScattering().

mscModels

std::vector<G4VMscModel*> G4VMultipleScattering::mscModels

privateinherited

Definition at line 256 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::EmModel(), G4VMultipleScattering::G4VMultipleScattering(), G4VMultipleScattering::SetEmModel(), and G4VMultipleScattering::SetIonisation().

numberOfModels

G4int G4VMultipleScattering::numberOfModels = 0

privateinherited

Definition at line 282 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepGetPhysicalInteractionLength(), G4VMultipleScattering::BuildPhysicsTable(), G4VMultipleScattering::NumberOfModels(), G4VMultipleScattering::PreparePhysicsTable(), and G4VMultipleScattering::StartTracking().

physStepLimit

G4double G4VMultipleScattering::physStepLimit = 0.0

privateinherited

Definition at line 277 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), and G4VMultipleScattering::AlongStepGetPhysicalInteractionLength().

pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4ImportanceProcess::AlongStepDoIt(), G4WeightCutOffProcess::AlongStepDoIt(), G4WeightWindowProcess::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VContinuousProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousProcess::AlongStepDoIt(), G4ParallelWorldProcess::AlongStepDoIt(), G4ParallelWorldScoringProcess::AlongStepDoIt(), G4VITRestProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4ScoreSplittingProcess::AtRestDoIt(), G4VITRestDiscreteProcess::AtRestDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4Decay::G4Decay(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4RadioactiveDecay::G4RadioactiveDecay(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4Transportation::G4Transportation(), G4UnknownDecay::G4UnknownDecay(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4VProcess::G4VProcess(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VITDiscreteProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4NeutronKiller::PostStepDoIt(), G4VITRestDiscreteProcess::PostStepDoIt(), G4LowECapture::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), and G4VTransitionRadiation::PostStepDoIt().

safetyHelper

G4SafetyHelper* G4VMultipleScattering::safetyHelper = nullptr

privateinherited

Definition at line 252 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), and G4VMultipleScattering::PreparePhysicsTable().

stepLimit

G4MscStepLimitType G4VMultipleScattering::stepLimit = fUseSafety

privateinherited

Definition at line 281 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::PreparePhysicsTable().

theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4VProcess::ClearNumberOfInteractionLengthLeft(), G4MuonicAtomDecay::DecayIt(), G4VProcess::EndTracking(), G4VProcess::GetNumberOfInteractionLengthLeft(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::StartTracking(), G4GammaGeneralProcess::StartTracking(), G4VEmProcess::StartTracking(), G4VEnergyLossProcess::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

theParameters

G4EmParameters* G4VMultipleScattering::theParameters

privateinherited

Definition at line 248 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::BuildPhysicsTable(), G4VMultipleScattering::G4VMultipleScattering(), G4VMultipleScattering::GeomFactor(), G4VMultipleScattering::PolarAngleLimit(), G4VMultipleScattering::PreparePhysicsTable(), G4VMultipleScattering::SetStepLimitType(), G4VMultipleScattering::Skin(), and G4VMultipleScattering::StepLimitType().

thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

tPathLength

G4double G4VMultipleScattering::tPathLength = 0.0

privateinherited

Definition at line 278 of file G4VMultipleScattering.hh.

Referenced by G4VMultipleScattering::AlongStepDoIt(), and G4VMultipleScattering::AlongStepGetPhysicalInteractionLength().

valueGPILSelection

G4GPILSelection G4VContinuousDiscreteProcess::valueGPILSelection = CandidateForSelection

privateinherited

Definition at line 117 of file G4VContinuousDiscreteProcess.hh.

Referenced by G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::GetGPILSelection(), and G4VContinuousDiscreteProcess::SetGPILSelection().

verboseLevel

G4int G4VProcess::verboseLevel = 0

protectedinherited

Definition at line 356 of file G4VProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4LowECapture::AddRegion(), G4CoupledTransportation::AlongStepDoIt(), G4Transportation::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4hImpactIonisation::AntiProtonParametrisedDEDX(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VXTRenergyLoss::BuildAngleTable(), G4VEnergyLossProcess::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4VEmProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLossTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4LowECapture::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4SynchrotronRadiation::BuildPhysicsTable(), G4VXTRenergyLoss::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4OpRayleigh::CalculateRayleighMeanFreePaths(), G4PolarizedAnnihilation::ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VPhononProcess::CreateSecondary(), G4VProcess::EndTracking(), G4VEmProcess::FindLambdaMax(), G4Cerenkov::G4Cerenkov(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GaussXTRadiator::G4GaussXTRadiator(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PolarizedIonisation::G4PolarizedIonisation(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VXTRenergyLoss::GetAngleVector(), G4ChargeExchangeProcess::GetElementCrossSection(), G4VXTRenergyLoss::GetGasZmuProduct(), G4PhononDownconversion::GetMeanFreePath(), G4PhononScattering::GetMeanFreePath(), G4PolarizedCompton::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4UCNAbsorption::GetMeanFreePath(), G4PolarizedAnnihilation::GetMeanFreePath(), G4PolarizedIonisation::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4VXTRenergyLoss::GetNumberOfPhotons(), G4VXTRenergyLoss::GetPlateZmuProduct(), G4SynchrotronRadiation::GetRandomEnergySR(), G4VProcess::GetVerboseLevel(), G4hhIonisation::InitialiseEnergyLossProcess(), G4eeToHadrons::InitialiseProcess(), G4hImpactIonisation::InitializeMe(), G4UCNBoundaryProcess::MRreflect(), G4UCNBoundaryProcess::MRreflectHigh(), G4DNASecondOrderReaction::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4DNAScavengerProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4hImpactIonisation::ProtonParametrisedDEDX(), G4UCNBoundaryProcess::Reflect(), G4CoupledTransportation::ReportInexactEnergy(), G4CoupledTransportation::ReportMissingLogger(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4CoupledTransportation::SetHighLooperThresholds(), G4Transportation::SetHighLooperThresholds(), G4VEnergyLossProcess::SetInverseRangeTable(), G4LowECapture::SetKinEnergyLimit(), G4NeutronKiller::SetKinEnergyLimit(), G4VEnergyLossProcess::SetLambdaTable(), G4CoupledTransportation::SetLowLooperThresholds(), G4Transportation::SetLowLooperThresholds(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4NeutronKiller::SetTimeLimit(), G4VProcess::SetVerboseLevel(), G4Cerenkov::SetVerboseLevel(), G4Scintillation::SetVerboseLevel(), G4OpAbsorption::SetVerboseLevel(), G4OpBoundaryProcess::SetVerboseLevel(), G4OpMieHG::SetVerboseLevel(), G4OpRayleigh::SetVerboseLevel(), G4OpWLS::SetVerboseLevel(), G4OpWLS2::SetVerboseLevel(), G4FastSimulationManagerProcess::SetWorldVolume(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4VProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StoreTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

---

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

• source/processes/electromagnetic/standard/include/G4hMultipleScattering.hh
• source/processes/electromagnetic/standard/src/G4hMultipleScattering.cc