lcsim/src/org/lcsim/recon/cluster/mipfinder

diff -N TrackClusterDriver.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ TrackClusterDriver.java	16 Jan 2006 21:09:32 -0000	1.1
@@ -0,0 +1,181 @@

+package org.lcsim.recon.cluster.mipfinder;
+
+import java.util.List;
+import java.util.Vector; 
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Collection;
+import java.io.IOException; 
+
+import org.lcsim.util.Driver;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.CalorimeterHit;
+import org.lcsim.util.decision.*;
+import org.lcsim.geometry.IDDecoder;
+import org.lcsim.recon.cluster.util.ClusterSizeDecision;
+
+/**
+ * An alternative driver. This is designed to find any track
+ * segment, not just MIPs.
+ *
+ * @version $Id: TrackClusterDriver.java,v 1.1 2006/01/16 21:09:32 mcharles Exp $
+ */
+
+public class TrackClusterDriver extends Driver
+{
+    /**
+     * Constructor.
+     */
+    public TrackClusterDriver() {
+    }
+
+    /**
+     * Constructor with convenience arguments to specify the input and
+     * output names.
+     */
+    public TrackClusterDriver(String inputHitMapName, String outputClusterListName, String outputHitMapName) {
+	m_inputHitMapName = inputHitMapName;
+	m_outputClusterListName = outputClusterListName;
+	m_outputHitMapName = outputHitMapName;
+	if (m_debug) {
+	    System.out.println("DEBUG: TrackClusterDriver: inputHitMapName="+inputHitMapName);
+	    System.out.println("DEBUG: TrackClusterDriver: outputClusterListName="+outputClusterListName);
+	    System.out.println("DEBUG: TrackClusterDriver: outputHitMapName="+outputHitMapName);
+	}
+    }
+
+    /**
+     * Find track segments in one event.
+     */
+    public void process(EventHeader event) 
+    {
+	// Fetch the hit map from the event:
+	Map<Long, CalorimeterHit> inputHitMap = (Map<Long, CalorimeterHit>) (event.get(m_inputHitMapName));
+	List<CalorimeterHit> inputHitList = new Vector<CalorimeterHit> (inputHitMap.values());
+
+	// Look for track segments. 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);
+
+	// We need to figure out how many layers there are in the calorimeter.
+	// This number should be the same for all hits.
+	int nLayers = 0; // We'll set this to the right number shortly
+	boolean firstCheck = true;
+	for (CalorimeterHit hit : inputHitMap.values()) {
+	    // Look up the number of layers for this hit's subdetector
+	    org.lcsim.geometry.Subdetector subdet = hit.getSubdetector();
+	    org.lcsim.geometry.layer.Layering layering = subdet.getLayering();
+	    int currentNumLayers = layering.getNumberOfLayers();
+	    if (firstCheck) {
+		// First hit => set nLayers and move on
+		nLayers = currentNumLayers;
+	    } else {
+		// Not first hit => check that # layers matches
+		if (nLayers != currentNumLayers) { 
+		    throw new AssertionError("Layering mismatch: "+nLayers+" vs "+currentNumLayers+". Maybe you mixed ECAL and HCAL?");
+		}
+	    }
+	}
+
+	// OK. Next, separate the hits out according to their layer:
+	Map<Integer, List<CalorimeterHit>> hitsPerLayer = new HashMap<Integer, List<CalorimeterHit>>();
+	for (CalorimeterHit hit : inputHitMap.values()) {
+	    // Look up the layer of this hit:
+	    IDDecoder id = hit.getIDDecoder();
+	    id.setID(hit.getCellID());
+	    Integer layer = new Integer(id.getLayer());
+	    // Add it to the list for that layer:
+	    List<CalorimeterHit> layerList = hitsPerLayer.get(layer);
+	    if (layerList == null) {
+		layerList = new Vector<CalorimeterHit>();
+		hitsPerLayer.put(layer, layerList);
+	    }
+	    layerList.add(hit);
+	}
+	
+	// Now run the cluster builder. We have to do this in a
+	// hackish way, unfortunately.
+	MIPClusterBuilder clusterBuilder = new MIPClusterBuilder(inputHitList, hitTypes); 
+	clusterBuilder.setDebugMode(m_debug);
+	clusterBuilder.setNumberOfSeedLayers(1);
+	clusterBuilder.initialize();
+	List<Cluster> allTrackSegments = new Vector<Cluster>();
+	
+	for (int iLayer=0; iLayer<nLayers; iLayer++) {
+	    // Run the finder outwards starting in layer iLayer:
+	    // Reset nuclei to that layer
+	    clusterBuilder.setDirectionAndFirstLayer(+1, iLayer);
+	    List<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);
+
+	    // Run the finder inwards starting in layer iLayer:
+	    // Reset nuclei to that layer
+	    clusterBuilder.setDirectionAndFirstLayer(-1, nLayers-iLayer-1);
+	    List<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);
+	}
+
+	// Require that the track segments have at least 4 hits:
+	ClusterSizeDecision dec = new ClusterSizeDecision(4);
+	ListFilter<Cluster> filter = new ListFilter<Cluster> (dec);
+	List<Cluster> filteredTrackSegments = filter.filterList(allTrackSegments);
+	
+	// Write out clusters
+	event.put(m_outputClusterListName, filteredTrackSegments);
+
+	// Make the output hit list
+	Map<Long, CalorimeterHit> outputHitMap = new HashMap<Long, CalorimeterHit>(inputHitMap); // initially cloned
+	for (Cluster clus : filteredTrackSegments) {
+	    for (CalorimeterHit hit : clus.getCalorimeterHits()) {
+		outputHitMap.remove(hit.getCellID());
+	    }
+	}
+	// Write out hit list
+	event.put(m_outputHitMapName, outputHitMap);
+    }
+	
+    /**
+     * Turn debug printout on or off.
+     */
+    public void setDebug(boolean debug) {
+	m_debug = debug;
+    }
+
+    public void setInputHitMapName(String inputHitMapName) {
+	m_inputHitMapName = inputHitMapName;
+    }
+    public void setOutputClusterListName(String outputClusterListName) {
+	m_outputClusterListName = outputClusterListName;
+    }
+    public void setOutputHitMapName(String outputHitMapName) {
+	m_outputHitMapName = outputHitMapName;
+    }
+
+    String m_inputHitMapName;
+    String m_outputClusterListName;
+    String m_outputHitMapName;
+    boolean m_debug = false;
+
+}