scavenger::ScoreSpecies Class Reference

Primitive scorer class for scoring the radiolytic species produced after irradiation in a water volume. More...

#include <Doxymodules_medical.h>

Inheritance diagram for scavenger::ScoreSpecies:

Classes
struct	SpeciesInfo

Public Member Functions
	ScoreSpecies (const G4String &name, const G4int &depth=0)
	~ScoreSpecies () override=default
void	AddTimeToRecord (const G4double &time)
	Add a time at which the number of species should be recorded.
void	ClearTimeToRecord ()
	Remove all times to record, must be reset by user.
G4int	GetNumberOfRecordedEvents () const
	Get number of recorded events.
void	Initialize (G4HCofThisEvent *) override
void	EndOfEvent (G4HCofThisEvent *) override
void	DrawAll () override
void	PrintAll () override
void	AbsorbResultsFromWorkerScorer (G4VPrimitiveScorer *)
	Method used in multithreading mode in order to merge the results.
void	OutputAndClear ()
void	SetNewValue (G4UIcommand *, G4String) override
void	WriteWithAnalysisManager (G4VAnalysisManager *)
	Write results to whatever chosen file format.

Protected Member Functions
G4bool	ProcessHits (G4Step *, G4TouchableHistory *) override

Private Types
typedef const G4MolecularConfiguration	Species
typedef std::map< Species *, SpeciesInfo >	InnerSpeciesMap
typedef std::map< G4double, InnerSpeciesMap >	SpeciesMap

Private Attributes
SpeciesMap	fSpeciesInfoPerTime
std::set< G4double >	fTimeToRecord
G4int	fNEvent = 0
G4double	fEdep = 0
G4String	fOutputType = "root"
G4int	fHCID = -1
G4THitsMap< G4double > *	fEvtMap = nullptr
std::unique_ptr< G4UIdirectory >	fpSpeciesdir
std::unique_ptr< G4UIcmdWithAnInteger >	fpTimeBincmd
std::unique_ptr< G4UIcmdWithADoubleAndUnit >	fpAddTimeToRecordcmd
std::unique_ptr< G4UIcmdWithAString >	fpSetResultsFileNameCmd
G4String	fRootFileName = "scorer.root"

Detailed Description

Primitive scorer class for scoring the radiolytic species produced after irradiation in a water volume.

This is a primitive scorer class for molecular species. The number of species is recorded for all times (predetermined or user chosen). It also scores the energy deposition in order to compute the radiochemical yields.

Definition at line 353 of file Doxymodules_medical.h.

Member Typedef Documentation

Species

typedef const G4MolecularConfiguration scavenger::ScoreSpecies::Species

private

Definition at line 115 of file ScoreSpecies.hh.

InnerSpeciesMap

typedef std::map<Species*, SpeciesInfo> scavenger::ScoreSpecies::InnerSpeciesMap

private

Definition at line 116 of file ScoreSpecies.hh.

SpeciesMap

typedef std::map<G4double, InnerSpeciesMap> scavenger::ScoreSpecies::SpeciesMap

private

Definition at line 117 of file ScoreSpecies.hh.

Constructor & Destructor Documentation

ScoreSpecies()

scavenger::ScoreSpecies::ScoreSpecies ( const G4String &  name, const G4int &  depth = 0  )

explicit

Definition at line 47 of file ScoreSpecies.cc.

  : G4VPrimitiveScorer(name, depth),
    G4UImessenger(),
    fpSpeciesdir(new G4UIdirectory("/scorer/species/")),
    fpTimeBincmd(new G4UIcmdWithAnInteger("/scorer/species/nOfTimeBins", this)),
    fpAddTimeToRecordcmd(
      new G4UIcmdWithADoubleAndUnit("/scorer/species/addTimeToRecord", this)),
    fpSetResultsFileNameCmd(
      new G4UIcmdWithAString("/scorer/species/setRootFileName", this)) {
  fpSpeciesdir->SetGuidance("ScoreSpecies commands");
  fpSetResultsFileNameCmd->SetGuidance("Set the root file name");
  G4MoleculeCounter::Instance()->ResetCounter();
}

~ScoreSpecies()

scavenger::ScoreSpecies::~ScoreSpecies ( )

overridedefault

Member Function Documentation

AddTimeToRecord()

void scavenger::ScoreSpecies::AddTimeToRecord ( const G4double &  time )

inline

Add a time at which the number of species should be recorded.

Default times are set up to 1 microsecond.

Definition at line 67 of file ScoreSpecies.hh.

  {
    fTimeToRecord.insert(time);
  }

ClearTimeToRecord()

void scavenger::ScoreSpecies::ClearTimeToRecord ( )

inline

Remove all times to record, must be reset by user.

Definition at line 73 of file ScoreSpecies.hh.

{ fTimeToRecord.clear(); }

GetNumberOfRecordedEvents()

G4int scavenger::ScoreSpecies::GetNumberOfRecordedEvents ( ) const

inline

Get number of recorded events.

Definition at line 76 of file ScoreSpecies.hh.

  {
    return fNEvent;
  }

Initialize()

void scavenger::ScoreSpecies::Initialize ( G4HCofThisEvent *  HCE )

override

Definition at line 101 of file ScoreSpecies.cc.

                                                  {
  fEvtMap = new G4THitsMap<G4double>(GetMultiFunctionalDetector()->GetName(),
                                     GetName());
  if (fHCID < 0) {
    fHCID = GetCollectionID(0);
  }
  HCE->AddHitsCollection(fHCID, (G4VHitsCollection *) fEvtMap);
  G4MoleculeCounter::Instance()->ResetCounter();
}

EndOfEvent()

void scavenger::ScoreSpecies::EndOfEvent ( G4HCofThisEvent *  )

override

Definition at line 113 of file ScoreSpecies.cc.

                                               {
  if (G4EventManager::GetEventManager()->GetConstCurrentEvent()->IsAborted()) {
    fEdep = 0.;
    G4MoleculeCounter::Instance()->ResetCounter();
    return;
  }
 
  auto species = G4MoleculeCounter::Instance()->GetRecordedMolecules();
 
  if (species == nullptr || species->empty()) {
    G4cout << "No molecule recorded, energy deposited= "
           << G4BestUnit(fEdep, "Energy") << G4endl;
    ++fNEvent;
    fEdep = 0.;
    G4MoleculeCounter::Instance()->ResetCounter();
    return;
  }
  for (auto molecule: *species) {
    for (auto time_mol: fTimeToRecord) {
      G4double n_mol =
        G4MoleculeCounter::Instance()->GetNMoleculesAtTime(molecule,
                                                           time_mol);
      if (n_mol < 0) {
        G4cerr << "N molecules not valid < 0 " << G4endl;
        G4Exception("", "N<0", FatalException, "");
      }
      SpeciesInfo &molInfo = fSpeciesInfoPerTime[time_mol][molecule];
      molInfo.fNumber += n_mol;
      G4double gValue = (n_mol / (fEdep / eV)) * 100.;
      molInfo.fG += gValue;
      molInfo.fG2 += gValue * gValue;
    }
  }
  ++fNEvent;
  fEdep = 0.;
  G4MoleculeCounter::Instance()->ResetCounter();
}

DrawAll()

void scavenger::ScoreSpecies::DrawAll ( )

inlineoverride

Definition at line 85 of file ScoreSpecies.hh.

{};

PrintAll()

void scavenger::ScoreSpecies::PrintAll ( )

override

Definition at line 188 of file ScoreSpecies.cc.

                            {
  G4cout << " MultiFunctionalDet  " << detector->GetName() << G4endl;
  G4cout << " PrimitiveScorer " << GetName() << G4endl;
  G4cout << " Number of events " << fNEvent << G4endl;
  G4cout << " Number of energy deposition recorded "
         << fEvtMap->entries() << G4endl;
 
  for (auto itr : *fEvtMap->GetMap()) {
    G4cout << "  copy no.: " << itr.first
           << "  energy deposit: "
           << *(itr.second) / GetUnitValue()
           << " [" << GetUnit() << "]"
           << G4endl;
  }
}

AbsorbResultsFromWorkerScorer()

void scavenger::ScoreSpecies::AbsorbResultsFromWorkerScorer

(

G4VPrimitiveScorer *

workerScorer

)

Method used in multithreading mode in order to merge the results.

Definition at line 154 of file ScoreSpecies.cc.

                                                                            {
  auto right = dynamic_cast<ScoreSpecies *>(dynamic_cast<G4VPrimitiveScorer *>(workerScorer));
 
  if (right == nullptr) {
    return;
  }
  if (right == this) {
    return;
  }
 
  auto it_map1 = right->fSpeciesInfoPerTime.begin();
  auto end_map1 = right->fSpeciesInfoPerTime.end();
 
  for (; it_map1 != end_map1; ++it_map1) {
    InnerSpeciesMap &map2 = it_map1->second;
    auto it_map2 = map2.begin();
    auto end_map2 = map2.end();
 
    for (; it_map2 != end_map2; ++it_map2) {
      SpeciesInfo &molInfo =
        fSpeciesInfoPerTime[it_map1->first][it_map2->first];
      molInfo.fNumber += it_map2->second.fNumber;
      molInfo.fG += it_map2->second.fG;
      molInfo.fG2 += it_map2->second.fG2;
    }
  }
  right->fSpeciesInfoPerTime.clear();
  fNEvent += right->fNEvent;
  right->fNEvent = 0;
  right->fEdep = 0.;
}

OutputAndClear()

void scavenger::ScoreSpecies::OutputAndClear

(

)

Definition at line 206 of file ScoreSpecies.cc.

                                  {
  if (G4Threading::IsWorkerThread()) {
    return;
  }
 
  auto analysisManager = G4AnalysisManager::Instance();
  analysisManager->SetDefaultFileType(fOutputType);
  this->WriteWithAnalysisManager(analysisManager);
  fNEvent = 0;
  fSpeciesInfoPerTime.clear();
}

SetNewValue()

void scavenger::ScoreSpecies::SetNewValue ( G4UIcommand *  command, G4String  newValue  )

override

Definition at line 63 of file ScoreSpecies.cc.

                                                                      {
  if (command == fpAddTimeToRecordcmd.get()) {
    G4double cmdTime = fpAddTimeToRecordcmd->GetNewDoubleValue(newValue);
    AddTimeToRecord(cmdTime);
  }
  if (command == fpTimeBincmd.get()) {
    ClearTimeToRecord();
    G4int cmdBins = fpTimeBincmd->GetNewIntValue(newValue);
    G4double timeMin = 1 * ps;
    G4double timeMax = G4Scheduler::Instance()->GetEndTime() - timeMin;
    G4double timeLogMin = std::log10(timeMin);
    G4double timeLogMax = std::log10(timeMax);
    for (G4int i = 0; i < cmdBins; i++) {
      AddTimeToRecord(std::pow(10, timeLogMin +
                                   i * (timeLogMax - timeLogMin) / (cmdBins - 1)));
    }
  }
  if (command == fpSetResultsFileNameCmd.get()) {
    fRootFileName = newValue;
  }
}

WriteWithAnalysisManager()

void scavenger::ScoreSpecies::WriteWithAnalysisManager

(

G4VAnalysisManager *

analysisManager

)

Write results to whatever chosen file format.

Definition at line 221 of file ScoreSpecies.cc.

                                                                          {
  analysisManager->OpenFile(fRootFileName);
  G4int fNtupleID = analysisManager->CreateNtuple("species", "species");
  analysisManager->CreateNtupleIColumn(fNtupleID, "speciesID");
  analysisManager->CreateNtupleIColumn(fNtupleID, "number");
  analysisManager->CreateNtupleIColumn(fNtupleID, "nEvent");
  analysisManager->CreateNtupleSColumn(fNtupleID, "speciesName");
  analysisManager->CreateNtupleDColumn(fNtupleID, "time");
  analysisManager->CreateNtupleDColumn(fNtupleID, "sumG");
  analysisManager->CreateNtupleDColumn(fNtupleID, "sumG2");
  analysisManager->FinishNtuple(fNtupleID);
 
  for (const auto &it_map1: fSpeciesInfoPerTime) {
    const InnerSpeciesMap &map2 = it_map1.second;
 
    for (const auto &it_map2 : map2) {
      G4double time = it_map1.first;
      auto species = it_map2.first;
      const G4String &name = species->GetName();
      auto molID = it_map2.first->GetMoleculeID();
      auto number = it_map2.second.fNumber;
      auto G = it_map2.second.fG;
      auto G2 = it_map2.second.fG2;
      analysisManager->FillNtupleIColumn(fNtupleID, 0, molID);   // MolID
      analysisManager->FillNtupleIColumn(fNtupleID, 1, number);  // Number
      analysisManager->FillNtupleIColumn(fNtupleID, 2, fNEvent); // Total nb events
      analysisManager->FillNtupleSColumn(fNtupleID, 3, name);    // molName
      analysisManager->FillNtupleDColumn(fNtupleID, 4, time);    // time
      analysisManager->FillNtupleDColumn(fNtupleID, 5, G);       // G
      analysisManager->FillNtupleDColumn(fNtupleID, 6, G2);      // G2
      analysisManager->AddNtupleRow(fNtupleID);
    }
  }
 
  analysisManager->Write();
  analysisManager->CloseFile();
}

ProcessHits()

G4bool scavenger::ScoreSpecies::ProcessHits ( G4Step *  aStep, G4TouchableHistory *    )

overrideprotected

Definition at line 87 of file ScoreSpecies.cc.

                                                                    {
  G4double edep = aStep->GetTotalEnergyDeposit();
  if (edep == 0.) {
    return FALSE;
  }
  edep *= aStep->GetPreStepPoint()->GetWeight(); // (Particle Weight)
  auto index = GetIndex(aStep);
  fEvtMap->add(index, edep);
  fEdep += edep;
  return TRUE;
}

Member Data Documentation

fSpeciesInfoPerTime

SpeciesMap scavenger::ScoreSpecies::fSpeciesInfoPerTime

private

Definition at line 118 of file ScoreSpecies.hh.

fTimeToRecord

std::set<G4double> scavenger::ScoreSpecies::fTimeToRecord

private

Definition at line 119 of file ScoreSpecies.hh.

fNEvent

G4int scavenger::ScoreSpecies::fNEvent = 0

private

Definition at line 120 of file ScoreSpecies.hh.

fEdep

G4double scavenger::ScoreSpecies::fEdep = 0

private

Definition at line 121 of file ScoreSpecies.hh.

fOutputType

G4String scavenger::ScoreSpecies::fOutputType = "root"

private

Definition at line 122 of file ScoreSpecies.hh.

fHCID

G4int scavenger::ScoreSpecies::fHCID = -1

private

Definition at line 123 of file ScoreSpecies.hh.

fEvtMap

G4THitsMap<G4double>* scavenger::ScoreSpecies::fEvtMap = nullptr

private

Definition at line 124 of file ScoreSpecies.hh.

fpSpeciesdir

std::unique_ptr<G4UIdirectory> scavenger::ScoreSpecies::fpSpeciesdir

private

Definition at line 125 of file ScoreSpecies.hh.

fpTimeBincmd

std::unique_ptr<G4UIcmdWithAnInteger> scavenger::ScoreSpecies::fpTimeBincmd

private

Definition at line 126 of file ScoreSpecies.hh.

fpAddTimeToRecordcmd

std::unique_ptr<G4UIcmdWithADoubleAndUnit> scavenger::ScoreSpecies::fpAddTimeToRecordcmd

private

Definition at line 127 of file ScoreSpecies.hh.

fpSetResultsFileNameCmd

std::unique_ptr<G4UIcmdWithAString> scavenger::ScoreSpecies::fpSetResultsFileNameCmd

private

Definition at line 128 of file ScoreSpecies.hh.

fRootFileName

G4String scavenger::ScoreSpecies::fRootFileName = "scorer.root"

private

Definition at line 129 of file ScoreSpecies.hh.

---

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

• .doxygen/Doxymodules_medical.h
• extended/medical/dna/scavenger/include/ScoreSpecies.hh
• extended/medical/dna/scavenger/src/ScoreSpecies.cc