These are routines for constructing protein geometry. Protein bond lengths and simple angles are, to a first approximation, conserved. However the dihedral or torsion angles rotate, allowing the protein to fold up into its native structure. When dealing with protein geometry in computer programs, therefore, a normal strategy is to manipulate the protein in torsion space, and then convert to Cartesian space for final calcualtions and output.

The backbone can be defined by psi, phi, and omega angles.

The omega bond is partly double in character and thus almost planar - allowed angles are 0 (cis) and 180 degrees (trans). With the exception of Proline, virtually all residues are in the trans conformation. The psi and phi angles are restricted to certain regions of space due to steric collisions. These were first plotted by Ramachandran, and the Ramachandran plot is named in his honour. With the exceptions of glycine and proline the angles are constrained to lie in three regions of the plot.

Protein side chains have up to four torsional degrees of freedom, called chi angles. Again bond lengths and simple angles are conserved.

I have included three functions, one for generating the backbone, one for placing side chains given a full set of chi angles, and one for placing side chains given a "rotamer", or one of three fairly likely orientations.

/*
place a protein backbone given a set of phi, psi, and omega angles
Params: vnh - return for hydrogen (H)
vn - return for nitrogen (N)
va - return for carbon alpha (CA)
vc - return for carbon (C)
vo - return for oxygen (O)
vb - return fro carbon beta (CB)
phi - phi torsion angles (radians)
psi - psi torsion angles (radians)
omega - omega torsion angles (radians, usually 0 or PI)
N - number of residues
*/
void backbonef(float *vnh, float *vn, float *va, float *vc, float *vo, float *vb, float *phi, float *psi, float *omega, int N )

This is the call to generate the backbone. The hydrogen on the nitogogen, carbon alpha, carbon, oxygen and carbon beta are returned in the intial arguments, the phi, psi and omega torsion angles passed in.

Note that there are some difficulties in holding peptides in torsion space. Because of the nature of the chain, a small error in a torsion angle in one part of the chain can translate to a large error in Carestian co-ordinates many bonds further down. Then the routine assumes ideal bond lengths and angles, which is not always the case for real structures.

You may wish to rewrite this routine to use double precison numbers for some purposes.

` `
/*
place an amino acid side chain given chi angles
Params: atoms - return for heavy atoms (PDB order)
aa - amino acid one letter code
N - nitrogen (input)
CA - carbon alpha (input)
CB - carbon beta (input)
chi - up to four chi angles, radinas, trans = PI
*/
void putchi(float *atoms, char aa, float *N, float *CA, float *CB, float *chi)

This is the basic chi-placement call. All bond lengths and angles are hard-coded.
The return atoms are in PDB order, that is proximal atoms first beginning with the corrected
carbon beta, and more distnat ones next. Where the chain branches the lighter chain has the
lower number.
Note that the side chains are relatively short and do not suffer from the same problems as the backbone routines.

` `
/*
place a rotamer given backbone atoms
Parmas: atoms - return for heavy atoms
aa - amino acid one letter code
N - nitrogen
CA - carbon alpha
CB - carbon beta
rot - rotamer (1-3)
*/
void putrotamer(float *atoms, char aa, float *N, float *CA, float *CB, int rot)

This routine is an interface to put chi that uses pre-defined chi angles for you.
The rotamers are numbered one to three. This is a convenience if you want reasonable
angles and don't need to work out the sidechain position accurately.