Limit proteins#

MATLAB functions in GECKO/src/limit_proteins of the GECKO toolbox.

Functions#

Function

Summary

calculateFfactor

Compute the f factor for an ecModel.

constrainEnzConcs

Constrain enzyme usages by their concentration.

constrainFluxData

Constrain ecModel fluxes to provided flux data.

fillEnzConcs

Populate model.ec.concs from proteome data.

flexibilizeEnzConcs

Flexibilize enzyme concentrations of an ecModel.

getConcControlCoeffs

Calculate control coefficients of protein usage.

relaxProteomicsGreedy

Greedy shadow-price-ordered relaxation of proteomics

updateProtPool

Update the protein pool to compensate for proteomics.

Reference#

calculateFfactor#

function f = calculateFfactor(model, varargin)

Compute the f factor for an ecModel.

Computes the f factor, as a proxy to the mass fraction of proteins accounted for in an ecModel out of the total protein content in cells.

Parameters

model : struct

an ecModel in GECKO 3 format (with ecModel.ec structure).

Name-Value Arguments

protData : struct

structure with proteome data, from loadProtData (by default it instead attempts to load data/paxDB.tsv).

enzymes : cell

list of enzymes (default model.ec.enzymes).

modelAdapter : ModelAdapter

a loaded model adapter (default: the current default model adapter).

Returns

f : double

f-factor.

Examples

% optional arguments may be given positionally or as name-value pairs:
f = calculateFfactor(model);
f = calculateFfactor(model, 'enzymes', enzymes);

See also

loadProtData, getProtFromProteomics

constrainEnzConcs#

function model = constrainEnzConcs(model, varargin)

Constrain enzyme usages by their concentration.

Constrain enzyme usages by their concentration as provided in model.ec.concs. For enzymes with non-NaN entries in model.ec.concs, their enzyme usage reaction will no longer draw from the protein pool, but is rather constraint by the measured protein abundance.

Parameters

model : struct

an ecModel in GECKO 3 format (with ecModel.ec structure) with enzyme concentrations in model.ec.concs.

Name-Value Arguments

removeConstraints : logical

whether enzyme concentration constraints should be removed (model.ec.concs will remain unchanged) (default false).

Returns

model : struct

an ecModel constraint with available enzyme concentrations.

Notes

To populate model.ec.concs you should run fillEnzConcs.

Examples

% optional arguments may be given positionally or as name-value pairs:
model = constrainEnzConcs(model);
model = constrainEnzConcs(model, 'removeConstraints', true);

See also

fillEnzConcs

constrainFluxData#

function model = constrainFluxData(model, varargin)

Constrain ecModel fluxes to provided flux data.

Constrains fluxes to the data that is provided in the fluxData structure, which itself is read by loadFluxData from data/fluxData.tsv.

Parameters

model : struct

an ecModel in GECKO 3 format (with ecModel.ec structure).

Name-Value Arguments

fluxData : struct

structure with flux data, with the fields:

  • conds : sampling condition.

  • Ptot : total protein (g/gDCW).

  • grRate : growth rate (1/h).

  • exchFluxes : exchange fluxes (mmol/gDCWh).

  • exchMets : exchanged metabolites, matching exchFluxes.

  • exchRxnIDs : exchange reaction IDs, matching exchMets.

condition : double or char

either index number or name of the sample condition in fluxData.conds (default 1).

maxMinGrowth : char

'max' if the provided growth rate should be set as maximum growth rate (= upper bound), or 'min' if it should be set as minimum growth rate (= lower bound). The latter option is suitable if minimization of prot_pool_exchange is used as objective function (default 'max').

looseStrictFlux : char or double

how strictly constrained the exchange fluxes should be (default 'loose'):

  • 'loose' : the exchange fluxes are constraint only by the "outer bounds". If exchFluxes(i) > 0, LB = 0 and UB = exchFluxes(i). If exchFluxes(i) < 0, LB = exchFluxes(i) and UB = 0.

  • 0-100 : LB and UB constraints are set with a specified percentage of variance around exchFluxes. If 10 is specified, LB = exchFluxes0.95 and UB = exchFluxes1.05. This allows for 10% variance around the exchFluxes values, but strictly forces a flux through the exchRxns.

modelAdapter : ModelAdapter

a loaded model adapter (default: the current default model adapter).

Returns

model : struct

an ecModel where fluxes are constraint.

Notes

If a provided constraint is either -1000 or 1000, then the function will update the reaction lower and upper bound to either allow uptake or excretion, irrespective of what option is given as the looseStrictFlux parameter.

Examples

% optional arguments may be given positionally or as name-value pairs:
model = constrainFluxData(model);
model = constrainFluxData(model, 'condition', 2);

See also

loadFluxData

fillEnzConcs#

function model = fillEnzConcs(model, protData, varargin)

Populate model.ec.concs from proteome data.

Uses the protein concentrations from protData to fill model.ec.concs. Protein levels should be provided in mg/gDCW. If no data is provided for a particular protein, its level is NaN. Existing entries in model.ec.concs are overwritten.

Parameters

model : struct

an ecModel in GECKO 3 format (with ecModel.ec structure).

protData : struct

structure with proteome data, from loadProtFluxData, with the fields:

  • uniprotIDs : cell array with Uniprot IDs matching protData.abundances.

  • abundances : matrix of proteomics data.

Name-Value Arguments

dataCol : double

number indicating the column in protData.abundances that contains the relevant protein concentrations. protData may contain data from multiple conditions/samples/experiments, each with their own column in protData.abundances (default 1).

Returns

model : struct

an ecModel where model.ec.concs is populated with protein concentrations.

Notes

To also constrain the model with the content of model.ec.concs, you should run constrainEnzConcs.

Examples

% optional arguments may be given positionally or as name-value pairs:
model = fillEnzConcs(model, protData);
model = fillEnzConcs(model, protData, 'dataCol', 2);

See also

constrainEnzConcs, loadProtFluxData

flexibilizeEnzConcs#

function [model, flexEnz] = flexibilizeEnzConcs(model, varargin)

Flexibilize enzyme concentrations of an ecModel.

Flexibilize enzyme concentration of an ecModel constrained with proteomics data. The upper bound of the protein usage reaction is changed, while the concentrations in ecModel.ec.concs remain unchanged.

If no (more) limiting enzyme concentrations can be found, it might be the protein pool exchange that is limiting growth. In that case, an attempt will be made to relax the protein pool exchange reaction, and if the growth rate indeed increases, it is suggested to set the protein pool exchange unconstrained (ub=1000) before again running flexibilizeEnzConcs. Such situations, where a proteomics integrated ecModel is overconstrained, may occur if the ecModel should be able to simulate maximum growth rate (from e.g. batch cultivation).

If relaxing the protein pool exchange does not increase the growth rate, then this is not due to enzyme constraints, but rather an issue with the metabolic network itself, or the set nutrient exchange is not sufficient.

Parameters

model : struct

an ecModel in GECKO 3 format (with ecModel.ec structure).

Name-Value Arguments

expGrowth : double

estimated experimental growth rate. If not specified, the value will be read from the model adapter.

foldChange : double

a value how much to increase the enzyme concentration (default 2).

iterPerEnzyme : double

the number of iterations that an enzyme can be increased. A zero number can be defined; if zero is defined no limit will be set, and it will increase the enzyme concentration until it reaches the defined growth rate (default 5).

modelAdapter : ModelAdapter

a loaded model adapter (default: the current default model adapter).

verbose : logical

whether progress should be reported (default true).

Returns

model : struct

ecModel where the constraint of measured enzyme concentrations have been flexibilized (=relaxed) in the S-matrix, to allow the model to reach the growth rate defined in expGrowth, while the values in ecModel.ec.concs have remained untouched.

flexEnz : struct

array with information about flexibilized proteins, with the fields:

  • uniprotIDs : enzymes whose usage UB was flexibilized.

  • oldConcs : original concentrations, from model.ec.concs.

  • flexConcs : flexibilized concentrations, new UB in model.

  • ratioIncr : ratio by which the concentration increased; the enzymes will be sorted by this field.

  • frequence : numeric how often the enzyme has been step-wise flexibilized.

Examples

% optional arguments may be given positionally or as name-value pairs:
[model, flexEnz] = flexibilizeEnzConcs(model);
[model, flexEnz] = flexibilizeEnzConcs(model, 'foldChange', 3);

See also

constrainEnzConcs, getConcControlCoeffs

getConcControlCoeffs#

function [enz, controlCoeffs] = getConcControlCoeffs(model, varargin)

Calculate control coefficients of protein usage.

For each candidate protein whose usage reaction is running above the given limit fraction of its upper bound, temporarily increases that protein's usage upper bound by foldChange, re-solves, and expresses the resulting growth-rate increase per unit of concentration increase as a control coefficient. Proteins below the limit, or whose increase does not measurably raise growth, get a coefficient of zero.

Parameters

model : struct

an ecModel in GECKO 3 format (with ecModel.ec structure).

Name-Value Arguments

proteins : cell

a list of proteins to calculate the coefficients (default model.ec.enzymes).

foldChange : double

a value how much to increase the protein concentration (default 2).

limit : double

threshold on the usage/concentration ratio (how saturated a protein's usage upper bound already is); only proteins with a ratio above this value are evaluated for a control coefficient (default 0, i.e. any nonzero usage is evaluated).

Returns

enz : logical

flags which of the input proteins had a usage/concentration ratio above limit and were evaluated for a control coefficient.

controlCoeffs : double

control coefficient per input protein (0 for proteins not evaluated or whose increase did not measurably raise growth).

Examples

% optional arguments may be given positionally or as name-value pairs:
[enz, controlCoeffs] = getConcControlCoeffs(model);
[enz, controlCoeffs] = getConcControlCoeffs(model, 'foldChange', 3);

See also

flexibilizeEnzConcs

relaxProteomicsGreedy#

function result = relaxProteomicsGreedy(model, varargin)

Greedy shadow-price-ordered relaxation of proteomics

constraints.

While growth is below minimalGrowth, finds the still-proteomics-constrained enzyme (usage_prot_ upper bound below defaultUpperBound) with the largest absolute shadow price on its prot_ mass-balance constraint, fully relaxes it back to defaultUpperBound, re-solves, and repeats.

Parameters

model : struct

a full ecModel in GECKO 3 format, with some usage_prot_ reactions constrained below defaultUpperBound (e.g. by constrainEnzConcs).

Name-Value Arguments

minimalGrowth : double

target objective value. Required.

enzymeSet : cell

subset of uniprot ids eligible for relaxation (default: every currently proteomics-constrained enzyme).

maxIterations : double

safety cap; errors if exceeded while eligible enzymes still remained (default 100).

defaultUpperBound : double

value to restore on a relaxed usage reaction, matching the shared-pool default makeEcModel itself sets (default 1000).

Returns

result : struct

  • relaxed : struct mapping each relaxed uniprot id to its original model.ec.concs value, so the caller can restore it later.

  • trace : struct array, one row per relaxation step, with fields iteration (0-based), relaxedUniprot, growthBefore, growthAfter, shadowPrice.

  • finalGrowth : objective value when the loop stopped.

  • converged : true iff finalGrowth >= minimalGrowth.

Examples

result = relaxProteomicsGreedy(ecModel, 'minimalGrowth', 0.1);

Notes

Different relaxation strategy from flexibilizeEnzConcs: this one is shadow-price-ordered (one solve per step) and often converges in fewer iterations when one or two enzymes dominate the infeasibility. The trade-off is that it fully unconstrains each picked enzyme with no tighten-back pass, so the result is looser (less proteomics-faithful).

There are two distinct non-convergence outcomes: running out of eligible candidates before reaching minimalGrowth returns normally with converged=false; exhausting maxIterations while candidates still remained raises an error instead.

See also

flexibilizeEnzConcs, getEnzymeBottlenecks

updateProtPool#

function ecModel  = updateProtPool(ecModel, varargin)

Update the protein pool to compensate for proteomics.

Only applicable to ecModels where unmeasured enzymes draw from the protein pool while measured enzymes (constrained via model.ec.concs) do not: shrinks the protein pool exchange upper bound so it represents only the remaining, unmeasured protein content (total protein content Ptot minus the measured protein mass). For ecModels generated with GECKO 3.2.0 or later, where all enzymes draw from the protein pool regardless of whether they are measured, this function raises an error instead; use setProtPoolSize (see https://github.com/SysBioChalmers/GECKO/issues/375).

Parameters

ecModel : struct

an ecModel in GECKO 3 format (with ecModel.ec structure).

Name-Value Arguments

Ptot : double

total protein content in g/gDCW, overwrites the value from modelAdapter. For instance, condition-specific fluxData.Ptot from loadFluxData can be used. If nothing is provided, the modelAdapter value is used.

modelAdapter : ModelAdapter

a loaded model adapter (default: the current default model adapter).

Returns

ecModel : struct

an ecModel where the protein pool exchange reaction's upper bound has been reduced to reflect only the unmeasured protein content.

Examples

% optional arguments may be given positionally or as name-value pairs:
ecModel = updateProtPool(ecModel);
ecModel = updateProtPool(ecModel, 'Ptot', 0.5);

See also

setProtPoolSize, loadFluxData