diff --git a/analysis/.gitignore b/analysis/.gitignore new file mode 100644 index 0000000000..ae3c172604 --- /dev/null +++ b/analysis/.gitignore @@ -0,0 +1 @@ +/bin/ diff --git a/online-monitoring/src/main/java/org/hps/monitoring/application/Commands.java b/online-monitoring/src/main/java/org/hps/monitoring/application/Commands.java index 7c5100b2b8..cec5f12f6f 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/application/Commands.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/application/Commands.java @@ -1,7 +1,8 @@ package org.hps.monitoring.application; /** - * These strings are used to identify ActionEvent commands in the MonitoringApplication. + * These strings are used to identify ActionEvent commands in the + * MonitoringApplication. */ final class Commands { @@ -51,7 +52,8 @@ final class Commands { static final String DATA_SOURCE_CHANGED = "dataSourceChanged"; /** - * Reset the application window to its default settings including scroll pane positions. + * Reset the application window to its default settings including scroll + * pane positions. */ static final String DEFAULT_WINDOW = "defaultWindow"; @@ -154,7 +156,7 @@ final class Commands { * Action when plot is selected from a tab. */ static final String PLOT_SELECTED = "PlotSelected"; - + /** * Enable plot pop-up window. */ @@ -166,7 +168,8 @@ final class Commands { static final String PROCESSING_STAGE_CHANGED = "processingStageChanged"; /** - * Select one of the items from the recent files list to be the current data source. + * Select one of the items from the recent files list to be the current data + * source. */ static final String RECENT_FILE_SELECTED = "recentFileSelected"; @@ -185,6 +188,11 @@ final class Commands { */ static final String SAVE_PLOTS = "savePlots"; + /** + * Save the plots to a ROOT, AIDA or PDF file. + */ + static final String SAVE_ROOT_AND_PDF = "savePlotsRootPdf"; + /** * Save a screenshot from the window graphics. */ diff --git a/online-monitoring/src/main/java/org/hps/monitoring/application/EventButtonsPanel.java b/online-monitoring/src/main/java/org/hps/monitoring/application/EventButtonsPanel.java index afd7f554e8..12a9b641af 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/application/EventButtonsPanel.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/application/EventButtonsPanel.java @@ -16,7 +16,8 @@ import org.hps.monitoring.application.model.ConnectionStatusModel; /** - * This is the panel with buttons for connecting or disconnecting from the session and controlling the application when + * This is the panel with buttons for connecting or disconnecting from the + * session and controlling the application when * event processing is paused. */ @SuppressWarnings("serial") @@ -53,6 +54,11 @@ static ImageIcon getImageIcon(final String resource) { return new ImageIcon(image); } + /** + * Button for saving PDF & root files + */ + private final JButton saveButton; + /** * Button for connect and disconnect which is toggled depending on state. */ @@ -84,6 +90,7 @@ static ImageIcon getImageIcon(final String resource) { connectionModel.addPropertyChangeListener(this); setLayout(new FlowLayout()); + this.saveButton = addButton("/monitoringButtonGraphics/icons8-multicast-64.png", Commands.SAVE_ROOT_AND_PDF, listener, true); this.connectButton = addButton(DISCONNECTED_ICON, Commands.CONNECT, listener, true); this.resumeButton = addButton("/toolbarButtonGraphics/media/Play24.gif", Commands.RESUME, listener, false); this.pauseButton = addButton("/toolbarButtonGraphics/media/Pause24.gif", Commands.PAUSE, listener, false); @@ -125,7 +132,8 @@ private JButton addButton(final String resource, final String actionCommand, fin } /** - * Handle property change events to set status from changes to the connection status model. + * Handle property change events to set status from changes to the + * connection status model. * * @param evt the PropertyChangeEvent to handle */ diff --git a/online-monitoring/src/main/java/org/hps/monitoring/application/MonitoringApplication.java b/online-monitoring/src/main/java/org/hps/monitoring/application/MonitoringApplication.java index b49177692b..4f0e8ff936 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/application/MonitoringApplication.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/application/MonitoringApplication.java @@ -18,6 +18,8 @@ import java.io.IOException; import java.io.OutputStream; import java.io.PrintStream; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; import java.util.ArrayList; import java.util.Date; import java.util.List; @@ -60,9 +62,11 @@ import org.lcsim.util.log.DefaultLogFormatter; /** - * This is the primary class that implements the data monitoring GUI application. + * This is the primary class that implements the data monitoring GUI + * application. *

- * It should not be used directly. Instead the {@link Main} class should be used from the command line. + * It should not be used directly. Instead the {@link Main} class should be used + * from the command line. * */ final class MonitoringApplication implements ActionListener, PropertyChangeListener { @@ -99,7 +103,8 @@ public void publish(final LogRecord record) { } /** - * Log handler which publishes messages to a stream (console or file in this case). + * Log handler which publishes messages to a stream (console or file in this + * case). */ class MonitoringApplicationStreamHandler extends StreamHandler { @@ -217,7 +222,8 @@ static MonitoringApplication create(final Configuration configuration) { private EventProcessing processing; /** - * The model which has information about the current run and events being processed. + * The model which has information about the current run and events being + * processed. */ private final RunModel runModel = new RunModel(); @@ -225,19 +231,21 @@ static MonitoringApplication create(final Configuration configuration) { * The handler for putting messages into the log table. */ private MonitoringApplicationStreamHandler streamHandler; - + /** * Class for displayed a pop-up of selected region. * Initialization is delayed until after AIDA is properly configured. */ private ChartPopup popup = null; - + private boolean plotPopupEnabled = true; - + /** - * Instantiate and show the monitoring application with the given configuration. + * Instantiate and show the monitoring application with the given + * configuration. * - * @param userConfiguration the Configuration object containing application settings + * @param userConfiguration the Configuration object containing application + * settings */ MonitoringApplication(final Configuration userConfiguration) { @@ -309,6 +317,8 @@ public void actionPerformed(final ActionEvent e) { runDisconnectThread(); } else if (Commands.SAVE_PLOTS.equals(command)) { savePlots(); + } else if (Commands.SAVE_ROOT_AND_PDF.equals(command)) { + savePlotsRootPdf(); } else if (Commands.EXIT.equals(command)) { // This will trigger the window closing action that cleans everything up. this.frame.dispose(); @@ -351,10 +361,11 @@ public void actionPerformed(final ActionEvent e) { } else if (Commands.PLOT_POPUP.equals(command)) { this.plotPopupEnabled = ((JCheckBox) e.getSource()).isSelected(); } - } - + } + /** - * Redirect System.out and System.err to a chosen file. + * Redirect System.out and System.err to a chosen + * file. */ private void chooseLogFile() { final JFileChooser fc = new JFileChooser(); @@ -485,7 +496,8 @@ private List getRunData() { } /** - * Get the run model with information about the run and event(s) currently being processed. + * Get the run model with information about the run and event(s) currently + * being processed. * * @return the run model */ @@ -494,10 +506,12 @@ RunModel getRunModel() { } /** - * This method sets the configuration on the model, which fires a change for every property. + * This method sets the configuration on the model, which fires a change for + * every property. * * @param configuration the new configuration - * @param merge true to merge the configuration into the current one rather than replace it + * @param merge true to merge the configuration into the + * current one rather than replace it */ private void loadConfiguration(final Configuration configuration, final boolean merge) { @@ -581,7 +595,8 @@ private void logToFile(final File file) { } /** - * Send System.out and System.err back to the terminal, e.g. if they were previously sent + * Send System.out and System.err back to the + * terminal, e.g. if they were previously sent * to a file. */ private void logToTerminal() { @@ -761,6 +776,53 @@ private void savePlots() { } } + /** + * Save plots to an AIDA, ROOT or PDF file using a file chooser. + */ + private void savePlotsRootPdf() { + int runNum = this.runModel.getRunNumber(); + String stationName = this.configurationModel.getStationName(); + String timestamp = DateTimeFormatter.ofPattern("yyyy-MM-dd:HH:mm:ss").format(LocalDateTime.now()); + String plotsDir=this.configurationModel.getPlotsDir(); + String pdfOut = plotsDir+"/"+stationName + "-run" + runNum + "-" + timestamp + ".pdf"; + String rootOut = plotsDir+"/"+stationName + "-run" + runNum + "-" + timestamp + ".root"; + + final File pdfFile = new File(pdfOut); + final File rootFile = new File(rootOut); + if (!pdfFile.exists()) { + String fileName = pdfFile.getAbsolutePath(); + try { + // Write out all plot graphics from the tabs to a single PDF file. + ExportPdf.write(MonitoringPlotFactory.getPlotterRegistry().getPlotters(), fileName, + getRunData()); + LOGGER.info("saved plots to " + fileName); + DialogUtil.showInfoDialog(this.frame, "Plots Saved", "Plots were successfully saved to " + '\n' + + fileName); + } catch (final IOException e) { + this.errorHandler.setError(e).setMessage("Error Saving Plots").printStackTrace().log() + .showErrorDialog(); + } + } else { + DialogUtil.showErrorDialog(this.frame, "File Exists", "Selected file already exists."); + } + + if (!rootFile.exists()) { + String fileName = rootFile.getAbsolutePath(); + try { + AIDA.defaultInstance().saveAs(fileName); + LOGGER.info("saved plots to " + fileName); + DialogUtil.showInfoDialog(this.frame, "Plots Saved", "Plots were successfully saved to " + '\n' + + fileName); + } catch (final IOException e) { + this.errorHandler.setError(e).setMessage("Error Saving Plots").printStackTrace().log() + .showErrorDialog(); + } + } else { + DialogUtil.showErrorDialog(this.frame, "File Exists", "Selected already exists."); + } + + } + /** * Save a screenshot to a file using a file chooser. */ @@ -805,7 +867,8 @@ private void saveSettings() { } /** - * Export a JTable's data to a comma-delimited text file using a file chooser. + * Export a JTable's data to a comma-delimited text file using a file + * chooser. * * @param table the table to export */ @@ -857,7 +920,7 @@ public void regionSelected(final PlotterRegion region) { if (region != null) { MonitoringApplication.this.frame.getPlotInfoPanel().setCurrentRegion(region); } - + if (plotPopupEnabled) { popup.update(region); } @@ -866,7 +929,7 @@ public void regionSelected(final PlotterRegion region) { // Perform global configuration of the JFreeChart back end. AnalysisFactory.configure(); - + this.popup = new ChartPopup(); } @@ -981,7 +1044,8 @@ private synchronized void startSession() { * Save a screenshot to an output file. * * @param fileName the name of the output file - * @param format the output file format (must be accepted by ImageIO) + * @param format the output file format (must be accepted by + * ImageIO) */ private void writeScreenshot(final String fileName, final String format) { this.frame.repaint(); diff --git a/online-monitoring/src/main/java/org/hps/monitoring/application/model/ConfigurationModel.java b/online-monitoring/src/main/java/org/hps/monitoring/application/model/ConfigurationModel.java index 5d06523279..2f6553f6b0 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/application/model/ConfigurationModel.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/application/model/ConfigurationModel.java @@ -117,6 +117,11 @@ public final class ConfigurationModel extends AbstractModel { */ private static final int MAX_RECENT_FILES = 10; + /** + * The directory to store plots (pdf and root) files in + */ + private static final String PLOTS_DIR_PROPERTY="PlotsDir"; + /** * The ET TCP/IP port. */ @@ -431,7 +436,14 @@ public Boolean getLogToFile() { public Long getMaxEvents() { return this.configuration.getLong(MAX_EVENTS_PROPERTY); } - + /** + * Get the directory to but root and pdf files + * @return directory name + */ + public String getPlotsDir(){ + return this.configuration.get(PLOTS_DIR_PROPERTY); + } + /** * Get the ET TCP/IP port value. * diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/KFTrackRecoHeadless.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/KFTrackRecoHeadless.java new file mode 100644 index 0000000000..d246e39804 --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/KFTrackRecoHeadless.java @@ -0,0 +1,328 @@ +package org.hps.monitoring.drivers.headless; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; + +import org.hps.recon.ecal.HodoUtils; +import org.hps.recon.ecal.SimpleGenericObject; +import org.hps.recon.tracking.CoordinateTransformations; +import org.hps.recon.tracking.TrackUtils; +import org.lcsim.detector.DetectorElement; +import org.lcsim.detector.identifier.IIdentifier; +import org.lcsim.detector.identifier.Identifier; +import org.lcsim.event.Cluster; +import org.lcsim.event.EventHeader; +import org.lcsim.event.LCIOParameters.ParameterName; +import org.lcsim.event.Track; +import org.lcsim.event.TrackState; +import org.lcsim.geometry.Detector; +import org.lcsim.geometry.IDDecoder; +import org.lcsim.util.Driver; +import org.lcsim.util.aida.AIDA; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogram2D; +import hep.aida.IPlotter; +import hep.aida.IPlotterFactory; +import hep.physics.vec.BasicHep3Vector; +import hep.physics.vec.Hep3Vector; + +public class KFTrackRecoHeadless extends Driver { + + private AIDA aida = AIDA.defaultInstance(); + private String trackCollectionName = "KalmanFullTracks"; + String ecalSubdetectorName = "Ecal"; + String ecalCollectionName = "EcalClusters"; + IDDecoder dec; + private String outputPlots = null; + private boolean debug = false; + + double feeMomentumCut = 3.5; + int nmodules = 7; + + IPlotter plotter; + IPlotter plotter22; + IPlotter plotterECal; + IPlotter plotterFEE; + IPlotter plotterLayers; + IPlotter plotterHodo; + + IHistogram1D nTracks; + IHistogram1D nhits; + IHistogram1D charge; + IHistogram1D trkPx; + IHistogram1D trkPy; + IHistogram1D trkPz; + IHistogram1D trkChi2; + IHistogram1D trkd0; + IHistogram1D trkphi; + IHistogram1D trkomega; + IHistogram1D trklam; + IHistogram1D trkz0; + IHistogram1D heOverP; + IHistogram1D hdelXECal; + IHistogram1D hdelYECal; + IHistogram2D heVsP; + IHistogram1D hfeeMom; + IHistogram1D hfeeTheta; + IHistogram1D hfeePOverE; + IHistogram2D hfeeClustPos; + IHistogram1D htopLay; + IHistogram1D hbotLay; + + IHistogram2D htrkProjH1TopMatch; + IHistogram2D htrkProjH2TopMatch; + IHistogram2D htrkProjH1BotMatch; + IHistogram2D htrkProjH2BotMatch; + + IHistogram2D htrkProjH1TopNoMatch; + IHistogram2D htrkProjH2TopNoMatch; + IHistogram2D htrkProjH1BotNoMatch; + IHistogram2D htrkProjH2BotNoMatch; + + IHistogram1D[] hthTop = new IHistogram1D[nmodules]; + IHistogram1D[] hthBot = new IHistogram1D[nmodules]; +//HODOSCOPE Stuff + private Map hodoMap = new HashMap(); + + private String hodoClustersCollectionName = "HodoGenericClusters"; + + double pMax = 7.0; + + public void setFeeMomentumCut(double cut) { + this.feeMomentumCut = cut; + } + + @Override + protected void detectorChanged(Detector detector) { + + + hodoMap = HodoUtils.getHodoscopeMap(detector); + + aida.tree().cd("/"); + + IAnalysisFactory fac = aida.analysisFactory(); + IPlotterFactory pfac = fac.createPlotterFactory("Track Recon"); + plotter = pfac.create("Momentum"); + + plotter.createRegions(2, 3); + // plotterFrame.addPlotter(plotter); + + nhits = aida.histogram1D("Hits per Track", 4, 4, 8); + + charge = aida.histogram1D("Track Charge", 3, -1, 2); + trkPx = aida.histogram1D("Track Momentum (Px)", 50, -0.1, 0.2); + trkPy = aida.histogram1D("Track Momentum (Py)", 50, -0.2, 0.2); + trkPz = aida.histogram1D("Track Momentum (Pz)", 50, 0, pMax); + trkChi2 = aida.histogram1D("Track Chi2/NDF", 50, 0, 15.0); + + // ****************************************************************** + nTracks = aida.histogram1D("Number of Tracks ", 7, 0, 7.0); + trkd0 = aida.histogram1D("d0 ", 50, -5.0, 5.0); + trkphi = aida.histogram1D("sinphi ", 50, -0.1, 0.15); + trkomega = aida.histogram1D("omega ", 50, -0.0006, 0.0006); + trklam = aida.histogram1D("tan(lambda) ", 50, -0.1, 0.1); + trkz0 = aida.histogram1D("y0 ", 50, -1.0, 1.0); + + // ****************************************************************** + heOverP = aida.histogram1D("Cluster Energy over Track Momentum ", 50, 0, 2.0); + hdelXECal = aida.histogram1D("delta X @ ECal (mm) ", 50, -15.0, 15.0); + hdelYECal = aida.histogram1D("delta Y @ ECal (mm) ", 50, -15.0, 15.0); + heVsP = aida.histogram2D("Momentum vs ECal E ", 50, 0, 7.0, 50, 0, 7.0); + + // ****************************************************************** + // fix the ranges here... + hfeeMom = aida.histogram1D("FEE Momentum", 50, feeMomentumCut, pMax); + hfeeTheta = aida.histogram1D("FEE Angle", 50, -15.0, 15.0); + hfeePOverE = aida.histogram1D("FEE POverE", 50, 0, 1.5); + hfeeClustPos = aida.histogram2D("FEE Cluster Position", 50, -2000.0, 2000.0, 50, -500, 500); + + + + htopLay = aida.histogram1D("Top Layers on Track", 7, 0, 7); + hbotLay = aida.histogram1D("Bottom Layers on Track", 7, 0, 7); + + htrkProjH1TopMatch = aida.histogram2D("Top Hodoscope L1 Projection Match", 50, 0, 350, 50, 0, 100); + htrkProjH2TopMatch = aida.histogram2D("Top Hodoscope L2 Projection Match", 50, 0, 350, 50, 0, 100); + htrkProjH1BotMatch = aida.histogram2D("Bottom Hodoscope L1 Projection Match", 50, 0, 350, 50, 0, 100); + htrkProjH2BotMatch = aida.histogram2D("Bottom Hodoscope L2 Projection Match", 50, 0, 350, 50, 0, 100); + htrkProjH1TopNoMatch = aida.histogram2D("Top Hodoscope L1 Projection No Match", 50, 0, 350, 50, 0, 100); + htrkProjH2TopNoMatch = aida.histogram2D("Top Hodoscope L2 Projection No Match", 50, 0, 350, 50, 0, 100); + htrkProjH1BotNoMatch = aida.histogram2D("Bottom Hodoscope L1 Projection No Match", 50, 0, 350, 50, 0, 100); + htrkProjH2BotNoMatch = aida.histogram2D("Bottom Hodoscope L2 Projection No Match", 50, 0, 350, 50, 0, 100); + + } + + public KFTrackRecoHeadless() { + } + + public void setOutputPlots(String output) { + this.outputPlots = output; + } + + public void setDebug(boolean dbg) { + this.debug = dbg; + } + + public void setTrackCollectionName(String trackCollectionName) { + this.trackCollectionName = trackCollectionName; + } + + @Override + public void process(EventHeader event) { + aida.tree().cd("/"); + + if (!event.hasCollection(Track.class, trackCollectionName)) { + nTracks.fill(0); + return; + } + + List tracks = event.get(Track.class, trackCollectionName); + nTracks.fill(tracks.size()); + + for (Track trk : tracks) { + Hep3Vector momentum = new BasicHep3Vector(trk.getTrackStates().get(0).getMomentum()); + double pmag = momentum.magnitude(); + double pt = Math.sqrt(momentum.z() * momentum.z() + momentum.y() * momentum.y()); + double theta = Math.asin(pt / pmag); + + trkPx.fill(momentum.y()); + trkPy.fill(momentum.z()); + trkPz.fill(momentum.x()); + trkChi2.fill(trk.getChi2() / trk.getNDF()); + + nhits.fill(trk.getTrackerHits().size()); + charge.fill(-trk.getCharge()); + trkd0.fill(trk.getTrackStates().get(0).getParameter(ParameterName.d0.ordinal())); + trkphi.fill(Math.sin(trk.getTrackStates().get(0).getParameter(ParameterName.phi0.ordinal()))); + trkomega.fill(trk.getTrackStates().get(0).getParameter(ParameterName.omega.ordinal())); + trklam.fill(trk.getTrackStates().get(0).getParameter(ParameterName.tanLambda.ordinal())); + trkz0.fill(trk.getTrackStates().get(0).getParameter(ParameterName.z0.ordinal())); + + if (pmag > feeMomentumCut && trk.getCharge() > 0) { // remember, hps-java track charge is opposite the real + // charge + hfeeMom.fill(momentum.magnitude()); + hfeeTheta.fill(theta); + } + + TrackState stateAtEcal = TrackUtils.getTrackStateAtECal(trk); + if (stateAtEcal == null) { + System.out.println("Couldn't get track state at ECal"); + continue; + } + + Hep3Vector posAtEcal = new BasicHep3Vector(stateAtEcal.getReferencePoint()); + // Hep3Vector posAtEcal = hpstrk.getPositionAtZMap(svt_l12, ecal_face, 5.0, + // event.getDetector().getFieldMap())[0]; + List clusters = event.get(Cluster.class, ecalCollectionName); + if (clusters != null) { + if (debug) + System.out.println("Found " + clusters.size() + " clusters"); + Cluster clust = findClosestCluster(posAtEcal, clusters); + if (clust != null) { + if (debug) + System.out.println("\t\t\t Found the best clusters"); + Hep3Vector clusterPos = new BasicHep3Vector(clust.getPosition()); + double eOverP = clust.getEnergy() / pmag; + double dx = posAtEcal.y() - clusterPos.x(); + double dy = posAtEcal.z() - clusterPos.y(); + heOverP.fill(eOverP); + hdelXECal.fill(dx); + hdelYECal.fill(dy); + heVsP.fill(pmag, clust.getEnergy()); + if (pmag > feeMomentumCut && trk.getCharge() > 0) { // remember, hps-java track charge is opposite + // the real charge + hfeePOverE.fill(pmag / clust.getEnergy()); + hfeeClustPos.fill(posAtEcal.x(), posAtEcal.y()); + } + } + } + + ////// Do Track-Hodoscope Matching //// + // Get RawTrackerHit collection from event. + List reconHits = event.get(SimpleGenericObject.class, hodoClustersCollectionName); + + //System.out.println("Size of reconHitsi is " + reconHits.size()); + int n_hits = reconHits.get(0).getNInt(); + + TrackState stateAtHodo1 = TrackUtils.getTrackStateAtHodoL1(trk); + TrackState stateAtHodo2 = TrackUtils.getTrackStateAtHodoL2(trk); + if (stateAtHodo1 != null && stateAtHodo2 != null) { + Hep3Vector posAtH1 = new BasicHep3Vector(stateAtHodo1.getReferencePoint()); + Hep3Vector posAtH2 = new BasicHep3Vector(stateAtHodo2.getReferencePoint()); + boolean isMatchHL1 = false; + boolean isMatchHL2 = false; + for (int ihit = 0; ihit < n_hits; ihit++) { + int detid = reconHits.get(5).getIntVal(ihit); + int layer = reconHits.get(2).getIntVal(ihit); + DetectorElement thisTile = hodoMap.get(new Identifier(detid)); + if (thisTile == null) { + System.out.println("Could not find this tile~~~~"); + continue; + } + if (layer == 0) + isMatchHL1 = isMatchHL1 || TrackUtils.detectorElementContainsPoint(CoordinateTransformations.transformVectorToDetector(posAtH1), + (DetectorElement) thisTile, 20.0); + if (layer == 1) + isMatchHL2 = isMatchHL2 || TrackUtils.detectorElementContainsPoint(CoordinateTransformations.transformVectorToDetector(posAtH2), + (DetectorElement) thisTile, 20.0); + } + if (posAtH1.z() > 0) + if (isMatchHL1) + htrkProjH1TopMatch.fill(posAtH1.y(), posAtH1.z()); + else + htrkProjH1TopNoMatch.fill(posAtH1.y(), posAtH1.z()); + else if (isMatchHL1) + htrkProjH1BotMatch.fill(posAtH1.y(), -1 * posAtH1.z()); + else + htrkProjH1BotNoMatch.fill(posAtH1.y(), -1 * posAtH1.z()); + + if (posAtH2.z() > 0) + if (isMatchHL2) + htrkProjH2TopMatch.fill(posAtH2.y(), posAtH2.z()); + else + htrkProjH2TopNoMatch.fill(posAtH2.y(), posAtH2.z()); + else if (isMatchHL2) + htrkProjH2BotMatch.fill(posAtH2.y(), -1 * posAtH2.z()); + else + htrkProjH2BotNoMatch.fill(posAtH2.y(), -1 * posAtH2.z()); + } + } + } + + @Override + public void endOfData() { + if (outputPlots != null) + try { + plotter.writeToFile(outputPlots + "-mom.gif"); + plotter22.writeToFile(outputPlots + "-trkparams.gif"); + + } catch (IOException ex) { + Logger.getLogger(KFTrackRecoHeadless.class + .getName()).log(Level.SEVERE, null, ex); + } + } + + /* + * mg...3/26/15...use this for now; eventually use the FinalStateParticle matching + */ + private Cluster findClosestCluster(Hep3Vector posonhelix, List clusters) { + Cluster closest = null; + double minDist = 9999; + for (Cluster cluster : clusters) { + double[] clPos = cluster.getPosition(); + double dist = Math.sqrt(Math.pow(clPos[1] - posonhelix.z(), 2)); // coordinates!!! + if (dist < minDist) { + closest = cluster; + minDist = dist; + } + } + return closest; + } + +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/KFTrackTimeHeadless.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/KFTrackTimeHeadless.java new file mode 100644 index 0000000000..52b83fc5c7 --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/KFTrackTimeHeadless.java @@ -0,0 +1,157 @@ +package org.hps.monitoring.drivers.headless; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.hps.recon.tracking.SvtPlotUtils; +import org.lcsim.detector.tracker.silicon.HpsSiSensor; +import org.lcsim.detector.tracker.silicon.SiSensor; +import org.lcsim.event.EventHeader; +import org.lcsim.event.RawTrackerHit; +import org.lcsim.event.Track; +import org.lcsim.event.TrackerHit; +import org.lcsim.geometry.Detector; +import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHitStrip1D; +import org.lcsim.util.Driver; +import org.lcsim.util.aida.AIDA; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogram2D; +import hep.aida.IHistogramFactory; +import hep.aida.ITree; + +public class KFTrackTimeHeadless extends Driver { + + // private AIDAFrame plotterFrame; + private String hitCollection = "StripClusterer_SiTrackerHitStrip1D"; + private String trackCollectionName = "KalmanFullTracks"; + + private static ITree tree = null; + private final IAnalysisFactory analysisFactory = AIDA.defaultInstance().analysisFactory(); + private IHistogramFactory histogramFactory = null; + + // Histogram Maps + private static final Map t0 = new HashMap(); + private static final Map trackHitDt = new HashMap(); + private static final Map trackHitT0 = new HashMap(); + private static final Map trackT0 = new HashMap(); + private static final Map trackTimeRange = new HashMap(); + + private static final Map trackTrigTime = new HashMap(); + private static final Map trackHitDtChan = new HashMap(); + private static final Map trackHit2D = new HashMap(); + private static final Map trackTimeMinMax = new HashMap(); + + private static final String subdetectorName = "Tracker"; + double minTime=-40; + double maxTime=40; + + public void setTrackCollectionName(String name) { + this.trackCollectionName = name; + } + + @Override + protected void detectorChanged(Detector detector) { + + tree = analysisFactory.createTreeFactory().create(); + histogramFactory = analysisFactory.createHistogramFactory(tree); + + List sensors = detector.getSubdetector(subdetectorName).getDetectorElement() + .findDescendants(HpsSiSensor.class); + + + for (HpsSiSensor sensor : sensors) { + t0.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - t0", 100, minTime, maxTime)); + trackHitT0.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - track hit t0", 100, minTime, maxTime)); + trackHitDt.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - track hit dt", 100, minTime, maxTime)); + + trackHit2D.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram2D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - trigger phase vs dt", 80, -20, 20.0, 6, 0, 24.0)); + trackHitDtChan.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram2D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - dt vs position", 200, -20, 20, 50, -20, 20.0)); + } + + trackT0.put("Top", + histogramFactory.createHistogram1D("Top Track Time", 80, -40, 40.0)); + + trackT0.put("Bottom", + histogramFactory.createHistogram1D("Bottom Track Time", 80, -40, 40.0)); + trackTrigTime.put("Top", + histogramFactory.createHistogram2D("Top Track Time vs. Trig Time", 80, -40, 40.0, 6, 0, 24)); + trackTrigTime.put("Bottom", + histogramFactory.createHistogram2D("Bottom Track Time vs. Trig Time", 80, -40, 40.0, 6, 0, 24)); + trackTimeRange.put("Top", + histogramFactory.createHistogram1D("Top Track Time Range", 75, 0, 30.0)); + trackTimeRange.put("Bottom", + histogramFactory.createHistogram1D("Bottom Track Time Range", 75, 0, 30.0)); + trackTimeMinMax.put("Top", + histogramFactory.createHistogram2D("Top Earliest vs Latest Track Hit Times", 80, -25, 25.0, 80, -25, 25.0)); + trackTimeMinMax.put("Bottom", + histogramFactory.createHistogram2D("Bottom Earliest vs Latest Track Hit Times", 80, -25, 25.0, 80, -25, 25.0)); + } + + public void setHitCollection(String hitCollection) { + this.hitCollection = hitCollection; + } + + @Override + public void process(EventHeader event) { + int trigTime = (int) (event.getTimeStamp() % 24); + + // ===> IIdentifierHelper helper = SvtUtils.getInstance().getHelper(); + List hits = event.get(SiTrackerHitStrip1D.class, hitCollection); + for (SiTrackerHitStrip1D hit : hits) { + SiSensor sensor = hit.getSensor(); + t0.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getTime()); + + } + // + + List tracks = event.get(Track.class, trackCollectionName); + for (Track track : tracks) { + String moduleName = "Top"; + if (track.getTrackerHits().get(0).getPosition()[2] < 0) { + moduleName = "Bottom"; + } + double minTime = Double.POSITIVE_INFINITY; + double maxTime = Double.NEGATIVE_INFINITY; + int hitCount = 0; + double trackTime = 0; + for (TrackerHit hitTH: track.getTrackerHits()){ + SiTrackerHitStrip1D hit=(SiTrackerHitStrip1D) hitTH; + SiSensor sensor = (SiSensor) ((RawTrackerHit) hit.getRawHits().get(0)).getDetectorElement(); + trackHitT0.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getTime()); + trackTime += hit.getTime(); + hitCount++; + if (hit.getTime() > maxTime) + maxTime = hit.getTime(); + if (hit.getTime() < minTime) + minTime = hit.getTime(); + } + trackTimeMinMax.get(moduleName).fill(minTime, maxTime); + trackTimeRange.get(moduleName).fill(maxTime - minTime); + trackTime /= hitCount; + trackT0.get(moduleName).fill(trackTime); + trackTrigTime.get(moduleName).fill(trackTime, trigTime); + + for (TrackerHit hitTH: track.getTrackerHits()){ + SiTrackerHitStrip1D hit=(SiTrackerHitStrip1D) hitTH; + SiSensor sensor = (SiSensor) ((RawTrackerHit) hit.getRawHits().get(0)).getDetectorElement(); + trackHitDt.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getTime() - trackTime); + trackHit2D.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getTime() - trackTime, event.getTimeStamp() % 24); + trackHitDtChan.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getMeasuredCoordinate().x(), hit.getTime() - trackTime); + } + } + } + + @Override + public void endOfData() { + // plotterFrame.dispose(); + } + +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtClusterOccHeadless.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtClusterOccHeadless.java new file mode 100644 index 0000000000..a919ff38c4 --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtClusterOccHeadless.java @@ -0,0 +1,328 @@ +package org.hps.monitoring.drivers.headless; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.hps.recon.tracking.SvtPlotUtils; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TIData; +import org.lcsim.detector.ITransform3D; +import org.lcsim.detector.tracker.silicon.ChargeCarrier; +import org.lcsim.detector.tracker.silicon.DopedSilicon; +import org.lcsim.detector.tracker.silicon.HpsSiSensor; +import org.lcsim.detector.tracker.silicon.SiSensorElectrodes; +import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; +import org.lcsim.event.RawTrackerHit; +import org.lcsim.geometry.Detector; +import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHitStrip1D; +import org.lcsim.util.Driver; +import org.lcsim.util.aida.AIDA; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogramFactory; +import hep.aida.ITree; +import hep.aida.ref.rootwriter.RootFileStore; +import hep.physics.vec.Hep3Vector; + +/** + * This Driver makes plots of SVT sensor occupancies across a run. + * + * 6/6/19: modified this to work with SVT upgrade including "L0"; separated all + * plotters into 2 + * so that we have one page for L1-4 and one for L5-7 + */ +public class SvtClusterOccHeadless extends Driver { + + private static ITree tree = null; + private IAnalysisFactory analysisFactory = AIDA.defaultInstance().analysisFactory(); + private IHistogramFactory histogramFactory = null; + + // Histogram maps + private static Map occupancyPlots = new HashMap(); + private static Map occupancyMap = new HashMap(); + + private List sensors; + private Map> stripPositions = new HashMap>(); + + private static final String SUBDETECTOR_NAME = "Tracker"; + private String rawTrackerHitCollectionName = "SVTRawTrackerHits"; + private String triggerBankCollectionName = "TriggerBank"; + private String stripClusterCollectionName = "StripClusterer_SiTrackerHitStrip1D"; + + private int timeWindowWeight = 1; + private int eventCount = 0; + private int eventRefreshRate = 1; + private int runNumber = -1; + + private boolean enableTriggerFilter = false; + private boolean filterPulserTriggers = false; + private boolean filterSingle0Triggers = false; + private boolean filterSingle1Triggers = false; + private boolean filterPair0Triggers = false; + private boolean filterPair1Triggers = false; + + private boolean dropSmallHitEvents = false; + + private boolean enableClusterTimeCuts = true; + private double clusterTimeCutMax = 20.0; + private double clusterTimeCutMin = 0.0; + + private boolean enableClusterChargeCut = true; + private double clusterChargeCut = 400; + + private boolean saveRootFile = true; + + public SvtClusterOccHeadless() { + } + + public void setDropSmallHitEvents(boolean dropSmallHitEvents) { + this.dropSmallHitEvents = dropSmallHitEvents; + } + + public void setRawTrackerHitCollectionName(String rawTrackerHitCollectionName) { + this.rawTrackerHitCollectionName = rawTrackerHitCollectionName; + } + + public void setEventRefreshRate(int eventRefreshRate) { + this.eventRefreshRate = eventRefreshRate; + } + + public void setEnableTriggerFilter(boolean enableTriggerFilter) { + this.enableTriggerFilter = enableTriggerFilter; + } + + public void setEnableClusterTimeCuts(boolean enableClusterTimeCuts) { + this.enableClusterTimeCuts = enableClusterTimeCuts; + } + + public void setFilterPulserTriggers(boolean filterPulserTriggers) { + this.filterPulserTriggers = filterPulserTriggers; + } + + public void setFilterSingle0Triggers(boolean filterSingle0Triggers) { + this.filterSingle0Triggers = filterSingle0Triggers; + } + + public void setFilterSingle1Triggers(boolean filterSingle1Triggers) { + this.filterSingle1Triggers = filterSingle1Triggers; + } + + public void setFilterPair0Triggers(boolean filterPair0Triggers) { + this.filterPair0Triggers = filterPair0Triggers; + } + + public void setFilterPair1Triggers(boolean filterPair1Triggers) { + this.filterPair1Triggers = filterPair1Triggers; + } + + public void setSaveRootFile(boolean saveRootFile) { + this.saveRootFile = saveRootFile; + } + + /** + * For each sensor, create a mapping between a physical channel number and + * it's global strip position. + */ + private void createStripPositionMap() { + for (HpsSiSensor sensor : sensors) + stripPositions.put(sensor, createStripPositionMap(sensor)); + } + + public static Map createStripPositionMap(HpsSiSensor sensor) { + Map positionMap = new HashMap(); + for (ChargeCarrier carrier : ChargeCarrier.values()) + if (sensor.hasElectrodesOnSide(carrier)) { + SiSensorElectrodes strips = (SiSensorElectrodes) sensor.getReadoutElectrodes(carrier); + ITransform3D parentToLocal = sensor.getReadoutElectrodes(carrier).getParentToLocal(); + ITransform3D localToGlobal = sensor.getReadoutElectrodes(carrier).getLocalToGlobal(); + for (int physicalChannel = 0; physicalChannel < 640; physicalChannel++) { + Hep3Vector localStripPosition = strips.getCellPosition(physicalChannel); + Hep3Vector stripPosition = parentToLocal.transformed(localStripPosition); + Hep3Vector globalStripPosition = localToGlobal.transformed(stripPosition); + positionMap.put(physicalChannel, globalStripPosition); + } + } + return positionMap; + } + + private static int getLayerNumber(HpsSiSensor sensor) { + return (int) Math.ceil(((double) sensor.getLayerNumber()) / 2); + } + + @Override + protected void detectorChanged(Detector detector) { + + // Get the HpsSiSensor objects from the geometry + sensors = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HpsSiSensor.class); + + // If there were no sensors found, throw an exception + if (sensors.isEmpty()) + throw new RuntimeException("There are no sensors associated with this detector"); + + // For each sensor, create a mapping between a physical channel number + // and the global strip position + this.createStripPositionMap(); + + tree = AIDA.defaultInstance().tree(); + tree.cd("/");// aida.tree().cd("/"); + histogramFactory = analysisFactory.createHistogramFactory(tree); + + for (HpsSiSensor sensor : sensors) { + + occupancyPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Occupancy", 640, 0, 640)); + + occupancyMap.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), new int[640]); + + } + + } + + private boolean passTriggerFilter(List triggerBanks) { + + // Loop through the collection of banks and get the TI banks. + for (GenericObject triggerBank : triggerBanks) + + // If the bank contains TI data, process it + if (AbstractIntData.getTag(triggerBank) == TIData.BANK_TAG) { + + TIData tiData = new TIData(triggerBank); + + if (filterPulserTriggers && tiData.isPulserTrigger()) + return false; + else if (filterSingle0Triggers && tiData.isSingle0Trigger()) + return false; + else if (filterSingle1Triggers && tiData.isSingle1Trigger()) + return false; + else if (filterPair0Triggers && tiData.isPair0Trigger()) + return false; + else if (filterPair1Triggers && tiData.isPair1Trigger()) + return false; + } + return true; + } + + @Override + public void process(EventHeader event) { + + // Get the run number from the event and store it. This will be used + // when writing the plots out to a ROOT file + if (runNumber == -1) + runNumber = event.getRunNumber(); + if (enableTriggerFilter && event.hasCollection(GenericObject.class, triggerBankCollectionName)) { + System.out.println("SensorOccupancyPlotsDriver:: Filtering Event"); + // Get the list of trigger banks from the event + List triggerBanks = event.get(GenericObject.class, triggerBankCollectionName); + + // Apply the trigger filter + if (!passTriggerFilter(triggerBanks)) + return; + } + + // If the event doesn't have a collection of RawTrackerHit's, skip it. + if (!event.hasCollection(RawTrackerHit.class, rawTrackerHitCollectionName)) { + System.out.println("No SVT RawTrackerHits in this event???"); + return; + } + // Get RawTrackerHit collection from event. + List rawHits = event.get(RawTrackerHit.class, rawTrackerHitCollectionName); + +// System.out.println("Number of SVT RawTrackerHts = " + rawHits.size()); + if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) + return; + + eventCount++; + + // Fill the strip cluster counts if available + if (event.hasCollection(SiTrackerHitStrip1D.class, stripClusterCollectionName)) { + List stripHits1D = event.get(SiTrackerHitStrip1D.class, stripClusterCollectionName); + for (SiTrackerHitStrip1D h : stripHits1D) { + if (enableClusterChargeCut && h.getdEdx() / DopedSilicon.ENERGY_EHPAIR < clusterChargeCut) + continue; + RawTrackerHit rth = h.getRawHits().get(0); + if ((h.getTime() < clusterTimeCutMax && h.getTime() > clusterTimeCutMin) || !enableClusterTimeCuts) + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) rth.getDetectorElement()).getName()))[rth + .getIdentifierFieldValue("strip")]++; // + } + } + + // Plot strip occupancies. + if (eventCount % eventRefreshRate == 0) + for (HpsSiSensor sensor : sensors) { + int[] strips = occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); + occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + + for (int channel = 0; channel < strips.length; channel++) { + double stripOccupancy = (double) strips[channel] / (double) eventCount; + + stripOccupancy /= this.timeWindowWeight; + // System.out.println("channel " + channel + " occupancy = " + stripOccupancy); + occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(channel, stripOccupancy); + } + } + } + + @Override + public void endOfData() { + + if (saveRootFile) { + String rootFile = "run" + runNumber + "_occupancy.root"; + RootFileStore store = new RootFileStore(rootFile); + try { + store.open(); + store.add(tree); + store.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + System.out.println("%===============================================================================%"); + System.out.println("%======================== Active Edge Sensor Occupancies =======================%"); + System.out.println("%===============================================================================%"); + System.out.println("% Total Events: " + eventCount); + // Calculate the occupancies at the sensor edge + + int[] topActiveEdgeStripOccupancy = new int[7]; + int[] bottomActiveEdgeStripOccupancy = new int[7]; + for (HpsSiSensor sensor : sensors) + if (sensor.isTopLayer() && sensor.isAxial()) + + if (sensor.getSide().equals(HpsSiSensor.ELECTRON_SIDE)) { + System.out.println("% Top Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]); + topActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]; + } else { + System.out.println("% Top Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]); + topActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]; + } + else if (sensor.isBottomLayer() && sensor.isAxial()) + if (sensor.getSide().equals(HpsSiSensor.ELECTRON_SIDE)) { + System.out.println("% Bottom Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]); + bottomActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]; + } else { + System.out.println("% Bottom Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]); + bottomActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]; + } + + for (int layerN = 0; layerN < 6; layerN++) { + double topStripOccupancy = (double) topActiveEdgeStripOccupancy[layerN] / (double) eventCount; + topStripOccupancy /= this.timeWindowWeight; + System.out.println("% Top Layer " + (layerN + 1) + ": Occupancy in " + (24 / this.timeWindowWeight) + + " ns window: " + topStripOccupancy); + double botStripOccupancy = (double) bottomActiveEdgeStripOccupancy[layerN] / (double) eventCount; + botStripOccupancy /= this.timeWindowWeight; + System.out.println("% Bottom Layer " + (layerN + 1) + ": Occupancy in " + (24 / this.timeWindowWeight) + + " ns window: " + botStripOccupancy); + } + System.out.println("%===============================================================================%"); + System.out.println("%===============================================================================%"); + } +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtClustersHeadless.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtClustersHeadless.java new file mode 100644 index 0000000000..bae7473b5f --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtClustersHeadless.java @@ -0,0 +1,200 @@ +package org.hps.monitoring.drivers.headless; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.hps.conditions.database.DatabaseConditionsManager; +import org.hps.conditions.svt.SvtTimingConstants; +import org.hps.recon.tracking.SvtPlotUtils; +import org.lcsim.detector.tracker.silicon.DopedSilicon; +import org.lcsim.detector.tracker.silicon.HpsSiSensor; +import org.lcsim.event.EventHeader; +import org.lcsim.event.RawTrackerHit; +import org.lcsim.geometry.Detector; +import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHitStrip1D; +import org.lcsim.util.Driver; +import org.lcsim.util.aida.AIDA; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogram2D; +import hep.aida.IHistogramFactory; +import hep.aida.ITree; +import hep.aida.ref.rootwriter.RootFileStore; + +/** + * Monitoring driver that looks at the SVT cluster charge. + */ +public class SvtClustersHeadless extends Driver { + + // Plotting + private static ITree tree = null; + private IAnalysisFactory analysisFactory = AIDA.defaultInstance().analysisFactory(); + private IHistogramFactory histogramFactory = null; + + private static int nmodlayers = 7; + + // Histogram Maps + private static Map clusterChargePlots = new HashMap(); + private static Map singleHitClusterChargePlots = new HashMap(); + private static Map clusterTimePlots = new HashMap(); + private static Map hitTimeTrigTimePlots = new HashMap(); + + private static IHistogram1D[][] hitTimeTrigTimePlots1D = new IHistogram1D[nmodlayers][2]; + private static IHistogram2D[][] hitTimeTrigTimePlots2D = new IHistogram2D[nmodlayers][2]; + private static final Map clusterYPlots = new HashMap(); + private SvtTimingConstants timingConstants; + + private static final int TOP = 0; + private static final int BOTTOM = 1; + + private List sensors; + // private Map fittedRawTrackerHitMap + // = new HashMap(); + + // Detector name + private static final String SUBDETECTOR_NAME = "Tracker"; + + // Collections + private String clusterCollectionName = "StripClusterer_SiTrackerHitStrip1D"; + + private int runNumber = -1; + + private boolean saveRootFile = true; + + private boolean dropSmallHitEvents = true; + + private boolean cutOutLowChargeClusters = false; + private double clusterChargeCut = 400; + + public void setDropSmallHitEvents(boolean dropSmallHitEvents) { + this.dropSmallHitEvents = dropSmallHitEvents; + } + + public void setClusterChargeCut(double clusterCharge) { + this.clusterChargeCut = clusterCharge; + } + + public void setCutOutLowChargeClusters(boolean cutOutLowChargeClusters) { + this.cutOutLowChargeClusters = cutOutLowChargeClusters; + } + + public void setSaveRootFile(boolean saveRootFile) { + this.saveRootFile = saveRootFile; + } + + protected void detectorChanged(Detector detector) { + + // Get the HpsSiSensor objects from the geometry + sensors = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HpsSiSensor.class); + + timingConstants = DatabaseConditionsManager.getInstance().getCachedConditions(SvtTimingConstants.SvtTimingConstantsCollection.class, "svt_timing_constants").getCachedData().get(0); + if (sensors.size() == 0) + throw new RuntimeException("No sensors were found in this detector."); + + // // If the tree already exist, clear all existing plots of any old data + // // they might contain. + // if (tree != null) { + // this.resetPlots(); + // return; + // } + tree = analysisFactory.createTreeFactory().create(); + histogramFactory = analysisFactory.createHistogramFactory(tree); + + for (HpsSiSensor sensor : sensors) { + + clusterChargePlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Charge", 100, 0, 5000)); + singleHitClusterChargePlots + .put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + + " - Single Hit Cluster Charge", 100, 0, 5000)); + clusterTimePlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Time", 100, -75, 75)); + + clusterYPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Y", 100, 0, 25.0)); + } + + hitTimeTrigTimePlots.put("Top", + histogramFactory.createHistogram2D("Top Cluster Time vs. Trigger Phase", 100, -75, 50, 6, -12, 12)); + + hitTimeTrigTimePlots.put("Bottom", + histogramFactory.createHistogram2D("Bottom Cluster Time vs. Trigger Phase", 100, -75, 50, 6, -12, 12)); + + for (int i = 0; i < 6; i++) + for (int j = 0; j < 2; j++) { + hitTimeTrigTimePlots1D[i][j] = histogramFactory.createHistogram1D( + String.format("Cluster Time for Phase %d, %s", i, j == TOP ? "Top" : "Bottom"), 100, -75, 50); + hitTimeTrigTimePlots2D[i][j] = histogramFactory.createHistogram2D( + String.format("Cluster Amplitude vs. Time for Phase %d, %s", i, j == TOP ? "Top" : "Bottom"), + 100, -75, 50, 100, 0, 5000.0); + } + + } + + public void process(EventHeader event) { + + if (runNumber == -1) + runNumber = event.getRunNumber(); + + // If the event doesn't contain any clusters, skip it + if (!event.hasCollection(SiTrackerHitStrip1D.class, clusterCollectionName)) + return; + + if (event.hasCollection(RawTrackerHit.class, "SVTRawTrackerHits")) { + // Get RawTrackerHit collection from event. + List rawHits = event.get(RawTrackerHit.class, "SVTRawTrackerHits"); + + if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) + return; + } + + // Get the list of clusters in the event + List clusters = event.get(SiTrackerHitStrip1D.class, clusterCollectionName); + + for (SiTrackerHitStrip1D cluster : clusters) { + + // Get the sensor associated with this cluster + HpsSiSensor sensor = (HpsSiSensor) cluster.getSensor(); + double absClY = Math.abs(cluster.getPosition()[1]); + // Fill all plots + clusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR); + + clusterYPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(absClY); + + if (cluster.getRawHits().size() == 1) + singleHitClusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR); + double trigPhase = (((event.getTimeStamp() - 4 * timingConstants.getOffsetPhase()) % 24) - 12); + if (cutOutLowChargeClusters) + if (cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR < clusterChargeCut) + continue; + clusterTimePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(cluster.getTime()); + if (sensor.isTopLayer()) { + hitTimeTrigTimePlots1D[(int) ((event.getTimeStamp() / 4) % 6)][TOP].fill(cluster.getTime()); + hitTimeTrigTimePlots2D[(int) ((event.getTimeStamp() / 4) % 6)][TOP].fill(cluster.getTime(), + cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR); + hitTimeTrigTimePlots.get("Top").fill(cluster.getTime(), trigPhase); + } else { + hitTimeTrigTimePlots1D[(int) ((event.getTimeStamp() / 4) % 6)][BOTTOM].fill(cluster.getTime()); + hitTimeTrigTimePlots2D[(int) ((event.getTimeStamp() / 4) % 6)][BOTTOM].fill(cluster.getTime(), + cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR); + hitTimeTrigTimePlots.get("Bottom").fill(cluster.getTime(), trigPhase); + } + } + } + + public void endOfData() { + if (saveRootFile) { + String rootFile = "run" + runNumber + "_cluster_analysis.root"; + RootFileStore store = new RootFileStore(rootFile); + try { + store.open(); + store.add(tree); + store.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + } +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtSensorOccHeadless.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtSensorOccHeadless.java new file mode 100644 index 0000000000..3d8ff49684 --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/headless/SvtSensorOccHeadless.java @@ -0,0 +1,481 @@ +package org.hps.monitoring.drivers.headless; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Logger; + +import org.hps.recon.tracking.SvtPlotUtils; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TIData; +import org.lcsim.detector.ITransform3D; +import org.lcsim.detector.tracker.silicon.ChargeCarrier; +import org.lcsim.detector.tracker.silicon.HpsSiSensor; +import org.lcsim.detector.tracker.silicon.SiSensorElectrodes; +import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; +import org.lcsim.event.RawTrackerHit; +import org.lcsim.geometry.Detector; +import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHitStrip1D; +import org.lcsim.recon.tracking.digitization.sisim.TrackerHitType; +import org.lcsim.util.Driver; +import org.lcsim.util.aida.AIDA; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogramFactory; +import hep.aida.ITree; +import hep.aida.ref.rootwriter.RootFileStore; +import hep.physics.vec.Hep3Vector; + +/** + * This Driver makes plots of SVT sensor occupancies across a run. + * + * 6/6/19: modified this to work with SVT upgrade including "L0"; separated all + * plotters into 2 + * so that we have one page for L1-4 and one for L5-7 + * 6/2/21: mg based on org.hps.monitoring.drivers.svt.SensorOccupancyPlotsDriver but removed all + * plot formating for new headless monitoring app + */ +public class SvtSensorOccHeadless extends Driver { + + // Logger + private static Logger LOGGER = Logger.getLogger(SvtSensorOccHeadless.class.getCanonicalName()); + + // Plotting + private static ITree tree = null; + private IAnalysisFactory analysisFactory = AIDA.defaultInstance().analysisFactory(); + private IHistogramFactory histogramFactory = null; + + // Histogram maps + private static Map occupancyPlots = new HashMap(); + private static Map positionPlots = new HashMap(); + private static Map clusterPositionPlots = new HashMap(); + private static Map clusterPositionPlotCounts = new HashMap(); + private static Map occupancyMap = new HashMap(); + private static Map maxSamplePositionPlots = new HashMap(); + + private List sensors; + private Map> stripPositions = new HashMap>(); + + private static final String SUBDETECTOR_NAME = "Tracker"; + private String rawTrackerHitCollectionName = "SVTRawTrackerHits"; + private String triggerBankCollectionName = "TriggerBank"; + private String stripClusterCollectionName = "StripClusterer_SiTrackerHitStrip1D"; + + private int maxSamplePosition = -1; + private int timeWindowWeight = 1; + private int eventCount = 0; + private int eventRefreshRate = 1; + private int runNumber = -1; + private int resetPeriod = -1; + + private boolean enablePositionPlots = false; + private boolean enableMaxSamplePlots = false; + private boolean enableTriggerFilter = false; + private boolean filterPulserTriggers = false; + private boolean filterSingle0Triggers = false; + private boolean filterSingle1Triggers = false; + private boolean filterPair0Triggers = false; + private boolean filterPair1Triggers = false; + + private boolean dropSmallHitEvents = false; + + private boolean enableClusterTimeCuts = true; + private double clusterTimeCutMax = 4.0; + private double clusterTimeCutMin = -4.0; + + private boolean saveRootFile = true; + + public void setDropSmallHitEvents(boolean dropSmallHitEvents) { + this.dropSmallHitEvents = dropSmallHitEvents; + } + + public void setRawTrackerHitCollectionName(String rawTrackerHitCollectionName) { + this.rawTrackerHitCollectionName = rawTrackerHitCollectionName; + } + + public void setEventRefreshRate(int eventRefreshRate) { + this.eventRefreshRate = eventRefreshRate; + } + + public void setResetPeriod(int resetPeriod) { + this.resetPeriod = resetPeriod; + } + + public void setEnablePositionPlots(boolean enablePositionPlots) { + this.enablePositionPlots = enablePositionPlots; + } + + public void setEnableMaxSamplePlots(boolean enableMaxSamplePlots) { + this.enableMaxSamplePlots = enableMaxSamplePlots; + } + + public void setEnableTriggerFilter(boolean enableTriggerFilter) { + this.enableTriggerFilter = enableTriggerFilter; + } + + public void setFilterPulserTriggers(boolean filterPulserTriggers) { + this.filterPulserTriggers = filterPulserTriggers; + } + + public void setFilterSingle0Triggers(boolean filterSingle0Triggers) { + this.filterSingle0Triggers = filterSingle0Triggers; + } + + public void setFilterSingle1Triggers(boolean filterSingle1Triggers) { + this.filterSingle1Triggers = filterSingle1Triggers; + } + + public void setFilterPair0Triggers(boolean filterPair0Triggers) { + this.filterPair0Triggers = filterPair0Triggers; + } + + public void setFilterPair1Triggers(boolean filterPair1Triggers) { + this.filterPair1Triggers = filterPair1Triggers; + } + + public void setMaxSamplePosition(int maxSamplePosition) { + this.maxSamplePosition = maxSamplePosition; + } + + public void setTimeWindowWeight(int timeWindowWeight) { + this.timeWindowWeight = timeWindowWeight; + } + + public void setSaveRootFile(boolean saveRootFile) { + this.saveRootFile = saveRootFile; + } + + public void setOccupancyYRange1(double occupancyYRange1) { + } + + /** + * Get the global strip position of a physical channel number for a given + * sensor. + * + * @param sensor : HpsSiSensor + * @param physicalChannel : physical channel number + * @return The strip position (mm) in the global coordinate system + */ + private Hep3Vector getStripPosition(HpsSiSensor sensor, int physicalChannel) { + return stripPositions.get(sensor).get(physicalChannel); + } + + /** + * For each sensor, create a mapping between a physical channel number and + * it's global strip position. + */ + private void createStripPositionMap() { + for (HpsSiSensor sensor : sensors) + stripPositions.put(sensor, createStripPositionMap(sensor)); + } + + public static Map createStripPositionMap(HpsSiSensor sensor) { + Map positionMap = new HashMap(); + for (ChargeCarrier carrier : ChargeCarrier.values()) + if (sensor.hasElectrodesOnSide(carrier)) { + // SiSensorElectrodes electrodes = sensor.getReadoutElectrodes(); + SiSensorElectrodes strips = (SiSensorElectrodes) sensor.getReadoutElectrodes(carrier); + ITransform3D parentToLocal = sensor.getReadoutElectrodes(carrier).getParentToLocal(); + ITransform3D localToGlobal = sensor.getReadoutElectrodes(carrier).getLocalToGlobal(); + for (int physicalChannel = 0; physicalChannel < 640; physicalChannel++) { + Hep3Vector localStripPosition = strips.getCellPosition(physicalChannel); + Hep3Vector stripPosition = parentToLocal.transformed(localStripPosition); + Hep3Vector globalStripPosition = localToGlobal.transformed(stripPosition); + positionMap.put(physicalChannel, globalStripPosition); + } + } + return positionMap; + } + + /** + * Clear all histograms of it's current data. + */ + private void resetPlots() { + + // Clear the hit counter map of all previously stored data. + occupancyMap.clear(); + + // Since all plots are mapped to the name of a sensor, loop + // through the sensors, get the corresponding plots and clear them. + for (HpsSiSensor sensor : sensors) { + + // Clear the occupancy plots. + occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + + if (enablePositionPlots) { + positionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + clusterPositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + clusterPositionPlotCounts.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + } + + if (enableMaxSamplePlots) + maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + + // Reset the hit counters. + occupancyMap.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), new int[640]); + } + } + + private static int getLayerNumber(HpsSiSensor sensor) { + return (int) Math.ceil(((double) sensor.getLayerNumber()) / 2); + } + + @Override + protected void detectorChanged(Detector detector) { + + // Get the HpsSiSensor objects from the geometry + sensors = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HpsSiSensor.class); + + // If there were no sensors found, throw an exception + if (sensors.isEmpty()) + throw new RuntimeException("There are no sensors associated with this detector"); + + // For each sensor, create a mapping between a physical channel number + // and the global strip position + this.createStripPositionMap(); + + // // If the tree already exist, clear all existing plots of any old data + // // they might contain. + // if (tree != null) { + // this.resetPlots(); + // return; + // } + // tree = analysisFactory.createTreeFactory().create(); + tree = AIDA.defaultInstance().tree(); + tree.cd("/"); + histogramFactory = analysisFactory.createHistogramFactory(tree); + + for (HpsSiSensor sensor : sensors) { + + occupancyPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Occupancy", 640, 0, 640)); + + if (enablePositionPlots) { + if (sensor.isTopLayer()) { + positionPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + + " - Occupancy vs Position", 1000, 0, 60)); + clusterPositionPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + + " - Cluster occupancy vs Position", 1000, 0, 60)); + clusterPositionPlotCounts.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + + " - Cluster count vs Position", 1000, 0, 60)); + } else { + positionPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + + " - Occupancy vs Position", 1000, -60, 0)); + clusterPositionPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + + " - Cluster occupancy vs Position", 1000, -60, 0)); + clusterPositionPlotCounts.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + + " - Cluster count vs Position", 1000, -60, 0)); + } + + } + occupancyMap.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), new int[640]); + + if (enableMaxSamplePlots) { + maxSamplePositionPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Max Sample Number", 6, -0.5, 5.5)); + + } + } + + } + + private boolean passTriggerFilter(List triggerBanks) { + + // Loop through the collection of banks and get the TI banks. + for (GenericObject triggerBank : triggerBanks) + + // If the bank contains TI data, process it + if (AbstractIntData.getTag(triggerBank) == TIData.BANK_TAG) { + + TIData tiData = new TIData(triggerBank); + + if (filterPulserTriggers && tiData.isPulserTrigger()) + return false; + else if (filterSingle0Triggers && tiData.isSingle0Trigger()) + return false; + else if (filterSingle1Triggers && tiData.isSingle1Trigger()) + return false; + else if (filterPair0Triggers && tiData.isPair0Trigger()) + return false; + else if (filterPair1Triggers && tiData.isPair1Trigger()) + return false; + } + return true; + } + + @Override + public void process(EventHeader event) { + + // Get the run number from the event and store it. This will be used + // when writing the plots out to a ROOT file + if (runNumber == -1) + runNumber = event.getRunNumber(); + if (enableTriggerFilter && event.hasCollection(GenericObject.class, triggerBankCollectionName)) { + LOGGER.info("Filtering Event"); + // Get the list of trigger banks from the event + List triggerBanks = event.get(GenericObject.class, triggerBankCollectionName); + + // Apply the trigger filter + if (!passTriggerFilter(triggerBanks)) + return; + } + + // If the event doesn't have a collection of RawTrackerHit's, skip it. + if (!event.hasCollection(RawTrackerHit.class, rawTrackerHitCollectionName)) { + LOGGER.warning("No SVT RawTrackerHits in this event."); + return; + } + // Get RawTrackerHit collection from event. + List rawHits = event.get(RawTrackerHit.class, rawTrackerHitCollectionName); + +// System.out.println("Number of SVT RawTrackerHts = " + rawHits.size()); + if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) + return; + + if (resetPeriod > 0 && eventCount > resetPeriod) { // reset occupancy numbers after resetPeriod events + eventCount = 0; + resetPlots(); + } + + eventCount++; + + // Increment strip hit count. + for (RawTrackerHit rawHit : rawHits) { + // Obtain the raw ADC samples for each of the six samples readout + short[] adcValues = rawHit.getADCValues(); + + // Find the sample that has the largest amplitude. This should + // correspond to the peak of the shaper signal if the SVT is timed + // in correctly. Otherwise, the maximum sample value will default + // to 0. + int maxAmplitude = 0; + int maxSamplePositionFound = -1; + for (int sampleN = 0; sampleN < 6; sampleN++) + if (adcValues[sampleN] > maxAmplitude) { + maxAmplitude = adcValues[sampleN]; + maxSamplePositionFound = sampleN; + } + if (maxSamplePosition == -1 || maxSamplePosition == maxSamplePositionFound) + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) rawHit.getDetectorElement()).getName()))[rawHit + .getIdentifierFieldValue("strip")]++; // System.out.println("Filling occupancy"); + + if (enableMaxSamplePlots) + maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) rawHit.getDetectorElement()).getName())).fill( + maxSamplePositionFound); + } + + // Fill the strip cluster counts if available + if (event.hasCollection(SiTrackerHitStrip1D.class, stripClusterCollectionName)) { + List stripHits1D = event.get(SiTrackerHitStrip1D.class, stripClusterCollectionName); + for (SiTrackerHitStrip1D h : stripHits1D) { + SiTrackerHitStrip1D global = h.getTransformedHit(TrackerHitType.CoordinateSystem.GLOBAL); + Hep3Vector pos_global = global.getPositionAsVector(); + if (enableClusterTimeCuts) { + if (h.getTime() < clusterTimeCutMax && h.getTime() > clusterTimeCutMin) + clusterPositionPlotCounts.get( + SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) h.getRawHits().get(0).getDetectorElement()).getName())).fill( + pos_global.y()); + } else + clusterPositionPlotCounts.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) h.getRawHits().get(0).getDetectorElement()).getName())) + .fill(pos_global.y()); + } + } + + // Plot strip occupancies. + if (eventCount % eventRefreshRate == 0) + for (HpsSiSensor sensor : sensors) { + int[] strips = occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); + occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + if (enablePositionPlots) + positionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + for (int channel = 0; channel < strips.length; channel++) { + double stripOccupancy = (double) strips[channel] / (double) eventCount; + + stripOccupancy /= this.timeWindowWeight; + // System.out.println("channel " + channel + " occupancy = " + stripOccupancy); + occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(channel, stripOccupancy); + + if (enablePositionPlots) { + double stripPosition = this.getStripPosition(sensor, channel).y(); + positionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(stripPosition, stripOccupancy); + } + } + if (enablePositionPlots) { + clusterPositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + IHistogram1D h = clusterPositionPlotCounts.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); + for (int bin = 0; bin < h.axis().bins(); ++bin) { + int y = h.binEntries(bin); + double stripClusterOccupancy = (double) y / (double) eventCount; + double x = h.axis().binCenter(bin); + clusterPositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(x, stripClusterOccupancy); + } + } + + } + + + } + + @Override + public void endOfData() { + + if (saveRootFile) { + String rootFile = "run" + runNumber + "_occupancy.root"; + RootFileStore store = new RootFileStore(rootFile); + try { + store.open(); + store.add(tree); + store.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + System.out.println("%===============================================================================%"); + System.out.println("%======================== Active Edge Sensor Occupancies =======================%"); + System.out.println("%===============================================================================%"); + System.out.println("% Total Events: " + eventCount); + // Calculate the occupancies at the sensor edge + + int[] topActiveEdgeStripOccupancy = new int[7]; + int[] bottomActiveEdgeStripOccupancy = new int[7]; + for (HpsSiSensor sensor : sensors) + if (sensor.isTopLayer() && sensor.isAxial()) + + if (sensor.getSide().equals(HpsSiSensor.ELECTRON_SIDE)) { + System.out.println("% Top Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]); + topActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]; + } else { + System.out.println("% Top Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]); + topActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]; + } + else if (sensor.isBottomLayer() && sensor.isAxial()) + if (sensor.getSide().equals(HpsSiSensor.ELECTRON_SIDE)) { + System.out.println("% Bottom Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]); + bottomActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]; + } else { + System.out.println("% Bottom Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]); + bottomActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]; + } + + for (int layerN = 0; layerN < 6; layerN++) { + double topStripOccupancy = (double) topActiveEdgeStripOccupancy[layerN] / (double) eventCount; + topStripOccupancy /= this.timeWindowWeight; + System.out.println("% Top Layer " + (layerN + 1) + ": Occupancy in " + (24 / this.timeWindowWeight) + + " ns window: " + topStripOccupancy); + double botStripOccupancy = (double) bottomActiveEdgeStripOccupancy[layerN] / (double) eventCount; + botStripOccupancy /= this.timeWindowWeight; + System.out.println("% Bottom Layer " + (layerN + 1) + ": Occupancy in " + (24 / this.timeWindowWeight) + + " ns window: " + botStripOccupancy); + } + System.out.println("%===============================================================================%"); + System.out.println("%===============================================================================%"); + } +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/hodoscope/HodoscopePlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/hodoscope/HodoscopePlots.java index 35c10bdad8..76fee21044 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/hodoscope/HodoscopePlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/hodoscope/HodoscopePlots.java @@ -124,7 +124,21 @@ protected void detectorChanged(Detector detector) { converter = new HodoRawConverter(); tree = AIDA.defaultInstance().tree(); - tree.cd("/");// aida.tree().cd("/"); + tree.cd("/"); + boolean dirExists = false; + String dirName = "/HodoMon"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + histogramFactory = analysisFactory.createHistogramFactory(tree); // Histogram maps @@ -604,4 +618,4 @@ class hodoID { public int iy; public int ilayer; public int ihole; -}; \ No newline at end of file +}; diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/shifters/MonitoringPlotsForShifters.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/shifters/MonitoringPlotsForShifters.java new file mode 100644 index 0000000000..4b5cf1f069 --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/shifters/MonitoringPlotsForShifters.java @@ -0,0 +1,713 @@ +package org.hps.monitoring.drivers.shifters; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogramFactory; +import hep.aida.IPlotter; +import hep.aida.IPlotterFactory; +import hep.aida.IPlotterRegion; +import hep.aida.IPlotterStyle; +import hep.aida.ITree; +import hep.aida.ref.rootwriter.RootFileStore; +import hep.physics.vec.Hep3Vector; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Logger; + +import org.hps.monitoring.subsys.StatusCode; +import org.hps.monitoring.subsys.Subsystem; +import org.hps.monitoring.subsys.SystemStatus; +import org.hps.monitoring.subsys.SystemStatusImpl; +import org.hps.recon.tracking.SvtPlotUtils; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TIData; +import org.lcsim.detector.ITransform3D; +import org.lcsim.detector.tracker.silicon.ChargeCarrier; +import org.lcsim.detector.tracker.silicon.HpsSiSensor; +//import org.lcsim.detector.tracker.silicon.SiStrips; +//import org.lcsim.detector.tracker.silicon.SiStriplets; +import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; +import org.lcsim.event.RawTrackerHit; +import org.lcsim.geometry.Detector; +import org.lcsim.util.Driver; +import org.lcsim.util.aida.AIDA; +import org.lcsim.detector.tracker.silicon.SiSensorElectrodes; + +/** + * Monitoring plots driver with the basic plots. Intended for use by worker + * shifters + * + * 7/5/21: Created...takes a lot of code from drivers in + * org.hps.monitoring.svt/trackrecon/ecal + */ +public class MonitoringPlotsForShifters extends Driver { + + // Logger + private static Logger LOGGER = Logger.getLogger(MonitoringPlotsForShifters.class.getCanonicalName()); + + // Plotting + private static ITree tree = null; + private IAnalysisFactory analysisFactory = AIDA.defaultInstance().analysisFactory(); + private IPlotterFactory plotterFactory = analysisFactory.createPlotterFactory("Plots For Shifters"); + private IHistogramFactory histogramFactory = null; + + // Histogram maps + private static Map plotters = new HashMap(); + private static Map occupancyPlots = new HashMap(); + private static Map occupancyMap = new HashMap(); + private static Map maxSamplePositionPlots = new HashMap(); + + private List sensors; + private Map> stripPositions = new HashMap>(); + + private static final String SUBDETECTOR_NAME = "Tracker"; + private String rawTrackerHitCollectionName = "SVTRawTrackerHits"; + private String triggerBankCollectionName = "TriggerBank"; + private String stripClusterCollectionName = "StripClusterer_SiTrackerHitStrip1D"; + + private int maxSamplePosition = -1; + private int timeWindowWeight = 1; + private int eventCount = 0; + private int eventRefreshRate = 1; + private int runNumber = -1; + private int resetPeriod = -1; + + private boolean enableMaxSamplePlots = false; + private boolean enableTriggerFilter = false; + private boolean filterPulserTriggers = false; + private boolean filterSingle0Triggers = false; + private boolean filterSingle1Triggers = false; + private boolean filterPair0Triggers = false; + private boolean filterPair1Triggers = false; + + SystemStatus maxSampleStatus; + private int maxSampleMonitorStart = 1000; + private int maxSampleMonitorPeriod = 100; + + SystemStatus occupancyStatus; + private int occupancyMonitorStart = 5000; + private int occupancyMonitorPeriod = 100; + private double minPeakOccupancy = 0.0001; + private double maxPeakOccupancy = 0.01; + + private boolean dropSmallHitEvents = false; + + private boolean enableClusterTimeCuts = true; + private double clusterTimeCutMax = 4.0; + private double clusterTimeCutMin = -4.0; + + private boolean saveRootFile = true; + + // Max Y range for occupancy plots. + private double occupancyYRange1 = 0.03; + private double occupancyYRange2 = 0.003; + + public MonitoringPlotsForShifters() { + maxSampleStatus = new SystemStatusImpl(Subsystem.SVT, "Checks that SVT is timed in (max sample plot)", true); + maxSampleStatus.setStatus(StatusCode.UNKNOWN, "Status is unknown."); + occupancyStatus = new SystemStatusImpl(Subsystem.SVT, "Checks SVT occupancy", true); + occupancyStatus.setStatus(StatusCode.UNKNOWN, "Status is unknown."); + } + + public void setDropSmallHitEvents(boolean dropSmallHitEvents) { + this.dropSmallHitEvents = dropSmallHitEvents; + } + + public void setRawTrackerHitCollectionName(String rawTrackerHitCollectionName) { + this.rawTrackerHitCollectionName = rawTrackerHitCollectionName; + } + + public void setEventRefreshRate(int eventRefreshRate) { + this.eventRefreshRate = eventRefreshRate; + } + + public void setResetPeriod(int resetPeriod) { + this.resetPeriod = resetPeriod; + } + + public void setEnableMaxSamplePlots(boolean enableMaxSamplePlots) { + this.enableMaxSamplePlots = enableMaxSamplePlots; + } + + public void setEnableTriggerFilter(boolean enableTriggerFilter) { + this.enableTriggerFilter = enableTriggerFilter; + } + + public void setFilterPulserTriggers(boolean filterPulserTriggers) { + this.filterPulserTriggers = filterPulserTriggers; + } + + public void setFilterSingle0Triggers(boolean filterSingle0Triggers) { + this.filterSingle0Triggers = filterSingle0Triggers; + } + + public void setFilterSingle1Triggers(boolean filterSingle1Triggers) { + this.filterSingle1Triggers = filterSingle1Triggers; + } + + public void setFilterPair0Triggers(boolean filterPair0Triggers) { + this.filterPair0Triggers = filterPair0Triggers; + } + + public void setFilterPair1Triggers(boolean filterPair1Triggers) { + this.filterPair1Triggers = filterPair1Triggers; + } + + public void setMaxSamplePosition(int maxSamplePosition) { + this.maxSamplePosition = maxSamplePosition; + } + + public void setTimeWindowWeight(int timeWindowWeight) { + this.timeWindowWeight = timeWindowWeight; + } + + public void setMaxSampleMonitorStart(int maxSampleMonitorStart) { + this.maxSampleMonitorStart = maxSampleMonitorStart; + } + + public void setMaxSampleMonitorPeriod(int maxSampleMonitorPeriod) { + this.maxSampleMonitorPeriod = maxSampleMonitorPeriod; + } + + public void setOccupancyMonitorStart(int occupancyMonitorStart) { + this.occupancyMonitorStart = occupancyMonitorStart; + } + + public void setOccupancyMonitorPeriod(int occupancyMonitorPeriod) { + this.occupancyMonitorPeriod = occupancyMonitorPeriod; + } + + public void setMinPeakOccupancy(double minPeakOccupancy) { + this.minPeakOccupancy = minPeakOccupancy; + } + + public void setMaxPeakOccupancy(double maxPeakOccupancy) { + this.maxPeakOccupancy = maxPeakOccupancy; + } + + public void setSaveRootFile(boolean saveRootFile) { + this.saveRootFile = saveRootFile; + } + + public void setOccupancyYRange1(double occupancyYRange1) { + this.occupancyYRange1 = occupancyYRange1; + } + + public void setOccupancyYRange2(double occupancyYRange2) { + this.occupancyYRange2 = occupancyYRange2; + } + + /** + * Get the global strip position of a physical channel number for a given + * sensor. + * + * @param sensor : HpsSiSensor + * @param physicalChannel : physical channel number + * @return The strip position (mm) in the global coordinate system + */ + private Hep3Vector getStripPosition(HpsSiSensor sensor, int physicalChannel) { + return stripPositions.get(sensor).get(physicalChannel); + } + + /** + * For each sensor, create a mapping between a physical channel number and + * it's global strip position. + */ + // TODO: Move this to a utility class + private void createStripPositionMap() { + for (HpsSiSensor sensor : sensors) + stripPositions.put(sensor, createStripPositionMap(sensor)); + } + + public static Map createStripPositionMap(HpsSiSensor sensor) { + Map positionMap = new HashMap(); + for (ChargeCarrier carrier : ChargeCarrier.values()) + if (sensor.hasElectrodesOnSide(carrier)) { + // SiSensorElectrodes electrodes = sensor.getReadoutElectrodes(); + SiSensorElectrodes strips = (SiSensorElectrodes) sensor.getReadoutElectrodes(carrier); + ITransform3D parentToLocal = sensor.getReadoutElectrodes(carrier).getParentToLocal(); + ITransform3D localToGlobal = sensor.getReadoutElectrodes(carrier).getLocalToGlobal(); + for (int physicalChannel = 0; physicalChannel < 640; physicalChannel++) { + Hep3Vector localStripPosition = strips.getCellPosition(physicalChannel); + Hep3Vector stripPosition = parentToLocal.transformed(localStripPosition); + Hep3Vector globalStripPosition = localToGlobal.transformed(stripPosition); + positionMap.put(physicalChannel, globalStripPosition); + } + } + return positionMap; + } + + /** + * Create a plotter style. + * + * @param xAxisTitle : Title of the x axis + * @param sensor : HpsSiSensor associated with the plot. This is used to set + * certain attributes based on the position of the sensor. + * @return plotter style + */ + // TODO: Move this to a utilities class + IPlotterStyle createOccupancyPlotStyle(String xAxisTitle, HpsSiSensor sensor, boolean isAlarming) { + // Create a default style + IPlotterStyle style = this.plotterFactory.createPlotterStyle(); + + // Set the style of the X axis + style.xAxisStyle().setLabel(xAxisTitle); + style.xAxisStyle().labelStyle().setFontSize(14); + style.xAxisStyle().setVisible(true); + + // Set the style of the Y axis + style.yAxisStyle().setLabel("Occupancy"); + style.yAxisStyle().labelStyle().setFontSize(14); + style.yAxisStyle().setVisible(true); + + // Turn off the histogram grid + style.gridStyle().setVisible(false); + + // Set the style of the data + style.dataStyle().lineStyle().setVisible(false); + style.dataStyle().outlineStyle().setVisible(false); + style.dataStyle().outlineStyle().setThickness(3); + style.dataStyle().fillStyle().setVisible(true); + style.dataStyle().fillStyle().setOpacity(.30); + if (sensor.isTopLayer()) { + style.dataStyle().fillStyle().setColor("31, 137, 229, 1"); + style.dataStyle().outlineStyle().setColor("31, 137, 229, 1"); + } else { + style.dataStyle().fillStyle().setColor("93, 228, 47, 1"); + style.dataStyle().outlineStyle().setColor("93, 228, 47, 1"); + } + style.dataStyle().errorBarStyle().setVisible(false); + + // Turn off the legend + style.legendBoxStyle().setVisible(false); + + style.regionBoxStyle().backgroundStyle().setOpacity(.20); + setBackgroundColor(style, sensor.isAxial(), isAlarming); + + return style; + } + + private void setBackgroundColor(IPlotterStyle style, boolean isAxial, boolean isAlarming) { + if (isAlarming) { + style.regionBoxStyle().backgroundStyle().setColor("246, 34, 34, 1"); + return; + } + if (isAxial) + style.regionBoxStyle().backgroundStyle().setColor("246, 246, 34, 1"); + } + + /** + * Clear all histograms of it's current data. + */ + private void resetPlots() { + + // Clear the hit counter map of all previously stored data. + occupancyMap.clear(); + + // Since all plots are mapped to the name of a sensor, loop + // through the sensors, get the corresponding plots and clear them. + for (HpsSiSensor sensor : sensors) { + + // Clear the occupancy plots. + occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + + if (enableMaxSamplePlots) + maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + + // Reset the hit counters. + occupancyMap.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), new int[640]); + } + } + + private static int getLayerNumber(HpsSiSensor sensor) { + return (int) Math.ceil(((double) sensor.getLayerNumber()) / 2); + } + + @Override + protected void detectorChanged(Detector detector) { + + // Get the HpsSiSensor objects from the geometry + sensors = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HpsSiSensor.class); + + // If there were no sensors found, throw an exception + if (sensors.isEmpty()) + throw new RuntimeException("There are no sensors associated with this detector"); + + // For each sensor, create a mapping between a physical channel number + // and the global strip position + this.createStripPositionMap(); + + // // If the tree already exist, clear all existing plots of any old data + // // they might contain. + // if (tree != null) { + // this.resetPlots(); + // return; + // } + // tree = analysisFactory.createTreeFactory().create(); + tree = AIDA.defaultInstance().tree(); + tree.cd("/"); + histogramFactory = analysisFactory.createHistogramFactory(tree); + + plotters.put("Occupancy: L0-L3", plotterFactory.create("Occupancy: L0-L3")); + plotters.get("Occupancy: L0-L3").createRegions(4, 4); + plotters.put("Occupancy: L4-L6", plotterFactory.create("Occupancy: L4-L6")); + plotters.get("Occupancy: L4-L6").createRegions(6, 4); + + occupancyStatus.setStatus(StatusCode.UNKNOWN, "Not enough statistics yet."); + + if (enableMaxSamplePlots) { + plotters.put("Max Sample Number: L0-L3", plotterFactory.create("Max Sample Number: L0-L3")); + plotters.get("Max Sample Number: L0-L3").createRegions(4, 4); + plotters.put("Max Sample Number: L4-L6", plotterFactory.create("Max Sample Number: L4-L6")); + plotters.get("Max Sample Number: L4-L6").createRegions(6, 4); + maxSampleStatus.setStatus(StatusCode.UNKNOWN, "Not enough statistics yet."); + } else + maxSampleStatus.setStatus(StatusCode.UNKNOWN, "Monitor disabled in steering file."); + + for (HpsSiSensor sensor : sensors) { + + occupancyPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Occupancy", 640, 0, 640)); + + if (sensor.getLayerNumber() < 9) + plotters.get("Occupancy: L0-L3") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createOccupancyPlotStyle("Physical Channel", sensor, false)); + else + plotters.get("Occupancy: L4-L6") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createOccupancyPlotStyle("Physical Channel", sensor, false)); + + occupancyMap.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), new int[640]); + + if (enableMaxSamplePlots) { + maxSamplePositionPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Max Sample Number", 6, -0.5, 5.5)); + if (sensor.getLayerNumber() < 9) + plotters.get("Max Sample Number: L0-L3") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createOccupancyPlotStyle("Max Sample Number", sensor, false)); + else + plotters.get("Max Sample Number: L4-L6") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createOccupancyPlotStyle("Max Sample Number", sensor, false)); + } + } + + IPlotter plotter = plotters.get("Occupancy: L0-L3"); + for (int i = 0; i < plotter.numberOfRegions(); i++) + plotter.region(i).setYLimits(occupancyYRange1); + + plotter = plotters.get("Occupancy: L4-L6"); + for (int i = 0; i < plotter.numberOfRegions(); i++) + plotter.region(i).setYLimits(occupancyYRange2); + + for (IPlotter plotterShow : plotters.values()) + plotterShow.show(); + } + + private boolean passTriggerFilter(List triggerBanks) { + + // Loop through the collection of banks and get the TI banks. + for (GenericObject triggerBank : triggerBanks) + + // If the bank contains TI data, process it + if (AbstractIntData.getTag(triggerBank) == TIData.BANK_TAG) { + + TIData tiData = new TIData(triggerBank); + + if (filterPulserTriggers && tiData.isPulserTrigger()) + return false; + else if (filterSingle0Triggers && tiData.isSingle0Trigger()) + return false; + else if (filterSingle1Triggers && tiData.isSingle1Trigger()) + return false; + else if (filterPair0Triggers && tiData.isPair0Trigger()) + return false; + else if (filterPair1Triggers && tiData.isPair1Trigger()) + return false; + } + return true; + } + + @Override + public void process(EventHeader event) { + + // Get the run number from the event and store it. This will be used + // when writing the plots out to a ROOT file + if (runNumber == -1) + runNumber = event.getRunNumber(); + if (enableTriggerFilter && event.hasCollection(GenericObject.class, triggerBankCollectionName)) { + LOGGER.info("Filtering Event"); + // Get the list of trigger banks from the event + List triggerBanks = event.get(GenericObject.class, triggerBankCollectionName); + + // Apply the trigger filter + if (!passTriggerFilter(triggerBanks)) + return; + } + + // If the event doesn't have a collection of RawTrackerHit's, skip it. + if (!event.hasCollection(RawTrackerHit.class, rawTrackerHitCollectionName)) { + LOGGER.warning("No SVT RawTrackerHits in this event."); + return; + } + // Get RawTrackerHit collection from event. + List rawHits = event.get(RawTrackerHit.class, rawTrackerHitCollectionName); + +// System.out.println("Number of SVT RawTrackerHts = " + rawHits.size()); + if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) + return; + + if (resetPeriod > 0 && eventCount > resetPeriod) { // reset occupancy numbers after resetPeriod events + eventCount = 0; + resetPlots(); + } + + eventCount++; + + // Increment strip hit count. + for (RawTrackerHit rawHit : rawHits) { + // Obtain the raw ADC samples for each of the six samples readout + short[] adcValues = rawHit.getADCValues(); + + // Find the sample that has the largest amplitude. This should + // correspond to the peak of the shaper signal if the SVT is timed + // in correctly. Otherwise, the maximum sample value will default + // to 0. + int maxAmplitude = 0; + int maxSamplePositionFound = -1; + for (int sampleN = 0; sampleN < 6; sampleN++) + if (adcValues[sampleN] > maxAmplitude) { + maxAmplitude = adcValues[sampleN]; + maxSamplePositionFound = sampleN; + } + if (maxSamplePosition == -1 || maxSamplePosition == maxSamplePositionFound) + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) rawHit.getDetectorElement()).getName()))[rawHit + .getIdentifierFieldValue("strip")]++; // System.out.println("Filling occupancy"); + + if (enableMaxSamplePlots) + maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) rawHit.getDetectorElement()).getName())).fill( + maxSamplePositionFound); + } + + if (enableMaxSamplePlots && eventCount > maxSampleMonitorStart && eventCount % maxSampleMonitorPeriod == 0) + checkMaxSample(); + + if (eventCount > occupancyMonitorStart && eventCount % occupancyMonitorPeriod == 0) + checkOccupancy(); + + // Plot strip occupancies. + if (eventCount % eventRefreshRate == 0) + for (HpsSiSensor sensor : sensors) { + int[] strips = occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); + occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + + for (int channel = 0; channel < strips.length; channel++) { + double stripOccupancy = (double) strips[channel] / (double) eventCount; + + stripOccupancy /= this.timeWindowWeight; + // System.out.println("channel " + channel + " occupancy = " + stripOccupancy); + occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(channel, stripOccupancy); + + } + + } + + if (plotters.get("Occupancy") != null) + plotters.get("Occupancy").refresh(); + + } + + private void checkMaxSample() { + StatusCode oldStatus = maxSampleStatus.getStatusCode(); + boolean isSystemOK = true; + + String label = "foo"; + for (HpsSiSensor sensor : sensors) { + + if (sensor.getLayerNumber() < 9) + label = "Max Sample Number: L0-L3"; + else + label = "Max Sample Number: L4-L6"; + IHistogram1D maxSamplePlot = maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); +// IPlotterRegion region = plotters.get("Max Sample Number").region(SvtPlotUtils.computePlotterRegion(sensor)); + IPlotterRegion region = plotters.get(label).region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)); + + boolean isSensorOK = maxSamplePlot.binEntries(maxSamplePosition) > maxSamplePlot + .binEntries(maxSamplePosition - 1) + && maxSamplePlot.binEntries(maxSamplePosition) > maxSamplePlot.binEntries(maxSamplePosition + 1); + if (!isSensorOK) { + isSystemOK = false; + if (oldStatus != StatusCode.ALARM) + maxSampleStatus.setStatus(StatusCode.ALARM, "Sensor " + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " looks out of time."); + IPlotterStyle plotterStyle = createOccupancyPlotStyle("Max Sample Number", sensor, true); + // region.clear(); + // region.plot(maxSamplePlot, plotterStyle); + region.applyStyle(plotterStyle); + // region.style().regionBoxStyle().backgroundStyle().setColor("246, 34, 34, 1"); + // setBackgroundColor(region.style(),sensor.isAxial(),true); + + } else { + IPlotterStyle plotterStyle = createOccupancyPlotStyle("Max Sample Number", sensor, false); + // region.clear(); + // region.plot(maxSamplePlot, plotterStyle); + region.applyStyle(plotterStyle); + // setBackgroundColor(region.style(),sensor.isAxial(),false); + } + } + if (isSystemOK) + if (oldStatus != StatusCode.OKAY) + maxSampleStatus.setStatus(StatusCode.OKAY, "All sensors are timed in."); + } + + private void checkOccupancy() { + StatusCode oldStatus = occupancyStatus.getStatusCode(); + boolean isSystemOK = true; + String label = "foo"; + for (HpsSiSensor sensor : sensors) { + if (sensor.getLayerNumber() < 9) + label = "Occupancy: L0-L3"; + else + label = "Occupancy: L4-L6"; + + IHistogram1D occupancyPlot = occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); + IPlotterRegion region = plotters.get(label).region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)); + + double apvOccupancy[] = new double[5]; + for (int i = 0; i < occupancyPlot.axis().bins(); i++) + apvOccupancy[i / 128] += occupancyPlot.binHeight(i); + for (int i = 0; i < 5; i++) + apvOccupancy[i] /= 128.0; + + boolean isSensorOK = isOccupancyOK(apvOccupancy); + if (!isSensorOK) { + LOGGER.info(String.format("%s: %f %f %f %f %f\n", + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), apvOccupancy[0], apvOccupancy[1], + apvOccupancy[2], apvOccupancy[3], apvOccupancy[4])); + isSystemOK = false; + if (oldStatus != StatusCode.ALARM) + occupancyStatus.setStatus(StatusCode.ALARM, "Sensor " + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " occupancy abnormal."); + IPlotterStyle plotterStyle = createOccupancyPlotStyle("Max Sample Number", sensor, true); + // region.clear(); + // region.plot(occupancyPlot, plotterStyle); + region.applyStyle(plotterStyle); + + } else { + IPlotterStyle plotterStyle = createOccupancyPlotStyle("Max Sample Number", sensor, false); + // region.clear(); + // region.plot(occupancyPlot, plotterStyle); + region.applyStyle(plotterStyle); + } + } + if (isSystemOK) + if (oldStatus != StatusCode.OKAY) + occupancyStatus.setStatus(StatusCode.OKAY, "Occupancy looks OK."); + } + + private boolean isOccupancyOK(double[] apvOccupancy) { + double peakOccupancy = 0; + int highestApv = -1; + for (int i = 0; i < 5; i++) + if (apvOccupancy[i] > peakOccupancy) { + peakOccupancy = apvOccupancy[i]; + highestApv = i; + } + if (highestApv != 0 && highestApv != 4) { + LOGGER.warning("peak occupancy not at edge"); + return false; + } + if (peakOccupancy > maxPeakOccupancy || peakOccupancy < minPeakOccupancy) { + LOGGER.warning("peak occupancy out of range"); + return false; + } + if (highestApv == 0) + for (int i = 4; i > 0; i--) { + if (apvOccupancy[i] < 0.1 * peakOccupancy || apvOccupancy[i] < minPeakOccupancy) + continue; // skip through the tail end of the sensor + if (0.9 * apvOccupancy[i] > apvOccupancy[i - 1]) { + LOGGER.warning("occupancy not monotonic"); + return false; + } + } + else if (highestApv == 4) + for (int i = 0; i < 4; i++) { + if (apvOccupancy[i] < 0.1 * peakOccupancy || apvOccupancy[i] < minPeakOccupancy) + continue; // skip through the tail end of the sensor + if (0.9 * apvOccupancy[i] > apvOccupancy[i + 1]) { + LOGGER.warning("occupancy not monotonic"); + return false; + } + } + + return true; + } + + @Override + public void endOfData() { + + if (saveRootFile) { + String rootFile = "run" + runNumber + "_occupancy.root"; + RootFileStore store = new RootFileStore(rootFile); + try { + store.open(); + store.add(tree); + store.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + System.out.println("%===============================================================================%"); + System.out.println("%======================== Active Edge Sensor Occupancies =======================%"); + System.out.println("%===============================================================================%"); + System.out.println("% Total Events: " + eventCount); + // Calculate the occupancies at the sensor edge + + int[] topActiveEdgeStripOccupancy = new int[7]; + int[] bottomActiveEdgeStripOccupancy = new int[7]; + for (HpsSiSensor sensor : sensors) + if (sensor.isTopLayer() && sensor.isAxial()) + + if (sensor.getSide().equals(HpsSiSensor.ELECTRON_SIDE)) { + System.out.println("% Top Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]); + topActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]; + } else { + System.out.println("% Top Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]); + topActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]; + } + else if (sensor.isBottomLayer() && sensor.isAxial()) + if (sensor.getSide().equals(HpsSiSensor.ELECTRON_SIDE)) { + System.out.println("% Bottom Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]); + bottomActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]; + } else { + System.out.println("% Bottom Layer " + getLayerNumber(sensor) + " Hit Counts: " + + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]); + bottomActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]; + } + + for (int layerN = 0; layerN < 6; layerN++) { + double topStripOccupancy = (double) topActiveEdgeStripOccupancy[layerN] / (double) eventCount; + topStripOccupancy /= this.timeWindowWeight; + System.out.println("% Top Layer " + (layerN + 1) + ": Occupancy in " + (24 / this.timeWindowWeight) + + " ns window: " + topStripOccupancy); + double botStripOccupancy = (double) bottomActiveEdgeStripOccupancy[layerN] / (double) eventCount; + botStripOccupancy /= this.timeWindowWeight; + System.out.println("% Bottom Layer " + (layerN + 1) + ": Occupancy in " + (24 / this.timeWindowWeight) + + " ns window: " + botStripOccupancy); + } + System.out.println("%===============================================================================%"); + System.out.println("%===============================================================================%"); + } +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/ClusterOccupancyPlotsDriver.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/ClusterOccupancyPlotsDriver.java index 0cfc1f07e0..002c08a856 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/ClusterOccupancyPlotsDriver.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/ClusterOccupancyPlotsDriver.java @@ -22,7 +22,7 @@ import org.lcsim.detector.tracker.silicon.ChargeCarrier; import org.lcsim.detector.tracker.silicon.DopedSilicon; import org.lcsim.detector.tracker.silicon.HpsSiSensor; -import org.lcsim.detector.tracker.silicon.SiStrips; +import org.lcsim.detector.tracker.silicon.SiSensorElectrodes; import org.lcsim.event.EventHeader; import org.lcsim.event.GenericObject; import org.lcsim.event.RawTrackerHit; @@ -164,7 +164,7 @@ public static Map createStripPositionMap(HpsSiSensor sensor Map positionMap = new HashMap(); for (ChargeCarrier carrier : ChargeCarrier.values()) if (sensor.hasElectrodesOnSide(carrier)) { - SiStrips strips = (SiStrips) sensor.getReadoutElectrodes(carrier); + SiSensorElectrodes strips = (SiSensorElectrodes) sensor.getReadoutElectrodes(carrier); ITransform3D parentToLocal = sensor.getReadoutElectrodes(carrier).getParentToLocal(); ITransform3D localToGlobal = sensor.getReadoutElectrodes(carrier).getLocalToGlobal(); for (int physicalChannel = 0; physicalChannel < 640; physicalChannel++) { diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/PedestalPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/PedestalPlots.java index 5e244237c7..50b32d20d8 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/PedestalPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/PedestalPlots.java @@ -37,7 +37,7 @@ public class PedestalPlots extends Driver { // Histogram maps private static Map plotters = new HashMap(); - private static Map occupancyPlots = new HashMap(); + private AIDA aida = AIDA.defaultInstance(); List sensors; @@ -81,16 +81,22 @@ protected void detectorChanged(Detector detector) { sensors = detector.getSubdetector(subdetectorName).getDetectorElement().findDescendants(HpsSiSensor.class); - plotters.put("Pedestal vs. channel", plotterFactory.create("Pedestal vs. channel")); - plotters.get("Pedestal vs. channel").createRegions(6, 6); + + plotters.put("Pedestal vs. channel: L0-L3", plotterFactory.create("Pedestal vs. channel: L0-L3")); + plotters.get("Pedestal vs. channel: L0-L3").createRegions(4, 4); + plotters.put("Pedestal vs. channel: L4-L6", plotterFactory.create("Pedestal vs. channel: L4-L6")); + plotters.get("Pedestal vs. channel: L4-L6").createRegions(6, 4); // ===> for (SiSensor sensor : SvtUtils.getInstance().getSensors()) { for (HpsSiSensor sensor : sensors) { hists.put(sensor, - aida.histogram2D(sensor.getName() + " sample 1 vs. ch", 640, -0.5, 639.5, 100, -500.0, 500.0)); - plotters.get("Pedestal vs. channel").region(SvtPlotUtils.computePlotterRegion(sensor)) + aida.histogram2D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " sample 1 vs. ch", 640, -0.5, 639.5, 100, -500.0, 500.0)); + if (sensor.getLayerNumber() < 9) + plotters.get("Pedestal vs. channel: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(hists.get(sensor), SvtPlotUtils.createStyle(plotterFactory, sensor, "Channel", "Sample 1")); + else + plotters.get("Pedestal vs. channel: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(hists.get(sensor), SvtPlotUtils.createStyle(plotterFactory, sensor, "Channel", "Sample 1")); - if (plotTimeSeries) { counts.put(sensor, new int[640]); means.put(sensor, new double[640]); @@ -99,7 +105,7 @@ protected void detectorChanged(Detector detector) { plots.put(sensor, plotArray); for (int i = 0; i < 640; i++) { plotArray[i] = aida.analysisFactory().createDataPointSetFactory(aida.tree()) - .create(sensor.getName() + ", channel " + i + " pedestal vs. event", 2); + .create(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + ", channel " + i + " pedestal vs. event", 2); } } } diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SVTPulseFitPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SVTPulseFitPlots.java index 42be182e6d..48a5eee7cd 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SVTPulseFitPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SVTPulseFitPlots.java @@ -19,8 +19,11 @@ import org.hps.readout.svt.HPSSVTConstants; import org.hps.recon.tracking.FittedRawTrackerHit; import org.hps.recon.tracking.SvtPlotUtils; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TSData2019; import org.lcsim.detector.tracker.silicon.HpsSiSensor; import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; import org.lcsim.geometry.Detector; import org.lcsim.recon.cat.util.Const; import org.lcsim.util.Driver; @@ -43,6 +46,21 @@ public class SVTPulseFitPlots extends Driver { private static final String subdetectorName = "Tracker"; private SvtTimingConstants timingConstants; + private boolean correctForT0Offset = false; + private boolean doShapePlots = false; + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } + + public void setCorrectForT0Offset(boolean correct) { + this.correctForT0Offset = correct; + } + + public void setDoShapePlots(boolean doit) { + this.doShapePlots = doit; + } @Override protected void detectorChanged(Detector detector) { @@ -52,52 +70,108 @@ protected void detectorChanged(Detector detector) { List sensors = detector.getSubdetector(subdetectorName).getDetectorElement() .findDescendants(HpsSiSensor.class); + tree = AIDA.defaultInstance().tree(); + tree.cd("/"); + boolean dirExists = false; + String dirName = "/SVTPulseFits"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + + plotters.put("Timing: L0-L3", plotterFactory.create("3a Timing")); + plotters.get("Timing: L0-L3").createRegions(4, 4); + plotters.put("Timing: L4-L6", plotterFactory.create("3b Timing")); + plotters.get("Timing: L4-L6").createRegions(6, 4); + + plotters.put("Amplitude: L0-L3", plotterFactory.create("3c Amplitude")); + plotters.get("Amplitude: L0-L3").createRegions(4, 4); + plotters.put("Amplitude: L4-L6", plotterFactory.create("3d Amplitude")); + plotters.get("Amplitude: L4-L6").createRegions(6, 4); + + plotters.put("Chisq: L0-L3", plotterFactory.create("3e Chisq")); + plotters.get("Chisq: L0-L3").createRegions(4, 4); + plotters.put("Chisq: L4-L6", plotterFactory.create("3f Chisq")); + plotters.get("Chisq: L4-L6").createRegions(6, 4); + + plotters.put("A vs. T0: L0-L3", plotterFactory.create("3g A vs. T0")); + plotters.get("A vs. T0: L0-L3").createRegions(4, 4); + plotters.put("A vs. T0: L4-L6", plotterFactory.create("3h A vs. T0")); + plotters.get("A vs. T0: L4-L6").createRegions(6, 4); + if (this.doShapePlots) { + plotters.put("Pulse shape: L0-L3", plotterFactory.create("3i Pulse shape")); + plotters.get("Pulse shape: L0-L3").createRegions(4, 4); + plotters.put("Pulse shape: L4-L6", plotterFactory.create("3j Pulse shape")); + plotters.get("Pulse shape: L4-L6").createRegions(6, 4); + } + tree = AIDA.defaultInstance().tree(); + IHistogramFactory histogramFactory = analysisFactory.createHistogramFactory(tree); - plotters.put("Timing", plotterFactory.create("Timing")); - plotters.get("Timing").createRegions(6, 6); - - plotters.put("Amplitude", plotterFactory.create("Amplitude")); - plotters.get("Amplitude").createRegions(6, 6); - - plotters.put("Chisq", plotterFactory.create("Chisq")); - plotters.get("Chisq").createRegions(6, 6); + // Setup the occupancy plots. + for (HpsSiSensor sensor : sensors) { - plotters.put("A vs. T0", plotterFactory.create("A vs. T0")); - plotters.get("A vs. T0").createRegions(6, 6); + t0Plots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D( + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + "_timing", 50, -100, 100.0)); - plotters.put("Pulse shape", plotterFactory.create("Pulse shape")); - plotters.get("Pulse shape").createRegions(6, 6); + ampPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D( + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + "_amplitude", 50, 0, 2000.0)); - tree = analysisFactory.createTreeFactory().create(); - IHistogramFactory histogramFactory = analysisFactory.createHistogramFactory(tree); + chiprobPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory + .createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + "_chiprob", 50, 0, 1.0)); - // Setup the occupancy plots. - for (HpsSiSensor sensor : sensors) { + t0aPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram2D( + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " A vs. T0", 100, -100, 100, 100, 0, 2000)); + if (this.doShapePlots) { + shapePlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram2D( + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " Shape", 100, + -1 * SAMPLING_INTERVAL, 6 * SAMPLING_INTERVAL, 100, -0.5, 1.5)); + } + if (sensor.getLayerNumber() < 9) { + plotters.get("Timing: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)).plot( + t0Plots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Hit time [ns]", "")); + plotters.get("Amplitude: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)).plot( + ampPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Hit amplitude [ADC]", "")); + plotters.get("Chisq: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)).plot( + chiprobPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Chisq probability", "")); + plotters.get("A vs. T0: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)).plot( + t0aPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Hit time [ns]", "Hit amplitude [ADC]")); + if (this.doShapePlots) { + plotters.get("Pulse shape: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(shapePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Time after hit [ns]", "Normalized amplitude")); + } + } else { + plotters.get("Timing: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)).plot( + t0Plots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Hit time [ns]", "")); + plotters.get("Amplitude: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)).plot( + ampPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Hit amplitude [ADC]", "")); + plotters.get("Chisq: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)).plot( + chiprobPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Chisq probability", "")); + plotters.get("A vs. T0: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)).plot( + t0aPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Hit time [ns]", "Hit amplitude [ADC]")); + if (this.doShapePlots) { + plotters.get("Pulse shape: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(shapePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Time after hit [ns]", "Normalized amplitude")); + } - t0Plots.put(sensor.getName(), - histogramFactory.createHistogram1D(sensor.getName() + "_timing", 50, -100, 100.0)); - plotters.get("Timing").region(SvtPlotUtils.computePlotterRegion(sensor)) - .plot(t0Plots.get(sensor.getName()), this.createStyle(sensor, "Hit time [ns]", "")); - ampPlots.put(sensor.getName(), - histogramFactory.createHistogram1D(sensor.getName() + "_amplitude", 50, 0, 2000.0)); - plotters.get("Amplitude").region(SvtPlotUtils.computePlotterRegion(sensor)) - .plot(ampPlots.get(sensor.getName()), this.createStyle(sensor, "Hit amplitude [ADC]", "")); - chiprobPlots.put(sensor.getName(), - histogramFactory.createHistogram1D(sensor.getName() + "_chiprob", 100, 0, 1.0)); - plotters.get("Chisq").region(SvtPlotUtils.computePlotterRegion(sensor)) - .plot(chiprobPlots.get(sensor.getName()), this.createStyle(sensor, "Chisq probability", "")); - t0aPlots.put(sensor.getName(), - histogramFactory.createHistogram2D(sensor.getName() + " A vs. T0", 100, -100, 100, 100, 0, 2000)); - plotters.get("A vs. T0") - .region(SvtPlotUtils.computePlotterRegion(sensor)) - .plot(t0aPlots.get(sensor.getName()), - this.createStyle(sensor, "Hit time [ns]", "Hit amplitude [ADC]")); - shapePlots.put(sensor.getName(), histogramFactory.createHistogram2D(sensor.getName() + " Shape", 200, -1 - * SAMPLING_INTERVAL, 6 * SAMPLING_INTERVAL, 100, -0.5, 1.5)); - plotters.get("Pulse shape") - .region(SvtPlotUtils.computePlotterRegion(sensor)) - .plot(shapePlots.get(sensor.getName()), - this.createStyle(sensor, "Time after hit [ns]", "Normalized amplitude")); + } } for (IPlotter plotter : plotters.values()) { @@ -128,6 +202,18 @@ public void setFittedTrackerHitCollectionName(String fittedTrackerHitCollectionN @Override public void process(EventHeader event) { + if (removeRandomEvents && event.hasCollection(GenericObject.class, "TSBank")) { + List triggerList = event.get(GenericObject.class, "TSBank"); + for (GenericObject data : triggerList) { + if (AbstractIntData.getTag(data) == TSData2019.BANK_TAG) { + TSData2019 triggerData = new TSData2019(data); + if (triggerData.isPulserTrigger() || triggerData.isFaradayCupTrigger()) { + return; + } + } + } + } + List fittedrawHits = event.get(FittedRawTrackerHit.class, fittedTrackerHitCollectionName); for (FittedRawTrackerHit fit : fittedrawHits) { HpsSiSensor sensor = (HpsSiSensor) fit.getRawTrackerHit().getDetectorElement(); @@ -140,17 +226,24 @@ public void process(EventHeader event) { double offset = timingConstants.getOffsetTime() + (((event.getTimeStamp() - 4 * timingConstants.getOffsetPhase()) % 24) - 12) + sensor.getShapeFitParameters(strip)[HpsSiSensor.T0_INDEX] + sensor.getT0Shift() + tof; + if (!correctForT0Offset) { + offset = 0.0; + } - t0Plots.get(sensor.getName()).fill(fittedT0); - ampPlots.get(sensor.getName()).fill(fittedAmp); - chiprobPlots.get(sensor.getName()).fill(fit.getShapeFitParameters().getChiProb()); - - t0aPlots.get(sensor.getName()).fill(fit.getT0(), fit.getAmp()); - if (fit.getAmp() > 4 * sensor.getNoise(strip, 0)) { - for (int i = 0; i < fit.getRawTrackerHit().getADCValues().length; i++) { - shapePlots.get(sensor.getName()).fill( - (i * HPSSVTConstants.SAMPLING_INTERVAL - fit.getT0() - offset), - (fit.getRawTrackerHit().getADCValues()[i] - sensor.getPedestal(strip, i)) / fit.getAmp()); + t0Plots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(fittedT0); + ampPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(fittedAmp); + chiprobPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())) + .fill(fit.getShapeFitParameters().getChiProb()); + + t0aPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(fit.getT0(), fit.getAmp()); + if (this.doShapePlots) { + if (fit.getAmp() > 4 * sensor.getNoise(strip, 0)) { + for (int i = 0; i < fit.getRawTrackerHit().getADCValues().length; i++) { + shapePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill( + (i * HPSSVTConstants.SAMPLING_INTERVAL - fit.getT0() - offset), + (fit.getRawTrackerHit().getADCValues()[i] - sensor.getPedestal(strip, i)) + / fit.getAmp()); + } } } } diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SensorOccupancyPlotsDriver.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SensorOccupancyPlotsDriver.java index ff5658fcc6..3e322144cd 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SensorOccupancyPlotsDriver.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SensorOccupancyPlotsDriver.java @@ -24,10 +24,12 @@ import org.hps.recon.tracking.SvtPlotUtils; import org.hps.record.triggerbank.AbstractIntData; import org.hps.record.triggerbank.TIData; +import org.hps.record.triggerbank.TSData2019; import org.lcsim.detector.ITransform3D; import org.lcsim.detector.tracker.silicon.ChargeCarrier; import org.lcsim.detector.tracker.silicon.HpsSiSensor; -import org.lcsim.detector.tracker.silicon.SiStrips; +//import org.lcsim.detector.tracker.silicon.SiStrips; +//import org.lcsim.detector.tracker.silicon.SiStriplets; import org.lcsim.event.EventHeader; import org.lcsim.event.GenericObject; import org.lcsim.event.RawTrackerHit; @@ -36,6 +38,7 @@ import org.lcsim.recon.tracking.digitization.sisim.TrackerHitType; import org.lcsim.util.Driver; import org.lcsim.util.aida.AIDA; +import org.lcsim.detector.tracker.silicon.SiSensorElectrodes; /** * This Driver makes plots of SVT sensor occupancies across a run. @@ -48,7 +51,7 @@ public class SensorOccupancyPlotsDriver extends Driver { // Logger private static Logger LOGGER = Logger.getLogger(SensorOccupancyPlotsDriver.class.getCanonicalName()); - + // Plotting private static ITree tree = null; private IAnalysisFactory analysisFactory = AIDA.defaultInstance().analysisFactory(); @@ -103,13 +106,20 @@ public class SensorOccupancyPlotsDriver extends Driver { private boolean enableClusterTimeCuts = true; private double clusterTimeCutMax = 4.0; private double clusterTimeCutMin = -4.0; - + private boolean saveRootFile = true; - + // Max Y range for occupancy plots. private double occupancyYRange1 = 0.03; private double occupancyYRange2 = 0.003; + private boolean enableAlarms = false; + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } + public SensorOccupancyPlotsDriver() { maxSampleStatus = new SystemStatusImpl(Subsystem.SVT, "Checks that SVT is timed in (max sample plot)", true); maxSampleStatus.setStatus(StatusCode.UNKNOWN, "Status is unknown."); @@ -204,11 +214,15 @@ public void setSaveRootFile(boolean saveRootFile) { public void setOccupancyYRange1(double occupancyYRange1) { this.occupancyYRange1 = occupancyYRange1; } - + public void setOccupancyYRange2(double occupancyYRange2) { this.occupancyYRange2 = occupancyYRange2; } - + + public void setEnableAlarms(boolean enable) { + this.enableAlarms = enable; + } + /** * Get the global strip position of a physical channel number for a given * sensor. @@ -227,15 +241,17 @@ private Hep3Vector getStripPosition(HpsSiSensor sensor, int physicalChannel) { */ // TODO: Move this to a utility class private void createStripPositionMap() { - for (HpsSiSensor sensor : sensors) + for (HpsSiSensor sensor : sensors) { stripPositions.put(sensor, createStripPositionMap(sensor)); + } } public static Map createStripPositionMap(HpsSiSensor sensor) { Map positionMap = new HashMap(); - for (ChargeCarrier carrier : ChargeCarrier.values()) + for (ChargeCarrier carrier : ChargeCarrier.values()) { if (sensor.hasElectrodesOnSide(carrier)) { - SiStrips strips = (SiStrips) sensor.getReadoutElectrodes(carrier); + // SiSensorElectrodes electrodes = sensor.getReadoutElectrodes(); + SiSensorElectrodes strips = (SiSensorElectrodes) sensor.getReadoutElectrodes(carrier); ITransform3D parentToLocal = sensor.getReadoutElectrodes(carrier).getParentToLocal(); ITransform3D localToGlobal = sensor.getReadoutElectrodes(carrier).getLocalToGlobal(); for (int physicalChannel = 0; physicalChannel < 640; physicalChannel++) { @@ -245,6 +261,7 @@ public static Map createStripPositionMap(HpsSiSensor sensor positionMap.put(physicalChannel, globalStripPosition); } } + } return positionMap; } @@ -303,8 +320,9 @@ private void setBackgroundColor(IPlotterStyle style, boolean isAxial, boolean is style.regionBoxStyle().backgroundStyle().setColor("246, 34, 34, 1"); return; } - if (isAxial) + if (isAxial) { style.regionBoxStyle().backgroundStyle().setColor("246, 246, 34, 1"); + } } /** @@ -328,8 +346,9 @@ private void resetPlots() { clusterPositionPlotCounts.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); } - if (enableMaxSamplePlots) + if (enableMaxSamplePlots) { maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + } // Reset the hit counters. occupancyMap.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), new int[640]); @@ -347,8 +366,9 @@ protected void detectorChanged(Detector detector) { sensors = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HpsSiSensor.class); // If there were no sensors found, throw an exception - if (sensors.isEmpty()) + if (sensors.isEmpty()) { throw new RuntimeException("There are no sensors associated with this detector"); + } // For each sensor, create a mapping between a physical channel number // and the global strip position @@ -363,46 +383,62 @@ protected void detectorChanged(Detector detector) { // tree = analysisFactory.createTreeFactory().create(); tree = AIDA.defaultInstance().tree(); tree.cd("/"); + boolean dirExists = false; + String dirName = "/SVTOccupancy"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + histogramFactory = analysisFactory.createHistogramFactory(tree); - plotters.put("Occupancy: L0-L3", plotterFactory.create("Occupancy: L0-L3")); + plotters.put("Occupancy: L0-L3", plotterFactory.create("1a Occupancy: L0-L3")); plotters.get("Occupancy: L0-L3").createRegions(4, 4); - plotters.put("Occupancy: L4-L6", plotterFactory.create("Occupancy: L4-L6")); + plotters.put("Occupancy: L4-L6", plotterFactory.create("1b Occupancy: L4-L6")); plotters.get("Occupancy: L4-L6").createRegions(6, 4); occupancyStatus.setStatus(StatusCode.UNKNOWN, "Not enough statistics yet."); if (enablePositionPlots) { - plotters.put("Occupancy vs Position", plotterFactory.create("Occupancy vs Position")); + plotters.put("Occupancy vs Position", plotterFactory.create("1e Occupancy vs Position")); plotters.get("Occupancy vs Position").createRegions(6, 6); - plotters.put("Cluster occupancy vs Position", plotterFactory.create("Cluster occupancy vs Position")); + plotters.put("Cluster occupancy vs Position", plotterFactory.create("1f Cluster occupancy vs Position")); plotters.get("Cluster occupancy vs Position").createRegions(6, 6); } if (enableMaxSamplePlots) { - plotters.put("Max Sample Number: L0-L3", plotterFactory.create("Max Sample Number: L0-L3")); + plotters.put("Max Sample Number: L0-L3", plotterFactory.create("1c Max Sample Number: L0-L3")); plotters.get("Max Sample Number: L0-L3").createRegions(4, 4); - plotters.put("Max Sample Number: L4-L6", plotterFactory.create("Max Sample Number: L4-L6")); + plotters.put("Max Sample Number: L4-L6", plotterFactory.create("1d Max Sample Number: L4-L6")); plotters.get("Max Sample Number: L4-L6").createRegions(6, 4); maxSampleStatus.setStatus(StatusCode.UNKNOWN, "Not enough statistics yet."); - } else + } else { maxSampleStatus.setStatus(StatusCode.UNKNOWN, "Monitor disabled in steering file."); + } for (HpsSiSensor sensor : sensors) { occupancyPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Occupancy", 640, 0, 640)); - if (sensor.getLayerNumber() < 9) + if (sensor.getLayerNumber() < 9) { plotters.get("Occupancy: L0-L3") .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createOccupancyPlotStyle("Physical Channel", sensor, false)); - else + } else { plotters.get("Occupancy: L4-L6") .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createOccupancyPlotStyle("Physical Channel", sensor, false)); + } if (enablePositionPlots) { if (sensor.isTopLayer()) { @@ -435,16 +471,17 @@ protected void detectorChanged(Detector detector) { if (enableMaxSamplePlots) { maxSamplePositionPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Max Sample Number", 6, -0.5, 5.5)); - if (sensor.getLayerNumber() < 9) + if (sensor.getLayerNumber() < 9) { plotters.get("Max Sample Number: L0-L3") .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createOccupancyPlotStyle("Max Sample Number", sensor, false)); - else + } else { plotters.get("Max Sample Number: L4-L6") .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createOccupancyPlotStyle("Max Sample Number", sensor, false)); + } } } @@ -457,50 +494,64 @@ protected void detectorChanged(Detector detector) { for (int i = 0; i < plotter.numberOfRegions(); i++) { plotter.region(i).setYLimits(occupancyYRange2); } - - for (IPlotter plotterShow : plotters.values()) + + for (IPlotter plotterShow : plotters.values()) { plotterShow.show(); + } } private boolean passTriggerFilter(List triggerBanks) { // Loop through the collection of banks and get the TI banks. - for (GenericObject triggerBank : triggerBanks) - - // If the bank contains TI data, process it + for (GenericObject triggerBank : triggerBanks) // If the bank contains TI data, process it + { if (AbstractIntData.getTag(triggerBank) == TIData.BANK_TAG) { TIData tiData = new TIData(triggerBank); - if (filterPulserTriggers && tiData.isPulserTrigger()) + if (filterPulserTriggers && tiData.isPulserTrigger()) { return false; - else if (filterSingle0Triggers && tiData.isSingle0Trigger()) + } else if (filterSingle0Triggers && tiData.isSingle0Trigger()) { return false; - else if (filterSingle1Triggers && tiData.isSingle1Trigger()) + } else if (filterSingle1Triggers && tiData.isSingle1Trigger()) { return false; - else if (filterPair0Triggers && tiData.isPair0Trigger()) + } else if (filterPair0Triggers && tiData.isPair0Trigger()) { return false; - else if (filterPair1Triggers && tiData.isPair1Trigger()) + } else if (filterPair1Triggers && tiData.isPair1Trigger()) { return false; + } } + } return true; } @Override public void process(EventHeader event) { - + if (removeRandomEvents && event.hasCollection(GenericObject.class, "TSBank")) { + List triggerList = event.get(GenericObject.class, "TSBank"); + for (GenericObject data : triggerList) { + if (AbstractIntData.getTag(data) == TSData2019.BANK_TAG) { + TSData2019 triggerData = new TSData2019(data); + if (triggerData.isPulserTrigger() || triggerData.isFaradayCupTrigger()) { + return; + } + } + } + } // Get the run number from the event and store it. This will be used // when writing the plots out to a ROOT file - if (runNumber == -1) + if (runNumber == -1) { runNumber = event.getRunNumber(); + } if (enableTriggerFilter && event.hasCollection(GenericObject.class, triggerBankCollectionName)) { LOGGER.info("Filtering Event"); // Get the list of trigger banks from the event List triggerBanks = event.get(GenericObject.class, triggerBankCollectionName); // Apply the trigger filter - if (!passTriggerFilter(triggerBanks)) + if (!passTriggerFilter(triggerBanks)) { return; + } } // If the event doesn't have a collection of RawTrackerHit's, skip it. @@ -512,8 +563,9 @@ public void process(EventHeader event) { List rawHits = event.get(RawTrackerHit.class, rawTrackerHitCollectionName); // System.out.println("Number of SVT RawTrackerHts = " + rawHits.size()); - if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) + if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) { return; + } if (resetPeriod > 0 && eventCount > resetPeriod) { // reset occupancy numbers after resetPeriod events eventCount = 0; @@ -533,18 +585,20 @@ public void process(EventHeader event) { // to 0. int maxAmplitude = 0; int maxSamplePositionFound = -1; - for (int sampleN = 0; sampleN < 6; sampleN++) + for (int sampleN = 0; sampleN < 6; sampleN++) { if (adcValues[sampleN] > maxAmplitude) { maxAmplitude = adcValues[sampleN]; maxSamplePositionFound = sampleN; } - if (maxSamplePosition == -1 || maxSamplePosition == maxSamplePositionFound) + } + if (maxSamplePosition == -1 || maxSamplePosition == maxSamplePositionFound) { occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) rawHit.getDetectorElement()).getName()))[rawHit .getIdentifierFieldValue("strip")]++; // System.out.println("Filling occupancy"); - - if (enableMaxSamplePlots) + } + if (enableMaxSamplePlots) { maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) rawHit.getDetectorElement()).getName())).fill( maxSamplePositionFound); + } } // Fill the strip cluster counts if available @@ -554,29 +608,34 @@ public void process(EventHeader event) { SiTrackerHitStrip1D global = h.getTransformedHit(TrackerHitType.CoordinateSystem.GLOBAL); Hep3Vector pos_global = global.getPositionAsVector(); if (enableClusterTimeCuts) { - if (h.getTime() < clusterTimeCutMax && h.getTime() > clusterTimeCutMin) + if (h.getTime() < clusterTimeCutMax && h.getTime() > clusterTimeCutMin) { clusterPositionPlotCounts.get( SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) h.getRawHits().get(0).getDetectorElement()).getName())).fill( pos_global.y()); - } else + } + } else { clusterPositionPlotCounts.get(SvtPlotUtils.fixSensorNumberLabel(((HpsSiSensor) h.getRawHits().get(0).getDetectorElement()).getName())) .fill(pos_global.y()); + } } } - if (enableMaxSamplePlots && eventCount > maxSampleMonitorStart && eventCount % maxSampleMonitorPeriod == 0) + if (enableMaxSamplePlots && eventCount > maxSampleMonitorStart && eventCount % maxSampleMonitorPeriod == 0) { checkMaxSample(); + } - if (eventCount > occupancyMonitorStart && eventCount % occupancyMonitorPeriod == 0) + if (eventCount > occupancyMonitorStart && eventCount % occupancyMonitorPeriod == 0) { checkOccupancy(); + } // Plot strip occupancies. - if (eventCount % eventRefreshRate == 0) + if (eventCount % eventRefreshRate == 0) { for (HpsSiSensor sensor : sensors) { int[] strips = occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); - if (enablePositionPlots) + if (enablePositionPlots) { positionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + } for (int channel = 0; channel < strips.length; channel++) { double stripOccupancy = (double) strips[channel] / (double) eventCount; @@ -601,9 +660,11 @@ public void process(EventHeader event) { } } + } - if (plotters.get("Occupancy") != null) + if (plotters.get("Occupancy") != null) { plotters.get("Occupancy").refresh(); + } } @@ -614,10 +675,11 @@ private void checkMaxSample() { String label = "foo"; for (HpsSiSensor sensor : sensors) { - if (sensor.getLayerNumber() < 9) + if (sensor.getLayerNumber() < 9) { label = "Max Sample Number: L0-L3"; - else + } else { label = "Max Sample Number: L4-L6"; + } IHistogram1D maxSamplePlot = maxSamplePositionPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); // IPlotterRegion region = plotters.get("Max Sample Number").region(SvtPlotUtils.computePlotterRegion(sensor)); IPlotterRegion region = plotters.get(label).region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)); @@ -627,8 +689,9 @@ private void checkMaxSample() { && maxSamplePlot.binEntries(maxSamplePosition) > maxSamplePlot.binEntries(maxSamplePosition + 1); if (!isSensorOK) { isSystemOK = false; - if (oldStatus != StatusCode.ALARM) + if (oldStatus != StatusCode.ALARM && enableAlarms) { maxSampleStatus.setStatus(StatusCode.ALARM, "Sensor " + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " looks out of time."); + } IPlotterStyle plotterStyle = createOccupancyPlotStyle("Max Sample Number", sensor, true); // region.clear(); // region.plot(maxSamplePlot, plotterStyle); @@ -644,9 +707,11 @@ private void checkMaxSample() { // setBackgroundColor(region.style(),sensor.isAxial(),false); } } - if (isSystemOK) - if (oldStatus != StatusCode.OKAY) + if (isSystemOK) { + if (oldStatus != StatusCode.OKAY) { maxSampleStatus.setStatus(StatusCode.OKAY, "All sensors are timed in."); + } + } } private void checkOccupancy() { @@ -654,19 +719,22 @@ private void checkOccupancy() { boolean isSystemOK = true; String label = "foo"; for (HpsSiSensor sensor : sensors) { - if (sensor.getLayerNumber() < 9) + if (sensor.getLayerNumber() < 9) { label = "Occupancy: L0-L3"; - else + } else { label = "Occupancy: L4-L6"; + } IHistogram1D occupancyPlot = occupancyPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())); IPlotterRegion region = plotters.get(label).region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)); double apvOccupancy[] = new double[5]; - for (int i = 0; i < occupancyPlot.axis().bins(); i++) + for (int i = 0; i < occupancyPlot.axis().bins(); i++) { apvOccupancy[i / 128] += occupancyPlot.binHeight(i); - for (int i = 0; i < 5; i++) + } + for (int i = 0; i < 5; i++) { apvOccupancy[i] /= 128.0; + } boolean isSensorOK = isOccupancyOK(apvOccupancy); if (!isSensorOK) { @@ -674,8 +742,9 @@ private void checkOccupancy() { SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), apvOccupancy[0], apvOccupancy[1], apvOccupancy[2], apvOccupancy[3], apvOccupancy[4])); isSystemOK = false; - if (oldStatus != StatusCode.ALARM) + if (oldStatus != StatusCode.ALARM && enableAlarms) { occupancyStatus.setStatus(StatusCode.ALARM, "Sensor " + SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " occupancy abnormal."); + } IPlotterStyle plotterStyle = createOccupancyPlotStyle("Max Sample Number", sensor, true); // region.clear(); // region.plot(occupancyPlot, plotterStyle); @@ -688,19 +757,22 @@ private void checkOccupancy() { region.applyStyle(plotterStyle); } } - if (isSystemOK) - if (oldStatus != StatusCode.OKAY) + if (isSystemOK) { + if (oldStatus != StatusCode.OKAY) { occupancyStatus.setStatus(StatusCode.OKAY, "Occupancy looks OK."); + } + } } private boolean isOccupancyOK(double[] apvOccupancy) { double peakOccupancy = 0; int highestApv = -1; - for (int i = 0; i < 5; i++) + for (int i = 0; i < 5; i++) { if (apvOccupancy[i] > peakOccupancy) { peakOccupancy = apvOccupancy[i]; highestApv = i; } + } if (highestApv != 0 && highestApv != 4) { LOGGER.warning("peak occupancy not at edge"); return false; @@ -709,24 +781,27 @@ private boolean isOccupancyOK(double[] apvOccupancy) { LOGGER.warning("peak occupancy out of range"); return false; } - if (highestApv == 0) + if (highestApv == 0) { for (int i = 4; i > 0; i--) { - if (apvOccupancy[i] < 0.1 * peakOccupancy || apvOccupancy[i] < minPeakOccupancy) + if (apvOccupancy[i] < 0.1 * peakOccupancy || apvOccupancy[i] < minPeakOccupancy) { continue; // skip through the tail end of the sensor + } if (0.9 * apvOccupancy[i] > apvOccupancy[i - 1]) { LOGGER.warning("occupancy not monotonic"); return false; } } - else if (highestApv == 4) + } else if (highestApv == 4) { for (int i = 0; i < 4; i++) { - if (apvOccupancy[i] < 0.1 * peakOccupancy || apvOccupancy[i] < minPeakOccupancy) + if (apvOccupancy[i] < 0.1 * peakOccupancy || apvOccupancy[i] < minPeakOccupancy) { continue; // skip through the tail end of the sensor + } if (0.9 * apvOccupancy[i] > apvOccupancy[i + 1]) { LOGGER.warning("occupancy not monotonic"); return false; } } + } return true; } @@ -754,9 +829,8 @@ public void endOfData() { int[] topActiveEdgeStripOccupancy = new int[7]; int[] bottomActiveEdgeStripOccupancy = new int[7]; - for (HpsSiSensor sensor : sensors) - if (sensor.isTopLayer() && sensor.isAxial()) - + for (HpsSiSensor sensor : sensors) { + if (sensor.isTopLayer() && sensor.isAxial()) { if (sensor.getSide().equals(HpsSiSensor.ELECTRON_SIDE)) { System.out.println("% Top Layer " + getLayerNumber(sensor) + " Hit Counts: " + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]); @@ -766,7 +840,7 @@ public void endOfData() { + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]); topActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]; } - else if (sensor.isBottomLayer() && sensor.isAxial()) + } else if (sensor.isBottomLayer() && sensor.isAxial()) { if (sensor.getSide().equals(HpsSiSensor.ELECTRON_SIDE)) { System.out.println("% Bottom Layer " + getLayerNumber(sensor) + " Hit Counts: " + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[1]); @@ -776,6 +850,8 @@ else if (sensor.isBottomLayer() && sensor.isAxial()) + occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]); bottomActiveEdgeStripOccupancy[getLayerNumber(sensor) - 1] += occupancyMap.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[638]; } + } + } for (int layerN = 0; layerN < 6; layerN++) { double topStripOccupancy = (double) topActiveEdgeStripOccupancy[layerN] / (double) eventCount; diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SvtClusterPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SvtClusterPlots.java index d37d14a100..fc509c5a50 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SvtClusterPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SvtClusterPlots.java @@ -18,9 +18,12 @@ import org.hps.conditions.svt.SvtTimingConstants; import org.hps.recon.tracking.SvtPlotUtils; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TSData2019; import org.lcsim.detector.tracker.silicon.DopedSilicon; import org.lcsim.detector.tracker.silicon.HpsSiSensor; import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; import org.lcsim.event.RawTrackerHit; import org.lcsim.geometry.Detector; import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHitStrip1D; @@ -38,7 +41,6 @@ public class SvtClusterPlots extends Driver { private IPlotterFactory plotterFactory = analysisFactory.createPlotterFactory("SVT Clusters"); private IHistogramFactory histogramFactory = null; private static Map plotters = new HashMap(); - private static int nmodlayers = 7; // Histogram Maps @@ -65,7 +67,7 @@ public class SvtClusterPlots extends Driver { // Collections private String clusterCollectionName = "StripClusterer_SiTrackerHitStrip1D"; private String fittedHitsCollectionName = "SVTFittedRawTrackerHits"; - + private boolean doClusterYPlots = false; private int runNumber = -1; private boolean saveRootFile = true; @@ -74,6 +76,11 @@ public class SvtClusterPlots extends Driver { private boolean cutOutLowChargeClusters = false; private double clusterChargeCut = 400; + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } public void setDropSmallHitEvents(boolean dropSmallHitEvents) { this.dropSmallHitEvents = dropSmallHitEvents; @@ -91,23 +98,31 @@ public void setSaveRootFile(boolean saveRootFile) { this.saveRootFile = saveRootFile; } + public void setDoClusterY(boolean doit) { + this.doClusterYPlots = doit; + } + private int computePlotterRegion(HpsSiSensor sensor) { - if (sensor.getLayerNumber() < 7) - if (sensor.isTopLayer()) + if (sensor.getLayerNumber() < 7) { + if (sensor.isTopLayer()) { return 6 * (sensor.getLayerNumber() - 1); - else + } else { return 6 * (sensor.getLayerNumber() - 1) + 1; - else if (sensor.isTopLayer()) - if (sensor.getSide() == HpsSiSensor.POSITRON_SIDE) + } + } else if (sensor.isTopLayer()) { + if (sensor.getSide() == HpsSiSensor.POSITRON_SIDE) { return 6 * (sensor.getLayerNumber() - 7) + 2; - else + } else { return 6 * (sensor.getLayerNumber() - 7) + 3; - else if (sensor.isBottomLayer()) - if (sensor.getSide() == HpsSiSensor.POSITRON_SIDE) + } + } else if (sensor.isBottomLayer()) { + if (sensor.getSide() == HpsSiSensor.POSITRON_SIDE) { return 6 * (sensor.getLayerNumber() - 7) + 4; - else + } else { return 6 * (sensor.getLayerNumber() - 7) + 5; + } + } return -1; } @@ -150,8 +165,9 @@ IPlotterStyle createStyle(HpsSiSensor sensor, String xAxisTitle, String yAxisTit style.dataStyle().errorBarStyle().setVisible(false); style.regionBoxStyle().backgroundStyle().setOpacity(.20); - if (sensor != null && sensor.isAxial()) + if (sensor != null && sensor.isAxial()) { style.regionBoxStyle().backgroundStyle().setColor("246, 246, 34, 1"); + } // Turn off the legend style.legendBoxStyle().setVisible(false); @@ -174,14 +190,16 @@ private void resetPlots() { clusterTimePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); } - for (IHistogram2D histogram : hitTimeTrigTimePlots.values()) + for (IHistogram2D histogram : hitTimeTrigTimePlots.values()) { histogram.reset(); + } - for (int i = 0; i < 6; i++) + for (int i = 0; i < 6; i++) { for (int j = 0; j < 2; j++) { hitTimeTrigTimePlots1D[i][j].reset(); hitTimeTrigTimePlots2D[i][j].reset(); } + } } // /** @@ -213,10 +231,10 @@ protected void detectorChanged(Detector detector) { // Get the HpsSiSensor objects from the geometry sensors = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HpsSiSensor.class); - timingConstants = DatabaseConditionsManager.getInstance().getCachedConditions(SvtTimingConstants.SvtTimingConstantsCollection.class, "svt_timing_constants").getCachedData().get(0); - if (sensors.size() == 0) + if (sensors.size() == 0) { throw new RuntimeException("No sensors were found in this detector."); + } // // If the tree already exist, clear all existing plots of any old data // // they might contain. @@ -224,30 +242,45 @@ protected void detectorChanged(Detector detector) { // this.resetPlots(); // return; // } - tree = analysisFactory.createTreeFactory().create(); + tree = AIDA.defaultInstance().tree(); + tree.cd("/"); + boolean dirExists = false; + String dirName = "/Clusters"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + histogramFactory = analysisFactory.createHistogramFactory(tree); - plotters.put("Cluster Amplitude: L0-L3", plotterFactory.create("Cluster Amplitude: L0-L3")); + plotters.put("Cluster Amplitude: L0-L3", plotterFactory.create("4a Cluster Amplitude: L0-L3")); plotters.get("Cluster Amplitude: L0-L3").createRegions(4, 4); - plotters.put("Cluster Amplitude: L4-L6", plotterFactory.create("Cluster Amplitude: L4-L6")); + plotters.put("Cluster Amplitude: L4-L6", plotterFactory.create("4b Cluster Amplitude: L4-L6")); plotters.get("Cluster Amplitude: L4-L6").createRegions(6, 4); - plotters.put("Cluster Time: L0-L3", plotterFactory.create("Cluster Time: L0-L3")); + plotters.put("Cluster Time: L0-L3", plotterFactory.create("4c Cluster Time: L0-L3")); plotters.get("Cluster Time: L0-L3").createRegions(4, 4); - plotters.put("Cluster Time: L4-L6", plotterFactory.create("Cluster Time: L4-L6")); + plotters.put("Cluster Time: L4-L6", plotterFactory.create("4d Cluster Time: L4-L6")); plotters.get("Cluster Time: L4-L6").createRegions(6, 4); - - plotters.put("L0-L3 Cluster Y", plotterFactory.create("L0-L3 Cluster Y")); - plotters.get("L0-L3 Cluster Y").createRegions(4, 4); - plotters.put("L4-L6 Cluster Y", plotterFactory.create("L4-L6 Cluster Y")); - plotters.get("L4-L6 Cluster Y").createRegions(6, 4); - + if (this.doClusterYPlots) { + plotters.put("L0-L3 Cluster Y", plotterFactory.create("4h L0-L3 Cluster Y")); + plotters.get("L0-L3 Cluster Y").createRegions(4, 4); + plotters.put("L4-L6 Cluster Y", plotterFactory.create("4i L4-L6 Cluster Y")); + plotters.get("L4-L6 Cluster Y").createRegions(6, 4); + } for (HpsSiSensor sensor : sensors) { clusterChargePlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), - histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Charge", 100, 0, 5000)); + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Charge", 100, 0, 2000)); singleHitClusterChargePlots .put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) - + " - Single Hit Cluster Charge", 100, 0, 5000)); + + " - Single Hit Cluster Charge", 100, 0, 2000)); clusterTimePlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Time", 100, -75, 75)); @@ -274,76 +307,93 @@ protected void detectorChanged(Detector detector) { plotters.get("Cluster Time: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(clusterTimePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(null, "Cluster Time [ns]", "")); } - - clusterYPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Y", 100, 0, 25.0)); - if (sensor.getLayerNumber() < 9) - plotters.get("L0-L3 Cluster Y") - .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) - .plot(clusterYPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), - this.createStyle(sensor, "Hit Cluster abs(Y)", "")); - else - plotters.get("L4-L6 Cluster Y") - .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) - .plot(clusterYPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), - this.createStyle(sensor, "Hit Cluster abs(Y)", "")); + if (this.doClusterYPlots) { + clusterYPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Y", 100, 0, 25.0)); + if (sensor.getLayerNumber() < 9) { + plotters.get("L0-L3 Cluster Y") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(clusterYPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Hit Cluster abs(Y)", "")); + } else { + plotters.get("L4-L6 Cluster Y") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(clusterYPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Hit Cluster abs(Y)", "")); + } + } } - plotters.put("SVT-trigger timing top-bottom", plotterFactory.create("SVT-trigger timing top-bottom")); - plotters.get("SVT-trigger timing top-bottom").createRegions(1, 2); + plotters.put("Cluster-trigger timing top-bottom", plotterFactory.create("4e Cluster-trigger timing top-bottom")); + plotters.get("Cluster-trigger timing top-bottom").createRegions(1, 2); hitTimeTrigTimePlots.put("Top", histogramFactory.createHistogram2D("Top Cluster Time vs. Trigger Phase", 100, -75, 50, 6, -12, 12)); - plotters.get("SVT-trigger timing top-bottom") + plotters.get("Cluster-trigger timing top-bottom") .region(0) .plot(hitTimeTrigTimePlots.get("Top"), this.createStyle(null, "Cluster Time [ns]", "Trigger Phase[ns]")); hitTimeTrigTimePlots.put("Bottom", histogramFactory.createHistogram2D("Bottom Cluster Time vs. Trigger Phase", 100, -75, 50, 6, -12, 12)); - plotters.get("SVT-trigger timing top-bottom") + plotters.get("Cluster-trigger timing top-bottom") .region(1) .plot(hitTimeTrigTimePlots.get("Bottom"), this.createStyle(null, "Cluster Time [ns]", "Trigger Phase[ns]")); - plotters.put("SVT-trigger timing by phase", plotterFactory.create("SVT-trigger timing by phase")); - plotters.get("SVT-trigger timing by phase").createRegions(2, 6); + plotters.put("Cluster-trigger timing by phase", plotterFactory.create("4f Cluster-trigger timing by phase")); + plotters.get("Cluster-trigger timing by phase").createRegions(2, 6); - plotters.put("SVT-trigger timing and amplitude by phase", - plotterFactory.create("SVT-trigger timing and amplitude by phase")); - plotters.get("SVT-trigger timing and amplitude by phase").createRegions(2, 6); + plotters.put("Cluster-trigger timing and amplitude by phase", + plotterFactory.create("4g Cluster-trigger timing and amplitude by phase")); + plotters.get("Cluster-trigger timing and amplitude by phase").createRegions(2, 6); - for (int i = 0; i < 6; i++) + for (int i = 0; i < 6; i++) { for (int j = 0; j < 2; j++) { hitTimeTrigTimePlots1D[i][j] = histogramFactory.createHistogram1D( String.format("Cluster Time for Phase %d, %s", i, j == TOP ? "Top" : "Bottom"), 100, -75, 50); - plotters.get("SVT-trigger timing by phase").region(i + 6 * j) + plotters.get("Cluster-trigger timing by phase").region(i + 6 * j) .plot(hitTimeTrigTimePlots1D[i][j], this.createStyle(null, "Cluster Time [ns]", "")); hitTimeTrigTimePlots2D[i][j] = histogramFactory.createHistogram2D( String.format("Cluster Amplitude vs. Time for Phase %d, %s", i, j == TOP ? "Top" : "Bottom"), - 100, -75, 50, 100, 0, 5000.0); - plotters.get("SVT-trigger timing and amplitude by phase") + 100, -75, 50, 100, 0, 2000.0); + plotters.get("Cluster-trigger timing and amplitude by phase") .region(i + 6 * j) .plot(hitTimeTrigTimePlots2D[i][j], this.createStyle(null, "Cluster Time [ns]", "Cluster Amplitude [ADC Counts]")); } + } - for (IPlotter plotter : plotters.values()) + for (IPlotter plotter : plotters.values()) { plotter.show(); + } } public void process(EventHeader event) { - - if (runNumber == -1) + if (removeRandomEvents && event.hasCollection(GenericObject.class, "TSBank")) { + List triggerList = event.get(GenericObject.class, "TSBank"); + for (GenericObject data : triggerList) { + if (AbstractIntData.getTag(data) == TSData2019.BANK_TAG) { + TSData2019 triggerData = new TSData2019(data); + if (triggerData.isPulserTrigger() || triggerData.isFaradayCupTrigger()) { + return; + } + } + } + } + if (runNumber == -1) { runNumber = event.getRunNumber(); + } // If the event doesn't contain any clusters, skip it - if (!event.hasCollection(SiTrackerHitStrip1D.class, clusterCollectionName)) + if (!event.hasCollection(SiTrackerHitStrip1D.class, clusterCollectionName)) { return; + } if (event.hasCollection(RawTrackerHit.class, "SVTRawTrackerHits")) { // Get RawTrackerHit collection from event. List rawHits = event.get(RawTrackerHit.class, "SVTRawTrackerHits"); - if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) + if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) { return; + } } // Get the list of clusters in the event @@ -356,15 +406,18 @@ public void process(EventHeader event) { double absClY = Math.abs(cluster.getPosition()[1]); // Fill all plots clusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR); - - clusterYPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(absClY); - - if (cluster.getRawHits().size() == 1) + if (this.doClusterYPlots) { + clusterYPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(absClY); + } + if (cluster.getRawHits().size() == 1) { singleHitClusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR); + } double trigPhase = (((event.getTimeStamp() - 4 * timingConstants.getOffsetPhase()) % 24) - 12); - if (cutOutLowChargeClusters) - if (cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR < clusterChargeCut) + if (cutOutLowChargeClusters) { + if (cluster.getdEdx() / DopedSilicon.ENERGY_EHPAIR < clusterChargeCut) { continue; + } + } clusterTimePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(cluster.getTime()); if (sensor.isTopLayer()) { hitTimeTrigTimePlots1D[(int) ((event.getTimeStamp() / 4) % 6)][TOP].fill(cluster.getTime()); diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SvtHitPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SvtHitPlots.java index 0b333117d8..925ee35831 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SvtHitPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/svt/SvtHitPlots.java @@ -21,7 +21,7 @@ import org.hps.recon.tracking.SvtPlotUtils; import org.hps.record.triggerbank.AbstractIntData; -import org.hps.record.triggerbank.TIData; +import org.hps.record.triggerbank.TSData2019; import org.lcsim.detector.tracker.silicon.DopedSilicon; import org.lcsim.detector.tracker.silicon.HpsSiSensor; import org.lcsim.event.EventHeader; @@ -39,12 +39,11 @@ public class SvtHitPlots extends Driver { // Plotting - private static ITree tree = null; + private static ITree tree = AIDA.defaultInstance().tree(); private final IAnalysisFactory analysisFactory = AIDA.defaultInstance().analysisFactory(); private final IPlotterFactory plotterFactory = analysisFactory.createPlotterFactory("SVT Hits"); - private IHistogramFactory histogramFactory = null; + private IHistogramFactory histogramFactory = analysisFactory.createHistogramFactory(tree); protected Map plotters = new HashMap(); - // Histogram Maps private static final Map hitsPerSensorPlots = new HashMap(); private static final Map hitsPerSensor = new HashMap(); @@ -79,6 +78,12 @@ public class SvtHitPlots extends Driver { private boolean cutOutLowChargeHits = false; private double hitChargeCut = 400; + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } + public void setDropSmallHitEvents(boolean dropSmallHitEvents) { this.dropSmallHitEvents = dropSmallHitEvents; } @@ -124,8 +129,9 @@ IPlotterStyle createStyle(HpsSiSensor sensor, String xAxisTitle, String yAxisTit } private void clearHitMaps() { - for (HpsSiSensor sensor : sensors) + for (HpsSiSensor sensor : sensors) { hitsPerSensor.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[0] = 0; + } } /** @@ -142,15 +148,18 @@ private void resetPlots() { hitsPerSensorPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); firstSamplePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); // firstSamplePlotsNoise.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); - if (doPerChannelSamplePlots) + if (doPerChannelSamplePlots) { firstSamplePlotsNoisePerChannel.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).reset(); + } } - for (IHistogram1D histogram : layersHitPlots.values()) + for (IHistogram1D histogram : layersHitPlots.values()) { histogram.reset(); + } - for (IHistogram1D histogram : hitCountPlots.values()) + for (IHistogram1D histogram : hitCountPlots.values()) { histogram.reset(); + } } @@ -161,37 +170,47 @@ protected void detectorChanged(Detector detector) { sensors = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HpsSiSensor.class); timingConstants = DatabaseConditionsManager.getInstance().getCachedConditions(SvtTimingConstants.SvtTimingConstantsCollection.class, "svt_timing_constants").getCachedData().get(0); - if (sensors.isEmpty()) + if (sensors.isEmpty()) { throw new RuntimeException("No sensors were found in this detector."); + } - // // If the tree already exist, clear all existing plots of any old data - // // they might contain. - // if (tree != null) { - // this.resetPlots(); - // return; - // } - tree = analysisFactory.createTreeFactory().create(); - histogramFactory = analysisFactory.createHistogramFactory(tree); + // Reset all hit maps + tree.cd("/"); + boolean dirExists = false; + String dirName = "/SvtHits"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + //histogramFactory = analysisFactory.createHistogramFactory(tree); - plotters.put("Raw hits per sensor: L0-L3", plotterFactory.create("Raw hits per sensor: L0-L3")); + plotters.put("Raw hits per sensor: L0-L3", plotterFactory.create("2a Raw hits per sensor: L0-L3")); plotters.get("Raw hits per sensor: L0-L3").createRegions(4, 4); - plotters.put("Raw hits per sensor: L4-L6", plotterFactory.create("Raw hits per sensor: L4-L6")); + plotters.put("Raw hits per sensor: L4-L6", plotterFactory.create("2b Raw hits per sensor: L4-L6")); plotters.get("Raw hits per sensor: L4-L6").createRegions(6, 4); for (HpsSiSensor sensor : sensors) { hitsPerSensorPlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Raw Hits", 25, 0, 25)); - if (sensor.getLayerNumber() < 9) + if (sensor.getLayerNumber() < 9) { plotters.get("Raw hits per sensor: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(hitsPerSensorPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "Number of Raw Hits", "")); - else + } else { plotters.get("Raw hits per sensor: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(hitsPerSensorPlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "Number of Raw Hits", "")); + } hitsPerSensor.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), new int[1]); } - plotters.put("Number of layers hit", plotterFactory.create("Number of layers hit")); + plotters.put("Number of layers hit", plotterFactory.create("2c Number of layers hit")); plotters.get("Number of layers hit").createRegions(1, 2); layersHitPlots.put("Top", histogramFactory.createHistogram1D("Top Layers Hit", 15, 0, 15)); @@ -205,7 +224,7 @@ protected void detectorChanged(Detector detector) { .plot(layersHitPlots.get("Bottom"), SvtPlotUtils.createStyle(plotterFactory, "Number of Bottom Layers Hit", "")); - plotters.put("Raw hit counts/Event", plotterFactory.create("Raw hit counts/Event")); + plotters.put("Raw hit counts/Event", plotterFactory.create("2d Raw hit counts/Event")); plotters.get("Raw hit counts/Event").createRegions(2, 2); hitCountPlots.put("Raw hit counts/Event", histogramFactory.createHistogram1D("Raw hit counts", 100, 0, 500)); @@ -226,30 +245,30 @@ protected void detectorChanged(Detector detector) { .plot(hitCountPlots.get("SVT bottom raw hit counts/Event"), SvtPlotUtils.createStyle(plotterFactory, "Number of Raw Bits in the Bottom Volume", "")); - plotters.put("First sample distributions (pedestal shifts): L0-L3", plotterFactory.create("First sample distributions (pedestal shifts): L0-L3")); + plotters.put("First sample distributions (pedestal shifts): L0-L3", plotterFactory.create("2e First sample distributions (pedestal shifts): L0-L3")); plotters.get("First sample distributions (pedestal shifts): L0-L3").createRegions(4, 4); - plotters.put("First sample distributions (pedestal shifts): L4-L6", plotterFactory.create("First sample distributions (pedestal shifts): L4-L6")); + plotters.put("First sample distributions (pedestal shifts): L4-L6", plotterFactory.create("2f First sample distributions (pedestal shifts): L4-L6")); plotters.get("First sample distributions (pedestal shifts): L4-L6").createRegions(6, 4); - plotters.put("L0-L3 t0", plotterFactory.create("L0-L3 t0")); + plotters.put("L0-L3 t0", plotterFactory.create("2g L0-L3 t0")); plotters.get("L0-L3 t0").createRegions(4, 4); - plotters.put("L4-L6 t0", plotterFactory.create("L4-L6 t0")); + plotters.put("L4-L6 t0", plotterFactory.create("2h L4-L6 t0")); plotters.get("L4-L6 t0").createRegions(6, 4); - plotters.put("L0-L3 t0 vs Trigger Phase", plotterFactory.create("L0-L3 t0 vs Trigger Phase")); + plotters.put("L0-L3 t0 vs Trigger Phase", plotterFactory.create("2i L0-L3 t0 vs Trigger Phase")); plotters.get("L0-L3 t0 vs Trigger Phase").createRegions(4, 4); - plotters.put("L4-L6 t0 vs Trigger Phase", plotterFactory.create("L4-L6 t0 vs Trigger Phase")); + plotters.put("L4-L6 t0 vs Trigger Phase", plotterFactory.create("2j L4-L6 t0 vs Trigger Phase")); plotters.get("L4-L6 t0 vs Trigger Phase").createRegions(6, 4); - plotters.put("L0-L3 t0 vs Channel", plotterFactory.create("L0-L3 t0 vs Channel")); + plotters.put("L0-L3 t0 vs Channel", plotterFactory.create("2k L0-L3 t0 vs Channel")); plotters.get("L0-L3 t0 vs Channel").createRegions(4, 4); - plotters.put("L4-L6 t0 vs Channel", plotterFactory.create("L4-L6 t0 vs Channel")); + plotters.put("L4-L6 t0 vs Channel", plotterFactory.create("2l L4-L6 t0 vs Channel")); plotters.get("L4-L6 t0 vs Channel").createRegions(6, 4); if (doPerChannelSamplePlots) { - plotters.put("First sample channel distributions (pedestal shifts): L0-L3", plotterFactory.create("First sample channel distributions (pedestal shifts): L0-L3")); + plotters.put("First sample channel distributions (pedestal shifts): L0-L3", plotterFactory.create("2m First sample channel distributions (pedestal shifts): L0-L3")); plotters.get("First sample channel distributions (pedestal shifts): L0-L3").createRegions(4, 4); - plotters.put("First sample channel distributions (pedestal shifts): L4-L6", plotterFactory.create("First sample channel distributions (pedestal shifts): L4-L6")); + plotters.put("First sample channel distributions (pedestal shifts): L4-L6", plotterFactory.create("2n First sample channel distributions (pedestal shifts): L4-L6")); plotters.get("First sample channel distributions (pedestal shifts): L4-L6").createRegions(6, 4); } @@ -257,35 +276,37 @@ protected void detectorChanged(Detector detector) { for (HpsSiSensor sensor : sensors) { firstSamplePlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - first sample", 100, -500.0, 2000.0)); - if (sensor.getLayerNumber() < 9) + if (sensor.getLayerNumber() < 9) { plotters.get("First sample distributions (pedestal shifts): L0-L3") .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(firstSamplePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "First sample - pedestal [ADC counts]", "")); - else + } else { plotters.get("First sample distributions (pedestal shifts): L4-L6") .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(firstSamplePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "First sample - pedestal [ADC counts]", "")); + } if (doPerChannelSamplePlots) { firstSamplePlotsNoisePerChannel.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram2D( SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " channels - first sample", 640, -0.5, 639.5, 20, -500.0, 500.0)); - if (sensor.getLayerNumber() < 9) + if (sensor.getLayerNumber() < 9) { plotters.get("First sample channel distributions (pedestal shifts): L0-L3") .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(firstSamplePlotsNoisePerChannel.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "First sample channels - pedestal [ADC counts]", "")); - else + } else { plotters.get("First sample channel distributions (pedestal shifts): L4-L6") .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) .plot(firstSamplePlotsNoisePerChannel.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "First sample channels - pedestal [ADC counts]", "")); + } } t0Plots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - t0", 100, -100, 100.0)); t0VsTriggerTime.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram2D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + "Hit Time vs. Trigger Phase", - 120, -60, 60, 30, -15, 15)); + 60, -60, 60, 6, -12, 12)); // t0VsTriggerBank.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram2D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + "Hit Time vs. Trigger Bank", // 100, -100, 100, 10, 5,12)); t0VsChannel.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram2D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + "Hit Time vs. Channel", @@ -327,43 +348,53 @@ protected void detectorChanged(Detector detector) { } } - for (IPlotter plotter : plotters.values()) - if (showPlots) + for (IPlotter plotter : plotters.values()) { + if (showPlots) { plotter.show(); + } + } } @Override public void process(EventHeader event ) { - TIData triggerData = null; - if (!event.hasCollection(RawTrackerHit.class, rawTrackerHitCollectionName)) + if (!event.hasCollection(RawTrackerHit.class, rawTrackerHitCollectionName)) { return; + } - if (!event.hasCollection(LCRelation.class, fittedHitsCollectioName)) + if (!event.hasCollection(LCRelation.class, fittedHitsCollectioName)) { return; - if (event.hasCollection(GenericObject.class, "TriggerBank")) { - List triggerList = event.get(GenericObject.class, "TriggerBank"); - for (GenericObject data : triggerList) - if (AbstractIntData.getTag(data) == TIData.BANK_TAG) - triggerData = new TIData(data); // System.out.println(triggerData.getIntVal(1) + " " - // + triggerData.getIntVal(2) ); } - if (debug && ((int) eventCount % 100 == 0)) + if (removeRandomEvents && event.hasCollection(GenericObject.class, "TSBank")) { + List triggerList = event.get(GenericObject.class, "TSBank"); + for (GenericObject data : triggerList) { + if (AbstractIntData.getTag(data) == TSData2019.BANK_TAG) { + TSData2019 triggerData = new TSData2019(data); + if (triggerData.isPulserTrigger() || triggerData.isFaradayCupTrigger()) { + return; + } + } + } + } + if (debug && ((int) eventCount % 100 == 0)) { System.out.println(this.getClass().getSimpleName() + ": processed " + String.valueOf(eventCount) + " events"); + } eventCount++; - if (outputRootFilename.isEmpty()) + if (outputRootFilename.isEmpty()) { outputRootFilename = "run" + String.valueOf(event.getRunNumber()); + } // Get RawTrackerHit collection from event. List rawHits = event.get(RawTrackerHit.class, rawTrackerHitCollectionName); List fittedHits = event.get(LCRelation.class, fittedHitsCollectioName); - if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) + if (dropSmallHitEvents && SvtPlotUtils.countSmallHits(rawHits) > 3) { return; + } this.clearHitMaps(); for (RawTrackerHit rawHit : rawHits) { @@ -373,19 +404,21 @@ public void process(EventHeader event // Find the sample with maximum ADC count int maxSample = 0; double maxSampleValue = 0; - for (int s = 0; s < 6; ++s) + for (int s = 0; s < 6; ++s) { if (((double) rawHit.getADCValues()[s] - pedestal) > maxSampleValue) { maxSample = s; maxSampleValue = ((double) rawHit.getADCValues()[s]) - pedestal; } + } hitsPerSensor.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[0]++; firstSamplePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(rawHit.getADCValues()[0] - pedestal); // if (maxSampleCutForNoise >= 0 && maxSample >= maxSampleCutForNoise) { // firstSamplePlotsNoise.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(rawHit.getADCValues()[0] - pedestal); - if (doPerChannelSamplePlots) + if (doPerChannelSamplePlots) { firstSamplePlotsNoisePerChannel.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())) .fill(channel, rawHit.getADCValues()[0] - pedestal); + } // } else { // firstSamplePlotsNoise.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(rawHit.getADCValues()[0] - pedestal); // if (doPerChannelSamplePlots) { @@ -403,9 +436,11 @@ public void process(EventHeader event double t0 = FittedRawTrackerHit.getT0(fittedHit); double amplitude = FittedRawTrackerHit.getAmp(fittedHit); double chi2Prob = ShapeFitParameters.getChiProb(FittedRawTrackerHit.getShapeFitParameters(fittedHit)); - if (cutOutLowChargeHits) - if (amplitude / DopedSilicon.ENERGY_EHPAIR < hitChargeCut) + if (cutOutLowChargeHits) { + if (amplitude / DopedSilicon.ENERGY_EHPAIR < hitChargeCut) { continue; + } + } t0Plots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(t0); double trigPhase = (((event.getTimeStamp() - 4 * timingConstants.getOffsetPhase()) % 24) - 12); t0VsTriggerTime.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(t0, trigPhase); @@ -427,7 +462,7 @@ public void process(EventHeader event eventHitCount += hitCount; - if (hitsPerSensor.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[0] > 0) + if (hitsPerSensor.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()))[0] > 0) { if (sensor.isTopLayer()) { topLayersHit[sensor.getLayerNumber() - 1]++; topEventHitCount += hitCount; @@ -435,6 +470,7 @@ public void process(EventHeader event botLayersHit[sensor.getLayerNumber() - 1]++; botEventHitCount += hitCount; } + } } totalHitCount += eventHitCount; @@ -449,10 +485,12 @@ public void process(EventHeader event int totalBotLayersHit = 0; for (int layerN = 0; layerN < 14; layerN++) { - if (topLayersHit[layerN] > 0) + if (topLayersHit[layerN] > 0) { totalTopLayersHit++; - if (botLayersHit[layerN] > 0) + } + if (botLayersHit[layerN] > 0) { totalBotLayersHit++; + } } layersHitPlots.get("Top").fill(totalTopLayersHit); diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/FinalStateParticlePlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/FinalStateParticlePlots.java index d731cfd181..f71e2664eb 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/FinalStateParticlePlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/FinalStateParticlePlots.java @@ -8,15 +8,19 @@ import hep.aida.IHistogram2D; import hep.aida.IPlotter; import hep.aida.IPlotterFactory; +import hep.aida.ITree; import hep.physics.vec.BasicHep3Vector; import hep.physics.vec.Hep3Vector; import static java.lang.Math.sqrt; import java.util.List; import org.hps.recon.tracking.TrackUtils; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TSData2019; import org.lcsim.event.Cluster; import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; import org.lcsim.event.ReconstructedParticle; import org.lcsim.event.TrackState; import org.lcsim.geometry.Detector; @@ -26,10 +30,8 @@ public class FinalStateParticlePlots extends Driver { private AIDA aida = AIDA.defaultInstance(); + private static ITree tree = AIDA.defaultInstance().tree(); String finalStateParticlesColName = "FinalStateParticles"; - String unconstrainedV0CandidatesColName = "UnconstrainedV0Candidates"; - String beamConV0CandidatesColName = "BeamspotConstrainedV0Candidates"; - String targetV0ConCandidatesColName = "TargetConstrainedV0Candidates"; // some counters int nRecoEvents = 0; @@ -71,6 +73,11 @@ public class FinalStateParticlePlots extends Driver { double pMax = 7.0; double pi0EsumCut = 3.0;//GeV double pi0EdifCut = 2.0;//GeV + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } public void setPMax(double pmax) { this.pMax = pmax; @@ -84,24 +91,42 @@ public void setPi0EdifCut(double cut) { this.pi0EdifCut = cut; } + public void setFinalStateParticlesColName(String name) { + this.finalStateParticlesColName = name; + } + @Override protected void detectorChanged(Detector detector) { // System.out.println("V0Monitoring::detectorChanged Setting up the plotter"); + tree.cd("/"); + boolean dirExists = false; + String dirName = "/FinalState"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + IAnalysisFactory fac = aida.analysisFactory(); IPlotterFactory pfac = fac.createPlotterFactory("Final State Recon"); functionFactory = aida.analysisFactory().createFunctionFactory(null); fitFactory = aida.analysisFactory().createFitFactory(); - aida.tree().cd("/"); // resetOccupancyMap(); // this is for calculatin - plotterEle = pfac.create("Electrons"); + plotterEle = pfac.create("3a Electrons"); plotterEle.createRegions(2, 3); - plotterPos = pfac.create("Positrons"); + plotterPos = pfac.create("3b Positrons"); plotterPos.createRegions(2, 3); - plotterPhot = pfac.create("Photons and Pi0"); + plotterPhot = pfac.create("3c Photons and Pi0"); plotterPhot.createRegions(2, 3); /* V0 Quantities */ @@ -154,15 +179,21 @@ protected void detectorChanged(Detector detector) { @Override public void process(EventHeader event) { + if (removeRandomEvents && event.hasCollection(GenericObject.class, "TSBank")) { + List triggerList = event.get(GenericObject.class, "TSBank"); + for (GenericObject data : triggerList) { + if (AbstractIntData.getTag(data) == TSData2019.BANK_TAG) { + TSData2019 triggerData = new TSData2019(data); + if (triggerData.isPulserTrigger() || triggerData.isFaradayCupTrigger()) { + return; + } + } + } + } /* make sure everything is there */ - if (!event.hasCollection(ReconstructedParticle.class, finalStateParticlesColName)) - return; - if (!event.hasCollection(ReconstructedParticle.class, unconstrainedV0CandidatesColName)) - return; - if (!event.hasCollection(ReconstructedParticle.class, beamConV0CandidatesColName)) - return; - if (!event.hasCollection(ReconstructedParticle.class, targetV0ConCandidatesColName)) + if (!event.hasCollection(ReconstructedParticle.class, finalStateParticlesColName)) { return; + } nRecoEvents++; List fspList = event.get(ReconstructedParticle.class, @@ -181,10 +212,11 @@ public void process(EventHeader event) { elePz.fill(mom.z()); TrackState stateAtEcal = TrackUtils.getTrackStateAtECal((fsp.getTracks().get(0))); Hep3Vector tPos = new BasicHep3Vector(stateAtEcal.getReferencePoint()); - if (fsp.getClusters().size() != 0) + if (fsp.getClusters().size() != 0) { eleProjXYEcalMatch.fill(tPos.y(), tPos.z()); - else + } else { eleProjXYEcalNoMatch.fill(tPos.y(), tPos.z()); + } } else if (charge > 0) { posCnt++; Hep3Vector mom = fsp.getMomentum(); @@ -193,27 +225,32 @@ public void process(EventHeader event) { posPz.fill(mom.z()); TrackState stateAtEcal = TrackUtils.getTrackStateAtECal((fsp.getTracks().get(0))); Hep3Vector tPos = new BasicHep3Vector(stateAtEcal.getReferencePoint()); - if (fsp.getClusters().size() != 0) + if (fsp.getClusters().size() != 0) { posProjXYEcalMatch.fill(tPos.y(), tPos.z());// tracking frame! - else + } else { posProjXYEcalNoMatch.fill(tPos.y(), tPos.z()); + } } else if (fsp.getClusters().size() != 0) { photCnt++; Cluster clu = fsp.getClusters().get(0); photEne.fill(clu.getEnergy()); photXYECal.fill(clu.getPosition()[0], clu.getPosition()[1]); - } else + } else { System.out.println("This FSP had no tracks or clusters???"); + } } for (ReconstructedParticle fsp1 : fspList) { - if (fsp1.getCharge() != 0) + if (fsp1.getCharge() != 0) { continue; + } for (ReconstructedParticle fsp2 : fspList) { - if (fsp1 == fsp2) + if (fsp1 == fsp2) { continue; - if (fsp2.getCharge() != 0) + } + if (fsp2.getCharge() != 0) { continue; + } // if (fsp1.getClusters().get(0) == null || fsp2.getClusters().get(0) == null) // continue;//this should never happen Cluster clu1 = fsp1.getClusters().get(0); @@ -221,10 +258,12 @@ public void process(EventHeader event) { double pi0ene = clu1.getEnergy() + clu2.getEnergy(); double pi0diff = Math.abs(clu1.getEnergy() - clu2.getEnergy()); double pi0mass = getClusterPairMass(clu1, clu2); - if (pi0diff > pi0EdifCut) + if (pi0diff > pi0EdifCut) { continue; - if (pi0ene < pi0EsumCut) + } + if (pi0ene < pi0EsumCut) { continue; + } if (clu1.getPosition()[1] * clu2.getPosition()[1] < 0) {//top bottom pi0Ene.fill(pi0ene); pi0Diff.fill(pi0diff); @@ -259,10 +298,11 @@ public double getClusterPairMass(Cluster clu1, Cluster clu2) { double psum = Math.sqrt(pxsum * pxsum + pysum * pysum + pzsum * pzsum); double evtmass = esum * esum - psum * psum; - if (evtmass > 0) + if (evtmass > 0) { return Math.sqrt(evtmass); - else + } else { return -99; + } } } diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFSVTOpeningAlignment.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFSVTOpeningAlignment.java new file mode 100644 index 0000000000..1ae98b696e --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFSVTOpeningAlignment.java @@ -0,0 +1,465 @@ +package org.hps.monitoring.drivers.trackrecon; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; + +import org.hps.recon.tracking.MaterialSupervisor; +import org.hps.recon.tracking.MaterialSupervisor.ScatteringDetectorVolume; +import org.hps.recon.tracking.MaterialSupervisor.SiStripPlane; +import org.hps.recon.tracking.kalman.KalmanInterface; +import org.hps.recon.tracking.kalman.KalmanKinkFit; +import org.hps.recon.tracking.kalman.KalmanParams; +import org.hps.recon.tracking.kalman.Vec; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TSData2019; +import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; +import org.lcsim.event.LCIOParameters.ParameterName; +import org.lcsim.event.LCRelation; +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; + +import hep.aida.IAnalysisFactory; +import hep.aida.IFitFactory; +import hep.aida.IFitter; +import hep.aida.IFunction; +import hep.aida.IFunctionFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogram2D; +import hep.aida.IPlotter; +import hep.aida.IPlotterFactory; +import hep.aida.IPlotterStyle; +import hep.aida.ITree; + +public class KFSVTOpeningAlignment extends Driver { + + static private AIDA aida = AIDA.defaultInstance(); + private static ITree tree = AIDA.defaultInstance().tree(); + private KalmanInterface KI; + private static final boolean debug = false; + private ArrayList detPlanes; + private MaterialSupervisor _materialManager; + private org.lcsim.geometry.FieldMap fm; + private KalmanParams kPar; + private String outputPlots = null; + IPlotter plotterTop; + IPlotter plotterParsTop; + IPlotter plotterBot; + IPlotter plotterParsBot; + IPlotter plotterHinge; + + IHistogram1D nTracksTop; + IHistogram1D nTracksBot; + IHistogram1D nHits03Top; + IHistogram1D nHits46Top; + IHistogram1D nHits03Bot; + IHistogram1D nHits46Bot; + IHistogram1D deld0Top; + IHistogram1D delphiTop; + IHistogram1D delwTop; + IHistogram1D delz0Top; + IHistogram1D lambdaTopL03; + IHistogram1D z0TopL03; + IHistogram1D lambdaTopL46; + IHistogram1D z0TopL46; + IHistogram1D deld0Bot; + IHistogram1D delphiBot; + IHistogram1D delwBot; + IHistogram1D delz0Bot; + IHistogram1D lambdaBotL03; + IHistogram1D z0BotL03; + IHistogram1D lambdaBotL46; + IHistogram1D z0BotL46; + + IHistogram1D zTargetTopL03; + IHistogram1D zTargetTopL46; + IHistogram1D zTargetBotL03; + IHistogram1D zTargetBotL46; + + IHistogram2D lambdaVsz0TopL03; + IHistogram2D lambdaVsz0BotL03; + IHistogram2D lambdaVsz0TopL46; + IHistogram2D lambdaVsz0BotL46; + + IHistogram1D delYAtHingeTop; + IHistogram1D delYAtHingeBot; + IHistogram2D yAtHingeL03VsL46Top; + IHistogram2D yAtHingeL03VsL46Bot; + IHistogram2D delYAtHingeVsL03SlopeTop; + IHistogram2D delYAtHingeVsL46SlopeTop; + IHistogram2D delYAtHingeVsL03SlopeBot; + IHistogram2D delYAtHingeVsL46SlopeBot; + + private IHistogram1D hProjAngTop, hAngTop, hChiInTop, hChiOutTop, hDofInTop, hDofOutTop; + private IHistogram1D hProjAngBot, hAngBot, hChiInBot, hChiOutBot, hDofInBot, hDofOutBot; + IPlotterFactory plotterFactory; + IFunctionFactory functionFactory; + IFitFactory fitFactory; + IFunction fd0Top; + IFunction fphi0Top; + IFunction fz0Top; + IFunction flambdaTop; + IFunction fwTop; + IFunction fd0Bot; + IFunction fphi0Bot; + IFunction fz0Bot; + IFunction flambdaBot; + IFunction fwBot; + + IFitter jminChisq; + + double targetPosition = -5.0; //mm + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } + + public KFSVTOpeningAlignment() { + } + + public void setOutputPlots(String output) { + this.outputPlots = output; + } + + @Override + protected void detectorChanged(Detector detector) { + tree.cd("/"); + boolean dirExists = false; + String dirName = "/KFSVTOpeningAlignment"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + + IAnalysisFactory fac = aida.analysisFactory(); + IPlotterFactory pfac = fac.createPlotterFactory("SVT Alignment"); + functionFactory = aida.analysisFactory().createFunctionFactory(null); + fitFactory = aida.analysisFactory().createFitFactory(); + jminChisq = fitFactory.createFitter("chi2", "jminuit"); + + plotterTop = pfac.create("5a Top Layers"); + IPlotterStyle style = plotterTop.style(); + style.dataStyle().fillStyle().setColor("yellow"); + style.dataStyle().errorBarStyle().setVisible(false); + style.legendBoxStyle().setVisible(false); + style.dataStyle().outlineStyle().setVisible(false); + plotterTop.createRegions(3, 3); + + // plotterFrame.addPlotter(plotter); + IPlotterStyle functionStyle = pfac.createPlotterStyle(); + functionStyle.dataStyle().lineStyle().setColor("red"); + functionStyle.dataStyle().markerStyle().setVisible(true); + functionStyle.dataStyle().markerStyle().setColor("black"); + functionStyle.dataStyle().markerStyle().setShape("dot"); + functionStyle.dataStyle().markerStyle().setSize(2); + + nTracksTop = aida.histogram1D("Number of Tracks: Top ", 7, 0, 7); + deld0Top = aida.histogram1D("Delta d0: Top", 50, -20.0, 20.0); + delphiTop = aida.histogram1D("Delta sin(phi): Top", 50, -0.1, 0.1); + delz0Top = aida.histogram1D("Delta yTarget: Top", 50, -2.5, 2.5); + delwTop = aida.histogram1D("Delta curvature: Top", 50, -0.0002, 0.0002); + + hChiInTop = aida.histogram1D("Top Inner helix chi^2", 100, 0., 100.); + hDofInTop = aida.histogram1D("Top Inner helix #dof", 5, 0., 5.); + hChiOutTop = aida.histogram1D("Top Outer helix chi^2", 100, 0., 100.); + hDofOutTop = aida.histogram1D("Top Outer helix #dof", 5, 0., 5.); + + hAngTop = aida.histogram1D("Kalman kink angle top", 100, 0., 0.15); + hProjAngTop = aida.histogram1D("Kalman projected kink angle top", 100, -0.03, 0.03); + + fd0Top = functionFactory.createFunctionByName("Gaussian", "G"); + fphi0Top = functionFactory.createFunctionByName("Gaussian", "G"); + fwTop = functionFactory.createFunctionByName("Gaussian", "G"); + flambdaTop = functionFactory.createFunctionByName("Gaussian", "G"); + fz0Top = functionFactory.createFunctionByName("Gaussian", "G"); + + plotterTop.region(0).plot(deld0Top); + plotterTop.region(3).plot(delphiTop); + plotterTop.region(6).plot(hProjAngTop); + plotterTop.region(1).plot(delwTop); + plotterTop.region(4).plot(delz0Top); + plotterTop.region(2).plot(nTracksTop); + plotterTop.region(5).plot(hAngTop); + plotterTop.region(7).plot(hDofInTop); + plotterTop.region(8).plot(hDofOutTop); + plotterTop.region(0).plot(fd0Top, functionStyle); + plotterTop.region(3).plot(fphi0Top, functionStyle); + plotterTop.region(6).plot(fwTop, functionStyle); + plotterTop.region(1).plot(flambdaTop, functionStyle); + plotterTop.region(4).plot(fz0Top, functionStyle); + plotterTop.show(); + +// plotterParsTop = pfac.create("Top Track Pars"); +// plotterParsTop.createRegions(2, 4); lambdaTopL03 = +// aida.histogram1D("slope: Top L0-3", 50, 0, 0.06); z0TopL03 = +// aida.histogram1D("y0: Top L0-3", 50, -2.5, 2.5); lambdaVsz0TopL03 = +// aida.histogram2D("slope vs y0: Top L0-3", 50, -2.5, 2.5, 50, 0.0, 0.06); +// lambdaTopL46 = aida.histogram1D("slope: Top L4-6", 50, 0, 0.06); z0TopL46 = +// aida.histogram1D("y0: Top L4-6", 50, -2.5, 2.5); lambdaVsz0TopL46 = +// aida.histogram2D("slope vs yTarget: Top L4-6", 50, -2.5, 2.5, 50, 0.0, 0.06); +// zTargetTopL03 = aida.histogram1D("yTarget: Top L0-3", 50, -2.5, 2.5); +// zTargetTopL46 = aida.histogram1D("yTarget: Top L4-6", 50, -2.5, 2.5); +// +// plotterParsTop.region(0).plot(lambdaTopL03); +// plotterParsTop.region(4).plot(lambdaTopL46); +// plotterParsTop.region(1).plot(z0TopL03); +// plotterParsTop.region(5).plot(z0TopL46); +// plotterParsTop.region(2).plot(lambdaVsz0TopL03); +// plotterParsTop.region(6).plot(lambdaVsz0TopL46); +// plotterParsTop.region(3).plot(zTargetTopL03); +// plotterParsTop.region(7).plot(zTargetTopL46); plotterParsTop.show(); + plotterBot = pfac.create("5b Bottom Layers"); + IPlotterStyle styleBot = plotterBot.style(); + styleBot.legendBoxStyle().setVisible(false); + styleBot.dataStyle().fillStyle().setColor("yellow"); + styleBot.dataStyle().errorBarStyle().setVisible(false); + styleBot.dataStyle().outlineStyle().setVisible(false); + plotterBot.createRegions(3, 3); + + nTracksBot = aida.histogram1D("Number of Tracks: Bot ", 7, 0, 7); + deld0Bot = aida.histogram1D("Delta d0: Bot", 50, -20.0, 20.0); + delphiBot = aida.histogram1D("Delta sin(phi): Bot", 50, -0.1, 0.1); + delwBot = aida.histogram1D("Delta curvature: Bot", 50, -0.0002, 0.0002); + delz0Bot = aida.histogram1D("Delta yTarget: Bot", 50, -2.5, 2.5); + hAngBot = aida.histogram1D("Kalman kink angle bottom", 100, 0., 0.15); + hProjAngBot = aida.histogram1D("Kalman projected kink angle bottom", 100, -0.03, 0.03); + + fd0Bot = functionFactory.createFunctionByName("Gaussian", "G"); + fphi0Bot = functionFactory.createFunctionByName("Gaussian", "G"); + fwBot = functionFactory.createFunctionByName("Gaussian", "G"); + flambdaBot = functionFactory.createFunctionByName("Gaussian", "G"); + fz0Bot = functionFactory.createFunctionByName("Gaussian", "G"); + + hChiInBot = aida.histogram1D("Bottom Inner helix chi^2", 100, 0., 100.); + hDofInBot = aida.histogram1D("Bottom Inner helix #dof", 5, 0., 5.); + hChiOutBot = aida.histogram1D("Bottom Outer helix chi^2", 100, 0., 100.); + hDofOutBot = aida.histogram1D("Bottom Outer helix #dof", 5, 0., 5.); + + plotterBot.region(0).plot(deld0Bot); + plotterBot.region(3).plot(delphiBot); + plotterBot.region(6).plot(hProjAngBot); + plotterBot.region(1).plot(delwBot); + plotterBot.region(4).plot(delz0Bot); + plotterBot.region(2).plot(nTracksBot); + plotterBot.region(5).plot(hAngBot); + plotterBot.region(7).plot(hDofInBot); + plotterBot.region(8).plot(hDofOutBot); + plotterBot.region(0).plot(fd0Bot, functionStyle); + plotterBot.region(3).plot(fphi0Bot, functionStyle); + plotterBot.region(6).plot(fwBot, functionStyle); + plotterBot.region(1).plot(flambdaBot, functionStyle); + plotterBot.region(4).plot(fz0Bot, functionStyle); + plotterBot.show(); + + _materialManager = new MaterialSupervisor(); + _materialManager.buildModel(detector); + + fm = detector.getFieldMap(); + + detPlanes = new ArrayList(); + List materialVols = ((MaterialSupervisor) (_materialManager)).getMaterialVolumes(); + for (ScatteringDetectorVolume vol : materialVols) { + detPlanes.add((SiStripPlane) (vol)); + } + + // Instantiate the interface to the Kalman-Filter code and set up the geometry + kPar = new KalmanParams(); + kPar.print(); + + KI = new KalmanInterface(false, kPar, fm); + KI.createSiModules(detPlanes); + +// plotterParsBot = pfac.create("Bot Track Pars"); +// plotterParsBot.createRegions(2, 4); +// lambdaBotL03 = aida.histogram1D("slope: Bot L0-3", 50, -0.06, 0.0); +// z0BotL03 = aida.histogram1D("y0: Bot L0-3", 50, -2.5, 2.5); +// lambdaVsz0BotL03 = aida.histogram2D("slope vs y0: Bot L0-3", 50, -2.5, 2.5, 50, -0.06, 0.0); +// lambdaBotL46 = aida.histogram1D("slope: Bot L4-6", 50, -0.06, 0.0); +// z0BotL46 = aida.histogram1D("y0: Bot L4-6", 50, -2.5, 2.5); +// lambdaVsz0BotL46 = aida.histogram2D("slope vs yTarget: Bot L4-6", 50, -2.5, 2.5, 50, -0.06, 0.0); +// zTargetBotL03 = aida.histogram1D("yTarget: Bot L0-3", 50, -2.5, 2.5); +// zTargetBotL46 = aida.histogram1D("yTarget: Bot L4-6", 50, -2.5, 2.5); +// plotterParsBot.region(0).plot(lambdaBotL03); +// plotterParsBot.region(4).plot(lambdaBotL46); +// plotterParsBot.region(1).plot(z0BotL03); +// plotterParsBot.region(5).plot(z0BotL46); +// plotterParsBot.region(2).plot(lambdaVsz0BotL03); +// plotterParsBot.region(6).plot(lambdaVsz0BotL46); +// plotterParsBot.region(3).plot(zTargetBotL03); +// plotterParsBot.region(7).plot(zTargetBotL46); +// plotterParsBot.show(); +// +// plotterHinge = pfac.create("Y @ Hinge"); +// plotterHinge.createRegions(2, 4); +// delYAtHingeTop = aida.histogram1D("DeltaY at Hinge Top", 50, -1.0, 1.0); +// delYAtHingeBot = aida.histogram1D("DeltaY at Hinge Bottom", 50, -1.0, 1.0); +// yAtHingeL03VsL46Top = aida.histogram2D("Y at Hinge Top L46 vs L03", 50, 0, 20, 50, 0, 20); +// yAtHingeL03VsL46Bot = aida.histogram2D("Y at Hinge Bottom L46 vs L03", 50, -20, 0, 50, -20, 0); +// delYAtHingeVsL03SlopeTop = aida.histogram2D("DeltaY at Hinge vs L03 Slope Top", 50, -1.0, 1.0, 50, 0, 0.06); +// delYAtHingeVsL46SlopeTop = aida.histogram2D("DeltaY at Hinge vs L46 Slope Top", 50, -1.0, 1.0, 50, 0, 0.06); +// delYAtHingeVsL03SlopeBot = aida.histogram2D("DeltaY at Hinge vs L03 Slope Bottom", 50, -1.0, 1.0, 50, -0.060, 0.0); +// delYAtHingeVsL46SlopeBot = aida.histogram2D("DeltaY at Hinge vs L46 Slope Bottom", 50, -1.0, 1.0, 50, -0.06, 0.0); +// plotterHinge.region(0).plot(delYAtHingeTop); +// plotterHinge.region(1).plot(yAtHingeL03VsL46Top); +// plotterHinge.region(2).plot(delYAtHingeVsL03SlopeTop); +// plotterHinge.region(3).plot(delYAtHingeVsL46SlopeTop); +// +// plotterHinge.region(4).plot(delYAtHingeBot); +// plotterHinge.region(5).plot(yAtHingeL03VsL46Bot); +// plotterHinge.region(6).plot(delYAtHingeVsL03SlopeBot); +// plotterHinge.region(7).plot(delYAtHingeVsL46SlopeBot); +// plotterHinge.show(); + } + + @Override + public void process(EventHeader event) { + if (removeRandomEvents && event.hasCollection(GenericObject.class, "TSBank")) { + List triggerList = event.get(GenericObject.class, "TSBank"); + for (GenericObject data : triggerList) { + if (AbstractIntData.getTag(data) == TSData2019.BANK_TAG) { + TSData2019 triggerData = new TSData2019(data); + if (triggerData.isPulserTrigger() || triggerData.isFaradayCupTrigger()) { + return; + } + } + } + } + aida.tree().cd("/"); + int nTrkTop = 0; + int nTrkBot = 0; + String stripDataRelationsInputCollectionName = "KFGBLStripClusterDataRelations"; + if (!event.hasCollection(LCRelation.class, stripDataRelationsInputCollectionName)) { + System.out.format("\nKalmanKinkFitDriver: the data collection %s is missing.\n", stripDataRelationsInputCollectionName); + } + String trackCollectionName = "KalmanFullTracks"; + if (event.hasCollection(Track.class, trackCollectionName)) { + List kalmanFullTracks = event.get(Track.class, trackCollectionName); + for (Track trk : kalmanFullTracks) { + if (trk.getNDF() >= 7) { + KalmanKinkFit knkFt = new KalmanKinkFit(event, KI, trk); + if (knkFt.doFits()) { + if (knkFt.innerMomentum()[2] < 0.) { + nTrkBot++; + hProjAngBot.fill(knkFt.projectedAngle()); + hAngBot.fill(knkFt.scatteringAngle()); + hChiInBot.fill(knkFt.innerChi2()); + hDofInBot.fill(knkFt.innerDOF()); + hChiOutBot.fill(knkFt.outerChi2()); + hDofOutBot.fill(knkFt.outerDOF()); + deld0Bot.fill(knkFt.outerHelix()[ParameterName.d0.ordinal()] - knkFt.innerHelix()[ParameterName.d0.ordinal()]); + delphiBot.fill(knkFt.outerHelix()[ParameterName.phi0.ordinal()] - knkFt.innerHelix()[ParameterName.phi0.ordinal()]); + delz0Bot.fill(knkFt.outerHelix()[ParameterName.z0.ordinal()] - knkFt.innerHelix()[ParameterName.z0.ordinal()]); + delwBot.fill(knkFt.outerHelix()[ParameterName.omega.ordinal()] - knkFt.innerHelix()[ParameterName.omega.ordinal()]); + } else { + nTrkTop++; + hProjAngTop.fill(knkFt.projectedAngle()); + hAngTop.fill(knkFt.scatteringAngle()); + hChiInTop.fill(knkFt.innerChi2()); + hDofInTop.fill(knkFt.innerDOF()); + hChiOutTop.fill(knkFt.outerChi2()); + hDofOutTop.fill(knkFt.outerDOF()); + deld0Top.fill(knkFt.outerHelix()[ParameterName.d0.ordinal()] - knkFt.innerHelix()[ParameterName.d0.ordinal()]); + delphiTop.fill(knkFt.outerHelix()[ParameterName.phi0.ordinal()] - knkFt.innerHelix()[ParameterName.phi0.ordinal()]); + delz0Top.fill(knkFt.outerHelix()[ParameterName.z0.ordinal()] - knkFt.innerHelix()[ParameterName.z0.ordinal()]); + delwTop.fill(knkFt.outerHelix()[ParameterName.omega.ordinal()] - knkFt.innerHelix()[ParameterName.omega.ordinal()]); + } + + if (debug) { + System.out.format("KinkFit: event number %d\n", event.getEventNumber()); + System.out.format(" KinkFit: chi^2 of inner helix = %8.4f with %d dof\n", knkFt.innerChi2(), knkFt.innerDOF()); + System.out.format(" KinkFit: chi^2 of outer helix = %8.4f with %d dof\n", knkFt.outerChi2(), knkFt.outerDOF()); + Vec inHx = new Vec(5, knkFt.innerHelix()); + Vec outHx = new Vec(5, knkFt.outerHelix()); + System.out.format(" KinkFit: inner helix = %s\n", inHx.toString()); + System.out.format(" KinkFit: outer helix = %s\n", outHx.toString()); + Vec inP = new Vec(3, knkFt.innerMomentum()); + Vec outP = new Vec(3, knkFt.outerMomentum()); + System.out.format(" KinkFit: inner momentum = %s\n", inP.toString()); + System.out.format(" KinkFit: outer momentum = %s\n", outP.toString()); + System.out.format(" KinkFit: scattering angle = %10.6f radians\n", knkFt.scatteringAngle()); + System.out.format(" KinkFit: projected scattering angle = %10.6f radians\n", knkFt.projectedAngle()); + } + } + } + } + } + KI.clearInterface(); + nTracksTop.fill(nTrkTop); + nTracksBot.fill(nTrkBot); + +// // IFunction currentFitFunction = performGaussianFit(deld0Bot, fd0Bot, jminChisq).fittedFunction();; +// // fd0Bot.setParameters(currentFitFunction.parameters()); +// fitAndPutParameters(deld0Bot, fd0Bot); +// fitAndPutParameters(delphiBot, fphi0Bot); +// fitAndPutParameters(delwBot, fwBot); +// fitAndPutParameters(delz0Bot, fz0Bot); +// fitAndPutParameters(dellambdaBot, flambdaBot); + } + + @Override + public void endOfData() { + if (outputPlots != null) { + try { + plotterTop.writeToFile(outputPlots + "-deltasTop.gif"); + plotterBot.writeToFile(outputPlots + "-deltasBottom.gif"); + } catch (IOException ex) { + Logger.getLogger(TrackingReconPlots.class.getName()).log(Level.SEVERE, null, ex); + } + } + } + + private List splitTrackList(List trks, boolean doTop) { + List tracksHalf = new ArrayList(); + boolean isTop = false; + boolean isBot = false; + for (Track trk : trks) { + isTop = false; + isBot = false; + for (TrackerHit hit : trk.getTrackerHits()) { + if (hit.getPosition()[2] > 0)// remember, non-bend in tracking frame is z-direction + { + isTop = true; + } else { + isBot = true; + } + } + if (isTop == true && isBot != true && doTop == true) // if we want top tracks and all hits are in top + { + tracksHalf.add(trk); + } + if (isBot == true && isTop != true && doTop == false) // if we want bottom tracks and all hits are in bottom + { + tracksHalf.add(trk); + } + } + return tracksHalf; + } + + private Track checkFullTrack(List fullTracks, Track t03, Track t46) { + List trkHitsL03 = t03.getTrackerHits(); + List trkHitsL46 = t46.getTrackerHits(); + + for (Track fullTr : fullTracks) { + List trkHitsFull = fullTr.getTrackerHits(); + if (trkHitsFull.containsAll(trkHitsL03) && trkHitsFull.containsAll(trkHitsL46)) { + return fullTr; + } + } + + return null; + } +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFTrackTimePlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFTrackTimePlots.java new file mode 100644 index 0000000000..048ff278bb --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFTrackTimePlots.java @@ -0,0 +1,440 @@ +package org.hps.monitoring.drivers.trackrecon; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogram2D; +import hep.aida.IHistogramFactory; +import hep.aida.IPlotter; +import hep.aida.IPlotterFactory; +import hep.aida.IPlotterStyle; +import hep.aida.ITree; +import hep.aida.ref.plotter.style.registry.IStyleStore; +import hep.aida.ref.plotter.style.registry.StyleRegistry; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.hps.recon.tracking.SvtPlotUtils; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TSData2019; +import org.lcsim.detector.tracker.silicon.DopedSilicon; +import org.lcsim.detector.tracker.silicon.HpsSiSensor; +import org.lcsim.detector.tracker.silicon.SiSensor; +import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; +import org.lcsim.event.RawTrackerHit; +import org.lcsim.event.Track; +import org.lcsim.event.TrackerHit; +import org.lcsim.geometry.Detector; +import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHitStrip1D; +import org.lcsim.util.Driver; +import org.lcsim.util.aida.AIDA; + +public class KFTrackTimePlots extends Driver { + + // private AIDAFrame plotterFrame; + private String hitCollection = "StripClusterer_SiTrackerHitStrip1D"; + private String trackCollectionName = "KalmanFullTracks"; + IPlotter plotter, plotter2, plotter3, plotter4, plotter5, plotter6, plotter7; +// private IHistogram1D[][] t0 = new IHistogram1D[4][14]; +// private IHistogram1D[][] trackHitT0 = new IHistogram1D[4][14]; +// private IHistogram1D[][] trackHitDt = new IHistogram1D[4][14]; +// private IHistogram2D[] trackHit2D = new IHistogram2D[124]; +// private IHistogram1D[] trackT0 = new IHistogram1D[4]; +// private IHistogram2D[] trackTrigTime = new IHistogram2D[4]; +// private IHistogram2D[] trackHitDtChan = new IHistogram2D[14]; +// private IHistogram1D[] trackTimeRange = new IHistogram1D[4]; +// private IHistogram2D[] trackTimeMinMax = new IHistogram2D[4]; + + private static ITree tree = AIDA.defaultInstance().tree(); + private final IAnalysisFactory analysisFactory = AIDA.defaultInstance().analysisFactory(); + private final IPlotterFactory plotterFactory = analysisFactory.createPlotterFactory("Track Timing"); + private IHistogramFactory histogramFactory = null; + protected Map plotters = new HashMap(); + + // Histogram Maps + private static final Map trackHitDt = new HashMap(); + private static final Map trackHitT0 = new HashMap(); + private static Map clusterChargePlots = new HashMap(); + private static Map singleHitClusterChargePlots = new HashMap(); + private static final Map trackT0 = new HashMap(); + private static final Map trackTimeRange = new HashMap(); + + private static final Map trackTrigTime = new HashMap(); + private static final Map trackHit2D = new HashMap(); + private static final Map trackTimeMinMax = new HashMap(); + + private static final String subdetectorName = "Tracker"; + double minTime = -40; + double maxTime = 40; + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } + + public void setTrackCollectionName(String name) { + this.trackCollectionName = name; + } + + @Override + protected void detectorChanged(Detector detector) { + tree.cd("/"); + boolean dirExists = false; + String dirName = "/KFTrackTime"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + + histogramFactory = analysisFactory.createHistogramFactory(tree); + + List sensors = detector.getSubdetector(subdetectorName).getDetectorElement() + .findDescendants(HpsSiSensor.class); + + StyleRegistry styleRegistry = StyleRegistry.getStyleRegistry(); + IStyleStore store = styleRegistry.getStore("DefaultStyleStore"); + IPlotterStyle style2d = store.getStyle("DefaultColorMapStyle"); + style2d.setParameter("hist2DStyle", "colorMap"); + style2d.dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + // style2d.zAxisStyle().setParameter("scale", "log"); + style2d.zAxisStyle().setVisible(false); + style2d.dataBoxStyle().setVisible(false); + + IPlotterStyle styleOverlay = store.getStyle("DefaultHistogram1DStyle"); + styleOverlay.dataStyle().errorBarStyle().setVisible(true); + styleOverlay.dataStyle().fillStyle().setVisible(false); + styleOverlay.legendBoxStyle().setVisible(false); + styleOverlay.dataStyle().outlineStyle().setVisible(false); + + plotters.put("Track Hit Charge: L0-L3", plotterFactory.create("2a Hit Charge: L0-L3")); + plotters.get("Track Hit Charge: L0-L3").createRegions(4, 4); + plotters.put("Track Hit Charge: L4-L6", plotterFactory.create("2b Hit Charge: L4-L6")); + plotters.get("Track Hit Charge: L4-L6").createRegions(6, 4); + + plotters.put("Track Hit Times: L0-L3", plotterFactory.create("2c Track Hit Times: L0-L3")); + plotters.get("Track Hit Times: L0-L3").createRegions(4, 4); + plotters.put("Track Hit Times: L4-L6", plotterFactory.create("2d Track Hit Times: L4-L6")); + plotters.get("Track Hit Times: L4-L6").createRegions(6, 4); + + plotters.put("Track Hit dt: L0-L3", plotterFactory.create("2e Track Hit dt: L0-L3")); + plotters.get("Track Hit dt: L0-L3").createRegions(4, 4); + plotters.put("Track Hit dt: L4-L6", plotterFactory.create("2f Track Hit dt: L4-L6")); + plotters.get("Track Hit dt: L4-L6").createRegions(6, 4); + + plotters.put("Track Time vs. dt: L0-L3", plotterFactory.create("2gTrack Time vs. dt: L0-L3")); + plotters.get("Track Time vs. dt: L0-L3").createRegions(4, 4); + plotters.put("Track Time vs. dt: L4-L6", plotterFactory.create("2h Track Time vs. dt: L4-L6")); + plotters.get("Track Time vs. dt: L4-L6").createRegions(6, 4); + + plotters.put("Track Time", plotterFactory.create("2i Track Time")); + plotters.get("Track Time").createRegions(2, 2); + +// plotters.put("Track Trig Time", plotterFactory.create("Track Trig Time")); +// plotters.get("Track Trig Time").createRegions(2, 2); + plotters.put("Track Hit Time Range", plotterFactory.create("2j Track Hit Time Range")); + plotters.get("Track Hit Time Range").createRegions(2, 2); + + for (HpsSiSensor sensor : sensors) { + clusterChargePlots.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - Cluster Charge", 100, 0, 2000)); + singleHitClusterChargePlots + .put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + + " - Single Hit Cluster Charge", 100, 0, 2000)); + + trackHitT0.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - track hit t0", 100, minTime, maxTime)); + trackHitDt.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram1D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - track hit dt", 100, minTime, maxTime)); + + trackHit2D.put(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()), + histogramFactory.createHistogram2D(SvtPlotUtils.fixSensorNumberLabel(sensor.getName()) + " - trigger phase vs dt", 80, -20, 20.0, 6, 0, 24.0)); + if (sensor.getLayerNumber() < 9) { + plotters.get("Track Hit Charge: L0-L3") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(clusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Cluster Amplitude [ADC Counts]", "")); + plotters.get("Track Hit Charge: L0-L3") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(singleHitClusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(null, "Cluster Amplitude [ADC Counts]", "")); + plotters.get("Track Hit Times: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(trackHitT0.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "track hit t0 (ns)", "")); + plotters.get("Track Hit dt: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(trackHitDt.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "track hit dt (ns)", "")); + plotters.get("Track Time vs. dt: L0-L3").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(trackHit2D.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "track hit dt (ns)", "event time%24 (ns)")); + } else { + plotters.get("Track Hit Charge: L4-L6") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(clusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(sensor, "Cluster Amplitude [ADC Counts]", "")); + plotters.get("Track Hit Charge: L4-L6") + .region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(singleHitClusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), + this.createStyle(null, "Cluster Amplitude [ADC Counts]", "")); + plotters.get("Track Hit Times: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(trackHitT0.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "track hit t0 (ns)", "")); + plotters.get("Track Hit dt: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(trackHitDt.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "track hit dt (ns)", "")); + plotters.get("Track Time vs. dt: L4-L6").region(SvtPlotUtils.computePlotterRegionSvtUpgrade(sensor)) + .plot(trackHit2D.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())), this.createStyle(sensor, "track hit dt (ns)", "event time%24 (ns)")); + } + } + +// for (int i = 0; i < nlayers; i++) { +// int region = computePlotterRegion(i); +// trackHit2D[i] = aida.histogram2D("Layer " + i + " trigger phase vs dt", 80, -20, 20.0, 6, 0, 24.0); +// plot(plotter5, trackHit2D[i], style2d, region); +// trackHitDtChan[i] = aida.histogram2D("Layer " + i + " dt vs position", 200, -20, 20, 50, -20, 20.0); +// plot(plotter6, trackHitDtChan[i], style2d, region); +// } + trackT0.put("Top", + histogramFactory.createHistogram1D("Top Track Time", 80, -40, 40.0)); + plotters.get("Track Time") + .region(0) + .plot(trackT0.get("Top"), SvtPlotUtils.createStyle(plotterFactory, "Track Time [ns]", "")); + trackT0.put("Bottom", + histogramFactory.createHistogram1D("Bottom Track Time", 80, -40, 40.0)); + plotters.get("Track Time") + .region(1) + .plot(trackT0.get("Bottom"), SvtPlotUtils.createStyle(plotterFactory, "Track Time [ns]", "")); + trackTrigTime.put("Top", + histogramFactory.createHistogram2D("Top Track Time vs. Trig Time", 80, -40, 40.0, 6, 0, 24)); + plotters.get("Track Time") + .region(2) + .plot(trackTrigTime.get("Top"), SvtPlotUtils.createStyle(plotterFactory, "Track Time [ns]", "event time%24 (ns)")); + trackTrigTime.put("Bottom", + histogramFactory.createHistogram2D("Bottom Track Time vs. Trig Time", 80, -40, 40.0, 6, 0, 24)); + plotters.get("Track Time") + .region(3) + .plot(trackTrigTime.get("Bottom"), SvtPlotUtils.createStyle(plotterFactory, "Track Time [ns]", "event time%24 (ns)")); + + trackTimeRange.put("Top", + histogramFactory.createHistogram1D("Top Track Time Range", 75, 0, 30.0)); + plotters.get("Track Hit Time Range") + .region(0) + .plot(trackTimeRange.get("Top"), SvtPlotUtils.createStyle(plotterFactory, "Track Time Range [ns]", "")); + trackTimeRange.put("Bottom", + histogramFactory.createHistogram1D("Bottom Track Time Range", 75, 0, 30.0)); + plotters.get("Track Hit Time Range") + .region(1) + .plot(trackTimeRange.get("Bottom"), SvtPlotUtils.createStyle(plotterFactory, "Track Time Range [ns]", "")); + trackTimeMinMax.put("Top", + histogramFactory.createHistogram2D("Top Earliest vs Latest Track Hit Times", 80, -25, 25.0, 80, -25, 25.0)); + plotters.get("Track Hit Time Range") + .region(2) + .plot(trackTimeMinMax.get("Top"), SvtPlotUtils.createStyle(plotterFactory, "Earliest Time (ns)", "Latest Time (ns)")); + trackTimeMinMax.put("Bottom", + histogramFactory.createHistogram2D("Bottom Earliest vs Latest Track Hit Times", 80, -25, 25.0, 80, -25, 25.0)); + plotters.get("Track Hit Time Range") + .region(3) + .plot(trackTimeMinMax.get("Bottom"), SvtPlotUtils.createStyle(plotterFactory, "Earliest Time (ns)", "Latest Time (ns)")); + + for (IPlotter plotter : plotters.values()) { + plotter.show(); + } + + } + + public void setHitCollection(String hitCollection) { + this.hitCollection = hitCollection; + } + + @Override + public void process(EventHeader event) { + if (removeRandomEvents && event.hasCollection(GenericObject.class, "TSBank")) { + List triggerList = event.get(GenericObject.class, "TSBank"); + for (GenericObject data : triggerList) { + if (AbstractIntData.getTag(data) == TSData2019.BANK_TAG) { + TSData2019 triggerData = new TSData2019(data); + if (triggerData.isPulserTrigger() || triggerData.isFaradayCupTrigger()) { + return; + } + } + } + } + int trigTime = (int) (event.getTimeStamp() % 24); + + // + List tracks = event.get(Track.class, trackCollectionName); + for (Track track : tracks) { + int trackModule; + String moduleName = "Top"; + if (track.getTrackerHits().get(0).getPosition()[1] > 0) { + trackModule = 0; + } else { + moduleName = "Bottom"; + trackModule = 1; + } + double minTime = Double.POSITIVE_INFINITY; + double maxTime = Double.NEGATIVE_INFINITY; + int hitCount = 0; + double trackTime = 0; + for (TrackerHit hitTH : track.getTrackerHits()) { + SiTrackerHitStrip1D hit = (SiTrackerHitStrip1D) hitTH; + SiSensor sensor = (SiSensor) ((RawTrackerHit) hit.getRawHits().get(0)).getDetectorElement(); + trackHitT0.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getTime()); + trackTime += hit.getTime(); + hitCount++; + if (hit.getTime() > maxTime) { + maxTime = hit.getTime(); + } + if (hit.getTime() < minTime) { + minTime = hit.getTime(); + } + } + trackTimeMinMax.get(moduleName).fill(minTime, maxTime); + trackTimeRange.get(moduleName).fill(maxTime - minTime); + trackTime /= hitCount; + trackT0.get(moduleName).fill(trackTime); + trackTrigTime.get(moduleName).fill(trackTime, trigTime); + + for (TrackerHit hitTH : track.getTrackerHits()) { + SiTrackerHitStrip1D hit = (SiTrackerHitStrip1D) hitTH; + int layer = ((HpsSiSensor) hit.getSensor()).getLayerNumber(); + int module = ((RawTrackerHit) hit.getRawHits().get(0)).getIdentifierFieldValue("module"); + SiSensor sensor = (SiSensor) ((RawTrackerHit) hit.getRawHits().get(0)).getDetectorElement(); + trackHitDt.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getTime() - trackTime); + trackHit2D.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getTime() - trackTime, event.getTimeStamp() % 24); + clusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getdEdx() / DopedSilicon.ENERGY_EHPAIR); + if (hit.getRawHits().size() == 1) { + singleHitClusterChargePlots.get(SvtPlotUtils.fixSensorNumberLabel(sensor.getName())).fill(hit.getdEdx() / DopedSilicon.ENERGY_EHPAIR); + } + + } + } + } + + @Override + public void endOfData() { + // plotterFrame.dispose(); + } + + // private int computePlotterRegion(int layer, int module) { + // int iy = (layer) / 2; + // int ix = 0; + // if (module > 0) + // ix += 2; + // if (layer % 2 == 0) + // ix += 1; + // int region = ix * 5 + iy; + // return region; + // } + // layer 1-12 + // module 0-4...0,2 = top; 1,3=bottom + // this computePlotterRegion puts top&bottom modules on same region + // and assume plotter is split in 3 columns, 4 rows...L0-5 on top 2 rows; L6-11 on bottom 2 + private int computePlotterRegion(int layer) { + + if (layer == 0) { + return 0; + } + if (layer == 1) { + return 1; + } + if (layer == 2) { + return 4; + } + if (layer == 3) { + return 5; + } + if (layer == 4) { + return 8; + } + if (layer == 5) { + return 9; + } + + if (layer == 6) { + return 2; + } + if (layer == 7) { + return 3; + } + if (layer == 8) { + return 6; + } + if (layer == 9) { + return 7; + } + if (layer == 10) { + return 10; + } + if (layer == 11) { + return 11; + } + return -1; + } + + private String getColor(int module) { + String color = "Black"; + if (module == 1) { + color = "Green"; + } + if (module == 2) { + color = "Blue"; + } + if (module == 3) { + color = "Red"; + } + return color; + } + + IPlotterStyle createStyle(HpsSiSensor sensor, String xAxisTitle, String yAxisTitle) { + + // Create a default style + IPlotterStyle style = this.plotterFactory.createPlotterStyle(); + + // Set the style of the X axis + style.xAxisStyle().setLabel(xAxisTitle); + style.xAxisStyle().labelStyle().setFontSize(14); + style.xAxisStyle().setVisible(true); + + // Set the style of the Y axis + style.yAxisStyle().setLabel(yAxisTitle); + style.yAxisStyle().labelStyle().setFontSize(14); + style.yAxisStyle().setVisible(true); + + // Turn off the histogram grid + style.gridStyle().setVisible(false); + + // Set the style of the data + style.dataStyle().lineStyle().setVisible(false); + style.dataStyle().outlineStyle().setVisible(false); + style.dataStyle().outlineStyle().setThickness(4); + style.dataStyle().fillStyle().setVisible(true); + style.dataStyle().fillStyle().setOpacity(.30); + + if (sensor == null) { + style.dataStyle().fillStyle().setColor("255, 38, 38, 1"); + style.dataStyle().outlineStyle().setColor("255, 38, 38, 1"); + style.dataStyle().fillStyle().setOpacity(.70); + } else if (sensor.isTopLayer()) { + style.dataStyle().fillStyle().setColor("31, 137, 229, 1"); + style.dataStyle().outlineStyle().setColor("31, 137, 229, 1"); + } else if (sensor.isBottomLayer()) { + style.dataStyle().fillStyle().setColor("93, 228, 47, 1"); + style.dataStyle().outlineStyle().setColor("93, 228, 47, 1"); + } + style.dataStyle().errorBarStyle().setVisible(false); + + style.regionBoxStyle().backgroundStyle().setOpacity(.20); + if (sensor != null && sensor.isAxial()) { + style.regionBoxStyle().backgroundStyle().setColor("246, 246, 34, 1"); + } + + // Turn off the legend + style.legendBoxStyle().setVisible(false); + + return style; + } + +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFTrackingReconPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFTrackingReconPlots.java new file mode 100644 index 0000000000..7c1e1f27a8 --- /dev/null +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/KFTrackingReconPlots.java @@ -0,0 +1,565 @@ +package org.hps.monitoring.drivers.trackrecon; + +import hep.aida.IAnalysisFactory; +import hep.aida.IHistogram1D; +import hep.aida.IHistogram2D; +import hep.aida.IPlotter; +import hep.aida.IPlotterFactory; +import hep.aida.ITree; +import hep.physics.vec.BasicHep3Vector; +import hep.physics.vec.Hep3Vector; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Level; +import java.util.logging.Logger; +import org.hps.detector.hodoscope.HodoscopeDetectorElement; +import org.hps.detector.hodoscope.HodoscopePixelDetectorElement; + +import static org.hps.monitoring.drivers.trackrecon.PlotAndFitUtilities.plot; +import org.hps.recon.ecal.HodoUtils; + +import org.hps.recon.tracking.TrackUtils; +import org.lcsim.detector.DetectorElement; +import org.lcsim.detector.identifier.IIdentifier; +import org.lcsim.event.Cluster; +import org.lcsim.event.EventHeader; +import org.lcsim.event.LCIOParameters.ParameterName; +import org.lcsim.event.RawTrackerHit; +import org.lcsim.event.Track; +import org.lcsim.event.TrackState; +import org.lcsim.event.TrackerHit; +import org.lcsim.geometry.Detector; +import org.lcsim.geometry.IDDecoder; +import org.lcsim.recon.tracking.digitization.sisim.SiTrackerHitStrip1D; +import org.lcsim.util.Driver; +import org.lcsim.util.aida.AIDA; + +public class KFTrackingReconPlots extends Driver { + + private AIDA aida = AIDA.defaultInstance(); + private static ITree tree = AIDA.defaultInstance().tree(); + private String trackCollectionName = "KalmanFullTracks"; + // private String helicalTrackHitCollectionName = "HelicalTrackHits"; + String ecalSubdetectorName = "Ecal"; + String ecalCollectionName = "EcalClusters"; + IDDecoder dec; + private String outputPlots = null; + private boolean debug = false; + + double feeMomentumCut = 0; + int nmodules = 7; + + IPlotter plotter; + IPlotter plotter22; + IPlotter plotterECal; + IPlotter plotterFEE; + IPlotter plotterLayers; + IPlotter plotterHodo; + + IHistogram1D nTracks; + IHistogram1D nhits; + IHistogram1D charge; + IHistogram1D trkPx; + IHistogram1D trkPy; + IHistogram1D trkPz; + IHistogram1D trkChi2; + IHistogram1D trkd0; + IHistogram1D trkphi; + IHistogram1D trkomega; + IHistogram1D trklam; + IHistogram1D trkz0; + IHistogram1D heOverP; + IHistogram1D hdelXECal; + IHistogram1D hdelYECal; + IHistogram2D heVsP; + IHistogram1D hfeeMom; + IHistogram1D hfeeMomTop; + IHistogram1D hfeeMomBot; + IHistogram1D hfeeTheta; + IHistogram1D hfeePOverE; + IHistogram2D hfeeClustPos; + IHistogram1D htopLay; + IHistogram1D hbotLay; + + IHistogram2D htrkProjH1TopMatch; + IHistogram2D htrkProjH2TopMatch; + IHistogram2D htrkProjH1BotMatch; + IHistogram2D htrkProjH2BotMatch; + + IHistogram2D htrkProjH1TopNoMatch; + IHistogram2D htrkProjH2TopNoMatch; + IHistogram2D htrkProjH1BotNoMatch; + IHistogram2D htrkProjH2BotNoMatch; + + IHistogram1D[] hthTop = new IHistogram1D[nmodules]; + IHistogram1D[] hthBot = new IHistogram1D[nmodules]; + // IHistogram2D[] xvsyTop = new IHistogram2D[nmodules]; + //IHistogram2D[] xvsyBot = new IHistogram2D[nmodules]; + // IHistogram2D[] xvsyTopHOT = new IHistogram2D[nmodules]; + //IHistogram2D[] xvsyBotHOT = new IHistogram2D[nmodules]; +//HODOSCOPE Stuff + private static final String SUBDETECTOR_NAME = "Hodoscope"; + private List pixels; + private List hodos; + private Map hodoMap = new HashMap(); + + // ===== The Mode1 Hodo hit collection name ===== +// private String rawCollectionName = "HodoReadoutHits"; +// private String hodoCollectionName = "HodoCalHits"; +// private final String hodoReadoutCollectionName = "HodoscopeHits"; +// private String hodoHitsCollectionName = "HodoGenericHits"; + private String hodoClustersCollectionName = "HodoGenericClusters"; + + double pMax = 6.0; + + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } + + public void setFeeMomentumCut(double cut) { + this.feeMomentumCut = cut; + } + + @Override + protected void detectorChanged(Detector detector) { + + // Get the HpsSiSensor objects from the geometry +// pixels = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HodoscopePixelDetectorElement.class); +// +// for (HodoscopePixelDetectorElement pix : pixels) { +// System.out.println("KFTrackingReconPlots:: pix = " + pix.getName() + " position = " + pix.getGeometry().getPosition().toString()); +// System.out.println("KFTrackingReconPlots:: cellID =" + pix.getIdentifier().toString()); +// hodoMap.put(pix.getIdentifier(), pix); +// } + hodoMap = HodoUtils.getHodoscopeMap(detector); + + //pix.getGeometry().getPhysicalVolume(pix.getGeometry().getPosition()). +// hodos = detector.getSubdetector(SUBDETECTOR_NAME).getDetectorElement().findDescendants(HodoscopeDetectorElement.class); +// for (HodoscopeDetectorElement hod : hodos) +// System.out.println("KFTrackingReconPlots:: hod = " + hod.getName() + " position = " + hod.getGeometry().getPosition().toString()); //pix.getGeometry().getPhysicalVolume(pix.getGeometry().getPosition()). + tree.cd("/"); + boolean dirExists = false; + String dirName = "/KFTrackingRecon"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + + IAnalysisFactory fac = aida.analysisFactory(); + IPlotterFactory pfac = fac.createPlotterFactory("Track Recon"); + plotter = pfac.create("1a Momentum"); + + plotter.createRegions(2, 3); + // plotterFrame.addPlotter(plotter); + + nhits = aida.histogram1D("Hits per Track", 11, 4, 15); + + charge = aida.histogram1D("Track Charge", 3, -1, 2); + trkPx = aida.histogram1D("Track Momentum (Px)", 50, -0.1, 0.2); + trkPy = aida.histogram1D("Track Momentum (Py)", 50, -0.2, 0.2); + trkPz = aida.histogram1D("Track Momentum (Pz)", 50, 0, pMax); + trkChi2 = aida.histogram1D("Track Chi2 PDF", 50, 0, 15.0); + + plot(plotter, nhits, null, 0); + plot(plotter, charge, null, 1); + plot(plotter, trkPx, null, 2); + plot(plotter, trkPy, null, 3); + plot(plotter, trkPz, null, 4); + plot(plotter, trkChi2, null, 5); + + plotter.show(); + + // ****************************************************************** + nTracks = aida.histogram1D("Number of Tracks ", 7, 0, 7.0); + trkd0 = aida.histogram1D("d0 ", 50, -5.0, 5.0); + trkphi = aida.histogram1D("sinphi ", 50, -0.1, 0.15); + trkomega = aida.histogram1D("omega ", 50, -0.0006, 0.0006); + trklam = aida.histogram1D("tan(lambda) ", 50, -0.1, 0.1); + trkz0 = aida.histogram1D("y0 ", 50, -1.0, 1.0); + + plotter22 = pfac.create("1b Track parameters"); + plotter22.createRegions(2, 3); + plot(plotter22, nTracks, null, 0); + plot(plotter22, trkd0, null, 1); + plot(plotter22, trkphi, null, 2); + plot(plotter22, trkomega, null, 3); + plot(plotter22, trklam, null, 4); + plot(plotter22, trkz0, null, 5); + + plotter22.show(); + + // ****************************************************************** + heOverP = aida.histogram1D("Cluster Energy over Track Momentum ", 50, 0, 2.0); + hdelXECal = aida.histogram1D("delta X @ ECal (mm) ", 50, -15.0, 15.0); + hdelYECal = aida.histogram1D("delta Y @ ECal (mm) ", 50, -15.0, 15.0); + heVsP = aida.histogram2D("Momentum vs ECal E ", 50, 0, 7.0, 50, 0, 7.0); + + plotterECal = pfac.create("1c Cluster Matching"); + plotterECal.createRegions(2, 2); + plot(plotterECal, heOverP, null, 0); + plot(plotterECal, hdelXECal, null, 1); + plot(plotterECal, hdelYECal, null, 2); + plot(plotterECal, heVsP, null, 3); + + plotterECal.show(); + + // ****************************************************************** + // fix the ranges here... + hfeeMom = aida.histogram1D("FEE Momentum", 50, feeMomentumCut, pMax); + hfeeMomTop = aida.histogram1D("Top FEE Momentum ", 50, feeMomentumCut, pMax); + hfeeMomBot = aida.histogram1D("Bottom FEE Momentum ", 50, feeMomentumCut, pMax); + hfeeTheta = aida.histogram1D("FEE Angle", 50, -15.0, 15.0); + hfeePOverE = aida.histogram1D("FEE EOverP", 50, 0, 1.5); + hfeeClustPos = aida.histogram2D("FEE Cluster Position", 50, -2000.0, 2000.0, 50, -500, 500); + + plotterFEE = pfac.create("1d Full Energy Electrons"); + plotterFEE.createRegions(2, 2); + plot(plotterFEE, hfeeMom, null, 0); + plot(plotterFEE, hfeeMomBot, null, 3); + plot(plotterFEE, hfeePOverE, null, 1); + plot(plotterFEE, hfeeMomTop, null, 2); + + plotterFEE.show(); + + // plotterHTH = pfac.create("Track Hits"); + //plotterHTH.createRegions(4, 4); + //plotterXvsY = pfac.create("3d Hit Positions"); + //plotterXvsY.createRegions(4, 4); + /* + plotterXvsYHOT = pfac.create("3d Hits-On-Track"); + plotterXvsYHOT.createRegions(4, 4); + + for (int i = 0; i < nmodules; i++) { + double maxHTHX = 150.0; + double maxHTHY = 50.0; + if (i < 2) { + maxHTHX = 10; + maxHTHY = 15; + } else if (i < 4) { + maxHTHX = 50; + maxHTHY = 30; + } + xvsyTop[i] = aida.histogram2D("Module " + i + " Top (abs(Y))", 100, -maxHTHX, maxHTHX, 55, 0, maxHTHY); + xvsyBot[i] = aida.histogram2D("Module " + i + " Bottom (abs(Y))", 100, -maxHTHX, maxHTHX, 55, 0, maxHTHY); + xvsyTopHOT[i] = aida.histogram2D("Module " + i + " Top HOT (abs(Y))", 100, -maxHTHX, maxHTHX, 55, 0, maxHTHY); + xvsyBotHOT[i] = aida.histogram2D("Module " + i + " Bottom HOT (abs(Y))", 100, -maxHTHX, maxHTHX, 55, 0, maxHTHY); + hthTop[i] = aida.histogram1D("Module " + i + "Top: Track Hits", 25, 0, 25); + hthBot[i] = aida.histogram1D("Module " + i + "Bot: Track Hits", 25, 0, 25); + plot(plotterHTH, hthTop[i], null, computePlotterRegion(i, true)); + plot(plotterHTH, hthBot[i], null, computePlotterRegion(i, false)); + plot(plotterXvsY, xvsyTop[i], null, computePlotterRegion(i, true)); + plot(plotterXvsY, xvsyBot[i], null, computePlotterRegion(i, false)); + plot(plotterXvsYHOT, xvsyTopHOT[i], null, computePlotterRegion(i, true)); + plot(plotterXvsYHOT, xvsyBotHOT[i], null, computePlotterRegion(i, false)); + } + */ + // plotterHTH.show(); + // plotterXvsY.show(); + // plotterXvsYHOT.show(); + htopLay = aida.histogram1D("Top Layers on Track", 15, 0, 15); + hbotLay = aida.histogram1D("Bottom Layers on Track", 15, 0, 15); + plotterLayers = pfac.create("1e Layers Hit on Track"); + plotterLayers.createRegions(1, 2); + plot(plotterLayers, htopLay, null, 0); + plot(plotterLayers, hbotLay, null, 1); + plotterLayers.show(); + +// plotterHodo = pfac.create("Hodoscope Matching"); +// plotterHodo.createRegions(2, 4); +// htrkProjH1TopMatch = aida.histogram2D("Top Hodoscope L1 Projection Match", 50, 0, 350, 50, 0, 100); +// htrkProjH2TopMatch = aida.histogram2D("Top Hodoscope L2 Projection Match", 50, 0, 350, 50, 0, 100); +// htrkProjH1BotMatch = aida.histogram2D("Bottom Hodoscope L1 Projection Match", 50, 0, 350, 50, 0, 100); +// htrkProjH2BotMatch = aida.histogram2D("Bottom Hodoscope L2 Projection Match", 50, 0, 350, 50, 0, 100); +// htrkProjH1TopNoMatch = aida.histogram2D("Top Hodoscope L1 Projection No Match", 50, 0, 350, 50, 0, 100); +// htrkProjH2TopNoMatch = aida.histogram2D("Top Hodoscope L2 Projection No Match", 50, 0, 350, 50, 0, 100); +// htrkProjH1BotNoMatch = aida.histogram2D("Bottom Hodoscope L1 Projection No Match", 50, 0, 350, 50, 0, 100); +// htrkProjH2BotNoMatch = aida.histogram2D("Bottom Hodoscope L2 Projection No Match", 50, 0, 350, 50, 0, 100); +// plot(plotterHodo, htrkProjH1TopMatch, null, 0); +// plot(plotterHodo, htrkProjH1BotMatch, null, 2); +// plot(plotterHodo, htrkProjH2TopMatch, null, 4); +// plot(plotterHodo, htrkProjH2BotMatch, null, 6); +// plot(plotterHodo, htrkProjH1TopNoMatch, null, 1); +// plot(plotterHodo, htrkProjH1BotNoMatch, null, 3); +// plot(plotterHodo, htrkProjH2TopNoMatch, null, 5); +// plot(plotterHodo, htrkProjH2BotNoMatch, null, 7); +// setZAxis(plotterHodo); +// plotterHodo.show(); + } + + public KFTrackingReconPlots() { + } + + public void setOutputPlots(String output) { + this.outputPlots = output; + } + + public void setDebug(boolean dbg) { + this.debug = dbg; + } + + public void setTrackCollectionName(String trackCollectionName) { + this.trackCollectionName = trackCollectionName; + } + + @Override + public void process(EventHeader event) { + aida.tree().cd("/"); + + if (!event.hasCollection(Track.class, trackCollectionName)) { + nTracks.fill(0); + return; + } + + // if (!event.hasCollection(TrackerHit.class, helicalTrackHitCollectionName)) + // return; + List tracks = event.get(Track.class, trackCollectionName); + nTracks.fill(tracks.size()); + + for (Track trk : tracks) { + Hep3Vector momentum = new BasicHep3Vector(trk.getTrackStates().get(0).getMomentum()); + double pmag = momentum.magnitude(); + double pt = Math.sqrt(momentum.z() * momentum.z() + momentum.y() * momentum.y()); + double theta = Math.asin(pt / pmag); + + trkPx.fill(momentum.y()); + trkPy.fill(momentum.z()); + trkPz.fill(momentum.x()); + trkChi2.fill(trk.getChi2() / trk.getNDF()); + + nhits.fill(trk.getTrackerHits().size()); + charge.fill(-trk.getCharge()); + trkd0.fill(trk.getTrackStates().get(0).getParameter(ParameterName.d0.ordinal())); + trkphi.fill(Math.sin(trk.getTrackStates().get(0).getParameter(ParameterName.phi0.ordinal()))); + trkomega.fill(trk.getTrackStates().get(0).getParameter(ParameterName.omega.ordinal())); + trklam.fill(trk.getTrackStates().get(0).getParameter(ParameterName.tanLambda.ordinal())); + trkz0.fill(trk.getTrackStates().get(0).getParameter(ParameterName.z0.ordinal())); + + if (pmag > feeMomentumCut && trk.getCharge() > 0) { // remember, hps-java track charge is opposite the real + // charge + hfeeMom.fill(momentum.magnitude()); + hfeeTheta.fill(theta); + if (momentum.z() < 0) { + hfeeMomBot.fill(pmag); + } else { + hfeeMomTop.fill(pmag); + } + } + + List hitsOnTrack = trk.getTrackerHits(); + for (TrackerHit hthOnTrack : hitsOnTrack) { + int module = ((RawTrackerHit) hthOnTrack.getRawHits().get(0)).getLayerNumber(); + SiTrackerHitStrip1D htc = (SiTrackerHitStrip1D) hthOnTrack; + if (htc.getPosition()[1] > 0) { + htopLay.fill(module); + } else { + hbotLay.fill(module); + } + } + + TrackState stateAtEcal = TrackUtils.getTrackStateAtECal(trk); + if (stateAtEcal == null) { + System.out.println("Couldn't get track state at ECal"); + continue; + } + + Hep3Vector posAtEcal = new BasicHep3Vector(stateAtEcal.getReferencePoint()); + // Hep3Vector posAtEcal = hpstrk.getPositionAtZMap(svt_l12, ecal_face, 5.0, + // event.getDetector().getFieldMap())[0]; + List clusters = event.get(Cluster.class, ecalCollectionName); + if (clusters != null) { + if (debug) { + System.out.println("Found " + clusters.size() + " clusters"); + } + Cluster clust = findClosestCluster(posAtEcal, clusters); + if (clust != null) { + if (debug) { + System.out.println("\t\t\t Found the best clusters"); + } + Hep3Vector clusterPos = new BasicHep3Vector(clust.getPosition()); + double zCluster = clusterPos.z(); + double eOverP = clust.getEnergy() / pmag; + double dx = posAtEcal.y() - clusterPos.x(); + double dy = posAtEcal.z() - clusterPos.y(); + heOverP.fill(eOverP); + hdelXECal.fill(dx); + hdelYECal.fill(dy); + heVsP.fill(pmag, clust.getEnergy()); + if (pmag > feeMomentumCut && trk.getCharge() > 0) { // remember, hps-java track charge is opposite + // the real charge + hfeePOverE.fill(clust.getEnergy() / pmag); + hfeeClustPos.fill(posAtEcal.x(), posAtEcal.y()); + } + } + } + + ////// Do Track-Hodoscope Matching //// + // Get RawTrackerHit collection from event. +// List reconHits = event.get(SimpleGenericObject.class, hodoClustersCollectionName); +// +// //System.out.println("Size of reconHitsi is " + reconHits.size()); +// int n_hits = reconHits.get(0).getNInt(); +// // ======= Loop over hits, and fill corresponding histogram ======= +// for (int ihit = 0; ihit < n_hits; ihit++) { +// int ix = reconHits.get(0).getIntVal(ihit); +// int iy = reconHits.get(1).getIntVal(ihit); +// int layer = reconHits.get(2).getIntVal(ihit); +// double Energy = reconHits.get(3).getDoubleVal(ihit); +// double hit_time = reconHits.get(4).getDoubleVal(ihit); +// int detid = reconHits.get(5).getIntVal(ihit); +// } +// TrackState stateAtHodo1 = TrackUtils.getTrackStateAtHodoL1(trk); +// TrackState stateAtHodo2 = TrackUtils.getTrackStateAtHodoL2(trk); +// if (stateAtHodo1 != null && stateAtHodo2 != null) { +// Hep3Vector posAtH1 = new BasicHep3Vector(stateAtHodo1.getReferencePoint()); +// Hep3Vector posAtH2 = new BasicHep3Vector(stateAtHodo2.getReferencePoint()); +// boolean isMatchHL1 = false; +// boolean isMatchHL2 = false; +// for (int ihit = 0; ihit < n_hits; ihit++) { +// int detid = reconHits.get(5).getIntVal(ihit); +// int layer = reconHits.get(2).getIntVal(ihit); +// DetectorElement thisTile = hodoMap.get(new Identifier(detid)); +// if (thisTile == null) { +// System.out.println("Could not find this tile~~~~"); +// continue; +// } +// if (layer == 0) { +// isMatchHL1 = isMatchHL1 || TrackUtils.detectorElementContainsPoint(CoordinateTransformations.transformVectorToDetector(posAtH1), +// (DetectorElement) thisTile, 20.0); +// } +// if (layer == 1) { +// isMatchHL2 = isMatchHL2 || TrackUtils.detectorElementContainsPoint(CoordinateTransformations.transformVectorToDetector(posAtH2), +// (DetectorElement) thisTile, 20.0); +// } +// } +// if (posAtH1.z() > 0) { +// if (isMatchHL1) { +// htrkProjH1TopMatch.fill(posAtH1.y(), posAtH1.z()); +// } else { +// htrkProjH1TopNoMatch.fill(posAtH1.y(), posAtH1.z()); +// } +// } else if (isMatchHL1) { +// htrkProjH1BotMatch.fill(posAtH1.y(), -1 * posAtH1.z()); +// } else { +// htrkProjH1BotNoMatch.fill(posAtH1.y(), -1 * posAtH1.z()); +// } +// +// if (posAtH2.z() > 0) { +// if (isMatchHL2) { +// htrkProjH2TopMatch.fill(posAtH2.y(), posAtH2.z()); +// } else { +// htrkProjH2TopNoMatch.fill(posAtH2.y(), posAtH2.z()); +// } +// } else if (isMatchHL2) { +// htrkProjH2BotMatch.fill(posAtH2.y(), -1 * posAtH2.z()); +// } else { +// htrkProjH2BotNoMatch.fill(posAtH2.y(), -1 * posAtH2.z()); +// } +// } + } +// for (HodoscopePixelDetectorElement pix : pixels) { +//// System.out.println("This pixel has hits = "+pix.getReadout().getHits(RawTrackerHit.class).size()); +// boolean inH1 = TrackUtils.detectorElementContainsPoint(CoordinateTransformations.transformVectorToDetector(posAtH1), (DetectorElement) pix, 1.5); +// } + } + + @Override + public void endOfData() { + if (outputPlots != null) { + try { + plotter.writeToFile(outputPlots + "-mom.gif"); + plotter22.writeToFile(outputPlots + "-trkparams.gif"); + + } catch (IOException ex) { + Logger.getLogger(KFTrackingReconPlots.class + .getName()).log(Level.SEVERE, null, ex); + } + } + + // plotterFrame.dispose(); + // topFrame.dispose(); + // bottomFrame.dispose(); + } + + /* + * mg...3/26/15...use this for now; eventually use the FinalStateParticle matching + */ + private Cluster findClosestCluster(Hep3Vector posonhelix, List clusters) { + Cluster closest = null; + double minDist = 9999; + for (Cluster cluster : clusters) { + double[] clPos = cluster.getPosition(); + double clEne = cluster.getEnergy(); + // double dist = Math.sqrt(Math.pow(clPos[0] - posonhelix.y(), 2) + Math.pow(clPos[1] - posonhelix.z(), 2)); + // //coordinates!!! + double dist = Math.sqrt(Math.pow(clPos[1] - posonhelix.y(), 2)); // coordinates!!! +// if (dist < minDist && clEne < 3.0) { + if (dist < minDist) { + closest = cluster; + minDist = dist; + } + } + return closest; + } + + private int computePlotterRegion(int i, boolean istop) { + + int region = -99; + if (i < 3) { + if (istop) { + region = i * 4; + } else { + region = i * 4 + 1; + } + } else if (istop) { + region = (i - 3) * 4 + 2; + } else { + region = (i - 3) * 4 + 3; + } + // System.out.println("Setting region to "+region); + return region; + } + + private void setZAxis(IPlotter plotter) { + for (int i = 0; i < plotter.numberOfRegions(); i++) { + plotter.region(i).style().setParameter("hist2DStyle", "colorMap"); + plotter.region(i).style().dataStyle().fillStyle().setParameter("colorMapScheme", "rainbow"); + plotter.region(i).style().zAxisStyle().setVisible(true); + plotter.region(i).style().zAxisStyle().setParameter("scale", "log"); + + } + } + + private int getModuleNumber(TrackerHit hit) { + int module = -666; + int layer = ((RawTrackerHit) hit.getRawHits().get(0)).getLayerNumber(); + if (layer < 2) { + module = 1; + } else if (layer < 4) { + module = 2; + } else if (layer < 6) { + module = 3; + } else if (layer < 8) { + module = 4; + } else if (layer < 10) { + module = 5; + } else if (layer < 12) { + module = 6; + } else { + module = 7; + } + return module; + } + +} diff --git a/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/V0ReconPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/V0ReconPlots.java index cdc9926a9b..a9bd8f5cd8 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/V0ReconPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/drivers/trackrecon/V0ReconPlots.java @@ -8,13 +8,17 @@ import hep.aida.IHistogram2D; import hep.aida.IPlotter; import hep.aida.IPlotterFactory; +import hep.aida.ITree; import java.io.IOException; import java.util.List; import java.util.logging.Level; import java.util.logging.Logger; +import org.hps.record.triggerbank.AbstractIntData; +import org.hps.record.triggerbank.TSData2019; import org.lcsim.event.EventHeader; +import org.lcsim.event.GenericObject; import org.lcsim.event.ReconstructedParticle; import org.lcsim.event.Track; import org.lcsim.event.Vertex; @@ -25,10 +29,11 @@ public class V0ReconPlots extends Driver { private AIDA aida = AIDA.defaultInstance(); + private static ITree tree = null; String finalStateParticlesColName = "FinalStateParticles"; String unconstrainedV0CandidatesColName = "UnconstrainedV0Candidates"; String beamConV0CandidatesColName = "BeamspotConstrainedV0Candidates"; - String targetV0ConCandidatesColName = "TargetConstrainedV0Candidates"; + String targetConV0CandidatesColName = "TargetConstrainedV0Candidates"; // some counters int nRecoEvents = 0; boolean debug = false; @@ -52,6 +57,27 @@ public class V0ReconPlots extends Driver { IHistogram2D pyEleVspyPos; IHistogram2D pxEleVspxPos; IHistogram2D massVsVtxZ; + private boolean removeRandomEvents = true; + + public void setRemoveRandomEvents(boolean doit) { + this.removeRandomEvents = doit; + } + + public void setFinalStateParticlesColName(String name) { + this.finalStateParticlesColName = name; + } + + public void setUnconstrainedV0CandidatesColName(String name) { + this.unconstrainedV0CandidatesColName = name; + } + + public void setBeamConV0CandidatesColName(String name) { + this.beamConV0CandidatesColName = name; + } + + public void setTargetConV0CandidatesColName(String name) { + this.targetConV0CandidatesColName = name; + } @Override protected void detectorChanged(Detector detector) { @@ -61,16 +87,30 @@ protected void detectorChanged(Detector detector) { IPlotterFactory pfac = fac.createPlotterFactory("V0 Recon"); functionFactory = aida.analysisFactory().createFunctionFactory(null); fitFactory = aida.analysisFactory().createFitFactory(); + tree = AIDA.defaultInstance().tree(); + tree.cd("/"); + boolean dirExists = false; + String dirName = "/V0Recon"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); - aida.tree().cd("/"); // resetOccupancyMap(); // this is for calculatin - plotterUncon = pfac.create("Unconstrained V0"); + plotterUncon = pfac.create("4a Unconstrained V0"); plotterUncon.createRegions(2, 3); /* V0 Quantities */ - /* Mass, vertex, chi^2 of fit */ - /* beamspot constrained */ + /* Mass, vertex, chi^2 of fit */ + /* beamspot constrained */ nV0 = aida.histogram1D("Number of V0 per event", 5, 0, 5); unconMass = aida.histogram1D("Unconstrained Mass (GeV)", 100, 0, 0.200); unconVx = aida.histogram1D("Unconstrained Vx (mm)", 50, -1, 1); @@ -84,7 +124,7 @@ protected void detectorChanged(Detector detector) { plot(plotterUncon, unconVy, null, 4); plot(plotterUncon, unconVz, null, 5); - plotter2d = pfac.create("Unconstrained 2d plots"); + plotter2d = pfac.create("4b Unconstrained 2d plots"); plotter2d.createRegions(2, 2); pEleVspPos = aida.histogram2D("P(e) vs P(p)", 50, 0, 2.5, 50, 0, 2.5); @@ -101,28 +141,43 @@ protected void detectorChanged(Detector detector) { @Override public void process(EventHeader event) { + if (removeRandomEvents && event.hasCollection(GenericObject.class, "TSBank")) { + List triggerList = event.get(GenericObject.class, "TSBank"); + for (GenericObject data : triggerList) { + if (AbstractIntData.getTag(data) == TSData2019.BANK_TAG) { + TSData2019 triggerData = new TSData2019(data); + if (triggerData.isPulserTrigger() || triggerData.isFaradayCupTrigger()) { + return; + } + } + } + } /* make sure everything is there */ - if (!event.hasCollection(ReconstructedParticle.class, finalStateParticlesColName)) + if (!event.hasCollection(ReconstructedParticle.class, finalStateParticlesColName)) { return; - if (!event.hasCollection(ReconstructedParticle.class, unconstrainedV0CandidatesColName)) + } + if (!event.hasCollection(ReconstructedParticle.class, unconstrainedV0CandidatesColName)) { return; - if (!event.hasCollection(ReconstructedParticle.class, beamConV0CandidatesColName)) + } + if (!event.hasCollection(ReconstructedParticle.class, beamConV0CandidatesColName)) { return; - if (!event.hasCollection(ReconstructedParticle.class, targetV0ConCandidatesColName)) + } + if (!event.hasCollection(ReconstructedParticle.class, targetConV0CandidatesColName)) { return; + } nRecoEvents++; List unConstrainedV0List = event.get(ReconstructedParticle.class, unconstrainedV0CandidatesColName); - aida.histogram1D("Number of V0 per event").fill(unConstrainedV0List.size()); + nV0.fill(unConstrainedV0List.size()); for (ReconstructedParticle uncV0 : unConstrainedV0List) { Vertex uncVert = uncV0.getStartVertex(); - aida.histogram1D("Unconstrained Vx (mm)").fill(uncVert.getPosition().x()); - aida.histogram1D("Unconstrained Vy (mm)").fill(uncVert.getPosition().y()); - aida.histogram1D("Unconstrained Vz (mm)").fill(uncVert.getPosition().z()); - aida.histogram1D("Unconstrained Mass (GeV)").fill(uncV0.getMass()); - aida.histogram1D("Unconstrained Chi2").fill(uncVert.getChi2()); - aida.histogram2D("Mass vs Vz").fill(uncV0.getMass(), uncVert.getPosition().z()); + unconVx.fill(uncVert.getPosition().x()); + unconVy.fill(uncVert.getPosition().y()); + unconVz.fill(uncVert.getPosition().z()); + unconMass.fill(uncV0.getMass()); + unconChi2.fill(uncVert.getChi2()); + massVsVtxZ.fill(uncV0.getMass(), uncVert.getPosition().z()); // this always has 2 tracks. List trks = uncV0.getParticles(); Track ele = trks.get(0).getTracks().get(0); @@ -133,10 +188,10 @@ public void process(EventHeader event) { pos = trks.get(0).getTracks().get(0); ele = trks.get(1).getTracks().get(0); } - aida.histogram2D("P(e) vs P(p)").fill(getMomentum(ele), getMomentum(pos)); - aida.histogram2D("Px(e) vs Px(p)").fill(ele.getTrackStates().get(0).getMomentum()[1], + pEleVspPos.fill(getMomentum(ele), getMomentum(pos)); + pxEleVspxPos.fill(ele.getTrackStates().get(0).getMomentum()[1], pos.getTrackStates().get(0).getMomentum()[1]); - aida.histogram2D("Py(e) vs Py(p)").fill(ele.getTrackStates().get(0).getMomentum()[2], + pyEleVspyPos.fill(ele.getTrackStates().get(0).getMomentum()[2], pos.getTrackStates().get(0).getMomentum()[2]); } } @@ -155,13 +210,14 @@ private double getMomentum(Track trk) { @Override public void endOfData() { - if (outputPlots != null) + if (outputPlots != null) { try { plotterUncon.writeToFile(outputPlots + "-Unconstrained.gif"); plotter2d.writeToFile(outputPlots + "-2d.gif"); } catch (IOException ex) { Logger.getLogger(TrackingReconPlots.class.getName()).log(Level.SEVERE, null, ex); } + } } diff --git a/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalClusterPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalClusterPlots.java index 5d2bd99cea..1357948fa3 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalClusterPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalClusterPlots.java @@ -4,6 +4,7 @@ import hep.aida.IHistogram2D; import hep.aida.IPlotter; import hep.aida.IPlotterFactory; +import hep.aida.ITree; import hep.physics.vec.BasicHep3Vector; import hep.physics.vec.Hep3Vector; import static java.lang.Math.sqrt; @@ -52,6 +53,7 @@ */ public class EcalClusterPlots extends Driver { + private static ITree tree = null; // Internal variables. private boolean hide = false; private boolean logScale = false; @@ -98,8 +100,24 @@ public class EcalClusterPlots extends Driver { */ @Override protected void detectorChanged(Detector detector) { - // Re-instantiate all of the histograms. - aida.tree().cd("/"); + // Re-instantiate all of the histograms. + + tree = AIDA.defaultInstance().tree(); + tree.cd("/"); + boolean dirExists = false; + String dirName = "/EcalClusters"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + clusterCountPlot = aida.histogram1D(detector.getDetectorName() + " : " + clusterCollectionName + " : Cluster Count per Event", 10, -0.5, 9.5); clusterSizePlot = aida.histogram1D(detector.getDetectorName() + " : " + clusterCollectionName @@ -135,8 +153,9 @@ protected void detectorChanged(Detector detector) { plotter[tabIndex].style().dataStyle().errorBarStyle().setVisible(false); plotter[tabIndex].style().dataStyle().fillStyle() .setParameter("showZeroHeightBins", Boolean.FALSE.toString()); - if (logScale) + if (logScale) { plotter[tabIndex].style().yAxisStyle().setParameter("scale", "log"); + } } // Define the Cluster Counts tab. @@ -171,9 +190,11 @@ protected void detectorChanged(Detector detector) { plotter[TAB_CLUSTER_MASS].region(2).plot(pairMassSameHalfFid); plotter[TAB_CLUSTER_MASS].region(3).plot(pairMassOppositeHalfFid); // If they should not be hidden, display the tabs. - if (!hide) - for (IPlotter tab : plotter) + if (!hide) { + for (IPlotter tab : plotter) { tab.show(); + } + } } /** @@ -200,8 +221,9 @@ public void process(EventHeader event) { for (Cluster cluster : clusterList) { // If this cluster has a higher energy then was seen // previously, it is now the highest energy cluster. - if (cluster.getEnergy() > maxEnergy) + if (cluster.getEnergy() > maxEnergy) { maxEnergy = cluster.getEnergy(); + } // Get the list of calorimeter hits and its size. List hitList = cluster.getCalorimeterHits(); @@ -238,23 +260,25 @@ public void process(EventHeader event) { // Cluster pairs are formed from all top/bottom cluster // combinations. To create these pairs, separate the // clusters into two lists based on their y-indices. - if (cluster.getCalorimeterHits().get(0).getIdentifierFieldValue("ix") > 0) + if (cluster.getCalorimeterHits().get(0).getIdentifierFieldValue("ix") > 0) { topList.add(cluster); - else + } else { bottomList.add(cluster); + } } // Populate the event plots. clusterCountPlot.fill(clusterList.size()); - if (maxEnergy > 0) + if (maxEnergy > 0) { clusterMaxEnergyPlot.fill(maxEnergy); + } // Create a list to store cluster pairs. List pairList = new ArrayList(topList.size() * bottomList.size()); // Form pairs from all possible combinations of clusters // from the top and bottom lists. - for (Cluster topCluster : topList) + for (Cluster topCluster : topList) { for (Cluster bottomCluster : bottomList) { // Make a cluster pair array. Cluster[] pair = new Cluster[2]; @@ -271,6 +295,7 @@ public void process(EventHeader event) { // Add the pair to the pair list. pairList.add(pair); } + } // Iterate over each pair and calculate the pair cut values. for (Cluster[] pair : pairList) { @@ -296,8 +321,9 @@ public void process(EventHeader event) { int idx0 = pair[0].getCalorimeterHits().get(0).getIdentifierFieldValue("ix"); int idx1 = pair[1].getCalorimeterHits().get(0).getIdentifierFieldValue("ix"); - if (Math.abs(idx0) > 2 && Math.abs(idx1) > 2) + if (Math.abs(idx0) > 2 && Math.abs(idx1) > 2) { pairMassOppositeHalfFid.fill(getClusterPairMass(pair)); + } } // Create a list to store cluster pairs. @@ -305,7 +331,7 @@ public void process(EventHeader event) { // Form pairs from all possible combinations of clusters // from the top and bottom lists. - for (Cluster topCluster : topList) + for (Cluster topCluster : topList) { for (Cluster topCluster2 : topList) { // Make a cluster pair array. Cluster[] pair = new Cluster[2]; @@ -322,8 +348,9 @@ public void process(EventHeader event) { // Add the pair to the pair list. pairListSameHalf.add(pair); } + } - for (Cluster cluster : bottomList) + for (Cluster cluster : bottomList) { for (Cluster cluster2 : bottomList) { // Make a cluster pair array. Cluster[] pair = new Cluster[2]; @@ -340,20 +367,23 @@ public void process(EventHeader event) { // Add the pair to the pair list. pairListSameHalf.add(pair); } + } // Iterate over each pair and calculate the pair cut values. for (Cluster[] pair : pairListSameHalf) { // Get the energy slope value. pairMassSameHalf.fill(getClusterPairMass(pair)); int idx0 = pair[0].getCalorimeterHits().get(0).getIdentifierFieldValue("ix"); int idx1 = pair[1].getCalorimeterHits().get(0).getIdentifierFieldValue("ix"); - if (Math.abs(idx0) > 2 && Math.abs(idx1) > 2) + if (Math.abs(idx0) > 2 && Math.abs(idx1) > 2) { pairMassSameHalfFid.fill(getClusterPairMass(pair)); + } } } // If the event does not contain clusters, update the "Event // Clusters" plot accordingly. - else + else { clusterCountPlot.fill(0); + } } /** @@ -418,9 +448,10 @@ public double getClusterPairMass(Cluster[] pair) { double psum = Math.sqrt(pxsum * pxsum + pysum * pysum + pzsum * pzsum); double evtmass = esum * esum - psum * psum; - if (evtmass > 0) + if (evtmass > 0) { return Math.sqrt(evtmass); - else + } else { return -99; + } } } diff --git a/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalDaqPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalDaqPlots.java index 7680098aef..e757339c8f 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalDaqPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalDaqPlots.java @@ -4,6 +4,7 @@ import hep.aida.IPlotter; import hep.aida.IPlotterFactory; import hep.aida.IPlotterStyle; +import hep.aida.ITree; import java.util.ArrayList; import java.util.Collections; @@ -18,9 +19,12 @@ import org.lcsim.util.aida.AIDA; /** - * The driver EcalDaqPlots implements the histogram shown to the user in the fourth tab of the - * Monitoring Application, when using the Ecal monitoring lcsim file. It contains only a sub-tab, showing - * the number of hits recorded by the different FADC channels. It is a very preliminary driver to monitor + * The driver EcalDaqPlots implements the histogram shown to the + * user in the fourth tab of the + * Monitoring Application, when using the Ecal monitoring lcsim file. It + * contains only a sub-tab, showing + * the number of hits recorded by the different FADC channels. It is a very + * preliminary driver to monitor * the DAQ status. These plots are updated continuously. */ public class EcalDaqPlots extends Driver { @@ -29,6 +33,7 @@ public class EcalDaqPlots extends Driver { private String inputCollection = "EcalCalHits"; private IPlotter plotter; private AIDA aida; + private static ITree tree = AIDA.defaultInstance().tree(); private List plots; @@ -86,14 +91,17 @@ public void detectorChanged(Detector detector) { int crate = channel.getCrate(); if (y > 0) { - if (!slotsT.contains(slot)) + if (!slotsT.contains(slot)) { slotsT.add(slot); + } } else if (y < 0) { - if (!slotsB.contains(slot)) + if (!slotsB.contains(slot)) { slotsB.add(slot); + } } - if (!crates.contains(crate)) + if (!crates.contains(crate)) { crates.add(crate); + } } /* Order the slots in increasing order */ Collections.sort(slotsB); @@ -105,9 +113,22 @@ public void detectorChanged(Detector detector) { * System.out.println(""); System.out.println("BOTTOM: "); for * (int slot : slotsB){ System.out.print(slot+" "); } System.out.println(""); */ - aida = AIDA.defaultInstance(); - aida.tree().cd("/"); + tree.cd("/"); + boolean dirExists = false; + String dirName = "/ECalDaq"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + plots = new ArrayList(); for (int j = 0; j < 14; j++) { // TOP slot @@ -133,15 +154,17 @@ public void detectorChanged(Detector detector) { id = i * 14 + j; plot_id = 0; if (i == 0) { // first-crate - if (j % 2 == 0) + if (j % 2 == 0) { plot_id = j * 2; - else + } else { plot_id = (j - 1) * 2 + 1; + } } else if (i == 1) { // second-crate - if (j % 2 == 0) + if (j % 2 == 0) { plot_id = j * 2 + 2; - else + } else { plot_id = (j - 1) * 2 + 3; + } } // System.out.println("Plot in region " + plot_id + " the plot " + plots.get(id).title() + "(index: " + // id + ")"); @@ -161,7 +184,6 @@ public void process(EventHeader event) { // daq.crate = 1; // daq.slot = 2; // daq.channel = 3; - // Find the matching channel. EcalChannel channel = channels.findGeometric(hit.getCellID()); int row = hit.getIdentifierFieldValue("iy"); @@ -173,7 +195,6 @@ public void process(EventHeader event) { // System.out.println("found channel at " + column + " " + row + // " corresponding to DAQ crate/slot/channel " + crateN + " "+slotN+" "+channelN); - // Top CRATE if (row > 0) { int index = slotsT.indexOf(slotN); diff --git a/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalHitPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalHitPlots.java index 6f11bd837d..ba173f9311 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalHitPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalHitPlots.java @@ -18,19 +18,25 @@ import org.lcsim.util.aida.AIDA; /** - * The driver EcalHitPlots implements the histogram shown to the user - * in the second tab of the Monitoring Application, when using the Ecal monitoring lcsim file. + * The driver EcalHitPlots implements the histogram shown to the + * user + * in the second tab of the Monitoring Application, when using the Ecal + * monitoring lcsim file. * These histograms shows single-channels distributions: - * - First sub-tab shows the hits distribution* (Histogram2D), the occupancy* (Histogram2D), the number of hits per + * - First sub-tab shows the hits distribution* (Histogram2D), the occupancy* + * (Histogram2D), the number of hits per * event (Histogram1D), * the time distribution of the hits (Histogram1D) * The first two histograms are defined in EcalMonitoringPlots. - * - Second sub-tab shows the energy distribution of the hits (Histogram1D), and the maximum energy in each event + * - Second sub-tab shows the energy distribution of the hits (Histogram1D), and + * the maximum energy in each event * (Histogram1D) - * - Third sub-tab shows the time distribution of the first hit per event, for the Ecal top (Histogram1D), for the Ecal + * - Third sub-tab shows the time distribution of the first hit per event, for + * the Ecal top (Histogram1D), for the Ecal * bottom (Histogram1D), for both for the Ecal top (Histogram1D). - * - * Histograms are updated continously, expect those marked with *, that are updated regularly depending on the event + * + * Histograms are updated continously, expect those marked with *, that are + * updated regularly depending on the event * refresh rate configured in the EcalMonitoringPlots driver */ public class EcalHitPlots extends Driver { @@ -75,7 +81,8 @@ public void setLogScale(boolean logScale) { protected void detectorChanged(Detector detector) { // System.out.println("Detector changed called: "+ detector.getClass().getName()); - aida.tree().cd("/"); + //aida.tree().mkdir("/EcalHits"); + //aida.tree().cd("/EcalHits"); plotterFactory = aida.analysisFactory().createPlotterFactory("Ecal Hit Plots"); // Setup plots. @@ -128,8 +135,9 @@ protected void detectorChanged(Detector detector) { if (logScale) { pstyle.zAxisStyle().setParameter("scale", "log"); - } else + } else { pstyle.zAxisStyle().setParameter("scale", "lin"); + } // plotter.region(0).plot(hitNumberPlot,pstyle); // Setup the plotter. @@ -139,8 +147,9 @@ protected void detectorChanged(Detector detector) { if (logScale) { pstyle.yAxisStyle().setParameter("scale", "log"); - } else + } else { pstyle.yAxisStyle().setParameter("scale", "lin"); + } // Create the plotter regions. plotter2.createRegions(1, 2); plotter2.region(0).plot(hitEnergyPlot, pstyle); @@ -152,8 +161,9 @@ protected void detectorChanged(Detector detector) { if (logScale) { pstyle.yAxisStyle().setParameter("scale", "log"); - } else + } else { pstyle.yAxisStyle().setParameter("scale", "lin"); + } plotter3.region(0).plot(topTimePlot, pstyle); plotter3.region(1).plot(botTimePlot, pstyle); @@ -165,8 +175,9 @@ protected void detectorChanged(Detector detector) { pstyle.yAxisStyle().setParameter("scale", "lin"); if (logScale) { pstyle.zAxisStyle().setParameter("scale", "log"); - } else + } else { pstyle.zAxisStyle().setParameter("scale", "lin"); + } plotter3.region(6).plot(topTimePlot2D, pstyle); plotter3.region(7).plot(botTimePlot2D, pstyle); @@ -266,7 +277,7 @@ public void setHide(boolean hide) { /** * Initializes the default style for plots. - * + * * @return Returns an IPlotterStyle object that * represents the default style for plots. */ diff --git a/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalMonitoringPlots.java b/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalMonitoringPlots.java index 0d63d99734..5ea2a10a66 100644 --- a/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalMonitoringPlots.java +++ b/online-monitoring/src/main/java/org/hps/monitoring/ecal/plots/EcalMonitoringPlots.java @@ -3,6 +3,7 @@ import hep.aida.IHistogram2D; import hep.aida.IPlotter; import hep.aida.IPlotterStyle; +import hep.aida.ITree; import java.util.List; @@ -14,16 +15,21 @@ import org.lcsim.util.aida.AIDA; /** - * The driver EcalMonitoringPlots implements the histogram shown to the user in the - * first tab of the Monitoring Application, when using the Ecal monitoring lcsim file. It contains - * only a sub-tab, with 3 histograms. - Hit counts by channel (Histogram2D), Occupancy by channel - * (Histogram2D), Cluster counts by channel (Histogram2D) Each cluster is associated with the seed + * The driver EcalMonitoringPlots implements the histogram shown to + * the user in the + * first tab of the Monitoring Application, when using the Ecal monitoring lcsim + * file. It contains + * only a sub-tab, with 3 histograms. - Hit counts by channel (Histogram2D), + * Occupancy by channel + * (Histogram2D), Cluster counts by channel (Histogram2D) Each cluster is + * associated with the seed * crystal. - * + * * These plots are updated regularly, according to the event refresh rate. */ public class EcalMonitoringPlots extends Driver { + private static ITree tree = null; String inputCollection = "EcalReadoutHits"; String clusterCollection = "EcalClusters"; AIDA aida = AIDA.defaultInstance(); @@ -57,8 +63,9 @@ public void setClusterCollection(String clusterCollection) { /** * Set the refresh rate for histograms in this driver - * - * @param eventRefreshRate the refresh rate, defined as number of events to accumulate before + * + * @param eventRefreshRate the refresh rate, defined as number of events to + * accumulate before * refreshing the plot */ public void setEventRefreshRate(int eventRefreshRate) { @@ -66,12 +73,29 @@ public void setEventRefreshRate(int eventRefreshRate) { } protected void detectorChanged(Detector detector) { + + tree = AIDA.defaultInstance().tree(); + tree.cd("/"); + boolean dirExists = false; + String dirName = "/EcalMon"; + for (String st : tree.listObjectNames()) { + System.out.println(st); + if (st.contains(dirName)) { + dirExists = true; + } + } + tree.setOverwrite(true); + if (!dirExists) { + tree.mkdir(dirName); + } + tree.cd(dirName); + // System.out.println("EcalMonitoringPlots:: detector changed was called"); // Setup the plotter. plotter = aida.analysisFactory().createPlotterFactory("Ecal Monitoring Plots") .create("HPS ECal Monitoring Plots"); - // Setup plots. - aida.tree().cd("/"); + // Setup plots. + String hitCountDrawPlotTitle; hitCountDrawPlotTitle = detector.getDetectorName() + " : " + inputCollection + " : Hit Rate KHz"; @@ -207,12 +231,14 @@ void redraw() { double mean = occupancyFill[id] / NoccupancyFill; occupancyFill[id] = 0; - if ((row != 0) && (column != 0) && (!EcalMonitoringUtilities.isInHole(row, column))) + if ((row != 0) && (column != 0) && (!EcalMonitoringUtilities.isInHole(row, column))) { occupancyDrawPlot.fill(column, row, mean); + } } plotter.region(2).clear(); - if (occupancyDrawPlot.sumAllBinHeights() > 0) + if (occupancyDrawPlot.sumAllBinHeights() > 0) { plotter.region(2).plot(occupancyDrawPlot); + } // plotter.region(2).refresh(); } diff --git a/online-monitoring/src/main/resources/monitoringButtonGraphics/icons8-multicast-64.png b/online-monitoring/src/main/resources/monitoringButtonGraphics/icons8-multicast-64.png new file mode 100644 index 0000000000..fc322f7a79 Binary files /dev/null and b/online-monitoring/src/main/resources/monitoringButtonGraphics/icons8-multicast-64.png differ diff --git a/online-monitoring/src/main/resources/org/hps/monitoring/config/default_config.prop b/online-monitoring/src/main/resources/org/hps/monitoring/config/default_config.prop index 194fe243cd..db1b254404 100644 --- a/online-monitoring/src/main/resources/org/hps/monitoring/config/default_config.prop +++ b/online-monitoring/src/main/resources/org/hps/monitoring/config/default_config.prop @@ -14,7 +14,7 @@ MaxEvents=-1 #SteeringFile= SteeringResource=org/hps/steering/monitoring/DummyMonitoring.lcsim SteeringType=RESOURCE - +PlotsDir=. # event source DataSourceType=ET_SERVER #DataSourcePath= diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring/KFTrackingAndReconMonitor.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring/KFTrackingAndReconMonitor.lcsim new file mode 100644 index 0000000000..3c5d57c21a --- /dev/null +++ b/steering-files/src/main/resources/org/hps/steering/monitoring/KFTrackingAndReconMonitor.lcsim @@ -0,0 +1,166 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CONFIG + + + + + + + + + WARNING + EcalClusters + + + EcalClusters + EcalClustersCorr + + + + + SVTRawTrackerHits + + + + Pileup + false + true + false + false + true + true + false + false + + + + 8.0 + false + 200 + false + + + + false + 40.0 + 400.0 + 20.0 + false + + + + + + 0.05 + false + + + + EcalClustersCorr + KalmanFullTracks + UnconstrainedV0Candidates_KF + UnconstrainedV0Vertices_KF + BeamspotConstrainedV0Candidates_KF + BeamspotConstrainedV0Vertices_KF + TargetConstrainedV0Candidates_KF + TargetConstrainedV0Vertices_KF + FinalStateParticles_KF + true + false + false + 0.180 + 0.05 + 0.04 + 0.020 + -7.5 + 7.0 + 7.0 + 0.0 + 40.0 + 40 + 40 + false + true + false + false + false + + + + + KalmanFullTracks + + + + UnconstrainedV0Candidates_KF + BeamspotConstrainedV0Candidates_KF + TargetConstrainedV0Candidates_KF + FinalStateParticles_KF + + + FinalStateParticles_KF + + + KalmanFullTracks + + + + + diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring/LooseTrackingAndReconMonitoring.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring/LooseTrackingAndReconMonitoring.lcsim index a7bc473b30..ac22afa78a 100644 --- a/steering-files/src/main/resources/org/hps/steering/monitoring/LooseTrackingAndReconMonitoring.lcsim +++ b/steering-files/src/main/resources/org/hps/steering/monitoring/LooseTrackingAndReconMonitoring.lcsim @@ -46,9 +46,9 @@ - + - + @@ -74,18 +74,14 @@ 8.0 false - - 9000.0 - - + + false 40.0 - 800.0 + 400.0 20.0 - 7.0 false - - + Tracks_s567_c3_e4 @@ -190,26 +186,30 @@ true - EcalClustersCorr - GBLTracks - + GBLTracks true - true - -0.224 - 0.125 - -0.08 - 0.030 - -4.3 - 7.0 - 7.0 + false + false + 0.180 + 0.05 + 0.04 + 0.020 + -7.5 + 10.0 + 7.0 0.0 - 10.0 - 1000 - 55 + 40.0 + 40 + 40 + false + true + true false + false + GBLTracks diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring/OpeningAngleAxialTrackingMonitoring.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring/OpeningAngleAxialTrackingMonitoring.lcsim index 8dafdb1d4f..1c577c8770 100644 --- a/steering-files/src/main/resources/org/hps/steering/monitoring/OpeningAngleAxialTrackingMonitoring.lcsim +++ b/steering-files/src/main/resources/org/hps/steering/monitoring/OpeningAngleAxialTrackingMonitoring.lcsim @@ -40,8 +40,7 @@ false 40.0 400.0 - 40.0 - 0.0 + 40.0 true diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring/OpeningAngleTrackingMonitoring.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring/OpeningAngleTrackingMonitoring.lcsim index 5f3bb0b879..ceb22cf4e4 100644 --- a/steering-files/src/main/resources/org/hps/steering/monitoring/OpeningAngleTrackingMonitoring.lcsim +++ b/steering-files/src/main/resources/org/hps/steering/monitoring/OpeningAngleTrackingMonitoring.lcsim @@ -42,7 +42,6 @@ 40.0 400.0 40.0 - 0.0 false diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring/SvtOnlineMonitoring.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring/SvtOnlineMonitoring.lcsim index 106bf1d25c..985e2ab93b 100644 --- a/steering-files/src/main/resources/org/hps/steering/monitoring/SvtOnlineMonitoring.lcsim +++ b/steering-files/src/main/resources/org/hps/steering/monitoring/SvtOnlineMonitoring.lcsim @@ -6,7 +6,8 @@ --> - + + @@ -23,6 +24,8 @@ + + diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring2021/BasicMonitoringForShifters2021.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring2021/BasicMonitoringForShifters2021.lcsim new file mode 100644 index 0000000000..9acc8234a2 --- /dev/null +++ b/steering-files/src/main/resources/org/hps/steering/monitoring2021/BasicMonitoringForShifters2021.lcsim @@ -0,0 +1,153 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CONFIG + + + + + + + + + WARNING + EcalClusters + + + EcalClusters + EcalClustersCorr + + + + + SVTRawTrackerHits + + + + Pileup + false + true + false + false + true + true + false + false + + + + 8.0 + false + 200 + false + + + + false + 40.0 + 400.0 + 20.0 + false + + + + + + 0.05 + false + + + + EcalClustersCorr + KalmanFullTracks + UnconstrainedV0Candidates_KF + UnconstrainedV0Vertices_KF + BeamspotConstrainedV0Candidates_KF + BeamspotConstrainedV0Vertices_KF + TargetConstrainedV0Candidates_KF + TargetConstrainedV0Vertices_KF + FinalStateParticles_KF + true + false + false + 0.180 + 0.05 + 0.04 + 0.020 + -7.5 + 7.0 + 7.0 + 0.0 + 40.0 + 40 + 40 + false + true + false + false + false + + + + + + 1000 + true + 3 + 3 + 50000 + + + false + + + + + + + onlinemon_plots.root + + + diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring2021/KFTrkAndRecoOnMon2021.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring2021/KFTrkAndRecoOnMon2021.lcsim new file mode 100644 index 0000000000..64ff41e1a8 --- /dev/null +++ b/steering-files/src/main/resources/org/hps/steering/monitoring2021/KFTrkAndRecoOnMon2021.lcsim @@ -0,0 +1,169 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + CONFIG + + + + + + + + + WARNING + EcalClusters + + + EcalClusters + EcalClustersCorr + + + + + SVTRawTrackerHits + + + + Pileup + false + true + false + false + true + true + false + false + + + + 8.0 + false + 200 + false + + + + false + 40.0 + 400.0 + 20.0 + false + + + + + + 0.05 + 10 + false + + + + EcalClustersCorr + KalmanFullTracks + UnconstrainedV0Candidates_KF + UnconstrainedV0Vertices_KF + BeamspotConstrainedV0Candidates_KF + BeamspotConstrainedV0Vertices_KF + TargetConstrainedV0Candidates_KF + TargetConstrainedV0Vertices_KF + FinalStateParticles_KF + true + false + false + 0.180 + 0.05 + 0.04 + 0.020 + -7.5 + 7.0 + 7.0 + 0.0 + 40.0 + 40 + 40 + false + true + false + false + false + + + + + KalmanFullTracks + + + + + UnconstrainedV0Candidates_KF + BeamspotConstrainedV0Candidates_KF + TargetConstrainedV0Candidates_KF + FinalStateParticles_KF + + + FinalStateParticles_KF + + + KalmanFullTracks + + + + + diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring2021/RandomsSvtCheckout2021.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring2021/RandomsSvtCheckout2021.lcsim new file mode 100644 index 0000000000..c3d1473350 --- /dev/null +++ b/steering-files/src/main/resources/org/hps/steering/monitoring2021/RandomsSvtCheckout2021.lcsim @@ -0,0 +1,100 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + svt_burstmode_noise_good + + + + + SVTRawTrackerHits + + + 1000 + false + true + 3 + 3 + 50000 + false + false + false + + + true + true + false + + + + + + + Pileup + false + false + + true + true + + false + + true + false + false + + + 8.0 + false + + + false + false + + + false + true + false + false + + + + + + + svtmon_plots2.root + + + diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring2021/SvtCheckout2021.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring2021/SvtCheckout2021.lcsim new file mode 100644 index 0000000000..f8b9bd23b2 --- /dev/null +++ b/steering-files/src/main/resources/org/hps/steering/monitoring2021/SvtCheckout2021.lcsim @@ -0,0 +1,96 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + svt_burstmode_noise_good + + + + + SVTRawTrackerHits + + + 1000 + false + true + 3 + 3 + 50000 + false + false + + + true + true + + + + + + + Pileup + false + false + + true + true + + false + + true + false + false + + + 8.0 + false + + + false + + + false + true + false + + + + + + + svtmon_plots2.root + + + diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring2021/SvtOnMon2021.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring2021/SvtOnMon2021.lcsim new file mode 100644 index 0000000000..9e3ca13263 --- /dev/null +++ b/steering-files/src/main/resources/org/hps/steering/monitoring2021/SvtOnMon2021.lcsim @@ -0,0 +1,91 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + svt_burstmode_noise_good + + + + + SVTRawTrackerHits + + + 1000 + false + true + 3 + 3 + 50000 + false + false + + + true + true + + + + + + + Pileup + false + false + true + true + 55.0 + false + true + false + false + + + 8.0 + false + + + + false + true + false + + + + 1000 + 50000 + false + + + + + svtmon_plots2.root + + + diff --git a/steering-files/src/main/resources/org/hps/steering/monitoring2021/TrkAndRecoOnMon2021.lcsim b/steering-files/src/main/resources/org/hps/steering/monitoring2021/TrkAndRecoOnMon2021.lcsim new file mode 100644 index 0000000000..742ad674e8 --- /dev/null +++ b/steering-files/src/main/resources/org/hps/steering/monitoring2021/TrkAndRecoOnMon2021.lcsim @@ -0,0 +1,231 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Pileup + false + true + false + false + true + true + false + false + + + + 8.0 + false + + + + false + 40.0 + 400.0 + 20.0 + false + + + + Tracks_s567_c3_e4 + HPS_s567_c3_e4_2019.xml + false + 9000.0 + 250 + + + + Tracks_s235_c6_e147 + HPS_s235_c6_e147.xml + false + 9000.0 + 250 + + + + Tracks_s356_c7_e124 + HPS_s356_c7_e124.xml + false + 9000.0 + 250 + + + + Tracks_s123_c5_e46_4hit + HPS_s123_c5_e46_4hit.xml + false + 9000.0 + 250 + + + Tracks_s123_c4_e56_4hit + HPS_s123_c4_e56_4hit.xml + false + 9000.0 + 250 + + + + Tracks_s345_c1_e16_4hit + HPS_s345_c2_e16_4hit.xml + false + 9000.0 + 250 + + + Tracks_s456_c3_e21_4hit + HPS_s456_c3_e21_4hit.xml + false + 40.0 + 250 + + + + Tracks_s234_c6_e157_4hit + HPS_s234_c6_e157_4hit.xml + false + 40.0 + 250 + + + + Tracks_s134_c6_e25_4hit + HPS_s134_c6_e25_4hit.xml + false + 40.0 + 250 + + + + + + + + + CONFIG + + + + + + + WARNING + EcalClusters + + + + EcalClusters + EcalClustersCorr + + + + 60. + 84. + true + + + + EcalClustersCorr + GBLTracks + true + false + false + 0.180 + 0.05 + 0.04 + 0.020 + -7.5 + 10.0 + 7.0 + 0.0 + 40.0 + 40 + 40 + false + true + true + false + false + + + + + GBLTracks + + + + + + + + + MatchedTracks + + + false + + + + diff --git a/tracking/src/main/java/org/hps/minuit/SimplexBuilder.java b/tracking/src/main/java/org/hps/minuit/SimplexBuilder.java index f379004116..8de90809e4 100644 --- a/tracking/src/main/java/org/hps/minuit/SimplexBuilder.java +++ b/tracking/src/main/java/org/hps/minuit/SimplexBuilder.java @@ -151,11 +151,11 @@ public FunctionMinimum minimum(MnFcn mfcn, GradientCalculator gc, MinimumSeed se states.add(st); if (mfcn.numOfCalls() > maxfcn) { - logger.info("Simplex did not converge, #fcn calls exhausted."); +// logger.info("Simplex did not converge, #fcn calls exhausted."); return new FunctionMinimum(seed, states, mfcn.errorDef(), new FunctionMinimum.MnReachedCallLimit()); } if (simplex.edm() > minedm) { - logger.info("Simplex did not converge, edm > minedm."); + // logger.info("Simplex did not converge, edm > minedm."); return new FunctionMinimum(seed, states, mfcn.errorDef(), new FunctionMinimum.MnAboveMaxEdm()); } diff --git a/tracking/src/main/java/org/hps/recon/tracking/kalman/KalmanKinkFit.java b/tracking/src/main/java/org/hps/recon/tracking/kalman/KalmanKinkFit.java index 2daf42a8ad..e5c3aea834 100644 --- a/tracking/src/main/java/org/hps/recon/tracking/kalman/KalmanKinkFit.java +++ b/tracking/src/main/java/org/hps/recon/tracking/kalman/KalmanKinkFit.java @@ -32,7 +32,7 @@ public class KalmanKinkFit { private double innerStereo, outerStereo; private int innerNhits, outerNhits; - KalmanKinkFit(EventHeader event, KalmanInterface KI, Track KalmanFullTrack) { + public KalmanKinkFit(EventHeader event, KalmanInterface KI, Track KalmanFullTrack) { this.event = event; this.KI = KI; this.KalmanFullTrack = KalmanFullTrack; diff --git a/tracking/src/main/java/org/hps/recon/tracking/kalman/KalmanParams.java b/tracking/src/main/java/org/hps/recon/tracking/kalman/KalmanParams.java index 3fb85c8681..eb0bb209c1 100644 --- a/tracking/src/main/java/org/hps/recon/tracking/kalman/KalmanParams.java +++ b/tracking/src/main/java/org/hps/recon/tracking/kalman/KalmanParams.java @@ -96,7 +96,7 @@ public void print() { System.out.format("\n"); } - KalmanParams() { + public KalmanParams() { logger = Logger.getLogger(KalmanParams.class.getName()); tb = new String[2]; diff --git a/tracking/src/main/java/org/hps/recon/tracking/kalman/Vec.java b/tracking/src/main/java/org/hps/recon/tracking/kalman/Vec.java index ee7ab54a1a..51ced5716e 100644 --- a/tracking/src/main/java/org/hps/recon/tracking/kalman/Vec.java +++ b/tracking/src/main/java/org/hps/recon/tracking/kalman/Vec.java @@ -3,11 +3,11 @@ /** * Simple N-vector for the Kalman filter */ -class Vec { +public class Vec { double[] v; int N; - Vec(int N, double[] vin) { + public Vec(int N, double[] vin) { v = new double[N]; for (int i = 0; i < N; i++) { v[i] = vin[i]; diff --git a/tracking/src/main/java/org/hps/recon/tracking/straighttracks/StraightTracker.java b/tracking/src/main/java/org/hps/recon/tracking/straighttracks/StraightTracker.java index c3099fdac5..bdc254a69f 100644 --- a/tracking/src/main/java/org/hps/recon/tracking/straighttracks/StraightTracker.java +++ b/tracking/src/main/java/org/hps/recon/tracking/straighttracks/StraightTracker.java @@ -91,7 +91,7 @@ private void initialize(List strategylist, boolean useHPSMaterialM * @param debug switch */ public void setDebug(boolean debug) { - _debug = true; + _debug = debug; _materialmanager.setDebug(debug); _fitter.setDebug(debug); _finder.setDebug(debug);