NPOptionManager.cxx

; /*****************************************************************************
   * Copyright (C) 2009-2016   this file is part of the NPTool Project         *
   *                                                                           *
   * For the licensing terms see $NPTOOL/Licence/NPTool_Licence                *
   * For the list of contributors see $NPTOOL/Licence/Contributors             *
   *****************************************************************************/

/*****************************************************************************
 * Original Author: A. MATTA  contact address: matta@lpccaen.in2p3.fr        *
 *                                                                           *
 * Creation Date  : 21/07/09                                                 *
 * Last update    :                                                          *
 *---------------------------------------------------------------------------*
 * Decription: This class is a singleton class which deals with input        *
 * arguments of the different NPTool programm (NPS and NPA)                  *
 *---------------------------------------------------------------------------*
 * Comment: The singleton form allow users to call the object from anywhere  *
 * in the code                                                               *
 *                                                                           *
 *                                                                           *
 *****************************************************************************/

#include "NPOptionManager.h"
#include "NPCore.h"
#include "NPInputParser.h"
#include "NPLibVersion.h"
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <sys/types.h>
#include <unistd.h>
#include <vector>

NPOptionManager* NPOptionManager::instance = 0;
////////////////////////////////////////////////////////////////////////////////
NPOptionManager* NPOptionManager::getInstance(int argc, char** argv) {
  if (instance == 0)
    instance = new NPOptionManager(argc, argv);

  return instance;
}

////////////////////////////////////////////////////////////////////////////////
NPOptionManager* NPOptionManager::getInstance(std::string arg) {

  if (instance == 0)
    instance = new NPOptionManager(arg);

  return instance;
}

////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::ReadProjectConfigFile() {
  // check if the file exist
  std::ifstream ProjectFile;
  ProjectFile.open("./project.config");

  if (ProjectFile.is_open()) {
    std::cout << "///// Loading Project Configuration: " << std::endl;
    ProjectFile.close();
    NPL::InputParser parser("./project.config");
    std::vector<NPL::InputBlock*> blocks = parser.GetAllBlocksWithToken("Project");
    unsigned int size = blocks.size();
    for (unsigned int i = 0; i < size; i++) {

      if (blocks[i]->HasToken("AnalysisOutput"))
        m_AnalysisOutputPath = blocks[i]->GetString("AnalysisOutput");

      if (blocks[i]->HasToken("SimulationOutput"))
        m_SimulationOutputPath = blocks[i]->GetString("SimulationOutput");

      if (blocks[i]->HasToken("EnergyLoss"))
        m_EnergyLossPath = blocks[i]->GetString("EnergyLoss");
    }
  }

  // else use the standard config
  else {

    std::cout << "///// No Project Configuration: " << std::endl;
    std::string Path = getenv("NPTOOL");
    m_AnalysisOutputPath = Path + "/Outputs/Analysis/";
    m_SimulationOutputPath = Path + "/Outputs/Simulation/";
    m_EnergyLossPath = Path + "/Inputs/EnergyLoss/";
    std::cout << "AnalysisOutput= " << m_AnalysisOutputPath << std::endl;
    std::cout << "SimulationOutput= " << m_SimulationOutputPath << std::endl;
    std::cout << "EnergyLoss= " << m_EnergyLossPath << std::endl;
  }
}

////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::ReadTheInputArgument(int argc, char** argv) {
  if (argc == 1)
    DisplayHelp();

  // Default Setting
  fDefaultReactionFileName = "defaultReaction.reaction";
  fDefaultDetectorFileName = "defaultDetector.detector";
  fDefaultOutputFileName = "SimulatedTree.root";
  fDefaultOutputTreeName = "NPTool_Tree";
  fDefaultRunToReadFileName = "defaultRunToTreat.txt";
  fDefaultCalibrationFileName = "defaultCalibration.txt";
  fDefaultG4MacroPath = "defaultG4MacroPath.txt";
  // Assigned values
  fReactionFileName = fDefaultReactionFileName;
  fDetectorFileName = fDefaultDetectorFileName;
  fOutputFileName = fDefaultOutputFileName;
  fOutputTreeName = fDefaultOutputTreeName;
  fRunToReadFileName = fDefaultRunToReadFileName;
  fCalibrationFileName = fDefaultCalibrationFileName;
  fG4MacroPath = fDefaultG4MacroPath;
  fIsSplit = false;
  fLastSimFile = false;
  fLastPhyFile = false;
  fLastResFile = false;
  fLastAnyFile = false;
  fIsAnalysis = false;
  fIsSimulation = false;
  fVerboseLevel = 1;
  fNumberOfEntryToAnalyse = -1;
  fFirstEntryToAnalyse = 0;
  fSpectraServerPort = 9092;
  fRandomSeed = -1;
  fRecordTrack = 0;
  fDisableAllBranchOption = false;
  fInputPhysicalTreeOption = false;
  fGenerateHistoOption = false;
  fCircularTree = false;
  fOnline = false;
  fG4BatchMode = false;
#ifdef __linux__
  fSharedLibExtension = ".so";
#endif

#ifdef __FreeBSD__
  fSharedLibExtension = ".so";
#endif

#ifdef __APPLE__
  fSharedLibExtension = ".dylib";
#endif

  for (int i = 1; i < argc; i++) {
    std::string argument = argv[i];
    if (argument == "-H" || argument == "-h" || argument == "--help")
      DisplayHelp();

    else if (argument == "--event-generator" && argc >= i + 1)
      fReactionFileName = argv[++i];

    else if (argument == "-E" && argc >= i + 1)
      fReactionFileName = argv[++i];

    else if (argument == "--detector" && argc >= i + 1)
      fDetectorFileName = argv[++i];

    else if (argument == "-D" && argc >= i + 1)
      fDetectorFileName = argv[++i];

    else if (argument == "--output" && argc >= i + 1)
      fOutputFileName = argv[++i];

    else if (argument == "-O" && argc >= i + 1)
      fOutputFileName = argv[++i];

    else if (argument == "--tree-name" && argc >= i + 1)
      fOutputTreeName = argv[++i];

    else if (argument == "--run" && argc >= i + 1)
      fRunToReadFileName = argv[++i];

    else if (argument == "-R" && argc >= i + 1)
      fRunToReadFileName = argv[++i];

    else if (argument == "-T" && argc >= i + 2) {
      std::string file = argv[++i];
      std::string tree = argv[++i];
      CreateRunToTreatFile(file, tree);
    }

    else if (argument == "--cal" && argc >= i + 1)
      fCalibrationFileName = argv[++i];

    else if (argument == "-S" && argc >= i + 1)
      fIsSplit = true;

    else if (argument == "-C" && argc >= i + 1)
      fCalibrationFileName = argv[++i];

    else if (argument == "-M" && argc >= i + 1)
      fG4MacroPath = argv[++i];

    else if (argument == "-B" && argc >= i + 1) {
      fG4MacroPath = argv[++i];
      fG4BatchMode = true;
    }

    else if (argument == "-V" && argc >= i + 1)
      fVerboseLevel = atoi(argv[++i]);

    else if (argument == "--verbose" && argc >= i + 1)
      fVerboseLevel = atoi(argv[++i]);

    else if (argument == "-P" && argc >= i + 1)
      fSpectraServerPort = atoi(argv[++i]);

    else if (argument == "--disable-branch")
      fDisableAllBranchOption = true;

    else if (argument == "--input-physical")
      fInputPhysicalTreeOption = true;

    else if (argument == "-IP")
      fInputPhysicalTreeOption = true;

    else if (argument == "-GH")
      fGenerateHistoOption = true;

    else if (argument == "-CH")
      fCheckHistoOption = true;

    else if (argument == "-check-histo")
      fCheckHistoOption = true;

    else if (argument == "--generate-histo")
      fGenerateHistoOption = true;

    else if (argument == "-L")
      fNumberOfEntryToAnalyse = atoi(argv[++i]);

    else if (argument == "--random-seed")
      fRandomSeed = atoi(argv[++i]);

    else if (argument == "--record-track")
      fRecordTrack = true;

    else if (argument == "-F")
      fFirstEntryToAnalyse = atoi(argv[++i]);

    else if (argument == "--last-sim")
      fLastSimFile = true;

    else if (argument == "--last-phy")
      fLastPhyFile = true;

    else if (argument == "--last-res")
      fLastResFile = true;

    else if (argument == "--last-any")
      fLastAnyFile = true;

    else if (argument == "--online") {
      fOnline = true;
      fGenerateHistoOption = true;
    }

    else if (argument == "--circular") {
      fCircularTree = true;
    }

    else if (argument == "--definition" && argc >= i + 1) {
      std::string def = argv[++i];
      fDefinition.insert(def);
    }

    else {
      SendErrorAndExit(argument.c_str());
    }
  }
  CheckArguments();
  if (argc != 0)
    DisplayVersion();
}
////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::CreateRunToTreatFile(std::string file, std::string tree) {

  char buffer[1024];
  sprintf(buffer, "/tmp/RunToTreat_%d.txt", getpid());
  std::ofstream run(buffer);
  if (!run.is_open())
    exit(1);

  run << "Tree " << tree << std::endl;
  run << " " << file << std::endl << std::endl;
  run.close();
  fRunToReadFileName = buffer;
}

////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::DisplayVersion() {
  if (fVerboseLevel > 0) {
    std::string line;
    line.resize(80, '*');
    std::cout << line << std::endl;
    std::cout << "***********************************  NPTool  ***********************************" << std::endl;
    std::cout << line << std::endl;
    std::cout << " NPLib version: nplib-" << NPL::version_major << "-" << NPL::version_minor << "-" << NPL::version_deta
              << std::endl;
    std::cout << " Copyright: NPTool Collaboration " << std::endl;
    std::cout << " Gitlab: https://gitlab.in2p3.fr/np/nptool" << std::endl;
    ;
    std::cout << line << std::endl;
  }
}
////////////////////////////////////////////////////////////////////////////////
NPOptionManager::NPOptionManager(int argc, char** argv) {
  // Start by reading the project configuration
  ReadProjectConfigFile();
  ReadTheInputArgument(argc, argv);
}
////////////////////////////////////////////////////////////////////////////////
NPOptionManager::NPOptionManager(std::string arg) {
  // add dummy string in front of arg string
  arg.insert(0, "ignore ");

  std::vector<char*> args;
  std::stringstream iss(arg);

  std::string token;
  while (iss >> token) {
    char* arg = new char[token.size() + 1];
    copy(token.begin(), token.end(), arg);
    arg[token.size()] = '\0';
    args.push_back(arg);
  }
  args.push_back(0);

  ReadTheInputArgument(args.size() - 1, &args[0]);

  /*  for(size_t i = 0; i < args.size(); i++)
      delete[] args[i];
      */
}
////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::CheckArguments() {
  CheckEventGenerator();
  CheckDetectorConfiguration();
  CheckG4Macro();
}

////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::CheckEventGenerator() {
  bool checkFile = true;

  // NPTool path
  std::string GlobalPath = getenv("NPTOOL");
  std::string StandardPath = GlobalPath + "/Inputs/EventGenerator/" + fReactionFileName;

  // ifstream to configfile
  std::ifstream ConfigFile;

  // test if config file is in local path
  ConfigFile.open(fReactionFileName.c_str());
  if (!ConfigFile.is_open()) {
    ConfigFile.open(StandardPath.c_str());
    if (!ConfigFile.is_open()) { // if not, assign standard path
      checkFile = false;
    }
    else {
      fReactionFileName = StandardPath;
    }
  }
  if (!checkFile && fReactionFileName != fDefaultReactionFileName) { // if file does not exist
    SendErrorAndExit("EventGenerator");
  }

  // close ConfigFile
  ConfigFile.close();
}

////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::CheckDetectorConfiguration() {
  bool checkFile = true;

  // NPTool path
  std::string GlobalPath = getenv("NPTOOL");
  std::string StandardPath = GlobalPath + "/Inputs/DetectorConfiguration/" + fDetectorFileName;

  // ifstream to configfile
  std::ifstream ConfigFile;

  // test if config file is in local path
  ConfigFile.open(fDetectorFileName.c_str());
  if (!ConfigFile.is_open()) {
    ConfigFile.open(StandardPath.c_str());
    if (!ConfigFile.is_open()) { // if not, assign standard path
      checkFile = false;
    }
    else {
      fDetectorFileName = StandardPath;
    }
  }
  if (!checkFile && fDetectorFileName != fDefaultDetectorFileName) { // if file does not exist
    SendErrorAndExit("DetectorConfiguration");
  }

  // close ConfigFile
  ConfigFile.close();
}

////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::CheckG4Macro() {
  if (IsDefault("G4MacroPath"))
    return;

  // ifstream to configfile
  std::ifstream MacroFile(fG4MacroPath);

  if (!MacroFile.is_open()) {
    SendErrorAndExit("G4MacroPath");
  }
}

////////////////////////////////////////////////////////////////////////////////
// This method tests if the input files are the default ones
bool NPOptionManager::IsDefault(const char* type) const {
  bool result = false;

  std::string stype = type;
  if (stype == "EventGenerator") {
    if (fReactionFileName == fDefaultReactionFileName)
      result = true;
  }
  else if (stype == "DetectorConfiguration") {
    if (fDetectorFileName == fDefaultDetectorFileName)
      result = true;
  }
  else if (stype == "Calibration") {
    if (fCalibrationFileName == fDefaultCalibrationFileName)
      result = true;
  }
  else if (stype == "RunToTreat") {
    if (fRunToReadFileName == fDefaultRunToReadFileName)
      result = true;
  }
  else if (stype == "OutputFileName") {
    if (fOutputFileName == fDefaultOutputFileName)
      result = true;
  }
  else if (stype == "TreeName") {
    if (fOutputTreeName == fDefaultOutputTreeName)
      result = true;
  }
  else if (stype == "G4MacroPath") {
    if (fG4MacroPath == fDefaultG4MacroPath)
      result = true;
  }

  else {
    std::cout << "NPOptionManager::IsDefault() unkwown keyword" << std::endl;
  }

  return result;
}

////////////////////////////////////////////////////////////////////////////////
// This method tests if the input files are the default ones
void NPOptionManager::SendErrorAndExit(const char* type) const {
  std::string stype = type;
  if (stype == "EventGenerator") {
    std::cout << std::endl;
    std::cout << "**********************************       Error       **********************************" << std::endl;
    std::cout << "* No event generator file found in $NPTool/Inputs/EventGenerator or local directories *" << std::endl;
    std::cout << "***************************************************************************************" << std::endl;
    std::cout << std::endl;
    exit(1);
  }
  else if (stype == "DetectorConfiguration") {
    std::cout << std::endl;
    std::cout << "***********************************       Error       ***********************************"
              << std::endl;
    std::cout << "* No detector geometry file found in $NPTool/Inputs/DetectorConfiguration or local directories *"
              << std::endl;
    std::cout << "*****************************************************************************************"
              << std::endl;
    std::cout << std::endl;
    exit(1);
  }
  else if (stype == "Calibration") {
  }
  else if (stype == "RunToTreat") {
  }
  else if (stype == "G4MacroPath") {
    std::cout << std::endl;
    std::cout << "***********************************       Error       ***********************************"
              << std::endl;
    std::cout << "*                  No Geant4 macro file found in the provided path                      *"
              << std::endl;
    std::cout << "*****************************************************************************************"
              << std::endl;
    std::cout << std::endl;
    exit(1);
  }

  else {
    std::cout << "NPOptionManager::SendErrorAndExit() unkwown program argument: " << type << std::endl;
    exit(1);
  }
}

////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::DisplayHelp() {
  DisplayVersion();
  std::cout << std::endl << "----NPOptionManager Help----" << std::endl << std::endl;
  std::cout << "List of Option " << std::endl;
  std::cout << "\t--help -H -h\t\t\tDisplay this help message" << std::endl;
  std::cout << "\t--detector -D <arg>\t\tSet arg as the detector configuration file" << std::endl;
  std::cout << "\t--event-generator -E <arg>\tSet arg as the event generator file" << std::endl;
  std::cout << "\t--output -O <arg>\t\tSet arg as the Output File Name (output tree)" << std::endl;
  std::cout << "\t--tree-name <arg>\t\tSet arg as the Output Tree Name " << std::endl;
  std::cout << "\t--definition <definition> \tAdd <definition> to the list of definition" << std::endl;
  std::cout << "\t-S \t\t\t\tOne tree output per detector" << std::endl;
  std::cout << "\t--verbose -V <arg>\t\tSet the verbose level, 0 for nothing, 1 for normal printout." << std::endl;
  std::cout << "\t\t\t\t\tError and warning are not affected" << std::endl;
  std::cout << std::endl << "NPAnalysis only:" << std::endl;
  std::cout << "\t--run -R <arg>\t\t\tSet arg as the run to read file list" << std::endl;
  std::cout << "\t-T <name> <file>\t\tTree <name> from root file <file>" << std::endl;
  std::cout << "\t--cal -C <arg>\t\t\tSet arg as the calibration file list" << std::endl;
  std::cout << "\t--disable-branch\t\tDisable of branch of Input tree except the one of the detector (faster)"
            << std::endl;
  std::cout << "\t--generate-histo -GH\t\tInstantiate the T*Spectra class of each detector" << std::endl;
  std::cout << "\t--check-histo -CH\t\tCheck if the Histogram looks ok and change there color if not" << std::endl;
  std::cout << "\t--input-physical -IP\t\tConsider the Input file is containing Physics Class." << std::endl;
  std::cout << "\t-L <arg>\t\t\tLimit the number of events to be analysed to arg" << std::endl;
  std::cout << "\t-F <arg>\t\t\tSet the first event to analyse to arg (analysis goes from F -> L+F)" << std::endl;
  std::cout << "\t-P <arg>\t\t\tSet the Spectra Server Port for online analyis" << std::endl;
  std::cout << "\t--last-sim\t\t\tIgnore the list of Run to treat if any and analysed the last simulated file"
            << std::endl;
  std::cout << "\t--last-phy\t\t\tIgnore the list of Run to treat if any and analysed the last Physics file"
            << std::endl;
  std::cout << "\t--last-res\t\t\tIgnore the list of Run to treat if any and analysed the last Result file"
            << std::endl;
  std::cout << "\t--last-any\t\t\tIgnore the list of Run to treat if any and analysed the last generated root file"
            << std::endl;
  std::cout << "\t--online  \t\t\tStart the spectra server" << std::endl;
  std::cout << "\t--circular \t\t\tSet the output tree a circular one" << std::endl;
  std::cout << std::endl << "NPSimulation only:" << std::endl;
  std::cout << "\t-M <arg>\t\t\tExecute Geant4 macro <arg> at startup" << std::endl;
  std::cout << "\t-B <arg>\t\t\tExecute in batch mode (no ui) with Geant4 macro <arg> at startup" << std::endl;
  std::cout << "\t--random-seed <arg>\t\tSet the random generator seed to <arg> (unsigned int)" << std::endl;
  std::cout << "\t--record-track\t\t\tRecord the track of every simulated particle to the ouput tree" << std::endl;
  std::cout << std::endl << std::endl;

  // exit current program
  exit(0);
}

////////////////////////////////////////////////////////////////////////////////
void NPOptionManager::Destroy() {
  if (instance != 0) {
    delete instance;
    instance = 0;
  }
}
////////////////////////////////////////////////////////////////////////////////
std::string NPOptionManager::GetLastFile() {
  std::string path = getenv("NPTOOL");
  if (fLastSimFile)
    return (path + "/.last_sim_file");

  else if (fLastPhyFile)
    return (path + "/.last_phy_file");

  else if (fLastResFile)
    return (path + "/.last_res_file");

  else if (fLastAnyFile)
    return (path + "/.last_any_file");

  else
    return "VOID";
}