GGSPenny.cpp

/*
 * GGSPenny.cpp
 *
 *  Created on: 2010-09-29
 *     Authors: Emiliano Mocchiutti and Cecilia Pizzolotto
 */
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// C++ and STL headers
#include <sys/stat.h>
#include <vector>

// ROOT headers
#include "TROOT.h"

// GEANT4 headers
#include "G4Version.hh"
#include "G4UImanager.hh"
#include "Randomize.hh"
#include "G4PhysListFactory.hh"

#ifdef G4VIS_USE
#include "G4VisExecutive.hh"
#endif

#ifdef G4UI_USE
#include "G4UIExecutive.hh"
#endif

// GGS headers
#include "GGSVersion.h" //Automatically generated by the CMake configuration system
#include "utils/GGSSmartLog.h"
#include "utils/GGSInputParser.h"
#include "montecarlo/GGSRunManager.h"
#include "montecarlo/GGSDetectorConstruction.h"
#include "montecarlo/services/GGSRootFileService.h"
#include "montecarlo/useractions/manager/GGSUserActionsManager.h"
#include "montecarlo/useractions/GGSStatusDumpAction.h"
#include "montecarlo/pluginmanagers/GGSMCPluginManager.h"
#include "montecarlo/generators/manager/GGSGeneratorActionsManager.h"
#ifdef CRMC
#include "montecarlo/physicslists/GGSCRMCPhysicsList.h"
#endif

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

void usage() {
  std::cout << "Usage: GGSPenny [options] \n";
  std::cout << "This is the GGS main MonteCarlo program\n\n";
  std::cout << "Run type selection\n";
  std::cout << "------------------\n";
  std::cout << " -X, --interactive                interactive mode [default: false]\n\n";
  std::cout << " -d, --data-card FILE             data card filename [default: not set]\n\n";
  std::cout << "If only -d is specified  the program will run in batch mode.\n";
  std::cout << "If both options are specified, the datacard will be processed before entering the interactive mode.\n\n";
  std::cout << "Configuration options\n";
  std::cout << "---------------------\n";
  std::cout << " -g, --geometry FILE              full path and name of the geometry; can be a .so or a .gdml.\n";
  std::cout << " -gd, --geo-data-card FILE        data card filename for geometry configuration [default: not set]\n\n";
  std::cout << " -pl, --physics-list NAME         physics list (standard list name or full path of physics list .so library) [default: QGSP_BERT]\n\n";
  std::cout << " -pd, --physlist-data-card FILE   data card filename for physics list configuration [default: not set]\n\n";
  std::cout << " -ap, --action-plugin FILE        full path and name of the plugin user and generator action library\n";
  std::cout << "                                  May be repeated to load many libraries: -ap libUserAction.so -ap libGeneratorAction.so\n\n";
  std::cout << " -ro, --root-output-file FILE     default ROOT output filename (may be overridden in datacard for each action)\n\n";
  std::cout << " -os, --output-suffix SUFFIX      output file suffix [default: " "]\n\n";
  std::cout << " --seed1 INT                      first random seed [default: 1]\n\n"; // do not put default 0!
  std::cout << " --seed2 INT                      second random seed [default: 2]\n\n";
  std::cout << " -s, --input-seed-file FILE       file containing input random seeds [default: not set]\n\n";
  std::cout << "Configuration options can either be given as command line parameters or placed in an input file.\n";
  std::cout << "File syntax is the same as the above specified commands, one command per line. Set the input file via command line as:\n\n";
  std::cout << " -i, --input-file FILE            file containing input arguments [default: not set]\n\n";
  std::cout << "Miscellaneous\n";
  std::cout << "-------------\n";
  std::cout << " -v, --verbose                    be verbose [default: false]\n\n";
  std::cout << " -V, --version                    displays software version and exit\n\n";
  std::cout << " -h, --help                       display this help and exit\n\n";
  std::cout << "\nTo run GGSPenny either the -d (data card) or the -X (interactive) option MUST be set!\n";
  std::cout << "Report bugs to: mori@fi.infn.it \n";
}

void GGSPennyVersion() {
  std::cout << "GGSPenny simulation software\n";
  std::cout << "Using GGS " << GGSVERSION << std::endl;
}

namespace GGSPenny {
G4String rootOutputFile = "";
G4String outputSuffix = "";
G4String dataCard = "";
G4String geoDataCard = "";
G4String physListDataCard = "";
G4String inputFile = "";
G4String inputSeedFile = "";
G4String geometry = "";
G4String physicsListName = "FTFP_BERT";
std::vector<G4String> actionPluginFiles;
G4bool interactiveMode = false;
G4long seed1 = 1;
G4long seed2 = 2;
}
using namespace GGSPenny;

void DumpGlobals() {
  std::cout << "==============> MonteCarlo globals used for this run <===============" << std::endl;
  std::cout << "dataCard        : " << dataCard.c_str() << std::endl;
  std::cout << "geometry        : " << geometry.c_str() << std::endl;
  std::cout << "geoDataCard     : " << geoDataCard.c_str() << std::endl;
  std::cout << "physicsListName : " << physicsListName.c_str() << std::endl;
  std::cout << "physListDataCard: " << physListDataCard.c_str() << std::endl;
  std::cout << "rootOutputFile  : " << rootOutputFile.c_str() << std::endl;
  std::cout << "outputSuffix    : " << outputSuffix.c_str() << std::endl;
  std::cout << "inputSeedFile   : " << inputSeedFile.c_str() << std::endl;
  std::cout << "seed1           : " << seed1 << std::endl;
  std::cout << "seed2           : " << seed2 << std::endl;
  std::cout << "inputFile       : " << inputFile.c_str() << std::endl;
  std::cout << "interactiveMode : " << interactiveMode << std::endl;
  std::cout << "======================================================================" << std::endl;
}

int HandleInputPar(int argc, char **argv) {
  static const std::string routineName("HandleInputPar");
  // Set verbose level to print warnings about unrecognized options
  GGSSmartLog::verboseLevel = GGSSmartLog::WARNING;
  int vLevel = GGSSmartLog::INFO;
  if (argc > 1) {
    int i = 1;
    while (i < argc) {
      if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
        usage();
        return 1;
      }
      // -----------------------------------------------------//
      if (!strcmp(argv[i], "-V") || !strcmp(argv[i], "--version")) {
        GGSPennyVersion();
        return 1;
      }
      // -----------------------------------------------------//
      if (!strcmp(argv[i], "--")) {
        return 0;
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--data-card")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        dataCard = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-gd") || !strcmp(argv[i], "--geo-data-card")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        geoDataCard = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-g") || !strcmp(argv[i], "--geometry")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        geometry = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-pl") || !strcmp(argv[i], "--physics-list")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        physicsListName = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-pd") || !strcmp(argv[i], "--physlist-data-card")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        physListDataCard = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-ap") || !strcmp(argv[i], "--action-plugin")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        actionPluginFiles.push_back(G4String(argv[i]));
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-X") || !strcmp(argv[i], "--interactive")) {
        interactiveMode = true;
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-ro") || !strcmp(argv[i], "--root-output-file")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        rootOutputFile = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-os") || !strcmp(argv[i], "--output-suffix")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        outputSuffix = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-i") || !strcmp(argv[i], "--input-file")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        inputFile = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-s") || !strcmp(argv[i], "--input-seed-file")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        inputSeedFile = argv[i];
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "--seed1")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        seed1 = atoi(argv[i]);
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "--seed2")) {
        if (++i >= argc) {
          usage();
          return 1;
        }
        seed2 = atoi(argv[i]);
      }
      // -----------------------------------------------------//
      else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--verbose")) {
        std::string vLevStr(argv[++i]);
        if (vLevStr == "error")
          vLevel = GGSSmartLog::ERROR;
        else if (vLevStr == "warning")
          vLevel = GGSSmartLog::WARNING;
        else if (vLevStr == "normal" || vLevStr == "info")
          vLevel = GGSSmartLog::INFO;
        else if (vLevStr == "debug")
          vLevel = GGSSmartLog::DEBUG;
        else if (vLevStr == "deepdeb")
          vLevel = GGSSmartLog::DEEPDEB;
        else {
          COUT(WARNING) << "Unrecognized verbosity level: " << vLevStr << ". Ignoring." << ENDL;
        }
      }
      // -----------------------------------------------------//
      else {
        COUT(WARNING)<< "Unidentified input argument \"" << argv[i] << "\". Ignoring." << std::endl;
      }
      i++;
    }
  }
  else {
    usage();
    return 1;
  }
  GGSSmartLog::verboseLevel = vLevel;
  return 0;
}

int main(int argc, char** argv) {

  static const std::string routineName("GGSPenny");

  if (HandleInputPar(argc, argv))
    return 0;

  GGSPennyVersion();

  int nPar = 0;
  char *cfileArgv[1000];
  if (strcmp(inputFile.c_str(), "")) {
    std::string mych[1000];
    GGSInputParser::GetInstance().ReadInput(inputFile, &nPar, (std::string*) mych);
    if (nPar > 1) {
      int i = 0;
      while (i < nPar - 1) {
        cfileArgv[i] = new char[(mych[i]).length()];
        strcpy(cfileArgv[i], (mych[i]).c_str());
        i++;
      }
      if (HandleInputPar(nPar - 1, cfileArgv))
        return 0;
    }
  }
  else {
    if (argc > 1) {
      nPar = argc;
      int i = 0;
      while (i < nPar) {
        cfileArgv[i] = new char[1000];
        cfileArgv[i] = (argv[i]);
        i++;
      }
    }
  }
  if (!strcmp(dataCard.c_str(), "") && !interactiveMode) {
    usage();
    return 1;
  }

  if (geometry == "") {
    COUT(ERROR) << "No geometry provided. Exit." << ENDL;
    return 1;
  }

  // print on the screen input to this run
  DumpGlobals();

  // Construct the default run manager
  //
  COUT(DEBUG) << "Create the run manager." << ENDL;
  GGSRunManager * runManager = new GGSRunManager;

  // Set mandatory initialization classes
  COUT(DEBUG) << "Create the detector." << ENDL;
  GGSDetectorConstruction* detector = NULL;
  if (geometry.length() > 4 && geometry.substr(geometry.length() - 5) == ".gdml") {
    detector = new GGSDetectorConstruction(geometry);
  }
  else {
    detector = new GGSDetectorConstruction(geometry, geoDataCard);
  }
  runManager->SetUserInitialization(detector);

  G4VUserPhysicsList *physicsList = nullptr;
  // Try to create reference physics list
  G4PhysListFactory *physListFactory = new G4PhysListFactory;
  if (physListFactory->IsReferencePhysList(physicsListName)) {
    physicsList = physListFactory->GetReferencePhysList(physicsListName);
  }
  // Try to create standard GGS physics lists
  if (physicsList == nullptr) {
#ifdef CRMC
    if (physicsListName == "GGSCRMC") {
      physicsList = new GGSCRMCPhysicsList;
    }
#endif
  }
  // Try to create user-defined physics list
  if (physicsList == nullptr) {
    // Try to load user defined list
    physicsList = GGSMCPluginManager::GetInstance().LoadPhysicsListPlugin(physicsListName);
    if (physicsList == NULL) {
      COUT(WARNING) << "User physics list has NOT been loaded. Fall back to standard list." << ENDL;
    }
  }
  // Build standard list if no list have been selected or library loading wasn't successful
  if (physicsList == NULL) {
    COUT(INFO) << "Load standard physics list: FTFP_BERT." << ENDL;
    physicsListName = "FTFP_BERT";
    physicsList = physListFactory->GetReferencePhysList(physicsListName);
  }

  runManager->SetUserInitialization(physicsList);

  // Creates the generator actions manager
  GGSGeneratorActionsManager::GetInstance();

  // Set user actions manager
  COUT(DEBUG) << "Initialize the user actions manager." << ENDL;
  GGSUserActionsManager *actionsManager = GGSUserActionsManager::GetInstance();
  runManager->SetUserAction((G4UserSteppingAction*) actionsManager);
  runManager->SetUserAction((G4UserTrackingAction*) actionsManager);
  runManager->SetUserAction((G4UserEventAction*) actionsManager);
  runManager->SetUserAction((G4UserRunAction*) actionsManager);
  runManager->SetUserAction((G4UserStackingAction*) actionsManager);

  // Add status dump
  actionsManager->AddAction(new GGSStatusDumpAction);

  // Load user and generator actions plugin libraries
  for (unsigned int i = 0; i < actionPluginFiles.size(); i++)
    GGSMCPluginManager::GetInstance().LoadPlugin(actionPluginFiles[i]);

  // Set default name, suffix of ROOT files
  COUT(DEBUG) << "Initialize output." << ENDL;
  if (rootOutputFile != "")
    GGSRootFileService::GetInstance().SetDefaultFileBase(rootOutputFile.data());
  GGSRootFileService::GetInstance().SetSuffix(outputSuffix);
  // Set the MC info to be saved on ROOT files
  GGSTSimInfo simInfo;
  simInfo.SetName("GGSSimInfo");
  simInfo.G4Version = G4Version.data();
  simInfo.GGSVersion = GGSVERSION;
  simInfo.dataCard = dataCard.data();
  simInfo.geometry = geometry.data();
  simInfo.geoDataCard = geoDataCard.data();
  simInfo.physicsList = physicsListName.data();
  simInfo.seed1 = seed1;
  simInfo.seed2 = seed2;
  GGSRootFileService::GetInstance().SetSimInfo(simInfo);

  // Get the pointer to the User Interface manager
  G4UImanager* UImanager = G4UImanager::GetUIpointer();

  // Execute physics list data card
  if (physListDataCard != "") {
    COUT(DEBUG) << "Execute physics list data card" << ENDL;
    std::ifstream fileChecker(physListDataCard);
    if (!fileChecker.good()) {
      COUT(ERROR)
      << "Physics list data card file " << physListDataCard << " not found." << ENDL;
      return 1;
    }
    UImanager->ExecuteMacroFile(physListDataCard);
  }

  // Initialize G4 kernel
  COUT(DEBUG) << "Initialize run manager." << ENDL;
  try {
    runManager->Initialize();
  } catch (std::runtime_error&) {
    COUT(ERROR) << "Impossible to set up the geometry. Exit." << ENDL;
    delete runManager;
    delete physListFactory;
    return 1;
  }

#ifdef G4VIS_USE
  // Create the ROOT cling interpreter before opening the graphical UI. This is needed to avoid
  // loading LLVM symbols (e.g. when using open source Radeon driver for AMD chips) before
  // creating the interpreter, which would cause a segmentation fault.
  gROOT->GetInterpreter();
  // Initialize visualization
  //
  G4VisManager* visManager = new G4VisExecutive;
  visManager->Initialize();
#endif

  COUT(DEBUG) << "Initialize random generator." << ENDL;
  // Choose the Random engine
  CLHEP::HepRandom::setTheEngine(new CLHEP::RanecuEngine);
  G4long seeds[2] = { seed1, seed2 };
  CLHEP::HepRandom::setTheSeeds(seeds, 0); // changing the index does not change random generation
  if (strcmp(inputSeedFile.c_str(), "")) {
    G4String command = "/random/resetEngineFrom ";
    UImanager->ApplyCommand(command + inputSeedFile);
  }
  CLHEP::HepRandom::showEngineStatus();

  if (dataCard != "") { // batch or configured interactive mode
    if (!interactiveMode)
      COUT(DEBUG) << "Start batch mode." << ENDL;
      G4String command = "/control/execute ";
      G4String fileName = dataCard;
      UImanager->ApplyCommand(command + fileName);
    }
  if (interactiveMode) { // interactive mode : define UI session
    if (dataCard != "") {
      COUT(DEBUG) << "Start configured interactive mode." << ENDL;
    }
    else {
      COUT(DEBUG) << "Start interactive mode." << ENDL;
    }

#ifdef G4UI_USE
    G4UIExecutive* ui = new G4UIExecutive(nPar, cfileArgv);
    struct stat st;
#ifdef G4VIS_USE
    //TODO: fix visualization macros
    if (stat("vis.mac", &st) == 0)
    UImanager->ApplyCommand("/control/execute vis.mac");
#endif
    if (ui->IsGUI()) {
      if (stat("visTutor/gui.mac", &st) == 0)
      UImanager->ApplyCommand("/control/execute visTutor/gui.mac");
    }
    ui->SessionStart();
    delete ui;
#endif
  }

  COUT(DEBUG) << "Job termination." << ENDL;

  // Job termination
  // Free the store: user actions, physics_list and detector_description are
  //                 owned and deleted by the run manager, so they should not
  //                 be deleted in the main() program !
#ifdef G4VIS_USE
  delete visManager;
#endif
  delete runManager;

  delete physListFactory;

  return 0;
}

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