--- java/branches/ecal-recon_HPSJAVA-93/src/main/java/org/hps/recon/ecal/EcalClusterIC.java	2014-06-03 09:59:04 UTC (rev 655)
+++ java/branches/ecal-recon_HPSJAVA-93/src/main/java/org/hps/recon/ecal/EcalClusterIC.java	2014-06-03 14:19:19 UTC (rev 656)
@@ -6,6 +6,7 @@

 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;

+import java.util.HashSet;

 import java.util.List;
 import java.util.Map;
 import java.util.Set;

@@ -21,352 +22,519 @@

 /**
  * This Driver creates clusters from the CalorimeterHits of an
  * {@link org.lcsim.geometry.subdetectur.HPSEcal3} detector.

+ * 
+ * This clustering logic is based on that from the CLAS-Note-2005-001. 
+ * This sorts hits from highest to lowest energy and build clusters around 
+ * each local maximum/seed hit. Common hits are distributed between clusters 
+ * when minimum between two clusters. There is a threshold cut for minimum
+ * hit energy, minimum cluster energy, and minimum seed hit energy. There is 
+ * also a timing threshold with respect to the seed hit. All of these parameters
+ * are tunable and should be refined with more analysis. 

  *
  *

- * @author Holly Szumila-Vance <h[log in to unmask]>

+ * @author Holly Szumila-Vance <h[log in to unmask]>
+ * @author Kyle McCarty <[log in to unmask]>

  *
  */
 public class EcalClusterIC extends Driver {

-	FileWriter writeHits;
-    HPSEcal3 ecal;

+	// File writer to output cluster results.
+    FileWriter writeHits;
+    // LCIO collection name for calorimeter hits.

     String ecalCollectionName;

+    // Name of the calorimeter detector object.

     String ecalName = "Ecal";

+    // LCIO cluster collection name to which to write.

     String clusterCollectionName = "EcalClusters";

+    // File path to which to write event display output.
+    String outfile = "cluster-hit-IC.txt";

     // Map of crystals to their neighbors.
     NeighborMap neighborMap = null;

-    //Minimum energy that counts as hit
-    double Emin = 0.001;

+    // Minimum energy threshold for hits; lower energy hits will be
+    // excluded from clustering. Units in GeV.
+    double hitEnergyThreshold = 0.0075;
+    // Minimum energy threshold for seed hits; if seed hit is below
+    // cluster is excluded from output. Units in GeV.
+    double seedEnergyThreshold = 0.2;
+    // Minimum energy threshold for cluster hits; if total cluster
+    // energy is below, the cluster is excluded. Units in GeV.
+    double clusterEnergyThreshold = 0.4;  
+    // A Comparator that sorts CalorimeterHit objects from highest to
+    // lowest energy.
+    private static final EnergyComparator ENERGY_COMP = new EnergyComparator();
+    // Track the event number for the purpose of outputting to event
+    // display format.
+    private int eventNum = -1;
+    // Apply time cut to hits
+    boolean timeCut = false;
+    // Minimum time cut window range. Units in ns.
+    double minTime = 0.0;
+    // Maximum time cut window range. Units in ns.
+    double timeWindow = 20.0;

-
-    public EcalClusterIC() {
-    }
-

+    HPSEcalCluster cluster = new HPSEcalCluster();
+    
+       

     public void setClusterCollectionName(String clusterCollectionName) {
         this.clusterCollectionName = clusterCollectionName;
     }

-

+    

     public void setEcalCollectionName(String ecalCollectionName) {
         this.ecalCollectionName = ecalCollectionName;
     }

-

+    

     public void setEcalName(String ecalName) {
         this.ecalName = ecalName;
     }

+    
+    /**
+     * Minimum energy for a hit to be used in a cluster. Default of 0.0075 GeV
+     *
+     * @param hitEnergyThreshold
+     */
+    public void sethitEnergyThreshold(double hitEnergyThreshold) {
+        this.hitEnergyThreshold = hitEnergyThreshold;
+    }

+    /**
+     * Minimum energy for a seed hit. Default of 0.2 GeV
+     *
+     * @param seedEnergyThreshold
+     */
+    public void setseedEnergyThreshold(double seedEnergyThreshold) {
+        this.seedEnergyThreshold = seedEnergyThreshold;
+    }
+    
+    /**
+     * Minimum energy for a cluster. Default of 0.4 GeV
+     *
+     * @param clusterEnergyThreshold
+     */
+    public void setclusterEnergyThreshold(double clusterEnergyThreshold) {
+        this.clusterEnergyThreshold = clusterEnergyThreshold;
+    }
+    
+    /**
+     * Apply time cuts to hits. Defaults to false.
+     *
+     * @param timeCut
+     */
+    public void setTimeCut(boolean timeCut) {
+        this.timeCut = timeCut;
+    }
+
+    /**
+     * Minimum hit time, if timeCut is true. Default of 0 ns.
+     *
+     * @param minTime
+     */
+    public void setMinTime(double minTime) {
+        this.minTime = minTime;
+    }
+
+    /**
+     * Width of time window, if timeCut is true. Default of 20 ns.
+     *
+     * @param timeWindow
+     */
+    public void setTimeWindow(double timeWindow) {
+        this.timeWindow = timeWindow;
+    }
+    
+    

     public void startOfData() {

+    	// Make sure that the calorimeter hit collection name is defined.

         if (ecalCollectionName == null) {
             throw new RuntimeException("The parameter ecalCollectionName was not set!");
         }

-

+        
+        // Make sure the name of calorimeter detector is defined.

         if (ecalName == null) {
             throw new RuntimeException("The parameter ecalName was not set!");
         }
         

-    	try{
-    		writeHits = new FileWriter("cluster-hit-IC.txt");
-    		writeHits.write("");
-    	}
-    	catch(IOException e) {};

+        // Create a file writer and clear the output file, if it exists.
+        try {
+            writeHits = new FileWriter(outfile);
+            writeHits.write("");
+        }
+        catch(IOException e) { }

     }
 
     public void detectorChanged(Detector detector) {

-        // Get the Subdetector.
-        ecal = (HPSEcal3) detector.getSubdetector(ecalName);
-
-        // Cache ref to neighbor map.

+    	
+    	// Must be set to use database conditions
+    	cluster.setDetector(detector);
+    	
+        // Get the calorimeter.
+    	HPSEcal3 ecal = (HPSEcal3) detector.getSubdetector(ecalName);
+    	
+        // Store the map of neighbor crystals for the current calorimeter set-up.

         neighborMap = ecal.getNeighborMap();
     }
 
     public void process(EventHeader event) {

-
-
-    	

+    	// Make sure the current event contains calorimeter hits.

         if (event.hasCollection(CalorimeterHit.class, ecalCollectionName)) {

-            // Get the list of raw ECal hits.
-            List<CalorimeterHit> hits = event.get(CalorimeterHit.class, ecalCollectionName);
-
-            // Make a hit map for quick lookup by ID.
-            Map<Long, CalorimeterHit> hitMap = new HashMap<Long, CalorimeterHit>();

+            // Get the list of raw calorimeter hits.
+            List<CalorimeterHit> hitList = event.get(CalorimeterHit.class, ecalCollectionName);

-            for (CalorimeterHit hit : hits) {
-                hitMap.put(hit.getCellID(), hit);
-            }

+            // Generate clusters from the calorimeter hits.
+            List<HPSEcalCluster> clusterList = null;
+            try { clusterList = createClusters(hitList); }
+            catch(IOException e) { }

-            //System.out.println("Number of ECal hits: "+hitMap.size());
-            
-            // Put Cluster collection into event.
-            int flag = 1 << LCIOConstants.CLBIT_HITS;
-            try {
-
-            	event.put(clusterCollectionName, createClusters(hitMap), HPSEcalCluster.class, flag);

+            // If clusters were successfully created, put them in the event.
+            if(clusterList != null) {
+	            int flag = 1 << LCIOConstants.CLBIT_HITS;
+	            event.put(clusterCollectionName, clusterList, HPSEcalCluster.class, flag);

             }

-            catch(IOException e) { }

         }
     }
 

-    public List<HPSEcalCluster> createClusters(Map<Long, CalorimeterHit> map) throws IOException {
-
-        // New Cluster list to be added to event.
-        List<HPSEcalCluster> clusters = new ArrayList<HPSEcalCluster>();
-             
-        //Create a Calorimeter hit list in each event, then sort with highest energy first
-        ArrayList<CalorimeterHit> chitList = new ArrayList<CalorimeterHit>(map.size());
-        for(CalorimeterHit h : map.values()) {
-        	if(h.getCorrectedEnergy()>Emin){
-        	chitList.add(h);}

+    public List<HPSEcalCluster> createClusters(List<CalorimeterHit> hitList) throws IOException {
+        // Create a list to store the newly created clusters in.
+        ArrayList<HPSEcalCluster> clusterList = new ArrayList<HPSEcalCluster>();

-        	Collections.sort(chitList, new EnergyComparator());}

+        // Sort the list of hits by energy.
+        Collections.sort(hitList, ENERGY_COMP);

-        //New Seed list containing each local maximum energy hit
-        List<CalorimeterHit> seedHits = new ArrayList<CalorimeterHit>();
-
-      	//Create map to contain common hits for evaluation later, key is crystal and values are seed
-      	Map<CalorimeterHit, List<CalorimeterHit>> commonHits = new HashMap<CalorimeterHit, List<CalorimeterHit>>();
-      	
-      	//Created map to contain seeds with listed hits, key is crystal, and value is seed
-      	Map<CalorimeterHit, CalorimeterHit> clusterHits = new HashMap<CalorimeterHit, CalorimeterHit>();
-      	
-      	//Create map to contain the total energy of each cluster
-      	Map<CalorimeterHit, Double> seedEnergy = new HashMap<CalorimeterHit,Double>();
-      	
-      	//Quick Map to access hits from cell IDs
-      	Map<Long, CalorimeterHit> hitID = new HashMap<Long, CalorimeterHit>();
-      	
-      	//List to contain all hits already put into clusters
-      	List<CalorimeterHit> clusterHitList = new ArrayList<CalorimeterHit>();
-      	
-        //Fill Map with cell ID and hit
-      	for (CalorimeterHit hit : chitList){
-      		hitID.put(hit.getCellID(), hit);
-      	}
-        
-        for (CalorimeterHit hit : chitList) { 
-        Set<Long> neighbors = neighborMap.get(hit.getCellID()); //get all neighbors of hit
-        List<CalorimeterHit> neighborHits = new ArrayList<CalorimeterHit>();
-        for(Long neighbor : neighbors){
-        	if(hitID.containsKey(neighbor)){//map contains (neighbor's cell id, neighbor hit)
-        		neighborHits.add(hitID.get(neighbor));

+        // Filter the hit list of any hits that fail to pass the
+        // designated threshold.
+        filterLoop:
+        for(int index = hitList.size() - 1; index >= 0; index--) {
+        	// If the hit is below threshold or outside of time window, kill it.
+        	if((hitList.get(index).getCorrectedEnergy() < hitEnergyThreshold)||
+        			(timeCut && (hitList.get(index).getTime() < minTime || hitList.get(index).getTime() > minTime + timeWindow))) {
+        		hitList.remove(index);

         	}

+        	
+        	// Since the hits are sorted by energy from highest to
+        	// lowest, any hit that is above threshold means that all
+        	// subsequent hits will also be above threshold. Continue through
+        	// list to check in time window. 
+        	else { continue; }

         }
         

-    	Collections.sort(neighborHits, new EnergyComparator());

+    	// Create a map to connect the cell ID of a calorimeter crystal
+        // to the hit which occurred in that crystal.
+    	HashMap<Long, CalorimeterHit> hitMap = new HashMap<Long, CalorimeterHit>();
+        for (CalorimeterHit hit : hitList) { hitMap.put(hit.getCellID(), hit); }

-        boolean highestE = true;
-        for(CalorimeterHit neighborHit : neighborHits){//check for seed hit
-        	if(hit.getCorrectedEnergy()>neighborHit.getCorrectedEnergy()){
-        		continue;
-        			}
-        	else {
-        		highestE = false;
-        		break;
-        	}	
-        }

+        // Map a crystal to a list of all clusters in which it is a member.
+        Map<CalorimeterHit, List<CalorimeterHit>> commonHits = new HashMap<CalorimeterHit, List<CalorimeterHit>>();

-        if (highestE == true){//seed hit, local maximum
-        	seedHits.add(hit);
-        	clusterHits.put(hit, hit);
-        	clusterHitList.add(hit);
-        }

+        // Map a crystal to the seed of the cluster of which it is a member.
+        HashMap<CalorimeterHit, CalorimeterHit> hitSeedMap = new HashMap<CalorimeterHit, CalorimeterHit>();

-        //not seed hit
-        else { 
-        	//builds immediate clusters around seed hits
-        	for(CalorimeterHit neighborHit : neighborHits){
-        		//if neighbor to seed, add to seed
-        		if (seedHits.contains(neighborHit)&&!clusterHits.containsKey(hit)){  
-					CalorimeterHit seed = clusterHits.get(neighborHit);
-        			clusterHits.put(hit, seed);
-        			clusterHitList.add(hit);
-        		}
-        		//if neighbor to two seeds, add to common hits
-        		else if (seedHits.contains(neighborHit)&&clusterHits.containsKey(hit)){
-        			CalorimeterHit prevSeed = clusterHits.get(neighborHit);
-        			CalorimeterHit currSeed = clusterHits.get(hit);
-        			List<CalorimeterHit> commonHitList = new ArrayList<CalorimeterHit>();
-        			commonHitList.add(prevSeed);
-        			commonHitList.add(currSeed);
-        			commonHits.put(hit, commonHitList);
-        		}
-        	}
-        }
-        }

+      	// Set containing hits immediately around a seed hit.
+      	HashSet<CalorimeterHit> surrSeedSet = new HashSet<CalorimeterHit>();

-        //loop over hit list, find neighbors, compare energies, add to list 
-        for(CalorimeterHit nHit : chitList){
-        	Set<Long> neighbors2 = neighborMap.get(nHit.getCellID()); //get all neighbors of hit
-            List<CalorimeterHit> neighborHits2 = new ArrayList<CalorimeterHit>();
-            for(Long neighbor : neighbors2){
-            	if(hitID.containsKey(neighbor)){//map contains (neighbor's cell id, neighbor hit)
-            		if(!clusterHitList.contains(hitID.get(neighbor))){
-            			neighborHits2.add(hitID.get(neighbor));
-            		}

+        // Loop through all calorimeter hits to locate seeds and perform
+        // first pass calculations for component and common hits.
+        for (CalorimeterHit hit : hitList) {
+        	// Get the set of all neighboring crystals to the current hit.
+            Set<Long> neighbors = neighborMap.get(hit.getCellID());
+            
+            // Generate a list to store any neighboring hits in.
+            ArrayList<CalorimeterHit> neighborHits = new ArrayList<CalorimeterHit>();
+            
+            // Sort through the set of neighbors and, if a hit exists
+            // which corresponds to a neighbor, add it to the list of
+            // neighboring hits.
+            for (Long neighbor : neighbors) {
+            	// Get the neighboring hit.
+            	CalorimeterHit neighborHit = hitMap.get(neighbor);
+            	
+            	// If it exists, add it to the list.
+            	if(neighborHit != null) { neighborHits.add(neighborHit); }
+            }
+            
+            // Track whether the current hit is a seed hit or not.
+            boolean isSeed = true;
+            
+            // Loops through all the neighboring hits to determine if
+            // the current hit is the local maximum within its set of
+            // neighboring hits.
+            seedHitLoop:
+            for(CalorimeterHit neighbor : neighborHits) {
+            	if(hit.getCorrectedEnergy() <= neighbor.getCorrectedEnergy()) {
+            		isSeed = false;
+            		break seedHitLoop;

             	}
             }
             

-        	Collections.sort(neighborHits2, new EnergyComparator());
-        	for(CalorimeterHit neighbor : neighborHits2){
-        		if(clusterHits.containsKey(nHit) && neighbor.getCorrectedEnergy()<nHit.getCorrectedEnergy()){
-        			CalorimeterHit seed = clusterHits.get(nHit);
-					clusterHits.put(neighbor, seed);
-					clusterHitList.add(neighbor);
-        		}
-        		else{continue;}
-        	}
-        }
-        //loop over cluster hits, compare energies of neighbors with diff seeds, if min->add to commonHits
-        for (CalorimeterHit mHit : clusterHitList){
-        	//exclude seed hits as possible common hits
-        	if(clusterHits.get(mHit) != mHit){
-        		
-        		Set<Long> neighbors3 = neighborMap.get(mHit.getCellID()); //get all neighbors of hit
-                List<CalorimeterHit> neighborHits3 = new ArrayList<CalorimeterHit>();
-                for(Long neighbor : neighbors3){
-                	if(hitID.containsKey(neighbor)){//map contains (neighbor's cell id, neighbor hit)
-                		neighborHits3.add(hitID.get(neighbor));
-                		

+            // If this hit is a seed hit, just map it to itself.
+            if (isSeed) { hitSeedMap.put(hit, hit); }
+            
+            // If this hit is not a seed hit, see if it should be
+            // attached to any neighboring seed hits.
+            else {
+                // Sort through the list of neighboring hits.
+                for (CalorimeterHit neighborHit : neighborHits) {
+                	// Check whether the neighboring hit is a seed.
+                	if(hitSeedMap.get(neighborHit) == neighborHit) {
+                        // If the neighboring hit is a seed hit and the
+                        // current hit has been associated with a cluster,
+                        // then it is a common hit between its previous
+                        // seed and the neighboring seed.
+                        if (hitSeedMap.containsKey(hit)) {
+                        	// Check and see if a list of common seeds
+                        	// for this hit already exists or not.
+                        	List<CalorimeterHit> commonHitList = commonHits.get(hit);
+                        	
+                        	// If it does not, make a new one.
+                        	if(commonHitList == null) { commonHitList = new ArrayList<CalorimeterHit>(); }
+                        	
+                        	// Add the neighbors to the seeds to set of
+                        	// common seeds.
+                            commonHitList.add(neighborHit);
+                            commonHitList.add(hitSeedMap.get(hit));
+                            
+                            // Put the common seed list back into the set.
+                            commonHits.put(hit, commonHitList);
+                        }
+                        
+                        // If the neighboring hit is a seed hit and the
+                    	// current hit has not been added to a cluster yet
+                    	// associate it with the neighboring seed and note
+                        // that it has been clustered.
+                        else {
+                        	hitSeedMap.put(hit, neighborHit);
+                        	surrSeedSet.add(hit);
+                        }

                 	}
                 }

-                
-            	Collections.sort(neighborHits3, new EnergyComparator());

+            }
+        } // End primary seed loop.
+        
+        // Performs second pass calculations for component hits.
+        secondaryHitsLoop:
+        for (CalorimeterHit secondaryHit : hitList) {
+        	// If the secondary hit is not associated with a seed, then
+        	// the rest of there is nothing further to be done.
+        	if(!hitSeedMap.containsKey(secondaryHit)) { continue secondaryHitsLoop; }
+        	
+        	// Get the secondary hit's neighboring crystals.
+            Set<Long> secondaryNeighbors = neighborMap.get(secondaryHit.getCellID());
+            
+            // Make a list to store the hits associated with the
+            // neighboring crystals.
+            List<CalorimeterHit> secondaryNeighborHits = new ArrayList<CalorimeterHit>();
+            
+            // Loop through the neighboring crystals.
+            for (Long secondaryNeighbor : secondaryNeighbors) {
+            	// Get the hit associated with the neighboring crystal.
+            	CalorimeterHit secondaryNeighborHit = hitMap.get(secondaryNeighbor);

-            	CalorimeterHit compSeed = clusterHits.get(mHit);
-            	for(CalorimeterHit neighbor : neighborHits3){
-            		if(clusterHits.containsKey(neighbor) && clusterHits.get(neighbor)!=compSeed){//borders clusters
-            			if(mHit.getCorrectedEnergy() < neighbor.getCorrectedEnergy()){
-            				//add to common hits, 
-            				List<CalorimeterHit> commonHitList = new ArrayList<CalorimeterHit>();
-                			commonHitList.add(compSeed);
-                			commonHitList.add(clusterHits.get(neighbor));
-                			commonHits.put(mHit, commonHitList);
-            			}	
-            		}
-            	}	
-        	}

+            	// If the neighboring crystal exists and is not already
+            	// in a cluster, add it to the list of neighboring hits.
+                if (secondaryNeighborHit != null && !hitSeedMap.containsKey(secondaryNeighborHit)) { //!clusteredHitSet.contains(secondaryNeighborHit)) {
+                	secondaryNeighborHits.add(secondaryNeighborHit);
+                }
+            }
+            
+            // Loop over the secondary neighbor hits.
+            for (CalorimeterHit secondaryNeighborHit : secondaryNeighborHits) {
+            	// If the neighboring hit is of lower energy than the
+            	// current secondary hit, then associate the neighboring
+            	// hit with the current secondary hit's seed.
+                if (secondaryNeighborHit.getCorrectedEnergy() < secondaryHit.getCorrectedEnergy()) {
+                	hitSeedMap.put(secondaryNeighborHit, hitSeedMap.get(secondaryHit));
+                }
+            }
+        } // End component hits loop.
+        
+        // Performs second pass calculations for common hits.
+        commonHitsLoop:
+        for (CalorimeterHit clusteredHit : hitSeedMap.keySet()) {
+        	// Seed hits are never common hits and can be skipped.
+        	if(hitSeedMap.get(clusteredHit) == clusteredHit || surrSeedSet.contains(clusteredHit)) { continue commonHitsLoop; }
+        	
+    		// Get the current clustered hit's neighboring crystals.
+            Set<Long> clusteredNeighbors = neighborMap.get(clusteredHit.getCellID());
+            
+            // Store a list of all the clustered hits neighboring
+            // crystals which themselves contain hits.
+            List<CalorimeterHit> clusteredNeighborHits = new ArrayList<CalorimeterHit>();
+            
+            // Loop through the neighbors and see if they have hits.
+            for (Long neighbor : clusteredNeighbors) {
+            	// Get the hit associated with the neighbor.
+            	CalorimeterHit clusteredNeighborHit = hitMap.get(neighbor);
+            	
+            	// If it exists, add it to the neighboring hit list.
+                if (clusteredNeighborHit != null) {
+                	clusteredNeighborHits.add(clusteredNeighborHit);
+                }
+            }
+            
+            // Get the seed hit associated with this clustered hit.
+            CalorimeterHit clusteredHitSeed = hitSeedMap.get(clusteredHit);
+            
+            // Loop over the clustered neighbor hits.
+            for (CalorimeterHit clusteredNeighborHit : clusteredNeighborHits) {
+            	// Check to make sure that the clustered neighbor hit
+            	// is not already associated with the current clustered
+            	// hit's seed.
+                if (hitSeedMap.get(clusteredNeighborHit) != clusteredHitSeed) {
+                    if (clusteredHit.getCorrectedEnergy() < clusteredNeighborHit.getCorrectedEnergy()) {
+                    	// Check and see if a list of common seeds
+                    	// for this hit already exists or not.
+                    	List<CalorimeterHit> commonHitList = commonHits.get(clusteredHit);
+                    	
+                    	// If it does not, make a new one.
+                    	if(commonHitList == null) { commonHitList = new ArrayList<CalorimeterHit>(); }
+                    	
+                    	// Add the neighbors to the seeds to set of
+                    	// common seeds.
+                        commonHitList.add(clusteredHitSeed);
+                        commonHitList.add(hitSeedMap.get(clusteredNeighborHit));
+                        
+                        // Put the common seed list back into the set.
+                        commonHits.put(clusteredHit, commonHitList);
+                    }
+                }
+            }
+        } // End common hits loop.
+        
+        // Remove any common hits from the clustered hits collection.
+        for(CalorimeterHit commonHit : commonHits.keySet()) {
+        	hitSeedMap.remove(commonHit);

         }
         

-        //remove common hits from cluster hits list
-        for(CalorimeterHit commHit : clusterHitList){
-        	if(clusterHitList.contains(commHit)&&commonHits.containsKey(commHit)){
-        		clusterHits.remove(commHit);
-        	}
-        	else{
-        		continue;
-        	}

+        
+        
+        /*
+         * All hits are sorted from above. The next part of the code is for calculating energies. Still 
+         * needs implementation into new cluster collection so as to preserve shared hit energy 
+         * distribution within clusters.
+         */
+                
+        //Create map to contain the total energy of each cluster
+        Map<CalorimeterHit, Double> seedEnergy = new HashMap<CalorimeterHit, Double>();
+        
+        // Get energy of each cluster, excluding common hits
+        for (CalorimeterHit iSeed : hitList) {
+            if(hitSeedMap.get(iSeed) == iSeed) {
+            	seedEnergy.put(iSeed, 0.0);
+            }

         }
         

-
-        		       	
-        //Get energy of each cluster, excluding common hits
-        for(CalorimeterHit iSeed : seedHits){
-        seedEnergy.put(iSeed, 0.0);
-        }

         //Putting total cluster energies excluding common hit energies into map with seed keys    

-        for (Map.Entry<CalorimeterHit, CalorimeterHit> entry : clusterHits.entrySet()) {
-        	CalorimeterHit eSeed = entry.getValue();
-        	double eEnergy = seedEnergy.get(eSeed);
-        	eEnergy += entry.getKey().getRawEnergy();
-        	seedEnergy.put(eSeed, eEnergy);

+        for (Map.Entry<CalorimeterHit, CalorimeterHit> entry : hitSeedMap.entrySet()) {
+            CalorimeterHit eSeed = entry.getValue();
+            double eEnergy = seedEnergy.get(eSeed);
+            eEnergy += entry.getKey().getRawEnergy();
+            seedEnergy.put(eSeed, eEnergy);

         }
         
         //Distribute common hit energies with clusters
         Map<CalorimeterHit, Double> seedEnergyTot = seedEnergy;
         for (Map.Entry<CalorimeterHit, List<CalorimeterHit>> entry1 : commonHits.entrySet()) {

-        	CalorimeterHit commonCell = entry1.getKey();
-        	List<CalorimeterHit> commSeedList = entry1.getValue();
-        	CalorimeterHit seedA = commSeedList.get(0);
-        	CalorimeterHit seedB = commSeedList.get(1);
-        	double eFractionA = seedEnergy.get(seedA)/(seedEnergy.get(seedA)+seedEnergy.get(seedB));

+            CalorimeterHit commonCell = entry1.getKey();
+            List<CalorimeterHit> commSeedList = entry1.getValue();
+            CalorimeterHit seedA = commSeedList.get(0);
+            CalorimeterHit seedB = commSeedList.get(1);
+            double eFractionA = seedEnergy.get(seedA)/(seedEnergy.get(seedA)+seedEnergy.get(seedB));

         	double eFractionB = seedEnergy.get(seedB)/(seedEnergy.get(seedA)+seedEnergy.get(seedB));

-        	double currEnergyA = seedEnergyTot.get(seedA);
-        	double currEnergyB = seedEnergyTot.get(seedB);
-        	currEnergyA += eFractionA*commonCell.getCorrectedEnergy();
-        	currEnergyB += eFractionB*commonCell.getCorrectedEnergy();
-        	
-        	seedEnergyTot.put(seedA, currEnergyA);
-        	seedEnergyTot.put(seedB, currEnergyB);

+            double currEnergyA = seedEnergyTot.get(seedA);
+            double currEnergyB = seedEnergyTot.get(seedB);
+            currEnergyA += eFractionA * commonCell.getCorrectedEnergy();
+            currEnergyB += eFractionB * commonCell.getCorrectedEnergy();
+
+            seedEnergyTot.put(seedA, currEnergyA);
+            seedEnergyTot.put(seedB, currEnergyB);

         }

-                   
-       
-        //Do some system.out for number of crystals in each cluster, energy of each cluster
-        for (Map.Entry<CalorimeterHit, Double> entryEnergy : seedEnergyTot.entrySet()){
-    //    	System.out.println(entryEnergy.getKey().getCellID()+"\t"+entryEnergy.getKey().getCorrectedEnergy()+
-    //    			"\t"+entryEnergy.getValue());
-        }

-   //     System.out.println("Number of clusters: "+seedHits.size());    
-

-      	if (map.size()!=0){
-          	writeHits.append("Event"+"\t"+"1"+"\n");
-          	for (CalorimeterHit n : chitList){
-          		writeHits.append("EcalHit" + "\t" + n.getIdentifierFieldValue("ix") + "\t" + n.getIdentifierFieldValue("iy")
-          		+ "\t" +n.getCorrectedEnergy() + "\n");
-          	}
-          	
-      		for (Map.Entry<CalorimeterHit, CalorimeterHit> entry2 : clusterHits.entrySet()){
-      			if (entry2.getKey()==entry2.getValue()){//seed
-      				writeHits.append("Cluster" + "\t" + entry2.getKey().getIdentifierFieldValue("ix")+
-        				"\t"+entry2.getKey().getIdentifierFieldValue("iy")+"\t"+seedEnergyTot.get(entry2.getKey())+"\n");
-                  
-      				HPSEcalCluster cluster = new HPSEcalCluster(entry2.getKey());

+        
+        
+        /*
+         * Prints the results in event display format. Not analyzed
+         * for efficiency, as this will ultimately not be a part of
+         * the driver and should be handled by the event display output
+         * driver instead.
+         */
+        // Only write to the output file is something actually exists.
+        if (hitMap.size() != 0) {
+        	// Increment the event number.
+        	eventNum++;
+        	
+        	// Write the event header.
+//        	writeHits.append(String.format("Event\t%d%n", eventNum));
+        	
+        	// Write the calorimeter hits that passed the energy cut.
+            for (CalorimeterHit n : hitList) {
+            	int hix = n.getIdentifierFieldValue("ix");
+            	int hiy = n.getIdentifierFieldValue("iy");
+            	double energy = n.getCorrectedEnergy();
+//            	writeHits.append(String.format("EcalHit\t%d\t%d\t%f%n", hix, hiy, energy));
+            }
+            
+            
+            for (Map.Entry<CalorimeterHit, CalorimeterHit> entry2 : hitSeedMap.entrySet()) {
+                if ((entry2.getKey() == entry2.getValue())&&(entry2.getKey().getCorrectedEnergy()>=seedEnergyThreshold)
+                		&&(seedEnergyTot.get(entry2.getKey())>=clusterEnergyThreshold)) {//seed and passes all thresholds
+                	int six = entry2.getKey().getIdentifierFieldValue("ix");
+                	int siy = entry2.getKey().getIdentifierFieldValue("iy");
+                	double energy = seedEnergyTot.get(entry2.getKey());
+//                	writeHits.append(String.format("Cluster\t%d\t%d\t%f%n", six, siy, energy));
+                	
+                    cluster.setParameters(entry2.getKey());

                     cluster.addHit(entry2.getKey());

-      				
-                    for (Map.Entry<CalorimeterHit, CalorimeterHit> entry3 : clusterHits.entrySet()){
-      					if (entry3.getValue() == entry2.getValue()){
-      						writeHits.append("CompHit" + "\t" + entry3.getKey().getIdentifierFieldValue("ix")+ "\t"
-      			        	+entry3.getKey().getIdentifierFieldValue("iy") + "\n");
-      						
-      						cluster.addHit(entry3.getKey());
-      					}
-      				}
-      				for (Map.Entry<CalorimeterHit, List<CalorimeterHit>> entry4 : commonHits.entrySet()){
-      					if (entry4.getValue().contains(entry2.getKey())){      						
-      						writeHits.append("SharHit" + "\t" + entry4.getKey().getIdentifierFieldValue("ix")+ "\t"
-      						+entry4.getKey().getIdentifierFieldValue("iy") + "\n");
-      						
-      						cluster.addHit(entry4.getKey());
-      						
-      					}
-      				}
-      				
-      				clusters.add(cluster);
-      			}	
-      		}
-      		writeHits.append("EndEvent\n");
-      		
-      	}
-      	
-      	 //Clear all maps for next event iteration
-        hitID.clear();
-        clusterHits.clear();
-        seedHits.clear();
-        commonHits.clear();
-        chitList.clear();
-        seedEnergy.clear();
- 
-        return clusters;
-      	
-      	
-      	

-      }

+                    for (Map.Entry<CalorimeterHit, CalorimeterHit> entry3 : hitSeedMap.entrySet()) {
+                        if (entry3.getValue() == entry2.getValue()) {
+                        	int ix = entry3.getKey().getIdentifierFieldValue("ix");
+                        	int iy = entry3.getKey().getIdentifierFieldValue("iy");
+//                       	writeHits.append(String.format("CompHit\t%d\t%d%n", ix, iy));
+                        	
+                            cluster.addHit(entry3.getKey());
+                        }
+                    }
+                    for (Map.Entry<CalorimeterHit, List<CalorimeterHit>> entry4 : commonHits.entrySet()) {
+                        if (entry4.getValue().contains(entry2.getKey())) {
+                        	int ix = entry4.getKey().getIdentifierFieldValue("ix");
+                        	int iy = entry4.getKey().getIdentifierFieldValue("iy");
+//                        	writeHits.append(String.format("SharHit\t%d\t%d%n", ix, iy));
+                        	
+                            cluster.addHit(entry4.getKey());
+                        }
+                    }
+
+                    clusterList.add(cluster);
+                }
+            }
+            
+            // Write the event termination header.
+//            writeHits.append("EndEvent\n");
+        } //End event display output loop.
+        
+        
+        
+        
+        
+        // Return the resulting cluster list.
+        return clusterList;
+    }

     
     public void endOfData() {

-    	try{
-    	writeHits.close();
-    	}
-    	catch (IOException e){ }

+    	// Close the event display output writer.
+        try { writeHits.close(); }
+        catch (IOException e) { }

     }

-
-    private class EnergyComparator implements Comparator<CalorimeterHit>{
-
-		@Override
-		public int compare(CalorimeterHit o1, CalorimeterHit o2) {
-			// TODO Auto-generated method stub
-			double diff = o1.getCorrectedEnergy()-o2.getCorrectedEnergy();
-			if(diff < 0) { return 1; }
-			if(diff > 0) { return -1; } 
-			else { return 0; }
-		}		
-    }   

+    
+    private static class EnergyComparator implements Comparator<CalorimeterHit> {
+        public int compare(CalorimeterHit o1, CalorimeterHit o2) {
+        	// If the energies are equivalent, the same, the two hits
+        	// are considered equivalent.
+        	if(o1.getCorrectedEnergy() == o2.getCorrectedEnergy()) { return 0; }
+        	
+        	// Higher energy hits are ranked higher than lower energy hits.
+        	else if(o1.getCorrectedEnergy() > o2.getCorrectedEnergy()) { return -1; }
+        	
+        	// Lower energy hits are ranked lower than higher energy hits.
+        	else { return 1; }
+        }
+    }

 }