LISTSERV 16.5 - LCD-CVS Archives

MonitoringPlotsDriver.java added at 1.1

diff -N MonitoringPlotsDriver.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ MonitoringPlotsDriver.java	29 Apr 2012 23:20:24 -0000	1.1
@@ -0,0 +1,255 @@

+package org.lcsim.hps.monitoring;
+
+import hep.aida.IAnalysisFactory;
+import hep.aida.IBaseHistogram;
+import hep.aida.ICloud1D;
+import hep.aida.IHistogram1D;
+import hep.aida.IManagedObject;
+import hep.aida.IPlotter;
+import hep.aida.IPlotterStyle;
+import hep.aida.ITree;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.lcsim.detector.tracker.silicon.SiSensor;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.RawCalorimeterHit;
+import org.lcsim.event.RawTrackerHit;
+import org.lcsim.event.Track;
+import org.lcsim.event.TrackerHit;
+import org.lcsim.geometry.Detector;
+import org.lcsim.util.Driver;
+import org.lcsim.util.aida.AIDA;
+
+// TODO Add Histogram2D of ECal cells.  Can plot as color map.
+public class MonitoringPlotsDriver extends Driver implements Resettable {
+        
+    private Map<SiSensor,int[]> occupancyMap;   
+    private IPlotter occuPlot;  
+    private List<IPlotter> plotters = new ArrayList<IPlotter>();
+    private AIDA aida = AIDA.defaultInstance();
+    private String rawTrackerHitCollectionName = "RawTrackerHitMaker_RawTrackerHits";
+    private String rawCalorimeterHitCollectionName = "EcalRawHits";
+    private String trackerHitCollectionName = "StripClusterer_SiTrackerHitStrip1D";    
+    private String trackerName = "Tracker";
+    private int eventCount;  
+    private Detector detector = null;
+    
+    private IHistogram1D adcValuePlot; 
+    private IHistogram1D rawHitCountPlot;
+    private IHistogram1D tkrHitCountPlot;            
+    private IHistogram1D tkrCountPlot;
+    private ICloud1D hitsPerTrackPlot;
+    private IHistogram1D tkrMomXPlot;
+    private IHistogram1D tkrMomYPlot;
+    private IHistogram1D tkrMomZPlot;
+    private IHistogram1D tkrMomPlot;
+    private ICloud1D timePlot;
+    private ICloud1D ecalTimePlot;
+    private ICloud1D ecalAmplitudePlot;
+    private ICloud1D ecalHitsPlot;
+    
+    protected void detectorChanged(Detector detector) {
+        
+        this.detector = detector;
+        
+        aida.tree().cd("/");
+        adcValuePlot = aida.histogram1D("ADC Value", 500, 0, 500); 
+        rawHitCountPlot = aida.histogram1D("Number of RawTrackerHits in Event", 100, 0, 100);                        
+        tkrHitCountPlot = aida.histogram1D("Number of TrackerHits in Event", 50, 0, 50);            
+        tkrCountPlot = aida.histogram1D("Number of Tracks in Event", 20, 0, 20);
+        hitsPerTrackPlot = aida.cloud1D("Number of Hits per Track");
+        tkrMomXPlot = aida.histogram1D("Track Px", 200, 0, 2.0);
+        tkrMomYPlot = aida.histogram1D("Track Py", 160, -0.2, 0.2);
+        tkrMomZPlot = aida.histogram1D("Track Pz", 160, -0.2, 0.2);
+        tkrMomPlot = aida.histogram1D("Track P", 200, 0, 4.0);
+        timePlot = aida.cloud1D("Time [ns]");
+                    
+        IAnalysisFactory fac = aida.analysisFactory();
+        IPlotter plotter = fac.createPlotterFactory().create("HPS SVT Plots");
+        plotters.add(plotter);
+        plotter.style().dataStyle().errorBarStyle().setVisible(false);
+        plotter.createRegions(4,4);
+        plotter.region(0).plot(adcValuePlot);
+        plotter.region(1).plot(rawHitCountPlot);
+        plotter.region(2).plot(tkrHitCountPlot);
+        plotter.region(3).plot(tkrCountPlot);
+        plotter.region(4).plot(hitsPerTrackPlot);
+        plotter.region(5).plot(tkrMomXPlot);
+        plotter.region(6).plot(tkrMomYPlot);
+        plotter.region(7).plot(tkrMomZPlot);
+        plotter.region(8).plot(tkrMomPlot);
+        plotter.region(9).plot(timePlot);
+        plotter.show();
+                                
+        // Make a list of sensors in the SVT.
+        List<SiSensor> sensors = detector.getSubdetector(trackerName).getDetectorElement().findDescendants(SiSensor.class);            
+        
+        // Setup occupancy plots.
+        IPlotter plotter2 = fac.createPlotterFactory().create("HPS SVT Sensor Occupancy Plots");
+        plotters.add(plotter2);
+        IPlotterStyle style = plotter2.style();
+        style.dataStyle().fillStyle().setColor("yellow");
+        style.dataStyle().errorBarStyle().setVisible(false);
+        plotter2.createRegions(5, 4);
+        int ns = sensors.size();
+        for (int i=0; i<ns; i++) {
+            IHistogram1D occupancyPlot = aida.histogram1D(sensors.get(i).getName(), 640, 0, 639);
+            plotter2.region(i).plot(occupancyPlot);
+        }
+        plotter2.show();
+        
+        // Data structure for occupancy calculations by sensor.
+        occupancyMap = new HashMap<SiSensor,int[]>();
+        for (SiSensor sensor : sensors) {
+            occupancyMap.put(sensor, new int[640]);
+        }
+        
+        // Normalized occupancy plots are only setup the first time. 
+        if (occuPlot == null) {
+            IPlotter plotter3 = fac.createPlotterFactory().create("HPS SVT Normalized Sensor Occupancy Plots");
+            occuPlot = plotter3;
+            IPlotterStyle style3 = plotter3.style();
+            style3.dataStyle().fillStyle().setColor("green");
+            style3.dataStyle().markerStyle().setColor("green");
+            style3.dataStyle().errorBarStyle().setVisible(false);
+            style3.statisticsBoxStyle().setVisible(false);
+            plotter3.createRegions(5, 4);
+            for (int i=0; i<ns; i++) {
+                IHistogram1D occupancyPlot = aida.histogram1D(sensors.get(i).getName() + " Normalized", 640, 0, 639);
+                plotter3.region(i).plot(occupancyPlot);
+            }
+            plotter3.show();
+        }
+        
+        // Ecal plots.
+        IPlotter plotter4 = fac.createPlotterFactory().create("HPS ECAL Plots");
+        plotters.add(plotter4);
+        ecalTimePlot = aida.cloud1D("Timestamp");
+        ecalAmplitudePlot = aida.cloud1D("Amplitude");
+        ecalHitsPlot = aida.cloud1D("Number of Hits");
+        plotter4.createRegions(2, 2);
+        plotter4.region(0).plot(ecalTimePlot);
+        plotter4.region(1).plot(ecalAmplitudePlot);
+        plotter4.region(2).plot(ecalHitsPlot);
+        plotter4.show();
+    }
+    
+    public MonitoringPlotsDriver()
+    {}
+    
+    public void setRawTrackerHitCollectionName(String rawTrackerHitCollectionName) {
+        this.rawTrackerHitCollectionName = rawTrackerHitCollectionName;
+    }
+    
+    public void setRawCalorimeterHitCollectionName(String rawCalorimeterHitCollectionName) {
+        this.rawCalorimeterHitCollectionName = rawCalorimeterHitCollectionName;
+    }
+    
+    public void setTrackerHitCollectionName(String trackerHitCollectionName) {
+        this.trackerHitCollectionName = trackerHitCollectionName;
+    }
+    
+    // Call this to reset if "reset" button is pressed on monitoring GUI.
+    public void reset() {
+        for (IPlotter plotter : plotters) {
+            plotter.hide();
+            plotter.clearRegions();
+        }
+        plotters.clear();
+        clearAidaTree();
+        detectorChanged(detector);
+        eventCount = 0;
+    }
+    
+    private void clearAidaTree() {
+        ITree tree = AIDA.defaultInstance().tree();
+        String names[] = tree.listObjectNames("/", true);
+        for (String name : names) {            
+            IManagedObject o = tree.find(name);
+            if (o instanceof IBaseHistogram) {
+                ((IBaseHistogram) o).reset();
+            }
+        }
+    }
+     
+    public void process(EventHeader event) {
+
+        ++eventCount;
+
+        // Get collections from event.
+        List<RawTrackerHit> rawTrackerHits = event.get(RawTrackerHit.class, rawTrackerHitCollectionName);
+        List<RawCalorimeterHit> rawCalorimeterHits = event.get(RawCalorimeterHit.class, rawCalorimeterHitCollectionName);
+
+        // Make ECal plots.
+        fillEcalPlots(aida, rawCalorimeterHits);
+
+        // Fill RawTrackerHit count.
+        rawHitCountPlot.fill(rawTrackerHits.size());
+
+        // Loop over RawTrackerHit collection.
+        for (RawTrackerHit hit : rawTrackerHits) {
+
+            // Fill ADC value plot.
+            adcValuePlot.fill(hit.getADCValues()[0]);
+
+            // Fill time plot.
+            timePlot.fill(hit.getTime());
+
+            // Fill basic (non-normalized) occupancy plot.
+            aida.histogram1D(hit.getDetectorElement().getName()).fill(hit.getIdentifierFieldValue("strip"));
+
+            // Increment hit counts for occupancy calculations.
+            int[] strips = occupancyMap.get((SiSensor) hit.getDetectorElement());
+            strips[hit.getIdentifierFieldValue("strip")] += 1;
+        }
+
+        // Normalized occupancy plots.
+        occuPlot.clearRegions();
+        int si = 0;
+        for (SiSensor sensor : occupancyMap.keySet()) {
+            int[] strips = occupancyMap.get(sensor);
+            aida.histogram1D(sensor.getName() + " Normalized").reset();
+            for (int i = 0; i < strips.length; i++) {
+                double stripOccupancy = (double) strips[i] / (double) (eventCount + 1);
+                if (stripOccupancy != 0) {
+                    aida.histogram1D(sensor.getName() + " Normalized").fill(i, stripOccupancy);
+                }
+            }
+            occuPlot.region(si).plot(aida.histogram1D(sensor.getName() + " Normalized"));
+            ++si;
+        }
+        occuPlot.show();
+
+        // Get Track list from event.  This breaks if > 1 Track collections are generated by LCSim.
+        List<Track> tracks = event.get(Track.class).get(0);
+
+        // Plot number of Tracks.
+        tkrCountPlot.fill(tracks.size());
+
+        // Track plots.
+        for (Track track : tracks) {
+            aida.cloud1D("Number of Hits per Track").fill(track.getTrackerHits().size());
+            tkrMomXPlot.fill(track.getPX());
+            tkrMomYPlot.fill(track.getPY());
+            tkrMomZPlot.fill(track.getPZ());
+            double[] p = track.getMomentum();
+            tkrMomPlot.fill(Math.sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]));
+        }
+
+        // Number of TrackerHits.
+        List<TrackerHit> trackerHits = event.get(TrackerHit.class, trackerHitCollectionName);
+        tkrHitCountPlot.fill(trackerHits.size());
+    }      
+    
+    private void fillEcalPlots(AIDA aida, List<RawCalorimeterHit> hits) {
+        ecalHitsPlot.fill(hits.size());
+        for (RawCalorimeterHit hit : hits) {
+            ecalTimePlot.fill(hit.getTimeStamp());   
+            ecalAmplitudePlot.fill(hit.getAmplitude());
+        }
+    }
+}

\ No newline at end of file

Commit in `hps-java/sandbox` on MAIN
`MonitoringPlotsDriver.java`	+255		added 1.1