diff -N DigitalCoreReclusterer.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ DigitalCoreReclusterer.java	24 Apr 2008 18:11:58 -0000	1.1
@@ -0,0 +1,134 @@

+/*
+ * DigitalCoreReclusterer.java
+ *
+ * Created on November 30, 2007, 9:14 AM
+ *
+ * Reclusters a cluster from a digital calorimeter into cores, and adds the
+ * unused hits to the nearest core. Setable parameters are:
+ * minimum # hits for a core
+ * clusterer to use for reclustering
+ */
+
+package org.lcsim.recon.cluster.util;
+import java.util.List;
+import java.util.ArrayList;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.CalorimeterHit;
+import org.lcsim.recon.cluster.util.Clusterer;
+import org.lcsim.recon.cluster.util.BasicCluster;
+import org.lcsim.recon.cluster.nn.NearestNeighborClusterer;
+import hep.physics.vec.Hep3Vector;
+import hep.physics.vec.BasicHep3Vector;
+
+/**
+ *
+ * @author cassell
+ */
+public class DigitalCoreReclusterer
+{
+    Clusterer clusterer;
+    boolean defClusterer = true;
+    int minNhitCore = 15;
+    /** Creates a new instance of DigitalCoreReclusterer */
+    public DigitalCoreReclusterer()
+    {
+        clusterer = new NearestNeighborClusterer(1,1,1,minNhitCore-1,0.);
+    }
+    public void setMinNHitCore(int n)
+    {
+        minNhitCore = n;
+        if(defClusterer)
+            clusterer = new NearestNeighborClusterer(1,1,1,minNhitCore-1,0.);
+    }
+    public void setClusterer(Clusterer cl)
+    {
+        clusterer = cl;
+        defClusterer = false;
+    }
+    public List<Cluster> reclusterList(List<Cluster> cl)
+    {
+        List<Cluster> out = new ArrayList<Cluster>();
+        for(Cluster c:cl)
+        {
+            out.addAll(reclusterCluster(c));
+        }
+        return out;
+    }
+    public List<Cluster> reclusterCluster(Cluster c)
+    {
+        List<Cluster> out = new ArrayList<Cluster>();
+//
+// If cluster too small to break up, just return orginal cluster
+//
+        if(c.getCalorimeterHits().size() < 2*minNhitCore)
+        {
+            out.add(c);
+            return out;
+        }
+//
+// Recluster the cluster
+//
+        List<Cluster> split = clusterer.createClusters(c.getCalorimeterHits());
+//
+// Count the cores with enough hits
+//
+        List<Cluster> cores = new ArrayList<Cluster>();
+        for(Cluster sc:split)
+        {
+            if(sc.getCalorimeterHits().size() >= minNhitCore)cores.add(sc);
+        }
+//
+// If it didn't split into at least 2 cores, return the original cluster
+//
+        if(cores.size() < 2)
+        {
+            out.add(c);
+            return out;
+        }
+//
+// It split, so add the unused hits to the nearest core and return the split
+// clusters
+//
+        BasicCluster[] newcl = new BasicCluster[split.size()];
+        Hep3Vector[] pos = new Hep3Vector[split.size()];
+        for(int j=0;j<cores.size();j++)
+        {
+            newcl[j] = new BasicCluster();
+            newcl[j].addCluster(split.get(j));
+            pos[j] = new BasicHep3Vector(newcl[j].getPosition());
+            out.add(newcl[j]);
+        }
+        for(CalorimeterHit h:c.getCalorimeterHits())
+        {
+            boolean used = false;
+            for(int i=0;i<cores.size();i++)
+            {
+                if(newcl[i].getCalorimeterHits().contains(h))
+                {
+                    used = true;
+                    break;
+                }
+            }
+            if(!used)
+            {
+                double[] hpos = h.getPosition();
+                double mindis = 99999.;
+                int minc = 0;
+                for(int j=0;j<cores.size();j++)
+                {
+                    double dissq = (pos[j].x() - hpos[0])*(pos[j].x() - hpos[0])+
+                                   (pos[j].y() - hpos[1])*(pos[j].y() - hpos[1])+
+                                   (pos[j].z() - hpos[2])*(pos[j].z() - hpos[2]);
+                    if(dissq < mindis)
+                    {
+                        mindis = dissq;
+                        minc = j;
+                    }
+                }
+                newcl[minc].addHit(h);
+            }
+        }
+        return out;
+    }
+    
+}

diff -N DigitalCoreReclustererDriver.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ DigitalCoreReclustererDriver.java	24 Apr 2008 18:11:58 -0000	1.1
@@ -0,0 +1,49 @@

+/*
+ * DigitalCoreReclustererDriver.java
+ *
+ * Created on November 30, 2007, 11:15 AM
+ *
+ * Driver to break up large clusters in a digital calorimeter
+ */
+
+package org.lcsim.recon.cluster.util;
+import org.lcsim.util.Driver;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.Cluster;
+import java.util.List;
+import org.lcsim.util.lcio.LCIOConstants;
+
+/**
+ *
+ * @author cassell
+ */
+public class DigitalCoreReclustererDriver extends Driver
+{
+    String in;
+    String out;
+    DigitalCoreReclusterer cr;
+    
+    /** Creates a new instance of DigitalCoreReclustererDriver */
+    public DigitalCoreReclustererDriver(String inlist, String outlist)
+    {
+        in = inlist;
+        out = outlist;
+        cr = new DigitalCoreReclusterer();
+    }
+    public void setMinNHitCore(int n)
+    {
+        cr.setMinNHitCore(n);
+    }
+    public void setClusterer(Clusterer cl)
+    {
+        cr.setClusterer(cl);
+    }
+    protected void process(EventHeader event)
+    {
+        List<Cluster> incl = event.get(Cluster.class,in);
+        List<Cluster> outl = cr.reclusterList(incl);
+		int flag = 1 << LCIOConstants.CLBIT_HITS;
+        event.put(out,outl,Cluster.class,flag);
+    }
+    
+}