LISTSERV 16.5 - LCD-CVS Archives

// The output is a map from a cluster (the big cluster) to a list of clusters (the clumps in that big cluster) MapClusterToListOfClusters outputMap = new MapClusterToListOfClusters(); // We also use a map from clusters to track segments:

- List<MapClusterToListOfClusters> inputTrackMapList = event.get(MapClusterToListOfClusters.class, m_trackMapName); - MapClusterToListOfClusters inputTrackMap = null; - if (inputTrackMapList != null) { - if (inputTrackMapList.iterator().hasNext()) { - inputTrackMap = inputTrackMapList.iterator().next(); - } - }

+ List<Object> dummyInputList = event.get(Object.class, m_trackMapName); + Object dummyInputObj = dummyInputList.iterator().next(); + Map<Cluster, List<Cluster>> inputTrackMap = (Map<Cluster, List<Cluster>>) (dummyInputObj);

+ + public boolean isLinkCorrect(Cluster clus1, MCParticle part, EventHeader event) + { + if (event != m_cacheEvent) { + m_cacheEvent = event; + m_cacheAssociator = new EnergyAssociator(event); + } + + if (part != null) { + List<MCParticle> mc1 = m_cacheAssociator.associateClusterToMCParticles(clus1); + if (mc1 != null) { + if (mc1.size()>0) { + MCParticle dominant1 = mc1.iterator().next(); + if (dominant1 == part) { + // Match! + return true; + } + } + } + } + // Failure + return false; + }

lcsim/src/org/lcsim/contrib/uiowa/structural

ExamplePFA.java 1.5 -> 1.6

diff -u -r1.5 -r1.6
--- ExamplePFA.java	19 Oct 2005 19:43:09 -0000	1.5
+++ ExamplePFA.java	16 Dec 2005 21:12:13 -0000	1.6
@@ -3,8 +3,12 @@

 import java.util.List;
 import java.util.Vector;

+import hep.physics.vec.*;
+

 import org.lcsim.event.EventHeader;
 import org.lcsim.util.Driver;

+import org.lcsim.event.Cluster;
+import org.lcsim.event.MCParticle;

 
 import structural.likelihood.*;
 import mst.MSTClusterDriver;

@@ -15,7 +19,7 @@

 /**
  * An example PFA using the structual algorithm.
  *

- * @version $Id: ExamplePFA.java,v 1.5 2005/10/19 19:43:09 mcharles Exp $

+ * @version $Id: ExamplePFA.java,v 1.6 2005/12/16 21:12:13 mcharles Exp $

  */
 
 public class ExamplePFA extends Driver

@@ -26,6 +30,30 @@

 
     public ExamplePFA(boolean writeLikelihood) 
     {

+        // Step 1 (here):
+        //   For each MC particle, make a helix swimmer.
+	//   Requires B field.
+        //   Output: Helix swimmer and MC particle (linked)
+        // Step 2:
+        //   For each helix, extrapolate it to the calorimeter
+        //   surfaces (barrel and endcap).
+	//   Requires geometry information.
+        //   Output: Position and momentum for each particle/swimmer
+        // Step 3:
+        //   For each helix that reaches an ECAL, look for
+        //   a MIP stub or cluster nearby.
+	//   Output: Bi-directional maps from MCParticle/swimmer to cluster
+	// Step 4:
+	//   (a) Handle MCParticles which weren't mapped properly
+        //   (b) Look at E/P for MCParticles which were mapped.
+	//
+	String nameOfHelixList = new String("HelixList");
+	String nameOfExtrapolationInfoList = new String("HelixExtrapolatedToECALList");
+	String nameOfHelixToClusterMap = new String("HelixToClusterMap");
+	String nameOfClusterToHelixMap = new String("ClusterToHelixMap");
+        add(new MakeHelixSwimmersFromTruth(nameOfHelixList)); // step 1 and 2
+	add(new SwimToECAL(nameOfHelixList, nameOfExtrapolationInfoList)); // step 2
+

 	// Begin with a big-scale cluster set, made with the MST:
 	Metrics geomDist = new GeometricalDistance();
 	Metrics hitHitDist = new MinimumHitToHitDistance();

@@ -49,6 +77,9 @@

 	add(findTracksEcal);
 	add(findTracksHcal);

+	// Try to link the tracks from the tracking system to MIP segments and/or clusters:
+        add(new MatchHelixToCluster(nameOfExtrapolationInfoList, "Track segments EMCal", "MSTCluster EMCal", nameOfHelixToClusterMap, nameOfClusterToHelixMap));
+

 	// Now, link them together across the ECAL-HCAL boundary:
 	MSTClusterDriver mstDriverLink = new MSTClusterDriver("User");
 	mstDriverLink.registerMetrics(hitHitDist);

@@ -59,9 +90,16 @@

 	add(mstDriverLink);
 
 	// Special thing: Map MIPs to clusters correctly after this cluster linking...

-	Remapper remapTracks = new Remapper("MSTCluster linked", "Track segments linked");
-	remapTracks.addInputClusters("MSTCluster EMCal", "Track segments EMCal");
-	remapTracks.addInputClusters("MSTCluster HCal", "Track segments HCal");

+	Remapper<Cluster> remapMIPs = new Remapper<Cluster>("MSTCluster linked", "Track segments linked");
+	remapMIPs.addInputClusters("MSTCluster EMCal", "Track segments EMCal");
+	remapMIPs.addInputClusters("MSTCluster HCal", "Track segments HCal");
+	remapMIPs.setDebug(true);
+	add(remapMIPs);
+	String nameOfClusterToHelixMapLinked = new String("ClusterToHelixMapLinked");
+	Remapper<TrackExtrapolationInfo> remapTracks = new Remapper<TrackExtrapolationInfo>("MSTCluster linked", nameOfClusterToHelixMapLinked);
+	remapTracks.addInputClusters("MSTCluster EMCal", nameOfClusterToHelixMap);
+	remapTracks.addInputClusters("MSTCluster HCal", nameOfClusterToHelixMap);
+	remapTracks.setDebug(true);

 	add(remapTracks);
 
 	// Find clumps within clusters

@@ -75,15 +113,15 @@

 		// Obtain and write likelihood histograms
 		System.out.println("ExamplePFA: I will obtain and write out likelihood histograms.");
 		LikelihoodEvaluator eval = new LikelihoodEvaluator();

-		eval.addLikelihoodQuantityTrackToTrack(new TrackToTrackDOCA(), 10, 0.0, 100.0, false, true);

+		eval.addLikelihoodQuantityTrackToTrack(new TrackToTrackDOCA(), 50, 0.0, 100.0, false, true);

 		eval.addLikelihoodQuantityTrackToTrack(new TrackToTrackPOCAInCalorimeter(), 2, -0.5, 1.5, false, false);

-		eval.addLikelihoodQuantityTrackToTrack(new TrackToTrackSmallestDistanceToPOCA(), 5, 0.0, 50.0, false, true);

+		eval.addLikelihoodQuantityTrackToTrack(new TrackToTrackSmallestDistanceToPOCA(), 25, 0.0, 250.0, false, true);

 		//eval.addLikelihoodQuantityTrackToTrack(new TrackToTrackIntermediateHitsCount(), 10, -0.5, 9.5, false, true);
 		//eval.addLikelihoodQuantityTrackToTrack(new TrackToTrackIntermediateHitsFraction(), 11, -0.05, 1.05, false, false);

-		eval.addLikelihoodQuantityTrackToClump(new TrackToClumpDOCA(), 5, 0.0, 250.0, false, true);
-		eval.addLikelihoodQuantityTrackToClump(new ClusterToClusterMinDistance(), 5, 0.0, 250.0, false, true);
-		eval.addLikelihoodQuantityClumpToClump(new ClumpToClumpDOCA(), 5, 0.0, 500.0, false, true);
-		eval.addLikelihoodQuantityClumpToClump(new ClusterToClusterMinDistance(), 5, 0.0, 500.0, false, true);

+		eval.addLikelihoodQuantityTrackToClump(new TrackToClumpDOCA(), 50, 0.0, 300.0, false, true);
+		eval.addLikelihoodQuantityTrackToClump(new ClusterToClusterMinDistance(), 25, 0.0, 250.0, false, true);
+		eval.addLikelihoodQuantityClumpToClump(new ClumpToClumpDOCA(), 20, 0.0, 200.0, false, true);
+		eval.addLikelihoodQuantityClumpToClump(new ClusterToClusterMinDistance(), 20, 0.0, 200.0, false, true);

 		// Handle things that have per-event info:
 		makeEventInfoList(eval);

@@ -93,26 +131,101 @@

                 Driver checkpoint = new LikelihoodEvaluatorCheckpointDriver(eval, 10);
 		add(checkpoint);
 	    } else {

-		// Use pre-existing likelihood histograms to check clusters

+		// Use pre-existing likelihood histograms to check clusters.
+		// Output is, for each large cluster, a list of skeletons clusters inside it.

 		System.out.println("ExamplePFA: I will read in likelihood histograms and use them to make clusters.");
 		LikelihoodEvaluator eval = LikelihoodEvaluator.readFromFile("likelihood.bin");

-		LikelihoodLinkPlotterDriver likelihoodPlotter = new LikelihoodLinkPlotterDriver(eval, 0.5, 0.5, 0.5, assoc, "MSTCluster linked", "Track segments linked", "Clumps", "MapClustersToSkeletons");

+		LikelihoodLinkPlotterDriver likelihoodPlotter = new LikelihoodLinkPlotterDriver(eval, 0.5, 0.6, 0.8, assoc, "MSTCluster linked", "Track segments linked", "Clumps", "MapClustersToSkeletons");

 		likelihoodPlotter.setIgnoreClusterDecision(new ClusterSizeDecision(10));
 		likelihoodPlotter.initPlots("likelihoodPerformance.aida");
 		add(likelihoodPlotter);

-
-		// Handle things that have per-event info:

+		// Some likelihood quantities need per-event info:

 		makeEventInfoList(eval);

+		// Assign hits that are within the local cluster but not part of a clump/MIP.
+		add (new HaloAssigner("MapClustersToSkeletons"));
+		// Output is a list of clusters where:
+		//    A large cluster with multiple skeletons has a separate entry for each skeleton (+ associated halo)
+		//    A large cluster with one skeleton will have one entry
+		//    A cluster with no skeletons will have one entry
+		//    The total number of hits is the same as the total number of hits in "MSTCluster linked"
+		add (new MakeSeparatedClusters("MSTCluster linked", "MapClustersToSkeletons", "MSTCluster separated"));
+		// Handle fragments:
+		add (new FragmentMerger("MSTCluster separated", "MSTCluster fragments merged", new SimpleFragmentIdentifier(nameOfHelixToClusterMap)));
+		//add (new FragmentMerger("MSTCluster separated", "MSTCluster fragments merged", new CheatFragmentIdentifier("MSTCluster separated")));
+		//add (new FragmentRemover("MSTCluster separated", "MSTCluster fragments merged", new SimpleFragmentIdentifier(nameOfHelixToClusterMap)));
+		//add (new CheatFragmentMerger("MSTCluster separated", "MSTCluster fragments merged", new CheatFragmentIdentifier("MSTCluster separated")));
+		// When done, check the total energy in the event
+		add (new EventEnergySum("MSTCluster fragments merged", nameOfClusterToHelixMapLinked, nameOfHelixToClusterMap));
+
+		List<String> knownClusterLists = new Vector<String>();
+		knownClusterLists.add("MSTCluster EMCal");
+		knownClusterLists.add("MSTCluster HCal");
+		knownClusterLists.add("MSTCluster linked");
+		knownClusterLists.add("MSTCluster separated");
+
+// 		add (new CheckStatusOfHitList("EcalBarrHits"));
+// 		add (new CheckStatusOfHitList("EcalEndcapHits"));
+// 		add (new CheckStatusOfHitList("HcalBarrHits"));
+// 		add (new CheckStatusOfHitList("HcalEndcapHits"));
+// 		add (new CheckStatusOfClusterList("MSTCluster EMCal", knownClusterLists));
+// 		add (new CheckStatusOfClusterList("MSTCluster HCal", knownClusterLists));
+ 		add (new CheckStatusOfClusterList("MSTCluster linked", knownClusterLists));
+ 		add (new CheckStatusOfClusterList("MSTCluster separated", knownClusterLists));

 	    }
 	}
     }

+    int m_count = 0;

     public void process(EventHeader event) {

+	System.out.println("DEBUG: "+this.getClass().getName()+": Event "+m_count+":"); m_count++;

 	// Special handling of things that need per-event info:

-	for (StructuralLikelihoodQuantityWithEventInfo quant : m_perEventQuantities) {
-	    quant.setEventInfo(event);

+	if (m_perEventQuantities != null) {
+	    for (StructuralLikelihoodQuantityWithEventInfo quant : m_perEventQuantities) {
+		quant.setEventInfo(event);
+	    }
+	}
+	// Here we can do a veto
+	if (checkEnergyBarrel(event, 0.9)) {
+	    if (checkEnergyNeutrinos(event, 100.0)) {
+		super.process(event);
+	    }
+	}
+    }
+
+    protected boolean checkEnergyNeutrinos(EventHeader event, double maxNeutrinoEnergy)
+    {
+        double truthNeutrinoEnergySum = 0.0;
+	List<MCParticle> eventMCParticles = event.getMCParticles();
+	for (MCParticle p : eventMCParticles) {
+            int pdg = p.getPDGID();
+            if (pdg==12 || pdg==14 || pdg==16 || pdg==18 || pdg==-12 || pdg==-14 || pdg==-16 || pdg==-18) {
+                truthNeutrinoEnergySum += p.getEnergy();
+            }
+	}
+	return (truthNeutrinoEnergySum <= maxNeutrinoEnergy); // <= in case they put 0 for the maximum
+    }
+
+    protected boolean checkEnergyBarrel(EventHeader event, double threshold) 
+    {
+	// Require that threshold (e.g. 90%) of the final-state particles are within the barrel ( cos(theta) < 0.8 )	
+	double energySumBarrel = 0.0;
+	double energySumNonBarrel = 0.0;
+	List<MCParticle> mcps = event.getMCParticles();
+	for (MCParticle mcp : mcps) {
+	    if (mcp.getGeneratorStatus() == mcp.FINAL_STATE) {
+		Hep3Vector momentum = mcp.getMomentum();
+		double cosTheta = momentum.z() / momentum.magnitude();
+		if (Math.abs(cosTheta) < 0.8) {
+		    // barrel
+		    energySumBarrel += mcp.getEnergy();
+		} else {
+		    // non-barrel
+		    energySumNonBarrel += mcp.getEnergy();
+		}
+	    }

-	super.process(event);

+	double energySumTotal = energySumBarrel + energySumNonBarrel;
+	return (energySumBarrel / energySumTotal > threshold);

     }
     
     protected void makeEventInfoList(LikelihoodEvaluator eval)

+ for (int iClump=0; iClump<vClumps.size(); iClump++) { + Cluster clump1 = vClumps.get(iClump); + for (int jClump=iClump+1; jClump<vClumps.size(); jClump++) { + Cluster clump2 = vClumps.get(jClump);

+ //System.out.println("DEBUG: "+this.getClass().getName()+": linking Track("+clus1.getCalorimeterHits().size()+") to Track("+clus2.getCalorimeterHits().size()+") likelihood="+likelihood+" (c.f. cut="+m_cutTrackToTrack+")");

} public void compareTrackSegmentToClump(Cluster clus1, Cluster clus2) { double likelihood = m_eval.getLinkLikelihoodTrackToClump(clus1, clus2); if (likelihood > m_cutTrackToClump) { m_vlinksTrackToClump.add(new Link(clus1, clus2)); }

+ //System.out.println("DEBUG: "+this.getClass().getName()+": linking Track("+clus1.getCalorimeterHits().size()+") to Clump("+clus2.getCalorimeterHits().size()+") likelihood="+likelihood+" (c.f. cut="+m_cutTrackToClump+")");

} public void compareClumpToClump(Cluster clus1, Cluster clus2) { double likelihood = m_eval.getLinkLikelihoodClumpToClump(clus1, clus2); if (likelihood > m_cutClumpToClump) { m_vlinksClumpToClump.add(new Link(clus1, clus2)); }

+ //System.out.println("DEBUG: "+this.getClass().getName()+": linking Clump("+clus1.getCalorimeterHits().size()+") to Clump("+clus2.getCalorimeterHits().size()+") likelihood="+likelihood+" (c.f. cut="+m_cutClumpToClump+")");

List<MapClusterToListOfClusters> tmpMapList = m_event.get(MapClusterToListOfClusters.class, m_outputMapName); MapClusterToListOfClusters tmpMap = tmpMapList.iterator().next(); tmpMap.put(bigClus, vLinkedClusters);

+ // Debug printout: + //System.out.println("DEBUG: "+this.getClass().getName()+": Studied a cluster with "+bigClus.getCalorimeterHits().size()+" hits. Found "+vClumps.size()+" clumps and "+vMIPs.size()+" MIPs. Made "+vLinkedClusters.size()+" linked clusters. I had "+m_vlinksTrackToTrack.size()+" MIP-MIP links, "+m_vlinksTrackToClump.size()+" MIP-Clump links and "+m_vlinksClumpToClump.size()+" Clump-Clump links."); + +

for (int i=0; i<m_clusterSubListNames.size(); i++) { String clusterSubListName = m_clusterSubListNames.get(i); String subMapName = m_subMapNames.get(i); List<Cluster> subClusters = event.get(Cluster.class, clusterSubListName);

+ // This next bit is ugly, due to a Java/org.lcsim language barrier: + List<Object> dummyListObj = event.get(Object.class, subMapName); + Object dummyObj = dummyListObj.iterator().next(); + Map<Cluster, List<T>> map = (Map<Cluster, List<T>>) (dummyObj);

// OK. We have a list of clusters, which feed into the merged clusters. // For each sub-cluster with associated MIPs, find the big cluster it went into for (Cluster subCluster : subClusters) {

Commit in `lcsim/src/org/lcsim/contrib/uiowa/structural` on MAIN
`ClumpFinder.java`	+7	-11	1.2 -> 1.3
`ClusterAssociator.java`	+2		1.2 -> 1.3
`ClusterEnergyAssociator.java`	+23		1.1 -> 1.2
`ExamplePFA.java`	+130	-17	1.5 -> 1.6
`GenericStructuralDriver.java`	+6	-4	1.3 -> 1.4
`LikelihoodLinkDriver.java`	+7		1.3 -> 1.4
`LikelihoodLinkPlotterDriver.java`	+8	-6	1.2 -> 1.3
`Link.java`	+3	-1	1.1 -> 1.2
`MapClusterToListOfClusters.java`	+1	-1	1.1 -> 1.2
`Remapper.java`	+16	-13	1.4 -> 1.5
	+203	-53