G4EnergyLossTables Class Reference

#include <G4EnergyLossTables.hh>

Collaboration diagram for G4EnergyLossTables:

Public Types
typedef const G4ParticleDefinition *	K

Static Public Member Functions
static const G4PhysicsTable *	GetDEDXTable (const G4ParticleDefinition *p)
static const G4PhysicsTable *	GetRangeTable (const G4ParticleDefinition *p)
static const G4PhysicsTable *	GetInverseRangeTable (const G4ParticleDefinition *p)
static const G4PhysicsTable *	GetLabTimeTable (const G4ParticleDefinition *p)
static const G4PhysicsTable *	GetProperTimeTable (const G4ParticleDefinition *p)
static G4double	GetDEDX (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4Material *aMaterial)
static G4double	GetRange (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4Material *aMaterial)
static G4double	GetLabTime (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4Material *aMaterial)
static G4double	GetDeltaLabTime (const G4ParticleDefinition *aParticle, G4double KineticEnergyStart, G4double KineticEnergyEnd, const G4Material *aMaterial)
static G4double	GetProperTime (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4Material *aMaterial)
static G4double	GetDeltaProperTime (const G4ParticleDefinition *aParticle, G4double KineticEnergyStart, G4double KineticEnergyEnd, const G4Material *aMaterial)
static G4double	GetPreciseDEDX (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4Material *aMaterial)
static G4double	GetPreciseRangeFromEnergy (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4Material *aMaterial)
static G4double	GetPreciseEnergyFromRange (const G4ParticleDefinition *aParticle, G4double range, const G4Material *aMaterial)
static G4double	GetDEDX (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4MaterialCutsCouple *couple, G4bool check=true)
static G4double	GetRange (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4MaterialCutsCouple *couple, G4bool check=true)
static G4double	GetPreciseDEDX (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4MaterialCutsCouple *couple)
static G4double	GetPreciseRangeFromEnergy (const G4ParticleDefinition *aParticle, G4double KineticEnergy, const G4MaterialCutsCouple *couple)
static G4double	GetPreciseEnergyFromRange (const G4ParticleDefinition *aParticle, G4double range, const G4MaterialCutsCouple *couple, G4bool check=true)
static void	Register (const G4ParticleDefinition *p, const G4PhysicsTable *tDEDX, const G4PhysicsTable *tRange, const G4PhysicsTable *tInverseRange, const G4PhysicsTable *tLabTime, const G4PhysicsTable *tProperTime, G4double lowestKineticEnergy, G4double highestKineticEnergy, G4double massRatio, G4int NumberOfBins)

Private Types
typedef std::map< K, G4EnergyLossTablesHelper, std::less< K > >	helper_map

Static Private Member Functions
static void	CPRWarning ()
static void	ParticleHaveNoLoss (const G4ParticleDefinition *aParticle, const G4String &)
static G4EnergyLossTablesHelper	GetTables (const G4ParticleDefinition *p)

Static Private Attributes
static helper_map *	dict = 0
static G4EnergyLossTablesHelper *	t = 0
static G4EnergyLossTablesHelper *	null_loss = 0
static G4ParticleDefinition *	lastParticle = 0
static G4double	QQPositron = 1.0
static G4double	Chargesquare
static G4int	oldIndex = -1
static G4double	rmin = 0.
static G4double	rmax = 0.
static G4double	Thigh = 0.
static G4int	let_counter = 0
static G4int	let_max_num_warnings = 100
static G4bool	first_loss = true

Detailed Description

Definition at line 105 of file G4EnergyLossTables.hh.

Member Typedef Documentation

helper_map

typedef std::map<K,G4EnergyLossTablesHelper,std::less<K> > G4EnergyLossTables::helper_map

private

Definition at line 228 of file G4EnergyLossTables.hh.

K

typedef const G4ParticleDefinition* G4EnergyLossTables::K

Definition at line 203 of file G4EnergyLossTables.hh.

Member Function Documentation

CPRWarning()

void G4EnergyLossTables::CPRWarning ( )

staticprivate

Definition at line 1045 of file G4EnergyLossTables.cc.

{
  if (let_counter <  let_max_num_warnings) {

    G4cout << G4endl;
    G4cout << "##### G4EnergyLossTable WARNING: The obsolete interface is used!" << G4endl;
    G4cout << "##### RESULTS ARE NOT GARANTEED!" << G4endl;
    G4cout << "##### Please, substitute G4Material by G4MaterialCutsCouple" << G4endl;
    G4cout << "##### Obsolete interface will be removed soon" << G4endl;
    G4cout << G4endl;
    let_counter++;

  } else if (let_counter == let_max_num_warnings) {

    G4cout << "##### G4EnergyLossTable WARNING closed" << G4endl;
    let_counter++;
  }
}

GetDEDX() [1/2]

G4double G4EnergyLossTables::GetDEDX ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4Material *  aMaterial  )

static

Definition at line 207 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if(aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle ;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                   QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  if (!dEdxTable) {
    ParticleHaveNoLoss(aParticle,"dEdx");
    return 0.0;
  }

  G4int materialIndex = aMaterial->GetIndex();
  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double dEdx;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     dEdx =(*dEdxTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut)
           *std::sqrt(scaledKineticEnergy/t->theLowestKineticEnergy);

  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     dEdx = (*dEdxTable)(materialIndex)->GetValue(
          t->theHighestKineticEnergy,isOut);

  } else {

    dEdx = (*dEdxTable)(materialIndex)->GetValue(
           scaledKineticEnergy,isOut);

  }

  return dEdx*Chargesquare;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetDEDX() [2/2]

G4double G4EnergyLossTables::GetDEDX ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4MaterialCutsCouple *  couple, G4bool  check = true  )

static

Definition at line 760 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  if(aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle ;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                   QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  
  if (!dEdxTable ) {
    if (check) return G4LossTableManager::Instance()->GetDEDX(aParticle,KineticEnergy,couple);
    else       ParticleHaveNoLoss(aParticle, "dEdx");
    return 0.0;
  }

  G4int materialIndex = couple->GetIndex();
  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double dEdx;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     dEdx =(*dEdxTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut)
           *std::sqrt(scaledKineticEnergy/t->theLowestKineticEnergy);

  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     dEdx = (*dEdxTable)(materialIndex)->GetValue(
          t->theHighestKineticEnergy,isOut);

  } else {

    dEdx = (*dEdxTable)(materialIndex)->GetValue(
           scaledKineticEnergy,isOut);

  }

  return dEdx*Chargesquare;
}

Here is the call graph for this function:

GetDEDXTable()

const G4PhysicsTable * G4EnergyLossTables::GetDEDXTable ( const G4ParticleDefinition *  p )

static

Definition at line 137 of file G4EnergyLossTables.cc.

{
  if (!dict) dict = new G4EnergyLossTables::helper_map;
  helper_map::iterator it;
  if((it=dict->find(p))==dict->end()) return 0;
  return (*it).second.theDEDXTable;
}

GetDeltaLabTime()

G4double G4EnergyLossTables::GetDeltaLabTime ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergyStart, G4double  KineticEnergyEnd, const G4Material *  aMaterial  )

static

Definition at line 308 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if(aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable* labtimeTable= t->theLabTimeTable;
  if (!labtimeTable) {
    ParticleHaveNoLoss(aParticle,"LabTime");
    return 0.0;
  }

  const G4double parlowen=0.4 , ppar=0.5-parlowen ;
  const G4double dToverT = 0.05 , facT = 1. -dToverT ;
  G4double timestart,timeend,deltatime,dTT;
  G4bool isOut;

  G4int materialIndex = aMaterial->GetIndex();
  G4double scaledKineticEnergy = KineticEnergyStart*t->theMassRatio;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     timestart = std::exp(ppar*std::log(scaledKineticEnergy/t->theLowestKineticEnergy))*
                (*labtimeTable)(materialIndex)->GetValue(
                t->theLowestKineticEnergy,isOut);


  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     timestart = (*labtimeTable)(materialIndex)->GetValue(
                t->theHighestKineticEnergy,isOut);

  } else {

    timestart = (*labtimeTable)(materialIndex)->GetValue(
                scaledKineticEnergy,isOut);

  }

  dTT = (KineticEnergyStart - KineticEnergyEnd)/KineticEnergyStart ;

  if( dTT < dToverT )
    scaledKineticEnergy = facT*KineticEnergyStart*t->theMassRatio;
  else
    scaledKineticEnergy = KineticEnergyEnd*t->theMassRatio;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     timeend = std::exp(ppar*std::log(scaledKineticEnergy/t->theLowestKineticEnergy))*
                (*labtimeTable)(materialIndex)->GetValue(
                t->theLowestKineticEnergy,isOut);


  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     timeend = (*labtimeTable)(materialIndex)->GetValue(
                t->theHighestKineticEnergy,isOut);

  } else {

    timeend = (*labtimeTable)(materialIndex)->GetValue(
                scaledKineticEnergy,isOut);

  }

  deltatime = timestart - timeend ;

  if( dTT < dToverT )
    deltatime *= dTT/dToverT;

  return deltatime/t->theMassRatio ;
}

Here is the call graph for this function:

GetDeltaProperTime()

G4double G4EnergyLossTables::GetDeltaProperTime ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergyStart, G4double  KineticEnergyEnd, const G4Material *  aMaterial  )

static

Definition at line 442 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if(aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable* propertimeTable= t->theProperTimeTable;
  if (!propertimeTable) {
    ParticleHaveNoLoss(aParticle,"ProperTime");
    return 0.0;
  }

  const G4double parlowen=0.4 , ppar=0.5-parlowen ;
  const G4double dToverT = 0.05 , facT = 1. -dToverT ;
  G4double timestart,timeend,deltatime,dTT;
  G4bool isOut;

  G4int materialIndex = aMaterial->GetIndex();
  G4double scaledKineticEnergy = KineticEnergyStart*t->theMassRatio;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     timestart = std::exp(ppar*std::log(scaledKineticEnergy/t->theLowestKineticEnergy))*
                (*propertimeTable)(materialIndex)->GetValue(
                t->theLowestKineticEnergy,isOut);


  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     timestart = (*propertimeTable)(materialIndex)->GetValue(
                t->theHighestKineticEnergy,isOut);

  } else {

    timestart = (*propertimeTable)(materialIndex)->GetValue(
                scaledKineticEnergy,isOut);

  }

  dTT = (KineticEnergyStart - KineticEnergyEnd)/KineticEnergyStart ;

  if( dTT < dToverT )
    scaledKineticEnergy = facT*KineticEnergyStart*t->theMassRatio;
  else
    scaledKineticEnergy = KineticEnergyEnd*t->theMassRatio;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     timeend = std::exp(ppar*std::log(scaledKineticEnergy/t->theLowestKineticEnergy))*
                (*propertimeTable)(materialIndex)->GetValue(
                t->theLowestKineticEnergy,isOut);


  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     timeend = (*propertimeTable)(materialIndex)->GetValue(
                t->theHighestKineticEnergy,isOut);

  } else {

    timeend = (*propertimeTable)(materialIndex)->GetValue(
                scaledKineticEnergy,isOut);

  }

  deltatime = timestart - timeend ;

  if( dTT < dToverT )
    deltatime *= dTT/dToverT ;

  return deltatime/t->theMassRatio ;
}

Here is the call graph for this function:

GetInverseRangeTable()

const G4PhysicsTable * G4EnergyLossTables::GetInverseRangeTable ( const G4ParticleDefinition *  p )

static

Definition at line 159 of file G4EnergyLossTables.cc.

{
  if (!dict) dict = new G4EnergyLossTables::helper_map;
  helper_map::iterator it;
  if((it=dict->find(p))==dict->end()) return 0;
  return (*it).second.theInverseRangeTable;
}

GetLabTime()

G4double G4EnergyLossTables::GetLabTime ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4Material *  aMaterial  )

static

Definition at line 258 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if(aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable* labtimeTable= t->theLabTimeTable;
  if (!labtimeTable) {
    ParticleHaveNoLoss(aParticle,"LabTime");
    return 0.0;
  }

  const G4double parlowen=0.4 , ppar=0.5-parlowen ;
  G4int materialIndex = aMaterial->GetIndex();
  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double time;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     time = std::exp(ppar*std::log(scaledKineticEnergy/t->theLowestKineticEnergy))*
            (*labtimeTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut);


  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     time = (*labtimeTable)(materialIndex)->GetValue(
              t->theHighestKineticEnergy,isOut);

  } else {

    time = (*labtimeTable)(materialIndex)->GetValue(
               scaledKineticEnergy,isOut);

  }

  return time/t->theMassRatio ;
}

Here is the call graph for this function:

GetLabTimeTable()

const G4PhysicsTable * G4EnergyLossTables::GetLabTimeTable ( const G4ParticleDefinition *  p )

static

Definition at line 170 of file G4EnergyLossTables.cc.

{
  if (!dict) dict = new G4EnergyLossTables::helper_map;
  helper_map::iterator it;
  if((it=dict->find(p))==dict->end()) return 0;
  return (*it).second.theLabTimeTable;
}

GetPreciseDEDX() [1/2]

G4double G4EnergyLossTables::GetPreciseDEDX ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4Material *  aMaterial  )

static

Definition at line 650 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if( aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                    QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  if (!dEdxTable) {
    ParticleHaveNoLoss(aParticle,"dEdx");
    return 0.0;
  }

  G4int materialIndex = aMaterial->GetIndex();
  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double dEdx;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     dEdx = std::sqrt(scaledKineticEnergy/t->theLowestKineticEnergy)
            *(*dEdxTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut);

  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     dEdx = (*dEdxTable)(materialIndex)->GetValue(
          t->theHighestKineticEnergy,isOut);

  } else {

      dEdx = (*dEdxTable)(materialIndex)->GetValue(
                          scaledKineticEnergy,isOut) ;

  }

  return dEdx*Chargesquare;
}

Here is the call graph for this function:

GetPreciseDEDX() [2/2]

G4double G4EnergyLossTables::GetPreciseDEDX ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4MaterialCutsCouple *  couple  )

static

Definition at line 940 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  if( aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                    QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  if ( !dEdxTable )
    return G4LossTableManager::Instance()->GetDEDX(aParticle,KineticEnergy,couple);

  G4int materialIndex = couple->GetIndex();
  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double dEdx;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     dEdx = std::sqrt(scaledKineticEnergy/t->theLowestKineticEnergy)
            *(*dEdxTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut);

  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     dEdx = (*dEdxTable)(materialIndex)->GetValue(
          t->theHighestKineticEnergy,isOut);

  } else {

      dEdx = (*dEdxTable)(materialIndex)->GetValue(
                          scaledKineticEnergy,isOut) ;

  }

  return dEdx*Chargesquare;
}

Here is the call graph for this function:

GetPreciseEnergyFromRange() [1/2]

G4double G4EnergyLossTables::GetPreciseEnergyFromRange ( const G4ParticleDefinition *  aParticle, G4double  range, const G4Material *  aMaterial  )

static

Definition at line 581 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if( aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                    QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  const G4PhysicsTable*  inverseRangeTable= t->theInverseRangeTable;
  if (!inverseRangeTable) {
    ParticleHaveNoLoss(aParticle,"InverseRange");
    return 0.0;
  }

  G4double scaledrange,scaledKineticEnergy ;
  G4bool isOut ;

  G4int materialIndex = aMaterial->GetIndex() ;

  if(materialIndex != oldIndex)
  {
    oldIndex = materialIndex ;
    rmin = (*inverseRangeTable)(materialIndex)->
                              GetLowEdgeEnergy(0) ;
    rmax = (*inverseRangeTable)(materialIndex)->
                   GetLowEdgeEnergy(t->theNumberOfBins-2) ;
    Thigh = (*inverseRangeTable)(materialIndex)->
                              GetValue(rmax,isOut) ;
  }

  scaledrange = range*Chargesquare*t->theMassRatio ;

  if(scaledrange < rmin)
  {
    scaledKineticEnergy = t->theLowestKineticEnergy*
                   scaledrange*scaledrange/(rmin*rmin) ;
  }
  else
  {
    if(scaledrange < rmax)
    {
      scaledKineticEnergy = (*inverseRangeTable)(materialIndex)->
                              GetValue( scaledrange,isOut) ;
    }
    else
    {
      scaledKineticEnergy = Thigh +
                      (scaledrange-rmax)*
                      (*dEdxTable)(materialIndex)->
                                 GetValue(Thigh,isOut) ;
    }
  }

  return scaledKineticEnergy/t->theMassRatio ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetPreciseEnergyFromRange() [2/2]

G4double G4EnergyLossTables::GetPreciseEnergyFromRange ( const G4ParticleDefinition *  aParticle, G4double  range, const G4MaterialCutsCouple *  couple, G4bool  check = true  )

static

Definition at line 869 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  if( aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                    QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  const G4PhysicsTable*  inverseRangeTable= t->theInverseRangeTable;
  
  if (!inverseRangeTable) {
    if(check) return G4LossTableManager::Instance()->GetEnergy(aParticle,range,couple);
    else      return DBL_MAX;      
    //    else      ParticleHaveNoLoss(aParticle,"InverseRange");
  }

  G4double scaledrange,scaledKineticEnergy ;
  G4bool isOut ;

  G4int materialIndex = couple->GetIndex() ;

  if(materialIndex != oldIndex)
  {
    oldIndex = materialIndex ;
    rmin = (*inverseRangeTable)(materialIndex)->
                              GetLowEdgeEnergy(0) ;
    rmax = (*inverseRangeTable)(materialIndex)->
                   GetLowEdgeEnergy(t->theNumberOfBins-2) ;
    Thigh = (*inverseRangeTable)(materialIndex)->
                              GetValue(rmax,isOut) ;
  }

  scaledrange = range*Chargesquare*t->theMassRatio ;

  if(scaledrange < rmin)
  {
    scaledKineticEnergy = t->theLowestKineticEnergy*
                   scaledrange*scaledrange/(rmin*rmin) ;
  }
  else
  {
    if(scaledrange < rmax)
    {
      scaledKineticEnergy = (*inverseRangeTable)(materialIndex)->
                              GetValue( scaledrange,isOut) ;
    }
    else
    {
      scaledKineticEnergy = Thigh +
                      (scaledrange-rmax)*
                      (*dEdxTable)(materialIndex)->
                                 GetValue(Thigh,isOut) ;
    }
  }

  return scaledKineticEnergy/t->theMassRatio ;
}

Here is the call graph for this function:

GetPreciseRangeFromEnergy() [1/2]

G4double G4EnergyLossTables::GetPreciseRangeFromEnergy ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4Material *  aMaterial  )

static

Definition at line 701 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if( aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                    QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable* rangeTable= t->theRangeTable;
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  if (!rangeTable) {
    ParticleHaveNoLoss(aParticle,"Range");
    return 0.0;
  }
  G4int materialIndex = aMaterial->GetIndex();

  G4double Thighr = t->theHighestKineticEnergy*t->theLowestKineticEnergy/
                   (*rangeTable)(materialIndex)->
                   GetLowEdgeEnergy(1) ;

  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double Range;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

    Range = std::sqrt(scaledKineticEnergy/t->theLowestKineticEnergy)*
            (*rangeTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut);

  } else if (scaledKineticEnergy>Thighr) {

    Range = (*rangeTable)(materialIndex)->GetValue(
          Thighr,isOut)+
            (scaledKineticEnergy-Thighr)/
            (*dEdxTable)(materialIndex)->GetValue(
              Thighr,isOut);

  } else {

     Range = (*rangeTable)(materialIndex)->GetValue(
                       scaledKineticEnergy,isOut) ;

  }

  return Range/(Chargesquare*t->theMassRatio);
}

Here is the call graph for this function:

GetPreciseRangeFromEnergy() [2/2]

G4double G4EnergyLossTables::GetPreciseRangeFromEnergy ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4MaterialCutsCouple *  couple  )

static

Definition at line 988 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  if( aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                    QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable* rangeTable= t->theRangeTable;
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  if ( !dEdxTable || !rangeTable)
    return G4LossTableManager::Instance()->GetDEDX(aParticle,KineticEnergy,couple);

  G4int materialIndex = couple->GetIndex();

  G4double Thighr = t->theHighestKineticEnergy*t->theLowestKineticEnergy/
                   (*rangeTable)(materialIndex)->
                   GetLowEdgeEnergy(1) ;

  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double Range;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

    Range = std::sqrt(scaledKineticEnergy/t->theLowestKineticEnergy)*
            (*rangeTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut);

  } else if (scaledKineticEnergy>Thighr) {

    Range = (*rangeTable)(materialIndex)->GetValue(
          Thighr,isOut)+
            (scaledKineticEnergy-Thighr)/
            (*dEdxTable)(materialIndex)->GetValue(
              Thighr,isOut);

  } else {

     Range = (*rangeTable)(materialIndex)->GetValue(
                       scaledKineticEnergy,isOut) ;

  }

  return Range/(Chargesquare*t->theMassRatio);
}

Here is the call graph for this function:

GetProperTime()

G4double G4EnergyLossTables::GetProperTime ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4Material *  aMaterial  )

static

Definition at line 392 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if(aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable* propertimeTable= t->theProperTimeTable;
  if (!propertimeTable) {
    ParticleHaveNoLoss(aParticle,"ProperTime");
    return 0.0;
  }

  const G4double parlowen=0.4 , ppar=0.5-parlowen ;
  G4int materialIndex = aMaterial->GetIndex();
  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double time;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

     time = std::exp(ppar*std::log(scaledKineticEnergy/t->theLowestKineticEnergy))*
            (*propertimeTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut);


  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

     time = (*propertimeTable)(materialIndex)->GetValue(
              t->theHighestKineticEnergy,isOut);

  } else {

    time = (*propertimeTable)(materialIndex)->GetValue(
               scaledKineticEnergy,isOut);

  }

  return time/t->theMassRatio ;
}

Here is the call graph for this function:

GetProperTimeTable()

const G4PhysicsTable * G4EnergyLossTables::GetProperTimeTable ( const G4ParticleDefinition *  p )

static

Definition at line 181 of file G4EnergyLossTables.cc.

{
  if (!dict) dict = new G4EnergyLossTables::helper_map;
  helper_map::iterator it;
  if((it=dict->find(p))==dict->end()) return 0;
  return (*it).second.theProperTimeTable;
}

GetRange() [1/2]

G4double G4EnergyLossTables::GetRange ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4Material *  aMaterial  )

static

Definition at line 526 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  CPRWarning();
  if(aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle ;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                    QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable* rangeTable= t->theRangeTable;
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  if (!rangeTable) {
    ParticleHaveNoLoss(aParticle,"Range");
    return 0.0;
  }

  G4int materialIndex = aMaterial->GetIndex();
  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double Range;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

    Range = std::sqrt(scaledKineticEnergy/t->theLowestKineticEnergy)*
            (*rangeTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut);

  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

    Range = (*rangeTable)(materialIndex)->GetValue(
          t->theHighestKineticEnergy,isOut)+
            (scaledKineticEnergy-t->theHighestKineticEnergy)/
            (*dEdxTable)(materialIndex)->GetValue(
              t->theHighestKineticEnergy,isOut);

  } else {

    Range = (*rangeTable)(materialIndex)->GetValue(
           scaledKineticEnergy,isOut);

  }

  return Range/(Chargesquare*t->theMassRatio);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetRange() [2/2]

G4double G4EnergyLossTables::GetRange ( const G4ParticleDefinition *  aParticle, G4double  KineticEnergy, const G4MaterialCutsCouple *  couple, G4bool  check = true  )

static

Definition at line 813 of file G4EnergyLossTables.cc.

{
  if (!t) t = new G4EnergyLossTablesHelper;

  if(aParticle != (const G4ParticleDefinition*) lastParticle)
  {
    *t= GetTables(aParticle);
    lastParticle = (G4ParticleDefinition*) aParticle ;
    Chargesquare = (aParticle->GetPDGCharge())*
                   (aParticle->GetPDGCharge())/
                    QQPositron ;
    oldIndex = -1 ;
  }
  const G4PhysicsTable* rangeTable= t->theRangeTable;
  const G4PhysicsTable*  dEdxTable= t->theDEDXTable;
  if (!rangeTable) {
    if(check) return G4LossTableManager::Instance()->GetRange(aParticle,KineticEnergy,couple);
    else      return DBL_MAX;      
      //ParticleHaveNoLoss(aParticle,"Range");
  }

  G4int materialIndex = couple->GetIndex();
  G4double scaledKineticEnergy = KineticEnergy*t->theMassRatio;
  G4double Range;
  G4bool isOut;

  if (scaledKineticEnergy<t->theLowestKineticEnergy) {

    Range = std::sqrt(scaledKineticEnergy/t->theLowestKineticEnergy)*
            (*rangeTable)(materialIndex)->GetValue(
              t->theLowestKineticEnergy,isOut);

  } else if (scaledKineticEnergy>t->theHighestKineticEnergy) {

    Range = (*rangeTable)(materialIndex)->GetValue(
          t->theHighestKineticEnergy,isOut)+
            (scaledKineticEnergy-t->theHighestKineticEnergy)/
            (*dEdxTable)(materialIndex)->GetValue(
              t->theHighestKineticEnergy,isOut);

  } else {

    Range = (*rangeTable)(materialIndex)->GetValue(
           scaledKineticEnergy,isOut);

  }

  return Range/(Chargesquare*t->theMassRatio);
}

Here is the call graph for this function:

GetRangeTable()

const G4PhysicsTable * G4EnergyLossTables::GetRangeTable ( const G4ParticleDefinition *  p )

static

Definition at line 148 of file G4EnergyLossTables.cc.

{
  if (!dict) dict = new G4EnergyLossTables::helper_map;
  helper_map::iterator it;
  if((it=dict->find(p))==dict->end()) return 0;
  return (*it).second.theRangeTable;
}

GetTables()

G4EnergyLossTablesHelper G4EnergyLossTables::GetTables ( const G4ParticleDefinition *  p )

staticprivate

Definition at line 192 of file G4EnergyLossTables.cc.

{
  if (!dict) dict = new G4EnergyLossTables::helper_map;
  if (!null_loss) null_loss = new G4EnergyLossTablesHelper;

  helper_map::iterator it;
  if ((it=dict->find(p))==dict->end()) {
    return *null_loss;
  }
  return (*it).second;
}

Here is the call graph for this function:

ParticleHaveNoLoss()

void G4EnergyLossTables::ParticleHaveNoLoss ( const G4ParticleDefinition *  aParticle, const G4String &    )

staticprivate

Definition at line 1067 of file G4EnergyLossTables.cc.

{
}

Register()

void G4EnergyLossTables::Register ( const G4ParticleDefinition *  p, const G4PhysicsTable *  tDEDX, const G4PhysicsTable *  tRange, const G4PhysicsTable *  tInverseRange, const G4PhysicsTable *  tLabTime, const G4PhysicsTable *  tProperTime, G4double  lowestKineticEnergy, G4double  highestKineticEnergy, G4double  massRatio, G4int  NumberOfBins  )

static

Definition at line 105 of file G4EnergyLossTables.cc.

{
  if (!dict) dict = new G4EnergyLossTables::helper_map;
  if (!null_loss) null_loss = new G4EnergyLossTablesHelper;
  if (!t) t = new G4EnergyLossTablesHelper;

  (*dict)[p]= G4EnergyLossTablesHelper(tDEDX, tRange,tInverseRange,
                    tLabTime,tProperTime,lowestKineticEnergy,
            highestKineticEnergy, massRatio,NumberOfBins);

  *t = GetTables(p) ;    // important for cache !!!!!
  lastParticle = (G4ParticleDefinition*) p ;
  Chargesquare = (p->GetPDGCharge())*(p->GetPDGCharge())/
                  QQPositron ;
  if (first_loss ) {
    *null_loss = G4EnergyLossTablesHelper(0, 0, 0, 0, 0, 0.0, 0.0, 0.0, 0);
    first_loss = false;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Chargesquare

G4double G4EnergyLossTables::Chargesquare

staticprivate

Definition at line 237 of file G4EnergyLossTables.hh.

dict

G4EnergyLossTables::helper_map * G4EnergyLossTables::dict = 0

staticprivate

Definition at line 229 of file G4EnergyLossTables.hh.

first_loss

G4bool G4EnergyLossTables::first_loss = true

staticprivate

Definition at line 242 of file G4EnergyLossTables.hh.

lastParticle

G4ParticleDefinition * G4EnergyLossTables::lastParticle = 0

staticprivate

Definition at line 235 of file G4EnergyLossTables.hh.

let_counter

G4int G4EnergyLossTables::let_counter = 0

staticprivate

Definition at line 240 of file G4EnergyLossTables.hh.

let_max_num_warnings

G4int G4EnergyLossTables::let_max_num_warnings = 100

staticprivate

Definition at line 241 of file G4EnergyLossTables.hh.

null_loss

G4EnergyLossTablesHelper * G4EnergyLossTables::null_loss = 0

staticprivate

Definition at line 234 of file G4EnergyLossTables.hh.

oldIndex

G4int G4EnergyLossTables::oldIndex = -1

staticprivate

Definition at line 238 of file G4EnergyLossTables.hh.

QQPositron

G4double G4EnergyLossTables::QQPositron = 1.0

staticprivate

Definition at line 236 of file G4EnergyLossTables.hh.

rmax

G4double G4EnergyLossTables::rmax = 0.

staticprivate

Definition at line 239 of file G4EnergyLossTables.hh.

rmin

G4double G4EnergyLossTables::rmin = 0.

staticprivate

Definition at line 239 of file G4EnergyLossTables.hh.

t

G4EnergyLossTablesHelper * G4EnergyLossTables::t = 0

staticprivate

Definition at line 233 of file G4EnergyLossTables.hh.

Thigh

G4double G4EnergyLossTables::Thigh = 0.

staticprivate

Definition at line 239 of file G4EnergyLossTables.hh.

---

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

• G4EnergyLossTables.hh
• G4EnergyLossTables.cc