\section*{Appendix}

\subsection*{Generic DLA Model}
\label{generic-dla}

The main tool used to generate the data in this report was the generic DLA framework written to support the report. Here we will briefly discuss the process of creating and verifying this framework.

An intrinsic problem of developing computational models for exploratory work is the question of correctness: is some novel result you find a bug in your model, or exactly the interesting new behaviour you set out to explore.

To mitigate this issue the model for this system was created iteratively, with each step being checked against the last where their domains overlap (naturally the newer model is likely to cover a superset of the domain of the old model so there will be some areas where they do not) and unit testing of specific behaviours and verifying expectations\fnmark{unit-test-egs}.

\fntext{unit-test-egs}{Examples that came up in development include: ensuring our uniform random walks are indeed uniform, that they visit all the desired neighbours, etc}

This creates a chain of grounding between one model and the next, where our trust model $N+1$ is grounded in our trust of model $N$ and our unit testing however this trust chain, depends on our trust of $N = 0$, the initially provided code. For this we rely on both the extensive history of the code, and (rough) agreement with literature (see the results section for this comparison).

To this end, starting with the initially provided code we made the minimal alterations necessary such that it would run in reasonable time\fnmark{macos-speed} and output the data required for later analysis.  This was done explicitly with the goal of perturbing the initial code's behaviour as little as possible, including not performing relatively obvious performance improvement that might introduce bugs (the previously mentioned performance improvements were predominantly code removal as opposed to code change). This allowed us to collect the data we needed and ground the initial model in theory.

\fntext{macos-speed}{When running on macOS systems the rendering code slows down the model by several orders of magnitude making it unsuitable for large scale modelling, hence it is removed and replaced with image generation mitigation as discussed later.}

Once rough accordance with literature was obtained (see Figure \ref{nc-fd-convergence}), and most importantly, consistency between runs (verifying against a ill behaved system is a fruitless and painful endeavour), we added the sticking probability alteration as the simplest alteration the DLA algorithm, verifying agreement between the traditional and probabilistic sticking models at $p_{stick} = 1$. See Figure \ref{sp-fd-rust-vs-c} for this comparison.

\begin{figure}[t]
\includegraphics[width=\columnwidth]{figures/sp-fd-rust-vs-c.png}
\caption{A comparison of the reported fractal dimension the probabilistic sticking extension of the Initially Provided Code (IPC + PS) in blue, and the New Framework with probabilistic sticking enabled (NF) in red. We can clearly see a high degree of agreement grounding our new framework and the basic functions of the model.}
\label{sp-fd-rust-vs-c}
\end{figure}


This then provided sufficient data for us to transition to our new generic framework, verifying that it agreed with this dataset to ensure correctness.
 
%TODO Should we reference git commits here? Or keep them all in one repo. Maybe a combo and have them as submodules in a report branch allowing for a linear history and also concurrent presentation for a report.

\subsection*{Auxiliary Programs}

A number of auxiliary programs were also developed to assist in the running and visualisation of the model. Most notably was the image generation tool which allowed for the model to focus on one thing: modelling DLA, separating out generating visualisations of the system. This was used to generate images such as that shown in Figure \ref{dla-eg} which are both useful for presentation, and visual qualitative assessment of model correctness. Additional tools can be found under the tools executable of the rust-codebase.
