Skip to the content

Geometric deep learning KDD 2021

Turn the chain. Its graph does not move.

Geometric Graph Representation Learning on Protein Structure Prediction

  1. Tian Xia1
  2. Wei-Shinn Ku1

Affiliation at the time of publication1Auburn University, Auburn, AL, USA

The paper writes a protein backbone as a graph, with a distance on every pair of residues and two dihedral angles on every residue, a description that stays the same however the protein is turned or moved, and trains one network, PG-GNN, to predict both parts together.The paper writes a protein backbone as a graph of distances and dihedral angles, which reads the same however the protein is turned, and trains one network to predict all of it.

Figure 1Illustration

Farthest an atom moved0.0Å
Largest distance change0.000Å
Largest angle change0.000°

This figure is interactive and needs JavaScript. The still shows its starting state: a toy chain of 28 residues and, next to it, the contact map read off its graph. In the live figure the chain turns, every coordinate changes, and the matrix and the angles stay exactly as they were.

THE CHAINITS CONTACT MAP15101520252811101020202828

Point at the matrix: every cell is one pair of residues.

Shape
Turn it, or drag the chain
A toy backbone built by this page, not the trained network. Lighter cells are closer pairs, and the two dials are φ and ψ of residue 14. The three numbers are measured from the turned coordinates on every frame.

01 The problem

A contact map only says near or far, so many shapes fit the same map.

Predicting a protein’s structure from its sequence is usually split into smaller problems. A common route predicts a contact map first, a grid that marks each pair of residues as closer than a threshold or not, and then rebuilds the structure from it. The paper’s first objection is that such a map leaves the backbone free to move.

Figure 2Illustrationa toy backbone built by this page, not the trained network: none of its numbers is a result from the paper

Search for a different shape that keeps every contact

Start from
Rule for the search
2400 small turns
Contacts that differ0of 378 pairs
Largest distance shift0.0Å
Turns kept0of 0 tried

This figure is interactive and needs JavaScript. It starts from a toy coil of 28 residues and searches, one small turn of one angle at a time, for other shapes in which no contact (two Cα atoms under 8 Å) appears or disappears. The contact map stays identical while the coil bends into a different shape and distances between residues move by more than 30 Å. From the toy hairpin, whose arms are tied together by contacts, the same search still moves distances by more than 2 Å.

  • where it started
  • where it is now
  • Now
  • contact, under 8 Å
  • Moved
  • under 0.5 Å
  • to 1
  • to 2
  • 2 Å or more
  • The steps are set by each search, so the ramp spans the run.

Press Search. Then point at the square to read one pair.

What to look for, and what to try
  1. Press Search. The solid chain leaves the dashed one and the lower left of the square fills with distances that have moved, while the contact map in the upper right does not change by a single cell.
  2. Start from Hairpin. Its two arms are tied together by contacts, so the search has less room, and the largest shift is still over 2 Å.
  3. Switch the rule off. The same search now pulls the contacts apart.
How the search works

Each press tries 2400 turns of one angle by up to 14°. A turn is kept only if nothing clashes (no two Cα atoms three or more apart closer than 4 Å), if it does not bring the shape back towards the start and, under the first rule, if no contact appears or disappears. The search is seeded, so every visitor sees the same run. The two shapes are laid over each other at residue 14. The constants are this page’s. The contact rule is the paper’s: two Cα atoms under 8 Å (Section 5.1).

The paper puts it this way: “Multiple conformations can be generated since alpha carbon can move freely in the space within the contact threshold.” (Section 1)

The map is not enough

A matrix of exact Cα distances is finer than a contact map, but the paper calls it still insufficient, “because of the absence of structural information of other backbone atoms”. The bonds on either side of each Cα rotate, so the other atoms can sit in more than one place. The rotation on both sides of the Cα is the extra information the paper adds to the distances.

Section 1, first challenge

Far in sequence, close in space

The paper notes that “residues sequentially far apart might be in spatially close contact in protein's 3D structure”. Earlier predictors slide small image filters over the pair map, and the paper argues that such filters focus on neighbours in the sequence. Section 03 below shows what that means cell by cell.

Section 4.2 (the quotation) and Section 1, second challenge (the image filters)

Proteins come in every length

Fixed size networks crop or pad the pair map. The paper warns that this “could potentially cause the loss of relational details or undesired distortion”, and asks for a model that takes a whole protein of any length as one graph.

Section 1, third challenge

02 The idea

Put distances on the edges and two angles on every node, and the fold becomes a graph that ignores the viewpoint.

The backbone is a chain of flat units with two free angles per residue, φ and ψ. The paper’s target is a graph over the residues: every pair carries the distance between its two Cα atoms, and every residue carries its φ and ψ. Turn or move the protein and every coordinate changes, while none of these numbers do.

Figure 3Illustrationa toy backbone built by this page, not the trained network: none of its numbers is a result from the paper

Bend one residue and watch the whole graph answer

This figure is interactive and needs JavaScript. The still below shows its starting state: a toy hairpin of 28 residues on the left and its contact map on the right. The stripe that runs away from the diagonal is the two arms of the hairpin lying side by side: residues far apart in the sequence and close in space.

THE CHAINITS CONTACT MAP, UNDER 8 Å15101520252811101020202828

The chain coordinates in space

Changed by turning it0.000Å, largest of any pair

Its graph distances on edges, φ and ψ on nodes

Pairs the last turn changed0of 378
  • under 8 Å
  • to 12
  • to 18
  • to 28
  • 28 Å or more
  • 8 Å or more
  • ringed: gained or lost by the last turn

Under 6 apart: 0 (outside the paper’s ranges, so not counted below)

Contacts, short 6 to 11 apart0
medium 12 to 230
long 24 or more0
14
0°
0°

TryDrag φ. One angle redraws a whole block of distances: every pair with one end on each side of the residue. The two halves of the graph are tied together.

The stripe running away from the diagonal is the hairpin’s two arms lying side by side: far apart in the sequence, close in space. Point at the matrix, or focus it and use the arrow keys, to read one pair.

Start from
The matrix shows
Turn the chain, or drag it

TryTurn it. Every coordinate changes, and “changed by turning it” stays at 0.000.

What the toy is built from

All of these are chosen by this page, not taken from the paper: 28 residues; bond lengths N to Cα 1.458 Å, Cα to C 1.525 Å, C to N 1.329 Å; bond angles 111.0°, 116.2° and 121.7°; the peptide torsion held flat at 180°. Only φ and ψ are free, which follows the paper’s description of the backbone as “coplanar units … with two primary degrees of freedom”. Every atom is placed from the three before it. The toy has no side chains and no energy, so it will happily take shapes a real protein cannot.

The preset angles (φ, ψ) are: Stretched (−139°, 135°), Coiled (−57°, −47°), Hairpin arms (−100°, 119°) with a four residue turn. Random draws each residue from a few ordinary angle pairs and rejects shapes in which two Cα atoms three or more apart come closer than 4 Å. The dials show φ and ψ measured back from the coordinates with the paper’s two plane definition. The first residue has no φ and the last has no ψ, because each needs a neighbour the chain does not have. The short, medium and long range bands outlined on the square are the paper’s (Section 5.3.1), and the accent cross marks every edge that touches the selected residue.

Why not predict coordinates

The authors write that, compared with Cartesian coordinates of nodes, the representation “gives a significant advantage because of its invariance to rotation and translation of the graph”. Two copies of one fold in different poses have different coordinates and the same graph, which is what Figure 1 on this page measures on the toy.

Sections 1 and 3

Why both halves, together

The distance matrix on its own “cannot fully characterize the overall backbone structure due to the rotation of chemical bonds around Cα”. And when distances and angles are generated on separate paths, the paper notes, “the predicted attributes may not be consistent as they are generated from different paths”. Figure 3 on this page shows how tightly the two are tied in the toy: a single angle moves a block of distances.

Appendix A.2 and Section 4.1

03 Reading the pair map

A pair map is not an image: a pair can be influenced by everything in its row and its column.

Earlier contact predictors treat the L × L map as a picture and slide small image filters over it. Around the cell for residues i and j, a 3 × 3 filter sees only pairs made from their next-door neighbours. The paper adds an edge-to-edge filter that reads the whole row and the whole column through the cell: every pair that shares residue i or residue j.

Figure 4Illustrationfootprints only, on the toy chain’s own contact map: no filter weights are involved and nothing here is a result

Add layers until the square reaches what the cross reads in one

1
6
23

This figure is interactive and needs JavaScript. On the contact map of the toy hairpin it outlines two footprints round one target cell: the square that a stack of 3 × 3 image filters can reach, and the full row and column that one edge-to-edge filter reads. For the pair of residues 6 and 23, a stack with a stride of 1 and no dilation needs 22 layers before its square holds that whole row and column. The edge-to-edge filter reads all 55 cells of them in one layer.

  • 3 × 3 stack
  • edge to edge: row and column
  • not reached by the stack yet
  • contact, under 8 Å

One 3 × 3 layer reads 9 cells.

Layers a 3 × 3 stack needs to reach the far end of this row and column22layersstride 1, no dilation
Edge to edge needs1layerhowever long the chain
Of the row and column, the stack has reached5of 55 cellswith 1 layer
What to look for, and what to try
  1. The target cell, residues 6 and 23, sits on the hairpin’s stripe, 17 apart along the chain. Add layers: the square grows by one cell each way and the hatched part of the row and column shrinks.
  2. Move the pair. Near a corner the far end of the row is further away, and the square is clipped by the edge of the map.
The growth of the square assumes a stride of 1 and no dilation, which the paper does not specify: it notes that dilated filters “can also be used” in the 2D branch. In its words the edge-to-edge filter “can consider the edges that connect to one residue”, with shared weights that make the representation “independent of the size of the input” (Section 4.2). A deep enough stack covers the row and column too, which is why question 3 asks what the branch adds.

04 Follow one chain

Two paths and one hand-off: the distances one path predicts steer the messages that set the angles.

Follow the toy hairpin from Figure 3 on this page through PG-GNN, the paper’s Protein Geometric Graph Neural Network. Shapes are written for its 28 residues. Sizes the paper does not give, such as the feature widths D and K, stay as letters.

Figure 5Illustration

Step through the network, or select any block to open it

The example at this stop targets from the toy, not network output

  1. A chain of 28 residues arrives as a graph

    The input is a graph of the sequence: one node per residue and an edge between neighbours along the chain, L − 1 of them. Each node carries features of its residue and each pair carries pairwise features. The order of the residues is known. The shape is not.

    In
    an amino acid sequence, L = 28 here
    Out
    F: 28 × D node features, E: 28 × 28 × K pair features
  2. Every pair of residues gets a cell

    For the edge path, the features of residue i and residue j pass through a 1D convolution and are joined onto the pair’s own features. The result is one stack of numbers for every cell of a 28 × 28 map.

    In
    F and E
    Out
    a 28 × 28 map with a feature stack per cell
  3. Three branches read the map, then add up

    Inside a block, 3 × 3 convolutions read each cell’s local neighbours, one edge-to-edge filter reads the cell’s whole row and column, and an identity branch carries the input through. The three are added and fed to the next block. The paper uses 10 blocks with 4 convolution layers in each.

    In
    the map from the block before
    Out
    a map of the same size, 28 × 28
  4. A softmax gives every pair a distance label

    The edge path ends in a softmax, trained with cross entropy against the true distance label of each pair. This is E′, the edge half of the target graph. The paper does not say how many distance classes it uses.

    In
    the map from block 10
    Out
    E′: a predicted distance label for each of the 28 × 28 pairs
  5. The predicted distances cross to the node path

    The node path takes the node features and, at each iteration, the distance matrix the edge path has just produced. That matrix becomes the edge representation for message passing, so the angles are predicted with the distances in view.

    In
    E′ and the node features F
    Out
    a graph whose edges carry predicted distances
  6. Each residue listens to the others through those distances

    A message from residue w to residue v is w’s hidden state multiplied by a matrix that depends on the edge between them. A gated recurrent unit then folds the incoming messages into v’s state. The paper stacks 6 such blocks.

    In
    a hidden state per residue, and E′
    Out
    an updated hidden state per residue
  7. Four numbers per residue become two angles

    A readout maps each final state to sin φ, cos φ, sin ψ and cos ψ. The angles are recovered with an arctangent of the sine over the cosine, as the paper prints it. This is F′, the node half of the target graph.

    In
    28 final hidden states
    Out
    4 numbers per residue, then φ and ψ per residue
  8. Both halves are trained as one network

    The edge loss is cross entropy over all pairs. The node loss is the mean squared error on the sines and cosines. The total is the edge loss plus λ times the node loss. The paper describes the network as trained under the co-guidance of both paths, and does not report the value of λ.

    In
    E′, F′ and the true graph
    Out
    one number to minimise
PG-GNN drawn as two columns. The edge translation path turns pair features into a distance for every pair. The node translation path uses those distances to pass messages between residues and outputs two angles per residue. Both meet in the target graph, which one loss trains. One protein, as a graphL residues, features F and E Edge translation path one edge block, of 10 Pair mapfeatures of i and j, per pair Identityunchanged 2D conv3 × 3, local Edge to edgerow + column Edge updateadd the three, feed the next block Softmax, then E′a distance label for every pair Node translation path one node block, of 6 Message passingneighbours, weighted through E′ Node update, GRUold state plus messages Readout Rsin φ, cos φ, sin ψ, cos ψ Arctangent, then F′φ and ψ for every residue Target graph G(E′, F′)distances on edges, angles on nodes One lossedge loss + λ × node loss
  • data, forward
  • training signal
  • the toy hairpin’s own pair map

Select any block to read what it does and where the paper says so. Arrow keys move between blocks.Tap any block to read what it does and where the paper says so.

The input graph

Nodes are the L residues. The input edges are the L − 1 edges of the protein sequence, one between each pair of neighbours along the chain. Node features F include a position-specific scoring matrix, predicted secondary structure and solvent accessibility. Pair features E include co-evolution information, a distance potential and an inter-residue coupling score.

Section 3, Appendix B.1

Pair map

In the paper’s words, “the node features Fi and Fj are transformed by 1D convolution then concatenated into Ei,j and Ej,i to be used as feature map for edge attributes generation.” The feature widths D and K are not given.

Appendix B.1

Identity branch

Each block has “one identity mapping branch, one edge-to-edge convolution branch, and one two-dimensional (2D) convolution branch”. The paper describes the edge path as a deep residual convolutional network, and this branch is its residual connection.

Sections 4.1 and 4.2

2D convolution branch

3 × 3 filters, each followed by batch normalisation and an ELU activation, 4 layers per block applied in sequence. The paper assigns this branch the local relations and notes that dilated filters can also be used here.

Section 4.2, Appendix B.2

Edge-to-edge branch

A filter that “can consider the edges that connect to one residue”. The paper’s Fig. 4 labels its kernel “Kernel=W×1, 1×H” and draws it as a cross: the full row and the full column through the cell, which is what Figure 4 on this page lets you move around. One such layer is applied to the block’s input, in parallel with the convolutions (Appendix B.2. The paper’s Fig. 4 draws this row with an ellipsis, as it does the 2D row.) Shared weights keep the representation “independent of the size of the input”.

Section 4.2, Eq. 3, the paper’s Fig. 4, Appendix B.2

Edge update layer

“All layer outputs and residual connections are added together and fed into the next block.” In the paper’s words, each edge is then generated from both its own two residues and the “edges that connected to the same nodes”.

Section 4.2

Predicted distances, E′

A softmax over distance labels for every pair, trained with cross entropy averaged over all L × L pairs. In the experiments these outputs are scored as contact predictions: Cα atoms under 8 Å. The number of distance classes and their boundaries are not given.

Section 4.1, the paper’s Fig. 3, Sections 5.1 and 5.3.1

Message passing layer

“We take the output distance matrix from the edge translation path at each iteration to use as edge representation” for the node path. The message from w to v is A(evw) hw: w’s hidden state times a matrix chosen by the edge between them (Eq. 4). The paper names the quantity handed over in three ways, and its exact form is not given.

Sections 4.1 and 4.3, Eq. 4

Node update

In the paper’s words, “we update the hidden state by the Gated Recurrent Units (GRU)”, from the old state and the aggregated message (Eq. 5). The node path has 6 message passing blocks with ReLU activations.

Section 4.3, Appendix B.2

Readout

The readout R maps the final hidden states to four numbers per residue, the sine and cosine of each angle, “for training purposes”. The paper gives no further reason for this encoding.

Section 4.3, Eq. 6

Predicted angles, F′

φ and ψ are derived as the arctangent of the predicted sine over the predicted cosine. φ measures the rotation of the N to Cα bond and ψ the rotation of the Cα to CO bond. The first node feature is φ and the second is ψ.

Section 4.3, Section 3, the paper’s Fig. 11

The target graph

The same residues as the input, now with pairwise distance information on the edges (E′) and the two dihedral angles on the nodes (F′). Both “are invariant under rotation of the coordinate system and graph translation”, which is what Figure 1 on this page measures on the toy.

Section 3

One loss

L = L(E, E′) + λ × L(F, F′) (Eq. 2). The dashed link in the drawing is this training signal, not data flowing forward. The reason given for joint training: on separate paths “the predicted attributes may not be consistent”. The value of λ is not reported.

Section 4.1, Eq. 1 and 2

An original drawing of the architecture described in Sections 4.1 to 4.3 of the paper. A copied link reopens the figure at the same stop.

05 The evidence

In every row of both angle tables, the message passing path has the lowest error.

Models were trained on 4726 proteins from PDB25 (Section 5.1; Section 6.3 gives 4725) and tested on five sets: a held out PDB25 split of 500 proteins, the CASP11 and CASP13 domains, 76 hard CAMEO proteins and 400 membrane proteins. Proteins longer than 300 residues were excluded. The neural baselines were re-implemented so that, in the paper’s words, they train “with the same data and features”. CCMpred was run from its source code.

Figure 6Measured, Tables 1 and 2

Compare the four node paths on each test set, for φ and for ψ

Exact values as printed, Tables 1 and 2

Table 1: error on φ

Table 1. Performance comparison with different node translation path (φ): average MAE of the predicted φ. Lower is better. The paper prints no unit for MAE.
Datasets GCN(k=5) GCN(k=10) GCN(k=20) MPNN
CASP1132.35034.10733.34325.696
CASP1332.40133.02732.87628.729
CAMEO32.38532.85433.33726.635
membrane32.06333.28532.89123.892
PDB2532.14333.02734.64224.114

Table 2: error on ψ

Table 2. Performance comparison with different node translation path (ψ): average MAE of the predicted ψ. Lower is better. The paper prints no unit for MAE.
Datasets GCN(k=5) GCN(k=10) GCN(k=20) MPNN
CASP1181.45180.50080.59242.003
CASP1381.86483.17884.55646.944
CAMEO81.86384.18580.60244.110
membrane82.22981.42384.55935.713
PDB2582.22483.17785.31637.688

GCN is a plain graph convolution network with dynamic k nearest neighbour selection. Column names are the paper’s, and the paper prints nothing in bold in these tables, so nothing is bold here. Both angles are drawn on one axis because every value in Table 2 is larger than the value in the same cell of Table 1. The paper does not comment on that difference, and this page offers no explanation for it.

How to read it. One panel per test set. In each, four bars for φ (solid, Table 1) sit above four bars for ψ (hatched, Table 2), every bar from zero on one axis, 0 to 90, with the printed value at its end. The panel named “All five sets” picks out, for every row of both tables, MPNN and the lowest of the three GCN values, and prints both. Open the exact values and sort a table, and the panels follow.

Figure 7Measured, Section 6.2.1

Read the edge path with and without its edge-to-edge branch

Average ACC of the top predicted contacts on each test set, as stated in the text of Section 6.2.1, in the paper’s order. Higher is better. The last column is computed by this page from the two before it.
Test set Without the edge-to-edge branch With it, the proposed ETP Difference
membrane43.345.52.2
CASP1344.348.44.1
CAMEO42.144.82.7
CASP1156.457.61.2
PDB2559.360.41.1

ACC is the accuracy of the top L/k predicted contacts, k = 10, 5, 2, 1, over short, medium and long range pairs. The paper does not say how these are averaged into one number. The paper’s Figure 6 labels the network without the branch “ResNet”.

How to read it. Two marks per test set on one axis, joined by a link whose length is the gain. The number over each link is the difference column of the table, computed by this page. The paper reports that the version with the edge-to-edge branch came out ahead “in all long-range, medium-range, and short-range metrics”. The paper’s Figure 6 plots those metrics as bars without printing values, and its Figure 7 does the same for the joint framework against the edge path alone, so neither is redrawn here.

Joint training, as reported

Against a network with only the edge path, the paper reports average ACC improvements for the joint framework of 5.6%, 3.6%, 4.7%, 0.9% and 1.2% on membrane, CASP13, CAMEO, CASP11 and PDB25, and says it “performs better in almost all metrics”. It does not say whether these are relative gains or percentage points, and the underlying values are not tabulated.

Section 6.2.3

All eight systems at once

The paper’s Figure 5 places eight combinations of edge path and node path on a plane for each test set, contact error (ERR) on the x axis and angle error (MAE) on the y axis, and reports that PG-GNN “shows the best performance across all five datasets”. The figure labels its axes but prints no value for any point, so this page describes it and does not plot it.

Section 6.1, the paper’s Fig. 5

The takeaway

Predict the graph, not the coordinates.

The target

A distance for every pair of residues and two dihedral angles for every residue. It reads the same from every viewpoint, and the paper trains both halves together because, on separate paths, the two “may not be consistent”.

The network

An edge path whose filter reads a pair’s whole row and column, a message passing node path, and a hand-off of predicted distances between them, trained with one loss.

Not claimed

The network does not output 3D coordinates. The abstract’s own summary is that the results “demonstrate the potential of GNNs for 3D structure prediction”.

06 Office hours

The night shift answers.

Written by Tian's agent while Tian slept and Pepper supervised. Pepper accepts no liability either.

Each answer says where in the paper it comes from, so you can check the agent's work.

Pepper, the tabby cat, supervising: fast asleep on his blanket on the sofa, beside the laptop.
Does the network produce a 3D structure?

No. It outputs distances and angles. For the case study, full atom models were built afterwards by PyRosetta relaxation under the predicted distance and torsion restraints, and the lowest energy model was kept. The comparison with the native structures is visual, for the four chains shown in the paper’s Fig. 9 (2c4j chain A, 2x27 chain X, 3pb8 chain B, 4pzo chain A); the text of Section 6.4 says five domains. The paper reports no RMSD or other numeric structure score.

Source: Sections 5.3.2 and 6.4, the paper’s Fig. 9
Do distances plus two angles pin down one fold?

The paper does not claim or prove that. Its wording is that the Cα distance matrix “determines the overall shape of the backbone structure”, that on its own it “cannot fully characterize” the backbone, and that the angles “could provide further geometric information”. Figure 2 on this page shows the weaker statement the paper does make, about contact maps.

Source: Section 1, Appendix A.1 and A.2
Stacked 3 × 3 filters reach far too. What does the edge-to-edge branch add?

The paper’s argument is about what one filter looks at: an image kernel “only focuses on the source and its surrounding pixels”, while, in the paper’s words, all the pairwise features in a cell’s row and column “could potentially influence” it. The evidence it offers is the ablation in Figure 7 on this page (the paper’s Section 6.2.1 and the paper’s Fig. 6): average ACC rises from 43.3% to 45.5% on the membrane set and from 59.3% to 60.4% on PDB25 when the branch is added. A dilated residual network (DRN) is also among the edge path baselines in the paper’s Figure 5, which prints no value for any point, so the size of that gap could only be estimated by eye, which this page does not do.

Source: Section 1, Sections 4.2, 5.2, 6.1 and 6.2.1
What was left out, or not reported?

Proteins longer than 300 residues were excluded. The neural baselines are re-implementations trained on the paper’s data and features, and CCMpred was run from its source code. None of them is the original authors’ server. Training time, inference time, parameter counts, the loss weight λ and the number of distance classes are not reported, and the conclusion’s remark about “less training time” has no measurement behind it in the paper. There is no ablation showing how joint training changes the angle error: that ablation measures contacts only. No experiment measures whether the predicted distances and angles agree with each other. The paper and its poster do not mention a code or data release.

Source: Sections 5.1, 5.2, 6.2.3 and 7, Appendix B.2
How close are the toys on this page to the real model?

Not close, on purpose. Figures 1 to 4 on this page run on a 28 residue backbone that this page builds from bond lengths and angles chosen by the page (listed under Figure 3). They show properties of the representation: what turning does, what a contact map forgets, how one angle moves many distances, which cells a filter reads. No network runs on this page and no toy number is a result. Every result the paper reports that appears here is in section 05: this page’s Figures 6 and 7 (copied from Tables 1 and 2 and from the text of Section 6.2.1), the five improvements quoted from Section 6.2.3 beneath them, and the dataset sizes in that section’s opening paragraph. The page also borrows a few of the paper’s settings: the 8 Å contact rule wherever a contact is drawn or counted (Figures 1 to 5 on this page, Section 5.1), the short, medium and long range groups in the read-outs of Figures 1 and 3 and the bands outlined in Figure 3 (Section 5.3.1), and the block counts in Figure 5 (Appendix B.2).