Geant4Manager.cc

Go to the documentation of this file.

#include "Geant4Manager.h"

#include <G4RunManager.hh>
#include <G4UImanager.hh>
#include <G4ParticleTable.hh>
#include <G4VUserDetectorConstruction.hh>
#include <G4VUserPrimaryGeneratorAction.hh>
#include <G4VUserPhysicsList.hh>

#include <G4ParticleDefinition.hh>
#include <G4ProcessVector.hh>
#include <G4VisManager.hh>
#include <G4UImanager.hh>

#include "GlobalGeometry.h"
#include "GlobalPhysicsList.h"
#include "G4VPhysicsListCustomization.h"

#include <fwk/CentralConfig.h>
#include <fwk/RandomEngineRegistry.h>
#include <utl/ErrorLogger.h>

#include <utl/AugerException.h>
#include <tls/DefaultPhysicsList.h>
#include <tls/G4OutputHandler.h>

using namespace std;


namespace tls {

  Geant4Manager::Geant4Manager() :
    fRunManager(new G4RunManager()),
    fMasterPhysicsList(new GlobalPhysicsList()),
    fVisManager(nullptr),
    fPhysicsInitialized(false),
    fClosedModules(0),
    fVerboseLevel(0)
    //fCurrentCustomization
  {
    INFO("creating and initializing runmanager..");

    // Set CLHEP random engine to the framework-specified one
    CLHEP::HepRandom::setTheEngine(
      &fwk::RandomEngineRegistry::GetInstance().Get(fwk::RandomEngineRegistry::eDetector).GetEngine()
    );

    // send output to utl::ErrorLogger
    G4UImanager::GetUIpointer()->SetCoutDestination(new G4OutputHandler());

    // Create the default physics list and geometry
    GlobalGeometry* const globalGeometry = new GlobalGeometry();
    DefaultPhysicsList* const defaultPhysicsList = new DefaultPhysicsList(0);
    Geant4Customization defaultMode("Default", globalGeometry, defaultPhysicsList);
    AddCustomization(defaultMode);

    // Physics list needs to be set before creating the primary injector
    fRunManager->SetUserInitialization(fMasterPhysicsList);
    // Not setting the dummy geometry because materials are initialized and G4TankFastCerenkov fails
    // If it is not set, it magically works.
    fRunManager->SetUserInitialization(globalGeometry);
  }


  void
  Geant4Manager::SetDefaultPhysicsList(G4VUserPhysicsList* const physicsList)
  {
    if (fPhysicsInitialized)
      throw utl::AugerException("Cannot set default physics list after Geant4 run manager is initialized.");
    auto& cd = fCustomizations["Default"];
    cd.SetPhysicsList(physicsList);
    fMasterPhysicsList->RegisterPhysics("Default", cd.GetPhysicsList());
  }


  void
  Geant4Manager::InitPhysics()
  {
    if (!fPhysicsInitialized) {
      INFO("Initializing physics...");
      fRunManager->Initialize();

      // Additional processes (those in addition to DefaultPhysicsList) cannot be disabled while in
      // G4State_PreInit or G4State_Init, so we have to do it here. We call the Inactivate-methods
      // to restore the default configuration of active processes
      for (auto& c : fCustomizations) {
        G4VPhysicsListCustomization* const custom = c.second.GetPhysicsListCustomization();
        if (custom)
          custom->InactivateCustomProcesses();
      }

      fPhysicsInitialized = true;
    }
  }


  void
  Geant4Manager::NotifyDelete()
  {
    Reset();
    ++fClosedModules;
    if (fClosedModules + 1 >= fCustomizations.size()) {
      fRunManager = G4RunManager::GetRunManager();
      if (fRunManager) {
        INFO("deleting G4RunManager..");
        delete fRunManager;
        fRunManager = nullptr;
      } else
        WARNING("RunManger was already deleted at an earlier stage!");

      if (fVisManager) {
        INFO("deleting G4VisManager..");
        delete fVisManager;
        fVisManager = nullptr;
      }
      if (fClosedModules > fCustomizations.size())
        ERROR("The use of Geant4Manager seems inconsistent! More Modules ask for deletion than initially registered!");
    } else {
      ostringstream msg;
      msg << fClosedModules << " < " << fCustomizations.size() << ", not deleting yet";
      INFO(msg);
    }
  }


  void
  Geant4Manager::AddVisManager(G4VisManager* const visManager)
  {
    if (fVisManager)
      throw utl::AugerException("Trying to register a second instance of G4VisManager. "
                                "G4 should have already failed at this point..");

    fVisManager = visManager;
  }


  void
  Geant4Manager::AddCustomization(Geant4Customization& custom)
  {
    fCustomizations[custom.GetName()] = custom;
    fMasterPhysicsList->RegisterPhysics(custom.GetName(), custom.GetPhysicsList());
    if (custom.GetDetectorConstruction())
      custom.GetDetectorConstruction()->Construct();
  }


  void
  Geant4Manager::Customize(const std::string& name)
  {
    if (fCurrentCustomization == name)
      return;

    const auto it = fCustomizations.find(name);
    if (it == fCustomizations.end()) {
      ostringstream msg;
      msg << "Unknown Geant4 customization: " << name;
      throw utl::AugerException(msg.str());
    }

    cout << "Customizing " << name << endl;
    Reset();
    G4VUserDetectorConstruction* const detectorConstruction = it->second.GetDetectorConstruction();

    fRunManager->SetUserInitialization(detectorConstruction);

    if (!fPhysicsInitialized) {
      InitPhysics();
    } else {
      INFO("Updating geometry...");
      fRunManager->DefineWorldVolume(detectorConstruction->Construct(), true);
    }

    INFO("Updating processes...");
    G4VPhysicsListCustomization* const physicsListCustomization = it->second.GetPhysicsListCustomization();
    if (physicsListCustomization) {
      physicsListCustomization->SetCustomCuts();
      if (physicsListCustomization->ActivateCustomProcesses()) {
        fRunManager->PhysicsHasBeenModified();
      }
    }

    // if (it->second.GetPrimaryGenerator())
    fRunManager->SetUserAction(it->second.GetPrimaryGenerator());

    fRunManager->SetUserAction(it->second.GetStackingAction());
    fRunManager->SetUserAction(it->second.GetTrackingAction());
    fRunManager->SetUserAction(it->second.GetSteppingAction());
    fRunManager->SetUserAction(it->second.GetEventAction());
    fRunManager->SetUserAction(it->second.GetRunAction());

    fCurrentCustomization = it->first;

    if (fVerboseLevel > 0)
      DumpProcesses();
  }


  void
  Geant4Manager::Reset()
  {
    // geometry is not reset.
    if (!fCurrentCustomization.empty()) {
      INFO("Setting default geometry...");
      G4VUserDetectorConstruction* const detectorConstruction = fCustomizations["Default"].GetDetectorConstruction();

      fRunManager->SetUserInitialization(detectorConstruction);
      fRunManager->DefineWorldVolume(detectorConstruction->Construct(), true);

      G4VPhysicsListCustomization* const physicsListCustomization = fCustomizations[fCurrentCustomization].GetPhysicsListCustomization();
      if (physicsListCustomization && physicsListCustomization->InactivateCustomProcesses())
        fRunManager->PhysicsHasBeenModified();
      fMasterPhysicsList->SetCuts();
    }

    fRunManager->SetUserAction(static_cast<G4VUserPrimaryGeneratorAction*>(nullptr));
    fRunManager->SetUserAction(static_cast<G4UserStackingAction*>(nullptr));
    fRunManager->SetUserAction(static_cast<G4UserTrackingAction*>(nullptr));
    fRunManager->SetUserAction(static_cast<G4UserSteppingAction*>(nullptr));
    fRunManager->SetUserAction(static_cast<G4UserEventAction*>(nullptr));
    fRunManager->SetUserAction(static_cast<G4UserRunAction*>(nullptr));
  }


  void
  Geant4Manager::DumpProcesses()
  {
    INFO("dumping process info for all particles--");
    auto& partIt = *G4ParticleTable::GetParticleTable()->GetIterator();
    for (partIt.reset(); partIt(); ) {
      auto& particle = *partIt.value();
      cout << "particle  " << particle.GetParticleName() << endl;
      const auto procMan = particle.GetProcessManager();
      if (!procMan)
        ERROR("ProcessManager not found!");
      else {
        auto& procList = *procMan->GetProcessList();
        for (unsigned int j = 0, n = procList.size(); j < n; ++j)
          G4cerr << "process " << procList[j]->GetProcessName() << ' '
                 << (procMan->GetProcessActivation(procList[j]) ? "active" : "inactive") << G4endl;
      }
    }
  }


  void
  Geant4Manager::SetVerbosity(const int verbosity)
  {
    fVerboseLevel = verbosity;

    auto& partIt = *G4ParticleTable::GetParticleTable()->GetIterator();
    std::ostringstream msg;
    for (partIt.reset(); partIt(); ) {
      auto& particle = *partIt.value();
      auto& procMan = *particle.GetProcessManager();
      auto& proc = *procMan.GetProcessList();
      for (int i = 0, n = procMan.GetProcessListLength(); i < n; ++i) {
        proc[i]->SetVerboseLevel(0);
        msg << "process: " << proc[i]->GetProcessName() << " for "
            << particle.GetParticleName() << ": " << proc[i]->GetVerboseLevel() << '\n';
      }
    }
    INFO(msg);
  }

}