GGSMultiUserAction.cpp

Go to the documentation of this file.

/*
 * GGSMultiUserAction.cpp
 *
 *  Created on: 26 Oct 2020
 *      Author: Nicola Mori
 */

#include "montecarlo/mccore/GGSMultiUserAction.h"
#include "montecarlo/mccore/GGSRunManager.h"
#include "montecarlo/services/GGSRootFileService.h"

#include "G4RunManager.hh"

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

GGSMultiUserAction::GGSMultiUserAction()
    : GGSUserAction(), _messenger(this, "/GGS/userActions/", "User actions build messenger") {}

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

GGSMultiUserAction::~GGSMultiUserAction() {

  // Warning: this destructor will be called by ~G4RunManager, which runs after
  //          ~GGSRunManager. So at this stage the child GGSRunManager is no
  //          more available and thus the mother G4Manager must be referenced.
  // TODO: handle the destruction of the actions manager inside ~GGSRunManager, when
  //       the GGSRunManager interface has been properly extended to handle the
  //       actions manager.
  G4RunManager *runManager = G4RunManager::GetRunManager();
  if (runManager->GetUserSteppingAction() == this)
    runManager->SetUserAction((G4UserSteppingAction *)0);
  if (runManager->GetUserTrackingAction() == this)
    runManager->SetUserAction((G4UserTrackingAction *)0);
  if (runManager->GetUserEventAction() == this)
    runManager->SetUserAction((G4UserEventAction *)0);
  if (runManager->GetUserRunAction() == this)
    runManager->SetUserAction((G4UserRunAction *)0);
  if (runManager->GetUserStackingAction() == this)
    runManager->SetUserAction((G4UserStackingAction *)0);
}

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

void GGSMultiUserAction::AddAction(std::unique_ptr<GGSUserAction> &&userAction) {
  if (userAction) {
    _userActions.push_back(std::move(userAction));
    _userActions.back()->SetTrackingManagerPointer(fpTrackingManager);
  }
}

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

void GGSMultiUserAction::AddAction(std::unique_ptr<G4UserSteppingAction> &&steppingAction) {
  if (steppingAction) {
    _steppingActions.push_back(std::move(steppingAction));
  }
}

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

void GGSMultiUserAction::AddAction(std::unique_ptr<G4UserTrackingAction> &&trackingAction) {
  if (trackingAction) {
    _trackingActions.push_back(std::move(trackingAction));
    _trackingActions.back()->SetTrackingManagerPointer(fpTrackingManager);
  }
}

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

void GGSMultiUserAction::AddAction(std::unique_ptr<G4UserEventAction> &&eventAction) {
  if (eventAction) {
    _eventActions.push_back(std::move(eventAction));
  }
}

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

void GGSMultiUserAction::AddAction(std::unique_ptr<G4UserRunAction> &&runAction) {
  if (runAction) {
    _runActions.push_back(std::move(runAction));
  }
}

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

void GGSMultiUserAction::AddAction(std::unique_ptr<G4UserStackingAction> &&stackingAction) {
  if (stackingAction) {
    _stackingActions.push_back(std::move(stackingAction));
  }
}

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

void GGSMultiUserAction::UserSteppingAction(const G4Step *step) {

  // Call routine for general actions
  for (unsigned int i = 0; i < _userActions.size(); i++)
    _userActions[i]->UserSteppingAction(step);

  // Call routine for stepping actions
  for (unsigned int i = 0; i < _steppingActions.size(); i++)
    _steppingActions[i]->UserSteppingAction(step);
}

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

void GGSMultiUserAction::PreUserTrackingAction(const G4Track *track) {

  // Call routine for general actions
  for (unsigned int i = 0; i < _userActions.size(); i++)
    _userActions[i]->PreUserTrackingAction(track);

  // Call routine for tracking actions
  for (unsigned int i = 0; i < _trackingActions.size(); i++)
    _trackingActions[i]->PreUserTrackingAction(track);
}

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

void GGSMultiUserAction::PostUserTrackingAction(const G4Track *track) {

  // Call routine for general actions
  for (unsigned int i = 0; i < _userActions.size(); i++)
    _userActions[i]->PostUserTrackingAction(track);

  // Call routine for tracking actions
  for (unsigned int i = 0; i < _trackingActions.size(); i++)
    _trackingActions[i]->PostUserTrackingAction(track);
}

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

void GGSMultiUserAction::BeginOfEventAction(const G4Event *event) {

  // Call routine for general actions
  for (unsigned int i = 0; i < _userActions.size(); i++)
    _userActions[i]->BeginOfEventAction(event);

  // Call routine for event actions
  for (unsigned int i = 0; i < _eventActions.size(); i++)
    _eventActions[i]->BeginOfEventAction(event);
}

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

void GGSMultiUserAction::EndOfEventAction(const G4Event *event) {

  GGSRunManagerExtensions &rmExt = dynamic_cast<GGSRunManagerExtensions &>(*(G4RunManager::GetRunManager()));
  if (!(rmExt.IsCurrentEventKilled())) {

    // Call routine for general actions
    for (unsigned int i = 0; i < _userActions.size(); i++)
      _userActions[i]->EndOfEventAction(event);

    // Call routine for event actions
    for (unsigned int i = 0; i < _eventActions.size(); i++)
      _eventActions[i]->EndOfEventAction(event);

    GGSRootFileService::GetInstance()._FillDefaultEventsTrees();
  }
}

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

void GGSMultiUserAction::BeginOfRunAction(const G4Run *run) {

  // Call routine for general actions
  for (unsigned int i = 0; i < _userActions.size(); i++)
    _userActions[i]->BeginOfRunAction(run);

  // Call routine for run actions
  for (unsigned int i = 0; i < _runActions.size(); i++)
    _runActions[i]->BeginOfRunAction(run);
}

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

void GGSMultiUserAction::EndOfRunAction(const G4Run *run) {

  // Call routine for general actions
  for (unsigned int i = 0; i < _userActions.size(); i++)
    _userActions[i]->EndOfRunAction(run);

  // Call routine for run actions
  for (unsigned int i = 0; i < _runActions.size(); i++)
    _runActions[i]->EndOfRunAction(run);
}

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

G4ClassificationOfNewTrack GGSMultiUserAction::ClassifyNewTrack(const G4Track *aTrack) {

  int classif, actionClassif;
  classif = -100;
  GGSUserAction *classifierUA = nullptr;
  G4UserStackingAction *classifierSA = nullptr;

  for (auto &actionPtr : _userActions) {
    actionClassif = actionPtr->ClassifyNewTrack(aTrack);
    if (actionClassif != -100) {
      if (actionClassif != classif && classif != -100) {
        G4ExceptionDescription ed;
        std::string classifierUAClassName = typeid(*classifierUA).name();
        auto *actionRawPtr = actionPtr.get(); // Call the unique_ptr method here to avoid a clang warning about possible
                                              // side effects if calling it inside typeid
        std::string thisUAClassName = typeid(*actionRawPtr).name();
        ed << "Classification of track " << aTrack->GetTrackID() << " from GGS action " << classifierUAClassName << " ("
           << classif << ") is different from classification from GGS action " << thisUAClassName << " ("
           << actionClassif << ")";
        G4Exception("GGSMultiUserAction::ClassifyNewTrack", "Clashing track classifications",
                    G4ExceptionSeverity::FatalException, ed);
      } else {
        classif = actionClassif;
        classifierUA = actionPtr.get();
      }
    }
  }
  for (auto &actionPtr : _stackingActions) {
    actionClassif = actionPtr->ClassifyNewTrack(aTrack);
    if (actionClassif != classif && classif != -100) {
      G4ExceptionDescription ed;
      std::string classifierActionType, classifierClassName;
      if (classifierUA != nullptr) {
        classifierActionType = "GGS";
        classifierClassName = typeid(*classifierUA).name();
      } else if (classifierSA != nullptr) {
        classifierActionType = "stacking";
        classifierClassName = typeid(*classifierSA).name();
      }
      auto *actionRawPtr = actionPtr.get(); // Call the unique_ptr method here to avoid a clang warning about possible
                                            // side effects if calling it inside typeid
      auto thisSAClassName = typeid(*actionRawPtr).name();
      ed << "Classification of track " << aTrack->GetTrackID() << " from " << classifierActionType << " action "
         << classifierClassName << " (" << classif << ") is different from classification from stacking action "
         << thisSAClassName << " (" << actionClassif << ")";
      G4Exception("GGSMultiUserAction::ClassifyNewTrack", "Clashing track classifications",
                  G4ExceptionSeverity::FatalException, ed);
    } else {
      classif = actionClassif;
      classifierSA = actionPtr.get();
    }
  }
  if (classif == -100) {
    return G4UserStackingAction::ClassifyNewTrack(aTrack);
  } else {
    return (G4ClassificationOfNewTrack)classif;
  }
}

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

void GGSMultiUserAction::NewStage() {
  for (unsigned int i = 0; i < _userActions.size(); i++) {
    _userActions[i]->NewStage();
  }
}

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

void GGSMultiUserAction::PrepareNewEvent() {

  for (unsigned int i = 0; i < _userActions.size(); i++) {
    _userActions[i]->PrepareNewEvent();
  }
}