PaperlayerView exact revision on arXiv

Source-linked AI summary

Computation Of Microbial Ecosystems in Time and Space (COMETS): An open source collaborative platform for modeling ecosystems metabolism

Ilija Dukovski, Djordje Bajić, Jeremy M Chacón, Michael Quintin, Jean CC Vila, Snorre Sulheim, Alan R Pacheco, David B Bernstein, William J Rieh, Kirill S Korolev, Alvaro Sanchez, William R Harcombe, Daniel Segrè

arXiv:2009.01734v1q-bio.QM

TL;DR

Microbial communities involve complex interactions across spatial and temporal scales, motivating better computational tools for their study. This paper presents COMETS 2, a user-friendly platform for simulating microbial metabolism, growth, diffusion, and interactions, and demonstrates its application across ecosystem scenarios.

  • Problem

    Microbial communities exhibit complex interactions across multiple spatial and temporal scales, creating a need for tools that model their metabolism and environmental dynamics.

  • Method

    COMETS 2 extends dynamic flux balance analysis with spatial diffusion, biomass propagation, and biological modules accessible through Python and MATLAB interfaces compatible with COBRA models.

  • Results

    COMETS 2 reproduces well-mixed bacterial growth and fermentation dynamics and generates spatial colony morphologies, including branching and strain segregation.

  • Takeaways & Limitations

    COMETS 2 supports accessible simulation and testing of microbial communities, from metabolic exchange and competition to spatially structured ecosystem scenarios.

  • Takeaways & Limitations

    COMETS uses fixed time-step integration, so users may need very small steps to avoid numerical errors and instability, increasing simulation times for complex layouts.

Abstract

from arXiv · show

Genome-scale stoichiometric modeling of metabolism has become a standard systems biology tool for modeling cellular physiology and growth. Extensions of this approach are also emerging as a valuable avenue for predicting, understanding and designing microbial communities. COMETS (Computation Of Microbial Ecosystems in Time and Space) was initially developed as an extension of dynamic flux balance analysis, which incorporates cellular and molecular diffusion, enabling simulations of multiple microbial species in spatially structured environments. Here we describe how to best use and apply the most recent version of this platform, COMETS 2, which incorporates a more accurate biophysical model of microbial biomass expansion upon growth, as well as several new biological simulation modules, including evolutionary dynamics and extracellular enzyme activity. COMETS 2 provides user-friendly Python and MATLAB interfaces compatible with the well-established COBRA models and methods, and comprehensive documentation and tutorials, facilitating the use of COMETS for researchers at all levels of expertise with metabolic simulations. This protocol provides a detailed guideline for installing, testing and applying COMETS 2 to different scenarios, with broad applicability to microbial communities across biomes and scales.

Introduction · Development of the protocol

COMETS 2 extends genome-scale stoichiometric modeling into dynamic, spatially structured simulations of microbial ecosystems. The protocol combines accessible Python and MATLAB interfaces with modules for community interactions, evolution, extracellular processes, and detailed biomass propagation.

  • Introduction: Microbial communities affect human health, ecology, biogeochemistry, and metabolic engineering, motivating computational approaches to their interspecies interactions.These communities range from synthetically constructed consortia to complex natural ecosystems.
  • Introduction: Genome-scale stoichiometric models use genome knowledge, steady-state assumptions, and optimality to predict metabolic fluxes without requiring thousands of kinetic parameters.FBA provides the metabolic modeling foundation used by COMETS.
  • Introduction: COMETS 2 simulates microbial ecosystems in space and time, supporting complex communities and many stoichiometric models through Python and MATLAB interfaces.The platform produces microbial biomass, metabolic fluxes, and media concentrations for downstream analysis.
  • Introduction: The platform supports research and education through graphical and scripting interfaces for simulating growth, competition, metabolic exchange, and evolution.Its capabilities include evolutionary processes, chemostats, crossfeeding, photosynthetic cycles, and competition assays.
  • Flux Balance Analysis: A brief overview: FBA represents metabolism with a stoichiometric matrix and searches feasible fluxes for solutions optimizing a specified objective function.COMETS accommodates arbitrary objective functions and iterative multiple-objective optimization, including parsimonious FBA.
  • Flux Balance Analysis: A brief overview: Dynamic FBA repeatedly estimates nutrient-dependent uptake bounds, solves each organism’s FBA, and updates biomass and extracellular metabolites over finite time steps.COMETS supports linear, Monod, and pseudo-Monod mappings between external nutrient concentrations and maximal uptake rates.
  • Spatial structure and dynamics: COMETS extends well-mixed dynamic FBA to arbitrary two-dimensional spatial structures by modeling biomass density with diffusion, velocity, and growth or death terms.Diffusivity can depend on time, position, local biomass, or external conditions.
  • Spatial structure and dynamics: Spatial biomass propagation includes mechanistic cellular pushing and cooperative density-dependent mobility, allowing pressure-driven motion and lubricant-mediated diffusion in dense colonies.Diffusivity can additionally be restricted to actively growing biomass using a Hill function.

Limitations

COMETS inherits limitations from stoichiometric modeling and FBA, including uncertain availability of genome-scale metabolic models. Its numerical solver also requires carefully chosen fixed time steps, and its simulations represent population-average rather than individual-cell behavior.

  • Modeling limitations: Genome-scale metabolic models may not be available for the organisms of interest, and model reconstruction from sequenced genomes is outside this protocol’s scope.The paper notes that reconstruction and gap filling require separate protocols.
  • Numerical limitations: COMETS uses fixed-step integration for convection-diffusion equations, requiring sufficiently small time steps to prevent numerical errors and instabilities.These instabilities can propagate through growth and spatial solutions.
  • Numerical limitations: The stability criterion requires Δt<Δx^2/D, where Δx is spatial grid spacing and D is the diffusion constant.Users must select the time step in relation to grid spacing and diffusion.
  • Modeling limitations: COMETS adopts a population-level rather than individual-based approach, estimating average metabolic behavior for cells within each spatial box.FBA is computed at each spatial coordinate to represent the average behavior of the local cell population.

Materials: Hardware requirements and Installation

COMETS 2 requires a 64-bit computing environment with Java and an optimization solver, with Gurobi recommended and GLPK available as an open-source alternative. Installation is supported through platform-specific installers or a tarball, while the MATLAB toolbox requires MATLAB and can be obtained from GitHub.

  • Hardware requirements and prerequisites: COMETS requires a 64-bit processor, Linux, Windows, or Mac OS, at least 8Gb of memory, and Java 64-bit version 1.8 or higher.A multicore processor is recommended for multithreaded simulations of large spatial grids but is not required.
  • Hardware requirements and prerequisites: Gurobi is the primary optimizer, requiring installation and licensing, while GLPK provides an open-source alternative.Individual academic users may obtain a free Gurobi academic license; environment variables may need configuration for COMETS to locate Gurobi libraries.
  • COMETS installation: COMETS can be installed with a platform-specific GUI installer or by unpacking the comets_2.10.0.tar.gz archive for custom installation.Installers are provided for Windows, MacOS, and Linux; Linux users may need to make the installer executable with chmod a+x.
  • COMETS installation: The installer configures command-line access and environment variables, but custom installation paths require manually editing configuration lines and sourcing shell files.COMETS_HOME and Gurobi-related variables may need adjustment in .bashrc, .bash_profile, or .zshrc, and Windows users may need to verify them manually.
  • MATLAB toolbox: The MATLAB toolbox requires MATLAB and can be downloaded as an archive or cloned from the comets-toolbox GitHub repository.The documented clone command creates a ./comets-toolbox directory in the working directory.

Expertise needed to implement the protocol: COMETS User Experience

COMETS supports progressively advanced use, from basic biological and computational familiarity for GUI or text-input simulations to programming and systems expertise for custom features and cluster-scale production runs. The Python and MATLAB toolboxes provide the full simulation capabilities, while command-line and development workflows extend COMETS for automation, high-performance computing, and novel capabilities.

  • Basic use: Basic COMETS use requires familiarity with simulated biological processes and basic computational skills, enabling GUI or manually written text-input simulations.The GUI is primarily intended as an educational introduction for novice users.
  • Toolbox workflows: The Python and MATLAB toolboxes require basic Python or MATLAB knowledge and support model and layout preparation using standard formats such as SBML and .mat.The Python toolbox integrates with scientific-computing packages and COBRAPy, while the MATLAB toolbox uses COBRA Toolbox model formats.
  • Command-line and cluster use: Command-line use suits users comfortable with scripting and can facilitate running COMETS in high-performance computing facilities.Production-scale simulation sets additionally require Linux, remote cluster connections, and queue-scheduler job management.
  • Custom development: Developing novel COMETS capabilities requires Java, Git, GitHub, and preferably familiarity with an integrated development environment such as Eclipse.This advanced level is needed for features beyond the protocol’s scope.
  • Interface selection: The protocol presents separate COMETS interfaces and provides simulation examples for each interface in the Procedures section.Users can choose among GUI, toolbox, input-file, command-line, and development-oriented workflows according to their expertise.

2. Load an existing model using COBRAPy. Here, we use the custom function

The workflow loads a COBRAPy test model, converts it into a COMETS model, and configures COMETS-specific parameters such as initial biomass. It then prepares simulation parameters and a minimal media layout before running and inspecting the simulation output.

  • Load and convert the model: A COBRAPy test model is loaded and converted into a COMETS model class for changing COMETS-specific settings.The example loads the textbook model with cobra.test.create_test_model('textbook') and converts it using c.model(test_model).
  • Configure the COMETS model: The COMETS model opens exchanges and sets the initial biomass, illustrated with test_model.initial_pop = [0, 0, 1e-7].Opening exchanges uses test_model.open_exchanges().
  • Configure simulation parameters: A default parameter dictionary is created, simulation settings can be changed, and available parameters with current values can be displayed.The example sets maxCycles to 100 with my_params.set_param('maxCycles', 100) and displays parameters using my_params.show_params().
  • Prepare the media layout: A layout is generated from the COMETS model and supplied with minimal media components, including glucose, oxygen, ammonium, phosphate, water, and hydrogen ions.The example sets glc__D_e to 0.011 and the other listed metabolites to 1000.
  • Run and inspect the simulation: The prepared layout and parameters define a COMETS simulation whose run output reports initialization and biomass at each time step.In this example, no growth occurs because a growth-supporting medium, such as a carbon source, was not defined; internal errors appear as a Java stack trace.

12. Access the errors of the COMETS simulation run

COMETS exposes simulation errors through `run_errors` and stores successful-run outputs in dedicated fields of the simulation object. These outputs can be analyzed with standard Python tools, while correct initialization, model placement, media definition, and parameters are critical for meaningful runs.

  • Access simulation errors: `run_errors` should be empty when the COMETS simulation completes successfully.The simulation errors are accessed with `print(my_simulation.run_errors)`.
  • Inspect simulation outputs: Successful simulations store total biomass, detailed biomass, media composition, and metabolic fluxes in separate output fields.The fields track values across timepoints, coordinates, and species as applicable.
  • Inspect simulation outputs: Additional model-specific fields can store specific media concentrations and evolutionary genotype information, including ancestors and mutations.The `specificMedia` and `genotypes` fields are examples of such outputs.
  • Analyze outputs: All output files are stored as pandas dataframes for further analysis or plotting with standard Python tools.The tutorial plots biomass growth and media composition from these outputs.
  • Validate the simulation run: Correct initial biomass, model placement, media definition, and simulation parameters are critical because they determine whether models grow and affect outcomes.The examples explicitly mark initial biomass, adding models to the layout, media composition, and parameter values as critical setup conditions.

8. Run the simulation

The simulation is run by creating a COMETS experiment with the test-tube model and serial parameters, then calling its run method.

  • 8. Run the simulation: Run the simulation by creating `serial_expt` with `c.comets(test_tube, serial_params)` and invoking `serial_expt.run()`.

9. Plot the biomasses of the two species during the experiment

The protocol derives total biomass from the serial experiment, converts cycle number to transfer time, and plots biomass against transfer with a labeled y-axis. Figure 8 illustrates the resulting competition and competitive-exclusion experiments for wild-type and mutant E. coli.

  • Biomass calculation: Total biomass is extracted from serial_expt.total_biomass and converted from cycle number to transfer time using the simulation time step.The transfer calculation is biomass['cycle'] * timeStep/24.
  • Biomass visualization: The biomass plot removes the cycle column, uses transfer as the x-axis, and labels the y-axis “Biomass (gr.).”The plotting code calls biomass.drop(columns=['cycle']).plot(x = 'transfer').
  • Competition experiment: Figure 8 shows competition assays between wild-type E. coli and a triose phosphate isomerase knockout, including serial transfers each 24h.Both experiments use aerobic glucose minimal media (10 mM) in a volume of 1uL.

3. Generate the COMETS models and set their initial population size

This section prepares two COMETS models by assigning unique identifiers, setting their initial populations, and configuring exchange bounds for media-dependent adjustment before manually making a chemostat.

  • Model generation: The two models receive unique IDs, “galE_KO” and “LCTStex_KO,” to prevent COMETS from confusing them.The original models share the same ID, so each is renamed before simulation.
  • Initial population size: Both galE_comets and lcts_comets are initialized at [0,0,initial_pop], representing x, y, and gDW coordinates.Each model is created from its corresponding knockout model and assigned the same initial population value.
  • Exchange constraints: The exchange-reaction lower bounds for both models are set to -1000 so COMETS can adjust them according to media concentrations.This configuration is applied to the exchange reactions of galE_comets and lcts_comets.
  • Chemostat setup: The workflow first uses the manual method to make a chemostat.This method is introduced after the models are generated and configured.

4. Create the layout for the chemostat by providing models

The chemostat layout is created by translating the COBRA medium into COMETS metabolite IDs, replenishing reservoir media at the dilution rate, and configuring matching outflow parameters. Simulation duration, biomass limits, time step, and metabolite logging are then specified.

  • Create the layout: COMETS media use metabolite IDs, so the COBRA medium is converted, galactose is removed, and each component is added to the layout.The conversion strips the exchange-reaction prefix before assigning specific metabolites.
  • Create the layout: Media replenishment is set by multiplying each reservoir concentration by the chemostat dilution rate.With dilution at 0.1 per hour, each metabolite receives the corresponding hourly refresh amount.
  • Create the layout: The chemostat outflow uses metaboliteDilutionRate and deathRate, both set equal to the desired dilution rate.Correctly configuring the outflow is identified as a critical step.
  • Create the layout: The simulation uses a 0.1-hour time step, 10 gDW maximum biomass per cell, and 2000 time steps.These parameters control temporal resolution, per-cell biomass, and simulation duration.
  • Create the layout: Specific-media logging tracks lactose and galactose by enabling the log, recording every time step, and selecting lcts_e and gal_e.The metabolites are specified as a comma-separated string without spaces.

10. Create a COMETS simulation and run it

COMETS simulations can be configured for typical chemostat conditions with a helper function, customized as needed, and run results plotted with explicitly specified axes. The workflow supports tracking total biomass and selected extracellular metabolites over simulation cycles.

  • Plot the results: Results should be plotted with axes explicitly assigned so cycle, x, and y are not incorrectly treated as state variables.The example plots total biomass against cycle and specific media for lcts_e and gal_e against cycle.
  • Set up a chemostat: The chemostat helper generates a layout and parameters from models, media, and a dilution rate for typical simulations.More complex setups can instead use distinct initial and reservoir concentrations or unequal inflow and outflow rates.
  • Set up a chemostat: Users can adjust simulation parameters, including time step, biomass limit, maximum cycles, and specific-media logging.The example sets timeStep to 0.1 hours, maxSpaceBiomass to 10. gDW, maxCycles to 500, and logs lcts_e and gal_e every time step.

14. Run the simulation

COMETS 2 simulations are configured with layouts and parameters, executed through a COMETS object, and analyzed with biomass and genotype outputs. The platform also models reaction-deletion and reaction-addition mutants, enabling population dynamics and phylogeny reconstruction.

  • Evolutionary processes: Evolutionary simulations introduce mutants with reaction deletions and additions during population growth.Reaction additions are controlled through addRate, whereas deletion events are governed by mutRate.
  • Evolutionary processes: The evolutionary example uses serial transfers every 3 h over 10 days, with a mutation rate of 10^-7 deletion events per reaction and generation.The cellSize parameter specifies the biomass corresponding to one newly appearing mutant cell.
  • Evolutionary processes: Evolutionary simulations are highly sensitive to mutRate, addRate when additions are modeled, and cellSize, the dry weight of one cell.The example sets evolution to true and configures these parameters before running the simulation.
  • Running the simulation: COMETS runs a configured simulation by creating a COMETS object from a layout and parameter set, then calling its run method.Simulation outputs can include total biomass plotted against cycle.
  • Analyzing results: The genotypes data frame records each mutant’s ancestor, mutation, and randomly assigned genotype name, allowing reconstruction of the simulation’s phylogeny.Combining genotype records with population dynamics identifies the mutations carried by each individual.

1. Load the necessary libraries · 3. Load the E. coli iJO1366 model

The workflow imports COMETS, COBRApy, pandas, NumPy, and plotting tools, then configures a well-mixed DM25 flask with specified nutrients. It loads the E. coli iJO1366 model, adjusts exchange bounds, constructs genotype variants, initializes populations, and sets nutrient uptake limits for carbon-limited growth.

  • 1. Load the necessary libraries: The workflow imports cometspy, matplotlib, cobra.test, cobra, pandas, and numpy for ecosystem simulation, modeling, plotting, and data handling.
  • 1. Load the necessary libraries: A flask containing DM25 medium is represented as a single well-mixed compartment.
  • 1. Load the necessary libraries: The DM25 medium receives typical trace metabolites, glucose at 0.000139, and citrate at 0.0017; nutrient amounts must be set correctly.
  • 3. Load the E. coli iJO1366 model: The E. coli iJO1366 model is loaded with COBRApy, and exchange-reaction lower bounds are set to -1000.0 for COMETS control.
  • 3. Load the E. coli iJO1366 model: Genotypes are generated using COBRApy by controlling citrate and succinate transport reactions, recreating the ancestral phenotype through three reaction knockouts.
  • 3. Load the E. coli iJO1366 model: The model is copied into Cit++, Cit+, and Ancestor genotypes by selectively disabling SUCCt2_2pp and CITt7pp while retaining the specified transport configurations.
  • 3. Load the E. coli iJO1366 model: COMETS models are created from the COBRApy genotypes, with the WT initialized at 3.9e-11 and CitT and CitTdctA absent initially.
  • 3. Load the E. coli iJO1366 model: Vmax values for oxygen, nitrogen, and protons are set to 1000 so model growth remains carbon limited.

7. Add the models to the simulation · 1. Import the necessary libraries

COMETS simulations begin by importing and preparing COBRA models, converting them into COMETS models, and adding them to a spatial layout. The workflow then configures spatial barriers, founder populations, metabolites, and simulation parameters for ecological modeling.

  • 7. Add the models to the simulation: The simulation layout includes the wild-type, CitT, and CitTdctA models.These models are added with flask.add_model(wt), flask.add_model(citT), and flask.add_model(citTdctA).
  • 7. Add the models to the simulation: The simulation uses a 1 hr COMETS timestep, with daily dilution parameters including deathRate = 0.01, dilTime = 24, and dilFactor = 100.A 0.1 hr timestep does not substantially change the final result in this case but significantly increases simulation time.
  • 7. Add the models to the simulation: The citrate-evolution experiment runs three phases: ancestor growth from generation 25,000, CitT introduction near 31,000, and CitTdctA introduction near 33,000.CitT outcompeted the ancestor, and CitTdctA subsequently outcompeted CitT.
  • 1. Import the necessary libraries: The COBRA models are converted to COMETS models, sink reactions are distinguished from exchanges, and exchange bounds are opened so COMETS controls media composition.Opening exchanges prevents saved COBRA media definitions from overriding the layout’s specified media.
  • 1. Import the necessary libraries: The spatial world uses a 100x100 box lattice with a root at x = 0, air at y = 0, and biomass and rocks elsewhere.Seventy impervious rocks with an average size of 15 boxes are used to define barriers and prevent biomass placement there.
  • 1. Import the necessary libraries: Each species is seeded at 60 non-overlapping locations, using rock and previously selected founder locations as forbidden locations.The forbidden_locs argument is critical for preventing initial biomass overlap with rocks or other species.
  • 1. Import the necessary libraries: The layout adds the three COMETS models and initializes trace metabolites, while oxygen, carbon dioxide, ammonium, and root-associated compounds receive spatially specified conditions.The setup uses static concentrations for air and ammonium sinks, plus refresh functions for citrate, methanol, and succinate near the root.

Timing · Troubleshooting

COMETS simulations typically require 30 minutes to a few hours, with input preparation taking no more than 30 minutes. Troubleshooting focuses on installation, environment, file consistency, optimizer configuration, numerical stability, and model setup.

  • Timing: A typical COMETS simulation takes 30 minutes to a few hours, while preparing MATLAB or Python input files takes no more than 30 minutes.Runtime varies with grid complexity, number of models, S-matrix size, and available CPU speed and count.
  • Troubleshooting: Install COBRA and add its path when MATLAB cannot find initCobraToolbox() or other Cobra commands.The problem occurs when the Cobra toolbox is not installed or its path was not added to MATLAB.
  • Troubleshooting: COMETS launch failures can result from missing Java, incorrect Java priority, unset COMETS_HOME, wrong usage syntax, or absent Java libraries.Use 64-bit Java preferentially, configure COMETS_HOME, follow the printed usage instructions, and place dependencies downstream from COMETS_HOME.
  • Troubleshooting: Simulation failures can arise from missing optimizers or licenses, parameter-file mismatches, script syntax errors, or models that do not grow or uptake supplied metabolites.Install and license Gurobi, verify optimizer settings, parameter names and values, script references, and model–media compatibility.
  • Troubleshooting: Numerical instability from poor time or spatial steps can be addressed by lowering the time step or using a coarser spatial grid.The troubleshooting guidance specifically links unstable biomass or media propagation to time and spatial step choices.
  • Troubleshooting: Dynamic exchange bounds must remain within the loaded model’s bounds, and initial biomass must be explicitly set to avoid zero-biomass simulations.Relevant exchange reactions should have widely open bounds, and initial biomass can be assigned through the Python or MATLAB toolbox.

Anticipated results

The anticipated results demonstrate COMETS 2 across metabolic, spatial, enzymatic, multispecies, and evolutionary simulations. These cases reproduce expected growth and metabolite dynamics while producing varied colony morphologies, spatial exchanges, and competitive outcomes.

  • Spatial environments: A virtual Petri dish with tenfold lower nutrient diffusivity in one half yields different colony sizes and spatially varying growth and metabolite distributions.Growth is concentrated at colony leading edges, with glucose depletion and acetate accumulation across the dish.
  • Extracellular enzymes: Extracellular enzyme simulations distinguish reactions with and without enzyme involvement, including A+B→C and enzyme-catalyzed F→G conversions.The capability models costly enzyme production and secretion, followed by diffusion through the environment.
  • Core metabolism: E. coli batch growth stops when glucose is depleted, while fermentation products accumulate alongside biomass growth.The simulation uses minimal medium with glucose as the only carbon source.
  • Spatial growth: Changing packedDensity produces either a stable colony front or an unstable branching and dendritic morphology.Demographic noise generates distinct single-strain and five-strain colony morphologies, with strain segregation in the five-strain case.
  • Multispecies communities: A 14-species community simulation captures temporally dependent nutrient utilization, biomass production, carbon-source consumption, and metabolic byproduct exchange.The community uses genome-scale models from diverse taxonomic categories.
  • Competition and evolution: The protocols also simulate competitive exclusion, crossfeeding, and evolution, including citrate-utilizing mutants that successively outcompete ancestral strains.These outcomes include E. coli competition assays, lactose–galactose crossfeeding, and simulated Lenski-style evolution.

Appendix 2 Table. COMETS parameters, with units, default value and a short definition. … Simulation parameters

COMETS documents simulation controls and output formats for configuring runs, tracking biomass, media, fluxes, and complete archives. The parameters specify growth, exchange, diffusion, visualization, logging, and model-specific behavior.

  • Appendix 2 Table. COMETS parameters, with units, default value and a short definition.: COMETS can be launched through a limited-functionality GUI by loading prepared layout, model, and parameter files, while console output records run initialization and model testing.The console reports script execution, layout loading, model discovery, parameter testing, optimizer status, and world construction.
  • Appendix 1: Detailed structure of Output Files: Output recording is optional and its rate is controlled by input parameters; files include stepwise total biomass, spatial biomass, media, fluxes, and complete run information.Error messages are written separately, while complete .mat records are intended for archiving and may become very large.
  • Total biomass file.: Total biomass files use space-delimited records with simulation steps in the first column and integrated biomass for each model in separate columns, measured in grams.An example records biomass from 5E-6 at step 0 through 5.0943886175E-6 at step 4.
  • Biomass file.: Biomass files store spatial model biomass in MATLAB format, with coordinates and amounts indexed by simulation step and model; example recordings use a 100×100 layout every 100 steps.The example initializes two models at the center with 2.5E-6 grams and records later values of 3.5426406048E-6 and 3.4688274362E-6 grams.
  • Media file: Media files record external metabolite amounts in mmol units using named MATLAB arrays, while flux files record every model’s flux vector at each spatial point and recorded time.Media examples include spatially indexed metabolite arrays; flux records use time, x coordinate, y coordinate, and model index.
  • Simulation parameters: Additional simulation controls govern graphics, cycle reporting, slideshow generation, logging, random seeds, velocity output, and MATLAB or COMETS log formats.The complete record can include parameters such as timeStepsSaved, total_biomass, flux, and spatial settings, while writeMatFile is FALSE by default.

Author contributions statement

The authors collectively managed, conceptualized, developed, and maintained the COMETS platform, while preparing protocols and the manuscript. Contributions covered initial code, current software, specific modules, protocols, and manuscript preparation.

  • DS and ID provided overall management of the COMETS platform and led its conceptualization with AS, WH, and KK.
  • ID and WJR wrote and maintained the initial COMETS code, while ID, DB, JC, and MQ developed the current software and capabilities.
  • Multiple authors wrote specific modules, prepared and implemented protocols, and contributed to conceptualizing and preparing the manuscript.Specific-module authors were WJR, ID, JC, DB, MQ, and SS; protocol contributors included ID, JC, DB, MQ, ARP, SS, and JV.
Loading 2009.01734v1…