#!/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
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.
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
You can have RESOLVE identify NCS from atoms in a PDB file:
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
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
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
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
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
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)
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.
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
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
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
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
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:
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:
You can tell RESOLVE to refine more potential locations of fragments in the FFT convolution search (default=100) with:
You can tell RESOLVE to search more finely for potential locations of fragments in the FFT convolution search (default=40 degrees) with:
You can tell RESOLVE to keep track of more placements (default=100) of partially-built ligands with:
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:
You can tell RESOLVE to try more sub-fragments as possible starting points for ligand building with:
You can center the search at a desired position (A) with:
search_center 3 25 6