From: yeom <yeom>
Date: Fri, 8 Oct 2010 05:36:13 +0000 (+0000)
Subject: Moldyn benchmark.
X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=1d98dec09fffd56d0b5e5d37391b33dda418d416;p=IRC.git

Moldyn benchmark.
---

diff --git a/Robust/src/Benchmarks/oooJava/moldyn/JGFMolDynBench.java b/Robust/src/Benchmarks/oooJava/moldyn/JGFMolDynBench.java
new file mode 100644
index 00000000..c658abce
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/JGFMolDynBench.java
@@ -0,0 +1,711 @@
+/**************************************************************************
+ * * Java Grande Forum Benchmark Suite - Thread Version 1.0 * * produced by * *
+ * Java Grande Benchmarking Project * * at * * Edinburgh Parallel Computing
+ * Centre * * email: epcc-javagrande@epcc.ed.ac.uk * * * This version copyright
+ * (c) The University of Edinburgh, 2001. * All rights reserved. * *
+ **************************************************************************/
+public class JGFMolDynBench {
+  public int ITERS;
+  public double LENGTH;
+  public double m;
+  public double mu;
+  public double kb;
+  public double TSIM;
+  public double deltat;
+
+  public int PARTSIZE;
+
+  public double[] epot;
+  public double[] vir;
+  public double[] ek;
+
+  int size, mm;
+  int[] datasizes;
+
+  public int interactions;
+  public int[] interacts;
+
+  public int nthreads;
+  public int workload;
+
+  public JGFMolDynBench(int nthreads,int workload) {
+    this.nthreads = nthreads;
+    this.workload=workload;
+  }
+
+  public void JGFsetsize(int size) {
+    this.size = size;
+  }
+
+  public void JGFinitialise() {
+    interactions = 0;
+    datasizes = new int[3];
+    datasizes[0] = 8;
+    datasizes[1] = 13;
+    datasizes[2] = 11;
+
+    mm = datasizes[size];
+    PARTSIZE = mm * mm * mm * 4;
+    ITERS = 100;
+    LENGTH = 50e-10;
+    m = 4.0026;
+    mu = 1.66056e-27;
+    kb = 1.38066e-23;
+    TSIM = 50;
+    deltat = 5e-16;
+  }
+
+  public static void JGFapplication(JGFMolDynBench mold) {
+    double sh_force[][];
+    double sh_force2[][][];
+    int partsize, numthreads;
+    partsize = mold.PARTSIZE;
+    numthreads = mold.nthreads;
+
+    sh_force = new double[3][partsize];
+    sh_force2 = new double[3][numthreads][partsize];
+    mold.epot = new double[numthreads];
+    mold.vir = new double[numthreads];
+    mold.ek = new double[numthreads];
+    mold.interacts = new int[numthreads];
+    // for(int i=0;i<numthreads;i++) {
+    // mold.epot[i]=new double();
+    // mold.vir[i]=new double();
+    // mold.ek[i]=new double();
+    // mold.interacts[i]=new IntWrapper();
+    // }
+
+    // spawn threads
+    MDWrap[] thobjects = new MDWrap[numthreads];
+
+    for (int i = 0; i < numthreads; i++) {
+      thobjects[i] = new MDWrap(new mdRunner(i, mold.mm, sh_force, sh_force2, mold.nthreads, mold,mold.workload));
+    }
+
+    /*
+     * boolean waitfordone=true; while(waitfordone) { if (mybarr.done)
+     * waitfordone=false; }
+     */
+
+    for (int i = 0; i < numthreads; i++) {
+      // thobjects[i].md.start(mid[i]);
+      thobjects[i].md.run();
+    }
+  }
+
+  public void JGFvalidate() {
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dev = Math.fabs(ek[0] - refval[size]);
+    if (dev > 1.0e-10) {
+      // System.printString("Validation failed\n");
+      // System.printString("Kinetic Energy = " + (long)ek[0] + "  " + (long)dev
+      // + "  " + size + "\n");
+    }
+  }
+}
+
+class mdRunner {
+
+  double count;
+  int id, i, j, k, lg, mm;
+  double l, rcoff, rcoffs, side, sideh, hsq, hsq2, vel, velt;
+  double a, r, sum, tscale, sc, ekin, ts, sp;
+  double den;
+  double tref;
+  double h;
+  double vaver, vaverh, rand;
+  double etot, temp, pres, rp;
+  double u1, u2, s, xx, yy, zz;
+  double xvelocity, yvelocity, zvelocity;
+
+  double[][] sh_force;
+  double[][][] sh_force2;
+  
+  int ijk, npartm, iseed, tint;
+  int irep;
+  int istop;
+  int iprint;
+
+  JGFMolDynBench mymd;
+  int nthreads;
+  int workload;
+
+  public mdRunner(int id, int mm, double[][] sh_force, double[][][] sh_force2, int nthreads,
+      JGFMolDynBench mymd, int workload) {
+    this.id = id;
+    this.mm = mm;
+    this.sh_force = sh_force;
+    this.sh_force2 = sh_force2;
+    this.nthreads = nthreads;
+    this.mymd = mymd;
+    count = 0.0;
+    den = 0.83134;
+    tref = 0.722;
+    h = 0.064;
+    irep = 10;
+    istop = 19;
+    iprint = 10;
+    this.workload=workload;
+  }
+
+  public void init(particle[] one, int mdsize) {
+    int id = this.id;
+    for (int lg = 0; lg <= 1; lg++) {
+      for (int i = 0; i < mm; i++) {
+        for (int j = 0; j < mm; j++) {
+          for (int k = 0; k < mm; k++) {
+            one[ijk] =
+                new particle((i * a + lg * a * 0.5), (j * a + lg * a * 0.5), (k * a), xvelocity,
+                    yvelocity, zvelocity, sh_force, sh_force2, id, one);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+
+    for (int lg = 1; lg <= 2; lg++) {
+      for (int i = 0; i < mm; i++) {
+        for (int j = 0; j < mm; j++) {
+          for (int k = 0; k < mm; k++) {
+            one[ijk] =
+                new particle((i * a + (2 - lg) * a * 0.5), (j * a + (lg - 1) * a * 0.5),
+                    (k * a + a * 0.5), xvelocity, yvelocity, zvelocity, sh_force, sh_force2, id,
+                    one);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+
+    /* Initialise velocities */
+
+    iseed = 0;
+    double v1 = 0.0;
+    double v2 = 0.0;
+    random randnum = new random(iseed, v1, v2);
+
+    for (int i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].xvelocity = r * randnum.v1;
+      one[i + 1].xvelocity = r * randnum.v2;
+    }
+
+    for (int i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].yvelocity = r * randnum.v1;
+      one[i + 1].yvelocity = r * randnum.v2;
+    }
+
+    for (int i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].zvelocity = r * randnum.v1;
+      one[i + 1].zvelocity = r * randnum.v2;
+    }
+
+    /* velocity scaling */
+
+    ekin = 0.0;
+    sp = 0.0;
+
+    for (int i = 0; i < mdsize; i++) {
+      sp = sp + one[i].xvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (int i = 0; i < mdsize; i++) {
+      one[i].xvelocity = one[i].xvelocity - sp;
+      ekin = ekin + one[i].xvelocity * one[i].xvelocity;
+    }
+
+    sp = 0.0;
+    for (int i = 0; i < mdsize; i++) {
+      sp = sp + one[i].yvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (int i = 0; i < mdsize; i++) {
+      one[i].yvelocity = one[i].yvelocity - sp;
+      ekin = ekin + one[i].yvelocity * one[i].yvelocity;
+    }
+
+    sp = 0.0;
+    for (int i = 0; i < mdsize; i++) {
+      sp = sp + one[i].zvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (int i = 0; i < mdsize; i++) {
+      one[i].zvelocity = one[i].zvelocity - sp;
+      ekin = ekin + one[i].zvelocity * one[i].zvelocity;
+    }
+
+    ts = tscale * ekin;
+    sc = h * Math.sqrt(tref / ts);
+
+    for (int i = 0; i < mdsize; i++) {
+
+      one[i].xvelocity = one[i].xvelocity * sc;
+      one[i].yvelocity = one[i].yvelocity * sc;
+      one[i].zvelocity = one[i].zvelocity * sc;
+
+    }
+
+  }
+
+  public void doinit(int mdsize) {
+    for (int j = 0; j < 3; j++) {
+      double[] sh = sh_force[j];
+      for (int i = 0; i < mdsize; i++) {
+        sh[i] = 0.0;
+      }
+    }
+  }
+
+  public void doinit2(int mdsize) {
+    for (int k = 0; k < 3; k++) {
+      double[] sh = sh_force[k];
+      double[][] sha = sh_force2[k];
+      for (int j = 0; j < nthreads; j++) {
+        double[] sha2 = sha[j];
+        for (int i = 0; i < mdsize; i++) {
+          sh[i] += sha2[i];
+        }
+      }
+    }
+
+    for (int k = 0; k < 3; k++) {
+      double[][] sh1 = sh_force2[k];
+      for (int j = 0; j < nthreads; j++) {
+        double[] sh2 = sh1[j];
+        for (int i = 0; i < mdsize; i++) {
+
+          sh2[i] = 0.0;
+        }
+      }
+    }
+
+    for (int j = 1; j < nthreads; j++) {
+      mymd.epot[0] += mymd.epot[j];
+      mymd.vir[0] += mymd.vir[j];
+    }
+    for (int j = 1; j < nthreads; j++) {
+      mymd.epot[j] = mymd.epot[0];
+      mymd.vir[j] = mymd.vir[0];
+    }
+    for (int j = 0; j < nthreads; j++) {
+      mymd.interactions += mymd.interacts[j];
+    }
+
+    for (int j = 0; j < 3; j++) {
+      double sh[] = sh_force[j];
+      for (int i = 0; i < mdsize; i++) {
+        sh[i] = sh[i] * hsq2;
+      }
+    }
+  }
+
+  public void run() {
+    /* Parameter determination */
+
+    int mdsize;
+    double tmpden;
+    int movemx = 50;
+    particle[] one;
+    int id;
+    id = this.id;
+    mdsize = mymd.PARTSIZE;
+    one = new particle[mdsize];
+    l = mymd.LENGTH;
+    tmpden = den;
+    side = Math.pow((mdsize / tmpden), 0.3333333);
+    rcoff = mm / 4.0;
+
+    a = side / mm;
+    sideh = side * 0.5;
+    hsq = h * h;
+    hsq2 = hsq * 0.5;
+    npartm = mdsize - 1;
+    rcoffs = rcoff * rcoff;
+    tscale = 16.0 / (1.0 * mdsize - 1.0);
+    vaver = 1.13 * Math.sqrt(tref / 24.0);
+    vaverh = vaver * h;
+
+    /* Particle Generation */
+
+    xvelocity = 0.0;
+    yvelocity = 0.0;
+    zvelocity = 0.0;
+    ijk = 0;
+    init(one, mdsize);
+
+    /* Synchronise threads and start timer before MD simulation */
+
+    /* MD simulation */
+    
+    int numP= (mdsize / workload)+1;
+
+    double scratchpad[][][];
+    scratchpad=new double[numP][3][mdsize];
+
+    for (int move = 0; move < movemx; move++) {
+      /* move the particles and update velocities */
+      for (int i = 0; i < mdsize; i++) {
+        one[i].domove(side, i);
+      }
+
+      if (id == 0) {
+        doinit(mdsize);
+      }
+
+      mymd.epot[id] = 0.0;
+      mymd.vir[id] = 0.0;
+      mymd.interacts[id] = 0;
+
+      /* compute forces */
+      int numThread = nthreads;
+      int lworkload = workload;
+      // for (int i=0+id;i<mdsize;i+=numThread) {
+      int scratch_idx=0;
+      for (int i = 0 ; i < mdsize; i += lworkload) {
+
+        int ilow = i;
+        int iupper = i + lworkload;
+        if (iupper > mdsize) {
+          iupper = mdsize;
+        }
+        int l_size = iupper - ilow;
+
+        double workingpad[][]=scratchpad[scratch_idx++];
+        sese parallel{
+          for(int j=0;j<3;j++){
+            for(int l=0;l<mdsize;l++){
+              workingpad[j][l]=0;
+            }
+          }
+          MDStore store = new MDStore();
+          for(int idx=ilow;idx<iupper;idx++){
+//            one[i].force(side, rcoff, mdsize, i, xx, yy, zz, mymd, worker);
+            one[idx].force(side, rcoff, mdsize, idx, xx, yy, zz, mymd, store,workingpad);
+          }
+        }
+
+        sese serial{
+          for (int k = 0; k < 3; k++) {
+            for (int j = 0; j < mdsize; j++) {
+//              sh_force[k][j] += worker.sh_force2[k][j];
+              sh_force[k][j] += workingpad[k][j];
+            }
+          }
+          mymd.epot[0] += store.epot;
+          mymd.vir[0] += store.vir;
+          mymd.interactions += store.interacts;
+        }
+
+      }
+      
+      for (int k = 0; k < 3; k++) {
+        for (int j = 0; j < mdsize; j++) {
+          sh_force[k][j] = sh_force[k][j] * hsq2;
+        }
+      }
+
+      /* update force arrays */
+      // if(id == 0) {
+      // doinit2(mdsize);
+      // }
+
+      /* scale forces, update velocities */
+      sum = 0.0;
+      for (int i = 0; i < mdsize; i++) {
+        sum = sum + one[i].mkekin(hsq2, i);
+      }
+
+      ekin = sum / hsq;
+
+      vel = 0.0;
+      count = 0.0;
+
+      /* average velocity */
+
+      for (int i = 0; i < mdsize; i++) {
+        velt = one[i].velavg(vaverh, h);
+        if (velt > vaverh) {
+          count = count + 1.0;
+        }
+        vel = vel + velt;
+      }
+
+      vel = vel / h;
+
+      /* temperature scale if required */
+
+      if ((move < istop) && (((move + 1) % irep) == 0)) {
+        sc = Math.sqrt(tref / (tscale * ekin));
+        for (int i = 0; i < mdsize; i++) {
+          one[i].dscal(sc, 1);
+        }
+        ekin = tref / tscale;
+      }
+
+      /* sum to get full potential energy and virial */
+
+      if (((move + 1) % iprint) == 0) {
+        mymd.ek[id] = 24.0 * ekin;
+        mymd.epot[id] = 4.0 * mymd.epot[id];
+        etot = mymd.ek[id] + mymd.epot[id];
+        temp = tscale * ekin;
+        pres = tmpden * 16.0 * (ekin - mymd.vir[id]) / mdsize;
+        vel = vel / mdsize;
+        rp = (count / mdsize) * 100.0;
+      }
+
+      // if (id == 0) JGFInstrumentor.stopTimer("Section3:MolDyn:Run",
+      // instr.timers);
+    }
+  }
+}
+
+class particle {
+
+  public double xcoord, ycoord, zcoord;
+  public double xvelocity, yvelocity, zvelocity;
+  int part_id;
+  int id;
+  double[][] sh_force;
+  double[][][] sh_force2;
+  particle[] one;
+
+  public particle(double xcoord, double ycoord, double zcoord, double xvelocity, double yvelocity,
+      double zvelocity, double[][] sh_force, double[][][] sh_force2, int id, particle[] one) {
+
+    this.xcoord = xcoord;
+    this.ycoord = ycoord;
+    this.zcoord = zcoord;
+    this.xvelocity = xvelocity;
+    this.yvelocity = yvelocity;
+    this.zvelocity = zvelocity;
+    this.sh_force = sh_force;
+    this.sh_force2 = sh_force2;
+    this.id = id;
+    this.one = one;
+  }
+
+  public void domove(double side, int part_id) {
+
+    xcoord = xcoord + xvelocity + sh_force[0][part_id];
+    ycoord = ycoord + yvelocity + sh_force[1][part_id];
+    zcoord = zcoord + zvelocity + sh_force[2][part_id];
+
+    if (xcoord < 0) {
+      xcoord = xcoord + side;
+    }
+    if (xcoord > side) {
+      xcoord = xcoord - side;
+    }
+    if (ycoord < 0) {
+      ycoord = ycoord + side;
+    }
+    if (ycoord > side) {
+      ycoord = ycoord - side;
+    }
+    if (zcoord < 0) {
+      zcoord = zcoord + side;
+    }
+    if (zcoord > side) {
+      zcoord = zcoord - side;
+    }
+
+    xvelocity = xvelocity + sh_force[0][part_id];
+    yvelocity = yvelocity + sh_force[1][part_id];
+    zvelocity = zvelocity + sh_force[2][part_id];
+
+  }
+
+  // public void force(double side, double rcoff,int mdsize,int x, double xx,
+  // double yy, double zz, JGFMolDynBench mymd) {
+  public void force(double side, double rcoff, int mdsize, int x, double xx, double yy, double zz,
+      JGFMolDynBench mymd, MDStore store,double workingpad[][]) {
+
+    double sideh;
+    double rcoffs;
+
+    double fxi, fyi, fzi;
+    double rd, rrd, rrd2, rrd3, rrd4, rrd6, rrd7, r148;
+    double forcex, forcey, forcez;
+    int id = this.id;
+    sideh = 0.5 * side;
+    rcoffs = rcoff * rcoff;
+
+    fxi = 0.0;
+    fyi = 0.0;
+    fzi = 0.0;
+
+    for (int i = x + 1; i < mdsize; i++) {
+      xx = this.xcoord - one[i].xcoord;
+      yy = this.ycoord - one[i].ycoord;
+      zz = this.zcoord - one[i].zcoord;
+
+      if (xx < (-sideh)) {
+        xx = xx + side;
+      }
+      if (xx > (sideh)) {
+        xx = xx - side;
+      }
+      if (yy < (-sideh)) {
+        yy = yy + side;
+      }
+      if (yy > (sideh)) {
+        yy = yy - side;
+      }
+      if (zz < (-sideh)) {
+        zz = zz + side;
+      }
+      if (zz > (sideh)) {
+        zz = zz - side;
+      }
+
+      rd = xx * xx + yy * yy + zz * zz;
+
+      if (rd <= rcoffs) {
+        rrd = 1.0 / rd;
+        rrd2 = rrd * rrd;
+        rrd3 = rrd2 * rrd;
+        rrd4 = rrd2 * rrd2;
+        rrd6 = rrd2 * rrd4;
+        rrd7 = rrd6 * rrd;
+        // mymd.epot[id] += (rrd6 - rrd3);
+        store.epot += (rrd6 - rrd3);
+        r148 = rrd7 - 0.5 * rrd4;
+        // mymd.vir[id] += - rd*r148;
+        store.vir += -rd * r148;
+        forcex = xx * r148;
+        fxi = fxi + forcex;
+
+        // sh_force2[0][id][i] = sh_force2[0][id][i] - forcex;
+//        worker.sh_force2[0][i] = worker.sh_force2[0][i] - forcex;
+        workingpad[0][i] = workingpad[0][i] - forcex;
+
+        forcey = yy * r148;
+        fyi = fyi + forcey;
+
+        // sh_force2[1][id][i] = sh_force2[1][id][i] - forcey;
+//        worker.sh_force2[1][i] = worker.sh_force2[1][i] - forcey;
+        workingpad[1][i] = workingpad[1][i] - forcey;
+
+        forcez = zz * r148;
+        fzi = fzi + forcez;
+
+        // sh_force2[2][id][i] = sh_force2[2][id][i] - forcez;
+//        worker.sh_force2[2][i] = worker.sh_force2[2][i] - forcez;
+        workingpad[2][i] = workingpad[2][i] - forcez;
+
+        // mymd.interacts[id]++;
+        store.interacts++;
+      }
+
+    }
+
+    // sh_force2[0][id][x] = sh_force2[0][id][x] + fxi;
+    // sh_force2[1][id][x] = sh_force2[1][id][x] + fyi;
+    // sh_force2[2][id][x] = sh_force2[2][id][x] + fzi;
+
+//    worker.sh_force2[0][x] = worker.sh_force2[0][x] + fxi;
+//    worker.sh_force2[1][x] = worker.sh_force2[1][x] + fyi;
+//    worker.sh_force2[2][x] = worker.sh_force2[2][x] + fzi;
+    
+    workingpad[0][x] = workingpad[0][x] + fxi;
+    workingpad[1][x] = workingpad[1][x] + fyi;
+    workingpad[2][x] = workingpad[2][x] + fzi;
+
+  }
+
+  public double mkekin(double hsq2, int part_id) {
+
+    double sumt = 0.0;
+
+    xvelocity = xvelocity + sh_force[0][part_id];
+    yvelocity = yvelocity + sh_force[1][part_id];
+    zvelocity = zvelocity + sh_force[2][part_id];
+
+    sumt = (xvelocity * xvelocity) + (yvelocity * yvelocity) + (zvelocity * zvelocity);
+    return sumt;
+  }
+
+  public double velavg(double vaverh, double h) {
+
+    double velt;
+    double sq;
+
+    sq = Math.sqrt(xvelocity * xvelocity + yvelocity * yvelocity + zvelocity * zvelocity);
+
+    velt = sq;
+    return velt;
+  }
+
+  public void dscal(double sc, int incx) {
+    xvelocity = xvelocity * sc;
+    yvelocity = yvelocity * sc;
+    zvelocity = zvelocity * sc;
+  }
+}
+
+class random {
+
+  public int iseed;
+  public double v1, v2;
+
+  public random(int iseed, double v1, double v2) {
+    this.iseed = iseed;
+    this.v1 = v1;
+    this.v2 = v2;
+  }
+
+  public double update() {
+
+    double rand;
+    double scale = 4.656612875e-10;
+
+    int is1, is2, iss2;
+    int imult = 16807;
+    int imod = 2147483647;
+
+    if (iseed <= 0) {
+      iseed = 1;
+    }
+
+    is2 = iseed % 32768;
+    is1 = (iseed - is2) / 32768;
+    iss2 = is2 * imult;
+    is2 = iss2 % 32768;
+    is1 = (is1 * imult + (iss2 - is2) / 32768) % (65536);
+
+    iseed = (is1 * 32768 + is2) % imod;
+
+    rand = scale * iseed;
+
+    return rand;
+
+  }
+
+  public double seed() {
+
+    double s, u1, u2, r;
+    s = 1.0;
+    do {
+      u1 = update();
+      u2 = update();
+
+      v1 = 2.0 * u1 - 1.0;
+      v2 = 2.0 * u2 - 1.0;
+      s = v1 * v1 + v2 * v2;
+
+    } while (s >= 1.0);
+
+    r = Math.sqrt(-2.0 * Math.log(s) / s);
+
+    return r;
+
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/JGFMolDynBenchSizeB.java b/Robust/src/Benchmarks/oooJava/moldyn/JGFMolDynBenchSizeB.java
new file mode 100644
index 00000000..3331e9df
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/JGFMolDynBenchSizeB.java
@@ -0,0 +1,78 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFMolDynBenchSizeB { 
+
+    public static void main(String argv[]){
+    int nthreads;
+    int workload;
+    if(argv.length != 0 ) {
+      nthreads = Integer.parseInt(argv[0]);
+      workload=Integer.parseInt(argv[1]);
+    } else {
+      System.printString("The no of threads has not been specified, defaulting to 1\n");
+      System.printString("  " + "\n");
+      nthreads = 1;
+      workload=100;
+    }
+
+//    JGFInstrumentor instr = new JGFInstrumentor();
+//    JGFInstrumentor.printHeader(3,1,nthreads);
+
+    JGFMolDynBench mold;
+    mold = new JGFMolDynBench(nthreads,workload); 
+    int size = 1;
+//    JGFInstrumentor.addTimer("Section3:MolDyn:Total", "Solutions",size, instr.timers);
+//    JGFInstrumentor.addTimer("Section3:MolDyn:Run", "Interactions",size, instr.timers);
+
+    mold.JGFsetsize(size); 
+
+//    JGFInstrumentor.startTimer("Section3:MolDyn:Total", instr.timers);
+
+    JGFMolDynBench tmp;
+    mold.JGFinitialise(); 
+    JGFMolDynBench.JGFapplication(mold); 
+
+    /* Validate data */
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dval;
+    dval = mold.ek[0];
+    double dev = Math.fabs(dval - refval[size]);
+    long l = (long) refval[size] *1000000;
+    long r = (long) dval * 1000000;
+    if (l != r ){
+      System.printString("Validation failed\n");
+      System.printString("Kinetic Energy = " + (long)dval + "  " + (long)dev + "  " + size + "\n");
+    }
+
+//    JGFInstrumentor.stopTimer("Section3:MolDyn:Total", instr.timers);
+//    double interactions;
+//    interactions = mold.interactions;
+
+//    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Run", (double) interactions, instr.timers);
+//    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Total", 1, instr.timers);
+
+//    JGFInstrumentor.printTimer("Section3:MolDyn:Run", instr.timers); 
+//    JGFInstrumentor.printTimer("Section3:MolDyn:Total", instr.timers); 
+    System.printString("Finished\n");
+  }
+}
+
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/JGFTimer.java b/Robust/src/Benchmarks/oooJava/moldyn/JGFTimer.java
new file mode 100644
index 00000000..4e1d168f
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/JGFTimer.java
@@ -0,0 +1,123 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 1999.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+
+public class JGFTimer {
+
+  public String name; 
+  public String opname; 
+  public double time; 
+  public double opcount; 
+  public long calls; 
+  public int size;
+
+  private long start_time;
+  private boolean on; 
+
+  public JGFTimer(String name, String opname){
+    this.size = -1;
+    this.name = name;
+    this.opname = opname;
+    reset(); 
+  }
+
+  public JGFTimer(String name, String opname, int size){
+    this.name = name;
+    this.opname = opname;
+    this.size = size;
+    reset();
+  }
+
+  public JGFTimer(String name){
+    this.name = name;
+    this.opname = "";
+    reset();
+  }
+
+
+
+  public void start(){
+    if (on) System.printString("Warning timer " + " was already turned on\n");
+    on = true; 
+    start_time = System.currentTimeMillis();
+  }
+
+
+  public void stop(){
+    time += (double) (System.currentTimeMillis()-start_time) / 1000.;
+    if (!on) System.printString("Warning timer " + " wasn't turned on\n");
+    calls++;
+    on = false;  
+  }
+
+  public void addops(double count){
+    opcount += count;
+  } 
+
+  public void addtime(double added_time){
+    time += added_time;
+  }
+
+  public void reset(){
+    time = 0.0; 
+    calls = 0; 
+    opcount = 0; 
+    on = false;
+  }
+
+  public double perf(){
+    return opcount / time; 
+  }
+
+  public void longprint(){
+    System.printString("Timer            Calls         Time(s)       Performance("+opname+"/s)\n");   
+    System.printString(name + "           " + calls +    "           "  +  (long)time + "        " + (long)this.perf() + "\n");
+  }
+
+  public void print(){
+    if (opname.equals("")) {
+      System.printString(name + "   " + (long)time + " (s)\n");
+    }
+    else {
+      if(size == 0) {
+        System.printString(name + ":SizeA" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else if (size == 1) {
+        System.printString(name + ":SizeB" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else if (size == 2) {
+        System.printString(name + ":SizeC" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else{
+        System.printString(name + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      }
+    }
+  }
+
+
+  public void printperf(){
+
+    String name;
+    name = this.name; 
+
+    // pad name to 40 characters
+    while ( name.length() < 40 ) name = name + " "; 
+
+    System.printString(name + "\t" + (long)this.perf() + "\t"
+        + " ("+opname+"/s)\n");  
+  }
+
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/MDStore.java b/Robust/src/Benchmarks/oooJava/moldyn/MDStore.java
new file mode 100644
index 00000000..ab40a39c
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/MDStore.java
@@ -0,0 +1,9 @@
+public class MDStore {
+  int interacts;
+  double vir;
+  double epot;
+  
+  public MDStore() {
+  }
+  
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/MDWrap.java b/Robust/src/Benchmarks/oooJava/moldyn/MDWrap.java
new file mode 100644
index 00000000..5c4ed746
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/MDWrap.java
@@ -0,0 +1,9 @@
+public class MDWrap {
+    public mdRunner md;
+    public MDWrap() {
+    }
+
+    public MDWrap(mdRunner m) {
+	md=m;
+    }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup/JGFMolDynBench.java b/Robust/src/Benchmarks/oooJava/moldyn/backup/JGFMolDynBench.java
new file mode 100644
index 00000000..4c022500
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup/JGFMolDynBench.java
@@ -0,0 +1,53 @@
+/**************************************************************************
+*                                                                         *
+*         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+*                                                                         *
+*                            produced by                                  *
+*                                                                         *
+*                  Java Grande Benchmarking Project                       *
+*                                                                         *
+*                                at                                       *
+*                                                                         *
+*                Edinburgh Parallel Computing Centre                      *
+*                                                                         * 
+*                email: epcc-javagrande@epcc.ed.ac.uk                     *
+*                                                                         *
+*                                                                         *
+*      This version copyright (c) The University of Edinburgh, 2001.      *
+*                         All rights reserved.                            *
+*                                                                         *
+**************************************************************************/
+
+public class JGFMolDynBench {
+
+  public static void main(String args[]) {
+    int datasize = 8; //8,13
+    int group = 16;
+    MD md = new MD(datasize, group);
+    md.initialise();
+    int movemx = 50;
+
+    
+    for (int move=0;move<movemx;move++) {
+      md.domove();
+      md.init();
+      
+      for(int i = 0; i < md.group; ++i) {
+        MDRunner runner = new MDRunner(i, md);
+        runner.init();
+        runner.run();                
+        md.update(runner);
+
+      } 
+      md.sum();
+      md.scale();
+    }
+   
+    
+    
+    md.validate();
+    
+  }
+  
+}
+  
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup/MD.java b/Robust/src/Benchmarks/oooJava/moldyn/backup/MD.java
new file mode 100644
index 00000000..e309d263
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup/MD.java
@@ -0,0 +1,343 @@
+package Benchmarks.oooJava.moldyn;
+
+/** Banboo Version */
+
+/**************************************************************************
+ * * Java Grande Forum Benchmark Suite - Version 2.0 * * produced by * * Java
+ * Grande Benchmarking Project * * at * * Edinburgh Parallel Computing Centre *
+ * * email: epcc-javagrande@epcc.ed.ac.uk * * Original version of this code by *
+ * Dieter Heermann * converted to Java by * Lorna Smith (l.smith@epcc.ed.ac.uk)
+ * * (see copyright notice below) * * This version copyright (c) The University
+ * of Edinburgh, 2001. * All rights reserved. * *
+ **************************************************************************/
+
+public class MD {
+  public int mm;
+  public int group;
+  public int mdsize;
+  public int move;
+  public int movemx;
+
+  public float side;
+  float hsq, hsq2, den, h, vaver, vaverh;
+  float tref, tscale;
+  int irep;
+  int istop;
+  int iprint;
+
+  public Particle[] one;
+  public float[][] sh_force;
+  // public float[] epot;
+  // public float[] vir;
+  // public float[] ek;
+  public float epot;
+  public float vir;
+  public float ek;
+  float ekin;
+
+  public int counter;
+
+  public void MD(int d, int g) {
+    this.mm = d;
+    this.group = g;
+    this.mdsize = this.mm * this.mm * this.mm * 4;
+    this.one = new Particle[this.mdsize];
+    this.sh_force = new float[3][this.mdsize];
+    this.move = 0;
+    this.movemx = 2;
+    this.den = (float) 0.83134;
+    this.h = (float) 0.064;
+    this.side = Math.powf((float) (this.mdsize / this.den), (float) 0.3333333);
+    this.hsq = this.h * this.h;
+    this.hsq2 = this.hsq * (float) 0.5;
+    this.vaver = (float) 1.13 * Math.sqrtf((float) this.tref / (float) 24.0);
+    this.vaverh = this.vaver * this.h;
+    this.irep = 10;
+    this.istop = 19;
+    // this.epot = (float)0.0;
+    // this.vir = (float)0.0;
+    this.tref = (float) 0.722;
+    this.tscale = (float) 16.0 / ((float) 1.0 * (float) this.mdsize - (float) 1.0);
+    this.iprint = 10;
+    this.counter = 0;
+
+    this.epot = (float) 0.0;// new float[this.group + 1];
+    this.vir = (float) 0.0;// new float[this.group + 1];
+    this.ek = (float) 0.0;// new float[this.group + 1];
+  }
+
+  public void init() {
+    /*
+     * for(int i = 0; i < this.group + 1; i++) { this.epot[i] = (float)0.0;
+     * this.vir[i] = (float)0.0; }
+     */
+    this.epot = (float) 0.0;
+    this.vir = (float) 0.0;
+    for (int j = 0; j < 3; j++) {
+      for (int i = 0; i < this.mdsize; i++) {
+        this.sh_force[j][i] = (float) 0.0;
+      }
+    }
+    this.counter = 0;
+  }
+
+  public void initialise() {
+
+    /* Particle Generation */
+    float xvelocity, yvelocity, zvelocity;
+    int ijk, lg, i, j, k;
+    float a = this.side / this.mm;
+    xvelocity = (float) 0.0;
+    yvelocity = (float) 0.0;
+    zvelocity = (float) 0.0;
+    // System.printString("here 1\n");
+    // System.printI(0xa0);
+    ijk = 0;
+    for (lg = 0; lg <= 1; lg++) {
+      for (i = 0; i < mm; i++) {
+        for (j = 0; j < mm; j++) {
+          for (k = 0; k < mm; k++) {
+            one[ijk] =
+                new Particle((float) (i * a + lg * a * (float) 0.5), (float) (j * a + lg * a
+                    * (float) 0.5), (k * a), xvelocity, yvelocity, zvelocity, this);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+    for (lg = 1; lg <= 2; lg++) {
+      for (i = 0; i < mm; i++) {
+        for (j = 0; j < mm; j++) {
+          for (k = 0; k < mm; k++) {
+            one[ijk] =
+                new Particle((float) (i * a + (2 - lg) * a * (float) 0.5),
+                    (float) (j * a + (lg - 1) * a * (float) 0.5),
+                    (float) (k * a + a * (float) 0.5), xvelocity, yvelocity, zvelocity, this);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+    // System.printString("here 2\n");
+    // System.printI(0xa1);
+    /* Initialise velocities */
+    int iseed;
+    float v1, v2, r;
+    iseed = 0;
+    v1 = (float) 0.0;
+    v2 = (float) 0.0;
+
+    MyRandom random = new MyRandom(iseed, v1, v2);
+    // System.printString("here 3\n");
+    // System.printI(0xa2);
+    for (i = 0; i < this.mdsize; i += 2) {
+      r = random.seed();
+      one[i].xvelocity = r * random.v1;
+      one[i + 1].xvelocity = r * random.v2;
+    }
+    // System.printString("here 4\n");
+    // System.printI(0xa3);
+    for (i = 0; i < this.mdsize; i += 2) {
+      r = random.seed();
+      one[i].yvelocity = r * random.v1;
+      one[i + 1].yvelocity = r * random.v2;
+    }
+    // System.printString("here 5\n");
+    // System.printI(0xa4);
+    for (i = 0; i < this.mdsize; i += 2) {
+      r = random.seed();
+      one[i].zvelocity = r * random.v1;
+      one[i + 1].zvelocity = r * random.v2;
+    }
+
+    /*
+     * for(i = 0; i < this.mdsize; i++) { System.printString("xvel: " +
+     * (int)(one[i].xvelocity*100000) + "; yvel: " +
+     * (int)(one[i].yvelocity*100000) + "; zvel: " +
+     * (int)(one[i].zvelocity*100000) + "\n"); }
+     */
+
+    // System.printString("here 6\n");
+    // System.printI(0xa5);
+    /* velocity scaling */
+    float sp, ts, sc;
+    ekin = (float) 0.0;
+    sp = (float) 0.0;
+    // System.printString("here 7\n");
+    // System.printI(0xa6);
+    for (i = 0; i < this.mdsize; i++) {
+      sp = sp + one[i].xvelocity;
+    }
+    sp = sp / this.mdsize;
+    // System.printString("here 8\n");
+    // System.printI(0xa7);
+    for (i = 0; i < this.mdsize; i++) {
+      one[i].xvelocity = one[i].xvelocity - sp;
+      ekin = ekin + one[i].xvelocity * one[i].xvelocity;
+    }
+    // System.printString("here 9\n");
+    // System.printI(0xa8);
+    sp = (float) 0.0;
+    for (i = 0; i < this.mdsize; i++) {
+      sp = sp + one[i].yvelocity;
+    }
+    sp = sp / this.mdsize;
+    // System.printString("here 10\n");
+    // System.printI(0xa9);
+    for (i = 0; i < this.mdsize; i++) {
+      one[i].yvelocity = one[i].yvelocity - sp;
+      ekin = ekin + one[i].yvelocity * one[i].yvelocity;
+    }
+    // System.printString("here 11\n");
+    // System.printI(0xa10);
+    sp = (float) 0.0;
+    for (i = 0; i < this.mdsize; i++) {
+      sp = sp + one[i].zvelocity;
+    }
+    sp = sp / this.mdsize;
+    // System.printString("here 12\n");
+    // System.printI(0xa11);
+    for (i = 0; i < this.mdsize; i++) {
+      one[i].zvelocity = one[i].zvelocity - sp;
+      ekin = ekin + one[i].zvelocity * one[i].zvelocity;
+    }
+    // System.printString("here 13\n");
+    // System.printI(0xa12);
+    ts = this.tscale * ekin;
+    sc = h * Math.sqrtf(this.tref / ts);
+
+    for (i = 0; i < this.mdsize; i++) {
+      one[i].xvelocity = one[i].xvelocity * sc;
+      one[i].yvelocity = one[i].yvelocity * sc;
+      one[i].zvelocity = one[i].zvelocity * sc;
+    }
+    // System.printString("here 14\n");
+    // System.printI(0xa13);
+  }
+
+  public void domove() {
+    for (int i = 0; i < this.mdsize; i++) {
+      one[i].domove(this.side, i);
+    }
+
+    /*
+     * for(int j=0;j<3;j++) { for (int i=0;i<mdsize;i++) { sh_force[j][i] =
+     * (float)0.0; } }
+     */
+
+    this.move++;
+  }
+
+  public boolean finish() {
+    if (this.move == this.movemx) {
+      return true;
+    }
+    return false;
+  }
+
+  public void update(MDRunner runner) {
+    float sum, vel, velt, count, sc;
+    float etot, temp, pres, rp;
+
+    /* update force arrays */
+    for (int k = 0; k < 3; k++) {
+      for (int i = 0; i < this.mdsize; i++) {
+        sh_force[k][i] += runner.sh_force2[k][i];
+      }
+    }
+
+    // runner.init();
+
+    // this.epot[runner.id + 1] = runner.epot;
+    // this.vir[runner.id + 1] = runner.vir;
+    this.epot += runner.epot;
+    this.vir += runner.vir;
+  }
+
+  public void sum() {
+    float sum = (float) 0.0;
+
+    for (int j = 0; j < 3; j++) {
+      for (int i = 0; i < this.mdsize; i++) {
+        sh_force[j][i] = sh_force[j][i] * hsq2;
+      }
+    }
+
+    sum = (float) 0.0;
+    for (int i = 0; i < this.mdsize; i++) {
+      sum = sum + this.one[i].mkekin(hsq2, i);
+    }
+    ekin = (float) (sum / hsq);
+  }
+
+  public void scale() {
+    float sum, vel, velt, count, sc;
+    float etot, temp, pres, rp;
+
+    // runner.epot = this.epot[0];
+    // runner.vir = this.vir[0];
+
+    vel = (float) 0.0;
+    count = (float) 0.0;
+
+    /* average velocity */
+    for (int i = 0; i < this.mdsize; i++) {
+      velt = this.one[i].velavg(vaverh, h);
+      if (velt > vaverh) {
+        count = count + (float) 1.0;
+      }
+      vel = vel + velt;
+    }
+    vel = (float) (vel / h);
+
+    /* temperature scale if required */
+    if ((this.move < this.istop) && (((this.move + 1) % this.irep) == 0)) {
+      sc = Math.sqrtf(this.tref / (this.tscale * ekin));
+      for (int i = 0; i < mdsize; i++) {
+        one[i].dscal(sc, 1);
+      }
+      ekin = (float) (this.tref / this.tscale);
+    }
+
+    /* sum to get full potential energy and virial */
+    if (((this.move + 1) % this.iprint) == 0) {
+      /*
+       * this.ek[runner.id+1] = (float)24.0*ekin; this.epot[runner.id+1] =
+       * (float)4.0*this.epot[runner.id+1]; etot = this.ek[runner.id+1] +
+       * this.epot[runner.id+1]; temp = this.tscale * ekin; pres = den *
+       * (float)16.0 * (ekin - this.vir[runner.id+1]) / mdsize; vel = vel /
+       * this.mdsize; rp = (count / this.mdsize) * (float)100.0;
+       * 
+       * if(this.counter == this.group) {
+       */
+      this.ek = (float) 24.0 * ekin;
+      // this.epot[0] = (float)4.0*this.epot[0];
+      // etot = this.ek[0] + this.epot[0];
+      // temp = this.tscale * ekin;
+      // pres = den * (float)16.0 * (ekin - this.vir[0]) / mdsize;
+      // vel = vel / this.mdsize;
+      // rp = (count / this.mdsize) * (float)100.0;
+      // System.printString("ek: " + (int)(this.ek*1000000) + " (" + this.move +
+      // ")\n");
+      // }
+    }
+  }
+
+  public void validate() {
+    float refval = (float) 1731.4306625334357;
+    float dev = Math.abs(this.ek - refval);
+    System.out.println("this.ek=" + this.ek);
+    if (dev > 1.0e-10) {
+      System.out.println("Validation failed\n");
+      // System.printString("Kinetic Energy = " + (int)(this.ek*1000000) + ";  "
+      // + (int)(refval*1000000) + "\n");
+      // System.printI(0xdddf);
+      // System.printI((int)(this.ek[0]*1000000));
+      // System.printI((int)(refval*1000000));
+      // System.printI((int)(ek*10000));
+      // System.printI((int)(refval*10000));
+    } else {
+      System.out.println("Validation success");
+    }
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup/MDRunner.java b/Robust/src/Benchmarks/oooJava/moldyn/backup/MDRunner.java
new file mode 100644
index 00000000..e01fbf92
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup/MDRunner.java
@@ -0,0 +1,68 @@
+public class MDRunner {
+    
+    public int id;  
+    int mm;
+    int mdsize;
+    public int group;
+    public int ilow, iupper;
+    //float l;
+    float rcoff;
+    //rcoffs,
+    float side/*sideh,*/;
+    //float rand;
+    public float [][] sh_force2;
+    public float epot;
+    public float vir;
+    public float ek;
+    //int npartm,tint;
+    //int iprint = 10;
+    MD md;
+    Particle[] one;
+
+    public MDRunner(int id, MD m) {
+	this.id=id;
+	this.md = m;
+	this.mm=this.md.mm;
+	//this.l = 50e-10;
+	this.mdsize = this.md.mdsize;
+	this.group = this.md.group;
+	this.side = this.md.side;
+	this.rcoff = this.mm/(float)4.0;
+//	this.rcoffs = this.rcoff * this.rcoff;
+	//this.sideh = this.side * 0.5;
+	//this.npartm = this.mdsize - 1;
+	//this.iprint = 10;
+	int slice = (this.mdsize - 1) / this.group + 1; 
+	this.ilow = this.id * slice; 
+	this.iupper = (this.id+1) * slice; 
+	if (this.iupper > this.mdsize )  {
+	    iupper = this.mdsize; 
+	}
+	sh_force2 = new float[3][this.mdsize];
+	
+	this.one = this.md.one;
+	this.epot = (float)0.0;//this.md.epot[id+1];
+	this.vir = (float)0.0;//this.md.vir[id+1];
+	this.ek = (float)0.0;//this.md.ek[id+1];
+    }
+    
+    public void init() {
+	this.epot = (float)0.0;
+	this.vir = (float)0.0;
+	for(int i = 0; i < this.mdsize; i++) {
+	    for(int j = 0; j < 3; j++) {
+		this.sh_force2[j][i] = (float)0.0;
+	    }
+	}
+    }
+
+    public void run() {
+	/* compute forces */
+	//System.printString("here 1: " + this.id + "\n");
+	for (int i = this.ilow; i < this.iupper; i++) {
+	    one[i].force(side,rcoff,mdsize,i,this); 
+	}
+	//System.printString("here 2: " + this.id + "\n");
+    }
+
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup/MyRandom.java b/Robust/src/Benchmarks/oooJava/moldyn/backup/MyRandom.java
new file mode 100644
index 00000000..3fdb7e47
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup/MyRandom.java
@@ -0,0 +1,61 @@
+public class MyRandom {
+
+    public int iseed;
+    public float v1,v2;
+
+    public MyRandom(int iseed, float v1, float v2) {
+	this.iseed = iseed;
+	this.v1 = v1;
+	this.v2 = v2;
+    }
+
+    public float update() {
+
+	float rand;
+	float scale= (float)4.656612875e-10;
+
+	int is1,is2,iss2;
+	int imult= 16807;
+	int imod = 2147483647;
+
+	if (iseed<=0) { 
+	    iseed = 1; 
+	    }
+
+	is2 = iseed % 32768;
+	is1 = (iseed-is2)/32768;
+	iss2 = is2 * imult;
+	is2 = iss2 % 32768;
+	is1 = (is1 * imult+(iss2-is2) / 32768) % (65536);
+
+	iseed = (is1 * 32768 + is2) % imod;
+
+	rand = scale * iseed;
+
+	return rand;
+
+    }
+
+    public float seed() {
+
+	float s,u1,u2,r;
+	s = (float)1.0;
+	//do {
+	    //System.printI(0xb1);
+	    u1 = update();
+	    u2 = update();
+
+	//System.printI(0xb2);
+	    v1 = (float)2.0 * u1 - (float)1.0;
+	    v2 = (float)2.0 * u2 - (float)1.0;
+	    s = v1*v1 + v2*v2;
+	//System.printI(0xb3);
+	//} while (s >= (float)1.0);
+	 s = s - (int)s;
+	//System.printI(0xb4);
+	r = Math.sqrtf((float)(-2.0*Math.logf(s))/(float)s);
+	//System.printI(0xb5);
+	return r;
+
+    }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup/Particle.java b/Robust/src/Benchmarks/oooJava/moldyn/backup/Particle.java
new file mode 100644
index 00000000..5376afa7
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup/Particle.java
@@ -0,0 +1,139 @@
+public class Particle {
+
+    public float xcoord, ycoord, zcoord;
+    public float xvelocity,yvelocity,zvelocity;
+    int id;
+    //float [][] sh_force;
+    //float [][][] sh_force2;
+    MD md;
+
+    public Particle(float xcoord, float ycoord, float zcoord, float xvelocity,
+	    float yvelocity,float zvelocity,/*float [][] sh_force, 
+	    float [][][] sh_force2, int id, */MD m) {
+
+	this.xcoord = xcoord; 
+	this.ycoord = ycoord; 
+	this.zcoord = zcoord;
+	this.xvelocity = xvelocity;
+	this.yvelocity = yvelocity;
+	this.zvelocity = zvelocity;
+	//this.sh_force = sh_force;
+	//this.sh_force2 = sh_force2;
+	this.id=id;
+	this.md=m;
+    }
+
+    public void domove(float side,int part_id) {
+	xcoord = xcoord + xvelocity + this.md.sh_force[0][part_id];
+	ycoord = ycoord + yvelocity + this.md.sh_force[1][part_id];
+	zcoord = zcoord + zvelocity + this.md.sh_force[2][part_id];
+
+	if(xcoord < 0) { xcoord = xcoord + side; } 
+	if(xcoord > side) { xcoord = xcoord - side; }
+	if(ycoord < 0) { ycoord = ycoord + side; }
+	if(ycoord > side) { ycoord = ycoord - side; }
+	if(zcoord < 0) { zcoord = zcoord + side; }
+	if(zcoord > side) { zcoord = zcoord - side; }
+
+	xvelocity = xvelocity + this.md.sh_force[0][part_id];
+	yvelocity = yvelocity + this.md.sh_force[1][part_id];
+	zvelocity = zvelocity + this.md.sh_force[2][part_id];
+	//System.printI(0xc0);
+    }
+
+    public void force(float side, float rcoff,int mdsize,int x, MDRunner runner) {
+	float sideh;
+	float rcoffs;
+
+	float fxi,fyi,fzi;
+	float rd,rrd,rrd2,rrd3,rrd4,rrd6,rrd7,r148;
+	float forcex,forcey,forcez;
+	
+	float xx, yy, zz;
+
+	sideh = (float)0.5*side; 
+	rcoffs = rcoff*rcoff;
+
+	fxi = (float)0.0;
+	fyi = (float)0.0;
+	fzi = (float)0.0;
+	//System.printString("here 111: " + runner.id + "\n");
+	for (int i=x+1;i<mdsize;i++) {
+	    xx = this.xcoord - this.md.one[i].xcoord;
+	    yy = this.ycoord - this.md.one[i].ycoord;
+	    zz = this.zcoord - this.md.one[i].zcoord;
+
+	    if(xx < (-sideh)) { xx = xx + side; }
+	    if(xx > (sideh))  { xx = xx - side; }
+	    if(yy < (-sideh)) { yy = yy + side; }
+	    if(yy > (sideh))  { yy = yy - side; }
+	    if(zz < (-sideh)) { zz = zz + side; }
+	    if(zz > (sideh))  { zz = zz - side; }
+
+
+	    rd = xx*xx + yy*yy + zz*zz;
+
+	    if(rd <= rcoffs) {
+		rrd = (float)1.0/rd;
+		rrd2 = rrd*rrd;
+		rrd3 = rrd2*rrd;
+		rrd4 = rrd2*rrd2;
+		rrd6 = rrd2*rrd4;
+		rrd7 = rrd6*rrd;
+		runner.epot = runner.epot + (rrd6 - rrd3);
+		r148 = rrd7 - (float)0.5*rrd4;
+		runner.vir = runner.vir - rd*r148;
+		forcex = xx * r148;
+		fxi = fxi + forcex;
+
+		runner.sh_force2[0][i] = runner.sh_force2[0][i] - forcex;
+
+		forcey = yy * r148;
+		fyi = fyi + forcey;
+
+		runner.sh_force2[1][i] = runner.sh_force2[1][i] - forcey;
+
+		forcez = zz * r148;
+		fzi = fzi + forcez;
+
+		runner.sh_force2[2][i] = runner.sh_force2[2][i] - forcez;
+
+		//this.md.interacts[id]++;
+	    }
+
+	}
+	//System.printString("here 222: " + runner.id + "\n");
+	runner.sh_force2[0][x] = runner.sh_force2[0][x] + fxi;
+	runner.sh_force2[1][x] = runner.sh_force2[1][x] + fyi;
+	runner.sh_force2[2][x] = runner.sh_force2[2][x] + fzi;
+	//System.printString("here 333: " + runner.id + "\n");
+    }
+
+    public float mkekin(float hsq2,int part_id) {
+	float sumt = (float)0.0; 
+
+	xvelocity = xvelocity + this.md.sh_force[0][part_id]; 
+	yvelocity = yvelocity + this.md.sh_force[1][part_id]; 
+	zvelocity = zvelocity + this.md.sh_force[2][part_id]; 
+
+	sumt = (xvelocity*xvelocity)+(yvelocity*yvelocity)+(zvelocity*zvelocity);
+	return sumt;
+    }
+
+    public float velavg(float vaverh,float h) {
+	float velt;
+	float sq;
+
+	sq = Math.sqrtf(xvelocity*xvelocity + yvelocity*yvelocity + zvelocity*zvelocity);
+
+	velt = sq;
+	return velt;
+    }
+
+    public void dscal(float sc,int incx) {
+	xvelocity = xvelocity * sc;
+	yvelocity = yvelocity * sc;   
+	zvelocity = zvelocity * sc;   
+    }
+
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup2/JGFMolDynBench.java b/Robust/src/Benchmarks/oooJava/moldyn/backup2/JGFMolDynBench.java
new file mode 100644
index 00000000..b15ef21e
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup2/JGFMolDynBench.java
@@ -0,0 +1,71 @@
+/**************************************************************************
+*                                                                         *
+*         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+*                                                                         *
+*                            produced by                                  *
+*                                                                         *
+*                  Java Grande Benchmarking Project                       *
+*                                                                         *
+*                                at                                       *
+*                                                                         *
+*                Edinburgh Parallel Computing Centre                      *
+*                                                                         * 
+*                email: epcc-javagrande@epcc.ed.ac.uk                     *
+*                                                                         *
+*                                                                         *
+*      This version copyright (c) The University of Edinburgh, 2001.      *
+*                         All rights reserved.                            *
+*                                                                         *
+**************************************************************************/
+
+
+public class JGFMolDynBench extends md  {
+
+  public static int nthreads;
+
+  public JGFMolDynBench(int nthreads) {
+        this.nthreads=nthreads;
+  }
+
+//   int size;
+
+  public void JGFsetsize(int size){
+    this.size = size;
+  }
+
+  public void JGFinitialise(){
+
+      initialise();
+
+  }
+
+  public void JGFapplication(){ 
+
+    runiters();
+
+  } 
+
+
+  public void JGFvalidate(){
+    double refval[] = new double[2];
+                                refval[0]= 1731.4306625334357;
+                                refval[1]=7397.392307839352;
+    double dev = Math.abs(ek[0] - refval[size]);
+    if (dev > 1.0e-10 ){
+      System.out.println("Validation failed");
+      System.out.println("Kinetic Energy = " + ek[0] + "  " + dev + "  " + size);
+    }
+  }
+
+  public void JGFrun(int size){
+    JGFsetsize(size); 
+
+    JGFinitialise(); 
+    JGFapplication(); 
+    JGFvalidate(); 
+
+  }
+
+
+}
+ 
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup2/JGFMolDynBenchSizeB.java b/Robust/src/Benchmarks/oooJava/moldyn/backup2/JGFMolDynBenchSizeB.java
new file mode 100644
index 00000000..3362f5e6
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup2/JGFMolDynBenchSizeB.java
@@ -0,0 +1,24 @@
+/**************************************************************************
+ * * Java Grande Forum Benchmark Suite - Thread Version 1.0 * * produced by * *
+ * Java Grande Benchmarking Project * * at * * Edinburgh Parallel Computing
+ * Centre * * email: epcc-javagrande@epcc.ed.ac.uk * * * This version copyright
+ * (c) The University of Edinburgh, 2001. * All rights reserved. * *
+ **************************************************************************/
+
+public class JGFMolDynBenchSizeB {
+
+  public static void main(String argv[]) {
+    int nthreads;
+    if (argv.length != 0) {
+      nthreads = Integer.parseInt(argv[0]);
+    } else {
+      System.out.println("The no of threads has not been specified, defaulting to 1");
+      System.out.println("  ");
+      nthreads = 1;
+    }
+    // JGFMolDynBench mold = new JGFMolDynBench(nthreads);
+    // mold.JGFrun(1);
+    md mold = new md();
+    mold.JGFrun(1,nthreads);
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup2/md.java b/Robust/src/Benchmarks/oooJava/moldyn/backup2/md.java
new file mode 100644
index 00000000..ca0f01ad
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup2/md.java
@@ -0,0 +1,756 @@
+import mlp.montecarlo.JGFTimer;
+
+/**************************************************************************
+ * * Java Grande Forum Benchmark Suite - Version 2.0 * * produced by * * Java
+ * Grande Benchmarking Project * * at * * Edinburgh Parallel Computing Centre *
+ * * email: epcc-javagrande@epcc.ed.ac.uk * * Original version of this code by *
+ * Dieter Heermann * converted to Java by * Lorna Smith (l.smith@epcc.ed.ac.uk)
+ * * (see copyright notice below) * * This version copyright (c) The University
+ * of Edinburgh, 2001. * All rights reserved. * *
+ **************************************************************************/
+
+public class md {
+
+  public static final int ITERS;
+  public static final double LENGTH;
+  public static final double m;
+  public static final double mu;
+  public static final double kb;
+  public static final double TSIM;
+  public static final double deltat;
+
+  public static int PARTSIZE;
+
+  public static double[] epot;
+  public static double[] vir;
+  public static double[] ek;
+
+  int size, mm;
+  int datasizes[];
+
+  public static int interactions;
+  public static int[] interacts;
+
+  public static int nthreads;
+  
+  /////////////////
+  double l, rcoff, rcoffs, side, sideh, hsq, hsq2, vel, velt;
+  double a, r, sum, tscale, sc, ekin, ts, sp;
+  double den;
+  double tref;
+  double h;
+  double vaver, vaverh, rand;
+  double etot, temp, pres, rp;
+  double u1, u2, v1, v2, s, xx, yy, zz;
+  double xvelocity, yvelocity, zvelocity;
+  int id, i, j, k, lg, mdsize, move;
+  particle one[];
+  int ijk, npartm, iseed, tint;
+  int irep;
+  int istop;
+  int iprint;
+  int movemx;
+  //////////////////
+
+  // int size;
+
+  public void JGFsetsize(int size) {
+    this.size = size;
+  }
+
+  public void JGFinitialise() {
+
+    initialise();
+
+  }
+
+  public void JGFapplication() {
+
+    runiters();
+
+  }
+
+  public void JGFvalidate() {
+    double refval[] = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dev = Math.abs(ek[0] - refval[size]);
+    if (dev > 1.0e-10) {
+      System.out.println("Validation failed");
+      System.out.println("Kinetic Energy = " + ek[0] + "  " + dev + "  " + size);
+    }
+  }
+
+  public void JGFrun(int size,int nthreads) {
+    this.nthreads=nthreads;
+
+    JGFsetsize(size);
+
+    JGFinitialise();
+    JGFapplication();
+    JGFvalidate();
+
+  }
+
+  public md() {
+    ITERS = 100;
+    LENGTH = 50e-10;
+    m = 4.0026;
+    mu = 1.66056e-27;
+    kb = 1.38066e-23;
+    TSIM = 50;
+    deltat = 5e-16;
+
+    datasizes = new int[2];
+    datasizes[0] = 8;
+    datasizes[1] = 13;
+
+    interactions = 0;
+
+  }
+
+  public void initialise() {
+
+    mm = datasizes[size];
+    PARTSIZE = mm * mm * mm * 4;
+
+  }
+
+  public void runiters() {
+
+    /* Create new arrays */
+
+    epot = new double[nthreads];
+    vir = new double[nthreads];
+    ek = new double[nthreads];
+
+    interacts = new int[nthreads];
+
+    double sh_force[][] = new double[3][PARTSIZE];
+    double sh_force2[][][] = new double[3][nthreads][PARTSIZE];
+
+//    mdRunner thobjects[] = new mdRunner[JGFMolDynBench.nthreads];
+//    for (int i = 0; i < JGFMolDynBench.nthreads; i++) {
+//      thobjects[i] = new mdRunner(i, mm, sh_force, sh_force2);
+//      thobjects[0].run();
+//    }
+    
+    
+    /* Parameter determination */
+
+    mdsize = PARTSIZE;
+    one = new particle[mdsize];
+    l = LENGTH;
+
+    side = Math.pow((mdsize / den), 0.3333333);
+    rcoff = mm / 4.0;
+
+    a = side / mm;
+    sideh = side * 0.5;
+    hsq = h * h;
+    hsq2 = hsq * 0.5;
+    npartm = mdsize - 1;
+    rcoffs = rcoff * rcoff;
+    tscale = 16.0 / (1.0 * mdsize - 1.0);
+    vaver = 1.13 * Math.sqrt(tref / 24.0);
+    vaverh = vaver * h;
+
+    /* Particle Generation */
+
+    xvelocity = 0.0;
+    yvelocity = 0.0;
+    zvelocity = 0.0;
+
+    ijk = 0;
+    for (lg = 0; lg <= 1; lg++) {
+      for (i = 0; i < mm; i++) {
+        for (j = 0; j < mm; j++) {
+          for (k = 0; k < mm; k++) {
+            one[ijk] =
+                new particle((i * a + lg * a * 0.5), (j * a + lg * a * 0.5), (k * a), xvelocity,
+                    yvelocity, zvelocity, sh_force, sh_force2, id);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+    for (lg = 1; lg <= 2; lg++) {
+      for (i = 0; i < mm; i++) {
+        for (j = 0; j < mm; j++) {
+          for (k = 0; k < mm; k++) {
+            one[ijk] =
+                new particle((i * a + (2 - lg) * a * 0.5), (j * a + (lg - 1) * a * 0.5),
+                    (k * a + a * 0.5), xvelocity, yvelocity, zvelocity, sh_force, sh_force2, id
+                    );
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+
+    
+
+  }
+
+}
+
+class mdRunner {
+
+  double count;
+
+  int id, i, j, k, lg, mdsize, move, mm;
+
+  double l, rcoff, rcoffs, side, sideh, hsq, hsq2, vel, velt;
+  double a, r, sum, tscale, sc, ekin, ts, sp;
+  double den;
+  double tref;
+  double h;
+  double vaver, vaverh, rand;
+  double etot, temp, pres, rp;
+  double u1, u2, v1, v2, s, xx, yy, zz;
+  double xvelocity, yvelocity, zvelocity;
+
+  double[][] sh_force;
+  double[][][] sh_force2;
+
+  int ijk, npartm, iseed, tint;
+  int irep;
+  int istop;
+  int iprint;
+  int movemx;
+
+  random randnum;
+
+  particle one[];
+
+  public double mdr_epot;
+  public double mdr_vir;
+  public int mdr_interacts;
+  md md;
+
+  public mdRunner(int id, int mm, double[][] sh_force, double[][][] sh_force2, md md) {
+    count = 0.0;
+    irep = 10;
+    istop = 19;
+    iprint = 10;
+    movemx = 50;
+    den = 0.83134;
+    tref = 0.722;
+    h = 0.064;
+
+    this.id = id;
+    this.mm = mm;
+    this.sh_force = sh_force;
+    this.sh_force2 = sh_force2;
+    this.md=md;
+  }
+
+  public void run() {
+
+    /* Parameter determination */
+
+    mdsize = md.PARTSIZE;
+    one = new particle[mdsize];
+    l = md.LENGTH;
+
+    side = Math.pow((mdsize / den), 0.3333333);
+    rcoff = mm / 4.0;
+
+    a = side / mm;
+    sideh = side * 0.5;
+    hsq = h * h;
+    hsq2 = hsq * 0.5;
+    npartm = mdsize - 1;
+    rcoffs = rcoff * rcoff;
+    tscale = 16.0 / (1.0 * mdsize - 1.0);
+    vaver = 1.13 * Math.sqrt(tref / 24.0);
+    vaverh = vaver * h;
+
+    /* Particle Generation */
+
+    xvelocity = 0.0;
+    yvelocity = 0.0;
+    zvelocity = 0.0;
+
+    ijk = 0;
+    for (lg = 0; lg <= 1; lg++) {
+      for (i = 0; i < mm; i++) {
+        for (j = 0; j < mm; j++) {
+          for (k = 0; k < mm; k++) {
+            one[ijk] =
+                new particle((i * a + lg * a * 0.5), (j * a + lg * a * 0.5), (k * a), xvelocity,
+                    yvelocity, zvelocity, sh_force, sh_force2, id);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+    for (lg = 1; lg <= 2; lg++) {
+      for (i = 0; i < mm; i++) {
+        for (j = 0; j < mm; j++) {
+          for (k = 0; k < mm; k++) {
+            one[ijk] =
+                new particle((i * a + (2 - lg) * a * 0.5), (j * a + (lg - 1) * a * 0.5),
+                    (k * a + a * 0.5), xvelocity, yvelocity, zvelocity, sh_force, sh_force2, id);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+
+    /* Initialise velocities */
+
+    iseed = 0;
+    v1 = 0.0;
+    v2 = 0.0;
+
+    randnum = new random(iseed, v1, v2);
+
+    for (i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].xvelocity = r * randnum.v1;
+      one[i + 1].xvelocity = r * randnum.v2;
+    }
+
+    for (i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].yvelocity = r * randnum.v1;
+      one[i + 1].yvelocity = r * randnum.v2;
+    }
+
+    for (i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].zvelocity = r * randnum.v1;
+      one[i + 1].zvelocity = r * randnum.v2;
+    }
+
+    /* velocity scaling */
+
+    ekin = 0.0;
+    sp = 0.0;
+
+    for (i = 0; i < mdsize; i++) {
+      sp = sp + one[i].xvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (i = 0; i < mdsize; i++) {
+      one[i].xvelocity = one[i].xvelocity - sp;
+      ekin = ekin + one[i].xvelocity * one[i].xvelocity;
+    }
+
+    sp = 0.0;
+    for (i = 0; i < mdsize; i++) {
+      sp = sp + one[i].yvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (i = 0; i < mdsize; i++) {
+      one[i].yvelocity = one[i].yvelocity - sp;
+      ekin = ekin + one[i].yvelocity * one[i].yvelocity;
+    }
+
+    sp = 0.0;
+    for (i = 0; i < mdsize; i++) {
+      sp = sp + one[i].zvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (i = 0; i < mdsize; i++) {
+      one[i].zvelocity = one[i].zvelocity - sp;
+      ekin = ekin + one[i].zvelocity * one[i].zvelocity;
+    }
+
+    ts = tscale * ekin;
+    sc = h * Math.sqrt(tref / ts);
+
+    for (i = 0; i < mdsize; i++) {
+
+      one[i].xvelocity = one[i].xvelocity * sc;
+      one[i].yvelocity = one[i].yvelocity * sc;
+      one[i].zvelocity = one[i].zvelocity * sc;
+
+    }
+
+    /* Synchronise threads and start timer before MD simulation */
+
+    // br.DoBarrier(id);
+    // if (id == 0) JGFInstrumentor.startTimer("Section3:MolDyn:Run");
+    // br.DoBarrier(id);
+
+    /* MD simulation */
+
+    move = 0;
+    for (move = 0; move < movemx; move++) {
+
+      /* move the particles and update velocities */
+
+      for (i = 0; i < mdsize; i++) {
+        one[i].domove(side, i);
+      }
+
+      /* Barrier */
+      // br.DoBarrier(id);
+
+      if (id == 0) {
+        for (j = 0; j < 3; j++) {
+          for (i = 0; i < mdsize; i++) {
+            sh_force[j][i] = 0.0;
+          }
+        }
+      }
+
+      // md.epot[id] = 0.0;
+      // md.vir[id] = 0.0;
+      // md.interacts[id] = 0;
+      mdr_epot = 0.0;
+      mdr_vir = 0.0;
+      mdr_interacts = 0;
+
+      /* Barrier */
+      // br.DoBarrier(id);
+
+      /* compute forces */
+
+      for (i = 0 + id; i < mdsize; i += md.nthreads) {        
+//        one[i].force(side, rcoff, mdsize, i, xx, yy, zz,mdr);
+      }
+
+      /* Barrier */
+      // br.DoBarrier(id);
+
+      /* update force arrays */
+
+      if (id == 0) {
+        for (int k = 0; k < 3; k++) {
+          for (i = 0; i < mdsize; i++) {
+            for (j = 0; j <md.nthreads; j++) {
+              sh_force[k][i] += sh_force2[k][j][i];
+            }
+          }
+        }
+      }
+
+      if (id == 0) {
+        for (int k = 0; k < 3; k++) {
+          for (i = 0; i < mdsize; i++) {
+            for (j = 0; j < md.nthreads; j++) {
+              sh_force2[k][j][i] = 0.0;
+            }
+          }
+        }
+      }
+
+      if (id == 0) {
+        for (j = 1; j < md.nthreads; j++) {
+          md.epot[0] += md.epot[j];
+          md.vir[0] += md.vir[j];
+        }
+        for (j = 1; j < md.nthreads; j++) {
+          md.epot[j] = md.epot[0];
+          md.vir[j] = md.vir[0];
+        }
+        for (j = 0; j <md.nthreads; j++) {
+          md.interactions += md.interacts[j];
+        }
+      }
+
+      /* Barrier */
+      // br.DoBarrier(id);
+
+      if (id == 0) {
+        for (j = 0; j < 3; j++) {
+          for (i = 0; i < mdsize; i++) {
+            sh_force[j][i] = sh_force[j][i] * hsq2;
+          }
+        }
+      }
+
+      sum = 0.0;
+
+      /* Barrier */
+      // br.DoBarrier(id);
+
+      /* scale forces, update velocities */
+
+      for (i = 0; i < mdsize; i++) {
+        sum = sum + one[i].mkekin(hsq2, i);
+      }
+
+      ekin = sum / hsq;
+
+      vel = 0.0;
+      count = 0.0;
+
+      /* average velocity */
+
+      for (i = 0; i < mdsize; i++) {
+        velt = one[i].velavg(vaverh, h);
+        if (velt > vaverh) {
+          count = count + 1.0;
+        }
+        vel = vel + velt;
+      }
+
+      vel = vel / h;
+
+      /* temperature scale if required */
+
+      if ((move < istop) && (((move + 1) % irep) == 0)) {
+        sc = Math.sqrt(tref / (tscale * ekin));
+        for (i = 0; i < mdsize; i++) {
+          one[i].dscal(sc, 1);
+        }
+        ekin = tref / tscale;
+      }
+
+      /* sum to get full potential energy and virial */
+
+      if (((move + 1) % iprint) == 0) {
+        md.ek[id] = 24.0 * ekin;
+        md.epot[id] = 4.0 * md.epot[id];
+        etot = md.ek[id] + md.epot[id];
+        temp = tscale * ekin;
+        pres = den * 16.0 * (ekin - md.vir[id]) / mdsize;
+        vel = vel / mdsize;
+        rp = (count / mdsize) * 100.0;
+      }
+
+      // br.DoBarrier(id);
+    }
+
+    // br.DoBarrier(id);
+    // if (id == 0) JGFInstrumentor.stopTimer("Section3:MolDyn:Run");
+
+  }
+
+}
+
+class particle {
+
+  public double xcoord, ycoord, zcoord;
+  public double xvelocity, yvelocity, zvelocity;
+  int part_id;
+  int id;
+  double[][] sh_force;
+  double[][][] sh_force2;
+//  mdRunner runner;
+
+  public particle(double xcoord, double ycoord, double zcoord, double xvelocity, double yvelocity,
+      double zvelocity, double[][] sh_force, double[][][] sh_force2, int id) {
+
+    this.xcoord = xcoord;
+    this.ycoord = ycoord;
+    this.zcoord = zcoord;
+    this.xvelocity = xvelocity;
+    this.yvelocity = yvelocity;
+    this.zvelocity = zvelocity;
+    this.sh_force = sh_force;
+    this.sh_force2 = sh_force2;
+    this.id = id;
+
+  }
+
+  public void domove(double side, int part_id) {
+
+    xcoord = xcoord + xvelocity + sh_force[0][part_id];
+    ycoord = ycoord + yvelocity + sh_force[1][part_id];
+    zcoord = zcoord + zvelocity + sh_force[2][part_id];
+
+    if (xcoord < 0) {
+      xcoord = xcoord + side;
+    }
+    if (xcoord > side) {
+      xcoord = xcoord - side;
+    }
+    if (ycoord < 0) {
+      ycoord = ycoord + side;
+    }
+    if (ycoord > side) {
+      ycoord = ycoord - side;
+    }
+    if (zcoord < 0) {
+      zcoord = zcoord + side;
+    }
+    if (zcoord > side) {
+      zcoord = zcoord - side;
+    }
+
+    xvelocity = xvelocity + sh_force[0][part_id];
+    yvelocity = yvelocity + sh_force[1][part_id];
+    zvelocity = zvelocity + sh_force[2][part_id];
+
+  }
+
+  public void force(double side, double rcoff, int mdsize, int x, double xx, double yy, double zz, mdRunner mdr) {
+
+    double sideh;
+    double rcoffs;
+
+    double fxi, fyi, fzi;
+    double rd, rrd, rrd2, rrd3, rrd4, rrd6, rrd7, r148;
+    double forcex, forcey, forcez;
+
+    sideh = 0.5 * side;
+    rcoffs = rcoff * rcoff;
+
+    fxi = 0.0;
+    fyi = 0.0;
+    fzi = 0.0;
+
+    for (int i = x + 1; i < mdsize; i++) {
+      xx = this.xcoord - mdr.one[i].xcoord;
+      yy = this.ycoord - mdr.one[i].ycoord;
+      zz = this.zcoord - mdr.one[i].zcoord;
+
+      if (xx < (-sideh)) {
+        xx = xx + side;
+      }
+      if (xx > (sideh)) {
+        xx = xx - side;
+      }
+      if (yy < (-sideh)) {
+        yy = yy + side;
+      }
+      if (yy > (sideh)) {
+        yy = yy - side;
+      }
+      if (zz < (-sideh)) {
+        zz = zz + side;
+      }
+      if (zz > (sideh)) {
+        zz = zz - side;
+      }
+
+      rd = xx * xx + yy * yy + zz * zz;
+
+      if (rd <= rcoffs) {
+        rrd = 1.0 / rd;
+        rrd2 = rrd * rrd;
+        rrd3 = rrd2 * rrd;
+        rrd4 = rrd2 * rrd2;
+        rrd6 = rrd2 * rrd4;
+        rrd7 = rrd6 * rrd;
+        // md.epot[id] = md.epot[id] + (rrd6 - rrd3);
+        mdr.mdr_epot = mdr.mdr_epot + (rrd6 - rrd3);
+        r148 = rrd7 - 0.5 * rrd4;
+        // md.vir[id] = md.vir[id] - rd*r148;
+        mdr.mdr_vir = mdr.mdr_vir - rd * r148;
+        forcex = xx * r148;
+        fxi = fxi + forcex;
+
+        sh_force2[0][id][i] = sh_force2[0][id][i] - forcex;
+
+        forcey = yy * r148;
+        fyi = fyi + forcey;
+
+        sh_force2[1][id][i] = sh_force2[1][id][i] - forcey;
+
+        forcez = zz * r148;
+        fzi = fzi + forcez;
+
+        sh_force2[2][id][i] = sh_force2[2][id][i] - forcez;
+
+        // md.interacts[id]++;
+        mdr.mdr_interacts++;
+      }
+
+    }
+
+    sh_force2[0][id][x] = sh_force2[0][id][x] + fxi;
+    sh_force2[1][id][x] = sh_force2[1][id][x] + fyi;
+    sh_force2[2][id][x] = sh_force2[2][id][x] + fzi;
+
+  }
+
+  public double mkekin(double hsq2, int part_id) {
+
+    double sumt = 0.0;
+
+    xvelocity = xvelocity + sh_force[0][part_id];
+    yvelocity = yvelocity + sh_force[1][part_id];
+    zvelocity = zvelocity + sh_force[2][part_id];
+
+    sumt = (xvelocity * xvelocity) + (yvelocity * yvelocity) + (zvelocity * zvelocity);
+    return sumt;
+  }
+
+  public double velavg(double vaverh, double h) {
+
+    double velt;
+    double sq;
+
+    sq = Math.sqrt(xvelocity * xvelocity + yvelocity * yvelocity + zvelocity * zvelocity);
+
+    velt = sq;
+    return velt;
+  }
+
+  public void dscal(double sc, int incx) {
+
+    xvelocity = xvelocity * sc;
+    yvelocity = yvelocity * sc;
+    zvelocity = zvelocity * sc;
+
+  }
+
+}
+
+class random {
+
+  public int iseed;
+  public double v1, v2;
+
+  public random(int iseed, double v1, double v2) {
+    this.iseed = iseed;
+    this.v1 = v1;
+    this.v2 = v2;
+  }
+
+  public double update() {
+
+    double rand;
+    double scale = 4.656612875e-10;
+
+    int is1, is2, iss2;
+    int imult = 16807;
+    int imod = 2147483647;
+
+    if (iseed <= 0) {
+      iseed = 1;
+    }
+
+    is2 = iseed % 32768;
+    is1 = (iseed - is2) / 32768;
+    iss2 = is2 * imult;
+    is2 = iss2 % 32768;
+    is1 = (is1 * imult + (iss2 - is2) / 32768) % (65536);
+
+    iseed = (is1 * 32768 + is2) % imod;
+
+    rand = scale * iseed;
+
+    return rand;
+
+  }
+
+  public double seed() {
+
+    double s, u1, u2, r;
+    s = 1.0;
+    do {
+      u1 = update();
+      u2 = update();
+
+      v1 = 2.0 * u1 - 1.0;
+      v2 = 2.0 * u2 - 1.0;
+      s = v1 * v1 + v2 * v2;
+
+    } while (s >= 1.0);
+
+    r = Math.sqrt(-2.0 * Math.log(s) / s);
+
+    return r;
+
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/Barrier.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/Barrier.java
new file mode 100644
index 00000000..590b3a66
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/Barrier.java
@@ -0,0 +1,48 @@
+public class Barrier {
+  int numthreads;
+  int entercount;
+  boolean cleared;
+
+  public Barrier(int n) {
+    numthreads=n;
+    cleared = false;
+  }
+
+  public Barrier() {
+
+  }
+
+  public void reset() {
+    cleared = false;
+    entercount = 0;
+  }
+
+  public static void enterBarrier(Barrier b) {
+    int tmp;
+    boolean retry=true;
+
+    do {
+      if (!b.cleared) {
+        b.entercount++;
+        tmp = b.entercount;
+        if (tmp==b.numthreads) {
+          if(b.numthreads > 1)
+            b.cleared=true;
+          b.entercount--;
+          return;
+        }
+        retry=false;
+      }
+    } while(retry);
+
+    while(true) {
+      if (b.cleared) {
+        b.entercount--;
+        int count = b.entercount;
+        if (count==0)
+          b.cleared=false;
+        return;
+      }
+    }
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/DoubleWrapper.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/DoubleWrapper.java
new file mode 100644
index 00000000..c0bd06da
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/DoubleWrapper.java
@@ -0,0 +1,6 @@
+public class DoubleWrapper {
+  public DoubleWrapper() {
+
+  }
+  double d;
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/IntWrapper.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/IntWrapper.java
new file mode 100644
index 00000000..8bf875d3
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/IntWrapper.java
@@ -0,0 +1,6 @@
+public class IntWrapper {
+  public IntWrapper() {
+
+  }
+  int i;
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFInstrumentor.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFInstrumentor.java
new file mode 100644
index 00000000..80db8282
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFInstrumentor.java
@@ -0,0 +1,201 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 1999.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFInstrumentor{
+
+  protected HashMap timers;
+  protected HashMap data; 
+
+  public JGFInstrumentor() {
+    timers = new HashMap();
+    data = new HashMap(); 
+  }
+
+  public static void addTimer (String name, HashMap timers){
+
+    if (timers.containsKey(name)) {
+      System.printString("JGFInstrumentor.addTimer: warning -  timer " + name + 
+          " already exists\n");
+    }
+    else {
+      timers.put(name, new JGFTimer(name));
+    }
+  }
+
+  public static void addTimer (String name, String opname, HashMap timers){
+
+    if (timers.containsKey(name)) {
+      System.printString("JGFInstrumentor.addTimer: warning -  timer " + name + 
+          " already exists\n");
+    }
+    else {
+      timers.put(name, new JGFTimer(name,opname));
+    }
+
+  }
+
+  public static void addTimer (String name, String opname, int size, HashMap timers){
+
+    if (timers.containsKey(name)) {
+      System.printString("JGFInstrumentor.addTimer: warning -  timer " + name +
+          " already exists\n");
+    }
+    else {
+      timers.put(name, new JGFTimer(name,opname,size));
+    }
+
+  }
+
+  public static void startTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).start();
+    }
+    else {
+      System.printString("JGFInstrumentor.startTimer: failed -  timer " + name + 
+          " does not exist\n");
+    }
+
+  }
+
+  public static void stopTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).stop();
+    }
+    else {
+      System.printString("JGFInstrumentor.stopTimer: failed -  timer " + name + 
+          " does not exist\n");
+    }
+  }
+
+  public static void addOpsToTimer(String name, double count, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).addops(count);
+    }
+    else {
+      System.printString("JGFInstrumentor.addOpsToTimer: failed -  timer " + name + 
+          " does not exist\n");
+    }
+  }  
+
+  public static void addTimeToTimer(String name, double added_time, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).addtime(added_time);
+    }
+    else {
+      System.printString("JGFInstrumentor.addTimeToTimer: failed -  timer " + name +
+          " does not exist\n");
+    }
+
+
+
+  }
+
+  public static double readTimer(String name, HashMap timers){
+    double time; 
+    if (timers.containsKey(name)) {
+      time = ((JGFTimer) timers.get(name)).time;
+    }
+    else {
+      System.printString("JGFInstrumentor.readTimer: failed -  timer " + name + 
+          " does not exist\n");
+      time = 0.0; 
+    }
+    return time; 
+  }  
+
+  public static void resetTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).reset();
+    }
+    else {
+      System.printString("JGFInstrumentor.resetTimer: failed -  timer " + name +
+          " does not exist\n");
+    }
+  }
+
+  public static void printTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).print();
+    }
+    else {
+      System.printString("JGFInstrumentor.printTimer: failed -  timer " + name +
+          " does not exist\n");
+    }
+  }
+
+  public static void printperfTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).printperf();
+    }
+    else {
+      System.printString("JGFInstrumentor.printTimer: failed -  timer " + name +
+          " does not exist\n");
+    }
+  }
+
+  public static void storeData(String name, Object obj, HashMap data){
+    data.put(name,obj); 
+  }
+
+  public static void retrieveData(String name, Object obj, HashMap data){
+    obj = data.get(name); 
+  }
+
+  public static void printHeader(int section, int size,int nthreads) {
+
+    String header, base; 
+
+    header = "";
+    base = "Java Grande Forum Thread Benchmark Suite - Version 1.0 - Section "; 
+
+    if (section == 1)
+    {
+      header = base + "1";
+    }
+    else if (section == 2)
+    {
+      if (size == 0)
+        header = base + "2 - Size A";
+      else if (size == 1)
+        header = base + "2 - Size B";
+      else if (size == 2)
+        header = base + "2 - Size C";
+    }
+    else if (section == 3)
+    {
+      if (size == 0)
+        header = base + "3 - Size A";
+      else if (size == 1)
+        header = base + "3 - Size B";
+      else if (size == 2)
+        header = base + "3 - Size C";
+    }
+
+    System.printString(header + "\n"); 
+
+    if (nthreads == 1) {
+      System.printString("Executing on " + nthreads + " thread\n");
+    }
+    else {
+      System.printString("Executing on " + nthreads + " threads\n");
+    }
+
+    System.printString(" \n");
+  } 
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBench.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBench.java
new file mode 100644
index 00000000..828ed06a
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBench.java
@@ -0,0 +1,653 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFMolDynBench {
+  public int ITERS;
+  public double LENGTH;
+  public double m;
+  public double mu;
+  public double kb;
+  public double TSIM;
+  public double deltat;
+
+  public int PARTSIZE;
+
+  public double[] epot;
+  public double[] vir;
+  public double[] ek;
+
+  int size,mm;
+  int[] datasizes;
+
+  public int interactions;
+  public int[] interacts;
+
+  public int nthreads;
+  public JGFInstrumentor instr;
+
+  public JGFMolDynBench(int nthreads) {
+    this.nthreads=nthreads;
+  }
+
+  public void JGFsetsize(int size){
+    this.size = size;
+  }
+
+  public void JGFinitialise(){
+    interactions = 0;
+    datasizes = new int[3];
+    datasizes[0] = 8;
+    datasizes[1] = 13;
+    datasizes[2] = 11;
+
+    mm = datasizes[size];
+    PARTSIZE = mm*mm*mm*4;
+    ITERS = 100;
+    LENGTH = 50e-10;
+    m = 4.0026;
+    mu = 1.66056e-27;
+    kb = 1.38066e-23;
+    TSIM = 50;
+    deltat = 5e-16;
+  }
+
+  public static void JGFapplication(JGFMolDynBench mold) { 
+    double sh_force [][];
+    double sh_force2 [][][];
+    int partsize, numthreads;
+    partsize = mold.PARTSIZE;
+    numthreads = mold.nthreads;
+
+    sh_force = new double[3][partsize];
+    sh_force2 = new double[3][numthreads][partsize];
+    mold.epot = new double[numthreads];
+    mold.vir  = new double[numthreads];
+    mold.ek   = new double[numthreads];
+    mold.interacts = new int[numthreads];
+//    for(int i=0;i<numthreads;i++) {
+//      mold.epot[i]=new double();
+//      mold.vir[i]=new double();
+//      mold.ek[i]=new double();
+//      mold.interacts[i]=new IntWrapper();
+//    }
+
+    // spawn threads 
+    MDWrap[] thobjects = new MDWrap[numthreads];
+
+    for(int i=0;i<numthreads;i++) {
+      thobjects[i] = new MDWrap(new mdRunner(i,mold.mm,sh_force,sh_force2,mold.nthreads,mold));
+    }
+
+    /*
+       boolean waitfordone=true;
+       while(waitfordone) {
+       if (mybarr.done)
+       waitfordone=false;
+       }
+       */
+
+    for(int i=0;i<numthreads;i++) {
+      //thobjects[i].md.start(mid[i]);
+      thobjects[i].md.run();
+    }
+  }
+
+  public void JGFvalidate(){
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dev = Math.fabs(ek[0] - refval[size]);
+    if (dev > 1.0e-10 ){
+      //System.printString("Validation failed\n");
+      //System.printString("Kinetic Energy = " + (long)ek[0] + "  " + (long)dev + "  " + size + "\n");
+    }
+  }
+}
+
+class mdRunner {
+
+  double count;
+  int id,i,j,k,lg,mm;
+  double l,rcoff,rcoffs,side,sideh,hsq,hsq2,vel,velt;
+  double a,r,sum,tscale,sc,ekin,ts,sp;
+  double den;
+  double tref;
+  double h;
+  double vaver,vaverh,rand;
+  double etot,temp,pres,rp;
+  double u1, u2, s, xx, yy, zz;
+  double xvelocity, yvelocity, zvelocity;
+
+  double [][] sh_force;
+  double [][][] sh_force2;
+
+  int ijk,npartm,iseed,tint;
+  int irep;
+  int istop;
+  int iprint;
+
+  JGFMolDynBench mymd;
+  int nthreads;
+
+  public mdRunner(int id, int mm, double [][] sh_force, double [][][] sh_force2, 
+      int nthreads, JGFMolDynBench mymd) {
+    this.id=id;
+    this.mm=mm;
+    this.sh_force=sh_force;
+    this.sh_force2=sh_force2;
+    this.nthreads = nthreads;
+    this.mymd = mymd;
+    count = 0.0;
+    den = 0.83134;
+    tref = 0.722;
+    h = 0.064;
+    irep = 10;
+    istop = 19;
+    iprint = 10;
+  } 
+
+  public void init(particle[] one, int mdsize) {
+    int id=this.id;
+    for (int lg=0; lg<=1; lg++) {
+      for (int i=0; i<mm; i++) {
+        for (int j=0; j<mm; j++) {
+          for (int k=0; k<mm; k++) {
+            one[ijk] = new particle((i*a+lg*a*0.5),(j*a+lg*a*0.5),(k*a),
+                xvelocity,yvelocity,zvelocity,sh_force,sh_force2,id,one);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+
+    for (int lg=1; lg<=2; lg++) {
+      for (int i=0; i<mm; i++) {
+        for (int j=0; j<mm; j++) {
+          for (int k=0; k<mm; k++) {
+            one[ijk] = new particle((i*a+(2-lg)*a*0.5),(j*a+(lg-1)*a*0.5),
+                (k*a+a*0.5),xvelocity,yvelocity,zvelocity,sh_force,sh_force2,id,one);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+
+    /* Initialise velocities */
+
+    iseed = 0;
+    double v1 = 0.0;
+    double v2 = 0.0;
+    random randnum = new random(iseed,v1,v2);
+
+
+    for (int i=0; i<mdsize; i+=2) {
+      r  = randnum.seed();
+      one[i].xvelocity = r*randnum.v1;
+      one[i+1].xvelocity  = r*randnum.v2;
+    }
+
+    for (int i=0; i<mdsize; i+=2) {
+      r  = randnum.seed();
+      one[i].yvelocity = r*randnum.v1;
+      one[i+1].yvelocity  = r*randnum.v2;
+    }
+
+    for (int i=0; i<mdsize; i+=2) {
+      r  = randnum.seed();
+      one[i].zvelocity = r*randnum.v1;
+      one[i+1].zvelocity  = r*randnum.v2;
+    }
+
+
+    /* velocity scaling */
+
+    ekin = 0.0;
+    sp = 0.0;
+
+    for(int i=0;i<mdsize;i++) {
+      sp = sp + one[i].xvelocity;
+    }
+    sp = sp / mdsize;
+
+    for(int i=0;i<mdsize;i++) {
+      one[i].xvelocity = one[i].xvelocity - sp;
+      ekin = ekin + one[i].xvelocity*one[i].xvelocity;
+    }
+
+    sp = 0.0;
+    for(int i=0;i<mdsize;i++) {
+      sp = sp + one[i].yvelocity;
+    }
+    sp = sp / mdsize;
+
+    for(int i=0;i<mdsize;i++) {
+      one[i].yvelocity = one[i].yvelocity - sp;
+      ekin = ekin + one[i].yvelocity*one[i].yvelocity;
+    }
+
+
+    sp = 0.0;
+    for(int i=0;i<mdsize;i++) {
+      sp = sp + one[i].zvelocity;
+    }
+    sp = sp / mdsize;
+
+    for(int i=0;i<mdsize;i++) {
+      one[i].zvelocity = one[i].zvelocity - sp;
+      ekin = ekin + one[i].zvelocity*one[i].zvelocity;
+    }
+
+    ts = tscale * ekin;
+    sc = h * Math.sqrt(tref/ts);
+
+
+    for(int i=0;i<mdsize;i++) {
+
+      one[i].xvelocity = one[i].xvelocity * sc;     
+      one[i].yvelocity = one[i].yvelocity * sc;     
+      one[i].zvelocity = one[i].zvelocity * sc;     
+
+    }
+
+  }
+
+  public void doinit(int mdsize) {
+    for(int j=0;j<3;j++) {
+      double[] sh=sh_force[j];
+      for (int i=0;i<mdsize;i++) {
+        sh[i] = 0.0;
+      }
+    }
+  }
+
+
+  public void doinit2(int mdsize) {
+    for(int k=0;k<3;k++) {
+      double[] sh=sh_force[k];
+      double [][] sha=sh_force2[k];
+      for(int j=0;j<nthreads;j++) {
+        double[] sha2=sha[j];
+        for(int i=0;i<mdsize;i++) {
+          sh[i] += sha2[i];
+        }
+      }
+    }
+
+    for(int k=0;k<3;k++) {
+      double [][] sh1=sh_force2[k];
+      for(int j=0;j<nthreads;j++) {
+        double[] sh2=sh1[j];
+        for(int i=0;i<mdsize;i++) {
+
+
+          sh2[i] = 0.0;
+        }
+      }
+    }
+
+    for(int j=1;j<nthreads;j++) {
+      mymd.epot[0] += mymd.epot[j];
+      mymd.vir[0] += mymd.vir[j];
+    }
+    for(int j=1;j<nthreads;j++) {       
+      mymd.epot[j] = mymd.epot[0];
+      mymd.vir[j] = mymd.vir[0];
+    }
+    for(int j=0;j<nthreads;j++) {
+      mymd.interactions += mymd.interacts[j]; 
+    }
+
+    for (int j=0;j<3;j++) {
+      double sh[]=sh_force[j];
+      for (int i=0;i<mdsize;i++) {
+        sh[i] = sh[i] * hsq2;
+      }
+    }
+  }
+
+  public void run() {
+    /* Parameter determination */
+
+    int mdsize;
+    double tmpden;
+    int movemx=50;
+    particle[] one;
+    int id;
+    id=this.id;
+    mdsize = mymd.PARTSIZE;
+    one=new particle[mdsize];
+    l = mymd.LENGTH;
+    tmpden = den;
+    side = Math.pow((mdsize/tmpden),0.3333333);
+    rcoff = mm/4.0;
+
+    a = side/mm;
+    sideh = side*0.5;
+    hsq = h*h;
+    hsq2 = hsq*0.5;
+    npartm = mdsize - 1;
+    rcoffs = rcoff * rcoff;
+    tscale = 16.0 / (1.0 * mdsize - 1.0);
+    vaver = 1.13 * Math.sqrt(tref / 24.0);
+    vaverh = vaver * h;
+
+    /* Particle Generation */
+
+    xvelocity = 0.0;
+    yvelocity = 0.0;
+    zvelocity = 0.0;
+    ijk = 0;
+    init(one, mdsize);
+
+
+    /* Synchronise threads and start timer before MD simulation */
+
+
+    /* MD simulation */
+
+    for (int move=0;move<movemx;move++) {
+      /* move the particles and update velocities */
+      for (int i=0;i<mdsize;i++) {
+        one[i].domove(side,i);       
+      }
+
+
+      if(id==0) {
+        doinit(mdsize);
+      }
+
+      mymd.epot[id] = 0.0;
+      mymd.vir[id] = 0.0;
+      mymd.interacts[id] = 0;
+
+
+
+      /* compute forces */
+      for (int i=0+id;i<mdsize;i+=nthreads) {
+        MDWorker worker=new MDWorker(mdsize);
+        one[i].force(side,rcoff,mdsize,i,xx,yy,zz,mymd,worker); 
+      }
+
+
+      /* update force arrays */
+      if(id == 0) {
+        doinit2(mdsize);
+      }
+
+
+      /*scale forces, update velocities */
+      sum = 0.0;
+      for (int i=0;i<mdsize;i++) {
+        sum = sum + one[i].mkekin(hsq2,i);  
+      }
+
+      ekin = sum/hsq;
+
+      vel = 0.0;
+      count = 0.0;
+
+      /* average velocity */
+
+      for (int i=0;i<mdsize;i++) {
+        velt = one[i].velavg(vaverh,h);
+        if(velt > vaverh) { count = count + 1.0; }
+        vel = vel + velt;                    
+      }
+
+      vel = vel / h;
+
+      /* temperature scale if required */
+
+      if((move < istop) && (((move+1) % irep) == 0)) {
+        sc = Math.sqrt(tref / (tscale*ekin));
+        for (int i=0;i<mdsize;i++) {
+          one[i].dscal(sc,1);
+        }
+        ekin = tref / tscale;
+      }
+
+      /* sum to get full potential energy and virial */
+
+      if(((move+1) % iprint) == 0) {
+        mymd.ek[id] = 24.0*ekin;
+        mymd.epot[id] = 4.0*mymd.epot[id];
+        etot = mymd.ek[id] + mymd.epot[id];
+        temp = tscale * ekin;
+        pres = tmpden * 16.0 * (ekin - mymd.vir[id]) / mdsize;
+        vel = vel / mdsize; 
+        rp = (count / mdsize) * 100.0;
+      }
+
+      //if (id == 0) JGFInstrumentor.stopTimer("Section3:MolDyn:Run", instr.timers);
+    }
+  }
+}
+
+  class particle {
+
+    public double xcoord, ycoord, zcoord;
+    public double xvelocity,yvelocity,zvelocity;
+    int part_id;
+    int id;
+    double [][] sh_force;
+    double [][][] sh_force2;
+    particle[] one;
+
+    public particle(double xcoord, double ycoord, double zcoord, double xvelocity,
+        double yvelocity,double zvelocity, double [][] sh_force, 
+        double [][][] sh_force2,int id, particle[] one) {
+
+      this.xcoord = xcoord; 
+      this.ycoord = ycoord; 
+      this.zcoord = zcoord;
+      this.xvelocity = xvelocity;
+      this.yvelocity = yvelocity;
+      this.zvelocity = zvelocity;
+      this.sh_force = sh_force;
+      this.sh_force2 = sh_force2;
+      this.id=id;
+      this.one=one;
+    }
+
+    public void domove(double side,int part_id) {
+
+      xcoord = xcoord + xvelocity + sh_force[0][part_id];
+      ycoord = ycoord + yvelocity + sh_force[1][part_id];
+      zcoord = zcoord + zvelocity + sh_force[2][part_id];
+
+      if(xcoord < 0) { xcoord = xcoord + side; } 
+      if(xcoord > side) { xcoord = xcoord - side; }
+      if(ycoord < 0) { ycoord = ycoord + side; }
+      if(ycoord > side) { ycoord = ycoord - side; }
+      if(zcoord < 0) { zcoord = zcoord + side; }
+      if(zcoord > side) { zcoord = zcoord - side; }
+
+      xvelocity = xvelocity + sh_force[0][part_id];
+      yvelocity = yvelocity + sh_force[1][part_id];
+      zvelocity = zvelocity + sh_force[2][part_id];
+
+    }
+
+//    public void force(double side, double rcoff,int mdsize,int x, double xx, double yy, double zz, JGFMolDynBench mymd) {
+      public void force(double side, double rcoff,int mdsize,int x, double xx, double yy, double zz, JGFMolDynBench mymd, MDWorker worker) {
+
+      double sideh;
+      double rcoffs;
+
+      double fxi,fyi,fzi;
+      double rd,rrd,rrd2,rrd3,rrd4,rrd6,rrd7,r148;
+      double forcex,forcey,forcez;
+      int id=this.id;
+      sideh = 0.5*side; 
+      rcoffs = rcoff*rcoff;
+
+      fxi = 0.0;
+      fyi = 0.0;
+      fzi = 0.0;
+
+      for (int i=x+1;i<mdsize;i++) {
+        xx = this.xcoord - one[i].xcoord;
+        yy = this.ycoord - one[i].ycoord;
+        zz = this.zcoord - one[i].zcoord;
+
+        if(xx < (-sideh)) { xx = xx + side; }
+        if(xx > (sideh))  { xx = xx - side; }
+        if(yy < (-sideh)) { yy = yy + side; }
+        if(yy > (sideh))  { yy = yy - side; }
+        if(zz < (-sideh)) { zz = zz + side; }
+        if(zz > (sideh))  { zz = zz - side; }
+
+
+        rd = xx*xx + yy*yy + zz*zz;
+
+        if(rd <= rcoffs) {
+          rrd = 1.0/rd;
+          rrd2 = rrd*rrd;
+          rrd3 = rrd2*rrd;
+          rrd4 = rrd2*rrd2;
+          rrd6 = rrd2*rrd4;
+          rrd7 = rrd6*rrd;
+//          mymd.epot[id] += (rrd6 - rrd3);
+          worker.epot+=(rrd6 - rrd3);
+          r148 = rrd7 - 0.5*rrd4;
+//          mymd.vir[id] += - rd*r148;
+          worker.vir+= - rd*r148;
+          forcex = xx * r148;
+          fxi = fxi + forcex;
+
+//          sh_force2[0][id][i] = sh_force2[0][id][i] - forcex;
+          worker.sh_force2[0][i]=worker.sh_force2[0][i]-forcex;
+
+          forcey = yy * r148;
+          fyi = fyi + forcey;
+
+//          sh_force2[1][id][i] = sh_force2[1][id][i] - forcey;
+          worker.sh_force2[1][i]=worker.sh_force2[1][i]-forcex;
+
+          forcez = zz * r148;
+          fzi = fzi + forcez;
+
+//          sh_force2[2][id][i] = sh_force2[2][id][i] - forcez;
+          worker.sh_force2[2][i]=worker.sh_force2[2][i]-forcez;
+
+//          mymd.interacts[id]++;
+          worker.interacts++;
+        }
+
+      }
+
+//      sh_force2[0][id][x] = sh_force2[0][id][x] + fxi;
+//      sh_force2[1][id][x] = sh_force2[1][id][x] + fyi;
+//      sh_force2[2][id][x] = sh_force2[2][id][x] + fzi;
+      
+      worker.sh_force2[0][x]=worker.sh_force2[0][x]-fxi;
+      worker.sh_force2[1][x]=worker.sh_force2[1][x]-fyi;
+      worker.sh_force2[2][x]=worker.sh_force2[2][x]-fzi;
+
+    }
+
+    public double mkekin(double hsq2,int part_id) {
+
+      double sumt = 0.0; 
+
+      xvelocity = xvelocity + sh_force[0][part_id]; 
+      yvelocity = yvelocity + sh_force[1][part_id]; 
+      zvelocity = zvelocity + sh_force[2][part_id]; 
+
+      sumt = (xvelocity*xvelocity)+(yvelocity*yvelocity)+(zvelocity*zvelocity);
+      return sumt;
+    }
+
+    public double velavg(double vaverh,double h) {
+
+      double velt;
+      double sq;
+
+      sq = Math.sqrt(xvelocity*xvelocity + yvelocity*yvelocity +
+          zvelocity*zvelocity);
+
+      velt = sq;
+      return velt;
+    }
+
+    public void dscal(double sc,int incx) {
+      xvelocity = xvelocity * sc;
+      yvelocity = yvelocity * sc;   
+      zvelocity = zvelocity * sc;   
+    }
+  }
+
+  class random {
+
+    public int iseed;
+    public double v1,v2;
+
+    public random(int iseed,double v1,double v2) {
+      this.iseed = iseed;
+      this.v1 = v1;
+      this.v2 = v2;
+    }
+
+    public double update() {
+
+      double rand;
+      double scale= 4.656612875e-10;
+
+      int is1,is2,iss2;
+      int imult=16807;
+      int imod = 2147483647;
+
+      if (iseed<=0) { iseed = 1; }
+
+      is2 = iseed % 32768;
+      is1 = (iseed-is2)/32768;
+      iss2 = is2 * imult;
+      is2 = iss2 % 32768;
+      is1 = (is1*imult+(iss2-is2)/32768) % (65536);
+
+      iseed = (is1*32768+is2) % imod;
+
+      rand = scale * iseed;
+
+      return rand;
+
+    }
+
+    public double seed() {
+
+      double s,u1,u2,r;
+      s = 1.0;
+      do {
+        u1 = update();
+        u2 = update();
+
+        v1 = 2.0 * u1 - 1.0;
+        v2 = 2.0 * u2 - 1.0;
+        s = v1*v1 + v2*v2;
+
+      } while (s >= 1.0);
+
+      r = Math.sqrt(-2.0*Math.log(s)/s);
+
+      return r;
+
+    }
+  }
+
+
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeA.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeA.java
new file mode 100644
index 00000000..61437401
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeA.java
@@ -0,0 +1,75 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFMolDynBenchSizeA { 
+
+    public static void main(String argv[]){
+    int nthreads;
+    if(argv.length != 0 ) {
+      nthreads = Integer.parseInt(argv[0]);
+    } else {
+      System.printString("The no of threads has not been specified, defaulting to 1\n");
+      System.printString("  " + "\n");
+      nthreads = 1;
+    }
+
+    JGFInstrumentor instr = new JGFInstrumentor();
+    JGFInstrumentor.printHeader(3,0,nthreads);
+
+    JGFMolDynBench mold;
+    mold = new JGFMolDynBench(nthreads); 
+    int size = 0;
+    JGFInstrumentor.addTimer("Section3:MolDyn:Total", "Solutions",size, instr.timers);
+    JGFInstrumentor.addTimer("Section3:MolDyn:Run", "Interactions",size, instr.timers);
+
+    mold.JGFsetsize(size); 
+
+    JGFInstrumentor.startTimer("Section3:MolDyn:Total", instr.timers);
+
+    JGFMolDynBench tmp;
+    mold.JGFinitialise(); 
+    JGFMolDynBench.JGFapplication(mold); 
+
+    /* Validate data */
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dval;
+    dval = mold.ek[0].d;
+    double dev = Math.fabs(dval - refval[size]);
+    long l = (long) refval[size] *1000000;
+    long r = (long) dval * 1000000;
+    if (l != r ){
+      System.printString("Validation failed\n");
+      System.printString("Kinetic Energy = " + (long)dval + "  " + (long)dev + "  " + size + "\n");
+    }
+
+    JGFInstrumentor.stopTimer("Section3:MolDyn:Total", instr.timers);
+    double interactions;
+    interactions = mold.interactions;
+
+    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Run", (double) interactions, instr.timers);
+    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Total", 1, instr.timers);
+
+    JGFInstrumentor.printTimer("Section3:MolDyn:Run", instr.timers); 
+    JGFInstrumentor.printTimer("Section3:MolDyn:Total", instr.timers); 
+    System.printString("Finished\n");
+  }
+}
+
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeB.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeB.java
new file mode 100644
index 00000000..d1d5ff2c
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeB.java
@@ -0,0 +1,75 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFMolDynBenchSizeB { 
+
+    public static void main(String argv[]){
+    int nthreads;
+    if(argv.length != 0 ) {
+      nthreads = Integer.parseInt(argv[0]);
+    } else {
+      System.printString("The no of threads has not been specified, defaulting to 1\n");
+      System.printString("  " + "\n");
+      nthreads = 1;
+    }
+
+//    JGFInstrumentor instr = new JGFInstrumentor();
+//    JGFInstrumentor.printHeader(3,1,nthreads);
+
+    JGFMolDynBench mold;
+    mold = new JGFMolDynBench(nthreads); 
+    int size = 0;
+//    JGFInstrumentor.addTimer("Section3:MolDyn:Total", "Solutions",size, instr.timers);
+//    JGFInstrumentor.addTimer("Section3:MolDyn:Run", "Interactions",size, instr.timers);
+
+    mold.JGFsetsize(size); 
+
+//    JGFInstrumentor.startTimer("Section3:MolDyn:Total", instr.timers);
+
+    JGFMolDynBench tmp;
+    mold.JGFinitialise(); 
+    JGFMolDynBench.JGFapplication(mold); 
+
+    /* Validate data */
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dval;
+    dval = mold.ek[0];
+    double dev = Math.fabs(dval - refval[size]);
+    long l = (long) refval[size] *1000000;
+    long r = (long) dval * 1000000;
+    if (l != r ){
+      System.printString("Validation failed\n");
+      System.printString("Kinetic Energy = " + (long)dval + "  " + (long)dev + "  " + size + "\n");
+    }
+
+//    JGFInstrumentor.stopTimer("Section3:MolDyn:Total", instr.timers);
+    double interactions;
+    interactions = mold.interactions;
+
+//    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Run", (double) interactions, instr.timers);
+//    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Total", 1, instr.timers);
+
+//    JGFInstrumentor.printTimer("Section3:MolDyn:Run", instr.timers); 
+//    JGFInstrumentor.printTimer("Section3:MolDyn:Total", instr.timers); 
+//    System.printString("Finished\n");
+  }
+}
+
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeC.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeC.java
new file mode 100644
index 00000000..170dffb2
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFMolDynBenchSizeC.java
@@ -0,0 +1,77 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFMolDynBenchSizeC { 
+
+    public static void main(String argv[]){
+    int nthreads;
+    if(argv.length != 0 ) {
+      nthreads = Integer.parseInt(argv[0]);
+    } else {
+      System.printString("The no of threads has not been specified, defaulting to 1\n");
+      System.printString("  " + "\n");
+      nthreads = 1;
+    }
+
+    JGFInstrumentor instr = new JGFInstrumentor();
+    JGFInstrumentor.printHeader(3,2,nthreads);
+
+    JGFMolDynBench mold;
+    mold = new JGFMolDynBench(nthreads); 
+    int size = 2;
+    JGFInstrumentor.addTimer("Section3:MolDyn:Total", "Solutions",size, instr.timers);
+    JGFInstrumentor.addTimer("Section3:MolDyn:Run", "Interactions",size, instr.timers);
+
+    mold.JGFsetsize(size); 
+
+    JGFInstrumentor.startTimer("Section3:MolDyn:Total", instr.timers);
+
+    JGFMolDynBench tmp;
+    mold.JGFinitialise(); 
+    JGFMolDynBench.JGFapplication(mold); 
+
+    /* Validate data */
+    /*
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dval;
+    dval = mold.ek[0].d;
+    double dev = Math.fabs(dval - refval[size]);
+    long l = (long) refval[size] *1000000;
+    long r = (long) dval * 1000000;
+    if (l != r ){
+      System.printString("Validation failed\n");
+      System.printString("Kinetic Energy = " + (long)dval + "  " + (long)dev + "  " + size + "\n");
+    }
+
+    JGFInstrumentor.stopTimer("Section3:MolDyn:Total", instr.timers);
+    double interactions;
+    interactions = mold.interactions;
+
+    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Run", (double) interactions, instr.timers);
+    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Total", 1, instr.timers);
+
+    JGFInstrumentor.printTimer("Section3:MolDyn:Run", instr.timers); 
+    JGFInstrumentor.printTimer("Section3:MolDyn:Total", instr.timers); 
+    */
+    System.printString("Finished\n");
+  }
+}
+
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFTimer.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFTimer.java
new file mode 100644
index 00000000..4e1d168f
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/JGFTimer.java
@@ -0,0 +1,123 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 1999.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+
+public class JGFTimer {
+
+  public String name; 
+  public String opname; 
+  public double time; 
+  public double opcount; 
+  public long calls; 
+  public int size;
+
+  private long start_time;
+  private boolean on; 
+
+  public JGFTimer(String name, String opname){
+    this.size = -1;
+    this.name = name;
+    this.opname = opname;
+    reset(); 
+  }
+
+  public JGFTimer(String name, String opname, int size){
+    this.name = name;
+    this.opname = opname;
+    this.size = size;
+    reset();
+  }
+
+  public JGFTimer(String name){
+    this.name = name;
+    this.opname = "";
+    reset();
+  }
+
+
+
+  public void start(){
+    if (on) System.printString("Warning timer " + " was already turned on\n");
+    on = true; 
+    start_time = System.currentTimeMillis();
+  }
+
+
+  public void stop(){
+    time += (double) (System.currentTimeMillis()-start_time) / 1000.;
+    if (!on) System.printString("Warning timer " + " wasn't turned on\n");
+    calls++;
+    on = false;  
+  }
+
+  public void addops(double count){
+    opcount += count;
+  } 
+
+  public void addtime(double added_time){
+    time += added_time;
+  }
+
+  public void reset(){
+    time = 0.0; 
+    calls = 0; 
+    opcount = 0; 
+    on = false;
+  }
+
+  public double perf(){
+    return opcount / time; 
+  }
+
+  public void longprint(){
+    System.printString("Timer            Calls         Time(s)       Performance("+opname+"/s)\n");   
+    System.printString(name + "           " + calls +    "           "  +  (long)time + "        " + (long)this.perf() + "\n");
+  }
+
+  public void print(){
+    if (opname.equals("")) {
+      System.printString(name + "   " + (long)time + " (s)\n");
+    }
+    else {
+      if(size == 0) {
+        System.printString(name + ":SizeA" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else if (size == 1) {
+        System.printString(name + ":SizeB" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else if (size == 2) {
+        System.printString(name + ":SizeC" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else{
+        System.printString(name + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      }
+    }
+  }
+
+
+  public void printperf(){
+
+    String name;
+    name = this.name; 
+
+    // pad name to 40 characters
+    while ( name.length() < 40 ) name = name + " "; 
+
+    System.printString(name + "\t" + (long)this.perf() + "\t"
+        + " ("+opname+"/s)\n");  
+  }
+
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/MDWorker.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/MDWorker.java
new file mode 100644
index 00000000..c8e08a68
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/MDWorker.java
@@ -0,0 +1,12 @@
+public class MDWorker {
+
+  int interacts;
+  double vir;
+  double epot;
+  double sh_force2[][];
+  
+  public MDWorker(int partsize) {
+    sh_force2=new double[3][partsize];
+  }
+
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/MDWrap.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/MDWrap.java
new file mode 100644
index 00000000..5c4ed746
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/MDWrap.java
@@ -0,0 +1,9 @@
+public class MDWrap {
+    public mdRunner md;
+    public MDWrap() {
+    }
+
+    public MDWrap(mdRunner m) {
+	md=m;
+    }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup3/TournamentBarrier.java b/Robust/src/Benchmarks/oooJava/moldyn/backup3/TournamentBarrier.java
new file mode 100755
index 00000000..96bf4f51
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup3/TournamentBarrier.java
@@ -0,0 +1,96 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         *
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+
+// This implements a simple tournament-based barrier, using entirely its
+// own synchronisation. At present Yield() is called to stop busy-waiting
+// processes hogging the processor(s)!
+
+public class TournamentBarrier {
+  // Array of flags indicating whether the given process and all those
+  // for which it is responsible have finished. The "sense" of this
+  // array alternates with each barrier, to prevent having to
+  // reinitialise.
+  boolean[] IsDone;
+  public int maxBusyIter;
+  int numThreads;
+
+  public TournamentBarrier(int n) {
+    numThreads = n;
+    maxBusyIter = 1;
+    // Superclass constructor should record the number of threads
+    // and thread manager.
+    //super(n);
+
+    // Initialise the IsDone array. The choice of initial value is
+    // arbitrary, but must be consistent!
+    IsDone = new boolean[numThreads];
+    for(int i = 0; i < n; i++) {
+      IsDone[i] = false;
+    }
+  }
+
+  // Uses the manager's debug function, so this can only be used after
+  // construction!
+  public void debug(String s) {
+    //System.err.println("Debug message" + s);
+  }
+
+  /*
+  public void setMaxBusyIter(int b) {
+    maxBusyIter = b;
+  }
+  */
+
+  public void DoBarrier(int myid) {
+    int b;
+     //debug("Thread " + myid + " checking in");
+
+    int roundmask = 3;
+    boolean donevalue = !IsDone[myid];
+
+    while(((myid & roundmask) == 0) && (roundmask<(numThreads<<2))) {
+      int spacing = (roundmask+1) >> 2;
+      for(int i=1; i<=3 && myid+i*spacing < numThreads; i++) {
+         //debug("Thread " + myid + " waiting for thread " + (myid+i*spacing));
+        b = maxBusyIter;
+        while(IsDone[myid+i*spacing] != donevalue) {
+          b--;
+          if(b==0) {
+            //Thread.yield();
+            b = maxBusyIter;
+          }
+        }
+      }
+      roundmask = (roundmask << 2) + 3;
+    }
+     //debug("Thread " + myid + " reporting done");
+    IsDone[myid] = donevalue;
+    b = maxBusyIter;
+    while(IsDone[0] != donevalue) {
+      b--;
+      if(b==0) {
+        //Thread.yield();
+        b = maxBusyIter;
+      }
+    }
+    //debug("Thread " + myid + " checking out");
+
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/Barrier.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/Barrier.java
new file mode 100644
index 00000000..590b3a66
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/Barrier.java
@@ -0,0 +1,48 @@
+public class Barrier {
+  int numthreads;
+  int entercount;
+  boolean cleared;
+
+  public Barrier(int n) {
+    numthreads=n;
+    cleared = false;
+  }
+
+  public Barrier() {
+
+  }
+
+  public void reset() {
+    cleared = false;
+    entercount = 0;
+  }
+
+  public static void enterBarrier(Barrier b) {
+    int tmp;
+    boolean retry=true;
+
+    do {
+      if (!b.cleared) {
+        b.entercount++;
+        tmp = b.entercount;
+        if (tmp==b.numthreads) {
+          if(b.numthreads > 1)
+            b.cleared=true;
+          b.entercount--;
+          return;
+        }
+        retry=false;
+      }
+    } while(retry);
+
+    while(true) {
+      if (b.cleared) {
+        b.entercount--;
+        int count = b.entercount;
+        if (count==0)
+          b.cleared=false;
+        return;
+      }
+    }
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/DoubleWrapper.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/DoubleWrapper.java
new file mode 100644
index 00000000..c0bd06da
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/DoubleWrapper.java
@@ -0,0 +1,6 @@
+public class DoubleWrapper {
+  public DoubleWrapper() {
+
+  }
+  double d;
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/IntWrapper.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/IntWrapper.java
new file mode 100644
index 00000000..8bf875d3
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/IntWrapper.java
@@ -0,0 +1,6 @@
+public class IntWrapper {
+  public IntWrapper() {
+
+  }
+  int i;
+}
\ No newline at end of file
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFInstrumentor.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFInstrumentor.java
new file mode 100644
index 00000000..80db8282
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFInstrumentor.java
@@ -0,0 +1,201 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 1999.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFInstrumentor{
+
+  protected HashMap timers;
+  protected HashMap data; 
+
+  public JGFInstrumentor() {
+    timers = new HashMap();
+    data = new HashMap(); 
+  }
+
+  public static void addTimer (String name, HashMap timers){
+
+    if (timers.containsKey(name)) {
+      System.printString("JGFInstrumentor.addTimer: warning -  timer " + name + 
+          " already exists\n");
+    }
+    else {
+      timers.put(name, new JGFTimer(name));
+    }
+  }
+
+  public static void addTimer (String name, String opname, HashMap timers){
+
+    if (timers.containsKey(name)) {
+      System.printString("JGFInstrumentor.addTimer: warning -  timer " + name + 
+          " already exists\n");
+    }
+    else {
+      timers.put(name, new JGFTimer(name,opname));
+    }
+
+  }
+
+  public static void addTimer (String name, String opname, int size, HashMap timers){
+
+    if (timers.containsKey(name)) {
+      System.printString("JGFInstrumentor.addTimer: warning -  timer " + name +
+          " already exists\n");
+    }
+    else {
+      timers.put(name, new JGFTimer(name,opname,size));
+    }
+
+  }
+
+  public static void startTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).start();
+    }
+    else {
+      System.printString("JGFInstrumentor.startTimer: failed -  timer " + name + 
+          " does not exist\n");
+    }
+
+  }
+
+  public static void stopTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).stop();
+    }
+    else {
+      System.printString("JGFInstrumentor.stopTimer: failed -  timer " + name + 
+          " does not exist\n");
+    }
+  }
+
+  public static void addOpsToTimer(String name, double count, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).addops(count);
+    }
+    else {
+      System.printString("JGFInstrumentor.addOpsToTimer: failed -  timer " + name + 
+          " does not exist\n");
+    }
+  }  
+
+  public static void addTimeToTimer(String name, double added_time, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).addtime(added_time);
+    }
+    else {
+      System.printString("JGFInstrumentor.addTimeToTimer: failed -  timer " + name +
+          " does not exist\n");
+    }
+
+
+
+  }
+
+  public static double readTimer(String name, HashMap timers){
+    double time; 
+    if (timers.containsKey(name)) {
+      time = ((JGFTimer) timers.get(name)).time;
+    }
+    else {
+      System.printString("JGFInstrumentor.readTimer: failed -  timer " + name + 
+          " does not exist\n");
+      time = 0.0; 
+    }
+    return time; 
+  }  
+
+  public static void resetTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).reset();
+    }
+    else {
+      System.printString("JGFInstrumentor.resetTimer: failed -  timer " + name +
+          " does not exist\n");
+    }
+  }
+
+  public static void printTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).print();
+    }
+    else {
+      System.printString("JGFInstrumentor.printTimer: failed -  timer " + name +
+          " does not exist\n");
+    }
+  }
+
+  public static void printperfTimer(String name, HashMap timers){
+    if (timers.containsKey(name)) {
+      ((JGFTimer) timers.get(name)).printperf();
+    }
+    else {
+      System.printString("JGFInstrumentor.printTimer: failed -  timer " + name +
+          " does not exist\n");
+    }
+  }
+
+  public static void storeData(String name, Object obj, HashMap data){
+    data.put(name,obj); 
+  }
+
+  public static void retrieveData(String name, Object obj, HashMap data){
+    obj = data.get(name); 
+  }
+
+  public static void printHeader(int section, int size,int nthreads) {
+
+    String header, base; 
+
+    header = "";
+    base = "Java Grande Forum Thread Benchmark Suite - Version 1.0 - Section "; 
+
+    if (section == 1)
+    {
+      header = base + "1";
+    }
+    else if (section == 2)
+    {
+      if (size == 0)
+        header = base + "2 - Size A";
+      else if (size == 1)
+        header = base + "2 - Size B";
+      else if (size == 2)
+        header = base + "2 - Size C";
+    }
+    else if (section == 3)
+    {
+      if (size == 0)
+        header = base + "3 - Size A";
+      else if (size == 1)
+        header = base + "3 - Size B";
+      else if (size == 2)
+        header = base + "3 - Size C";
+    }
+
+    System.printString(header + "\n"); 
+
+    if (nthreads == 1) {
+      System.printString("Executing on " + nthreads + " thread\n");
+    }
+    else {
+      System.printString("Executing on " + nthreads + " threads\n");
+    }
+
+    System.printString(" \n");
+  } 
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBench.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBench.java
new file mode 100644
index 00000000..d7b6fb4e
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBench.java
@@ -0,0 +1,692 @@
+/**************************************************************************
+ * * Java Grande Forum Benchmark Suite - Thread Version 1.0 * * produced by * *
+ * Java Grande Benchmarking Project * * at * * Edinburgh Parallel Computing
+ * Centre * * email: epcc-javagrande@epcc.ed.ac.uk * * * This version copyright
+ * (c) The University of Edinburgh, 2001. * All rights reserved. * *
+ **************************************************************************/
+public class JGFMolDynBench {
+  public int ITERS;
+  public double LENGTH;
+  public double m;
+  public double mu;
+  public double kb;
+  public double TSIM;
+  public double deltat;
+
+  public int PARTSIZE;
+
+  public double[] epot;
+  public double[] vir;
+  public double[] ek;
+
+  int size, mm;
+  int[] datasizes;
+
+  public int interactions;
+  public int[] interacts;
+
+  public int nthreads;
+  public JGFInstrumentor instr;
+  public int workload;
+
+  public JGFMolDynBench(int nthreads,int workload) {
+    this.nthreads = nthreads;
+    this.workload=workload;
+  }
+
+  public void JGFsetsize(int size) {
+    this.size = size;
+  }
+
+  public void JGFinitialise() {
+    interactions = 0;
+    datasizes = new int[3];
+    datasizes[0] = 8;
+    datasizes[1] = 13;
+    datasizes[2] = 11;
+
+    mm = datasizes[size];
+    PARTSIZE = mm * mm * mm * 4;
+    ITERS = 100;
+    LENGTH = 50e-10;
+    m = 4.0026;
+    mu = 1.66056e-27;
+    kb = 1.38066e-23;
+    TSIM = 50;
+    deltat = 5e-16;
+  }
+
+  public static void JGFapplication(JGFMolDynBench mold) {
+    double sh_force[][];
+    double sh_force2[][][];
+    int partsize, numthreads;
+    partsize = mold.PARTSIZE;
+    numthreads = mold.nthreads;
+
+    sh_force = new double[3][partsize];
+    sh_force2 = new double[3][numthreads][partsize];
+    mold.epot = new double[numthreads];
+    mold.vir = new double[numthreads];
+    mold.ek = new double[numthreads];
+    mold.interacts = new int[numthreads];
+    // for(int i=0;i<numthreads;i++) {
+    // mold.epot[i]=new double();
+    // mold.vir[i]=new double();
+    // mold.ek[i]=new double();
+    // mold.interacts[i]=new IntWrapper();
+    // }
+
+    // spawn threads
+    MDWrap[] thobjects = new MDWrap[numthreads];
+
+    for (int i = 0; i < numthreads; i++) {
+      thobjects[i] = new MDWrap(new mdRunner(i, mold.mm, sh_force, sh_force2, mold.nthreads, mold,mold.workload));
+    }
+
+    /*
+     * boolean waitfordone=true; while(waitfordone) { if (mybarr.done)
+     * waitfordone=false; }
+     */
+
+    for (int i = 0; i < numthreads; i++) {
+      // thobjects[i].md.start(mid[i]);
+      thobjects[i].md.run();
+    }
+  }
+
+  public void JGFvalidate() {
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dev = Math.fabs(ek[0] - refval[size]);
+    if (dev > 1.0e-10) {
+      // System.printString("Validation failed\n");
+      // System.printString("Kinetic Energy = " + (long)ek[0] + "  " + (long)dev
+      // + "  " + size + "\n");
+    }
+  }
+}
+
+class mdRunner {
+
+  double count;
+  int id, i, j, k, lg, mm;
+  double l, rcoff, rcoffs, side, sideh, hsq, hsq2, vel, velt;
+  double a, r, sum, tscale, sc, ekin, ts, sp;
+  double den;
+  double tref;
+  double h;
+  double vaver, vaverh, rand;
+  double etot, temp, pres, rp;
+  double u1, u2, s, xx, yy, zz;
+  double xvelocity, yvelocity, zvelocity;
+
+  double[][] sh_force;
+  double[][][] sh_force2;
+
+  int ijk, npartm, iseed, tint;
+  int irep;
+  int istop;
+  int iprint;
+
+  JGFMolDynBench mymd;
+  int nthreads;
+  int workload;
+
+  public mdRunner(int id, int mm, double[][] sh_force, double[][][] sh_force2, int nthreads,
+      JGFMolDynBench mymd, int workload) {
+    this.id = id;
+    this.mm = mm;
+    this.sh_force = sh_force;
+    this.sh_force2 = sh_force2;
+    this.nthreads = nthreads;
+    this.mymd = mymd;
+    count = 0.0;
+    den = 0.83134;
+    tref = 0.722;
+    h = 0.064;
+    irep = 10;
+    istop = 19;
+    iprint = 10;
+    this.workload=workload;
+  }
+
+  public void init(particle[] one, int mdsize) {
+    int id = this.id;
+    for (int lg = 0; lg <= 1; lg++) {
+      for (int i = 0; i < mm; i++) {
+        for (int j = 0; j < mm; j++) {
+          for (int k = 0; k < mm; k++) {
+            one[ijk] =
+                new particle((i * a + lg * a * 0.5), (j * a + lg * a * 0.5), (k * a), xvelocity,
+                    yvelocity, zvelocity, sh_force, sh_force2, id, one);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+
+    for (int lg = 1; lg <= 2; lg++) {
+      for (int i = 0; i < mm; i++) {
+        for (int j = 0; j < mm; j++) {
+          for (int k = 0; k < mm; k++) {
+            one[ijk] =
+                new particle((i * a + (2 - lg) * a * 0.5), (j * a + (lg - 1) * a * 0.5),
+                    (k * a + a * 0.5), xvelocity, yvelocity, zvelocity, sh_force, sh_force2, id,
+                    one);
+            ijk = ijk + 1;
+          }
+        }
+      }
+    }
+
+    /* Initialise velocities */
+
+    iseed = 0;
+    double v1 = 0.0;
+    double v2 = 0.0;
+    random randnum = new random(iseed, v1, v2);
+
+    for (int i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].xvelocity = r * randnum.v1;
+      one[i + 1].xvelocity = r * randnum.v2;
+    }
+
+    for (int i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].yvelocity = r * randnum.v1;
+      one[i + 1].yvelocity = r * randnum.v2;
+    }
+
+    for (int i = 0; i < mdsize; i += 2) {
+      r = randnum.seed();
+      one[i].zvelocity = r * randnum.v1;
+      one[i + 1].zvelocity = r * randnum.v2;
+    }
+
+    /* velocity scaling */
+
+    ekin = 0.0;
+    sp = 0.0;
+
+    for (int i = 0; i < mdsize; i++) {
+      sp = sp + one[i].xvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (int i = 0; i < mdsize; i++) {
+      one[i].xvelocity = one[i].xvelocity - sp;
+      ekin = ekin + one[i].xvelocity * one[i].xvelocity;
+    }
+
+    sp = 0.0;
+    for (int i = 0; i < mdsize; i++) {
+      sp = sp + one[i].yvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (int i = 0; i < mdsize; i++) {
+      one[i].yvelocity = one[i].yvelocity - sp;
+      ekin = ekin + one[i].yvelocity * one[i].yvelocity;
+    }
+
+    sp = 0.0;
+    for (int i = 0; i < mdsize; i++) {
+      sp = sp + one[i].zvelocity;
+    }
+    sp = sp / mdsize;
+
+    for (int i = 0; i < mdsize; i++) {
+      one[i].zvelocity = one[i].zvelocity - sp;
+      ekin = ekin + one[i].zvelocity * one[i].zvelocity;
+    }
+
+    ts = tscale * ekin;
+    sc = h * Math.sqrt(tref / ts);
+
+    for (int i = 0; i < mdsize; i++) {
+
+      one[i].xvelocity = one[i].xvelocity * sc;
+      one[i].yvelocity = one[i].yvelocity * sc;
+      one[i].zvelocity = one[i].zvelocity * sc;
+
+    }
+
+  }
+
+  public void doinit(int mdsize) {
+    for (int j = 0; j < 3; j++) {
+      double[] sh = sh_force[j];
+      for (int i = 0; i < mdsize; i++) {
+        sh[i] = 0.0;
+      }
+    }
+  }
+
+  public void doinit2(int mdsize) {
+    for (int k = 0; k < 3; k++) {
+      double[] sh = sh_force[k];
+      double[][] sha = sh_force2[k];
+      for (int j = 0; j < nthreads; j++) {
+        double[] sha2 = sha[j];
+        for (int i = 0; i < mdsize; i++) {
+          sh[i] += sha2[i];
+        }
+      }
+    }
+
+    for (int k = 0; k < 3; k++) {
+      double[][] sh1 = sh_force2[k];
+      for (int j = 0; j < nthreads; j++) {
+        double[] sh2 = sh1[j];
+        for (int i = 0; i < mdsize; i++) {
+
+          sh2[i] = 0.0;
+        }
+      }
+    }
+
+    for (int j = 1; j < nthreads; j++) {
+      mymd.epot[0] += mymd.epot[j];
+      mymd.vir[0] += mymd.vir[j];
+    }
+    for (int j = 1; j < nthreads; j++) {
+      mymd.epot[j] = mymd.epot[0];
+      mymd.vir[j] = mymd.vir[0];
+    }
+    for (int j = 0; j < nthreads; j++) {
+      mymd.interactions += mymd.interacts[j];
+    }
+
+    for (int j = 0; j < 3; j++) {
+      double sh[] = sh_force[j];
+      for (int i = 0; i < mdsize; i++) {
+        sh[i] = sh[i] * hsq2;
+      }
+    }
+  }
+
+  public void run() {
+    /* Parameter determination */
+
+    int mdsize;
+    double tmpden;
+    int movemx = 50;
+    particle[] one;
+    int id;
+    id = this.id;
+    mdsize = mymd.PARTSIZE;
+    one = new particle[mdsize];
+    l = mymd.LENGTH;
+    tmpden = den;
+    side = Math.pow((mdsize / tmpden), 0.3333333);
+    rcoff = mm / 4.0;
+
+    a = side / mm;
+    sideh = side * 0.5;
+    hsq = h * h;
+    hsq2 = hsq * 0.5;
+    npartm = mdsize - 1;
+    rcoffs = rcoff * rcoff;
+    tscale = 16.0 / (1.0 * mdsize - 1.0);
+    vaver = 1.13 * Math.sqrt(tref / 24.0);
+    vaverh = vaver * h;
+
+    /* Particle Generation */
+
+    xvelocity = 0.0;
+    yvelocity = 0.0;
+    zvelocity = 0.0;
+    ijk = 0;
+    init(one, mdsize);
+
+    /* Synchronise threads and start timer before MD simulation */
+
+    /* MD simulation */
+
+    for (int move = 0; move < movemx; move++) {
+      /* move the particles and update velocities */
+      for (int i = 0; i < mdsize; i++) {
+        one[i].domove(side, i);
+      }
+
+      if (id == 0) {
+        doinit(mdsize);
+      }
+
+      mymd.epot[id] = 0.0;
+      mymd.vir[id] = 0.0;
+      mymd.interacts[id] = 0;
+
+      /* compute forces */
+      int numThread = nthreads;
+      int lworkload = workload;
+      // for (int i=0+id;i<mdsize;i+=numThread) {
+      for (int i = 0 ; i < mdsize; i += lworkload) {
+
+        int ilow = i;
+        int iupper = i + lworkload;
+        if (iupper > mdsize) {
+          iupper = mdsize;
+        }
+        int l_size = iupper - ilow;
+
+        sese parallel{
+          MDWorker worker = new MDWorker(mdsize);
+          for(int idx=ilow;idx<iupper;idx++){
+//            one[i].force(side, rcoff, mdsize, i, xx, yy, zz, mymd, worker);
+            one[idx].force(side, rcoff, mdsize, idx, xx, yy, zz, mymd, worker);
+          }
+        }
+
+        sese serial{
+          for (int k = 0; k < 3; k++) {
+            for (int j = 0; j < mdsize; j++) {
+              sh_force[k][j] += worker.sh_force2[k][j];
+            }
+          }
+          mymd.epot[0] += worker.epot;
+          mymd.vir[0] += worker.vir;
+          mymd.interactions += worker.interacts;
+        }
+
+      }
+
+      for (int k = 0; k < 3; k++) {
+        for (int j = 0; j < mdsize; j++) {
+          sh_force[k][j] = sh_force[k][j] * hsq2;
+        }
+      }
+
+      /* update force arrays */
+      // if(id == 0) {
+      // doinit2(mdsize);
+      // }
+
+      /* scale forces, update velocities */
+      sum = 0.0;
+      for (int i = 0; i < mdsize; i++) {
+        sum = sum + one[i].mkekin(hsq2, i);
+      }
+
+      ekin = sum / hsq;
+
+      vel = 0.0;
+      count = 0.0;
+
+      /* average velocity */
+
+      for (int i = 0; i < mdsize; i++) {
+        velt = one[i].velavg(vaverh, h);
+        if (velt > vaverh) {
+          count = count + 1.0;
+        }
+        vel = vel + velt;
+      }
+
+      vel = vel / h;
+
+      /* temperature scale if required */
+
+      if ((move < istop) && (((move + 1) % irep) == 0)) {
+        sc = Math.sqrt(tref / (tscale * ekin));
+        for (int i = 0; i < mdsize; i++) {
+          one[i].dscal(sc, 1);
+        }
+        ekin = tref / tscale;
+      }
+
+      /* sum to get full potential energy and virial */
+
+      if (((move + 1) % iprint) == 0) {
+        mymd.ek[id] = 24.0 * ekin;
+        mymd.epot[id] = 4.0 * mymd.epot[id];
+        etot = mymd.ek[id] + mymd.epot[id];
+        temp = tscale * ekin;
+        pres = tmpden * 16.0 * (ekin - mymd.vir[id]) / mdsize;
+        vel = vel / mdsize;
+        rp = (count / mdsize) * 100.0;
+      }
+
+      // if (id == 0) JGFInstrumentor.stopTimer("Section3:MolDyn:Run",
+      // instr.timers);
+    }
+  }
+}
+
+class particle {
+
+  public double xcoord, ycoord, zcoord;
+  public double xvelocity, yvelocity, zvelocity;
+  int part_id;
+  int id;
+  double[][] sh_force;
+  double[][][] sh_force2;
+  particle[] one;
+
+  public particle(double xcoord, double ycoord, double zcoord, double xvelocity, double yvelocity,
+      double zvelocity, double[][] sh_force, double[][][] sh_force2, int id, particle[] one) {
+
+    this.xcoord = xcoord;
+    this.ycoord = ycoord;
+    this.zcoord = zcoord;
+    this.xvelocity = xvelocity;
+    this.yvelocity = yvelocity;
+    this.zvelocity = zvelocity;
+    this.sh_force = sh_force;
+    this.sh_force2 = sh_force2;
+    this.id = id;
+    this.one = one;
+  }
+
+  public void domove(double side, int part_id) {
+
+    xcoord = xcoord + xvelocity + sh_force[0][part_id];
+    ycoord = ycoord + yvelocity + sh_force[1][part_id];
+    zcoord = zcoord + zvelocity + sh_force[2][part_id];
+
+    if (xcoord < 0) {
+      xcoord = xcoord + side;
+    }
+    if (xcoord > side) {
+      xcoord = xcoord - side;
+    }
+    if (ycoord < 0) {
+      ycoord = ycoord + side;
+    }
+    if (ycoord > side) {
+      ycoord = ycoord - side;
+    }
+    if (zcoord < 0) {
+      zcoord = zcoord + side;
+    }
+    if (zcoord > side) {
+      zcoord = zcoord - side;
+    }
+
+    xvelocity = xvelocity + sh_force[0][part_id];
+    yvelocity = yvelocity + sh_force[1][part_id];
+    zvelocity = zvelocity + sh_force[2][part_id];
+
+  }
+
+  // public void force(double side, double rcoff,int mdsize,int x, double xx,
+  // double yy, double zz, JGFMolDynBench mymd) {
+  public void force(double side, double rcoff, int mdsize, int x, double xx, double yy, double zz,
+      JGFMolDynBench mymd, MDWorker worker) {
+
+    double sideh;
+    double rcoffs;
+
+    double fxi, fyi, fzi;
+    double rd, rrd, rrd2, rrd3, rrd4, rrd6, rrd7, r148;
+    double forcex, forcey, forcez;
+    int id = this.id;
+    sideh = 0.5 * side;
+    rcoffs = rcoff * rcoff;
+
+    fxi = 0.0;
+    fyi = 0.0;
+    fzi = 0.0;
+
+    for (int i = x + 1; i < mdsize; i++) {
+      xx = this.xcoord - one[i].xcoord;
+      yy = this.ycoord - one[i].ycoord;
+      zz = this.zcoord - one[i].zcoord;
+
+      if (xx < (-sideh)) {
+        xx = xx + side;
+      }
+      if (xx > (sideh)) {
+        xx = xx - side;
+      }
+      if (yy < (-sideh)) {
+        yy = yy + side;
+      }
+      if (yy > (sideh)) {
+        yy = yy - side;
+      }
+      if (zz < (-sideh)) {
+        zz = zz + side;
+      }
+      if (zz > (sideh)) {
+        zz = zz - side;
+      }
+
+      rd = xx * xx + yy * yy + zz * zz;
+
+      if (rd <= rcoffs) {
+        rrd = 1.0 / rd;
+        rrd2 = rrd * rrd;
+        rrd3 = rrd2 * rrd;
+        rrd4 = rrd2 * rrd2;
+        rrd6 = rrd2 * rrd4;
+        rrd7 = rrd6 * rrd;
+        // mymd.epot[id] += (rrd6 - rrd3);
+        worker.epot += (rrd6 - rrd3);
+        r148 = rrd7 - 0.5 * rrd4;
+        // mymd.vir[id] += - rd*r148;
+        worker.vir += -rd * r148;
+        forcex = xx * r148;
+        fxi = fxi + forcex;
+
+        // sh_force2[0][id][i] = sh_force2[0][id][i] - forcex;
+        worker.sh_force2[0][i] = worker.sh_force2[0][i] - forcex;
+
+        forcey = yy * r148;
+        fyi = fyi + forcey;
+
+        // sh_force2[1][id][i] = sh_force2[1][id][i] - forcey;
+        worker.sh_force2[1][i] = worker.sh_force2[1][i] - forcey;
+
+        forcez = zz * r148;
+        fzi = fzi + forcez;
+
+        // sh_force2[2][id][i] = sh_force2[2][id][i] - forcez;
+        worker.sh_force2[2][i] = worker.sh_force2[2][i] - forcez;
+
+        // mymd.interacts[id]++;
+        worker.interacts++;
+      }
+
+    }
+
+    // sh_force2[0][id][x] = sh_force2[0][id][x] + fxi;
+    // sh_force2[1][id][x] = sh_force2[1][id][x] + fyi;
+    // sh_force2[2][id][x] = sh_force2[2][id][x] + fzi;
+
+    worker.sh_force2[0][x] = worker.sh_force2[0][x] + fxi;
+    worker.sh_force2[1][x] = worker.sh_force2[1][x] + fyi;
+    worker.sh_force2[2][x] = worker.sh_force2[2][x] + fzi;
+
+  }
+
+  public double mkekin(double hsq2, int part_id) {
+
+    double sumt = 0.0;
+
+    xvelocity = xvelocity + sh_force[0][part_id];
+    yvelocity = yvelocity + sh_force[1][part_id];
+    zvelocity = zvelocity + sh_force[2][part_id];
+
+    sumt = (xvelocity * xvelocity) + (yvelocity * yvelocity) + (zvelocity * zvelocity);
+    return sumt;
+  }
+
+  public double velavg(double vaverh, double h) {
+
+    double velt;
+    double sq;
+
+    sq = Math.sqrt(xvelocity * xvelocity + yvelocity * yvelocity + zvelocity * zvelocity);
+
+    velt = sq;
+    return velt;
+  }
+
+  public void dscal(double sc, int incx) {
+    xvelocity = xvelocity * sc;
+    yvelocity = yvelocity * sc;
+    zvelocity = zvelocity * sc;
+  }
+}
+
+class random {
+
+  public int iseed;
+  public double v1, v2;
+
+  public random(int iseed, double v1, double v2) {
+    this.iseed = iseed;
+    this.v1 = v1;
+    this.v2 = v2;
+  }
+
+  public double update() {
+
+    double rand;
+    double scale = 4.656612875e-10;
+
+    int is1, is2, iss2;
+    int imult = 16807;
+    int imod = 2147483647;
+
+    if (iseed <= 0) {
+      iseed = 1;
+    }
+
+    is2 = iseed % 32768;
+    is1 = (iseed - is2) / 32768;
+    iss2 = is2 * imult;
+    is2 = iss2 % 32768;
+    is1 = (is1 * imult + (iss2 - is2) / 32768) % (65536);
+
+    iseed = (is1 * 32768 + is2) % imod;
+
+    rand = scale * iseed;
+
+    return rand;
+
+  }
+
+  public double seed() {
+
+    double s, u1, u2, r;
+    s = 1.0;
+    do {
+      u1 = update();
+      u2 = update();
+
+      v1 = 2.0 * u1 - 1.0;
+      v2 = 2.0 * u2 - 1.0;
+      s = v1 * v1 + v2 * v2;
+
+    } while (s >= 1.0);
+
+    r = Math.sqrt(-2.0 * Math.log(s) / s);
+
+    return r;
+
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeA.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeA.java
new file mode 100644
index 00000000..61437401
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeA.java
@@ -0,0 +1,75 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFMolDynBenchSizeA { 
+
+    public static void main(String argv[]){
+    int nthreads;
+    if(argv.length != 0 ) {
+      nthreads = Integer.parseInt(argv[0]);
+    } else {
+      System.printString("The no of threads has not been specified, defaulting to 1\n");
+      System.printString("  " + "\n");
+      nthreads = 1;
+    }
+
+    JGFInstrumentor instr = new JGFInstrumentor();
+    JGFInstrumentor.printHeader(3,0,nthreads);
+
+    JGFMolDynBench mold;
+    mold = new JGFMolDynBench(nthreads); 
+    int size = 0;
+    JGFInstrumentor.addTimer("Section3:MolDyn:Total", "Solutions",size, instr.timers);
+    JGFInstrumentor.addTimer("Section3:MolDyn:Run", "Interactions",size, instr.timers);
+
+    mold.JGFsetsize(size); 
+
+    JGFInstrumentor.startTimer("Section3:MolDyn:Total", instr.timers);
+
+    JGFMolDynBench tmp;
+    mold.JGFinitialise(); 
+    JGFMolDynBench.JGFapplication(mold); 
+
+    /* Validate data */
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dval;
+    dval = mold.ek[0].d;
+    double dev = Math.fabs(dval - refval[size]);
+    long l = (long) refval[size] *1000000;
+    long r = (long) dval * 1000000;
+    if (l != r ){
+      System.printString("Validation failed\n");
+      System.printString("Kinetic Energy = " + (long)dval + "  " + (long)dev + "  " + size + "\n");
+    }
+
+    JGFInstrumentor.stopTimer("Section3:MolDyn:Total", instr.timers);
+    double interactions;
+    interactions = mold.interactions;
+
+    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Run", (double) interactions, instr.timers);
+    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Total", 1, instr.timers);
+
+    JGFInstrumentor.printTimer("Section3:MolDyn:Run", instr.timers); 
+    JGFInstrumentor.printTimer("Section3:MolDyn:Total", instr.timers); 
+    System.printString("Finished\n");
+  }
+}
+
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeB.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeB.java
new file mode 100644
index 00000000..c4e710f9
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeB.java
@@ -0,0 +1,77 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFMolDynBenchSizeB { 
+
+    public static void main(String argv[]){
+    int nthreads;
+    int workload;
+    if(argv.length != 0 ) {
+      nthreads = Integer.parseInt(argv[0]);
+      workload=Integer.parseInt(argv[1]);
+    } else {
+      System.printString("The no of threads has not been specified, defaulting to 1\n");
+      System.printString("  " + "\n");
+      nthreads = 1;
+    }
+
+//    JGFInstrumentor instr = new JGFInstrumentor();
+//    JGFInstrumentor.printHeader(3,1,nthreads);
+
+    JGFMolDynBench mold;
+    mold = new JGFMolDynBench(nthreads,workload); 
+    int size = 1;
+//    JGFInstrumentor.addTimer("Section3:MolDyn:Total", "Solutions",size, instr.timers);
+//    JGFInstrumentor.addTimer("Section3:MolDyn:Run", "Interactions",size, instr.timers);
+
+    mold.JGFsetsize(size); 
+
+//    JGFInstrumentor.startTimer("Section3:MolDyn:Total", instr.timers);
+
+    JGFMolDynBench tmp;
+    mold.JGFinitialise(); 
+    JGFMolDynBench.JGFapplication(mold); 
+
+    /* Validate data */
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dval;
+    dval = mold.ek[0];
+    double dev = Math.fabs(dval - refval[size]);
+    long l = (long) refval[size] *1000000;
+    long r = (long) dval * 1000000;
+    if (l != r ){
+      System.printString("Validation failed\n");
+      System.printString("Kinetic Energy = " + (long)dval + "  " + (long)dev + "  " + size + "\n");
+    }
+
+//    JGFInstrumentor.stopTimer("Section3:MolDyn:Total", instr.timers);
+    double interactions;
+    interactions = mold.interactions;
+
+//    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Run", (double) interactions, instr.timers);
+//    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Total", 1, instr.timers);
+
+//    JGFInstrumentor.printTimer("Section3:MolDyn:Run", instr.timers); 
+//    JGFInstrumentor.printTimer("Section3:MolDyn:Total", instr.timers); 
+//    System.printString("Finished\n");
+  }
+}
+
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeC.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeC.java
new file mode 100644
index 00000000..170dffb2
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFMolDynBenchSizeC.java
@@ -0,0 +1,77 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+public class JGFMolDynBenchSizeC { 
+
+    public static void main(String argv[]){
+    int nthreads;
+    if(argv.length != 0 ) {
+      nthreads = Integer.parseInt(argv[0]);
+    } else {
+      System.printString("The no of threads has not been specified, defaulting to 1\n");
+      System.printString("  " + "\n");
+      nthreads = 1;
+    }
+
+    JGFInstrumentor instr = new JGFInstrumentor();
+    JGFInstrumentor.printHeader(3,2,nthreads);
+
+    JGFMolDynBench mold;
+    mold = new JGFMolDynBench(nthreads); 
+    int size = 2;
+    JGFInstrumentor.addTimer("Section3:MolDyn:Total", "Solutions",size, instr.timers);
+    JGFInstrumentor.addTimer("Section3:MolDyn:Run", "Interactions",size, instr.timers);
+
+    mold.JGFsetsize(size); 
+
+    JGFInstrumentor.startTimer("Section3:MolDyn:Total", instr.timers);
+
+    JGFMolDynBench tmp;
+    mold.JGFinitialise(); 
+    JGFMolDynBench.JGFapplication(mold); 
+
+    /* Validate data */
+    /*
+    double[] refval = new double[2];
+    refval[0] = 1731.4306625334357;
+    refval[1] = 7397.392307839352;
+    double dval;
+    dval = mold.ek[0].d;
+    double dev = Math.fabs(dval - refval[size]);
+    long l = (long) refval[size] *1000000;
+    long r = (long) dval * 1000000;
+    if (l != r ){
+      System.printString("Validation failed\n");
+      System.printString("Kinetic Energy = " + (long)dval + "  " + (long)dev + "  " + size + "\n");
+    }
+
+    JGFInstrumentor.stopTimer("Section3:MolDyn:Total", instr.timers);
+    double interactions;
+    interactions = mold.interactions;
+
+    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Run", (double) interactions, instr.timers);
+    JGFInstrumentor.addOpsToTimer("Section3:MolDyn:Total", 1, instr.timers);
+
+    JGFInstrumentor.printTimer("Section3:MolDyn:Run", instr.timers); 
+    JGFInstrumentor.printTimer("Section3:MolDyn:Total", instr.timers); 
+    */
+    System.printString("Finished\n");
+  }
+}
+
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFTimer.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFTimer.java
new file mode 100644
index 00000000..4e1d168f
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/JGFTimer.java
@@ -0,0 +1,123 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         * 
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 1999.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+
+public class JGFTimer {
+
+  public String name; 
+  public String opname; 
+  public double time; 
+  public double opcount; 
+  public long calls; 
+  public int size;
+
+  private long start_time;
+  private boolean on; 
+
+  public JGFTimer(String name, String opname){
+    this.size = -1;
+    this.name = name;
+    this.opname = opname;
+    reset(); 
+  }
+
+  public JGFTimer(String name, String opname, int size){
+    this.name = name;
+    this.opname = opname;
+    this.size = size;
+    reset();
+  }
+
+  public JGFTimer(String name){
+    this.name = name;
+    this.opname = "";
+    reset();
+  }
+
+
+
+  public void start(){
+    if (on) System.printString("Warning timer " + " was already turned on\n");
+    on = true; 
+    start_time = System.currentTimeMillis();
+  }
+
+
+  public void stop(){
+    time += (double) (System.currentTimeMillis()-start_time) / 1000.;
+    if (!on) System.printString("Warning timer " + " wasn't turned on\n");
+    calls++;
+    on = false;  
+  }
+
+  public void addops(double count){
+    opcount += count;
+  } 
+
+  public void addtime(double added_time){
+    time += added_time;
+  }
+
+  public void reset(){
+    time = 0.0; 
+    calls = 0; 
+    opcount = 0; 
+    on = false;
+  }
+
+  public double perf(){
+    return opcount / time; 
+  }
+
+  public void longprint(){
+    System.printString("Timer            Calls         Time(s)       Performance("+opname+"/s)\n");   
+    System.printString(name + "           " + calls +    "           "  +  (long)time + "        " + (long)this.perf() + "\n");
+  }
+
+  public void print(){
+    if (opname.equals("")) {
+      System.printString(name + "   " + (long)time + " (s)\n");
+    }
+    else {
+      if(size == 0) {
+        System.printString(name + ":SizeA" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else if (size == 1) {
+        System.printString(name + ":SizeB" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else if (size == 2) {
+        System.printString(name + ":SizeC" + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      } else{
+        System.printString(name + "\t" + (long)time + " (s) \t " + (long)this.perf() + "\t" + " ("+opname+"/s)\n");
+      }
+    }
+  }
+
+
+  public void printperf(){
+
+    String name;
+    name = this.name; 
+
+    // pad name to 40 characters
+    while ( name.length() < 40 ) name = name + " "; 
+
+    System.printString(name + "\t" + (long)this.perf() + "\t"
+        + " ("+opname+"/s)\n");  
+  }
+
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/MDWorker.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/MDWorker.java
new file mode 100644
index 00000000..ba579f34
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/MDWorker.java
@@ -0,0 +1,17 @@
+public class MDWorker {
+
+  int interacts;
+  double vir;
+  double epot;
+  double sh_force2[][];
+  
+  public MDWorker(int partsize) {
+    sh_force2=new double[3][partsize];
+//    for(int i=0;i<3;i++){
+//      for(int j=0;j<partsize;j++){
+//        sh_force2[i][j]=0;
+//      }
+//    }
+  }
+
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/MDWrap.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/MDWrap.java
new file mode 100644
index 00000000..5c4ed746
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/MDWrap.java
@@ -0,0 +1,9 @@
+public class MDWrap {
+    public mdRunner md;
+    public MDWrap() {
+    }
+
+    public MDWrap(mdRunner m) {
+	md=m;
+    }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/backup_working/TournamentBarrier.java b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/TournamentBarrier.java
new file mode 100755
index 00000000..96bf4f51
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/backup_working/TournamentBarrier.java
@@ -0,0 +1,96 @@
+/**************************************************************************
+ *                                                                         *
+ *         Java Grande Forum Benchmark Suite - Thread Version 1.0          *
+ *                                                                         *
+ *                            produced by                                  *
+ *                                                                         *
+ *                  Java Grande Benchmarking Project                       *
+ *                                                                         *
+ *                                at                                       *
+ *                                                                         *
+ *                Edinburgh Parallel Computing Centre                      *
+ *                                                                         *
+ *                email: epcc-javagrande@epcc.ed.ac.uk                     *
+ *                                                                         *
+ *                                                                         *
+ *      This version copyright (c) The University of Edinburgh, 2001.      *
+ *                         All rights reserved.                            *
+ *                                                                         *
+ **************************************************************************/
+
+// This implements a simple tournament-based barrier, using entirely its
+// own synchronisation. At present Yield() is called to stop busy-waiting
+// processes hogging the processor(s)!
+
+public class TournamentBarrier {
+  // Array of flags indicating whether the given process and all those
+  // for which it is responsible have finished. The "sense" of this
+  // array alternates with each barrier, to prevent having to
+  // reinitialise.
+  boolean[] IsDone;
+  public int maxBusyIter;
+  int numThreads;
+
+  public TournamentBarrier(int n) {
+    numThreads = n;
+    maxBusyIter = 1;
+    // Superclass constructor should record the number of threads
+    // and thread manager.
+    //super(n);
+
+    // Initialise the IsDone array. The choice of initial value is
+    // arbitrary, but must be consistent!
+    IsDone = new boolean[numThreads];
+    for(int i = 0; i < n; i++) {
+      IsDone[i] = false;
+    }
+  }
+
+  // Uses the manager's debug function, so this can only be used after
+  // construction!
+  public void debug(String s) {
+    //System.err.println("Debug message" + s);
+  }
+
+  /*
+  public void setMaxBusyIter(int b) {
+    maxBusyIter = b;
+  }
+  */
+
+  public void DoBarrier(int myid) {
+    int b;
+     //debug("Thread " + myid + " checking in");
+
+    int roundmask = 3;
+    boolean donevalue = !IsDone[myid];
+
+    while(((myid & roundmask) == 0) && (roundmask<(numThreads<<2))) {
+      int spacing = (roundmask+1) >> 2;
+      for(int i=1; i<=3 && myid+i*spacing < numThreads; i++) {
+         //debug("Thread " + myid + " waiting for thread " + (myid+i*spacing));
+        b = maxBusyIter;
+        while(IsDone[myid+i*spacing] != donevalue) {
+          b--;
+          if(b==0) {
+            //Thread.yield();
+            b = maxBusyIter;
+          }
+        }
+      }
+      roundmask = (roundmask << 2) + 3;
+    }
+     //debug("Thread " + myid + " reporting done");
+    IsDone[myid] = donevalue;
+    b = maxBusyIter;
+    while(IsDone[0] != donevalue) {
+      b--;
+      if(b==0) {
+        //Thread.yield();
+        b = maxBusyIter;
+      }
+    }
+    //debug("Thread " + myid + " checking out");
+
+  }
+}
diff --git a/Robust/src/Benchmarks/oooJava/moldyn/makefile b/Robust/src/Benchmarks/oooJava/moldyn/makefile
new file mode 100644
index 00000000..de3cbce7
--- /dev/null
+++ b/Robust/src/Benchmarks/oooJava/moldyn/makefile
@@ -0,0 +1,50 @@
+PROGRAM=JGFMolDynBenchSizeB
+
+SOURCE_FILES=JGFMolDynBenchSizeB.java
+
+BUILDSCRIPT=../../../buildscript
+
+
+COREPROFOVERFLOW= #-coreprof-checkoverflow
+USECOREPROF= -coreprof $(COREPROFOVERFLOW) \
+	-coreprof-eventwords 1024*1024*128 \
+	-coreprof-enable cpe_main \
+	-coreprof-enable cpe_taskdispatch
+#	-coreprof-enable cpe_runmalloc \
+#	-coreprof-enable cpe_runfree \
+#	-coreprof-enable cpe_count_poolalloc \
+#	-coreprof-enable cpe_count_poolreuse \
+#	-coreprof-enable cpe_workschedgrab \
+#	-coreprof-enable cpe_taskexecute \
+#	-coreprof-enable cpe_taskretire \
+#	-coreprof-enable cpe_taskstallvar \
+#	-coreprof-enable cpe_taskstallmem
+
+
+USEOOO= -ooojava 24 2  -ooodebug -ooodebug-disable-task-mem-pool 
+BSFLAGS= -64bit -mainclass $(PROGRAM)  -heapsize-mb 5024 -garbagestats -joptimize -noloop -optimize #-debug 
+
+DRELEASEMODE=-disjoint-release-mode -disjoint-alias-file aliases.txt tabbed
+DISJOINT= -disjoint -disjoint-k 1 -enable-assertions $(DRELEASEMODE) #-disjoint-desire-determinism
+
+default:
+	$(BUILDSCRIPT) -nojava $(BSFLAGS) $(USECOREPROF) $(USEOOO) $(DISJOINT) -o $(PROGRAM)p -builddir par  $(SOURCE_FILES)
+
+single:
+	$(BUILDSCRIPT) -thread $(BSFLAGS) $(USECOREPROF)                       -o $(PROGRAM)s -builddir sing $(SOURCE_FILES) 
+
+ooo:
+	$(BUILDSCRIPT)         $(BSFLAGS) $(USECOREPROF) $(USEOOO) $(DISJOINT) -o $(PROGRAM)p -builddir par  $(SOURCE_FILES) 
+
+clean:
+	rm -f  $(PROGRAM)p.bin $(PROGRAM)s.bin
+	rm -fr par sing
+	rm -f  *~
+	rm -f  *.dot
+	rm -f  *.png
+	rm -f  *.txt
+	rm -f  aliases.txt
+	rm -f  mlpReport*txt
+	rm -f  results*txt
+	rm -f coreprof.dat
+	rm -f trace.out