Abstract
Biochemical interactions in systems and synthetic biology are often modeled with chemical reaction networks (CRNs). CRNs provide a principled modeling environment capable of expressing a huge range of biochemical processes. In this paper, we present a software toolbox, written in Python, that complies high-level design specifications to CRN representations. This compilation process offers four advantages. First, the building of the actual CRN representation is automatic and outputs Systems Biology Markup Language (SBML) models compatible with numerous simulators. Second, a library of modular biochemical components allows for different architectures and implementations of biochemical circuits to be represented succinctly with design choices propagated throughout the underlying CRN automatically. This prevents the often occurring mismatch between high-level designs and model dynamics. Third, high-level design specification can be embedded into diverse biomolecular environments, such as cell-free extracts and in vivo milieus. Finally, our software toolbox has a parameter database, which allows users to rapidly prototype large models using very few parameters which can be customized later. By using BioCRNpyler, users can easily build, manage, and explore sophisticated biochemical models using diverse biochemical implementations, environments, and modeling assumptions.
1 Introduction
Chemical reaction networks (CRNs) are the workhorse for modeling in systems and synthetic biology.1 The power of CRNs lies in their expressivity; CRN models can range from physically realistic descriptions of individual molecules to coarse-grained idealizations of complex multi-step processes.2 However, this expressivity comes at a cost. Choosing the right level of detail in a model is more an art than a science. The modeling process requires careful consideration of the desired use of the model, the available data to parameterize the model, and prioritization of certain aspects of modeling or analysis over others. Additionally, biological CRN models can be incredibly complex including dozens or even hundreds or thousands of species, reactions, and parameters . Maintaining complex hand-built models is challenging and errors can quickly grow out of control for large models. Software tools can answer many of these challenges by automating and streamlining the model construction process.
Due to CRN’s rich history and diverse applications, the available tools for a CRN modeler are vast and include: extensive software to generate and simulate CRNs3,4, databases of models5, model analysis tools 6,7, and many more. However, relatively few tools exist to aid in the automated construction of general CRN models from simple specifications. For example, even though synthetic biologists have adopted a module and part-driven approach to their laboratory work,8 models are still typically built by hand on a case-by-case basis. Recognizing the fragile non-modular nature of hand built models, several synthetic biology design automation tools have been developed for specific purposes such as implementing transcription factor or integrase-based logic.9,10 These tools indicate a growing need for design and simulation automation in synthetic biology, as part and design libraries are expanded.
As the name would suggest, BioCRNpyler (pronounced bio-compiler) is a Python package that compiles CRNs from simple specifications of biological motifs and contexts. This package is inspired by the molecular compilers developed by the DNA-strand displacement community and molecular programming communities which, broadly speaking, aim to compile models of DNA circuit implementations from simpler CRN specifications 11–13 or rudimentary programming languages.14,15 However, BioCRNpyler differs from these tools for three main reasons: first, it is not focused only on DNA implementations of chemical computation; second, it does not take the form of a traditional programming language; and third, modeling assumptions and compilation schemas can be easily redefined by the user. BioCRNpyler combines specifications consisting of synthetic biological parts and systems biology motifs that can be reused and recombined in diverse biochemical contexts at customizable levels of model complexity. In other words, BioCRNpyler compiles detailed CRN models from abstract specifications of a biochemical system. Importantly, BioCRNpyler is not a CRN simulator—models are saved in the Systems Biology Markup Language (SBML)16 to be compatible with the user’s simulator of choice. Figure 1 provides motivating examples for the utility of BioCRNpyler by demonstrating the rapid construction of diverse CRNs by reusing common parts and modifying the modeling context.
There are many existing tools that provide some of the features present in BioCRNpyler. Systems Biology Open Language (SBOL)17 uses similar abstractions to BioCRNpyler but is fundamentally a format for sharing DNA-sequences with assigned functions and does not compile a CRN. The software package iBioSim18,19 compiles SBOL specifications into SBML models and performs analysis and simulation. Although BioCRNpyler is capable of similar kinds of compilation into SBML, it is not a simulator. Importantly, BioCRNpyler does not hard code how models are compiled—instead it should be viewed as a customizable software compilation language that can be applied to compile many kinds of systems beyond genetic networks. The rule-based modeling framework BioNetGen20 allows for a system to be defined via interaction rules which can then be simulated directly or compiled into a CRN. Internally, BioCRNpyler functions similarly to this rule based-modeling compilation. Similarly to PySB21, BioCRNpyler provides a library of parts, mechanisms, and biomolecular contexts that allow for models to be succinctly produced without having to manually specify and verify many complex rules. Finally, the MATLAB TX-TL Toolbox 22 can be seen as a prototype for BioCRNpyler but lacks the objected-oriented framework and extendability beyond cell-free extract systems.
BioCRNpyler is a purposefully suited to in silico workflows because it is an extendable objected-oriented framework that integrates existing software development standards and allows complete control over model compilation. Simultaneously, BioCRNpyler accelerates model construction with extensive libraries of biochemical parts, models, and examples relevant to synthetic biologists, bio-engineers, and systems biologists. The BioCRNpyler package is available on GitHub23 and can be installed via the Python package index (PyPi).
2 Motivating Examples
This section highlights the ease-of-use of BioCRNpyler through several well-known synthetic biology examples. As a summary, Figure 1 demonstrates the utility of compiling CRNs with BioCRNpyler. The names of Python classes are highlighted typographically and are defined more thoroughly in later sections. Time-course simulations in Figure 1 were done with Bioscrape24 and circuit diagrams were created with DNAplotlib. 25 Additional example models of the lac operon and an integrase circuit are depicted in Figures 3 and 5, respectively.
2.1 Inducible Repression, Toggle Switch and Repressilator
Models A, B, and C show three archetypal motifs from synthetic biology: inducible repression, a bistable toggle switch,26 and the repressilator.27 All three of these examples are created by reusing the same Components wired together in different ways as described in Section 6. The ability to reuse Components allows for convenient design-space exploration of different circuit architectures. Furthermore, as explained in Section 2.2 and 2.4, examples D, E and F show how these Components can be tested in different contexts by changing the Mechanisms and Mixtures used to compile the Components resulting in nuanced implementation-specific and context-specific models.
2.2 dCas9 Repressor and Guide RNA Coexpressed with Reporter
Figure 1D builds upon the repression Model A by modeling an implementation consisting of a guide-RNA and dCas9 ChemicalComplex that also acts as a repressor by inhibiting RNA-polymerase binding to the reporter DNAassembly.28 Model A also includes more intracellular context such as nucleases and ribosomes. By including cellular machinery in the model, the co-expression of dCas9 and the guide RNA is able to influence the reporter via loading effects and retroactivity, which can cause unintended increases and decreases in reporter expression29 even when only the guide-RNA or dCas9 is present.
2.3 Targeted RNAase Toggle Switch
Figure 1E models a hypothetical toggle switch that functions at the RNA level instead of the transcriptional level. Each DNAassembly expresses a subunits A and B of two homodimer-RNAase. The homodimer-RNAase made from subunit A selectively degrades the mRNA producing subunit B and visa-versa. Such a system could potentially be engineered via RNA-targeting Cas930 or more complex fusion proteins. 31
2.4 Multiple Ribosome Occupancy Repressilator Dynamics
Figure 1F illustrates how BioCRNpyler can be used to easily generate more realistic and complex models of biochemical processes in order to validate if model simplifications are accurate. It is common practice in transcription and translation models to use an enzymatic process consisting of a single ribosome (R) to a transcript (T) which then produces a single protein (P). This translation Mechanism could be written as: R + T L ⥦ R : T → R + T + P . Indeed, both example models D and E use such a simplification. However, experiments show that in fact many ribosomes can co-occupy the same mRNA.32 By changing the underlying translation Mechanism to model multiple ribosomal occupancy of a single mRNA, a considerably more complex Repressilator model was created. Importantly, this model exhibits very similar behavior to the simpler model, suggesting that multi-occupancy of ribosomes on mRNA can be neglected in these kinds of genetic regulatory circuits.
2.5 Network complexity
Finally, the bottom bar chart in Figure 1G shows that even as the size of the underlying CRN grows, the amount of BioCRNpyler code that is needed to generate the model remains very small. This enables the generation of large and complex models with greater accuracy and lower chance of human error. For example, imagine writing down ODEs with hundreds of terms and then trying to systematically modify the equation: human error is nearly inevitable. By using BioCRNpyler to compile CRNs, models can be easily produced, modified, and maintained.
2.6 Parameter Database
Importantly, all these examples in this section make use of the same underlying set of 10-20 default parameters (estimated from Cell Biology by the Numbers33) demonstrating how BioCRNpyler’s ParameterDatabase makes model construction and simulation possible even before detailed experiments or literature review.
3 Framework and Compilation Overview
BioCRNpyler is an open-source Python package that compiles high-level design specifications into detailed CRN models, which then are saved as an SBML files.34 BioCRNpyler is written in Python with a flexible object-oriented design, extensive documentation, and detailed examples which allow for easy model construction by modelers, customization and extension by developers, and rapid integration into data pipelines. As Figure 2 shows, underlying BioCRNpyler is a comprehensive ChemicalReactionNetwork class allowing for the direct creation and manipulation of Reactions and the participating Species to represent molecular interactions at many levels of complexity. For example, an entire gene may be modeled as a single Species, as an OrderedPolymerSpecies with multiple binding specific sites, or as a PolymerConformation which represents the secondary structure of one or more OrderedPolymerSpecies.
BioCRNpyler also compiles ChemicalReactionNetwork objects from high-level specifications defined by modular Components combined together in a Mixture representing a biochemical context (e.g. cell lysate extract). Modeling assumptions and specific knowledge of biochemical processes are defined via Mechanisms which can be placed inside Components and Mixtures. This class structure allows for the biochemical parts (e.g. Components) to be reused to quickly produce numerous different architectures and implementations, such as those described in the motivating examples. These different architectures and implementations can further be tested in different contexts providing easily customizable levels of biochemical and modeling complexity represented by Mixtures and Mechanisms.
The Mixture, Component, and Mechanism classes are hierarchical. Mixtures represent biological context by containing Components to represent the biochemical environment and Mechanisms to represent the modeling details. For example, the TxTlExtract subclass of Mixture represents bacterial cell extract and contains Ribosomes, RNA Polymerase, and RNAases Components as well as transcription, translation, and RNA-degredation Mechanisms. Additionally, Components can be added to a Mixture to produce a particular biochemical system of interest in a particular context. Figure (3) illustrates how a set of BioCRNpyler Components and Mechanisms can be joined together to produce a systems level model of the lac operon — a highly studied gene regulatory network in E. coli which regulates whether glucose or lactose is metabolized.35 This model consists of around a dozen Components and Mechanisms which jointly enumerate hundreds of species and reactions representing the combinatorial set of conformations of the lac operon and its associated transcription factors, transcription, translation, transport, mRNA degradation and dilution.
During compilation, Components represent biochemical functionality by calling Mechanisms to produce Species and Reactions. The Component class may use the Mechanisms contained in the Mixture or have their own custom Mechanisms to have more differentiated functionality. For example, a RepressiblePromoter (a subclass of Component) might rely on the Mixture for its translation Mechanism but use a custom transcription Mechanism. BioCRN-pyler uses flexible ParameterDatabases contained in both Mixtures and Components to allow for rapid model prototyping using just a few default parameters, which can later customized for each Component and Mechanism. Specifically, Mechanisms will first search for parameters in the Component that called them before defaulting to the parameters of the Mixture. This defaulting behavior is illustrated by the light gray arrows of Figure 2. Finally, ComponentEnumerators provide a highly flexible framework to automatically generate new Components during compilation as illustrated in the integrase example Figure 5.
3.1 Internal CRN Representation
Formally, a CRN is a set of species S = {Si} and reactions where I and O are multisets of species, ρ is the rate function or propensity, s is a vector of species’ concentrations (or counts), and θ are rate parameters. Typically, CRNs are simulated using as ordinary differential equations (ODEs) and numerically integrated.2 A stochastic semantics also allows CRNs to be simulated as continuous-time Markov chains.36 Besides their prevalence in biological modeling, there is rich theoretical body of work related to CRNs from the mathematical,37 computer science, 38 and physics communities.39 Despite these theoretical foundations, many models are phenomenological in nature and lack mechanistic details of various biological processes. The challenge of constructing correct models is compounded by the difficulty in differentiating between correct and incorrect models based upon experimental data.40–42
BioCRNpyler allows users to easily build diverse CRNs with flexible species and reaction representations which are then saved as SBML16 for simulation with many different simulators. The CRN classes inside BioCRNpyler provide useful functionality so that users can easily modify CRNs produced via compilation, produce entire CRNs by hand, or interface hand-produced CRNs with compiled CRNs. These functionalities include classes to represent Species bound together as ComplexSpecies, lists of species organized as OrderedPolymerSpecies, a multi-polymer secondary structures called a PolymerConformation, and many diverse propensity functoin types including mass-action, hill functions, and general user specified propensities. Additionally, user-friendly printing functionality allows for the easy visualization of CRNs in multiple text formats or as interactive reaction graphs formatted and drawn using Bokeh and ForceAtlas2. 43,44
3.2 Mechanisms are Reaction Schemas
When modeling biological systems, modelers frequently make use of mass-action CRN kinetics which ensure that parameters and states have clear underlying mechanistic meanings. However, for the design of synthetic biological circuits and analysis using experimental data, phenomenological or reduced-order models are commonly utilized as well.2 Empirical phenomenological models have been successful in predicting and analyzing complex circuit behavior using simple models with only a few lumped parameters.45–47 Bridging the connections between the different modeling abstractions is a challenging research problem. This has been explored in the literature using various approaches such as by direct mathematical comparison of mechanistic and phenomenological models48–50 or by studying particular examples of reduced models.2 BioCRNpyler provides a computational approach using reaction schemas to easily change the mechanisms used in compilation from detailed mass-action to coarse-grained at various level of complexity.
Reaction schemas refer to BioCRNpyler’s generalization of switching between different mechanistic models: a single process can be modeled using multiple underlying motifs to generate a class of models. Mechanisms are the BioCRNpyler objects responsible for defining reaction schemas. In other words, various levels of abstractions and model reductions can all be represented easily by using built-in and custom Mechanisms in BioCRNpyler. For example, to model the process of transcription (as shown in Figure 4), BioCRNpyler allows the use of various phenomenological and mass-action kinetic models by simply changing the choice of reaction schema. Notably, this provides a unique capability to quickly compare system models across various levels of abstraction enabling a more nuanced approach to circuit design and exploring system parameter regimes.
Formally, reaction schemas are functions that produce CRN species and reactions from a set of input species and parameters: f : (S′, θ) → (S, R). Here the inputs S′ are chemical species and θ are rate constants. The outputs S ⊇ S′ is an increased set of species and R is a set of reactions. Figure 4 gives different examples of a reaction schema’s representing transcription. This functionality allows modelers to generate CRNs at different levels of complexity and reuse CRN motifs for some Components while customizing Mechanisms for others. Importantly, BioCRNpyler contains a large and growing library of existing Mechanisms extensively documented via examples making them easy to use and re-purpose without extensive coding. Internally, each Mechanism class has a type (e.g. transcription) which defines the input and output species it requires. GlobalMechanisms are a special subclass of Mechanism called at the end of compilation to represent processes which act on large subsets of CRN species such as dilution in cellular models. The ability to generate chemical Species and Reactions via customizable Mechanisms is one of the key features making BioCRNpyler distinct from other frameworks. Hierarchical SBML and supporting software provide 51 a noteable exception—however BioCRNpyler contains library of reusable chemical reaction motifs, while Hierarchical SBML is a standard for describing embedded CRN models.
3.3 Components Represent Functionality
In BioCRNpyler, Components are biochemical parts or motifs, such as promoters, enzymes and chemical complexes. Components represent biomolecular functionality; a promoter enables transcription, enzymes perform catalysis, and chemical complexes must bind together. Components express their functionality by calling particular Mechanism types during compilation. Importantly, Components are not the same as CRN Species; one Species might be represented by multiple Components and a Component might produce multiple Species! For example, the single CombinatorialConformationPromoter Component used in the lac operon model (shown in Figure 3) produces hundreds of unique Species. Conversely, the chemical species β-Galactosidase is modeled using two components: an Enzyme to model the metabolism of lactose and a ChemicalComplex to model the fact that β-Galactosidase is a homeotetramer. Components are flexible and can behave differently in different contexts or behave context-independently. To define dynamic-context behavior, Components may use mechanisms and parameters provided by the Mixture. To define context-independent behavior, Components may have their own internal Mechanisms and (ParameterDatabases). The BioCRNpyler library includes many Component subclasses to model enzymes (Enzyme), chemical complexes (ChemicalComplexes) formed by molecular binding, Promoters (Promoter), Ribosome Binding Sites (RBS), complex genetic architectures (such as DNA construct illustrated in Figure 5), and more.
3.4 Mixtures Represent Context
Mixtures are collections of default Components, default Mechanisms, and user-added Components. Mixtures can represent chemical context (e.g. cell extract vs. in vivo), as well as modeling resolution (e.g. what level of detail to model transcription or translation at) by containing different internal Components and Mechanisms. Mixtures also control CRN compilation by requesting Species and Reactions for each of their Components. After receiving all these Species and Reactions, Mixtures then apply GlobalMechanisms which act on all the Species produced by Components. BioCRNpyler comes with a variety of Mixtures to represent cell-extracts and cell-like systems with multiple levels of modeling complexity.
3.5 Component Enumeration allows for Arbitrary Complexity
ComponentEnumerators are specialized classes which allow additional Components to be generated dynamically during the compilation process. Local component enumeration occurs when one Component compiles itself into a set of many sub-components. For example, the DNA construct Component, made out of an ordered list of DNA parts, such as Promoters, RBSs, and CDSs, uses the ConstructExplorer ComponentEnumerator to enumerate all the possible mRNAs which could be transcribed as new RNA construct Components. When the CRN is compiled, many RNA constructs may be generated from a single DNA construct. These RNA constructs can then be coupled to Mechanisms automatically to compile a complex CRN.
Similarly, global component enumeration endows a Mixture with a ComponentEnumerator that generates a set of Components based upon all the Components in the Mixture. For example, serine integrases are enzymes which are capable of recombining strands of DNA at specific integration sites. 52 Integration events can happen within a single piece of DNA or between multiple DNA species. The Integrase Enumerator is a ComponentEnumerator which looks at all the DNA constructs present in a Mixture and enumerates all possible integration events to generate new DNA constructs which are then fed back into the Integrase Enumerator. Figure 5 illustrates both local and global component enumeration involving a DNA construct with serine integrase attachment sites. Other integrase types (for example homotypic sites) are also supported. Due to the potential of an unbounded number of Components being produced by such a process, component enumeration can be called to a user specified recursion depth in order to compile arbitrarily large chemical reaction networks.
3.6 Flexible Parameter Databases
Developing models is a process that involves defining then parameterizing interactions. Often, at the early stage of model construction, exact parameter values will be unavailable. BioCRNpyler has a sophisticated parameter framework which allows for the software to search user-populated ParameterDatabases for the parameter that closest matches a specific Mechanism, Component, and parameter name. This allows for models to be rapidly constructed and simulated with “ball-park” parameters and then later refined with specific parameters derived from literature or experiments later. This framework also makes it easy to incorporate diverse parameter files together and share parameters between many chemical reactions.
4 Building an Open-Source Community
BioCRNpyler aims to be a piece of open-source community driven software that is easily accessible to biologists and bioengineers with varying levels of programming experience as well as easily customizable by computational biologists and more advanced developers. Towards these ends, the software package is available via GitHub and PyPi, requires very minimal software dependencies, contains extensive examples and documentation in the form of interactive Jupyter notebooks,23 YouTube tutorials,53 and automated testing to ensure stability. Furthermore this software has been extensively tested via inclusion in a bio-modeling course and bootcamps with dozens of users ranging from college freshmen and sophomores with minimal coding experience to advanced computational biologists. BioCRNpyler has already been deployed to build diverse models in systems and synthetic biology. 54–57 Developing new software functionality is also a simple process documented on the GitHub contributions page.
4.1 Integrated Testing
BioCRNpyler uses Travis-CI58 and Codecov59 to automate testing on GitHub. Whenever the software is updated, a suite of tests is run including extensive unit tests and functional testing of tutorial and documentation notebooks. Automated testing unit testing ensures that changes to the core BioCRNpyler code preserve functionality of the package. The integration of Jupyter notebooks into testing allows users to easily define new functionality for the soft-ware and document that functionality with detailed explanations which are simultaneously tests cases.
4.2 Documentation and Tutorials
The BioCRNpyler GitHub page contains over a dozen tutorial Jupyter notebooks23 and presentations explaining everything from the fundamental features of the code to specialized functionality for advanced models to how to add to the BioCRNpyler code-base. 53 This documentation has been used successful in multiple academic courses and is guaranteed to be up-to-date and functional due to automatic testing.
5 Future Directions
BioCRNpyler is an ongoing effort which will grow and change with the needs of its community. Extending this community via outreach, documentation, and an ever expanding suite of functionalities is central to the goals of this project. We are particularly interested in facilitating the integration of BioCRNpyler into existing laboratory pipelines in order to make modeling a central part of the design-build-test cycle in synthetic biology. One avenue towards this goal is to add compatibility to existing standards such as SBOL 17 and automation platforms such as DNA-BOT 60 so BioCRNpyler can automatically compile models of circuits as they are being designed and built. This approach will be a generalization and extension of Roehner et al. 61 In particular due to the modular BioCRNpyler compilation process, it will be possible to have programmatic control over the SBML model produced from BioCRNpyler.
We also plan on extending the library to include more realistic and diverse Mixtures, Mechanisms, and Components (particularly experimentally validated models of circuits in E. coli and in cell extracts). We hope that these models will serve as examples and inspiration for other scientists to add their own model systems in other organisms to the software library. Finally, we believe that the Context-Part-Mechanism abstraction of model compilation used in BioCRNpyler is quite fundamental and could be extended to other non-CRN based modeling approaches. Advanced simulation techniques beyond chemical reaction networks will be required to accurately model the diversity and complexity of biological systems. New software frameworks such as Vivarium 57 have the potential to generate models which couple many simulation modalities. The abstractions used in BioCRNpyler could be extended to compile models beyond chemical reaction networks such as mechanical models, flux balance models, and statistical models derived from data. The integration of these models together will naturally depend on both detailed mechanistic descriptions as well as overarching system context. We emphasize that building extendable and reusable frameworks to enable quantitative modeling in biology will become increasingly necessary to understand and design ever more complex biochemical systems.
6 Supplemental: Code for Examples
This section provides code from the examples Figure 1. The first three models are idealized in the sense that they are represented by Hill functions and include no cellular machinery such as ribosomes or polymerases. Producing these models in BioCRNpyler is easy and just requires the reuse of a few parts: DNAassembly represents a simple transcriptional unit with a promoter, transcript and optionally an ribosome binding site (RBS) and protein product. RepressiblePromoter creates a promoter modeled by a hill function. Species creates CRN species used in the models. Notice that only Species which are shared between different Components need created by hand — BioCRNpyler takes care of the rest. For example, in inducible repression example the repressor R is created by hand because it is placed inside the RepressiblePrmoter. However the DNA, transcript, and protein are automatically generated from the name of the DNAassmebly. Finally, everything is added together into a subclass of Mixture and compiled into a ChemicalReactionNetwork. The second three models build off the general architectures of the first three but add in more complicated context and implementation details. Instead of using ExpressionDilutionMixture and SimpleTxTlDilutionMixture, these models use the considerably more complex TxTlDilutionMixture which includes molecular machinery such as RNAP, ribosomes, RNAases, and background cellular processes. Additional implementation details in the form of Components and Mechanisms are also added to these models.
6.1 Inducible Repression
Here a repressor is constituitively produces from a DNAassembly. This repressor is then linked to a RepressiblePromoter which models repression using a hill function.
6.2 Toggle Switch
In the following example, a toggle switch is created by connecting two instances of RepressiblePromoter together. Notice that string names passed to promoter and rbs are used to help find parameters. BioCRNpyler comes with many default parameters to enable rapid model prototyping.
6.3 Repressilator
The code to create a 3-node repession oscillator is really just adding one more unit and rewiring the toggle switch example.
6.4 Cas9 Repressor and Guide RNA Coexpressed with Reporter
Modeling a dCas9-guideRNA repressor in bioCRNpyler requires that the dCAs9 and guide RNA know to bind together. This is accomplished via the Component subclass ChemicalComplex which models binding between multiple species. The resulting dCas9-guideRNA ComplexSpecies is used as a repressor.
6.5 Targeted RNAase Toggle Switch
The targeted RNAase toggle switch model is a hypothetical model similar to a normal toggle switch but with regulation at the RNA level instead of the transcriptional level. This is accomplished by creating two constitutively expressed RNAases (which are ChemicalComplexes made up of two subunits) and adding custom Mechanisms to the Mixture modeling the degradation of any species with the attribute “tagA” and “tagB” by RNAase A and RNAase B, respectively.
6.6 Multiple Ribosome Occupancy Repressilator Dynamics
Simulating multiple-ribosome occupancy in the Repressilator mostly reuses the code from Section 6.3 with the main addition of a new Mechanism to model transcription being placed into the Mixture.
7 Supplemental: Tables of Features
This section lists many of the different Mixture, Component and Mechanism classes available in BioCRNpyler. For more details about these classes and examples using many of them, check out the examples folder on GitHub.
7.1 Mixtures
7.2 Components
7.3 Mechanisms
8 Supplemental: Creating Custom BioCRNpyler Classes
BioCRNpyler is designed to be easily extendable so even non-computer scientists can add their own custom functionality. In this section we briefly show how to subclass core BioCRN-pyler classes. For more details and examples, interested readers should look at the developer overview on our github.
8.1 Mechanisms
Developing custom Mechanisms is also as easy as making a subclass of Mechanism and defining three functions to produce the desired CRN:
8.2 Components
It is also straightforward to make custom Components: simply subclass Component and define three functions:
8.3 Mixtures
Making custom Mixtures is also easy — it can be done via simple scripts by adding
Components and Mechanisms to a Mixture object:
Acknowledgement
We would like to thank the Caltech BE 240 class and the Murray Biocircuits lab for extensive testing of this software and discussions of relevant models, library of parts, and parameters. In particular, we would like to thank Matthieu Kratz, Liana Merk, and Ankita Roychoudhury for contributing to the software library. The authors W.P. and A.P. are partially supported by US National Science Foundation (CBET-1903477). A.P. is also supported by the Defense Advanced Research Projects Agency (Agreement HR0011-17-2-0008). The content of the information does not necessarily reflect the position or the policy of the Government, and no official endorsement should be inferred.
Footnotes
E-mail: wpoole{at}caltech.edu
This version of the BioCRNpyler paper reflects version 1.1.1 of the software which includes many new features and bug fixes.
References
- (1).↵
- (2).↵
- (3).↵
- (4).↵
- (5).↵
- (6).↵
- (7).↵
- (8).↵
- (9).↵
- (10).↵
- (11).↵
- (12).
- (13).↵
- (14).↵
- (15).↵
- (16).↵
- (17).↵
- (18).↵
- (19).↵
- (20).↵
- (21).↵
- (22).↵
- (23).↵
- (24).↵
- (25).↵
- (26).↵
- (27).↵
- (28).↵
- (29).↵
- (30).↵
- (31).↵
- (32).↵
- (33).↵
- (34).↵
- (35).↵
- (36).↵
- (37).↵
- (38).↵
- (39).↵
- (40).↵
- (41).
- (42).↵
- (43).↵
- (44).↵
- (45).↵
- (46).
- (47).↵
- (48).↵
- (49).
- (50).↵
- (51).↵
- (52).↵
- (53).↵
- (54).↵
- (55).
- (56).
- (57).↵
- (58).↵
- (59).↵
- (60).↵
- (61).↵
- (62).