SsDNA Kuhn length

In this example we will compute the Kuhn length strand of ssDNA with two different lengths: 10 and 30 nucleotides. Given the simplicity of the system, the computation required is of the order on one hour to get very accurate results.

Since ssDNA has stacked and unstacked regions, in constant evolution, the usual definition of persistence length as a function of the correlation function between segments is not directly applicable. Instead, we resort (see Ref. 2) to a more general property, which is the Kuhn length defined as:

k = <L * L> / L_max

where L is the end to end vector of the strand and L_max is the maximum length of the polymer. Brackets indicate thermal average. Since our ssDNA is not a rigid polymer, we use as a proxy of the maximum length the average distance between nucleotides times the number of covalent bonds along the backbone.

For this simulations, we will use Brownian Dynamics with the usual values for the [[Thermostat|thermostat]. We'll run the simulations at room temperature, and we will use poly-A sequence with the average parametrisation of the model. We use nucleotides that are all the same to avoid the formation of secondary structure that could affect the end-to-end distance. With the sequence-independent parametrisation, a poly-X sequence is for all intents and purposes the same as any sequence that does not form secondary structure.

The directories 30B and 10B inside EXAMPLES/SSDNA/ are ready to run the simulations of the 10-base and 30-base ssDNA, respectively.

The files relative to this example are in the directory ${oxDNA}/EXAMPLES/SSDNAKUHNLENGTH/.

10-base ssDNA Kuhn length

We start by creating a sequence file to generate the initial confiugration. We just need to put 30 A's in a file which we'll call seq.txt

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

and then generate the initial configuration with

${OXDNA}/UTILS/generate-sa.py 20. seq.txt

which generates generated.top and generated.dat. We can use any standart input file for dynamics with the temperature set to 23C, which we will call input. We store configurations every 50000 steps, which should produce almost independent values for the end-to-end distance with the standart thermostat settings. Of course this is cannot be known a priori, but we know this since we have ran this simulation before.

The end-to-end distance of ssDNA, which is the relevant parameter to monitor for measuring the Kuhn length, has very large fluctuations in our model. A large number of values is thus needed to have a reliable average; we store 2000 configurations, thus we use a total number of steps of 50 000 * 2 000 = 100 000 000.

The subdirectory 10B contains a working sequence and input file ready to be run.

The next step is to generate the trajectory by running the program on the input file.

${OXDNA}/Release/oxDNA input

Let's now discuss the analysis script sspl.py that will extract the kuhn length from the trajectory. The core of the program is as follows:

line = conffile.readline ()
line = conffile.readline ()
line = conffile.readline ()
line = conffile.readline ()
while line:
    # end 2 end
    r1 = [float(x) for x in line.split()[0:3]]
    a1 = [float(x) for x in line.split()[3:6]]
    line = conffile.readline ()

    r2 = [float(x) for x in line.split()[0:3]]
    a2 = [float(x) for x in line.split()[3:6]]
    
    b1 = [r1[i] - 0.4 * a1[i] for i in xrange(3)]
    b2 = [r2[i] - 0.4 * a2[i] for i in xrange(3)]
    
    for i in xrange (nnucl - 2):
        line = conffile.readline()

    rN = [float(x) for x in line.split()[0:3]]
    aN = [float(x) for x in line.split()[3:6]]
    bN = [rN[i] - 0.4 * aN[i] for i in xrange(3)]
    
    for i in xrange (4):
        line = conffile.readline()

    r1N = [rN[i] - r1[i] for i in xrange(3)]
    r12 = [r2[i] - r1[i] for i in xrange(3)]
    b1N = [bN[i] - b1[i] for i in xrange(3)]
    b12 = [b2[i] - b1[i] for i in xrange(3)]
    
    niter += 1

Ll0 /= float (niter)
L2 /= float (niter)
l0 /= float (niter)

Kl = L2 / ((nnucl -1) * l0)

print "Kuhn length: ", Kl 

We read the position of the first, second and last nucleotide in the system, skipping all other lines, and compute the thermal average of L * L and l_0. All distances are computed relative to backbone sites, which are 0.4 simulation units away from the centres along the principal axis of the molecule as described in Documentation. The script produces a file called end2end.dat with the time series of the end-to-end distance, which can be used to check for good statistics.

At the end, we use those the averages to compute the Kuhn length of the strand.

The result coming out should be around 1.9 simulation length units, which translates to 1.6nm.

30-Base ssDNA

All the steps above can be repeated specifying a longer sequence in the seq.txt file. The subdirectory 30B contains a working sequence and input file ready to be run. Note that we expect a threefold increase in simulation time due to the system being three times as large. We can use the same python script to analyse the trajectory; the Kuhn length should come out as roughly 2.9 simulation units.