Provided by: vienna-rna_2.5.1+dfsg-1_amd64 bug

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

       Christoph Flamm <xtof@tbi.univie.ac.at>
       Ivo Hofacker <ivo@tbi.univie.ac.at>

SEE ALSO

       The Vienna RNA package http://www.tbi.univie.ac.at/~ivo/RNA