LANL Home  |  Phone
 

Sample scripts for resolve

The minimal script for running RESOLVE (on experimental data)

Keywords for running RESOLVE with a different input file

Running RESOLVE with different numbers of cycles or resolution

Running RESOLVE with NCS

Prime-and-switch phasing starting from an MR model

Iterative model-building (starting from solve.mtz, solve_image.mtz or an MR model)and refinement with RESOLVE and refmac5

Density modification using local patterns

Adding HL coefficients to a file

Adjusting origin of phase set to match another phase set

Merging phase sets with different origins

Fitting a loop (with fixed ends)

Fitting flexible ligands to difference electron density maps

The minimal script for running resolve: (Some sample data and input files are located the library directory where SOLVE and RESOLVE are installed, usually located in the directory referred to by $SOLVEDIR/examples_resolve/ )

#!/bin/csh
#
# Here is a minimal script to run resolve:
#
# Set CCP4 variables for symmetry information and
# for file handling:
#
setenv SYMOP /usr/local/lib/solve/symop.lib
setenv SYMINFO /usr/local/lib/solve/syminfo.lib
setenv CCP4_OPEN UNKNOWN
#
# Now run resolve:
#
resolve<<EOD
solvent_content 0.4             ! your solvent content goes here. Next line is your
                                  sequence file
seq_file protein.seq
EOD

RESOLVE assumes "solve.mtz" as input with FP PHIB FOM HLA HLB HLC HLD

Output is "resolve.mtz" with FP PHIM FOMM HLAM HLBM HLCM HLDM  (M is for modified)

You need to tell RESOLVE the solvent content (approximately)

If you want to save time and do not want a model, specify the keyword: no_build

The sequence file for your protein should look like:

MIVLTVHYSSEGILV  [put the sequence of chain type 1 here, up to 80 characters per line]
>>>      [this defines the end of chain 1]
MKLVERWISSTV     [put the sequence of chain type 2 here, up to 80 characters per line]

NOTE: just input 1 copy of each unique chain

Back to Top

Keywords for running RESOLVE with a different input file:

hklin other.mtz
LABIN FP=F PHIB=PHI FOM=W HLA=HLA HLB=HLB HLC=HLC HLD=HLD
hklout resolve.mtz
solvent_content 0.4         ! your solvent content goes here. Next line is your
                              sequence file
seq_file protein.seq

The input file is named with HKLIN

The column names can be specified with the LABIN keyword

The output file can be specified with the HKLOUT keyword.

Back to Top

Running RESOLVE with a different number of cycles or changing resolution:

mask_cycles 4              ! number of cycles of solvent mask generation (default = 5)
minor_cycles 3             ! cycles of iteration for each mask cycle (default = 10)
solvent_content 0.4        ! your solvent content goes here. Next line is your 
                             sequence file
seq_file protein.seq
mask_cycles 4              ! number of cycles of solvent mask generation
resolution 20 3.5          ! You can limit the resolution if you want
 

You might want fewer mask cycles to save time if the phase change in the last cycles is very small.

Alternatively you might want more minor cycles for each mask cycle if the phase change in the last minor cycles of each mask cycle is not very small.

You can limit the resolution if you want. Currently, RESOLVE does not fill in reflections that are not in the input file.  RESOLVE will fill in phase information  for any reflections that it reads in that have a non-zero structure factor amplitude

Back to Top

Running RESOLVE with NCS

You can have RESOLVE identify NCS from atoms in a PDB file:

ha_file ha.pdb

You can also generate an appropriate file for molecular replacement cases by selecting 3 equivalent atoms in each molecule and creating a PDB file with just these 3*N atoms.

In some cases the NCS correlation in the starting map is very low and NCS will be rejected. You can sometimes override this with the keyword

force_ncs which will use NCS even if the correlation is very low. Also if you know the number of NCS operators is 6 you might want to try

ncs_restrict 6

Alternatively, you can enter NCS operators directly to resolve. In this case you also need to enter  an estimate of the center-of-mass of molecule 1.

You need to input N sets of rotation matrices/translations/centers-of-mass, 1 for each copy in the asymmetric unit. Start with the identity for molecule 1.  You can conveniently get all the numbers you need from the CCP4 program lsqkab if you have a model that you are starting with. The rotation/translation matrices and the center-of-mass are all input in a form appropriate for operating on orthogonal Angstrom coordinates (not fractional coordinates).

        rota_matrix  .92  .01  .33       !rotation matrix for molecule j ->molecule 1
        rota_matrix -.01 -.99  .03
        rota_matrix  .05  .10 -.95
        tran_orth    .50  .00 .00        ! translation for molecule j -> molecule 1
        center_orth   25.  39. 44.       !  center of mass, molecule j
        fraction_ncs 0.15                ! fraction of the asymmetric unit in 1 
                                           copy of NCS
                      ! (only needed if it is not equal to (fraction protein)/(number
                         of NCS copies)

If you have more than one type of domain/molecule to use in NCS, then you can specify them separately. Before each new group of NCS relationships, just enter the keyword

new_ncs_group

If you are using multi-domain averaging then it is best if you can specify the maximum extent of the region over which each set of NCS operators is to be applied. You can do this for each ncs group by specifying

ncs_domain_pdb  domain_1.pdb 

where domain_1.pdb has dummy atoms that cover the region of this domain. Only the region within domain_1.pdb that actually has some NCS correlation will be used. You can specify the radius of spheres to be drawn around each of these atoms in constructing the region with the keyword

rad_mask 2.5  

RESOLVE automatically identifies a mask for NCS, but requires an estimate of the center of molecule 1, in orthogonal A units ("center_orth")

 RESOLVE expects rotation matrices ("rota_matrix") and translation vectors ("trans_orth")  in orthogonal Angstrom units that map each of the N molecules onto molecule 1 in the asymmetric unit.  This is the form produced by the CCP4  program lsqkab with xyzin1 (reference)= molecule 1 and xyzin2 (working)= molecule j. If you have transformations that go from molecule 1 to molecule  N, you can specify "invert" to invert the transformations.

Input the matrices first (three lines of "rota_matrix" for each matrix); then the translation vector

Input the identity as the first rotation matrix, with a zero translation vector

For at least the first molecule, you need to enter an estimate of the center of the molecule ("center_orth"). If you enter centers for others, RESOLVE will verify that the centers match the positions expected from the symmetry you input

Back to Top

Prime-and-switch phasing starting from a SIGMAA-weighted map (see also script above starting right from an MR model)

To carry out prime-and-switch phasing starting with a model and SIGMAA phases:  (Sample data and input files are located the library directory where SOLVE and RESOLVE are installed, usually located in the directory referred to by $SOLVEDIR/examples_resolve/ )

1. Run Randy Read's SIGMAA program to get as unbiased a starting map as possible into "sigmaa.mtz"
2. Go to the directory where you ran sigmaa and type (or put in a command file):

#!/bin/csh
# Here is a very minimal script to run prime-and-switch phasing
#
# Set CCP4 variables for symmetry information and
# for file handling:
#
setenv SYMOP /usr/local/lib/solve/symop.lib
setenv SYMINFO /usr/local/lib/solve/syminfo.lib
setenv CCP4_OPEN UNKNOWN
#
# Now run prime-and-switch phasing:
#
resolve<<EOD
hklin sigmaa.mtz
labin FP=FP FC=FC PHIC=PHIC FOM=WCMB FWT=FWT
hklout ps.mtz
solvent_content 0.4             ! your solvent content goes here. Next line is your
                                  sequence file
seq_file protein.seq
prime_and_switch
EOD
#
# Now "ps.mtz" has the output amplitudes, phases,
# figure of merit and HL-coeffs in columns labelled: FP PHIM FOMM HLAM HLBM HLCM HLDM
#

Note:  The least biased map from SIGMAA is FWT exp(i PHIC), so RESOLVE works best starting with FWT from SIGMAA.  However, you can leave out FWT if you wish. You need FP FC PHIC at a minimum.

Output is "resolve.mtz" with FP PHIM FOMM HLAM HLBM HLCM HLDM  (M is for modified)

Back to Top

Iterative model-building with RESOLVE and refmac5

You can carry out model-building and refinement iteratively with RESOLVE and refmac5 .  A script that you can edit and use is resolve_build.csh.  This is convenient for starting with solve.mtz (right from SOLVE)

You can also carry out iterative model-rebuilding (starting from an MR model, for example) with resolve_build.csh.

Back to Top

Adding HL coeffs

You can convert from PHI FOM to PHI FOM HL ABCD in an approximate way with this script:

hklin phases.mtz
labin FP=FP PHIB=PHIB FOM=FOM
scale_refl 0.  ! just use prior phase information
mask_cycles 1
minor_cycles 1
solvent_content 0.5  !any number, not used but needed
no_build
hklout phases_hl.mtz

Back to Top

Adjusting origin to match another phase set

You can apply an offset of the origin for a dataset to match the origin in another phase set. It uses an FFT convolution to find the best allowed offset between the maps calculated with the two phase sets. Unlike merging two phase sets (below) HL coefficients are optional. Note: the FP and SIGFP in the output file will come from the hklin file NOT the hklmerge file.

hklin random_1_hl.mtz   ! File with target map (fixed)
labin FP=FP PHIB=PHIM FOM=FOMM 
hklmerge random_2_hl.mtz  ! File to be offset
labmerge FP=FP PHIB=PHIM FOM=FOMM HLA=HLAM HLB=HLBM HLC=HLCM HLD=HLDM
hkl_offset_file resolve_off.mtz  ! The hklmerge file, offset all by itself

Back to Top

Merging phase sets with different origins

You can merge phase sets with different origins with this script. It uses an FFT convolution to find the best allowed offset between the maps calculated with the two phase sets. Merging the files REQUIRES HL coefficients (see above for generating them if you do not have them). Note: the FP and SIGFP in the output file will come from the hklin file NOT the hklmerge file:

hklin random_1_hl.mtz   ! File with target map (fixed)
labin FP=FP PHIB=PHIM FOM=FOMM HLA=HLAM HLB=HLBM HLC=HLCM HLD=HLDM
hklmerge random_2_hl.mtz  ! File to be offset
labmerge FP=FP PHIB=PHIM FOM=FOMM HLA=HLAM HLB=HLBM HLC=HLCM HLD=HLDM
hkl_offset_file resolve_off.mtz  ! The hklmerge file, offset all by itself
hkl_merge_file resolve_merge.mtz  ! The hklmerge file offset, then merged with hklin

Back to Top

Fitting a loop (with fixed ends)

You can now fit a loop if you know the ends. Put the two amino acids before the loop and the two after the loop in a pdb file (loop_ends.pdb) and put all the rest of your model in another PDB file (all_but_loops.pdb) that will be used as a mask to prevent building where your model exists. Then run the script below, specifying the number of residues in the loop, including the 2 on each end that you are supplying.

hklin resolve.mtz
labin FP=FP PHIB=PHIM FOM=FOMM
pdb_in loop_ends.pdb     ! Just 2 residues at beginning of loop, 2 at end.
seq_file seq.dat
extend_only
loop_only                ! just fit the loop
model all_but_loop.pdb
build_outside_model      ! don't build in region defined by model
no_sub_segments          ! fit the whole loop to sequence, not parts
n_random_loop 20
loop_length 8            ! exact length of loop, including ends in pdb_in
                         ! you can leave it out if unknown
rms_random_loop 0.3      ! how much to vary each try of building the loop
EOD

Back to Top

Fitting flexible ligands to difference electron density maps

You can fit a flexible ligand into a difference electron density map.

You have two choices of input for the ligand. You can either input a single copy (preferred method) and the program will guess acceptable configurations, or you can make about 10 copies of the ligand in different allowed conformations and put them all into a one PDB file.

In either case, RESOLVE will identify the rigid parts of the molecule and all allowed relationships between them from this group of structures. It will then build the ligand into the electron density map. See the list of RESOLVE keywords for additional options (i.e., delta_phi_ligand...)

hklin difference_density.mtz   ! File with map
labin FP=FP PHIB=PHIM FOM=FOMM
ligand_file ligand_in_1_or_10_conformations.pdb

That's it. RESOLVE will fit the ligand into the density and write it out to "ligand_fit.pdb" along with an analysis of the fit.

If you want to input an experimental map and a model for most of the structure you can add the keyword model:

model protein_model.pdb 

and RESOLVE will subtract off the density from the model and just fit the remaining (ligand) density.

For more information on ligand fitting, see the introduction in ligand fitting.

A script you can edit is resolve_ligand_fit.com.

To score many ligands against your map, use resolve_ligand_id.com.

If you want to calculate a map with difference density for the ligand, then use resolve_difference script. This script starts with an mtz file containing native amplitudes (FP) and a PDB file containing a model for the structure without the ligand and calculates a simple difference map. You can also use any other suitable program to calculate this map. The output file resolve_diff.mtz (with FP PHIM FOMM) can then be used for ligand fitting with resolve_ligand_fit.com (for fitting one type of ligand), resolve_ligand_id.com (for testing a list of ligands), or a simple script like:

hklin resolve_map.mtz   ! File with map
labin FP=FP PHIB=PHIM FOM=FOMM
ligand_file ligand_in_1_or_10_conformations.pdb
model protein_model.pdb 

If the ligand-fitting routine does not fit your ligand well, there are some options to get it to try harder:

You can tell RESOLVE to screen more potential locations of fragments in the FFT convolution search (default=300) with:

n_ligand_pos 400   

You can tell RESOLVE to refine more potential locations of fragments in the FFT convolution search (default=100) with:

n_ligand_pos_ref 200   

You can tell RESOLVE to search more finely for potential locations of fragments in the FFT convolution search (default=40 degrees) with:

 delta_phi_ligand 20   

You can tell RESOLVE to keep track of more placements (default=100) of partially-built ligands with:

n_keep_plac 200   

Resolve will always take all the refined placements of fragments as a group and try to build from them, keeping the top n_keep_plac all the time. Resolve also tries one at a time if n_indiv_tries_min > 0. You can tell RESOLVE to try to build starting with more individual placements (defaults min:0, max:5) of each sub-fragment with:

n_indiv_tries_min 20   
n_indiv_tries_max 20   

You can tell RESOLVE to try more sub-fragments as possible starting points for ligand building with:

n_group_search 10   

You can center the search at a desired position (A) with:

search_center  3 25 6   

Back to Top

Disclaimer

Operated by Los Alamos National Security, LLC for the U.S. Department of Energy's NNSA

Inside | © Copyright 2006 Los Alamos National Security, LLC All rights reserved | Disclaimer/Privacy | Web Contact