int kabsch_sander(const float* xyz, const int* nco_indices, const int* ca_indices,
const int n_frames, const int n_atoms, const int n_residues,
int* hbonds, float* henergies) {
/* Find all of backbone hydrogen bonds between residues in each frame of a
trajectory.
Parameters
----------
xyz : array, shape=(n_frames, n_atoms, 3)
The cartesian coordinates of all of the atoms in each frame.
nco_indices : array, shape=(n_residues, 3)
The indices of the backbone N, C, and O atoms for each residue.
ca_indices : array, shape=(n_residues,)
The index of the CA atom of each residue. If a residue does not contain
a CA atom, or you want to skip the residue for another reason, the
value should be -1
Returns
-------
hbonds : array, shape=(n_frames, n_residues, 2)
This is a little tricky, so bear with me. This array gives the indices
of the residues that each backbone hbond *acceptor* is engaged in an hbond
with. For instance, the equality `bonds[i, j, 0] == k` is interpreted as
"in frame i, residue j is accepting its first hydrogen bond from residue
k". `bonds[i, j, 1] == k` means that residue j is accepting its second
hydrogen bond from residue k. A negative value indicates that no such
hbond exists.
henergies : array, shape=(n_frames, n_residues, 2)
The semantics of this array run parallel to the hbonds array, but
instead of giving the identity of the interaction partner, it gives
the energy of the hbond. Only hbonds with energy below -0.5 kcal/mol
are recorded.
*/
int i, ri, rj;
static float HBOND_ENERGY_CUTOFF = -0.5;
__m128 ri_ca, rj_ca, r12;
__m128 MINIMAL_CA_DISTANCE2 = _mm_set1_ps(0.81);
float* hcoords = (float*) malloc(n_residues*3 * sizeof(float));
if (hcoords == NULL) {
fprintf(stderr, "Memory Error\n");
exit(1);
}
for (i = 0; i < n_frames; i++) {
ks_assign_hydrogens(xyz, nco_indices, n_residues, hcoords);
for (ri = 0; ri < n_residues; ri++) {
// -1 is used to indicate that this residue lacks a this atom type
// so just skip it
if (ca_indices[ri] == -1) continue;
ri_ca = load_float3(xyz + 3*ca_indices[ri]);
for (rj = ri + 1; rj < n_residues; rj++) {
if (ca_indices[rj] == -1) continue;
rj_ca = load_float3(xyz + 3*ca_indices[rj]);
// check the ca distance before proceding
r12 = _mm_sub_ps(ri_ca, rj_ca);
if(_mm_extract_epi16(CAST__M128I(_mm_cmplt_ps(_mm_dp_ps(r12, r12, 0x7F), MINIMAL_CA_DISTANCE2)), 0)) {
float e = ks_donor_acceptor(xyz, hcoords, nco_indices, ri, rj);
if (e < HBOND_ENERGY_CUTOFF)
// hbond from donor=ri to acceptor=rj
store_energies(hbonds, henergies, ri, rj, e);
if (rj != ri + 1) {
float e = ks_donor_acceptor(xyz, hcoords, nco_indices, rj, ri);
if (e < HBOND_ENERGY_CUTOFF)
// hbond from donor=rj to acceptor=ri
store_energies(hbonds, henergies, rj, ri, e);
}
}
}
}
xyz += n_atoms*3; // advance to the next frame
hbonds += n_residues*2;
henergies += n_residues*2;
}
free(hcoords);
return 1;
}
static void asa_frame(const float* frame, const int n_atoms, const float* atom_radii,
const float* sphere_points, const int n_sphere_points,
int* neighbor_indices, float* centered_sphere_points, float* areas)
{
/*// Calculate the accessible surface area of each atom in a single snapshot
//
// Parameters
// ----------
// frame : 2d array, shape=[n_atoms, 3]
// The coordinates of the nuclei
// n_atoms : int
// the major axis length of frame
// atom_radii : 1d array, shape=[n_atoms]
// the van der waals radii of the atoms PLUS the probe radius
// sphere_points : 2d array, shape=[n_sphere_points, 3]
// a bunch of uniformly distributed points on a sphere
// n_sphere_points : int
// the number of sphere points
// centered_sphere_points : WORK BUFFER 2d array, shape=[n_sphere_points, 3]
// empty memory that intermediate calculations can be stored in
// neighbor_indices : WORK BUFFER 2d array, shape=[n_atoms]
// empty memory that intermediate calculations can be stored in
// NOTE: the point of these work buffers is that if we want to call
// this function repreatedly, its more efficient not to keep re-mallocing
// these work buffers, but instead just reuse them.
// areas : 1d array, shape=[n_atoms]
// the output buffer to place the results in -- the surface area of each
// atom
*/
int i, j, k, k_prime;
__m128 r, r_i, r_j, r_ij, atom_radius_i, atom_radius_j, radius_cutoff;
__m128 radius_cutoff2, sp, r_jk, r2;
int n_neighbor_indices, is_accessible, k_closest_neighbor;
float constant = 4.0 * M_PI / n_sphere_points;
for (i = 0; i < n_atoms; i++) {
atom_radius_i = _mm_set1_ps(atom_radii[i]);
r_i = load_float3(frame+i*3);
/* Get all the atoms close to atom `i` */
n_neighbor_indices = 0;
for (j = 0; j < n_atoms; j++) {
if (i == j) {
continue;
}
r_j = load_float3(frame+j*3);
r_ij = _mm_sub_ps(r_i, r_j);
atom_radius_j = _mm_set1_ps(atom_radii[j]);
/* Look for atoms `j` that are nearby atom `i` */
radius_cutoff = _mm_add_ps(atom_radius_i, atom_radius_j);
radius_cutoff2 = _mm_mul_ps(radius_cutoff, radius_cutoff);
r2 = _mm_dp_ps(r_ij, r_ij, 0x7F);
if (_mm_extract_epi16(CAST__M128I(_mm_cmplt_ps(r2, radius_cutoff2)), 0)) {
neighbor_indices[n_neighbor_indices] = j;
n_neighbor_indices++;
}
if (_mm_extract_epi16(CAST__M128I(_mm_cmplt_ps(r2, _mm_set1_ps(1e-10))), 0)) {
printf("ERROR: THIS CODE IS KNOWN TO FAIL WHEN ATOMS ARE VIRTUALLY");
printf("ON TOP OF ONE ANOTHER. YOU SUPPLIED TWO ATOMS %f", _mm_cvtss_f32(r));
printf("APART. QUITTING NOW");
exit(1);
}
}
/* Center the sphere points on atom i */
for (j = 0; j < n_sphere_points; j++) {
sp = _mm_add_ps(r_i, _mm_mul_ps(atom_radius_i, load_float3(sphere_points + 3*j)));
store_float3(centered_sphere_points + 3*j, sp);
}
/* Check if each of these points is accessible */
k_closest_neighbor = 0;
for (j = 0; j < n_sphere_points; j++) {
is_accessible = 1;
r_j = load_float3(centered_sphere_points + 3*j);
/* iterate through the sphere points by cycling through them */
/* in a circle, starting with k_closest_neighbor and then wrapping */
/* around */
for (k = k_closest_neighbor; k < n_neighbor_indices + k_closest_neighbor; k++) {
k_prime = k % n_neighbor_indices;
r = _mm_set1_ps(atom_radii[neighbor_indices[k_prime]]);
r_jk = _mm_sub_ps(r_j, load_float3(frame+3*neighbor_indices[k_prime]));
if (_mm_extract_epi16(CAST__M128I(_mm_cmplt_ps(_mm_dp_ps(r_jk, r_jk, 0xFF), _mm_mul_ps(r, r))), 0)) {
k_closest_neighbor = k;
is_accessible = 0;
break;
}
}
if (is_accessible) {
areas[i]++;
}
}
areas[i] *= constant * (atom_radii[i])*(atom_radii[i]);
}
}
