5 added + 3 modified, total 8 files
lcsim/src/org/lcsim/contrib/uiowa
diff -N ExampleReadPFA.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ExampleReadPFA.java 4 Sep 2007 17:27:56 -0000 1.1
@@ -0,0 +1,20 @@
+package org.lcsim.contrib.uiowa;
+
+import java.util.*;
+import org.lcsim.util.*;
+import org.lcsim.event.*;
+
+/**
+ * Very simple example driver to make some PFA benchmark plots
+ * without actually running the PFA -- this would be
+ * used if you had previously run the PFA and written
+ * the output to an LCIO file, and were now reading that
+ * LCIO file back in.
+ */
+
+public class ExampleReadPFA extends Driver
+{
+ public ExampleReadPFA() {
+ add(new MassPlots("PFAReconstructedParticles", "output-read.aida"));
+ }
+}
lcsim/src/org/lcsim/contrib/uiowa
diff -N ExampleRunAndWriteOutPFA.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ExampleRunAndWriteOutPFA.java 4 Sep 2007 17:27:56 -0000 1.1
@@ -0,0 +1,45 @@
+package org.lcsim.contrib.uiowa;
+
+import java.util.*;
+import org.lcsim.util.Driver;
+import org.lcsim.contrib.uiowa.NonTrivialPFA;
+import org.lcsim.event.EventHeader;
+import org.lcsim.util.loop.LCIODriver;
+import org.lcsim.util.*;
+import org.lcsim.event.*;
+
+/**
+ * Example driver to create PFA output with a list of
+ * ReconstructedParticle objects. The output is written
+ * to "test.slcio". In addition, some dijet mass plots
+ * are written to "output-write.aida".
+ *
+ * Beware that the LCIO output file will be large!
+ */
+
+public class ExampleRunAndWriteOutPFA extends Driver
+{
+ /** Constructor sets up daughter drivers. */
+ public ExampleRunAndWriteOutPFA()
+ {
+ add(new org.lcsim.contrib.uiowa.NonTrivialPFA(false)); // Run the PFA, output is a List<ReconstructedParticle> named "PFAReconstructedParticles"
+ add(new org.lcsim.contrib.uiowa.MassPlots("PFAReconstructedParticles", "output-write.aida")); // Make some histograms and write them to a file
+ add(new LocalRemoveMCPColls()); // Remove nonstandard MCParticle lists (needed to ensure internally consistent output)
+ add(new org.lcsim.util.loop.LCIODriver("test.slcio")); // Write out to an LCIO file
+ }
+
+ /** Class by Ron, designed to remove nonstandard MCParticle lists. */
+ private class LocalRemoveMCPColls extends Driver {
+ public LocalRemoveMCPColls() {}
+ public void process(EventHeader event) {
+ List<MCParticle> particles = event.get(MCParticle.class,event.MC_PARTICLES);
+ List<List<MCParticle>> collections = event.get(MCParticle.class);
+ for (List<MCParticle> collection : collections) {
+ if(collection != particles) {
+ String name = event.getMetaData(collection).getName();
+ event.remove(name);
+ }
+ }
+ }
+ }
+}
lcsim/src/org/lcsim/contrib/uiowa
diff -u -r1.16 -r1.17
--- NonTrivialPFA.java 27 Aug 2007 21:03:58 -0000 1.16
+++ NonTrivialPFA.java 4 Sep 2007 17:27:56 -0000 1.17
@@ -275,9 +275,11 @@
addLikelihoodWriter("likwrite__", eventLargeClusters, eventMips, eventClumps, inputHitListsForAssociator, inputClusterListsForAssociator, mcListName);
} else {
// Read in likelihood:
- LikelihoodEvaluator eval = null;
+ LikelihoodEvaluatorWrapper evalWrapper = null;
try {
- eval = LikelihoodEvaluator.readFromFile("likelihood.bin");
+ //eval = LikelihoodEvaluator.readFromFile("likelihood.bin");
+ evalWrapper = new LikelihoodEvaluatorWrapper();
+ m_evalWrapper = evalWrapper;
} catch (AssertionError x) {
System.out.println("ERROR: Failed to read in the likelihood control file <likelihood.bin> from the working directory.");
System.out.println("To generate this file, run this Driver in write mode on a similar sample of events.");
@@ -289,11 +291,12 @@
System.out.println(" http://www.slac.stanford.edu/~mcharles/tmp/sid/acme0605_steel_rpc/likelihood.bin");
System.out.println(" http://www.slac.stanford.edu/~mcharles/tmp/sid/acme0605_steel_scint/likelihood.bin");
System.out.println(" http://www.slac.stanford.edu/~mcharles/tmp/sid/acme0605_w_rpc/likelihood.bin");
- System.exit(-1);
+ //System.exit(-1);
+ throw(x);
}
// Some likelihood quantities need per-event info:
- makeEventInfoList(eval);
- eval.setDebug(false); // lots of debug printout if enabled!
+ //makeEventInfoList(eval);
+ evalWrapper.setDebug(false); // lots of debug printout if enabled!
// Link MIPs, clumps
String eventSkeletonClusters = "skeletons";
@@ -309,9 +312,9 @@
} else {
boolean makeExtraLikelihoodPlots = false;
if (makeExtraLikelihoodPlots) {
- addStructuralLinkerWithPlots(prefix, eval, eventLargeClusters, eventMips, eventClumps, eventSkeletonClusters, eventUnusedHits, inputHitListsForAssociator, inputClusterListsForAssociator, mcListName);
+ addStructuralLinkerWithPlots(prefix, evalWrapper, eventLargeClusters, eventMips, eventClumps, eventSkeletonClusters, eventUnusedHits, inputHitListsForAssociator, inputClusterListsForAssociator, mcListName);
} else {
- addStructuralLinker(prefix, eval, eventLargeClusters, eventMips, eventClumps, eventSkeletonClusters, eventUnusedHits);
+ addStructuralLinker(prefix, evalWrapper, eventLargeClusters, eventMips, eventClumps, eventSkeletonClusters, eventUnusedHits);
}
}
// Book-keeping
@@ -320,7 +323,7 @@
// Check track matches are sensible; don't match multiple
// tracks to the same skeleton.
String eventSplitSkeletonClusters = "splitSkeletons";
- add(new CheckSkeletonsForMultipleTracks(eval, trackList, eventSkeletonClusters, eventSplitSkeletonClusters, eventMips, eventClumps));
+ add(new CheckSkeletonsForMultipleTracks(evalWrapper, trackList, eventSkeletonClusters, eventSplitSkeletonClusters, eventMips, eventClumps));
// Add halo of nearby hits
prefix = "halo__";
@@ -394,7 +397,10 @@
public void process(EventHeader event) {
// Special handling of things that need per-event info.
// This probably belongs in its own driver.
- if (m_perEventQuantities != null) {
+ if (m_evalWrapper != null) {
+ makeEventInfoList(m_evalWrapper);
+ }
+ if (m_perEventQuantities != null) {
for (StructuralLikelihoodQuantityWithEventInfo quant : m_perEventQuantities) {
quant.setEventInfo(event);
}
@@ -423,6 +429,7 @@
// Special treatment for likelihood quantities that need per-event info
// (e.g. geometry)
List<StructuralLikelihoodQuantityWithEventInfo> m_perEventQuantities = null;
+ LikelihoodEvaluatorWrapper m_evalWrapper = null;
protected void addCheatingPhotonFinder(String prefix, String inputHitMap, String inputTrackList, String outputPhotonClusterList, String outputHitMap, String mcListName)
@@ -640,7 +647,7 @@
protected void addLikelihoodWriter(String prefix, String inputClusterList, String inputMIPList, String inputClumpList, String[] inputHitListsForAssociator, String[] inputClusterListsForAssociator, String mcListName)
{
// Make likelihood PDFs
- LikelihoodEvaluator eval = new LikelihoodEvaluator();
+ LikelihoodEvaluator eval = new LikelihoodEvaluatorImplementation();
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(), 25, 0.0, 250.0, false, true);
lcsim/src/org/lcsim/recon/cluster/structural/likelihood
diff -N LikelihoodEvaluatorWrapper.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ LikelihoodEvaluatorWrapper.java 4 Sep 2007 17:27:57 -0000 1.1
@@ -0,0 +1,153 @@
+package org.lcsim.recon.cluster.structural.likelihood;
+
+import java.util.List;
+import java.util.Vector;
+import org.lcsim.event.Cluster;
+
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectInputStream;
+import java.io.InputStream;
+import java.io.Serializable;
+import java.io.IOException;
+
+import org.lcsim.conditions.ConditionsManager;
+import org.lcsim.conditions.RawConditions;
+import org.lcsim.conditions.ConditionsListener;
+import org.lcsim.conditions.ConditionsConverter;
+import org.lcsim.conditions.CachedConditions;
+import org.lcsim.conditions.ConditionsEvent;
+
+/** Wrapper class.
+ */
+
+public class LikelihoodEvaluatorWrapper implements ConditionsListener,LikelihoodEvaluator {
+ private LikelihoodEvaluator m_eval = null;
+ protected CachedConditions<LikelihoodEvaluator> _cachedConditions;
+ protected boolean m_debug;
+
+ public LikelihoodEvaluatorWrapper() {
+ ConditionsManager mgr = ConditionsManager.defaultInstance();
+ ConditionsConverter conv = new LikelihoodConditionsConverter();
+ mgr.registerConditionsConverter(conv);
+ }
+
+ /** Access the raw evaluator, if needed. */
+ public LikelihoodEvaluator getEvaluator() {
+ return m_eval;
+ }
+
+ /** Force read of evaluator from a file. */
+ public void readEvaluatorFromFile(String filename) throws java.io.IOException, java.lang.ClassNotFoundException {
+ try {
+ FileInputStream fis = new FileInputStream(filename);
+ ObjectInputStream ois = new ObjectInputStream(fis);
+ Object o = ois.readObject();
+ LikelihoodEvaluator eval = (LikelihoodEvaluator) o;
+ m_eval = eval;
+ m_eval.setDebug(m_debug);
+ } catch (java.io.IOException x) {
+ throw new AssertionError("java.io.IOException: "+x);
+ } catch (java.lang.ClassNotFoundException x) {
+ throw new AssertionError("java.lang.ClassNotFoundException: "+x);
+ }
+ }
+
+ /** Force read of evaluator from conditions. */
+ static public LikelihoodEvaluator readFromConditions() throws java.io.IOException, java.lang.ClassNotFoundException {
+ ConditionsManager mgr = ConditionsManager.defaultInstance();
+ RawConditions conditions = mgr.getRawConditions("structuralPFA/likelihood.bin");
+ InputStream is = conditions.getInputStream();
+ ObjectInputStream ois = new ObjectInputStream(is);
+ Object o = ois.readObject();
+ LikelihoodEvaluator eval = (LikelihoodEvaluator) o;
+ return eval;
+ }
+
+ /** Register to receive likelihood.bin from events */
+ public void registerAsConditionsListener(ConditionsEvent event) {
+ ConditionsManager mgr;
+ if (event != null) {
+ mgr = event.getConditionsManager();
+ } else {
+ mgr = ConditionsManager.defaultInstance();
+ }
+ _cachedConditions = mgr.getCachedConditions(LikelihoodEvaluator.class,"structuralPFA/likelihood.bin");
+ m_eval = _cachedConditions.getCachedData();
+ _cachedConditions.addConditionsListener(this);
+ }
+
+ public void conditionsChanged(ConditionsEvent event) {
+ registerAsConditionsListener(event);
+ }
+
+ protected void checkInit() {
+ if (m_eval == null) {
+ registerAsConditionsListener(null);
+ }
+ }
+
+ // Interface
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantities() {
+ checkInit();
+ return m_eval.getLikelihoodQuantities();
+ }
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesTrackToTrack() {
+ checkInit();
+ return m_eval.getLikelihoodQuantitiesTrackToTrack();
+ }
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesTrackToClump() {
+ checkInit();
+ return m_eval.getLikelihoodQuantitiesTrackToClump();
+ }
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesClumpToClump() {
+ checkInit();
+ return m_eval.getLikelihoodQuantitiesClumpToClump();
+ }
+ public void addLikelihoodQuantityTrackToTrack(StructuralLikelihoodQuantity quant, int nbins, double min, double max, boolean useUnderFlow, boolean useOverFlow) {
+ checkInit();
+ m_eval.addLikelihoodQuantityTrackToTrack(quant, nbins, min, max, useUnderFlow, useOverFlow);
+ }
+ public void addLikelihoodQuantityTrackToClump(StructuralLikelihoodQuantity quant, int nbins, double min, double max, boolean useUnderFlow, boolean useOverFlow) {
+ checkInit();
+ m_eval.addLikelihoodQuantityTrackToClump(quant, nbins, min, max, useUnderFlow, useOverFlow);
+ }
+ public void addLikelihoodQuantityClumpToClump(StructuralLikelihoodQuantity quant, int nbins, double min, double max, boolean useUnderFlow, boolean useOverFlow) {
+ checkInit();
+ m_eval.addLikelihoodQuantityClumpToClump(quant, nbins, min, max, useUnderFlow, useOverFlow);
+ }
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionTrackToTrack(boolean goodLink) {
+ checkInit();
+ return m_eval.getLikelihoodDistributionTrackToTrack(goodLink);
+ }
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionTrackToClump(boolean goodLink) {
+ checkInit();
+ return m_eval.getLikelihoodDistributionTrackToClump(goodLink);
+ }
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionClumpToClump(boolean goodLink) {
+ checkInit();
+ return m_eval.getLikelihoodDistributionClumpToClump(goodLink);
+ }
+ public double getLinkLikelihoodTrackToTrack(Cluster clus1, Cluster clus2) {
+ checkInit();
+ return m_eval.getLinkLikelihoodTrackToTrack(clus1, clus2);
+ }
+ public double getLinkLikelihoodTrackToClump(Cluster clus1, Cluster clus2) {
+ checkInit();
+ return m_eval.getLinkLikelihoodTrackToClump(clus1, clus2);
+ }
+ public double getLinkLikelihoodClumpToClump(Cluster clus1, Cluster clus2) {
+ checkInit();
+ return m_eval.getLinkLikelihoodClumpToClump(clus1, clus2);
+ }
+ public void writeToFile(String filename) {
+ checkInit();
+ m_eval.writeToFile(filename);
+ }
+ public void setDebug(boolean debug) {
+ m_debug = debug;
+ }
+
+
+}
lcsim/src/org/lcsim/recon/cluster/structural/likelihood
diff -N LikelihoodEvaluatorImplementation.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ LikelihoodEvaluatorImplementation.java 4 Sep 2007 17:27:57 -0000 1.1
@@ -0,0 +1,303 @@
+package org.lcsim.recon.cluster.structural.likelihood;
+
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Vector;
+
+import java.io.FileOutputStream;
+import java.io.FileInputStream;
+import java.io.ObjectOutputStream;
+import java.io.ObjectInputStream;
+import java.io.InputStream;
+import java.io.Serializable;
+import java.io.IOException;
+
+import hep.aida.ITree;
+import hep.aida.IAnalysisFactory;
+import hep.aida.IHistogramFactory;
+import hep.aida.IHistogram1D;
+
+import org.lcsim.event.Cluster;
+import org.lcsim.conditions.ConditionsManager;
+import org.lcsim.conditions.RawConditions;
+
+public class LikelihoodEvaluatorImplementation implements java.io.Serializable, LikelihoodEvaluator {
+
+ Map<Boolean, Vector<LikelihoodDistribution> > m_LikelihoodDistributionsTrackToTrack = null;
+ Map<Boolean, Vector<LikelihoodDistribution> > m_LikelihoodDistributionsTrackToClump = null;
+ Map<Boolean, Vector<LikelihoodDistribution> > m_LikelihoodDistributionsClumpToClump = null;
+ transient boolean m_debug; // default value is false
+
+ public LikelihoodEvaluatorImplementation()
+ {
+ // Maps from Boolean (the tag) to Distribution
+ m_LikelihoodDistributionsTrackToTrack = new HashMap<Boolean, Vector<LikelihoodDistribution> >();
+ m_LikelihoodDistributionsTrackToClump = new HashMap<Boolean, Vector<LikelihoodDistribution> >();
+ m_LikelihoodDistributionsClumpToClump = new HashMap<Boolean, Vector<LikelihoodDistribution> >();
+ m_LikelihoodDistributionsTrackToTrack.put(Boolean.valueOf(true), new Vector<LikelihoodDistribution>());
+ m_LikelihoodDistributionsTrackToTrack.put(Boolean.valueOf(false), new Vector<LikelihoodDistribution>());
+ m_LikelihoodDistributionsTrackToClump.put(Boolean.valueOf(true), new Vector<LikelihoodDistribution>());
+ m_LikelihoodDistributionsTrackToClump.put(Boolean.valueOf(false), new Vector<LikelihoodDistribution>());
+ m_LikelihoodDistributionsClumpToClump.put(Boolean.valueOf(true), new Vector<LikelihoodDistribution>());
+ m_LikelihoodDistributionsClumpToClump.put(Boolean.valueOf(false), new Vector<LikelihoodDistribution>());
+ }
+
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantities() {
+ Vector<StructuralLikelihoodQuantity> vOut = new Vector<StructuralLikelihoodQuantity>();
+ vOut.addAll(getLikelihoodQuantitiesTrackToTrack());
+ vOut.addAll(getLikelihoodQuantitiesTrackToClump());
+ vOut.addAll(getLikelihoodQuantitiesClumpToClump());
+ return vOut;
+ }
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesTrackToTrack() {
+ return getLikelihoodQuantities(m_LikelihoodDistributionsTrackToTrack.get(Boolean.valueOf(true)));
+ }
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesTrackToClump() {
+ return getLikelihoodQuantities(m_LikelihoodDistributionsTrackToClump.get(Boolean.valueOf(true)));
+ }
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesClumpToClump() {
+ return getLikelihoodQuantities(m_LikelihoodDistributionsClumpToClump.get(Boolean.valueOf(true)));
+ }
+ protected List<StructuralLikelihoodQuantity> getLikelihoodQuantities(Vector<LikelihoodDistribution> vect) {
+ Vector<StructuralLikelihoodQuantity> vOut = new Vector<StructuralLikelihoodQuantity>();
+ for (LikelihoodDistribution dist : vect) {
+ StructuralLikelihoodQuantity quant = dist.getQuantity();
+ vOut.add(quant);
+ }
+ return vOut;
+ }
+
+ public void addLikelihoodQuantityTrackToTrack(StructuralLikelihoodQuantity quant, int nbins, double min, double max, boolean useUnderFlow, boolean useOverFlow) {
+ Vector<LikelihoodDistribution> vTrue = m_LikelihoodDistributionsTrackToTrack.get(Boolean.valueOf(true));
+ Vector<LikelihoodDistribution> vFalse = m_LikelihoodDistributionsTrackToTrack.get(Boolean.valueOf(false));
+ vTrue .add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
+ vFalse.add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
+ }
+ public void addLikelihoodQuantityTrackToClump(StructuralLikelihoodQuantity quant, int nbins, double min
+, double max, boolean useUnderFlow, boolean useOverFlow) {
+ Vector<LikelihoodDistribution> vTrue = m_LikelihoodDistributionsTrackToClump.get(Boolean.valueOf(true));
+ Vector<LikelihoodDistribution> vFalse = m_LikelihoodDistributionsTrackToClump.get(Boolean.valueOf(false));
+ vTrue .add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
+ vFalse.add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
+ }
+ public void addLikelihoodQuantityClumpToClump(StructuralLikelihoodQuantity quant, int nbins, double min
+, double max, boolean useUnderFlow, boolean useOverFlow) {
+ Vector<LikelihoodDistribution> vTrue = m_LikelihoodDistributionsClumpToClump.get(Boolean.valueOf(true));
+ Vector<LikelihoodDistribution> vFalse = m_LikelihoodDistributionsClumpToClump.get(Boolean.valueOf(false));
+ vTrue .add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
+ vFalse.add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
+ }
+
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionTrackToTrack(boolean goodLink) {
+ Boolean isLinkCorrect = Boolean.valueOf(goodLink);
+ Vector<LikelihoodDistribution> vDistributions = m_LikelihoodDistributionsTrackToTrack.get(isLinkCorrect);
+ return vDistributions;
+ }
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionTrackToClump(boolean goodLink) {
+ Boolean isLinkCorrect = Boolean.valueOf(goodLink);
+ Vector<LikelihoodDistribution> vDistributions = m_LikelihoodDistributionsTrackToClump.get(isLinkCorrect);
+ return vDistributions;
+ }
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionClumpToClump(boolean goodLink) {
+ Boolean isLinkCorrect = Boolean.valueOf(goodLink);
+ Vector<LikelihoodDistribution> vDistributions = m_LikelihoodDistributionsClumpToClump.get(isLinkCorrect);
+ return vDistributions;
+ }
+
+ public double getLinkLikelihoodTrackToTrack(Cluster clus1, Cluster clus2) {
+ Vector<LikelihoodDistribution> vLinked = getLikelihoodDistributionTrackToTrack(true);
+ Vector<LikelihoodDistribution> vUnlinked = getLikelihoodDistributionTrackToTrack(false);
+ if (m_debug) {
+ double totalGoodLikelihood = 1.0;
+ double totalBadLikelihood = 1.0;
+ for (int i=0; i<vLinked.size(); i++) {
+ LikelihoodDistribution distLinked = vLinked.get(i);
+ LikelihoodDistribution distUnlinked = vUnlinked.get(i);
+ StructuralLikelihoodQuantity quant = distLinked.getQuantity();
+ try {
+ double goodPDF = distLinked.getPDF(clus1, clus2);
+ double badPDF = distUnlinked.getPDF(clus1, clus2);
+ double goodProb = goodPDF/(goodPDF+badPDF);
+ double badProb = badPDF/(goodPDF+badPDF);
+ totalGoodLikelihood *= goodProb;
+ totalBadLikelihood *= badProb;
+ System.out.println("DEBUG: Quantity"+i+" = "+quant.evaluate(clus1,clus2)+" so prob(good)="+goodProb);
+ } catch (QuantityNotDefinedException x) {
+ // Have to ignore this one.
+ System.out.println("Warning: "+x);
+ }
+ }
+ double normalizedGoodLikelihood = totalGoodLikelihood / (totalGoodLikelihood+totalBadLikelihood);
+ System.out.println("DEBUG: => net probs: "+totalGoodLikelihood+" vs "+totalBadLikelihood+" => prob(good) = "+normalizedGoodLikelihood);
+ }
+ return getLinkLikelihood(clus1, clus2, vLinked, vUnlinked);
+ }
+ public double getLinkLikelihoodTrackToClump(Cluster clus1, Cluster clus2) {
+ Vector<LikelihoodDistribution> vLinked = getLikelihoodDistributionTrackToClump(true);
+ Vector<LikelihoodDistribution> vUnlinked = getLikelihoodDistributionTrackToClump(false);
+ if (m_debug) {
+ double totalGoodLikelihood = 1.0;
+ double totalBadLikelihood = 1.0;
+ for (int i=0; i<vLinked.size(); i++) {
+ LikelihoodDistribution distLinked = vLinked.get(i);
+ LikelihoodDistribution distUnlinked = vUnlinked.get(i);
+ StructuralLikelihoodQuantity quant = distLinked.getQuantity();
+ try {
+ double goodPDF = distLinked.getPDF(clus1, clus2);
+ double badPDF = distUnlinked.getPDF(clus1, clus2);
+ double goodProb = goodPDF/(goodPDF+badPDF);
+ double badProb = badPDF/(goodPDF+badPDF);
+ totalGoodLikelihood *= goodProb;
+ totalBadLikelihood *= badProb;
+ System.out.println("DEBUG: Quantity"+i+" = "+quant.evaluate(clus1,clus2)+" so prob(good)="+goodProb);
+ } catch (QuantityNotDefinedException x) {
+ // Have to ignore this one.
+ System.out.println("Warning: "+x);
+ }
+ }
+ double normalizedGoodLikelihood = totalGoodLikelihood / (totalGoodLikelihood+totalBadLikelihood);
+ System.out.println("DEBUG: => net probs: "+totalGoodLikelihood+" vs "+totalBadLikelihood+" => prob(good) = "+normalizedGoodLikelihood);
+ }
+ return getLinkLikelihood(clus1, clus2, vLinked, vUnlinked);
+ }
+ public double getLinkLikelihoodClumpToClump(Cluster clus1, Cluster clus2) {
+ Vector<LikelihoodDistribution> vLinked = getLikelihoodDistributionClumpToClump(true);
+ Vector<LikelihoodDistribution> vUnlinked = getLikelihoodDistributionClumpToClump(false);
+ if (m_debug) {
+ double totalGoodLikelihood = 1.0;
+ double totalBadLikelihood = 1.0;
+ for (int i=0; i<vLinked.size(); i++) {
+ LikelihoodDistribution distLinked = vLinked.get(i);
+ LikelihoodDistribution distUnlinked = vUnlinked.get(i);
+ StructuralLikelihoodQuantity quant = distLinked.getQuantity();
+ try {
+ double goodPDF = distLinked.getPDF(clus1, clus2);
+ double badPDF = distUnlinked.getPDF(clus1, clus2);
+ double goodProb = goodPDF/(goodPDF+badPDF);
+ double badProb = badPDF/(goodPDF+badPDF);
+ totalGoodLikelihood *= goodProb;
+ totalBadLikelihood *= badProb;
+ System.out.println("DEBUG: Quantity"+i+" = "+quant.evaluate(clus1,clus2)+" so prob(good)="+goodProb);
+ } catch (QuantityNotDefinedException x) {
+ // Have to ignore this one.
+ System.out.println("Warning: "+x);
+ }
+ }
+ double normalizedGoodLikelihood = totalGoodLikelihood / (totalGoodLikelihood+totalBadLikelihood);
+ System.out.println("DEBUG: => net probs: "+totalGoodLikelihood+" vs "+totalBadLikelihood+" => prob(good) = "+normalizedGoodLikelihood);
+ }
+ return getLinkLikelihood(clus1, clus2, vLinked, vUnlinked);
+ }
+
+ protected double getLinkLikelihood(Cluster clus1, Cluster clus2, Vector<LikelihoodDistribution> vLinked, Vector<LikelihoodDistribution> vUnlinked)
+ {
+ double totalGoodLikelihood = 1.0;
+ double totalBadLikelihood = 1.0;
+ for (int i=0; i<vLinked.size(); i++) {
+ LikelihoodDistribution distLinked = vLinked.get(i);
+ LikelihoodDistribution distUnlinked = vUnlinked.get(i);
+ try {
+ double goodPDF = distLinked.getPDF(clus1, clus2);
+ double badPDF = distUnlinked.getPDF(clus1, clus2);
+ double goodProb = goodPDF/(goodPDF+badPDF);
+ double badProb = badPDF/(goodPDF+badPDF);
+ totalGoodLikelihood *= goodProb;
+ totalBadLikelihood *= badProb;
+ } catch (QuantityNotDefinedException x) {
+ // Have to ignore this one.
+ System.out.println("Warning: "+x);
+ }
+ }
+ double normalizedGoodLikelihood = totalGoodLikelihood / (totalGoodLikelihood+totalBadLikelihood);
+ return normalizedGoodLikelihood;
+ }
+
+ public void writeToFile(String filename)
+ {
+ // Open the file for writing:
+ try {
+ FileOutputStream fos = new FileOutputStream(filename);
+ ObjectOutputStream oos = new ObjectOutputStream(fos);
+ oos.writeObject(this);
+ } catch (java.io.IOException x) {
+ throw new AssertionError("java.io.IOException: "+x);
+ }
+ }
+
+ // Routines to make interesting plots:
+
+ /**
+ * Write the likelihood distributions out to the given file
+ */
+ public void makePlots(String filename)
+ {
+ IAnalysisFactory af = IAnalysisFactory.create();
+ try {
+ ITree t = af.createTreeFactory().create(filename,"xml",false,true);
+ IHistogramFactory hf = af.createHistogramFactory(t);
+ makePlots(hf, "hTrackTrack", m_LikelihoodDistributionsTrackToTrack);
+ makePlots(hf, "hTrackClump", m_LikelihoodDistributionsTrackToClump);
+ makePlots(hf, "hClumpClump", m_LikelihoodDistributionsClumpToClump);
+ t.commit();
+ } catch(IOException ioe1) {
+ ioe1.printStackTrace();
+ }
+ }
+
+ /**
+ * Make the plots for a particular set of variables (clump-clump, track-track, track-clump)
+ */
+ protected void makePlots(IHistogramFactory hf, String name1, Map<Boolean, Vector<LikelihoodDistribution> > map)
+ {
+ for (LikelihoodDistribution dist : map.get(Boolean.valueOf(true))) {
+ makePlot(hf, name1, "Signal", dist);
+ }
+ for (LikelihoodDistribution dist : map.get(Boolean.valueOf(false))) {
+ makePlot(hf, name1, "Background", dist);
+ }
+ }
+
+ /**
+ * Make one plot
+ */
+ protected void makePlot(IHistogramFactory hf, String name1, String name2, LikelihoodDistribution dist)
+ {
+ String subName = dist.getQuantity().getClass().getName();
+ String fullName = new String(name1 + "_" + name2 + "_" + subName);
+ if (m_debug) { System.out.println("DEBUG: Making histogram for ["+fullName+"]"); }
+ int nbins = dist.getNbins();
+ double min = dist.getMin();
+ double max = dist.getMax();
+ double binsize = (max-min) / ( (double)(nbins) );
+ int histo_nbins = nbins;
+ double histo_min = min;
+ double histo_max = max;
+ if (dist.useUnderFlow()) {
+ histo_nbins++;
+ histo_min -= binsize;
+ }
+ if (dist.useOverFlow()) {
+ histo_nbins++;
+ histo_max += binsize;
+ }
+ IHistogram1D histo = hf.createHistogram1D(fullName, histo_nbins, histo_min, histo_max);
+ for (int i=0; i<nbins; i++) {
+ double binCenter = min + binsize*( (double)(i) + 0.5);
+ histo.fill(binCenter, dist.getPDF(i));
+ if (m_debug) { System.out.println(" "+i+": "+dist.getPDF(i)); }
+ }
+ if (dist.useUnderFlow()) {
+ histo.fill(min-0.5*binsize, dist.getPDF(-1));
+ if (m_debug) { System.out.println(" underflow: "+dist.getPDF(-1)); }
+ }
+ if (dist.useOverFlow()) {
+ histo.fill(max+0.5*binsize, dist.getPDF(nbins));
+ if (m_debug) { System.out.println(" overflow: "+dist.getPDF(nbins)); }
+ }
+ }
+
+ public void setDebug(boolean debug) {
+ m_debug = debug;
+ }
+}
lcsim/src/org/lcsim/recon/cluster/structural/likelihood
diff -N LikelihoodConditionsConverter.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ LikelihoodConditionsConverter.java 4 Sep 2007 17:27:57 -0000 1.1
@@ -0,0 +1,28 @@
+package org.lcsim.recon.cluster.structural.likelihood;
+
+import org.lcsim.conditions.ConditionsConverter;
+import org.lcsim.conditions.ConditionsManager;
+import org.lcsim.conditions.RawConditions;
+import java.io.ObjectInputStream;
+import java.io.InputStream;
+
+public class LikelihoodConditionsConverter implements ConditionsConverter<LikelihoodEvaluator> {
+ public LikelihoodEvaluator getData(ConditionsManager manager, String name) {
+ System.out.println("DEBUG: LikelihoodConditionsConverter: Getting data for name='"+name+"'");
+ RawConditions conditions = manager.getRawConditions(name);
+ try {
+ InputStream is = conditions.getInputStream();
+ ObjectInputStream ois = new ObjectInputStream(is);
+ Object o = ois.readObject();
+ LikelihoodEvaluator eval = (LikelihoodEvaluator) o;
+ return eval;
+ } catch (java.io.IOException x) {
+ throw new AssertionError("java.io.IOException: "+x);
+ } catch (java.lang.ClassNotFoundException x) {
+ throw new AssertionError("java.lang.ClassNotFoundException: "+x);
+ }
+ }
+ public Class<LikelihoodEvaluator> getType() {
+ return LikelihoodEvaluator.class;
+ }
+}
lcsim/src/org/lcsim/recon/cluster/structural/likelihood
diff -u -r1.2 -r1.3
--- LikelihoodEvaluator.java 26 Apr 2007 17:18:44 -0000 1.2
+++ LikelihoodEvaluator.java 4 Sep 2007 17:27:57 -0000 1.3
@@ -1,316 +1,29 @@
package org.lcsim.recon.cluster.structural.likelihood;
import java.util.List;
-import java.util.Map;
-import java.util.HashMap;
import java.util.Vector;
-
-import java.io.FileOutputStream;
-import java.io.FileInputStream;
-import java.io.ObjectOutputStream;
-import java.io.ObjectInputStream;
-import java.io.Serializable;
-import java.io.IOException;
-
-import hep.aida.ITree;
-import hep.aida.IAnalysisFactory;
-import hep.aida.IHistogramFactory;
-import hep.aida.IHistogram1D;
-
import org.lcsim.event.Cluster;
-public class LikelihoodEvaluator implements java.io.Serializable {
-
- Map<Boolean, Vector<LikelihoodDistribution> > m_LikelihoodDistributionsTrackToTrack = null;
- Map<Boolean, Vector<LikelihoodDistribution> > m_LikelihoodDistributionsTrackToClump = null;
- Map<Boolean, Vector<LikelihoodDistribution> > m_LikelihoodDistributionsClumpToClump = null;
- transient boolean m_debug; // default value is false
-
- public LikelihoodEvaluator()
- {
- // Maps from Boolean (the tag) to Distribution
- m_LikelihoodDistributionsTrackToTrack = new HashMap<Boolean, Vector<LikelihoodDistribution> >();
- m_LikelihoodDistributionsTrackToClump = new HashMap<Boolean, Vector<LikelihoodDistribution> >();
- m_LikelihoodDistributionsClumpToClump = new HashMap<Boolean, Vector<LikelihoodDistribution> >();
- m_LikelihoodDistributionsTrackToTrack.put(Boolean.valueOf(true), new Vector<LikelihoodDistribution>());
- m_LikelihoodDistributionsTrackToTrack.put(Boolean.valueOf(false), new Vector<LikelihoodDistribution>());
- m_LikelihoodDistributionsTrackToClump.put(Boolean.valueOf(true), new Vector<LikelihoodDistribution>());
- m_LikelihoodDistributionsTrackToClump.put(Boolean.valueOf(false), new Vector<LikelihoodDistribution>());
- m_LikelihoodDistributionsClumpToClump.put(Boolean.valueOf(true), new Vector<LikelihoodDistribution>());
- m_LikelihoodDistributionsClumpToClump.put(Boolean.valueOf(false), new Vector<LikelihoodDistribution>());
- }
-
- public List<StructuralLikelihoodQuantity> getLikelihoodQuantities() {
- Vector<StructuralLikelihoodQuantity> vOut = new Vector<StructuralLikelihoodQuantity>();
- vOut.addAll(getLikelihoodQuantitiesTrackToTrack());
- vOut.addAll(getLikelihoodQuantitiesTrackToClump());
- vOut.addAll(getLikelihoodQuantitiesClumpToClump());
- return vOut;
- }
- public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesTrackToTrack() {
- return getLikelihoodQuantities(m_LikelihoodDistributionsTrackToTrack.get(Boolean.valueOf(true)));
- }
- public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesTrackToClump() {
- return getLikelihoodQuantities(m_LikelihoodDistributionsTrackToClump.get(Boolean.valueOf(true)));
- }
- public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesClumpToClump() {
- return getLikelihoodQuantities(m_LikelihoodDistributionsClumpToClump.get(Boolean.valueOf(true)));
- }
- protected List<StructuralLikelihoodQuantity> getLikelihoodQuantities(Vector<LikelihoodDistribution> vect) {
- Vector<StructuralLikelihoodQuantity> vOut = new Vector<StructuralLikelihoodQuantity>();
- for (LikelihoodDistribution dist : vect) {
- StructuralLikelihoodQuantity quant = dist.getQuantity();
- vOut.add(quant);
- }
- return vOut;
- }
-
- public void addLikelihoodQuantityTrackToTrack(StructuralLikelihoodQuantity quant, int nbins, double min, double max, boolean useUnderFlow, boolean useOverFlow) {
- Vector<LikelihoodDistribution> vTrue = m_LikelihoodDistributionsTrackToTrack.get(Boolean.valueOf(true));
- Vector<LikelihoodDistribution> vFalse = m_LikelihoodDistributionsTrackToTrack.get(Boolean.valueOf(false));
- vTrue .add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
- vFalse.add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
- }
- public void addLikelihoodQuantityTrackToClump(StructuralLikelihoodQuantity quant, int nbins, double min
-, double max, boolean useUnderFlow, boolean useOverFlow) {
- Vector<LikelihoodDistribution> vTrue = m_LikelihoodDistributionsTrackToClump.get(Boolean.valueOf(true));
- Vector<LikelihoodDistribution> vFalse = m_LikelihoodDistributionsTrackToClump.get(Boolean.valueOf(false));
- vTrue .add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
- vFalse.add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
- }
- public void addLikelihoodQuantityClumpToClump(StructuralLikelihoodQuantity quant, int nbins, double min
-, double max, boolean useUnderFlow, boolean useOverFlow) {
- Vector<LikelihoodDistribution> vTrue = m_LikelihoodDistributionsClumpToClump.get(Boolean.valueOf(true));
- Vector<LikelihoodDistribution> vFalse = m_LikelihoodDistributionsClumpToClump.get(Boolean.valueOf(false));
- vTrue .add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
- vFalse.add(new LikelihoodDistribution(quant, nbins, min, max, useUnderFlow, useOverFlow));
- }
+public interface LikelihoodEvaluator {
- public Vector<LikelihoodDistribution> getLikelihoodDistributionTrackToTrack(boolean goodLink) {
- Boolean isLinkCorrect = Boolean.valueOf(goodLink);
- Vector<LikelihoodDistribution> vDistributions = m_LikelihoodDistributionsTrackToTrack.get(isLinkCorrect);
- return vDistributions;
- }
- public Vector<LikelihoodDistribution> getLikelihoodDistributionTrackToClump(boolean goodLink) {
- Boolean isLinkCorrect = Boolean.valueOf(goodLink);
- Vector<LikelihoodDistribution> vDistributions = m_LikelihoodDistributionsTrackToClump.get(isLinkCorrect);
- return vDistributions;
- }
- public Vector<LikelihoodDistribution> getLikelihoodDistributionClumpToClump(boolean goodLink) {
- Boolean isLinkCorrect = Boolean.valueOf(goodLink);
- Vector<LikelihoodDistribution> vDistributions = m_LikelihoodDistributionsClumpToClump.get(isLinkCorrect);
- return vDistributions;
- }
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantities();
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesTrackToTrack();
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesTrackToClump();
+ public List<StructuralLikelihoodQuantity> getLikelihoodQuantitiesClumpToClump();
+
+ public void addLikelihoodQuantityTrackToTrack(StructuralLikelihoodQuantity quant, int nbins, double min, double max, boolean useUnderFlow, boolean useOverFlow);
+ public void addLikelihoodQuantityTrackToClump(StructuralLikelihoodQuantity quant, int nbins, double min, double max, boolean useUnderFlow, boolean useOverFlow);
+ public void addLikelihoodQuantityClumpToClump(StructuralLikelihoodQuantity quant, int nbins, double min, double max, boolean useUnderFlow, boolean useOverFlow);
+
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionTrackToTrack(boolean goodLink);
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionTrackToClump(boolean goodLink);
+ public Vector<LikelihoodDistribution> getLikelihoodDistributionClumpToClump(boolean goodLink);
- public double getLinkLikelihoodTrackToTrack(Cluster clus1, Cluster clus2) {
- Vector<LikelihoodDistribution> vLinked = getLikelihoodDistributionTrackToTrack(true);
- Vector<LikelihoodDistribution> vUnlinked = getLikelihoodDistributionTrackToTrack(false);
- if (m_debug) {
- double totalGoodLikelihood = 1.0;
- double totalBadLikelihood = 1.0;
- for (int i=0; i<vLinked.size(); i++) {
- LikelihoodDistribution distLinked = vLinked.get(i);
- LikelihoodDistribution distUnlinked = vUnlinked.get(i);
- StructuralLikelihoodQuantity quant = distLinked.getQuantity();
- try {
- double goodPDF = distLinked.getPDF(clus1, clus2);
- double badPDF = distUnlinked.getPDF(clus1, clus2);
- double goodProb = goodPDF/(goodPDF+badPDF);
- double badProb = badPDF/(goodPDF+badPDF);
- totalGoodLikelihood *= goodProb;
- totalBadLikelihood *= badProb;
- System.out.println("DEBUG: Quantity"+i+" = "+quant.evaluate(clus1,clus2)+" so prob(good)="+goodProb);
- } catch (QuantityNotDefinedException x) {
- // Have to ignore this one.
- System.out.println("Warning: "+x);
- }
- }
- double normalizedGoodLikelihood = totalGoodLikelihood / (totalGoodLikelihood+totalBadLikelihood);
- System.out.println("DEBUG: => net probs: "+totalGoodLikelihood+" vs "+totalBadLikelihood+" => prob(good) = "+normalizedGoodLikelihood);
- }
- return getLinkLikelihood(clus1, clus2, vLinked, vUnlinked);
- }
- public double getLinkLikelihoodTrackToClump(Cluster clus1, Cluster clus2) {
- Vector<LikelihoodDistribution> vLinked = getLikelihoodDistributionTrackToClump(true);
- Vector<LikelihoodDistribution> vUnlinked = getLikelihoodDistributionTrackToClump(false);
- if (m_debug) {
- double totalGoodLikelihood = 1.0;
- double totalBadLikelihood = 1.0;
- for (int i=0; i<vLinked.size(); i++) {
- LikelihoodDistribution distLinked = vLinked.get(i);
- LikelihoodDistribution distUnlinked = vUnlinked.get(i);
- StructuralLikelihoodQuantity quant = distLinked.getQuantity();
- try {
- double goodPDF = distLinked.getPDF(clus1, clus2);
- double badPDF = distUnlinked.getPDF(clus1, clus2);
- double goodProb = goodPDF/(goodPDF+badPDF);
- double badProb = badPDF/(goodPDF+badPDF);
- totalGoodLikelihood *= goodProb;
- totalBadLikelihood *= badProb;
- System.out.println("DEBUG: Quantity"+i+" = "+quant.evaluate(clus1,clus2)+" so prob(good)="+goodProb);
- } catch (QuantityNotDefinedException x) {
- // Have to ignore this one.
- System.out.println("Warning: "+x);
- }
- }
- double normalizedGoodLikelihood = totalGoodLikelihood / (totalGoodLikelihood+totalBadLikelihood);
- System.out.println("DEBUG: => net probs: "+totalGoodLikelihood+" vs "+totalBadLikelihood+" => prob(good) = "+normalizedGoodLikelihood);
- }
- return getLinkLikelihood(clus1, clus2, vLinked, vUnlinked);
- }
- public double getLinkLikelihoodClumpToClump(Cluster clus1, Cluster clus2) {
- Vector<LikelihoodDistribution> vLinked = getLikelihoodDistributionClumpToClump(true);
- Vector<LikelihoodDistribution> vUnlinked = getLikelihoodDistributionClumpToClump(false);
- if (m_debug) {
- double totalGoodLikelihood = 1.0;
- double totalBadLikelihood = 1.0;
- for (int i=0; i<vLinked.size(); i++) {
- LikelihoodDistribution distLinked = vLinked.get(i);
- LikelihoodDistribution distUnlinked = vUnlinked.get(i);
- StructuralLikelihoodQuantity quant = distLinked.getQuantity();
- try {
- double goodPDF = distLinked.getPDF(clus1, clus2);
- double badPDF = distUnlinked.getPDF(clus1, clus2);
- double goodProb = goodPDF/(goodPDF+badPDF);
- double badProb = badPDF/(goodPDF+badPDF);
- totalGoodLikelihood *= goodProb;
- totalBadLikelihood *= badProb;
- System.out.println("DEBUG: Quantity"+i+" = "+quant.evaluate(clus1,clus2)+" so prob(good)="+goodProb);
- } catch (QuantityNotDefinedException x) {
- // Have to ignore this one.
- System.out.println("Warning: "+x);
- }
- }
- double normalizedGoodLikelihood = totalGoodLikelihood / (totalGoodLikelihood+totalBadLikelihood);
- System.out.println("DEBUG: => net probs: "+totalGoodLikelihood+" vs "+totalBadLikelihood+" => prob(good) = "+normalizedGoodLikelihood);
- }
- return getLinkLikelihood(clus1, clus2, vLinked, vUnlinked);
- }
-
- protected double getLinkLikelihood(Cluster clus1, Cluster clus2, Vector<LikelihoodDistribution> vLinked, Vector<LikelihoodDistribution> vUnlinked)
- {
- double totalGoodLikelihood = 1.0;
- double totalBadLikelihood = 1.0;
- for (int i=0; i<vLinked.size(); i++) {
- LikelihoodDistribution distLinked = vLinked.get(i);
- LikelihoodDistribution distUnlinked = vUnlinked.get(i);
- try {
- double goodPDF = distLinked.getPDF(clus1, clus2);
- double badPDF = distUnlinked.getPDF(clus1, clus2);
- double goodProb = goodPDF/(goodPDF+badPDF);
- double badProb = badPDF/(goodPDF+badPDF);
- totalGoodLikelihood *= goodProb;
- totalBadLikelihood *= badProb;
- } catch (QuantityNotDefinedException x) {
- // Have to ignore this one.
- System.out.println("Warning: "+x);
- }
- }
- double normalizedGoodLikelihood = totalGoodLikelihood / (totalGoodLikelihood+totalBadLikelihood);
- return normalizedGoodLikelihood;
- }
-
- // A static routine to read from a serialised file:
- static public LikelihoodEvaluator readFromFile(String filename)
- {
- try {
- FileInputStream fis = new FileInputStream(filename);
- ObjectInputStream ois = new ObjectInputStream(fis);
- Object o = ois.readObject();
- LikelihoodEvaluator eval = (LikelihoodEvaluator) o;
- return eval;
- } catch (java.io.IOException x) {
- throw new AssertionError("java.io.IOException: "+x);
- } catch (java.lang.ClassNotFoundException x) {
- throw new AssertionError("java.lang.ClassNotFoundException: "+x);
- }
- }
-
- public void writeToFile(String filename)
- {
- // Open the file for writing:
- try {
- FileOutputStream fos = new FileOutputStream(filename);
- ObjectOutputStream oos = new ObjectOutputStream(fos);
- oos.writeObject(this);
- } catch (java.io.IOException x) {
- throw new AssertionError("java.io.IOException: "+x);
- }
- }
-
- // Routines to make interesting plots:
-
- /**
- * Write the likelihood distributions out to the given file
- */
- public void makePlots(String filename)
- {
- IAnalysisFactory af = IAnalysisFactory.create();
- try {
- ITree t = af.createTreeFactory().create(filename,"xml",false,true);
- IHistogramFactory hf = af.createHistogramFactory(t);
- makePlots(hf, "hTrackTrack", m_LikelihoodDistributionsTrackToTrack);
- makePlots(hf, "hTrackClump", m_LikelihoodDistributionsTrackToClump);
- makePlots(hf, "hClumpClump", m_LikelihoodDistributionsClumpToClump);
- t.commit();
- } catch(IOException ioe1) {
- ioe1.printStackTrace();
- }
- }
-
- /**
- * Make the plots for a particular set of variables (clump-clump, track-track, track-clump)
- */
- protected void makePlots(IHistogramFactory hf, String name1, Map<Boolean, Vector<LikelihoodDistribution> > map)
- {
- for (LikelihoodDistribution dist : map.get(Boolean.valueOf(true))) {
- makePlot(hf, name1, "Signal", dist);
- }
- for (LikelihoodDistribution dist : map.get(Boolean.valueOf(false))) {
- makePlot(hf, name1, "Background", dist);
- }
- }
+ public double getLinkLikelihoodTrackToTrack(Cluster clus1, Cluster clus2);
+ public double getLinkLikelihoodTrackToClump(Cluster clus1, Cluster clus2);
+ public double getLinkLikelihoodClumpToClump(Cluster clus1, Cluster clus2);
- /**
- * Make one plot
- */
- protected void makePlot(IHistogramFactory hf, String name1, String name2, LikelihoodDistribution dist)
- {
- String subName = dist.getQuantity().getClass().getName();
- String fullName = new String(name1 + "_" + name2 + "_" + subName);
- if (m_debug) { System.out.println("DEBUG: Making histogram for ["+fullName+"]"); }
- int nbins = dist.getNbins();
- double min = dist.getMin();
- double max = dist.getMax();
- double binsize = (max-min) / ( (double)(nbins) );
- int histo_nbins = nbins;
- double histo_min = min;
- double histo_max = max;
- if (dist.useUnderFlow()) {
- histo_nbins++;
- histo_min -= binsize;
- }
- if (dist.useOverFlow()) {
- histo_nbins++;
- histo_max += binsize;
- }
- IHistogram1D histo = hf.createHistogram1D(fullName, histo_nbins, histo_min, histo_max);
- for (int i=0; i<nbins; i++) {
- double binCenter = min + binsize*( (double)(i) + 0.5);
- histo.fill(binCenter, dist.getPDF(i));
- if (m_debug) { System.out.println(" "+i+": "+dist.getPDF(i)); }
- }
- if (dist.useUnderFlow()) {
- histo.fill(min-0.5*binsize, dist.getPDF(-1));
- if (m_debug) { System.out.println(" underflow: "+dist.getPDF(-1)); }
- }
- if (dist.useOverFlow()) {
- histo.fill(max+0.5*binsize, dist.getPDF(nbins));
- if (m_debug) { System.out.println(" overflow: "+dist.getPDF(nbins)); }
- }
- }
+ public void writeToFile(String filename);
- public void setDebug(boolean debug) {
- m_debug = debug;
- }
+ public void setDebug(boolean debug);
}
lcsim/src/org/lcsim/recon/cluster/structural/likelihood
diff -u -r1.2 -r1.3
--- LikelihoodEvaluatorCheckpointDriver.java 2 Nov 2006 22:52:51 -0000 1.2
+++ LikelihoodEvaluatorCheckpointDriver.java 4 Sep 2007 17:27:57 -0000 1.3
@@ -21,7 +21,7 @@
if (m_eval != null) {
if (m_frequency>0 && m_count % m_frequency == 0) {
m_eval.writeToFile("likelihood.bin");
- m_eval.makePlots("likelihoodDistributions.aida");
+ //m_eval.makePlots("likelihoodDistributions.aida");
if (m_debug) {
System.out.println("DEBUG: Wrote likelihood distribution at checkpoint of "+m_count+" events.");
}
@@ -31,7 +31,7 @@
public void suspend() {
m_eval.writeToFile("likelihood.bin");
- m_eval.makePlots("likelihoodDistributions.aida");
+ //m_eval.makePlots("likelihoodDistributions.aida");
super.suspend();
}
CVSspam 0.2.8
