#include <Doxymodules_medical.h>

Inheritance diagram for RadioBio::LET:

Public Member Functions
	LET ()

	~LET () override

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 Member Functions
void	SetNTotalLETT (const array_type NTotalLETT)

void	SetNTotalLETD (const array_type NTotalLETD)

void	SetDTotalLETT (const array_type DTotalLETT)

void	SetDTotalLETD (const array_type DTotalLETD)

void	AddNTotalLETT (const array_type NTotalLETT)

void	AddNTotalLETD (const array_type NTotalLETD)

void	AddDTotalLETT (const array_type DTotalLETT)

void	AddDTotalLETD (const array_type DTotalLETD)

void	AddIon (const IonLet ion)

Private Attributes
array_type	fNTotalLETT = {}

array_type	fDTotalLETT = {}

array_type	fNTotalLETD = {}

array_type	fDTotalLETD = {}

array_type	fTotalLETT = {}

array_type	fTotalLETD = {}

std::vector< IonLet >	fIonLetStore

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 134 of file Doxymodules_medical.h.

Constructor & Destructor Documentation

◆ LET()

RadioBio::LET::LET ( )

Definition at line 48 of file LET.cc.

         : VRadiobiologicalQuantity()
{
  fPath = "RadioBio_LET.out";  // Default output filename
 
  fMessenger = new LETMessenger(this);
 
  Initialize();
}

◆ ~LET()

RadioBio::LET::~LET ( )

override

Definition at line 59 of file LET.cc.

{
  delete fMessenger;
}

Member Function Documentation

◆ AddFromAccumulable()

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

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 253 of file LET.cc.

{
  LETAccumulable* acc = (LETAccumulable*)GenAcc;
 
  AddNTotalLETT(acc->GetTotalLETT());
  AddDTotalLETT(acc->GetDTotalLETT());
  AddNTotalLETD(acc->GetTotalLETD());
  AddDTotalLETD(acc->GetDTotalLETD());
 
  // Merges ion counters
  // Loop over rhs ions
  for (unsigned int l = 0; l < acc->GetIonLetStore().size(); l++) {
    G4int PDGencoding = acc->GetIonLetStore()[l].GetPDGencoding();
    size_t q;
    // Loop over lhs ions to find the one
    for (q = 0; q < fIonLetStore.size(); q++) {
      // If he found it, sums values
      if (fIonLetStore[q].GetPDGencoding() == PDGencoding) {
        if (acc->GetIonLetStore()[l].IsPrimary() == fIonLetStore[q].IsPrimary()) break;
      }
    }
    // If ion is missing, copy it
    if (q == fIonLetStore.size())
      fIonLetStore.push_back(acc->GetIonLetStore()[l]);
    else  // Merge rhs data with lhs ones
      fIonLetStore[q].Merge(&(acc->GetIonLetStore()[l]));
  }
  fCalculated = false;
}

◆ Initialize()

void RadioBio::LET::Initialize ( )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 66 of file LET.cc.

{
  G4int VoxelNumber = VoxelizedSensitiveDetector::GetInstance()->GetTotalVoxelNumber();
 
  // Instances for Total LET
  fNTotalLETT.resize(VoxelNumber);
  fNTotalLETD.resize(VoxelNumber);
  fDTotalLETT.resize(VoxelNumber);
  fDTotalLETD.resize(VoxelNumber);
 
  fTotalLETD.resize(VoxelNumber);
  fTotalLETT.resize(VoxelNumber);
 
  fInitialized = true;
}

◆ Compute()

void RadioBio::LET::Compute ( )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 84 of file LET.cc.

{
  // Skip LET computation if calculation not enabled.
  if (!fCalculationEnabled) {
    if (fVerboseLevel > 0) {
      G4cout << "LET::Compute() called but skipped as calculation not enabled" << G4endl;
    }
    return;
  }
  if (fVerboseLevel > 0) G4cout << "LET::Compute()" << G4endl;
 
  if (VoxelizedSensitiveDetector::GetInstance() == nullptr)
    G4Exception("LET::ComputeLET", "PointerNotAvailable", FatalException,
                "Computing LET without voxelized geometry pointer!");
 
  G4int VoxelNumber = VoxelizedSensitiveDetector::GetInstance()->GetTotalVoxelNumber();
 
  for (G4int v = 0; v < VoxelNumber; v++) {
    if (fVerboseLevel > 1) G4cout << "COMPUTING LET of voxel " << v << G4endl;
 
    // Compute total LET
    if (fDTotalLETD[v] > 0.) fTotalLETD[v] = fNTotalLETD[v] / fDTotalLETD[v];
    // G4cout << "ERASE ME. DEBUG: voxel = " << v << " fNTotalLETD[v] = " << fNTotalLETD[v]
    //        << " fDTotalLETD[v] = " << fDTotalLETD[v] << G4endl;
    if (fDTotalLETT[v] > 0.) fTotalLETT[v] = fNTotalLETT[v] / fDTotalLETT[v];
  }
 
  // Sort ions by A and then by Z ...
  std::sort(fIonLetStore.begin(), fIonLetStore.end());
 
  // Compute LET Track and LET Dose for ions
  for (size_t ion = 0; ion < fIonLetStore.size(); ion++) {
    fIonLetStore[ion].Calculate();
  }
 
  fCalculated = true;
}

◆ Reset()

void RadioBio::LET::Reset ( )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 233 of file LET.cc.

{
  if (fVerboseLevel > 1) {
    G4cout << "LET::Reset(): ";
  }
  fNTotalLETT = 0.0;
  fNTotalLETD = 0.0;
  fDTotalLETT = 0.0;
  fDTotalLETD = 0.0;
 
  fTotalLETD = 0.0;
  fTotalLETT = 0.0;
 
  fIonLetStore.clear();
  fCalculated = false;
}

◆ Store()

void RadioBio::LET::Store ( )

overridevirtual

Implements RadioBio::VRadiobiologicalQuantity.

Definition at line 125 of file LET.cc.

{
  // Skip LET storing if calculation not enabled.
  if (!fCalculationEnabled) {
    if (fVerboseLevel > 0) {
      G4cout << "LET::Store() called but skipped as calculation not enabled" << G4endl;
    }
    return;
  }
 
  if (fSaved == true)
    G4Exception("LET::StoreLET", "NtuplesAlreadySaved", FatalException,
                "Overwriting LET file. For multiple runs, change filename.");
 
  Compute();
#define width 15L
  if (fVerboseLevel > 0) G4cout << "LET::StoreLET" << G4endl;
 
  // If there is at least one ion
  if (fIonLetStore.size()) {
    std::ofstream ofs(fPath);
    // ofs.open(fPath, std::ios::out);
    if (ofs.is_open()) {
      // Write the voxels index and total LETs and the list of particles/ions
      ofs << std::setprecision(6) << std::left << "i\tj\tk\t";
      ofs << std::setw(width) << "LDT";
      ofs << std::setw(width) << "LTT";
 
      for (size_t l = 0; l < fIonLetStore.size(); l++)  // Write ions name
      {
        G4String a = (fIonLetStore[l].IsPrimary()) ? "_1_D" : "_D";
        ofs << std::setw(width) << fIonLetStore[l].GetName() + a;
        G4String b = (fIonLetStore[l].IsPrimary()) ? "_1_T" : "_T";
        ofs << std::setw(width) << fIonLetStore[l].GetName() + b;
      }
      ofs << G4endl;
 
      // Write data
      G4AnalysisManager* LETFragmentTuple = G4AnalysisManager::Instance();
 
      LETFragmentTuple->SetVerboseLevel(1);
      LETFragmentTuple->SetFirstHistoId(1);
      LETFragmentTuple->SetFirstNtupleId(1);
 
      LETFragmentTuple->SetDefaultFileType("xml");
      LETFragmentTuple->OpenFile("LET");
 
      LETFragmentTuple->CreateNtuple("coordinate", "LET");
 
      LETFragmentTuple->CreateNtupleIColumn("i");  // 0
      LETFragmentTuple->CreateNtupleIColumn("j");  // 1
      LETFragmentTuple->CreateNtupleIColumn("k");  // 2
      LETFragmentTuple->CreateNtupleDColumn("TotalLETD");  // 3
      LETFragmentTuple->CreateNtupleDColumn("TotalLETT");  // 4
      LETFragmentTuple->CreateNtupleIColumn("A");  // 5
      LETFragmentTuple->CreateNtupleIColumn("Z");  // 6
      LETFragmentTuple->CreateNtupleDColumn("IonLetD");  // 7
      LETFragmentTuple->CreateNtupleDColumn("IonLetT");  // 8
      LETFragmentTuple->FinishNtuple();
 
      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++) {
            LETFragmentTuple->FillNtupleIColumn(1, 0, i);
            LETFragmentTuple->FillNtupleIColumn(1, 1, j);
            LETFragmentTuple->FillNtupleIColumn(1, 2, k);
 
            G4int v = voxSensDet->GetThisVoxelNumber(i, j, k);
 
            // Write total LETs and voxels index
            ofs << G4endl;
            ofs << i << '\t' << j << '\t' << k << '\t';
            ofs << std::setw(width) << fTotalLETD[v] / (keV / um);
            ofs << std::setw(width) << fTotalLETT[v] / (keV / um);
 
            // Write ions LETs
            for (size_t l = 0; l < fIonLetStore.size(); l++) {
              // Write ions LETs
              ofs << std::setw(width) << fIonLetStore[l].GetLETD()[v] / (keV / um);
              ofs << std::setw(width) << fIonLetStore[l].GetLETT()[v] / (keV / um);
            }
 
            LETFragmentTuple->FillNtupleDColumn(1, 3, fTotalLETD[v] / (keV / um));
            LETFragmentTuple->FillNtupleDColumn(1, 4, fTotalLETT[v] / (keV / um));
 
            for (size_t ll = 0; ll < fIonLetStore.size(); ll++) {
              LETFragmentTuple->FillNtupleIColumn(1, 5, fIonLetStore[ll].GetA());
              LETFragmentTuple->FillNtupleIColumn(1, 6, fIonLetStore[ll].GetZ());
 
              LETFragmentTuple->FillNtupleDColumn(1, 7, fIonLetStore[ll].GetLETD()[v] / (keV / um));
              LETFragmentTuple->FillNtupleDColumn(1, 8, fIonLetStore[ll].GetLETT()[v] / (keV / um));
              LETFragmentTuple->AddNtupleRow(1);
            }
          }
      ofs.close();
 
      // LETFragmentTuple->Write();
      LETFragmentTuple->CloseFile();
    }
  }
 
  fSaved = true;
}

◆ PrintParameters()

void RadioBio::LET::PrintParameters ( )

overridevirtual

Reimplemented from RadioBio::VRadiobiologicalQuantity.

Definition at line 285 of file LET.cc.

{
  G4cout << "*******************************************" << G4endl
         << "******* Parameters of the class LET *******" << G4endl
         << "*******************************************" << G4endl;
  PrintVirtualParameters();
}

◆ SetNTotalLETT()

void RadioBio::LET::SetNTotalLETT ( const array_type NTotalLETT )

inlineprivate

Definition at line 85 of file LET.hh.

    {
      fNTotalLETT = NTotalLETT;
    }

◆ SetNTotalLETD()

void RadioBio::LET::SetNTotalLETD ( const array_type NTotalLETD )

inlineprivate

Definition at line 89 of file LET.hh.

    {
      fNTotalLETD = NTotalLETD;
    }

◆ SetDTotalLETT()

void RadioBio::LET::SetDTotalLETT ( const array_type DTotalLETT )

inlineprivate

Definition at line 93 of file LET.hh.

    {
      fDTotalLETT = DTotalLETT;
    }

◆ SetDTotalLETD()

void RadioBio::LET::SetDTotalLETD ( const array_type DTotalLETD )

inlineprivate

Definition at line 97 of file LET.hh.

    {
      fDTotalLETD = DTotalLETD;
    }

◆ AddNTotalLETT()

void RadioBio::LET::AddNTotalLETT ( const array_type NTotalLETT )

inlineprivate

Definition at line 102 of file LET.hh.

    {
      fNTotalLETT += NTotalLETT;
    }

◆ AddNTotalLETD()

void RadioBio::LET::AddNTotalLETD ( const array_type NTotalLETD )

inlineprivate

Definition at line 106 of file LET.hh.

    {
      fNTotalLETD += NTotalLETD;
    }

◆ AddDTotalLETT()

void RadioBio::LET::AddDTotalLETT ( const array_type DTotalLETT )

inlineprivate

Definition at line 110 of file LET.hh.

    {
      fDTotalLETT += DTotalLETT;
    }

◆ AddDTotalLETD()

void RadioBio::LET::AddDTotalLETD ( const array_type DTotalLETD )

inlineprivate

Definition at line 114 of file LET.hh.

    {
      fDTotalLETD += DTotalLETD;
    }

◆ AddIon()

void RadioBio::LET::AddIon ( const IonLet ion )

private

Member Data Documentation

◆ fNTotalLETT

array_type RadioBio::LET::fNTotalLETT = {}

private

Definition at line 69 of file LET.hh.

69{};

◆ fDTotalLETT

array_type RadioBio::LET::fDTotalLETT = {}

private

Definition at line 70 of file LET.hh.

70{};

◆ fNTotalLETD

array_type RadioBio::LET::fNTotalLETD = {}

private

Definition at line 73 of file LET.hh.

73{};

◆ fDTotalLETD

array_type RadioBio::LET::fDTotalLETD = {}

private

Definition at line 74 of file LET.hh.

74{};

◆ fTotalLETT

array_type RadioBio::LET::fTotalLETT = {}

private

Definition at line 77 of file LET.hh.

77{};

◆ fTotalLETD

array_type RadioBio::LET::fTotalLETD = {}

private

Definition at line 78 of file LET.hh.

78{};

◆ fIonLetStore

std::vector<IonLet> RadioBio::LET::fIonLetStore

private

Definition at line 80 of file LET.hh.

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

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LET()

◆ ~LET()

Member Function Documentation

◆ AddFromAccumulable()

◆ Initialize()

◆ Compute()

◆ Reset()

◆ Store()

◆ PrintParameters()

◆ SetNTotalLETT()

◆ SetNTotalLETD()

◆ SetDTotalLETT()

◆ SetDTotalLETD()

◆ AddNTotalLETT()

◆ AddNTotalLETD()

◆ AddDTotalLETT()

◆ AddDTotalLETD()

◆ AddIon()

Member Data Documentation

◆ fNTotalLETT

◆ fDTotalLETT

◆ fNTotalLETD

◆ fDTotalLETD

◆ fTotalLETT

◆ fTotalLETD

◆ fIonLetStore