3 added files
lcsim/sandbox/Partridge
diff -N SeedSectoring.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ SeedSectoring.java 10 Mar 2010 21:55:57 -0000 1.1
@@ -0,0 +1,109 @@
+package org.lcsim.recon.tracking.seedtracker;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *
+ * @author Richard Partridge
+ */
+public class SeedSectoring {
+
+ private List<List<Sector>> _seedsectors;
+ private List<List<Sector>> _spairs;
+ private Map<List<Sector>, List<Sector>> _smap;
+
+ public SeedSectoring(HitManager hmanager, SeedStrategy strategy,
+ double bfield) {
+
+ _seedsectors = new ArrayList<List<Sector>>();
+
+ FastCheck checker = new FastCheck(strategy, bfield, null);
+
+ // Get the SeedLayers for this strategy
+ List<SeedLayer> layers = strategy.getLayers(SeedLayer.SeedType.Seed);
+ if (layers.size() != 3)
+ throw new RuntimeException("Illegal Strategy "+strategy.getName()+": Number of Seed Layers is not 3");
+
+ // Find the approximate midpoint of each seedlayer by averaging rmax and rmin
+ double[] rmid = new double[3];
+ int[] indx = new int[3];
+ for (int i=0; i<3; i++) {
+ double rmin = 1.e9;
+ double rmax = -1.e9;
+
+ // Loop over all sectors for this layer and find the min/max r
+ for (Sector sector : hmanager.getSectors(layers.get(i))) {
+ if (rmin > sector.rmin()) rmin = sector.rmin();
+ if (rmax < sector.rmax()) rmax = sector.rmax();
+ }
+
+ // Find the midpoint and save an index to identify the layers after sorting
+ rmid[i] = 0.5 * (rmin + rmax);
+ indx[i] = i;
+ }
+
+ // Sort the layers by increasing radius
+ for (int i=0; i<2; i++) {
+ for (int j=i+1; j<3; j++) {
+ if (rmid[j] < rmid[i]) {
+ double temp = rmid[i];
+ rmid[i] = rmid[j];
+ rmid[j] = temp;
+ int itemp = indx[i];
+ indx[i] = indx[j];
+ indx[j] = itemp;
+ }
+ }
+ }
+
+ System.out.println("Lowest radius layer is "+layers.get(indx[0])+" with radius "+rmid[0]+" and index "+indx[0]);
+ System.out.println("Medium radius layer is "+layers.get(indx[1])+" with radius "+rmid[1]+" and index "+indx[1]);
+ System.out.println("Higest radius layer is "+layers.get(indx[2])+" with radius "+rmid[2]+" and index "+indx[2]);
+
+ // Use the outer two layers to make hit pairs, add the inner radius hit for the third seed hit
+ List<Sector> slist0 = hmanager.getSectors(layers.get(indx[2]));
+ List<Sector> slist1 = hmanager.getSectors(layers.get(indx[1]));
+ List<Sector> slist2 = hmanager.getSectors(layers.get(indx[0]));
+
+ _spairs = new ArrayList<List<Sector>>();
+ _smap = new HashMap<List<Sector>, List<Sector>>();
+
+ // Use the inner and outer layers to make hit pairs, take the middle layer last
+ for (Sector s0 : slist0) {
+ for (Sector s1 : slist1) {
+ if (!checker.CheckSectorPair(s0, s1)) continue;
+ List<Sector> spair = new ArrayList<Sector>();
+ spair.add(s0);
+ spair.add(s1);
+ _spairs.add(spair);
+ List<Sector> sthird = new ArrayList<Sector>();
+ for (Sector s2 : slist2) {
+ if (!checker.CheckSectorPair(s0, s2)) continue;
+ if (!checker.CheckSectorPair(s1, s2)) continue;
+ sthird.add(s2);
+ List<Sector> slist = new ArrayList<Sector>();
+ slist.add(s0);
+ slist.add(s1);
+ slist.add(s2);
+ _seedsectors.add(slist);
+ }
+ _smap.put(spair, sthird);
+ }
+ }
+ }
+
+ public List<List<Sector>> SeedSectors() {
+ return _seedsectors;
+ }
+
+ public List<List<Sector>> SeedPairs() {
+ return _spairs;
+ }
+
+ public List<Sector> SeedThirds(List<Sector> seedpair) {
+ return _smap.get(seedpair);
+ }
+}
\ No newline at end of file
lcsim/sandbox/Partridge
diff -N SeedTrackFinder.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ SeedTrackFinder.java 10 Mar 2010 21:55:58 -0000 1.1
@@ -0,0 +1,168 @@
+/*
+ * SeedTrackFinder.java
+ *
+ * Created on January 22, 2008, 9:39 AM
+ *
+ */
+package org.lcsim.recon.tracking.seedtracker;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
+import java.util.Set;
+import org.lcsim.event.MCParticle;
+import org.lcsim.fit.helicaltrack.HelicalTrackHit;
+import org.lcsim.recon.tracking.seedtracker.diagnostic.ISeedTrackerDiagnostics;
+
+/**
+ *
+ * @author Richard Partridge
+ * @version 1.0
+ */
+public class SeedTrackFinder {
+
+ private HitManager _hitmanager;
+ private HelixFitter _helixfitter;
+ private ConfirmerExtender _confirmer;
+ private List<SeedCandidate> _trackseeds;
+ private ISeedTrackerDiagnostics _diag = null;
+ private Set<MCParticle> _seededmcp;
+ private Set<MCParticle> _confirmedmcp;
+
+ TrackCheck _trackCheck; // set by SeedTracker
+
+ /**
+ * Creates a new instance of SeedTrackFinder
+ */
+ public SeedTrackFinder(HitManager hitmanager, HelixFitter helixfitter) {
+
+ // Save the pointers to the hit manager and helix fitter classes
+ _hitmanager = hitmanager;
+ _helixfitter = helixfitter;
+
+ // Instantiate the Confirmer/Extender and Seed Candidate merging classes
+ _confirmer = new ConfirmerExtender(_hitmanager, _helixfitter);
+
+ // Create a list of track seeds that have been found
+ _trackseeds = new ArrayList<SeedCandidate>();
+
+ // Create a set of MC Particles that have been seeded, confirmed
+ _seededmcp = new HashSet<MCParticle>();
+ _confirmedmcp = new HashSet<MCParticle>();
+
+ }
+
+ public void setDiagnostic(ISeedTrackerDiagnostics d) {
+
+ // Setup the diagnostics for this class and the classes used by this class
+ _diag = d;
+ _confirmer.setDiagnostics(_diag);
+ }
+
+ public boolean FindTracks(SeedStrategy strategy, double bfield) {
+
+ // Instantiate the fast hit checker
+ FastCheck checker = new FastCheck(strategy, bfield, _diag);
+
+ // Find the valid sector combinations
+ SeedSectoring ss = new SeedSectoring(_hitmanager, strategy, bfield);
+
+ List<List<Sector>> spairs = ss.SeedPairs();
+ System.out.println("Number of sector pairs: "+spairs.size());
+
+ // Loop over the first seed layer
+ for (List<Sector> spair : spairs) {
+ System.out.println("New sector pair - triplet sectors: "+ss.SeedThirds(spair).size()+
+ " hits in layer 0: "+spair.get(0).Hits().size()+" layer 1: "+spair.get(1).Hits().size());
+
+ for (HelicalTrackHit hit1 : spair.get(0).Hits()) {
+
+ // Loop over the second seed layer and check that we have a hit pair consistent with our strategy
+ for (HelicalTrackHit hit2 : spair.get(1).Hits()) {
+
+ // Check if the pair of hits is consistent with the current strategy
+ if (!checker.TwoPointCircleCheck(hit1, hit2, null)) {
+ if (_diag != null) _diag.fireCheckHitPairFailed(hit1, hit2);
+ continue;
+ }
+
+ for (Sector sector : ss.SeedThirds(spair)) {
+
+ // Loop over the third seed layer and check that we have a hit triplet consistent with our strategy
+ for (HelicalTrackHit hit3 : sector.Hits()) {
+
+ // Check if the triplet of hits is consistent with the current strategy
+ if (!checker.ThreePointHelixCheck(hit1, hit2, hit3)) {
+ if (_diag != null) _diag.fireCheckHitTripletFailed(hit1, hit2, hit3);
+ continue;
+ }
+
+ // Form a seed candidate from the seed hits
+ SeedCandidate seed = new SeedCandidate(strategy, bfield);
+ seed.addHit(hit1);
+ seed.addHit(hit2);
+ seed.addHit(hit3);
+
+ // If it's a true seed, add the MC Particle to those that were seeded
+ if (_diag != null) {
+ if (seed.isTrueSeed()) _seededmcp.addAll(seed.getMCParticles());
+ }
+
+ // See if we can fit a helix to this seed candidate
+ boolean success = _helixfitter.FitCandidate(seed, strategy);
+ if (!success) continue;
+
+ // Save the helix fit
+ seed.setHelix(_helixfitter.getHelix());
+
+ // Check the seed - hook for plugging in external constraint
+ if ((_trackCheck != null) && (! _trackCheck.checkSeed(seed))) continue;
+
+ // See if we can confirm this seed candidate
+ success = _confirmer.Confirm(seed, strategy, bfield);
+ if (!success) continue;
+
+ // Confirmed a seed - if it's a true seed, add the MC Particle to those that were confirmed
+ if (_diag != null) {
+ if (seed.isTrueSeed()) _confirmedmcp.addAll(seed.getMCParticles());
+ }
+
+ // Try to extend each confirmed seed candidates to make a track candidate
+ List<SeedCandidate> confirmedlist = _confirmer.getResult();
+ for (SeedCandidate confirmedseed : confirmedlist) {
+
+ // See if we can extend this seed candidate
+ _confirmer.Extend(confirmedseed, strategy, bfield, _trackseeds);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Done with track finding for this strategy
+ if (_diag != null)
+ _diag.fireFinderDone(_trackseeds, _seededmcp);
+
+ return _trackseeds.size() > 0;
+ }
+
+ public List<SeedCandidate> getTrackSeeds() {
+ return _trackseeds;
+ }
+
+ public void clearTrackSeedList() {
+ _trackseeds.clear();
+ _seededmcp.clear();
+ _confirmedmcp.clear();
+ }
+
+ public Set<MCParticle> getSeededMCParticles() {
+ return _seededmcp;
+ }
+
+ public Set<MCParticle> getConfirmedMCParticles() {
+ return _confirmedmcp;
+ }
+}
\ No newline at end of file
lcsim/sandbox/Partridge
diff -N SeedTrackerDiagnostics.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ SeedTrackerDiagnostics.java 10 Mar 2010 21:55:58 -0000 1.1
@@ -0,0 +1,125 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.recon.tracking.seedtracker.diagnostic;
+
+import org.lcsim.event.MCParticle;
+import org.lcsim.fit.helicaltrack.HelicalTrackFitter;
+import org.lcsim.fit.helicaltrack.HelicalTrackHit;
+import org.lcsim.recon.tracking.seedtracker.SeedCandidate;
+import org.lcsim.recon.tracking.seedtracker.SeedStrategy;
+import org.lcsim.util.aida.AIDA;
+
+/**
+ *
+ * @author cozzy
+ */
+public class SeedTrackerDiagnostics extends EmptySeedTrackerDiagnostics implements ISeedTrackerDiagnostics{
+
+ AIDA aida = AIDA.defaultInstance();
+ private String prefix = "";
+
+ public SeedTrackerDiagnostics(){
+ }
+
+ @Override
+ public void fireCheckHitPairFailed(HelicalTrackHit hit1, HelicalTrackHit hit2) {
+ SeedCandidate seed = new SeedCandidate(super.currentStrategy, super.bField);
+ seed.addHit(hit1);
+ seed.addHit(hit2);
+ if (seed.isTrueSeed()) {
+ for (MCParticle mcp : seed.getMCParticles()) {
+ System.out.println("Hits from same MC particle failed hit pair check");
+ System.out.println("MC momentum: "+mcp.getMomentum().toString());
+ System.out.println("Hit 1 position: "+hit1.getCorrectedPosition().toString());
+ System.out.println("Hit 2 position: "+hit2.getCorrectedPosition().toString());
+ }
+ }
+ }
+
+ @Override
+ public void fireCheckHitTripletFailed(HelicalTrackHit hit1, HelicalTrackHit hit2, HelicalTrackHit hit3) {
+ SeedCandidate seed = new SeedCandidate(super.currentStrategy, super.bField);
+ seed.addHit(hit1);
+ seed.addHit(hit2);
+ seed.addHit(hit3);
+ if (seed.isTrueSeed()) {
+ for (MCParticle mcp : seed.getMCParticles()) {
+ System.out.println("Hits from same MC particle failed hit triplet check");
+ System.out.println("MC momentum: "+mcp.getMomentum().toString());
+ System.out.println("Hit 1 position: "+hit1.getCorrectedPosition().toString());
+ System.out.println("Hit 2 position: "+hit2.getCorrectedPosition().toString());
+ System.out.println("Hit 3 position: "+hit3.getCorrectedPosition().toString());
+ }
+ }
+ }
+
+ @Override
+ public void fireCheckHitFailed(HelicalTrackHit hit, SeedCandidate seed) {
+ printmsg(seed, "True seed failed hit and seed check");
+ }
+
+ @Override
+ public void fireHelixFitFailed(SeedCandidate seed, HelicalTrackFitter.FitStatus status, boolean firstfit) {
+ if (firstfit) printmsg(seed, "Initial fit of true seed failed");
+ else printmsg(seed, "Helix fit of true seed failed with "+seed.getHits().size()+" hits");
+ }
+
+ @Override
+ public void fireFailedChisqCut(SeedCandidate seed) {
+ printmsg(seed, "True seed failed chisq cut - chisq = "+seed.getHelix().chisqtot());
+ }
+
+ @Override
+ public void fireMergeKillingNewSeed(SeedCandidate seed, SeedCandidate newseed) {
+ if (!seed.isTrueSeed() && newseed.isTrueSeed())
+ printmsg(seed, "Merge keeping false seed instead of new true seed");
+ if (seed.isTrueSeed() && newseed.isTrueSeed()) {
+ if (newseed.getHits().size() > seed.getHits().size()) {
+ printmsg(seed, "Merge killing new true seed with more hits than old true seed");
+ System.out.println("New seed has "+newseed.getHits().size()
+ +" hits, old seed has "+seed.getHits().size()+" hits");
+ System.out.println("New seed has chisq = "+newseed.getHelix().chisqtot()+
+ ", old seed has chisq = "+seed.getHelix().chisqtot());
+ }
+ }
+ }
+
+ @Override
+ public void fireMergeKillingOldSeed(SeedCandidate seed, SeedCandidate newseed) {
+ if (seed.isTrueSeed() && !newseed.isTrueSeed())
+ printmsg(seed, "Merge eliminating true seed duplicate in favor of false seed");
+ if (seed.isTrueSeed() && newseed.isTrueSeed()) {
+ if (newseed.getHits().size() < seed.getHits().size()) {
+ printmsg(seed, "Merge killing old true seed with more hits than new true seed");
+ System.out.println("New seed has "+newseed.getHits().size()
+ +" hits, old seed has "+seed.getHits().size()+" hits");
+ System.out.println("New seed has chisq = "+newseed.getHelix().chisqtot()+
+ ", old seed has chisq = "+seed.getHelix().chisqtot());
+ }
+ }
+ }
+
+ /**
+ * Sets the prefix to be appended to the beginning of each plot (for example, a strategy name
+ * @param str the new prefix
+ */
+ public void setPrefix(String str){
+ this.prefix = str;
+ }
+
+ @Override
+ public void fireStrategyChanged(SeedStrategy strategy) {
+ setPrefix("chisq cut = "+strategy.getMaxChisq()+"/");
+ super.fireStrategyChanged(strategy);
+ }
+
+ private void printmsg(SeedCandidate seed, String message) {
+ if (!seed.isTrueSeed()) return;
+ for (MCParticle mcp : seed.getMCParticles()) {
+ System.out.println(message+" p: "+mcp.getMomentum().toString());
+ }
+ }
+}
\ No newline at end of file
CVSspam 0.2.8
