#include <G4TablesForExtrapolator.hh>

Collaboration diagram for G4TablesForExtrapolator:

Public Member Functions
	G4TablesForExtrapolator (G4int verb, G4int bins, G4double e1, G4double e2)

	~G4TablesForExtrapolator ()

const G4PhysicsTable *	GetPhysicsTable (ExtTableType type) const

Private Member Functions
void	Initialisation ()

G4PhysicsTable *	PrepareTable ()

void	ComputeElectronDEDX (const G4ParticleDefinition part, G4PhysicsTable table)

void	ComputeMuonDEDX (const G4ParticleDefinition part, G4PhysicsTable table)

void	ComputeProtonDEDX (const G4ParticleDefinition part, G4PhysicsTable table)

void	ComputeTrasportXS (const G4ParticleDefinition part, G4PhysicsTable table)

G4TablesForExtrapolator &	operator= (const G4TablesForExtrapolator &right)

	G4TablesForExtrapolator (const G4TablesForExtrapolator &)

Private Attributes
const G4ParticleDefinition *	currentParticle

const G4ParticleDefinition *	electron

const G4ParticleDefinition *	positron

const G4ParticleDefinition *	muonPlus

const G4ParticleDefinition *	muonMinus

const G4ParticleDefinition *	proton

G4DataVector	cuts

G4ProductionCuts *	pcuts

std::vector< const G4MaterialCutsCouple * >	couples

G4PhysicsTable *	dedxElectron

G4PhysicsTable *	dedxPositron

G4PhysicsTable *	dedxMuon

G4PhysicsTable *	dedxProton

G4PhysicsTable *	rangeElectron

G4PhysicsTable *	rangePositron

G4PhysicsTable *	rangeMuon

G4PhysicsTable *	rangeProton

G4PhysicsTable *	invRangeElectron

G4PhysicsTable *	invRangePositron

G4PhysicsTable *	invRangeMuon

G4PhysicsTable *	invRangeProton

G4PhysicsTable *	mscElectron

G4int	verbose

G4int	nbins

G4int	nmat

G4double	emin

G4double	emax

G4double	mass

G4double	charge2

G4bool	splineFlag

Detailed Description

Definition at line 75 of file G4TablesForExtrapolator.hh.

Constructor & Destructor Documentation

◆ G4TablesForExtrapolator() [1/2]

G4TablesForExtrapolator::G4TablesForExtrapolator	(	G4int	verb,
		G4int	bins,
		G4double	e1,
		G4double	e2
	)

Definition at line 74 of file G4TablesForExtrapolator.cc.

   : verbose(verb), nbins(bins), emin(e1), emax(e2)
 {
   Initialisation();
 }

Here is the call graph for this function:

◆ ~G4TablesForExtrapolator()

G4TablesForExtrapolator::~G4TablesForExtrapolator ( )

Definition at line 83 of file G4TablesForExtrapolator.cc.

 {
   for(G4int i=0; i<nmat; i++) {delete couples[i];}
 
   dedxElectron->clearAndDestroy();
   dedxPositron->clearAndDestroy();
   dedxProton->clearAndDestroy();
   dedxMuon->clearAndDestroy();
   rangeElectron->clearAndDestroy();
   rangePositron->clearAndDestroy();
   rangeProton->clearAndDestroy();
   rangeMuon->clearAndDestroy();
   invRangeElectron->clearAndDestroy();
   invRangePositron->clearAndDestroy();
   invRangeProton->clearAndDestroy();
   invRangeMuon->clearAndDestroy();
   mscElectron->clearAndDestroy();
 
   delete dedxElectron;
   delete dedxPositron;
   delete dedxProton;
   delete dedxMuon;
   delete rangeElectron;
   delete rangePositron;
   delete rangeProton;
   delete rangeMuon;
   delete invRangeElectron;
   delete invRangePositron;
   delete invRangeProton;
   delete invRangeMuon;
   delete mscElectron;
   delete pcuts;
 }

Here is the call graph for this function:

◆ G4TablesForExtrapolator() [2/2]

G4TablesForExtrapolator::G4TablesForExtrapolator ( const G4TablesForExtrapolator & )

private

Member Function Documentation

◆ ComputeElectronDEDX()

void G4TablesForExtrapolator::ComputeElectronDEDX	(	const G4ParticleDefinition *	part,
		G4PhysicsTable *	table
	)

private

Definition at line 271 of file G4TablesForExtrapolator.cc.

 {
   G4MollerBhabhaModel* ioni = new G4MollerBhabhaModel();
   G4eBremsstrahlungRelModel* brem = new G4eBremsstrahlungRelModel();
   ioni->Initialise(part, cuts);
   brem->Initialise(part, cuts);
 
   mass    = electron_mass_c2;
   charge2 = 1.0;
   currentParticle = part;
 
   const G4MaterialTable* mtable = G4Material::GetMaterialTable();
   if(0<verbose) {
     G4cout << "G4TablesForExtrapolator::ComputeElectronDEDX for " 
            << part->GetParticleName() 
            << G4endl;
   }
   for(G4int i=0; i<nmat; ++i) {  
 
     const G4Material* mat = (*mtable)[i];
     if(1<verbose) {
       G4cout << "i= " << i << "  mat= " << mat->GetName() << G4endl;
     }
     const G4MaterialCutsCouple* couple = couples[i];
     G4PhysicsVector* aVector = (*table)[i];
 
     for(G4int j=0; j<=nbins; ++j) {
         
        G4double e = aVector->Energy(j);
        G4double dedx = ioni->ComputeDEDX(couple,part,e,e) 
      + brem->ComputeDEDX(couple,part,e,e);
        if(1<verbose) {
          G4cout << "j= " << j
                 << "  e(MeV)= " << e/MeV  
                 << " dedx(Mev/cm)= " << dedx*cm/MeV
                 << " dedx(Mev.cm2/g)= " 
         << dedx/((MeV*mat->GetDensity())/(g/cm2)) 
         << G4endl;
        }
        aVector->PutValue(j,dedx);
     }
     if(splineFlag) { aVector->FillSecondDerivatives(); }
   }
   delete ioni;
   delete brem;
 } 

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeMuonDEDX()

void G4TablesForExtrapolator::ComputeMuonDEDX	(	const G4ParticleDefinition *	part,
		G4PhysicsTable *	table
	)

private

Definition at line 323 of file G4TablesForExtrapolator.cc.

 {
   G4BetheBlochModel* ioni = new G4BetheBlochModel();
   G4MuPairProductionModel* pair = new G4MuPairProductionModel();
   G4MuBremsstrahlungModel* brem = new G4MuBremsstrahlungModel();
   ioni->Initialise(part, cuts);
   pair->Initialise(part, cuts);
   brem->Initialise(part, cuts);
 
   mass    = part->GetPDGMass();
   charge2 = 1.0;
   currentParticle = part;
 
   const G4MaterialTable* mtable = G4Material::GetMaterialTable();
 
   if(0<verbose) {
     G4cout << "G4TablesForExtrapolator::ComputeMuonDEDX for " 
        << part->GetParticleName() 
            << G4endl;
   }
  
   for(G4int i=0; i<nmat; ++i) {  
 
     const G4Material* mat = (*mtable)[i];
     if(1<verbose) {
       G4cout << "i= " << i << "  mat= " << mat->GetName() << G4endl;
     }
     const G4MaterialCutsCouple* couple = couples[i];
     G4PhysicsVector* aVector = (*table)[i];
     for(G4int j=0; j<=nbins; j++) {
         
        G4double e = aVector->Energy(j);
        G4double dedx = ioni->ComputeDEDX(couple,part,e,e) +
                    pair->ComputeDEDX(couple,part,e,e) +
                    brem->ComputeDEDX(couple,part,e,e);
        aVector->PutValue(j,dedx);
        if(1<verbose) {
          G4cout << "j= " << j
                 << "  e(MeV)= " << e/MeV  
                 << " dedx(Mev/cm)= " << dedx*cm/MeV
                 << " dedx(Mev/(g/cm2)= " 
                 << dedx/((MeV*mat->GetDensity())/(g/cm2))
         << G4endl;
        }
     }
     if(splineFlag) { aVector->FillSecondDerivatives(); }
   }
   delete ioni;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeProtonDEDX()

void G4TablesForExtrapolator::ComputeProtonDEDX	(	const G4ParticleDefinition *	part,
		G4PhysicsTable *	table
	)

private

Definition at line 377 of file G4TablesForExtrapolator.cc.

 {
   G4BetheBlochModel* ioni = new G4BetheBlochModel();
   ioni->Initialise(part, cuts);
 
   mass    = part->GetPDGMass();
   charge2 = 1.0;
   currentParticle = part;
 
   const G4MaterialTable* mtable = G4Material::GetMaterialTable();
 
   if(0<verbose) {
     G4cout << "G4TablesForExtrapolator::ComputeProtonDEDX for " 
        << part->GetParticleName() 
            << G4endl;
   }
  
   for(G4int i=0; i<nmat; ++i) {  
 
     const G4Material* mat = (*mtable)[i];
     if(1<verbose)
       G4cout << "i= " << i << "  mat= " << mat->GetName() << G4endl;
     const G4MaterialCutsCouple* couple = couples[i];
     G4PhysicsVector* aVector = (*table)[i];
     for(G4int j=0; j<=nbins; j++) {
         
        G4double e = aVector->Energy(j);
        G4double dedx = ioni->ComputeDEDX(couple,part,e,e);
        aVector->PutValue(j,dedx);
        if(1<verbose) {
          G4cout << "j= " << j
                 << "  e(MeV)= " << e/MeV  
                 << " dedx(Mev/cm)= " << dedx*cm/MeV
                 << " dedx(Mev.cm2/g)= " << dedx/((mat->GetDensity())/(g/cm2)) 
         << G4endl;
        }
     }
     if(splineFlag) { aVector->FillSecondDerivatives(); }
   }
   delete ioni;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ComputeTrasportXS()

void G4TablesForExtrapolator::ComputeTrasportXS	(	const G4ParticleDefinition *	part,
		G4PhysicsTable *	table
	)

private

Definition at line 423 of file G4TablesForExtrapolator.cc.

 {
   G4WentzelVIModel* msc = new G4WentzelVIModel();
   msc->SetPolarAngleLimit(CLHEP::pi);
   msc->Initialise(part, cuts);
 
   mass    = part->GetPDGMass();
   charge2 = 1.0;
   currentParticle = part;
 
   const G4MaterialTable* mtable = G4Material::GetMaterialTable();
 
   if(0<verbose) {
     G4cout << "G4TablesForExtrapolator::ComputeProtonDEDX for " 
        << part->GetParticleName() 
            << G4endl;
   }
  
   for(G4int i=0; i<nmat; ++i) {  
 
     const G4Material* mat = (*mtable)[i];
     msc->SetCurrentCouple(couples[i]);
     if(1<verbose)
       G4cout << "i= " << i << "  mat= " << mat->GetName() << G4endl;
     G4PhysicsVector* aVector = (*table)[i];
     for(G4int j=0; j<=nbins; j++) {
         
        G4double e = aVector->Energy(j);
        G4double xs = msc->CrossSectionPerVolume(mat,part,e);
        aVector->PutValue(j,xs);
        if(1<verbose) {
          G4cout << "j= " << j << "  e(MeV)= " << e/MeV  
                 << " xs(1/mm)= " << xs*mm << G4endl;
        }
     }
     if(splineFlag) { aVector->FillSecondDerivatives(); }
   }
   delete msc;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPhysicsTable()

const G4PhysicsTable * G4TablesForExtrapolator::GetPhysicsTable ( ExtTableType type ) const

Definition at line 120 of file G4TablesForExtrapolator.cc.

 {
   const G4PhysicsTable* table = 0;
   switch (type) 
     {
     case fDedxElectron:
       table = dedxElectron;
       break;
     case fDedxPositron:
       table = dedxPositron;
       break;
     case fDedxProton:
       table = dedxProton;
       break;
     case fDedxMuon:
       table = dedxMuon;
       break;
     case fRangeElectron:
       table = rangeElectron;
       break;
     case fRangePositron:
       table = rangePositron;
       break;
     case fRangeProton:
       table = rangeProton;
       break;
     case fRangeMuon:
       table = rangeMuon;
       break;
     case fInvRangeElectron:
       table = invRangeElectron;
       break;
     case fInvRangePositron:
       table = invRangePositron;
       break;
     case fInvRangeProton:
       table = invRangeProton;
       break;
     case fInvRangeMuon:
       table = invRangeMuon;
       break;
     case fMscElectron:
       table = mscElectron;
     }
   return table;
 }

Here is the caller graph for this function:

◆ Initialisation()

void G4TablesForExtrapolator::Initialisation ( )

private

Definition at line 169 of file G4TablesForExtrapolator.cc.

 {
   if(verbose>1) {
     G4cout << "### G4TablesForExtrapolator::Initialisation" << G4endl;
   }
   currentParticle = 0;
 
   electron = G4Electron::Electron();
   positron = G4Positron::Positron();
   proton   = G4Proton::Proton();
   muonPlus = G4MuonPlus::MuonPlus();
   muonMinus= G4MuonMinus::MuonMinus();
 
   mass = charge2 = 0.0;
 
   nmat = G4Material::GetNumberOfMaterials();
   const G4MaterialTable* mtable = G4Material::GetMaterialTable();
   pcuts = new G4ProductionCuts();
 
   couples.resize(nmat,0);
   cuts.resize(nmat,DBL_MAX);
 
   for(G4int i=0; i<nmat; ++i) {
     couples[i] = new G4MaterialCutsCouple((*mtable)[i],pcuts);  
   }
 
   splineFlag = G4EmParameters::Instance()->Spline();
 
   dedxElectron     = PrepareTable();
   dedxPositron     = PrepareTable();
   dedxMuon         = PrepareTable();
   dedxProton       = PrepareTable();
   rangeElectron    = PrepareTable();
   rangePositron    = PrepareTable();
   rangeMuon        = PrepareTable();
   rangeProton      = PrepareTable();
   invRangeElectron = PrepareTable();
   invRangePositron = PrepareTable();
   invRangeMuon     = PrepareTable();
   invRangeProton   = PrepareTable();
   mscElectron      = PrepareTable();
 
   G4LossTableBuilder builder; 
 
   if(verbose>1) {
     G4cout << "### G4TablesForExtrapolator Builds electron tables" 
        << G4endl;
   }
   ComputeElectronDEDX(electron, dedxElectron);
   builder.BuildRangeTable(dedxElectron,rangeElectron);  
   builder.BuildInverseRangeTable(rangeElectron, invRangeElectron);  
 
   if(verbose>1) {
     G4cout << "### G4TablesForExtrapolator Builds positron tables" 
        << G4endl;
   }
   ComputeElectronDEDX(positron, dedxPositron);
   builder.BuildRangeTable(dedxPositron, rangePositron);  
   builder.BuildInverseRangeTable(rangePositron, invRangePositron);  
 
   if(verbose>1) {
     G4cout << "### G4TablesForExtrapolator Builds muon tables" << G4endl;
   }
   ComputeMuonDEDX(muonPlus, dedxMuon);
   builder.BuildRangeTable(dedxMuon, rangeMuon);  
   builder.BuildInverseRangeTable(rangeMuon, invRangeMuon);  
   /*
   G4cout << "DEDX MUON" << G4endl
   G4cout << *dedxMuon << G4endl;
   G4cout << "RANGE MUON" << G4endl
   G4cout << *rangeMuon << G4endl;
   G4cout << "INVRANGE MUON" << G4endl
   G4cout << *invRangeMuon << G4endl;
   */
   if(verbose>1) {
     G4cout << "### G4TablesForExtrapolator Builds proton tables" 
        << G4endl;
   }
   ComputeProtonDEDX(proton, dedxProton);
   builder.BuildRangeTable(dedxProton, rangeProton);  
   builder.BuildInverseRangeTable(rangeProton, invRangeProton);  
 
   ComputeTrasportXS(electron, mscElectron);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

private

◆ PrepareTable()

G4PhysicsTable * G4TablesForExtrapolator::PrepareTable ( )

private

Definition at line 256 of file G4TablesForExtrapolator.cc.

 {
   G4PhysicsTable* table = new G4PhysicsTable();
 
   for(G4int i=0; i<nmat; ++i) {  
 
     G4PhysicsVector* v = new G4PhysicsLogVector(emin, emax, nbins);
     v->SetSpline(splineFlag);
     table->push_back(v);
   }
   return table;
 }