Staple architecture

[shanilpanara]

Summary

The stapling architecture will consist of the following workflow:

1. Use scaffold (represented as LatticeRoute) to form multi-dimensional array representation of the scaffold (StapleBaseClass)

2. Use this multidimensional array to generate staples, by modifying it with a StaplingAlgorithm. The array will contain staple information such as:

• their start point, endpoint and where they crossover to another branch
• also which parts of the scaffold have and haven't been "Stapled"

3. Convert this multidimensional array to an oxDNA system (This will be stored in StapleCollection). This works by finding the start, crossover and end points corresponding to each staple and then cross-referencing these points to the corresponding nucleotides in the scaffold

[shanilpanara]

Stapling Architecture: Multiple Algorithms

The goal of this architecture is to facilitate ease of construction of many stapling algorithms, such that one only needs to focus on writing algorithms to program the logic of choosing where the staples go, not how to store this information and convert the computer representation to a file readable format etc.

Stapling Architecture: Configurations

The architecture should also allow for the autonomous generation of multiple staple configurations.

Here configurations are defined as: a specific set of staples designed for a particular scaffold.

The variation in configurations generated for a particular scaffold can be achieved in two ways:

1. Designing new stapling algorithms, which let us decide the size and location of staples.
2. Designing configuration modifying algorithms, which could allow us to remove staples from a particular configuration or modify them.
   • Modifications could occur, for example, by slicing a double-domain staple in half such that they become two single-domain staples (i.e. simply double stranded sections of DNA)
   • Removal of staples could be randomised and multiple random configurations with the same number of staples could be generated for example
   • The possibilities are huge

[shanilpanara]

Staple Architecture: Technical Summary

1. Input: LatticeRoute (generated using DNASnake() from the lattice folder)
2. Staple algorithms can then be run. Note, they should be written as StapleAlgorithmX, where X is a number and should subclass StapleBaseClass
3. Output 1: StapleCollection objects should be generated from the StapleAlgorithmX object using .staple_collection()
4. Output 2: oxDNA System objects can be generated from the staple configuration(s) stored in StapleCollection using .system()
5. An oxDNA .top and .conf file can be written using .write_oxDNA() on the System object.

Staple Architecture: The StapleBaseClass

StapleBaseClass contains methods to:

• generate/store information about the scaffold, for each row. Including number of nucleotides on each row, 3' and 5' direction of each row and hence start side of a row (left/right) [this is all information useful for the generation of staples]
• find the location of all possible crossover points (i.e. the nucleotides furthest away from the central helical axis)
• moreover, generate a 2D lattice representation of the scaffold, i.e. where staples can be placed [this is the most important datastructure, which we can read and modify when generating staples]
• plot schematics of the scaffold and, if they have been created, staples too
• generate a origami configuration as a StapleCollection (from here one should be able to manipulate the given origami configuration to further produce configurations)