Part VII — Chapter 21

Systems Plant Biology

Multi-omics integration, genome-scale metabolic modelling, and network-theoretic analysis of plant metabolism — from GC-MS metabolite profiling and RNA-seq transcriptomics to machine learning-guided flux prediction.

Multi-Omics Integration in Plant Systems Biology

Omics Technologies

Metabolomics

GC-MS (Gas Chromatography-MS)

After derivatisation (TMS/TBDMS), volatile and semi-volatile metabolites (primary metabolites: amino acids, sugars, organic acids) separated by GC and fragmented by electron ionisation. Library matching (NIST, MassBank). ~200-500 metabolites per run.

LC-MS (Liquid Chromatography-MS)

Reversed-phase or HILIC separation; soft ionisation (ESI, APCI). Untargeted profiling of secondary metabolites (phenolics, terpenoids, alkaloids). HRMS (Q-TOF, Orbitrap) enables molecular formula determination.

NMR metabolomics

1H-NMR: quantitative, non-destructive; fingerprinting of complex mixtures. No derivatisation required. Lower sensitivity than MS but excellent for primary metabolites in crude extracts.

Transcriptomics & Proteomics

RNA-seq

Total or polyA-selected RNA fragmented, reverse-transcribed, and sequenced (Illumina/Nanopore). Alignment to genome (HISAT2, STAR) or de novo assembly (Trinity). DESeq2/edgeR for differential expression. Single-cell RNA-seq (10x Genomics) resolves cell-type-specific expression.

Label-free quantitative proteomics

Tryptic digests of cell extracts separated by nanoLC; MS2 fragmentation (DDA or DIA/SWATH) gives peptide identity and intensity. MaxQuant, Perseus for quantification. iBAQ normalisation for protein abundance.

13C-MFA (metabolic flux analysis)

Isotopically labelled substrates (1-13C-glucose, U-13C-glucose) fed to plants; isotopomer distributions measured by GC-MS or NMR. EMU (elementary metabolite unit) framework models labelling patterns. Gold standard for in vivo flux measurement.

Metabolic Network Analysis

Graph Theory Metrics

Degree centrality

\( C_D(v) = \frac{k_v}{n-1} \)

Fraction of neighbours of v. Hub metabolites (ATP, CoA, NAD) have high degree.

Betweenness centrality

\( C_B(v) = \sum_{s \ne v \ne t} \frac{\sigma_{st}(v)}{\sigma_{st}} \)

Fraction of shortest paths through v. Identifies metabolic chokepoints.

Closeness centrality

\( C_C(v) = \frac{n-1}{\sum_u d(v,u)} \)

Inverse mean distance to all other nodes. Fast-signalling metabolites.

Network diameter

\( D = \max_{u,v} d(u,v) \)

Longest shortest path in the network; measures overall connectivity.

Hub Metabolites in Plant Networks

Metabolic networks exhibit scale-free topology: a few hub metabolites participate in many reactions while most connect to only a few. In plant networks, universal hubs include:

ATP / ADPEnergy currency; participates in >200 reactions

NAD⁺ / NADH, NADP⁺ / NADPHRedox cofactors; >180 reactions

CoA / acetyl-CoAAcyl carrier; lipid, terpenoid, phenylpropanoid nodes

Glutamate / glutamineNitrogen hub; connects N assimilation to all AA

UDP-glucoseActivated sugar donor; sucrose, cellulose, glycosylation

Machine Learning for Metabolic Prediction

ML approaches complement mechanistic models:

Random forests / XGBoost: predict metabolite levels from transcriptomic data
Graph neural networks (GNNs): predict enzyme kinetic parameters from metabolic network structure
LSTM / transformer models: time-series metabolomics under stress
Variational autoencoders: latent representation of multi-omics data
Active learning: guide 13C-MFA experiments for maximum information gain

Python: Metabolic Network Graph & Centrality Analysis

Build a 12-node plant central metabolism network (Calvin cycle, glycolysis, TCA), compute degree, betweenness, and closeness centrality from scratch, identify hub metabolites, and visualise the adjacency matrix.

Python

script.py178 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches

# Build a small plant metabolic network graph and compute centrality measures
# Nodes: metabolites; Edges: reactions connecting them
# We use a manual adjacency representation (no networkx required)

# Metabolic network: 12 metabolites, ~18 directed reactions
# Core plant central metabolism
metabolites = [
    'CO2', 'G3P', 'RuBP', '3PGA', 'G6P', 'F6P',
    'Pyruvate', 'AcCoA', 'OAA', 'Citrate', 'alphaKG', 'Succinyl'
]
n = len(metabolites)
met_idx = {m: i for i, m in enumerate(metabolites)}

# Directed edges: (source, target, reaction_name)
reactions = [
    ('CO2', 'RuBP', 'Calvin carboxylation'),
    ('RuBP', '3PGA', 'RuBisCO'),
    ('3PGA', 'G3P', 'Calvin reduction'),
    ('G3P', 'G6P', 'Gluconeogenesis'),
    ('G6P', 'F6P', 'PGI'),
    ('F6P', 'G3P', 'Aldolase (reverse)'),
    ('G3P', 'Pyruvate', 'Glycolysis (lower)'),
    ('Pyruvate', 'AcCoA', 'PDH'),
    ('AcCoA', 'Citrate', 'Citrate synthase'),
    ('OAA', 'Citrate', 'Citrate synthase (2)'),
    ('Citrate', 'alphaKG', 'Aconitase/IDH'),
    ('alphaKG', 'Succinyl', 'alphaKGDH'),
    ('Succinyl', 'OAA', 'TCA (lower half)'),
    ('OAA', 'Pyruvate', 'PEPC/ME'),
    ('Pyruvate', 'OAA', 'PEPC/PC'),
    ('G6P', 'CO2', 'Pentose phosphate'),
    ('G3P', 'RuBP', 'Calvin regeneration'),
    ('3PGA', 'F6P', 'Calvin (bypass)'),
]

# Build adjacency matrix
adj = np.zeros((n, n), dtype=int)
reaction_edges = []
for src, tgt, name in reactions:
    if src in met_idx and tgt in met_idx:
        adj[met_idx[src], met_idx[tgt]] += 1
        reaction_edges.append((met_idx[src], met_idx[tgt]))

# Compute degree centrality
in_degree = adj.sum(axis=0)
out_degree = adj.sum(axis=1)
total_degree = in_degree + out_degree

# Compute simple betweenness centrality (BFS-based, unweighted)
def bfs_shortest_paths(adj, source):
    n = adj.shape[0]
    dist = [-1] * n
    sigma = [0] * n
    dist[source] = 0
    sigma[source] = 1
    queue = [source]
    order = []
    pred = [[] for _ in range(n)]
    while queue:
        v = queue.pop(0)
        order.append(v)
        for w in range(n):
            if adj[v, w] > 0 or adj[w, v] > 0:  # undirected
                if dist[w] < 0:
                    dist[w] = dist[v] + 1
                    queue.append(w)
                if dist[w] == dist[v] + 1:
                    sigma[w] += sigma[v]
                    pred[w].append(v)
    return order, sigma, pred, dist

def betweenness_centrality(adj):
    n = adj.shape[0]
    bet = np.zeros(n)
    for s in range(n):
        order, sigma, pred, dist = bfs_shortest_paths(adj, s)
        delta = np.zeros(n)
        for w in reversed(order):
            for v in pred[w]:
                if sigma[w] > 0:
                    delta[v] += (sigma[v] / sigma[w]) * (1 + delta[w])
            if w != s:
                bet[w] += delta[w]
    # Normalise
    norm = (n - 1) * (n - 2)
    if norm > 0:
        bet = 2 * bet / norm
    return bet

bet_centrality = betweenness_centrality(adj + adj.T)

# Closeness centrality
def closeness_centrality(adj):
    n = adj.shape[0]
    close = np.zeros(n)
    for s in range(n):
        _, _, _, dist = bfs_shortest_paths(adj + adj.T, s)
        reachable = [d for d in dist if d > 0]
        if reachable:
            close[s] = len(reachable) / sum(reachable)
    return close

close_centrality = closeness_centrality(adj)

# Identify hub metabolites
hub_threshold = np.percentile(total_degree, 70)
hub_indices = np.where(total_degree >= hub_threshold)[0]
hub_names = [metabolites[i] for i in hub_indices]
print("Hub metabolites (high connectivity):", hub_names)
print()
print("Centrality measures:")
print(f"{'Metabolite':<15} {'In':>5} {'Out':>5} {'Total':>7} {'Betweenness':>13} {'Closeness':>11}")
sorted_indices = np.argsort(total_degree)[::-1]
for i in sorted_indices:
    print(f"{metabolites[i]:<15} {in_degree[i]:>5} {out_degree[i]:>5} {total_degree[i]:>7} "
          f"{bet_centrality[i]:>13.4f} {close_centrality[i]:>11.4f}")

fig, axes = plt.subplots(1, 3, figsize=(15, 6))
fig.patch.set_facecolor('#0f172a')
for ax in axes:
    ax.set_facecolor('#1e293b')
    ax.tick_params(colors='#94a3b8')
    ax.spines['bottom'].set_color('#475569')
    ax.spines['left'].set_color('#475569')
    ax.spines['top'].set_visible(False)
    ax.spines['right'].set_visible(False)

# Plot 1: Degree centrality (in vs out)
x_pos = np.arange(n)
node_colors = ['#ef4444' if i in hub_indices else '#a3e635' for i in range(n)]
axes[0].bar(x_pos - 0.2, in_degree, width=0.35, color='#34d399', alpha=0.85, label='In-degree')
axes[0].bar(x_pos + 0.2, out_degree, width=0.35, color='#f59e0b', alpha=0.85, label='Out-degree')
axes[0].set_xticks(x_pos)
axes[0].set_xticklabels(metabolites, rotation=55, ha='right', fontsize=7.5, color='#94a3b8')
axes[0].set_ylabel('Degree', color='#94a3b8', fontsize=9)
axes[0].set_title('Metabolite Degree Centrality
(In vs Out)', color='#e2e8f0', fontsize=10)
axes[0].legend(fontsize=8, facecolor='#1e293b', edgecolor='#475569', labelcolor='#e2e8f0')

# Plot 2: Betweenness centrality
bar_colors2 = ['#ef4444' if i in hub_indices else '#60a5fa' for i in sorted_indices]
axes[1].barh([metabolites[i] for i in sorted_indices], bet_centrality[sorted_indices],
             color=bar_colors2, alpha=0.85, edgecolor='#475569')
axes[1].set_xlabel('Betweenness Centrality', color='#94a3b8', fontsize=9)
axes[1].set_title('Betweenness Centrality
(Hub metabolites in red)', color='#e2e8f0', fontsize=10)
hub_patch = mpatches.Patch(color='#ef4444', alpha=0.85, label='Hub metabolite')
axes[1].legend(handles=[hub_patch], fontsize=8, facecolor='#1e293b', edgecolor='#475569', labelcolor='#e2e8f0')

# Plot 3: Metabolic network as adjacency heatmap
sym_adj = (adj + adj.T).astype(float)
sym_adj[sym_adj > 1] = 1
im = axes[2].imshow(sym_adj, cmap='YlGn', aspect='auto', vmin=0, vmax=1.5)
axes[2].set_xticks(range(n))
axes[2].set_xticklabels(metabolites, rotation=55, ha='right', fontsize=7, color='#94a3b8')
axes[2].set_yticks(range(n))
axes[2].set_yticklabels(metabolites, fontsize=7, color='#94a3b8')
axes[2].set_title('Metabolic Network
Adjacency Matrix', color='#e2e8f0', fontsize=10)
# Highlight hubs
for h in hub_indices:
    axes[2].add_patch(plt.Rectangle((h - 0.5, -0.5), 1, n, fill=False,
                                     edgecolor='#ef4444', linewidth=1.5, alpha=0.7))
    axes[2].add_patch(plt.Rectangle((-0.5, h - 0.5), n, 1, fill=False,
                                     edgecolor='#ef4444', linewidth=1.5, alpha=0.7))

fig.suptitle('Plant Metabolic Network Analysis: Centrality & Hub Identification',
             color='#e2e8f0', fontsize=12, fontweight='bold')
plt.tight_layout()
plt.savefig('output.png', dpi=110, bbox_inches='tight',
            facecolor='#0f172a', edgecolor='none')

Click Run to execute the Python code

Code will be executed with Python 3 on the server

Course Complete

You have covered all 21 chapters of Plant Biochemistry — from the quantum mechanics of light harvesting through to CRISPR-guided metabolic engineering and systems-level network analysis. The molecular logic underlying plant life is now at your fingertips.

PhotosynthesisCalvin CycleGlycolysisTCA CycleLipid BiosynthesisN FixationHormonesTerpenoidsAlkaloidsFlavonoidsCelluloseStarch/SucroseC4/CAMROS/AntioxidantsMetabolic EngineeringSystems Biology

Return to Course Overview →

← Ch 20: Metabolic Engineering Course Overview →