Author: [log in to unmask] Date: Fri Jan 20 11:20:44 2017 New Revision: 4681 Log: Driver to make SVT hit/track plots Added: java/trunk/users/src/main/java/org/hps/users/byale/SvtTrackPlotDriver.java (with props) Added: java/trunk/users/src/main/java/org/hps/users/byale/SvtTrackPlotDriver.java ============================================================================= --- java/trunk/users/src/main/java/org/hps/users/byale/SvtTrackPlotDriver.java (added) +++ java/trunk/users/src/main/java/org/hps/users/byale/SvtTrackPlotDriver.java Fri Jan 20 11:20:44 2017 @@ -0,0 +1,848 @@ +package org.hps.users.byale; + +import static java.lang.Math.sqrt; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogramFactory; +import hep.aida.IPlotterFactory; +import hep.aida.IPlotter; +import hep.aida.IHistogram1D; +import hep.aida.ITree; +import hep.aida.ref.rootwriter.RootFileStore; +import hep.physics.matrix.SymmetricMatrix; +import hep.physics.vec.BasicHep3Vector; +import hep.physics.vec.Hep3Vector; + +import org.lcsim.detector.DetectorElementStore; +import org.lcsim.detector.IDetectorElement; +import org.lcsim.detector.IRotation3D; +import org.lcsim.detector.ITransform3D; +import org.lcsim.detector.ITranslation3D; +import org.lcsim.detector.identifier.IExpandedIdentifier; +import org.lcsim.detector.identifier.IIdentifier; +import org.lcsim.detector.identifier.IIdentifierDictionary; +import org.lcsim.detector.tracker.silicon.HpsSiSensor; +import org.lcsim.detector.tracker.silicon.SiSensor; +import org.lcsim.event.EventHeader; +import org.lcsim.event.LCRelation; +import org.lcsim.event.RawTrackerHit; +import org.lcsim.event.RelationalTable; +import org.lcsim.event.SimTrackerHit; +import org.lcsim.event.Track; +import org.lcsim.event.TrackerHit; +import org.lcsim.event.base.BaseRelationalTable; +import org.lcsim.fit.helicaltrack.HelicalTrackHit; +import org.lcsim.fit.helicaltrack.HelicalTrackStrip; +import org.lcsim.geometry.Detector; +import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHit; +import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHitStrip1D; +import org.lcsim.recon.tracking.digitization.sisim.TrackerHitType; +import org.lcsim.recon.tracking.digitization.sisim.TransformableTrackerHit; +import org.lcsim.util.Driver; + +import org.hps.recon.tracking.FittedRawTrackerHit; +import org.hps.recon.tracking.TrackUtils; + +/** + * + * @author Bradley Yale <[log in to unmask]> + * + */ +public class SvtTrackPlotDriver extends Driver { + + // Use JFreeChart as the default plotting backend + static { + hep.aida.jfree.AnalysisFactory.register(); + } + + // Plotting + ITree tree; + IHistogramFactory histogramFactory; + IPlotterFactory plotterFactory = IAnalysisFactory.create().createPlotterFactory(); + protected Map<String, IPlotter> plotters = new HashMap<String, IPlotter>(); + private Map<String, IHistogram1D> trackPlots = new HashMap<String, IHistogram1D>(); + private Map<String, IHistogram1D> clusterChargePlots = new HashMap<String, IHistogram1D>(); + private Map<String, IHistogram1D> clusterSizePlots = new HashMap<String, IHistogram1D>(); + private Map<String, IHistogram1D> MCPlots = new HashMap<String, IHistogram1D>(); + + private List<HpsSiSensor> sensors; + private Map<RawTrackerHit, LCRelation> fittedRawTrackerHitMap + = new HashMap<RawTrackerHit, LCRelation>(); + + // Detector name + private static final String SUBDETECTOR_NAME = "Tracker"; + + // Collections + private String trackCollectionName = "MatchedTracks"; + private String stereoHitRelationsColName = "HelicalTrackHitRelations"; + private String fittedHitsCollectionName = "SVTFittedRawTrackerHits"; + private String rotatedHthRelationsColName = "RotatedHelicalTrackHitRelations"; + // private String StripsCollectionName = "SiTrackerHitStrip"; + //private String MCParticleCollectionName = "MCParticles"; + + + private int runNumber = -1; + + int npositive = 0; + int nnegative = 0; + double ntracks = 0; + double ntracksTop = 0; + double ntracksBottom = 0; + double nTwoTracks = 0; + double nevents = 0; + + double d0Cut = -9999; + + // Flags + boolean electronCut = false; + boolean positronCut = false; + + /** + * Default Constructor + */ + public SvtTrackPlotDriver(){ + } + + public void setEnableElectronCut(boolean electronCut) { + this.electronCut = electronCut; + } + + public void setEnablePositronCut(boolean positronCut) { + this.positronCut = positronCut; + } + + public void setD0Cut(double d0Cut) { + this.d0Cut = d0Cut; + } + + private int computePlotterRegion(HpsSiSensor sensor) { + + if (sensor.getLayerNumber() < 7) { + if (sensor.isTopLayer()) { + return 6*(sensor.getLayerNumber() - 1); + } else { + return 6*(sensor.getLayerNumber() - 1) + 1; + } + } else { + + if (sensor.isTopLayer()) { + if (sensor.getSide() == HpsSiSensor.POSITRON_SIDE) { + return 6*(sensor.getLayerNumber() - 7) + 2; + } else { + return 6*(sensor.getLayerNumber() - 7) + 3; + } + } else if (sensor.isBottomLayer()) { + if (sensor.getSide() == HpsSiSensor.POSITRON_SIDE) { + return 6*(sensor.getLayerNumber() - 7) + 4; + } else { + return 6*(sensor.getLayerNumber() - 7) + 5; + } + } + } + return -1; + } + + protected void detectorChanged(Detector detector){ + + tree = IAnalysisFactory.create().createTreeFactory().create(); + histogramFactory = IAnalysisFactory.create().createHistogramFactory(tree); + + // Get the HpsSiSensor objects from the tracker detector element + sensors = detector.getSubdetector(SUBDETECTOR_NAME) + .getDetectorElement().findDescendants(HpsSiSensor.class); + + // If the detector element had no sensors associated with it, throw + // an exception + if (sensors.size() == 0) { + throw new RuntimeException("No sensors were found in this detector."); + } + + plotters.put("Event Information", plotterFactory.create("Event information")); + plotters.get("Event Information").createRegions(2, 3); + + trackPlots.put("Number of tracks", histogramFactory.createHistogram1D("Number of tracks", 10, 0, 10)); + plotters.get("Event Information").region(0).plot(trackPlots.get("Number of tracks")); + + trackPlots.put("Track charge", histogramFactory.createHistogram1D("Track charge", 3, -1, 2)); + plotters.get("Event Information").region(1).plot(trackPlots.get("Track charge")); + + trackPlots.put("chi2", histogramFactory.createHistogram1D("chi2", 40, 0, 40)); + plotters.get("Event Information").region(2).plot(trackPlots.get("chi2")); + + plotters.put("Track Parameters", plotterFactory.create("Track Parameters")); + plotters.get("Track Parameters").createRegions(4, 4); + + trackPlots.put("doca", histogramFactory.createHistogram1D("doca", 80, -10, 10)); + plotters.get("Track Parameters").region(0).plot(trackPlots.get("doca")); + + trackPlots.put("z0", histogramFactory.createHistogram1D("z0", 80, -2, 2)); + plotters.get("Track Parameters").region(1).plot(trackPlots.get("z0")); + + trackPlots.put("sin(phi0)", histogramFactory.createHistogram1D("sin(phi0)", 40, -0.2, 0.2)); + plotters.get("Track Parameters").region(2).plot(trackPlots.get("sin(phi0)")); + + trackPlots.put("curvature", histogramFactory.createHistogram1D("curvature", 50, -0.001, 0.001)); + plotters.get("Track Parameters").region(3).plot(trackPlots.get("curvature")); + + trackPlots.put("tan_lambda", histogramFactory.createHistogram1D("tan_lambda", 100, -0.1, 0.1)); + plotters.get("Track Parameters").region(4).plot(trackPlots.get("tan_lambda")); + + trackPlots.put("cos(theta)", histogramFactory.createHistogram1D("cos(theta)", 40, -0.1, 0.1)); + plotters.get("Track Parameters").region(5).plot(trackPlots.get("cos(theta)")); + + trackPlots.put("cluster time dt", histogramFactory.createHistogram1D("cluster time dt", 100, -20, 20)); + plotters.get("Track Parameters").region(6).plot(trackPlots.get("cluster time dt")); + + plotters.put("Cluster Amplitude", plotterFactory.create("Cluster Amplitude")); + plotters.get("Cluster Amplitude").createRegions(6, 6); + + plotters.put("Cluster Size", plotterFactory.create("Cluster Size")); + plotters.get("Cluster Size").createRegions(6, 6); + + // Strip hit coordinate + MCPlots.put("simHit_U", histogramFactory.createHistogram1D("simHit_U", 200, -20, 20)); + plotters.get("Track Parameters").region(7).plot(MCPlots.get("simHit_U")); + + MCPlots.put("trackerHit_U", histogramFactory.createHistogram1D("trackerHit_U", 200, -20, 20)); + plotters.get("Track Parameters").region(8).plot(MCPlots.get("trackerHit_U")); + + MCPlots.put("MC_U", histogramFactory.createHistogram1D("MC_U", 200, -20, 20)); + plotters.get("Track Parameters").region(9).plot(MCPlots.get("MC_U")); + + MCPlots.put("trackerHit-MC_U", histogramFactory.createHistogram1D("trackerHit-MC_U", 200, -20, 20)); + plotters.get("Track Parameters").region(10).plot(MCPlots.get("trackerHit-MC_U")); + + MCPlots.put("trackerHit-MC_U_Pull", histogramFactory.createHistogram1D("trackerHit-MC_U_Pull", 200, -20, 20)); + plotters.get("Track Parameters").region(11).plot(MCPlots.get("trackerHit-MC_U_Pull")); + + MCPlots.put("trackerHit-MC_U_Chi2", histogramFactory.createHistogram1D("trackerHit-MC_U_Chi2", 200, -20, 20)); + plotters.get("Track Parameters").region(12).plot(MCPlots.get("trackerHit-MC_U_Chi2")); + + for (HpsSiSensor sensor : sensors) { + + clusterChargePlots.put(sensor.getName(), + histogramFactory.createHistogram1D(sensor.getName() + " - Cluster Charge", 100, 0, 5000)); + plotters.get("Cluster Amplitude").region(this.computePlotterRegion(sensor)) + .plot(clusterChargePlots.get(sensor.getName())); + + clusterSizePlots.put(sensor.getName(), + histogramFactory.createHistogram1D(sensor.getName() + " - Cluster Size", 10, 0, 10)); + plotters.get("Cluster Size").region(this.computePlotterRegion(sensor)) + .plot(clusterSizePlots.get(sensor.getName())); + + } + + //--- Track Extrapolation ---// + //---------------------------// + /*plotters.add(aida.analysisFactory().createPlotterFactory().create("Track Position at Ecal")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("Track Position at Ecal", 200, -350, 350, 200, -100, 100)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style(); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Track Position at Harp")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("Track Position at Harp", 200, -200, 200, 100, -50, 50)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Track Position at Ecal: curvature < 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("Track Position at Ecal: curvature < 0",200, -350, 350, 200, -100, 100)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Track Position at Harp: curvature < 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("Track Position at Harp: curvature < 0", 200, -200, 200, 100, -50, 50)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Track Position at Ecal: curvature > 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("Track Position at Ecal: curvature > 0", 200, -350, 350, 200, -100, 100)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Track Position at Harp: curvature > 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("Track Position at Harp: curvature > 0", 200, -200, 200, 100, -50, 50)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Track Position at Ecal: Two Tracks")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("Track Position at Ecal: Two Tracks", 200, -350, 350, 200, -100, 100)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style(); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Track Position at Harp: Two Tracks")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("Track Position at Harp: Two Tracks", 200, -200, 200, 100, -50, 50)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + nPlotters++; + + + //--- Momentum ---// + //----------------// + plotters.add(aida.analysisFactory().createPlotterFactory().create("Px")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Px", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Py")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Py", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Pz")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Pz", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Px: C > 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Px: C > 0", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Py: C > 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Py: C > 0", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Pz: C > 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Pz: C > 0", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Px: C < 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Px: C < 0", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Py: C < 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Py: C < 0", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Pz: C < 0")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Pz: C < 0", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("Px: Two Tracks")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("Px: Two Tracks", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("E over P")); + plotters.get(nPlotters).region(0).plot(aida.histogram1D("E over P", 100, 0, 5)); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + plotters.get(nPlotters).style().dataStyle().errorBarStyle().setVisible(false); + nPlotters++; + + plotters.add(aida.analysisFactory().createPlotterFactory().create("E versus P")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("E versus P", 100, 0, 1500, 100, 0, 4000)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + nPlotters++; + + //--- Cluster Matching ---// + //------------------------// + plotters.add(aida.analysisFactory().createPlotterFactory().create("XY Difference between Ecal Cluster and Track Position")); + plotters.get(nPlotters).region(0).plot(aida.histogram2D("XY Difference between Ecal Cluster and Track Position", 200, -200, 200, 100, -50, 50)); + plotters.get(nPlotters).region(0).style().setParameter("hist2DStyle", "colorMap"); + plotters.get(nPlotters).region(0).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotters.get(nPlotters).style().statisticsBoxStyle().setVisible(false); + nPlotters++; + */ + for (IPlotter plotter : plotters.values()) { + plotter.show(); + } + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + public void process(EventHeader event){ + nevents++; + + // Get the run number from the event + if (runNumber == -1) runNumber = event.getRunNumber(); + + // If the event doesn't have any tracks, skip it + // if(!event.hasCollection(Track.class, trackCollectionName)) return; + + // If the event doesn't have any SimTrackerHits, skip it + // if(!event.hasCollection(SimTrackerHit.class, TrackerHitsCollectionName)) return; + // If the event doesn't have any SimTrackerHits, skip it + // if(!event.hasCollection(SiTrackerHitStrip1D.class)) return; + + +//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + // Get the local u coordinate from SimTrackerHits + + + // a map of MC hit positions keyed on sensor name + Map<String, List<Double>> mcSensorHitPositionMap = new HashMap<String, List<Double>>(); + // a map of Tracker hit positions keyed on sensor name + Map<String, List<Double>> trackSensorHitPositionMap = new HashMap<String, List<Double>>(); + + // First step is to get the SimTrackerHits and determine their location + // in local coordinates. + List<SimTrackerHit> simHits = event.get(SimTrackerHit.class, "TrackerHits"); + // System.out.println("found " + simHits.size() + " SimTrackerHits"); + // loop over each hit + for (SimTrackerHit hit : simHits) { + // get the hit's position in global coordinates.. + Hep3Vector globalPos = hit.getPositionVec(); + // get the transformation from global to local + ITransform3D g2lXform = hit.getDetectorElement().getGeometry().getGlobalToLocal(); + //System.out.println("transform matrix: " + g2lXform); + IRotation3D rotMat = g2lXform.getRotation(); + //System.out.println("rotation matrix: " + rotMat); + ITranslation3D transMat = g2lXform.getTranslation(); + //System.out.println("translation vector: " + transMat); + // check that we can reproduce the local origin + ITransform3D l2gXform = hit.getDetectorElement().getGeometry().getLocalToGlobal(); + Hep3Vector o = new BasicHep3Vector(); + //System.out.println("origin: " + o); + // tranform the local origin into global position + Hep3Vector localOriginInglobal = l2gXform.transformed(o); + //System.out.println("transformed local to global: " + localOriginInglobal); + // and now back... + //System.out.println("and back: " + g2lXform.transformed(localOriginInglobal)); + // hmmm, so why is this not the same as the translation vector of the transform? + //Note: + // u is the measurement direction perpendicular to the strip + // v is along the strip + // w is normal to the wafer plane + + Hep3Vector localPos = g2lXform.transformed(globalPos); +// System.out.println("Layer: " + hit.getLayer() + " Layer Number: " + hit.getLayerNumber() + " ID: " + hit.getCellID() + " " + hit.getDetectorElement().getName()); +// System.out.println("global position " + globalPos); +// System.out.println("local position " + localPos); + String sensorName = hit.getDetectorElement().getName(); + double u = localPos.x(); + // System.out.println("MC " + hit.getDetectorElement().getName() + " u= " + localPos.x()); + if (mcSensorHitPositionMap.containsKey(sensorName)) { + List<Double> vals = mcSensorHitPositionMap.get(sensorName); + vals.add(u); + } else { + List<Double> vals = new ArrayList<Double>(); + vals.add(u); + mcSensorHitPositionMap.put(sensorName, vals); + } + + MCPlots.get("simHit_U").fill(u); + + } // end of loop over SimTrackerHits + +//TRACKER HITS + setupSensors(event); + RelationalTable hitToStrips = TrackUtils.getHitToStripsTable(event); + RelationalTable hitToRotated = TrackUtils.getHitToRotatedTable(event); + List<Track> tracks = event.get(Track.class, "MatchedTracks"); + // System.out.println("found " + tracks.size() + " tracks"); + for (Track t : tracks) { + List<TrackerHit> hits = t.getTrackerHits(); + // System.out.println("track has " + hits.size() + " hits"); + if (hits.size() == 6) { + for (TrackerHit h : hits) { + Set<TrackerHit> stripList = hitToStrips.allFrom(hitToRotated.from(h)); + for (TrackerHit strip : stripList) { + List rawHits = strip.getRawHits(); + HpsSiSensor sensor = null; + for (Object o : rawHits) { + RawTrackerHit rth = (RawTrackerHit) o; + // TODO figure out why the following collection is always null + //List<SimTrackerHit> stipMCHits = rth.getSimTrackerHits(); + sensor = (HpsSiSensor) rth.getDetectorElement(); + } + int nHitsInCluster = rawHits.size(); + String sensorName = sensor.getName(); + Hep3Vector posG = new BasicHep3Vector(strip.getPosition()); + Hep3Vector posL = sensor.getGeometry().getGlobalToLocal().transformed(posG); + double u = posL.x(); + double mcU = mcSensorHitPositionMap.get(sensorName).get(0); + + // now for the uncertainty in u + SymmetricMatrix covG = new SymmetricMatrix(3, strip.getCovMatrix(), true); + SymmetricMatrix covL = sensor.getGeometry().getGlobalToLocal().transformed(covG); + double sigmaU = sqrt(covL.e(0, 0)); + + MCPlots.get("trackerHit_U").fill(u); + MCPlots.get("MC_U").fill(mcU); + MCPlots.get("trackerHit-MC_U").fill(u-mcU); + MCPlots.get("trackerHit-MC_U_Pull").fill((u-mcU)/sigmaU); + MCPlots.get("trackerHit-MC_U_Chi2").fill(((u-mcU)/sigmaU)*((u-mcU)/sigmaU)); + + + //System.out.println(" Track Hit: " + nHitsInCluster + " " + sensorName + " u " + u + " mcU " + mcU + " sigmaU " + sigmaU); + } + } + } // end of loop over six-hit tracks + } // end of loop over tracks + + + + + + + + + + + + + + +// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + + + + + + + + + + + + + + +//*********************THIS IS JUNK ***************************************************** +// List<SimTrackerHit> OneDHits = event.get(SimTrackerHit.class, "TrackerHits"); +// for(SimTrackerHit OneDHit : OneDHits){ +// +// double umeas = ((TransformableTrackerHit) OneDHit).getTransformedHit(TrackerHitType.CoordinateSystem.SENSOR).getPosition()[0]; +// // Hep3Vector v = OneDStrip.; +// // HelicalTrackStrip strip = makeDigiStrip(OneDStrips); + +// MCPlots.get("umeas").fill(umeas); + +// } + + + // Get the collection of SimTrackerHits from the event + // List<SimTrackerHit> hits = event.get(SimTrackerHit.class, TrackerHitsCollectionName); + + // for(SimTrackerHit hit : hits){ + + // double[] hitPosition = hit.getPosition(); + // double MCPosition_x = hit.getMCParticle(); + + // MCPlots.get("umeas").fill(MCPosition_x); + //hitPosition[0] + + + // } + + // ************************** THIS IS JUNK ************************************************************************ + + + + // Get the collection of LCRelations between a stereo hit and the strips making it up +// List<LCRelation> stereoHitRelations = event.get(LCRelation.class, stereoHitRelationsColName); +// BaseRelationalTable stereoHitToClusters = new BaseRelationalTable(RelationalTable.Mode.MANY_TO_MANY, RelationalTable.Weighting.UNWEIGHTED); +// for (LCRelation relation : stereoHitRelations) { +// if (relation != null && relation.getFrom() != null && relation.getTo() != null) { +// stereoHitToClusters.add(relation.getFrom(), relation.getTo()); + // } + // } + + // Get the collection of LCRelations relating RotatedHelicalTrackHits to + // HelicalTrackHits + // List<LCRelation> rotatedHthToHthRelations = event.get(LCRelation.class, rotatedHthRelationsColName); + // BaseRelationalTable hthToRotatedHth = new BaseRelationalTable(RelationalTable.Mode.ONE_TO_ONE, RelationalTable.Weighting.UNWEIGHTED); + // for (LCRelation relation : rotatedHthToHthRelations) { + // if (relation != null && relation.getFrom() != null && relation.getTo() != null) { + // hthToRotatedHth.add(relation.getFrom(), relation.getTo()); + // } + // } + + // Get the list of fitted hits from the event +// List<LCRelation> fittedHits = event.get(LCRelation.class, fittedHitsCollectionName); + + // Map the fitted hits to their corresponding raw hits +// this.mapFittedRawHits(fittedHits); + + trackPlots.get("Number of tracks").fill(tracks.size()); + + // Loop over all of the tracks in the event + for(Track track : tracks){ + + //if (TrackUtils.getR(track) < 0 && electronCut) continue; + + //if (TrackUtils.getR(track) > 0 && positronCut) continue; + + //if (d0Cut != -9999 && Math.abs(TrackUtils.getDoca(track)) < d0Cut) continue; + + trackPlots.get("Track charge").fill(TrackUtils.getR(track), 1); + + // Fill the track parameter plots + trackPlots.get("doca").fill(TrackUtils.getDoca(track)); + trackPlots.get("z0").fill(TrackUtils.getZ0(track)); + trackPlots.get("sin(phi0)").fill(TrackUtils.getPhi0(track)); + trackPlots.get("curvature").fill(TrackUtils.getR(track)); + trackPlots.get("tan_lambda").fill(TrackUtils.getTanLambda(track)); + trackPlots.get("cos(theta)").fill(TrackUtils.getCosTheta(track)); + trackPlots.get("chi2").fill(track.getChi2()); + } + } + // for (TrackerHit rotatedStereoHit : track.getTrackerHits()) { + + // Get the HelicalTrackHit corresponding to the RotatedHelicalTrackHit + // associated with a track +// Set<TrackerHit> clusters = stereoHitToClusters.allFrom(hthToRotatedHth.from(rotatedStereoHit)); + +// int clusterIndex = 0; +// double clusterTimeDt = 0; +// for (TrackerHit cluster : clusters) { + +// if (clusterIndex == 0) { +// clusterTimeDt += cluster.getTime(); +// clusterIndex++; + // } else { + // clusterTimeDt -= cluster.getTime(); + // } + + // double amplitude = 0; + // HpsSiSensor sensor = null; + // for (Object rawHitObject : cluster.getRawHits()) { + // RawTrackerHit rawHit = (RawTrackerHit) rawHitObject; + + // sensor = (HpsSiSensor) rawHit.getDetectorElement(); + + // Get the channel of the raw hit + //int channel = rawHit.getIdentifierFieldValue("strip"); + + // Add the amplitude of that channel to the total amplitude + // amplitude += FittedRawTrackerHit.getAmp(this.getFittedHit(rawHit)); + // } + + // clusterChargePlots.get(sensor.getName()).fill(amplitude); + // clusterSizePlots.get(sensor.getName()).fill(cluster.getRawHits().size()); + // } + + // trackPlots.get("cluster time dt").fill(clusterTimeDt); + // } + // } + // } + + public void endOfData() { + + String rootFile = "run" + runNumber + "_track_analysis.root"; + RootFileStore store = new RootFileStore(rootFile); + try { + store.open(); + store.add(tree); + store.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + /** + * Method that creates a map between a fitted raw hit and it's corresponding raw fit + * + * @param fittedHits : List of fitted hits to map + */ +// private void mapFittedRawHits(List<LCRelation> fittedHits) { + + // Clear the fitted raw hit map of old values +// fittedRawTrackerHitMap.clear(); + + // Loop through all fitted hits and map them to their corresponding raw hits + // for (LCRelation fittedHit : fittedHits) { + // fittedRawTrackerHitMap.put(FittedRawTrackerHit.getRawTrackerHit(fittedHit), fittedHit); + // } + // } + + /** + * + * @param rawHit + * @return + */ +// private LCRelation getFittedHit(RawTrackerHit rawHit) { +// return fittedRawTrackerHitMap.get(rawHit); +// } + + + + + // Setup Sensors to use + private void setupSensors(EventHeader event) + { + List<RawTrackerHit> rawTrackerHits = null; + if (event.hasCollection(RawTrackerHit.class, "SVTRawTrackerHits")) { + rawTrackerHits = event.get(RawTrackerHit.class, "SVTRawTrackerHits"); + } + if (event.hasCollection(RawTrackerHit.class, "RawTrackerHitMaker_RawTrackerHits")) { + rawTrackerHits = event.get(RawTrackerHit.class, "RawTrackerHitMaker_RawTrackerHits"); + } + EventHeader.LCMetaData meta = event.getMetaData(rawTrackerHits); + // Get the ID dictionary and field information. + IIdentifierDictionary dict = meta.getIDDecoder().getSubdetector().getDetectorElement().getIdentifierHelper().getIdentifierDictionary(); + int fieldIdx = dict.getFieldIndex("side"); + int sideIdx = dict.getFieldIndex("strip"); + for (RawTrackerHit hit : rawTrackerHits) { + // The "side" and "strip" fields needs to be stripped from the ID for sensor lookup. + IExpandedIdentifier expId = dict.unpack(hit.getIdentifier()); + expId.setValue(fieldIdx, 0); + expId.setValue(sideIdx, 0); + IIdentifier strippedId = dict.pack(expId); + // Find the sensor DetectorElement. + List<IDetectorElement> des = DetectorElementStore.getInstance().find(strippedId); + if (des == null || des.size() == 0) { + throw new RuntimeException("Failed to find any DetectorElements with stripped ID <0x" + Long.toHexString(strippedId.getValue()) + ">."); + } else if (des.size() == 1) { + hit.setDetectorElement((SiSensor) des.get(0)); + } else { + // Use first sensor found, which should work unless there are sensors with duplicate IDs. + for (IDetectorElement de : des) { + if (de instanceof SiSensor) { + hit.setDetectorElement((SiSensor) de); + break; + } + } + } + // No sensor was found. + if (hit.getDetectorElement() == null) { + throw new RuntimeException("No sensor was found for hit with stripped ID <0x" + Long.toHexString(strippedId.getValue()) + ">."); + } + } + } +} + + + /* + ntracks++; + Hep3Vector positionEcal = TrackUtils.getTrackPositionAtEcal(track); + System.out.println("Position at Ecal: " + positionEcal); + Hep3Vector positionConverter = TrackUtils.extrapolateTrack(track,-700); + + aida.histogram2D("Track Position at Ecal").fill(positionEcal.y(), positionEcal.z()); + aida.histogram2D("Track Position at Harp").fill(positionConverter.y(), positionConverter.z()); + + if(positionEcal.z() > 0 ) ntracksTop++; + else if(positionEcal.z() < 0) ntracksBottom++; + */ + + + /* + aida.histogram1D("Px").fill(track.getTrackStates().get(0).getMomentum()[0]); + aida.histogram1D("Py").fill(track.getTrackStates().get(0).getMomentum()[1]); + aida.histogram1D("Pz").fill(track.getTrackStates().get(0).getMomentum()[2]); + aida.histogram1D("ChiSquared").fill(track.getChi2()); + + if(Math.signum(TrackUtils.getR(track)) < 0){ + aida.histogram2D("Track Position at Ecal: curvature < 0").fill(positionEcal.y(), positionEcal.z()); + aida.histogram2D("Track Position at Harp: curvature < 0").fill(positionConverter.y(), positionConverter.z()); + aida.histogram1D("Px: C < 0").fill(track.getTrackStates().get(0).getMomentum()[0]); + aida.histogram1D("Py: C < 0").fill(track.getTrackStates().get(0).getMomentum()[1]); + aida.histogram1D("Pz: C < 0").fill(track.getTrackStates().get(0).getMomentum()[2]); + nnegative++; + } else if(Math.signum(TrackUtils.getR(track)) > 0){ + aida.histogram2D("Track Position at Ecal: curvature > 0").fill(positionEcal.y(), positionEcal.z()); + aida.histogram2D("Track Position at Harp: curvature > 0").fill(positionConverter.y(), positionConverter.z()); + aida.histogram1D("Px: C > 0").fill(track.getTrackStates().get(0).getMomentum()[0]); + aida.histogram1D("Px: C > 0").fill(track.getTrackStates().get(0).getMomentum()[1]); + aida.histogram1D("Px: C > 0").fill(track.getTrackStates().get(0).getMomentum()[2]); + npositive++; + } + + if(tracks.size() > 1){ + aida.histogram2D("Track Position at Ecal: Two Tracks").fill(positionEcal.y(), positionEcal.z()); + aida.histogram2D("Track Position at Harp: Two Tracks").fill(positionConverter.y(), positionConverter.z()); + aida.histogram1D("Px: Two Tracks").fill(track.getTrackStates().get(0).getMomentum()[0]); + if(tracks.size() == 2) nTwoTracks++; + } + + trackToEcalPosition.put(positionEcal, track); + ecalPos.add(positionEcal); + } + + if(!event.hasCollection(Cluster.class, "EcalClusters")) return; + List<Cluster> clusters = event.get(Cluster.class, "EcalClusters"); + + + for(Hep3Vector ecalP : ecalPos){ + double xdiff = 1000; + double ydiff = 1000; + for(Cluster cluster : clusters){ + double xd = ecalP.y() - cluster.getPosition()[0]; + double yd = ecalP.z() - cluster.getPosition()[1]; + if(yd < ydiff){ + xdiff = xd; + ydiff = yd; + trackToCluster.put(trackToEcalPosition.get(ecalP),cluster); + } + } + clusters.remove(trackToCluster.get(trackToEcalPosition.get(ecalP))); + aida.histogram2D("XY Difference between Ecal Cluster and Track Position").fill(xdiff, ydiff); + } + + for(Map.Entry<Track, Cluster> entry : trackToCluster.entrySet()){ + double Energy = entry.getValue().getEnergy(); + Track track = entry.getKey(); + double pTotal = Math.sqrt(track.getTrackStates().get(0).getMomentum()[0]*track.getTrackStates().get(0).getMomentum()[0] + track.getTrackStates().get(0).getMomentum()[1]*track.getTrackStates().get(0).getMomentum()[1] + track.getTrackStates().get(0).getMomentum()[2]*track.getTrackStates().get(0).getMomentum()[2]); + + double ep = Energy/(pTotal*1000); + + System.out.println("Energy: " + Energy + "P: " + pTotal + " E over P: " + ep); + + aida.histogram1D("E over P").fill(ep); + aida.histogram2D("E versus P").fill(Energy, pTotal*1000); + } + + for(Cluster cluster : clusters){ + double[] clusterPosition = cluster.getPosition(); + + System.out.println("Cluster Position: [" + clusterPosition[0] + ", " + clusterPosition[1] + ", " + clusterPosition[2]+ "]"); + } + + double ratio = nnegative/npositive; + System.out.println("Ratio of Negative to Position Tracks: " + ratio); + + double tracksRatio = ntracks/nevents; + double tracksTopRatio = ntracksTop/nevents; + double tracksBottomRatio = ntracksBottom/nevents; + double twoTrackRatio = nTwoTracks/nevents; + System.out.println("Number of tracks per event: " + tracksRatio); + System.out.println("Number of top tracks per event: " + tracksTopRatio); + System.out.println("Number of bottom tracks per event: " + tracksBottomRatio); + System.out.println("Number of two track events: " + twoTrackRatio); + }*/ + +