File indexing completed on 2026-05-11 08:09:11
0001
0002
0003
0004
0005
0006
0007
0008
0009
0010
0011
0012
0013
0014
0015
0016
0017
0018
0019
0020
0021
0022
0023
0024
0025
0026
0027
0028
0029 #include "Scorer.hh"
0030
0031 #include "InterPulseAction.hh"
0032 #include "PrimaryGeneratorAction.hh"
0033 #include "PulseAction.hh"
0034 #include "TimeStepAction.hh"
0035
0036 #include "G4AnalysisManager.hh"
0037 #include "G4DNAEventScheduler.hh"
0038 #include "G4DNAScavengerMaterial.hh"
0039 #include "G4Event.hh"
0040 #include "G4PhysicalConstants.hh"
0041 #include "G4RunManager.hh"
0042 #include "G4Scheduler.hh"
0043 #include "G4UIcmdWithADoubleAndUnit.hh"
0044 #include "G4UIcmdWithAnInteger.hh"
0045 #include "G4VChemistryWorld.hh"
0046
0047 #include <G4EventManager.hh>
0048 #include <G4MolecularConfiguration.hh>
0049 #include <G4SystemOfUnits.hh>
0050 #include <globals.hh>
0051
0052
0053
0054
0055 Dose::Dose()
0056 : G4UImessenger(),
0057 fpDoseDir(new G4UIdirectory("/scorer/Dose/")),
0058 fpAddDoseCutOff(new G4UIcmdWithADoubleAndUnit("/scorer/Dose/cutoff", this)),
0059 fpAddDoseToAbort(new G4UIcmdWithADoubleAndUnit("/scorer/Dose/abortedDose", this))
0060 {
0061 fpDoseDir->SetGuidance("Dose scorer commands");
0062 }
0063
0064
0065
0066 void Dose::SetNewValue(G4UIcommand* command, G4String newValue)
0067 {
0068 if (command == fpAddDoseCutOff.get()) {
0069 fDosesCutOff = G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(newValue);
0070 }
0071 if (command == fpAddDoseToAbort.get()) {
0072 fDosesToAbort = G4UIcmdWithADoubleAndUnit::GetNewDoubleValue(newValue);
0073 }
0074 }
0075
0076
0077
0078 template<>
0079 void Scorer<Dose>::SetChemistryWorld(G4VChemistryWorld* pChemistryWorld)
0080 {
0081 fpChemistryWorld = pChemistryWorld;
0082 }
0083
0084
0085
0086 template<>
0087 G4VChemistryWorld* Scorer<Dose>::GetChemistryWorld() const
0088 {
0089 return fpChemistryWorld;
0090 }
0091
0092
0093
0094 template<>
0095 void Scorer<Dose>::clear()
0096 {
0097 fpScorer->fCumulatedDose = 0.;
0098 fpScorer->fPulseMax = 0;
0099 }
0100
0101 template<>
0102 void Scorer<Dose>::Initialize(G4HCofThisEvent* HCE)
0103 {
0104 clear();
0105 fpEvtMap = new G4THitsMap<G4double>(GetMultiFunctionalDetector()->GetName(),
0106 GetName());
0107 if (fHCID < 0) {
0108 fHCID = GetCollectionID(0);
0109 }
0110 HCE->AddHitsCollection(fHCID, (G4VHitsCollection*)fpEvtMap);
0111
0112 fPulseActionInfo =
0113 dynamic_cast<const InterPulseAction*>(G4RunManager::GetRunManager()
0114 ->GetUserTrackingAction());
0115 }
0116
0117
0118
0119 template<>
0120 void Scorer<Dose>::EndOfEvent(G4HCofThisEvent*)
0121 {
0122 if (!G4RunManager::GetRunManager()->GetCurrentEvent()->IsAborted()) {
0123 fpEvtMap->add(0, fpScorer->fDosesCutOff);
0124 }
0125 fpScorer->fCumulatedDose = 0.;
0126 fpScorer->fPulseMax = 0;
0127 }
0128
0129
0130
0131 template<>
0132 G4bool Scorer<Dose>::ProcessHits(G4Step* aStep, G4TouchableHistory*)
0133 {
0134 auto currentEvent = G4EventManager::GetEventManager();
0135 const G4Track* track = aStep->GetTrack();
0136 auto boundingBox = fpChemistryWorld->GetChemistryBoundary();
0137
0138 G4double V = boundingBox->Volume() / cm3;
0139 G4double edep = aStep->GetTotalEnergyDeposit();
0140 if (edep == 0.) {
0141 return false;
0142 }
0143 G4double eToGray = (0.001 * V * 6.242e+18);
0144 if (eToGray != 0) {
0145 (fpScorer->fCumulatedDose) += ((edep) / eV) / eToGray;
0146 }
0147 if (track->GetParentID() == 0 && aStep->IsFirstStepInVolume()) {
0148 auto pulseInfo = dynamic_cast<PulseInfo*>(track->GetUserInformation());
0149 if (pulseInfo != nullptr) {
0150 auto delayedTime = pulseInfo->GetDelayedTime();
0151 if (fpScorer->fPulseMax < delayedTime) {
0152 fpScorer->fPulseMax = delayedTime;
0153 }
0154 }
0155 G4double DoseInGray = fpScorer->fCumulatedDose;
0156 if (DoseInGray > fpScorer->fDosesCutOff / gray) {
0157 G4cout << "______________________________________________________________"
0158 << G4endl;
0159 auto name = currentEvent->GetConstCurrentEvent()
0160 ->GetPrimaryVertex()
0161 ->GetPrimary()
0162 ->GetParticleDefinition()
0163 ->GetParticleName();
0164 auto energy = currentEvent->GetConstCurrentEvent()
0165 ->GetPrimaryVertex()->GetPrimary()->GetKineticEnergy();
0166
0167 G4cout << "Beam line : " << "(" << name << ", " << energy
0168 << " MeV)" << G4endl;
0169 G4cout << "Cut-off dose : " << fpScorer->fDosesCutOff / gray
0170 << " Gy" << G4endl;
0171 G4cout << "Stop at actual dose : " << DoseInGray << " Gy" << G4endl;
0172 if (fPulseActionInfo != nullptr) {
0173 auto numberOfPulse = fPulseActionInfo->GetNumberOfPulse();
0174 auto DIT = fPulseActionInfo->GetPulsePeriod();
0175 G4cout << "DIT : " << DIT / CLHEP::ms << " ms" << G4endl;
0176 G4cout << "Pulse number : " << numberOfPulse << G4endl;
0177 }
0178
0179 const auto generatorAction = static_cast<const PrimaryGeneratorAction*>(
0180 G4RunManager::GetRunManager()->GetUserPrimaryGeneratorAction());
0181 const auto particleGun = generatorAction->GetSPGun();
0182 auto NumberOfParticlesGeneratedinOneEvent = particleGun->GetNumberOfParticles();
0183
0184 G4cout << "Beam duration : " << fpScorer->fPulseMax / second
0185 << " s" << G4endl;
0186 if(fpScorer->fPulseMax != 0){
0187 G4cout << "Actual dose rate : "
0188 << DoseInGray / (fpScorer->fPulseMax / second) << " Gy/s"
0189 << G4endl;
0190 }else{
0191 G4cout << "Actual dose rate : " << "infinite"
0192 << G4endl;
0193 }
0194
0195 G4cout << "Track number : "
0196 << NumberOfParticlesGeneratedinOneEvent
0197 - currentEvent->GetStackManager()->GetNUrgentTrack() - 1
0198 << " tracks" << G4endl;
0199 G4cout << "Irradiated volume : " << V * 1e+12
0200 << " um3 (" << 2 * boundingBox->halfSideLengthInX() / um << " x "
0201 << 2 * boundingBox->halfSideLengthInY() / um << " x "
0202 << 2 * boundingBox->halfSideLengthInZ() / um << ")" << G4endl;
0203 auto ChemComponent = fpChemistryWorld->GetChemicalComponent();
0204 for (const auto& it : ChemComponent) {
0205 if (fH2O == it.first) continue;
0206 if (fOHm == it.first) continue;
0207 if (it.first == fH3Op) {
0208 G4cout << "pH : "
0209 << -std::log10(it.second * (mole * liter)) << G4endl;
0210 continue;
0211 }
0212 G4cout << it.first->GetName() << " : "
0213 << it.second * (mole * liter) << " M "
0214 << G4endl;
0215 }
0216
0217 G4cout << "Total deposit energy : "
0218 << fpScorer->fCumulatedDose * eToGray << " eV" << G4endl;
0219 G4double DoseAbort;
0220 if (fpScorer->fDosesToAbort == 0) {
0221 DoseAbort = fpScorer->fDosesCutOff / gray
0222 + 0.5 * fpScorer->fDosesCutOff / gray;
0223 }
0224 else {
0225 DoseAbort = fpScorer->fDosesToAbort / gray;
0226 }
0227
0228 G4cout << "Dose to abort : " << DoseAbort << " Gy" << G4endl;
0229 if (DoseInGray > DoseAbort) {
0230 G4cout << "Abort this beam line (" << name << ", " << energy
0231 << " MeV) at actual dose: " << DoseInGray << " Gy" << G4endl;
0232 G4RunManager::GetRunManager()->AbortEvent();
0233 }
0234 G4cout << "______________________________________________________________"
0235 << G4endl;
0236 auto myTrack = ((G4Track*)track);
0237 myTrack->SetTrackStatus(fStopAndKill);
0238 auto secondaries = track->GetStep()->GetSecondaryInCurrentStep();
0239 if (!secondaries->empty()) {
0240 for (auto it : *(secondaries)) {
0241 if (it != nullptr) {
0242 ((G4Track*)it)->SetTrackStatus(fStopAndKill);
0243 }
0244 }
0245 }
0246 currentEvent->GetStackManager()->ClearUrgentStack();
0247 }
0248 }
0249 return true;
0250 }
0251
0252
0253
0254
0255 Gvalues::Gvalues()
0256 : G4UImessenger(),
0257 fTimeLimit(G4Scheduler::Instance()->GetEndTime()),
0258 fSpeciesdir(new G4UIdirectory("/scorer/Gvalues/")),
0259 fTimeBincmd(new G4UIcmdWithAnInteger("/scorer/Gvalues/nOfTimeBins", this)),
0260 fAddTimeToRecordcmd(new G4UIcmdWithADoubleAndUnit("/scorer/Gvalues/addTimeToRecord", this))
0261 {
0262 fSpeciesdir->SetGuidance("ScoreSpecies commands");
0263 }
0264
0265
0266
0267 void Gvalues::SetNewValue(G4UIcommand* command, G4String newValue)
0268 {
0269 if (command == fAddTimeToRecordcmd.get()) {
0270 G4double cmdTime = fAddTimeToRecordcmd->GetNewDoubleValue(newValue);
0271 if (fTimeLimit >= cmdTime) {
0272 AddTimeToRecord(cmdTime);
0273 }
0274 else {
0275 AddTimeToRecord(fTimeLimit);
0276 }
0277 }
0278 if (command == fTimeBincmd.get()) {
0279 G4int cmdBins = fTimeBincmd->GetNewIntValue(newValue);
0280 G4double timeMin = 1 * ps;
0281 G4double timeMax = G4Scheduler::Instance()->GetEndTime() - timeMin;
0282 G4double timeLogMin = std::log10(timeMin);
0283 G4double timeLogMax = std::log10(timeMax);
0284 for (int i = 0; i <= cmdBins; i++) {
0285 AddTimeToRecord(std::pow(10, timeLogMin + i * (timeLogMax - timeLogMin) / cmdBins));
0286 }
0287 }
0288 }
0289
0290
0291 void Gvalues::
0292 WriteInfo(G4VAnalysisManager* analysisManager, const std::string& out)
0293 {
0294 G4int NtupleID = analysisManager->CreateNtuple("info", "Simulation");
0295 analysisManager->CreateNtupleDColumn(NtupleID, "Dose");
0296 analysisManager->FinishNtuple(NtupleID);
0297 analysisManager->FillNtupleDColumn(NtupleID, 0, std::stod(out));
0298 analysisManager->AddNtupleRow(NtupleID);
0299 }
0300
0301 void Gvalues::WriteGvalues(G4VAnalysisManager* analysisManager)
0302 {
0303 G4int NtupleID = analysisManager->CreateNtuple("Gvalue", "Gvalue");
0304 analysisManager->CreateNtupleIColumn(NtupleID, "speciesID");
0305 analysisManager->CreateNtupleIColumn(NtupleID, "number");
0306 analysisManager->CreateNtupleIColumn(NtupleID, "nEvent");
0307 analysisManager->CreateNtupleSColumn(NtupleID, "speciesName");
0308 analysisManager->CreateNtupleDColumn(NtupleID, "time");
0309 analysisManager->CreateNtupleDColumn(NtupleID, "sumG");
0310 analysisManager->CreateNtupleDColumn(NtupleID, "sumG2");
0311 analysisManager->CreateNtupleDColumn(NtupleID, "TotalDose");
0312 analysisManager->CreateNtupleDColumn(NtupleID, "TotalDose2");
0313 analysisManager->CreateNtupleDColumn(NtupleID, "TotalDoseRate");
0314 analysisManager->CreateNtupleDColumn(NtupleID, "TotalDoseRate2");
0315 analysisManager->FinishNtuple(NtupleID);
0316
0317 for (const auto& it_map1 : fSpeciesInfoPerTime) {
0318 const InnerSpeciesMap& map2 = it_map1.second;
0319 for (auto it_map2 : map2) {
0320 double time = it_map1.first;
0321 auto species = it_map2.first;
0322 const G4String& name = species->GetName();
0323 int molID = it_map2.first->GetMoleculeID();
0324 auto number = it_map2.second.fNumber;
0325 double G = it_map2.second.fG;
0326 double G2 = it_map2.second.fG2;
0327
0328 analysisManager->FillNtupleIColumn(NtupleID, 0, molID);
0329 analysisManager->FillNtupleIColumn(NtupleID, 1, number);
0330 analysisManager->FillNtupleIColumn(NtupleID, 2, fNEvent);
0331 analysisManager->FillNtupleSColumn(NtupleID, 3, name);
0332 analysisManager->FillNtupleDColumn(NtupleID, 4, time);
0333 analysisManager->FillNtupleDColumn(NtupleID, 5, G);
0334 analysisManager->FillNtupleDColumn(NtupleID, 6, G2);
0335 analysisManager->FillNtupleDColumn(NtupleID, 7, fTotalDose);
0336 analysisManager->FillNtupleDColumn(NtupleID, 8, fTotalDose2);
0337 analysisManager->FillNtupleDColumn(NtupleID, 9, fTotalDoseRate);
0338 analysisManager->FillNtupleDColumn(NtupleID, 10, fTotalDoseRate2);
0339 analysisManager->AddNtupleRow(NtupleID);
0340 }
0341 }
0342 }
0343
0344
0345 void Gvalues::
0346 WriteWithAnalysisManager(G4VAnalysisManager* analysisManager, const std::string& out)
0347 {
0348 WriteInfo(analysisManager, out);
0349 WriteGvalues(analysisManager);
0350
0351 }
0352
0353
0354 template<>
0355 void Scorer<Gvalues>::clear()
0356 {
0357 fpEvtMap->clear();
0358 fpScorer->fNEvent = 0;
0359 fpScorer->fEdep = 0;
0360 fpScorer->fSpeciesInfoPerTime.clear();
0361 }
0362
0363
0364
0365 template<>
0366 void Scorer<Gvalues>::Initialize(G4HCofThisEvent* HCE)
0367 {
0368 fpEvtMap = new G4THitsMap<G4double>(GetMultiFunctionalDetector()->GetName(), GetName());
0369 if (fHCID < 0) {
0370 fHCID = GetCollectionID(0);
0371 }
0372 HCE->AddHitsCollection(fHCID, (G4VHitsCollection*)fpEvtMap);
0373 }
0374
0375
0376
0377 template<>
0378 void Scorer<Gvalues>::SetChemistryWorld(G4VChemistryWorld* pChemistryWorld)
0379 {
0380 fpChemistryWorld = pChemistryWorld;
0381 }
0382
0383
0384
0385 template<>
0386 G4VChemistryWorld* Scorer<Gvalues>::GetChemistryWorld() const
0387 {
0388 return fpChemistryWorld;
0389 }
0390
0391
0392
0393 template<>
0394 G4bool Scorer<Gvalues>::ProcessHits(G4Step* aStep, G4TouchableHistory*)
0395 {
0396 const G4Track* track = aStep->GetTrack();
0397 auto pulseInfo = dynamic_cast<PulseInfo*>(track->GetUserInformation());
0398 if (pulseInfo != nullptr) {
0399 auto delayedTime = pulseInfo->GetDelayedTime();
0400 if (fpScorer->fPulseMax < delayedTime) {
0401 fpScorer->fPulseMax = delayedTime;
0402 }
0403 }
0404
0405 G4double edep = aStep->GetTotalEnergyDeposit();
0406 if (edep == 0.) {
0407 return FALSE;
0408 }
0409 edep *= aStep->GetPreStepPoint()->GetWeight();
0410 G4int index = GetIndex(aStep);
0411 fpEvtMap->add(index, edep);
0412 (fpScorer->fEdep) += edep;
0413 return TRUE;
0414 }
0415
0416
0417
0418 template<>
0419 void Scorer<Gvalues>::SaveScavengerChange()
0420 {
0421 auto pScavengerMaterial =
0422 dynamic_cast<G4DNAScavengerMaterial*>(G4Scheduler::Instance()->GetScavengerMaterial());
0423 if (pScavengerMaterial == nullptr) {
0424 G4ExceptionDescription errMsg;
0425 errMsg << "pScavengerMaterial == nullptr";
0426 G4Exception("Scorer<Gvalues>::SaveScavengerChange()", "SaveScavengerChange",
0427 FatalErrorInArgument, errMsg);
0428 }
0429 auto scavengerList = pScavengerMaterial->GetScavengerList();
0430 auto V = fpChemistryWorld->GetChemistryBoundary()->Volume();
0431 auto iniC = fpChemistryWorld->GetChemicalComponent();
0432
0433 G4double eToGray = (0.001 * V * 6.242e+18);
0434 if (eToGray != 0) {
0435 G4double dose = 1000 * (fpScorer->fEdep / eV) / eToGray;
0436 for (const auto& it : scavengerList) {
0437 if (it == fH2O || fH3Op == it || fOHm == it) {
0438 continue;
0439 }
0440 for (auto time_mol : fpScorer->fTimeToRecord) {
0441 int64_t n_mol = pScavengerMaterial->GetNMoleculesAtTime(it, time_mol);
0442 if (n_mol < 0) {
0443 G4ExceptionDescription errMsg;
0444 errMsg << "SaveScavengerChange()::N molecules not valid < 0 : " << it->GetName()
0445 << " N : " << n_mol << G4endl;
0446 G4Exception("", "N<0", FatalException, errMsg);
0447 }
0448
0449 Gvalues::SpeciesInfo& molInfo =
0450 fpScorer->fSpeciesInfoPerTime[time_mol][it];
0451 molInfo.fNumber += n_mol;
0452 if (V > 0) {
0453 auto concentration = n_mol / (Avogadro * V );
0454
0455
0456 auto inuM = (iniC[it] - concentration) * (mole * liter) * 1e6;
0457
0458 if (dose > 0) {
0459 G4double gValue = inuM / dose;
0460 molInfo.fG += gValue;
0461 molInfo.fG2 += gValue * gValue;
0462 }
0463 }
0464 }
0465 }
0466 }
0467 }
0468
0469
0470
0471 template<>
0472 void Scorer<Gvalues>::SaveMoleculeCounter()
0473 {
0474 if (fpEventScheduler == nullptr) {
0475 G4Exception("fpEventScheduler == nullptr",
0476 "Scorer<Gvalues>::SaveMoleculeCounter()",
0477 FatalException, "fpEventScheduler == nullptr");
0478 }
0479 else {
0480 auto counterMap = fpEventScheduler->GetCounterMap();
0481 if (counterMap.empty()) {
0482 G4Exception("No counter", "Scorer<Gvalues>::SaveMoleculeCounter()",
0483 JustWarning, "CounterMap is not used");
0484 return;
0485 }
0486 for (const auto& map_mol : counterMap) {
0487 auto time_mol = map_mol.first;
0488 for (auto it_mol : map_mol.second) {
0489 auto molecule = it_mol.first;
0490 if (molecule == fO2) {
0491 continue;
0492 }
0493 int n_mol = it_mol.second;
0494
0495 if (n_mol < 0) {
0496 G4ExceptionDescription errMsg;
0497 errMsg << "N molecules not valid < 0 " << " molecule : "
0498 << it_mol.first->GetName()
0499 << " N : " << n_mol << G4endl;
0500 G4Exception("", "N<0", FatalException, errMsg);
0501 }
0502
0503 if (fpScorer->fEdep > 0) {
0504 Gvalues::SpeciesInfo& molInfo =
0505 fpScorer->fSpeciesInfoPerTime[time_mol][molecule];
0506 molInfo.fNumber += n_mol;
0507 G4double gValue = (n_mol / (fpScorer->fEdep / eV)) * 100.;
0508
0509 molInfo.fG += gValue;
0510 molInfo.fG2 += gValue * gValue;
0511 }
0512 }
0513 }
0514
0515 auto boundingBox = fpChemistryWorld->GetChemistryBoundary();
0516 G4double V = boundingBox->Volume() / cm3;
0517 G4double eToGray = (0.001 * V * 6.242e+18);
0518 if (eToGray != 0) {
0519 G4double dose = (fpScorer->fEdep / eV) / eToGray;
0520 if (fpScorer->fPulseMax != 0) {
0521 G4double doseRate = dose / (fpScorer->fPulseMax / second);
0522 fpScorer->fTotalDose += dose;
0523 fpScorer->fTotalDose2 += dose * dose;
0524 fpScorer->fTotalDoseRate += doseRate;
0525 fpScorer->fTotalDoseRate2 += doseRate * doseRate;
0526 }
0527 }
0528 }
0529 }
0530
0531
0532
0533 template<>
0534 void Scorer<Gvalues>::EndOfEvent(G4HCofThisEvent*)
0535 {
0536 if (G4EventManager::GetEventManager()->GetConstCurrentEvent()->IsAborted()) {
0537 fpScorer->fEdep = 0.;
0538 fpEventScheduler->ResetCounter();
0539 return;
0540 }
0541
0542 SaveScavengerChange();
0543 SaveMoleculeCounter();
0544
0545 ++(fpScorer->fNEvent);
0546 fpScorer->fEdep = 0.;
0547
0548 fpEventScheduler->ResetCounter();
0549 }
0550
0551
0552
0553 template<>
0554 void Scorer<Gvalues>::AbsorbResultsFromWorkerScorer(G4VPrimitiveScorer* workerScorer)
0555 {
0556 auto right = dynamic_cast<Scorer<Gvalues>*>(dynamic_cast<G4VPrimitiveScorer*>(workerScorer));
0557
0558 if (right == nullptr) {
0559 return;
0560 }
0561 if (right == this) {
0562 return;
0563 }
0564 auto it_map1 = right->fpScorer->fSpeciesInfoPerTime.begin();
0565 auto end_map1 = right->fpScorer->fSpeciesInfoPerTime.end();
0566
0567 for (; it_map1 != end_map1; ++it_map1) {
0568 Gvalues::InnerSpeciesMap& map2 = it_map1->second;
0569 auto it_map2 = map2.begin();
0570 auto end_map2 = map2.end();
0571
0572 for (; it_map2 != end_map2; ++it_map2) {
0573 Gvalues::SpeciesInfo& molInfo =
0574 fpScorer->fSpeciesInfoPerTime[it_map1->first][it_map2->first];
0575 molInfo.fNumber += it_map2->second.fNumber;
0576 molInfo.fG += it_map2->second.fG;
0577 molInfo.fG2 += it_map2->second.fG2;
0578 }
0579 }
0580
0581
0582 fpScorer->fTotalDose += right->fpScorer->fTotalDose;
0583 fpScorer->fTotalDose2 += right->fpScorer->fTotalDose2;
0584 right->fpScorer->fTotalDose = 0;
0585 right->fpScorer->fTotalDose2 = 0.;
0586
0587
0588 fpScorer->fTotalDoseRate += right->fpScorer->fTotalDoseRate;
0589 fpScorer->fTotalDoseRate2 += right->fpScorer->fTotalDoseRate2;
0590 right->fpScorer->fTotalDoseRate = 0;
0591 right->fpScorer->fTotalDoseRate2 = 0.;
0592
0593 right->fpScorer->fSpeciesInfoPerTime.clear();
0594 fpScorer->fNEvent += right->fpScorer->fNEvent;
0595 right->fpScorer->fNEvent = 0;
0596 right->fpScorer->fEdep = 0.;
0597 }
0598
0599
0600
0601 template<>
0602 void Scorer<Gvalues>::OutputAndClear(const std::string& dose)
0603 {
0604 if (G4Threading::IsWorkerThread()) {
0605 return;
0606 }
0607 G4VAnalysisManager* analysisManager = G4AnalysisManager::Instance();
0608 if (analysisManager != nullptr) {
0609 this->fpScorer->WriteWithAnalysisManager(analysisManager, dose);
0610 }
0611 fpScorer->fNEvent = 0;
0612 fpScorer->fSpeciesInfoPerTime.clear();
0613 }
0614
0615
