Edit on GitHub

Types

Base types

COBREXA._default — Method
_default(d::T, x::Maybe{T})::T where {T}

Fold the Maybe{T} down to T by defaulting.

source
COBREXA.Annotations — Type
Annotations = Dict{String,Vector{String}}

Dictionary used to store (possible multiple) standardized annotations of something, such as a Metabolite and a Reaction.

Example

Annotations("PubChem" => ["CID12345", "CID54321"])
source
COBREXA.GeneAssociation — Type
GeneAssociation = Vector{Vector{String}}

An association to genes, represented as a logical formula in a positive disjunctive normal form (DNF). (The 2nd-level vectors of strings are connected by "and" to form conjunctions, and the 1st-level vectors of these conjunctions are connected by "or" to form the DNF.)

source
COBREXA.MetabolicModel — Type
abstract type MetabolicModel end

A helper supertype of everything usable as a linear-like model for COBREXA functions.

If you want your model type to work with COBREXA, add the MetabolicModel as its supertype, and implement the accessor functions. Accessors reactions, metabolites, stoichiometry, bounds and objective must be implemented; others are not mandatory and default to safe "empty" values.

source
COBREXA.Notes — Type
Notes = Dict{String,Vector{String}}

Free-form notes about something (e.g. a Gene), categorized by "topic".

source

Model types and contents

COBREXA.CoreModel — Type
struct CoreModel <: MetabolicModel

A "bare bones" core linear optimization problem of the form, with reaction and metabolite names.

min c^T x
s.t. S x = b
      xₗ ≤ x ≤ xᵤ
source
Base.convert — Method
Base.convert(::Type{CoreModel}, m::M) where {M <: MetabolicModel}

Make a CoreModel out of any compatible model type.

source
COBREXA.bounds — Method
bounds(a::CoreModel)::Tuple{Vector{Float64},Vector{Float64}}

CoreModel flux bounds.

source
COBREXA.genes — Method
genes(a::CoreModel)::Vector{String}

Collect all genes contained in the CoreModel. The call is expensive for large models, because the vector is not stored and instead gets rebuilt each time this function is called.

source
COBREXA.CoreCoupling — Type
mutable struct CoreCoupling{M} <: ModelWrapper where {M<:MetabolicModel}

A matrix-based wrap that adds reaction coupling matrix to the inner model. A flux x feasible in this model must satisfy:

    cₗ ≤ C x ≤ cᵤ
source
COBREXA.CoreModelCoupled — Type
const CoreModelCoupled = CoreCoupling{CoreModel}

A matrix-based linear model with additional coupling constraints in the form:

    cₗ ≤ C x ≤ cᵤ

Internally, the model is implemented using CoreCoupling that contains a single CoreModel.

source
Base.convert — Method
Base.convert(::Type{CoreCoupling{M}}, mm::MetabolicModel; clone_coupling = true) where {M}

Make a CoreCoupling out of any compatible model type.

source
COBREXA.coupling — Method
coupling(a::CoreCoupling)::SparseMat

Coupling constraint matrix for a CoreCoupling.

source
COBREXA.coupling_bounds — Method
coupling_bounds(a::CoreCoupling)::Tuple{Vector{Float64},Vector{Float64}}

Coupling bounds for a CoreCoupling.

source
COBREXA.FluxSummary — Type
FluxSummary

A struct used to store summary information about the solution of a constraint based analysis result.

source
COBREXA.flux_summary — Method
flux_summary(flux_result::Dict{String, Float64};
    exclude_exchanges = false,
    exchange_prefixes = _constants.exchange_prefixes,
    biomass_strings = _constants.biomass_strings,
    exclude_biomass = false,
    small_flux_bound = 1.0/_constants.default_reaction_bound^2,
    large_flux_bound = _constants.default_reaction_bound,
    keep_unbounded = false,
)::FluxSummary

Summarize a dictionary of fluxes into small, useful representation of the most important information contained. Useful for pretty-printing and quickly exploring the results. Internally this function uses looks_like_biomass_reaction and looks_like_exchange_reaction. The corresponding keyword arguments passed to these functions. Use this if your model has non-standard ids for reactions. Fluxes smaller than small_flux_bound are not stored, while fluxes larger than large_flux_bound are only stored if keep_unbounded is true.

Example

julia> sol = flux_dict(flux_balance_analysis(model, Tulip.Optimizer))
julia> fr = flux_summary(sol)
Biomass:
  BIOMASS_Ecoli_core_w_GAM: 0.8739
Import:
  EX_o2_e:     -21.7995
  EX_glc__D_e: -10.0
  EX_nh4_e:    -4.7653
  EX_pi_e:     -3.2149
Export:
  EX_h_e:      17.5309
  EX_co2_e:    22.8098
  EX_h2o_e:    29.1758
source
COBREXA.flux_variability_summary — Method
flux_variability_summary(flux_result::Tuple{Dict{String, Dict{String, Float64}}, Dict{String, Dict{String, Float64}}};
    exclude_exchanges = false,
    exchange_prefixes = _constants.exchange_prefixes,
    biomass_strings = _constants.biomass_strings,
    exclude_biomass = false,
    )::FluxVariabilitySummary

Summarize a dictionary of flux dictionaries obtained eg. from flux_variability_analysis_dict. The simplified summary representation is useful for pretty-printing and easily showing the most important results.

Internally this function uses looks_like_biomass_reaction and looks_like_exchange_reaction. The corresponding keyword arguments are passed to these functions. Use this if your model has an uncommon naming of reactions.

Example

julia> sol = flux_variability_analysis_dict(model, Gurobi.Optimizer; bounds = objective_bounds(0.99))
julia> flux_res = flux_variability_summary(sol)
Biomass                     Lower bound   Upper bound
  BIOMASS_Ecoli_core_w_GAM: 0.8652        0.8652
Exchange
  EX_h2o_e:                 28.34         28.34
  EX_co2_e:                 22.0377       22.0377
  EX_o2_e:                  -22.1815      -22.1815
  EX_h_e:                   17.3556       17.3556
  EX_glc__D_e:              -10.0         -10.0
  EX_nh4_e:                 -4.8448       -4.8448
  EX_pi_e:                  -3.2149       -3.2149
  EX_for_e:                 0.0           0.0
  ...                       ...           ...
source
COBREXA.Gene — Type

Gene struct.

Fields

id :: String
name :: Maybe{String}
notes :: Dict{String, Vector{String}}
annotation :: Dict{String, Union{Vector{String}, String}}
source
COBREXA.Isozyme — Type
mutable struct Isozyme

Information about isozyme composition and activity.

Fields

  • gene_product_count :: Dict{String, Int} assigns each gene product ID its count in the isozyme complex (which is used to determine the total mass of the isozyme)
  • kcat_forward, kcat_reverse – forward and reverse turnover numbers of the isozyme

````

source
COBREXA.JSONModel — Type
struct JSONModel <: MetabolicModel
    json::Dict{String,Any}
    rxn_index::Dict{String,Int}
    rxns::Vector{Any}
    met_index::Dict{String,Int}
    mets::Vector{Any}
    gene_index::Dict{String,Int}
    genes::Vector{Any}
end

A struct used to store the contents of a JSON model, i.e. a model read from a file ending with .json. These model files typically store all the model data in arrays of JSON objects (represented in Julia as vectors of dictionaries).

Usually, not all of the fields of the input JSON can be easily represented when converting to other models, care should be taken to avoid losing information.

Direct work with the json structure is not very efficient; the model structure therefore caches some of the internal structure in the extra fields. The single-parameter JSONModel constructor creates these caches correctly from the json. The model structure is designed as read-only, and changes in json invalidate the cache.

Example

model = load_json_model("some_model.json")
model.json # see the actual underlying JSON
reactions(model) # see the list of reactions
source
COBREXA.bounds — Method
bounds(model::JSONModel)

Get the bounds for reactions, assuming the information is stored in .lower_bound and .upper_bound.

source
COBREXA.objective — Method
objective(model::JSONModel)

Collect .objective_coefficient keys from model reactions.

source
COBREXA.reactions — Method
reactions(model::JSONModel)

Extract reaction names (stored as .id) from JSON model.

source
COBREXA.stoichiometry — Method
stoichiometry(model::JSONModel)

Get the stoichiometry. Assuming the information is stored in reaction object under key .metabolites.

source
COBREXA.MATModel — Type
struct MATModel

Wrapper around the models loaded in dictionaries from the MATLAB representation.

source
Base.convert — Method
Base.convert(::Type{MATModel}, m::MetabolicModel)

Convert any metabolic model to MATModel.

source
COBREXA.balance — Method
balance(m::MATModel)

Extracts balance from the MAT model, defaulting to zeroes if not present.

source
COBREXA.bounds — Method
bounds(m::MATModel)

Extracts bounds from the MAT file, saved under lb and ub.

source
COBREXA.coupling_bounds — Method
coupling_bounds(m::MATModel)

Extracts the coupling constraints. Currently, there are several accepted ways to store these in MATLAB models; this takes the constraints from vectors cl and cu.

source
COBREXA.genes — Method
genes(m::MATModel)

Extracts the possible gene list from genes key.

source
COBREXA.metabolites — Method
metabolites(m::MATModel)::Vector{String}

Extracts metabolite names from mets key in the MAT file.

source
COBREXA.objective — Method
objective(m::MATModel)

Extracts the objective from the MAT model (defaults to zeroes).

source
COBREXA.reactions — Method
reactions(m::MATModel)::Vector{String}

Extracts reaction names from rxns key in the MAT file.

source
COBREXA.balance — Method
balance(a::MetabolicModel)::SparseVec

Get the sparse balance vector of a model.

source
COBREXA.bounds — Method
bounds(a::MetabolicModel)::Tuple{Vector{Float64},Vector{Float64}}

Get the lower and upper solution bounds of a model.

source
COBREXA.coupling — Method
coupling(a::MetabolicModel)::SparseMat

Get a matrix of coupling constraint definitions of a model. By default, there is no coupling in the models.

source
COBREXA.coupling_bounds — Method
coupling_bounds(a::MetabolicModel)::Tuple{Vector{Float64},Vector{Float64}}

Get the lower and upper bounds for each coupling bound in a model, as specified by coupling. By default, the model does not have any coupling bounds.

source
COBREXA.fluxes — Method
fluxes(a::MetabolicModel)::Vector{String}

In some models, the reactions that correspond to the columns of stoichiometry matrix do not fully represent the semantic contents of the model; for example, fluxes may be split into forward and reverse reactions, reactions catalyzed by distinct enzymes, etc. Together with reaction_flux (and n_fluxes) this specifies how the flux is decomposed into individual reactions.

By default (and in most models), fluxes and reactions perfectly correspond.

source
COBREXA.gene_annotations — Method
gene_annotations(a::MetabolicModel, gene_id::String)::Annotations

Return standardized names that identify the corresponding gene or product. The dictionary assigns vectors of possible identifiers to identifier system names, e.g. "PDB" => ["PROT01"].

source
COBREXA.gene_name — Method
gene_name(model::MetabolicModel, gid::String)

Return the name of gene with ID gid.

source
COBREXA.gene_notes — Method
gene_notes(model::MetabolicModel, gene_id::String)::Notes

Return the notes associated with the gene gene_id in model.

source
COBREXA.genes — Method
genes(a::MetabolicModel)::Vector{String}

Return identifiers of all genes contained in the model. By default, there are no genes.

In SBML, these are usually called "gene products" but we write genes for simplicity.

source
COBREXA.metabolite_annotations — Method
metabolite_annotations(a::MetabolicModel, metabolite_id::String)::Annotations

Return standardized names that may help to reliably identify the metabolite. The dictionary assigns vectors of possible identifiers to identifier system names, e.g. "ChEMBL" => ["123"] or "PubChem" => ["CID123", "CID654645645"].

source
COBREXA.metabolite_charge — Method
metabolite_charge(model::MetabolicModel, metabolite_id::String)::Maybe{Int}

Return the charge associated with metabolite metabolite_id in model. Returns nothing if charge not present.

source
COBREXA.metabolite_compartment — Method
metabolite_compartment(model::MetabolicModel, metabolite_id::String)::Maybe{String}

Return the compartment of metabolite metabolite_id in model if it is assigned. If not, return nothing.

source
COBREXA.metabolite_formula — Method
metabolite_formula(
    a::MetabolicModel,
    metabolite_id::String,
)::Maybe{MetaboliteFormula}

Return the formula of metabolite metabolite_id in model. Return nothing in case the formula is not known or irrelevant.

source
COBREXA.metabolite_notes — Method
metabolite_notes(model::MetabolicModel, metabolite_id::String)::Notes

Return the notes associated with metabolite reaction_id in model.

source
COBREXA.metabolites — Method
metabolites(a::MetabolicModel)::Vector{String}

Return a vector of metabolite identifiers in a model. The vector precisely corresponds to the rows in stoichiometry matrix.

As with reactionss, some metabolites in models may be virtual, representing purely technical equality constraints.

source
COBREXA.n_genes — Method
n_genes(a::MetabolicModel)::Int

Return the number of genes in the model (as returned by genes). If you just need the number of the genes, this may be much more efficient than calling genes and measuring the array.

source
COBREXA.objective — Method
objective(a::MetabolicModel)::SparseVec

Get the objective vector of the model. Analysis functions, such as flux_balance_analysis, are supposed to maximize dot(objective, x) where x is a feasible solution of the model.

source
COBREXA.precache! — Method
precache!(a::MetabolicModel)::Nothing

Do whatever is feasible to get the model into a state that can be read from as-quickly-as-possible. This may include e.g. generating helper index structures and loading delayed parts of the model from disk. The model should be modified "transparently" in-place. Analysis functions call this right before applying modifications or converting the model to the optimization model using make_optimization_model; usually on the same machine where the optimizers (and, generally, the core analysis algorithms) will run. The calls are done in a good hope that the performance will be improved.

By default, it should be safe to do nothing.

source
COBREXA.reaction_annotations — Method
reaction_annotations(a::MetabolicModel, reaction_id::String)::Annotations

Return standardized names that may help identifying the reaction. The dictionary assigns vectors of possible identifiers to identifier system names, e.g. "Reactome" => ["reactomeID123"].

source
COBREXA.reaction_flux — Method
reaction_flux(a::MetabolicModel)::SparseMat

Retrieve a sparse matrix that describes the correspondence of a solution of the linear system to the fluxes (see fluxes for rationale). Returns a sparse matrix of size (n_reactions(a), n_fluxes(a)). For most models, this is an identity matrix.

source
COBREXA.reaction_gene_association — Method
reaction_gene_association(a::MetabolicModel, gene_id::String)::Maybe{GeneAssociation}

Returns the sets of genes that need to be present so that the reaction can work (technically, a DNF on gene availability, with positive atoms only).

For simplicity, nothing may be returned, meaning that the reaction always takes place. (in DNF, that would be equivalent to returning [[]].)

source
COBREXA.reaction_notes — Method
reaction_notes(model::MetabolicModel, reaction_id::String)::Notes

Return the notes associated with reaction reaction_id in model.

source
COBREXA.reaction_stoichiometry — Method
reaction_stoichiometry(model::MetaboliteModel, rid::String)::Dict{String, Float64}

Return the stoichiometry of reaction with ID rid in the model. The dictionary maps the metabolite IDs to their stoichiometric coefficients.

source
COBREXA.reaction_subsystem — Method
reaction_subsystem(model::MetabolicModel, reaction_id::String)::Maybe{String}

Return the subsystem of reaction reaction_id in model if it is assigned. If not, return nothing.

source
COBREXA.reactions — Method
reactions(a::MetabolicModel)::Vector{String}

Return a vector of reaction identifiers in a model. The vector precisely corresponds to the columns in stoichiometry matrix.

For technical reasons, the "reactions" may sometimes not be true reactions but various virtual and helper pseudo-reactions that are used in the metabolic modeling, such as metabolite exchanges, separate forward and reverse reactions, supplies of enzymatic and genetic material and virtual cell volume, etc. To simplify the view of the model contents use reaction_flux.

source
COBREXA.stoichiometry — Method
stoichiometry(a::MetabolicModel)::SparseMat

Get the sparse stoichiometry matrix of a model. A feasible solution x of a model m is defined as satisfying the equations:

  • stoichiometry(m) * x .== balance(m)
  • x .>= lbs
  • y .<= ubs
  • `(lbs, ubs) == bounds(m)
source
COBREXA.Metabolite — Type

Metabolite structure.

Fields

id :: String
name :: Maybe{String}
formula :: String
charge :: Int
compartment :: String
notes :: Dict{String, Vector{String}}
annotation :: Dict{String, Union{Vector{String}, String}}
source
COBREXA.Reaction — Type
Reaction(
    id::String,
    metabolites::Dict{String,Union{Int, Float64}},
    dir = :bidirectional;
    default_bound = _constants.default_reaction_bound,
)

Convenience constructor for Reaction. The reaction equation is specified using metabolites, which is a dictionary mapping metabolite ids to stoichiometric coefficients. The direcion of the reaction is set through dir which can take :bidirectional, :forward, and :reverse as values. Finally, the default_bound is the value taken to mean infinity in the context of constraint based models, often this is set to a very high flux value like 1000.

source
COBREXA.Reaction — Type
Reaction(
    id = "";
    name = nothing,
    metabolites = Dict{String,Float64}(),
    lb = -_constants.default_reaction_bound,
    ub = _constants.default_reaction_bound,
    grr = nothing,
    subsystem = nothing,
    notes = Notes(),
    annotations = Annotations(),
    objective_coefficient = 0.0,
)

A constructor for Reaction that only takes a reaction id and assigns default/uninformative values to all the fields that are not explicitely assigned.

source
COBREXA.Reaction — Type
mutable struct Reaction
    id::String
    name::Maybe{String}
    metabolites::Dict{String,Float64}
    lb::Float64
    ub::Float64
    grr::Maybe{GeneAssociation}
    subsystem::Maybe{String}
    notes::Notes
    annotations::Annotations
    objective_coefficient::Float64
end

A structure for representing a single reaction in a StandardModel.

source
COBREXA.SBMLModel — Type
struct SBMLModel

Thin wrapper around the model from SBML.jl library. Allows easy conversion from SBML to any other model format.

source
COBREXA.bounds — Method
bounds(model::SBMLModel)::Tuple{Vector{Float64},Vector{Float64}}

Get the lower and upper flux bounds of model SBMLModel. Throws DomainError in case if the SBML contains mismatching units.

source
COBREXA.Serialized — Type
mutable struct Serialized{M <: MetabolicModel}
    m::Maybe{M}
    filename::String
end

A meta-model that represents a model that is serialized on the disk. The internal model will be loaded on-demand by using any accessor, or by calling precache! directly.

source
COBREXA.precache! — Method
precache!(model::Serialized{MetabolicModel})::Nothing

Load the Serialized model from disk in case it's not alreadly loaded.

source
COBREXA.StandardModel — Type
mutable struct StandardModel

StandardModel is used to store a constraint based metabolic model with meta-information. Meta-information is defined as annotation details, which include gene-reaction-rules, formulas, etc.

This model type seeks to keep as much meta-information as possible, as opposed to CoreModel and CoreModelCoupled, which keep the bare neccessities only. When merging models and keeping meta-information is important, use this as the model type. If meta-information is not important, use the more efficient core model types. See CoreModel and CoreModelCoupled for comparison.

In this model, reactions, metabolites, and genes are stored in ordered dictionaries indexed by each struct's id field. For example, model.reactions["rxn1_id"] returns a Reaction where the field id equals "rxn1_id". This makes adding and removing reactions efficient.

Note that the stoichiometric matrix (or any other core data, e.g. flux bounds) is not stored directly as in CoreModel. When this model type is used in analysis functions, these core data structures are built from scratch each time an analysis function is called. This can cause performance issues if you run many small analysis functions sequentially. Consider using the core model types if performance is critical.

See also: Reaction, Metabolite, Gene

Fields

id :: String
reactions :: OrderedDict{String, Reaction}
metabolites :: OrderedDict{String, Metabolite}
genes :: OrderedDict{String, Gene}

Example

model = load_model(StandardModel, "my_model.json")
keys(model.reactions)
source
Base.convert — Method

Base.convert(::Type{StandardModel}, model::MetabolicModel)

Convert any MetabolicModel into a StandardModel. Note, some data loss may occur since only the generic interface is used during the conversion process.

source
COBREXA.balance — Method
balance(model::StandardModel)

Return the balance of the linear problem, i.e. b in Sv = 0 where S is the stoichiometric matrix and v is the flux vector.

source
COBREXA.bounds — Method
bounds(model::StandardModel)::Tuple{Vector{Float64},Vector{Float64}}

Return the lower and upper bounds, respectively, for reactions in model. Order matches that of the reaction ids returned in reactions().

source
COBREXA.gene_annotations — Method
gene_annotations(model::StandardModel, id::String)::Annotations

Return the annotation associated with gene id in model. Return an empty Dict if not present.

source
COBREXA.gene_notes — Method
gene_notes(model::StandardModel, id::String)::Notes

Return the notes associated with gene id in model. Return an empty Dict if not present.

source
COBREXA.genes — Method
genes(model::StandardModel)

Return a vector of gene id strings in model.

source
COBREXA.lower_bounds — Method
lower_bounds(model::StandardModel)::Vector{Float64}

Return the lower bounds for all reactions in model in sparse format.

source
COBREXA.metabolite_annotations — Method
metabolite_annotations(model::StandardModel, id::String)::Annotations

Return the annotation associated with metabolite id in model. Return an empty Dict if not present.

source
COBREXA.metabolite_charge — Method
metabolite_charge(model::StandardModel, id::String)

Return the charge associated with metabolite id in model. Return nothing if not present.

source
COBREXA.metabolite_compartment — Method
metabolite_compartment(model::StandardModel, id::String)

Return compartment associated with metabolite id in model. Return nothing if not present.

source
COBREXA.metabolite_formula — Method
metabolite_formula(model::StandardModel, id::String)

Return the formula of reaction id in model. Return nothing if not present.

source
COBREXA.metabolite_notes — Method
metabolite_notes(model::StandardModel, id::String)::Notes

Return the notes associated with metabolite id in model. Return an empty Dict if not present.

source
COBREXA.metabolites — Method
metabolites(model::StandardModel)

Return a vector of metabolite id strings contained in model. The order of metabolite strings returned here matches the order used to construct the stoichiometric matrix.

source
COBREXA.reaction_annotations — Method
reaction_annotations(model::StandardModel, id::String)::Annotations

Return the annotation associated with reaction id in model. Return an empty Dict if not present.

source
COBREXA.reaction_gene_association — Method
reaction_gene_association(model::StandardModel, id::String)

Return the gene reaction rule in string format for reaction with id in model. Return nothing if not available.

source
COBREXA.reaction_notes — Method
reaction_notes(model::StandardModel, id::String)::Notes

Return the notes associated with reaction id in model. Return an empty Dict if not present.

source
COBREXA.reaction_subsystem — Method
reaction_subsystem(id::String, model::StandardModel)

Return the subsystem associated with reaction id in model. Return nothing if not present.

source
COBREXA.reactions — Method
reactions(model::StandardModel)

Return a vector of reaction id strings contained in model. The order of reaction ids returned here matches the order used to construct the stoichiometric matrix.

source
COBREXA.stoichiometry — Method
stoichiometry(model::StandardModel)

Return the stoichiometric matrix associated with model in sparse format.

source
COBREXA.upper_bounds — Method
upper_bounds(model::StandardModel)::Vector{Float64}

Return the upper bounds for all reactions in model in sparse format. Order matches that of the reaction ids returned in reactions().

source

Model type wrappers

COBREXA.GeckoModel — Type
struct GeckoModel <: ModelWrapper

A model with complex enzyme concentration and capacity bounds, as described in Sánchez, Benjamín J., et al. "Improving the phenotype predictions of a yeast genome-scale metabolic model by incorporating enzymatic constraints." Molecular systems biology 13.8 (2017): 935.

Use make_gecko_model or with_gecko to construct this kind of model.

The model wraps another "internal" model, and adds following modifications:

  • enzymatic reactions with known enzyme information are split into multiple forward and reverse variants for each isozyme,
  • reaction coupling is added to ensure the groups of isozyme reactions obey the global reaction flux bounds from the original model,
  • gene concentrations specified by each reaction and its gene product stoichiometry, can constrained by the user to reflect measurements, such as from mass spectrometry,
  • additional coupling is added to simulate total masses of different proteins grouped by type (e.g., membrane-bound and free-floating proteins), which can be again constrained by the user (this is slightly generalized from original GECKO algorithm, which only considers a single group of indiscernible proteins).

The structure contains fields columns that describe the contents of the stoichiometry matrix columns, coupling_row_reaction, coupling_row_gene_product and coupling_row_mass_group that describe correspondence of the coupling rows to original model and determine the coupling bounds (note: the coupling for gene product is actually added to stoichiometry, not in coupling), and inner, which is the original wrapped model. The objective of the model includes also the extra columns for individual genes, as held by coupling_row_gene_product.

Implementation exposes the split reactions (available as reactions(model)), but retains the original "simple" reactions accessible by fluxes. The related constraints are implemented using coupling and coupling_bounds.

source
COBREXA._gecko_capacity — Type
struct _gecko_capacity

A helper struct that contains the gene product capacity terms organized by the grouping type, e.g. metabolic or membrane groups etc.

source
COBREXA.balance — Method
balance(model::GeckoModel)

Return the balance of the reactions in the inner model, concatenated with a vector of zeros representing the enzyme balance of a GeckoModel.

source
COBREXA.coupling — Method
coupling(model::GeckoModel)

Return the coupling of GeckoModel. That combines the coupling of the wrapped model, coupling for split (arm) reactions, and the coupling for the total enzyme capacity.

source
COBREXA.genes — Method
genes(model::GeckoModel)

Return the gene ids of genes that have enzymatic constraints associated with them.

source
COBREXA.n_genes — Method
n_genes(model::GeckoModel)

Return the number of genes that have enzymatic constraints associated with them.

source
COBREXA.n_reactions — Method
n_reactions(model::GeckoModel)

Returns the number of all irreversible reactions in model as well as the number of gene products that take part in enzymatic reactions.

source
COBREXA.objective — Method
objective(model::GeckoModel)

Return the objective of the GeckoModel. Note, the objective is with respect to the internal variables, i.e. reactions(model), which are the unidirectional reactions and the genes involved in enzymatic reactions that have kinetic data.

source
COBREXA.reactions — Method
reactions(model::GeckoModel)

Returns the internal reactions in a GeckoModel (these may be split to forward- and reverse-only parts with different isozyme indexes; reactions IDs are mangled accordingly with suffixes).

source
COBREXA.stoichiometry — Method
stoichiometry(model::GeckoModel)

Return a stoichiometry of the GeckoModel. The enzymatic reactions are split into unidirectional forward and reverse ones, each of which may have multiple variants per isozyme.

source
COBREXA.SMomentModel — Type
struct SMomentModel <: ModelWrapper

An enzyme-capacity-constrained model using sMOMENT algorithm, as described by Bekiaris, Pavlos Stephanos, and Steffen Klamt, "Automatic construction of metabolic models with enzyme constraints" BMC bioinformatics, 2020.

Use make_smoment_model or with_smoment to construct the models.

The model is constructed as follows:

  • stoichiometry of the original model is retained as much as possible, but enzymatic reations are split into forward and reverse parts (marked by a suffix like ...#forward and ...#reverse),
  • coupling is added to simulate a virtual metabolite "enzyme capacity", which is consumed by all enzymatic reactions at a rate given by enzyme mass divided by the corresponding kcat,
  • the total consumption of the enzyme capacity is constrained to a fixed maximum.

The SMomentModel structure contains a worked-out representation of the optimization problem atop a wrapped MetabolicModel, in particular the separation of certain reactions into unidirectional forward and reverse parts, an "enzyme capacity" required for each reaction, and the value of the maximum capacity constraint. Original coupling in the inner model is retained.

In the structure, the field columns describes the correspondence of stoichiometry columns to the stoichiometry and data of the internal wrapped model, and total_enzyme_capacity is the total bound on the enzyme capacity consumption as specified in sMOMENT algorithm.

This implementation allows easy access to fluxes from the split reactions (available in reactions(model)), while the original "simple" reactions from the wrapped model are retained as fluxes. All additional constraints are implemented using coupling and coupling_bounds.

source
COBREXA.coupling — Method
coupling(model::SMomentModel)

Return the coupling of SMomentModel. That combines the coupling of the wrapped model, coupling for split reactions, and the coupling for the total enzyme capacity.

source
COBREXA.reactions — Method
reactions(model::SMomentModel)

Returns the internal reactions in a SMomentModel (these may be split to forward- and reverse-only parts; reactions IDs are mangled accordingly with suffixes).

source
COBREXA.stoichiometry — Method
stoichiometry(model::SMomentModel)

Return a stoichiometry of the SMomentModel. The enzymatic reactions are split into unidirectional forward and reverse ones.

source