#include <G4TablesForExtrapolator.hh>

Public Member Functions
	G4TablesForExtrapolator (const G4TablesForExtrapolator &)=delete

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

const G4PhysicsTable *	GetPhysicsTable (ExtTableType type) const

void	Initialisation ()

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

	~G4TablesForExtrapolator ()

Private Member Functions
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)

G4PhysicsTable *	PrepareTable (G4PhysicsTable *)

Private Attributes
G4LossTableBuilder *	builder = nullptr

G4double	charge2 = 0.0

std::vector< const G4MaterialCutsCouple * >	couples

const G4ParticleDefinition *	currentParticle = nullptr

G4DataVector	cuts

G4PhysicsTable *	dedxElectron = nullptr

G4PhysicsTable *	dedxMuon = nullptr

G4PhysicsTable *	dedxPositron = nullptr

G4PhysicsTable *	dedxProton = nullptr

const G4ParticleDefinition *	electron

G4double	emax

G4double	emin

G4PhysicsTable *	invRangeElectron = nullptr

G4PhysicsTable *	invRangeMuon = nullptr

G4PhysicsTable *	invRangePositron = nullptr

G4PhysicsTable *	invRangeProton = nullptr

G4double	mass = 0.0

G4PhysicsTable *	mscElectron = nullptr

const G4ParticleDefinition *	muonMinus

const G4ParticleDefinition *	muonPlus

G4int	nbins

G4int	nmat = 0

G4ProductionCuts *	pcuts = nullptr

const G4ParticleDefinition *	positron

const G4ParticleDefinition *	proton

G4PhysicsTable *	rangeElectron = nullptr

G4PhysicsTable *	rangeMuon = nullptr

G4PhysicsTable *	rangePositron = nullptr

G4PhysicsTable *	rangeProton = nullptr

G4bool	splineFlag = false

G4int	verbose

Detailed Description

Definition at line 74 of file G4TablesForExtrapolator.hh.

Constructor & Destructor Documentation

◆ G4TablesForExtrapolator() [1/2]

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

explicit

Definition at line 74 of file G4TablesForExtrapolator.cc.

  : emin(e1), emax(e2), verbose(verb), nbins(bins)
{
  electron = G4Electron::Electron();
  positron = G4Positron::Positron();
  proton   = G4Proton::Proton();
  muonPlus = G4MuonPlus::MuonPlus();
  muonMinus= G4MuonMinus::MuonMinus();
}

References G4Electron::Electron(), electron, G4MuonMinus::MuonMinus(), muonMinus, G4MuonPlus::MuonPlus(), muonPlus, G4Positron::Positron(), positron, G4Proton::Proton(), and proton.

◆ ~G4TablesForExtrapolator()

G4TablesForExtrapolator::~G4TablesForExtrapolator ( )

Definition at line 87 of file G4TablesForExtrapolator.cc.

{
  if(nullptr != dedxElectron) {
    dedxElectron->clearAndDestroy();
    delete dedxElectron;
  }
  if(nullptr != dedxPositron) {
    dedxPositron->clearAndDestroy();
    delete dedxPositron;
  }
  if(nullptr != dedxProton) {
    dedxProton->clearAndDestroy();
    delete dedxProton;
  }
  if(nullptr != dedxMuon) {
    dedxMuon->clearAndDestroy();
    delete dedxMuon;
  }
  if(nullptr != rangeElectron) {
    rangeElectron->clearAndDestroy();
    delete rangeElectron;
  }
  if(nullptr != rangePositron) {
    rangePositron->clearAndDestroy();
    delete rangePositron;
  }
  if(nullptr != rangeProton) {
    rangeProton->clearAndDestroy();
    delete rangeProton;
  }
  if(nullptr != rangeMuon) {
    rangeMuon->clearAndDestroy();
    delete rangeMuon;
  }
  if(nullptr != invRangeElectron) {
    invRangeElectron->clearAndDestroy();
    delete invRangeElectron;
  }
  if(nullptr != invRangePositron) {
    invRangePositron->clearAndDestroy();
    delete invRangePositron;
  }
  if(nullptr != invRangeProton) {
    invRangeProton->clearAndDestroy();
    delete invRangeProton;
  }
  if(nullptr != invRangeMuon) {
    invRangeMuon->clearAndDestroy();
    delete invRangeMuon;
  }
  if(nullptr != mscElectron) {
    mscElectron->clearAndDestroy();
    delete mscElectron;
  }
  delete pcuts;
  delete builder;
}

References builder, G4PhysicsTable::clearAndDestroy(), dedxElectron, dedxMuon, dedxPositron, dedxProton, invRangeElectron, invRangeMuon, invRangePositron, invRangeProton, mscElectron, pcuts, rangeElectron, rangeMuon, rangePositron, and rangeProton.

◆ G4TablesForExtrapolator() [2/2]

G4TablesForExtrapolator::G4TablesForExtrapolator ( const G4TablesForExtrapolator & )

delete

Member Function Documentation

◆ ComputeElectronDEDX()

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

private

Definition at line 291 of file G4TablesForExtrapolator.cc.

{
  G4MollerBhabhaModel* ioni = new G4MollerBhabhaModel();
  G4eBremsstrahlungRelModel* brem = new G4eBremsstrahlungRelModel();
  ioni->Initialise(part, cuts);
  brem->Initialise(part, cuts);
  ioni->SetUseBaseMaterials(false);
  brem->SetUseBaseMaterials(false);
 
  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;
    }
    G4PhysicsVector* aVector = (*table)[i];
 
    for(G4int j=0; j<=nbins; ++j) {
        
       G4double e = aVector->Energy(j);
       G4double dedx = ioni->ComputeDEDXPerVolume(mat,part,e,e) 
     + brem->ComputeDEDXPerVolume(mat,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;
} 

References charge2, cm, cm2, G4eBremsstrahlungRelModel::ComputeDEDXPerVolume(), G4MollerBhabhaModel::ComputeDEDXPerVolume(), currentParticle, cuts, source.hepunit::electron_mass_c2, G4PhysicsVector::Energy(), G4PhysicsVector::FillSecondDerivatives(), g, G4cout, G4endl, G4Material::GetDensity(), G4Material::GetMaterialTable(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4eBremsstrahlungRelModel::Initialise(), G4MollerBhabhaModel::Initialise(), mass, MeV, nbins, nmat, G4PhysicsVector::PutValue(), G4VEmModel::SetUseBaseMaterials(), splineFlag, and verbose.

Referenced by Initialisation().

◆ ComputeMuonDEDX()

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

private

Definition at line 344 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);
  ioni->SetUseBaseMaterials(false);
  pair->SetUseBaseMaterials(false);
  brem->SetUseBaseMaterials(false);
 
  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;
    }
    G4PhysicsVector* aVector = (*table)[i];
    for(G4int j=0; j<=nbins; ++j) {
        
       G4double e = aVector->Energy(j);
       G4double dedx = ioni->ComputeDEDXPerVolume(mat,part,e,e) +
                   pair->ComputeDEDXPerVolume(mat,part,e,e) +
                   brem->ComputeDEDXPerVolume(mat,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;
}

References charge2, cm, cm2, G4MuBremsstrahlungModel::ComputeDEDXPerVolume(), G4MuPairProductionModel::ComputeDEDXPerVolume(), G4BetheBlochModel::ComputeDEDXPerVolume(), currentParticle, cuts, G4PhysicsVector::Energy(), G4PhysicsVector::FillSecondDerivatives(), g, G4cout, G4endl, G4Material::GetDensity(), G4Material::GetMaterialTable(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4MuBremsstrahlungModel::Initialise(), G4MuPairProductionModel::Initialise(), G4BetheBlochModel::Initialise(), mass, MeV, nbins, nmat, G4PhysicsVector::PutValue(), G4VEmModel::SetUseBaseMaterials(), splineFlag, and verbose.

Referenced by Initialisation().

◆ ComputeProtonDEDX()

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

private

Definition at line 400 of file G4TablesForExtrapolator.cc.

{
  G4BetheBlochModel* ioni = new G4BetheBlochModel();
  ioni->Initialise(part, cuts);
  ioni->SetUseBaseMaterials(false);
 
  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;
    G4PhysicsVector* aVector = (*table)[i];
    for(G4int j=0; j<=nbins; ++j) {
        
       G4double e = aVector->Energy(j);
       G4double dedx = ioni->ComputeDEDXPerVolume(mat,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;
}

References charge2, cm, cm2, G4BetheBlochModel::ComputeDEDXPerVolume(), currentParticle, cuts, G4PhysicsVector::Energy(), G4PhysicsVector::FillSecondDerivatives(), g, G4cout, G4endl, G4Material::GetDensity(), G4Material::GetMaterialTable(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4BetheBlochModel::Initialise(), mass, MeV, nbins, nmat, G4PhysicsVector::PutValue(), G4VEmModel::SetUseBaseMaterials(), splineFlag, and verbose.

Referenced by Initialisation().

◆ ComputeTrasportXS()

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

private

Definition at line 446 of file G4TablesForExtrapolator.cc.

{
  G4WentzelVIModel* msc = new G4WentzelVIModel();
  msc->SetPolarAngleLimit(CLHEP::pi);
  msc->Initialise(part, cuts);
  msc->SetUseBaseMaterials(false);
 
  mass    = part->GetPDGMass();
  charge2 = 1.0;
  currentParticle = part;
 
  const G4MaterialTable* mtable = G4Material::GetMaterialTable();
 
  if(0<verbose) {
    G4cout << "G4TablesForExtrapolator::ComputeTransportXS 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;
}

References charge2, couples, G4VEmModel::CrossSectionPerVolume(), currentParticle, cuts, G4PhysicsVector::Energy(), G4PhysicsVector::FillSecondDerivatives(), G4cout, G4endl, G4Material::GetMaterialTable(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMass(), G4WentzelVIModel::Initialise(), mass, MeV, mm, nbins, nmat, CLHEP::pi, G4PhysicsVector::PutValue(), G4VEmModel::SetCurrentCouple(), G4VEmModel::SetPolarAngleLimit(), G4VEmModel::SetUseBaseMaterials(), splineFlag, and verbose.

Referenced by Initialisation().

◆ GetPhysicsTable()

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

Definition at line 148 of file G4TablesForExtrapolator.cc.

{
  const G4PhysicsTable* table = nullptr;
  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;
}

References dedxElectron, dedxMuon, dedxPositron, dedxProton, fDedxElectron, fDedxMuon, fDedxPositron, fDedxProton, fInvRangeElectron, fInvRangeMuon, fInvRangePositron, fInvRangeProton, fMscElectron, fRangeElectron, fRangeMuon, fRangePositron, fRangeProton, invRangeElectron, invRangeMuon, invRangePositron, invRangeProton, mscElectron, rangeElectron, rangeMuon, rangePositron, and rangeProton.

Referenced by G4EnergyLossForExtrapolator::GetPhysicsTable().

◆ Initialisation()

void G4TablesForExtrapolator::Initialisation ( )

Definition at line 197 of file G4TablesForExtrapolator.cc.

{
  if(verbose>1) {
    G4cout << "### G4TablesForExtrapolator::Initialisation" << G4endl;
  }
  G4int num = G4Material::GetNumberOfMaterials();
  if(nmat == num) { return; }
  nmat = num;
  nmat = G4Material::GetNumberOfMaterials();
  cuts.resize(nmat, DBL_MAX);
  couples.resize(nmat, nullptr);
 
  const G4MaterialTable* mtable = G4Material::GetMaterialTable();
  if(!pcuts) { pcuts = new G4ProductionCuts(); }
 
  for(G4int i=0; i<nmat; ++i) {
    couples[i] = new G4MaterialCutsCouple((*mtable)[i],pcuts);
  }
 
  dedxElectron     = PrepareTable(dedxElectron);
  dedxPositron     = PrepareTable(dedxPositron);
  dedxMuon         = PrepareTable(dedxMuon);
  dedxProton       = PrepareTable(dedxProton);
  rangeElectron    = PrepareTable(rangeElectron);
  rangePositron    = PrepareTable(rangePositron);
  rangeMuon        = PrepareTable(rangeMuon);
  rangeProton      = PrepareTable(rangeProton);
  invRangeElectron = PrepareTable(invRangeElectron);
  invRangePositron = PrepareTable(invRangePositron);
  invRangeMuon     = PrepareTable(invRangeMuon);
  invRangeProton   = PrepareTable(invRangeProton);
  mscElectron      = PrepareTable(mscElectron);
 
  builder = new G4LossTableBuilder(true);
  builder->SetBaseMaterialActive(false);
 
  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);  
  
  if(verbose>2) {
    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);
}

References builder, G4LossTableBuilder::BuildInverseRangeTable(), G4LossTableBuilder::BuildRangeTable(), ComputeElectronDEDX(), ComputeMuonDEDX(), ComputeProtonDEDX(), ComputeTrasportXS(), couples, cuts, DBL_MAX, dedxElectron, dedxMuon, dedxPositron, dedxProton, electron, G4cout, G4endl, G4Material::GetMaterialTable(), G4Material::GetNumberOfMaterials(), invRangeElectron, invRangeMuon, invRangePositron, invRangeProton, mscElectron, muonPlus, nmat, pcuts, positron, PrepareTable(), proton, rangeElectron, rangeMuon, rangePositron, rangeProton, G4LossTableBuilder::SetBaseMaterialActive(), and verbose.

Referenced by G4EnergyLossForExtrapolator::Initialisation().

◆ operator=()

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

delete

◆ PrepareTable()

G4PhysicsTable * G4TablesForExtrapolator::PrepareTable ( G4PhysicsTable * ptr )

private

Definition at line 277 of file G4TablesForExtrapolator.cc.

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