Types

Maybe{T} = Union{Nothing, T}

A nice name for "nullable" type.

_default(d::T, x::Maybe{T})::T where {T}

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

_maybemap(f, x::Maybe)::Maybe

Apply a function to x only if it is not nothing.

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"])

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

abstract type MetabolicModel end

A helper supertype that wraps 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.

MetaboliteFormula = Dict{String,Int}

Dictionary of atoms and their abundances in a molecule.

Notes = Dict{String,Vector{String}}

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

balance(a::MetabolicModel)::SparseVec

Get the sparse balance vector of a model (ie. the b from S x = b).

bounds(a::MetabolicModel)::Tuple{Vector{Float64},Vector{Float64}}

Get the lower and upper flux bounds of a model.

coupling(a::MetabolicModel)::SparseMat

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

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.

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"].

gene_name(model::MetabolicModel, gid::String)

Return the name of gene with ID gid.

gene_notes(model::MetabolicModel, gene_id::String)::Notes

Return the notes associated with the gene gene_id in model.

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.

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"].

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.

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.

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.

metabolite_name(model::MetabolicModel, mid::String)

Return the name of metabolite with ID mid.

metabolite_notes(model::MetabolicModel, metabolite_id::String)::Notes

Return the notes associated with metabolite reaction_id in model.

metabolites(a::MetabolicModel)::Vector{String}

Return a vector of metabolite identifiers in a model.

n_coupling_constraints(a::MetabolicModel)::Int

Get the number of coupling constraints in a model.

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.

n_metabolites(a::MetabolicModel)::Int

Get the number of metabolites in a model.

n_reactions(a::MetabolicModel)::Int

Get the number of reactions in a model.

objective(a::MetabolicModel)::SparseVec

Get the objective vector of a model.

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.

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"].

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

reaction_name(model::MetabolicModel, rid::String)

Return the name of reaction with ID rid.

reaction_notes(model::MetabolicModel, reaction_id::String)::Notes

Return the notes associated with reaction reaction_id in model.

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.

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.

reactions(a::MetabolicModel)::Vector{String}

Return a vector of reaction identifiers in a model.

stoichiometry(a::MetabolicModel)::SparseMat

Get the sparse stoichiometry matrix of a model.

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ᵤ

Base.convert(::Type{CoreModel}, m::M) where {M <: MetabolicModel}

Make a CoreModel out of any compatible model type.

balance(a::CoreModel)::SparseVec

CoreModel target flux balance.

bounds(a::CoreModel)::Tuple{Vector{Float64},Vector{Float64}}

CoreModel flux bounds.

metabolites(a::CoreModel)::Vector{String}

Metabolites in a CoreModel.

objective(a::CoreModel)::SparseVec

CoreModel objective vector.

reaction_gene_association(model::CoreModel, ridx::Int)::Maybe{GeneAssociation}

Retrieve the GeneAssociation from CoreModel by reaction index.

reaction_gene_association(model::CoreModel, rid::String)::Maybe{GeneAssociation}

Retrieve the GeneAssociation from CoreModel by reaction ID.

reaction_gene_association_vec(model::CoreModel)::Vector{Maybe{GeneAssociation}}

Retrieve a vector of all gene associations in a CoreModel, in the same order as reactions(model).

reaction_stoichiometry(model::CoreModel, ridx)::Dict{String, Float64}

Return the stoichiometry of reaction at index ridx.

reaction_stoichiometry(model::CoreModel, rid::String)::Dict{String, Float64}

Return the stoichiometry of reaction with ID rid.

reactions(a::CoreModel)::Vector{String}

Get the reactions in a CoreModel.

stoichiometry(a::CoreModel)::SparseMat

CoreModel stoichiometry matrix.

struct CoreModelCoupled <: MetabolicModel

The linear model with additional coupling constraints in the form

    cₗ ≤ C x ≤ cᵤ

Base.convert(::Type{CoreModelCoupled}, mm::MetabolicModel)

Make a CoreModelCoupled out of any compatible model type.

balance(a::CoreModelCoupled)

Extract balance from CoreModelCoupled (uses the internal CoreModel).

bounds(a::CoreModelCoupled)

Extract bounds from CoreModelCoupled (uses the internal CoreModel).

coupling(a::CoreModelCoupled)::SparseMat

Coupling constraint matrix for a CoreModelCoupled.

coupling_bounds(a::CoreModelCoupled)::Tuple{Vector{Float64},Vector{Float64}}

Coupling bounds for a CoreModelCoupled.

metabolites(a::CoreModelCoupled)

Extract metabolites from CoreModelCoupled (uses the internal CoreModel).

n_coupling_constraints(a::CoreModelCoupled)::Int

The number of coupling constraints in a CoreModelCoupled.

objective(a::CoreModelCoupled)

Extract objective from CoreModelCoupled (uses the internal CoreModel).

reaction_gene_association(model::CoreModelCoupled, ridx::Int)::Maybe{GeneAssociation}

Retrieve the GeneAssociation from CoreModelCoupled by reaction index.

reaction_gene_association(model::CoreModelCoupled, rid::String)::Maybe{GeneAssociation}

Retrieve the GeneAssociation from CoreModelCoupled by reaction ID.

reaction_gene_association_vec(model::CoreModelCoupled)::Vector{Maybe{GeneAssociation}}

Retrieve a vector of gene associations in a CoreModelCoupled, in the same order as reactions(model).

reaction_stoichiometry(model::CoreModelCoupled, ridx)::Dict{String, Float64}

Return the stoichiometry of reaction at index ridx.

reaction_stoichiometry(model::CoreModelCoupled, rid::String)::Dict{String, Float64}

Return the stoichiometry of reaction with ID rid.

reactions(a::CoreModelCoupled)

Extract reactions from CoreModelCoupled (uses the internal CoreModel).

stoichiometry(a::CoreModelCoupled)

Extract stoichiometry from CoreModelCoupled (uses the internal CoreModel).

FluxSummary

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

FluxSummary()

A default empty constructor for FluxSummary.

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

FluxVariabilitySummary

Stores summary information about the result of a flux variability analysis.

FluxVariabilitySummary()

A default empty constructor for FluxVariabilitySummary.

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

Gene struct.

Fields

id :: String
name :: Maybe{String}
notes :: Dict{String, Vector{String}}
annotation :: Dict{String, Union{Vector{String}, String}}

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

Base.convert(::Type{JSONModel}, mm::MetabolicModel)

Convert any MetabolicModel to JSONModel.

bounds(model::JSONModel)

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

gene_annotations(model::JSONModel, gid::String)::Annotations

Gene annotations from the JSONModel.

gene_name(model::JSONModel, gid::String)

Return the name of gene with ID gid.

gene_notes(model::JSONModel, gid::String)::Notes

Gene notes from the JSONModel.

genes(model::JSONModel)

Extract gene names from a JSON model.

metabolite_annotations(model::JSONModel, mid::String)::Annotations

Metabolite annotations from the JSONModel.

metabolite_charge(model::JSONModel, mid::String)

Return the metabolite .charge

metabolite_compartment(model::JSONModel, mid::String)

Return the metabolite .compartment

metabolite_formula(model::JSONModel, mid::String)

Parse and return the metabolite .formula

metabolite_name(model::JSONModel, mid::String)

Return the name of metabolite with ID mid.

metabolite_notes(model::JSONModel, mid::String)::Notes

Metabolite notes from the JSONModel.

metabolites(model::JSONModel)

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

objective(model::JSONModel)

Collect .objective_coefficient keys from model reactions.

reaction_annotations(model::JSONModel, rid::String)::Annotations

Reaction annotations from the JSONModel.

reaction_gene_associaton(model::JSONModel, rid::String)

Parses the .gene_reaction_rule from reactions.

reaction_name(model::JSONModel, rid::String)

Return the name of reaction with ID rid.

reaction_notes(model::JSONModel, rid::String)::Notes

Reaction notes from the JSONModel.

reaction_stoichiometry(model::JSONModel, rid::String)::Dict{String, Float64}

Return the stoichiometry of reaction with ID rid.

reaction_subsystem(model::JSONModel, rid::String)

Parses the .subsystem out from reactions.

reactions(model::JSONModel)

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

stoichiometry(model::JSONModel)

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

struct MATModel

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

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

Convert any metabolic model to MATModel.

_mat_has_squashed_coupling(mat)

Guesses whether C in the MAT file is stored in A=[S;C].

balance(m::MATModel)

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

bounds(m::MATModel)

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

coupling(m::MATModel)

Extract coupling matrix stored, in C key.

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.

genes(m::MATModel)

Extracts the possible gene list from genes key.

metabolite_charge(m::MATModel, mid::String)

Extract metabolite charge from metCharge or metCharges.

metabolite_compartment(m::MATModel, mid::String)

Extract metabolite compartment from metCompartment or metCompartments.

metabolite_formula(m::MATModel, mid::String)

Extract metabolite formula from key metFormula or metFormulas.

metabolites(m::MATModel)::Vector{String}

Extracts metabolite names from mets key in the MAT file.

objective(m::MATModel)

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

reaction_gene_association(m::MATModel, rid::String)

Extracts the associations from grRules key, if present.

reaction_stoichiometry(model::MATModel, ridx)::Dict{String, Float64}

Return the stoichiometry of reaction at index ridx.

reaction_stoichiometry(model::MATModel, rid::String)::Dict{String, Float64}

Return the stoichiometry of reaction with ID rid.

reactions(m::MATModel)::Vector{String}

Extracts reaction names from rxns key in the MAT file.

stoichiometry(m::MATModel)

Extract the stoichiometry matrix, stored under key S.

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}}

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.

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.

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.

Used for concise reporting of modeling results.

struct SBMLModel

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

Base.convert(::Type{SBMLModel}, mm::MetabolicModel)

Convert any metabolic model to SBMLModel.

balance(model::SBMLModel)::SparseVec

Balance vector of a SBMLModel. This is always zero.

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.

gene_name(model::SBMLModel, gid::String)

Return the name of gene with ID gid.

genes(model::SBMLModel)::Vector{String}

Get genes of a SBMLModel.

metabolite_charge(model::SBMLModel, mid::String)::Maybe{Int}

Get charge of a chosen metabolite from SBMLModel.

metabolite_formula(model::SBMLModel, mid::String)::Maybe{MetaboliteFormula}

Get MetaboliteFormula from a chosen metabolite from SBMLModel.

metabolite_name(model::SBMLModel, mid::String)

Return the name of metabolite with ID mid.

metabolites(model::SBMLModel)::Vector{String}

Get metabolites from a SBMLModel.

n_genes(model::SBMLModel)::Int

Get number of genes in SBMLModel.

n_metabolites(model::SBMLModel)::Int

Efficient counting of metabolites in SBMLModel.

n_reactions(model::SBMLModel)::Int

Efficient counting of reactions in SBMLModel.

objective(model::SBMLModel)::SparseVec

Objective of the SBMLModel.

reaction_gene_association(model::SBMLModel, rid::String)::Maybe{GeneAssociation}

Retrieve the GeneAssociation from SBMLModel.

reaction_name(model::SBMLModel, rid::String)

Return the name of reaction with ID rid.

reaction_stoichiometry(model::SBMLModel, rid::String)::Dict{String, Float64}

Return the stoichiometry of reaction with ID rid.

reactions(model::SBMLModel)::Vector{String}

Get reactions from a SBMLModel.

stoichiometry(model::SBMLModel)::SparseMat

Recreate the stoichiometry matrix from the SBMLModel.

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.

precache!(model::Serialized{MetabolicModel})::Nothing

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

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)

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.

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.

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

gene_annotations(model::StandardModel, id::String)::Annotations

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

gene_name(m::StandardModel, gid::String)

Return the name of gene with ID id.

gene_notes(model::StandardModel, id::String)::Notes

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

genes(model::StandardModel)

Return a vector of gene id strings in model.

lower_bounds(model::StandardModel)::Vector{Float64}

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

metabolite_annotations(model::StandardModel, id::String)::Annotations

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

metabolite_charge(model::StandardModel, id::String)

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

metabolite_compartment(model::StandardModel, id::String)

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

metabolite_formula(model::StandardModel, id::String)

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

metabolite_name(m::StandardModel, mid::String)

Return the name of metabolite with ID id.

metabolite_notes(model::StandardModel, id::String)::Notes

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

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.

n_genes(model::StandardModel)

Return the number of genes in model.

n_metabolites(model::StandardModel)

Return the number of metabolites in model.

n_reactions(model::StandardModel)

Return the number of reactions contained in model.

objective(model::StandardModel)

Return sparse objective vector for model.

reaction_annotations(model::StandardModel, id::String)::Annotations

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

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.

reaction_name(m::StandardModel, rid::String)

Return the name of reaction with ID id.

reaction_notes(model::StandardModel, id::String)::Notes

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

reaction_stoichiometry(model::StandardModel, rid::String)::Dict{String, Float64}

Return the stoichiometry of reaction with ID rid.

reaction_subsystem(id::String, model::StandardModel)

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

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.

stoichiometry(model::StandardModel)

Return the stoichiometric matrix associated with model in sparse format.

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