G4DNAMultipleIonisationManager Class Reference

#include <G4DNAMultipleIonisationManager.hh>

Public Member Functions
	G4DNAMultipleIonisationManager ()=default
	~G4DNAMultipleIonisationManager ()=default
void	CreateMultipleIonisedWaterMolecule (MultipleIonisedModification mod, G4int *shell_level, const G4Track *incoming_track)
G4bool	CheckShellEnergy (MultipleIonisedModification mod, G4double *shell_energy)
void	LoadAlphaParam (const G4String &filepath, G4double Z, G4double A)
G4double	GetAlphaParam (G4double energy)

Detailed Description

Definition at line 46 of file G4DNAMultipleIonisationManager.hh.

Constructor & Destructor Documentation

G4DNAMultipleIonisationManager()

G4DNAMultipleIonisationManager::G4DNAMultipleIonisationManager ( )

default

~G4DNAMultipleIonisationManager()

G4DNAMultipleIonisationManager::~G4DNAMultipleIonisationManager ( )

default

Member Function Documentation

CheckShellEnergy()

G4bool G4DNAMultipleIonisationManager::CheckShellEnergy	(	MultipleIonisedModification	mod,
		G4double *	shell_energy )

Definition at line 78 of file G4DNAMultipleIonisationManager.cc.

{
  G4int num_shells{0};
  switch (mod) {
    case eDoubleIonisedMolecule:
      num_shells = 2;
      break;
    case eTripleIonisedMolecule:
      num_shells = 3;
      break;
    case eQuadrupleIonisedMolecule:
      num_shells = 4;
      break;
    default: // never happen
      break;
  }
 
  G4bool stop_process{false};
  for (G4int i = 0; i < num_shells; i++) {
    if (shell_energy[i] < 0.0) {
      stop_process = true;
      break;
    }
  }
 
  return stop_process;
}

CreateMultipleIonisedWaterMolecule()

void G4DNAMultipleIonisationManager::CreateMultipleIonisedWaterMolecule	(	MultipleIonisedModification	mod,
		G4int *	shell_level,
		const G4Track *	incoming_track )

Definition at line 42 of file G4DNAMultipleIonisationManager.cc.

{
  if (!G4DNAChemistryManager::IsActivated()) { return; }
 
  G4int num_shells{0};
  switch (mod) {
    case eDoubleIonisedMolecule:
      num_shells = 2;
      break;
    case eTripleIonisedMolecule:
      num_shells = 3;
      break;
    case eQuadrupleIonisedMolecule:
      num_shells = 4;
      break;
    default: // never happen
      return;
  }
 
  auto* H2O = new G4Molecule(G4H2O::Definition());
  for (G4int i = 0; i < num_shells; i++) {
    H2O->IonizeMolecule(4 - shell_level[i]);
  }
 
  constexpr G4double kT0 = 1.0 * picosecond;
  auto* H2O_track = H2O->BuildTrack(kT0, incoming_track->GetPosition());
  H2O_track->SetParentID(incoming_track->GetTrackID());
  H2O_track->SetTrackStatus(fStopButAlive);
  H2O_track->SetKineticEnergy(0.0);
 
  G4VITTrackHolder::Instance()->Push(H2O_track);
}

GetAlphaParam()

G4double G4DNAMultipleIonisationManager::GetAlphaParam

(

G4double

energy

)

Definition at line 137 of file G4DNAMultipleIonisationManager.cc.

{
  auto find_lower_bound = [this](G4double e) {
    auto low = 0;
    auto upp = num_node_ - 1;
    if (e < Eion_[0]) { return low; }
    while (low <= upp) {
      const auto mid = static_cast<int>((low + upp) * 0.5);
      if (e < Eion_[mid]) { upp = mid - 1; }
      else { low = mid + 1; }
      if (upp < 0) { upp = 0; }
    }
    return upp;
  };
 
  auto interp_log_log = [this](G4int bin1, G4double e) {
    if (e < Eion_[0]) { return alpha_[0]; }
    const auto num_bin = num_node_ - 1;
    const auto bin2 = bin1 + 1;
    G4double value{0.0};
    if (bin2 <= num_bin) {
      auto log10_e  = std::log10(e);
      auto log10_e1 = Eion_[bin1];
      auto log10_e2 = Eion_[bin2];
      auto log10_a1 = alpha_[bin1];
      auto log10_a2 = alpha_[bin2];
      if (log10_a1 != 0.0 && log10_a2 != 0.0) {
        log10_e1 = std::log10(log10_e1);
        log10_e2 = std::log10(log10_e2);
        log10_a1 = std::log10(log10_a1);
        log10_a2 = std::log10(log10_a2);
        value = log10_a1 + (log10_a2 - log10_a1)
                  * (log10_e - log10_e1) / (log10_e2 - log10_e1);
        value = std::pow(10.0, value);
      }
    } else {
      value = alpha_[num_bin];
    }
    return value;
  };
 
  const auto bin1 = find_lower_bound(energy);
  return interp_log_log(bin1, energy);
}

LoadAlphaParam()

void G4DNAMultipleIonisationManager::LoadAlphaParam	(	const G4String &	filepath,
		G4double	Z,
		G4double	A )

Definition at line 108 of file G4DNAMultipleIonisationManager.cc.

{
  const char* path = G4FindDataDir("G4LEDATA");
  if (path == nullptr) {
    G4Exception("G4DNAMultipleIonisationManager::LoadAlphaParam","em0006",
                FatalException,"G4LEDATA environment variable not set.");
  }
 
  std::stringstream fullpath;
  fullpath << path << "/" << filepath;
 
  std::fstream fin(fullpath.str());
 
  G4double e, a;
  std::string line = "";
  while (getline(fin, line)) {
    std::stringstream ss;
    ss << line;
    ss >> e >> a;
    Eion_.push_back(e * Z * A * MeV);
    alpha_.push_back(a);
  }
 
  num_node_ = (G4int)Eion_.size();
  fin.close();
}

---

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

• G4DNAMultipleIonisationManager.hh
• G4DNAMultipleIonisationManager.cc