GBApp

Welcome to GBApp, your user-friendly platform for exploring Growth Balance Analysis (GBA) in metabolic modeling. GBApp is designed to make modeling cellular growth and metabolism accessible to all, from seasoned computational researchers to newcomers. Unlike traditional tools focused on linear models, GBApp brings a nonlinear approach that considers the crucial role of metabolite concentrations and reaction kinetics in shaping cellular processes. In this tutorial, you’ll be introduced to GBApp's intuitive interface, where you can easily construct and analyze GBA models without needing to code. You’ll see how GBApp integrates with the BRENDA enzyme database, allowing you to retrieve essential kinetic parameters like turnover numbers and Michaelis constants to create more accurate models. We’ll guide you through using our interactive visualization tools—customizable plots and dynamic pathway maps—that make it simple to interpret your results and gain insights into cellular resource allocation and proteome efficiency. With GBApp, you can dive into the complexities of cellular metabolism with ease, empowering you to explore, collaborate, and drive new insights in the field. GBApp is freely accessible to all users, promoting open science and collaboration within the research community.

Model Input

In GBApp, uploading your GBA model is straightforward. As shown in the figure, users can start by uploading the model file in an open-source spreadsheet format (ODS) via the “Choose File” button. If you haven’t yet prepared your model, you can download a preformatted GBA template using the “Download GBA template” button (Figure 1). This template provides a structured example that includes all required matrices and columns, helping you set up your model correctly.

Figure 1: Interface for uploading your GBA model file and downloading the GBA template in GBApp.

The mass fraction matrix M is derived from the stoichiometric matrix S and represents the distribution of mass for each reactant across the system's reactions. Each row in M corresponds to a metabolite, while each column corresponds to a reaction.

• Rows starting with "x_" represent external metabolites.
• The last row, labeled "Protein", represents the cumulative mass of all proteins.
• The last column, labeled "Ribosome", indicates the ribosome reaction responsible for synthesizing proteins.

To illustrate, let’s look at a basic biological reaction where a substrate is converted into a product, facilitated by an enzyme, and ultimately leading to the production of a protein. The following reactions break down this process:

Figure: Schematic representation of the simplified GBA model

Example Biological Reactions with Two Redundant Pathways

1. Reaction 1: Glucose (G) is taken up from the external environment (x_G) and converted into an intermediate.
   Reaction equation: x_G → G
   Stoichiometry: Glucose (x_G) is consumed (-1), and intracellular Glucose (G) is produced (+1).
2. Reaction 2: Nitrogen (N) is imported from the external environment (x_N) for further cellular processes.
   Reaction equation: x_N → N
   Stoichiometry: External Nitrogen (x_N) is consumed (-1), producing intracellular Nitrogen (N) (+1).
3. Reaction 3: Synthesis of amino acids (AA) requires both Glucose (G) and Nitrogen (N) as inputs.
   Reaction equation: G + 5N → AA
   Stoichiometry: Inputs are 1 unit of Glucose and 5 units of Nitrogen. The molecular weight of Glucose is 180 g/mol, and the molecular weight of Nitrogen is 14 g/mol.
   Normalization:
   • For Glucose: (1 * 180) / ((1 * 180) + (5 * 14)) = 180 / 250 = 0.72
   • For Nitrogen: (5 * 14) / ((1 * 180) + (5 * 14)) = 70 / 250 = 0.28
   Normalized Stoichiometry: Glucose contributes 0.72 to the mass fraction, and Nitrogen contributes 0.28.
4. Reaction 4: Synthesis of amino acids (AA) by another enzyme, which also requires both Glucose (G) and Nitrogen (N) as inputs.
   Reaction equation: G + 3N → AA
   Stoichiometry: Inputs are 1 unit of Glucose and 3 units of Nitrogen.
   Normalization:
   • For Glucose: (1 * 180) / ((1 * 180) + (3 * 14)) = 180 / 222 ≈ 0.81
   • For Nitrogen: (3 * 14) / ((1 * 180) + (3 * 14)) = 42 / 222 ≈ 0.19
   Normalized Stoichiometry: Glucose contributes 0.81 to the mass fraction, and Nitrogen contributes 0.19.
5. Ribosome Reaction: The ribosome uses amino acids to synthesize proteins, representing ongoing cellular production of proteins.
   Reaction equation: AA + 2N → Protein
   Stoichiometry: The ribosome reaction consumes amino acids and nitrogen, and produces proteins.

Constructing the Matrix

The values in each column reflect the stoichiometric coefficients of each reactant in the reaction. To form the mass fraction matrix M, each stoichiometric value is converted to mass units by multiplying by the molecular mass of each metabolite. Additionally, the matrix is normalized to ensure mass balance, with the sum of negative entries equal to -1 and the sum of positive entries equal to +1 for each reaction.

Example of Normalized Values in the Mass Fraction Matrix (M)

Here’s a closer look at each column in the matrix based on our example:

• rxn1: x_G is consumed (-1), producing G (+1).
• rxn2: x_N is consumed (-1), producing N (+1).
• rxn3: Glucose and Nitrogen are partially consumed (-0.72, -0.28) to produce amino acids (AA, +1).
• rxn4: Glucose and Nitrogen are partially consumed (-0.81, -0.19) to produce amino acids (AA, +1).
• Ribosome: Amino acids and Nitrogen are consumed (-0.8, -0.2), and Protein is produced.

These normalized coefficients ensure mass balance and accurately represent how cellular resources are allocated in each reaction, with the values in the matrix reflecting the mass fractions of each reactant moving into and out of each reaction.

Figure: Example of a Mass Fraction Matrix (M) for a cellular system. This matrix illustrates the normalized mass fractions for each metabolite across different reactions.

Kinetic parameters are essential for accurately modeling the behavior of enzymes in cellular reactions. In GBApp, the kinetic parameters are organized into several matrices that provide values for Michaelis constants (K), inhibition and activation constants (KI and KA), and turnover numbers (kcat). These matrices correspond to the structure of the mass fraction matrix M to ensure consistency across the model.

K Matrix (Michaelis Constant Matrix)

The K matrix stores the Michaelis constant (K_m) values for each reaction. These values describe the substrate concentration at which the reaction rate is half of its maximum value, giving insight into the affinity between an enzyme and its substrate.

• The K matrix provides K_m values for the substrates of each enzyme.
• To ensure consistency, all K_m values originally measured in [mol L⁻¹] are converted to [g L⁻¹] by multiplying by the molecular mass of the substrates.
• The row and column labels of this matrix match those in the mass fraction matrix M.
• If no K_m value is available for a given enzyme-substrate pair, a default value of 0.1 is used.

Figure: Example of the K Matrix (Michaelis Constant Matrix) for a cellular system.

KI and KA Matrices (Inhibition and Activation Constants)

The KI and KA matrices represent inhibition and activation constants, respectively, for specific enzymes in the cell. These constants provide additional regulatory details about how inhibitors or activators affect enzyme activity.

• KI stores inhibition constants for enzyme-substrate pairs, indicating the effect of inhibitors.
• KA stores activation constants, representing the influence of activators on enzyme activity.
• The row and column labels of these matrices are aligned with those in the mass fraction matrix M.
• If no values are provided for a given enzyme in KI or KA, the model assumes no inhibition or activation effects for that enzyme.

Figure: Example of the KI and KA Matrices (Inhibition and Activation Constants) for a cellular system.

kcat Matrix (Turnover Number Matrix)

The kcat matrix stores the turnover numbers (kcat) for enzymes within the cell, which represent the number of substrate molecules converted to product per enzyme molecule per unit time. The turnover number is critical for understanding the efficiency of enzymes in catalyzing reactions.

• The matrix contains two rows:
  • kcat_f: Turnover numbers for forward reactions.
  • kcat_b: Turnover numbers for backward reactions.
• The column labels in the kcat matrix correspond to those in the mass fraction matrix M.
• kcat values are typically expressed in units of [h⁻¹], which is the number of reactions catalyzed per enzyme molecule per hour.
• To maintain unit consistency, kcat values in [h⁻¹] should be adjusted by multiplying by the molecular mass of the product and dividing by the mass of the enzyme.

Figure: Example of the kcat Matrix (Turnover Number Matrix) for a cellular system.

Example Calculation for kcat and Km

Here’s an example of the parameters needed for calculating the Michaelis constant (K_m) and turnover number (k_cat) for the ribosome:

Calculation Steps

• Michaelis Constant (Km):
  Calculation: Km = 40 × 3 × 10-6 mol L-1 × 69,167 g mol-1 = 8.3 g L-1.
• Turnover Number (kcat):
  Calculation: kcat = 22 AA s-1 × (132.60 g AA-1 / 2,306,967 g mol-1) × 3600 s h-1 = 4.55 h-1.

This example illustrates the conversion and normalization of K_m and k_cat values to match the mass concentration units used in GBApp, ensuring accurate kinetic parameter representation in the model.

Retrieving Kinetic Data from BRENDA

Below each matrix creation area, GBApp provides access to the BRENDA database in an interactive table format. This table enables you to search and filter data to find specific kinetic values:

• Michaelis Constant Data: The table allows you to search for K_m values by enzyme name, EC number, or organism. In the example shown below, you can see data entries for enzymes such as "(-)-11-nor-9-carboxy-DELTA9-tetrahydrocannabinol."
• Filter Options: Filter fields at the top of the table allow you to narrow down results based on specific EC number digits or organisms, making it easy to find relevant kinetic values for your model.

Figure: Michaelis constant (K_m) data retrieved from BRENDA, displayed in an interactive table for easy filtering and selection.

These matrices provide the fundamental kinetic parameters needed to capture the dynamics of cellular reactions in your GBA model. By incorporating K, KI, KA, and kcat matrices, GBApp allows for a more detailed and accurate representation of metabolic processes, enabling users to model enzyme behavior under different conditions effectively.

The Conditions matrix is used to define the cellular density and external concentrations for each condition in the model. This matrix allows you to specify different environmental conditions, which can then be optimized during the analysis in GBApp.

Structure of the Conditions Matrix

The Conditions matrix consists of rows and columns that store values for different aspects of the cellular environment:

• First Row ("rho"): Represents the cell density in units of [g L⁻¹]. This value applies to each condition in the matrix.
• External Reactants: Starting from the second row, each row represents the concentration of an external reactant in the environment. Each reactant is labeled with "x_" followed by a unique identifier (e.g., x_G for glucose, x_N for nitrogen).
• Columns: Each column represents a specific environmental condition for the cell. This setup allows you to define multiple conditions, each with its own set of cell density and external reactant concentrations.

The exact number of rows for external reactants depends on the number of reactants included in the model. Each reactant’s concentration is entered in units of [g L⁻¹] to maintain consistency across the model.

Example Setup of a Conditions Matrix

Here’s an example layout of a Conditions matrix that includes cell density and two external reactants across three different conditions:

Explanation of the Example

In this example, the first row labeled rho defines the cell density for each condition. The next two rows represent the concentrations of two external reactants, glucose (x_G) and nitrogen (x_N), in [g L⁻¹]. Each column corresponds to a different condition, allowing for variations in cell density and reactant concentrations across the conditions.

Using the Conditions Matrix in Analysis

By setting up multiple conditions, you can simulate different environmental scenarios within GBApp. During the analysis, these conditions can be optimized to understand how variations in cell density and external reactant concentrations affect cellular processes. This approach enables you to explore a range of scenarios and better understand the metabolic behavior of cells under different environmental conditions.

Figure: Example of the Conditions Matrix used in GBApp.

Alternatively, users can build their Growth Balance Analysis (GBA) models directly within the “Create Model” section of GBApp. This section is designed using the “shinyMatrix” package in R, which allows for a dynamic and intuitive experience when setting up model matrices. The user interface includes enhanced JavaScript features, such as arrow key scrolling and full-cell editing, to improve usability.

Getting Started

To start creating your model, specify the number of metabolites and reactions required. These selections will automatically update the draft model, generating a blank mass fraction matrix for you to fill out. The interface ensures that as you name your reactions and metabolites, these labels are consistently applied across all model tabs.

Figure: The “Create Model” section in GBApp, where users can specify the number of metabolites and reactions, and input their mass fraction matrix.

Automatic Labeling and Structure

When entering names for your reactions and metabolites, GBApp automatically assigns these labels across all other tabs to maintain consistency. The labels “Ribosome” and “Protein” are predefined and automatically placed in the last column and row of the mass fraction matrix, respectively, to reflect the essential cellular components of protein synthesis.

Interactive Matrices

The matrix creation tool provides full interactivity, allowing you to easily input and edit values. In each corresponding tab, you can also access collapsible cards that contain kinetic parameter data such as Michaelis constants (K_m) and turnover numbers (kcat). These parameters can be queried and adjusted to ensure unit consistency throughout your model.

Setting External Conditions

In the final tab, labeled “Condition”, users can define the number of external reactants, including “rho” for cell density, and the total number of environmental conditions they wish to optimize. The condition matrix adjusts accordingly, enabling you to set various external concentrations for each condition.

For simplicity, GBApp limits the number of reactions and metabolites to a maximum of 10 and the number of conditions to a maximum of 20, ensuring the model remains manageable and efficient.

Figure: The “Condition” tab in GBApp, where users can define the number of external reactants, including cell density (rho), and specify up to 20 different environmental conditions.

Preview and Modify Your Model

Once your model is Created or Uploaded, GBApp provides a comprehensive preview of your input data. This feature allows you to review and make modifications directly within the app, including adjustments to mass fractions, Michaelis constants (K_m), inhibition and activation constants (KI and KA), turnover numbers (kcat), and external conditions. When you are satisfied with your model, you can save it in the open-source spreadsheet (ODS) format for further analysis or refinement.

This flexibility ensures that users can iteratively refine their models, enhancing accuracy and performance while making the modeling process accessible and intuitive.

Figure: The “Preview Model” interface in GBApp, providing users with a detailed view of their input data. Users can easily make adjustments to mass fractions, Michaelis constants (K_m), inhibition and activation constants (KI and KA), turnover numbers (kcat), and external conditions, ensuring flexibility and accuracy before saving the model in an open-source format.

After importing your GBA model into GBApp, it is essential to ensure that your model meets the criteria required by the Growth Balance Analysis (GBA) framework. To assist users—especially those new to computational modeling—GBApp provides a helpful tool: the “Check Model” button.

Figure: The “Check Model” feature in GBApp, designed to validate your GBA model and ensure compliance with the Growth Balance Analysis framework.

Using the “Check Model” Feature

The “Check Model” button allows you to verify that your model is correctly configured before running any analysis. While not mandatory, this validation step is highly recommended to ensure your model’s parameters are accurately imported and to identify any issues that need correction. The validation process performs the following checks:

Figure: The “Check Model” feature in GBApp, which performs a series of validation checks to ensure your model is correctly configured. This step is recommended to verify the accuracy of imported parameters and to identify potential issues before proceeding with further analysis.

• Ensures there are no missing (NA) or non-numeric values in the model.
• Verifies that all matrices have consistent dimensions, meaning the same number of reactions and metabolites.
• Checks that values for external conditions and cell density (rho) are greater than zero.
• Scans the K_m matrix for missing values and issues a warning if any are found. Missing K_m values will be automatically assigned a default low value of 0.1 [g L⁻¹].

Figure: Example of a warning message in the “Check Model” feature of GBApp.

If the model fails to meet any of these criteria, an error message will be displayed. The message will guide you to reset the session and review your model for corrections. Once all checks are successfully passed, a notification will confirm that your model is validated and ready for analysis.

Figure: Example of an error message in the “Check Model” feature of GBApp.

Running the Growth Balance Analysis

Once your model is validated (or if you choose to skip the validation), you can initiate the growth balance analysis by clicking the “Run” button. GBApp uses the “nloptr” package in R to solve the non-linear optimization problem, employing the AUGLAG method—an augmented Lagrangian approach (Ypma and Johnson 2011).

Optimization Solvers and Methods

The AUGLAG method in nloptr utilizes various sub-solvers, each designed for specific types of optimization problems. By default, GBApp uses the low-storage BFGS (LBFGS) solver due to its low memory usage and broad applicability. However, depending on the complexity and constraints of your model, you may select different solvers via the “Advanced option” collapsible card:

• LBFGS: Ideal for general-purpose optimization with efficient memory usage, suitable for large-scale models.
• Method of Moving Asymptotes (MMA): Better suited for highly non-linear models with constraints, offering robust performance in complex scenarios.
• Sequential Quadratic Programming (SLSQP): Effective for smaller models that require precise constraint management and high accuracy.

Users should choose a solver based on the size and complexity of their model, as some solvers may yield faster convergence or higher accuracy for specific problem types. Experimenting with different solvers can help optimize performance for your particular model.

Convergence of the Non-Linear Solver

In the context of numerical optimization, convergence refers to the process where the solver iteratively approaches an optimal solution within a specified tolerance level. Successful convergence indicates that the solver has found a solution that satisfies the optimization criteria, while failure to converge suggests that the solver was unable to meet these criteria within the set number of iterations or due to numerical difficulties.

In nloptr, the convergence status is represented by an integer code. A convergence code of 4 signifies that the optimization was successful, meaning the solver has reached a solution that meets the required criteria. Any other convergence code indicates non-convergence, and it is recommended to review the model parameters or try a different solver or optimization method to achieve better results.

Figure: Result of the convergence status displayed in GBApp after running the optimization process.

Tracking the Optimization Progress

During the numerical optimization process, GBApp displays a progress bar to keep you informed. The progress bar provides real-time updates, tracking the optimization status for each condition and giving you an estimate of how long the analysis will take. This feature ensures that you can monitor the optimization efficiently and plan your workflow accordingly.