slotted_request.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_SOLVERS_SLOTTED_REQUEST_H
#define LINE_SOLVERS_SLOTTED_REQUEST_H
 
/**
 * @file
 * @ingroup line_solvers
 * Port of `matlab/src/solvers/line_slotted_request.m`: the one reading of the
 * discrete-time switch shared by SolverNC, SolverMAM and SolverLDES, so the
 * same options mean the same thing to all three.
 *
 * MODE is "discrete" when `config.slotted` is true or `config.timescale` is
 * "discrete", "continuous" when the timescale is "continuous", and "auto"
 * otherwise. Asking for slotted together with a continuous timescale is an
 * error. What "auto" means is the solver's business: MAM infers the time scale
 * from the laws (`sn_is_discrete_time`), NC and LDES read it as continuous.
 *
 * SLOT LENGTH is `config.slotlength` (default 1), the lattice unit d in model
 * time units. Every interarrival and service sample must be a positive multiple
 * of d; a law keeps its meaning whatever d is.
 */
 
#include <algorithm>
#include <cctype>
#include <cmath>
#include <string>
 
#include "line/util/error.h"
 
namespace line {
namespace solvers {
 
/** The resolved time-scale request. */
struct SlottedRequest {
    std::string mode = "auto";  ///< "auto", "discrete" or "continuous"
    double slot_length = 1.0;   ///< the lattice unit d in model time units
    bool discrete() const { return mode == "discrete"; }
};
 
/**
 * Resolves `timescale` (empty reads as "auto"), `slotted` and `slotlength` as
 * they come from `options.config`.
 */
inline SlottedRequest slotted_request(std::string timescale, bool slotted, double slotlength) {
    if (timescale.empty()) timescale = "auto";
    std::transform(timescale.begin(), timescale.end(), timescale.begin(),
                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    if (timescale != "auto" && timescale != "discrete" && timescale != "continuous")
        throw InputError(ErrorKind{"Option"},
                         "options.config.timescale must be 'auto', 'discrete' or 'continuous'.");
    if (!std::isfinite(slotlength) || slotlength <= 0)
        throw InputError(ErrorKind{"Option"},
                         "options.config.slotlength must be a positive finite scalar.");
    if (slotted && timescale == "continuous")
        throw InputError(ErrorKind{"Option"},
                         "options.config.slotted=true asks for a discrete time scale but "
                         "options.config.timescale='continuous' asks for a continuous one.");
    SlottedRequest out;
    out.mode = slotted ? std::string("discrete") : timescale;
    out.slot_length = slotlength;
    return out;
}
 
}  // namespace solvers
}  // namespace line
 
#endif  // LINE_SOLVERS_SLOTTED_REQUEST_H