//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
/// \file Run.cc
/// \brief Implementation of the Run class

#include "Run.hh"

#include "DetectorConstruction.hh"
#include "HistoManager.hh"
#include "PrimaryGeneratorAction.hh"

#include "G4SystemOfUnits.hh"
#include "G4UnitsTable.hh"

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

Run::Run(DetectorConstruction* det) : fDetector(det) {}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void Run::SetPrimary(G4ParticleDefinition* particle, G4double energy)
{
  fParticle = particle;
  fEkin = energy;
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void Run::CountProcesses(const G4VProcess* process)
{
  if (process == nullptr) return;
  G4String procName = process->GetProcessName();
  std::map<G4String, G4int>::iterator it = fProcCounter.find(procName);
  if (it == fProcCounter.end()) {
    fProcCounter[procName] = 1;
  }
  else {
    fProcCounter[procName]++;
  }
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void Run::ParticleCount(G4String name, G4double Ekin)
{
  std::map<G4String, ParticleData>::iterator it = fParticleDataMap.find(name);
  if (it == fParticleDataMap.end()) {
    fParticleDataMap[name] = ParticleData(1, Ekin, Ekin, Ekin);
  }
  else {
    ParticleData& data = it->second;
    data.fCount++;
    data.fEmean += Ekin;
    // update min max
    G4double emin = data.fEmin;
    if (Ekin < emin) data.fEmin = Ekin;
    G4double emax = data.fEmax;
    if (Ekin > emax) data.fEmax = Ekin;
  }
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void Run::SumTrackLength(G4int nstep1, G4int nstep2, G4double trackl1, G4double trackl2,
                         G4double time1, G4double time2)
{
  fNbStep1 += nstep1;
  fNbStep2 += nstep2;
  fTrackLen1 += trackl1;
  fTrackLen2 += trackl2;
  fTime1 += time1;
  fTime2 += time2;
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void Run::Merge(const G4Run* run)
{
  const Run* localRun = static_cast<const Run*>(run);

  // primary particle info
  //
  fParticle = localRun->fParticle;
  fEkin = localRun->fEkin;

  // accumulate sums
  //
  fNbStep1 += localRun->fNbStep1;
  fNbStep2 += localRun->fNbStep2;
  fTrackLen1 += localRun->fTrackLen1;
  fTrackLen2 += localRun->fTrackLen2;
  fTime1 += localRun->fTime1;
  fTime2 += localRun->fTime2;

  // map: processes count
  std::map<G4String, G4int>::const_iterator itp;
  for (itp = localRun->fProcCounter.begin(); itp != localRun->fProcCounter.end(); ++itp) {
    G4String procName = itp->first;
    G4int localCount = itp->second;
    if (fProcCounter.find(procName) == fProcCounter.end()) {
      fProcCounter[procName] = localCount;
    }
    else {
      fProcCounter[procName] += localCount;
    }
  }

  // map: created particles count
  std::map<G4String, ParticleData>::const_iterator itn;
  for (itn = localRun->fParticleDataMap.begin(); itn != localRun->fParticleDataMap.end(); ++itn) {
    G4String name = itn->first;
    const ParticleData& localData = itn->second;
    if (fParticleDataMap.find(name) == fParticleDataMap.end()) {
      fParticleDataMap[name] =
        ParticleData(localData.fCount, localData.fEmean, localData.fEmin, localData.fEmax);
    }
    else {
      ParticleData& data = fParticleDataMap[name];
      data.fCount += localData.fCount;
      data.fEmean += localData.fEmean;
      G4double emin = localData.fEmin;
      if (emin < data.fEmin) data.fEmin = emin;
      G4double emax = localData.fEmax;
      if (emax > data.fEmax) data.fEmax = emax;
    }
  }

  G4Run::Merge(run);
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

void Run::EndOfRun()
{
  G4int prec = 5, wid = prec + 2;
  G4int dfprec = G4cout.precision(prec);

  // run condition
  //
  G4Material* material = fDetector->GetMaterial();
  G4double density = material->GetDensity();

  G4String Particle = fParticle->GetParticleName();
  G4cout << "\n The run is " << numberOfEvent << " " << Particle << " of "
         << G4BestUnit(fEkin, "Energy") << " through "
         << G4BestUnit(0.5 * (fDetector->GetSize()), "Length") << " of " << material->GetName()
         << " (density: " << G4BestUnit(density, "Volumic Mass") << ")" << G4endl;

  if (numberOfEvent == 0) {
    G4cout.precision(dfprec);
    return;
  }

  // frequency of processes
  //
  G4cout << "\n Process calls frequency :" << G4endl;
  G4int survive = 0;
  std::map<G4String, G4int>::iterator it;
  for (it = fProcCounter.begin(); it != fProcCounter.end(); it++) {
    G4String procName = it->first;
    G4int count = it->second;
    G4cout << "\t" << procName << "= " << count;
    if (procName == "Transportation") survive = count;
  }
  G4cout << G4endl;

  if (survive > 0) {
    G4cout << "\n Nb of incident particles surviving after "
           << G4BestUnit(0.5 * (fDetector->GetSize()), "Length") << " of "
           << fDetector->GetMaterial()->GetName() << " : " << survive << G4endl;
  }

  // total track length of incident neutron
  //
  G4cout << "\n Parcours of incident neutron:";

  G4double meanCollision1 = (G4double)fNbStep1 / numberOfEvent;
  G4double meanCollision2 = (G4double)fNbStep2 / numberOfEvent;
  G4double meanCollisTota = meanCollision1 + meanCollision2;

  G4cout << "\n   nb of collisions    E>1*eV= " << meanCollision1
         << "      E<1*eV= " << meanCollision2 << "       total= " << meanCollisTota;

  G4double meanTrackLen1 = fTrackLen1 / numberOfEvent;
  G4double meanTrackLen2 = fTrackLen2 / numberOfEvent;
  G4double meanTrackLtot = meanTrackLen1 + meanTrackLen2;

  G4cout << "\n   track length        E>1*eV= " << G4BestUnit(meanTrackLen1, "Length")
         << "  E<1*eV= " << G4BestUnit(meanTrackLen2, "Length")
         << "   total= " << G4BestUnit(meanTrackLtot, "Length");

  G4double meanTime1 = fTime1 / numberOfEvent;
  G4double meanTime2 = fTime2 / numberOfEvent;
  G4double meanTimeTo = meanTime1 + meanTime2;

  G4cout << "\n   time of flight      E>1*eV= " << G4BestUnit(meanTime1, "Time")
         << "  E<1*eV= " << G4BestUnit(meanTime2, "Time")
         << "   total= " << G4BestUnit(meanTimeTo, "Time") << G4endl;

  // particles count
  //
  G4cout << "\n List of generated particles:" << G4endl;

  std::map<G4String, ParticleData>::iterator itn;
  for (itn = fParticleDataMap.begin(); itn != fParticleDataMap.end(); itn++) {
    G4String name = itn->first;
    ParticleData data = itn->second;
    G4int count = data.fCount;
    G4double eMean = data.fEmean / count;
    G4double eMin = data.fEmin;
    G4double eMax = data.fEmax;

    G4cout << "  " << std::setw(13) << name << ": " << std::setw(7) << count
           << "  Emean = " << std::setw(wid) << G4BestUnit(eMean, "Energy") << "\t( "
           << G4BestUnit(eMin, "Energy") << " --> " << G4BestUnit(eMax, "Energy") << ")" << G4endl;
  }

  // normalize histograms
  ////G4AnalysisManager* analysisManager = G4AnalysisManager::Instance();
  ////G4double factor = 1./numberOfEvent;
  ////analysisManager->ScaleH1(3,factor);

  // remove all contents in fProcCounter, fCount
  fProcCounter.clear();
  fParticleDataMap.clear();

  // restore default format
  G4cout.precision(dfprec);
}

//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
