Lesson 6.1: Polar Covalent Bonds and Hydrogen Bonds
The last section of code will add hydrogen bonding functionality between molecules. To do so,
we have to understand the chemistry of polar covalent bonds and hydrogen bonds. We also need
to understand how hydrogen bonding works between the atoms of the four DNA bases.
Polar Covalent Bonds and Hydrogen Bonds
Polar COVALENT Bonds
Not all covalent bonds are equal. When an atom forms a covalent bond with another atom that is
somewhat different in electronegativity, the bond may become unequal, or polar.
A polar covalent bond is formed when electrons are shared unequally between two atoms.
In a polar covalent bond, the shared electrons spend more time orbiting the nucleus of the more
electronegative atom. You can think of this unequal sharing as the electrons spending more time
near one of the atoms than the other. Because electrons have a negative charge, the end of the
molecule where the electrons tend to hang out becomes slightly negative. The end of the
molecule that gets ignored by the electrons has fewer negative charges than positive charges - its
electrons are hanging out somewhere else - so it become slightly positive.
Figure 1a
Figure 1b
An important molecule that has polar covalent bonds is water. A water molecule has 2 hydrogen
atoms and one oxygen atom (H20). Both hydrogen and oxygen are nonmetals, which are usually
electron receivers, so they share electrons with each other. Oxygen needs two valence electrons
to become stable. Each hydrogen atoms can supply one. So, one oxygen atom share electrons
with two hydrogen atoms. However, oxygen is much more electronegative than hydrogen, so
oxygen doesn't share equally. It tends to keep the electrons at its end of the molecule. The
oxygen end of the water molecule develops a slight negative charge (represented by δ-). The
hydrogen ends of the water molecule develop a slight positive charge (δ+). Each covalent bond
within the water molecule is a polar covalent bond, and the entire molecule itself is also said to
be polar (Figures 1a and 1b).
-1-
Lesson 6.1: Polar Covalent Bonds and Hydrogen Bonds
HYDROGEN Bonds
After polar covalent bonds are formed, they set up conditions for the formation of another type
of bond: the hydrogen bond. Hydrogen bonds are weak electrical attractions that form between
the ends of polar molecules. As always, opposites attract, so the negatively charged end of one
molecule would be attracted to the positively charged end of another.
The term hydrogen bond doesn't refer to a covalent bond with a hydrogen atom. The bond got it's
name because the hydrogen atoms on polar molecules are often seen sticking to atoms on other
polar molecules. For example, in the water molecules shown in Figures 2a and 2b, the hydrogen
bonds occur between the water molecules, NOT within them.
Hydrogen bonds are only about 1/10 as strong as covalent bonds. The length of a hydrogen bond
averages about 1.97 Angstroms, about twice as long as the 0.97 Angstrom length of a normal
covalent bond.
Figure 2a
Figure 2b
Hydrogen bonds are the molecular equivalent of Velcro. If you look closely at a piece of Velcro,
you'll see that one side has tiny little hooks, and on the other side are soft fuzzy material for the
hooks to grab. Each little hook on its own forms a very weak attachment to the fuzzy material - it
easily is pulled apart. However, a strip of hundreds of these bonds collectively forms a very
powerful grip. Another analogous structure would be a zipper.
Hydrogen bonds work the same way. Each individual hydrogen bond is very weak. However,
many hydrogen bonds together perform important functions inside cells.
-2-
Lesson 6.1: Polar Covalent Bonds and Hydrogen Bonds
1. Hydrogen bonds hold the two half strands of DNA molecules together so that they form a
twisting, ladder-like double helix.
2. Hydrogen bonds are also important in holding proteins together in their proper shapes
(called conformations), without which the proteins would be unable to perform their
specific functions.
3. Finally, without hydrogen bonds, water would not have its amazing properties. Hydrogen
bonds between the positively and negatively charged ends of the water molecules cause
them to cling together.
4. (a) Water's high boiling point is due to hydrogen bonding - it takes a lot of heat/energy
to break the hydrogen bonds holding water molecules together so that they vaporize.
(b) Surface tension is also due to hydrogen bonding. Surface tension accounts for water
being able to form droplets. Surface tension also allows small water bugs to skim along
the surface of lakes and streams.
-3-
Lesson 6.2: Hydrogen Bonds in DNA
Imagining the HYDROGEN BONDS between DNA Base Pairs
After a double helix structure was deemed the most likely structure for DNA, it was still not
immediately obvious to investigators how the 4 DNA bases were arranged.
The Austrian-American biochemist Erwin Chargaff had established that in all natural DNA, the
number of Guanine molecules equals the number of Cytosine molecules and the number of
Adenine molecules equals the number of Thymine molecules. That is, there is a one-to-one
correspondence between each matching Purine and Pyrimidine.
Watson and Crick hypothesized that hydrogen bonds holding together individual C-G and A-T
pairs within the double helix would be consistent with Chargaff's data. The problem then was to
determine the physical arrangement of these Purine-Pyrimidine pairs, that is, how did they
actually fit together?
There was also a further requirement: the C-G and A-T molecules being paired on the inside of
the double helix needed to take up the same amount of space. If the base pairs were different
sizes, the double helix would bulge in some areas and narrow in others. The x-ray diffraction
data showed, however, that the helix was of uniform width.
To solve this problem, we need to look at the available electro-Positive Hydrogens and electroNegative Atoms on the 4 DNA bases.
Remember that an ELECTRO-POSITIVE Hydrogen is one that is bonded to either a Nitrogen or
Oxygen atom.
An ELECTRO-NEGATIVE atom is a Nitrogen or Oxygen atom that is receptive to an electropositive Hydrogen.
Below are images of the four bases showing the available electro-positive Hydrogens and the
electro-negative atoms.
Adenine
Thymine
Guanine
Electro-POSITIVE HYDROGENS
Figure 6.2A
-4-
Cytosine
Lesson 6.2: Hydrogen Bonds in DNA
Adenine
Thymine
Guanine
Cytosine
Electro-NEGATIVE ATOMS
NOTE that the Pyrimidine N-1 and Purine N-9 atoms are not available for hydrogen bonding
because they are already covalently bonded to the double helix backbone through deoxyribose.
Figure 6.2B
Hydrogen Bonds formed between A-T and G-C
Immediately above you can see normal base pairing between A-T and G-C.
This is what DNA looks like when everything is working correctly.
But what happens when things occasionally DON'T work as they should?
Take a look at the two base pair MISMATCHES below.
-5-
Lesson 6.2: Hydrogen Bonds in DNA
In the first mismatch, Adenine pairs with Thymine through the N-7 Nitrogen on the Imidazole
ring, rather than via the usual N-1 Nitrogen on its Pyrimidine ring (the Adenine shown is a
mirror image). In the second mismatch, Guanine is paired incorrectly with Thymine.
Such mismatches are NOT anomalies: although infrequent, they are part of the normal
functioning of nature and they have both beneficial and deleterious (damaging) effects. The
deleterious effects are, of course, mutations that can cause disease and/or death. The beneficial
effects are that such molecular base-pair mismatches are the mechanism by which organisms
evolve, conferring advantageous traits that enable them to compete and survive. What determines
whether a mutation is beneficial or deleterious is the specific location in an organism's genome
(genetic code).
We can use the 2-D Molecular Modeling program we have been writing to help us understand
the Watson-Crick structure of DNA proposed long ago in an article in Nature April 25, 1953 and
later confirmed by subsequent experiments and measurements. This is an important
DESCRIPTIVE use of the program. What makes a program useful, though, is its PREDICTIVE
power, its ability to reveal things that we don't already know. One important use of this very
simple program vis-a-vis (regarding) DNA is that it can help us explore all possible base pair
mismatches, and thereby enhance our understanding of the different types of point mutations.
-6-
Lesson 6.3: Implementing Electropositive and Electronegative Atoms
We'll first write Boolean methods to determine whether atoms are electropositive or
electronegative.
In the 4 DNA bases, ELECTROPOSITIVE atoms are
(1) Hydrogens. AND
(2) Bonded to Oxygen OR Nitrogen.
The images in Figure 6.2A show that all of the Hydrogens that we've added to our bases are
electropositive, since they are all bonded to either Oxygen or Nitrogen. The images, however,
are an oversimplification: we didn't bother adding Hydrogens that were bonded to Carbons
because they were not chemically significant in terms of the hydrogen bonds we wanted to study.
Such Hydrogens are missing from the Cytosine C5 and C6 atoms, from the Thymine Methyl
Carbon and C6 atom, from the Guanine C8 atom, and from the Adenine C8 and C2 atoms.
Therefore we will include condition (2) above so that the program will still work should we want
to extend the program to show these atoms.
We can write simple methods in the Atom class to check an atom's element type:
// Atom
boolean isHydrogen() { return this.element.equalsIgnoreCase("H"); }
boolean isOxygen() { return this.element.equalsIgnoreCase("O"); }
boolean isNitrogen() { return this.element.equalsIgnoreCase("N"); }
We can use the latter two to write a method to check whether an atom is either oxygen OR
nitrogen.
// Atom
boolean isOxygenOrNitrogen() { return isOxygen() || isNitrogen(); }
To determine whether a Hydrogen is bonded to Oxygen or Nitrogen, we'll need to iterate through
a molecule's bond list, check whether the bond includes the Hydrogen atom of interest, and see
whether the atom at the other end is Oxygen or Nitrogen. Note that we check both
configurations of the two atoms.
// Molecule
boolean bondedToOxygenOrNitrogen(Atom a) {
for (Bond b : this.bondList) {
if ( b.a1 == a && b.a2.isOxygenOrNitrogen() ) {
return true;
}
else if ( b.a2 == a && b.a1.isOxygenOrNitrogen() ) {
return true;
}
}
return false;
}
We can combining these two conditions for the isElecPosH() method:
-7-
Lesson 6.3: Implementing Electropositive and Electronegative Atoms
// Molecule
boolean isElecPosH(Atom a) {
return a.isHydrogen() && this.bondedToOxygenOrNitrogen(a);
}
Studying Figure 6.2B shows that ELECTRONEGATIVE atoms are either Oxygens or
Nitrogens. If they are Oxygens, there are no further conditions. If they are Nitrogens,
though, they must (1) not be connected to the DNA backbone, i.e. atom N1 for
Pyrimidines and atom N9 for Purines; and (2) have fewer than 3 bonds.
We need two new helper methods. Note that numberBonds() below checks both of a bond's
atoms when looking at whether to count the bond.
// Molecule
int numberBonds(Atom a) {
int nBonds = 0;
for (Bond b : this.bondList) {
if (b.a1 == a || b.a2 == a) {
nBonds++;
}
}
return nBonds;
}
Since we need two different versions of isBondedToBackbone() – one for Pyrimidines and
one for Purines – we can use the same technique that we used for writing the two versions of
getPolygon(). That is, we create an abstract method in Molecule, and write concrete methods
in both Purine and Pyrimidine.
// Molecule
abstract boolean isBondedToBackbone(Atom a);
// Pyrimidine
boolean isBondedToBackbone(Atom a) {
return this.getAtom(1) == a;
}
// Purine
boolean isBondedToBackbone(Atom a) {
return this.getAtom(9) == a;
}
Below is one way of writing isElecNegAtom().
// Molecule
boolean isElecNegAtom(Atom a) {
if ( a.isOxygen() ) {
return true;
}
-8-
Lesson 6.3: Implementing Electropositive and Electronegative Atoms
if ( a.isNitrogen() && !this.isBondedToBackbone(a) && this.numberBonds(a) < 3 ) {
return true;
}
return false;
}
An Alternative Way to Define / Structure isBondedToBackbone()
An alternative to defining isBondedToBackbone() as an abstract method and using
inheritance to override the method in the two subclasses Pyrimidine and Purine is to use
the Java operator instanceof and to write a single method body in Molecule alone.
Although using the overridden methods is the accepted practice in most cases, this situation
provides an opportunity to see how instanceof behaves.
Suppose that we had defined two methods to distinguish Purines from Pyrimidines, and inserted
code in setup() to test it out:
// Molecule
boolean isPurine() {
return this instanceof Purine;
}
boolean isPyrimidine() {
return this instanceof Pyrimidine;
}
// DNA
void setup() {
…
println("isPurine TEST");
println("Adenine: " + mol[0].isPurine() );
println("Cytosine: " + mol[1].isPurine() );
println("Guanine: " + mol[2].isPurine() );
println("Thymine: " + mol[3].isPurine() );
println("isPyrimidine TEST");
println("Adenine: " + mol[0].isPyrimidine() );
println("Cytosine: " + mol[1].isPyrimidine() );
println("Guanine: " + mol[2].isPyrimidine() );
println("Thymine: " + mol[3].isPyrimidine() );
}
The output to the console window appears below.
isPurine TEST
Adenine: true
Cytosine: false
Guanine: true
Thymine: false
isPyrimidine TEST
Adenine: true
Cytosine: true
Guanine: true
Thymine: true
-9-
Lesson 6.3: Implementing Electropositive and Electronegative Atoms
The Purine test behaves as expected, however, the Pyrimidine test reports all 4 bases as
Pyrimidines. This is because Purine objects also inherit from their immediate superclass
Pyrimidine. The modification to isPyrimidine() below fixes this problem.
// Molecule
boolean isPyrimidine() {
return this instanceof Pyrimidine && !isPurine();
}
We can now write a non-abstract method body for the Molecule class method
isBondedToBackbone().
// Molecule
boolean isBondedToBackbone(Atom a) {
if ( this.isPurine() && this.getAtom(9) == a ) {
return true;
}
else if ( this.isPyrimidine() && this.getAtom(1) == a ) {
return true;
}
else {
return false;
}
}
Decide for yourself which of these two ways is better
program structure for coding isBondedToBackbone(),
keeping in mind that projects such as these may be
maintained by more than one programmer.
- 10 -
Lesson 6.4: Implementing Hydrogen Bonding
To implement Hydrogen Bonds, below we create an HBond class and constructor. Because a
hydrogen bond is an inter-molecular bond, an HBond object needs instance variables not only
for the two atoms, but for their respective molecules as well. Recall that Molecule objects
contain translation and rotation information, which is necessary for calculating an Atom object's
current position.
// HBond
class HBond {
Molecule m1;
Molecule m2;
Atom a1;
Atom a2;
HBond(Molecule mol1, Atom atom1, Molecule mol2, Atom atom2) {
this.m1 = mol1;
this.a1 = atom1;
this.m2 = mol2;
this.a2 = atom2;
}
}
The program needs to (1) calculate all possible intermolecular HBonds between the atoms of the
4 DNA bases, then (2) draw only those HBonds whose atoms are at an optimal distance –
approximately twice the covalent C-H bond length.
A first approximation to accomplish (1) would be the use of nested for-loops to create an
ArrayList of HBonds:
// HBond The methods below are static methods not belonging the class.
// In Java, they could be part of the class definition and labeled static.
// In Processing, they appear outside of (below) the HBond class definition.
void addHBonds(ArrayList<HBond> hBonds, Molecule m1, Molecule m2) {
…
}
ArrayList<HBond> createHBonds(Molecule[] mols) {
ArrayList<HBond> hBondsList = new ArrayList<HBond>();
for (Molecule m1 : mols) {
for (Molecule m2 : mols) {
addHBonds(hBondsList, m1, m2);
}
}
return hBondsList;
}
However, because we are matching atoms in the same set to each other, this particular coding of
nested for-loops would create duplicate HBonds, as well as intra-molecular HBonds, as the table
below illustrates:
- 11 -
Lesson 6.4: Implementing Hydrogen Bonding
Index
1
2
3
4
1
2
3
4
What we want to end up with are the following 6 combinations: 1-2, 1-3, 1-4, 2-3, 2-4 and 3-4,
i.e., the blocks shaded yellow. The blocks shaded red are the corresponding duplicates and the
blocks shaded blue would create intra-molecular (not inter-molecular) hydrogen bonds (1-1, 22, 3-3, and 4-4). Note that the algebraic expression for number of UNIQUE pairs of different
2
molecules is (n – n)/2 or n(n – 1)/2.
The use of and careful setting of starting and final indices in the code below accomplishes this.
// HBond
ArrayList<HBond> createHBonds(Molecule[] mols) {
ArrayList<HBond> hBondsList = new ArrayList<HBond>();
for (int i = 0; i < mols.length-1; i++) {
for (int j = i+1; j < mols.length; j++) {
addHBonds( hBondsList, mols[i], mols[j] );
}
}
return hBondsList;
}
To complete addHBonds() requires nested for-loops to test all combinations of atoms from any
two molecules. Because these two loops deal with disjoint / non-intersecting sets of atoms, we
don't run into the same problem as above. Notice that we need to check both combinations of the
two atoms for electropositive and electronegative properties. The algebraic expression for
2
number of UNIQUE pairs of different atoms is n .
// HBond
void addHBonds(ArrayList<HBond> hBonds, Molecule m1, Molecule m2) {
for (Atom a1 : m1.atomList) {
for (Atom a2 : m2.atomList) {
if ( ( m1.isElecPosH(a1) && m2.isElecNegAtom(a2) ) ||
( m2.isElecPosH(a2) && m1.isElecNegAtom(a1) ) ) {
hBonds.add( new HBond(m1, a1, m2, a2) );
}
}
}
}
- 12 -
Lesson 6.5: Displaying Hydrogen Bonds at Optimal Distance
Once the HBonds are created, they can be displayed. Note how the rendering of the HBonds
can be coded very similar to the way the Molecule class draws its covalent bonds, taking care
to also translate the origin of the graphics display to the center of the window.
// HBond, another static method
void drawHBonds(Molecule[] mols) {
ArrayList<HBond> hBondsList = createHBonds(mols);
translate(width/2, height/2);
for (HBond b : hBondsList) {
b.display();
}
translate(-width/2, -height/2);
}
Two tasks remain: (1) calling drawHBonds() and (2) writing the HBond display() method.
The code below adds drawHBonds() to setup(). Notice that the Hydrogen Bonds are drawn
before the Molecules, much as we drew covalent bonds BEFORE drawing the atoms.
// DNA
void draw() {
background(255);
drawHBonds(mol);
for (Molecule m : mol) {
m.display();
}
drawLasso();
}
Below is a first draft of the HBond class display()
method.
// HBond
void display() {
color clr = color(255, 255, 0);
int weight = 2;
stroke(clr);
strokeWeight(weight);
line(
this.a1.getX(this.m1),
this.a1.getY(this.m1),
this.a2.getX(this.m2),
this.a2.getY(this.m2)
);
}
Figure 6.5.A shows the graphics output when the
program is run. The output shows a hydrogen bond
between every intermolecular pair of electro-positive
- 13 -
Figure 6.5.A
Lesson 6.5: Displaying Hydrogen Bonds at Optimal Distance
and –negative atoms. A small refinement is needed to limit the rendering of HBonds to the
optimal distances. The pseudocode will be the following:
If the Length of the Hydrogen Bond is:
1. Within 90-110% of the optimal distance, it will be drawn red with a stroke weight of
4.
2. In the range 110-140% of the optimal distance, it will be drawn yellow with a stroke
weight of 2.
3. In the range 0-90% of the optimal distance, it will be drawn purple with a stroke
weight of 2.
4. Greater than140%, the bond will not be drawn.
We can use the Processing library method dist() to get the Pythagorean distance between two
2
2
points (atoms). Recall that the Pythagorean distance is sqrt(Δx + Δy ). The final code
appears below.
// Molecule
final int HYDROGEN_BONDLEN = 2 * CH_BONDLEN;
// HBond
float getLen() {
return dist (
this.a1.getX(this.m1), this.a1.getY(this.m1),
this.a2.getX(this.m2), this.a2.getY(this.m2)
);
}
void display() {
float len = this.getLen();
if ( len > HYDROGEN_BONDLEN * 1.4 ) {
return;
}
int weight;
color clr;
if ( len > HYDROGEN_BONDLEN * 1.1 ) {
weight = 2;
clr = color(255, 255, 0);
}
else if ( len > HYDROGEN_BONDLEN * 0.9 ) {
clr = color(255, 0, 0);
weight = 4;
}
else {
clr = color(192, 0, 255);
weight = 2;
}
stroke(clr);
strokeWeight(weight);
line(
- 14 -
Lesson 6.5: Displaying Hydrogen Bonds at Optimal Distance
this.a1.getX(this.m1),
this.a1.getY(this.m1),
this.a2.getX(this.m2),
this.a2.getY(this.m2)
);
}
The following initial positions and rotations for the molecules draws the typical G-C and A-T
pairs Figure 6.5.B.
// DNA
size(700, 700);
mol[0]
mol[1]
mol[2]
mol[3]
=
=
=
=
new
new
new
new
Guanine(-200, -180, 0, false);
Cytosine(50, -180, 60, false);
Adenine(0, 185, 0, false);
Thymine(250, 185, 60, false);
Figure 6.5.B
Figure 6.5.C shows mismatched base pair configurations – G-T and A-C – which can lead to
point mutations.
- 15 -
Lesson 6.5: Displaying Hydrogen Bonds at Optimal Distance
Figure 6.5.C
- 16 -
Lesson 6.6: What's Next? Extensions of this Program
Figure 6.5.C shows two possible mismatched pairings, but there exist others. Although one can
experiment by observing and manually dragging and rotating bases into position, one can also
automate the program – using nested loops – to iterate through all possible rotational and
translational configurations of the bases (pyrimidine with purine) to find all possible mismatches.
Another extension would be to create an animation where the bases follow a trajectory, either a
mathematical curve or random, that leads them into a stable hydrogen bond pairing.
- 17 -