Enum Commands 

pub enum Commands {
    Display(Display),
    Duplicate(Duplicate),
    Set(Set),
    Import(Import),
    Save(Save),
    Run(Run),
    StartCommandsBlock(StartCommandsBlock),
    FinishCommandsBlock,
    Remove(Remove),
    Integrate(Integrate),
    Generate(Generate),
    Select(Select),
    Quit(SaveState),
    Inspect(Inspect),
    Approach(Approach),
    Evaluate(Evaluate),
    Renormalize(Renormalize),
    Bench {
        samples: usize,
        process: ProcessRef,
        integrand_name: String,
        n_cores: usize,
    },
    Profile(Profile),
    Batch {
        process_file: PathBuf,
        batch_input_file: PathBuf,
        name: String,
        output_name: String,
    },
    Shell(Shell),
}

Variants

Display(Display)

Inspect models, processes, integrands, settings, and named session data.

Duplicate(Duplicate)

Copy generated data to a new process or integrand name.

Set(Set)

Change global, runtime, model, or process settings.

Import(Import)

Import models or previously generated graphs into the active state.

Save(Save)

Export graph data, standalone evaluators, schemas, or the current state.

Run(Run)

Execute a stored command block or an inline command list.

StartCommandsBlock(StartCommandsBlock)

Begin recording subsequent commands under a reusable block name.

FinishCommandsBlock

Stop recording commands and store the active command block.

Remove(Remove)

Remove generated processes from the active state.

Integrate(Integrate)

Integrate one or more generated process integrands.

Generate(Generate)

Select(Select)

Select graph groups and write the selection to a new process or integrand.

Quit(SaveState)

End the interactive GammaLoop session without executing further commands.

Inspect(Inspect)

Inspect integrand contributions at one phase-space point or momentum configuration.

Approach(Approach)

Sample an integrand while approaching a phase-space point along selected scaling axes.

Evaluate(Evaluate)

Evaluate a vacuum amplitude analytically or numerically with Vakint.

Renormalize(Renormalize)

Compute and export ultraviolet renormalization contributions for an amplitude.

Bench

Measure raw integrand evaluation throughput over random samples and selected worker counts.

Fields

samples: usize

Number of random samples to evaluate

process: ProcessRef

Process reference: #<id>, name:<name>, or <id>/<name>

integrand_name: String

The integrand name to benchmark

n_cores: usize

Number of cores to parallelize over

Profile(Profile)

Profile ultraviolet or infrared scaling limits of a generated integrand.

Batch

Evaluate a process-definition file against an HPC batch input and write named results.

Fields

process_file: PathBuf

Process-definition file used to construct the batch evaluator.

batch_input_file: PathBuf

Batch input file containing the evaluation points or jobs to execute.

name: String

Logical batch name used in generated output metadata.

output_name: String

Base name assigned to the batch result output.

Shell(Shell)

Run an operating-system shell command from the interactive GammaLoop session.

Implementations

impl Commands

pub fn run( self, state: &mut State, run_history: &mut RunHistory, global_cli_settings: &mut CLISettings, default_runtime_settings: &mut RuntimeSettings, ) -> Result<CommandExecution, Report>

Trait Implementations

impl Clone for Commands

fn clone(&self) -> Commands

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Commands

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Commands

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl FromStr for Commands

type Err = Report

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl JsonSchema for Commands

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Commands

fn eq(&self, other: &Commands) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Commands

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Commands

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand