// 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: G4IhIonisation.icc,v 1.1.10.1.2.1 1999/12/08 17:34:21 gunter Exp $
// GEANT4 tag $Name: geant4-01-01 $
//
// 
// ---------------------------------------------------------------
//      GEANT 4 class inlined methods file 
//
//      For information related to this code contact:
//      CERN, IT Division, ASD group
//      ------------ G4IhIonisation physics process ------------
//                  by Laszlo Urban, 30 May 1997
// ***************************************************************
// It is the first implementation of the NEW IONISATION PROCESS.               
// It calculates the ionisation of charged hadrons.
// ***************************************************************
// 24/09/97: corrected by L.Urban
// 20/11/97: correction on MeanFreePath for KineticEnergy > HighestLimit
// 29/10/98: some cleanup + small changes , L.Urban
// ---------------------------------------------------------------

inline G4double G4IhIonisation::PostStepGetPhysicalInteractionLength(
                                               const G4Track& track,
                                               G4double   previousStepSize,
                                               G4ForceCondition* condition)
{// get particle,particle type,kin.energy,material,mat.index
  const G4double Tfac=0.95,Tfac1=1.-Tfac,eps=1.e-2  ;

  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)) {
    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 << "G4IhIonisation 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 << "G4IhIonisation 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 G4IhIonisation::IsApplicable(
                            const G4ParticleDefinition& particle)
{
   return(particle.GetPDGCharge() != 0.);
}