Ubuntu Manpage: Kinfold - Simulate kinetic folding of RNA secondary structures

Provided by: vienna-rna_2.5.1+dfsg-1build3_amd64

NAME

       Kinfold - Simulate kinetic folding of RNA secondary structures

SYNTAX

       Kinfold [OPTIONS] < input

DESCRIPTION

       The  program   Kinfold   simulates  the  stochastic  folding  kinetics  of  RNA  sequences into secondary
       structures. Folding trajectories are simulated using a Monte Carlo procedure  using  the  formation,  and
       dissociation  of  individual  base pairs, and (optionally) the shifting of individual base pairs. For the
       energy evaluation of RNA secondary structures  Kinfold  uses routines from the  Vienna RNA Package.
       Input is read from stdin and consists of an RNA sequence, optionally followed by  the  initial  structure
       and one or more stop structures in dot-bracket notation.
       Output  consists of trajecotires (written to stdout) as well as a log file containing summary information
       for each trajectory.

OPTIONS

Move set options

--noShift
turn of shift moves.

--noLP forbid structures containing isolated base-pairs

Simulation options

--num Number of trajectories to compute (default=1).

--time<tmax>
Set maximum length of folding trajectory. The default (500) is very short and meant for testing
purposes only.

--grow <rate>
Simulate folding during transcription with a chain growth event taking place every rate
timesteps.

--glen <len>
Start a folding during transcription simulation with an inital chain length of len.

--fpt Toggles between first passage time calculations that end as soon a stop struicture is reached and
open-ended simulations. Since the default is "first passage time", i.e. using the --fpt switches
to open ended simulation.

--start
Read a start conformation from stdin, otherwise the open chain is used as start structures.

--stop Read one or more stop structures from stdin, otherwise the MFE structure is used.

--met Use the Metropolis rule for rate between two neighboring conformations, i.e. k=min{1,exp(-dE/RT)}.
By default Kinfold uses the symmetric Kawasaki rule k=exp(-dE/2RT).

--seed<string>
Specify the random number seed for the simulation. The seed string consists of three numbers
separated by an equal sign, e.g. 123=456=789. If no seed is specified it is derived from the
system clock at program start.

Output options

-v or --verbose
Print more information to stdout.

-q or --silent
Do not write trajectories to stdout.

--lmin Don't print complete trajectory, but only local minimas encountered.

--cut<energy>
Print only those parts of the trajectory that stays below energy.

--log<file>
Set the log file to file.log. Default "kinout".

Energy model see e.g. the Vienna RNA documentation for details

--dangles<int>
Select dangling end model. Possible values "0" (none), "1" (normal), "2" (simplified)

--T, --Temp<temp>
Set simulation temperature to temp degrees centigrade.

-P, --Par <filename>
read energy-parameters from filename.

--logML
use logarithmic multiloop energies instead of linear. Default is on, i.e. using --logML switches
log energies off.

Generic options

--help Output help information and exit.

--version
Output version information and exit.

EXAMPLES

       default  mode:  Start structure is open chain, stop structure is MFE structure.  The example output below
       is a possible trajectory for the sequence ACUGAUCGUAGUCAC.

          Kinfold --time 100000 < seq.in
          ...............   0.00      2.660
          ....(......)...   4.80      2.664
          ...((......))..   0.70      2.760
          ..(((......))).   0.20      3.407
          ..((((....)))).  -0.60      3.579 X1

       The trajectory lists stucture, energy, and time for each simulation  step.  The  X1  signifies  that  the
       trajectory  terminated  in  the  first  stop structure.  In addition the logfile kinout.log would contain
       information needed to reproduce the simulation results such as options and random seeds used.

          #Date: Tue Oct  7 10:24:27 2008
          #EnergyModel: dangle=2 Temp=37.0 logML=logarithmic Par=(null)
          #MoveSet: noShift=off noLP=off
          #Simulation: num=2 time=500.00 seed=clock fpt=on mc=Kawasaki
          #Simulation: phi=1 pbounds=0.1 0.1 2
          #Output: log=kinout silent=off lmin=off cut=20.00
          #ACUGAUCGUAGUCAC
          #............... (  0.00)
          #..((((....)))). ( -0.60) X01
          (20773  2191 29311) X01        3.579
          ( 7439 25635 52414)

       Note that all times are given in internal units that can be translated into real time only by copmparison
       with experiment. Very roughly one time step corresponds to about 1e-7 seconds.

       To run a folding during transcription simulation use the --grow option. Assuming a transcription rate  of
       100 nt/sec and 1 sec about 1e7 time steps we could use

          Kinfold --grow 100000 --glen 10 < seq.in

AUTHORS