Author: [log in to unmask]
Date: Fri May 1 17:11:54 2015
New Revision: 2877
Log:
Added diff plots
Modified:
java/trunk/monitoring-drivers/src/main/java/org/hps/monitoring/drivers/svt/GblTrackingReconstructionPlots.java
Modified: java/trunk/monitoring-drivers/src/main/java/org/hps/monitoring/drivers/svt/GblTrackingReconstructionPlots.java
=============================================================================
--- java/trunk/monitoring-drivers/src/main/java/org/hps/monitoring/drivers/svt/GblTrackingReconstructionPlots.java (original)
+++ java/trunk/monitoring-drivers/src/main/java/org/hps/monitoring/drivers/svt/GblTrackingReconstructionPlots.java Fri May 1 17:11:54 2015
@@ -2,7 +2,9 @@
import java.io.IOException;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
@@ -10,15 +12,29 @@
import hep.aida.IHistogram1D;
import hep.aida.IPlotter;
import hep.aida.IPlotterStyle;
-
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import org.hps.analysis.ecal.HPSMCParticlePlotsDriver;
+import org.hps.recon.tracking.TrackUtils;
+import org.hps.recon.tracking.gbl.HpsGblRefitter;
+import org.hps.util.BasicLogFormatter;
+import org.lcsim.constants.Constants;
import org.lcsim.event.EventHeader;
+import org.lcsim.event.MCParticle;
import org.lcsim.event.Track;
+import org.lcsim.event.base.ParticleTypeClassifier;
+import org.lcsim.fit.helicaltrack.HelicalTrackFit;
import org.lcsim.geometry.Detector;
+import org.lcsim.recon.tracking.seedtracker.SeedCandidate;
+import org.lcsim.recon.tracking.seedtracker.SeedTrack;
import org.lcsim.util.Driver;
import org.lcsim.util.aida.AIDA;
+import org.lcsim.util.log.LogUtil;
public class GblTrackingReconstructionPlots extends Driver {
- private Logger logger = getLogger();
+ private double _bfield;
+ private static Logger logger = LogUtil.create(HpsGblRefitter.class, new BasicLogFormatter());
private AIDA aida = AIDA.defaultInstance();
private String outputPlots = null;
private final String trackCollectionName = "MatchedTracks";
@@ -26,12 +42,31 @@
IHistogram1D nTracks;
IHistogram1D nTracksGbl;
IHistogram1D nTracksDiff;
+ IHistogram1D d0Diff;
+ IHistogram1D z0Diff;
+ IHistogram1D phiDiff;
+ IHistogram1D slopeDiff;
+ IHistogram1D rDiff;
+ IHistogram1D d0Diff2;
+ IHistogram1D z0Diff2;
+ IHistogram1D phiDiff2;
+ IHistogram1D slopeDiff2;
+ IHistogram1D rDiff2;
+ IHistogram1D d0DiffGbl;
+ IHistogram1D z0DiffGbl;
+ IHistogram1D phiDiffGbl;
+ IHistogram1D slopeDiffGbl;
+ IHistogram1D rDiffGbl;
IPlotter plotter1;
+ IPlotter plotter2;
+ IPlotter plotter3;
+ IPlotter plotter4;
+
public GblTrackingReconstructionPlots() {
// TODO Auto-generated constructor stub
- logger.setLevel(Level.WARNING);
+ logger.setLevel(Level.INFO);
}
public void setOutputPlots(String output) {
@@ -41,6 +76,11 @@
protected void detectorChanged(Detector detector) {
aida.tree().cd("/");
IAnalysisFactory fac = aida.analysisFactory();
+
+ Hep3Vector bfieldvec = detector.getFieldMap().getField(new BasicHep3Vector(0., 0., 1.));
+ _bfield = bfieldvec.y();
+ //double bfac = 0.0002998 * bfield;
+ //double bfac = Constants.fieldConversion * bfield;
nTracks = aida.histogram1D("Seed tracks per event", 3, 0, 3);
nTracksGbl = aida.histogram1D("Gbl tracks per event", 3, 0, 3);
@@ -56,7 +96,60 @@
plotter1.region(1).plot(nTracksGbl);
plotter1.region(2).plot(nTracksDiff);
plotter1.show();
-
+
+ d0Diff = aida.histogram1D("d0Diff", 25, -1.1, 1.1);
+ z0Diff = aida.histogram1D("z0Diff", 25, -0.8, 0.8);
+ slopeDiff = aida.histogram1D("slopeDiff", 25, -0.01, 0.01);
+ phiDiff = aida.histogram1D("phiDiff", 25, -0.01, 0.01);
+ rDiff = aida.histogram1D("rDiff", 25, -0.0001, 0.0001);
+
+ plotter2 = fac.createPlotterFactory().create("Truth comparison");
+ plotter2.setStyle(style1);
+ plotter2.createRegions(3, 2);
+ plotter2.region(0).plot(d0Diff);
+ plotter2.region(1).plot(z0Diff);
+ plotter2.region(2).plot(phiDiff);
+ plotter2.region(3).plot(slopeDiff);
+ plotter2.region(4).plot(rDiff);
+ plotter2.show();
+
+
+ d0DiffGbl = aida.histogram1D("d0DiffGbl", 25, -1.1, 1.1);
+ z0DiffGbl = aida.histogram1D("z0DiffGbl", 25, -0.8, 0.8);
+ slopeDiffGbl = aida.histogram1D("slopeDiffGbl", 25, -0.01, 0.01);
+ phiDiffGbl = aida.histogram1D("phiDiffGbl", 25, -0.01, 0.01);
+ rDiffGbl = aida.histogram1D("rDiffGbl", 25, -0.0001, 0.0001);
+
+
+ plotter3 = fac.createPlotterFactory().create("Truth comparison GBL");
+ plotter3.setStyle(style1);
+ plotter3.createRegions(3, 2);
+ plotter3.region(0).plot(d0DiffGbl);
+ plotter3.region(1).plot(z0DiffGbl);
+ plotter3.region(2).plot(phiDiffGbl);
+ plotter3.region(3).plot(slopeDiffGbl);
+ plotter3.region(4).plot(rDiffGbl);
+ plotter3.show();
+
+
+ d0Diff2 = aida.histogram1D("d0Diff2", 25, -1.1, 1.1);
+ z0Diff2 = aida.histogram1D("z0Diff2", 25, -0.8, 0.8);
+ slopeDiff2 = aida.histogram1D("slopeDiff2", 25, -0.01, 0.01);
+ phiDiff2 = aida.histogram1D("phiDiff2", 25, -0.01, 0.01);
+ rDiff2 = aida.histogram1D("rDiff2", 25, -0.0001, 0.0001);
+
+
+ plotter4 = fac.createPlotterFactory().create("Seed vs GBL");
+ plotter4.setStyle(style1);
+ plotter4.createRegions(3, 2);
+ plotter4.region(0).plot(d0Diff2);
+ plotter4.region(1).plot(z0Diff2);
+ plotter4.region(2).plot(phiDiff2);
+ plotter4.region(3).plot(slopeDiff2);
+ plotter4.region(4).plot(rDiff2);
+ plotter4.show();
+
+
}
@@ -76,9 +169,123 @@
logger.warning("no gbl track collection");
gblTracks = new ArrayList<Track>();
}
+
+ List<MCParticle> mcparticles;
+ List<MCParticle> fsParticles;
+ if( event.hasCollection(MCParticle.class) ) {
+ mcparticles = event.get(MCParticle.class).get(0);
+ fsParticles = HPSMCParticlePlotsDriver.makeGenFSParticleList(mcparticles);
+ } else {
+ logger.warning("no gbl track collection");
+ mcparticles = new ArrayList<MCParticle>();
+ fsParticles = new ArrayList<MCParticle>();
+ }
+
+
+
+
+ logger.info("Number of Tracks = " + tracks.size());
+ logger.info("Number of GBL Tracks = " + gblTracks.size());
+ logger.info("Number of MC particles = " + mcparticles.size());
+ logger.info("Number of FS MC particles = " + fsParticles.size());
+
+
+
+ Map<Track, MCParticle> trackTruthMatch = new HashMap<Track,MCParticle>();
+
+ for(Track track : gblTracks) {
+ MCParticle part = TrackUtils.getMatchedTruthParticle(track);
+ trackTruthMatch.put(track, part);
+ if(part!=null) {
+ logger.info("Match track with q " + track.getCharge() + " p " + track.getMomentum()[0] + "," + track.getMomentum()[1] + "," + track.getMomentum()[2]);
+ } else {
+ logger.info("no match for track with q " + track.getCharge() + " p " + track.getMomentum()[0] + "," + track.getMomentum()[1] + "," + track.getMomentum()[2]);
+ }
+ }
+
+ for(Track track : gblTracks) {
+
+ logger.info("Track:");
+ SeedTrack st = (SeedTrack)track;
+ SeedCandidate seed = st.getSeedCandidate();
+ HelicalTrackFit htf = seed.getHelix();
+// Track seedTrack = null;
+// for(Track trk : tracks) {
+// SeedTrack st2 = (SeedTrack)trk;
+// SeedCandidate s2 = st2.getSeedCandidate();
+// logger.info("");
+// if(seed.equals(s2)) {
+// seedTrack = trk;
+// }
+// }
+// if(seedTrack!=null) {
+// throw new RuntimeException("could;t find the seed track from GBL track");
+// }
+ logger.info(htf.toString());
+ HelicalTrackFit pHTF = null;
+ if(trackTruthMatch.get(track)==null) {
+ logger.info("no truth mc particle for this track");
+ } else {
+ pHTF = TrackUtils.getHTF(trackTruthMatch.get(track),-1*_bfield);
+ logger.info("part: " + trackTruthMatch.get(track).getPDGID());
+ logger.info("pHTF:");
+ logger.info(pHTF.toString());
+ }
+
+
+
+
+ double d0 = htf.dca();
+ double z0 = htf.z0();
+ double C = htf.curvature();
+ double phi = htf.phi0();
+ double slope = htf.slope();
+
+ double d0Gbl = track.getTrackStates().get(0).getD0();
+ double z0Gbl = track.getTrackStates().get(0).getZ0();
+ double CGbl = track.getTrackStates().get(0).getOmega();
+ double phiGbl = track.getTrackStates().get(0).getPhi();
+ double slopeGbl = track.getTrackStates().get(0).getTanLambda();
+
+ if(pHTF!=null) {
+ double d0Truth = pHTF.dca();
+ double z0Truth = pHTF.z0();
+ double CTruth = pHTF.curvature();
+ double phiTruth = pHTF.phi0();
+ double slopeTruth = pHTF.slope();
+ logger.info("d0 " + d0 + " d0 trugh " + d0Truth);
+ d0Diff.fill(d0-d0Truth);
+ z0Diff.fill(z0-z0Truth);
+ phiDiff.fill(phi-phiTruth);
+ rDiff.fill(C-CTruth);
+ slopeDiff.fill(slope-slopeTruth);
+
+ d0DiffGbl.fill(d0Gbl-d0Truth);
+ z0DiffGbl.fill(z0Gbl-z0Truth);
+ phiDiffGbl.fill(phiGbl-phiTruth);
+ rDiffGbl.fill(CGbl-CTruth);
+ slopeDiffGbl.fill(slopeGbl-slopeTruth);
+ }
+
+
+ d0Diff2.fill(d0-d0Gbl);
+ z0Diff2.fill(z0-z0Gbl);
+ phiDiff2.fill(phi-phiGbl);
+ rDiff2.fill(C-CGbl);
+ slopeDiff2.fill(slope-slopeGbl);
+
+
+ }
+
+
+
+
+
nTracks.fill(tracks.size());
nTracksGbl.fill(gblTracks.size());
nTracksDiff.fill(tracks.size()-gblTracks.size());
+
+
}
|
