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.

getComplexFamilies

Group the enzymes of multi-subunit reactions into complexes.

getConcControlCoeffs

Calculate control coefficients of protein usage.

getIsozymeCoverage

Report isozyme groups with partial proteomics coverage.

levelComplexConcs

Give every enzyme complex one abundance.

relaxEnzConcs

Relax enzyme concentrations by the least total amount.

relaxProteomicsGreedy

Greedy shadow-price-ordered relaxation of proteomics

zeroUnmeasuredIsozymes

Limit unmeasured isozymes that have a measured sibling.

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 (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). With several samples, the abundance of a protein is averaged over the samples in which it is measured.

enzymes : cell

list of enzymes (default model.ec.enzymes). An empty cell array {} means no enzymes (f is 0); [] means the default.

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, fillEnzConcs

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, the upper bound of their enzyme usage reaction becomes the measured concentration. Their usage reactions keep drawing from the protein pool.

Parameters

model : struct

an ecModel (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).

restrictTo : cell

enzymes (Uniprot IDs) to process; the usage reactions of the other enzymes are left unchanged. IDs that are not in model.ec.enzymes are ignored (default: all enzymes in model.ec.enzymes).

Returns

model : struct

an ecModel constraint with available enzyme concentrations.

Notes

A negative concentration in model.ec.concs is contradictory data and raises the error constrainEnzConcs:negativeConcentration. To populate model.ec.concs you should run fillEnzConcs.

A NaN entry means that the enzyme was not measured, and its usage draws from the protein pool. An entry of 0 means that the enzyme was measured as absent: its usage upper bound is 0, which removes every flux through the enzyme. flexibilizeEnzConcs multiplies the concentration and cannot raise a bound of 0; relaxProteomicsGreedy sets the bound back to its default.

Examples

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

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 (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'). Any other value raises constrainFluxData:invalidMaxMinGrowth.

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

An exchange reaction in fluxData.exchRxnIDs that is not in the model raises constrainFluxData:missingReaction, and a condition that is not in fluxData.conds raises constrainFluxData:unknownCondition.

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 (with ecModel.ec structure).

protData : struct

structure with proteome data, from loadProtData, 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

A negative abundance of a protein that is an enzyme of the model is contradictory data and raises the error fillEnzConcs:negativeAbundance.

A NaN entry in model.ec.concs means that the protein was not measured, and the usage of the enzyme draws from the protein pool. An entry of 0 means that the protein was measured as absent, and constrainEnzConcs limits the usage of the enzyme to 0. loadProtData returns a measured 0 only with the option zerosAsMeasured.

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, loadProtData

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

perComplex : logical

whether every complex (see getComplexFamilies) is flexibilized as one enzyme (default false). Enzymes and complexes are then ranked by the growth gained per foldChange of raising all their usage upper bounds together (a levelled complex binds on all subunits at once, so no single subunit shows a gain), every measured subunit of the selected complex is raised by the same factor, iterations are counted per complex, and one factor per complex is kept in the final pass, so that concentrations levelled by levelComplexConcs stay levelled. The frequence of a complex is recorded on its first subunit with a concentration above 0.

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.

Notes

While flexibilizing, an upper bound is never lowered below its current value. The total number of iterations is limited to (iterPerEnzyme + 1) times the number of measured enzymes, with 1000 for iterPerEnzyme when it is 0 (no limit per enzyme); at that limit flexibilizing stops with a warning. When the input model has no optimal solution, flexibilizeEnzConcs warns with the identifier flexibilizeEnzConcs:infeasible and returns an empty flexEnz.

The usage upper bound of an enzyme is raised by a factor of its concentration, so an enzyme with a concentration of 0 in model.ec.concs stays at 0 and is never flexibilized. If such enzymes exist, the warning flexibilizeEnzConcs:measuredZero lists them: a growth rate that is not reached can then be caused by these enzymes, and flexibilizeEnzConcs reports no limiting enzyme for them.

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, levelComplexConcs, getComplexFamilies

getComplexFamilies#

function families = getComplexFamilies(model, varargin)

Group the enzymes of multi-subunit reactions into complexes.

A complex is a set of enzymes that catalyses a reaction together, taken from model.ec.rxnEnzMat. Two enzyme sets are one complex when they share at least minShared subunits and at least a fraction minOverlap of the larger set (isozyme variants that swap a subunit, the same complex on different reactions). A single shared protein never merges two sets, so electron carriers and shared subunits (cytochrome c, thioredoxin, the E3 subunit of the 2-oxo-acid dehydrogenases) do not chain unrelated complexes together.

A subunit in exactly two complexes belongs to the one whose enzyme sets catalyse more reactions (the core subunits COX1-3 of complex IV also appear in one assembly reaction). A subunit in three or more complexes, in two with equal weight, or that also catalyses a reaction on its own is shared: it is left as measured and does not take part in the summary of a complex.

When isozyme variants of a complex disagree on the number of copies of a subunit, the first variant is used and a warning is given.

Parameters

model : struct

an ecModel (with ecModel.ec structure), with ec.rxnEnzMat (copies per subunit).

Name-Value Arguments

minOverlap : double

two enzyme sets are one complex when they share at least this fraction of the larger set's subunits (default 0.5)...

minShared : double

...and at least this many subunits (default 2).

Returns

families : struct

the complexes of the model, with the fields:

  • complexes : cell array with one struct per complex, with the fields enzymes (cell array with every subunit that appears in any of its enzyme sets), copies (copies of each of these subunits) and owned (logical, true for the subunits that belong to this complex).

  • owner : numeric vector with one entry per model.ec.enzymes, the index in complexes of the complex that the subunit belongs to, or 0 if it belongs to none.

  • shared : cell array with the subunits of a complex that belong to none: carriers and subunits shared between complexes.

Examples

% optional arguments may be given positionally or as name-value pairs:
families = getComplexFamilies(model);
families = getComplexFamilies(model, 'minShared', 3);

See also

levelComplexConcs, flexibilizeEnzConcs

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

method : char

'finite_difference' (default) or 'shadow_price'. See Notes.

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

Notes

The default method 'finite_difference' raises the upper bound of one usage reaction by foldChange, re-solves and divides the rise of the objective by the rise of the bound, one solve per evaluated protein. A rise of at most 1e-10 counts as no sensitivity.

The method 'shadow_price' reads, from a single solve, the absolute reduced cost of each evaluated usage reaction: the local derivative of the objective to the upper bound of that reaction. A nonzero reduced cost is kept only when raising that bound by 0.01 percent raises the objective by at least half of the rise the reduced cost predicts, and by more than 1e-12 times max(1, |objective|) (one extra solve per nonzero value), as the reduced cost can overestimate the effect at a degenerate optimum. A usage reaction held at a positive lower bound gets 0. When the solver gives no reduced costs (as with SCIP), the 'finite_difference' method is used instead. The two methods agree where raising the bound does not change the set of active constraints.

When the model has no feasible solution, the error getConcControlCoeffs:infeasible is raised.

Examples

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

See also

flexibilizeEnzConcs

getIsozymeCoverage#

function [coverage, zeroable] = getIsozymeCoverage(model)

Report isozyme groups with partial proteomics coverage.

The reactions in model.ec.rxns that share an identifier once the suffix EXP is removed are the isozymes of one reaction of the conventional GEM. An entry is measured when at least one of its enzymes has a concentration above 0 in model.ec.concs, and unmeasured when none of its enzymes has a concentration (all NaN). A group has partial coverage when it has both a measured and an unmeasured entry. An unmeasured entry next to a measured one can be a protein below the detection limit as well as a protein that is absent, so the report makes no statement on which. The kcat of an entry is not considered.

Parameters

model : struct

a full ecModel (with ecModel.ec structure), not GECKO light, with concentrations in model.ec.concs (see fillEnzConcs).

Returns

coverage : table

one row per group with partial coverage, sorted by reaction, with the variables:

  • rxn : the reaction identifier without the EXP suffix.

  • nEntries : number of entries of the group in model.ec.rxns.

  • nMeasured : number of measured entries.

  • nUnmeasured : number of unmeasured entries.

  • measuredEnzymes : cell array with the enzymes of the measured entries that have a concentration above 0.

  • unmeasuredEnzymes : cell array with the enzymes of the unmeasured entries.

  • sharedEnzymes : cell array with the unmeasured enzymes that also catalyse an entry outside the unmeasured entries of groups with partial coverage. zeroUnmeasuredIsozymes leaves them unchanged.

zeroable : cell array

the enzymes that zeroUnmeasuredIsozymes acts on: the enzymes in unmeasuredEnzymes that are not in sharedEnzymes of any group.

Examples

coverage = getIsozymeCoverage(model);
[coverage, zeroable] = getIsozymeCoverage(model);

See also

zeroUnmeasuredIsozymes, fillKcatsFromIsozymes, fillEnzConcs

levelComplexConcs#

function [model, result] = levelComplexConcs(model, varargin)

Give every enzyme complex one abundance.

Absolute proteomics recovers the subunits of a complex unevenly, so after fillEnzConcs the subunits of one complex can disagree several fold about how much of it there is. Capped one by one, the complex can then carry no more flux than its least abundant subunit allows. This function groups the enzymes of every multi-subunit reaction into complexes (see getComplexFamilies) and gives each complex one abundance, scaled to every subunit by its stoichiometry.

Run after fillEnzConcs and before constrainEnzConcs. The concentrations (mg/gDCW) in model.ec.concs are converted to molar amounts with model.ec.mw for the levelling and back afterwards. Per complex, the statistic over the subunits with a concentration above 0 that belong to the complex of the molar amount divided by the copies of the subunit is written back, times the copies and the molecular weight, to every subunit that belongs to the complex. Subunits that are shared between complexes, or that also catalyse a reaction on their own, are left as measured. A subunit with a concentration of 0 is measured as absent and stays 0.

Parameters

model : struct

an ecModel (with ecModel.ec structure), with ec.concs filled.

Name-Value Arguments

statistic : char

the summary over the subunits with a concentration above 0, 'median' or 'mean' (default 'median').

fillMissing : logical

whether subunits without a measurement, that belong to a complex, are given the concentration of the complex (default true).

families : struct

the complexes of the model, as returned by getComplexFamilies (default: calculated from the model).

Returns

model : struct

ecModel where model.ec.concs has one abundance per complex, except for subunits at 0, shared subunits and skipped complexes.

result : struct

what was changed, with the fields:

  • adjusted : cell array with the measured subunits whose concentration was replaced by that of the complex.

  • added : cell array with the unmeasured subunits that were given the concentration of the complex.

  • shared : cell array with the measured subunits that were left as measured because they belong to more than one complex or also catalyse a reaction on their own.

  • skipped : cell array with one cell array of subunits per complex that has no subunit with a concentration above 0 that belongs to it.

Examples

% optional arguments may be given positionally or as name-value pairs:
model = levelComplexConcs(model);
model = levelComplexConcs(model, 'statistic', 'mean');
[model, result] = levelComplexConcs(model, 'fillMissing', false);

See also

getComplexFamilies, fillEnzConcs, constrainEnzConcs, flexibilizeEnzConcs

relaxEnzConcs#

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

Relax enzyme concentrations by the least total amount.

Relaxes the upper bounds of the usage reactions of the measured enzymes (and, where needed, of the protein pool exchange) by the least total amount that lets the model reach the target growth rate, in one linear program. flexibilizeEnzConcs and relaxProteomicsGreedy relax one enzyme at a time, so which enzymes end up relaxed depends on how the most limiting enzyme is ranked; relaxEnzConcs does not depend on such a ranking.

The upper bound of the usage reaction of every measured enzyme becomes base * (1 + x), where base is its current upper bound (at most 1000), and the sum of the folds x is minimised with the growth rate at least expGrowth. The protein pool exchange may be raised by a fold as well, at poolWeight times the price of the fold of an enzyme, so that it is raised only where raising enzymes does not suffice. A current upper bound is never lowered. The concentrations in model.ec.concs are not changed.

Parameters

model : struct

a full ecModel with model.ec.concs filled and the concentrations applied as upper bounds (fillEnzConcs and constrainEnzConcs).

Name-Value Arguments

expGrowth : double

the growth rate to reach (default: gr_exp of the model adapter).

bioRxn : char

the biomass reaction (default: bioRxn of the model adapter).

perComplex : logical

whether the measured subunits of a complex (the subunits it owns, see getComplexFamilies) share one fold, so that concentrations levelled by levelComplexConcs stay levelled. A subunit with an upper bound of 0 gets its own fold (default false).

weight : char

'relative' minimises the sum of the folds, so that an enzyme measured at almost nothing is not relaxed freely because its absolute cost is small; 'absolute' minimises the mg/gDCW added (default 'relative').

poolWeight : double

price of one fold of the protein pool relative to one fold of an enzyme, or per mg with weight 'absolute' (default 1000).

floor : double

a base below this value is taken as this value when scaling its fold, so that an enzyme measured at 0 can still be relaxed, at a high relative price (default 1e-9).

modelAdapter : ModelAdapter

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

Returns

model : struct

the ecModel with the relaxed upper bounds of the usage reactions and of prot_pool_exchange. The upper bound of the biomass reaction is raised to expGrowth when it was lower.

flexEnz : struct

the relaxed enzymes, with the fields of flexibilizeEnzConcs:

  • uniprotIDs : enzymes whose usage upper bound was relaxed, and 'prot_pool' when the protein pool exchange was raised.

  • oldConcs : the upper bounds before relaxation.

  • flexConcs : the relaxed upper bounds.

  • ratioIncr : flexConcs ./ oldConcs; the entries are sorted by this field, highest first.

  • frequence : 1 for every entry.

Notes

The error relaxEnzConcs:noMeasured is raised when no enzyme has a concentration, relaxEnzConcs:infeasible when no relaxation of the measured enzymes and the protein pool reaches expGrowth (the growth rate is then not limited by protein), and relaxEnzConcs:arguments for an unknown weight. A fold of at most 1e-9 counts as no relaxation. geckopy has the same function (relax_enz_concs).

Examples

[model, flexEnz] = relaxEnzConcs(model);
[model, flexEnz] = relaxEnzConcs(model, 'expGrowth', 0.3, 'perComplex', true);

See also

flexibilizeEnzConcs, relaxProteomicsGreedy, constrainEnzConcs, levelComplexConcs

relaxProteomicsGreedy#

function [result, model] = 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. An enzyme with a concentration of 0 in model.ec.concs is a candidate like any other and is relaxed in the same way.

Parameters

model : struct

a full ecModel, 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). An empty cell array {} means no enzyme is eligible (converged is false unless the model already reaches minimalGrowth); [] means the default.

maxIterations : double

safety cap on the number of relaxations; errors when this many relaxations were made, minimalGrowth is still not reached and eligible enzymes remain (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.

model : struct

the ecModel with the usage_prot_ upper bounds of the relaxed enzymes set to defaultUpperBound.

Examples

[result, ecModel] = 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 selected 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; making maxIterations relaxations without reaching minimalGrowth while candidates still remain raises an error instead.

See also

flexibilizeEnzConcs, getEnzymeBottlenecks

zeroUnmeasuredIsozymes#

function [model, changed] = zeroUnmeasuredIsozymes(model, varargin)

Limit unmeasured isozymes that have a measured sibling.

For a reaction with a measured and an unmeasured isozyme (see getIsozymeCoverage), the usage upper bound of the enzymes of the unmeasured isozyme is lowered, instead of leaving them to draw from the protein pool without a limit. The function lowers the usage upper bound in the model and does not change model.ec.concs. An enzyme that also catalyses a reaction without a measured sibling is left unchanged, because limiting it would limit that reaction as well.

Not detecting a protein is not the same as the protein being absent: a protein below the detection limit of the measurement is missing from the data as well. Method 'zero' treats the unmeasured isozyme as absent and sets its usage upper bound to 0, which removes every flux through the enzyme and can lower the growth rate or make the model infeasible. Method 'detectionLimit' treats it as present at or below the detection limit and sets the upper bound to the detection limit.

An enzyme lowered by this function has no concentration in model.ec.concs and is a candidate in relaxProteomicsGreedy like any other enzyme with an upper bound below the default.

Run after constrainEnzConcs, which resets the usage upper bounds of all enzymes. The function is not called by other functions of GECKO.

Parameters

model : struct

a full ecModel (with ecModel.ec structure), not GECKO light, with concentrations in model.ec.concs, constrained by constrainEnzConcs.

Name-Value Arguments

method : char

'zero' or 'detectionLimit' (default 'zero').

limit : double

the detection limit in mg/gDCW for method 'detectionLimit' (default the smallest concentration above 0 in model.ec.concs).

Returns

model : struct

an ecModel with lowered usage upper bounds. An upper bound that is already below the new value is not raised.

changed : table

one row per enzyme that the function acted on, with the variables uniprot and newUpperBound.

Examples

% optional arguments may be given positionally or as name-value pairs:
model = zeroUnmeasuredIsozymes(model);
model = zeroUnmeasuredIsozymes(model, 'method', 'detectionLimit');

See also

getIsozymeCoverage, constrainEnzConcs, fillEnzConcs