G4IonDEDXHandler Class Reference

#include <G4IonDEDXHandler.hh>

Public Member Functions
	G4IonDEDXHandler (G4VIonDEDXTable *tables, G4VIonDEDXScalingAlgorithm *algorithm, const G4String &name, G4int maxCacheSize=5, G4bool splines=true)
	~G4IonDEDXHandler ()
G4bool	IsApplicable (const G4ParticleDefinition *, const G4Material *)
G4double	GetDEDX (const G4ParticleDefinition *, const G4Material *, G4double)
G4bool	BuildDEDXTable (const G4ParticleDefinition *, const G4Material *)
G4bool	BuildDEDXTable (G4int atomicNumberIon, const G4Material *)
void	PrintDEDXTable (const G4ParticleDefinition *, const G4Material *, G4double, G4double, G4int, G4bool logScaleEnergy=true)
G4double	GetLowerEnergyEdge (const G4ParticleDefinition *, const G4Material *)
G4double	GetUpperEnergyEdge (const G4ParticleDefinition *, const G4Material *)
void	ClearCache ()
G4String	GetName ()

Detailed Description

Definition at line 82 of file G4IonDEDXHandler.hh.

Constructor & Destructor Documentation

G4IonDEDXHandler::G4IonDEDXHandler	(	G4VIonDEDXTable *	tables,
		G4VIonDEDXScalingAlgorithm *	algorithm,
		const G4String &	name,
		G4int	maxCacheSize = 5,
		G4bool	splines = true
	)

Definition at line 67 of file G4IonDEDXHandler.cc.

References G4cerr, and G4endl.

                                            :
  table(ionTable),
  algorithm(ionAlgorithm),
  tableName(name),
  useSplines(splines),
  maxCacheEntries(maxCacheSize) {

  if(table == 0) {
     G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
            << " Pointer to G4VIonDEDXTable object is null-pointer." 
            << G4endl;
  }

  if(algorithm == 0) {
     G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
            << " Pointer to G4VIonDEDXScalingAlgorithm object is null-pointer." 
            << G4endl;
  }

  if(maxCacheEntries <= 0) {
     G4cerr << "G4IonDEDXHandler::G4IonDEDXHandler() "
            << " Cache size <=0. Resetting to 5." 
            << G4endl;
     maxCacheEntries = 5;
  }
}

G4IonDEDXHandler::~G4IonDEDXHandler

(

)

Definition at line 101 of file G4IonDEDXHandler.cc.

References ClearCache().

                                    {

  ClearCache();

  // All stopping power vectors built according to Bragg's addivitiy rule
  // are deleted. All other stopping power vectors are expected to be
  // deleted by their creator class (sub-class of G4VIonDEDXTable). 
  // DEDXTableBraggRule::iterator iter = stoppingPowerTableBragg.begin();
  // DEDXTableBraggRule::iterator iter_end = stoppingPowerTableBragg.end();

  //  for(;iter != iter_end; iter++) delete iter -> second;
  stoppingPowerTableBragg.clear();

  stoppingPowerTable.clear();

  if(table != 0) delete table;
  if(algorithm != 0) delete algorithm;
}

Member Function Documentation

G4bool G4IonDEDXHandler::BuildDEDXTable	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

Definition at line 195 of file G4IonDEDXHandler.cc.

                                             {          // Target material 

  G4int atomicNumberIon = particle -> GetAtomicNumber();

  G4bool isApplicable = BuildDEDXTable(atomicNumberIon, material);

  return isApplicable;
}

G4bool G4IonDEDXHandler::BuildDEDXTable	(	G4int	atomicNumberIon,
		const G4Material *	material
	)

Definition at line 209 of file G4IonDEDXHandler.cc.

References test::b, ClearCache(), G4cout, G4endl, and GetName().

                                             {         // Target material 

  G4bool isApplicable = true; 

  if(table == 0 || algorithm == 0) {
     isApplicable = false;
     return isApplicable;
  }

  G4int atomicNumberBase = 
                algorithm -> AtomicNumberBaseIon(atomicNumberIon, material);

  // Checking if vector is already built, and returns if this is indeed 
  // the case
  G4IonKey key = std::make_pair(atomicNumberBase, material);

  DEDXTable::iterator iter = stoppingPowerTable.find(key);
  if(iter != stoppingPowerTable.end()) return isApplicable;

  // Checking if table contains stopping power vector for given material name
  // or chemical formula
  const G4String& chemFormula = material -> GetChemicalFormula();
  const G4String& materialName = material -> GetName();

  isApplicable = table -> BuildPhysicsVector(atomicNumberBase, chemFormula);

  if(isApplicable) { 
     stoppingPowerTable[key] = 
              table -> GetPhysicsVector(atomicNumberBase, chemFormula);
     return isApplicable;
  }

  isApplicable = table -> BuildPhysicsVector(atomicNumberBase, materialName);
  if(isApplicable) { 
     stoppingPowerTable[key] = 
              table -> GetPhysicsVector(atomicNumberBase, materialName);
     return isApplicable;
  }

  // Building the stopping power vector based on Bragg's additivity rule
  const G4ElementVector* elementVector = material -> GetElementVector() ;

  std::vector<G4PhysicsVector*> dEdxTable;

  size_t nmbElements = material -> GetNumberOfElements();

  for(size_t i = 0; i < nmbElements; i++) {

      G4int atomicNumberMat = G4int((*elementVector)[i] -> GetZ());

      isApplicable = table -> BuildPhysicsVector(atomicNumberBase, atomicNumberMat);

      if(isApplicable) { 

         G4PhysicsVector* dEdx = 
                  table -> GetPhysicsVector(atomicNumberBase, atomicNumberMat);
         dEdxTable.push_back(dEdx);
      }
      else {

         dEdxTable.clear();
         break;
      }
  }
     
  if(isApplicable) {

     if(dEdxTable.size() > 0) {

        size_t nmbdEdxBins = dEdxTable[0] -> GetVectorLength();
        G4double lowerEdge = dEdxTable[0] -> GetLowEdgeEnergy(0);
        G4double upperEdge = dEdxTable[0] -> GetLowEdgeEnergy(nmbdEdxBins-1);

        G4LPhysicsFreeVector* dEdxBragg = 
                    new G4LPhysicsFreeVector(nmbdEdxBins,
                                             lowerEdge,
                                             upperEdge);

        const G4double* massFractionVector = material -> GetFractionVector();

        G4bool b;
        for(size_t j = 0; j < nmbdEdxBins; j++) {

            G4double edge = dEdxTable[0] -> GetLowEdgeEnergy(j);

            G4double value = 0.0;
        for(size_t i = 0; i < nmbElements; i++) {
 
                value += (dEdxTable[i] -> GetValue(edge ,b)) *
                                                       massFractionVector[i];
        }

            dEdxBragg -> PutValues(j, edge, value); 
    }
        dEdxBragg -> SetSpline(useSplines);

#ifdef PRINT_DEBUG
        G4cout << "G4IonDEDXHandler::BuildPhysicsVector() for ion with Z="
               << atomicNumberBase << " in "
               << material -> GetName()
               << G4endl;

        G4cout << *dEdxBragg;
#endif

    stoppingPowerTable[key] = dEdxBragg;
    stoppingPowerTableBragg[key] = dEdxBragg;
     }
  }  

  ClearCache();

  return isApplicable;
}

void G4IonDEDXHandler::ClearCache

(

)

Definition at line 424 of file G4IonDEDXHandler.cc.

References python.hepunit::second.

Referenced by BuildDEDXTable(), and ~G4IonDEDXHandler().

                                  {

  CacheIterPointerMap::iterator iter = cacheKeyPointers.begin();
  CacheIterPointerMap::iterator iter_end = cacheKeyPointers.end();
  
  for(;iter != iter_end; iter++) {
      void* pointerIter = iter -> second;
      CacheEntryList::iterator* listPointerIter = 
                          (CacheEntryList::iterator*) pointerIter;

      delete listPointerIter;
  }
 
  cacheEntries.clear();
  cacheKeyPointers.clear();
}

G4double G4IonDEDXHandler::GetDEDX	(	const G4ParticleDefinition *	particle,
		const G4Material *	material,
		G4double	kineticEnergy
	)

Definition at line 148 of file G4IonDEDXHandler.cc.

References test::b, python.hepunit::cm, CacheValue::dedxVector, CacheValue::density, CacheValue::energyScaling, G4cout, G4endl, GetName(), CacheValue::lowerEnergyEdge, and python.hepunit::MeV.

Referenced by PrintDEDXTable().

                                         {     // Kinetic energy of projectile

  G4double dedx = 0.0;

  G4CacheValue value = GetCacheValue(particle, material); 
     
  if(kineticEnergy <= 0.0) dedx = 0.0;
  else if(value.dedxVector != 0) {
 
     G4bool b;
     G4double factor = value.density;

     factor *= algorithm -> ScalingFactorDEDX(particle, 
                                             material,
                                             kineticEnergy);
     G4double scaledKineticEnergy = kineticEnergy * value.energyScaling;

     if(scaledKineticEnergy < value.lowerEnergyEdge) {

        factor *= std::sqrt(scaledKineticEnergy / value.lowerEnergyEdge);
        scaledKineticEnergy = value.lowerEnergyEdge;
     }

     dedx = factor * value.dedxVector -> GetValue(scaledKineticEnergy, b);

     if(dedx < 0.0) dedx = 0.0;
  }
  else dedx = 0.0;

#ifdef PRINT_DEBUG
     G4cout << "G4IonDEDXHandler::GetDEDX() E = " 
            << kineticEnergy / MeV << " MeV * "
            << value.energyScaling << " = "
            << kineticEnergy * value.energyScaling / MeV 
            << " MeV, dE/dx = " << dedx / MeV * cm << " MeV/cm"
            << ", material = " << material -> GetName()
            << G4endl;
#endif

  return dedx;
}

G4double G4IonDEDXHandler::GetLowerEnergyEdge	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

Definition at line 516 of file G4IonDEDXHandler.cc.

References CacheValue::energyScaling, and CacheValue::lowerEnergyEdge.

Referenced by PrintDEDXTable().

                                             {          // Target material 

  G4double edge = 0.0; 

  G4CacheValue value = GetCacheValue(particle, material); 
     
  if(value.energyScaling > 0) 
          edge = value.lowerEnergyEdge / value.energyScaling;

  return edge;
}

G4String G4IonDEDXHandler::GetName

(

void

)

Definition at line 548 of file G4IonDEDXHandler.cc.

Referenced by BuildDEDXTable(), GetDEDX(), and PrintDEDXTable().

                                   {

  return tableName;
}

G4double G4IonDEDXHandler::GetUpperEnergyEdge	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

Definition at line 532 of file G4IonDEDXHandler.cc.

References CacheValue::energyScaling, and CacheValue::upperEnergyEdge.

Referenced by PrintDEDXTable().

                                             {          // Target material 

  G4double edge = 0.0; 

  G4CacheValue value = GetCacheValue(particle, material); 
     
  if(value.energyScaling > 0) 
          edge = value.upperEnergyEdge / value.energyScaling;

  return edge;
}

G4bool G4IonDEDXHandler::IsApplicable	(	const G4ParticleDefinition *	particle,
		const G4Material *	material
	)

Definition at line 122 of file G4IonDEDXHandler.cc.

                                             {          // Target material 

  G4bool isApplicable = true; 

  if(table == 0 || algorithm == 0) {
     isApplicable = false;
  }
  else {

     G4int atomicNumberIon = particle -> GetAtomicNumber();
     G4int atomicNumberBase = 
                algorithm -> AtomicNumberBaseIon(atomicNumberIon, material);

     G4IonKey key = std::make_pair(atomicNumberBase, material);

     DEDXTable::iterator iter = stoppingPowerTable.find(key);
     if(iter == stoppingPowerTable.end()) isApplicable = false; 
  }

  return isApplicable; 
}

void G4IonDEDXHandler::PrintDEDXTable	(	const G4ParticleDefinition *	particle,
		const G4Material *	material,
		G4double	lowerBoundary,
		G4double	upperBoundary,
		G4int	nmbBins,
		G4bool	logScaleEnergy = true
	)

Definition at line 443 of file G4IonDEDXHandler.cc.

References python.hepunit::cm, python.hepunit::cm2, python.hepunit::cm3, energy(), g(), G4cout, G4endl, GetDEDX(), GetLowerEnergyEdge(), GetName(), GetUpperEnergyEdge(), python.hepunit::MeV, and right.

                                         {     // Logarithmic scaling of energy

  G4double atomicMassNumber = particle -> GetAtomicMass();
  G4double materialDensity = material -> GetDensity();

  G4cout << "# dE/dx table for " << particle -> GetParticleName() 
         << " in material " << material -> GetName()
         << " of density " << materialDensity / g * cm3
         << " g/cm3"
         << G4endl
         << "# Projectile mass number A1 = " << atomicMassNumber
         << G4endl
         << "# Energy range (per nucleon) of tabulation: " 
         << GetLowerEnergyEdge(particle, material) / atomicMassNumber / MeV
         << " - " 
         << GetUpperEnergyEdge(particle, material) / atomicMassNumber / MeV
         << " MeV"
         << G4endl
         << "# ------------------------------------------------------"
         << G4endl;
  G4cout << "#"
         << std::setw(13) << std::right << "E"
         << std::setw(14) << "E/A1"
         << std::setw(14) << "dE/dx"
         << std::setw(14) << "1/rho*dE/dx"
         << G4endl;
  G4cout << "#"
         << std::setw(13) << std::right << "(MeV)"
         << std::setw(14) << "(MeV)"
         << std::setw(14) << "(MeV/cm)"
         << std::setw(14) << "(MeV*cm2/mg)"
         << G4endl
         << "# ------------------------------------------------------"
         << G4endl;

  //G4CacheValue value = GetCacheValue(particle, material); 

  G4double energyLowerBoundary = lowerBoundary * atomicMassNumber;
  G4double energyUpperBoundary = upperBoundary * atomicMassNumber; 

  if(logScaleEnergy) {

     energyLowerBoundary = std::log(energyLowerBoundary);
     energyUpperBoundary = std::log(energyUpperBoundary); 
  }

  G4double deltaEnergy = (energyUpperBoundary - energyLowerBoundary) / 
                                                           G4double(nmbBins);

  G4cout.precision(6);
  for(int i = 0; i < nmbBins + 1; i++) {

      G4double energy = energyLowerBoundary + i * deltaEnergy;
      if(logScaleEnergy) energy = std::exp(energy);

      G4double loss = GetDEDX(particle, material, energy);

      G4cout << std::setw(14) << std::right << energy / MeV
             << std::setw(14) << energy / atomicMassNumber / MeV
             << std::setw(14) << loss / MeV * cm
             << std::setw(14) << loss / materialDensity / (MeV*cm2/(0.001*g)) 
             << G4endl;
  }
}

---

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

• G4IonDEDXHandler.hh
• G4IonDEDXHandler.cc