#include <Doxymodules_medical.h>

Inheritance diagram for RadioBio::RBE:

Public Member Functions
	RBE ()

	~RBE ()

void	LoadLEMTable (G4String path)

void	SetCellLine (G4String name)

std::tuple< G4double, G4double >	GetHitAlphaAndBeta (G4double E, G4int Z)

void	AddFromAccumulable (G4VAccumulable *) override

void	Initialize () override

void	Compute () override

void	Reset () override

void	Store () override

void	PrintParameters () override

Public Member Functions inherited from RadioBio::VRadiobiologicalQuantity
	VRadiobiologicalQuantity ()

virtual	~VRadiobiologicalQuantity ()

G4bool	IsCalculationEnabled () const

G4bool	HasBeenCalculated () const

void	SetCalculationEnabled (G4bool enabled)

void	SetVerboseLevel (G4int level)

G4int	GetVerboseLevel () const

void	SetPath (G4String fN)

void	PrintVirtualParameters ()

Private Types
using	vector_type = std::map< G4int, std::vector< G4double > >

Private Member Functions
void	ComputeAlphaAndBeta ()

void	ComputeRBE ()

void	StoreAlphaAndBeta ()

void	StoreRBE ()

void	SetAlphaNumerator (const array_type alpha)

void	SetBetaNumerator (const array_type beta)

void	SetDenominator (const array_type denom)

void	AddAlphaNumerator (const array_type alpha)

void	AddBetaNumerator (const array_type beta)

void	AddDenominator (const array_type denom)

void	GetDose ()

Private Attributes
G4double	fAlphaX = 0.

G4double	fBetaX = 0.

G4double	fDoseCut = 0.

array_type	fAlpha = {}

array_type	fBeta = {}

array_type	fDose = {}

array_type	fAlphaNumerator = {}

array_type	fBetaNumerator = {}

array_type	fDenominator = {}

array_type	fLnS = {}

array_type	fSurvival = {}

array_type	fDoseX = {}

array_type	fRBE = {}

std::map< G4String, vector_type >	fTablesEnergy = {}

std::map< G4String, vector_type >	fTablesAlpha = {}

std::map< G4String, vector_type >	fTablesBeta = {}

std::map< G4String, G4double >	fTablesAlphaX = {}

std::map< G4String, G4double >	fTablesBetaX = {}

std::map< G4String, G4double >	fTablesDoseCut = {}

G4String	fActiveCellLine

vector_type *	fActiveTableEnergy = nullptr

vector_type *	fActiveTableAlpha = nullptr

vector_type *	fActiveTableBeta = nullptr

std::map< G4int, G4double >	fMaxEnergies = {}

std::map< G4int, G4double >	fMinEnergies = {}

G4int	fMinZ = -1

G4int	fMaxZ = -1

Additional Inherited Members
Public Types inherited from RadioBio::VRadiobiologicalQuantity
using	array_type = std::valarray< G4double >

Protected Attributes inherited from RadioBio::VRadiobiologicalQuantity
G4UImessenger *	fMessenger = nullptr

G4int	fVerboseLevel = 1

G4bool	fInitialized = false

G4bool	fSaved = false

G4bool	fCalculated = false

G4String	fPath

G4bool	fCalculationEnabled = false

Detailed Description

Definition at line 141 of file Doxymodules_medical.h.

Member Typedef Documentation

◆ vector_type

using RadioBio::RBE::vector_type = std::map<G4int, std::vector<G4double> >

private

Definition at line 116 of file RBE.hh.

Constructor & Destructor Documentation

◆ RBE()

RadioBio::RBE::RBE ( )

Definition at line 62 of file RBE.cc.

         : VRadiobiologicalQuantity()
{
  fPath = "RadioBio";
 
  // CreateMessenger
  fMessenger = new RBEMessenger(this);
 
  Initialize();
}

◆ ~RBE()

RadioBio::RBE::~RBE ( )

Definition at line 74 of file RBE.cc.

{
  delete fMessenger;
}

Member Function Documentation

◆ LoadLEMTable()

void RadioBio::RBE::LoadLEMTable ( G4String path )

Definition at line 146 of file RBE.cc.

{
  std::ifstream in(path);
  if (!in) {
    std::stringstream ss;
    ss << "Cannot open LEM table input file: " << path;
    G4Exception("RBE::LoadData", "WrongTable", FatalException, ss.str().c_str());
  }
 
  // Start with the first line
  G4String line;
  if (!getline(in, line)) {
    std::stringstream ss;
    ss << "Cannot read header from the LEM table file: " << path;
    G4Exception("RBE::LoadLEMTable", "CannotReadHeader", FatalException, ss.str().c_str());
  }
  std::vector<G4String> header = split(line, ",");
 
  // Find the order of columns
  std::vector<G4String> columns = {"alpha_x", "beta_x", "D_t",  "specific_energy",
                                   "alpha",   "beta",   "cell", "particle"};
  std::map<G4String, int> columnIndices;
  for (auto columnName : columns) {
    auto pos = find(header.begin(), header.end(), columnName);
    if (pos == header.end()) {
      std::stringstream ss;
      ss << "Column " << columnName << " not present in the LEM table file.";
      G4Exception("RBE::LoadLEMTable", "ColumnNotPresent", FatalException, ss.str().c_str());
    }
    else {
      columnIndices[columnName] = distance(header.begin(), pos);
    }
  }
 
  // Continue line by line
  while (getline(in, line)) {
    std::vector<G4String> lineParts = split(line, ",");
    G4String cellLine = lineParts[columnIndices["cell"]];
    // G4int element = elements.at(lineParts[columnIndices["particle"]]);
    G4NistManager* man = G4NistManager::Instance();
    G4int element = man->FindOrBuildElement(lineParts[columnIndices["particle"]])->GetZasInt();
 
    fTablesEnergy[cellLine][element].push_back(
      std::stod(lineParts[columnIndices["specific_energy"]]) * MeV);
    fTablesAlpha[cellLine][element].push_back(stod(lineParts[columnIndices["alpha"]]));
    /* fTablesLet[cellLine][element].push_back(
        stod(lineParts[columnIndices["let"]])
    ); */
    fTablesBeta[cellLine][element].push_back(stod(lineParts[columnIndices["beta"]]));
 
    fTablesAlphaX[cellLine] = stod(lineParts[columnIndices["alpha_x"]]) / gray;
    fTablesBetaX[cellLine] = stod(lineParts[columnIndices["beta_x"]]) / (gray * gray);
    fTablesDoseCut[cellLine] = stod(lineParts[columnIndices["D_t"]]) * gray;
  }
 
  // Sort the tables by energy
  // (https://stackoverflow.com/a/12399290/2692780)
  for (auto aPair : fTablesEnergy) {
    for (auto ePair : aPair.second) {
      std::vector<G4double>& tableEnergy = fTablesEnergy[aPair.first][ePair.first];
      std::vector<G4double>& tableAlpha = fTablesAlpha[aPair.first][ePair.first];
      std::vector<G4double>& tableBeta = fTablesBeta[aPair.first][ePair.first];
 
      std::vector<size_t> idx(tableEnergy.size());
      iota(idx.begin(), idx.end(), 0);
      std::sort(idx.begin(), idx.end(),
           [&tableEnergy](size_t i1, size_t i2) { return tableEnergy[i1] < tableEnergy[i2]; });
 
      std::vector<std::vector<G4double>*> tables = {&tableEnergy, &tableAlpha, &tableBeta};
      for (std::vector<G4double>* table : tables) {
        std::vector<G4double> copy = *table;
        for (size_t i = 0; i < copy.size(); ++i) {
          (*table)[i] = copy[idx[i]];
        }
        // G4cout << (*table)[0];
        // reorder(*table, idx);
        // G4cout << (*table)[0] << G4endl;
      }
    }
  }
 
  if (fVerboseLevel > 0) {
    G4cout << "RBE: read LEM data for the following cell lines and elements [number of points]:"
           << G4endl;
    for (auto aPair : fTablesEnergy) {
      G4cout << "- " << aPair.first << ": ";
      for (auto ePair : aPair.second) {
        G4cout << ePair.first << "[" << ePair.second.size() << "] ";
      }
      G4cout << G4endl;
    }
  }
}

◆ SetCellLine()

void RadioBio::RBE::SetCellLine ( G4String name )

Definition at line 242 of file RBE.cc.

{
  G4cout << "*************************" << G4endl << "*******SetCellLine*******" << G4endl
         << "*************************" << G4endl;
  if (fTablesEnergy.size() == 0) {
    G4Exception("RBE::SetCellLine", "NoCellLine", FatalException,
                "Cannot select cell line, probably LEM table not loaded yet?");
  }
  if (fTablesEnergy.find(name) == fTablesEnergy.end()) {
    std::stringstream str;
    str << "Cell line " << name << " not found in the LEM table.";
    G4Exception("RBE::SetCellLine", "", FatalException, str.str().c_str());
  }
  else {
    fAlphaX = fTablesAlphaX[name];
    fBetaX = fTablesBetaX[name];
    fDoseCut = fTablesDoseCut[name];
 
    fActiveTableEnergy = &fTablesEnergy[name];
    fActiveTableAlpha = &fTablesAlpha[name];
    fActiveTableBeta = &fTablesBeta[name];
 
    fMinZ = 0;
    fMaxZ = 0;
    fMinEnergies.clear();
    fMaxEnergies.clear();
 
    for (auto energyPair : *fActiveTableEnergy) {
      if (!fMinZ || (energyPair.first < fMinZ)) fMinZ = energyPair.first;
      if (energyPair.first > fMaxZ) fMaxZ = energyPair.first;
 
      fMinEnergies[energyPair.first] = energyPair.second[0];
      fMaxEnergies[energyPair.first] = energyPair.second[energyPair.second.size() - 1];
    }
  }
 
  fActiveCellLine = name;
 
  if (fVerboseLevel > 0) {
    G4cout << "RBE: cell line " << name << " selected." << G4endl;
  }
}

◆ GetHitAlphaAndBeta()

std::tuple< G4double, G4double > RadioBio::RBE::GetHitAlphaAndBeta	(	G4double	E,
		G4int	Z
	)

Definition at line 287 of file RBE.cc.

{
  if (!fActiveTableEnergy) {
    G4Exception("RBE::GetHitAlphaAndBeta", "NoCellLine", FatalException,
                "No cell line selected. Please, do it using the /rbe/cellLine command.");
  }
 
  // Check we are in the tables
  if ((Z < fMinZ) || (Z > fMaxZ)) {
    if (fVerboseLevel > 2) {
      std::stringstream str;
      str << "Alpha & beta calculation supported only for ";
      str << fMinZ << " <= Z <= " << fMaxZ << ", but " << Z << " requested.";
      G4Exception("RBE::GetHitAlphaAndBeta", "", JustWarning, str.str().c_str());
    }
    return std::make_tuple<G4double, G4double>(0.0, 0.0);  // out of table!
  }
  if ((E < fMinEnergies[Z]) || (E >= fMaxEnergies[Z])) {
    if (fVerboseLevel > 2) {
      G4cout << "RBE hit: Z=" << Z << ", E=" << E << " => out of LEM table";
      if (fVerboseLevel > 3) {
        G4cout << " (" << fMinEnergies[Z] << " to " << fMaxEnergies[Z] << " MeV)";
      }
      G4cout << G4endl;
    }
    return std::make_tuple<G4double, G4double>(0.0, 0.0);  // out of table!
  }
 
  std::vector<G4double>& vecEnergy = (*fActiveTableEnergy)[Z];
  std::vector<G4double>& vecAlpha = (*fActiveTableAlpha)[Z];
  std::vector<G4double>& vecBeta = (*fActiveTableBeta)[Z];
 
  // Find the row in energy tables
  const auto eLarger = upper_bound(begin(vecEnergy), end(vecEnergy), E);
  const G4int lower = distance(begin(vecEnergy), eLarger) - 1;
  const G4int upper = lower + 1;
 
  // Interpolation
  const G4double energyLower = vecEnergy[lower];
  const G4double energyUpper = vecEnergy[upper];
  const G4double energyFraction = (E - energyLower) / (energyUpper - energyLower);
 
  // linear interpolation along E
  const G4double alpha =
    ((1 - energyFraction) * vecAlpha[lower] + energyFraction * vecAlpha[upper]);
  const G4double beta = ((1 - energyFraction) * vecBeta[lower] + energyFraction * vecBeta[upper]);
  if (fVerboseLevel > 2) {
    G4cout << "RBE hit: Z=" << Z << ", E=" << E << " => alpha=" << alpha << ", beta=" << beta
           << G4endl;
  }
 
  return std::make_tuple(alpha, beta);
}

◆ AddFromAccumulable()

void RadioBio::RBE::AddFromAccumulable ( G4VAccumulable * GenAcc )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 653 of file RBE.cc.

{
  RBEAccumulable* acc = (RBEAccumulable*)GenAcc;
  AddAlphaNumerator(acc->GetAlphaNumerator());
  AddBetaNumerator(acc->GetBetaNumerator());
  AddDenominator(acc->GetDenominator());
 
  fCalculated = false;
}

◆ Initialize()

void RadioBio::RBE::Initialize ( )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 81 of file RBE.cc.

{
  fLnS.resize(VoxelizedSensitiveDetector::GetInstance()->GetTotalVoxelNumber());
  fDoseX.resize(VoxelizedSensitiveDetector::GetInstance()->GetTotalVoxelNumber());
 
  fInitialized = true;
}

◆ Compute()

void RadioBio::RBE::Compute ( )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 416 of file RBE.cc.

{
  // Skip RBE computation if calculation not enabled.
  if (!fCalculationEnabled) {
    if (fVerboseLevel > 0) {
      G4cout << "RBE::Compute() called but skipped as calculation not enabled" << G4endl;
    }
    return;
  }
 
  if (fCalculated == true) return;
 
  GetDose();
 
  ComputeAlphaAndBeta();
  ComputeRBE();
 
  // If this method reached the bottom, set calculated to true
  fCalculated = true;
}

◆ Reset()

void RadioBio::RBE::Reset ( )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 636 of file RBE.cc.

{
  if (fVerboseLevel > 1) {
    G4cout << "RBE: Reset(): ";
  }
  fAlphaNumerator = 0.0;
  fBetaNumerator = 0.0;
  fDenominator = 0.0;
  fDose = 0.0;
  fCalculated = false;
  if (fVerboseLevel > 1) {
    G4cout << fAlphaNumerator.size() << " points." << G4endl;
  }
}

◆ Store()

void RadioBio::RBE::Store ( )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 91 of file RBE.cc.

{
  StoreAlphaAndBeta();
  StoreRBE();
}

◆ PrintParameters()

void RadioBio::RBE::PrintParameters ( )

overridevirtual

Reimplemented from RadioBio::VRadiobiologicalQuantity.

Definition at line 99 of file RBE.cc.

{
  G4cout << "*******************************************" << G4endl
         << "******* Parameters of the class RBE *******" << G4endl
         << "*******************************************" << G4endl;
  PrintVirtualParameters();
  G4cout << "** RBE Cell line: " << fActiveCellLine << G4endl;
  G4cout << "** RBE Dose threshold value: " << fDoseCut / gray << " gray" << G4endl;
  G4cout << "** RBE Alpha X value: " << fAlphaX * gray << " 1/gray" << G4endl;
  G4cout << "** RBE Beta X value: " << fBetaX * std::pow(gray, 2.0) << " 1/gray2" << G4endl;
  G4cout << "*******************************************" << G4endl;
}

◆ ComputeAlphaAndBeta()

void RadioBio::RBE::ComputeAlphaAndBeta ( )

private

Definition at line 344 of file RBE.cc.

{
    // Skip RBE computation if calculation not enabled.
    if (!fCalculationEnabled) {
        if (fVerboseLevel > 0) {
            G4cout << "RBE::ComputeAlphaAndBeta() called but skipped as calculation not enabled"
                   << G4endl;
        }
        return;
    }
 
    if (fVerboseLevel > 0) {
        G4cout << "RBE: Computing alpha and beta..." << G4endl;
    }
 
    // Re-initialize the number of voxels
    fAlpha.resize(fAlphaNumerator.size()); // Initialize with the same number of elements
    fBeta.resize(fBetaNumerator.size());   // Initialize with the same number of elements
 
    for (size_t ii = 0; ii < fDenominator.size(); ii++) {
        if (fDenominator[ii] > 0) {
            fAlpha[ii] = fAlphaNumerator[ii] / (fDenominator[ii] * gray);
            fBeta[ii] = std::pow(fBetaNumerator[ii] / (fDenominator[ii] * gray), 2.0);
        } 
        
        else {
            fAlpha[ii] = 0.;
            fBeta[ii] = 0.;
        }
    }
}

◆ ComputeRBE()

void RadioBio::RBE::ComputeRBE ( )

private

Definition at line 378 of file RBE.cc.

{
  // Skip RBE computation if calculation not enabled.
  if (!fCalculationEnabled) {
    if (fVerboseLevel > 0) {
      G4cout << "RBE::ComputeRBE() called but skipped as calculation not enabled" << G4endl;
    }
    return;
  }
 
  if (fVerboseLevel > 0) {
    G4cout << "RBE: Computing survival and RBE..." << G4endl;
  }
  G4double smax = fAlphaX + 2 * fBetaX * fDoseCut;
 
  for (G4int i = 0; i < VoxelizedSensitiveDetector::GetInstance()->GetTotalVoxelNumber(); i++) {
    if (std::isnan(fAlpha[i]) || std::isnan(fBeta[i])) {
      fLnS[i] = 0.0;
      fDoseX[i] = 0.0;
    }
    else if (fDose[i] <= fDoseCut) {
      fLnS[i] = -(fAlpha[i] * fDose[i]) - (fBeta[i] * (std::pow(fDose[i], 2.0)));
      fDoseX[i] =
        std::sqrt((-fLnS[i] / fBetaX) + std::pow((fAlphaX / (2 * fBetaX)), 2.0)) - (fAlphaX / (2 * fBetaX));
    }
    else {
      G4double ln_Scut = -(fAlpha[i] * fDoseCut) - (fBeta[i] * (std::pow((fDoseCut), 2.0)));
      fLnS[i] = ln_Scut - ((fDose[i] - fDoseCut) * smax);
 
      fDoseX[i] = ((-fLnS[i] + ln_Scut) / smax) + fDoseCut;
    }
  }
  fRBE = fDoseX / fDose;
  fSurvival = std::exp(fLnS);
}

◆ StoreAlphaAndBeta()

void RadioBio::RBE::StoreAlphaAndBeta ( )

private

Definition at line 547 of file RBE.cc.

{
  // Skip RBE storing if calculation not enabled.
  if (!fCalculationEnabled) {
    if (fVerboseLevel > 0) {
      G4cout << "RBE::StoreAlphaAndBeta() called but skipped as calculation not enabled" << G4endl;
    }
    return;
  }
 
  G4String AlphaBetaPath = fPath + "_AlphaAndBeta.out";
  if (fVerboseLevel > 1) {
    G4cout << "RBE: Writing alpha and beta..." << G4endl;
  }
  std::ofstream ofs(AlphaBetaPath);
 
  Compute();
 
  if (ofs.is_open()) {
    ofs << std::left << std::setw(width) << "i" << std::setw(width) << "j" << std::setw(width)
        << "k" << std::setw(width) << "alpha" << std::setw(width) << "beta " << G4endl;
 
    auto voxSensDet = VoxelizedSensitiveDetector::GetInstance();
 
    // Alpha and beta are written only if valid. If value is -nan, 0 is written
    // on the text file
    for (G4int i = 0; i < voxSensDet->GetVoxelNumberAlongX(); i++)
      for (G4int j = 0; j < voxSensDet->GetVoxelNumberAlongY(); j++)
        for (G4int k = 0; k < voxSensDet->GetVoxelNumberAlongZ(); k++) {
          G4int v = voxSensDet->GetThisVoxelNumber(i, j, k);
 
          ofs << std::left << std::setw(width) << i << std::setw(width) << j << std::setw(width)
              << k << std::setw(width) << (std::isnan(fAlpha[v]) ? 0 : (fAlpha[v] * gray))
              << std::setw(width) << (std::isnan(fBeta[v]) ? 0 : (fBeta[v] * std::pow(gray, 2.0)))
              << G4endl;
        }
  }
  if (fVerboseLevel > 0) {
    G4cout << "RBE: Alpha and beta written to " << AlphaBetaPath << G4endl;
  }
}

◆ StoreRBE()

void RadioBio::RBE::StoreRBE ( )

private

Definition at line 591 of file RBE.cc.

{
  // Skip RBE storing if calculation not enabled.
  if (!fCalculationEnabled) {
    if (fVerboseLevel > 0) {
      G4cout << "RBE::StoreRBE() called but skipped as calculation not enabled" << G4endl;
    }
    return;
  }
 
  G4String RBEPath = fPath + "_RBE.out";
  if (fSaved == true)
    G4Exception("RBE::StoreRBE", "RBEOverwrite", JustWarning,
                "Overwriting RBE file. For multiple runs, change filename.");
  std::ofstream ofs(RBEPath);
 
  Compute();
 
  if (ofs.is_open()) {
    ofs << std::left << std::setw(width) << "i" << std::setw(width) << "j" << std::setw(width)
        << "k" << std::setw(width) << "Dose(Gy)" << std::setw(width) << "ln(S) " << std::setw(width)
        << "Survival" << std::setw(width) << "DoseB(Gy)" << std::setw(width) << "RBE" << G4endl;
 
    auto voxSensDet = VoxelizedSensitiveDetector::GetInstance();
 
    for (G4int i = 0; i < voxSensDet->GetVoxelNumberAlongX(); i++)
      for (G4int j = 0; j < voxSensDet->GetVoxelNumberAlongY(); j++)
        for (G4int k = 0; k < voxSensDet->GetVoxelNumberAlongZ(); k++) {
          G4int v = voxSensDet->GetThisVoxelNumber(i, j, k);
 
          ofs << std::left << std::setw(width) << i << std::setw(width) << j << std::setw(width)
              << k << std::setw(width) << (fDose[v] / gray) << std::setw(width) << fLnS[v]
              << std::setw(width) << fSurvival[v] << std::setw(width) << fDoseX[v] / gray
              << std::setw(width) << (std::isnan(fRBE[v]) ? 0. : fRBE[v]) << G4endl;
        }
  }
  if (fVerboseLevel > 0) {
    G4cout << "RBE: RBE written to " << RBEPath << G4endl;
  }
 
  fSaved = true;
}

◆ SetAlphaNumerator()

void RadioBio::RBE::SetAlphaNumerator ( const array_type alpha )

private

Definition at line 489 of file RBE.cc.

{
  if (fVerboseLevel > 1) {
    G4cout << "RBE: Setting alpha numerator..." << G4endl;
  }
  fAlphaNumerator = alpha;
}

◆ SetBetaNumerator()

void RadioBio::RBE::SetBetaNumerator ( const array_type beta )

private

Definition at line 499 of file RBE.cc.

{
  if (fVerboseLevel > 1) {
    G4cout << "RBE: Setting beta numerator..." << G4endl;
  }
  fBetaNumerator = beta;
}

◆ SetDenominator()

void RadioBio::RBE::SetDenominator ( const array_type denom )

private

Definition at line 460 of file RBE.cc.

{
  if (fVerboseLevel > 1) {
    G4cout << "RBE: Setting denominator..." << G4endl;
  }
  fDenominator = denom;
}

◆ AddAlphaNumerator()

void RadioBio::RBE::AddAlphaNumerator ( const array_type alpha )

private

Definition at line 509 of file RBE.cc.

{
  if (fVerboseLevel > 1) {
    G4cout << "RBE: Adding alpha numerator...";
  }
  if (fAlphaNumerator.size()) {
    fAlphaNumerator += alpha;
  }
  else {
    if (fVerboseLevel > 1) {
      G4cout << " (created empty array)";
    }
    fAlphaNumerator = alpha;
  }
  G4cout << G4endl;
}

◆ AddBetaNumerator()

void RadioBio::RBE::AddBetaNumerator ( const array_type beta )

private

Definition at line 528 of file RBE.cc.

{
  if (fVerboseLevel > 1) {
    G4cout << "RBE: Adding beta numerator...";
  }
  if (fBetaNumerator.size()) {
    fBetaNumerator += beta;
  }
  else {
    if (fVerboseLevel > 1) {
      G4cout << " (created empty array)";
    }
    fBetaNumerator = beta;
  }
  G4cout << G4endl;
}

◆ AddDenominator()

void RadioBio::RBE::AddDenominator ( const array_type denom )

private

Definition at line 470 of file RBE.cc.

{
  if (fVerboseLevel > 1) {
    G4cout << "RBE: Adding denominator...";
  }
  if (fDenominator.size()) {
    fDenominator += denom;
  }
  else {
    if (fVerboseLevel > 1) {
      G4cout << " (created empty array)";
    }
    fDenominator = denom;
  }
  G4cout << G4endl;
}

◆ GetDose()

void RadioBio::RBE::GetDose ( )

private

Definition at line 439 of file RBE.cc.

{
  // Get the pointer to dose. If it does not exist, launch an exception
  const Dose* dose = dynamic_cast<const Dose*>(Manager::GetInstance()->GetQuantity("Dose"));
  if (dose == nullptr)
    G4Exception("RBE::Compute", "RBEMissingDose", FatalException,
                "Trying to compute RBE without knowing the dose. Please add a valid dose or "
                "disable RBE calculation");
 
  // Check whether dose has been calculated.
  // If not, give a warning
  if (!dose->HasBeenCalculated())
    G4Exception("RBE::Compute", "RBEDoseNotCalculated", JustWarning,
                "Dose has not been calculated yet while computing RBE, that will be wrong."
                " Please, first calculate dose");
  // Copy the proper vector from Dose class to RBE class
  fDose = dose->GetDose();
}

Member Data Documentation

◆ fAlphaX

G4double RadioBio::RBE::fAlphaX = 0.

private

Definition at line 96 of file RBE.hh.

◆ fBetaX

G4double RadioBio::RBE::fBetaX = 0.

private

Definition at line 97 of file RBE.hh.

◆ fDoseCut

G4double RadioBio::RBE::fDoseCut = 0.

private

Definition at line 98 of file RBE.hh.

◆ fAlpha

array_type RadioBio::RBE::fAlpha = {}

private

Definition at line 101 of file RBE.hh.

101{};

◆ fBeta

array_type RadioBio::RBE::fBeta = {}

private

Definition at line 102 of file RBE.hh.

102{};

◆ fDose

array_type RadioBio::RBE::fDose = {}

private

Definition at line 103 of file RBE.hh.

103{}; // Note: this is copied from calculation in Dose

◆ fAlphaNumerator

array_type RadioBio::RBE::fAlphaNumerator = {}

private

Definition at line 105 of file RBE.hh.

105{};

◆ fBetaNumerator

array_type RadioBio::RBE::fBetaNumerator = {}

private

Definition at line 106 of file RBE.hh.

106{};

◆ fDenominator

array_type RadioBio::RBE::fDenominator = {}

private

Definition at line 107 of file RBE.hh.

107{};

◆ fLnS

array_type RadioBio::RBE::fLnS = {}

private

Definition at line 110 of file RBE.hh.

110{};

◆ fSurvival

array_type RadioBio::RBE::fSurvival = {}

private

Definition at line 111 of file RBE.hh.

111{};

◆ fDoseX

array_type RadioBio::RBE::fDoseX = {}

private

Definition at line 112 of file RBE.hh.

112{};

◆ fRBE

array_type RadioBio::RBE::fRBE = {}

private

Definition at line 113 of file RBE.hh.

113{};

◆ fTablesEnergy

std::map<G4String, vector_type> RadioBio::RBE::fTablesEnergy = {}

private

Definition at line 117 of file RBE.hh.

117{};

◆ fTablesAlpha

std::map<G4String, vector_type> RadioBio::RBE::fTablesAlpha = {}

private

Definition at line 118 of file RBE.hh.

118{};

◆ fTablesBeta

std::map<G4String, vector_type> RadioBio::RBE::fTablesBeta = {}

private

Definition at line 119 of file RBE.hh.

119{};

◆ fTablesAlphaX

std::map<G4String, G4double> RadioBio::RBE::fTablesAlphaX = {}

private

Definition at line 120 of file RBE.hh.

120{};

◆ fTablesBetaX

std::map<G4String, G4double> RadioBio::RBE::fTablesBetaX = {}

private

Definition at line 121 of file RBE.hh.

121{};

◆ fTablesDoseCut

std::map<G4String, G4double> RadioBio::RBE::fTablesDoseCut = {}

private

Definition at line 122 of file RBE.hh.

122{};

◆ fActiveCellLine

G4String RadioBio::RBE::fActiveCellLine

private

Definition at line 126 of file RBE.hh.

◆ fActiveTableEnergy

vector_type* RadioBio::RBE::fActiveTableEnergy = nullptr

private

Definition at line 127 of file RBE.hh.

◆ fActiveTableAlpha

vector_type* RadioBio::RBE::fActiveTableAlpha = nullptr

private

Definition at line 128 of file RBE.hh.

◆ fActiveTableBeta

vector_type* RadioBio::RBE::fActiveTableBeta = nullptr

private

Definition at line 129 of file RBE.hh.

◆ fMaxEnergies

std::map<G4int, G4double> RadioBio::RBE::fMaxEnergies = {}

private

Definition at line 130 of file RBE.hh.

130{};

◆ fMinEnergies

std::map<G4int, G4double> RadioBio::RBE::fMinEnergies = {}

private

Definition at line 131 of file RBE.hh.

131{};

◆ fMinZ

G4int RadioBio::RBE::fMinZ = -1

private

Definition at line 132 of file RBE.hh.

◆ fMaxZ

G4int RadioBio::RBE::fMaxZ = -1

private

Definition at line 133 of file RBE.hh.

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

.doxygen/Doxymodules_medical.h
extended/medical/radiobiology/include/RBE.hh
extended/medical/radiobiology/src/RBE.cc

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ vector_type

Constructor & Destructor Documentation

◆ RBE()

◆ ~RBE()

Member Function Documentation

◆ LoadLEMTable()

◆ SetCellLine()

◆ GetHitAlphaAndBeta()

◆ AddFromAccumulable()

◆ Initialize()

◆ Compute()

◆ Reset()

◆ Store()

◆ PrintParameters()

◆ ComputeAlphaAndBeta()

◆ ComputeRBE()

◆ StoreAlphaAndBeta()

◆ StoreRBE()

◆ SetAlphaNumerator()

◆ SetBetaNumerator()

◆ SetDenominator()

◆ AddAlphaNumerator()

◆ AddBetaNumerator()

◆ AddDenominator()

◆ GetDose()

Member Data Documentation

◆ fAlphaX

◆ fBetaX

◆ fDoseCut

◆ fAlpha

◆ fBeta

◆ fDose

◆ fAlphaNumerator

◆ fBetaNumerator

◆ fDenominator

◆ fLnS

◆ fSurvival

◆ fDoseX

◆ fRBE

◆ fTablesEnergy

◆ fTablesAlpha

◆ fTablesBeta

◆ fTablesAlphaX

◆ fTablesBetaX

◆ fTablesDoseCut

◆ fActiveCellLine

◆ fActiveTableEnergy

◆ fActiveTableAlpha

◆ fActiveTableBeta

◆ fMaxEnergies

◆ fMinEnergies

◆ fMinZ

◆ fMaxZ