File npanalysis.cxx

File List > src > utility > npanalysis.cxx

Go to the documentation of this file

#include "NPApplication.h"
#include "NPDetectorManager.h"
#include "NPException.h"
#include "NPFunction.h"
#include "NPProgressDisplay.h"
#include "NPTerminalColor.h"
#include "NPVDataInput.h"
#include "NPVDataOutput.h"
#include <chrono>
#include <iomanip>
#include <iostream>
using namespace nptool;

int main(int argc, char** argv) {
  auto app = nptool::Application::InitApplication(argc, argv);
  try {
    // instantiate an application
    app->Start();

    // For Progress Display
    long long event_processed = 0;
    long long event_to_process = -1;
    long long size_to_read = -1;

    // Data Input
    std::shared_ptr<nptool::VDataInput> input;
    if (app->HasFlag("--input")) {
      auto input_arg = app->GetVectorArg("--input");
      if (input_arg.size()) {
        input = app->ConstructDataInput(input_arg[0]);
        if (input) {
          input->Init(input_arg);
        }
        else {
          throw(nptool::Error("npanalysis", "Fail to construct data input : " + input_arg[0]));
        }
        if (input->GetEntries() == 0) {
          throw(nptool::Error("npanalysis", "No entries to analyse"));
        }
        else {
          nptool::message("green", "core", "npanalysis  ",
                          "Data input:  " + nptool::itoa(input->GetEntries()) + " entries loaded ", true);
          event_to_process = input->GetEntries();
          size_to_read = input->GetFileSize();
        }
      }
      else
        throw(nptool::Error("npanalysis", "--input flag provided with no arguments, at least one needed"));
    }
    else {
      throw(nptool::Error("npanalysis", "npanalysis requires --input flag"));
    }

    // limit number of entry to analyse
    auto limit = event_to_process;
    if (app->HasFlag("--limit"))
      limit = app->GetIntArg("--limit");

    // Data Output
    std::shared_ptr<nptool::VDataOutput> output;
    if (app->HasFlag("--output")) {
      auto output_arg = app->GetVectorArg("--output");
      if (output_arg.size()) {
        output = app->ConstructDataOutput(output_arg[0]);
        if (output) {
          output->Init(output_arg);
        }
        else {
          throw(nptool::Error("npanalysis", "Fail to construct data output " + output_arg[0]));
        }
      }
      else
        throw(nptool::Error("npanalysis", "--output flag provided with no arguments, at least one needed"));
    }
    else {
      throw(nptool::Error("npanalysis", "npanalysis requires --output flag"));
    }

    // Detector Configuration
    if (input)
      app->InitializeDataInputRaw(input);
    if (output)
      app->InitializeDataOutputPhysics(output);

    app->AttachASCIIFiles();
    // User analysis
    std::vector<std::shared_ptr<nptool::VUserAnalysis>> user_analysis;
    if (app->HasFlag("--user-analysis")) {
      auto analysis_arg = app->GetVectorArg("--user-analysis");
      // load all analysis plugin
      for (auto analysis : analysis_arg) {
        app->LoadPlugin(analysis);
        user_analysis.push_back(app->ConstructUserAnalysis(analysis));
        nptool::message("green", "core", "npanalysis  ", "User analysis: " + analysis + " loaded ", true);
      }

      for (auto analysis : user_analysis) {
        analysis->Init();
        if (input)
          analysis->SetDataInput(input);
        if (output)
          analysis->SetDataOutput(output);
      }
    }

    nptool::ProgressDisplay progress(event_to_process, size_to_read);
    // Main loop
    while (input->GetNextEntry()) {
      app->BuildPhysicalEvent();
      for (auto analysis : user_analysis) {
        analysis->TreatEvent();
      }
      bool Fill = true;
      for (auto analysis : user_analysis) {
        if (!analysis->FillOutputCondition())
          Fill = false;
      }
      if (Fill)
        output->Fill();
      progress.AttemptDisplay(event_processed++, input->GetReadSize());
      /*  if (event_processed > limit)
          break;*/
      app->ClearEventData();
    }
    progress.ForceDisplay(event_processed, input->GetReadSize());

    // call user analysis end
    for (auto analysis : user_analysis) {
      analysis->End();
    }

    // Stop the app
    app->Stop();
  }
  catch (nptool::Warning& ex) {
    nptool::DisplayException(ex);
  }
  catch (nptool::Error& ex) {
    nptool::DisplayException(ex);

    app->Stop();
    return 1;
  }

  // any other exception
  catch (...) {
    return 1;
  }
  return 0;
}