marley::CommandHandler Class Reference

Wrapper for handling commands in the main marley executable. More...

#include <CommandHandler.hh>

Classes
struct	CommandInfo

Public Types
using	CommandMap = std::map< std::string, CommandInfo >

Public Member Functions
	CommandHandler (int argc, char *argv[])
bool	execute ()

Static Public Member Functions
static bool	print_top_level_help ()

Static Protected Member Functions
static bool	cmd_convert (std::deque< std::string > &args)
	Convert MARLEY event files between supported formats.
static bool	cmd_decay (std::deque< std::string > &args)
	Simulate nuclear de-excitations.
static bool	cmd_generate (std::deque< std::string > &args)
	Generate Monte Carlo events.
static bool	cmd_help (std::deque< std::string > &args)
	Display top-level or command-specific help messages.
static bool	cmd_print (std::deque< std::string > &args)
	Print existing MARLEY events in a human-readable format.
static bool	cmd_reweight (std::deque< std::string > &args)
	Reweight existing MARLEY events.
static bool	cmd_summarize (std::deque< std::string > &args)
	Summarize an existing sample of MARLEY events as a ROOT TTree.
static bool	cmd_xsec (std::deque< std::string > &args)
	Tabulate energy-dependent total cross section values.

Protected Attributes
std::deque< std::string >	cmds_

Static Protected Attributes
static const CommandMap	command_map_

Detailed Description

Wrapper for handling commands in the main marley executable.

Definition at line 28 of file CommandHandler.hh.

---

Class Documentation

marley::CommandHandler::CommandInfo

struct marley::CommandHandler::CommandInfo

Definition at line 34 of file CommandHandler.hh.

Class Members
function< bool(deque< string > &) >	cmd_	Function to call to execute the command.
function< void() >	print_help_	Functiont that prints a detailed help message to stdout.
bool	requires_root_ = false	Indicates whether MARLEY needs to be linked against ROOT to execute this command
string	summary_	Simple description of the command.

Member Typedef Documentation

CommandMap

using marley::CommandHandler::CommandMap = std::map< std::string, CommandInfo >

Definition at line 49 of file CommandHandler.hh.

Constructor & Destructor Documentation

CommandHandler()

marley::CommandHandler::CommandHandler	(	int	argc,
		char *	argv[] )

Definition at line 244 of file CommandHandler.cc.

  : cmds_( argv, argv + argc )
{
  // Strip the executable name off of the front of the deque
  cmds_.pop_front();
}

Member Function Documentation

cmd_convert()

bool marley::CommandHandler::cmd_convert ( std::deque< std::string > & args )

staticprotected

Convert MARLEY event files between supported formats.

Definition at line 248 of file cmd_convert.cc.

                                                                    {
 
  std::string output_path;
  std::string output_format;
  bool force = false;
  std::vector< std::string > input_files;
 
  while ( !args.empty() ) {
    std::string arg = args.front();
    args.pop_front();
 
    if ( arg == "-o" || arg == "--output" ) {
      if ( args.empty() ) {
        std::cerr << "marley convert: missing argument after '" << arg
          << "'\n";
        return false;
      }
      output_path = args.front();
      args.pop_front();
    }
    else if ( arg == "--output-format" ) {
      if ( args.empty() ) {
        std::cerr << "marley convert: missing argument after '"
          << "--output-format'\n";
        return false;
      }
      output_format = args.front();
      args.pop_front();
    }
    else if ( arg == "--force" || arg == "-f" ) {
      force = true;
    }
    else if ( arg == "--help" || arg == "-h" ) {
      args.clear();
      args.push_front( "convert" );
      return marley::CommandHandler::cmd_help( args );
    }
    else if ( arg.front() == '-' ) {
      std::cerr << "marley convert: unrecognized option '" << arg << "'\n";
      return false;
    }
    else {
      input_files.push_back( arg );
    }
  }
 
  if ( output_path.empty() ) {
    std::cerr << "marley convert: missing required option -o OUTPUT_FILE\n";
    args.push_front( "convert" );
    marley::CommandHandler::cmd_help( args );
    return false;
  }
 
  if ( input_files.empty() ) {
    std::cerr << "marley convert: no input files specified\n";
    args.push_front( "convert" );
    marley::CommandHandler::cmd_help( args );
    return false;
  }
 
  if ( output_format.empty() ) {
    if ( output_path.size() >= 5
      && output_path.substr( output_path.size() - 5 ) == ".root" )
    {
      output_format = "root";
    }
    else {
      output_format = "ascii";
    }
  }
 
  if ( output_format != "ascii" && output_format != "root"
    && output_format != "legacy" && output_format != "hepevt" )
  {
    std::cerr << "marley convert: invalid output format '"
      << output_format << "'. Supported formats:"
      " ascii, root, legacy, hepevt\n";
    return false;
  }
 
#ifndef USE_ROOT
  if ( output_format == "root" ) {
    std::cerr << "marley convert: ROOT output format requires a"
      " ROOT-enabled build of MARLEY.\n";
    return false;
  }
#endif
 
  if ( !force ) {
    std::ifstream test( output_path );
    if ( test ) {
      bool overwrite = marley_utils::prompt_yes_no(
        "Really overwrite " + output_path + "?" );
      if ( !overwrite ) {
        std::cout << "Action aborted.\n";
        return true;
      }
    }
  }
 
  if ( output_format == "legacy" ) {
    convert_to_legacy( input_files, output_path );
    return true;
  }
 
  if ( output_format == "hepevt" ) {
    convert_to_hepevt( input_files, output_path );
    return true;
  }
 
  std::string out_config_str = "{ format: \"" + output_format
    + "\", file: \"" + output_path
    + "\", mode: \"overwrite\", force: true }";
  auto out_config = marley::JSON::load( out_config_str );
  auto output_file = marley::OutputFile::make_OutputFile( out_config );
 
  bool multi_file = (input_files.size() > 1);
  std::shared_ptr< HepMC3::GenRunInfo > cleaned_run_info;
  for_each_event( input_files,
    [ & ]( HepMC3::GenEvent& ev, bool first_event, double,
      const auto& first_info )
    {
      if ( first_event && multi_file ) {
        cleaned_run_info = make_cleaned_run_info( first_info );
      }
      if ( cleaned_run_info ) {
        ev.set_run_info( cleaned_run_info );
      }
      output_file->write_event( &ev );
    } );
 
  return true;
}

References cmd_help(), and HepMC3::GenEvent::set_run_info().

cmd_decay()

bool marley::CommandHandler::cmd_decay ( std::deque< std::string > & args )

staticprotected

Simulate nuclear de-excitations.

Definition at line 60 of file cmd_decay.cc.

                                                                  {
 
  std::string config_file_name;
  if ( !args.empty() ) config_file_name = args.front();
 
  if ( config_file_name.empty() || config_file_name == "-h"
    || config_file_name == "--help" )
  {
    args.clear();
    args.push_front( "decay" );
    return marley::CommandHandler::cmd_help( args );
  }
 
  // -------------------------------------------------------------------------
  // Load the JSON config from file, then patch in null entries for "reactions"
  // and "source" if those keys are absent.  This allows create_generator() to
  // take its early-return path and skip cross-section normalisation, which is
  // irrelevant for standalone de-excitation events.
  // -------------------------------------------------------------------------
  marley::JSON json = marley::JSON::load_file( config_file_name );
 
  if ( !json.has_key("reactions") ) json["reactions"] = marley::JSON( nullptr );
  if ( !json.has_key("source")    ) json["source"]    = marley::JSON( nullptr );
 
  marley::JSONConfig jc( json );
  marley::Generator gen = jc.create_generator();
  gen.set_up_run_info();
 
  bool ok;
 
  // -------------------------------------------------------------------------
  // Parse the required top-level "decay" block
  // -------------------------------------------------------------------------
  const std::string decay_config_label( "decay" );
  marley::JSON decay_config;
  ok = get_from_json< marley::JSON >( decay_config_label, json, decay_config );
  if ( !ok ) throw marley::Error( "Missing key '" + decay_config_label
    + "' in job configuration file" );
 
  long num_events = assign_from_json< long >( "events", decay_config, ok, 1000 );
 
  // -------------------------------------------------------------------------
  // Parse the required "nucleus" sub-object
  // -------------------------------------------------------------------------
  if ( !decay_config.has_key("nucleus") ) {
    throw marley::Error( "Missing required \"nucleus\" key in the"
      " \"decay\" configuration block" );
  }
  const marley::JSON& nuc_config = decay_config.at( "nucleus" );
 
  // Read the nucleus identity.  The user may supply either (or both) of:
  //   Option A: Z and A integer keys
  //   Option B: pdg integer key (nuclear PDG code)
  // If both are supplied they must be consistent.
 
  bool has_pdg = nuc_config.has_key("pdg");
  bool has_Z   = nuc_config.has_key("Z");
  bool has_A   = nuc_config.has_key("A");
 
  if ( !has_pdg && !( has_Z && has_A ) ) {
    throw marley::Error( "The \"nucleus\" block must specify the nuclide"
      " using either the \"pdg\" key or both the \"Z\" and \"A\" keys" );
  }
 
  int nucleus_pdg = 0;
  int Z = 0, A = 0;
 
  if ( has_pdg ) {
    nucleus_pdg = assign_from_json< int >( "pdg", nuc_config, ok );
    int Z_from_pdg = 0, A_from_pdg = 0;
    if ( !pdg_to_ZA( nucleus_pdg, Z_from_pdg, A_from_pdg ) ) {
      throw marley::Error( "The value " + std::to_string(nucleus_pdg)
        + " given for \"nucleus.pdg\" is not a recognized nuclear"
        " or nucleon PDG code" );
    }
    Z = Z_from_pdg;
    A = A_from_pdg;
  }
 
  if ( has_Z && has_A ) {
    int Z_cfg = assign_from_json< int >( "Z", nuc_config, ok );
    int A_cfg = assign_from_json< int >( "A", nuc_config, ok );
    if ( has_pdg ) {
      // Both representations present — verify consistency
      if ( Z_cfg != Z || A_cfg != A ) {
        throw marley::Error( "Inconsistent nucleus specification: pdg="
          + std::to_string(nucleus_pdg) + " implies Z=" + std::to_string(Z)
          + ", A=" + std::to_string(A) + ", but Z=" + std::to_string(Z_cfg)
          + ", A=" + std::to_string(A_cfg) + " were also given" );
      }
    }
    else {
      Z = Z_cfg;
      A = A_cfg;
      nucleus_pdg = marley_utils::get_nucleus_pid( Z, A );
    }
  }
 
  if ( Z < 0 ) throw marley::Error( "Negative Z encountered" );
  if ( A < 1 ) throw marley::Error( "A < 1 encountered" );
 
  // Net ionic charge of the nucleus (protons minus electrons).
  // Default 0 = neutral atom.
  int net_charge = assign_from_json< int >( "net_charge", nuc_config, ok, 0 );
 
  // -------------------------------------------------------------------------
  // Parse excitation energy: fixed value or uniform sampling interval
  // -------------------------------------------------------------------------
  double Ex = 0.;
  double Ex_min = 0.;
  double Ex_max = 0.;
  bool sample_Ex = nuc_config.has_key( "Ex_max" );
  if ( !sample_Ex ) {
    Ex = assign_from_json< double >( "Ex", nuc_config, ok, -1.0 );
    if ( !ok ) throw marley::Error( "Missing \"Ex\" key in \"nucleus\" block"
      " (or use \"Ex_min\" + \"Ex_max\" for uniform sampling)" );
    if ( Ex < 0. ) throw marley::Error( "Negative excitation energy"
      " encountered (Ex = " + std::to_string(Ex) + " MeV)" );
  }
  else {
    Ex_min = assign_from_json< double >( "Ex_min", nuc_config, ok, -1.0 );
    Ex_max = assign_from_json< double >( "Ex_max", nuc_config, ok, -1.0 );
    if ( Ex_min < 0. ) throw marley::Error( "Negative lower excitation"
      " energy bound (Ex_min = " + std::to_string(Ex_min) + " MeV)" );
    if ( Ex_max < 0. ) throw marley::Error( "Negative upper excitation"
      " energy bound (Ex_max = " + std::to_string(Ex_max) + " MeV)" );
    if ( Ex_max < Ex_min ) throw marley::Error( "Upper Ex bound"
      " (" + std::to_string(Ex_max) + " MeV) is less than lower Ex bound"
      " (" + std::to_string(Ex_min) + " MeV)" );
  }
 
  // -------------------------------------------------------------------------
  // Parse nuclear spin: required array of 2J values
  // -------------------------------------------------------------------------
  std::vector< int > twoJ_vec;
  if ( !nuc_config.has_key("twoJ") ) {
    throw marley::Error( "Missing \"twoJ\" key in \"nucleus\" block" );
  }
  else {
    const marley::JSON& twoJ_obj = nuc_config.at( "twoJ" );
    if ( !twoJ_obj.is_array() ) {
      throw marley::Error( "The \"twoJ\" key in \"nucleus\" must have"
        " a value that is a JSON array" );
    }
    convert_json< std::vector<int> >( twoJ_obj, twoJ_vec );
  }
  if ( twoJ_vec.empty() ) {
    throw marley::Error( "The \"twoJ\" array in \"nucleus\" must not"
      " be empty" );
  }
  for ( const auto& tJ : twoJ_vec ) {
    if ( tJ < 0 ) throw marley::Error( "Negative 2J value encountered"
      " in \"twoJ\" array" );
    bool even_A = ( A % 2 == 0 );
    bool even_twoJ = ( tJ % 2 == 0 );
    if ( even_A != even_twoJ ) throw marley::Error( "Unphysical twoJ = "
      + std::to_string( tJ ) + " encountered for A = "
      + std::to_string( A ) );
  }
 
  std::vector< double > twoJ_weights( twoJ_vec.size(), 1. );
  std::discrete_distribution< size_t > twoJ_dist(
    twoJ_weights.cbegin(), twoJ_weights.cend() );
 
  // -------------------------------------------------------------------------
  // Parse parity: optional, default "+"
  // -------------------------------------------------------------------------
  auto parity_str = assign_from_json< std::string >( "parity", nuc_config,
    ok, "+" );
  if ( parity_str != "+" && parity_str != "-" && parity_str != "random" ) {
    throw marley::Error( "Invalid \"parity\" setting \""
      + parity_str + "\" in \"nucleus\" block."
      " Expected \"+\", \"-\", or \"random\"" );
  }
 
  const std::vector< std::string > parity_strings = { "+", "-" };
  const std::vector< double > parity_weights = { 1., 1. };
  std::discrete_distribution< size_t > parity_dist(
    parity_weights.cbegin(), parity_weights.cend() );
 
  // -------------------------------------------------------------------------
  // Parse output configuration
  // -------------------------------------------------------------------------
  std::vector< std::shared_ptr<marley::OutputFile> > output_files;
 
  if ( decay_config.has_key("output") ) {
    marley::JSON output_set = decay_config.at( "output" );
    if ( !output_set.is_array() ) throw marley::Error( "The"
      " \"output\" key must have a value that is a JSON array." );
    for ( const auto& el : output_set.array_range() ) {
      output_files.push_back( marley::OutputFile::make_OutputFile(el) );
    }
  }
  else {
    std::string out_cfg_str = "{ format: \"ascii\","
      " file: \"decay_events.hepmc3\", mode: \"overwrite\" }";
    auto out_cfg = marley::JSON::load( out_cfg_str );
    output_files.push_back( marley::OutputFile::make_OutputFile(out_cfg) );
  }
 
  for ( const auto& file : output_files ) {
    if ( file->mode_is_resume() ) {
      throw marley::Error( "The \"resume\" output mode is not supported"
        " by the \"marley decay\" command" );
    }
  }
 
  // -------------------------------------------------------------------------
  // Pre-compute fixed quantities used each event
  // -------------------------------------------------------------------------
  const auto& mt = marley::MassTable::Instance();
 
  double gs_mass = mt.get_atomic_mass( nucleus_pdg )
    - net_charge * mt.get_particle_mass( marley_utils::ELECTRON );
 
  double unbound_threshold = mt.unbound_threshold( nucleus_pdg );
 
  int signal_proc_id = marley_hepmc3::get_nuhepmc_proc_id(
    ProcType::StandaloneDecay );
 
  // -------------------------------------------------------------------------
  // Event loop
  // -------------------------------------------------------------------------
  // One-time warning flags for the level-snap behaviour
  bool warned_snap        = false; // suppress after first snap warning
  bool warned_snap_sample = false; // suppress after first "will continue" note
 
  for ( long evnum = 0; evnum < num_events; ++evnum ) {
 
    // --- Sample Ex, twoJ, and parity for this event -----------------------
    if ( sample_Ex ) {
      Ex = gen.uniform_random_double( Ex_min, Ex_max, true );
    }
 
    size_t twoJ_index = gen.sample_from_distribution( twoJ_dist );
    int twoJ = twoJ_vec.at( twoJ_index );
 
    std::string par_str = parity_str;
    if ( par_str == "random" ) {
      size_t par_index = gen.sample_from_distribution( parity_dist );
      par_str = parity_strings.at( par_index );
    }
    marley::Parity parity;
    std::istringstream temp_iss( par_str );
    temp_iss >> parity;
 
    // --- Snap to nearest discrete level if below the unbound threshold ----
    if ( Ex <= unbound_threshold ) {
      auto* ds = gen.get_structure_db().get_decay_scheme( nucleus_pdg );
      if ( ds ) {
        auto* lev = ds->get_pointer_to_closest_level( Ex );
 
        // Check what changes on the snap
        double Ex_lev   = lev->energy();
        int    twoJ_lev = lev->twoJ();
        marley::Parity P_lev = lev->parity();
 
        bool Ex_changed   = ( std::abs(Ex_lev - Ex) > 1e-5 );
        bool twoJ_changed = ( twoJ_lev != twoJ );
        bool P_changed    = ( static_cast<int>(P_lev)
                              != static_cast<int>(parity) );
 
        if ( ( Ex_changed || twoJ_changed || P_changed ) && !warned_snap ) {
          std::ostringstream warn_msg;
          warn_msg << "User-specified nuclear state (Ex=" << Ex
            << " MeV, 2J=" << twoJ
            << ", P=" << parity
            << ") was snapped to nearest discrete level (Ex="
            << Ex_lev << " MeV, 2J=" << twoJ_lev
            << ", P=" << P_lev << ").";
          if ( !Ex_changed   ) warn_msg << " Ex unchanged.";
          if ( !twoJ_changed ) warn_msg << " 2J unchanged.";
          if ( !P_changed    ) warn_msg << " Parity unchanged.";
          warn_msg << " This warning will not be repeated.";
          MARLEY_LOG( WARN, "cmd.decay" ) << warn_msg.str();
          warned_snap = true;
 
          if ( sample_Ex && !warned_snap_sample ) {
            MARLEY_LOG( WARN, "cmd.decay" ) << "Discrete level matching"
              " will continue for subsequent events as Ex values below the"
              " unbound threshold (" << unbound_threshold << " MeV) are"
              " sampled. This message will not be repeated.";
            warned_snap_sample = true;
          }
        }
 
        // Apply the snap — use the level's quantum numbers
        Ex    = Ex_lev;
        twoJ  = twoJ_lev;
        parity = P_lev;
      }
    }
 
    // --- Build the HepMC3 event object ------------------------------------
    //
    // Primary vertex layout:
    //
    //   IN:  dummy projectile (PDG 0, status 4, zero 4-momentum)
    //        target nucleus   (status 20, at rest, gs mass)
    //
    //   OUT: dummy ejectile   (PDG 0, status 1, zero 4-momentum)
    //        residue nucleus  (status 27, mass = gs + Ex, with Ex/twoJ/parity
    //                          attributes for NucleusDecayer)
 
    auto event = std::make_shared< HepMC3::GenEvent >(
      HepMC3::Units::MEV, HepMC3::Units::CM );
 
    event->set_event_number( evnum + 1 );
 
    event->add_attribute( "signal_process_id",
      std::make_shared< HepMC3::IntAttribute >( signal_proc_id ) );
 
    auto prim_vtx = std::make_shared< HepMC3::GenVertex >();
    prim_vtx->set_status( marley_hepmc3::NUHEPMC_PRIMARY_VERTEX );
    event->add_vertex( prim_vtx );
 
    // Dummy projectile — PDG 0, zero 4-momentum
    auto projectile = marley_hepmc3::make_particle( 0, 0., 0., 0., 0.,
      marley_hepmc3::NUHEPMC_PROJECTILE_STATUS, 0. );
 
    // Target nucleus — at rest, ground-state mass
    auto target = marley_hepmc3::make_particle( nucleus_pdg,
      marley_hepmc3::NUHEPMC_TARGET_STATUS, gs_mass );
 
    // Dummy ejectile — clone of projectile (PDG 0, zero 4-momentum), final-state
    auto ejectile = marley_hepmc3::make_particle( 0, 0., 0., 0., 0.,
      marley_hepmc3::NUHEPMC_FINAL_STATE_STATUS, 0. );
 
    // Residue nucleus — excited state
    double m_residue = gs_mass + Ex;
    auto residue = marley_hepmc3::make_particle( nucleus_pdg, 0., 0., 0.,
      m_residue, marley_hepmc3::NUHEPMC_UNDECAYED_RESIDUE_STATUS, m_residue );
 
    prim_vtx->add_particle_in( projectile );
    prim_vtx->add_particle_in( target );
    prim_vtx->add_particle_out( ejectile );
    prim_vtx->add_particle_out( residue );
 
    // Set attributes for the target + residue now that these particles
    // are attached to the event
    marley_hepmc3::set_particle_charge( *target, net_charge );
    marley_hepmc3::set_particle_charge( *residue, net_charge );
 
    residue->add_attribute( "Ex",
      std::make_shared< HepMC3::DoubleAttribute >( Ex ) );
    residue->add_attribute( "twoJ",
      std::make_shared< HepMC3::IntAttribute >( twoJ ) );
    residue->add_attribute( "parity",
      std::make_shared< HepMC3::IntAttribute >( static_cast<int>(parity) ) );
 
    // --- Run de-excitation cascade ----------------------------------------
    marley::NucleusDecayer nd;
    nd.process_event( *event, gen );
 
    gen.finish_event_metadata( *event );
 
    for ( const auto& file : output_files ) {
      file->write_event( event.get() );
    }
 
    std::cout << "Event " << evnum << "\n";
  }
 
  return true;
}

References cmd_help(), marley::Generator::finish_event_metadata(), marley::StructureDatabase::get_decay_scheme(), marley::Generator::get_structure_db(), marley::MassTable::Instance(), marley::NucleusDecayer::process_event(), marley::Generator::sample_from_distribution(), marley::Generator::set_up_run_info(), and marley::Generator::uniform_random_double().

cmd_generate()

bool marley::CommandHandler::cmd_generate ( std::deque< std::string > & args )

staticprotected

Generate Monte Carlo events.

Definition at line 340 of file cmd_generate.cc.

                                                                     {
 
  // Declared here so the catch block can pass it to reset_terminal().
  // Remains 0 if an exception is thrown before output_files is populated.
  int num_status_lines = 0;
 
  // Flag that indicates whether caught exceptions need to call
  // reset_terminal(). After we set up the status line display, this becomes
  // important. Before that, it clears logging messages from the screen
  // unnecessarily.
  bool exception_needs_reset_terminal = false;
 
  // Create a pointer to store a buffered event and its corresponding
  // random number generator state string. We write out the buffered
  // event only when generation of the following event has successfully
  // completed. This saves space by allowing the generator state to be
  // saved only when needed at the end of a run (normal termination or
  // an early exit in response to an interruption/exception). The state can
  // be used to restart the MARLEY simulation job where it left off
  // without a drift in the random number state.
  std::shared_ptr< HepMC3::GenEvent > buffered_event;
  std::string cached_generator_state;
 
  std::vector< std::shared_ptr<marley::OutputFile> > output_files;
 
  try {
 
    std::string config_file_name;
    if ( !args.empty() ) config_file_name = args.front();
 
    bool cfn_empty = config_file_name.empty();
 
    if ( cfn_empty || config_file_name.front() == '-' )
    {
      if ( !cfn_empty && config_file_name != "-h"
        && config_file_name != "--help" )
      {
        std::cerr << "marley generate: unrecognized option '"
          << config_file_name << "'\n";
      }
      args.clear();
      args.push_front( "generate" );
      marley::CommandHandler::cmd_help( args );
      return false;
    }
 
    marley::JSON json = marley::JSON::load_file( config_file_name );
    marley::JSONConfig jc( json );
 
    std::chrono::system_clock::time_point start_time_point
      = std::chrono::system_clock::now();
 
    std::time_t start_time = std::chrono::system_clock::to_time_t(
      start_time_point );
 
    std::cout << "\nMARLEY started on "
      << put_time( std::localtime(&start_time), "%c %Z" ) << '\n';
 
    long num_old_events = 0;
 
    marley::JSON ex_set = json.get_object( "generate", false );
    long num_events = ex_set.get_long( "events", 1e3 );
 
    MARLEY_LOG( INFO, "app" ) << "Requested events: " << num_events
      << ", configuration file: \"" << config_file_name << "\"";
 
    int status_update_interval = DEFAULT_STATUS_UPDATE_INTERVAL;
    if ( ex_set.has_key("status_update_interval") ) {
      const auto& sui = ex_set.at( "status_update_interval" );
      bool ok;
      int sui_value = sui.to_long( ok );
 
      if ( !ok || sui_value < 1 ) {
        throw marley::Error( "Invalid value " + sui.dump_string()
          + " given for the \"status_update_interval\" key in the"
          " job configuration file" );
      }
      else status_update_interval = sui_value;
    }
 
    if ( ex_set.has_key("output") ) {
      marley::JSON output_set = ex_set.at( "output" );
      if ( !output_set.is_array() ) throw marley::Error( "The"
        " \"output\" key in the \"generate\" section must have a value that"
        " is a JSON array." );
      else for ( const auto& el : output_set.array_range() ) {
        output_files.push_back( marley::OutputFile::make_OutputFile(el) );
      }
    }
    else {
      std::string out_config_str = "{ format: \"ascii\","
        " file: \"events.hepmc3\", mode: \"overwrite\", force: false }";
      auto out_config = marley::JSON::load( out_config_str );
 
      output_files.push_back( marley::OutputFile::make_OutputFile(
        out_config ) );
    }
 
    // Fixed status line count for this run (computed once; used for scroll
    // region sizing and fallback threshold throughout).
    const int file_lines = ( output_files.size() <= MAX_FILE_STATUS_LINES )
      ? static_cast< int >( output_files.size() ) : 1;
    num_status_lines = 3 + file_lines;
 
    // Reset module-level state in case cmd_generate is called more than once.
    interrupted = false;
    terminal_resized = false;
    g_fallback_mode = false;
    g_status_region_active = false;
 
    std::signal( SIGINT,   signal_handler );
    std::signal( SIGWINCH, sigwinch_handler );
 
    // Create the generator before setting up the scroll region so that
    // initialization logging (including the active-reaction summary printed
    // at the end of create_generator()) appears before the status zone is
    // claimed. This avoids truncation of those log messages.
    std::unique_ptr< marley::Generator > gen;
 
    bool need_to_resume = false;
    for ( auto& file : output_files ) {
      if ( file->mode_is_resume() ) {
        if ( need_to_resume ) throw marley::Error( "Only one file may be used"
          " to resume a previous run." );
        else {
          need_to_resume = true;
          bool resume_ok = file->resume( gen, num_old_events );
          if ( !resume_ok ) throw marley::Error( "Failed to resume previous"
            " run from the file \"" + file->name() + '\"' );
        }
      }
    }
 
    if ( !need_to_resume ) gen = std::make_unique<marley::Generator>(
      jc.create_generator() );
 
    // Reset the start timestamp after generator creation so that rate and ETA
    // calculations exclude initialization overhead.
    start_time_point = std::chrono::system_clock::now();
    start_time = std::chrono::system_clock::to_time_t( start_time_point );
 
    exception_needs_reset_terminal = true;
 
    // Initialize the terminal display now that generator construction is done.
    // Enter fallback mode if stdout is not a TTY or the terminal is too small.
    {
      TermSize ts = get_terminal_size();
      if ( ts.rows == 0 || ts.rows < num_status_lines + 2 ) {
        enter_fallback_mode();
      } else {
        setup_scroll_region( num_status_lines );
      }
    }
 
    long ev_count = 1 + num_old_events;
 
    auto last_resize_time = std::chrono::steady_clock::time_point{};
 
    for (; ev_count <= num_events && !interrupted; ++ev_count) {
 
      // Handle terminal resize with clock-based debounce. The debounce
      // prevents thrashing during active window dragging; it is included
      // unconditionally because some physics configurations (e.g. CEvNS)
      // run at rates too fast to rely on event-loop latency alone.
      if ( terminal_resized ) {
        auto now = std::chrono::steady_clock::now();
        if ( now - last_resize_time >= RESIZE_DEBOUNCE ) {
          terminal_resized = false;
          last_resize_time = now;
 
          TermSize ts = get_terminal_size();
          if ( ts.rows == 0 || ts.rows < num_status_lines + 2 ) {
            enter_fallback_mode();
          } else if ( g_fallback_mode ) {
            exit_fallback_mode( num_status_lines );
          } else {
            setup_scroll_region( num_status_lines );
          }
        }
      }
 
      auto event = gen->create_event();
      event->set_event_number( ev_count );
 
      // If we have a buffered event from the previous iteration, we will
      // write it to the output file(s) now. The generator state string
      // will not be included here to save space. We can use implicit
      // conversion of the std::shared_ptr here since it default-constructs
      // to a nullptr and will therefore evaluate to false if we haven't
      // used it yet.
      if ( buffered_event ) {
        for ( const auto& file : output_files ) {
          file->write_event( buffered_event.get() );
        }
      }
 
      // Replace the buffered event with the current event. Also cache the
      // generator state string value corresponding to when the current
      // event was finished.
      buffered_event = event;
      cached_generator_state = gen->get_state_string();
 
      if ( !g_fallback_mode
        && ( (ev_count - num_old_events) % status_update_interval == 1
             || ev_count == num_events
             || status_update_interval == 1 ) )
      {
        update_status_bars( ev_count, num_events, num_old_events,
          start_time_point, output_files, num_status_lines );
      }
 
    } // event loop
 
    // We've exited the event loop, so write out the last completed event
    // (if any), which will be stored in the buffered_event pointer.
    // Attach the generator state string this time so that the MARLEY
    // job can be resumed from where it left off.
    // NOTE: This call to OutputFile::write_event() handles normal
    // termination and interruption via the SIGINT signal. The exception
    // exit path is handled separately below in the catch block.
    if ( buffered_event ) {
      marley::Generator::add_state_to_event( *buffered_event,
        cached_generator_state );
      for ( const auto& file : output_files ) {
        file->write_event( buffered_event.get() );
      }
    }
 
    reset_terminal( g_fallback_mode ? 0 : num_status_lines );
 
    for ( const auto& file : output_files ) {
      std::cout << "Data written to " << file->name() << ' '
        << marley_utils::num_bytes_to_string( file->bytes_written() ) << '\n';
    }
 
    std::chrono::system_clock::time_point end_time_point
      = std::chrono::system_clock::now();
    std::time_t end_time
      = std::chrono::system_clock::to_time_t( end_time_point );
 
    if ( !interrupted ) {
      MARLEY_LOG( NOTICE, "app" ) << "Generated " << ( ev_count - 1
        - num_old_events ) << " event(s) successfully";
      std::cout << "MARLEY terminated normally on ";
      }
    else {
      MARLEY_LOG( NOTICE, "app" ) << "Generation interrupted after "
        << ( ev_count - 1 - num_old_events ) << " event(s)";
      std::cout << "MARLEY was interrupted by the user on ";
    }
    std::cout << put_time( std::localtime(&end_time), "%c %Z" ) << '\n';
 
    return true;
  }
 
  catch ( const std::exception& error ) {
    if ( exception_needs_reset_terminal && g_status_region_active ) {
      reset_terminal( g_fallback_mode ? 0 : num_status_lines,
        /*clear_status=*/false );
    }
 
    // Write out the buffered event (if any) that was successfully completed
    // before the exception occurred. Attach the generator state string
    // so that the MARLEY job can be restarted from the last successful
    // event for easier debugging.
    // NOTE: The buffered event was fully created before the exception
    // occurred, so no exceptions are expected to be thrown in this block.
    // Just in case, we wrap it with an additional try/catch to inform
    // the user if writing out the buffered event fails.
    try {
      if ( buffered_event ) {
        marley::Generator::add_state_to_event( *buffered_event,
          cached_generator_state );
        for ( const auto& file : output_files ) {
          file->write_event( buffered_event.get() );
        }
      }
    } catch ( const std::exception& except ) {
      MARLEY_LOG( WARN, "app" ) << std::flush << "Output of buffered"
        " MARLEY event and its generator state failed";
      MARLEY_LOG( ERROR, "app" ) << except.what();
    }
 
    MARLEY_LOG( ERROR, "app" ) << std::flush << error.what();
  }
 
  return false;
}

References marley::Generator::add_state_to_event(), and cmd_help().

Referenced by execute().

cmd_help()

bool marley::CommandHandler::cmd_help ( std::deque< std::string > & args )

staticprotected

Display top-level or command-specific help messages.

Definition at line 24 of file cmd_help.cc.

                                                                 {
  if ( args.empty() ) {
    marley::CommandHandler::print_top_level_help();
    return true;
  }
 
  if ( args.size() > 1u ) {
    std::cerr << "marley help: too many arguments\n";
    return false;
  }
 
  // If we've made it here, then the help command has exactly one argument
  // which corresponds to a command name or the -h/--help options
  std::string command_name = args.front();
 
  // These options are considered synonyms of the help command itself
  if ( command_name == "-h" || command_name == "--help" ) {
    command_name = "help";
  }
 
  auto cmd_iter = command_map_.find( command_name );
  if ( cmd_iter != command_map_.end() ) {
    cmd_iter->second.print_help_();
    return true;
  }
 
  std::cerr << "marley: unknown command '" << command_name << "'\n";
  std::cerr << "Run 'marley help' for a list of available commands.\n";
  return false;
}

References command_map_, and print_top_level_help().

Referenced by cmd_convert(), cmd_decay(), cmd_generate(), cmd_print(), cmd_reweight(), and cmd_xsec().

cmd_print()

bool marley::CommandHandler::cmd_print ( std::deque< std::string > & args )

staticprotected

Print existing MARLEY events in a human-readable format.

Definition at line 105 of file cmd_print.cc.

                                                                  {
 
  std::string first_arg;
  if ( !args.empty() ) first_arg = args.front();
 
  if ( first_arg.empty() || first_arg == "-h" || first_arg == "--help" ) {
    args.clear();
    args.push_front( "print" );
    return marley::CommandHandler::cmd_help( args );
  }
 
  PrintFormat format = PrintFormat::Pretty;
  if ( first_arg == "pretty" ) {
    // Pretty is the default format (set above), so just
    // drop the format specifier from the input arguments
    args.pop_front();
  }
  else if ( first_arg == "hepmc3" ) {
    format = PrintFormat::HepMC3;
    args.pop_front();
  }
  else if ( first_arg == "legacy" ) {
    format = PrintFormat::Legacy;
    args.pop_front();
  }
 
  // If there are no input files listed, print the help message
  // and signal that an error condition was encountered
  if ( args.empty() ) {
    args.push_front( "print" );
    marley::CommandHandler::cmd_help( args );
    return false;
  }
 
  // Now do the actual printing by iterating over the events in each
  // input file specified in the remaining command-line arguments
  for ( const auto& file_name : args ) {
    marley::EventFileReader reader( file_name );
    HepMC3::GenEvent ev;
    int event_number = 0;
    while ( reader >> ev ) {
      if ( format == PrintFormat::Pretty ) {
        marley_hepmc3::print_event( ev );
      }
      else if ( format == PrintFormat::HepMC3 ) {
        std::cout << ev;
      }
      else {
        // Legacy format
        print_event_info( ev, event_number );
        ++event_number;
      }
    }
  }
  return true;
}

References cmd_help().

cmd_reweight()

bool marley::CommandHandler::cmd_reweight ( std::deque< std::string > & args )

staticprotected

Reweight existing MARLEY events.

Definition at line 40 of file cmd_reweight.cc.

                                                                     {
 
  // If we have fewer than two arguments, decide whether the
  // user intended to request help with this command
  if ( args.size() < 2u ) {
    std::string first_arg;
    if ( !args.empty() ) first_arg = args.front();
 
    // Print the help message either way
    args.clear();
    args.push_front( "reweight" );
    marley::CommandHandler::cmd_help( args );
 
    // Return a boolean status based on whether the help message was
    // explicitly requested (normal behavior) or not (an error condition)
    if ( first_arg == "-h" || first_arg == "--help" ) return true;
    return false;
  }
 
  // Extract the configuration file name and collect all input files
  std::string config_file_name( args.front() );
  args.pop_front();
  std::vector< std::string > input_files( args.begin(), args.end() );
 
  // Load the reweight configuration
  marley::JSON rw_config = marley::JSON::load_file( config_file_name );
  if ( !rw_config.has_key("weights") ) throw marley::Error( "Missing"
    " \"weights\" key in marley reweight configuration file \""
    + config_file_name + "\"" );
 
  const auto& json_weights = rw_config.at( "weights" );
 
  // Read the first event from the first input file to extract the run
  // information needed to reconstruct the Generator and check weight names.
  marley::EventFileReader first_reader( input_files[0] );
  HepMC3::GenEvent first_ev;
  if ( !(first_reader >> first_ev) ) {
    throw marley::Error( "Failed to read the first event from input file \""
      + input_files[0] + "\". The file may be empty or corrupt." );
  }
 
  auto first_run_info = first_ev.run_info();
  const std::vector< std::string > wgt_names = first_run_info->weight_names();
 
  // Reconstruct the original Generator from the saved configuration
  auto prior_config_str = first_run_info->attribute< HepMC3::StringAttribute >(
    "MARLEY.JSONconfig" );
 
  if ( !prior_config_str ) {
    throw marley::Error( "Failed to retrieve previous generator"
      " configuration from the input file \"" + input_files[0] + "\"" );
  }
 
  auto prior_json_config = marley::JSON::load( prior_config_str->value() );
  marley::JSONConfig jc( prior_json_config );
  auto gen = std::make_unique< marley::Generator >( jc.create_generator() );
 
  // Create the Weighter and check for name conflicts
  marley::Weighter weighter( json_weights, *gen );
  weighter.set_use_cv_weight( false );
 
  auto& calc_vec = weighter.get_weight_calculators();
 
  for ( const auto& wc : calc_vec ) {
    if ( std::find( wgt_names.cbegin(), wgt_names.cend(), wc->name() )
      != wgt_names.cend() )
    {
      throw marley::Error( "Weight name \"" + wc->name()
        + "\" from the reweight configuration file \"" + config_file_name
        + "\" conflicts with an existing weight in the input file" );
    }
  }
 
  // Prepend TrivialWeightCalculators for the existing weight names so that
  // the Weighter preserves them in the output. Iterate in reverse order
  // and insert at the beginning to maintain the original ordering.
  for ( auto riter = wgt_names.crbegin();
    riter != wgt_names.crend(); ++riter )
  {
    const auto& w_name = *riter;
    marley::JSON temp_json;
    temp_json[ "name" ] = w_name;
    auto w_calc = std::make_shared< marley
      ::TrivialWeightCalculator >( temp_json );
    calc_vec.insert( calc_vec.begin(), w_calc );
  }
 
  auto full_name_vec = weighter.get_weight_names();
 
  // Read output settings from the optional "reweight" section (if present)
  marley::JSON rw_section;
  bool has_rw_section = false;
  if ( rw_config.has_key("reweight") ) {
    const marley::JSON& rw_section_ref = rw_config.at( "reweight" );
    if ( !rw_section_ref.is_object() ) throw marley::Error(
      "The \"reweight\" section in the marley reweight configuration"
      " file \"" + config_file_name + "\" must be a JSON object" );
    rw_section = rw_section_ref;
    has_rw_section = true;
  }
 
  std::vector< std::shared_ptr<marley::OutputFile> > output_files;
 
  if ( has_rw_section && rw_section.has_key("output") ) {
    marley::JSON output_set = rw_section.at( "output" );
    if ( !output_set.is_array() ) throw marley::Error( "The"
      " \"output\" key in the reweighting configuration must have a value"
      " that is a JSON array." );
    else for ( const auto& el : output_set.array_range() ) {
      if ( el.has_key("mode") ) {
        std::string mode_str = el.at( "mode" ).to_string();
        if ( mode_str != "overwrite" ) throw marley::Error( "Only the"
          " \"overwrite\" output file mode is allowed for a reweighting"
          " job." );
      }
      output_files.push_back( marley::OutputFile::make_OutputFile(el) );
    }
  }
  else {
    std::string out_config_str = "{ format: \"ascii\","
      " file: \"reweighted_events.hepmc3\", mode: \"overwrite\" }";
    auto out_config = marley::JSON::load( out_config_str );
 
    output_files.push_back( marley::OutputFile::make_OutputFile(out_config) );
  }
 
  // Build the reweighted GenRunInfo from a copy of the first file's run info
  bool multi_file = ( input_files.size() > 1 );
  auto reweighted_run_info = std::make_shared< HepMC3::GenRunInfo >(
    *first_run_info );
  reweighted_run_info->set_weight_names( full_name_vec );
 
  // For multi-file reweight, strip the RNG seed to prevent unsafe resume.
  // Single-file reweight preserves the seed so that resume remains possible
  // (the accumulated Weighter will be reconstructed from the saved reweight
  // provenance attributes when needed).
  if ( multi_file ) reweighted_run_info->remove_attribute(
    "MARLEY.RNGseed" );
 
  // Save the reweight configuration as run info provenance attributes
  {
    int rw_index = 0;
    auto count_attr = first_run_info->attribute< HepMC3::IntAttribute >(
      "MARLEY.ReweightConfig.count" );
    if ( count_attr ) rw_index = count_attr->value();
 
    // Build a combined provenance object with the weights array and
    // (if present) the reweight section containing output settings
    marley::JSON prov_obj = marley::JSON::object();
    prov_obj["weights"] = json_weights;
    if ( has_rw_section ) {
      prov_obj["reweight"] = rw_section;
    }
 
    reweighted_run_info->add_attribute(
      "MARLEY.ReweightConfig." + std::to_string( rw_index ),
      std::make_shared< HepMC3::StringAttribute >(
        prov_obj.dump_string() ) );
 
    reweighted_run_info->add_attribute(
      "MARLEY.ReweightConfig.count",
      std::make_shared< HepMC3::IntAttribute >( rw_index + 1 ) );
  }
 
  // Process all events across all input files
  int event_count = 0;
  for_each_event( input_files,
    [ & ]( HepMC3::GenEvent& ev, bool /*first_event*/,
      double /*flux_avg_xsec*/, const auto& /*first_info*/ )
    {
      std::cout << "Event " << event_count << '\n';
 
      // Save the original weight values before set_run_info resizes
      // the event's weight vector to match the reweighted run info.
      auto orig_weights = ev.weights();
 
      // Apply the reweighted GenRunInfo. HepMC3's set_run_info resizes
      // m_weights to match the weight_names count, filling with 1.0.
      ev.set_run_info( reweighted_run_info );
 
      // Restore the original weight values into the first slots
      for ( size_t i = 0; i < orig_weights.size(); ++i )
        ev.weights()[ i ] = orig_weights[ i ];
 
      // Compute the new weight values
      weighter.process_event( ev, *gen );
 
      // Write the event to all output files
      for ( const auto& file : output_files )
        file->write_event( &ev );
 
      ++event_count;
    } );
 
  return true;
}

References cmd_help(), marley::Weighter::get_weight_calculators(), marley::Weighter::get_weight_names(), marley::Weighter::process_event(), HepMC3::GenEvent::run_info(), HepMC3::GenEvent::set_run_info(), marley::Weighter::set_use_cv_weight(), HepMC3::IntAttribute::value(), and HepMC3::GenEvent::weights().

cmd_summarize()

bool marley::CommandHandler::cmd_summarize ( std::deque< std::string > & args )

staticprotected

Summarize an existing sample of MARLEY events as a ROOT TTree.

Definition at line 46 of file cmd_summarize.cc.

{
  std::cerr << "marley: the 'summarize' command requires linking to ROOT.";
  std::cerr << "Please rebuild MARLEY against ROOT and try again.\n";
  return false;
}

cmd_xsec()

bool marley::CommandHandler::cmd_xsec ( std::deque< std::string > & args )

staticprotected

Tabulate energy-dependent total cross section values.

Definition at line 39 of file cmd_xsec.cc.

                                                                 {
 
  std::string output_path;
  std::string config_file_path;
  bool force = false;
 
  while ( !args.empty() ) {
    std::string arg = args.front();
    args.pop_front();
 
    if ( arg == "-o" || arg == "--output" ) {
      if ( args.empty() ) {
        std::cerr << "marley xsec: missing argument after '" << arg << "'\n";
        return false;
      }
      output_path = args.front();
      args.pop_front();
    }
    else if ( arg == "-f" || arg == "--force" ) {
      force = true;
    }
    else if ( arg == "-h" || arg == "--help" ) {
      args.clear();
      args.push_front( "xsec" );
      return marley::CommandHandler::cmd_help( args );
    }
    else if ( arg.front() == '-' ) {
      std::cerr << "marley xsec: unrecognized option '" << arg << "'\n";
      return false;
    }
    else if ( config_file_path.empty() ) {
      config_file_path = arg;
    }
    else {
      std::cerr << "marley xsec: unexpected extra argument '"
        << arg << "'\n";
      return false;
    }
  }
 
  if ( output_path.empty() ) {
    std::cerr << "marley xsec: missing required output file\n";
    args.push_front( "xsec" );
    marley::CommandHandler::cmd_help( args );
    return false;
  }
 
  if ( config_file_path.empty() ) {
    std::cerr << "marley xsec: missing required configuration file\n";
    args.push_front( "xsec" );
    marley::CommandHandler::cmd_help( args );
    return false;
  }
 
  if ( !force ) {
    std::ifstream temp_stream( output_path );
    if ( temp_stream ) {
      bool overwrite = marley_utils::prompt_yes_no(
        "Really overwrite " + output_path + '?');
      if ( !overwrite ) {
        std::cout << "Total cross section dump aborted.\n";
        return true;
      }
    }
  }
 
  std::ofstream out_file( output_path );
 
  marley::JSONConfig config( config_file_path );
  marley::Generator gen = config.create_generator();
 
  double KEmin = DEFAULT_KE_MIN;
  double KEmax = DEFAULT_KE_MAX;
  int num_steps = DEFAULT_NUM_STEPS;
  int projectile_pdg = DEFAULT_PDG;
 
  const marley::JSON& json = config.get_json();
 
  if ( json.has_key("xsec") ) {
    const marley::JSON& xsec_settings = json.at( "xsec" );
 
    if ( xsec_settings.has_key("KEmin") ) {
      bool ok = false;
      KEmin = xsec_settings.at("KEmin").to_double( ok );
      if ( !ok ) throw marley::Error("Unrecognized KEmin value "
        + xsec_settings.at("KEmin").to_string() + " encountered in the"
        " \"xsec\" section of the job configuration file.");
    }
 
    if ( xsec_settings.has_key("KEmax") ) {
      bool ok = false;
      KEmax = xsec_settings.at("KEmax").to_double( ok );
      if ( !ok ) throw marley::Error("Unrecognized KEmax value "
        + xsec_settings.at("KEmax").to_string() + " encountered in the"
        " \"xsec\" section of the job configuration file.");
    }
 
    if ( xsec_settings.has_key("steps") ) {
      bool ok = false;
      num_steps = xsec_settings.at("steps").to_long( ok );
      if ( !ok ) throw marley::Error("Unrecognized steps value "
        + xsec_settings.at("steps").to_string() + " encountered in the"
        " \"xsec\" section of the job configuration file.");
    }
 
    if ( xsec_settings.has_key("pdg") ) {
      bool ok = false;
      projectile_pdg = xsec_settings.at("pdg").to_long( ok );
      if ( !ok ) throw marley::Error("Unrecognized pdg value "
        + xsec_settings.at("pdg").to_string() + " encountered in the"
        " \"xsec\" section of the job configuration file.");
    }
  }
 
  double KE = KEmin;
  int steps = num_steps;
 
  if ( steps <= 1 ) {
    double xsec = gen.total_xs( projectile_pdg, KE );
    xsec *= marley_utils::hbar_c2 * marley_utils::fm2_to_minus40_cm2 * 1e2;
 
    out_file << KE << ' ' << xsec << '\n';
 
    MARLEY_LOG( INFO, "app" ) << "KE = " << KE
      << " MeV, abundance-weighted total xsec = "
      << xsec << " × 10^{-42} cm^2 / atom";
  }
  else {
    double delta = ( KEmax - KEmin ) / ( steps - 1 );
    for ( int s = 0; s < steps; ++s ) {
      KE = KEmin + s * delta;
      double xsec = gen.total_xs( projectile_pdg, KE );
      xsec *= marley_utils::hbar_c2 * marley_utils::fm2_to_minus40_cm2 * 1e2;
 
      out_file << KE << ' ' << xsec << '\n';
 
      MARLEY_LOG( INFO, "app" ) << "KE = " << KE
        << " MeV, abundance-weighted total xsec = "
        << xsec << " × 10^{-42} cm^2 / atom";
    }
  }
 
  return true;
}

References cmd_help(), and marley::Generator::total_xs().

execute()

bool marley::CommandHandler::execute

(

)

Execute the requested command based on the command-line arguments

Returns

true if the command was successful, false otherwise

Definition at line 188 of file CommandHandler.cc.

                                   {
 
  // If we don't have any command-line arguments, then just print the
  // standard top-level help message
  if ( cmds_.empty() ) {
    return this->print_top_level_help();
  }
 
  // Otherwise, get the first argument which should correspond to a command
  // or one of the top-level options
  std::string subcmd = cmds_.front();
 
  // Reassign some synonyms to their corresponding commands that appear in the
  // map of accepted values
  if ( subcmd == "--version" || subcmd == "-v" ) {
    subcmd = "version";
  }
  else if ( subcmd == "--help" || subcmd == "-h" ) {
    subcmd = "help";
  }
 
  auto cmd_iter = command_map_.find( subcmd );
  if ( cmd_iter != command_map_.end() ) {
    // The user provided an explicit command, so drop it from the
    // deque before delegating to the appropriate function. We no longer need to
    // resolve the command name.
    cmds_.pop_front();
    // Call the function corresponding to the chosen command
    try {
      return cmd_iter->second.cmd_( cmds_ );
    } catch ( const std::exception& e ) {
      // If we encountered an uncaught exception, log the error message
      MARLEY_LOG( ERROR, "app" ) << std::flush << e.what();
      return false;
    }
  }
 
  // The 'marley' command is an easter egg that doesn't appear in the official
  // list
  if ( subcmd == "marley" ) {
    std::cout << marley_utils::marley_pic;
    return true;
  }
 
  // The default command is 'generate', so if the user didn't explicitly
  // provide it and didn't use an option prefix, then assume that the user
  // intended 'generate'
  if ( !subcmd.empty() && subcmd[0] != '-' ) {
    return this->cmd_generate( cmds_ );
  }
 
  std::cerr << "marley: unknown option '" << subcmd << "'\n";
  std::cerr << "Run 'marley help' for a list of available commands.\n";
  return false;
}

References cmd_generate(), cmds_, command_map_, and print_top_level_help().

print_top_level_help()

bool marley::CommandHandler::print_top_level_help ( )

static

Print the top-level help message by aggregating the command summaries from the map

Definition at line 168 of file CommandHandler.cc.

                                                {
  std::cout << "Usage: marley <command> [options]\n\n"
    << "Commands:\n";
 
  for ( const auto& [name, info] : command_map_ ) {
    std::cout << "  " << std::left << std::setw(12) << name
      << info.summary_;
    if ( info.requires_root_ ) std::cout << " [requires ROOT]";
    std::cout << '\n';
  }
 
  std::cout << "\nOptions:\n"
    << "  -h, --help     Show top-level help\n"
    << "  -v, --version  Print version information\n";
  std::cout << "\nRun 'marley help <command>' or 'marley <command> --help' for"
    << " details.\n"
    << "MARLEY home page: <https://www.marleygen.org>\n";
  return true;
}

References command_map_.

Referenced by cmd_help(), and execute().

Member Data Documentation

cmds_

std::deque< std::string > marley::CommandHandler::cmds_

protected

Stores the command-line arguments with the executable name removed from the front

Definition at line 67 of file CommandHandler.hh.

Referenced by execute().

command_map_

const marley::CommandHandler::CommandMap marley::CommandHandler::command_map_

staticprotected

Map containing information about recognized commands handled by the marley executable

Definition at line 136 of file CommandHandler.hh.

Referenced by cmd_help(), execute(), and print_top_level_help().

---

The documentation for this class was generated from the following files:

• /home/sjg/Desktop/marley/include/marley/CommandHandler.hh
• /home/sjg/Desktop/marley/src/app/cmd_convert.cc
• /home/sjg/Desktop/marley/src/app/cmd_decay.cc
• /home/sjg/Desktop/marley/src/app/cmd_generate.cc
• /home/sjg/Desktop/marley/src/app/cmd_help.cc
• /home/sjg/Desktop/marley/src/app/cmd_print.cc
• /home/sjg/Desktop/marley/src/app/cmd_reweight.cc
• /home/sjg/Desktop/marley/src/app/cmd_summarize.cc
• /home/sjg/Desktop/marley/src/app/cmd_xsec.cc
• /home/sjg/Desktop/marley/src/app/CommandHandler.cc