Struct kair::model::ModelLp

pub struct ModelLp {
    pub id: String,
    pub name: String,
    pub metabolites: HashMap<String, Species>,
    pub reactions: HashMap<String, ReactionLp>,
    pub variables: HashMap<String, Variable>,
    pub config: HashMap<String, Parameter>,
    pub objective: String,
    pub stoichiometry: HashMap<String, Vec<Expression>>,
}

LP problem as a Flux Balance Analysis formulation.

See: What is flux balance analysis?, Orth et al., 2010

Being $f(\overrightarrow{z})$ a function to optimize (historically, biomass or ATPase), $S$ and stoichimetry matrix and $\overrightarrow{v}$ the flux vector representing the reactions in the reconstruction:

$$ \text{Max.} f(\overrightarrow{z}) \newline \text{subject to}\medspace S\overrightarrow{v} = 0 \newline \text{where}\medspace lb_j \le v_j \le ub_j $$

Fields

id: String

Id from SBML document

name: String

Name from SBML document

metabolites: HashMap<String, Species>

Metabolites from the SBML document

reactions: HashMap<String, ReactionLp>

Reactions from the SBML document

variables: HashMap<String, Variable>

Parsed from reactions, variables of LP problem

config: HashMap<String, Parameter>

Parameters from the SBML document

objective: String

Reaction id to be used as the objective in the LP problem

stoichiometry: HashMap<String, Vec<Expression>>

Parsed stoichiometry matrix

Implementations

impl ModelLp

pub fn new(input_sbml: Model) -> Self

Read and call the LP builder.

Example

use kair::ModelLp;
use std::str::FromStr;

// contents is a &str containing a SBML document
ModelLp::from_str(&contents).unwrap();

pub fn populate_model(&mut self, problem: &mut ProblemVariables)

Build LP problem as an FBA formulation.

pub fn get_objective(&self) -> Variable

Get objective variable given the objective identifier

pub fn get_objective_reaction(&mut self) -> Result<&mut ReactionLp, SBMLError>

Get objective variable given the objective identifier

pub fn add_constraints<S: Solver>(&self, model: &mut S::Model)

Add the constraints to th problem

Trait Implementations

impl Clone for ModelLp

fn clone(&self) -> ModelLp

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl From<Model> for ModelLp

fn from(model: Model) -> ModelLp

Performs the conversion.

impl FromStr for ModelLp

type Err = Box<dyn Error>

The associated error which can be returned from parsing.

fn from_str(input_sbml: &str) -> Result<Self, Box<dyn Error>>

Parses a string s to return a value of this type.