NtpMaker.cpp

Go to the documentation of this file.

// dependencies headers
#include "spdlog/sinks/stdout_color_sinks.h"
#include "spdlog/spdlog.h"

// AMS headers
#include "Tofrec02_ihep.h"
#include "TrdKCluster.h"
#include "amschain.h"
#include "root.h"
#include "tkdcards.h"

// NAIA headers
#include "NtpMaker/NtpSelector.h"
#include "NtpMaker/NtpTools.h"
#include "NtpMaker/cli_options.h"
#include "Utility/Logging/Logging.h"

int main(int argc, char **argv) {
  auto logger = spdlog::stdout_color_st("NtpMaker");

  logger->info("Starting up...");

  struct arguments arguments;
  arguments.flag_overwrite = false;
  arguments.flag_input = false;
  arguments.flag_output = false;

  int parse_status = argp_parse(&argp, argc, argv, 0, 0, &arguments);

  if (parse_status)
    throw std::runtime_error("Failed parsing CLI arguments");

  if (std::string(arguments.debug_level) == "Debug") {
    spdlog::set_level(spdlog::level::debug);
  } else if (std::string(arguments.debug_level) == "Trace") {
    spdlog::set_level(spdlog::level::trace);
  }

  // handle input and output arguments
  if (!arguments.flag_input) {
    logger->error("Missing input file");
    return 1;
  }
  std::string inputFileName = arguments.infilename;

  bool flag_filelist;
  if (inputFileName.find(".txt") != std::string::npos) {
    flag_filelist = true;
  } else if (inputFileName.find(".root") != std::string::npos) {
    flag_filelist = false;
  } else {
    logger->error("{} is not a valid input file", inputFileName);
    return 1;
  }
  std::string outputFileName;
  if (arguments.flag_output)
    outputFileName = arguments.outfilename;
  else {
    outputFileName = inputFileName.substr(inputFileName.find_last_of('/') + 1,
                                          inputFileName.size() - inputFileName.find_last_of('/'));
    if (flag_filelist)
      outputFileName = outputFileName.substr(0, outputFileName.find_last_of('.')) + ".root";
  }

  logger->info("Running on input file {}", inputFileName);
  logger->info("Writing output file {}", outputFileName);

  // logger->debug("Setting up branches");
  // chain.SetupBranches(NAIAChain::AccessMode::Write);

  logger->debug("Creating AMSChain");
  auto amsChain = std::make_unique<AMSChain>();
  if (std::string(arguments.debug_level) == "Info") {
    NAIA::Logging::MuteOutput();
  }
  if (!flag_filelist) {
    amsChain->Add(inputFileName.c_str());
  } else {
    ifstream infilelist(inputFileName.c_str());
    TString bufname;
    while (!infilelist.eof()) {
      infilelist >> bufname;
      if (bufname.CompareTo("")) {
        logger->info("Adding file {} to amsChain", bufname);
        amsChain->Add(bufname);
      }
    }
  }
  unsigned long long nEvents = amsChain->GetEntries();
  logger->info("{} events in this file", nEvents);

  // Get the first event to gather some info, this is needed especially when processing MC
  AMSEventR *event = amsChain->GetEvent(0);
  bool isMC = event->nMCEventg() > 0;

  if (std::string(arguments.debug_level) == "Info") {
    NAIA::Logging::UnmuteOutput();
  }

  // check if running on one event or on a smaller subset
  unsigned long long EventNumber = 0;
  unsigned long long firstev, lastev;
  if (arguments.event > 0) {
    logger->debug("Run in single event mode");
    EventNumber = amsChain->GetEntryNo(event->Run(), arguments.event);
    logger->debug("  event no. {} - {}", event->Run(), EventNumber);
    firstev = EventNumber;
    lastev = EventNumber + 1;
  } else if (arguments.from_event > 0) {
    logger->debug("Run in from-event mode");
    EventNumber = amsChain->GetEntryNo(event->Run(), arguments.from_event);
    logger->debug("  event no. {} - {}", event->Run(), EventNumber);
    firstev = EventNumber;
    lastev = arguments.nevents > 0 ? EventNumber + arguments.nevents : nEvents;
  } else {
    firstev = 0;
    lastev = arguments.nevents > 0 ? arguments.nevents : nEvents;
  }

  // ====== setup standard AMS pre-conditions and objects ======
  // RTI
  if (!isMC) {
    AMSSetupR::RTI::UseLatest(7);
  } else {
    AMSSetupR::SlowControlR::ReadFromExternalFile = false;
  }
  TkDBc::UseFinal();
  TRMCFFKEY_DEF::ReadFromFile = 0;
  TRFITFFKEY_DEF::ReadFromFile = 0;
  TRFITFFKEY.ErcHeY = 0;

  TofRecH::RebuildBetaHInReadHeader = false;

  // Additional (effective) temperature corrections
  RichRingR::useEffectiveTemperatureCorrection = true;
  // force load Config & Status from ext. files (needed for pass6 run>=1407139304 && run<=1411991495)
  RichRingR::reloadRunTag = true;

  // TrdK stuff
  if (isMC) {
    TrdKCluster::ForceReadAlignment = 0;
    TrdKCluster::ForceReadCalibration = 0;
    TrdKCluster::ForceReadXePressure = 0;
    TrdKCluster::SetDefaultMCXePressure(900);
  }

  NAIA::NtpSelector analysis(isMC);
  analysis.SetOutputFilename(outputFileName);
  analysis.firstentry = firstev;
  analysis.lastentry = lastev;

  amsChain->Process(&analysis, "", lastev - firstev, firstev);

  logger->info("...exiting");
  return 0;
}