Choosing the Right Solver
=========================

Ask the model
-------------

The guidelines below say what each solver is *for*. To find out what a
particular model can actually be solved with, ask the model::

    T = model.findSolver()                % every (solver, method) pair that runs
    T = model.findSolver('cdf')           % ... that returns a passage-time law
    T = model.findSolver('getCdfRespT')   % the same question, asked by accessor
    T = model.findSolver('', true)        % also the pairs refused, and why

``findMethod`` and ``help`` are aliases. The result is a table with one row per
pair and the columns

``Solver``
    the method family: ``mva``, ``ctmc``, ``ldes``, ...

``Method``
    the method name to pass as a solver method, e.g. ``mva.exact``, so a row can be
    acted on directly::

        T = model.findSolver('cdf');
        solver = LINE(model, T.Method{1});

``Runnable``
    whether the model passes that method's own support gate

``Class``
    ``exact``, ``approx``, ``bound`` or ``simulation``. Exactness is claimed of
    the **model**, not of the algorithm in the abstract: ``mva.exact`` reports
    ``exact`` on a product-form network and ``approx`` on one without a
    product-form solution.

``Metrics``
    the measure groups the family can report: ``avg``, ``tran``, ``cdf``,
    ``prob``, ``tranprob``, ``sample``, ``cache``, ``loss``, ``orbit``,
    ``moment``, ``sens``. This is what the first argument filters on.

``Reason``
    empty on a runnable row, otherwise the features that caused the refusal, so
    a refusal says what to change.

The same report is available from the command line as
``line-cli -f model.json --find-solver`` (and ``--find-solver-all`` to keep the
refused pairs).

Selection Guidelines
--------------------

Use **AUTO** when:

- You want LINE to automatically select the best solver for your model
- You are not sure which solver is most appropriate
- The model may change and you want adaptive solver selection

Use **CTMC** when:

- You need exact solutions for a Markovian model
- The model is small to medium-sized (<6000 states)
- You need detailed state probabilities or transient analysis
- Precision is more important than speed

Use **FLUID** when:

- You have a large-scale model where CTMC would have too many states
- The model has many jobs or uses PS/INF scheduling
- Approximate solutions with fast computation are acceptable
- You need transient analysis for large models

Use **JMT** when:

- Your model uses non-Markovian distributions (Pareto, deterministic, traces)
- You need comprehensive feature support (JMT supports virtually everything)
- You want simulation-based validation or sample paths
- CTMC state space is too large and FLUID/MVA do not support your features

Use **MAM** when:

- You have open Markovian systems with MAP/PH arrivals
- You need exact solutions for infinite state-space models
- The model exhibits QBD structure

Use **MVA** when:

- You have a closed or mixed product-form queueing network
- You need fast approximate solutions for medium to large models
- Single-server FCFS stations dominate your model
- Mean performance metrics are sufficient (no distributions needed)

Use **NC** when:

- You need state probabilities for closed networks
- You want normalizing constant computations
- The model is product-form and you prefer exact or sampling-based methods

Use **SSA** when:

- You need sample paths with detailed phase information
- You want flexible parallelization of stochastic simulation
- You need to track service phase evolution
- CTMC is too large but you prefer simulation over FLUID approximation

Performance Considerations
--------------------------

**Speed (fastest to slowest):**

1. MVA (approximate methods)
2. NC (sampling methods), FLUID
3. MAM (for QBD models)
4. CTMC (small models)
5. JMT, SSA (simulation)

**Accuracy (most accurate to approximate):**

1. CTMC (exact for Markovian models)
2. MAM (exact for QBD models)
3. NC with exact methods
4. MVA with exact methods
5. NC with sampling, MVA approximations
6. FLUID approximations
7. JMT/SSA (simulation - statistical accuracy)

**Scalability (supports largest models):**

1. JMT, SSA (simulation)
2. FLUID, MVA
3. NC (with sampling)
4. MAM (for QBD structure)
5. CTMC (limited by state space)

See Also
--------

- :doc:`Solver Reference <solver_reference>` - Complete solver method reference
- :doc:`Quick Start <quickstart>` - Getting started with LINE solvers
- :doc:`Examples <examples>` - Example models using different solvers