lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e083ffb441420cfd0cca24e1836d0341283e439d
geant4/source/processes/electromagnetic/utils/src/G4VEnergyLossProcess.cc
T
Gabriele Cosmo e083ffb441 Import Geant4 6.2.0 source tree
2016-06-09 10:56:29 +02:00

1428 lines
45 KiB
C++
Raw Blame History

//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: G4VEnergyLossProcess.cc,v 1.22 2004/05/17 09:46:57 vnivanch Exp $
// GEANT4 tag $Name: geant4-06-02 $
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4VEnergyLossProcess
//
// Author: Vladimir Ivanchenko
//
// Creation date: 03.01.2002
//
// Modifications:
//
// 13-11-02 Minor fix - use normalised direction (V.Ivanchenko)
// 04-12-02 Minor change in PostStepDoIt (V.Ivanchenko)
// 23-12-02 Change interface in order to move to cut per region (V.Ivanchenko)
// 26-12-02 Secondary production moved to derived classes (V.Ivanchenko)
// 04-01-03 Fix problem of very small steps for ions (V.Ivanchenko)
// 20-01-03 Migrade to cut per region (V.Ivanchenko)
// 24-01-03 Temporarily close a control on usage of couples (V.Ivanchenko)
// 24-01-03 Make models region aware (V.Ivanchenko)
// 05-02-03 Fix compilation warnings (V.Ivanchenko)
// 06-02-03 Add control on tmax in PostStepDoIt (V.Ivanchenko)
// 13-02-03 SubCutoffProcessors defined for regions (V.Ivanchenko)
// 15-02-03 Lambda table can be scaled (V.Ivanchenko)
// 17-02-03 Fix problem of store/restore tables (V.Ivanchenko)
// 18-02-03 Add control on CutCouple usage (V.Ivanchenko)
// 26-02-03 Simplify control on GenericIons (V.Ivanchenko)
// 06-03-03 Control on GenericIons using SubType + update verbose (V.Ivanchenko)
// 10-03-03 Add Ion registration (V.Ivanchenko)
// 22-03-03 Add Initialisation of cash (V.Ivanchenko)
// 26-03-03 Remove finalRange modification (V.Ivanchenko)
// 09-04-03 Fix problem of negative range limit for non integral (V.Ivanchenko)
// 26-04-03 Fix retrieve tables (V.Ivanchenko)
// 06-05-03 Set defalt finalRange = 1 mm (V.Ivanchenko)
// 12-05-03 Update range calculations + lowKinEnergy (V.Ivanchenko)
// 13-05-03 Add calculation of precise range (V.Ivanchenko)
// 23-05-03 Remove tracking cuts (V.Ivanchenko)
// 03-06-03 Fix initialisation problem for STD ionisation (V.Ivanchenko)
// 21-07-03 Add UpdateEmModel method (V.Ivanchenko)
// 03-11-03 Fix initialisation problem in RetrievePhysicsTable (V.Ivanchenko)
// 04-11-03 Add checks in RetrievePhysicsTable (V.Ivanchenko)
// 12-11-03 G4EnergyLossSTD -> G4EnergyLossProcess (V.Ivanchenko)
// 21-01-04 Migrade to G4ParticleChangeForLoss (V.Ivanchenko)
// 27-02-04 Fix problem of loss in low presure gases, cleanup precise range
// calculation, use functions ForLoss in AlongStepDoIt (V.Ivanchenko)
// 10-03-04 Fix a problem of Precise Range table (V.Ivanchenko)
// 19-03-04 Fix a problem energy below lowestKinEnergy (V.Ivanchenko)
// 31-03-04 Fix a problem of retrieve tables (V.Ivanchenko)
//
// Class Description:
//
// It is the unified energy loss process it calculates the continuous
// energy loss for charged particles using a set of Energy Loss
// models valid for different energy regions. There are a possibility
// to create and access to dE/dx and range tables, or to calculate
// that information on fly.
// -------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "G4VEnergyLossProcess.hh"
#include "G4LossTableManager.hh"
#include "G4Step.hh"
#include "G4ParticleDefinition.hh"
#include "G4VEmModel.hh"
#include "G4VEmFluctuationModel.hh"
#include "G4DataVector.hh"
#include "G4PhysicsTable.hh"
#include "G4PhysicsVector.hh"
#include "G4PhysicsLogVector.hh"
#include "G4VParticleChange.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4Proton.hh"
#include "G4VSubCutoffProcessor.hh"
#include "G4ProcessManager.hh"
#include "G4UnitsTable.hh"
#include "G4GenericIon.hh"
#include "G4ProductionCutsTable.hh"
#include "G4Region.hh"
#include "G4RegionStore.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4VEnergyLossProcess::G4VEnergyLossProcess(const G4String& name, G4ProcessType type):
G4VContinuousDiscreteProcess(name, type),
nSCoffRegions(0),
idxSCoffRegions(0),
theDEDXTable(0),
theRangeTableForLoss(0),
thePreciseRangeTable(0),
theSecondaryRangeTable(0),
theInverseRangeTable(0),
theLambdaTable(0),
theSubLambdaTable(0),
theDEDXAtMaxEnergy(0),
theRangeAtMaxEnergy(0),
theEnergyOfCrossSectionMax(0),
theCrossSectionMax(0),
particle(0),
baseParticle(0),
secondaryParticle(0),
currentCouple(0),
nDEDXBins(90),
nDEDXBinsForRange(70),
nLambdaBins(90),
linLossLimit(0.05),
minSubRange(0.1),
defaultRoverRange(0.2),
defaultIntegralRange(1.0),
lambdaFactor(0.1),
mfpKinEnergy(0.0),
lossFluctuationFlag(true),
rndmStepFlag(false),
hasRestProcess(true),
tablesAreBuilt(false),
integral(true),
meanFreePath(true)
{
lowestKinEnergy = 1.*eV;
minKinEnergy = 0.1*keV;
maxKinEnergy = 100.0*GeV;
maxKinEnergyForRange = 1.0*GeV;
pParticleChange = &fParticleChange;
// default dRoverRange and finalRange
SetStepFunction(defaultIntegralRange, 1.0*mm);
SetVerboseLevel(0);
modelManager = new G4EmModelManager();
(G4LossTableManager::Instance())->Register(this);
scoffProcessors.clear();
scoffRegions.clear();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4VEnergyLossProcess::~G4VEnergyLossProcess()
{
Clear();
if (nSCoffRegions) {
for (G4int i=0; i<nSCoffRegions; i++) {
if (scoffProcessors[i]) {
for (G4int j=i+1; j<nSCoffRegions; j++) {
if(scoffProcessors[i] == scoffProcessors[j]) scoffProcessors[j] = 0;
}
delete scoffProcessors[i];
}
}
scoffProcessors.clear();
scoffRegions.clear();
}
delete modelManager;
(G4LossTableManager::Instance())->DeRegister(this);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::Clear()
{
if(0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::Clear() for " << GetProcessName() << G4endl;
}
if ( !baseParticle ) {
if(theDEDXTable) theDEDXTable->clearAndDestroy();
if(thePreciseRangeTable) thePreciseRangeTable->clearAndDestroy();
if(theRangeTableForLoss) theRangeTableForLoss->clearAndDestroy();
if(theInverseRangeTable) theInverseRangeTable->clearAndDestroy();
if(theLambdaTable) theLambdaTable->clearAndDestroy();
if(theSubLambdaTable) theSubLambdaTable->clearAndDestroy();
}
if(theDEDXAtMaxEnergy) delete [] theDEDXAtMaxEnergy;
if(theRangeAtMaxEnergy) delete [] theRangeAtMaxEnergy;
if(theEnergyOfCrossSectionMax) delete [] theEnergyOfCrossSectionMax;
if(theCrossSectionMax) delete [] theCrossSectionMax;
theDEDXTable = 0;
thePreciseRangeTable = 0;
theRangeTableForLoss = 0;
theInverseRangeTable = 0;
theSecondaryRangeTable = 0;
theLambdaTable = 0;
theSubLambdaTable = 0;
theDEDXAtMaxEnergy = 0;
theRangeAtMaxEnergy = 0;
theEnergyOfCrossSectionMax = 0,
theCrossSectionMax = 0,
tablesAreBuilt = false;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::Initialise()
{
if(0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::Initialise() for "
<< GetProcessName()
<< " for " << particle->GetParticleName()
<< G4endl;
}
Clear();
G4double initialCharge = particle->GetPDGCharge();
G4double initialMass = particle->GetPDGMass();
chargeSquare = initialCharge*initialCharge/(eplus*eplus);
chargeSqRatio = 1.0;
massRatio = 1.0;
reduceFactor = 1.0;
if(particle->GetProcessManager()->GetAtRestProcessVector()->size())
hasRestProcess = true;
else hasRestProcess = false;
if (baseParticle) {
massRatio = (baseParticle->GetPDGMass())/initialMass;
G4double q = initialCharge/baseParticle->GetPDGCharge();
chargeSqRatio = q*q;
reduceFactor = 1.0/(chargeSqRatio*massRatio);
}
theCuts = modelManager->Initialise(particle, secondaryParticle, minSubRange, verboseLevel);
// Sub Cutoff Regime
idxSCoffRegions.clear();
const G4ProductionCutsTable* theCoupleTable=
G4ProductionCutsTable::GetProductionCutsTable();
size_t numOfCouples = theCoupleTable->GetTableSize();
if (nSCoffRegions) {
const G4DataVector* theSubCuts = modelManager->SubCutoff();
for (G4int i=0; i<nSCoffRegions; i++) {
scoffProcessors[i]->Initialise(particle, secondaryParticle, theCuts, theSubCuts);
}
for (size_t j=0; j<numOfCouples; j++) {
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
const G4ProductionCuts* pcuts = couple->GetProductionCuts();
G4int reg = nSCoffRegions;
do {reg--;} while (reg && pcuts != (scoffRegions[reg]->GetProductionCuts()));
idxSCoffRegions.push_back(reg);
}
}
if (0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::Initialise() is done "
<< " chargeSqRatio= " << chargeSqRatio
<< " massRatio= " << massRatio
<< " reduceFactor= " << reduceFactor << G4endl;
if (nSCoffRegions) {
G4cout << " SubCutoff Regime is ON for regions: " << G4endl;
for (G4int i=0; i<nSCoffRegions; i++) {
const G4Region* r = scoffRegions[i];
G4cout << " " << r->GetName() << G4endl;
}
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::BuildPhysicsTable(const G4ParticleDefinition& part)
{
currentCouple = 0;
preStepLambda = 0.0;
preStepMFP = DBL_MAX;
if(0 < verboseLevel) {
G4cout << "========================================================" << G4endl;
G4cout << "### G4VEnergyLossProcess::BuildPhysicsTable() for "
<< GetProcessName()
<< " and particle " << part.GetParticleName()
<< G4endl;
}
if (part.GetParticleName() != "GenericIon" &&
part.GetParticleType() == "nucleus" &&
part.GetParticleSubType() == "generic")
{
(G4LossTableManager::Instance())->RegisterIon(&part, this);
/*
G4cout << part.GetProcessManager() << " "
<< (G4GenericIon::GenericIon())->GetProcessManager()
<< G4endl;
*/
return;
}
// Are particle defined?
if( !particle ) {
particle = &part;
baseParticle = DefineBaseParticle(particle);
}
// Recalculation is needed because cuts were changed or recalculation is forced
G4LossTableManager* lManager = G4LossTableManager::Instance();
if ( lManager->IsRecalcNeeded(particle) ) {
// It is responsability of the G4LossTables to build DEDX and range tables
lManager->BuildPhysicsTable(particle);
if(!baseParticle) PrintInfoDefinition();
if(0 < verboseLevel) {
G4cout << "### G4VEnergyLossProcess::BuildPhysicsTable() done for "
<< GetProcessName()
<< " and particle " << part.GetParticleName()
<< G4endl;
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::AddEmModel(G4int order, G4VEmModel* p, G4VEmFluctuationModel* fluc,
const G4Region* region)
{
modelManager->AddEmModel(order, p, fluc, region);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::UpdateEmModel(const G4String& nam, G4double emin, G4double emax)
{
modelManager->UpdateEmModel(nam, emin, emax);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::AddSubCutoffProcessor(G4VSubCutoffProcessor* p,
const G4Region* r)
{
if( !p ) {
G4cout << "G4VEnergyLossProcess::AddSubCutoffProcessor WARNING: no SubCutoffProcessor defined."
<< G4endl;
return;
}
G4RegionStore* regionStore = G4RegionStore::GetInstance();
if (!r) r = regionStore->GetRegion("DefaultRegionForTheWorld", false);
if (nSCoffRegions) {
for (G4int i=0; i<nSCoffRegions; i++) {
if (r == scoffRegions[i]) {
if ( scoffProcessors[i] ) delete scoffProcessors[i];
scoffProcessors[i] = p;
return;
}
}
}
scoffProcessors.push_back(p);
scoffRegions.push_back(r);
nSCoffRegions++;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsTable* G4VEnergyLossProcess::BuildDEDXTable()
{
if(0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::BuildDEDXTable() for "
<< GetProcessName()
<< " and particle " << particle->GetParticleName()
<< G4endl;
}
// vectors to provide continues dE/dx
G4DataVector factor;
G4DataVector dedxLow;
G4DataVector dedxHigh;
// Access to materials
const G4ProductionCutsTable* theCoupleTable=
G4ProductionCutsTable::GetProductionCutsTable();
size_t numOfCouples = theCoupleTable->GetTableSize();
G4PhysicsTable* theTable = new G4PhysicsTable(numOfCouples);
if(0 < verboseLevel) {
G4cout << numOfCouples << " materials"
<< " minKinEnergy= " << minKinEnergy
<< " maxKinEnergy= " << maxKinEnergy
<< G4endl;
}
for(size_t i=0; i<numOfCouples; i++) {
// create physics vector and fill it
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
G4PhysicsVector* aVector = DEDXPhysicsVector(couple);
modelManager->FillDEDXVector(aVector, couple);
// Insert vector for this material into the table
theTable->insert(aVector) ;
}
if(0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::BuildDEDXTable(): table is built for "
<< particle->GetParticleName()
<< G4endl;
if(2 < verboseLevel) {
G4cout << *theTable << G4endl;
}
}
return theTable;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsTable* G4VEnergyLossProcess::BuildDEDXTableForPreciseRange()
{
if(0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::BuildDEDXTableForPreciseRange() for "
<< GetProcessName()
<< " and particle " << particle->GetParticleName()
<< G4endl;
}
// vectors to provide continues dE/dx
G4DataVector factor;
G4DataVector dedxLow;
G4DataVector dedxHigh;
// Access to materials
const G4ProductionCutsTable* theCoupleTable=
G4ProductionCutsTable::GetProductionCutsTable();
size_t numOfCouples = theCoupleTable->GetTableSize();
G4PhysicsTable* theTable = new G4PhysicsTable(numOfCouples);
if(0 < verboseLevel) {
G4cout << numOfCouples << " materials"
<< " minKinEnergy= " << minKinEnergy
<< " maxKinEnergy= " << maxKinEnergy
<< G4endl;
}
for(size_t i=0; i<numOfCouples; i++) {
// create physics vector and fill it
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
G4PhysicsVector* aVector = DEDXPhysicsVectorForPreciseRange(couple);
modelManager->FillDEDXVectorForPreciseRange(aVector, couple);
// Insert vector for this material into the table
theTable->insert(aVector) ;
}
if(0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::BuildDEDXTableForPreciseRange(): table is built for "
<< particle->GetParticleName()
<< G4endl;
if(2 < verboseLevel) {
G4cout << *theTable << G4endl;
}
}
return theTable;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsTable* G4VEnergyLossProcess::BuildLambdaTable()
{
if(0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::BuildLambdaTable() for process "
<< GetProcessName() << " and particle "
<< particle->GetParticleName()
<< G4endl;
}
// Access to materials
const G4ProductionCutsTable* theCoupleTable=
G4ProductionCutsTable::GetProductionCutsTable();
size_t numOfCouples = theCoupleTable->GetTableSize();
G4PhysicsTable* theTable = new G4PhysicsTable(numOfCouples);
for(size_t i=0; i<numOfCouples; i++) {
// create physics vector and fill it
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
G4PhysicsVector* aVector = LambdaPhysicsVector(couple);
modelManager->FillLambdaVector(aVector, couple);
// Insert vector for this material into the table
theTable->insert(aVector) ;
}
if(0 < verboseLevel) {
G4cout << "Lambda table is built for "
<< particle->GetParticleName()
<< G4endl;
if(2 < verboseLevel) {
G4cout << *theTable << G4endl;
}
}
return theTable;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsTable* G4VEnergyLossProcess::BuildLambdaSubTable()
{
if(0 < verboseLevel) {
G4cout << "G4VEnergyLossProcess::BuildLambdaSubTable() for process "
<< GetProcessName() << " and particle "
<< particle->GetParticleName() << G4endl;
}
// Access to materials
const G4ProductionCutsTable* theCoupleTable=
G4ProductionCutsTable::GetProductionCutsTable();
size_t numOfCouples = theCoupleTable->GetTableSize();
G4PhysicsTable* theTable = new G4PhysicsTable(numOfCouples);
for(size_t i=0; i<numOfCouples; i++) {
// create physics vector and fill it
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
G4PhysicsVector* aVector = SubLambdaPhysicsVector(couple);
modelManager->FillSubLambdaVector(aVector, couple);
// Insert vector for this material into the table
theTable->insert(aVector) ;
}
if(0 < verboseLevel) {
G4cout << "Table is built for "
<< particle->GetParticleName()
<< G4endl;
}
return theTable;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4VParticleChange* G4VEnergyLossProcess::AlongStepDoIt(const G4Track& track,
const G4Step& step)
{
fParticleChange.InitializeForAlongStep(track);
// The process has range table - calculate energy loss
if(!theRangeTableForLoss) return &fParticleChange;
// Get the actual (true) Step length
G4double length = step.GetStepLength();
G4double eloss = 0.0;
/*
if(-1 < verboseLevel) {
const G4ParticleDefinition* d = track.GetDefinition();
G4cout << "AlongStepDoIt for "
<< GetProcessName() << " and particle "
<< d->GetParticleName()
<< " eScaled(MeV)= " << preStepScaledEnergy/MeV
<< " slim(mm)= " << fRange/mm
<< " s(mm)= " << length/mm
<< " q^2= " << chargeSqRatio
<< " md= " << d->GetPDGMass()
<< G4endl;
}
*/
// stopping
if (length >= fRange) {
eloss = preStepKinEnergy;
// Short step
} else if( length <= linLossLimit * fRange ) {
eloss = GetDEDXForLoss(preStepKinEnergy)*length;
// Long step
} else {
G4double r = GetRangeForLoss(preStepKinEnergy)/reduceFactor;
G4double x = r - length/reduceFactor;
eloss = (ScaledKinEnergyForLoss(r) - ScaledKinEnergyForLoss(x))/massRatio;
/*
if(-1 < verboseLevel) {
G4bool b;
G4cout << "rPre(mm)= " << r/mm
<< " rPost(mm)= " << x/mm
<< " ePre(MeV)= " << preStepScaledEnergy/MeV
<< " eloss(MeV)= " << eloss/MeV
<< " eloss0(MeV)= " << GetDEDXForLoss(preStepKinEnergy)*length/MeV
<< G4endl;
}
*/
}
const G4DynamicParticle* dynParticle = track.GetDynamicParticle();
G4double tmax = MaxSecondaryEnergy(dynParticle);
tmax = std::min(tmax,(*theCuts)[currentMaterialIndex]);
/*
G4double eloss0 = eloss;
if(-1 < verboseLevel) {
G4bool b;
//G4cout << *theDEDXTable << G4endl;
G4cout << "eloss(MeV)= " << eloss/MeV
<< " eloss0(MeV)= " << GetDEDXForLoss(preStepKinEnergy)*length
<< " r0(mm)= " << GetRangeForLoss(preStepKinEnergy)
<< " tmax= " << tmax
<< " e-eloss= " << preStepKinEnergy-eloss
// << " preCouple= " << (step.GetPreStepPoint())->GetMaterialCutsCouple()
// << " postCouple= " << (step.GetPostStepPoint())->GetMaterialCutsCouple()
<< G4endl;
}
*/
// Sample fluctuations
if (lossFluctuationFlag && eloss + lowestKinEnergy <= preStepKinEnergy) {
eloss = modelManager->SampleFluctuations(currentMaterial, dynParticle,
tmax, length, eloss, preStepScaledEnergy,
currentMaterialIndex);
}
/*
if(-1 < verboseLevel) {
G4cout << "eloss(MeV)= " << eloss/MeV
<< " fluc= " << (eloss-eloss0)/MeV
<< " currentChargeSquare= " << chargeSquare
<< " massRatio= " << massRatio
<< G4endl;
}
*/
G4double finalT = preStepKinEnergy - eloss;
if (finalT <= lowestKinEnergy) {
finalT = 0.0;
if (hasRestProcess) fParticleChange.SetStatusChange(fStopButAlive);
else fParticleChange.SetStatusChange(fStopAndKill);
}
eloss = preStepKinEnergy-finalT;
fParticleChange.SetProposedKineticEnergy(finalT);
// Subcutoff and/or deexcitation
std::vector<G4Track*>* newp =
SecondariesAlongStep(step, tmax, eloss, preStepScaledEnergy);
if(newp) {
G4int n = newp->size();
if(n > 0) {
fParticleChange.SetNumberOfSecondaries(n);
G4Track* t;
G4double e;
for (G4int i=0; i<n; i++) {
t = (*newp)[i];
e = t->GetKineticEnergy();
const G4ParticleDefinition* pd = t->GetDefinition();
if (pd != G4Positron::Positron() ) e += electron_mass_c2;
if (e > eloss) e = eloss;
eloss -= e;
pParticleChange->AddSecondary(t);
}
}
delete newp;
}
/*
if(-1 < verboseLevel) {
G4cout << "Final value eloss(MeV)= " << eloss/MeV
<< " preStepKinEnergy= " << preStepKinEnergy
<< " postStepKinEnergy= " << finalT
<< " lossFlag= " << lossFluctuationFlag
<< G4endl;
}
*/
fParticleChange.SetLocalEnergyDeposit(eloss);
return &fParticleChange;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4VParticleChange* G4VEnergyLossProcess::PostStepDoIt(const G4Track& track,
const G4Step& step)
{
fParticleChange.InitializeForPostStep(track);
G4double finalT = track.GetKineticEnergy();
G4double postStepScaledEnergy = finalT*massRatio;
// Integral approach
if (integral) {
if(preStepLambda*G4UniformRand() > GetLambda(postStepScaledEnergy))
return G4VContinuousDiscreteProcess::PostStepDoIt(track,step);
}
G4VEmModel* currentModel = SelectModel(postStepScaledEnergy);
G4double tcut = (*theCuts)[currentMaterialIndex];
const G4DynamicParticle* dynParticle = track.GetDynamicParticle();
G4double tmax = currentModel->MaxSecondaryEnergy(dynParticle);
/*
if(0 < verboseLevel) {
const G4ParticleDefinition* pd = dynParticle->GetDefinition();
G4cout << "G4VEnergyLossProcess::PostStepDoIt: Sample secondary; E= " << finalT/MeV
<< " MeV; model= (" << currentModel->LowEnergyLimit(pd)
<< ", " << currentModel->HighEnergyLimit(pd) << ")"
<< G4endl;
}
*/
if (tcut < tmax)
SecondariesPostStep(currentModel,currentCouple,dynParticle,tcut,finalT);
if (finalT <= 0.0) {
fParticleChange.SetProposedKineticEnergy(0.0);
if (hasRestProcess) fParticleChange.SetStatusChange(fStopButAlive);
else fParticleChange.SetStatusChange(fStopAndKill);
return &fParticleChange;
}
fParticleChange.SetProposedKineticEnergy(finalT);
return G4VContinuousDiscreteProcess::PostStepDoIt(track,step);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::PrintInfoDefinition()
{
if(-1 < verboseLevel) {
G4cout << G4endl << GetProcessName() << ": tables are built for "
<< particle->GetParticleName()
<< G4endl
<< " dE/dx and range tables from "
<< G4BestUnit(minKinEnergy,"Energy")
<< " to " << G4BestUnit(maxKinEnergy,"Energy")
<< " in " << nDEDXBins << " bins." << G4endl
<< " Lambda tables from threshold to "
<< G4BestUnit(maxKinEnergy,"Energy")
<< " in " << nLambdaBins << " bins."
<< G4endl;
if(theRangeTableForLoss) {
G4cout << " Step function: finalRange(mm)= " << finalRange/mm
<< ", dRoverRange= " << dRoverRange
<< ", integral: " << integral
<< G4endl;
}
if(thePreciseRangeTable) {
G4cout << " Precise range table up"
<< " to " << G4BestUnit(maxKinEnergyForRange,"Energy")
<< " in " << nDEDXBinsForRange << " bins." << G4endl;
}
if(2 < verboseLevel) {
G4cout << "DEDXTable address= " << theDEDXTable << G4endl;
if(theDEDXTable) G4cout << (*theDEDXTable) << G4endl;
G4cout << "PreciseRangeTable address= " << thePreciseRangeTable << G4endl;
if(thePreciseRangeTable) G4cout << (*thePreciseRangeTable) << G4endl;
G4cout << "RangeTableForLoss address= " << theRangeTableForLoss << G4endl;
if(theRangeTableForLoss) G4cout << (*theRangeTableForLoss) << G4endl;
G4cout << "InverseRangeTable address= " << theInverseRangeTable << G4endl;
if(theInverseRangeTable) G4cout << (*theInverseRangeTable) << G4endl;
G4cout << "LambdaTable address= " << theLambdaTable << G4endl;
if(theLambdaTable) G4cout << (*theLambdaTable) << G4endl;
G4cout << "SubLambdaTable address= " << theSubLambdaTable << G4endl;
if(theSubLambdaTable) G4cout << (*theSubLambdaTable) << G4endl;
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetDEDXTable(G4PhysicsTable* p)
{
if(theDEDXTable && !baseParticle) theDEDXTable->clearAndDestroy();
theDEDXTable = p;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetPreciseRangeTable(G4PhysicsTable* p)
{
if(thePreciseRangeTable && !baseParticle) thePreciseRangeTable->clearAndDestroy();
if(theDEDXAtMaxEnergy) delete [] theDEDXAtMaxEnergy;
if(theRangeAtMaxEnergy) delete [] theRangeAtMaxEnergy;
thePreciseRangeTable = p;
if(p) {
size_t n = p->length();
G4PhysicsVector* pv = (*p)[0];
// G4double emax = pv->GetLowEdgeEnergy(pv->GetVectorLength());
G4double emax = maxKinEnergyForRange;
G4bool b;
theDEDXAtMaxEnergy = new G4double [n];
theRangeAtMaxEnergy = new G4double [n];
for (size_t i=0; i<n; i++) {
pv = (*p)[i];
G4double r2 = pv->GetValue(emax, b);
G4double dedx = ((*theDEDXTable)[i])->GetValue(emax,b);
theDEDXAtMaxEnergy[i] = dedx;
theRangeAtMaxEnergy[i] = r2;
//G4cout << "i= " << i << " e2(MeV)= " << emax/MeV << " r2= " << r2
// << " dedx= " << dedx << G4endl;
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetRangeTableForLoss(G4PhysicsTable* p)
{
if(theRangeTableForLoss && !baseParticle) theRangeTableForLoss->clearAndDestroy();
theRangeTableForLoss = p;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetSecondaryRangeTable(G4PhysicsTable* p)
{
theSecondaryRangeTable = p;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetInverseRangeTable(G4PhysicsTable* p)
{
if(theInverseRangeTable && !baseParticle) theInverseRangeTable->clearAndDestroy();
theInverseRangeTable = p;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetLambdaTable(G4PhysicsTable* p)
{
if(theLambdaTable && !baseParticle) theLambdaTable->clearAndDestroy();
theLambdaTable = p;
tablesAreBuilt = true;
if(theEnergyOfCrossSectionMax) delete [] theEnergyOfCrossSectionMax;
if(theCrossSectionMax) delete [] theCrossSectionMax;
if(p) {
size_t n = p->length();
G4PhysicsVector* pv = (*p)[0];
size_t nb = pv->GetVectorLength();
G4double emax = pv->GetLowEdgeEnergy(nb);
G4double e, s, smax = 0.0;
theEnergyOfCrossSectionMax = new G4double [n];
theCrossSectionMax = new G4double [n];
G4bool b;
for (size_t i=0; i<n; i++) {
pv = (*p)[i];
smax = 0.0;
for (size_t j=0; j<nb; j++) {
e = pv->GetLowEdgeEnergy(j);
s = pv->GetValue(e,b);
if(s > smax) {
smax = s;
emax = e;
}
}
theEnergyOfCrossSectionMax[i] = emax;
theCrossSectionMax[i] = smax;
// G4cout << "i= " << i << " e2(MeV)= " << emax/MeV
// << " lambda= " << smax << G4endl;
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetSubLambdaTable(G4PhysicsTable* p)
{
if(theSubLambdaTable && !baseParticle) theSubLambdaTable->clearAndDestroy();
theSubLambdaTable = p;
if (nSCoffRegions) {
for (G4int i=0; i<nSCoffRegions; i++) {
scoffProcessors[i]->SetLambdaSubTable(theSubLambdaTable);
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsVector* G4VEnergyLossProcess::DEDXPhysicsVector(const G4MaterialCutsCouple*)
{
G4int nbins = nDEDXBins;
G4PhysicsVector* v = new G4PhysicsLogVector(minKinEnergy, maxKinEnergy, nbins);
return v;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsVector* G4VEnergyLossProcess::DEDXPhysicsVectorForPreciseRange(
const G4MaterialCutsCouple*)
{
G4int nbins = nDEDXBinsForRange;
G4PhysicsVector* v = new G4PhysicsLogVector(minKinEnergy, maxKinEnergyForRange, nbins);
return v;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsVector* G4VEnergyLossProcess::LambdaPhysicsVector(const G4MaterialCutsCouple* couple)
{
G4double cut = (*theCuts)[couple->GetIndex()];
G4int nbins = nLambdaBins;
G4double tmin = std::max(MinPrimaryEnergy(particle, couple->GetMaterial(), cut),
minKinEnergy);
if(tmin >= maxKinEnergy) tmin = 0.5*maxKinEnergy;
G4PhysicsVector* v = new G4PhysicsLogVector(tmin, maxKinEnergy, nbins);
return v;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsVector* G4VEnergyLossProcess::SubLambdaPhysicsVector(const G4MaterialCutsCouple* couple)
{
return LambdaPhysicsVector(couple);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4VEnergyLossProcess::MicroscopicCrossSection(G4double kineticEnergy,
const G4MaterialCutsCouple* couple)
{
// Cross section per atom is calculated
DefineMaterial(couple);
G4double cross = 0.0;
G4bool b;
if(theLambdaTable) {
cross = (((*theLambdaTable)[currentMaterialIndex])->
GetValue(kineticEnergy, b));
cross /= currentMaterial->GetTotNbOfAtomsPerVolume();
}
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4VEnergyLossProcess::MeanFreePath(const G4Track& track,
G4double s,
G4ForceCondition* cond)
{
return GetMeanFreePath(track, s, cond);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4VEnergyLossProcess::ContinuousStepLimit(const G4Track& track,
G4double x, G4double y, G4double& z)
{
return GetContinuousStepLimit(track, x, y, z);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetStepLimits(G4double v1, G4double v2)
{
dRoverRange = v1;
finalRange = v2;
if (dRoverRange > 1.0) dRoverRange = 1.0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetIntegral(G4bool val)
{
if(integral != val) {
if(val) dRoverRange = defaultIntegralRange;
else dRoverRange = defaultRoverRange;
}
integral = val;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetStepFunction(G4double v1, G4double v2)
{
dRoverRange = v1;
finalRange = v2;
if (dRoverRange > 0.999) dRoverRange = 1.0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetParticle(const G4ParticleDefinition* p)
{
particle = p;
baseParticle = DefineBaseParticle(particle);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetBaseParticle(const G4ParticleDefinition* p)
{
baseParticle = p;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetSecondaryParticle(const G4ParticleDefinition* p)
{
secondaryParticle = p;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4bool G4VEnergyLossProcess::StorePhysicsTable(G4ParticleDefinition* part,
const G4String& directory,
G4bool ascii)
{
G4bool res = true;
if ( baseParticle ) return res;
G4bool yes = true;
if ( theDEDXTable ) {
const G4String name = GetPhysicsTableFileName(part,directory,"DEDX",ascii);
yes = theDEDXTable->StorePhysicsTable(name,ascii);
if( !yes ) res = false;
}
if ( thePreciseRangeTable ) {
const G4String name = GetPhysicsTableFileName(part,directory,"PreciseRange",ascii);
yes = thePreciseRangeTable->StorePhysicsTable(name,ascii);
if( !yes ) res = false;
}
if ( theRangeTableForLoss ) {
const G4String name = GetPhysicsTableFileName(part,directory,"Range",ascii);
yes = theRangeTableForLoss->StorePhysicsTable(name,ascii);
if( !yes ) res = false;
}
if ( theInverseRangeTable ) {
const G4String name = GetPhysicsTableFileName(part,directory,"InverseRange",ascii);
yes = theInverseRangeTable->StorePhysicsTable(name,ascii);
if( !yes ) res = false;
}
if ( theLambdaTable ) {
const G4String name = GetPhysicsTableFileName(part,directory,"Lambda",ascii);
yes = theLambdaTable->StorePhysicsTable(name,ascii);
if( !yes ) res = false;
}
if ( theSubLambdaTable ) {
const G4String name = GetPhysicsTableFileName(part,directory,"SubLambda",ascii);
yes = theSubLambdaTable->StorePhysicsTable(name,ascii);
if( !yes ) res = false;
}
if ( res ) {
G4cout << "Physics tables are stored for " << particle->GetParticleName()
<< " and process " << GetProcessName()
<< " in the directory <" << directory
<< "> " << G4endl;
} else {
G4cout << "Fail to store Physics Tables for " << particle->GetParticleName()
<< " and process " << GetProcessName()
<< " in the directory <" << directory
<< "> " << G4endl;
}
return res;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4bool G4VEnergyLossProcess::RetrievePhysicsTable(G4ParticleDefinition* part,
const G4String& directory,
G4bool ascii)
{
G4bool res = true;
currentCouple = 0;
preStepLambda = 0.0;
if(0 < verboseLevel) {
G4cout << "========================================================" << G4endl;
G4cout << "G4VEnergyLossProcess::RetrievePhysicsTable() for "
<< part->GetParticleName() << " and process " << GetProcessName()
<< "; tables_are_built= " << tablesAreBuilt
<< G4endl;
}
const G4String particleName = part->GetParticleName();
if( !particle ) {
particle = part;
baseParticle = DefineBaseParticle(particle);
}
if(particleName != "GenericIon" &&
part->GetParticleType() == "nucleus" &&
part->GetParticleSubType() == "generic")
{
(G4LossTableManager::Instance())->RegisterIon(part, this);
return res;
}
if(tablesAreBuilt) return res;
Initialise();
// Recalculation is needed because cuts were changed or recalculation is forced
G4LossTableManager* lManager = G4LossTableManager::Instance();
if ( lManager->IsRecalcNeeded(particle)) {
G4bool yes = true;
G4bool fpi = true;
if ( !baseParticle ) {
G4PhysicsTable* table;
G4String filename;
const G4ProductionCutsTable* theCoupleTable=
G4ProductionCutsTable::GetProductionCutsTable();
size_t numOfCouples = theCoupleTable->GetTableSize();
filename = GetPhysicsTableFileName(part,directory,"DEDX",ascii);
table = new G4PhysicsTable(numOfCouples);
yes = table->ExistPhysicsTable(filename);
if(yes) yes = table->RetrievePhysicsTable(filename,ascii);
if(yes) {
SetDEDXTable(table);
if (-1 < verboseLevel) {
G4cout << "DEDX table for " << particleName << " is retrieved from <"
<< filename << ">"
<< G4endl;
}
} else {
fpi = false;
table->clearAndDestroy();
if (0 < verboseLevel) {
G4cout << "DEDX table for " << particleName << " from file <"
<< filename << "> is not retrieved"
<< G4endl;
}
}
filename = GetPhysicsTableFileName(part,directory,"Range",ascii);
table = new G4PhysicsTable(numOfCouples);
yes = table->ExistPhysicsTable(filename);
if(yes) yes = table->RetrievePhysicsTable(filename,ascii);
if(yes) {
SetRangeTableForLoss(table);
if (-1 < verboseLevel) {
G4cout << "Range table for loss for " << particleName << " is retrieved from <"
<< filename << ">"
<< G4endl;
}
} else {
table->clearAndDestroy();
if(fpi) {
res = false;
G4cout << "Range table for loss for " << particleName << " from file <"
<< filename << "> is not retrieved"
<< G4endl;
}
}
filename = GetPhysicsTableFileName(part,directory,"PreciseRange",ascii);
table = new G4PhysicsTable(numOfCouples);
yes = table->ExistPhysicsTable(filename);
if(yes) yes = table->RetrievePhysicsTable(filename,ascii);
if(yes) {
SetPreciseRangeTable(table);
if (-1 < verboseLevel) {
G4cout << "Precise Range table for " << particleName << " is retrieved from <"
<< filename << ">"
<< G4endl;
}
} else {
table->clearAndDestroy();
G4cout << "Precise Range table for loss for " << particleName << " does not exist"
<< G4endl;
}
filename = GetPhysicsTableFileName(part,directory,"InverseRange",ascii);
table = new G4PhysicsTable(numOfCouples);
yes = table->ExistPhysicsTable(filename);
if(yes) yes = table->RetrievePhysicsTable(filename,ascii);
if(yes) {
SetInverseRangeTable(table);
if (-1 < verboseLevel) {
G4cout << "InverseRange table for " << particleName << " is retrieved from <"
<< filename << ">"
<< G4endl;
}
} else {
table->clearAndDestroy();
if(fpi) {
res = false;
G4cout << "InverseRange table for " << particleName << " from file <"
<< filename << "> is not retrieved"
<< G4endl;
}
}
filename = GetPhysicsTableFileName(part,directory,"Lambda",ascii);
table = new G4PhysicsTable(numOfCouples);
yes = table->ExistPhysicsTable(filename);
if(yes) yes = table->RetrievePhysicsTable(filename,ascii);
if(yes) {
SetLambdaTable(table);
if (-1 < verboseLevel) {
G4cout << "Lambda table for " << particleName << " is retrieved from <"
<< filename << ">"
<< G4endl;
}
} else {
table->clearAndDestroy();
if(fpi) {
res = false;
G4cout << "Lambda table for " << particleName << " from file <"
<< filename << "> is not retrieved"
<< G4endl;
}
}
filename = GetPhysicsTableFileName(part,directory,"SubLambda",ascii);
table = new G4PhysicsTable(numOfCouples);
yes = table->ExistPhysicsTable(filename);
if(yes) yes = table->RetrievePhysicsTable(filename,ascii);
if(yes) {
SetSubLambdaTable(table);
if (-1 < verboseLevel) {
G4cout << "SubLambda table for " << particleName << " is retrieved from <"
<< filename << ">"
<< G4endl;
}
} else {
table->clearAndDestroy();
if(nSCoffRegions) {
res=false;
G4cout << "SubLambda table for " << particleName << " from file <"
<< filename << "> is not retrieved"
<< G4endl;
}
}
if(res) PrintInfoDefinition();
else {
G4cout << "### BuildPhysicsTable will be requested for " << GetProcessName()
<< " for " << particleName << G4endl;
}
}
tablesAreBuilt = true;
}
lManager->RetrievePhysicsTables(particle, this);
return res;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetLinearLossLimit(G4double val)
{
linLossLimit = val;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetLossFluctuations(G4bool val)
{
lossFluctuationFlag = val;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetSubCutoff(G4bool)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetRandomStep(G4bool val)
{
rndmStepFlag = val;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetMinSubRange(G4double val)
{
minSubRange = val;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4bool G4VEnergyLossProcess::TablesAreBuilt() const
{
return tablesAreBuilt;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4int G4VEnergyLossProcess::NumberOfSubCutoffRegions() const
{
return nSCoffRegions;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
const G4ParticleDefinition* G4VEnergyLossProcess::DefineBaseParticle(
const G4ParticleDefinition*)
{
return 0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetDEDXBinning(G4int nbins)
{
nDEDXBins = nbins;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetDEDXBinningForPreciseRange(G4int nbins)
{
nDEDXBinsForRange = nbins;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetLambdaBinning(G4int nbins)
{
nLambdaBins = nbins;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4VEnergyLossProcess::MinKinEnergy() const
{
return minKinEnergy;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetMinKinEnergy(G4double e)
{
minKinEnergy = e;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetMaxKinEnergy(G4double e)
{
maxKinEnergy = e;
if(e < maxKinEnergyForRange) maxKinEnergyForRange = e;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetMaxKinEnergyForPreciseRange(G4double e)
{
maxKinEnergyForRange = e;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4VEnergyLossProcess::MaxKinEnergy() const
{
return maxKinEnergy;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::ActivateFluorescence(G4bool, const G4Region*)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::ActivateAugerElectronProduction(G4bool, const G4Region*)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4VEnergyLossProcess::SetLambdaFactor(G4double val)
{
if(val > 0.0 && val <= 1.0) lambdaFactor = val;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
Reference in New Issue View Git Blame Copy Permalink