Comparing 3D Structures of Motifs Using FR3D: Identifying Local and Composite Recurrent Structural Motifs

in RNA Using the Discrepancy Calculation

The rapidly growing database of atomic-resolution RNA 3D structures, including ribozymes and ribosomal
components, necessitates systematic methods to identify and classify recurrent RNA 3D motifs, which are
crucial for understanding RNA structure, function, and evolution. RNA motifs, which include local (e.g.,
hairpin loops) and composite motifs (e.g., interactions between distant regions), are stabilized by specific
base-pairing and stacking interactions.

RNA 3D motif searching aims to identify and rank candidate motifs based on their structural similarity to a
query motif, using a numerical measure called geometric discrepancy. This measure accounts for the
general shape and base orientations of the candidate motifs. It involves calculating a fitting error (aligning
base centers through shift vectors and rotation matrices) and an orientation error (rotational alignment of
individual bases), with the geometric discrepancy being the RMS sum of these errors divided by the number
of bases.

Discrepancy Calculation Process:

FR3D includes routines for analyzing RNA 3D structure files, focusing on the geometric and interaction
properties of nucleotides. The program calculates the geometric center and orientation (rotation matrix) for
each nucleotide base, based on its heavy atom coordinates.

Geometric discrepancy D is a measure used to compare RNA motifs by assessing how well a candidate motif
matches a query motif in 3D space. Here's a detailed breakdown of how this is computed:

1. Problem Setup

• Query Motif: Consists of m nucleotides with their geometric centers represented as vectors 𝑏𝑖
(1,...,m).
• Candidate Motif: Contains m corresponding nucleotides with geometric centers 𝑐𝑖 (1,...,m).
• Goal: Align the candidate motif onto the query motif by translating and rotating it such that the root-
mean-square (RMS) fitting error is minimized.

2. Translation and Rotation

To align the candidate motif:

1. Translation (t):
a. The candidate motif is translated so that its geometric centers are shifted closer to the query
motif's geometric centers.
2. Rotation (R):
 a. The candidate motif is rotated using a 3X3 rotation matrix R, which orients it to match the
query motif as closely as possible.

3. Fitting Error (L)

The fitting error is calculated using the following formula:

𝐿2 = 𝑅𝑚𝑖𝑛 𝑡𝑚𝑖𝑛 ∑ 𝑤𝑖 ∥ 𝑏𝑖 − 𝑅(𝑐𝑖 − 𝑡) ∥ 2

𝑖=1

Where:

• 𝑏𝑖 : Geometric center of the i-th nucleotide in the query motif.

• 𝑐𝑖 : Geometric center of the i-th nucleotide in the candidate motif.
• t: Translation vector.
• R : Rotation matrix.
• 𝑤𝑖: : Weight assigned to the i-th nucleotide. These weights allow prioritizing certain nucleotides
during fitting.
• ∥⋅∥2 : Squared Euclidean distance.

The term L represents the RMS sum of the distances between the aligned geometric centers of the query and
candidate motifs after optimal translation and rotation.

4. Weighting System

The weights 𝑤𝑖 :

• Are strictly positive ( 𝑤𝑖 > 0).

• Sum to m, i.e., ∑𝑚 𝑖=1 𝑤𝑖 = 𝑚.
• Allow finer control over the alignment by emphasizing certain bases more than others.

5. Minimization Process

• The translation vector t and rotation matrix R minimize the fitting error L determined using
optimization techniques. The method for achieving this is described in Appendix A of the article and
references specific algorithms.

The additional contribution to the geometric discrepancy D involves assessing differences in orientation
between corresponding bases in the candidate and query motifs. Here’s a detailed breakdown of this aspect:
1. Rotation Matrices for Bases

• 𝑀𝑖 : Rotation matrix for base i in the query motif, which transforms the base into its orientation
relative to the standard reference orientation.
• 𝑁𝑖: Rotation matrix for base i of the candidate motif before it is aligned onto the query motif.
• R: Rotation matrix used to align the entire candidate motif onto the query motif.

2. Rotation Matrix Transformation

• After aligning the candidate motif onto the query, the rotation matrix:

𝑀𝑖 𝑁𝑖−1 𝑅 −1

specifies how to rotate base i of the candidate onto the corresponding base i in the query motif.

3. Orientation Error ( 𝛼𝑖 )

• For each base i, calculate the angle of rotation ( 𝛼 𝑖 ) needed to transform the candidate's base
orientation into the orientation of the corresponding base in the query motif.
• The angle 𝛼𝑖 is computed between the standard orientation of the base (as defined in Fig. 1) and
the transformed orientation after aligning the candidate base.
• 𝛼𝑖 is a value between 0 and 𝜋 (0 to 180 degrees) and indicates the rotational discrepancy for each
base.

4. Calculation of Orientation Error (A)

• The orientation error A is the sum of the squares of these rotational discrepancies across all bases:

𝐴 = ∑ 𝑣𝑖2 𝛼2𝑖
𝑖=1

Where:

• m: Total number of nucleotides in the motif.

• 𝑣𝑖 : Weights assigned to base i, which determine the importance of its rotational alignment.
• 𝛼𝑖 : Angle of rotation for base i.

5. Interpretation

• A quantifies the additional error introduced by differences in orientation between the corresponding
bases of the candidate and query motifs.
• By incorporating this rotational error, A helps in refining the overall geometric discrepancy D, making
the comparison more comprehensive and discriminating.
 • Incorporating orientation errors (A) into the geometric discrepancy D allows for a more accurate and
nuanced comparison between RNA motifs, accounting for both spatial arrangement and orientation
differences.

3. Combining Fitting and Orientation Errors

• Geometric Discrepancy (D): The total geometric discrepancy D is a combination of the fitting error
(L) and the orientation error (A):
1 2
𝐷= 𝐿 + 𝐴2
𝑚

Where:

• Dividing by M: This division allows D to represent a discrepancy per nucleotide, making it a useful
measure for comparing motifs of different sizes. It standardizes the measure so that the discrepancy
is meaningful whether the motif is small or large.
• Units: L Ångstroms, and A Ångstroms, representing the arc-length traveled by an atom during
rotational alignment.
• The eigenvalue and eigenvector decomposition play a key role in determining the
optimal rotation matrix to minimize the least-squares error when aligning vectors 𝑏𝑖
𝑐𝑖 . . The matrix M is constructed from the weighted cross-products of these vectors.
Its eigenvalue decomposition yields eigenvalues (𝜆1 , 𝜆 2 , 𝜆 3 ) ) and their
corresponding orthogonal eigenvectors (𝑢 1 , 𝑢 2, 𝑢 3 ). The optimal rotation matrix R
is then formed using these eigenvectors, which guide the transformation of 𝑐𝑖 to
align as closely as possible with 𝑏𝑖 .

4. Interpretation of D

• Discrepancy Values:
o 0 to 0.2 Å: This range typically represents excellent matches to the query motif, indicating
very minimal geometric discrepancy.
o 0.2 to 0.6 Å: Matches in this range are still considered good but not as close as those in the
lower range.
o Greater than 0.6 Å: Indicates poorer matches, with significant geometric discrepancies.
Implementation

Following the methodology described above, I plan to compare a total of 4733 motifs, each one individually
against the rest of the motifs. By applying geometric discrepancy calculation to each comparison, I aim to
uncover local and composite recurrent motifs, enhancing our understanding of their spatial arrangements
and interactions within the 3D context.

In my initial attempt, I calculated the discrepancy based on the steps described in the article. However, upon
reviewing the FR3D repository, I realized there were additional considerations regarding regrouping and the
treatment of heavy atoms that were not fully addressed. To improve the accuracy and efficiency of my
project, I decided to reuse some of the code from the same repository.

I refactored and optimized the discrepancy calculation process using the methods from the FR3D repository,
resulting in a more efficient and streamlined approach.

The method constructs a Component class using atom coordinates and nucleotide data of individual
residues. It then passes two Component objects at a time to the discrepancy class to compute the
discrepancy between residues(components).

The script including the below functionalities iterates through 4,733 motifs to calculate their pairwise
discrepancies and saves the results into a text file.

Functions

1. residue_component:
a. Converts a residue represented by atoms into a component object.
b. Creates Atom objects from the provided atom information and combines them into a
Component.
2. residue_components:
a. Takes a list of residues from a JSON entry and converts each into a Component.
b. Iterates through each residue, creating Component objects for them and appending them to
a list.
3. residues_components:
a. Parses the JSON data to extract 3D occurrences and converts them into a list of Component
objects.
b. Iterates through the entries, processes each, and constructs a list of Component objects for
further comparison.
4. compare_one:
a. Compares a specified residue index with all subsequent residues.
b. Uses the discrepancy function to calculate the geometric discrepancy between each pair
of Component objects.
c. Writes the results to a file named comparison_discrepency_residues.txt.
5. parallel_comparison:
a. Utilizes a thread pool executor to run the compare_one function in parallel for all items in
the residues_components_list.
b. Ensure all comparisons are completed before the script continues.

Validation:

To evaluate the discrepancies produced by FR3D, I created PDB files from the residues to compare them in
PyMOL. I was able to observe the similarity between different residues and validate the results. The table
below summarizes some of the tests and validations conducted using PyMOL to assess the values and their
consistency:
 Residues Fr3d Pymol alignment score RMSD interpretation
discrepancy
comparison
8P5D-845 to 0.0001001 MatchAlign: score 10.000 Executive: High similarity
RMSD = 0.000
7QJH-845: (22 to 22 observed
atoms)

similarity between
the two residues, an
exact match with no
deviation
6WDD-2086 to 0.5551327 MatchAlign: score 0.000 RMSD = Low similarity
4.370 (18 to 18 observed
6BZ7-2534: atoms) Average deviation
discrepancy
2ZJR-2502 to 0.1000920 MatchAlign: score 10.000 Executive: Good alignment,
RMSD = 3.755 average deviation
4WFN-2502 (23 to 23
atoms)

4V6M-769 0.309470597 MatchAlign: score 0.000 RMSD = 4.608 Good alignment,

compared to 3118354 (18 to 18 moderate deviation
5FDV-2534: atoms)
discrepancy

The screenshots from PyMOL were added to the repository to visually document this evaluation process.

Observations of the data(discrepancies)

The range of discrepancies varying between 0.0 and 0.5 in all comparisons in the text file, suggest

1. Structural Similarity: All the compared motifs have a high degree of structural similarity. None of
the discrepancies exceed 0.5 Å, indicating that even the largest differences are relatively minor.
2. Good Alignment: The motifs align well with the query motif, with the geometric discrepancies being
minimal to moderate. This shows that the motifs are consistently close to the query motif in terms of
spatial configuration.
3. High Quality Matches: Since discrepancies below 0.5 Å are generally considered good, this range
indicates that the dataset or method used for comparison has successfully identified motifs with
strong structural correspondence.