Tinkergpu:Development-rna

From tinkergpu
Jump to: navigation, search

Download and Install

Download (2017)

This page is for coarse-grained RNA model RACER that we have developed to model and simulate RNA molecules and predict RNA structures.

The simulation program is based on Tinker (in Fortran), and is available free of charge from

http://biomol.bme.utexas.edu/~rnacg/RNACG

or a compressed tarball without *.x and *.o file (compilation is needed)

http://biomol.bme.utexas.edu/~davbell/RNACG.tgz


Compiling RACER Using Intel compilers

  • You can use intel mkl library (change link.make below). Or compile FFTW yourself; assuming your top directory is Tinker (or RNACG if from above)
  • Execute commands after "$" on the command

1. Source intel compilers 

$/opt/intel/bin/compilervars.sh intel64

2. Change directories into the fftw folder and read 0README

$ cd Tinker/fftw/

$ vi 0README

3. Set "CC" and "F77" to icc and ifort, and compile fftw libraries

$ CC=icc F77=ifort ./configure --prefix=$PWD --enable-threads

$ make -j 6

$make install

New libraries should be produced in fftw/lib folder. This will be used by link.make below.

4. Copy makefiles for intel compilers (compile.make, library.make, and link.make) from linux/intel/ folder

$ cd ../source

$ cp ../linux/intel/*make .

5. Compile source code

$ ./compile.make 

$ ./library.make

$ ./link.make 

  • Note that the link.make will use the fftw/lib/*.a from above



03/04/19 updates by Sara Cheng

  • (03/04/19) Updated for GNU compiler: make files in "linux/gfortran/" (missing kcghbonds.f), initial.f  in "source/"(comment out intel related lines), and "linux/gfortrant/0README" for compiling with gcc compilers
  • Modified ecghbond1.f available in /RNACG_updated_03_04_19 (see detailed changes below,)
    • Changed all "-1*" to "-1.0d0*"
    • line number (previous code "c ... " modified code in bold)

293 c &                          ((-1*zicb*ry + yicb*rz)/(rip*rhbond)

294      &                          ((yicb*rz - zicb*ry)/(rip*rhbond)

295 c     &                          - doti*(yip*-1*zicb + zip*yicb)/

296      &                          - doti*(zip*yicb -  yip*zicb)/

305 c     &                          ((-1*yicb*rx + xicb*ry)/(rip*rhbond)

306      &                          ((xicb*ry - yicb*rx)/(rip*rhbond))

357 c     &                          ((-1*ziab*rx + xiab*rz)/(rip*rhbond)

358      &                          ((xiab*rz - ziab*rx)/(rip*rhbond)

370 c     &                          ((-1*zjcb*ry + yjcb*rz)/(rjp*rhbond)

371 c     &                          - dotj*(-1*yjp*zjcb + zjp*yjcb)/

372      &                          ((yjcb*rz - zjcb*ry)/(rjp*rhbond)

373      &                          - dotj*(zjp*yjcb - yjp*zjcb)/

382 c     &                          ((-1*yjcb*rx + xjcb*ry)/(rjp*rhbond)

383 c     &                          - dotj*(-1*xjp*yjcb + yjp*xjcb)/

384      &                          ((xjcb*ry - yjcb*rx)/(rjp*rhbond)

385      &                          - dotj*(yjp*xjcb - xjp*yjcb)/

389 c     &                          (((-1*xjp + (zjcb-zjab)*ry + 

390      &                          (((-1*xjp + (zjcb-zjab)*ry +

395 c     &                          (rjp * rhbond**3))) + dangledcosinei *

396      &                          (rjp * rhbond**3))) - dangledcosinei *

397 c     &                          ((-1*xip/(rip*rhbond)) + (doti * rx/ 

398      &                          ((xip/(rip*rhbond)) + (doti * rx/   

407 c     &                          (rjp * rhbond**3))) + dangledcosinei *

408 c     &                          ((-1*yip/(rip*rhbond)) + (doti * ry/

409      &                          (rjp * rhbond**3))) - dangledcosinei *

410      &                          ((yip/(rip*rhbond)) + (doti * ry/

419 c     &                          (rjp * rhbond**3))) + dangledcosinei *

420 c     &                          ((-1*zip/(rip*rhbond)) + (doti * rz/

421      &                          (rjp * rhbond**3))) - dangledcosinei *

422      &                          ((zip/(rip*rhbond)) + (doti * rz/

432 c     &                          ((-1*zjab*rx + xjab*rz)/(rjp*rhbond)

433 c     &                          - dotj*(-1*xjp*zjab + zjp*xjab)/

434      &                          ((xjab*rz - zjab*rx)/(rjp*rhbond)

435      &                          - dotj*(zjp*xjab - xjp*zjab)/

  • The code has been sucessfully compiled using intel (v13) and GNU Compilers (gcc version 4.4.7)

[http://biomol.bme.utexas.edu/~syc384/RNACG_updated_03_04_19]

(03/04/19) Tarball of 03/04/19 code available for download 

[http://biomol.bme.utexas.edu/~syc384/RNACG_updated_03_04_19.tar.gz]

For questions about compiling RACER code, please contact Sara Cheng at sara.y.cheng@utexas.edu

Please include compiler versions and error logs in your email.

Compiling RACER Using GNU compilers

  • Comilping instruction for GNU is the same as above except 
    • Read "linux/gfortran/0README"
    • Modify initial.f (read the header in that file); The file from below downloads should be modified for GNU already. If you wnat to use the intel compiler, reverse the changes (please check either way).
    • Compile fftw/ using GNU
    • Copy make files from "linux/gfortran/" to "source/" and run make, library and link.make
  • You can use intel mkl library (change link.make below). Or compile FFTW yourself; assuming your top directory is Tinker (or RNACG if from above)
  • Execute commands after "$" on the command

1. Change directories into the fftw folder and read 0README

$ cd Tinker/fftw/

$ vi 0README

3. Compile and Install fftw libraries

'$ '/configure --prefix=$PWD --enable-threads

$ make -j 6

$make install

New libraries should be produced in fftw/lib folder. This will be used by link.make below.

4. Copy makefiles for intel compilers (compile.make, library.make, and link.make) from linux/gfortran/ folder

$ cd ../source

$ cp ../linux/gfortran/*make .

5. Compile source code

$ ./compile.make 

$ ./library.make

$ ./link.make 

  • Note that the link.make will use the fftw/lib/*.a from above

Parameters

Most recent set of parameters is located in http://biomol.bme.utexas.edu/~davbell/RNACG/RNA_CG.prm

Key files for annealing simulations http://biomol.bme.utexas.edu/~davbell/RNACG/key_annealing/



Conversion scripts

Located in directory https://biomol.bme.utexas.edu/~rnacg/RNACG/conversion_scripts/ 

(older ver) http://biomol.bme.utexas.edu/~davbell/RNACG/conversion_scripts

  1. mapping_atocg.py (converts all-atom pdb to coarse-grained pdb)
  2. Run tinker "pdbxyz" to convert the CG pdb to CG xyz file
  3. xyz2cg_xyz.py (adds tinker atom connections to xyz file)*
  4. cg_xyz2aa_pdb.py (converts coarse-grained xyz file back to all-atom pdb; must minimize to properly position all atoms)
  • 07/25/17 updated xyz2cg_xyz.py (xyz2cg_xyz_v2.py) see conversion scripts folder and 07_25_17 readme
  • 12/12/2019 racerize.py converts atomic pdb to CG pdb/xyz with connections
racerize.py -i inp.pdb -o out.pdb
racerize.py -i inp.pdb -oxyz out.xyz

See tutorials for more information.

To visualize the CG pdb in pymol, you need add the CONET records if missing, and then 

set connect_mode, 1
set stick_radius=0.3
set sphere_scale, 0.5
show sticks

To creat a bond between any two atoms in Pymol:

bond id 1, id 11

 

Conversion of protein for visualization

  • Convert all atom to CG using martinize.py link
  • Generate pdb with connectivity using .top and .pdb files.
martinize.py -f inp.pdb -o cg.top -x cg.pdb
itp_to_conect.py -i cg.pdb -p cg.top -o out.pdb

 

  • Tool for reconstructing all-atom coordinates from alpha Carbon. pulchra

As of version 306, only convert the first chain in a pdb file. Need to split into one file for each chain, convert and then combine.

Modify Source Code

All potential routines in TINKER can be found in e***.f files in the source code. For instance, Lennard Jones potential is found in elj.f. Files e**.f and e***3.f only include potential energy computations: e***3.f is computed from the analyze command while e***.f is run for other processes. The force (gradient of the potential) can be found in e**1.f files (1st derivative) which are used in MD. e**2.f files contain the second derivative for computation of the Hessian for certain calculations.

To run MD, analyze, minimize, or run annealing, you need to write e***.f, e**1.f, and e**3.f files. You also need to write a k***.f file (e.g. kvdw.f) if you need to assign parameters from entries read in the key file. You need to add your potential calling and value to the analysis.f, energy.f, and gradient.f subroutines. The parameters you will read into the key file need to be added in the prmkey.f subroutine. You may also need to define global parameters in modules such as kvdws.f.

Once you have modified the appropriate files, be sure to add the correct lines in the compilation scripts ./compile.make (all files), ./library.make (all files), ./link.make (only executable files). Then you can compile and test your new potential with testgrad.x. If you modify again, you need to re-compile only those files with dependencies (e.g. elj.f, gradient.f, and testgrad.f if modifying LJ potential elj.f)

 

Tutorials

For user tutorials, see the link on the left panel or click here Tinkergpu:Tutorials-rna

Citation

Bell, D. R., et al. (2017). "Capturing RNA Folding Free Energy with Coarse-Grained Molecular Dynamics Simulations." Sci Rep 7: 45812.