#include "RunAction.h"

#include "DetectorConstruction.h"
#include "G4AccumulableManager.hh"
#include "G4LogicalVolume.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4Run.hh"
#include "G4RunManager.hh"
#include "G4SystemOfUnits.hh"
#include "G4UnitsTable.hh"
#include "PrimaryGeneratorAction.h"

RunAction::RunAction() {
    const G4double milligray = 1.e-3 * gray;
    const G4double microgray = 1.e-6 * gray;
    const G4double nanogray = 1.e-9 * gray;
    const G4double picogray = 1.e-12 * gray;

    new G4UnitDefinition("milligray", "mGy", "Dose", milligray);
    new G4UnitDefinition("microgray", "uGy", "Dose", microgray);
    new G4UnitDefinition("nanogray", "nGy", "Dose", nanogray);
    new G4UnitDefinition("picogray", "pGy", "Dose", picogray);

    G4AccumulableManager* accumulableManager = G4AccumulableManager::Instance();
    accumulableManager->RegisterAccumulable(fEdep);
    accumulableManager->RegisterAccumulable(fEdep2);
}

RunAction::~RunAction() {}

void RunAction::BeginOfRunAction(const G4Run*) {
    G4RunManager::GetRunManager()->SetRandomNumberStore(false);

    G4AccumulableManager* accumulableManager = G4AccumulableManager::Instance();
    accumulableManager->Reset();
}

void RunAction::EndOfRunAction(const G4Run* run) {
    G4int nofEvents = run->GetNumberOfEvent();
    if (nofEvents == 0) return;

    G4AccumulableManager* accumulableManager = G4AccumulableManager::Instance();
    accumulableManager->Merge();

    G4double edep = fEdep.GetValue();
    G4double edep2 = fEdep2.GetValue();
    G4double rms = edep2 - edep * edep / nofEvents;
    if (rms > 0.)
        rms = std::sqrt(rms);
    else
        rms = 0.;

    const DetectorConstruction* detConstruction =
        static_cast<const DetectorConstruction*>(G4RunManager::GetRunManager()->GetUserDetectorConstruction());
    G4double mass = detConstruction->GetScoringVolume()->GetMass();
    G4double dose = edep / mass;
    G4double rmsDose = rms / mass;

    G4String runCondition;
    const PrimaryGeneratorAction* generatorAction =
        static_cast<const PrimaryGeneratorAction*>(G4RunManager::GetRunManager()->GetUserPrimaryGeneratorAction());
    if (generatorAction) {
        const G4ParticleGun* particleGun = generatorAction->GetParticleGun();
        runCondition += particleGun->GetParticleDefinition()->GetParticleName();
        runCondition += " of ";
        G4double particleEnergy = particleGun->GetParticleEnergy();
        runCondition += G4BestUnit(particleEnergy, "Energy");
    }

    // Print
    if (IsMaster()) {
        G4cout << G4endl << "--------------------End of Global Run-----------------------";
    } else {
        G4cout << G4endl << "--------------------End of Local Run------------------------";
    }

    G4cout << G4endl << " The run consists of " << nofEvents << " " << runCondition << G4endl
           << " Cumulated dose per run, in scoring volume : " << G4BestUnit(dose, "Dose")
           << " rms = " << G4BestUnit(rmsDose, "Dose") << G4endl
           << "------------------------------------------------------------" << G4endl << G4endl;
}

void RunAction::AddEdep(G4double edep) {
    // 累加沉积能量
    fEdep += edep;
    fEdep2 += edep * edep;
}