#include <G4EmTableUtil.hh>

Static Public Member Functions
static const G4DataVector *	PrepareEmProcess (G4VEmProcess proc, const G4ParticleDefinition part, const G4ParticleDefinition secPart, G4EmModelManager modelManager, const G4double &maxKinEnergy, G4int &secID, G4int &tripletID, G4int &mainSec, const G4int &verb, const G4bool &master)

static void	BuildEmProcess (G4VEmProcess proc, const G4VEmProcess masterProc, const G4ParticleDefinition firstPart, const G4ParticleDefinition part, const G4int nModels, const G4int verb, const G4bool master, const G4bool isLocked, const G4bool toBuild, G4bool &baseMat)

static void	BuildLambdaTable (G4VEmProcess proc, const G4ParticleDefinition part, G4EmModelManager modelManager, G4LossTableBuilder bld, G4PhysicsTable theLambdaTable, G4PhysicsTable theLambdaTablePrim, const G4double minKinEnergy, const G4double minKinEnergyPrim, const G4double maxKinEnergy, const G4double scale, const G4int verbose, const G4bool startFromNull, const G4bool splineFlag)

static void	BuildLambdaTable (G4VEnergyLossProcess proc, const G4ParticleDefinition part, G4EmModelManager modelManager, G4LossTableBuilder bld, G4PhysicsTable theLambdaTable, const G4DataVector theCuts, const G4double minKinEnergy, const G4double maxKinEnergy, const G4double scale, const G4int verbose, const G4bool splineFlag)

static const G4ParticleDefinition *	CheckIon (G4VEnergyLossProcess proc, const G4ParticleDefinition part, const G4ParticleDefinition *particle, const G4int verboseLevel, G4bool &isIon)

static void	UpdateModels (G4VEnergyLossProcess proc, G4EmModelManager modelManager, const G4double maxKinEnergy, const G4int nModels, G4int &secID, G4int &biasID, G4int &mainSecondaries, const G4bool baseMat, const G4bool isMaster, const G4bool useAGen)

static void	BuildLocalElossProcess (G4VEnergyLossProcess proc, const G4VEnergyLossProcess masterProc, const G4ParticleDefinition *part, const G4int nModels)

static void	BuildDEDXTable (G4VEnergyLossProcess proc, const G4ParticleDefinition part, G4EmModelManager modelManager, G4LossTableBuilder bld, G4PhysicsTable *table, const G4double minKinEnergy, const G4double maxKinEnergy, const G4int nbins, const G4int verbose, const G4EmTableType tType, const G4bool splineFlag)

static void	PrepareMscProcess (G4VMultipleScattering proc, const G4ParticleDefinition &part, G4EmModelManager modelManager, G4MscStepLimitType &stepLimit, G4double &facrange, G4bool &latDisplacement, G4bool &master, G4bool &isIon, G4bool &baseMat)

static void	BuildMscProcess (G4VMultipleScattering proc, const G4VMultipleScattering masterProc, const G4ParticleDefinition &part, const G4ParticleDefinition *firstPart, G4int nModels, G4bool master)

static G4bool	StoreMscTable (G4VMultipleScattering proc, const G4ParticleDefinition part, const G4String &directory, const G4int nModels, const G4int verb, const G4bool ascii)

static G4bool	StoreTable (G4VProcess , const G4ParticleDefinition , G4PhysicsTable *, const G4String &dir, const G4String &tname, G4int verb, G4bool ascii)

static G4bool	RetrieveTable (G4VProcess ptr, const G4ParticleDefinition part, G4PhysicsTable *aTable, const G4String &dir, const G4String &tname, const G4int verb, const G4bool ascii, const G4bool spline)

Detailed Description

Definition at line 48 of file G4EmTableUtil.hh.

Member Function Documentation

◆ BuildDEDXTable()

void G4EmTableUtil::BuildDEDXTable	(	G4VEnergyLossProcess *	proc,
		const G4ParticleDefinition *	part,
		G4EmModelManager *	modelManager,
		G4LossTableBuilder *	bld,
		G4PhysicsTable *	table,
		const G4double	minKinEnergy,
		const G4double	maxKinEnergy,
		const G4int	nbins,
		const G4int	verbose,
		const G4EmTableType	tType,
		const G4bool	splineFlag )

static

Definition at line 444 of file G4EmTableUtil.cc.

{
  // Access to materials
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  std::size_t numOfCouples = theCoupleTable->GetTableSize();
 
  if(1 < verbose) {
    G4cout << numOfCouples << " couples" << " minKinEnergy(MeV)= " << emin
           << " maxKinEnergy(MeV)= " << emax << " nbins= " << nbins << G4endl;
  }
  G4PhysicsLogVector* aVector = nullptr;
  G4PhysicsLogVector* bVector = nullptr;
 
  for(std::size_t i=0; i<numOfCouples; ++i) {
 
    if(1 < verbose) {
      G4cout << "G4EmTableUtil::BuildDEDXVector idx= " << i 
             << "  flagTable=" << table->GetFlag(i) 
             << " flagBuilder=" << bld->GetFlag(i) << G4endl;
    }
    if(bld->GetFlag(i)) {
 
      // create physics vector and fill it
      const G4MaterialCutsCouple* couple = 
        theCoupleTable->GetMaterialCutsCouple((G4int)i);
      delete (*table)[i];
      if(nullptr != bVector) {
        aVector = new G4PhysicsLogVector(*bVector);
      } else {
        bVector = new G4PhysicsLogVector(emin, emax, nbins, spline);
        aVector = bVector;
      }
 
      modelManager->FillDEDXVector(aVector, couple, tType);
      if(spline) { aVector->FillSecondDerivatives(); }
 
      // Insert vector for this material into the table
      G4PhysicsTableHelper::SetPhysicsVector(table, i, aVector);
    }
  }
 
  if(1 < verbose) {
    G4cout << "G4EmTableUtil::BuildDEDXTable(): table is built for "
           << part->GetParticleName()
           << " and process " << proc->GetProcessName()
           << G4endl;
    if(2 < verbose) G4cout << (*table) << G4endl;
  }
}

Referenced by G4VEnergyLossProcess::BuildDEDXTable().

◆ BuildEmProcess()

void G4EmTableUtil::BuildEmProcess	(	G4VEmProcess *	proc,
		const G4VEmProcess *	masterProc,
		const G4ParticleDefinition *	firstPart,
		const G4ParticleDefinition *	part,
		const G4int	nModels,
		const G4int	verb,
		const G4bool	master,
		const G4bool	isLocked,
		const G4bool	toBuild,
		G4bool &	baseMat )

static

Definition at line 111 of file G4EmTableUtil.cc.

{
  G4String num = part->GetParticleName();
  if(1 < verb) {
    G4cout << "### G4EmTableUtil::BuildPhysicsTable() for "
           << proc->GetProcessName() << " and particle " << num
           << " buildLambdaTable=" << toBuild << " master= " << master 
           << G4endl;
  }
 
  if(firstPart == part) { 
 
    // worker initialisation
    if(!master) { 
      proc->SetLambdaTable(masterProc->LambdaTable());
      proc->SetLambdaTablePrim(masterProc->LambdaTablePrim());
      proc->SetCrossSectionType(masterProc->CrossSectionType());
      proc->SetEnergyOfCrossSectionMax(masterProc->EnergyOfCrossSectionMax());
 
      // local initialisation of models
      baseMat = masterProc->UseBaseMaterial();
      G4bool printing = true;
      for(G4int i=0; i<nModels; ++i) {
        G4VEmModel* mod = proc->GetModelByIndex(i, printing);
        G4VEmModel* mod0= masterProc->GetModelByIndex(i, printing);
        mod->SetUseBaseMaterials(baseMat);
        mod->InitialiseLocal(part, mod0);
      }
      // master thread
    } else {
      if(toBuild) { proc->BuildLambdaTable(); }
      auto fXSType = proc->CrossSectionType();
      auto v = proc->EnergyOfCrossSectionMax();
      delete v;
      v = nullptr;
      if(fXSType == fEmOnePeak) {
        auto table = proc->LambdaTable();
        if(nullptr == table) {
      v = G4EmUtility::FindCrossSectionMax(proc, part);
    } else {
      v = G4EmUtility::FindCrossSectionMax(table);
    }
        if(nullptr == v) { proc->SetCrossSectionType(fEmIncreasing); }
      }
      proc->SetEnergyOfCrossSectionMax(v);
    }
  }
  // protection against double printout
  if(isLocked) { return; }
 
  // explicitly defined printout by particle name
  if(1 < verb || (0 < verb && (num == "gamma" || num == "e-" || 
                   num == "e+"    || num == "mu+" || 
                   num == "mu-"   || num == "proton"|| 
                   num == "pi+"   || num == "pi-" || 
                   num == "kaon+" || num == "kaon-" || 
                   num == "alpha" || num == "anti_proton" || 
                   num == "GenericIon" ||
                   num == "alpha+" || num == "helium" ||
                   num == "hydrogen"))) { 
    proc->StreamInfo(G4cout, *part);
  }
 
  if(1 < verb) {
    G4cout << "### G4EmTableUtil::BuildPhysicsTable() done for "
           << proc->GetProcessName() << " and particle " << num
           << " baseMat=" << baseMat << G4endl;
  }
}

Referenced by G4VEmProcess::BuildPhysicsTable().

◆ BuildLambdaTable() [1/2]

void G4EmTableUtil::BuildLambdaTable	(	G4VEmProcess *	proc,
		const G4ParticleDefinition *	part,
		G4EmModelManager *	modelManager,
		G4LossTableBuilder *	bld,
		G4PhysicsTable *	theLambdaTable,
		G4PhysicsTable *	theLambdaTablePrim,
		const G4double	minKinEnergy,
		const G4double	minKinEnergyPrim,
		const G4double	maxKinEnergy,
		const G4double	scale,
		const G4int	verbose,
		const G4bool	startFromNull,
		const G4bool	splineFlag )

static

Definition at line 189 of file G4EmTableUtil.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4EmTableUtil::BuildLambdaTable() for process "
           << proc->GetProcessName() << " and particle "
           << part->GetParticleName() << G4endl;
  }
 
  // Access to materials
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  std::size_t numOfCouples = theCoupleTable->GetTableSize();
 
  G4PhysicsLogVector* aVector = nullptr;
  G4PhysicsLogVector* aVectorPrim = nullptr;
  G4PhysicsLogVector* bVectorPrim = nullptr;
 
  G4double emax1 = std::min(maxKinEnergy, minKinEnergyPrim);
    
  for(std::size_t i=0; i<numOfCouples; ++i) {
 
    if (bld->GetFlag(i)) {
      // create physics vector and fill it
      const G4MaterialCutsCouple* couple = 
        theCoupleTable->GetMaterialCutsCouple((G4int)i);
 
      // build main table
      if(nullptr != theLambdaTable) {
        delete (*theLambdaTable)[i];
 
        // if start from zero then change the scale
        G4double emin = minKinEnergy;
        G4bool startNull = false;
        if(startFromNull) {
          G4double e = proc->MinPrimaryEnergy(part, couple->GetMaterial());
          if(e >= emin) {
            emin = e;
            startNull = true;
          }
        }
        G4double emax = emax1;
        if(emax <= emin) { emax = 2*emin; }
        G4int bin = G4lrint(scale*G4Log(emax/emin));
        bin = std::max(bin, 5);
        aVector = new G4PhysicsLogVector(emin, emax, bin, splineFlag);
        modelManager->FillLambdaVector(aVector, couple, startNull);
        if(splineFlag) { aVector->FillSecondDerivatives(); }
        G4PhysicsTableHelper::SetPhysicsVector(theLambdaTable, i, aVector);
      }
      // build high energy table
      if(nullptr != theLambdaTablePrim) {
        delete (*theLambdaTablePrim)[i];
 
        // start not from zero and always use spline
        if(nullptr == bVectorPrim) {
          G4int bin = G4lrint(scale*G4Log(maxKinEnergy/minKinEnergyPrim));
          bin = std::max(bin, 5);
          aVectorPrim = 
            new G4PhysicsLogVector(minKinEnergyPrim, maxKinEnergy, bin, true);
          bVectorPrim = aVectorPrim;
        } else {
          aVectorPrim = new G4PhysicsLogVector(*bVectorPrim);
        }
        modelManager->FillLambdaVector(aVectorPrim, couple, false, 
                                       fIsCrossSectionPrim);
        aVectorPrim->FillSecondDerivatives();
        G4PhysicsTableHelper::SetPhysicsVector(theLambdaTablePrim, i, 
                                               aVectorPrim);
      }
    }
  }
 
  if(1 < verboseLevel) {
    G4cout << "Lambda table is built for " << part->GetParticleName() << G4endl;
  }
}

Referenced by G4VEmProcess::BuildLambdaTable(), and G4VEnergyLossProcess::BuildLambdaTable().

◆ BuildLambdaTable() [2/2]

void G4EmTableUtil::BuildLambdaTable	(	G4VEnergyLossProcess *	proc,
		const G4ParticleDefinition *	part,
		G4EmModelManager *	modelManager,
		G4LossTableBuilder *	bld,
		G4PhysicsTable *	theLambdaTable,
		const G4DataVector *	theCuts,
		const G4double	minKinEnergy,
		const G4double	maxKinEnergy,
		const G4double	scale,
		const G4int	verbose,
		const G4bool	splineFlag )

static

Definition at line 280 of file G4EmTableUtil.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4EmTableUtil::BuildLambdaTable() for process "
           << proc->GetProcessName() << " and particle "
           << part->GetParticleName() << G4endl;
  }
 
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  std::size_t numOfCouples = theCoupleTable->GetTableSize();
 
  G4PhysicsLogVector* aVector = nullptr;
  for(std::size_t i=0; i<numOfCouples; ++i) {
    if (bld->GetFlag(i)) {
      // create physics vector and fill it
      const G4MaterialCutsCouple* couple = 
        theCoupleTable->GetMaterialCutsCouple((G4int)i);
 
      delete (*theLambdaTable)[i];
      G4bool startNull = true;
      G4double emin = 
        proc->MinPrimaryEnergy(part, couple->GetMaterial(), (*theCuts)[i]);
      if(minKinEnergy > emin) { 
        emin = minKinEnergy; 
        startNull = false;
      }
 
      G4double emax = maxKinEnergy;
      if(emax <= emin) { emax = 2*emin; }
      G4int bin = G4lrint(scale*G4Log(emax/emin));
      bin = std::max(bin, 5);
      aVector = new G4PhysicsLogVector(emin, emax, bin, splineFlag);
      modelManager->FillLambdaVector(aVector, couple, startNull, fRestricted);
      if(splineFlag) { aVector->FillSecondDerivatives(); }
      G4PhysicsTableHelper::SetPhysicsVector(theLambdaTable, i, aVector);
    }
  }
 
  if(1 < verboseLevel) {
    G4cout << "Lambda table is built for " << part->GetParticleName() << G4endl;
  }
}

◆ BuildLocalElossProcess()

void G4EmTableUtil::BuildLocalElossProcess	(	G4VEnergyLossProcess *	proc,
		const G4VEnergyLossProcess *	masterProc,
		const G4ParticleDefinition *	part,
		const G4int	nModels )

static

Definition at line 413 of file G4EmTableUtil.cc.

{
  // copy table pointers from master thread
  proc->SetDEDXTable(masterProc->DEDXTable(),fRestricted);
  proc->SetDEDXTable(masterProc->DEDXunRestrictedTable(),fTotal);
  proc->SetDEDXTable(masterProc->IonisationTable(),fIsIonisation);
  proc->SetRangeTableForLoss(masterProc->RangeTableForLoss());
  proc->SetCSDARangeTable(masterProc->CSDARangeTable());
  proc->SetInverseRangeTable(masterProc->InverseRangeTable());
  proc->SetLambdaTable(masterProc->LambdaTable());
  proc->SetCrossSectionType(masterProc->CrossSectionType());
  proc->SetEnergyOfCrossSectionMax(masterProc->EnergyOfCrossSectionMax());
  proc->SetTwoPeaksXS(masterProc->TwoPeaksXS());
  proc->SetIonisation(masterProc->IsIonisationProcess());
  G4bool baseMat = masterProc->UseBaseMaterial();
 
  // local initialisation of models
  G4bool printing = true;
  for(G4int i=0; i<nModels; ++i) {
    G4VEmModel* mod = proc->GetModelByIndex(i, printing);
    G4VEmModel* mod0= masterProc->GetModelByIndex(i, printing);
    mod->SetUseBaseMaterials(baseMat);
    mod->InitialiseLocal(part, mod0);
  }
}

Referenced by G4VEnergyLossProcess::BuildPhysicsTable().

◆ BuildMscProcess()

void G4EmTableUtil::BuildMscProcess	(	G4VMultipleScattering *	proc,
		const G4VMultipleScattering *	masterProc,
		const G4ParticleDefinition &	part,
		const G4ParticleDefinition *	firstPart,
		G4int	nModels,
		G4bool	master )

static

Definition at line 560 of file G4EmTableUtil.cc.

{
  auto param = G4EmParameters::Instance();
  G4int verb = param->Verbose(); 
 
  if(!master && firstPart == &part) {
    // initialisation of models
    G4bool baseMat = masterProc->UseBaseMaterial();
    for(G4int i=0; i<nModels; ++i) {
      G4VMscModel* msc = proc->GetModelByIndex(i);
      G4VMscModel* msc0 = masterProc->GetModelByIndex(i);
      msc->SetUseBaseMaterials(baseMat);
      msc->SetCrossSectionTable(msc0->GetCrossSectionTable(), false);
      msc->InitialiseLocal(&part, msc0);
    }
  }
  if(!param->IsPrintLocked()) {
    const G4String& num = part.GetParticleName();
 
    // explicitly defined printout by particle name
    if(1 < verb || (0 < verb && (num == "e-" || 
                 num == "e+"    || num == "mu+" || 
                 num == "mu-"   || num == "proton"|| 
                 num == "pi+"   || num == "pi-" || 
                 num == "kaon+" || num == "kaon-" || 
                 num == "alpha" || num == "anti_proton" || 
                 num == "GenericIon" || num == "alpha+" || 
                 num == "alpha" ))) { 
      proc->StreamInfo(G4cout, part);
    }
  }
  if(1 < verb) {
    G4cout << "### G4EmTableUtil::BuildPhysicsTable() done for "
       << proc->GetProcessName()
       << " and particle " << part.GetParticleName() << G4endl;
  }
}

Referenced by G4VMultipleScattering::BuildPhysicsTable().

◆ CheckIon()

const G4ParticleDefinition * G4EmTableUtil::CheckIon	(	G4VEnergyLossProcess *	proc,
		const G4ParticleDefinition *	part,
		const G4ParticleDefinition *	particle,
		const G4int	verboseLevel,
		G4bool &	isIon )

static

Definition at line 337 of file G4EmTableUtil.cc.

{
  if(1 < verb) {
    G4cout << "G4EmTableUtil::CheckIon for "
           << proc->GetProcessName() << " for " << part->GetParticleName() 
           << " should be called from G4VEnergyLossProcess::PreparePhysicsTable" 
           << G4endl;
  }
  const G4ParticleDefinition* particle = partLocal;
 
  // Are particle defined?
  if(nullptr == particle) { particle = part; }
  if(part->GetParticleType() == "nucleus") {
    G4String pname = part->GetParticleName();
    if(pname != "deuteron" && pname != "triton" &&
       pname != "alpha+"   && pname != "alpha") {
 
      const G4ParticleDefinition* theGIon = G4GenericIon::GenericIon();
      isIon = true; 
 
      // this is a loop to compare pointers of G4GenericIon processes in order
      // to confirm that for given particle the G4GenericIon physics is used 
      if(particle != theGIon) {
        G4ProcessManager* pm = theGIon->GetProcessManager();
        G4ProcessVector* v = pm->GetAlongStepProcessVector();
        G4int n = (G4int)v->size();
        for(G4int j=0; j<n; ++j) {
          if((*v)[j] == proc) {
            particle = theGIon;
            break;
          } 
        }
      }
    }
  }
  return particle;
}

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

◆ PrepareEmProcess()

const G4DataVector * G4EmTableUtil::PrepareEmProcess	(	G4VEmProcess *	proc,
		const G4ParticleDefinition *	part,
		const G4ParticleDefinition *	secPart,
		G4EmModelManager *	modelManager,
		const G4double &	maxKinEnergy,
		G4int &	secID,
		G4int &	tripletID,
		G4int &	mainSec,
		const G4int &	verb,
		const G4bool &	master )

static

Definition at line 51 of file G4EmTableUtil.cc.

{
  G4EmParameters* param = G4EmParameters::Instance();
 
  // initialisation of models
  G4double plimit = param->MscThetaLimit();
  G4int nModels = modelManager->NumberOfModels();
  for(G4int i=0; i<nModels; ++i) {
    G4VEmModel* mod = modelManager->GetModel(i);
    if(nullptr == mod) { continue; }
    mod->SetPolarAngleLimit(plimit);
    mod->SetMasterThread(master);
    if(mod->HighEnergyLimit() > maxKinEnergy) {
      mod->SetHighEnergyLimit(maxKinEnergy);
    }
    proc->SetEmModel(mod);
  }
 
  // defined ID of secondary particles and verbosity
  G4int stype = proc->GetProcessSubType();
  if(stype == fAnnihilation) {
    secID = _Annihilation;
    tripletID = _TripletGamma;
  } else if(stype == fGammaConversion) {
    secID = _PairProduction;
    mainSec = 2;
  } else if(stype == fPhotoElectricEffect) {
    secID = _PhotoElectron;
  } else if(stype == fComptonScattering) {
    secID = _ComptonElectron;
  } else if(stype >= fLowEnergyElastic) {
    secID = fDNAUnknownModel;
  }
  if(master) { 
    proc->SetVerboseLevel(param->Verbose());
  } else {  
    proc->SetVerboseLevel(param->WorkerVerbose()); 
  }
 
  // model initialisation
  const G4DataVector* cuts = modelManager->Initialise(part, secPart, verb);
 
  if(1 < verb) {
    G4cout << "### G4EmTableUtil::PreparePhysicsTable() done for " 
           << proc->GetProcessName()
           << " and particle " << part->GetParticleName()
           << G4endl;
  }
  return cuts;
}

Referenced by G4VEmProcess::PreparePhysicsTable().

◆ PrepareMscProcess()

void G4EmTableUtil::PrepareMscProcess	(	G4VMultipleScattering *	proc,
		const G4ParticleDefinition &	part,
		G4EmModelManager *	modelManager,
		G4MscStepLimitType &	stepLimit,
		G4double &	facrange,
		G4bool &	latDisplacement,
		G4bool &	master,
		G4bool &	isIon,
		G4bool &	baseMat )

static

Definition at line 507 of file G4EmTableUtil.cc.

{
  auto param = G4EmParameters::Instance();
  G4int verb = (master) ? param->Verbose() : param->WorkerVerbose(); 
  proc->SetVerboseLevel(verb);
 
  if(part.GetPDGMass() > CLHEP::GeV ||
     part.GetParticleName() == "GenericIon") { isIon = true; }
 
  if(1 < verb) {
    G4cout << "### G4EmTableUtil::PrepearPhysicsTable() for "
           << proc->GetProcessName()
           << " and particle " << part.GetParticleName()
           << " isIon: " << isIon << " isMaster: " << master
       << G4endl;
  }
 
  // initialise process
  proc->InitialiseProcess(&part);
 
  // heavy particles 
  if(part.GetPDGMass() > CLHEP::MeV) {
    stepLimit = param->MscMuHadStepLimitType(); 
    facrange = param->MscMuHadRangeFactor(); 
    latDisplacement = param->MuHadLateralDisplacement();
  } else {
    stepLimit = param->MscStepLimitType(); 
    facrange = param->MscRangeFactor(); 
    latDisplacement = param->LateralDisplacement();
  }
 
  // initialisation of models
  auto numberOfModels = modelManager->NumberOfModels();
  for(G4int i=0; i<numberOfModels; ++i) {
    G4VMscModel* msc = proc->GetModelByIndex(i);
    msc->SetIonisation(nullptr, &part);
    msc->SetMasterThread(master);
    msc->SetPolarAngleLimit(param->MscThetaLimit());
    G4double emax = std::min(msc->HighEnergyLimit(),param->MaxKinEnergy());
    msc->SetHighEnergyLimit(emax);
    msc->SetUseBaseMaterials(baseMat);
  }
  modelManager->Initialise(&part, nullptr, verb);
}

Referenced by G4VMultipleScattering::PreparePhysicsTable().

◆ RetrieveTable()

G4bool G4EmTableUtil::RetrieveTable	(	G4VProcess *	ptr,
		const G4ParticleDefinition *	part,
		G4PhysicsTable *	aTable,
		const G4String &	dir,
		const G4String &	tname,
		const G4int	verb,
		const G4bool	ascii,
		const G4bool	spline )

static

Definition at line 665 of file G4EmTableUtil.cc.

{
  G4bool res = true;
  if (nullptr == aTable) { return res; }
  if (0 < verb) {
    G4cout << tname << " table for " << part->GetParticleName() 
           << " will be retrieved " << G4endl;
  }
  const G4String& name = 
    ptr->GetPhysicsTableFileName(part, dir, tname, ascii);
  if(G4PhysicsTableHelper::RetrievePhysicsTable(aTable, name, ascii, spline)) {
    if(spline) {
      for(auto & v : *aTable) {
    if(nullptr != v) { v->FillSecondDerivatives(); }
      }
    }
    if (0 < verb) {
      G4cout << tname << " table for " << part->GetParticleName() 
         << " is Retrieved from <" << name << ">"
         << G4endl;
    }
  } else {
    res = false;
    G4cout << "G4EmTableUtil::RetrieveTable fail to retrieve: " << tname 
           << " from " << name << " for " << part->GetParticleName() << G4endl;
  }
  return res;
}

Referenced by G4VEmProcess::RetrievePhysicsTable(), and G4VEnergyLossProcess::RetrievePhysicsTable().

◆ StoreMscTable()

G4bool G4EmTableUtil::StoreMscTable	(	G4VMultipleScattering *	proc,
		const G4ParticleDefinition *	part,
		const G4String &	directory,
		const G4int	nModels,
		const G4int	verb,
		const G4bool	ascii )

static

Definition at line 604 of file G4EmTableUtil.cc.

{
  G4bool ok = true;
  for(G4int i=0; i<nModels; ++i) {
    G4VMscModel* msc = proc->GetModelByIndex(i);
    G4PhysicsTable* table = msc->GetCrossSectionTable();
    if (nullptr != table) {
      G4String ss = G4UIcommand::ConvertToString(i);
      G4String name = 
        proc->GetPhysicsTableFileName(part, dir, "LambdaMod"+ss, ascii);
      G4bool yes = table->StorePhysicsTable(name,ascii);
 
      if ( yes ) {
        if ( verb > 0 ) {
          G4cout << "Physics table are stored for " 
                 << part->GetParticleName()
                 << " and process " << proc->GetProcessName()
                 << " with a name <" << name << "> " << G4endl;
        }
      } else {
        G4cout << "Fail to store Physics Table for " 
               << part->GetParticleName()
               << " and process " << proc->GetProcessName()
               << " in the directory <" << dir
               << "> " << G4endl;
    ok = false;
      }
    }
  }
  return ok;
}

Referenced by G4VMultipleScattering::StorePhysicsTable().

◆ StoreTable()

G4bool G4EmTableUtil::StoreTable	(	G4VProcess *	ptr,
		const G4ParticleDefinition *	part,
		G4PhysicsTable *	aTable,
		const G4String &	dir,
		const G4String &	tname,
		G4int	verb,
		G4bool	ascii )

static

Definition at line 642 of file G4EmTableUtil.cc.

{
  G4bool res = true;
  if (nullptr != aTable) {
    const G4String& name = 
      ptr->GetPhysicsTableFileName(part, dir, tname, ascii);
    if ( aTable->StorePhysicsTable(name, ascii) ) {
      if (1 < verb) G4cout << "Stored: " << name << G4endl;
    } else {
      res = false;
      G4cout << "G4EmTableUtil::StoreTable fail to store: " << name << G4endl;
    }
  }
  return res;
}

Referenced by G4VEmProcess::StorePhysicsTable(), and G4VEnergyLossProcess::StorePhysicsTable().

◆ UpdateModels()

void G4EmTableUtil::UpdateModels	(	G4VEnergyLossProcess *	proc,
		G4EmModelManager *	modelManager,
		const G4double	maxKinEnergy,
		const G4int	nModels,
		G4int &	secID,
		G4int &	biasID,
		G4int &	mainSecondaries,
		const G4bool	baseMat,
		const G4bool	isMaster,
		const G4bool	useAGen )

static

Definition at line 380 of file G4EmTableUtil.cc.

{
  // defined ID of secondary particles
  G4int stype = proc->GetProcessSubType();
  if(stype == fBremsstrahlung) {
    secID = _Bremsstrahlung;
    biasID = _SplitBremsstrahlung;
  } else if(stype == fPairProdByCharged) {
    secID = _PairProduction;
    mainSec = 2;
  }
 
  // initialisation of models
  for(G4int i=0; i<nModels; ++i) {
    G4VEmModel* mod = modelManager->GetModel(i);
    mod->SetMasterThread(isMaster);
    mod->SetAngularGeneratorFlag(useAGen);
    if(mod->HighEnergyLimit() > maxKinEnergy) {
      mod->SetHighEnergyLimit(maxKinEnergy);
    }
    mod->SetUseBaseMaterials(baseMat);
  }
}

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

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

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ BuildDEDXTable()

◆ BuildEmProcess()

◆ BuildLambdaTable() [1/2]

◆ BuildLambdaTable() [2/2]

◆ BuildLocalElossProcess()

◆ BuildMscProcess()

◆ CheckIon()

◆ PrepareEmProcess()

◆ PrepareMscProcess()

◆ RetrieveTable()

◆ StoreMscTable()

◆ StoreTable()

◆ UpdateModels()