solvers.BA

ba_spnlp_refusal(sn, method)

REASON = BA_SPNLP_REFUSAL(SN, METHOD)

The structural premises of the ‘spnlp’ family, in one place: the reason the resolved METHOD cannot bound the net SN, or ‘’ when it can. Empty for every name outside the family.

ONE PREDICATE, TWO CALLERS. solver_ba_spnlp_analyzer asks it before building the polytope and raises what it returns; BA_METHOD_REFUSAL asks it so that supportsModelMethod, findSolver and listValidMethods report the same sentence. Until it existed the mode rules lived in SPN_LPBND alone, so on a net with an Erlang mode model.help called ‘spnlp.upper’ runnable and the run raised; and with no rule at all a queueing network answered supportsModelMethod(‘spnlp.upper’) with yes.

THE RULES ARE SPN_LPBND’S OWN, restated over sn.nodeparam so that a predicate can answer them without assembling an LP: the model must hold Transition and Place nodes; a Place must not carry an embedded queue (the relaxation has one variable per (place, class) marking and no notion of a local queue); and every firing mode must be timed with a finite constant rate – an IMMEDIATE mode, a marking-dependent rate (setFiringRateDependence) and a multi-server mode are each refused by name, as is a firing law that is not phase-type at all. A PHASE-TYPE law with more than one phase is where the two variants part: the Markovian pair ‘spnlp.upper’/’spnlp.lower’ needs the marking alone to be the state and refuses it, the operational pair ‘spnlp.op.*’ reads only its mean and admits it. SPN_LPBND keeps its own copies of these tests as the library’s guard; the sentences here are the same ones it raises.

ba_open_refusal(sn, method)

REASON = BA_OPEN_REFUSAL(SN, METHOD)

The structural premises of the three OPEN-network bound families, ‘bpt’, ‘bgt’ and ‘snc’, in one place: the reason the resolved METHOD cannot bound SN, or ‘’ when it can. Empty for every other method.

ONE PREDICATE, TWO CALLERS. Each of solver_ba_bpt_analyzer, solver_ba_bgt_analyzer and solver_ba_snc_analyzer asks it before touching the model and raises what it returns; BA_METHOD_REFUSAL asks it so that supportsModelMethod, findSolver and listValidMethods report the same sentence. Until it existed the routing rules lived in the analyzers alone, so model.help called ‘bgt.upper’ runnable on an open model with a probabilistic split and ‘snc.upper’ runnable on a station graph with a cycle, and both raised the moment they were run.

WHAT IS CHECKED, family by family. All three: a fully open model with a Source, one server per queueing station and no delay (each bound is derived for one exponential server per station), and exponential service at every (station, class) pair that CARRIES TRAFFIC – the traffic equations are solved here, as the analyzers solve them, so a service time given to a pair its class never visits is not held against the model. ‘bgt’ additionally needs DETERMINISTIC, NON-MERGING routes: a pair sends everything to one successor or everything to the Sink, and belongs to exactly one type. ‘snc’ needs deterministic routing downstream of the Source (a split AT a Poisson Source is exact and allowed, a split of any other Markovian source is not), one service rate per station across the classes it serves, and a FEED-FORWARD station graph. The arrival law is deliberately NOT checked: ‘snc’ consumes any Markovian (D0,D1) source, and for ‘bpt’/’bgt’ the exponential arrival premise is a registry-expressible delta in SolverBA.getMethodFeatureSet.

ba_resolve_model_method(sn, method)

The concrete bound method NAME runs as on the model SN

Two resolutions in one place, so that runAnalyzer, SolverBA.resolveMethod, BA_METHOD_REFUSAL and SolverBA.getMethodFeatureSet all judge a name by the same target. First the model-free aliases of BA_RESOLVE_METHOD (‘default’ -> gb.upper, ‘auto’ -> auto.upper, ‘qr’ -> qrf.mmi, ‘lr’ -> lr.upper). Then the finite-buffer routing of BA_BLOCKING_DEFAULT: on a model whose buffer BINDS, ‘default’, ‘auto’ and ‘auto.upper’ run as ‘qrf.bas’, the one upper bound that models the buffer, when the model has the shape that bound needs.

WHY is the reason the routing did NOT apply – the delay station, the multiserver station, the second binding buffer or the oversized enumeration that BA_BLOCKING_DEFAULT names – and is empty when it applied, when the name is not one of the three routable ones, or when the model is unblocked. BA_METHOD_REFUSAL appends it to the blocking refusal so that a caller is told what about THIS model rules the blocking bound out.

Only the UPPER side routes: the analyzer solves ‘qrf.bas’ in the ‘max’ direction alone, so ‘auto.lower’ keeps refusing rather than being answered with the wrong side.

Parameters:

sn – Network structure
method – SolverBA bound method name as given

Returns:

method – The method the name runs as on this model why: Reason the finite-buffer routing did not apply, ‘’ otherwise

Examples

[method, why] = ba_resolve_model_method(sn, method)

ba_method_degenerate(sn, method)

REASON = BA_METHOD_DEGENERATE(SN, METHOD)

Whether METHOD APPLIES to SN but its bound carries no information there, and why. Empty when the bound is informative, and empty for every method that has no such regime.

THIS IS A DIFFERENT QUESTION FROM BA_METHOD_REFUSAL, which is why it is a different function. That one answers “is this model outside the method’s domain”, and its answer is what the analyzer raises. This one answers “inside the domain, does the formula still say anything”, and its answer is NOT raised: a degenerate bound is a VALID bound, just a vacuous one, so an analyzer asked for it by name is entitled to publish it. What must not happen is OFFERING it: findSolver and listValidMethods exist to name the pairs a caller can act on, and a table of zeros over a network with jobs circulating in it is not something anyone can act on.

THE ONE METHOD WITH SUCH A REGIME IS ‘ldbcmp.lower’. The Anselmi-Cremonesi bound is built from the population SURPLUS a = N - Qhat, where Qhat is the occupancy the non-bottleneck stations and the think time would hold in the open network fed at the bottleneck’s saturation rate. pfqn_ldbcmp returns NaN below the regime (a < 0), which solver_ba_analyzer already refuses by name; AT the boundary a = 0 it returns Xlo = 0, which is formally the trivial bound X >= 0 and propagates into a table whose queue lengths, utilizations and throughputs are all zero. Every entry of that table is a true lower bound and none of them is usable, and a caller cannot tell it from a real answer of zero. So the bound is computed here and the name withheld when it degenerates.

The cost is one pfqn_ldbcmp evaluation, a closed form plus a scalar fixed point, and only for the single method that has the regime – every other name returns immediately.

ba_method_refusal(sn, method, options)

REASON = BA_METHOD_REFUSAL(SN, METHOD, OPTIONS)

The STRUCTURAL premises of the SolverBA bound families, in one place: the reason METHOD cannot bound the model SN, or ‘’ when it can.

ONE PREDICATE, TWO CALLERS. @SolverBA/runAnalyzer and solver_ba_analyzer ask it before dispatching and raise the reason it returns; SolverBA.supportsModelMethod asks it after the feature gate and reports the same sentence, which is what findSolver, listValidMethods and SolverAUTO’s ranked choice all read. A second copy of any rule below is how the report and the run drift apart: the report offers a pair that raises the moment it is run, which is the defect this function exists to remove.

WHAT BELONGS HERE AND WHAT DOES NOT. Only the rules the feature registry cannot name. SolverFeatureSet.fields has no entry for “one class”, for a server count, for a station count, for a binding buffer, for “FCFS with a non-exponential law” (a conjunction of two names the registry holds separately) or for “a Transition node is present”, so those rules are structural and live here. Rules of the form “this family does not accept a delay station”, “does not accept an open class” or “does not read a MAP” ARE nameable, and belong in SolverBA.getMethodFeatureSet, which drops SchedStrategy_INF / ClosedClass / MAP from the offending method’s set instead – a feature set can refuse a model for HAVING a construct, never for lacking one.

THE PREMISES, family by family:

single-class closed aba, bjb, pb, sb, gb, harel, lr, pbh, cbh, pbk, bjbk,: ssd, sib, scb, ldbcmp, mapamva, qr/qrf.* and the auto composite. Every one of them is a function of the single-chain demand vector D = V./rates (or of the single-chain phase-type chain, for the QRF and MAP-AMVA reductions), the think time Z and the population N, which a multiclass or open model does not have.
fully closed mwba, cub, mbjb, looping. These are the multiclass: families: they take a per-chain demand matrix and a population VECTOR, so several classes are fine but an infinite population is not.
fully open bpt, bgt, snc, judged in BA_OPEN_REFUSAL together: with the routing premises of bgt and snc.
one server every family above except ssd, ldbcmp, auto and the: two load-dependent QRF arms. ssd is the multiserver bound (Suri-Dallery), ldbcmp is a lower bound that stays one when a station gains servers, auto composes whichever candidates survive, and ‘qrf.mmi.ld’ / ‘qrf.mmi.linear’ carry alpha(i,n) = min(n,c).
product form every family parameterized by demands – all of the: single-class closed and fully closed ones above except mwba and the phase-type reductions – is derived for a BCMP network and reads the service MEAN alone, so a FCFS station whose law is not exponential is refused: the arm would return the bound of the exponential network, which is a bracket for a different system. PS, LCFSPR and INF are insensitive and admit any law. The three multiclass BCMP families (cub, mbjb, looping) also refuse class-dependent FCFS rates, which BCMP type 1 does not allow. mwba is the exception: it is derived for NBUE service at FIFO and priority stations, so there it admits Exp, Erlang, Det and Uniform and refuses a law the registry cannot certify as NBUE.
phase-type chain qr/qrf.* and mapamva. Their chain carries ONE phase: per station, the phase of the job in service, which is FCFS semantics: a multi-phase law at a PS or LCFSPR single server would describe a different chain (that station’s true law is the exponential one, by insensitivity), so it is refused. SN_TO_QRF_ALPHA owns the delay / multiserver / load-dependent rate law of the QRF arms and the one restriction that survives there (exponential service where a station serves several jobs at once); the alpha-free arms refuse any such station by naming the two arms that serve it. The blocking arms need the tables SN_TO_QRF_BLOCKING derives and the capacities SN_TO_QRF_CAPACITY reads. mapamva additionally carries phases at ONE station.
finite buffer every family but the QRF blocking bounds and spnlp: (BA_IGNORES_BLOCKING) presumes unbounded buffers, so a buffer that BINDS refuses it. ‘default’, ‘auto’ and ‘auto.upper’ are first routed to ‘qrf.bas’ where that bound applies (BA_RESOLVE_MODEL_METHOD), and the refusal otherwise says why the routing did not.
Petri net spnlp.* alone bounds a model holding Transition nodes,: and bounds nothing else; its own mode rules are in BA_SPNLP_REFUSAL.

METHOD is taken as the caller spells it and resolved through BA_RESOLVE_MODEL_METHOD, so ‘default’ is judged as the gb.upper it runs as (or as the qrf.bas it runs as on a blocked model) and the reason names that. OPTIONS is optional and is read for the QRF overrides (config.qrf_params, config.qrf_maxvars) exactly as solver_ba_qrf_analyzer reads them.

solver_ba_spnlp_analyzer(sn, options)

[Q,U,R,T,C,X,LG,RUNTIME] = SOLVER_BA_SPNLP_ANALYZER(SN, OPTIONS)

Linear-programming bounds on the mean marking and the throughputs of a stochastic timed Petri net. The polytope and the LP are SPN_LPBND; this analyzer maps the LINE model onto them and reads one side of the bracket back per place and class.

METHOD NAMES. Four, in two families:

spnlp.upper Markovian LP, upper side exponential firing spnlp.lower Markovian LP, lower side exponential firing spnlp.op.upper operational LP, upper side any phase-type firing spnlp.op.lower operational LP, lower side any phase-type firing

The operational variant drops the second-moment, covariance and Little’s-law families and the whole E[X_p e_t] block with them, which is what removes the exponential requirement. It is much looser, and is the reference’s own “without Markovian assumption” column.

BOUND CONVENTION. Q(i,r) is the reported side of the bracket on the mean number of class-r tokens in place i. T(i,r) is the same side of the bracket on the token throughput of that place, and R follows by Little’s law from the two. U(i,r) = Q(i,r) DELIBERATELY: a Place is an INF station and LINE reports U = Q at an infinite server, which is what SolverCTMC and SOLVER_NC_SPN_ANALYZER both do on the same net. The reference’s place utilization 1 - P(m = 0) is a different quantity and is not this column.

A TRANSITION GETS NO ROW. It is a StatefulNode and not a Station, so it has no station index; the mode throughputs and enabling probabilities the LP also brackets stay inside SPN_LPBND’s return value, the same way SPN_METRICS keeps modeTput and modeUtil off the table.

THE TWO SIDES ARE NOT ONE SOLVE. Each reported cell is its own linear form, minimised and maximised over the same polytope, so a ‘.upper’ run and a ‘.lower’ run cost the same and neither is derivable from the other.

HOW TIGHT. The reference’s own Table 2 measures it on a four-server production line: the upper side lands 2% to 11% above simulation and the lower side 30% to 40% below it, both comfortably inside the operational bounds it also reports. Expect a usable upper bound and a weak lower one.

Reference: Z. Liu (1998). Performance analysis of stochastic timed Petri nets using linear programming approach. IEEE Transactions on Software Engineering 24(11), 1014-1030.

solver_ba_qrf_analyzer(sn, options)

SOLVER_BA_QRF_ANALYZER Adapter for QRF library functions within SolverBA

[QN,UN,RN,TN,CN,XN,RUNTIME] = SOLVER_BA_QRF_ANALYZER(SN, OPTIONS)

Bridges the LINE sn struct to QRF (Quadratic Reduction Framework) library functions for approximating performance metrics of single-class closed queueing networks with PH service.

ba_resolve_method(method)

Resolves ‘default’, ‘auto’, ‘qr’ and ‘lr’ to the method they name

‘default’ selects the tightest noniterative upper bound (geometric); bare ‘auto’ is the AUTO composite’s upper side; ‘qr’ is the friendly alias of the QRF quadratic reduction bound; bare ‘lr’ is the LP-based Linear Reduction upper bound (Mapqn_bnd_lr_pf, simplex), NOT an alias of ‘qrf.mmi.linear’, which is “linear” only in its explicit Aeq/beq constraint representation while its objective is the nonlinear MMI mutual information.

Any other name is returned unchanged. Kept as one function so that runAnalyzer, listValidMethods and getBounds all judge a method by the same resolved name: gating on the raw ‘default’ would let the geometric bound through every check written against ‘gb.upper’.

BARE ‘auto’ IS DELIBERATELY ABSENT FROM SolverBA.listAllMethods, and the arm here is live rather than dead. SolverBA is the one Network solver that does not pass through NetworkSolver.runAnalyzerChecks, so no name gate ever reads a list before this resolution runs: runAnalyzer dispatches on the RESOLVED ‘auto.upper’, which listAllMethods does carry. Three production callers set it – SolverAUTO’s ‘bound’ intent (SolverAUTO.m), its baSolver fallback, and resolveMethodToken’s bare ‘ba’ token, all added with ‘bound’ in 160dd688f. Listing it would put it in listValidMethods too (that list is a narrowing of listAllMethods), which enumerates into the qn/jqn sanity baselines; the alias needs no listing to work, so it stays unlisted.

Parameters:: method – SolverBA bound method name as given
Returns:: method – The resolved method name

Examples

method = ba_resolve_method(method)

ba_ignores_blocking(method)

True when METHOD bounds a model as if its buffers were unbounded

Every bound family in SolverBA except the QRF BLOCKING bounds is parameterized by demands (visits x service time) and a population alone, which is the BCMP parameterization: the buffers are unbounded and the equilibrium distribution factorizes. A finite buffer that BINDS breaks both premises – the truncation couples the station occupancies – so the resulting numbers do not bracket the blocked model. On cqn_bas_blocking (Queue2 capped at 1, N = 2) gb.upper reports QLen 1.28 at a station that can never hold more than one job, which is not a loose bound but a wrong one, and the lower sides are not one-sided at all.

The exceptions are ‘qrf.bas*’ and ‘qrf.rsrd’, the Quadratic Reduction Framework bounds that carry the blocking tables (MM, MM1, ZZ, ZM, BB, F) explicitly and therefore model the finite buffer rather than ignore it, and ‘spnlp.*’, whose polytope is indexed by the marking itself: a bounded place enters it as a variable upper bound and as the P-invariant equality that produced the bound, so the buffer is modelled and not assumed away.

METHOD is the RESOLVED name (after the ‘default’/’auto’/’qr’/’lr’ aliases), so a caller must resolve before asking.

Parameters:: method – Resolved SolverBA bound method name
Returns:: bool – True if the method assumes unbounded buffers

Examples

bool = ba_ignores_blocking(method)

ba_blocking_default(sn)

Selects the QRF BAS bound as the default of a blocked model

‘default’ resolves to the geometric upper bound, which is parameterized by demands and a population alone and therefore bounds a blocked model as if its buffers were unbounded. BA_IGNORES_BLOCKING refuses that, which is right; but refusing is not the whole answer, because ‘qrf.bas’ DOES model the finite buffer and the model itself says everything that bound needs. So a blocked model that fits the QRF shape gets ‘qrf.bas’ as its default, exactly as SolverMVA routes a BAS model to ‘sqd’ through SN_IS_BAS_MODEL.

The shape is the one listValidMethods already calls “reducible” and solver_ba_qrf_analyzer gates on: single class, closed, no delay station, no multiserver station. On top of that the blocking tables must actually derive, which is asked of SN_TO_QRF_BLOCKING rather than re-tested here – it owns the single-finite-buffer rule and the size guard, and a second copy of either is how the two drift apart.

WHY is the derivation’s own reason when the routing does not apply, so the caller is told what about THIS model rules the blocking bound out (two binding buffers, an oversized enumeration) instead of a generic refusal. It is empty when the model is simply not blocked.

Only the UPPER side is routed. qrf.bas is solved in the ‘max’ direction alone by the analyzer, so ‘auto.lower’ has no blocking counterpart and keeps refusing rather than being answered with the wrong side.

Parameters:: sn – Network structure
Returns:: method – ‘qrf.bas’ when the blocked model admits it, otherwise empty why: Reason the blocking bound does not apply, empty when it does or when the model is unblocked

Examples

[method, why] = ba_blocking_default(sn)

solver_ba_snc_analyzer(sn, options)

[Q,U,R,T,C,X,LG,RUNTIME,ENV] = SOLVER_BA_SNC_ANALYZER(SN, OPTIONS)

Stochastic network calculus UPPER bound on the mean response times and queue lengths of a feed-forward open network, valid for EVERY work-conserving scheduling policy at every station. The api family in matlab/src/api/snc supplies the envelope algebra; this analyzer maps the LINE model onto it, propagates envelopes hop by hop, and reads the bound back per station and class.

UNITS ARE JOBS, NOT WORK. The arrival envelope counts jobs and the service element is snc_srv_exp, the counting process of an Exp(mu) server. That is what lets a departure envelope from one station be the arrival envelope of the next: a service-time work unit differs from station to station, a job does not. On a single M/M/1 the resulting backlog bound decays as (lambda/mu)^n and the delay bound as exp(-(mu-lambda)*d), both exact rates.

BOUND CONVENTION. R(i,r) is snc_mean_delay of the (arrival, service) envelope pair at that station, i.e. the integral of the delay tail bound, so each entry is a valid upper bound on its own. Q follows by Little’s law from the bounded R and the EXACT throughput T (an open network’s per-class rates are fixed by the traffic equations, not by the policy), and so does the per-class system response time C. U is exact for the same reason.

WHAT IS ASSUMED, and refused when it does not hold:

fully open network with a Source, no delay station, one server per station
exponential service; the source may be any Markovian (D0,D1) process
FEED-FORWARD at the station level: the station graph must be acyclic, so that the cross traffic of a station is always determined upstream of it
DETERMINISTIC ROUTING downstream of the Source: a probabilistic split of an already-queued flow has no exponential-form envelope short of bounding the split by the whole flow, which would report a false instability. Splitting AT a Poisson Source is exact and is allowed
classes sharing a station must have the SAME service rate, since the blind-multiplexing leftover subtracts job counts from a job-count capacity
independence of the flow of interest and its cross traffic, and of the stations; the dependent case needs a Hoelder split that the elementary envelope algebra does not implement

TIGHTNESS. This is a policy-robust bound, so it is loose on the mean: 2.4x the exact M/M/1 mean response time at rho = 0.1 and 10.4x at rho = 0.95. Its sharp object is the TAIL, whose decay rate it reproduces exactly; reach it through SolverBA.getDelayPerc / getBacklogPerc / getPercTable rather than through the mean columns when the quantile is what matters.

Reference: M. Fidler and A. Rizk (2015). A Guide to the Stochastic Network Calculus. IEEE Communications Surveys and Tutorials 17(1), 92-105.

solver_ba_bpt_analyzer(sn, options)

[Q,U,R,T,C,X,LG,RUNTIME] = SOLVER_BA_BPT_ANALYZER(SN, OPTIONS)

Achievable-region LOWER bound on the mean response times of a multiclass open Markovian network, valid for EVERY non-idling scheduling policy at every station. The polyhedron is the first-order linear-programming relaxation of the achievable region (NPFQN_BND_BPT); this analyzer maps the LINE model onto it and reads the bound back per station and class.

CLASS SPACE. The reference’s “class” is a buffer: one exponential service rate, one Markovian routing law. LINE’s (station, job class) pair is exactly that, so a pair carrying traffic becomes one LP class, the Source is absorbed into the external arrival vector, and class switching needs no special treatment because sn.rt already carries it.

BOUND CONVENTION. R(i,r) is obtained by minimizing x over the polyhedron with the objective set to the unit vector of that pair, so each entry is a valid lower bound on its own. Q follows by Little’s law from the bounded R and the EXACT throughput T (an open network’s per-class rates are fixed by the traffic equations, not by the policy), and so does the per-class system response time C. U is exact for the same reason.

TIGHTNESS. The relaxation is exact on M/M/1 and tight on the externally fed classes, but it is weak on a class whose arrivals are all internal: the only term coupling x_r to the second-moment block carries the factor lambda0_r, so an internally fed class can fall back to its own mean service time. That is a property of the first-order relaxation, not of this port; the reference’s remedy is the higher-order (nonlinear/semidefinite) characterizations of its Section 5.

Reference: D. Bertsimas, I. Paschalidis, J. Tsitsiklis (1994). Optimization of multiclass queueing networks: polyhedral and nonlinear characterizations of achievable performance. Annals of Applied Probability 4(1), 43-75.

solver_ba_bgt_analyzer(sn, options)

[Q,U,R,T,C,X,LG,RUNTIME] = SOLVER_BA_BGT_ANALYZER(SN, OPTIONS)

Piecewise-linear Lyapunov UPPER bound on the steady-state queue lengths of a multitype open Markovian network, valid for EVERY work-conserving Markovian policy. The polyhedron and the bound are NPFQN_BND_BGT; this analyzer maps the LINE model onto them and reads the bound back per station and class.

CLASS SPACE. The reference’s network is a MULTITYPE one: each type follows a FIXED sequence of stages, and stage k of type i is its own buffer. LINE’s (station, job class) pair is that buffer, so the analyzer walks the routing matrix from the Source and turns each open class into one type whose stages are the pairs it visits. Two gates follow from the model and are enforced by name rather than approximated:

ROUTING MUST BE DETERMINISTIC: a pair sends everything to one successor, or everything to the Sink. A probabilistic split is a different network.

ROUTES MUST NOT MERGE: a pair belongs to exactly one type. Where two types share a buffer the reference’s class index (i,k) is not defined, and its arrival term L^j(i,1) lambda_i would be ambiguous.

A re-entrant line is expressible: give the revisits distinct LINE classes (class switching), so each visit is its own pair.

BOUND CONVENTION. Q(i,r) is the Theorem 4 bound; R follows by Little’s law from it and the EXACT throughput T (an open network’s per-class rates are fixed by the traffic equations, not by the policy), as does C. U is exact for the same reason.

THE BOUND IS LOOSE, and knowingly so: the exception parameter of the smoothed Lyapunov function carries (Lmax+gamma)^3/gamma^2 and dominates as soon as there is more than one station. On M/M/1 it is 18x to 56x the exact mean queue length (tighter as the load rises); on a two-station tandem it is three orders of magnitude above. What is sharp is the STABILITY CERTIFICATE – a feasible gamma > 0 proves every work-conserving policy stable, and the LP correctly refuses the Lu-Kumar network at per-station loads of 0.7, where global stability genuinely fails – and the geometric tail RATE.

Reference: D. Bertsimas, D. Gamarnik, J. N. Tsitsiklis (2001). Performance of multiclass Markovian queueing networks via piecewise linear Lyapunov functions. Annals of Applied Probability 11(4), 1384-1428, Section 5.1.

solver_ba_analyzer(sn, options): [Q,U,R,T,C,X,LG,RUNTIME,ITER] = SOLVER_BA_ANALYZER(QN, OPTIONS)