diff -N MyCovMatrix.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ MyCovMatrix.java	3 Nov 2006 21:05:33 -0000	1.1
@@ -0,0 +1,366 @@

+import java.io.*;
+import Jama.*;
+import java.util.*;
+
+public class MyCovMatrix implements Serializable {
+    private double[][] _covMat; // the covariance matrix
+    private double[] _vec; // the vector of measurements
+    private double[] _covMeas; // the variance on the measurements
+    private int _dim; // the dimensionality
+    private int _key; // the key for the matrix
+    private double[] _tmp; // temporary array
+    private double[] _tmp2; // temporary array
+    private double[][] _invcovMat; // inverse of covariance matrix
+    private boolean _isSingular;
+
+    /**
+     * Constructor to create a covariance matrix from raw data.
+     *
+     * @param   dim    The dimensionality of this covariance matrix.
+     * @param   key    The key for indexing this matrix.
+     * @param   vec    The array of average values for the measurement space.
+     * @param   cov    The matrix for the averages.
+     * @param   covMat The matrix.
+     */
+    public MyCovMatrix(int dim, int key, double [] vec, double[] cov,
+		       double[][] covMat) {
+        _dim = dim;
+        _key = key;
+        _vec = new double[_dim];
+        _covMeas = new double[_dim];
+        System.arraycopy(vec, 0, _vec, 0, _dim);
+        System.arraycopy(cov, 0, _covMeas, 0, _dim);
+        _covMat = new double[_dim][_dim];
+	_isSingular = false;
+
+        for(int i =0; i<_dim; ++i) {
+            System.arraycopy(covMat[i], 0, _covMat[i], 0, _dim);
+        }
+
+        _tmp = new double[_dim];
+        _tmp2 = new double[_dim];
+
+	try {
+	    _invcovMat = invert();
+	}
+	catch (RuntimeException e) {
+	    System.out.println("Covariance matrix for dimension " + _dim + " is singular.");
+	    _isSingular = true;
+	}
+    }
+
+    /**
+     * Constructor to read the covariance matrix from a file.
+     *
+     * If the file is not present, or there is an error reading the file,
+     * go ahead and throw the underlying IOException and let the caller
+     * handle it.
+     *
+     * @param resourceFileName The name of the file where the covariance matrix is located.
+     *
+     */
+    public MyCovMatrix(String resourceFileName) throws IOException {
+	InputStream in = null;
+	_isSingular = false;
+
+	in = new FileInputStream(resourceFileName);
+
+	BufferedReader bufferedreader
+	    = new BufferedReader(new InputStreamReader(in));
+	readTheMatrix(bufferedreader);
+	bufferedreader.close();
+
+	_tmp = new double[_dim];
+	_tmp2 = new double[_dim];
+
+	try {
+	    _invcovMat = invert();
+	}
+	catch (RuntimeException e) {
+	    System.out.println("Covariance matrix for dimension " + _dim + " is singular.");
+	    _isSingular = true;
+	}
+    }
+
+    public boolean isSingular() {
+	return _isSingular;
+    }
+
+    public double[] getAvgVector() {
+	double[] avgvec = new double[_dim];
+	System.arraycopy(_vec, 0, avgvec, 0, _dim);
+	return avgvec;
+    }
+
+    public double[] getVarVector() {
+	double[] covvec = new double[_dim];
+	System.arraycopy(_covMeas, 0, covvec, 0, _dim);
+	return covvec;
+    }
+
+    public double[][] getCovMatrix() {
+	double[][] covmat = new double[_dim][_dim];
+	for (int i = 0; i < _dim; i++) {
+	    System.arraycopy(_covMat[i], 0, covmat[i], 0, _dim);
+	}
+	return covmat;
+    }
+
+    public double getDim() {
+	return _dim;
+    }
+
+    /**
+     * Calculates the chi-squared for the measurement compared to
+     * the expected values and covariances represented by the matrix.
+     *
+     * @param   dat  The array of measured values
+     * @return  The value of chi-squared.
+     */
+    public double chisquared(double[] dat) {
+	int dim = dat.length;
+
+        // vector of measured-predicted values
+        for(int i = 0; i < dim; ++i) {
+            _tmp[i] = dat[i] - _vec[i];
+        }
+
+        double chisqr = 0.;
+
+        // covariance matrix times difference vector
+        for(int i = 0; i < dim; ++i) {
+            _tmp2[i] = 0.;
+            for(int j = 0; j < dim; ++j) {
+                _tmp2[i] += _invcovMat[j][i] * _tmp[j];
+            }
+            chisqr += _tmp[i]*_tmp2[i];
+        }
+        return chisqr;
+    }
+
+    /**
+     * Calculates the diagonal chi-squared for the measurement compared to
+     * the expected values and covariances represented by the HMatrix,
+     * neglecting correlations.
+     *
+     * @param   dat  The array of measured values
+     * @return  The value of the diagonal chi-squared.
+     */
+    public double chisquaredDiagonal(double[] dat) {    
+        double chisqr = 0.;
+        // diagonal terms of covariance matrix times difference vector 
+        for(int i = 0; i < dat.length; ++i) {
+            //measured-predicted values
+            _tmp[i] = dat[i] - _vec[i];
+            //squared, divided by the variance of the prediction
+            chisqr += _tmp[i] * _tmp[i] / _covMeas[i];
+        }
+        return chisqr;
+    }
+
+    /**
+     *Output stream
+     *
+     * @return   A String representation of the object.
+     */
+    public String toString() {
+        StringBuffer sb = new StringBuffer("CovMatrix: dimension "+_dim+" key "+_key+ "\n");
+        sb.append("vector: \n");
+        for(int i = 0; i<_dim; ++i) {
+            sb.append(_vec[i]+" ");
+        }
+        sb.append("\n\nCovariance matrix: \n");
+        for(int i = 0; i<_dim; ++i) {
+            for(int j = 0; j<_dim; ++j) {
+                sb.append(_covMat[i][j]+" ");
+            }
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    /**
+     *  Writes out the covariance matrix to an ASCII file
+     */
+    public void write(String filename, String comment) {
+        System.out.println("Writing covariance matrix to '" + filename + "'.");
+        try {
+            PrintWriter printwriter = new PrintWriter(new BufferedWriter(new FileWriter(filename)));
+            // Print the comment
+            String s2 = "# " + comment;
+            printwriter.println(s2);
+
+            // Now the dimension and index of the matrix
+            String s3 = _dim+" "+_key;
+            printwriter.println(s3);
+            String s4 = "";
+
+            //Now the vector of average values
+	    String s5 = "";
+	    for(int i = 0; i < _dim; i++)
+		s5 = s5 + _vec[i] + " ";
+	    printwriter.println(s5.substring(0, s5.length() - 1));
+
+            //Now the vector of variance of average values
+	    String s7 = "";
+	    for(int i = 0; i < _dim; i++)
+		s7 = s7 + _covMeas[i] + " ";
+	    printwriter.println(s7.substring(0, s7.length() - 1));
+
+            //Now the covariance matrix
+            for(int i = 0; i < _dim; i++) {
+                String s6 = "";
+                for(int j = 0; j < _dim; j++)
+                    s6 = s6 + _covMat[i][j] + " ";
+
+                printwriter.println(s6.substring(0, s6.length() - 1));
+            }
+            
+            printwriter.close();
+        }
+        catch(IOException _ex) {
+            System.err.println("MyCovMatrix::write -> Error writing to '" +
+			       filename + "'.");
+	    return;
+            //System.exit(0);
+        }
+        System.out.println("Covariance matrix written.");
+    }
+    
+    private void readTheMatrix(BufferedReader bufferedreader)
+      throws IOException {
+        boolean flag = false;
+        boolean readVec = false;
+        boolean readCovDiag = false;
+        int i = 0;
+        int ii = 0;
+        int j = 0;
+
+        for(String s1 = new String();
+	    (s1 = bufferedreader.readLine()) != null;) {
+            if(s1.startsWith("#"))
+                System.out.println(s1);
+            else {
+                if(!flag) {
+                    _dim = Integer.parseInt(s1.substring(0, s1.indexOf(" ")));
+                    _key = Integer.parseInt(s1.substring(s1.indexOf(" ") + 1, s1.length()));
+
+		    System.out.println("_dim = " + _dim + " _key = " + _key);
+
+                    _vec = new double[_dim];
+                    _covMeas = new double[_dim];
+                    _covMat = new double[_dim][_dim];
+                    flag = true;
+                }
+                else {
+                    if (!readVec) {
+                        // Read the vector of averages
+                        while(s1.length() > 0 && s1.indexOf(" ") != -1) {
+                            double d = Double.valueOf(s1.substring(0, s1.indexOf(" "))).doubleValue();
+                            s1 = s1.substring(s1.indexOf(" ") + 1, s1.length());
+                            _vec[ii] = d;
+                            ii++;
+                        }
+                        double d1 = Double.valueOf(s1).doubleValue();
+                        _vec[ii] = d1;
+                        readVec = true;
+                        ii=0;
+                    }
+                    else if(!readCovDiag) {
+                        // Read the vector of variance of averages
+                        while(s1.length() > 0 && s1.indexOf(" ") != -1) {
+                            double d = Double.valueOf(
+				s1.substring(0,s1.indexOf(" "))).doubleValue();
+                            s1 = s1.substring(s1.indexOf(" ")+1, s1.length());
+                            _covMeas[ii] = d;
+                            ii++;
+                        }
+                        double d1 = Double.valueOf(s1).doubleValue();
+                        _covMeas[ii] = d1;
+                        readCovDiag = true;
+                    }
+                    else {
+                        // Read the covariance matrix
+                        while(s1.length() > 0 && s1.indexOf(" ") != -1) {
+                            double d = Double.valueOf(
+                                s1.substring(0,s1.indexOf(" "))).doubleValue();
+                            s1 = s1.substring(s1.indexOf(" ")+1, s1.length());
+                            _covMat[i][j] = d;
+                            j++;
+                        }
+                        double d1 = Double.valueOf(s1).doubleValue();
+                        _covMat[i][j] = d1;
+                        i++;
+                        j = 0;
+                    }
+                }
+	    }
+	}
+    }
+
+    // Invert the covariance matrix _covMat with the Jama standard
+    // inverse() calculation.
+    //
+    private double[][] invert() {
+	Matrix M = new Matrix(_covMat, _dim, _dim);
+	Matrix Minv = M.inverse();
+
+	Matrix leftEM = Minv.times(M).minus(Matrix.identity(_dim,_dim));
+	Matrix rightEM = M.times(Minv).minus(Matrix.identity(_dim,_dim));
+
+	double leftE = leftEM.normF();
+	double rightE = rightEM.normF();
+
+	System.out.println("||M^-1 * M - I||_F = " + leftE);
+	System.out.println("||M * M^-1 - I||_F = " + rightE);
+
+	return Minv.getArrayCopy();
+    }
+
+
+    // Invert the covariance matrix _covMat using its SVD M = U*S*V'.
+    // M^(-1) = V*S^(-1)*U'
+    //
+    private double[][] invert_old() {
+	Matrix M = new Matrix(_covMat, _dim, _dim);
+	SingularValueDecomposition svdM = M.svd();
+	Matrix Ut = svdM.getU().transpose();
+	double[][] V = svdM.getV().getArrayCopy();
+	int i, j;
+
+	// After the loop, Sinv contains the inverse of Sigma
+	double[][] Sinv = svdM.getS().getArrayCopy();
+
+	for (i = 0; i < _dim; i++) {
+	    if (Sinv[i][i] != 0) {
+		Sinv[i][i] = 1.0 / Sinv[i][i];
+	    }
+	}
+
+	// Multiply product V * Sigma^(-1) in place using that Sigma^(-1)
+	// is diagonal; store in V
+	//
+	for (j = 0; j < _dim; j++) {
+	    for (i = 0; i < _dim; i++) {
+		V[i][j] *= Sinv[j][j];
+	    }
+	}
+
+	Matrix VSinv = new Matrix(V, _dim, _dim);
+	Matrix Minv = VSinv.times(Ut);
+
+	System.out.println("Covariance matrix dimension " + _dim +
+			   " inversion error:");
+
+	Matrix leftEM = Minv.times(M).minus(Matrix.identity(_dim,_dim));
+	Matrix rightEM = M.times(Minv).minus(Matrix.identity(_dim,_dim));
+
+	double leftE = leftEM.normF();
+	double rightE = rightEM.normF();
+
+	System.out.println("||M^-1 * M - I||_F = " + leftE);
+	System.out.println("||M * M^-1 - I||_F = " + rightE);
+
+	return Minv.getArrayCopy();
+    }
+}

diff -N MyCovMatrixBuilder.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ MyCovMatrixBuilder.java	3 Nov 2006 21:05:34 -0000	1.1
@@ -0,0 +1,98 @@

+import java.io.*;
+import Jama.*;
+
+public class MyCovMatrixBuilder {
+    private double[][] _cov;
+    private double[] _vec;
+    private double[] _vals;
+    private double[][] _valsq;
+    private int _dim;
+    private int _key;
+    private int _ndata;
+    private boolean _isValid;
+    private MyCovMatrix _covmat;
+
+    /** Construct an <b>n</b> x <b>n</b> MyCovMatrixBuilder.
+     * Leaves covariance matrix in an invalid state.
+     * One must either accumulate entries to build up the
+     * covariance matrix or read in the covariance matrix
+     * values from a file.
+     *
+     * @param   n  The dimension of the measurement space.
+     * @param   key The key by which to index this matrix.
+     */
+    public MyCovMatrixBuilder(int n, int key) {
+        _dim = n;
+        _key = key;
+        _cov = new double[_dim][_dim];
+        _vec = new double[_dim];
+        _vals = new double[_dim];
+        _valsq = new double[_dim][_dim];
+        _isValid = false;
+    }
+
+    public int getDim() {
+	return _dim;
+    }
+
+    /**
+     * Add the measurement vector to the accumulated matrix
+     *
+     * @param   dat  The array of measurements.
+     */
+    public void accumulate(double[] dat) {
+        for(int i = 0; i < _dim; ++i) {
+            for(int j = 0; j < _dim; ++j) {
+                _valsq[i][j] += dat[i]*dat[j];
+
+                if(i == j)
+		    _vals[i] += dat[i];
+            }
+        }
+	++_ndata;
+    }
+
+    /**
+     * Validates the matrix by performing the averages
+     */
+    public void validate() {
+	System.out.println("Number of data: " + _ndata);
+
+        double[] _covDiag = new double[_dim];
+
+        for(int i = 0; i < _dim; ++i) {
+            _vec[i] = _vals[i]/_ndata;
+
+            for(int j = 0; j < _dim; ++j) {
+                _cov[i][j] = (_valsq[i][j]/_ndata) - ((_vals[i]/_ndata)*(_vals[j]/_ndata));
+            }
+            _covDiag[i] = _cov[i][i];
+        }
+
+	_covmat = new MyCovMatrix(_dim, _key, _vec, _covDiag, _cov);
+        _isValid = true;
+    }
+
+    /**
+     * Output Stream
+     *
+     * @return  String representation of the object
+     */
+    public String toString() {
+        StringBuffer sb = new StringBuffer("HMatrixBuilder: dimension "+_dim+" ");
+        if(!_isValid)
+	    return (sb.append("INVALID").toString());
+        sb.append(_cov);
+        return sb.toString();
+    }
+
+    /**
+     *  Writes out the HMatrix to an ASCII file
+     *
+     * @param   filename  The file to which to write.
+     * @param   comment   A comment for the header.
+     */
+    public void write(String filename, String comment) {
+	_covmat.write(filename, comment);
+    }
+}

diff -N MyCovMatrixTask.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ MyCovMatrixTask.java	3 Nov 2006 21:05:34 -0000	1.1
@@ -0,0 +1,7 @@

+/*
+ * MyCovMatrixTask.java
+ *
+ */
+
+public enum MyCovMatrixTask
+{BUILD, ANALYZE};

diff -N PerformanceAnalysis.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ PerformanceAnalysis.java	3 Nov 2006 21:05:34 -0000	1.1
@@ -0,0 +1,99 @@

+import hep.aida.*;
+import org.freehep.application.*;
+import org.freehep.application.studio.*;
+
+/* Performance analysis: Plots the purity of neutrons vs. the efficiency of
+ * photons for two sets of data opened at the same time.
+ *
+ * NB: Make sure that, before running this, that the paths
+ *   /gamma.aida and /neutron.aida
+ * exist in the JAS3 main tree.
+ *
+ * This program is meant to be run under JAS3 and does not save an AIDA
+ * file when its analysis is complete. A version that does so may be created
+ * as time permits.
+ */
+public class PerformanceAnalysis {
+    public static void main(String[] args) {
+        IAnalysisFactory af = IAnalysisFactory.create();
+	IPlotterFactory pf = af.createPlotterFactory();
+
+        ITree tree = (ITree)((Studio)Application.getApplication()).getLookup().lookup(ITree.class);
+	IHistogramFactory hf = af.createHistogramFactory(tree);
+
+	ICloud1D origGammaCloud = (ICloud1D)tree.find("/gamma.aida/log(Chisq Prob)");
+	ICloud1D origGammaCloudD = (ICloud1D)tree.find("/gamma.aida/log(ChisqD Prob)");
+	ICloud1D origNCloud = (ICloud1D)tree.find("/neutron.aida/log(ChisqD Prob)");
+	ICloud1D origNCloudD = (ICloud1D)tree.find("/neutron.aida/log(Chisq Prob)");
+
+	int gammaTotEnt = origGammaCloud.entries();
+	int gammaTotEntD = origGammaCloudD.entries();
+	int nTotEnt = origNCloud.entries();
+	int nTotEntD = origNCloudD.entries();
+
+	ICloud1D gammaCloud = hf.createCopy("gamma_cloud", origGammaCloud);
+	ICloud1D gammaCloudD = hf.createCopy("gamma_cloudD", origGammaCloudD);
+	ICloud1D nCloud = hf.createCopy("n_cloud", origNCloud);
+	ICloud1D nCloudD = hf.createCopy("n_cloudD", origNCloudD);
+
+	int gammaLEdge = (int)Math.floor(gammaCloud.lowerEdge());
+	int gammaLEdgeD = (int)Math.floor(gammaCloudD.lowerEdge());
+	int nLEdge = gammaLEdge;
+	int nLEdgeD = gammaLEdgeD;
+
+	gammaCloud.convert((int)Math.abs(gammaLEdge)+1, gammaLEdge-0.5, 0.5);
+	gammaCloudD.convert((int)Math.abs(gammaLEdgeD)+1, gammaLEdgeD-0.5, 0.5);
+	nCloud.convert((int)Math.abs(nLEdge)+1, nLEdge-0.5, 0.5);
+	nCloudD.convert((int)Math.abs(nLEdgeD)+1, nLEdgeD-0.5, 0.5);
+
+	IHistogram1D gammaHist = gammaCloud.histogram();
+	IHistogram1D gammaHistD = gammaCloudD.histogram();
+	IHistogram1D nHist = nCloud.histogram();
+	IHistogram1D nHistD = nCloudD.histogram();
+
+	int gammaEnt = 0;
+	int gammaEntD = 0;
+	int nEnt = 0;
+	int nEntD = 0;
+
+	ICloud2D perfPlot = hf.createCloud2D("Performance plot from chisq");
+	ICloud2D perfPlotD = hf.createCloud2D("Performance plot from chisqD");
+
+	for (int i = 0; i >= gammaLEdge; i--) {
+	    gammaEnt += gammaHist.binEntries(gammaHist.coordToIndex(i));
+	    gammaEntD += gammaHistD.binEntries(gammaHistD.coordToIndex(i));
+	    nEnt += nHist.binEntries(nHist.coordToIndex(i));
+	    nEntD += nHistD.binEntries(nHistD.coordToIndex(i));
+
+	    double gammaFrac = (double)gammaEnt / (double)gammaTotEnt;
+	    double gammaFracD = (double)gammaEntD / (double)gammaTotEntD;
+	    double nFrac = 1.0 - (double)nEnt / (double)nTotEnt;
+	    double nFracD = 1.0 - (double)nEntD / (double)nTotEntD;
+
+	    perfPlot.fill(gammaFrac, nFrac);
+	    perfPlotD.fill(gammaFracD, nFracD);
+	}
+
+	IPlotter plotter = pf.create("Performance plot from chisq");
+	IPlotterStyle pStyle = plotter.currentRegion().style();
+	pStyle.dataStyle().markerStyle().setColor("black");
+	plotter.currentRegion().plot(perfPlot);
+	plotter.show();
+
+	IPlotter plotterD = pf.create("Performance plot from chisqD");
+	IPlotterStyle pStyleD = plotterD.currentRegion().style();
+	pStyleD.dataStyle().markerStyle().setColor("black");
+	plotterD.currentRegion().plot(perfPlotD);
+	plotterD.show();
+
+	// Comment out the following two lines if closing off gamma.aida
+	// and neutron.aida gets to be annoying.
+	tree.unmount("gamma.aida");
+	tree.unmount("neutron.aida");
+
+	tree.rm("gamma_cloud");
+	tree.rm("gamma_cloudD");
+	tree.rm("n_cloud");
+	tree.rm("n_cloudD");
+    }
+}

diff -N README
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ README	3 Nov 2006 21:05:34 -0000	1.1
@@ -0,0 +1,67 @@

+This code builds HMatrices and uses them in the analysis of single particle
+events.
+
+This code was written in a Linux environment, and the included classpath.sh
+file sets up the Java classpath appropriately. You will need to edit the
+variable LCSIM_SRC to point to where you have a built copy of the org.lcsim
+source for it to work.
+
+Building information:
+
+First, set up the classpath appropriately. The provided classpath.sh file
+should work under Linux environments (but see note above).
+
+Then, build the classes using the `javac' command, in the following order:
+  javac MyCovMatrixTask.java
+  javac MyCovMatrix.java
+  javac MyCovMatrixBuilder.java
+  javac EMClusterID_NoE.java
+  javac Standalone_NoE.java
+  javac PerformanceAnalysis.java
+
+Usage information:
+
+I recommend building the HMatrices in standalone mode. To do this, first make
+a directory called "CovMatrices" under this directory. Then, execute the
+Standalone_NoE class at a terminal. Usage information:
+
+  java Standalone_NoE [-a|-b] inputFile [# events]
+where
+  -a specifies that task is to analyze
+  -b specifies that task is to build (default)
+  inputFile specifies the .slcio file to analyze
+  # events specifies the number of events to process (default -1: process all)
+
+Analysis is possible in batch, by using the -a switch. The resulting .aida
+file is then called "emClusterAnalysis.aida".
+
+Also, analysis is possible under JAS3 with the org.lcsim plugin. To do this
+analysis, open up JAS3 and do the following:
+
+  1. Compile the .java files under JAS3 in the order specified above for
+     standalone compilation (except that it's not necessary to compile
+     Standalone_NoE.java or PerformanceAnalysis.java).
+  2. Right-click the EMClusterID_NoE.java source code and choose Load.
+  3. Open up a .slcio file in JAS3 using the org.lcsim plugin.
+  4. Press the Run button (the button icon looks like a standard "play" button
+     on a CD or tape player). (Do *not* right-click the source and choose Run.)
+
+PerformanceAnalysis.java is used to plot the efficiency of photon events vs.
+the purity of neutron events. This class can only be run under JAS3 with the
+org.lcsim plugin. To do this, open up JAS3 and do the following:
+
+  1. If you haven't already, compile the .java files under JAS3 in the order
+     specified above for standalone compilation. This time, you must compile
+     PerformanceAnalysis.java (but it's not necessary to compile
+     Standalone_NoE.java under JAS3).
+  2. Right-click the PerformanceAnalysis.java source code and choose Load.
+  3. Open up an aida file named gamma.aida that is the result of running the
+     analysis on a set of photon events. If you have such an .aida file with
+     a different name, rename the file to gamma.aida or create a link to it
+     called gamma.aida. Alternatively, edit lines 24 and 25 of
+     PerformanceAnalysis.java, replacing "gamma.aida" on those lines with your
+     preferred filename.
+  4. Do step 3, but for neutron.aida instead of gamma.aida.
+  5. Press the Run button (the button icon looks like a standard "play" button
+     on a CD or tape player). (Do *not* right-click the source and choose Run.)
+

diff -N Standalone_NoE.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ Standalone_NoE.java	3 Nov 2006 21:05:34 -0000	1.1
@@ -0,0 +1,86 @@

+import java.io.File;
+import java.io.IOException;
+import org.lcsim.util.Driver;
+import org.lcsim.util.aida.AIDA;
+import org.lcsim.util.loop.LCSimLoop;
+import org.lcsim.util.loop.LCIOEventSource;
+
+/**
+ * A simple standalone EMClusterID example
+ */
+public class Standalone_NoE extends Driver {
+    public Standalone_NoE() {}
+
+    public static void main(String[] args) throws Exception {
+	MyCovMatrixTask task = MyCovMatrixTask.BUILD;
+	File input;
+	int numToProcess = -1;
+
+        if(args.length < 1 || args.length > 3) {
+            usage();
+            System.exit(1);
+        }
+
+	// Task selection: build or analyze
+	// Default behavior: build if switch not present
+	//  - but return if switch is invalid
+	//
+	if (args[0].charAt(0) == '-') {
+	    if (args.length < 2 || args.length > 3) {
+		usage();
+		System.exit(1);
+	    }
+
+	    // analyze
+	    if (args[0].equals("-a"))
+		task = MyCovMatrixTask.ANALYZE;
+	    else if (args[0].equals("-b"))
+		task = MyCovMatrixTask.BUILD;
+	    else {
+		usage();
+		System.exit(1);
+	    }
+
+	    input = new File(args[1]);
+
+	    if (args.length == 3)
+		numToProcess = Integer.parseInt(args[2]);
+	}
+	else {
+	    if (args.length > 2) {
+		usage();
+		System.exit(1);
+	    }
+	    input = new File(args[0]);
+
+	    if (args.length == 2)
+		numToProcess = Integer.parseInt(args[1]);
+	}
+
+        System.out.println("Processing " + numToProcess+" events from "+input);
+        LCSimLoop loop = new LCSimLoop();
+
+	LCIOEventSource evtSrc = new LCIOEventSource(input);
+        loop.setRecordSource(evtSrc);
+
+        System.out.println("adding the driver");
+
+        loop.add(new EMClusterID_NoE(task));
+
+        System.out.println("looping");
+        loop.loop(numToProcess);
+
+        loop.dispose();
+        AIDA.defaultInstance().saveAs("emClusterAnalysis.aida");
+    }
+
+    public static void usage() {
+        System.out.println("This is Standalone_NoE");
+        System.out.println("Usage:");
+        System.out.println("  java Standalone_NoE [-a|-b] inputFile [# events]");
+	System.out.println("where");
+	System.out.println("  -a specifies that task is to analyze");
+	System.out.println("  -b specifies that task is to build (default)");
+	System.out.println("  # events specifies the number of events to process (default -1: process all)");
+    }
+}

diff -N classpath.sh
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ classpath.sh	3 Nov 2006 21:05:34 -0000	1.1
@@ -0,0 +1,33 @@

+#!/bin/bash
+
+# LCSIM_SRC: the root of the org.lcsim source tree. Is where GeomConverter
+# and lcsim are stored.
+
+#LCSIM_SRC=/home/eric/lcsim_1.1
+LCSIM_SRC=/home/eric/lcsim_061103
+
+#for i in $HOME/.JAS3/extensions/*.jar
+#do
+#	export CLASSPATH=$i:$CLASSPATH
+#done
+
+for i in $HOME/.maven/repository/*
+do
+	for j in $i/jars/*.jar
+	do
+		export CLASSPATH=$j:$CLASSPATH
+	done
+done
+
+for i in $LCSIM_SRC/GeomConverter/target/*.jar
+do
+	export CLASSPATH=$i:$CLASSPATH
+done
+
+for i in $LCSIM_SRC/lcsim/target/*.jar
+do
+	export CLASSPATH=$i:$CLASSPATH
+done
+
+export CLASSPATH=$PWD/Jama-1.0.2.jar:$CLASSPATH
+