The NetTAS simulator was implemented using Angular, as it meets industry standards and offers a user-friendly development environment. Angular natively supports both the Model-View-ViewModel (MVVM) and Model-View-Controller (MVC) architectural patterns. NetTAS was developed following the MVVM structure, where the view is connected to the model bidirectionally through the view model. This allows changes in the model to be immediately reflected in the view, and vice versa.

The model was implemented in an object-oriented manner, strictly adhering to Winfree’s definitions for aTAM and kTAM (Winfree et al., 1998). A Tile consists of four Glue elements and one label. The label is represented directly as text. Each Glue is defined as a tuple g = { l , s } , where l is the label and s is the strength of the glue.

New tilesets can be created directly within NetTAS. Alternatively, users can import existing sets from JSON or ISU TAS files. Once a tileset has been created, it can be saved in JSON format for future reuse.

In addition to Glue and Tile, there are two other fundamental data types: Direction and Position. Direction is an enumeration that defines the four cardinal directions–Top, Right, Bottom, and Left–as well as the Self direction. This enumeration facilitates directional iteration and helps avoid code duplication.

Position stores the x and y coordinates used to define specific locations within the assembly.

The TileAssembly class utilizes the created Tiles to execute simulations. Additionally, it maintains the current growthfront. For this purpose, the changes to the growth front are checked with every assembly or breaking process. In the worst case, this means four checks per process. Checking at each process where another assembly can be connected would always require checks on the size of the assembly. Since new tiles can only attach to this growth front in subsequent steps, tracking it enables efficient simulation updates. Additionally, TileAssembly keeps track of the overall size of the assembly, allowing this information to be accessed without iterating through all individual AssemblyNodes. This improves the efficiency of comparing two assemblies for structural equivalence.

In the initial implementation attempts, the Tiles were stored in a two-dimensional array. However, since assemblies can grow in all four directions, the array had to be continuously resized, which was time-consuming and resulted in the creation of many unnecessary Tiles.

A more critical limitation of arrays is that they do not support negative indexing. This means that if the assembly expands in the negative x or y direction, every access to the array had to be recalculated whenever the array was resized. Managing this overhead in an acceptable runtime proved to be non-trivial, prompting the search for an alternative data structure.

The chosen alternative was a hash map. Hash maps offer fast access times and only require the creation of Tiles that are actually needed. However, TypeScript does not natively support hash maps with compound keys. To address this limitation, a custom data structure called PositionMap was implemented which creates a bidirectional link between a Tile and a Position.

In addition to storing Tiles in the PositionMap, each Tile also contains its own Position. This is necessary to determine the location of a given Tile during access, enabling further computations based on its position. For example, each Tile can directly check how strong its current glue strength is.

The individual simulators for aTAM, kTAM and 2HAM utilize TileAssembly instances in different ways and their simulation follow the definitions of Winfree (Winfree et al., 1998). Both the aTAM and kTAM simulators require only a single TileAssembly, on which they place a seed tile at a designated rootNode. From this seed tile, the assembly is grown. In each time step, Positions are randomly selected from the growthfront until either a suitable tile is found or all elements in the growthfront have been considered. For the selected element, tiles from the tileset are tested sequentially to determine whether one can be placed at that position in a τ -stable manner. If no suitable tile is found, the algorithm proceeds to the next element in the growthfront. Once a valid tile is identified, it is placed, and the step is completed. Due to the random selection of elements from the growthfront, the aTAM process is inherently non-deterministic.

The kTAM operates differently in this regard. When adding a tile, a random Position is selected, and a randomly chosen Tile is placed at that position. Removing a tile presents a greater challenge for the implementation. The basic process involves first removing the Tile, then undoing all changes caused by this Tile. This includes the re-evaluating and recalculating the overall bond strength of the neighboring tiles. However, it is possible that other Tiles are attached to the removed Tile, which may no longer be connected to the assembly after its removal. Thus, whenever a Tile is removed, it is necessary to check which Tiles are still connected to the assembly. This becomes particularly problematic for very large assemblies, as such checks can significantly degrade runtime performance. To address this, each AssemblyNode stores the Tiles that were added to the assembly after it, referred to as its Children. As a result, when a Tile is removed, only these Children need to be checked to ensure they are still connected to the assembly. This reduces the check from all Tiles in the assembly to just the Children, which should typically be much smaller, since Tiles generally fall off before any new Tiles can attach to them.

In contrast, the 2HAM simulator operates on multiple aTAMAssembly instances, attempting to combine them into new aTAMAssembly structures. The merging of two assemblies is done iteratively. Starting from the merge point, the second assembly is iterated through. In each iteration step, the current Tile is inserted into the first assembly. This approach takes longer than directly merging the assemblies at the merge point, but it ensures that all dependencies, such as the growthfront or the neighboring relationships, are correctly set. A direct merge would require iterating through the entire assembly to achieve the same result. To improve runtime, not every assembly is merged with every other assembly in each step. Instead, only the assemblies added in the last step are attempted to be merged with all other assemblies. Furthermore, when creating new assemblies, only truly new assemblies are stored. This means that each new assembly is checked to see if it already exists. In general, this check can be significantly optimized by keeping track of the overall size of an assembly, to reduce the number of possible candidates. The kTHAM uses a combination of 2HAM and kTAM implementation for simulation, which is described in more detail in Section 5.

The latest update of the NetTAS introduces several changes on the layout and graphical user interface. The goal was to increase the usability and make it more expandable for the introduction of future simulation modes. A key aspect of this design is the restructuring of the tileset page where the tile is placed in the middle (see Figure 3). It reduces cognitive load and is minimizing navigation effort (Nielsen, 1994). By placing core elements in an accessible area, the user can interact more intuitively, aligning with established principles of user-centered design (Norman, 2013).

Furthermore, by adding new tabs for the navigation to the different simulation models, switching between them is simple and does not involve switching pages anymore. This leads to a more efficient workflow when working on more complex scenarios and emphasizes the benefits of multi-tabbed interfaces for task efficiency (Cockburn et al., 2003). In addition, the code structure is more optimized for future features and maintainability. These enhancements contribute to an improved user experience and are likely to be advantageous in the future.

In the kTHAM, a finite number of tiles is located in a common medium. Unlike aTAM and kTAM, the restriction to one seed tile is removed. Instead, all tiles and assemblies can freely interact with each other and form bindings, as long as a combination is somewhat realistically possible. This behavior is based on a combination of both the kTAM and the 2HAM.

As the 2HAM has a very high runtime already, we allow for a simulation speed-up by specifying a minimum number of glues that must match, the minimum binding temperature τ min . This simplification is necessary to keep the complexity of the simulation in terms of runtime and memory requirements as low as possible while still allowing for realism if needed. By adjusting parameters, the simulation can be tuned in one or the other way.

Further, at any point in time, individual tiles may disassociate from each assembly and even entire assemblies can break into two pieces. If an assembly is created from different original assemblies, the assemblies into which it breaks are selected at random. This selection is modified by the resulting bonds–an assembly is more likely to break at an unstable position.

The following parameters specify the kTHAM:

A tileset T ,

An example of the state Z i of a kTHAM instance can be seen in Figure 4. Multiple tiles and assemblies coexist and may influence each other, resulting in a large space of possible structures. For engineering/networking purposes, a fixed number of tiles is more beneficial than the assumption of infinitely many.

A state in the kTHAM contains the information how often each tile or assembly occurs in the simulated area. Each assembly has the same probability of being selected to interact with a random assembly in each simulation step. Thus, the probability of selecting an assembly only changes based on its frequency.

In the most general case, the simulation itself does not terminate unless manually stopped. However, it is possible to specify a desired assembly from a prior simulation run that may serve as a “stopping point” for future runs in a loop.

One of the most important results of DNN simulations is the required duration in real time. This section explains how real time is modeled in the kTHAM and how different parameters influence the simulation. As the kTHAM is implemented in parallel to achieve more timely results, this posed an additional challenge.

The estimation of the real-time is based on the work of Winfree (Winfree et al., 1998). The time t is computed by summing up the time that passes between the states Z i and Z i + 1 that mark successive steps of a kTHAM simulation. The time can be described as the reciprocal of the reaction rates r f + r b . These rates can be computed using the parameters k f , G mc , G se of the kTAM as well as the initial amount of tiles per tile type.

The required time can be stated as follows: t ( k ) = ∑ i = 1 k 1 r f i + r r i .

r_f models all possible reactions between available assemblies and tiles C Z given τ min within the state Z and is based on Winfree: r f = ∑ i ∈ C Z i ⋅ 20 k f e − G mc . τ min influences the accuracy of the simulation and can be used to speed up the process in exchange for accuracy. When this parameter is set to 0, all assemblies or tiles may form an assembly even if the resulting structure is very unstable. However, this comes at the expense of simulating errors.

r r models all already computed binding reactions for assemblies in Z . At these points, the assemblies are most likely to break again. All of these assemblies have a binding strength b greater than or equal to τ min , which is part of A C for each assembly in C Z . Based on this, all possible rates for breaking bonds are summed up as: r r = ∑ i ∈ C Z ( i ⋅ ∑ b ∈ A C 20 k f e − b G se ) .

The resulting time of the simulation will be influenced by changing the number of tiles per tile type in the initial state Z 0 . Fewer tiles allow for a faster simulation, and changing τ min to a higher value leads to a faster simulation as well.

For a realistic simulation, the parameters have to be chosen carefully. Not all possible values correspond to suitable values of wet lab experiments. Small changes in the environmental parameters can lead to large changes in the resulting time. Both the relation between the values as well as the absolute values are important. The default values of the simulation correspond to the prior simulations of wet lab experiments in (Rothemund et al., 2004) but may be adjusted if necessary.

Technically, self-assembly systems are computational models and as such, the runtime of the simulation depends on the tileset, which is akin to a program with regular computers. As such, every tileset has to be considered individually as well. For especially bad tilesets, the 2HAM and kTHAM are computationally infeasible and can achieve complexities of up to O ( n n ) .

This can be easily seen by using just two tiles with identical glues that match the temperature threshold and allow for stable possible bindings in all directions. The resulting simulation does not terminate and the number of assemblies that have to be considered at each simulation step can be compared with the faculty function. Yet, the 2HAM and kTHAM are still useful for the small and finite assemblies that suffice for simulating often resource-constrained DNN (Akyildiz et al., 2008).

We still try to give an estimate of the expected complexity of the kTHAM. The kTHAM can be separated into two parts: the start and the execution of simulation steps. The start of the kTHAM is equivalent to the start of the 2HAM, since a separate assembly must be considered for each existing tile/assembly.

A step of the kTHAM is divided into determining whether an assembly breaks down or whether two assemblies or tiles combine. The runtime is the same as with the kTAM and is part of O ( n ) , with n being the size of the assembly. Secondly, a step consists of either combining or breaking assemblies. The breaking can be computed in O ( 1 ) as we only select from the prior components and assembly has been created from.

The combining of two assemblies is realized in O ( 1 ) if and only if this combination has been computed and saved already. Initially, the assembly takes O ( W m ) where W is the size of the growth front and m is the size of the second assembly. Each point on the growth front must be considered to see if it matches each tile from the second assembly. This means that a single kTHAM step requires O ( W m ) steps. However, the total number of required steps cannot be known in advance due to the halting problem and the non-deterministic/random nature of the kTAM and therefore also the kTHAM.

We now demonstrate the correctness of the kTHAM by showing that it is a combination of the kTAM and 2HAM models already validated by Winfree and others. In essence, the kTHAM simulation steps are computed exactly as in the kTAM only that possibly hundreds of assemblies may coexist at the same time and interact with each other. The rules of assembly-interaction are described by the 2HAM and the remaining assembly behavior is guided by the rules of the 2HAM. As such, most assemblies formed by the interaction of two sub-assemblies may also be reached by the kTAM alone. The only exception are assemblies where the binding is based on multiple glues from different parts of the assembly. In such cases, the simulation behaves exactly like the 2HAM with the exception that assemblies created in such a way may also break apart again. However, due to the computational complexity, assemblies may not break apart arbitrarily but only either one tile at a time or at the prior points of interaction between two assemblies.

We further numerically demonstrate the intended behavior by simulating an example molecule in both kTAM and 2HAM and demonstrate that the kTHAM indeed behaves like a combination of both. The chosen molecule can be seen in Figure 5 and includes the tiles of the 4-bit-And molecule (Lau et al., 2019). The molecule only fully assembles in the presence of the four tiles 1–4. Once those are present, a receptor may attach to the assembly and finalize the message molecule.

For the comparison simulation in the kTAM of the ISU TAS, we used the parameters G s e = 10.4 and G m c = 17.0 . Here G mc describes the monomer concentration present and G se the cost of breaking a bond.

Next, the tiles from Figure 6 have also been simulated in the 2HAM of NetTAS. Both the 4-bit-And molecule and a possible message receptor at a nanodevice assemble from the same tileset. We can only model the receptor in the 2HAM, since there is no seed tile specified and many assemblies or tiles assembled in parallel.

Due to the design of the two assemblies, there can only be an interaction between them when they are both completely assembled. There are countless possibilities to create smaller intermediate assemblies. However, the assembly consisting of the 4-bit-And molecule and the receptor is unique.

Both the number of possible assemblies and the resulting assembly correspond exactly to (Lau et al., 2019) where the ISU TAS was used. In the aTAM and 2HAM, the NetTAS can reproduce the results of the ISU TAS for the 4-bit-And molecule.

However, the kTAM simulation results of the 4-bit-And differed greatly from those of the ISU TAS. The reason for this is the probability computation of the add-event from Winfree’s dissertation (Winfree et al., 1998). This is defined as p on = n k f e − G mc and the NetTAS follows exactly this definition (Winfree et al., 1998).

In the ISU TAS, the probability computation is implemented by the usage of an attachmentEvent and an detachmentEvent. Here, the attachmentEvent corresponds to the add-event from Winfree’s dissertation (Winfree et al., 1998) and the detachmentEvent corresponds to the detach-event. The ISU TAS does not implement the constant k f , because it is contained in the add-event and detach-event and may be omitted. In the ISU TAS the value total is added. This changes the computation of an attachmentEvent. In the ISU TAS, the total number of tiles in a given medium grows with the number of specified tile types. In the NetTAS, we fixed the overall concentration of tiles. When more tile types are added, their overall concentration is lowered. In the kTHAM, we simply specify the total amount of tiles of each type and do not assume an infinite supply of a given concentration. While the ISU TAS correctly simulates the first few seconds of a self-assembly process, the NetTAS aims at simulating the interaction of a less well-mixed solution of possibly minutes or hours.

This means that in the ISU TAS kTAM, an assembly with many tiles can also form at lower temperatures, or that assemblies can form more quickly. A simple way to check this change is to duplicate tiles in a tileset. To do this, the tileset from Figure 6 was modified for the 4-bit-And molecule by duplicating every tile except the seed tile. Thus, all tiles remain equally likely but are present more often in the tileset.

With the values G s e = 10 and G m c = 19.8 , the ISU TAS needs over 10,000 binding reactions on average to complete the assembly. If the tileset is increased tenfold, the ISU TAS needs only 3,000 binding reactions to complete the assembly. This leads to differences in the number of binding reactions between the NetTAS and ISU TAS (Winfree et al., 1998). The ISU TAS interpretation is neither better nor worse than the NetTAS interpretation. For DNN, it is just better to fix the overall concentration. Yet, those numbers can be adjusted as wised in the kTHAM.

Overall, the resulting assemblies in the kTAM function of the NetTAS and the ISU TAS are identical except for the differences in the required simulation steps. Further, the resulting intermediate assemblies in the kTHAM are all part of the 2HAM computation as we use the same underlying function for the computation minus possible errors that may occur. As such, the kTHAM performs exactly as expected and provides a combination of both kTAM and 2HAM.

Next to demonstrating the correctness of the assembly, it is also necessary to illustrate that the real-time measured by the NetTAS somewhat correctly reflects the timing of wet lab experiments. In his PhD thesis, Winfree (Winfree, 1998) shows six stages with different assembly sizes and the corresponding assembly durations. Two of these stages are shown in Figures 7a,b. These are used as a basis for comparison the real-time presented in this paper.

Winfree chose the parameters G se = 8 and T = 1.95 (Winfree, 1998) for his wet-lab experiments while (Rothemund et al., 2004) successfully used G se = 10.4 and G mc = 17 . Those values correspond to 32.7 and 41.8 °C respectively. The temperature of the system can be chosen according to the desired assembly speed and the number of errors that may be tolerated (Winfree, 1998). If the temperature is chosen precisely, the number of errors may converge to zero while the speed of the assembly approaches infinity. Winfree further chose r f = 2 / s which corresponds to a forward rate of k f = 600.000 M s ² . We chose τ min = 2 as a default as this allows for a feasible simulation speed.

The NetTAS simulation uses the following parameters:

A forward Rate k f = 600.000 ,

In Figures 7c,d the two stages after 9 and 63 s are shown. Below, in Figures 7e,f, the number of assemblies by size for the corresponding time points is shown as a histogram. The x-axes are limited to 100 and therefore do not show all assemblies of size one. It can be seen that there are many small assemblies.

The computed real-time of the simulation can be compared with the results of Winfree, since he has already carried out a similar simulation with his implementation of the kTAM. It should be noted that the simulations were carried out using different models. Winfree uses the kTAM, while in this work the kTHAM is used. The result of a single simulation is therefore not a single assembly, as with Winfree, but a (multi)set of assemblies. After a 9-s simulation, it can be seen that the largest assembly from the NetTAS kTHAM simulation (Figure 7c) with 85 tiles is significantly larger than the eleven tiles in Winfree’s representation. Due to the high number of assemblies simulated at the same time, the largest assembly is likely always an “outlier” and much bigger in a short time compared to the average.

Most tiles that already have at least one connection to other tiles form assemblies with a size of two to twelve tiles. This conforms to Winfree’s example, which consists of eleven tiles. After 63 s, Winfree’s assembly consists of 490 tiles, while the largest assembly from the NetTAS simulation consists of only 172 tiles. At this point, there is a clear difference between the two simulations. This difference can be explained by the different models, since with kTHAM, the edge tiles are no longer present individually after a certain point and the largest assembly cannot grow any further. None of the initial 500 tiles are available anymore while the ISU TAS and other models still assume an infinite supply of tiles of each type at any given time.

This effect could be mitigated by increasing the initial supply of tiles of chosen tiles. Yet, an additional increase in tiles quickly results in infeasible simulation times as the kTHAM is already quite slow due to the potentially very large number of assemblies simulated at the same time. This is the biggest theoretical disadvantage of kTHAM. Luckily, most proposed medical applications are relatively simple in terms of their computational complexity and the expected computational power of individual nanodevices is so low, that the kTHAM should be able to simulate most realistic scenarios without difficulty. Lau et al. (2017); Akyildiz et al. (2008).

The test further shows that the real-time is not computed entirely accurate with the simplification parameter τ min = 0 – however, it is still pretty close. This is due to the optimization that has been carried out, which parallelizes the computation of the reactions. To avoid this problem and still perform a simulation with τ min = 0 , it is recommended to deactivate parallelization for the simulation with τ min = 0 . The resulting longer computation times must be accepted in this case for the correct calculation of the real-time and, if possible, reduced again by optimizing the implementation. After this change, the real-time must be validated with the corresponding parameters.