geant4/source/processes/electromagnetic/integral/include/G4IeIonisation.icc

//
// ********************************************************************
// * 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: G4IeIonisation.icc,v 1.1.2.2 2001/06/28 20:19:19 gunter Exp $
// GEANT4 tag $Name:  $
//
// $Id: 
// ---------------------------------------------------------------
//      GEANT 4 class inlined methods file 
//
//      ------------ G4IeIonisation physics process ------------
//                by Laszlo Urban, 23 June 1998
// ************************************************************
// It is the first implementation of the IONISATION
// PROCESS. ( delta rays + continuous energy loss)
//   using an INTEGRAL APPROACH instead of the differential
//   one used in the standard implementation .
// ************************************************************
// 27/10/98: minor changes , cleanup , L.Urban
// ------------------------------------------------------------

inline G4double G4IeIonisation::PostStepGetPhysicalInteractionLength(
                             const G4Track& track,
                             G4double   previousStepSize,
                             G4ForceCondition* condition)
{
  const G4double eps=1.e-2,Tfac=0.95,Tfac1=1.-Tfac  ;

  G4double nl,nll,nlold,range,rangeold,rangenext,
           dEdx,KineticEnergyOld,KineticEnergyNext,value;
  G4bool isOut;

  const G4DynamicParticle* particle = track.GetDynamicParticle();
  const G4ParticleDefinition* particletype = particle->GetDefinition() ;
  G4double KineticEnergy = particle->GetKineticEnergy();
  G4Material* material = track.GetMaterial();
  const G4MaterialTable* theMaterialTable =
                                    G4Material::GetMaterialTable();
  G4int materialindex = material->GetIndex();  

  nl = (*theNlambdaTable)[materialindex]->
                           GetValue(KineticEnergy,isOut);
  range = G4EnergyLossTables::GetPreciseRangeFromEnergy(particletype,
                                       KineticEnergy,material) ;

  if ( (previousStepSize <=0.0) || (theNumberOfInteractionLengthLeft<=0.0)) {
    // beggining of tracking (or just after DoIt of this process)
    ResetNumberOfInteractionLengthLeft();
  } else {
   if(previousStepSize/range < eps)
   {
    nll = (*theNlambdaTable)[materialindex]->
                             GetValue(Tfac*KineticEnergy,isOut) ;
    dEdx = G4EnergyLossTables::GetPreciseDEDX(particletype,
                                              KineticEnergy,
                                              material) ;
    nlold = nl + dEdx*previousStepSize*(nl-nll)/
                                  (Tfac1*KineticEnergy) ;
   }
   else 
   {
    rangeold = range + previousStepSize ;
    KineticEnergyOld = G4EnergyLossTables::GetPreciseEnergyFromRange(
                                             particletype,
                                       rangeold,material);   
    nlold = (*theNlambdaTable)[materialindex]->
                           GetValue(KineticEnergyOld,isOut);

    if(nlold < nl)
     {
     if(verboseLevel>2)
     {
      G4cout << "G4IeIonisation PostStepGPIL : Nlambda has been" <<
              " increased at update.Nlambda old/new :" << nlold <<
              "  " << nl << G4endl;
      G4cout << "(theNumberOfInteractionLengthLeft has been increased!)"
                                                                     << G4endl; 
      G4cout << " correction : Nlambda old=new ........." << G4endl;
     }
      nlold = nl ;
     }
    }

    theNumberOfInteractionLengthLeft -= nlold-nl ; 

    if(theNumberOfInteractionLengthLeft<perMillion)
       theNumberOfInteractionLengthLeft=0.;
  }


  // condition is set to "Not Forced"
  *condition = NotForced;
  if(nl <= theNumberOfInteractionLengthLeft)
  {
    value = DBL_MAX ;
  }
  else
  {
   if(theNumberOfInteractionLengthLeft/nl < eps)
   {
    nll = (*theNlambdaTable)[materialindex]->
                             GetValue(Tfac*KineticEnergy,isOut) ;
    dEdx = G4EnergyLossTables::GetPreciseDEDX(particletype,
                                              KineticEnergy,
                                              material) ;
    
    value = theNumberOfInteractionLengthLeft*Tfac1*
                                      KineticEnergy/(dEdx*(nl-nll)) ;
   }
   else
   {

    KineticEnergyNext = (*theInverseNlambdaTable)[materialindex]->
                        GetValue(nl-theNumberOfInteractionLengthLeft,isOut);
    rangenext = G4EnergyLossTables::GetPreciseRangeFromEnergy(particletype,
                                       KineticEnergyNext,material);
    value = range - rangenext ;
    if(range<rangenext)
    {
     if(verboseLevel>2)
     {
      G4cout << "G4IeIonisation PostStepGPIL: Step < 0.!, Step="
                                                        << value << G4endl; 
      G4cout << "range,rangenext:" << range << "  " << rangenext << G4endl ;
      G4cout << "correction : rangenext=range ....." << G4endl;
     }
     rangenext = range ;
     value = range - rangenext ;
    }
   }
  }
  return value;
}

inline G4bool G4IeIonisation::IsApplicable(
                            const G4ParticleDefinition& particle)
{
   return(   (&particle == (const G4ParticleDefinition *)theElectron)
           ||(&particle == (const G4ParticleDefinition *)thePositron)
         ) ;
}
         
inline G4double G4IeIonisation::GetNlambda(
                              G4double KineticEnergy,
                              G4Material* material)
{
  G4bool isOut;
  const G4MaterialTable* theMaterialTable =
                       G4Material::GetMaterialTable() ;

  G4double lambda = (*theNlambdaTable)
                    [material->GetIndex()]->
                    GetValue(KineticEnergy,isOut);
  return lambda;
}