Add Project 4 Hints

Author: kcpearce

Project#04/README.md

@@ -22,7 +22,7 @@ The most straightforward expression of the AO/MO integral transformation is
 
 This approach is easy to implement (hence the word "[noddy](http://www.hackerslang.com/noddy.html)" above), but is expensive due to its N<sup>8</sup> computational order.  Nevertheless, you should start with this algorithm to get your code working, and run timings (use the UNIX "time" command) for the test cases below to get an idea of its computational cost.
 
-  * Hint 1: Noddy transformation code
+  * [Hint 1](./hints/hint1.md): Noddy transformation code
 ### The Smarter Algorithm
 
 Notice that none of the *C* coefficients in the above expression have any indices in common.  Thus, the summation could be rearranged such that:
@@ -37,15 +37,15 @@ while the AO-basis integrals have eight-fold permutational symmetry, the partial
 
 After you have the noddy algorithm working and timed, modify it to use this smarter algorithm and time the test cases again.  Enjoy!
 
-  * Hint 2: Smarter transformation code
+  * [Hint 2](./hints/hint2.md): Smarter transformation code
 
 ## Step #4: Compute the MP2 Energy
 
 <img src="./figures/mp2-energy.png" height="60">
 
 where *i* and *j* denote doubly-occupied orbitals and *a* and *b* unoccupied orbitals, and the denominator involves the MO energies.
 
-  * Hint 3: Occupied versus unoccupied orbitals
+  * [Hint 3](./hints/hint3.md): Occupied versus unoccupied orbitals
 
 ## Test Cases
 The input structures, integrals, etc. for these examples are found in the [input directory](./input).

Project#04/hints/hint1.md

@@ -0,0 +1,37 @@
+Here's a code block that demonstrates how to carry out the AO to MO two-electron integral transformation using a single N<sup>8</sup> step.  Note that the original AO- and transformed MO-basis integrals are stored in a one-dimensional array taking full advantage of their eight-fold permutational symmetry, as described in [Project #3](../Project%2303).
+
+Note how the loop structure in the MO-indices (*i*, *j*, *k*, and *l*) automatically takes into account the permutational symmetry of the fully transformed integrals.
+
+```c++
+  #define INDEX(i,j) ((i>j) ? (((i)*((i)+1)/2)+(j)) : (((j)*((j)+1)/2)+(i)))
+  ...
+  double *TEI_AO, *TEI_MO;
+  int i, j, k, l, ijkl;
+  int p, q, r, s, pq, rs, pqrs;
+  ...
+
+  for(i=0,ijkl=0; i < nao; i++) {
+    for(j=0; j <= i; j++) {
+      for(k=0; k <= i; k++) {
+        for(l=0; l <= (i==k ? j : k); l++,ijkl++) {
+
+          for(p=0; p < nao; p++) {
+            for(q=0; q < nao; q++) {
+              pq = INDEX(p,q);
+              for(r=0; r < nao; r++) {
+                for(s=0; s < nao; s++) {
+                  rs = INDEX(r,s);
+                  pqrs = INDEX(pq,rs);
+
+                  TEI_MO[ijkl] += C[p][i] * C[q][j] * C[r][k] * C[s][l] * TEI_AO[pqrs];
+
+                }
+              }
+            }
+          }
+
+        }
+      }
+    }
+  }
+```

Project#04/hints/hint2.md

@@ -0,0 +1,59 @@
+Here's a code block that demonstrates how to carry out the AO to MO two-electron integral transformation using four N<sup>5</sup> steps.  Note that the original AO- and transformed MO-basis integrals are stored in a one-dimensional array taking advantage of their eight-fold permutational symmetry, as described in [Project #3](../Project%2303).  However, the half-transformed integrals, which lack bra-ket permutational symmetry, are stored in a two-dimensional array.
+
+A number of convenient functions [`mmult()`, `init_matrix()`, etc.] used in this code block can be found in the [diag.cc](http://sirius.chem.vt.edu/~crawdad/programming/diag.cc) discussed in [Project #1](../Project%2301).
+
+```c++
+  #define INDEX(i,j) ((i>j) ? (((i)*((i)+1)/2)+(j)) : (((j)*((j)+1)/2)+(i)))
+  ...
+  double **X, **Y, **TMP, *TEI;
+  int i, j, k, l, ij, kl, ijkl, klij;
+
+  ...
+  X = init_matrix(nao, nao);
+  Y = init_matrix(nao, nao);
+
+  TMP = init_matrix((nao*(nao+1)/2),(nao*(nao+1)/2));
+  for(i=0,ij=0; i < nao; i++)
+    for(j=0; j <= i; j++,ij++) {
+      for(k=0,kl=0; k < nao; k++)
+        for(l=0; l <= k; l++,kl++) {
+          ijkl = INDEX(ij,kl);
+          X[k][l] = X[l][k] = TEI[ijkl];
+        }
+      zero_matrix(Y, nao, nao);
+      mmult(C, 1, X, 0, Y, nao, nao, nao);
+      zero_matrix(X, nao, nao);
+      mmult(Y, 0, C, 0, X, nao, nao, nao);
+      for(k=0, kl=0; k < nao; k++)
+        for(l=0; l <= k; l++, kl++)
+          TMP[kl][ij] = X[k][l];
+    }
+
+  zero_array(TEI, (nao*(nao+1)/2)*((nao*(nao+1)/2)+1)/2);
+
+  for(k=0,kl=0; k < nao; k++)
+    for(l=0; l <= k; l++,kl++) {
+      zero_matrix(X, nao, nao);
+      zero_matrix(Y, nao, nao);
+      for(i=0,ij=0; i < nao; i++)
+        for(j=0; j <=i; j++,ij++)
+          X[i][j] = X[j][i] = TMP[kl][ij];
+      zero_matrix(Y, nao, nao);
+      mmult(C, 1, X, 0, Y, nao, nao, nao);
+      zero_matrix(X, nao, nao);
+      mmult(Y, 0, C, 0, X, nao, nao, nao);
+      for(i=0, ij=0; i < nao; i++)
+        for(j=0; j <= i; j++,ij++) {
+          klij = INDEX(kl,ij);
+          TEI[klij] = X[i][j];
+        }
+    }
+
+  ...
+
+  free_matrix(X, nao);
+  free_matrix(Y, nao);
+  free_matrix(TMP, (nao*(nao+1)/2));
+
+```
+

Project#04/hints/hint3.md

@@ -0,0 +1,20 @@
+The following code block illustrates a simple-minded MP2 energy calculation with the two-electron integrals stored in a one-dimensional array.  The molecular orbitals are assumed to be ordered with all doubly-occupied orbitals first, followed by the unoccupied/virtual orbitals.  Notice the difference in limits of the loops over *i* and *a*:
+
+```c++
+  Emp2 = 0.0;
+  for(i=0; i < ndocc; i++) {
+    for(a=ndocc; a < nao; a++) {
+      ia = INDEX(i,a);
+      for(j=0; j < ndocc; j++) {
+        ja = INDEX(j,a);
+        for(b=ndocc; b < nao; b++) {
+          jb = INDEX(j,b);
+          ib = INDEX(i,b);
+          iajb = INDEX(ia,jb);
+          ibja = INDEX(ib,ja);
+          Emp2 += TEI[iajb] * (2 * TEI[iajb] - TEI[ibja])/(eps[i] + eps[j] - eps[a] - eps[b]);
+        }
+      }
+    }
+  }
+```