Author: [log in to unmask]
Date: Tue Nov 3 13:13:56 2015
New Revision: 3932
Log:
merge tracks
Modified:
java/trunk/tracking/src/main/java/org/hps/recon/tracking/gbl/GBLRefitterDriver.java
java/trunk/tracking/src/main/java/org/hps/recon/tracking/gbl/GblUtils.java
Modified: java/trunk/tracking/src/main/java/org/hps/recon/tracking/gbl/GBLRefitterDriver.java
=============================================================================
--- java/trunk/tracking/src/main/java/org/hps/recon/tracking/gbl/GBLRefitterDriver.java (original)
+++ java/trunk/tracking/src/main/java/org/hps/recon/tracking/gbl/GBLRefitterDriver.java Tue Nov 3 13:13:56 2015
@@ -10,11 +10,9 @@
import org.hps.recon.tracking.MultipleScattering;
import org.hps.recon.tracking.TrackUtils;
import org.lcsim.event.EventHeader;
-import org.lcsim.event.RawTrackerHit;
import org.lcsim.event.RelationalTable;
import org.lcsim.event.Track;
import org.lcsim.event.TrackerHit;
-import org.lcsim.fit.helicaltrack.HelicalTrackFit;
import org.lcsim.geometry.Detector;
import org.lcsim.lcio.LCIOConstants;
import org.lcsim.util.Driver;
@@ -30,6 +28,7 @@
private double bfield;
private final MultipleScattering _scattering = new MultipleScattering(new MaterialSupervisor());
+ private boolean mergeTracks = false;
public void setInputCollectionName(String inputCollectionName) {
this.inputCollectionName = inputCollectionName;
@@ -37,6 +36,16 @@
public void setOutputCollectionName(String outputCollectionName) {
this.outputCollectionName = outputCollectionName;
+ }
+
+ /**
+ * Merge tracks with overlapping hit content. Right now nothing actually
+ * happens to the merged tracks; this is just for testing.
+ *
+ * @param mergeTracks default to false
+ */
+ public void setMergeTracks(boolean mergeTracks) {
+ this.mergeTracks = mergeTracks;
}
@Override
@@ -59,46 +68,63 @@
Map<Track, Track> inputToRefitted = new HashMap<Track, Track>();
for (Track track : tracks) {
- HelicalTrackFit helix = TrackUtils.getHTF(track);
- FittedGblTrajectory fit = GblUtils.doGBLFit(helix, TrackUtils.getStripHits(track, hitToStrips, hitToRotated), _scattering, bfield, 0);
-
- Track newTrack = MakeGblTracks.makeCorrectedTrack(fit, helix, track.getTrackerHits(), track.getType(), bfield);
+ Track newTrack = GblUtils.refitTrack(TrackUtils.getHTF(track), TrackUtils.getStripHits(track, hitToStrips, hitToRotated), track.getTrackerHits(), 5, _scattering, bfield);
refittedTracks.add(newTrack);
inputToRefitted.put(track, newTrack);
}
- Map<Set<TrackerHit>, List<Track>> hitSetToTrackList = new HashMap<Set<TrackerHit>, List<Track>>();
+ if (mergeTracks) {
+ List<Track> mergedTracks = new ArrayList<Track>();
- for (Track track : tracks) {
- Set<TrackerHit> trackHth = new HashSet<TrackerHit>(track.getTrackerHits());
- for (Track otherTrack : tracks) {
- Set<TrackerHit> allHth = new HashSet<TrackerHit>(otherTrack.getTrackerHits());
- allHth.addAll(trackHth);
- List<TrackerHit> hthList = new ArrayList<TrackerHit>(allHth);
- if (hthList.size() == trackHth.size()) {
- continue;
+ for (Track track : refittedTracks) {
+ List<TrackerHit> trackHth = track.getTrackerHits();
+ otherTrackLoop:
+ for (Track otherTrack : refittedTracks) {
+ if (track == otherTrack) {
+ continue;
+ }
+
+ Set<TrackerHit> allHth = new HashSet<TrackerHit>(otherTrack.getTrackerHits());
+ allHth.addAll(trackHth);
+// if (allHth.size() == trackHth.size()) {
+// continue;
+// }
+
+ boolean[] hasHit = new boolean[6];
+
+ for (TrackerHit hit : allHth) {
+ int layer = (TrackUtils.getLayer(hit) - 1) / 2;
+ if (hasHit[layer]) {
+ continue otherTrackLoop;
+ }
+ hasHit[layer] = true;
+ }
+ for (Track mergedTrack : mergedTracks) {
+ if (mergedTrack.getTrackerHits().containsAll(allHth)) {
+ continue otherTrackLoop;
+ }
+ }
+
+ Track mergedTrack = GblUtils.refitTrack(TrackUtils.getHTF(track), TrackUtils.getStripHits(track, hitToStrips, hitToRotated), allHth, 5, _scattering, bfield);
+ mergedTracks.add(mergedTrack);
+// System.out.format("%f %f %f\n", fit.get_chi2(), inputToRefitted.get(track).getChi2(), inputToRefitted.get(otherTrack).getChi2());
+// mergedTrackToTrackList.put(mergedTrack, new ArrayList<Track>());
}
+ }
- boolean[] hasHit = new boolean[6];
- boolean isGood = true;
-
- for (TrackerHit hit : hthList) {
- int layer = (TrackUtils.getLayer(hit) - 1) / 2;
- if (hasHit[layer]) {
- isGood = false;
- break;
+ for (Track mergedTrack : mergedTracks) {
+ List<Track> subTracks = new ArrayList<Track>();
+ Set<TrackerHit> trackHth = new HashSet<TrackerHit>(mergedTrack.getTrackerHits());
+ for (Track track : refittedTracks) {
+ if (trackHth.containsAll(track.getTrackerHits())) {
+ subTracks.add(track);
}
- hasHit[layer] = true;
}
- if (isGood) {
- HelicalTrackFit helix = TrackUtils.getHTF(track);
- Set<TrackerHit> allStripHits = new HashSet<TrackerHit>(TrackUtils.getStripHits(track, hitToStrips, hitToRotated));
- allStripHits.addAll(TrackUtils.getStripHits(otherTrack, hitToStrips, hitToRotated));
-
- FittedGblTrajectory fit = GblUtils.doGBLFit(helix, new ArrayList<TrackerHit>(allStripHits), _scattering, bfield, 0);
- Track newTrack = MakeGblTracks.makeCorrectedTrack(fit, helix, new ArrayList<TrackerHit>(allHth), 0, bfield);
- System.out.format("%f %f %f\n", fit.get_chi2(), inputToRefitted.get(track).getChi2(), inputToRefitted.get(otherTrack).getChi2());
+ System.out.format("%f:\t", mergedTrack.getChi2());
+ for (Track subTrack : subTracks) {
+ System.out.format("%f (%d)\t", subTrack.getChi2(), subTrack.getTrackerHits().size());
}
+ System.out.println();
}
}
// Put the tracks back into the event and exit
Modified: java/trunk/tracking/src/main/java/org/hps/recon/tracking/gbl/GblUtils.java
=============================================================================
--- java/trunk/tracking/src/main/java/org/hps/recon/tracking/gbl/GblUtils.java (original)
+++ java/trunk/tracking/src/main/java/org/hps/recon/tracking/gbl/GblUtils.java Tue Nov 3 13:13:56 2015
@@ -6,6 +6,9 @@
import hep.physics.vec.Hep3Vector;
import hep.physics.vec.VecOp;
import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
import java.util.List;
import org.hps.recon.tracking.CoordinateTransformations;
import org.hps.recon.tracking.MaterialSupervisor;
@@ -19,6 +22,7 @@
import org.lcsim.detector.tracker.silicon.SiSensor;
import org.lcsim.detector.tracker.silicon.SiSensorElectrodes;
import org.lcsim.event.RawTrackerHit;
+import org.lcsim.event.Track;
import org.lcsim.event.TrackerHit;
import org.lcsim.fit.helicaltrack.HelicalTrackFit;
import org.lcsim.fit.helicaltrack.HelicalTrackStrip;
@@ -125,6 +129,34 @@
}
}
+ /**
+ * Do a GBL fit to an arbitrary set of strip hits, with a starting value of
+ * the helix parameters.
+ *
+ * @param helix Initial helix parameters. Only track parameters are used
+ * (not covariance)
+ * @param stripHits Strip hits to be used for the GBL fit. Does not need to
+ * be in sorted order.
+ * @param hth Stereo hits for the track's hit list (these are not used in
+ * the GBL fit). Does not need to be in sorted order.
+ * @param nIterations Number of times to iterate the GBL fit.
+ * @param scattering Multiple scattering manager.
+ * @param bfield B-field
+ * @return The refitted track.
+ */
+ public static Track refitTrack(HelicalTrackFit helix, Collection<TrackerHit> stripHits, Collection<TrackerHit> hth, int nIterations, MultipleScattering scattering, double bfield) {
+ List<TrackerHit> allHthList = sortHits(hth);
+ List<TrackerHit> sortedStripHits = sortHits(stripHits);
+ FittedGblTrajectory fit = GblUtils.doGBLFit(helix, sortedStripHits, scattering, bfield, 0);
+ for (int i = 0; i < nIterations; i++) {
+ Track newTrack = MakeGblTracks.makeCorrectedTrack(fit, helix, allHthList, 0, bfield);
+ helix = TrackUtils.getHTF(newTrack);
+ fit = GblUtils.doGBLFit(helix, sortedStripHits, scattering, bfield, 0);
+ }
+ Track mergedTrack = MakeGblTracks.makeCorrectedTrack(fit, helix, allHthList, 0, bfield);
+ return mergedTrack;
+ }
+
public static FittedGblTrajectory doGBLFit(HelicalTrackFit htf, List<TrackerHit> stripHits, MultipleScattering _scattering, double bfield, int debug) {
List<GBLStripClusterData> stripData = makeStripData(htf, stripHits, _scattering, bfield, debug);
double bfac = Constants.fieldConversion * bfield;
@@ -294,4 +326,18 @@
return strip;
}
+
+ private static List<TrackerHit> sortHits(Collection<TrackerHit> hits) {
+ List<TrackerHit> hitList = new ArrayList<TrackerHit>(hits);
+ Collections.sort(hitList, new LayerComparator());
+ return hitList;
+ }
+
+ private static class LayerComparator implements Comparator<TrackerHit> {
+
+ @Override
+ public int compare(TrackerHit o1, TrackerHit o2) {
+ return Integer.compare(TrackUtils.getLayer(o1), TrackUtils.getLayer(o2));
+ }
+ }
}
