Import Geant4 10.7.0 source tree

2020-12-04 12:30:43 +01:00
parent 67ba86d073
commit dab42d2018
3770 changed files with 226369 additions and 286486 deletions
@@ -56,7 +56,6 @@
 //              > add protection against /0
 //              > G4MaterialPropertiesTable; new physics/tracking scheme
 //
-// mail:        gum@triumf.ca
 //
 ////////////////////////////////////////////////////////////////////////

@@ -70,30 +69,30 @@
 #include "G4MaterialCutsCouple.hh"
 #include "G4ParticleDefinition.hh"

+#include "G4OpticalParameters.hh"
 #include "G4Cerenkov.hh"

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 G4Cerenkov::G4Cerenkov(const G4String& processName, G4ProcessType type)
-           : G4VProcess(processName, type),
-             fTrackSecondariesFirst(false),
-             fMaxBetaChange(0.0),
-             fMaxPhotons(0),
-             fStackingFlag(true),
-             fNumPhotons(0)
+  : G4VProcess(processName, type)
+  , fNumPhotons(0)
 {
  SetProcessSubType(fCerenkov);

  thePhysicsTable = nullptr;

-  if (verboseLevel>0) {
+  if(verboseLevel > 0)
+  {
    G4cout << GetProcessName() << " is created." << G4endl;
  }
+  Initialise();
 }

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 G4Cerenkov::~G4Cerenkov()
 {
-  if (thePhysicsTable != nullptr) {
+  if(thePhysicsTable != nullptr)
+  {
    thePhysicsTable->clearAndDestroy();
    delete thePhysicsTable;
  }
@@ -103,38 +102,102 @@ G4Cerenkov::~G4Cerenkov()
 G4bool G4Cerenkov::IsApplicable(const G4ParticleDefinition& aParticleType)
 {
  return (aParticleType.GetPDGCharge() != 0.0 &&
-	        aParticleType.GetPDGMass() != 0.0 &&
-	        aParticleType.GetParticleName() != "chargedgeantino" &&
-	       !aParticleType.IsShortLived() ) ? true : false;
+          aParticleType.GetPDGMass() != 0.0 &&
+          aParticleType.GetParticleName() != "chargedgeantino" &&
+          !aParticleType.IsShortLived())
+           ? true
+           : false;
 }

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
-void G4Cerenkov::SetTrackSecondariesFirst(const G4bool state)
+void G4Cerenkov::Initialise()
 {
-  fTrackSecondariesFirst = state;
-}
-
-//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
-void G4Cerenkov::SetMaxBetaChangePerStep(const G4double value)
-{
-  fMaxBetaChange = value*CLHEP::perCent;
-}
-
-//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
-void G4Cerenkov::SetMaxNumPhotonsPerStep(const G4int NumPhotons)
-{
-  fMaxPhotons = NumPhotons;
+  G4OpticalParameters* params = G4OpticalParameters::Instance();
+  SetMaxBetaChangePerStep(params->GetCerenkovMaxBetaChange());
+  SetMaxNumPhotonsPerStep(params->GetCerenkovMaxPhotonsPerStep());
+  SetTrackSecondariesFirst(params->GetCerenkovTrackSecondariesFirst());
+  SetStackPhotons(params->GetCerenkovStackPhotons());
+  SetVerboseLevel(params->GetCerenkovVerboseLevel());
 }

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 void G4Cerenkov::BuildPhysicsTable(const G4ParticleDefinition&)
 {
-  if (!thePhysicsTable) BuildThePhysicsTable();
+  if(thePhysicsTable)
+    return;
+
+  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
+  G4int numOfMaterials                    = G4Material::GetNumberOfMaterials();
+
+  thePhysicsTable = new G4PhysicsTable(numOfMaterials);
+
+  // loop over materials
+  for(G4int i = 0; i < numOfMaterials; ++i)
+  {
+    G4PhysicsOrderedFreeVector* aPhysicsOrderedFreeVector = 0;
+
+    // Retrieve vector of refraction indices for the material
+    // from the material's optical properties table
+    G4Material* aMaterial = (*theMaterialTable)[i];
+    G4MaterialPropertiesTable* aMaterialPropertiesTable =
+      aMaterial->GetMaterialPropertiesTable();
+
+    if(aMaterialPropertiesTable)
+    {
+      aPhysicsOrderedFreeVector = new G4PhysicsOrderedFreeVector();
+      G4MaterialPropertyVector* theRefractionIndexVector =
+        aMaterialPropertiesTable->GetProperty(kRINDEX);
+
+      if(theRefractionIndexVector)
+      {
+        // Retrieve the first refraction index in vector
+        // of (photon energy, refraction index) pairs
+        G4double currentRI = (*theRefractionIndexVector)[0];
+
+        if(currentRI > 1.0)
+        {
+          // Create first (photon energy, Cerenkov Integral) pair
+          G4double currentPM  = theRefractionIndexVector->Energy(0);
+          G4double currentCAI = 0.0;
+
+          aPhysicsOrderedFreeVector->InsertValues(currentPM, currentCAI);
+
+          // Set previous values to current ones prior to loop
+          G4double prevPM  = currentPM;
+          G4double prevCAI = currentCAI;
+          G4double prevRI  = currentRI;
+
+          // loop over all (photon energy, refraction index)
+          // pairs stored for this material
+          for(size_t ii = 1; ii < theRefractionIndexVector->GetVectorLength();
+              ++ii)
+          {
+            currentRI  = (*theRefractionIndexVector)[ii];
+            currentPM  = theRefractionIndexVector->Energy(ii);
+            currentCAI = prevCAI + (currentPM - prevPM) * 0.5 *
+                                     (1.0 / (prevRI * prevRI) +
+                                      1.0 / (currentRI * currentRI));
+
+            aPhysicsOrderedFreeVector->InsertValues(currentPM, currentCAI);
+
+            prevPM  = currentPM;
+            prevCAI = currentCAI;
+            prevRI  = currentRI;
+          }
+        }
+      }
+    }
+
+    // The Cerenkov integral for a given material will be inserted in
+    // thePhysicsTable according to the position of the material in
+    // the material table.
+    thePhysicsTable->insertAt(i, aPhysicsOrderedFreeVector);
+  }
 }

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
-G4VParticleChange*
-G4Cerenkov::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
+G4VParticleChange* G4Cerenkov::PostStepDoIt(const G4Track& aTrack,
+                                            const G4Step& aStep)
 // This routine is called for each tracking Step of a charged particle
 // in a radiator. A Poisson-distributed number of photons is generated
 // according to the Cerenkov formula, distributed evenly along the track
@@ -150,43 +213,45 @@ G4Cerenkov::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
  aParticleChange.Initialize(aTrack);

  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
-  const G4Material* aMaterial = aTrack.GetMaterial();
+  const G4Material* aMaterial        = aTrack.GetMaterial();

  G4StepPoint* pPreStepPoint  = aStep.GetPreStepPoint();
  G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();

  G4ThreeVector x0 = pPreStepPoint->GetPosition();
  G4ThreeVector p0 = aStep.GetDeltaPosition().unit();
-  G4double      t0 = pPreStepPoint->GetGlobalTime();
+  G4double t0      = pPreStepPoint->GetGlobalTime();

-  G4MaterialPropertiesTable* aMaterialPropertiesTable =
-                               aMaterial->GetMaterialPropertiesTable();
-  if (!aMaterialPropertiesTable) return pParticleChange;
+  G4MaterialPropertiesTable* MPT = aMaterial->GetMaterialPropertiesTable();
+  if(!MPT)
+    return pParticleChange;

-  G4MaterialPropertyVector* Rindex = 
-                aMaterialPropertiesTable->GetProperty(kRINDEX); 
-  if (!Rindex) return pParticleChange;
+  G4MaterialPropertyVector* Rindex = MPT->GetProperty(kRINDEX);
+  if(!Rindex)
+    return pParticleChange;

  G4double charge = aParticle->GetDefinition()->GetPDGCharge();
-  G4double beta = (pPreStepPoint->GetBeta() + pPostStepPoint->GetBeta())*0.5;
+  G4double beta = (pPreStepPoint->GetBeta() + pPostStepPoint->GetBeta()) * 0.5;

-  //fNumPhotons = 0;  // in PostStepGetPhysicalInteractionLength()
+  // fNumPhotons = 0;  // in PostStepGetPhysicalInteractionLength()

-  G4double MeanNumberOfPhotons = 
-                     GetAverageNumberOfPhotons(charge,beta,aMaterial,Rindex);
+  G4double MeanNumberOfPhotons =
+    GetAverageNumberOfPhotons(charge, beta, aMaterial, Rindex);

-  if (MeanNumberOfPhotons <= 0.0) {
+  if(MeanNumberOfPhotons <= 0.0)
+  {
    // return unchanged particle and no secondaries
    aParticleChange.SetNumberOfSecondaries(0);
    return pParticleChange;
  }

  G4double step_length = aStep.GetStepLength();
-  MeanNumberOfPhotons = MeanNumberOfPhotons * step_length;
-  fNumPhotons = (G4int)G4Poisson(MeanNumberOfPhotons);
+  MeanNumberOfPhotons  = MeanNumberOfPhotons * step_length;
+  fNumPhotons          = (G4int) G4Poisson(MeanNumberOfPhotons);

-  if (fNumPhotons <= 0 || !fStackingFlag) {
-    // return unchanged particle and no secondaries  
+  if(fNumPhotons <= 0 || !fStackingFlag)
+  {
+    // return unchanged particle and no secondaries
    aParticleChange.SetNumberOfSecondaries(0);
    return pParticleChange;
  }
@@ -194,66 +259,71 @@ G4Cerenkov::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
  ////////////////////////////////////////////////////////////////
  aParticleChange.SetNumberOfSecondaries(fNumPhotons);

-  if (fTrackSecondariesFirst) {
-    if (aTrack.GetTrackStatus() == fAlive)
-                           aParticleChange.ProposeTrackStatus(fSuspend);
+  if(fTrackSecondariesFirst)
+  {
+    if(aTrack.GetTrackStatus() == fAlive)
+      aParticleChange.ProposeTrackStatus(fSuspend);
  }

  ////////////////////////////////////////////////////////////////
  G4double Pmin = Rindex->GetMinLowEdgeEnergy();
  G4double Pmax = Rindex->GetMaxLowEdgeEnergy();
-  G4double dp = Pmax - Pmin;
+  G4double dp   = Pmax - Pmin;

-  G4double nMax = Rindex->GetMaxValue();
-  G4double BetaInverse = 1./beta;
+  G4double nMax        = Rindex->GetMaxValue();
+  G4double BetaInverse = 1. / beta;

-  G4double maxCos = BetaInverse / nMax; 
+  G4double maxCos  = BetaInverse / nMax;
  G4double maxSin2 = (1.0 - maxCos) * (1.0 + maxCos);

-  G4double beta1 = pPreStepPoint ->GetBeta();
+  G4double beta1 = pPreStepPoint->GetBeta();
  G4double beta2 = pPostStepPoint->GetBeta();

  G4double MeanNumberOfPhotons1 =
-                     GetAverageNumberOfPhotons(charge,beta1,aMaterial,Rindex);
+    GetAverageNumberOfPhotons(charge, beta1, aMaterial, Rindex);
  G4double MeanNumberOfPhotons2 =
-                     GetAverageNumberOfPhotons(charge,beta2,aMaterial,Rindex);
+    GetAverageNumberOfPhotons(charge, beta2, aMaterial, Rindex);

-  for (G4int i=0; i<fNumPhotons; ++i) {
+  for(G4int i = 0; i < fNumPhotons; ++i)
+  {
    // Determine photon energy
    G4double rand;
-    G4double sampledEnergy, sampledRI; 
+    G4double sampledEnergy, sampledRI;
    G4double cosTheta, sin2Theta;

    // sample an energy
-    do {
-      rand = G4UniformRand();	
-      sampledEnergy = Pmin + rand * dp; 
-      sampledRI = Rindex->Value(sampledEnergy);
-      cosTheta = BetaInverse / sampledRI;  
+    do
+    {
+      rand          = G4UniformRand();
+      sampledEnergy = Pmin + rand * dp;
+      sampledRI     = Rindex->Value(sampledEnergy);
+      cosTheta      = BetaInverse / sampledRI;

-      sin2Theta = (1.0 - cosTheta)*(1.0 + cosTheta);
-      rand = G4UniformRand();	
+      sin2Theta = (1.0 - cosTheta) * (1.0 + cosTheta);
+      rand      = G4UniformRand();

      // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
-    } while (rand*maxSin2 > sin2Theta);
+    } while(rand * maxSin2 > sin2Theta);

    // Create photon momentum direction vector. The momentum direction is still
    // with respect to the coordinate system where the primary particle
-    // direction is aligned with the z axis  
-    rand = G4UniformRand();
-    G4double phi = twopi*rand;
-    G4double sinPhi = std::sin(phi);
-    G4double cosPhi = std::cos(phi);
-    G4double sinTheta = std::sqrt(sin2Theta); 
-    G4ParticleMomentum photonMomentum(sinTheta*cosPhi, sinTheta*sinPhi, cosTheta);
+    // direction is aligned with the z axis
+    rand              = G4UniformRand();
+    G4double phi      = twopi * rand;
+    G4double sinPhi   = std::sin(phi);
+    G4double cosPhi   = std::cos(phi);
+    G4double sinTheta = std::sqrt(sin2Theta);
+    G4ParticleMomentum photonMomentum(sinTheta * cosPhi, sinTheta * sinPhi,
+                                      cosTheta);

-    // Rotate momentum direction back to global reference system 
+    // Rotate momentum direction back to global reference system
    photonMomentum.rotateUz(p0);

-    // Determine polarization of new photon 
-    G4ThreeVector photonPolarization(cosTheta*cosPhi, cosTheta*sinPhi, -sinTheta);
+    // Determine polarization of new photon
+    G4ThreeVector photonPolarization(cosTheta * cosPhi, cosTheta * sinPhi,
+                                     -sinTheta);

-    // Rotate back to original coord system 
+    // Rotate back to original coord system
    photonPolarization.rotateUz(p0);

    // Generate a new photon:
@@ -265,285 +335,258 @@ G4Cerenkov::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)

    G4double NumberOfPhotons, N;

-    do {
-      rand = G4UniformRand();
-      NumberOfPhotons = MeanNumberOfPhotons1 - rand *
-                             (MeanNumberOfPhotons1-MeanNumberOfPhotons2);
-      N = G4UniformRand() *
-                     std::max(MeanNumberOfPhotons1,MeanNumberOfPhotons2);
+    do
+    {
+      rand            = G4UniformRand();
+      NumberOfPhotons = MeanNumberOfPhotons1 -
+                        rand * (MeanNumberOfPhotons1 - MeanNumberOfPhotons2);
+      N =
+        G4UniformRand() * std::max(MeanNumberOfPhotons1, MeanNumberOfPhotons2);
      // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
-    } while (N > NumberOfPhotons);
+    } while(N > NumberOfPhotons);

    G4double delta = rand * aStep.GetStepLength();
-    G4double deltaTime = delta / (pPreStepPoint->GetVelocity() +
-                                  rand*(pPostStepPoint->GetVelocity() -
-                                  pPreStepPoint->GetVelocity())*0.5);
+    G4double deltaTime =
+      delta /
+      (pPreStepPoint->GetVelocity() +
+       rand * (pPostStepPoint->GetVelocity() - pPreStepPoint->GetVelocity()) *
+         0.5);

-    G4double aSecondaryTime = t0 + deltaTime;
+    G4double aSecondaryTime          = t0 + deltaTime;
    G4ThreeVector aSecondaryPosition = x0 + rand * aStep.GetDeltaPosition();

    // Generate new G4Track object:
-    G4Track* aSecondaryTrack = 
-             new G4Track(aCerenkovPhoton,aSecondaryTime,aSecondaryPosition);
+    G4Track* aSecondaryTrack =
+      new G4Track(aCerenkovPhoton, aSecondaryTime, aSecondaryPosition);

    aSecondaryTrack->SetTouchableHandle(
-                             aStep.GetPreStepPoint()->GetTouchableHandle());
+      aStep.GetPreStepPoint()->GetTouchableHandle());
    aSecondaryTrack->SetParentID(aTrack.GetTrackID());
    aParticleChange.AddSecondary(aSecondaryTrack);
  }

-  if (verboseLevel>1) {
+  if(verboseLevel > 1)
+  {
    G4cout << "\n Exiting from G4Cerenkov::DoIt -- NumberOfSecondaries = "
-	         << aParticleChange.GetNumberOfSecondaries() << G4endl;
+           << aParticleChange.GetNumberOfSecondaries() << G4endl;
  }

  return pParticleChange;
 }

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
-void G4Cerenkov::BuildThePhysicsTable()
+void G4Cerenkov::PreparePhysicsTable(const G4ParticleDefinition&)
 {
-  if (thePhysicsTable) return;
-
-  const G4MaterialTable* theMaterialTable=
-  G4Material::GetMaterialTable();
-  G4int numOfMaterials = G4Material::GetNumberOfMaterials();
-
-  thePhysicsTable = new G4PhysicsTable(numOfMaterials);
-
-  // loop over materials
-  for (G4int i=0; i<numOfMaterials; ++i) {
-    G4PhysicsOrderedFreeVector* aPhysicsOrderedFreeVector = 0;
-
-    // Retrieve vector of refraction indices for the material
-    // from the material's optical properties table 
-    G4Material* aMaterial = (*theMaterialTable)[i];
-    G4MaterialPropertiesTable* aMaterialPropertiesTable =
-                                    aMaterial->GetMaterialPropertiesTable();
-
-    if (aMaterialPropertiesTable) {
-      aPhysicsOrderedFreeVector = new G4PhysicsOrderedFreeVector();
-      G4MaterialPropertyVector* theRefractionIndexVector = 
-                           aMaterialPropertiesTable->GetProperty(kRINDEX);
-
-      if (theRefractionIndexVector) {
-        // Retrieve the first refraction index in vector
-        // of (photon energy, refraction index) pairs 
-        G4double currentRI = (*theRefractionIndexVector)[0];
-
-        if (currentRI > 1.0) {
-          // Create first (photon energy, Cerenkov Integral) pair  
-          G4double currentPM = theRefractionIndexVector->Energy(0);
-          G4double currentCAI = 0.0;
-
-          aPhysicsOrderedFreeVector->InsertValues(currentPM , currentCAI);
-
-          // Set previous values to current ones prior to loop
-          G4double prevPM  = currentPM;
-          G4double prevCAI = currentCAI;
-          G4double prevRI  = currentRI;
-
-          // loop over all (photon energy, refraction index)
-          // pairs stored for this material  
-          for (size_t ii = 1;
-                    ii < theRefractionIndexVector->GetVectorLength();
-                    ++ii) {
-            currentRI = (*theRefractionIndexVector)[ii];
-            currentPM = theRefractionIndexVector->Energy(ii);
-            currentCAI = prevCAI + (currentPM - prevPM) * 
-                      0.5*(1.0/(prevRI*prevRI) + 1.0/(currentRI*currentRI));
-
-            aPhysicsOrderedFreeVector->InsertValues(currentPM, currentCAI);
-
-            prevPM  = currentPM;
-            prevCAI = currentCAI;
-            prevRI  = currentRI;
-          }
-        }
-      }
-    }
-
-    // The Cerenkov integral for a given material will be inserted in 
-    // thePhysicsTable according to the position of the material in
-    // the material table. 
-    thePhysicsTable->insertAt(i,aPhysicsOrderedFreeVector); 
-  }
+  Initialise();
 }

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
-G4double G4Cerenkov::GetMeanFreePath(const G4Track&,
-                                           G4double,
-                                           G4ForceCondition*)
+G4double G4Cerenkov::GetMeanFreePath(const G4Track&, G4double,
+                                     G4ForceCondition*)
 {
  return 1.;
 }

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 G4double G4Cerenkov::PostStepGetPhysicalInteractionLength(
-                                           const G4Track& aTrack,
-                                           G4double,
-                                           G4ForceCondition* condition)
+  const G4Track& aTrack, G4double, G4ForceCondition* condition)
 {
-  *condition = NotForced;
+  *condition         = NotForced;
  G4double StepLimit = DBL_MAX;
-  fNumPhotons = 0;
+  fNumPhotons        = 0;

  const G4Material* aMaterial = aTrack.GetMaterial();
-  G4int materialIndex = aMaterial->GetIndex();
+  G4int materialIndex         = aMaterial->GetIndex();

  // If Physics Vector is not defined no Cerenkov photons
-  if (!(*thePhysicsTable)[materialIndex]) { return StepLimit; }
+  if(!(*thePhysicsTable)[materialIndex])
+  {
+    return StepLimit;
+  }

  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
  const G4MaterialCutsCouple* couple = aTrack.GetMaterialCutsCouple();

-  G4double kineticEnergy = aParticle->GetKineticEnergy();
+  G4double kineticEnergy                   = aParticle->GetKineticEnergy();
  const G4ParticleDefinition* particleType = aParticle->GetDefinition();
-  G4double mass = particleType->GetPDGMass();
+  G4double mass                            = particleType->GetPDGMass();

  G4double beta  = aParticle->GetTotalMomentum() / aParticle->GetTotalEnergy();
-  G4double gamma = aParticle->GetTotalEnergy()/mass;
+  G4double gamma = aParticle->GetTotalEnergy() / mass;

  G4MaterialPropertiesTable* aMaterialPropertiesTable =
-                                      aMaterial->GetMaterialPropertiesTable();
+    aMaterial->GetMaterialPropertiesTable();

  G4MaterialPropertyVector* Rindex = nullptr;

-  if (aMaterialPropertiesTable)
-                     Rindex = aMaterialPropertiesTable->GetProperty(kRINDEX);
+  if(aMaterialPropertiesTable)
+    Rindex = aMaterialPropertiesTable->GetProperty(kRINDEX);

  G4double nMax;
-  if (Rindex) {
+  if(Rindex)
+  {
    nMax = Rindex->GetMaxValue();
-  } else {
+  }
+  else
+  {
    return StepLimit;
  }

-  G4double BetaMin = 1./nMax;
-  if (BetaMin >= 1.) return StepLimit;
+  G4double BetaMin = 1. / nMax;
+  if(BetaMin >= 1.)
+    return StepLimit;

-  G4double GammaMin = 1./std::sqrt(1.-BetaMin*BetaMin);
-  if (gamma < GammaMin) return StepLimit;
+  G4double GammaMin = 1. / std::sqrt(1. - BetaMin * BetaMin);
+  if(gamma < GammaMin)
+    return StepLimit;

-  G4double kinEmin = mass*(GammaMin-1.);
+  G4double kinEmin = mass * (GammaMin - 1.);
  G4double RangeMin =
    G4LossTableManager::Instance()->GetRange(particleType, kinEmin, couple);
-  G4double Range = 
-    G4LossTableManager::Instance()->GetRange(particleType, kineticEnergy, couple);
+  G4double Range = G4LossTableManager::Instance()->GetRange(
+    particleType, kineticEnergy, couple);
  G4double Step = Range - RangeMin;

  // If the step is smaller than 1e-16 mm, it may happen that the particle
  // does not move. See bug 1992.
  //  2019-03-11: change to 1e-15
-  if (Step < 1.e-15*mm) return StepLimit;
-  
-  if (Step < StepLimit) StepLimit = Step; 
+  if(Step < 1.e-15 * mm)
+    return StepLimit;
+
+  if(Step < StepLimit)
+    StepLimit = Step;

  // If user has defined an average maximum number of photons to be generated in
-  // a Step, then calculate the Step length for that number of photons. 
-  if (fMaxPhotons > 0) {
+  // a Step, then calculate the Step length for that number of photons.
+  if(fMaxPhotons > 0)
+  {
    const G4double charge = aParticle->GetDefinition()->GetPDGCharge();
-    G4double MeanNumberOfPhotons = 
-                     GetAverageNumberOfPhotons(charge,beta,aMaterial,Rindex);
+    G4double MeanNumberOfPhotons =
+      GetAverageNumberOfPhotons(charge, beta, aMaterial, Rindex);
    Step = 0.;
-    if (MeanNumberOfPhotons > 0.0) Step = fMaxPhotons / MeanNumberOfPhotons;
-    if (Step > 0. && Step < StepLimit) StepLimit = Step;
+    if(MeanNumberOfPhotons > 0.0)
+      Step = fMaxPhotons / MeanNumberOfPhotons;
+    if(Step > 0. && Step < StepLimit)
+      StepLimit = Step;
  }

  // If user has defined an maximum allowed change in beta per step
-  if (fMaxBetaChange > 0.) {
-    G4double dedx =
-      G4LossTableManager::Instance()->GetDEDX(particleType, kineticEnergy, couple);
+  if(fMaxBetaChange > 0.)
+  {
+    G4double dedx = G4LossTableManager::Instance()->GetDEDX(
+      particleType, kineticEnergy, couple);
    G4double deltaGamma =
-      gamma - 1./std::sqrt(1.-beta*beta* (1.-fMaxBetaChange)* (1.-fMaxBetaChange));
+      gamma - 1. / std::sqrt(1. - beta * beta * (1. - fMaxBetaChange) *
+                                    (1. - fMaxBetaChange));

    Step = mass * deltaGamma / dedx;
-    if (Step > 0. && Step < StepLimit) StepLimit = Step;
+    if(Step > 0. && Step < StepLimit)
+      StepLimit = Step;
  }

  *condition = StronglyForced;
  return StepLimit;
 }

-
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
-G4double
-G4Cerenkov::GetAverageNumberOfPhotons(const G4double charge,
-                                      const G4double beta, 
-                			                const G4Material* aMaterial,
-			                                G4MaterialPropertyVector* Rindex) const
+G4double G4Cerenkov::GetAverageNumberOfPhotons(
+  const G4double charge, const G4double beta, const G4Material* aMaterial,
+  G4MaterialPropertyVector* Rindex) const
 // This routine computes the number of Cerenkov photons produced per
 // GEANT4-unit (millimeter) in the current medium.
 //              ^^^^^^^^^^
 {
-  const G4double Rfact = 369.81/(eV * cm);
-  if (beta <= 0.0) return 0.0;
-  G4double BetaInverse = 1./beta;
+  const G4double Rfact = 369.81 / (eV * cm);
+  if(beta <= 0.0)
+    return 0.0;
+  G4double BetaInverse = 1. / beta;

  // Vectors used in computation of Cerenkov Angle Integral:
  // 	- Refraction Indices for the current material
  //	- new G4PhysicsOrderedFreeVector allocated to hold CAI's
  G4int materialIndex = aMaterial->GetIndex();

-  // Retrieve the Cerenkov Angle Integrals for this material  
+  // Retrieve the Cerenkov Angle Integrals for this material
  G4PhysicsOrderedFreeVector* CerenkovAngleIntegrals =
-             (G4PhysicsOrderedFreeVector*)((*thePhysicsTable)(materialIndex));
+    (G4PhysicsOrderedFreeVector*) ((*thePhysicsTable)(materialIndex));

-  if (!(CerenkovAngleIntegrals->IsFilledVectorExist())) return 0.0;
+  if(!(CerenkovAngleIntegrals->IsFilledVectorExist()))
+    return 0.0;

-  // Min and Max photon energies 
+  // Min and Max photon energies
  G4double Pmin = Rindex->GetMinLowEdgeEnergy();
  G4double Pmax = Rindex->GetMaxLowEdgeEnergy();

-  // Min and Max Refraction Indices 
-  G4double nMin = Rindex->GetMinValue();	
+  // Min and Max Refraction Indices
+  G4double nMin = Rindex->GetMinValue();
  G4double nMax = Rindex->GetMaxValue();

-  // Max Cerenkov Angle Integral 
+  // Max Cerenkov Angle Integral
  G4double CAImax = CerenkovAngleIntegrals->GetMaxValue();

  G4double dp, ge;
-  // If n(Pmax) < 1/Beta -- no photons generated 
-  if (nMax < BetaInverse) {
+  // If n(Pmax) < 1/Beta -- no photons generated
+  if(nMax < BetaInverse)
+  {
    dp = 0.0;
    ge = 0.0;
-  } 
-  // otherwise if n(Pmin) >= 1/Beta -- photons generated  
-  else if (nMin > BetaInverse) {
-    dp = Pmax - Pmin;	
-    ge = CAImax; 
-  } 
+  }
+  // otherwise if n(Pmin) >= 1/Beta -- photons generated
+  else if(nMin > BetaInverse)
+  {
+    dp = Pmax - Pmin;
+    ge = CAImax;
+  }
  // If n(Pmin) < 1/Beta, and n(Pmax) >= 1/Beta, then we need to find a P such
  // that the value of n(P) == 1/Beta. Interpolation is performed by the
  // GetEnergy() and Value() methods of the G4MaterialPropertiesTable and
-  // the Value() method of G4PhysicsVector.  
-  else {
+  // the Value() method of G4PhysicsVector.
+  else
+  {
    Pmin = Rindex->GetEnergy(BetaInverse);
-    dp = Pmax - Pmin;
+    dp   = Pmax - Pmin;

    G4double CAImin = CerenkovAngleIntegrals->Value(Pmin);
-    ge = CAImax - CAImin;
+    ge              = CAImax - CAImin;

-    if (verboseLevel>1) {
-      G4cout << "CAImin = " << CAImin << G4endl
-             << "ge = " << ge << G4endl;
+    if(verboseLevel > 1)
+    {
+      G4cout << "CAImin = " << CAImin << G4endl << "ge = " << ge << G4endl;
    }
  }
-	
-  // Calculate number of photons 
-  G4double NumPhotons = Rfact * charge/eplus * charge/eplus *
-                                 (dp - ge * BetaInverse*BetaInverse);

-  return NumPhotons;		
+  // Calculate number of photons
+  G4double NumPhotons = Rfact * charge / eplus * charge / eplus *
+                        (dp - ge * BetaInverse * BetaInverse);
+
+  return NumPhotons;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void G4Cerenkov::SetTrackSecondariesFirst(const G4bool state)
+{
+  fTrackSecondariesFirst = state;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void G4Cerenkov::SetMaxBetaChangePerStep(const G4double value)
+{
+  fMaxBetaChange = value * CLHEP::perCent;
+}
+
+//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
+void G4Cerenkov::SetMaxNumPhotonsPerStep(const G4int NumPhotons)
+{
+  fMaxPhotons = NumPhotons;
 }

 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 void G4Cerenkov::DumpPhysicsTable() const
 {
-  G4PhysicsOrderedFreeVector *v;
-  for (size_t i=0 ; i<thePhysicsTable->entries(); ++i) {
-      v = (G4PhysicsOrderedFreeVector*)(*thePhysicsTable)[i];
-      v->DumpValues();
+  G4PhysicsOrderedFreeVector* v;
+  for(size_t i = 0; i < thePhysicsTable->entries(); ++i)
+  {
+    v = (G4PhysicsOrderedFreeVector*) (*thePhysicsTable)[i];
+    v->DumpValues();
  }
 }
-
@@ -32,33 +32,33 @@

 G4Allocator<G4ScintillationTrackInformation>*& aScintillationTIAllocator()
 {
-    G4ThreadLocalStatic G4Allocator<G4ScintillationTrackInformation>*
-            _instance = nullptr;
-    return _instance;
+  G4ThreadLocalStatic G4Allocator<G4ScintillationTrackInformation>* _instance =
+    nullptr;
+  return _instance;
 }

-const G4String G4ScintillationTrackInformation::BaseType = "G4ScintillationTrackInformation";
+const G4String G4ScintillationTrackInformation::BaseType =
+  "G4ScintillationTrackInformation";

-G4ScintillationTrackInformation::G4ScintillationTrackInformation(const G4ScintillationType& aType)
-: G4VUserTrackInformation(BaseType),
-scintillationType(aType)
-{
-}
+G4ScintillationTrackInformation::G4ScintillationTrackInformation(
+  const G4ScintillationType& aType)
+  : G4VUserTrackInformation(BaseType)
+  , scintillationType(aType)
+{}

-G4ScintillationTrackInformation::~G4ScintillationTrackInformation()
-{
-}
+G4ScintillationTrackInformation::~G4ScintillationTrackInformation() {}

-G4ScintillationTrackInformation::G4ScintillationTrackInformation(const G4ScintillationTrackInformation& right)
-: G4VUserTrackInformation(right),
-scintillationType(right.scintillationType)
-{
-}
+G4ScintillationTrackInformation::G4ScintillationTrackInformation(
+  const G4ScintillationTrackInformation& right)
+  : G4VUserTrackInformation(right)
+  , scintillationType(right.scintillationType)
+{}

-G4ScintillationTrackInformation& G4ScintillationTrackInformation::operator=(const G4ScintillationTrackInformation& right)
+G4ScintillationTrackInformation& G4ScintillationTrackInformation::operator=(
+  const G4ScintillationTrackInformation& right)
 {
  G4VUserTrackInformation::operator=(right);
-  this->scintillationType = right.scintillationType;
+  this->scintillationType          = right.scintillationType;
  return *this;
 }

@@ -67,13 +67,15 @@ void G4ScintillationTrackInformation::Print() const
  G4cout << "The user track information is a scintillation" << G4endl;
 }

-G4bool G4ScintillationTrackInformation::IsScintillationTrackInformation(const G4VUserTrackInformation* const aTI)
+G4bool G4ScintillationTrackInformation::IsScintillationTrackInformation(
+  const G4VUserTrackInformation* const aTI)
 {
  G4bool isSTI = (aTI && aTI->GetType() == BaseType.c_str());
  return isSTI;
 }

-G4ScintillationTrackInformation* G4ScintillationTrackInformation::Cast(const G4VUserTrackInformation* const aTI)
+G4ScintillationTrackInformation* G4ScintillationTrackInformation::Cast(
+  const G4VUserTrackInformation* const aTI)
 {
  G4ScintillationTrackInformation* STI = nullptr;
  if(IsScintillationTrackInformation(aTI))