Differences between revisions 35 and 38 (spanning 3 versions)
⇤ ← Revision 35 as of 2024-12-11 13:27:31 →
Size: 5182
Editor: mark
Comment:
← Revision 38 as of 2024-12-11 13:47:38 → ⇥
Size: 1671
Editor: mark
Comment:
Deletions are marked like this. Additions are marked like this.
Line 2: Line 2:
== Part 1 ==
Line 7: Line 8:
 1.  We can now generate a linear programming object:  1. We can now generate a linear programming object:
Line 10: Line 11:
  1. lp.SetObjective(m.sm.cnames)   1. lp.!SetObjective(m.sm.cnames)
Line 12: Line 13:
  1. lp.SetFixedFlux({"TAG_Exp_tx":-1})   1. lp.!SetFixedFlux({"TAG_Exp_tx":-1})
Line 14: Line 15:
  1. lp.Sovle()   1. lp.Solve()
Line 16: Line 17:
  1. sol = lp.GetPrimSol()   1. sol = lp.!GetPrimSol()
Line 18: Line 19:
Sol is a dictionary, mapping reactions to fluxes, satisfying our constraints and objectives. Examine its properties. e.g. what transport processes are involved? Sol is a dictionary, mapping reactions to fluxes, satisfying our constraints and objectives. Examine its properties. e.g. what transport processes are involved?for r in sol:
Line 20: Line 21:
for r in sol:  . if "_tx" in r:
  . print(r, sol[r])
Line 22: Line 24:
    if "_tx" in r:

        print(r, sol[r])





The code that you will be using is stored in module “!LipidScan.py” in the “Analysis” directory. (Note: Model directory contains the model definition files i.e .spy files and analysis contains the python modules, i.e., the ` .py` files you will need for this practical)

The module "!LipidScan.py" contains tNow exaine wo functions. Following is their code:

'''a. BuildLP ''''''function'''

{{{#!python
def BuildLP(m):
        lp = m.GetLP()
        lp.SetObjective(m.sm.cnames)
        lp.SetFluxBounds({"RIBULOSE-BISPHOSPHATE-CARBOXYLASE-RXN_Plas":(0,400.0)})
        if "GLYCEROL_Cyto_tx" in m.sm.cnames:
                lp.SetFluxBounds({"GLYCEROL_Cyto_tx":(0,20)})
        return lp
}}}
'''b. !LipidScan ''''''function'''

{{{#!python
def LipidScan(m,lp=None,lo=1.0,hi=20.0):
        ds = DataSets.DataSet()
        ranges = numpy.arange(lo,hi)
        if lp == None:
                lp = BuildLP(m)
        for t in ranges:
                lp.SetFixedFlux({"TAG_synthesis_Cyto":t})
                lp.Solve()
                if lp.GetStatusMsg() == "optimal":
                        sol = lp.GetPrimSol()
                        ds.UpdateFromDic(sol)
        ds.SetPlotX("TAG_synthesis_Cyto")
        ds.AddToPlot("RIBULOSE-BISPHOSPHATE-CARBOXYLASE-RXN_Plas")
        return ds
}}}
To use these methods you need to import the "!LipidScan" module. On ScrumPy window execute the following statements.

{{{#!python
import sys
sys.path.append('../Analysis')
import LipidScan
}}}
Now the methods in the "!LipidScan" module can be used.

 a. Generate LP problem where the objective is to minimise total flux. Constrain the maximum Rubisco flux and glycerol transporter flux to 400 and 20 respectively (make use of !SetFluxBounds() function).

{{{#!python
lp = LipidScan.BuildLP(m)
}}}
 . b. Solve this LP repeatedly (using for loop) while increasing flux in TAG synthesis reaction in range between 1 to 20. Save each of the solution in a dataset.

{{{#!python
ds = LipidScan.LipidScan(m, lp=lp)
}}}
 . c. Examine the flux pattern in Rubisco reaction with respect to increasing flux in TAG synthesis. What is the maximum flux in Rubisco reaction?

{{{#!python
ds.SetPlotX("TAG_synthesis_Cyto") #setting x-axis
ds.AddToPlot("RIBULOSE-BISPHOSPHATE-CARBOXYLASE-RXN_Plas")
}}}
 . d. Add inorganic carbon transporters (Hint: “CO2_Cyto_tx” and “HCO3_Cyto_tx”) and organic carbon transporter (“GLYCEROL_Cyto_tx”) to the plot ''' '''
 . e. What is the maximum flux in TAG synthesis? ''' '''

4. As you would have noticed TAG synthesis in above example is through mixotrophic mode (i.e model uses light energy and organic carbon, glycerol, for lipid production).

As you remember from the lecture, ''P. tricornutum'' can grow under phototrophic condition too (i.e in the absence of glycerol). You will simulate the model in autotrophic condition. For this, constrain the flux in glycerol transporter to zero. ''' '''

{{{#!python
lp = LipidScan.BuildLP(m)
lp.SetFixedFlux({"GLYCEROL_Cyto_tx":0})
res = LipidScan.LipidScan(m, lp=lp)
}}}
 * Plot reactions as above. Examine the difference in flux patterns.'
 * What is the maximum feasible flux in TAG synthesis under phototrophic condition?
 * Is is higher or lower than that in mixotrophic condition (in question 3)?

5. Find the reactions that are active in mixotrophic condition but not in phototrophic condition?

{{{#!python
from ScrumPy.Util import Set
Set.Complement(ds.cnames,res.cnames)
}}}
Try and identify which pathways these reactions belong to, see the digrams in the previous slides or search on the [[https://metacyc.org|MetaCyc]] website. NB: the `_Cyto suffix` is added to differentiate compartmentalisation in the model and is not part of !MetaCyc identifier, and should be removed before searching on !MetaCyc.		 Reaction and metabolite names are derived from [[https://metacyc.org|MetaCyc]] so you can use thses to find out more about individual reactions in the solution. NB: the `_Cyto suffix` is added to differentiate compartmentalisation in the model and is not part of !MetaCyc identifier, and should be removed before searching on !MetaCyc.
Line 113: Line 27:
 <<BR>>

== Part 2 - Constraint Scanning ==
=== See Demo and Tomorrow ===

Practical 5: Identifying pathways for TAG synthesis in Phaeodactylum tricornutum

Part 1

Here, we will investigate the genome-scale metabolic model of P. tricornutum to identify pathways for TAG synthesis. See Villanova et al (2021). Front. Plant Sci. 12:642199. doi: 10.3389/fpls.2021.642199

  1. Download the archive containing the model from here and extract the files.This will generate a new directory,"srcs", containing two sub-directories: "Model" and "Analysis". Start ScrumPy.

  2. Load the Model:

    1. m = ScrumPy.Model("../Model/Phaeo.spy")

  3. We can now generate a linear programming object:
    1. lp = m.GetLP()
  4. And specify minimising total flux as the objective:

    1. lp.SetObjective(m.sm.cnames)

  5. With the constraint that we must generate 1 mole of TAG:

    1. lp.SetFixedFlux({"TAG_Exp_tx":-1})

  6. We can now solve te lp:
    1. lp.Solve()
  7. And obtain the solution:

    1. sol = lp.GetPrimSol()

Sol is a dictionary, mapping reactions to fluxes, satisfying our constraints and objectives. Examine its properties. e.g. what transport processes are involved?for r in sol:

  • if "_tx" in r:
    • print(r, sol[r])

Reaction and metabolite names are derived from MetaCyc so you can use thses to find out more about individual reactions in the solution. NB: the _Cyto suffix is added to differentiate compartmentalisation in the model and is not part of MetaCyc identifier, and should be removed before searching on MetaCyc.


Part 2 - Constraint Scanning

See Demo and Tomorrow

None: Meetings/Nottingham2024/Prac5 (last edited 2024-12-12 09:03:16 by mark)