java/trunk/ecal-readout-sim/src/main/java/org/hps/readout/ecal
--- java/trunk/ecal-readout-sim/src/main/java/org/hps/readout/ecal/FADCPrimaryTriggerDriver.java 2014-09-09 01:51:13 UTC (rev 972)
+++ java/trunk/ecal-readout-sim/src/main/java/org/hps/readout/ecal/FADCPrimaryTriggerDriver.java 2014-09-09 02:35:51 UTC (rev 973)
@@ -1,5 +1,8 @@
package org.hps.readout.ecal;
+import hep.aida.IHistogram1D;
+import hep.aida.IHistogram2D;
+
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
@@ -8,6 +11,7 @@
import org.hps.recon.ecal.ECalUtils;
import org.hps.recon.ecal.HPSEcalCluster;
import org.lcsim.event.EventHeader;
+import org.lcsim.util.aida.AIDA;
/**
* Class <code>FADCPrimaryTriggerDriver</code> reads reconstructed
@@ -59,6 +63,37 @@
private int pairEnergySlopeCount = 0; // Track the pairs which pass the energy slope cut.
private int pairCoplanarityCount = 0; // Track the pairs which pass the coplanarity cut.
+ // ==================================================================
+ // ==== Trigger Distribution Plots ==================================
+ // ==================================================================
+ private AIDA aida = AIDA.defaultInstance();
+ IHistogram1D clusterSeedEnergy = aida.histogram1D("Trigger Plots :: Cluster Seed Energy Distribution", 176, 0.0, 2.2);
+ IHistogram1D clusterSeedEnergy100 = aida.histogram1D("Trigger Plots :: Cluster Seed Energy Distribution (Over 100 MeV)", 176, 0.0, 2.2);
+ IHistogram1D clusterSeedEnergySingle = aida.histogram1D("Trigger Plots :: Cluster Seed Energy Distribution (Passed Single Cuts)", 176, 0.0, 2.2);
+ IHistogram1D clusterSeedEnergyAll = aida.histogram1D("Trigger Plots :: Cluster Seed Energy Distribution (Passed All Cuts)", 176, 0.0, 2.2);
+ IHistogram1D clusterHitCount = aida.histogram1D("Trigger Plots :: Cluster Hit Count Distribution", 9, 1, 10);
+ IHistogram1D clusterHitCount100 = aida.histogram1D("Trigger Plots :: Cluster Hit Count Distribution (Over 100 MeV)", 9, 1, 10);
+ IHistogram1D clusterHitCountSingle = aida.histogram1D("Trigger Plots :: Cluster Hit Count Distribution (Passed Single Cuts)", 9, 1, 10);
+ IHistogram1D clusterHitCountAll = aida.histogram1D("Trigger Plots :: Cluster Hit Count Distribution (Passed All Cuts)", 9, 1, 10);
+ IHistogram1D clusterTotalEnergy = aida.histogram1D("Trigger Plots :: Cluster Total Energy Distribution", 176, 0.0, 2.2);
+ IHistogram1D clusterTotalEnergy100 = aida.histogram1D("Trigger Plots :: Cluster Total Energy Distribution (Over 100 MeV)", 176, 0.0, 2.2);
+ IHistogram1D clusterTotalEnergySingle = aida.histogram1D("Trigger Plots :: Cluster Total Energy Distribution (Passed Single Cuts)", 176, 0.0, 2.2);
+ IHistogram1D clusterTotalEnergyAll = aida.histogram1D("Trigger Plots :: Cluster Total Energy Distribution (Passed All Cuts)", 176, 0.0, 2.2);
+
+ IHistogram1D pairEnergySum = aida.histogram1D("Trigger Plots :: Pair Energy Sum Distribution", 176, 0.0, 4.4);
+ IHistogram1D pairEnergySumAll = aida.histogram1D("Trigger Plots :: Pair Energy Sum Distribution (Passed All Cuts)", 176, 0.0, 4.4);
+ IHistogram1D pairEnergyDifference = aida.histogram1D("Trigger Plots :: Pair Energy Difference Distribution", 176, 0.0, 2.2);
+ IHistogram1D pairEnergyDifferenceAll = aida.histogram1D("Trigger Plots :: Pair Energy Difference Distribution (Passed All Cuts)", 176, 0.0, 2.2);
+ IHistogram1D pairCoplanarity = aida.histogram1D("Trigger Plots :: Pair Coplanarity Distribution", 360, 0.0, 180.0);
+ IHistogram1D pairCoplanarityAll = aida.histogram1D("Trigger Plots :: Pair Coplanarity Distribution (Passed All Cuts)", 360, 0.0, 180.0);
+ IHistogram1D pairEnergySlope = aida.histogram1D("Trigger Plots :: Pair Energy Slope Distribution", 400, 0.0, 4.0);
+ IHistogram1D pairEnergySlopeAll = aida.histogram1D("Trigger Plots :: Pair Energy Slope Distribution (Passed All Cuts)", 400, 0.0, 4.0);
+
+ IHistogram2D clusterDistribution = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution", 44, -22.0, 22.0, 10, -5, 5);
+ IHistogram2D clusterDistribution100 = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution (Over 100 MeV)", 44, -23, 23, 11, -5.5, 5.5);
+ IHistogram2D clusterDistributionSingle = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution (Passed Single Cuts)", 44, -23, 23, 11, -5.5, 5.5);
+ IHistogram2D clusterDistributionAll = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution (Passed All Cuts)", 44, -23, 23, 11, -5.5, 5.5);
+
/**
* Prints out the results of the trigger at the end of the run.
*/
@@ -107,6 +142,28 @@
// Increment the number of processed clusters.
allClusters++;
+ // Get the cluster plot values.
+ int hitCount = cluster.getCalorimeterHits().size();
+ double seedEnergy = cluster.getSeedHit().getCorrectedEnergy();
+ double clusterEnergy = cluster.getEnergy();
+ int ix = cluster.getSeedHit().getIdentifierFieldValue("ix");
+ int iy = cluster.getSeedHit().getIdentifierFieldValue("iy");
+ if(ix > 0) { ix = ix - 1; }
+
+ // Fill the general plots.
+ clusterSeedEnergy.fill(seedEnergy, 1);
+ clusterTotalEnergy.fill(clusterEnergy, 1);
+ clusterHitCount.fill(hitCount, 1);
+ clusterDistribution.fill(ix, iy, 1);
+
+ // Fill the "over 100 MeV" plots if applicable.
+ if(seedEnergy >= 0.100) {
+ clusterSeedEnergy100.fill(seedEnergy, 1);
+ clusterTotalEnergy100.fill(clusterEnergy, 1);
+ clusterHitCount100.fill(hitCount, 1);
+ clusterDistribution100.fill(ix, iy, 1);
+ }
+
// ==== Seed Hit Energy Cut ====================================
// =============================================================
// If the cluster fails the cut, skip to the next cluster.
@@ -131,6 +188,12 @@
// Otherwise, note that it passed the cut.
clusterTotalEnergyCount++;
+ // Fill the "passed single cuts" plots.
+ clusterSeedEnergySingle.fill(seedEnergy, 1);
+ clusterTotalEnergySingle.fill(clusterEnergy, 1);
+ clusterHitCountSingle.fill(hitCount, 1);
+ clusterDistributionSingle.fill(ix, iy, 1);
+
// A cluster that passes all of the single-cluster cuts
// can be used in cluster pairs.
goodClusterList.add(cluster);
@@ -486,8 +549,6 @@
double[] clusterAngle = new double[2];
for(int i = 0; i < 2; i++) {
double position[] = clusterPair[i].getSeedHit().getPosition();
- //clusterAngle[i] = Math.toDegrees(Math.atan2(position[1], position[0] - originX));
- //clusterAngle[i] = (clusterAngle[i] + 180.0) % 180.0;
clusterAngle[i] = (Math.toDegrees(Math.atan2(position[1], position[0] - originX)) + 180.0) % 180.0;
}
@@ -711,6 +772,18 @@
// Increment the number of processed cluster pairs.
allPairs++;
+ // Get the plot values for the pair cuts.
+ double energySum = getValueEnergySum(clusterPair);
+ double energyDifference = getValueEnergyDifference(clusterPair);
+ double energySlope = getValueEnergySlope(clusterPair);
+ double coplanarity = getValueCoplanarity(clusterPair);
+
+ // Fill the general plots.
+ pairEnergySum.fill(energySum, 1);
+ pairEnergyDifference.fill(energyDifference, 1);
+ pairEnergySlope.fill(energySlope, 1);
+ pairCoplanarity.fill(coplanarity, 1);
+
// ==== Pair Energy Sum Cut ====================================
// =============================================================
// If the cluster fails the cut, skip to the next pair.
@@ -744,6 +817,35 @@
// Otherwise, note that it passed the cut.
pairCoplanarityCount++;
+ // Get the cluster plot values.
+ int[] hitCount = new int[2];
+ double[] seedEnergy = new double[2];
+ double[] clusterEnergy = new double[2];
+ int[] ix = new int[2];
+ int[] iy = new int[2];
+ for(int i = 0; i < 2; i++) {
+ hitCount[i] = clusterPair[i].getCalorimeterHits().size();
+ seedEnergy[i] = clusterPair[i].getSeedHit().getCorrectedEnergy();
+ clusterEnergy[i] = clusterPair[i].getEnergy();
+ ix[i] = clusterPair[i].getSeedHit().getIdentifierFieldValue("ix");
+ iy[i] = clusterPair[i].getSeedHit().getIdentifierFieldValue("iy");
+ if(ix[i] > 0) { ix[i] = ix[i] - 1; }
+ }
+
+ // Fill the general plots.
+ for(int i = 0; i < 2; i++) {
+ clusterSeedEnergyAll.fill(seedEnergy[i], 1);
+ clusterTotalEnergyAll.fill(clusterEnergy[i], 1);
+ clusterHitCountAll.fill(hitCount[i], 1);
+ clusterDistributionAll.fill(ix[i], iy[i], 1);
+ }
+
+ // Fill the "passed all cuts" plots.
+ pairEnergySumAll.fill(energySum, 1);
+ pairEnergyDifferenceAll.fill(energyDifference, 1);
+ pairEnergySlopeAll.fill(energySlope, 1);
+ pairCoplanarityAll.fill(coplanarity, 1);
+
// Clusters that pass all of the pair cuts produce a trigger.
return true;
}
java/trunk/ecal-readout-sim/src/main/java/org/hps/readout/ecal
--- java/trunk/ecal-readout-sim/src/main/java/org/hps/readout/ecal/NeutralPionTriggerDriver.java 2014-09-09 01:51:13 UTC (rev 972)
+++ java/trunk/ecal-readout-sim/src/main/java/org/hps/readout/ecal/NeutralPionTriggerDriver.java 2014-09-09 02:35:51 UTC (rev 973)
@@ -45,7 +45,7 @@
* it will output more details with every event to help with diagnostics.
*
* @author Kyle McCarty
- * @author Michel Garcon
+ * @author Michel Garรงon
*/
public class NeutralPionTriggerDriver extends TriggerDriver {
@@ -53,6 +53,29 @@
// ==== Trigger Algorithms ==========================================
// ==================================================================
+ @Override
+ public void endOfData() {
+ // Print out the results of the trigger cuts.
+ System.out.printf("Trigger Processing Results%n");
+ System.out.printf("\tSingle-Cluster Cuts%n");
+ System.out.printf("\t\tTotal Clusters Processed :: %d%n", allClusters);
+ System.out.printf("\t\tPassed Seed Energy Cut :: %d%n", clusterSeedEnergyCount);
+ System.out.printf("\t\tPassed Hit Count Cut :: %d%n", clusterHitCountCount);
+ if(rejectEdgeCrystals) {
+ System.out.printf("\t\tPassed Edge Crystal Cut :: %d%n", clusterEdgeCount);
+ }
+ System.out.printf("%n");
+ System.out.printf("\tCluster Pair Cuts%n");
+ System.out.printf("\t\tTotal Pairs Processed :: %d%n", allPairs);
+ System.out.printf("\t\tPassed Energy Sum Cut :: %d%n", pairEnergySumCount);
+ System.out.printf("\t\tPassed Energy Invariant Mass :: %d%n", pairInvariantMassCount);
+ System.out.printf("%n");
+ System.out.printf("\tTrigger Count :: %d%n", triggers);
+
+ // Run the superclass method.
+ super.endOfData();
+ }
+
public void process(EventHeader event) {
// Generate a temporary list to store the good clusters
// in before they are added to the buffer.
@@ -74,6 +97,12 @@
// if they pass the minimum total cluster energy and seed
// energy thresholds.
for(HPSEcalCluster cluster : eventList) {
+ // Increment the clusters processed count.
+ allClusters++;
+
+ // Plot the seed energy / cluster energy histogram.
+ seedPercent.fill(cluster.getSeedHit().getCorrectedEnergy() / cluster.getEnergy(), 1);
+
// Get the cluster position indices.
int ix = cluster.getSeedHit().getIdentifierFieldValue("ix");
int iy = cluster.getSeedHit().getIdentifierFieldValue("iy");
@@ -93,7 +122,7 @@
// VERBOSE :: Output the single cluster trigger thresholds.
if(verbose) {
System.out.printf("\tCluster seed energy threshold :: [%f, %f]%n", clusterSeedEnergyThresholdLow, clusterSeedEnergyThresholdHigh);
- System.out.printf("\tCluster total energy threshold :: %f%n%n", clusterTotalEnergyThreshold);
+ System.out.printf("\tCluster total energy threshold :: %f%n%n", clusterTotalEnergyThresholdLow);
}
// Perform the single cluster cuts.
@@ -102,6 +131,17 @@
boolean hitCountCut = clusterHitCountCut(cluster);
boolean edgeCrystalCut = isEdgeCluster(cluster);
+ // Increment the single cut counts.
+ if(seedEnergyCut) {
+ clusterSeedEnergyCount++;
+ if(hitCountCut) {
+ clusterHitCountCount++;
+ if(rejectEdgeCrystals && edgeCrystalCut) {
+ clusterEdgeCount++;
+ }
+ }
+ }
+
// VERBOSE :: Note whether the cluster passed the single
// cluster cuts.
if(verbose) {
@@ -157,19 +197,6 @@
if(verbose) { System.out.println("No cluster collection is present for event.\n"); }
}
- /**
- // If the cluster buffer has fewer than the allowed number of
- // events stored, just add the temporary list to the buffer.
- if(clusterBuffer.size() < coincidenceWindow) { clusterBuffer.addLast(tempList); }
-
- // Otherwise, remove the first element of the list (the oldest
- // buffer) and append the new list.
- else {
- clusterBuffer.removeFirst();
- clusterBuffer.addLast(tempList);
- }
- **/
-
// Reset the highest energy pair to null.
clusterTriplet[0] = null;
clusterTriplet[1] = null;
@@ -245,9 +272,9 @@
aClusterSeedEnergy = aida.histogram1D("Trigger Plots :: Cluster Seed Energy Distribution (Passed All Cuts)", 176, 0.0, 2.2);
// Initialize the seed distribution diagnostic plots.
- clusterDistribution = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution", 176, -22.0, 22.0, 10, -5, 5);
- pClusterDistribution = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution (Passed Single Cuts)", 176, -23, 23, 11, -5.5, 5.5);
- aClusterDistribution = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution (Passed All Cuts)", 176, -23, 23, 11, -5.5, 5.5);
+ clusterDistribution = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution", 44, -22.0, 22.0, 10, -5, 5);
+ pClusterDistribution = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution (Passed Single Cuts)", 44, -23, 23, 11, -5.5, 5.5);
+ aClusterDistribution = aida.histogram2D("Trigger Plots :: Cluster Seed Distribution (Passed All Cuts)", 44, -23, 23, 11, -5.5, 5.5);
// Initialize the cluster pair energy sum diagnostic plots.
pairEnergySum = aida.histogram1D("Trigger Plots :: Pair Energy Sum Distribution", 176, 0.0, 2.2);
@@ -256,6 +283,9 @@
// Initialize the cluster pair hypothetical invariant mass diagnostic plots.
invariantMass = aida.histogram1D("Trigger Plots :: Invariant Mass Distribution", 1500, 0.0, 0.03);
pInvariantMass = aida.histogram1D("Trigger Plots :: Invariant Mass Distribution (Passed Pair Cuts)", 1500, 0.0, 0.03);
+
+ // Initialize the seed percentage of cluster energy.
+ seedPercent = aida.histogram1D("Analysis Plots :: Seed Percentage of Total Energy", 400, 0.0, 1.0);
}
protected boolean triggerDecision(EventHeader event) {
@@ -282,6 +312,9 @@
return false;
}
+ // Increment the number of pairs considered.
+ allPairs++;
+
// Get the cluster position indices.
int[] ix = { clusterPair[0].getSeedHit().getIdentifierFieldValue("ix"), clusterPair[1].getSeedHit().getIdentifierFieldValue("ix") };
int[] iy = { clusterPair[0].getSeedHit().getIdentifierFieldValue("iy"), clusterPair[1].getSeedHit().getIdentifierFieldValue("iy") };
@@ -313,6 +346,14 @@
boolean energySumCut = pairEnergySumCut(clusterPair);
boolean invariantMassCut = pairInvariantMassCut(clusterPair);
+ // Increment the pair cut counts.
+ if(energySumCut) {
+ pairEnergySumCount++;
+ if(invariantMassCut) {
+ pairInvariantMassCount++;
+ }
+ }
+
// VERBOSE :: Note the outcome of the trigger cuts.
if(verbose) {
System.out.printf("\tPassed energy sum cut :: %b%n", energySumCut);
@@ -338,6 +379,9 @@
// VERBOSE :: Note that the event has triggered.
if(verbose) { System.out.println("Event triggers!\n\n"); }
+ // Increment the number of triggers.
+ triggers++;
+
// Return the trigger.
return true;
}
@@ -411,7 +455,11 @@
* false</code> if it does not.
*/
private boolean clusterTotalEnergyCut(HPSEcalCluster cluster) {
- return cluster.getEnergy() >= clusterTotalEnergyThreshold;
+ // Get the cluster energy.
+ double clusterEnergy = cluster.getEnergy();
+
+ // Perform the cut.
+ return clusterEnergy >= clusterTotalEnergyThresholdLow && clusterEnergy <= clusterTotalEnergyThresholdHigh;
}
/**
@@ -666,14 +714,25 @@
* Sets the threshold for the total cluster energy of individual
* clusters under which the cluster will be rejected and not used
* for triggering.
- * @param clusterTotalEnergyThreshold - The cluster total energy
+ * @param clusterTotalEnergyThresholdLow - The cluster total energy
* lower bound.
*/
- public void setClusterTotalEnergyThreshold(double clusterTotalEnergyThreshold) {
- this.clusterTotalEnergyThreshold = clusterTotalEnergyThreshold;
+ public void setClusterTotalEnergyThresholdLow(double clusterTotalEnergyThresholdLow) {
+ this.clusterTotalEnergyThresholdLow = clusterTotalEnergyThresholdLow;
}
/**
+ * Sets the threshold for the total cluster energy of individual
+ * clusters above which the cluster will be rejected and not used
+ * for triggering.
+ * @param clusterTotalEnergyThresholdHigh - The cluster total energy
+ * upper bound.
+ */
+ public void setClusterTotalEnergyThresholdHigh(double clusterTotalEnergyThresholdHigh) {
+ this.clusterTotalEnergyThresholdHigh = clusterTotalEnergyThresholdHigh;
+ }
+
+ /**
* Sets the number of events that clusters will be retained and
* employed for triggering before they are cleared.
* @param coincidenceWindow - The number of events that clusters
@@ -684,6 +743,18 @@
}
/**
+ * Sets the invariant mass threshold to accept only cluster pairs
+ * with a reconstructed invariant mass within a certain number of
+ * standard deviations of the mean (corrected for sampling fraction).
+ * @param invariantMassSigma - The number of standard deviations
+ * within which a cluster pair invariant mass is accepted.
+ */
+ public void setInvariantMassSigma(int invariantMassSigma) {
+ this.invariantMassThresholdLow = 0.012499 - (invariantMassSigma * 0.0011095);
+ this.invariantMassThresholdHigh = 0.012499 + (invariantMassSigma * 0.0011095);
+ }
+
+ /**
* Sets the threshold for the calculated invariant mass of the
* generating particle (assuming that the clusters are produced
* by a positron/electron pair) above which the cluster pair will
@@ -711,7 +782,7 @@
* Sets the threshold for the sum of the energies of a cluster pair
* above which the pair will be rejected and not produce a trigger.
* @param pairEnergySumThresholdHigh - The cluster pair energy sum
- * lower bound.
+ * upper bound.
*/
public void setPairEnergySumThresholdHigh(double pairEnergySumThresholdHigh) {
this.pairEnergySumThresholdHigh = pairEnergySumThresholdHigh;
@@ -728,6 +799,18 @@
}
/**
+ * Sets whether clusters centered on an edge crystal should be
+ * used for triggering or not.
+ *
+ * @param rejectEdgeCrystals - <code>true</code> means that edge
+ * clusters will not be used and <code>false</code> means that they
+ * will be used.
+ */
+ public void setRejectEdgeCrystals(boolean rejectEdgeCrystals) {
+ this.rejectEdgeCrystals = rejectEdgeCrystals;
+ }
+
+ /**
* Sets the threshold for the sum of the energies of a cluster triplet
* under which the triplet will be rejected and not produce a trigger.
* @param tripletEnergySumThreshold - The cluster triplet energy sum
@@ -799,6 +882,7 @@
IHistogram1D pClusterTotalEnergy;
IHistogram1D pPairEnergySum;
IHistogram1D pInvariantMass;
+ IHistogram1D seedPercent;
// ==================================================================
// ==== Variables ===================================================
@@ -809,7 +893,7 @@
* <code>private AIDA <b>aida</b></code><br/><br/>
* Factory for generating histograms.
*/
- private AIDA aida = AIDA.defaultInstance();
+ private AIDA aida = AIDA.defaultInstance();
/**
* <b>clusterBuffer</b><br/><br/>
@@ -836,7 +920,7 @@
* cluster first in the array.
*/
private HPSEcalCluster[] clusterPair = new HPSEcalCluster[2];
-
+
/**
* <b>clusterHitCountThreshold</b><br/><br/>
* <code>private int <b>clusterHitCountThreshold</b></code><br/><br/>
@@ -862,14 +946,22 @@
private double clusterSeedEnergyThresholdHigh = 1.00;
/**
- * <b>clusterTotalEnergyThreshold</b><br/><br/>
+ * <b>clusterTotalEnergyThresholdLow</b><br/><br/>
* <code>private double <b>clusterTotalEnergyThreshold</b></code><br/><br/>
* Defines the threshold for the total cluster energy under which
* a cluster will be rejected.
*/
- private double clusterTotalEnergyThreshold = Double.MIN_VALUE;
+ private double clusterTotalEnergyThresholdLow = 0.0;
/**
+ * <b>clusterTotalEnergyThresholdHigh</b><br/><br/>
+ * <code>private double <b>clusterTotalEnergyThresholdHigh</b></code><br/><br/>
+ * Defines the threshold for the total cluster energy above which
+ * a cluster will be rejected.
+ */
+ private double clusterTotalEnergyThresholdHigh = Double.MAX_VALUE;
+
+ /**
* <b>clusterTriplet</b><br/><br/>
* <code>private HPSEcalCluster[] <b>clusterTriplet</b></code><br/><br/>
* Stores the three highest energy clusters located in the cluster
@@ -884,14 +976,14 @@
* The number of events for which clusters will be retained and
* used in the trigger before they are removed.
*/
- private int coincidenceWindow = 3;
-
+ private int coincidenceWindow = 3;
+
/**
* <b>D2</b><br/><br/>
* <code>private static final double <b>D2</b></code><br/><br/>
* The squared distance of the calorimeter from the target.
*/
- private static final double D2 = 1414 * 1414; // (1414^2 mm^2)
+ private static final double D2 = 1414 * 1414; // (1414^2 mm^2)
/**
* <b>invariantMassThresholdHigh</b><br/><br/>
@@ -977,4 +1069,13 @@
* invariant mass calculations.
*/
private Map<CalorimeterHit, Double[]> seedPosMap = new HashMap<CalorimeterHit, Double[]>();
+
+ private int triggers = 0; // Track the number of triggers.
+ private int allClusters = 0; // Track the number of clusters processed.
+ private int allPairs = 0; // Track the number of cluster pairs processed.
+ private int clusterSeedEnergyCount = 0; // Track the clusters which pass the seed energy cut.
+ private int clusterHitCountCount = 0; // Track the clusters which pass the hit count cut.
+ private int clusterEdgeCount = 0; // Track the clusters which pass the edge cut.
+ private int pairEnergySumCount = 0; // Track the pairs which pass the energy sum cut.
+ private int pairInvariantMassCount = 0; // Track the pairs which pass the invariant mass cut.
}