nca.options¶

rule for the values before the first measurable value

rule for the values between two measurable values

rule for the values after the last measurable value

rule for the values before the maximum

rule for the values at or after the maximum

whether an imputed or kept value below the limit may enter the terminal regression

smallest adjusted \(R^2\) of the terminal regression (lambda_z_r2_adj)

largest extrapolated fraction \((\mathrm{AUC}_{0\text{-}\infty,\mathrm{pred}} - \mathrm{AUC}_{0\text{-}t_\mathrm{last}}) / \mathrm{AUC}_{0\text{-}\infty,\mathrm{pred}}\), the predicted variant PKanalix and Phoenix check

smallest number of half-lives the terminal window covers (lambda_z_span)

smallest number of points of the terminal regression (lambda_z_n_points)

whether a sample which is not accepted is also marked excluded, which keeps it out of the summary statistics and of the statistics of pkpdutils.stats

the selection rule

minimal number of points of a regression (at least 3)

whether the windows must start after the point of the maximum (True) or may start anywhere (False). It applies to BEST_FIT and to LAST_N, whose window then holds the points after the maximum when n_points reaches beyond it (fewer points than asked for, NCAFlag.TOO_FEW_POINTS below min_points); it does not apply to MANUAL, which regresses the given points as they are, and ALL_AFTER_TMAX starts after the maximum anyway

number of points for LAST_N

indices of the points (in the time order of the curve) for MANUAL

minimal adjusted R² a regression must reach, None for no limit

a window with more points wins over the best adjusted R² when its adjusted R² is within this tolerance of the best

the terminal window (t_first, t_last) of single samples, keyed by the sample label (the label of a batch with one sample dimension, the tuple of labels of a batch with several, and the string "*" for every sample which the mapping does not name). A sample with a window regresses the points inside it, in the times of the analysis (relative to its reference dose), as TerminalMethod.MANUAL does with indices; every other sample follows method. This is the per-profile window of the interactive tools (Phoenix Lambda_z_lower/Lambda_z_upper, the "Check lambda_z" tab of PKanalix), and pkpdutils.nca.NCAResult.terminal_windows writes the windows of a result back in this form, so that a reviewed analysis is re-run unchanged

whether the regression keeps the table of every candidate window instead of the chosen one alone (pkpdutils.nca.terminal.TerminalFit.candidates). The analysis of a single curve (pkpdutils.nca.nca_single, or a batch of one sample) then reports the windows as the point variables candidate_t_first, candidate_n_points and candidate_r2_adj over the dimension candidate, which pkpdutils.plot.plot_terminal_windows draws: the diagnostic of the judgement call behind the half-life, as the Slopes Selector of Phoenix WinNonlin and the "Check lambda_z" tab of PKanalix show it. A batch of several samples keeps no table, since the windows of a row are a table of their own and the rows need not have equally many of them

concentration or effect timecourses

trapezoid rule of the areas

selection of the terminal phase

lower limit of quantification in the unit of the values, None to take the per-sample lloq of the batch (the coordinate the readers of pkpdutils.io write), and no limit without one

handling of values below lloq, one of the two classic BLQHandling values or a BLQRules rule set by position

estimate of C(0) after an intravenous bolus

fraction of AUC(0-inf) above which EXTRAPOLATION_HIGH is set

thresholds of the terminal phase every sample is checked against (Acceptance); the result carries accepted and, where Acceptance.exclude is set, excluded

named partial areas, name to (t_start, t_end) in the time unit of the batch, relative to the first dose of the protocol. Every one of them becomes a variable of the result with the unit of auc_last; an interval which reaches beyond the last measurable value is completed with the terminal regression and the sample is flagged NCAFlag.PARTIAL_EXTRAPOLATED. AUC(0-72) of a drug with a long half-life is {"auc_0_72": (0.0, 72.0)} (ICH M13A 2024)

length of the last dosing interval, None to take it from the dosing protocol (the distance of the last two doses); it is needed for a steady state curve given with its last dose only and it overrides the protocol for the last interval

how far the last sample of the analysed dosing interval may fall short of its end, as a fraction of tau, before the interval is given up as incomplete. Within the tolerance the exposure of the interval is completed with the terminal regression, auc_tau_extrap_fraction reports the share which was extrapolated and the sample is not flagged; beyond it every steady state parameter is NaN and the sample carries NCAFlag.INCOMPLETE_INTERVAL. The default 0.1 covers the sample which was taken a few minutes before or after the nominal end of the interval, the case EMA and Phoenix WinNonlin both describe; 0 switches the completion off

whether the per-interval parameters (interval_*) are part of the result of a multiple dose analysis

reporting units of the result, variable name to unit ({"auc_inf_obs": "h*ng/mL", "cl_f": "mL/min"}). The analysis runs in the units of the batch as before and the result is converted at the end (pkpdutils.result.ParameterResult.to_units), together with the uncertainty, summary and dose normalized variables of every named parameter; an empty mapping leaves the derived units as they are

threshold of time_above for effect timecourses, None for none

workers of the analysis. None is automatic: the calling thread up to pkpdutils.parallel.NCA_WORKER_THRESHOLD rows and one worker per usable core, at most 8, above it; 1 is always serial and n > 1 uses that many workers. The core is vectorized numpy and releases the GIL, so its workers are threads of the calling process (pkpdutils.parallel) and no if __name__ == "__main__": guard is needed; the fit (FitOptions.n_workers) uses processes and does need one

most rows of a chunk of the vectorized core, which bounds its memory: a run holds the temporaries of as many chunks as run at once, min(n_workers, n_chunks) * chunk_rows rows. The chunks are mapped in order; how many there are follows from the rows, the workers and this bound (pkpdutils.parallel.split_rows), so a serial run of a small batch is one chunk whatever n_workers says

propagation of sd/se to the parameters; None selects BOOTSTRAP when the batch carries an uncertainty and NONE otherwise

number of bootstrap replicates

seed of the bootstrap random generator; the default None draws from a fresh generator, so a bootstrap is not reproducible

level of the confidence intervals

whether the replicates are drawn with se or sd

normal or log-normal draws

relative perturbation of a point, in units of its se, for the delta method