G4VRangeToEnergyConverter Class Reference

#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) const =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 114 of file G4VRangeToEnergyConverter.hh.

typedef G4PhysicsLogVector G4VRangeToEnergyConverter::G4LossVector [protected]

Definition at line 118 of file G4VRangeToEnergyConverter.hh.

typedef G4PhysicsLogVector G4VRangeToEnergyConverter::G4RangeVector [protected]

Definition at line 130 of file G4VRangeToEnergyConverter.hh.

Constructor & Destructor Documentation

G4VRangeToEnergyConverter::G4VRangeToEnergyConverter ( )

Definition at line 51 of file G4VRangeToEnergyConverter.cc.

References fMaxEnergyCut.

00051                                                     :
00052   theParticle(0), theLossTable(0), NumberOfElements(0), TotBin(300),
00053   verboseLevel(1)
00054 {
00055   fMaxEnergyCut = 0.;
00056 }

G4VRangeToEnergyConverter::G4VRangeToEnergyConverter ( const G4VRangeToEnergyConverter & right )

Definition at line 58 of file G4VRangeToEnergyConverter.cc.

References fMaxEnergyCut.

00058                                                                                            :  theParticle(right.theParticle), theLossTable(0), TotBin(right.TotBin)
00059 {
00060   fMaxEnergyCut = 0.;
00061   *this = right;
00062 }

G4VRangeToEnergyConverter::~G4VRangeToEnergyConverter ( ) [virtual]

Definition at line 115 of file G4VRangeToEnergyConverter.cc.

References Reset().

00116 { 
00117   Reset(); 
00118 }

Member Function Documentation

void G4VRangeToEnergyConverter::BuildLossTable ( ) [protected, virtual]

Definition at line 279 of file G4VRangeToEnergyConverter.cc.

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

Referenced by Convert().

00280 {
00281   if (size_t(NumberOfElements) == G4Element::GetNumberOfElements()) return;
00282   
00283   // clear Loss table and Range vectors
00284   Reset();
00285 
00286   //  Build dE/dx tables for elements
00287   NumberOfElements = G4Element::GetNumberOfElements();
00288   theLossTable = new G4LossTable();
00289   theLossTable->reserve(G4Element::GetNumberOfElements());
00290 #ifdef G4VERBOSE
00291   if (GetVerboseLevel()>3) {
00292     G4cout << "G4VRangeToEnergyConverter::BuildLossTable() ";
00293     G4cout << "Create theLossTable[" << theLossTable << "]";
00294     G4cout << " NumberOfElements=" << NumberOfElements <<G4endl;
00295   }
00296 #endif
00297   
00298   
00299   // fill the loss table
00300   for (size_t j=0; j<size_t(NumberOfElements); j++){
00301     G4double Value;
00302     G4LossVector* aVector= 0;
00303     aVector= new G4LossVector(LowestEnergy, MaxEnergyCut, TotBin);
00304     for (size_t i=0; i<size_t(TotBin); i++) {
00305       Value = ComputeLoss(  (*G4Element::GetElementTable())[j]->GetZ(),
00306                             aVector->GetLowEdgeEnergy(i)
00307                             );
00308       aVector->PutValue(i,Value);
00309     }
00310     theLossTable->insert(aVector);
00311   }
00312 }

void G4VRangeToEnergyConverter::BuildRangeVector	(	const G4Material *	aMaterial,
		G4RangeVector *	rangeVector
	)			`[protected, virtual]`

Definition at line 317 of file G4VRangeToEnergyConverter.cc.

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

Referenced by Convert().

00319 {
00320   //  create range vector for a material
00321   const G4ElementVector* elementVector = aMaterial->GetElementVector();
00322   const G4double* atomicNumDensityVector = aMaterial->GetAtomicNumDensityVector();
00323   G4int NumEl = aMaterial->GetNumberOfElements();
00324 
00325   // calculate parameters of the low energy part first
00326   size_t i;
00327   std::vector<G4double> lossV;
00328   for ( size_t ib=0; ib<size_t(TotBin); ib++) {
00329     G4double loss=0.;
00330     for (i=0; i<size_t(NumEl); i++) {
00331       G4int IndEl = (*elementVector)[i]->GetIndex();
00332       loss += atomicNumDensityVector[i]*
00333                 (*((*theLossTable)[IndEl]))[ib];
00334     }
00335     lossV.push_back(loss);
00336   }
00337    
00338   // Integrate with Simpson formula with logarithmic binning
00339   G4double ltt = std::log(MaxEnergyCut/LowestEnergy);
00340   G4double dltau = ltt/TotBin;
00341 
00342   G4double s0 = 0.;
00343   G4double Value;
00344   for ( i=0; i<size_t(TotBin); i++) {
00345     G4double t = rangeVector->GetLowEdgeEnergy(i);
00346     G4double q = t/lossV[i];
00347     if (i==0) s0 += 0.5*q;
00348     else s0 += q;
00349     
00350     if (i==0) {
00351        Value = (s0 + 0.5*q)*dltau ;
00352     } else {
00353       Value = (s0 - 0.5*q)*dltau ;
00354     }
00355     rangeVector->PutValue(i,Value);
00356   }
00357 }

virtual G4double G4VRangeToEnergyConverter::ComputeLoss	(	G4double	AtomicNumber,
		G4double	KineticEnergy
	)			const `[protected, pure virtual]`

Implemented in G4RToEConvForElectron, G4RToEConvForGamma, G4RToEConvForPositron, and G4RToEConvForProton.

Referenced by BuildLossTable().

G4double G4VRangeToEnergyConverter::Convert	(	G4double	rangeCut,
		const G4Material *	material
	)			`[virtual]`

Reimplemented in G4RToEConvForProton.

Definition at line 134 of file G4VRangeToEnergyConverter.cc.

References BuildLossTable(), BuildRangeVector(), ConvertCutToKineticEnergy(), fMaxEnergyCut, fRangeVectorStore, G4cout, G4endl, G4Material::GetDensity(), G4Material::GetIndex(), G4Material::GetMaterialTable(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), GetVerboseLevel(), LowestEnergy, MaxEnergyCut, Reset(), theParticle, and TotBin.

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

00136 {
00137 #ifdef G4VERBOSE
00138     if (GetVerboseLevel()>3) {
00139       G4cout << "G4VRangeToEnergyConverter::Convert() ";
00140       G4cout << "Convert for " << material->GetName() 
00141              << " with Range Cut " << rangeCut/mm << "[mm]" << G4endl;
00142     }
00143 #endif
00144 
00145   G4double theKineticEnergyCuts = 0.;
00146 
00147   if (fMaxEnergyCut != MaxEnergyCut) {
00148     fMaxEnergyCut = MaxEnergyCut;      
00149     // clear loss table and renge vectors
00150     Reset();
00151   }
00152  
00153   // Build the energy loss table
00154   BuildLossTable();
00155   
00156   // Build range vector for every material, convert cut into energy-cut,
00157   // fill theKineticEnergyCuts and delete the range vector
00158   G4double tune = 0.025*mm*g/cm3 ,lowen = 30.*keV ; 
00159 
00160   // check density
00161   G4double density = material->GetDensity() ;
00162   if(density <= 0.) {
00163  #ifdef G4VERBOSE
00164     if (GetVerboseLevel()>0) {
00165       G4cout << "G4VRangeToEnergyConverter::Convert() ";
00166       G4cout << material->GetName() << "has zero density "
00167              << "( " << density << ")" << G4endl;
00168     }
00169 #endif
00170     return 0.;
00171   }
00172  
00173    // initialize RangeVectorStore
00174   const G4MaterialTable* table = G4Material::GetMaterialTable();
00175   G4int ext_size = table->size() - fRangeVectorStore.size();
00176   for (int i=0; i<ext_size; i++) fRangeVectorStore.push_back(0);
00177   
00178   // Build Range Vector
00179   G4int idx = material->GetIndex(); 
00180   G4RangeVector* rangeVector = fRangeVectorStore.at(idx);
00181   if (rangeVector == 0) {
00182     rangeVector = new G4RangeVector(LowestEnergy, MaxEnergyCut, TotBin); 
00183     BuildRangeVector(material, rangeVector);
00184     fRangeVectorStore.at(idx) = rangeVector;
00185   }
00186 
00187   // Convert Range Cut ro Kinetic Energy Cut 
00188   theKineticEnergyCuts = ConvertCutToKineticEnergy(rangeVector, rangeCut, idx);
00189   
00190   if( ((theParticle->GetParticleName()=="e-")||(theParticle->GetParticleName()=="e+"))
00191       && (theKineticEnergyCuts < lowen) ) {
00192     //  corr. should be switched on smoothly   
00193     theKineticEnergyCuts /= (1.+(1.-theKineticEnergyCuts/lowen)*
00194                              tune/(rangeCut*density)); 
00195   }
00196   
00197   if(theKineticEnergyCuts < LowestEnergy) {
00198     theKineticEnergyCuts = LowestEnergy ;
00199   } else if(theKineticEnergyCuts > MaxEnergyCut) {
00200     theKineticEnergyCuts = MaxEnergyCut;
00201   }
00202   
00203   return theKineticEnergyCuts;
00204 }

G4double G4VRangeToEnergyConverter::ConvertCutToKineticEnergy	(	G4RangeVector *	theRangeVector,
		G4double	theCutInLength,
		size_t	materialIndex
	)			const `[protected]`

Definition at line 362 of file G4VRangeToEnergyConverter.cc.

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

Referenced by Convert().

00371 {
00372   const G4double epsilon=0.01;
00373 
00374   //  find max. range and the corresponding energy (rmax,Tmax)
00375   G4double rmax= -1.e10*mm;
00376 
00377   G4double T1 = LowestEnergy;
00378   G4double r1 =(*rangeVector)[0] ;
00379 
00380   G4double T2 = MaxEnergyCut;
00381 
00382   // check theCutInLength < r1 
00383   if ( theCutInLength <= r1 ) {  return T1; }
00384 
00385   // scan range vector to find nearest bin 
00386   // ( suppose that r(Ti) > r(Tj) if Ti >Tj )
00387   for (size_t ibin=0; ibin<size_t(TotBin); ibin++) {
00388     G4double T=rangeVector->GetLowEdgeEnergy(ibin);
00389     G4double r=(*rangeVector)[ibin];
00390     if ( r>rmax )   rmax=r;
00391     if (r <theCutInLength ) {
00392       T1 = T;
00393       r1 = r;
00394     } else if (r >theCutInLength ) {
00395       T2 = T;
00396       break;
00397     }
00398   }
00399 
00400   // check cut in length is smaller than range max
00401   if ( theCutInLength >= rmax )  {
00402 #ifdef G4VERBOSE
00403     if (GetVerboseLevel()>2) {
00404       G4cout << "G4VRangeToEnergyConverter::ConvertCutToKineticEnergy ";
00405       G4cout << "  for " << theParticle->GetParticleName() << G4endl;
00406       G4cout << "The cut in range [" << theCutInLength/mm << " (mm)]  ";
00407       G4cout << " is too big  " ;
00408       G4cout << " for material  idx=" << materialIndex <<G4endl; 
00409     }
00410 #endif
00411     return  MaxEnergyCut;
00412   }
00413   
00414   // convert range to energy
00415   G4double T3 = std::sqrt(T1*T2);
00416   G4double r3 = rangeVector->Value(T3);
00417   while ( std::fabs(1.-r3/theCutInLength)>epsilon ) {
00418     if ( theCutInLength <= r3 ) {
00419       T2 = T3;
00420     } else {
00421       T1 = T3;
00422     }
00423     T3 = std::sqrt(T1*T2);
00424     r3 = rangeVector->Value(T3);
00425   }
00426 
00427   return T3;
00428 }

G4double G4VRangeToEnergyConverter::GetHighEdgeEnergy ( ) [static]

Definition at line 235 of file G4VRangeToEnergyConverter.cc.

References HighestEnergy.

Referenced by G4ProductionCutsTable::GetHighEdgeEnergy().

00236 {
00237   return HighestEnergy;
00238 }

const G4PhysicsTable* G4VRangeToEnergyConverter::GetLossTable ( ) const

G4double G4VRangeToEnergyConverter::GetLowEdgeEnergy ( ) [static]

Definition at line 229 of file G4VRangeToEnergyConverter.cc.

References LowestEnergy.

Referenced by G4ProductionCutsTable::GetLowEdgeEnergy().

00230 {
00231   return LowestEnergy;
00232 }

G4double G4VRangeToEnergyConverter::GetMaxEnergyCut ( ) [static]

Definition at line 243 of file G4VRangeToEnergyConverter.cc.

References MaxEnergyCut.

Referenced by G4ProductionCutsTable::GetMaxEnergyCut().

00244 {
00245   return MaxEnergyCut;
00246 }

const G4ParticleDefinition * G4VRangeToEnergyConverter::GetParticleType ( ) const [inline]

Definition at line 171 of file G4VRangeToEnergyConverter.hh.

References theParticle.

00172 {
00173    return theParticle;
00174 }

G4int G4VRangeToEnergyConverter::GetVerboseLevel ( ) const [inline]

Definition at line 164 of file G4VRangeToEnergyConverter.hh.

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

00165 {
00166    return verboseLevel;
00167 }

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

Definition at line 125 of file G4VRangeToEnergyConverter.cc.

00126 {
00127   return this != &right;
00128 }

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

Definition at line 64 of file G4VRangeToEnergyConverter.cc.

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

00065 {
00066   if (this == &right) return *this;
00067   if (theLossTable) {
00068     theLossTable->clearAndDestroy();
00069     delete theLossTable;
00070     theLossTable=0;
00071  }
00072 
00073   NumberOfElements = right.NumberOfElements;
00074   theParticle = right.theParticle;
00075   verboseLevel = right.verboseLevel;
00076   
00077   // create the loss table
00078   theLossTable = new G4LossTable();
00079   theLossTable->reserve(G4Element::GetNumberOfElements());  
00080   // fill the loss table
00081   for (size_t j=0; j<size_t(NumberOfElements); j++){
00082     G4LossVector* aVector= new
00083             G4LossVector(LowestEnergy, MaxEnergyCut, TotBin);
00084     for (size_t i=0; i<size_t(TotBin); i++) {
00085       G4double Value = (*((*right.theLossTable)[j]))[i];
00086       aVector->PutValue(i,Value);
00087     }
00088     theLossTable->insert(aVector);
00089   }
00090 
00091   // clean up range vector store
00092   for (size_t idx=0; idx<fRangeVectorStore.size(); idx++){
00093     delete fRangeVectorStore.at(idx);
00094   }
00095   fRangeVectorStore.clear();
00096 
00097   // copy range vector store
00098   for (size_t j=0; j<((right.fRangeVectorStore).size()); j++){
00099     G4RangeVector* vector = (right.fRangeVectorStore).at(j);
00100     G4RangeVector* rangeVector = 0; 
00101     if (vector !=0 ) {
00102       rangeVector = new G4RangeVector(LowestEnergy, MaxEnergyCut, TotBin);
00103       fMaxEnergyCut = MaxEnergyCut;   
00104       for (size_t i=0; i<size_t(TotBin); i++) {
00105         G4double Value = (*vector)[i];
00106         rangeVector->PutValue(i,Value);
00107       }
00108     }
00109     fRangeVectorStore.push_back(rangeVector);
00110   }
00111   return *this;
00112 }

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

Definition at line 120 of file G4VRangeToEnergyConverter.cc.

00121 {
00122   return this == &right;
00123 }

void G4VRangeToEnergyConverter::Reset ( ) [virtual]

Reimplemented in G4RToEConvForProton.

Definition at line 256 of file G4VRangeToEnergyConverter.cc.

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

Referenced by BuildLossTable(), Convert(), and ~G4VRangeToEnergyConverter().

00257 {
00258   // delete loss table
00259   if (theLossTable) {  
00260     theLossTable->clearAndDestroy();
00261     delete theLossTable;
00262   }
00263   theLossTable=0;
00264   NumberOfElements=0;
00265   
00266   //clear RangeVectorStore
00267   for (size_t idx=0; idx<fRangeVectorStore.size(); idx++){
00268     delete fRangeVectorStore.at(idx);
00269   }
00270   fRangeVectorStore.clear();
00271 }

void G4VRangeToEnergyConverter::SetEnergyRange	(	G4double	lowedge,
		G4double	highedge
	)			`[static]`

Definition at line 209 of file G4VRangeToEnergyConverter.cc.

References G4cerr, G4endl, G4Exception(), HighestEnergy, JustWarning, and LowestEnergy.

Referenced by G4ProductionCutsTable::SetEnergyRange().

00211 {
00212   // check LowestEnergy/ HighestEnergy 
00213   if ( (lowedge<0.0)||(highedge<=lowedge) ){
00214 #ifdef G4VERBOSE
00215     G4cerr << "Error in G4VRangeToEnergyConverter::SetEnergyRange";
00216     G4cerr << " :  illegal energy range" << "(" << lowedge/GeV;
00217     G4cerr << "," << highedge/GeV << ") [GeV]" << G4endl;
00218 #endif
00219     G4Exception( "G4VRangeToEnergyConverter::SetEnergyRange()",
00220                  "ProcCuts101",
00221                  JustWarning, "Illegal energy range ");
00222   } else {
00223     LowestEnergy = lowedge;
00224     HighestEnergy = highedge;
00225   }
00226 }

void G4VRangeToEnergyConverter::SetMaxEnergyCut ( G4double value ) [static]

Definition at line 248 of file G4VRangeToEnergyConverter.cc.

References MaxEnergyCut.

Referenced by G4ProductionCutsTable::SetMaxEnergyCut().

00249 {
00250   MaxEnergyCut = value;
00251 }

void G4VRangeToEnergyConverter::SetVerboseLevel ( G4int value ) [inline]

Definition at line 158 of file G4VRangeToEnergyConverter.hh.

Referenced by G4ProductionCutsTable::UpdateCoupleTable().

00159 {
00160    verboseLevel = value;
00161 }

Field Documentation

G4double G4VRangeToEnergyConverter::fMaxEnergyCut [protected]

Definition at line 111 of file G4VRangeToEnergyConverter.hh.

Referenced by Convert(), G4VRangeToEnergyConverter(), and operator=().

std::vector< G4RangeVector* > G4VRangeToEnergyConverter::fRangeVectorStore [protected]

Definition at line 135 of file G4VRangeToEnergyConverter.hh.

Referenced by Convert(), operator=(), and Reset().

G4double G4VRangeToEnergyConverter::HighestEnergy = 100.0e6*MeV [static, protected]

Definition at line 109 of file G4VRangeToEnergyConverter.hh.

Referenced by GetHighEdgeEnergy(), and SetEnergyRange().

G4double G4VRangeToEnergyConverter::LowestEnergy = 0.99e-3*MeV [static, protected]

Definition at line 109 of file G4VRangeToEnergyConverter.hh.

Referenced by BuildLossTable(), BuildRangeVector(), Convert(), ConvertCutToKineticEnergy(), GetLowEdgeEnergy(), operator=(), and SetEnergyRange().

G4double G4VRangeToEnergyConverter::MaxEnergyCut = 10.0*GeV [static, protected]

Definition at line 110 of file G4VRangeToEnergyConverter.hh.

Referenced by BuildLossTable(), BuildRangeVector(), Convert(), ConvertCutToKineticEnergy(), GetMaxEnergyCut(), operator=(), and SetMaxEnergyCut().

G4int G4VRangeToEnergyConverter::NumberOfElements [protected]

Definition at line 116 of file G4VRangeToEnergyConverter.hh.

Referenced by BuildLossTable(), operator=(), and Reset().

G4LossTable* G4VRangeToEnergyConverter::theLossTable [protected]

Definition at line 115 of file G4VRangeToEnergyConverter.hh.

Referenced by G4RToEConvForGamma::BuildAbsorptionLengthVector(), BuildLossTable(), operator=(), and Reset().

const G4ParticleDefinition* G4VRangeToEnergyConverter::theParticle [protected]

Definition at line 113 of file G4VRangeToEnergyConverter.hh.

Referenced by G4RToEConvForProton::ComputeLoss(), G4RToEConvForPositron::ComputeLoss(), G4RToEConvForElectron::ComputeLoss(), Convert(), ConvertCutToKineticEnergy(), G4RToEConvForElectron::G4RToEConvForElectron(), G4RToEConvForGamma::G4RToEConvForGamma(), G4RToEConvForPositron::G4RToEConvForPositron(), G4RToEConvForProton::G4RToEConvForProton(), GetParticleType(), and operator=().

const G4int G4VRangeToEnergyConverter::TotBin [protected]

Definition at line 119 of file G4VRangeToEnergyConverter.hh.

Referenced by G4RToEConvForGamma::BuildAbsorptionLengthVector(), BuildLossTable(), BuildRangeVector(), Convert(), ConvertCutToKineticEnergy(), and operator=().

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

Generated on Mon May 27 17:53:54 2013 for Geant4 by

1.4.7

G4VRangeToEnergyConverter Class Reference

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation