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. 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

    • 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

    • 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. This method is 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()

    • 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)
      Generates a sample path (state trajectory) for a specific node using LDES transient simulation.
      Parameters:
      node - The stateful node to sample
      numEvents - Number of time points to sample
      Returns:
      SampleResult containing the state trajectory for the node

    • sampleAggr

      public Ret.SampleResult sampleAggr(StatefulNode node, int numEvents)
      Generates an aggregated sample path for a specific node. For LDES, the sample() method already returns per-class queue lengths (nir), so this method simply marks the result as aggregated without additional marginal computation. This differs from SSA which requires toMarginal processing on raw state vectors.
      Parameters:
      node - The stateful node to sample
      numEvents - Number of time points to sample
      Returns:
      SampleResult containing the aggregated state trajectory

    • sampleSys

      public Ret.SampleResult sampleSys(int numEvents)
      Generates a system-wide sample path (state trajectory) for all stateful nodes.
      Overrides:
      sampleSys in class NetworkSolver
      Parameters:
      numEvents - Number of time points to sample
      Returns:
      SampleResult containing the state trajectory for all nodes

    • sampleSysAggr

      public Ret.SampleResult sampleSysAggr(int numEvents)
      Generates an aggregated system-wide sample path for all stateful nodes.
      Overrides:
      sampleSysAggr in class NetworkSolver
      Parameters:
      numEvents - Number of time points to sample
      Returns:
      SampleResult containing the aggregated state trajectory for all nodes

    • 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)
      Estimates the steady-state probability of a specific state at a node via LDES simulation. This method runs a LDES simulation and estimates state probabilities by computing the fraction of total simulation time spent in each state. The simulation collects state trajectories and weights each state by its dwell time.
      Parameters:
      node - The stateful node to analyze
      state - The state vector to compute probability for. If null, uses current network state.
      Returns:
      Estimated probability of the specified state (0 if state not observed)

    • 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)
      Estimates the steady-state probability of a specific aggregated (per-class) state at a node. This method estimates the probability of observing a specific per-class job distribution (e.g., [2 jobs of class 1, 1 job of class 2]) at a station. States are aggregated over service phases - only the number of jobs per class matters.
      Parameters:
      node - The stateful node to analyze
      stateAggr - The aggregated state vector (per-class job counts) to compute probability for. If null, uses current network state aggregated over phases.
      Returns:
      Estimated probability of the specified aggregated state (0 if state not observed)

    • 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()
      Estimates the joint steady-state probability of the entire system state via LDES simulation. This method estimates the probability of observing the current system state (combined state across all stateful nodes) using simulation-based estimation. States include phase information from service distributions.
      Overrides:
      getProbSys in class NetworkSolver
      Returns:
      Estimated joint probability of the current system state (0 if state not observed)

    • getProbSysAggr

      public Ret.ProbabilityResult getProbSysAggr()
      Estimates the joint steady-state probability of the entire aggregated system state. This method estimates the probability of observing the current system state (combined per-class job counts across all stateful nodes) using simulation. States are aggregated over service phases - only job counts per class matter.
      Overrides:
      getProbSysAggr in class NetworkSolver
      Returns:
      Estimated joint probability of the current aggregated system state (0 if state not observed)

    • 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.
      Parameters:
      rewardName - the reward name
      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

    • 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