NtpMaker.cpp

Go to the documentation of this file.

 
// dependencies headers
#include <docopt.h>
#include <fmt/ranges.h>
#include <signal.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/spdlog.h>
 
// AMS headers
#include "TrdKCluster.h"
#include "amschain.h"
#include "root.h"
#include "tkdcards.h"
 
// NAIA headers
#include "NAIAVersion.h"
#include "NtpMaker/NtpSelector.h"
#include "NtpMaker/NtpTools.h"
#include "Utility/Logging/Logging.h"
 
static constexpr auto EXENAME = R"(NtpMaker)";
static constexpr auto USAGE = R"(NtpMaker, NAIA ntuple version
 
Usage:
  NtpMaker (-i FILE...) (-o FILE) [-v | -vv] [options]
  NtpMaker --version
 
Options:
    -i, --input-file=FILE      Input file
    -o, --output-file=FILE     Output file
    -w, --overwrite            Overwrite results
    -v...                      Verbosity level (once for Debug, twice for Trace)
    -e, --from-event=EVNO      Process from this event
    -E, --single-event=EVNO    Process only this event
    -n, --nevents=NEV          Process # events
    --reprocess_rti            Reprocess and replace the RTIInfo tree only
    --use-getmcbeta            Use GetMCBeta() instead of GetBeta() (default: false, needed before MC production 1308) 
    -h, --help                 Give this help list
)";
 
bool StopSelector = false;
 
void sig_handler(int signum) {
  spdlog::warn("Signal Handler called with signal {}", signum);
  StopSelector = true;
}
 
int main(int argc, char **argv) {
  signal(SIGINT, sig_handler); // Register signal handler
 
  auto naiaVersion = NAIA::Version{};
  auto versionString = fmt::format("{} v{}.{}.{}", EXENAME, naiaVersion.major, naiaVersion.minor, naiaVersion.patch);
  std::map<std::string, docopt::value> arguments = docopt::docopt(USAGE, {std::next(argv), std::next(argv, argc)},
                                                                  true,           // show help if requested
                                                                  versionString); // version string
 
  auto logger = NAIA::getLogger(EXENAME);
  switch (arguments["-v"].asLong()) {
  case 1:
    spdlog::set_level(spdlog::level::debug);
    break;
  case 2:
    spdlog::set_level(spdlog::level::trace);
    break;
  }
 
  // handle input and output arguments
  auto inputFiles = arguments["--input-file"].asStringList();
  auto outputFile = arguments["--output-file"].asString();
 
  auto fileList = NAIA::NtpTools::LoadInputFiles(inputFiles);
 
  logger->info("Input files: {}", inputFiles);
  logger->info("Output file: {}", outputFile);
 
  logger->debug("Creating AMSChain");
  auto amsChain = std::make_unique<AMSChain>();
  if (spdlog::get_level() == spdlog::level::info) {
    NAIA::Logging::MuteOutput();
  }
 
  for (const auto &filename : fileList) {
    amsChain->Add(filename.c_str());
  }
 
  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;
 
  spdlog::debug("isMC = {}", isMC);
 
  if (spdlog::get_level() == spdlog::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["--single-event"]) {
    logger->debug("Run in single event mode");
    EventNumber = amsChain->GetEntryNo(event->Run(), arguments["--single-event"].asLong());
    logger->debug("  event no. {} - {}", event->Run(), EventNumber);
    firstev = EventNumber;
    lastev = EventNumber + 1;
  } else if (arguments["--from_event"]) {
    logger->debug("Run in from-event mode");
    EventNumber = amsChain->GetEntryNo(event->Run(), arguments["--from_event"].asLong());
    logger->debug("  event no. {} - {}", event->Run(), EventNumber);
    firstev = EventNumber;
    lastev = arguments["--nevents"] ? EventNumber + arguments["--nevents"].asLong() : nEvents;
  } else {
    firstev = 0;
    lastev = arguments["--nevents"] ? arguments["--nevents"].asLong() : nEvents;
  }
 
  bool reprocess_rti = arguments["--reprocess_rti"].asBool();
  if (reprocess_rti) {
    logger->info("Reprocessing RTIInfo tree only");
  }
 
  // ====== setup standard AMS pre-conditions and objects ======
  // RTI
  if (!isMC) {
    AMSSetupR::RTI::UseLatest(8);
  } else {
    AMSSetupR::SlowControlR::ReadFromExternalFile = false;
  }
  TkDBc::UseFinal();
  TRMCFFKEY_DEF::ReadFromFile = 0;
  TRFITFFKEY_DEF::ReadFromFile = 0;
  TRFITFFKEY.ErcHeY = 0;
 
  // 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(outputFile);
  analysis.ReprocessRTI(reprocess_rti);
  analysis.firstentry = firstev;
  analysis.lastentry = lastev;
  analysis.useGetMCBeta = arguments["--use-getmcbeta"].asBool();
 
  amsChain->Process(&analysis, "", lastev - firstev, firstev);
 
  logger->info("...exiting");
  return 0;
}