7 added + 5 modified, total 12 files
lcsim/src/org/lcsim/contrib/uiowa/template
diff -N BothCalorimetersDecision.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ BothCalorimetersDecision.java 17 Jan 2006 00:33:12 -0000 1.1
@@ -0,0 +1,46 @@
+package template;
+
+import org.lcsim.util.decision.*;
+import org.lcsim.util.*;
+import org.lcsim.event.*;
+
+/**
+ * Require one cluster to be in the ECAL and one to be in the HCAL
+ */
+public class BothCalorimetersDecision implements DecisionMakerPair<Cluster,Cluster>
+{
+ /**
+ * Constructor.
+ */
+ public BothCalorimetersDecision() {
+ // empty
+ }
+
+ /**
+ * Check a pair. Written in a lazy way for now.
+ */
+ public boolean valid(Cluster clus1, Cluster clus2)
+ {
+ // Require at least one hit in each
+ if (clus1.getCalorimeterHits().size()<1 || clus2.getCalorimeterHits().size()<1 ) {
+ return false;
+ }
+
+ // Find the first hit in each
+ CalorimeterHit hit1 = clus1.getCalorimeterHits().get(0);
+ CalorimeterHit hit2 = clus2.getCalorimeterHits().get(0);
+
+ // Are they ECAL or HCAL? (ugly)
+ org.lcsim.geometry.Subdetector subdet1 = hit1.getSubdetector();
+ org.lcsim.geometry.Subdetector subdet2 = hit2.getSubdetector();
+ String name1 = subdet1.getName();
+ String name2 = subdet2.getName();
+ boolean ecal1 = (name1.compareTo("EMBarrel") == 0 || name1.compareTo("EMEndcap") == 0);
+ boolean ecal2 = (name2.compareTo("EMBarrel") == 0 || name2.compareTo("EMEndcap") == 0);
+ boolean hcal1 = (name1.compareTo("HADBarrel") == 0 || name1.compareTo("HADEndcap") == 0);
+ boolean hcal2 = (name2.compareTo("HADBarrel") == 0 || name2.compareTo("HADEndcap") == 0);
+
+ // Check that we have one of each
+ return ( (ecal1&&hcal2) || (ecal2&&hcal1) );
+ }
+}
lcsim/src/org/lcsim/contrib/uiowa/template
diff -N DebugInfoClusterList.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DebugInfoClusterList.java 17 Jan 2006 00:33:12 -0000 1.1
@@ -0,0 +1,115 @@
+package template;
+
+import java.util.List;
+import java.util.Vector;
+import java.util.Map;
+import java.util.HashMap;
+import java.lang.String;
+import java.util.Set;
+import java.util.HashSet;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import org.lcsim.event.EventHeader;
+import org.lcsim.util.Driver;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.Track;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.CalorimeterHit;
+
+public class DebugInfoClusterList extends Driver
+{
+ public DebugInfoClusterList(String inputClusterListName)
+ {
+ m_inputClusterListName = inputClusterListName;
+ }
+
+ public void process(EventHeader event)
+ {
+ // Read in the clusters:
+ List<Cluster> inputClusterList = event.get(Cluster.class, m_inputClusterListName);
+
+ int hitSum = 0;
+ Set<CalorimeterHit> usedHits = new HashSet<CalorimeterHit>();
+ Set<CalorimeterHit> duplicateHits = new HashSet<CalorimeterHit>();
+ for (Cluster currentCluster : inputClusterList) {
+ hitSum += currentCluster.getCalorimeterHits().size();
+ for (CalorimeterHit hit : currentCluster.getCalorimeterHits()) {
+ if (usedHits.contains(hit)) {
+ duplicateHits.add(hit);
+ } else {
+ usedHits.add(hit);
+ }
+ }
+ }
+ System.out.println("For cluster list ["+m_inputClusterListName+"]:"
+ +" clusters="+inputClusterList.size()
+ +" hits="+hitSum);
+
+ /*
+ if (duplicateHits.size()>0) {
+ System.out.println("There were "+duplicateHits.size()+" duplicate hits...");
+
+ Map<List<Cluster>, List<CalorimeterHit>> duplicateMap = new HashMap<List<Cluster>, List<CalorimeterHit>> ();
+ Map<CalorimeterHit, List<Cluster>> duplicateReverseMap = new HashMap<CalorimeterHit, List<Cluster>> ();
+ // Build the backwards map:
+ for (Cluster currentCluster : inputClusterList) {
+ for (CalorimeterHit hit : currentCluster.getCalorimeterHits()) {
+ if (duplicateHits.contains(hit)) {
+ List<Cluster> clusterList = duplicateReverseMap.get(hit);
+ if (clusterList == null) {
+ clusterList = new Vector<Cluster> ();
+ duplicateReverseMap.put(hit, clusterList);
+ }
+ if (clusterList.contains(currentCluster)) { throw new AssertionError("Hit twice in cluster!"); }
+ clusterList.add(currentCluster);
+ }
+ }
+ }
+ // Build the forwards map:
+ for (CalorimeterHit hit : duplicateHits) {
+ List<Cluster> clusterList = duplicateReverseMap.get(hit);
+ if (clusterList == null) { throw new AssertionError("Hit never appears!"); }
+ // Let's see if the cluster list appears already:
+ boolean matchFound = false;
+ for (List<Cluster> anotherClusterList : duplicateMap.keySet()) {
+ boolean matchSize = (clusterList.size() == anotherClusterList.size());
+ boolean matchContent = true;
+ if (matchSize) {
+ for (Cluster clus : clusterList) {
+ matchContent = matchContent && (anotherClusterList.contains(clus));
+ }
+ }
+ if (matchSize && matchContent) {
+ // Yah, this is a match
+ List<CalorimeterHit> hits = duplicateMap.get(anotherClusterList);
+ hits.add(hit);
+ matchFound = true;
+ }
+ }
+ if (!matchFound) {
+ // No match exists - need to create a new entry
+ List<CalorimeterHit> hits = new Vector<CalorimeterHit>();
+ hits.add(hit);
+ duplicateMap.put(clusterList, hits);
+ }
+ }
+
+ // Look at the forwards map
+ System.out.println(duplicateMap.keySet().size()+" kinds of duplicate:");
+ for (List<Cluster> clusterList : duplicateMap.keySet()) {
+ List<CalorimeterHit> hits = duplicateMap.get(clusterList);
+ String str = new String();
+ str += " "+hits.size()+" cases of "+clusterList.size()+" clusters: ";
+ for (Cluster clus : clusterList) {
+ str += "[" + clus + "]";
+ }
+ System.out.println(str);
+ }
+ }
+ */
+ }
+
+ String m_inputClusterListName;
+}
lcsim/src/org/lcsim/contrib/uiowa/template
diff -N DebugInfoHitMap.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DebugInfoHitMap.java 17 Jan 2006 00:33:13 -0000 1.1
@@ -0,0 +1,50 @@
+package template;
+
+import java.util.List;
+import java.util.Map;
+import java.lang.String;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import org.lcsim.event.EventHeader;
+import org.lcsim.util.Driver;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.Track;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.CalorimeterHit;
+
+import java.util.Set;
+import java.util.HashSet;
+
+public class DebugInfoHitMap extends Driver
+{
+ public DebugInfoHitMap(String inputHitMapName)
+ {
+ m_inputHitMapName = inputHitMapName;
+ }
+
+ public void process(EventHeader event)
+ {
+ // Read in the clusters:
+ Map<Long, CalorimeterHit> inputHitMap = (Map<Long, CalorimeterHit>) (event.get(m_inputHitMapName));
+
+ int hitSum = 0;
+ Set<CalorimeterHit> usedHits = new HashSet<CalorimeterHit>();
+ Set<CalorimeterHit> duplicateHits = new HashSet<CalorimeterHit>();
+ for (CalorimeterHit hit : inputHitMap.values()) {
+ hitSum++;
+ if (usedHits.contains(hit)) {
+ duplicateHits.add(hit);
+ } else {
+ usedHits.add(hit);
+ }
+ }
+ System.out.println("For HitMap ["+m_inputHitMapName+"]:"
+ +" hits="+hitSum
+ +" duplicate hits="+(duplicateHits.size())
+ +" used hits="+(usedHits.size())
+ );
+ }
+ String m_inputHitMapName;
+}
lcsim/src/org/lcsim/contrib/uiowa/template
diff -N DebugInfoParticleList.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DebugInfoParticleList.java 17 Jan 2006 00:33:13 -0000 1.1
@@ -0,0 +1,30 @@
+package template;
+
+import java.util.List;
+import java.lang.String;
+import org.lcsim.event.EventHeader;
+import org.lcsim.util.Driver;
+
+import org.lcsim.event.ReconstructedParticle;
+
+public class DebugInfoParticleList extends Driver
+{
+ public DebugInfoParticleList(String inputClusterListName)
+ {
+ m_inputParticleListName = inputClusterListName;
+ }
+
+ public void process(EventHeader event)
+ {
+ // Read in the clusters:
+ List<ReconstructedParticle> inputParticleList = event.get(ReconstructedParticle.class, m_inputParticleListName);
+ double energySum = 0.0;
+ for (ReconstructedParticle part : inputParticleList) {
+ energySum += part.getEnergy();
+ }
+
+ System.out.println("There were "+inputParticleList.size()+" particles found in this event, for a total energy of "+energySum);
+ }
+
+ String m_inputParticleListName;
+}
lcsim/src/org/lcsim/contrib/uiowa/template
diff -N DebugInfoTrackList.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DebugInfoTrackList.java 17 Jan 2006 00:33:13 -0000 1.1
@@ -0,0 +1,31 @@
+package template;
+
+import java.util.List;
+
+import org.lcsim.event.EventHeader;
+import org.lcsim.util.Driver;
+import org.lcsim.event.Track;
+import org.lcsim.event.MCParticle;
+
+public class DebugInfoTrackList extends Driver
+{
+ public DebugInfoTrackList(String inputName) {
+ m_name = inputName;
+ }
+
+ public void process(EventHeader event)
+ {
+ List<Track> inputTrackList = event.get(Track.class, m_name);
+ System.out.println("Track list "+m_name+" contains "+inputTrackList.size()+" tracks.");
+ for (Track t : inputTrackList) {
+ String paramDump = new String(" Params:");
+ double[] params = t.getTrackParameters();
+ for (double param : params) {
+ paramDump += " "+param;
+ }
+ //System.out.println(paramDump);
+ }
+ }
+
+ String m_name;
+}
lcsim/src/org/lcsim/contrib/uiowa/template
diff -N NewMSTDriver.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ NewMSTDriver.java 17 Jan 2006 00:33:13 -0000 1.1
@@ -0,0 +1,111 @@
+package template;
+
+import java.io.*;
+import java.util.*;
+
+import org.lcsim.util.*;
+import org.lcsim.event.*;
+import org.lcsim.recon.cluster.mst.*;
+import org.lcsim.recon.cluster.util.*;
+import org.lcsim.util.decision.*;
+import org.lcsim.recon.cluster.clumpfinder.*;
+import org.lcsim.recon.cluster.util.ClusterSizeDecision;
+
+// Input: hitmap
+// Output: modified hitmap,
+// Output: List<Cluster>
+
+public class NewMSTDriver extends Driver
+{
+ public NewMSTDriver(String inputHitMap, String outputHitMap, String outputClusterList) {
+ m_inputHitMapNames.add(inputHitMap);
+ m_outputHitMapName = outputHitMap;
+ m_outputClusterListName = outputClusterList;
+ }
+ public NewMSTDriver(String outputHitMap, String outputClusterList) {
+ m_outputHitMapName = outputHitMap;
+ m_outputClusterListName = outputClusterList;
+ }
+
+ public void process(EventHeader event)
+ {
+ // Set up the inputs:
+ List<Map<Long, CalorimeterHit>> inputHitMaps = new Vector<Map<Long, CalorimeterHit>>();
+ Collection<CalorimeterHit> inputHits = new Vector<CalorimeterHit>();
+ for (String inputHitMapName : m_inputHitMapNames) {
+ Map<Long, CalorimeterHit> currentInputHitMap = (Map<Long, CalorimeterHit>) (event.get(inputHitMapName));
+ inputHitMaps.add(currentInputHitMap);
+ inputHits.addAll(currentInputHitMap.values());
+ }
+ List<Cluster> inputClusters = new Vector<Cluster>();
+ for (String inputClusterListName : m_inputClusterListNames) {
+ List<Cluster> currentInputClusterList = event.get(Cluster.class, inputClusterListName);
+ inputClusters.addAll(currentInputClusterList);
+ }
+
+ // Wrap the inputs:
+ ObjectToClusterWrapper wrap = new BasicObjectToClusterWrapper();
+ List<Cluster> wrappedHits;
+ try {
+ wrappedHits = wrap.wrapListOfObjects(inputHits);
+ } catch (UnwrappableObjectException x) {
+ // We fed it an object it didn't understand
+ throw new AssertionError(x);
+ }
+ wrappedHits.addAll(inputClusters);
+
+ // Apply prefilter:
+ ListFilter<Cluster> filter = new ListFilter<Cluster> (inputDecision);
+ List<Cluster> filteredInputList = filter.filterList(wrappedHits);
+
+ // Make the clusterer:
+ MSTClusterBuilder clusterBuilder = new MSTClusterBuilder( filteredInputList, event );
+ clusterBuilder.registerMetrics(metrics);
+ clusterBuilder.setThreshold(threshold);
+ clusterBuilder.setSeedDecision(seedDecision);
+ clusterBuilder.setPairDecision(pairDecision);
+ clusterBuilder.setOutputDecision(outputDecision);
+
+ // Cluster & write out cluster list:
+ List<Cluster> outputList = clusterBuilder.doClustering();
+ event.put(m_outputClusterListName, outputList );
+
+ // Now, produce an updated HitMap
+ Map<Long, CalorimeterHit> outputHitMap = new HashMap<Long, CalorimeterHit>();
+ // Add all input hits
+ for (Map<Long, CalorimeterHit> inputHitMap : inputHitMaps) {
+ outputHitMap.putAll(inputHitMap);
+ }
+ // Remove all used hits:
+ for (Cluster clus : outputList) {
+ for (CalorimeterHit hit : clus.getCalorimeterHits()) {
+ Long cellID = new Long(hit.getCellID());
+ outputHitMap.remove(cellID);
+ }
+ }
+ // Write out:
+ event.put(m_outputHitMapName, outputHitMap);
+ }
+
+ public void addInputClusterList(String name) { m_inputClusterListNames.add(name); }
+ public void addInputHitMap(String name) { m_inputHitMapNames.add(name); }
+ public void setThreshold(double value){threshold = value;}
+ public void registerMetrics(Metrics inMetrics){metrics = inMetrics;}
+ public void setInputDecision(DecisionMakerSingle<Cluster> decision){inputDecision = decision;}
+ public void setSeedDecision(DecisionMakerSingle<Cluster> decision){seedDecision = decision;}
+ public void setPairDecision(DecisionMakerPair<Cluster,Cluster> decision){pairDecision = decision;}
+ public void setOutputDecision(DecisionMakerSingle<Cluster> decision){outputDecision = decision;}
+
+ double threshold = 30.0;
+ Metrics metrics = new GeometricalDistance();
+ DecisionMakerSingle<Cluster> inputDecision = new ClusterNotEmptyDecisionMaker();
+ DecisionMakerSingle<Cluster> seedDecision = new ClusterNotEmptyDecisionMaker();
+ DecisionMakerPair<Cluster,Cluster> pairDecision = new ClusterNotEmptyDecisionMaker();
+ DecisionMakerSingle<Cluster> outputDecision = new ClusterNotEmptyDecisionMaker();
+
+ String m_outputHitMapName;
+ String m_outputClusterListName;
+
+ List<String> m_inputHitMapNames = new Vector<String>();
+ List<String> m_inputClusterListNames = new Vector<String>();
+}
lcsim/src/org/lcsim/contrib/uiowa/template
diff -N NonTrivialPFA.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ NonTrivialPFA.java 17 Jan 2006 00:33:13 -0000 1.1
@@ -0,0 +1,111 @@
+package template;
+
+import java.util.*;
+
+import org.lcsim.util.*;
+import org.lcsim.event.*;
+import org.lcsim.recon.cluster.mst.*;
+import org.lcsim.recon.cluster.mipfinder.*;
+import org.lcsim.recon.cluster.clumpfinder.*;
+
+//import structural.*;
+
+public class NonTrivialPFA extends Driver
+{
+ public NonTrivialPFA()
+ {
+ // Step 0: Set up input hit lists:
+ HitMapDriver hitmapEcal = new HitMapDriver();
+ hitmapEcal.addInputList("EcalBarrHits");
+ hitmapEcal.addInputList("EcalEndcapHits");
+ hitmapEcal.setOutput("input hit map ecal");
+ HitMapDriver hitmapHcal = new HitMapDriver();
+ hitmapHcal.addInputList("HcalBarrHits");
+ hitmapHcal.addInputList("HcalEndcapHits");
+ hitmapHcal.setOutput("input hit map hcal");
+ add(hitmapEcal);
+ add(hitmapHcal);
+
+ // Step 1: Run digisim
+ // [digisim]
+
+ // Find tracks
+ // Output: List<Track> saved as EventHeader.TRACKS
+ add (new org.lcsim.mc.fast.tracking.MCFastTracking());
+
+ // Find track segments in ECAL and HCAL
+ TrackClusterDriver ecalMIP = new TrackClusterDriver("input hit map ecal", "ecalMIP", "hit map ecal without mips");
+ TrackClusterDriver hcalMIP = new TrackClusterDriver("input hit map hcal", "hcalMIP", "hit map hcal without mips");
+ add(ecalMIP);
+ add(hcalMIP);
+
+ // Step 5b: Find clumps in ECAL and HCAL
+ // Clumps are defined as contiguous sets of
+ // 6+ hits where the local hit density (in a 5x5x3 block) is 7/75
+ // or more for each hit. Track segment hits
+ // are NOT used.
+ ClumpFinder findClumpsECAL = new ClumpFinder("hit map ecal without mips", "clumps ecal", "hit map ecal without mips or clumps");
+ ClumpFinder findClumpsHCAL = new ClumpFinder("hit map hcal without mips", "clumps hcal", "hit map hcal without mips or clumps");
+ add(findClumpsECAL);
+ add(findClumpsHCAL);
+
+
+ // Step 3: Find large-scale clusters with the MST
+ // Output: List<Cluster>
+ NewMSTDriver mstEcal = new NewMSTDriver("ecal hit map after mst", "mst clusters ecal");
+ NewMSTDriver mstHcal = new NewMSTDriver("hcal hit map after mst", "mst clusters hcal");
+ mstEcal.addInputHitMap("hit map ecal without mips or clumps");
+ mstHcal.addInputHitMap("hit map hcal without mips or clumps");
+ mstEcal.addInputClusterList("ecalMIP");
+ mstHcal.addInputClusterList("hcalMIP");
+ mstEcal.addInputClusterList("clumps ecal");
+ mstHcal.addInputClusterList("clumps hcal");
+ mstEcal.setThreshold(30.0);
+ mstHcal.setThreshold(100.0);
+ mstEcal.registerMetrics(new MinimumHitToHitDistance());
+ mstHcal.registerMetrics(new MinimumHitToHitDistance());
+ add (mstEcal);
+ add (mstHcal);
+
+ // Step 4: Link across the ECAL-HCAL boundary
+ // Input: List<Cluster> for ECAL
+ // Input: List<Cluster> for HCAL
+ // Output: List<Cluster>
+ MSTClusterDriver mstDriverLink = new MSTClusterDriver("User");
+ mstDriverLink.registerMetrics(new MinimumHitToHitDistance());
+ mstDriverLink.setThreshold(50.0); // 5cm
+ mstDriverLink.addUserInputList("mst clusters ecal");
+ mstDriverLink.addUserInputList("mst clusters hcal");
+ mstDriverLink.setClusterName("mst clusters linked");
+ mstDriverLink.setPairDecision(new BothCalorimetersDecision());
+ add(mstDriverLink);
+
+ // if (writeLikelihood) {
+ // Step 6a: Make likelihood PDFs
+ // } else {
+ // Step 6b: Structural algorithm
+ // Step 6c: Extrapolate tracks to ECAL surface
+ // Step 6d: Handle fragments
+ // Step 6e: Plots
+ // }
+
+ add(new DebugInfoHitMap("input hit map ecal"));
+ add(new DebugInfoHitMap("input hit map hcal"));
+ add(new DebugInfoHitMap("hit map ecal without mips"));
+ add(new DebugInfoHitMap("hit map hcal without mips"));
+ add(new DebugInfoHitMap("hit map ecal without mips or clumps"));
+ add(new DebugInfoHitMap("hit map hcal without mips or clumps"));
+ add(new DebugInfoHitMap("ecal hit map after mst"));
+ add(new DebugInfoHitMap("hcal hit map after mst"));
+
+ add(new DebugInfoClusterList("ecalMIP"));
+ add(new DebugInfoClusterList("hcalMIP"));
+ add(new DebugInfoClusterList("clumps ecal"));
+ add(new DebugInfoClusterList("clumps hcal"));
+ add(new DebugInfoClusterList("mst clusters ecal"));
+ add(new DebugInfoClusterList("mst clusters hcal"));
+ add(new DebugInfoClusterList("mst clusters linked"));
+
+ add(new DebugInfoTrackList(EventHeader.TRACKS));
+ }
+}
lcsim/src/org/lcsim/contrib/uiowa/template
diff -u -r1.1 -r1.2
--- BasicReconstructedParticle.java 11 Jan 2006 21:26:50 -0000 1.1
+++ BasicReconstructedParticle.java 17 Jan 2006 00:33:12 -0000 1.2
@@ -1,6 +1,6 @@
// WARNING! Doesn't do anything
-package devel;
+package template;
import hep.physics.vec.*;
import java.util.*;
@@ -74,6 +74,9 @@
public BasicReconstructedParticle() {
// empty
}
+ public void setEnergy(double energy) {
+ m_energy = energy;
+ }
// Data:
lcsim/src/org/lcsim/contrib/uiowa/template
diff -u -r1.1 -r1.2
--- HitMapDriver.java 11 Jan 2006 21:26:50 -0000 1.1
+++ HitMapDriver.java 17 Jan 2006 00:33:13 -0000 1.2
@@ -1,4 +1,4 @@
-package devel;
+package template;
import java.util.*;
import org.lcsim.util.*;
lcsim/src/org/lcsim/contrib/uiowa/template
diff -u -r1.1 -r1.2
--- PerfectClusterer.java 11 Jan 2006 21:26:50 -0000 1.1
+++ PerfectClusterer.java 17 Jan 2006 00:33:13 -0000 1.2
@@ -1,4 +1,4 @@
-package devel;
+package template;
import java.util.*;
lcsim/src/org/lcsim/contrib/uiowa/template
diff -u -r1.1 -r1.2
--- PerfectIdentifier.java 11 Jan 2006 21:26:51 -0000 1.1
+++ PerfectIdentifier.java 17 Jan 2006 00:33:13 -0000 1.2
@@ -1,4 +1,4 @@
-package devel;
+package template;
import java.util.*;
import org.lcsim.util.*;
@@ -19,8 +19,9 @@
// Identify
MCParticle truthID = findTruthID(clus, mcList);
// Add to output list
- ReconstructedParticle part = new BasicReconstructedParticle();
+ BasicReconstructedParticle part = new BasicReconstructedParticle();
part.addCluster(clus);
+ part.setEnergy(truthID.getEnergy());
// [... do more to fix up particle...]
outputParticleList.add(part);
}
lcsim/src/org/lcsim/contrib/uiowa/template
diff -u -r1.1 -r1.2
--- TrivialPFA.java 11 Jan 2006 21:26:51 -0000 1.1
+++ TrivialPFA.java 17 Jan 2006 00:33:13 -0000 1.2
@@ -1,4 +1,4 @@
-package devel;
+package template;
import org.lcsim.util.*;
import org.lcsim.event.*;
@@ -39,5 +39,10 @@
id.setMCParticleList("GenFinalStateParticles");
add(id);
+ // Some debug output
+ add(new DebugInfoHitMap("hits"));
+ add(new DebugInfoHitMap("leftover hits"));
+ add(new DebugInfoClusterList("perfect clusters"));
+ add(new DebugInfoParticleList("perfect particles"));
}
}
CVSspam 0.2.8
