Step-by-step guide to the GENESIS system:

Below is a small guide to design your first small circuit. This is a basic guide, for more information you should refer to the advanced documentation or contact the team.
The simple guide:

1. Make sure you have credentials!
   Please contact the system administrator if you don't have or have forgotten your credentials.
2. Log into the login page by filling in your credentials and clicking the Sign in button.
   N.B. Your username is your email.
3. Now you will be confronted with a setup modal. Pick the library you want to use. You can pick a library you uploaded previously or one that is public.
   These libraries contain the proteins that can be used in your circuit, so investigate into the libraries so you know which one to pick.
   You will also have to provide a name for your circuit. No need to think of very complex names, these names only have to be unique within your account. It wouldn't hurt to use a name that represents the circuit you want to design, because you can include this circuit in others after you save it, see the advanced functionality.
   Click "Apply setup" to finish the setup and close the modal.
4. Now you will see an input and an output gate. These will act as a source and sink to the circuit. Drag and drop the pictures of gates on the right into the workspace to create a new gate instance.
   You can also drag the names under Modified gates into the workspace to import an existing circuit. The circuit will be drawn just the way it was saved, so you won't have to reorder everything. It will be drawn at a slight offset from the place where it is dropped, because it is drawn relative to that position.
5. When you create a new instance, endpoints are added to the gate. Use these to connect your gates, but remember, gates have inputs and outputs, and you can only drag a connection from the blue output circles to the green input circles.
   After connecting you see the connection and on that connection will be an arrow indicating the direction of the connection.
6. When two gates are linked up, you can click that connection to select the protein that should be used in that connection. Be careful not to choose the same protein multiple times.
   After selecting a label will appear on the connection indicating which protein is used.
7. When you are satisfied with your circuit, you can click on "Simulation". Another modal will show that enables you to specify an input for each protein that comes from the source (the big input box). A default input where all signals are on is provided. You can make it more interesting by specifying more lines of input according to the format in the Inputs section.
8. You can also specify the number of steps to take, and how big the steps should be. It is advised not to take more than two thousand steps, because that will probably cause your machine to slow down when you try to interact with the results (see below and in the Output section). Also, if the step size is greater than four the simulation will become so inaccurate that some of the values in the system will tend to infinity and the simulator doesn't know what to do with that, so it will give back an error. The default value of one should be just fine in most cases.
9. Once you've specified the input parameters, click "Apply" and the simulation will start. When it is done you will be presented with a graph and a button to download a CSV file with the results. More info about the output is given in the Outputs section.

Specifying the inputs:

The inputs are specified in a vector format, meaning that all the values that belong together should be beneath each other. This is ordering is column based, and the first column should be the time at which the input should change.
For simpler use of this system, a binary input was chosen what will be parsed to weighed signals in the backend.
At the top of the vectors should be the identifiers, the first one being t for the time. Next should be all the protein names as described in the library.
Here is an example (though it's a cropped version better viewing of this page.):

More concretely, on the first line the time and input proteins are specified. These will be filled in automatically for you. The next lines are each of the format <time>,0,0,1,1,0,1,0,0,... Here the first number is the time step at which the inputs are specified, and the zeros and ones say which input is on at this time. The inputs will maintain this state until the time of the next line, or until the end of the simulation if this is the last line.

This is a simple input method so we could focus on getting the primary functionality working. In the section about wanted functionality you can read more about what our ideas where about what to implement when we would have had more time.

What is shown in the output:

The output is specified by the circuit you designed, proteins you used, the library and the input signal. This is then sent to the back-end to be parsed into a full memory model, but more on that in the section about the inner workings. The output is then given back is the form of series data, for each input protein you get both the mRNA and protein levels as result. These levels are plotted in an interactive graph, which enables you to zoom horizontally. In the graph the mRNA concentrations are turned off by default, but you can use the legend on the right to enable them again. You can click on the ticks in this legend to enable or disable a specific protein or mRNA concentration, and you can also click on the name of one of the items to display just that item.

Also a CSV file can be downloaded that will have a similar form as the input signal. This can be used for further analysis and plotting outside of the GENESIS environment. The only difference between the input and this file is that instead of just proteins, the mRNA and protein levels are given, and instead of just ones and zeros, the actual concentrations are given.

How does GENESIS work:

GENESIS is built upon the idea that pieces of DNA can be chained together to form genetic material that can act as a simple circuit. This is a simplified model, since other processes can and will influence this circuit. Since a protein is released into the cell body fluid, which is a continuous process, and not directed to a specific target/location, which would be more discrete, the best way to keep track of the current level of proteins is through the use of differential equations.
On the back-end of the GENESIS system a memory model is used to generate the appropriate equations using the levels of the mRNA and protein as variables, according to the circuit you designed. This system is solved in the specified number of steps with the specified step size.

Other important components are the web-framework on which GENESIS is built. This is the Play! framework This is a modular (MVC) framework that can be built using Java and/or Scala. The front-end is built using HTML templates with Scala identifiers to inject other templates, data, raw HTML or a combination. To make the front-end appealing and interactive Javascript and CSS are used, a common practice on the modern web.

Within this framework objects and classes are used to represent the data, which in turn can stored in a database. We opted for an off-site database so everyone could use the same data and stay consistent. This database is a POSTGRESQL database, since it offers simple and efficient access to data as well as advanced functionality, like update rules and user login roles.
The most important information is stored inside the database, and only the most important. This is done to keep the database small and fast while being able to extract all useful information. This is why neither inputs or simulation results are stored. For longer simulations the results can consist of thousands of entries. The same goes for the input, though on a smaller scale and on top of that, why would you want to use the same inputs every time you simulate?

More advanced GENESIS functions:

Other functionality of the system is as listed below:

• You can save a circuit into the database, for use in further projects. To do this you click on "Circuit" and then "Save" to save your circuit.
  If you want to save it under a different you have to rerun the setup. This can be done by clicking "Simulation" and then "Setup". Now the setup modal will show again.
  Once a circuit has been saved, its name will appear under the modified gates and can be dragged into the workspace. There it will be expanded just the way it was saved. N.B. Its name will only appear after you reload the page, because it doesn't make much sense to drag the circuit you're currently working (and just saved) on into the workspace.
• If you want to load a circuit, click "Circuit" and then "Load". You will be presented with a list of your circuits you can load, and then edit or simulate. The list will also contain public circuits that anyone can load or edit.
• To reset the workspace, click on Circuit and the New. This will remove all gates from your workspace, but remember to save first because else all your hard work will be lost.
• In the Circuit menu, there is also an option to Delete a circuit. Clicking this will show a modal with a dropdown menu to select which circuit to delete. Select the circuit you want to delete and click Delete to delete it. When you do this, it will also disappear from the list of custom gates.
• If after simulating you accidentally (or otherwise) close the result modal, there's no need to panic. The Simulation menu also contains an option to view the results, so there's no need to redo the simulation.
• Finally, the Simulation menu also contains an option to import your own library. Here, obviously, you can import a library of your choice. Simply paste the parameters of all the coding sequences and gates in the appropriate boxes. Coding sequences are formatted as four-tuples, with the name coming first, followed by the k₂, d₁ and d₂ parameters, separated by commas. NOT gates are specified as (input name, k₁, K_m, n) tuples, and AND gates the same way, except there are two names instead of one for the two inputs.

Wanted functionality for further development:

We would have liked to make the input specification a little bit more advanced. In particular, we were thinking about making an input field where the user could draw a graph of the input concentration using the mouse. This graph would then be sampled and the samples used as the inputs for the simulation.

It would have been nice to have a little tooltip appear when a custom gate is dragged into the workspace. This would show the user what the gate looked like, in case they forgot. Another way to achieve this would be to draw a kind of ghost image of the gates that would be drawn, then when the user releases the mouse, to make them concrete.

The administration page is currently very limited. It only supports the creation of new users. It would be better if the administrator were able to administer for instance which custom circuits are public, and which users are allowed to see which circuits. Another good option would be to regulate the privileges that users have with respect to the creation and deletion of circuits. Users creating a publicly accessible circuit may not be desirable, and deleting such a circuit almost certainly is not.

We were going to implement the simulator as a multithreaded program. This would have enabled the user to cancel a simulation if it took too long. It could also relieve the server if there are many users trying to simulate circuits. Unfortunately, time was short and there were other, more urgent things that needed to be attended to before we could implement this feature.

About our team, JAMES:

Developer: Michael The
Site: http://stackoverblog.wordpress.com
Twitter: @ReturnFalse
Location: The Netherlands, Rotterdam

Developer: Stijn van Schooten
Site: http://svanschooten.nl
Twitter: @SSchooten
Location: The Netherlands, Delft

Developer: Edward

Developer: Jeroen

Developer: Anton

Special thanks to:
Dick de Ridder
Marcel Reinders
Alexey Gritsenko
Wouter Willems

What libraries were used for GENESIS:

• jQuery
• jQuery UI
• Twitter bootstrap
• jsPlumb
• rickshaw
• d3.js
• QUnit
• Blanket