diff -N TrackSegmentFinder.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ TrackSegmentFinder.java	1 Oct 2005 01:37:46 -0000	1.1
@@ -0,0 +1,113 @@

+package structural; // package org.lcsim.recon.cluster.structural;
+
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Vector; 
+import org.lcsim.event.EventHeader;
+import org.lcsim.util.Driver;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.CalorimeterHit;
+import org.lcsim.geometry.IDDecoder;
+
+import mipfinder.*;
+
+
+/**
+ * This driver looks at a list of clusters and
+ * finds track segments within each cluster.
+ * These are then written out as [?].
+ */
+class TrackSegmentFinder extends Driver
+{
+    public TrackSegmentFinder(String inputListName, String outputListName) {
+	m_inputListName = inputListName;
+	m_outputListName = outputListName;
+    }
+
+    public void process(EventHeader event) {
+	List<Cluster> clusters = event.get(Cluster.class, m_inputListName);
+	MapClusterToListOfClusters mapClustersToTracks = new MapClusterToListOfClusters();
+	// OK. Now, we need to look for MIPs within this cluster.
+	// Any isolated hit could be a seed...
+	List<AbstractHitType> hitTypes = new Vector<AbstractHitType>();
+	SingleHit singleHit = new SingleHit();
+	DoubleHit doubleHit = new DoubleHit();
+	singleHit.useInSeeds(true);
+	doubleHit.useInSeeds(false);
+	hitTypes.add(singleHit);
+	hitTypes.add(doubleHit);
+	
+	for (Cluster cluster : clusters) {
+	    List<CalorimeterHit> hits = cluster.getCalorimeterHits();
+	    // All hits in cluster should have the same number of layers...
+	    int nLayers = 0;
+	    boolean firstCheck = true;
+	    Map<Integer, List<CalorimeterHit>> hitsPerLayer = new HashMap<Integer, List<CalorimeterHit>>();
+	    for (CalorimeterHit hit : hits) {
+		org.lcsim.geometry.Subdetector subdet = hit.getSubdetector();
+		org.lcsim.geometry.layer.Layering layering = subdet.getLayering();
+		int currentNumLayers = layering.getNumberOfLayers();
+		if (!firstCheck && nLayers != currentNumLayers) {
+		    throw new AssertionError("Layering mismatch: "+nLayers+" vs "+currentNumLayers);
+		} else if (firstCheck) {
+		    nLayers = currentNumLayers;
+		}
+		IDDecoder id = hit.getIDDecoder();
+		id.setID(hit.getCellID());
+		Integer layer = new Integer(id.getLayer());
+		List<CalorimeterHit> layerList = hitsPerLayer.get(layer);
+		if (layerList == null) {
+		    layerList = new Vector<CalorimeterHit>();
+		    hitsPerLayer.put(layer, layerList);
+		}
+		layerList.add(hit);
+	    }
+	    // OK!
+	    // Looks like we have to do this a hackish way...
+	    MIPClusterBuilder clusterBuilder = new MIPClusterBuilder(hits, hitTypes); 
+	    clusterBuilder.setDebugMode(false);
+	    clusterBuilder.setNumberOfSeedLayers(1);
+	    clusterBuilder.initialize();
+	    List<Cluster> allTrackSegments = new Vector<Cluster>();
+	    
+	    for (int iLayer=0; iLayer<nLayers; iLayer++) {
+		// Reset nuclei to that layer
+		clusterBuilder.setDirectionAndFirstLayer(+1, iLayer);
+		Vector<CalorimeterHit> forwardNuclei = new Vector<CalorimeterHit>();
+		List<CalorimeterHit> hitsInLayerForward = hitsPerLayer.get(new Integer(iLayer));
+		if (hitsInLayerForward != null) {
+		    for (CalorimeterHit hit : hitsInLayerForward) {
+			forwardNuclei.add(hit);
+		    }
+		}
+		clusterBuilder.provideNucleii(forwardNuclei);
+		List<Cluster> forwardTrackSegments = clusterBuilder.getMIPClusterList();
+		allTrackSegments.addAll(forwardTrackSegments);
+		// Reset nuclei to that layer
+		clusterBuilder.setDirectionAndFirstLayer(-1, nLayers-iLayer-1);
+		Vector<CalorimeterHit> backwardNuclei = new Vector<CalorimeterHit>();
+		List<CalorimeterHit> hitsInLayerBackward = hitsPerLayer.get(new Integer(nLayers-iLayer-1));
+		if (hitsInLayerBackward != null) {
+		    for (CalorimeterHit hit : hitsInLayerBackward) {
+			    backwardNuclei.add(hit);
+		    }
+		}
+		clusterBuilder.provideNucleii(backwardNuclei);
+		List<Cluster> backwardTrackSegments = clusterBuilder.getMIPClusterList();
+		allTrackSegments.addAll(backwardTrackSegments);
+	    }
+	    // Add them together and write to map:
+	    mapClustersToTracks.put(cluster, allTrackSegments);
+	}
+
+	// Dummy...
+	List<MapClusterToListOfClusters> dummyList = new Vector<MapClusterToListOfClusters> ();
+	dummyList.add(mapClustersToTracks);
+	event.put(m_outputListName, dummyList);
+    }
+    
+    protected String m_inputListName;
+    protected String m_outputListName;
+    
+}