G4LossTableBuilder Class Reference

#include <G4LossTableBuilder.hh>

Public Member Functions
void	BuildDEDXTable (G4PhysicsTable *dedxTable, const std::vector< G4PhysicsTable * > &)
void	BuildInverseRangeTable (const G4PhysicsTable *rangeTable, G4PhysicsTable *invRangeTable)
void	BuildRangeTable (const G4PhysicsTable *dedxTable, G4PhysicsTable *rangeTable)
G4PhysicsTable *	BuildTableForModel (G4PhysicsTable *table, G4VEmModel *model, const G4ParticleDefinition *, G4double emin, G4double emax, G4bool spline)
	G4LossTableBuilder (const G4LossTableBuilder &)=delete
	G4LossTableBuilder (G4bool master=true)
G4bool	GetBaseMaterialFlag ()
const std::vector< G4int > *	GetCoupleIndexes () const
const std::vector< G4double > *	GetDensityFactors () const
G4bool	GetFlag (size_t idx)
void	InitialiseBaseMaterials (const G4PhysicsTable *table=nullptr)
G4LossTableBuilder &	operator= (const G4LossTableBuilder &right)=delete
void	SetBaseMaterialActive (G4bool flag)
void	SetInitialisationFlag (G4bool flag)
void	SetSplineFlag (G4bool flag)
	~G4LossTableBuilder ()

Private Attributes
G4bool	baseMatFlag = false
G4bool	isBaseMatActive = true
G4bool	isInitialized = false
G4bool	isMaster
G4bool	splineFlag = true
G4EmParameters *	theParameters

Static Private Attributes
static std::vector< G4double > *	theDensityFactor = nullptr
static std::vector< G4int > *	theDensityIdx = nullptr
static std::vector< G4bool > *	theFlag = nullptr

Detailed Description

Definition at line 60 of file G4LossTableBuilder.hh.

Constructor & Destructor Documentation

G4LossTableBuilder() [1/2]

G4LossTableBuilder::G4LossTableBuilder

(

G4bool

master = true

)

Definition at line 78 of file G4LossTableBuilder.cc.

                                                    : isMaster(master) 
{
  theParameters = G4EmParameters::Instance();
  if(nullptr == theFlag) {
#ifdef G4MULTITHREADED
    G4MUTEXLOCK(&ltbMutex);
    if(nullptr == theFlag) {
#endif
      if(!isMaster) {
    G4ExceptionDescription ed;
    ed << "Initialisation called from a worker thread ";
    G4Exception("G4LossTableBuilder: ", "em0001",
            JustWarning, ed);
      }
      theDensityFactor = new std::vector<G4double>;
      theDensityIdx = new std::vector<G4int>;
      theFlag = new std::vector<G4bool>;
#ifdef G4MULTITHREADED
    }
    G4MUTEXUNLOCK(&ltbMutex);
#endif
  }
}

References G4Exception(), G4MUTEXLOCK, G4MUTEXUNLOCK, G4EmParameters::Instance(), isMaster, JustWarning, theDensityFactor, theDensityIdx, theFlag, and theParameters.

~G4LossTableBuilder()

G4LossTableBuilder::~G4LossTableBuilder

(

)

Definition at line 104 of file G4LossTableBuilder.cc.

{
  if(isMaster) {
    delete theDensityFactor;
    delete theDensityIdx;
    delete theFlag;
    theDensityFactor = nullptr;
    theDensityIdx = nullptr;
    theFlag = nullptr;
  }
}

References isMaster, theDensityFactor, theDensityIdx, and theFlag.

G4LossTableBuilder() [2/2]

G4LossTableBuilder::G4LossTableBuilder ( const G4LossTableBuilder &  )

delete

Member Function Documentation

BuildDEDXTable()

void G4LossTableBuilder::BuildDEDXTable	(	G4PhysicsTable *	dedxTable,
		const std::vector< G4PhysicsTable * > &	list
	)

Definition at line 149 of file G4LossTableBuilder.cc.

{
  InitialiseBaseMaterials(dedxTable);
  size_t n_processes = list.size();
  if(1 >= n_processes) { return; }
 
  size_t nCouples = dedxTable->size();
  //G4cout << "Nproc= " << n_processes << " nCouples=" << nCouples << " Nv= " 
  //     << dedxTable->size() << G4endl;
  if(0 >= nCouples) { return; }
 
  for (size_t i=0; i<nCouples; ++i) {
    G4PhysicsLogVector* pv0 = static_cast<G4PhysicsLogVector*>((*(list[0]))[i]);
    if(pv0 == nullptr) { continue; } 
    size_t npoints = pv0->GetVectorLength();
    G4PhysicsLogVector* pv = new G4PhysicsLogVector(*pv0);
    for (size_t j=0; j<npoints; ++j) {
      G4double dedx = 0.0;
      for (size_t k=0; k<n_processes; ++k) {
    const G4PhysicsVector* pv1 = (*(list[k]))[i];
    dedx += (*pv1)[j];
      }
      pv->PutValue(j, dedx);
    }
    if(splineFlag) { pv->FillSecondDerivatives(); }
    G4PhysicsTableHelper::SetPhysicsVector(dedxTable, i, pv);
  }
  //G4cout << "### G4LossTableBuilder::BuildDEDXTable " << G4endl; 
  //G4cout << *dedxTable << G4endl;
}

References G4PhysicsVector::FillSecondDerivatives(), G4PhysicsVector::GetVectorLength(), InitialiseBaseMaterials(), G4PhysicsVector::PutValue(), G4PhysicsTableHelper::SetPhysicsVector(), and splineFlag.

Referenced by G4LossTableManager::BuildTables().

BuildInverseRangeTable()

void G4LossTableBuilder::BuildInverseRangeTable	(	const G4PhysicsTable *	rangeTable,
		G4PhysicsTable *	invRangeTable
	)

Definition at line 263 of file G4LossTableBuilder.cc.

{
  std::size_t nCouples = rangeTable->size();
  if(0 >= nCouples) { return; }
 
  for (std::size_t i=0; i<nCouples; ++i) {
    G4PhysicsVector* pv = (*rangeTable)[i];
    if((pv == nullptr) || (isBaseMatActive && !(*theFlag)[i])) { continue; } 
    std::size_t npoints = pv->GetVectorLength();
      
    delete (*invRangeTable)[i];
    G4PhysicsFreeVector* v = new G4PhysicsFreeVector(npoints,splineFlag);
 
    for (std::size_t j=0; j<npoints; ++j) {
      G4double e  = pv->Energy(j);
      G4double r  = (*pv)[j];
      v->PutValues(j,r,e);
    }
    if(splineFlag) { v->FillSecondDerivatives(); }
 
    G4PhysicsTableHelper::SetPhysicsVector(invRangeTable, i, v);
  }
  //G4cout << "### Inverse range table" << G4endl; 
  //G4cout << *invRangeTable << G4endl;
}

References G4PhysicsVector::Energy(), G4PhysicsVector::FillSecondDerivatives(), G4PhysicsVector::GetVectorLength(), isBaseMatActive, G4PhysicsFreeVector::PutValues(), G4PhysicsTableHelper::SetPhysicsVector(), splineFlag, and theFlag.

Referenced by G4LossTableManager::BuildTables(), and G4TablesForExtrapolator::Initialisation().

BuildRangeTable()

void G4LossTableBuilder::BuildRangeTable	(	const G4PhysicsTable *	dedxTable,
		G4PhysicsTable *	rangeTable
	)

Definition at line 183 of file G4LossTableBuilder.cc.

{
  //G4cout << "### G4LossTableBuilder::BuildRangeTable: DEDX table" << G4endl; 
  //G4cout << *const_cast<G4PhysicsTable*>(dedxTable) << G4endl;
  const std::size_t nCouples = dedxTable->size();
  if(0 >= nCouples) { return; }
 
  const std::size_t n = 100;
  const G4double del = 1.0/(G4double)n;
 
  for (std::size_t i=0; i<nCouples; ++i) {
    G4PhysicsLogVector* pv = static_cast<G4PhysicsLogVector*>((*dedxTable)[i]);
    if((pv == nullptr) || (isBaseMatActive && !(*theFlag)[i])) { continue; } 
    std::size_t npoints = pv->GetVectorLength();
    std::size_t bin0    = 0;
    G4double elow  = pv->Energy(0);
    G4double ehigh = pv->Energy(npoints-1);
    G4double dedx1 = (*pv)[0];
 
    //G4cout << "i= " << i << "npoints= " << npoints << " dedx1= " 
    //<< dedx1 << G4endl;
 
    // protection for specific cases dedx=0
    if(dedx1 == 0.0) {
      for (std::size_t k=1; k<npoints; ++k) {
    ++bin0;
    elow  = pv->Energy(k);
    dedx1 = (*pv)[k];
    if(dedx1 > 0.0) { break; }
      }
      npoints -= bin0;
    }
    //G4cout<<"New Range vector" << G4endl;
    //G4cout<<"nbins= "<<npoints-1<<" elow= "<<elow<<" ehigh= "<<ehigh
    //            <<" bin0= " << bin0 <<G4endl;
 
    // initialisation of a new vector
    if(npoints < 3) { npoints = 3; }
 
    delete (*rangeTable)[i];
    G4PhysicsLogVector* v;
    if(0 == bin0) { v = new G4PhysicsLogVector(*pv); }
    else { v = new G4PhysicsLogVector(elow, ehigh, npoints-1, splineFlag); }
 
    // assumed dedx proportional to beta
    G4double energy1 = v->Energy(0);
    G4double range   = 2.*energy1/dedx1;
    //G4cout << "range0= " << range << G4endl;
    v->PutValue(0,range);
 
    for (std::size_t j=1; j<npoints; ++j) {
 
      G4double energy2 = v->Energy(j);
      G4double de      = (energy2 - energy1) * del;
      G4double energy  = energy2 + de*0.5;
      G4double sum = 0.0;
      std::size_t idx = j - 1;
      //G4cout << "j= " << j << " e1= " << energy1 << " e2= " << energy2 
      //       << " n= " << n << G4endl;
      for (std::size_t k=0; k<n; ++k) {
    energy -= de;
    dedx1 = pv->Value(energy, idx);
    if(dedx1 > 0.0) { sum += de/dedx1; }
      }
      range += sum;
      v->PutValue(j,range);
      energy1 = energy2;
    }
    if(splineFlag) { v->FillSecondDerivatives(); }
    G4PhysicsTableHelper::SetPhysicsVector(rangeTable, i, v);
  }
  //G4cout << "### Range table" << G4endl; 
  //G4cout << *rangeTable << G4endl;
}

References G4PhysicsVector::Energy(), G4INCL::KinematicsUtils::energy(), G4PhysicsVector::FillSecondDerivatives(), G4PhysicsVector::GetVectorLength(), isBaseMatActive, CLHEP::detail::n, G4PhysicsVector::PutValue(), G4PhysicsTableHelper::SetPhysicsVector(), splineFlag, and G4PhysicsVector::Value().

Referenced by G4LossTableManager::BuildTables(), and G4TablesForExtrapolator::Initialisation().

BuildTableForModel()

G4PhysicsTable * G4LossTableBuilder::BuildTableForModel	(	G4PhysicsTable *	table,
		G4VEmModel *	model,
		const G4ParticleDefinition *	part,
		G4double	emin,
		G4double	emax,
		G4bool	spline
	)

Definition at line 384 of file G4LossTableBuilder.cc.

{
  // check input
  G4PhysicsTable* table = G4PhysicsTableHelper::PreparePhysicsTable(aTable);
  if(nullptr == table) { return table; }
  if(emin >= emax) { 
    table->clearAndDestroy();
    delete table;
    table = nullptr;
    return table; 
  }
  InitialiseBaseMaterials(table);
  G4int nbins = theParameters->NumberOfBinsPerDecade();
 
  // Access to materials
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  std::size_t numOfCouples = theCoupleTable->GetTableSize();
 
  G4PhysicsLogVector* aVector = nullptr;
 
  for(std::size_t i=0; i<numOfCouples; ++i) {
    if ((*theFlag)[i]) {
 
      // create physics vector and fill it
      auto couple = theCoupleTable->GetMaterialCutsCouple(i);
      delete (*table)[i];
 
      // if start from zero then change the scale
 
      const G4Material* mat = couple->GetMaterial();
 
      G4double tmin = std::max(emin,model->MinPrimaryEnergy(mat,part));
      if(0.0 >= tmin) { tmin = CLHEP::eV; }
      G4int n = nbins;
 
      if(tmin >= emax) {
        aVector = nullptr;
      } else {
        n *= G4lrint(std::log10(emax/tmin));
        n = std::max(n, 3);
        aVector = new G4PhysicsLogVector(tmin, emax, n, spline);
      }
 
      if(nullptr != aVector) {
        //G4cout << part->GetParticleName() << " in " << mat->GetName() 
    //       << " tmin= " << tmin << G4endl;
        for(G4int j=0; j<=n; ++j) {
          aVector->PutValue(j, model->Value(couple, part, 
                                            aVector->Energy(j)));
        }
        if(spline) { aVector->FillSecondDerivatives(); }
      }
      G4PhysicsTableHelper::SetPhysicsVector(table, i, aVector);
    }
  }
  /*
  G4cout << "G4LossTableBuilder::BuildTableForModel done for "
         << part->GetParticleName() << " and "<< model->GetName()
         << "  " << table << G4endl;
  */
  //G4cout << *table << G4endl;
  return table; 
}

References G4PhysicsTable::clearAndDestroy(), emax, G4PhysicsVector::Energy(), CLHEP::eV, G4PhysicsVector::FillSecondDerivatives(), G4lrint(), G4Material::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), InitialiseBaseMaterials(), G4INCL::Math::max(), G4VEmModel::MinPrimaryEnergy(), CLHEP::detail::n, G4EmParameters::NumberOfBinsPerDecade(), G4PhysicsTableHelper::PreparePhysicsTable(), G4PhysicsVector::PutValue(), G4PhysicsTableHelper::SetPhysicsVector(), theFlag, theParameters, and G4VEmModel::Value().

Referenced by G4VMscModel::GetParticleChangeForMSC().

GetBaseMaterialFlag()

G4bool G4LossTableBuilder::GetBaseMaterialFlag

(

)

Definition at line 140 of file G4LossTableBuilder.cc.

{
  if(theFlag->empty()) { InitialiseBaseMaterials(); }
  return baseMatFlag;
}

References baseMatFlag, InitialiseBaseMaterials(), and theFlag.

Referenced by G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VMultipleScattering::PreparePhysicsTable().

GetCoupleIndexes()

const std::vector< G4int > * G4LossTableBuilder::GetCoupleIndexes

(

)

const

Definition at line 118 of file G4LossTableBuilder.cc.

{
  return theDensityIdx;
}

References theDensityIdx.

Referenced by G4VEmModel::G4VEmModel(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), and G4VEnergyLossProcess::SetLambdaTable().

GetDensityFactors()

const std::vector< G4double > * G4LossTableBuilder::GetDensityFactors

(

)

const

Definition at line 125 of file G4LossTableBuilder.cc.

{
  return theDensityFactor;
}

References theDensityFactor.

Referenced by G4VEmModel::G4VEmModel(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), and G4VEnergyLossProcess::SetLambdaTable().

GetFlag()

G4bool G4LossTableBuilder::GetFlag

(

size_t

idx

)

Definition at line 132 of file G4LossTableBuilder.cc.

{
  if(theFlag->empty()) { InitialiseBaseMaterials(); }
  return (idx < theFlag->size()) ? (*theFlag)[idx] : false;
}

References InitialiseBaseMaterials(), and theFlag.

Referenced by G4VEnergyLossProcess::BuildDEDXTable(), G4VEmProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), and G4GammaGeneralProcess::BuildPhysicsTable().

InitialiseBaseMaterials()

void G4LossTableBuilder::InitialiseBaseMaterials

(

const G4PhysicsTable *

table = nullptr

)

Definition at line 293 of file G4LossTableBuilder.cc.

{
  if(!isMaster) { return; }
  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  std::size_t nCouples = theCoupleTable->GetTableSize();
  std::size_t nFlags = theFlag->size();
  /*
  G4cout << "### InitialiseBaseMaterials: nCouples=" << nCouples
     << " nFlags=" << nFlags << " isInit:" << isInitialized
     << " baseMat:" << baseMatFlag << G4endl; 
  */
  // define base material flag
  if(isBaseMatActive && !baseMatFlag) {
    for(std::size_t i=0; i<nCouples; ++i) {
      if(nullptr != theCoupleTable->GetMaterialCutsCouple(i)->GetMaterial()->GetBaseMaterial()) {
    baseMatFlag = true;
        isInitialized = false;
    break;
      }
    }
  }
 
  if(nFlags != nCouples) { isInitialized = false; }
  if(isInitialized) { return; }
 
  // reserve memory
  theFlag->resize(nCouples, true);
  if(nullptr == table) { return; }
 
  if(baseMatFlag) {
    theDensityFactor->resize(nCouples,1.0);
    theDensityIdx->resize(nCouples);
  }
 
  // define default flag and index of used material cut couple
  for(std::size_t i=0; i<nCouples; ++i) {
    (*theFlag)[i] = table->GetFlag(i); 
    if(baseMatFlag) { (*theDensityIdx)[i] = i; }
  }
  isInitialized = true;
  if(baseMatFlag) {
    // use base materials
    for(std::size_t i=0; i<nCouples; ++i) { 
      // base material is needed only for a couple which is not
      // initialised and for which tables will be computed
      auto couple = theCoupleTable->GetMaterialCutsCouple(i);
      auto pcuts = couple->GetProductionCuts();
      auto mat  = couple->GetMaterial();
      auto bmat = mat->GetBaseMaterial();
 
      // base material exists - find it and check if it can be reused
      if(nullptr != bmat) {
    for(std::size_t j=0; j<nCouples; ++j) {
      if(j == i) { continue; }
      auto bcouple = theCoupleTable->GetMaterialCutsCouple(j);
 
      if(bcouple->GetMaterial() == bmat && 
         bcouple->GetProductionCuts() == pcuts) {
 
        // based couple exist in the same region
        (*theDensityFactor)[i] = mat->GetDensity()/bmat->GetDensity();
        (*theDensityIdx)[i] = j;
        (*theFlag)[i] = false;
 
        // ensure that there will no double initialisation
        (*theDensityFactor)[j] = 1.0;
        (*theDensityIdx)[j] = j;
        (*theFlag)[j] = true;
        break;
      } 
    }
      }
    }
  }
  /*
  G4cout << "### G4LossTableBuilder::InitialiseBaseMaterials: flag=" 
     << baseMatFlag << G4endl;
  for(size_t i=0; i<nCouples; ++i) {
    G4cout << "CoupleIdx=" << i << "  Flag= " << (*theFlag)[i] << "  "
           << theCoupleTable->GetMaterialCutsCouple(i)->GetMaterial()->GetName()
       << "  TableFlag= " << table->GetFlag(i)
           << "  " << (*table)[i]
       << G4endl;
  }
  */
}

References baseMatFlag, G4Material::GetBaseMaterial(), G4PhysicsTable::GetFlag(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4MaterialCutsCouple::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), isBaseMatActive, isInitialized, isMaster, theDensityFactor, theDensityIdx, and theFlag.

Referenced by BuildDEDXTable(), BuildTableForModel(), GetBaseMaterialFlag(), GetFlag(), G4VEmProcess::PreparePhysicsTable(), and G4VEnergyLossProcess::PreparePhysicsTable().

operator=()

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

delete

SetBaseMaterialActive()

void G4LossTableBuilder::SetBaseMaterialActive ( G4bool  flag )

inline

Definition at line 137 of file G4LossTableBuilder.hh.

{
  isBaseMatActive = flag;
  if(!flag) {
    baseMatFlag = false;
    isInitialized = false;
  } 
}

References baseMatFlag, isBaseMatActive, and isInitialized.

Referenced by G4TablesForExtrapolator::Initialisation().

SetInitialisationFlag()

void G4LossTableBuilder::SetInitialisationFlag ( G4bool  flag )

inline

Definition at line 132 of file G4LossTableBuilder.hh.

{
  isInitialized = flag;
}

References isInitialized.

Referenced by G4LossTableManager::ResetParameters().

SetSplineFlag()

void G4LossTableBuilder::SetSplineFlag ( G4bool  flag )

inline

Definition at line 127 of file G4LossTableBuilder.hh.

{
  splineFlag = flag;
}

References splineFlag.

Field Documentation

baseMatFlag

G4bool G4LossTableBuilder::baseMatFlag = false

private

Definition at line 115 of file G4LossTableBuilder.hh.

Referenced by GetBaseMaterialFlag(), InitialiseBaseMaterials(), and SetBaseMaterialActive().

isBaseMatActive

G4bool G4LossTableBuilder::isBaseMatActive = true

private

Definition at line 116 of file G4LossTableBuilder.hh.

Referenced by BuildInverseRangeTable(), BuildRangeTable(), InitialiseBaseMaterials(), and SetBaseMaterialActive().

isInitialized

G4bool G4LossTableBuilder::isInitialized = false

private

Definition at line 114 of file G4LossTableBuilder.hh.

Referenced by InitialiseBaseMaterials(), SetBaseMaterialActive(), and SetInitialisationFlag().

isMaster

G4bool G4LossTableBuilder::isMaster

private

Definition at line 117 of file G4LossTableBuilder.hh.

Referenced by G4LossTableBuilder(), InitialiseBaseMaterials(), and ~G4LossTableBuilder().

splineFlag

G4bool G4LossTableBuilder::splineFlag = true

private

Definition at line 113 of file G4LossTableBuilder.hh.

Referenced by BuildDEDXTable(), BuildInverseRangeTable(), BuildRangeTable(), and SetSplineFlag().

theDensityFactor

std::vector< G4double > * G4LossTableBuilder::theDensityFactor = nullptr

staticprivate

Definition at line 119 of file G4LossTableBuilder.hh.

Referenced by G4LossTableBuilder(), GetDensityFactors(), InitialiseBaseMaterials(), and ~G4LossTableBuilder().

theDensityIdx

std::vector< G4int > * G4LossTableBuilder::theDensityIdx = nullptr

staticprivate

Definition at line 120 of file G4LossTableBuilder.hh.

Referenced by G4LossTableBuilder(), GetCoupleIndexes(), InitialiseBaseMaterials(), and ~G4LossTableBuilder().

theFlag

std::vector< G4bool > * G4LossTableBuilder::theFlag = nullptr

staticprivate

Definition at line 121 of file G4LossTableBuilder.hh.

Referenced by BuildInverseRangeTable(), BuildTableForModel(), G4LossTableBuilder(), GetBaseMaterialFlag(), GetFlag(), InitialiseBaseMaterials(), and ~G4LossTableBuilder().

theParameters

G4EmParameters* G4LossTableBuilder::theParameters

private

Definition at line 111 of file G4LossTableBuilder.hh.

Referenced by BuildTableForModel(), and G4LossTableBuilder().

---

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

• source/processes/electromagnetic/utils/include/G4LossTableBuilder.hh
• source/processes/electromagnetic/utils/src/G4LossTableBuilder.cc