Package jline.solvers.ldes

Class SolverLDES

java.lang.Object
jline.solvers.Solver
jline.solvers.NetworkSolver
jline.solvers.ldes.SolverLDES
Direct Known Subclasses:
LDES
public class SolverLDES extends NetworkSolver

  • Field Details

    • threadPool

      public ExecutorService threadPool
      Thread pool for parallel replication execution

  • Constructor Details

    • SolverLDES

      public SolverLDES(Network model)
      Constructs a SolverLDES with the given model using default options.
      Parameters:
      model - the queueing network model to solve

    • SolverLDES

      public SolverLDES(LayeredNetwork model)
      Constructs a SolverLDES with the given LayeredNetwork model using default options.
      Parameters:
      model - the layered queueing network model to solve

    • SolverLDES

      public SolverLDES(LayeredNetwork model, Object... args)
      Constructs a SolverLDES with the given LayeredNetwork model and variable arguments.
      Parameters:
      model - the layered queueing network model to solve
      args - variable arguments for solver options

    • SolverLDES

      public SolverLDES(LayeredNetwork model, SolverOptions options)
      Constructs a SolverLDES with the given LayeredNetwork model and options.
      Parameters:
      model - the layered queueing network model to solve
      options - solver configuration options

    • SolverLDES

      public SolverLDES(Network model, Object... args)
      Constructs a SolverLDES with the given model and variable arguments.
      Parameters:
      model - the queueing network model to solve
      args - variable arguments for solver options

    • SolverLDES

      public SolverLDES(Network model, String method)
      Constructs a SolverLDES with the given model and method.
      Parameters:
      model - the queueing network model to solve
      method - the solution method to use

    • SolverLDES

      public SolverLDES(Network model, SolverOptions options)
      Constructs a SolverLDES with the given model and options.
      Parameters:
      model - the queueing network model to solve
      options - solver configuration options

    • SolverLDES

      public SolverLDES(String filename)
      Load a JMT model file (.jsimg/.jsim/.jsimw/.jmva) and simulate with LDES.
      Parameters:
      filename - path to the JMT model file

    • SolverLDES

      public SolverLDES(String filename, Object... args)
      Load a JMT model file (.jsimg/.jsim/.jsimw/.jmva) and simulate with LDES, accepting variable option arguments (e.g., "seed", 23000, "samples", 50000).
      Parameters:
      filename - path to the JMT model file
      args - variable arguments for solver options

    • SolverLDES

      public SolverLDES(Network model, NetworkSolver initSolver, Object... args)
      Constructs a SolverLDES that warm-starts the simulation from the steady-state distribution computed by another solver. The auxiliary solver is used to find the stationary distribution of the model; the resulting distribution decides the initial state of the simulation (see initFromSolver(NetworkSolver)).
      Parameters:
      model - the queueing network model to solve
      initSolver - auxiliary solver used to compute the steady-state distribution
      args - variable arguments for solver options

  • Method Details

    • initFromSolver

      public SolverLDES initFromSolver(NetworkSolver initSolver)
      Warm-start the simulation from the steady-state solution of an auxiliary solver. If the auxiliary solver is a SolverCTMC, the exact stationary distribution over the aggregate state space is computed and the initial state is set to the mode of that distribution (the most probable aggregate state). For any other network solver, the steady-state mean queue lengths are used instead and rounded to an integer placement that conserves each closed-class population. The placement is applied as the model initial state via initFromMarginal, as for every other state-driven solver, and LDES starts the run from it. Note that this modifies the initial state of the model object shared with any other solver instance. Since the simulation starts (approximately) in steady state, the transient removal filter is disabled (tranfilter = "fixed" with warmupfrac = 0), so every simulated sample contributes to the estimators.
      Overrides:
      initFromSolver in class NetworkSolver
      Parameters:
      initSolver - auxiliary solver used to compute the steady-state distribution
      Returns:
      this solver, for chaining

    • initFromJobs

      public SolverLDES initFromJobs(Matrix jobs)
      Start the simulation from a job-level initial state.

      jobs has one row per job, [station, class, remaining, elapsed, qage, sage, order, id], with 0-based station and class indexes. remaining is the service work the job still owes (-1 draws a fresh service time, -2 the residual given the attained service elapsed); qage and sage are the times already spent at the station and in the system; order ranks the jobs of a station, the first ones taking the servers; and id is an optional tag (-1 untagged). The layout is the one getFinalJobs() returns, so a run can be continued exactly where an earlier one stopped: s2.initFromJobs(s1.getFinalJobs()).

      Unlike Network.initFromMarginal, which restores counts only and so restarts every job with a fresh service, this keeps each job's residual work. It is LDES-specific, so it is held by the solver (options.init_jobs) rather than by the model, takes precedence over the model initial state and over options.init_sol, and enables options.track_jobs. Supported at FCFS queues, the PS family and Delays.

      Parameters:
      jobs - one row per job, at least the first seven columns
      Returns:
      this solver, for chaining

    • getFinalJobs

      public Matrix getFinalJobs()
      The jobs present at the end of the run, in the layout of initFromJobs(Matrix), so passing the result back restarts each job with its residual service work.

      Runs the analyzer with options.track_jobs when the current result carries no job state. A transient run (options.timespan) is read at its horizon. The departures of the tagged jobs are returned by getJobDepartures().

      Returns:
      one row [station, class, remaining, elapsed, qage, sage, order, id] per job

    • getJobDepartures

      public Matrix getJobDepartures()
      One row [id, station, class, time] per departure of a tagged initFromJobs(Matrix) job from the station it was placed at.
      Returns:
      the departures of the tagged jobs, empty when none was tagged

    • getThreadPool

      public ExecutorService getThreadPool()
      Returns the thread pool for parallel replication execution.
      Returns:
      the thread pool

    • getNumThreads

      public int getNumThreads()
      Returns the number of threads for parallel execution.
      Returns:
      the number of threads

    • setNumThreads

      public void setNumThreads(int numThreads)
      Sets the parallelism level for replication execution.
      Parameters:
      numThreads - number of parallel threads

    • getFeatureSet

      public static FeatureSet getFeatureSet()
      Returns the feature set supported by the LDES solver. Supports multiclass Jackson queueing networks with FCFS queues.
      Returns:
      the feature set supported by the LDES solver

    • getStruct

      public NetworkStruct getStruct()
      Returns the network structure for this solver.
      Returns:
      the network structure

    • getTranAvg

      public void getTranAvg()
      Performs a transient analysis of the model using discrete event simulation. The simulation is run for the time horizon specified in options.timespan. If options.timespan is not specified, it defaults to [0, 30/min_rate]. The number of replications is determined by LDESOptions.replications.
      Overrides:
      getTranAvg in class NetworkSolver

    • getAvg

      public SolverResult getAvg()
      Computes and returns average station metrics at steady-state. For LayeredNetwork models, this delegates to the LN-specific analyzer.
      Overrides:
      getAvg in class NetworkSolver
      Returns:
      solver result containing average metrics

    • listValidMethods

      public List<String> listValidMethods()
      Returns the list of valid solution methods for LDES.
      Returns:
      list of valid method names

    • listValidMethods

      public List<String> listValidMethods(Network model)
      Returns the list of valid solution methods for LDES.
      Parameters:
      model - the network model (unused, for interface compatibility)
      Returns:
      list of valid method names

    • supportsTransientAnalysis

      public boolean supportsTransientAnalysis()
      Description copied from class: Solver
      Does this solver produce transient averages, i.e. does getTranAvg return trajectories on a finite options.timespan? Declared false here and overridden by the solvers that populate result.Tran (Fluid, CTMC, LDES, JMT). It is a capability claim, not a state test: it must answer before any run has taken place, because the MAP/MMPP random-environment fallback uses it to decide whether the environment stages can be coupled by the mean-field analyzer (which needs getTranAvg) or only by the two steady-state limits.
      Overrides:
      supportsTransientAnalysis in class Solver
      Returns:
      true if the solver can return transient averages

    • closedPopulationWarnings

      public static List<String> closedPopulationWarnings(NetworkStruct sn, Matrix QN)
      Closed-chain population conservation check on a steady-state QN, ported from MATLAB's parseSteady.

      A closed chain must conserve its population in the reported queue lengths. Engine builds that drop blocked closed jobs at a finite-capacity station (pre-guard ldes.jar) leak population silently, and the reported means then describe a different model. FCR models are excluded (a WAITQ waiter is parked outside the station rows), and so are fork-join models (a forked job is counted once per sibling task, so the rows sum to more than the population by construction). A chain is flagged when |sum(QN) - N| > max(0.05*N, 0.05), NaN entries being omitted from the sum.

      Parameters:
      sn - the model's network struct
      QN - the (stations x classes) mean queue lengths returned by the engine
      Returns:
      one warning message per chain that fails the check, empty when none does

    • runAnalyzer

      public void runAnalyzer() throws IllegalAccessException, ParserConfigurationException, IOException
      Description copied from class: Solver
      Executes the solver algorithm to analyze the model. This abstract method must be implemented by concrete solver classes.
      Specified by:
      runAnalyzer in class Solver
      Throws:
      IllegalAccessException - if access to required resources is denied
      ParserConfigurationException - if XML parsing configuration fails
      IOException - if I/O operations fail

    • runMethodSpecificAnalyzer

      public SolverResult runMethodSpecificAnalyzer()
      Run the LDES analyzer with current options including init_sol. Called by SolverENV for transient analysis with initial conditions.
      Returns:
      SolverResult containing transient metrics (QNt, UNt, TNt, t)

    • supports

      public boolean supports(Network model)
      Description copied from class: Solver
      Checks if this solver supports the given network model. Default implementation returns true; subclasses should override to provide specific feature validation.
      Overrides:
      supports in class Solver
      Parameters:
      model - the network model to check
      Returns:
      true if the model is supported, false otherwise

    • isStochasticMethod

      public boolean isStochasticMethod(String method)
      LDES is a discrete-event simulator; all methods are stochastic.
      Overrides:
      isStochasticMethod in class Solver
      Parameters:
      method - the method name to classify
      Returns:
      true always

    • supports

      public boolean supports(LayeredNetwork model)
      Checks if the solver supports the given LayeredNetwork model.
      Parameters:
      model - the LayeredNetwork model to check
      Returns:
      true if the model is supported

    • getLNFeatureSet

      public static FeatureSet getLNFeatureSet()
      Returns the feature set supported by the LDES solver for LayeredNetwork models.
      Returns:
      the feature set supported for LQN models

    • getLNModel

      public LayeredNetwork getLNModel()
      Returns the LayeredNetwork model (if solving an LQN).
      Returns:
      the LayeredNetwork model, or null if solving a regular Network

    • getLNStruct

      public LayeredNetworkStruct getLNStruct()
      Returns the LayeredNetworkStruct (if solving an LQN).
      Returns:
      the LayeredNetworkStruct, or null if solving a regular Network

    • getAvgCacheTable

      public NetworkAvgCacheTable getAvgCacheTable()
      Cache performance table for a layered cache-queueing (LCQ) model: one row per CacheTask read (ItemEntry), reporting hit / delayed-hit / miss probabilities and rates. Mirrors the flat-network NetworkSolver.getAvgCacheTable() convention (delayed hits reported in their own column; reads = hits + misses + delayed hits). Returns an empty table for LQNs without a CacheTask.
      Overrides:
      getAvgCacheTable in class NetworkSolver
      Returns:
      cache performance table

    • getLNAvgThinkTime

      public Matrix getLNAvgThinkTime()
      Mean think time of every LQN element, at task indices and zero elsewhere.

      The time a thread of the task holds no request, per completion. The thread pool of a task is a closed cycle of one delay stage and one service stage, so its Little's law reads X(t)*Z(t) + sum_k B(t,k) = N(t); the simulation measures the occupancy B and the throughput X and this returns the Z that closes it. SolverLN arrives at the same quantity by iterating updateThinkTimes, which makes this the natural reference for it. Zero at a task whose threads are unbounded, which has no pool for the law to close on.

      Returns:
      [1 x nidx] think times, indexed as the LQN struct is
      Throws:
      RuntimeException - if not solving a LayeredNetwork model or results not available

    • getLNAvgCallUtil

      public Matrix getLNAvgCallUtil()
      Per-call occupancy of the called task's thread pool, in job units.

      Entry c is the mean number of threads of the callee held on behalf of call c: the B(t,k) term of the thread-pool law, whose caller classes are the calls reaching the task. Indexed by the call's own index in 0..ncalls-1 -- the one keying lsn.calltype and listed by lsn.callsof -- because calls sit outside the element index space that getLNAvgTable covers.

      Returns:
      [1 x ncalls] occupancies
      Throws:
      RuntimeException - if not solving a LayeredNetwork model or results not available

    • getLNAvgCallTput

      public Matrix getLNAvgCallTput()
      Rate at which each call is dispatched, counted at the caller.

      Counting at the caller rather than the callee is what lets an asynchronous call register: nobody waits for it, so it never returns. This is X(c) in the call-flow law X(c) = X(src(c))*y(c).

      Returns:
      [1 x ncalls] throughputs
      Throws:
      RuntimeException - if not solving a LayeredNetwork model or results not available

    • getLNAvgEntryClassUtil

      public Matrix getLNAvgEntryClassUtil()
      Occupancy contributed by each entry's own request stream, in job units.

      A reference task cycles on its own entries and an open arrival drives an entry from outside the model; the request that results holds a thread just as a call does, and so enters the thread-pool law as a caller class of its own. Indexed by local entry index, 0..nentries-1. Together with getLNAvgCallUtil() over the calls into a task, these are all the B(t,k) that task has.

      Returns:
      [1 x nentries] occupancies
      Throws:
      RuntimeException - if not solving a LayeredNetwork model or results not available

    • getAvgTable

      public NetworkAvgTable getAvgTable()
      Returns a table of average station metrics organized by job classes.

      Refused for a LayeredNetwork: the AvgTable is indexed by STATION and this solver holds LQN elements. The inherited implementation reaches for a NetworkStruct that an LQN solve never built, so without this the caller met a NullPointerException naming a field rather than the mistake. Its return type is NetworkAvgTable, so the layered table cannot be returned in its place -- ask getLNAvgTable() for that.

      Overrides:
      getAvgTable in class NetworkSolver
      Returns:
      table containing station-level metrics for each class

    • getCdfRespTLN

      public List<Matrix> getCdfRespTLN()
      Empirical response time distribution of every entry of a LayeredNetwork, measured on the simulated sample path.

      Counterpart of SolverLN.getCdfRespT(), and the SIMULATED answer to the same question: where SolverLN's moment3 pass fits an APH to three moments and convolves, this is the ecdf of the response times the run actually observed, so its tail is measured rather than extrapolated. The engine times each request from the instant the entry acquires a thread to the instant it replies -- the same interval RLN averages, which is why the mean of this law reproduces that row.

      Returns:
      one entry per entry of the LQN, in the entry-local index space (lsn.eshift + i). Each element is an (n x 2) matrix whose columns are [F(t), t], the column order every CDF getter in LINE uses, or null for an entry the run observed nothing at -- left empty rather than filled with a guess.
      Throws:
      RuntimeException - if not solving a LayeredNetwork model, or if the run retained no samples

    • getLNAvgTable

      public LayeredNetworkAvgTable getLNAvgTable()
      Returns average metrics for a LayeredNetwork model as a table. This method should be called after getAvg() for LayeredNetwork models.
      Returns:
      LayeredNetworkAvgTable containing average metrics per LQN element
      Throws:
      RuntimeException - if not solving a LayeredNetwork model or results not available

    • defaultOptions

      public static SolverOptions defaultOptions()
      Returns the default solver options for the LDES solver.
      Returns:
      Default solver options with SolverType.LDES

    • sample

      public Ret.SampleResult sample(StatefulNode node, int numEvents)
      Exact sample path of one node: one row per step, holding the LINE State of the node OCCUPIED UNTIL t[k], with the events of the node tagged at t[k], as in SolverSSA. Phase-level rows follow the LDES phase map (samplePath.phases), which is one phase for a law with no phase structure.
      Parameters:
      node - the stateful node to sample
      numEvents - number of rows (steps) to record
      Returns:
      the node's state rows, times and events

    • sampleAggr

      public Ret.SampleResult sampleAggr(StatefulNode node, int numEvents)
      Exact sample path of one node as per-class job counts (always available, also where the detailed rows are refused).
      Parameters:
      node - the stateful node to sample
      numEvents - number of rows (steps) to record
      Returns:
      the node's per-class counts, times and events

    • sampleSys

      public Ret.SampleResult sampleSys(int numEvents)
      Exact system sample path: one LINE State matrix per stateful node, all sharing the step times, and every event of the run.
      Overrides:
      sampleSys in class NetworkSolver
      Parameters:
      numEvents - number of rows (steps) to record
      Returns:
      the state rows of every stateful node, times and events

    • sampleSysAggr

      public Ret.SampleResult sampleSysAggr(int numEvents)
      Exact system sample path as per-class job counts per stateful node.
      Overrides:
      sampleSysAggr in class NetworkSolver
      Parameters:
      numEvents - number of rows (steps) to record
      Returns:
      the per-class counts of every stateful node, times and events

    • stream

      public Ret.SampleResult stream(StatefulNode node, StreamingOptions streamingOptions)
      Generates a sample path with streaming metrics pushed via OTLP.
      Parameters:
      node - The stateful node to sample
      streamingOptions - Configuration for streaming (endpoint, mode, frequency)
      Returns:
      SampleResult containing the state trajectory for the node

    • stream

      public Ret.SampleResult stream(StatefulNode node, int numEvents, StreamingOptions streamingOptions)
      Generates a sample path with streaming metrics pushed via OTLP.
      Parameters:
      node - The stateful node to sample
      numEvents - Number of time points to sample
      streamingOptions - Configuration for streaming (endpoint, mode, frequency)
      Returns:
      SampleResult containing the state trajectory for the node

    • streamAggr

      public Ret.SampleResult streamAggr(StatefulNode node, StreamingOptions streamingOptions)
      Generates an aggregated sample path with streaming metrics pushed via OTLP.
      Parameters:
      node - The stateful node to sample
      streamingOptions - Configuration for streaming (endpoint, mode, frequency)
      Returns:
      SampleResult containing the aggregated state trajectory

    • streamAggr

      public Ret.SampleResult streamAggr(StatefulNode node, int numEvents, StreamingOptions streamingOptions)
      Generates an aggregated sample path with streaming metrics pushed via OTLP.
      Parameters:
      node - The stateful node to sample
      numEvents - Number of time points to sample
      streamingOptions - Configuration for streaming (endpoint, mode, frequency)
      Returns:
      SampleResult containing the aggregated state trajectory

    • getStream

      public Collector getStream()
      Returns the current streaming collector, or null if not streaming.
      Returns:
      the streaming collector

    • getProb

      public Ret.ProbabilityResult getProb(StatefulNode node, Matrix state)
      Steady-state probability of a state at a node, read from the engine's exact joint-state residence-time histogram as the reference getProb.m. The state is marginalized to per-class counts, which is what the histogram records.
      Parameters:
      node - the stateful node to analyze; must be a station
      state - the state to evaluate (one per row, probabilities summed); null uses the model's current state
      Returns:
      fraction of simulated time spent in the state

    • getProb

      public Ret.ProbabilityResult getProb(int nodeIndex, Matrix state)
      Estimates state probability using node index.
      Overrides:
      getProb in class NetworkSolver
      Parameters:
      nodeIndex - Index of the stateful node
      state - The state vector to compute probability for
      Returns:
      Estimated probability of the specified state

    • getProb

      public Ret.ProbabilityResult getProb(StatefulNode node)
      Estimates state probability using current network state.
      Parameters:
      node - The stateful node to analyze
      Returns:
      Estimated probability of current network state at the node

    • getProbAggr

      public Ret.ProbabilityResult getProbAggr(StatefulNode node, Matrix stateAggr)
      Steady-state probability of a per-class job distribution at a node, read from the engine's exact residence-time histogram as the reference getProbAggr.m.
      Parameters:
      node - the stateful node to analyze; must be a station
      stateAggr - per-class job counts (one per row, probabilities summed); null aggregates the model's current state
      Returns:
      fraction of simulated time spent in the aggregated state

    • getProbAggr

      public Ret.ProbabilityResult getProbAggr(int nodeIndex, Matrix stateAggr)
      Estimates aggregated state probability using node index.
      Overrides:
      getProbAggr in class NetworkSolver
      Parameters:
      nodeIndex - Index of the stateful node
      stateAggr - The aggregated state vector to compute probability for
      Returns:
      Estimated probability of the specified aggregated state

    • getProbAggr

      public Ret.ProbabilityResult getProbAggr(StatefulNode node)
      Estimates aggregated state probability using current network state.
      Parameters:
      node - The stateful node to analyze
      Returns:
      Estimated probability of current aggregated network state at the node

    • getProbSys

      public Ret.ProbabilityResult getProbSys()
      Joint steady-state probability of the model's current state over every station, read from the engine's exact residence-time histogram as the reference getProbSys.m. The histogram records per-class counts, so this equals getProbSysAggr().
      Overrides:
      getProbSys in class NetworkSolver
      Returns:
      fraction of simulated time spent in the current joint state

    • getProbSysAggr

      public Ret.ProbabilityResult getProbSysAggr()
      Joint steady-state probability of the model's current aggregated state; the histogram is already per-class, so this is getProbSys(), as in the reference.
      Overrides:
      getProbSysAggr in class NetworkSolver
      Returns:
      fraction of simulated time spent in the current aggregated joint state

    • getAvgBusyPeriod

      public double getAvgBusyPeriod(int[] stations, int jobClass, int order)
      Mean busy period of order n for a set of stations, measured along the simulated sample path. A busy period of order n runs from the instant an arrival raises the jobs held by the set to n up to the instant the set falls back below n (H. Daduna, "Busy Periods for Subnetworks in Stochastic Networks: Mean Value Analysis", J. ACM 35(3), 1988). Periods in progress when the warmup ends are discarded, since their start is not observable.
      Parameters:
      stations - station indexes forming the subnetwork
      jobClass - class index, or -1 to count every class
      order - busy period order, 1 for the ordinary busy period
      Returns:
      mean busy period duration, NaN if no such period completed

    • getAvgReward

      public Map<String,Double> getAvgReward()
      Steady-state expected reward for every reward function defined on the model. The reward integral E[r] = (1/T) integral_0^T r(X(t)) dt is accumulated inside the discrete-event simulation on the exact integer joint state, so it is correct for nonlinear rewards (e.g. E[n^2]) and converges to the stationary expectation sum_s pi(s) r(s) computed exactly by the CTMC solver.
      Returns:
      map from reward name to expected reward value in steady state
      Throws:
      IllegalStateException - if no rewards are defined on the model

    • getAvgReward

      public double getAvgReward(String rewardName)
      Steady-state expected reward for a single named reward function.
      Returns:
      the expected reward value in steady state
      Throws:
      IllegalArgumentException - if the reward name is not defined

    • getTranReward

      public Map<String,double[]> getTranReward(String rewardName)
      Single-run transient reward trajectory r(X(t)) recorded along the simulated path. The associated time vector is available via getRewardTimeVector().
      Parameters:
      rewardName - optional reward name to filter; if null, all rewards are returned
      Returns:
      map from reward name to the reward time series
      Throws:
      IllegalStateException - if no rewards are defined on the model

    • getTranReward

      public Map<String,double[]> getTranReward()
      Transient reward trajectory for all reward functions.
      Returns:
      map from reward name to the reward time series

    • getRewardTimeVector

      public Matrix getRewardTimeVector()
      Time vector associated with getTranReward().
      Returns:
      the time points, or null if not available

    • getRewardNames

      public List<String> getRewardNames()
      Names of the reward functions defined on the model.
      Returns:
      list of reward names (empty if none are defined)

    • getStateHistogram

      public Matrix[] getStateHistogram()
      Runs the simulation with state-histogram export enabled and returns the exact joint-state residence-time histogram. Row i of the returned space matrix is an aggregated system state (CTMC stateSpaceAggr layout, station-major) and entry i of the time vector is its residence time. Host languages that cannot pass a Java reward function into the simulation use this to evaluate arbitrary Markov rewards: E[r] = sum_i (time_i / sum(time)) * r(state_i).
      Returns:
      a two-element array {space, time}; both null if the histogram is empty

    • getStateTrajectory

      public Matrix[] getStateTrajectory()
      Runs the simulation with state export enabled and returns the integer joint-state trajectory along the sampled path: {space, time} where row i of space is the aggregated state (CTMC stateSpaceAggr layout) at time[i]. Host languages evaluate their reward functions on each state to obtain the transient reward trajectory r(X(t)).
      Returns:
      a two-element array {space, time}; both null if unavailable

    • getCdfRespT

      public Ret.DistributionResult getCdfRespT()
      Empirical response time CDF, measured on the simulated sample path.

      A simulator must report what it observed: the base NetworkSolver implementation fabricates an exponential law with the right mean, which is an analytical fallback and says nothing about the tail. The LDES engine records every per-job response time, so the CDF here is the ecdf of those samples, exactly as the reference @SolverLDES/getCdfRespT.m. Each populated cell is an (n x 2) matrix of [F(t), t]; a (station, class) pair with no observation is left empty rather than filled with a guess.

      The reference dispatches a LayeredNetwork to getCdfRespTLN; here the two return types differ (DistributionResult versus a per-entry List<Matrix>), so a layered model is refused by name with the same redirection instead.

      Overrides:
      getCdfRespT in class NetworkSolver
      Returns:
      DistributionResult containing empirical CDFs for each station-class pair

    • getCdfRespT

      public Ret.DistributionResult getCdfRespT(AvgHandle R)
      Empirical response time CDF, handle form. The handle only names which metrics the caller wants; the engine records every (station, class) anyway, so it is accepted for signature compatibility and not read.
      Overrides:
      getCdfRespT in class NetworkSolver
      Parameters:
      R - response time handles, accepted for signature compatibility
      Returns:
      DistributionResult containing empirical CDFs for each station-class pair

    • getPerctRespT

      public List<LDESPercentileResult> getPerctRespT()
      Response time percentiles with the default levels 10, 25, 50, 75, 90, 95 and 99.
      Returns:
      one entry per (station, class) pair with recorded response times
      See Also:

    • getPerctRespT

      public List<LDESPercentileResult> getPerctRespT(double[] percentiles)
      Steady-state response time percentiles measured on the simulated sample path, each with a confidence interval.

      The input is the departure-ordered sequence of per-job response times of each (station, class), warmup included, since the procedures detect and delete the warmup themselves. A single run is analysed by FQUEST (Lolos et al., WSC 2023). A replicated run (replications >= 2, or method parallel) is analysed by FIRQUEST (Lolos et al., WSC 2025) on the per-replication sequences, each trimmed at the END to the shortest of them, because FIRQUEST needs equal lengths and cutting the tail leaves the warmup at the start and the replications independent.

      The confidence level is options.confint when it is set, 0.95 otherwise. A pair with too few observations for the procedure gets the empirical quantile of all its samples and NaN interval fields, with a warning; a pair with no observation (e.g. the Source) is omitted.

      Parameters:
      percentiles - percentile levels, fractions in (0,1) or percentages in (0,100)
      Returns:
      one entry per (station, class) pair with recorded response times

    • getPerctRespT

      public Matrix getPerctRespT(double[] percentiles, String method)
      Percentiles by a named method. Only forktail is served here, by the base implementation, because its Matrix return type cannot carry an interval; the measured percentiles with FQUEST/FIRQUEST confidence intervals are getPerctRespT(double[]).
      Overrides:
      getPerctRespT in class NetworkSolver
      Parameters:
      percentiles - percentile levels, fractions in (0,1) or percentages in (0,100)
      method - "forktail"
      Returns:
      matrix [classes x percentiles] of ForkTail predictions

    • getTranCdfRespT

      public Ret.DistributionResult getTranCdfRespT()
      Returns cumulative distribution functions of response times during transient analysis. The engine keeps one set of per-job response time samples, so this is the same measured ecdf getCdfRespT() reports, under the transient getter's name.
      Overrides:
      getTranCdfRespT in class NetworkSolver
      Returns:
      DistributionResult containing empirical CDFs for each station-class pair

    • getTranCdfRespT

      public Ret.DistributionResult getTranCdfRespT(AvgHandle R)
      Returns cumulative distribution functions of response times during transient analysis.
      Overrides:
      getTranCdfRespT in class NetworkSolver
      Parameters:
      R - response time handles specifying which metrics to compute
      Returns:
      DistributionResult containing empirical CDFs for each station-class pair

    • getTranCdfPassT

      public Ret.DistributionResult getTranCdfPassT()
      Returns cumulative distribution functions of passage times during transient analysis. For LDES, passage times are equivalent to response times in single-visit networks.
      Overrides:
      getTranCdfPassT in class NetworkSolver
      Returns:
      DistributionResult containing empirical CDFs for passage times

    • getTranCdfPassT

      public Ret.DistributionResult getTranCdfPassT(AvgHandle R)
      Returns cumulative distribution functions of passage times during transient analysis.
      Overrides:
      getTranCdfPassT in class NetworkSolver
      Parameters:
      R - response time handles specifying which metrics to compute
      Returns:
      DistributionResult containing empirical CDFs for passage times

    • getTranProb

      public Ret.ProbabilityResult getTranProb(StatefulNode node)
      Computes transient state probabilities at a specific node over time using LDES simulation.
      Parameters:
      node - the stateful node to analyze
      Returns:
      ProbabilityResult containing transient probability data

    • getTranProbAggr

      public Ret.ProbabilityResult getTranProbAggr(StatefulNode node)
      Computes transient aggregated state probabilities at a specific node over time.
      Parameters:
      node - the stateful node to analyze
      Returns:
      ProbabilityResult containing transient aggregated probability data

    • getTranProbSys

      public Ret.ProbabilityResult getTranProbSys()
      Computes transient system-wide state probabilities over time using LDES simulation.
      Returns:
      ProbabilityResult containing transient system probability data

    • getTranProbSysAggr

      public Ret.ProbabilityResult getTranProbSysAggr()
      Computes transient system-wide aggregated state probabilities over time.
      Returns:
      ProbabilityResult containing transient system aggregated probability data