#include <G4VRangeToEnergyConverter.hh>

Inheritance diagram for G4VRangeToEnergyConverter:

Public Member Functions
	G4VRangeToEnergyConverter ()

	G4VRangeToEnergyConverter (const G4VRangeToEnergyConverter &right)

G4VRangeToEnergyConverter &	operator= (const G4VRangeToEnergyConverter &right)

virtual	~G4VRangeToEnergyConverter ()

G4int	operator== (const G4VRangeToEnergyConverter &right) const

G4int	operator!= (const G4VRangeToEnergyConverter &right) const

virtual G4double	Convert (G4double rangeCut, const G4Material *material)

const G4ParticleDefinition *	GetParticleType () const

const G4PhysicsTable *	GetLossTable () const

virtual void	Reset ()

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

Static Public Member Functions
static void	SetEnergyRange (G4double lowedge, G4double highedge)

static G4double	GetLowEdgeEnergy ()

static G4double	GetHighEdgeEnergy ()

static G4double	GetMaxEnergyCut ()

static void	SetMaxEnergyCut (G4double value)

Protected Types
typedef G4PhysicsTable	G4LossTable

typedef G4PhysicsLogVector	G4LossVector

typedef G4PhysicsLogVector	G4RangeVector

Protected Member Functions
virtual void	BuildLossTable ()

virtual G4double	ComputeLoss (G4double AtomicNumber, G4double KineticEnergy)=0

virtual void	BuildRangeVector (const G4Material aMaterial, G4RangeVector rangeVector)

G4double	ConvertCutToKineticEnergy (G4RangeVector *theRangeVector, G4double theCutInLength, size_t materialIndex) const

Protected Attributes
G4double	fMaxEnergyCut

const G4ParticleDefinition *	theParticle

G4LossTable *	theLossTable

G4int	NumberOfElements

const G4int	TotBin

std::vector< G4RangeVector * >	fRangeVectorStore

Static Protected Attributes
static G4double	LowestEnergy = 0.99e-3*MeV

static G4double	HighestEnergy = 100.0e6*MeV

static G4double	MaxEnergyCut = 10.0*GeV

Detailed Description

Definition at line 58 of file G4VRangeToEnergyConverter.hh.

Member Typedef Documentation

typedef G4PhysicsTable G4VRangeToEnergyConverter::G4LossTable

protected

Definition at line 115 of file G4VRangeToEnergyConverter.hh.

typedef G4PhysicsLogVector G4VRangeToEnergyConverter::G4LossVector

protected

Definition at line 119 of file G4VRangeToEnergyConverter.hh.

typedef G4PhysicsLogVector G4VRangeToEnergyConverter::G4RangeVector

protected

Definition at line 131 of file G4VRangeToEnergyConverter.hh.

Constructor & Destructor Documentation

G4VRangeToEnergyConverter::G4VRangeToEnergyConverter ( )

Definition at line 48 of file G4VRangeToEnergyConverter.cc.

References fMaxEnergyCut.

                                                     :
   theParticle(0), theLossTable(0), NumberOfElements(0), TotBin(300),
   verboseLevel(1)
 {
   fMaxEnergyCut = 0.;
 }

G4VRangeToEnergyConverter::G4VRangeToEnergyConverter ( const G4VRangeToEnergyConverter & right )

Definition at line 55 of file G4VRangeToEnergyConverter.cc.

References G4PhysicsTable::clearAndDestroy(), fMaxEnergyCut, right, and theLossTable.

                                                                                            :  theParticle(right.theParticle), theLossTable(0), TotBin(right.TotBin)
 {
   fMaxEnergyCut = 0.;
   if (theLossTable) {
     theLossTable->clearAndDestroy();
     delete theLossTable;
     theLossTable=0;
   }
   *this = right;
 }

G4VRangeToEnergyConverter::~G4VRangeToEnergyConverter ( )

virtual

Definition at line 120 of file G4VRangeToEnergyConverter.cc.

References fRangeVectorStore, NumberOfElements, and theLossTable.

 { 
   // Reset();
   // Comment out Reset() for MT application  
 
   // delete loss table without deleteing vectors  
   if (theLossTable) {  
     delete theLossTable;
   }
   theLossTable=0;
   NumberOfElements=0;
   
   //clear RangeVectorStore without deleteing vectors
   fRangeVectorStore.clear();
 
 }

Member Function Documentation

void G4VRangeToEnergyConverter::BuildLossTable ( )

protectedvirtual

Definition at line 296 of file G4VRangeToEnergyConverter.cc.

References ComputeLoss(), G4PhysicsVector::Energy(), G4cout, G4endl, G4Element::GetElementTable(), G4Element::GetNumberOfElements(), GetVerboseLevel(), G4PhysicsTable::insert(), LowestEnergy, MaxEnergyCut, NumberOfElements, G4PhysicsVector::PutValue(), Reset(), theLossTable, and TotBin.

Referenced by Convert().

 {
   if (size_t(NumberOfElements) == G4Element::GetNumberOfElements()) return;
   
   // clear Loss table and Range vectors
   Reset();
 
   //  Build dE/dx tables for elements
   NumberOfElements = G4Element::GetNumberOfElements();
   theLossTable = new G4LossTable();
   theLossTable->reserve(G4Element::GetNumberOfElements());
 #ifdef G4VERBOSE
   if (GetVerboseLevel()>3) {
     G4cout << "G4VRangeToEnergyConverter::BuildLossTable() ";
     G4cout << "Create theLossTable[" << theLossTable << "]";
     G4cout << " NumberOfElements=" << NumberOfElements <<G4endl;
   }
 #endif
   
   
   // fill the loss table
   for (size_t j=0; j<size_t(NumberOfElements); j++){
     G4double Value;
     G4LossVector* aVector= 0;
     aVector= new G4LossVector(LowestEnergy, MaxEnergyCut, TotBin);
     for (size_t i=0; i<=size_t(TotBin); i++) {
       Value = ComputeLoss(  (*G4Element::GetElementTable())[j]->GetZ(),
                 aVector->Energy(i)
                 );
       aVector->PutValue(i,Value);
     }
     theLossTable->insert(aVector);
   }
 }

void G4VRangeToEnergyConverter::BuildRangeVector	(	const G4Material *	aMaterial,
		G4RangeVector *	rangeVector
	)

protectedvirtual

Reimplemented in G4RToEConvForGamma.

Definition at line 334 of file G4VRangeToEnergyConverter.cc.

References G4Material::GetAtomicNumDensityVector(), G4Material::GetElementVector(), G4PhysicsVector::GetLowEdgeEnergy(), G4Material::GetNumberOfElements(), LowestEnergy, MaxEnergyCut, G4PhysicsVector::PutValue(), G4InuclParticleNames::s0, and TotBin.

Referenced by Convert().

 {
   //  create range vector for a material
   const G4ElementVector* elementVector = aMaterial->GetElementVector();
   const G4double* atomicNumDensityVector = aMaterial->GetAtomicNumDensityVector();
   G4int NumEl = aMaterial->GetNumberOfElements();
 
   // calculate parameters of the low energy part first
   size_t i;
   std::vector<G4double> lossV;
   for ( size_t ib=0; ib<=size_t(TotBin); ib++) {
     G4double loss=0.;
     for (i=0; i<size_t(NumEl); i++) {
       G4int IndEl = (*elementVector)[i]->GetIndex();
       loss += atomicNumDensityVector[i]*
             (*((*theLossTable)[IndEl]))[ib];
     }
     lossV.push_back(loss);
   }
    
   // Integrate with Simpson formula with logarithmic binning
   G4double ltt = std::log(MaxEnergyCut/LowestEnergy);
   G4double dltau = ltt/TotBin;
 
   G4double s0 = 0.;
   G4double Value;
   for ( i=0; i<=size_t(TotBin); i++) {
     G4double t = rangeVector->GetLowEdgeEnergy(i);
     G4double q = t/lossV[i];
     if (i==0) s0 += 0.5*q;
     else s0 += q;
     
     if (i==0) {
        Value = (s0 + 0.5*q)*dltau ;
     } else {
       Value = (s0 - 0.5*q)*dltau ;
     }
     rangeVector->PutValue(i,Value);
   }
 } 

virtual G4double G4VRangeToEnergyConverter::ComputeLoss	(	G4double	AtomicNumber,
		G4double	KineticEnergy
	)

protectedpure virtual

Implemented in G4RToEConvForProton, G4RToEConvForGamma, G4RToEConvForElectron, and G4RToEConvForPositron.

Referenced by BuildLossTable().

G4double G4VRangeToEnergyConverter::Convert	(	G4double	rangeCut,
		const G4Material *	material
	)

virtual

Reimplemented in G4RToEConvForProton.

Definition at line 151 of file G4VRangeToEnergyConverter.cc.

References BuildLossTable(), BuildRangeVector(), python.hepunit::cm3, ConvertCutToKineticEnergy(), density, fMaxEnergyCut, fRangeVectorStore, g(), G4cout, G4endl, G4Material::GetDensity(), G4Material::GetIndex(), G4Material::GetMaterialTable(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), GetVerboseLevel(), python.hepunit::keV, LowestEnergy, MaxEnergyCut, python.hepunit::mm, Reset(), theParticle, and TotBin.

Referenced by G4ProductionCutsTable::ConvertRangeToEnergy(), and G4ProductionCutsTable::UpdateCoupleTable().

 {
 #ifdef G4VERBOSE
     if (GetVerboseLevel()>3) {
       G4cout << "G4VRangeToEnergyConverter::Convert() ";
       G4cout << "Convert for " << material->GetName() 
          << " with Range Cut " << rangeCut/mm << "[mm]" << G4endl;
     }
 #endif
 
   G4double theKineticEnergyCuts = 0.;
 
   if (fMaxEnergyCut != MaxEnergyCut) {
     fMaxEnergyCut = MaxEnergyCut;      
     // clear loss table and renge vectors
     Reset();
   }
  
   // Build the energy loss table
   BuildLossTable();
   
   // Build range vector for every material, convert cut into energy-cut,
   // fill theKineticEnergyCuts and delete the range vector
   static const G4double tune = 0.025*mm*g/cm3 ,lowen = 30.*keV ; 
 
   // check density
   G4double density = material->GetDensity() ;
   if(density <= 0.) {
 #ifdef G4VERBOSE
     if (GetVerboseLevel()>0) {
       G4cout << "G4VRangeToEnergyConverter::Convert() ";
       G4cout << material->GetName() << "has zero density "
          << "( " << density << ")" << G4endl;
     }
 #endif
     return 0.;
   }
  
    // initialize RangeVectorStore
   const G4MaterialTable* table = G4Material::GetMaterialTable();
   G4int ext_size = table->size() - fRangeVectorStore.size();
   for (int i=0; i<ext_size; i++) fRangeVectorStore.push_back(0);
   
   // Build Range Vector
   G4int idx = material->GetIndex(); 
   G4RangeVector* rangeVector = fRangeVectorStore.at(idx);
   if (rangeVector == 0) {
     rangeVector = new G4RangeVector(LowestEnergy, MaxEnergyCut, TotBin); 
     BuildRangeVector(material, rangeVector);
     fRangeVectorStore.at(idx) = rangeVector;
   }
 
   // Convert Range Cut ro Kinetic Energy Cut 
   theKineticEnergyCuts = ConvertCutToKineticEnergy(rangeVector, rangeCut, idx);
   
   if( ((theParticle->GetParticleName()=="e-")||(theParticle->GetParticleName()=="e+"))
       && (theKineticEnergyCuts < lowen) ) {
     //  corr. should be switched on smoothly   
     theKineticEnergyCuts /= (1.+(1.-theKineticEnergyCuts/lowen)*
                  tune/(rangeCut*density)); 
   }
   
   if(theKineticEnergyCuts < LowestEnergy) {
     theKineticEnergyCuts = LowestEnergy ;
   } else if(theKineticEnergyCuts > MaxEnergyCut) {
     theKineticEnergyCuts = MaxEnergyCut;
   }
   
   return theKineticEnergyCuts;
 }

G4double G4VRangeToEnergyConverter::ConvertCutToKineticEnergy	(	G4RangeVector *	theRangeVector,
		G4double	theCutInLength,
		size_t	materialIndex
	)		const

protected

Definition at line 379 of file G4VRangeToEnergyConverter.cc.

References G4cout, G4endl, G4PhysicsVector::GetLowEdgeEnergy(), G4ParticleDefinition::GetParticleName(), GetVerboseLevel(), LowestEnergy, MaxEnergyCut, python.hepunit::mm, theParticle, TotBin, and G4PhysicsVector::Value().

Referenced by Convert().

 {
   const G4double epsilon=0.01;
 
   //  find max. range and the corresponding energy (rmax,Tmax)
   G4double rmax= -1.e10*mm;
 
   G4double T1 = LowestEnergy;
   G4double r1 =(*rangeVector)[0] ;
 
   G4double T2 = MaxEnergyCut;
 
   // check theCutInLength < r1 
   if ( theCutInLength <= r1 ) {  return T1; }
 
   // scan range vector to find nearest bin 
   // ( suppose that r(Ti) > r(Tj) if Ti >Tj )
   for (size_t ibin=0; ibin<=size_t(TotBin); ibin++) {
     G4double T=rangeVector->GetLowEdgeEnergy(ibin);
     G4double r=(*rangeVector)[ibin];
     if ( r>rmax )   rmax=r;
     if (r <theCutInLength ) {
       T1 = T;
       r1 = r;
     } else if (r >theCutInLength ) {
       T2 = T;
       break;
     }
   }
 
   // check cut in length is smaller than range max
   if ( theCutInLength >= rmax )  {
 #ifdef G4VERBOSE
     if (GetVerboseLevel()>2) {
       G4cout << "G4VRangeToEnergyConverter::ConvertCutToKineticEnergy ";
       G4cout << "  for " << theParticle->GetParticleName() << G4endl;
       G4cout << "The cut in range [" << theCutInLength/mm << " (mm)]  ";
       G4cout << " is too big  " ;
       G4cout << " for material  idx=" << materialIndex <<G4endl; 
     }
 #endif
     return  MaxEnergyCut;
   }
   
   // convert range to energy
   G4double T3 = std::sqrt(T1*T2);
   G4double r3 = rangeVector->Value(T3);
   while ( std::fabs(1.-r3/theCutInLength)>epsilon ) {
     if ( theCutInLength <= r3 ) {
       T2 = T3;
     } else {
       T1 = T3;
     }
     T3 = std::sqrt(T1*T2);
     r3 = rangeVector->Value(T3);
   }
 
   return T3;
 }

G4double G4VRangeToEnergyConverter::GetHighEdgeEnergy ( )

static

Definition at line 252 of file G4VRangeToEnergyConverter.cc.

References HighestEnergy.

Referenced by G4ProductionCutsTable::GetHighEdgeEnergy().

 {
   return HighestEnergy;
 }

const G4PhysicsTable* G4VRangeToEnergyConverter::GetLossTable ( ) const

G4double G4VRangeToEnergyConverter::GetLowEdgeEnergy ( )

static

Definition at line 246 of file G4VRangeToEnergyConverter.cc.

References LowestEnergy.

Referenced by G4ProductionCutsTable::GetLowEdgeEnergy().

 {
   return LowestEnergy;
 }

G4double G4VRangeToEnergyConverter::GetMaxEnergyCut ( )

static

Definition at line 260 of file G4VRangeToEnergyConverter.cc.

References MaxEnergyCut.

Referenced by G4ProductionCutsTable::GetMaxEnergyCut().

 {
   return MaxEnergyCut;
 }

const G4ParticleDefinition * G4VRangeToEnergyConverter::GetParticleType ( ) const

inline

Definition at line 172 of file G4VRangeToEnergyConverter.hh.

References theParticle.

 {
    return theParticle;
 }

G4int G4VRangeToEnergyConverter::GetVerboseLevel ( ) const

inline

Definition at line 165 of file G4VRangeToEnergyConverter.hh.

Referenced by BuildLossTable(), Convert(), ConvertCutToKineticEnergy(), G4RToEConvForElectron::G4RToEConvForElectron(), G4RToEConvForGamma::G4RToEConvForGamma(), G4RToEConvForPositron::G4RToEConvForPositron(), and G4RToEConvForProton::G4RToEConvForProton().

 {
    return verboseLevel;
 }

G4int G4VRangeToEnergyConverter::operator!= ( const G4VRangeToEnergyConverter & right ) const

Definition at line 142 of file G4VRangeToEnergyConverter.cc.

References right.

 {
   return this != &right;
 }

G4VRangeToEnergyConverter & G4VRangeToEnergyConverter::operator= ( const G4VRangeToEnergyConverter & right )

Definition at line 66 of file G4VRangeToEnergyConverter.cc.

References G4PhysicsTable::clearAndDestroy(), fMaxEnergyCut, fRangeVectorStore, G4Element::GetNumberOfElements(), HighestEnergy, G4PhysicsTable::insert(), LowestEnergy, MaxEnergyCut, NumberOfElements, G4PhysicsVector::PutValue(), theLossTable, theParticle, and TotBin.

 {
   if (this == &right) return *this;
   if (theLossTable) {
     theLossTable->clearAndDestroy();
     delete theLossTable;
     theLossTable=0;
  }
 
   LowestEnergy = right.LowestEnergy;
   HighestEnergy = right.HighestEnergy;
   MaxEnergyCut = right.MaxEnergyCut;
   fMaxEnergyCut = right.fMaxEnergyCut;
   NumberOfElements = right.NumberOfElements;
   theParticle = right.theParticle;
   verboseLevel = right.verboseLevel;
   
   // create the loss table
   theLossTable = new G4LossTable();
   theLossTable->reserve(G4Element::GetNumberOfElements());  
   // fill the loss table
   for (size_t j=0; j<size_t(NumberOfElements); j++){
     G4LossVector* aVector = new G4LossVector(LowestEnergy, MaxEnergyCut, TotBin);
     for (size_t i=0; i<=size_t(TotBin); i++) {
       G4double Value = (*((*right.theLossTable)[j]))[i];
       aVector->PutValue(i,Value);
     }
     theLossTable->insert(aVector);
   }
 
   // clean up range vector store
   for (size_t idx=0; idx<fRangeVectorStore.size(); idx++){
     delete fRangeVectorStore.at(idx);
   }
   fRangeVectorStore.clear();
 
   // copy range vector store
   for (size_t j=0; j<((right.fRangeVectorStore).size()); j++){
     G4RangeVector* vector = (right.fRangeVectorStore).at(j);
     G4RangeVector* rangeVector = 0; 
     if (vector !=0 ) {
       rangeVector = new G4RangeVector(LowestEnergy, MaxEnergyCut, TotBin);
       fMaxEnergyCut = MaxEnergyCut;   
       for (size_t i=0; i<=size_t(TotBin); i++) {
     G4double Value = (*vector)[i];
     rangeVector->PutValue(i,Value);
       }
     }
     fRangeVectorStore.push_back(rangeVector);
   }
   return *this;
 }

G4int G4VRangeToEnergyConverter::operator== ( const G4VRangeToEnergyConverter & right ) const

Definition at line 137 of file G4VRangeToEnergyConverter.cc.

References right.

 {
   return this == &right;
 }

void G4VRangeToEnergyConverter::Reset ( )

virtual

Reimplemented in G4RToEConvForProton.

Definition at line 273 of file G4VRangeToEnergyConverter.cc.

References G4PhysicsTable::clearAndDestroy(), fRangeVectorStore, NumberOfElements, and theLossTable.

Referenced by BuildLossTable(), Convert(), and G4ProductionCutsTable::ResetConverters().

 {
   // delete loss table
   if (theLossTable) {  
     theLossTable->clearAndDestroy();
     delete theLossTable;
   }
   theLossTable=0;
   NumberOfElements=0;
   
   //clear RangeVectorStore
   for (size_t idx=0; idx<fRangeVectorStore.size(); idx++){
     delete fRangeVectorStore.at(idx);
   }
   fRangeVectorStore.clear();
 } 

void G4VRangeToEnergyConverter::SetEnergyRange	(	G4double	lowedge,
		G4double	highedge
	)

static

Definition at line 226 of file G4VRangeToEnergyConverter.cc.

References G4cerr, G4endl, G4Exception(), python.hepunit::GeV, HighestEnergy, JustWarning, and LowestEnergy.

Referenced by G4ProductionCutsTable::SetEnergyRange().

 {
   // check LowestEnergy/ HighestEnergy 
   if ( (lowedge<0.0)||(highedge<=lowedge) ){
 #ifdef G4VERBOSE
     G4cerr << "Error in G4VRangeToEnergyConverter::SetEnergyRange";
     G4cerr << " :  illegal energy range" << "(" << lowedge/GeV;
     G4cerr << "," << highedge/GeV << ") [GeV]" << G4endl;
 #endif
     G4Exception( "G4VRangeToEnergyConverter::SetEnergyRange()",
          "ProcCuts101",
          JustWarning, "Illegal energy range ");
   } else {
     LowestEnergy = lowedge;
     HighestEnergy = highedge;
   }
 }