SlicDiagnostics/src/org/lcsim/slic/diagnostics
diff -u -r1.3 -r1.4
--- AbstractPlots.java 5 Jan 2006 03:23:04 -0000 1.3
+++ AbstractPlots.java 1 Feb 2006 01:35:08 -0000 1.4
@@ -1,6 +1,5 @@
package org.lcsim.slic.diagnostics;
-import hep.aida.IPlotter;
import org.lcsim.util.aida.AIDA;
import hep.aida.ITree;
import org.lcsim.event.EventHeader;
@@ -8,12 +7,12 @@
/**
* @author jeremym
- * @version $Id: AbstractPlots.java,v 1.3 2006/01/05 03:23:04 jeremy Exp $
+ * @version $Id: AbstractPlots.java,v 1.4 2006/02/01 01:35:08 jeremy Exp $
*/
abstract class AbstractPlots
{
protected static AIDA _aida = org.lcsim.util.aida.AIDA.defaultInstance();
- protected static ITree _tree = _aida.tree();
+ protected static ITree _tree = _aida.tree();
protected EventHeader _eventHeader;
SlicDiagnostics/src/org/lcsim/slic/diagnostics
diff -u -r1.19 -r1.20
--- CalorimeterHitPlots.java 27 Jan 2006 01:04:12 -0000 1.19
+++ CalorimeterHitPlots.java 1 Feb 2006 01:35:08 -0000 1.20
@@ -24,7 +24,7 @@
/**
* @author jeremym
- * @version $Id: CalorimeterHitPlots.java,v 1.19 2006/01/27 01:04:12 jeremy Exp $
+ * @version $Id: CalorimeterHitPlots.java,v 1.20 2006/02/01 01:35:08 jeremy Exp $
*/
class CalorimeterHitPlots extends AbstractPlots
{
@@ -37,7 +37,7 @@
ICloud1D _mcpMissing;
ICloud2D _mcpCluster;
ICloud1D _clusterHitCount;
- ICloud1D _clusterHitMaxE;
+ ICloud1D _clusterHitMaxE;
String _collName;
@@ -116,15 +116,15 @@
protected void definePlots()
{
cd();
- _mcpCountPerHit = _aida.cloud1D("MCParticles per Hit");
- _mcpPDG = _aida.cloud1D("MCParticle PDGID");
- _mcpSingleContribPDG = _aida.cloud1D("MCParticle Single Contribution PDGID");
- _hitCorrectedEnergy = _aida.cloud1D("Hit Corrected Energy");
- _hitRawVsCorrectedEnergy = _aida.cloud2D("Hit Raw vs Corrected Energy");
- _mcpMissing = _aida.cloud1D("MCParticle Contribution Missing");
- _mcpCluster = _aida.cloud2D("Particle Kinetic Energy vs CheatCluster Energy");
- _clusterHitCount = _aida.cloud1D("Hit Count in a Single Cluster");
- _clusterHitMaxE = _aida.cloud1D("Max Cell Energy in a Cluster Divided by Total Cluster Energy");
+ _mcpCountPerHit = _aida.cloud1D("MCParticles: # per Hit");
+ _mcpPDG = _aida.cloud1D("MCParticles: PDGID");
+ _mcpSingleContribPDG = _aida.cloud1D("MCParticles: Single Contribution PDGID");
+ _hitCorrectedEnergy = _aida.cloud1D("Hit: Corrected Energy");
+ _hitRawVsCorrectedEnergy = _aida.cloud2D("Hit: Raw vs Corrected Energy");
+ _mcpMissing = _aida.cloud1D("MCParticles: Contribution Missing");
+ _mcpCluster = _aida.cloud2D("Clusters: Particle Kinetic Energy vs CheatCluster Energy");
+ _clusterHitCount = _aida.cloud1D("Hit: Count in a Single Cluster");
+ _clusterHitMaxE = _aida.cloud1D("Clusters: Max Cell Energy in a Cluster Divided by Total Cluster Energy");
}
protected void fill(EventHeader event)
@@ -343,5 +343,5 @@
(double)segmentation.getValue("z")
);
}
- }
+ }
}
\ No newline at end of file
SlicDiagnostics/src/org/lcsim/slic/diagnostics
diff -u -r1.8 -r1.9
--- CalorimeterHitPlotsDriver.java 5 Jan 2006 03:23:04 -0000 1.8
+++ CalorimeterHitPlotsDriver.java 1 Feb 2006 01:35:08 -0000 1.9
@@ -1,15 +1,13 @@
package org.lcsim.slic.diagnostics;
-import hep.aida.ICloud2D;
import java.util.List;
import org.lcsim.event.EventHeader;
import org.lcsim.event.EventHeader.LCMetaData;
import org.lcsim.event.SimCalorimeterHit;
-import org.lcsim.util.aida.AIDA;
/**
* @author jeremym
- * @version $Id: CalorimeterHitPlotsDriver.java,v 1.8 2006/01/05 03:23:04 jeremy Exp $
+ * @version $Id: CalorimeterHitPlotsDriver.java,v 1.9 2006/02/01 01:35:08 jeremy Exp $
*/
public class CalorimeterHitPlotsDriver extends PlotsDriver
{
@@ -40,4 +38,6 @@
}
return (CalorimeterHitPlots)_plots.get(name);
}
+
+
}
\ No newline at end of file
SlicDiagnostics/src/org/lcsim/slic/diagnostics
diff -u -r1.18 -r1.19
--- GenericHitPlots.java 26 Jan 2006 20:17:20 -0000 1.18
+++ GenericHitPlots.java 1 Feb 2006 01:35:09 -0000 1.19
@@ -1,242 +1,493 @@
package org.lcsim.slic.diagnostics;
-import java.util.List;
-import java.util.Map;
-import java.util.HashMap;
-import hep.aida.IHistogram1D;
-import hep.aida.IHistogram2D;
import hep.aida.ICloud1D;
import hep.aida.ICloud2D;
+import hep.aida.IHistogram1D;
+import hep.aida.IHistogram2D;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
import org.lcsim.event.EventHeader;
import org.lcsim.event.EventHeader.LCMetaData;
-import org.lcsim.geometry.SubdetectorIDDecoder;
-import org.lcsim.util.aida.AIDA;
-import org.lcsim.geometry.Subdetector;
import org.lcsim.geometry.Layered;
+import org.lcsim.geometry.Subdetector;
+import org.lcsim.geometry.SubdetectorIDDecoder;
/**
* @author jeremym
- * @version $Id: GenericHitPlots.java,v 1.18 2006/01/26 20:17:20 jeremy Exp $
+ * @version $Id: GenericHitPlots.java,v 1.19 2006/02/01 01:35:09 jeremy Exp $
*/
class GenericHitPlots extends AbstractPlots
{
- /* plots */
- ICloud1D _energy;
- ICloud1D _energyEvent;
- IHistogram1D _time;
- ICloud2D _thetaPhi;
- ICloud2D _xy;
- ICloud2D _rz;
- ICloud2D _zx;
- ICloud2D _zy;
- IHistogram1D _layer;
- ICloud1D _hitCount;
- ICloud1D _hitAvgEnergy;
- IHistogram1D _layerEnergy;
- ICloud1D _layerHitCount;
- ICloud1D _hitMinEdep;
- ICloud1D _hitMaxEdep;
- ICloud2D _hitMinVsMaxEdep;
- ICloud2D _hitVsTotE;
- IHistogram2D _layerPercentTotE;
- IHistogram2D _layerPercentHits;
-// IHistogram1D layerAvgEventE;
-// IHistogram1D layerAvgEventHits;
-
- int _nlayers = 0;
- double _eventTotEnergy = 0;
-
- List<GenericHit> _hits;
- Map<Integer, LayerInfo> _layers = new HashMap<Integer, LayerInfo>();
-
- GenericHit.HitType _hitType = null;
-
- private static String getBaseDir(LCMetaData meta)
- {
- String dir = null;
-
- if ( meta.getType().getSimpleName().compareTo("SimCalorimeterHit") == 0 )
- {
- dir = "CalorimeterHits";
- }
- else
- {
- dir = "TrackerHits";
- }
-
- //System.out.println(meta.getName() + " = " + dir + " f/ " + meta.getType().getSimpleName());
-
- return dir;
- }
-
- public GenericHitPlots(String collName, LCMetaData meta)
- {
- super(getBaseDir(meta), meta);
-
- /* set number of layers */
- Subdetector det = ((SubdetectorIDDecoder)meta.getIDDecoder()).getSubdetector();
- _nlayers = ((Layered)det).getLayering().getLayerCount();
-
- /* make a LayerInfo for each layer */
- makeLayers();
-
- /* define the plots */
- definePlots();
- }
-
- private void makeLayers()
- {
- for ( int i=0; i<_nlayers; i++)
- {
- _layers.put(i, new LayerInfo(i));
- }
- }
-
- /* plots for GenericHits */
- protected void definePlots()
- {
- cd();
- _energy = _aida.cloud1D("Individual Hit Energy");
- _hitAvgEnergy = _aida.cloud1D("Hit Average Energy by Event");
- _time = _aida.histogram1D("Time", 100, 0, 50);
- _thetaPhi = _aida.cloud2D("Theta vs Phi");
- _xy = _aida.cloud2D("X vs Y");
- _zx = _aida.cloud2D("Z vs X");
- _zy = _aida.cloud2D("Z vs Y");
- _rz = _aida.cloud2D("R vs Z");
- _layer = _aida.histogram1D("Layer Number", _nlayers, 0, _nlayers);
- _layerEnergy = _aida.histogram1D("Layer Energy", _nlayers, 0, _nlayers);
- _energyEvent = _aida.cloud1D("Event Total Energy");
- _hitCount = _aida.cloud1D("Event Total Hit Count");
- _hitMinEdep = _aida.cloud1D("Hit Min Edep");
- _hitMaxEdep = _aida.cloud1D("Hit Max Edep");
- _hitMinVsMaxEdep = _aida.cloud2D("Hit Max vs Min Edep");
- _hitVsTotE = _aida.cloud2D("Total Energy vs Hit Count");
- _layerPercentTotE = _aida.histogram2D("Layer Percentage of Energy Total", _nlayers, 0, _nlayers, 100, 0, 1.0);
- _layerPercentHits = _aida.histogram2D("Layer Percentage of Hit Count", _nlayers, 0, _nlayers, 100, 0, 1.0);
-// layerAvgEventNHits = _aida.histogram2D(makePlotName("Average Event Hit Count"), _nlayers, 0, _nlayers);
- }
-
- /* GenericHitPlotsDriver sets hit list for these plots. */
- public void setGenericHitList(List<GenericHit> hits)
- {
- this._hits = hits;
- }
-
- protected void fill(EventHeader event)
- {
- super.fill(event);
- fill(this._hits);
- }
-
- private void fill(List<GenericHit> hits)
- {
- _eventTotEnergy = 0;
- int nhits = 0;
- double minEdep = 9999.0;
- double maxEdep = 0;
-
- if ( hits.size() != 0 )
- {
- for ( GenericHit hit : hits )
- {
- double[] position = hit.getPosition();
- double edep = hit.getEnergy();
-
- /* hit _energy */
- _energy.fill(edep);
-
- /* hit _time */
- _time.fill(hit.getTime() );
-
- /* hit theta vs. phi */
- _thetaPhi.fill(HitUtil.getTheta(position), HitUtil.getPhi(position) );
-
- /* hit X vs. Y */
- _xy.fill(hit.getX(), hit.getY() );
-
- /* Z vs. X */
- _zx.fill(hit.getZ(), hit.getX() );
-
- /* Z vs. Y */
- _zy.fill(hit.getZ(), hit.getY() );
-
- /* hit Z vs. cylindrical radius */
- _rz.fill(hit.getZ(), HitUtil.getCylindricalRadius(position) );
-
- /* hit layer */
- _layer.fill(hit.getLayer());
-
- /* hit weighted layer energy */
- _layerEnergy.fill(hit.getLayer(), edep);
-
- /* incr tot E */
- _eventTotEnergy += edep;
-
- /* incr num _hits */
- ++nhits;
-
- /* check max edep */
- if ( edep > maxEdep )
- {
- maxEdep = edep;
- }
-
- /* check min edep */
- if ( edep < minEdep )
- {
- minEdep = edep;
- }
-
- /* fetch the LayerInfo for this hit */
- LayerInfo layerInfo = _layers.get(hit.getLayer());
-
- /* add _layer edep */
- layerInfo.addEdep(edep);
-
- /* add _layer hit */
- layerInfo.incrNHits();
- }
-
- /* event _energy */
- _energyEvent.fill(_eventTotEnergy);
-
- /* event hit count */
- _hitCount.fill(nhits);
-
- /* avg _energy per hit */
- double hitAvgE = _eventTotEnergy / nhits;
- _hitAvgEnergy.fill(hitAvgE);
-
- /* min edep */
- _hitMinEdep.fill(minEdep);
-
- /* max edep */
- _hitMaxEdep.fill(maxEdep);
-
- /* min vs max edep */
- _hitMinVsMaxEdep.fill(maxEdep, minEdep);
-
- /* hit count vs total _energy */
- _hitVsTotE.fill(_eventTotEnergy, nhits);
-
- /* set _layer calcs and fill the plots */
- for ( LayerInfo layerInfo : _layers.values() )
- {
- /* set and fill percent total edep */
- layerInfo.setPercentTotalEnergy(_eventTotEnergy);
- _layerPercentTotE.fill(layerInfo.getLayerNumber(), layerInfo.getPercentTotalEnergy());
-
- /* set and fill percent hit count */
- layerInfo.setPercentNHits(nhits);
- _layerPercentHits.fill(layerInfo.getLayerNumber(), layerInfo.getPercentNHits());
- }
-
- /* reset _layers */
- for ( LayerInfo layerInfo : _layers.values() )
- {
- layerInfo.reset();
- }
- }
- }
+ ICloud1D _energy;
+ ICloud1D _energyEvent;
+ ICloud1D _hitAvgEnergy;
+ ICloud1D _hitMinEdep;
+ ICloud1D _hitMinEdepOverTot;
+ ICloud1D _hitMaxEdep;
+ ICloud1D _hitMaxEdepOverTot;
+ ICloud2D _hitMinVsMaxEdep;
+ ICloud2D _hitVsTotE;
+
+ IHistogram1D _layer;
+ ICloud1D _hitCount;
+
+ IHistogram1D _time;
+ ICloud1D _timeAvg;
+ ICloud2D _timeVsSphR;
+ ICloud2D _thetaPhi;
+ ICloud2D _xy;
+ ICloud2D _rz;
+ ICloud2D _zx;
+ ICloud2D _zy;
+ ICloud1D _hitMinX;
+ ICloud1D _hitMaxX;
+ ICloud1D _hitMinY;
+ ICloud1D _hitMaxY;
+ ICloud1D _hitMinZ;
+ ICloud1D _hitMaxZ;
+ ICloud1D _hitMaxR;
+ ICloud1D _hitMinR;
+
+ IHistogram1D _layerEnergy;
+ ICloud2D _layerVsR;
+ IHistogram1D _layerAvgHitEdep;
+ IHistogram2D _layerPercentTotE;
+ IHistogram2D _layerPercentHits;
+ ICloud1D _layerHitCount;
+ ICloud1D _layerAvgEdep;
+ ICloud1D _layerAvgNHits;
+ ICloud2D _layerAvgEdepVsAvgNHits;
+ ICloud1D _layerMaxEdep;
+ ICloud1D _layerMinEdep;
+ ICloud1D _layerMaxNHits;
+ ICloud1D _layerMinNHits;
+ ICloud1D _layerMaxEOverTot;
+ ICloud1D _layerMinEOverTot;
+ ICloud1D _layerMaxNHitsOverTot;
+ ICloud1D _layerMinNHitsOverTot;
+ IHistogram1D _layerAvgTotE;
+ IHistogram1D _layerAvgTotNHits;
+
+ int _nlayers = 0;
+
+ // total energy in all processed events
+ double _totalAvgEnergy = 0.0;
+
+ // current list of hits to process
+ List<GenericHit> _hits;
+
+ // map of layer number to LayerInfo
+ Map<Integer, LayerInfo> _layers = new HashMap<Integer, LayerInfo>();
+
+ // type of hits
+ GenericHit.HitType _hitType = null;
+
+ private static String getBaseDir(LCMetaData meta)
+ {
+ String dir = null;
+
+ if ( meta.getType().getSimpleName().compareTo("SimCalorimeterHit") == 0 )
+ {
+ dir = "CalorimeterHits";
+ } else
+ {
+ dir = "TrackerHits";
+ }
+
+ return dir;
+ }
+
+ public GenericHitPlots(String collName, LCMetaData meta)
+ {
+ super(getBaseDir(meta), meta);
+
+ // set number of layers
+ Subdetector det = ((SubdetectorIDDecoder) meta.getIDDecoder())
+ .getSubdetector();
+ _nlayers = ((Layered) det).getLayering().getLayerCount();
+
+ // make a LayerInfo for each layer
+ makeLayers();
+
+ // define the plots
+ definePlots();
+ }
+
+ private void makeLayers()
+ {
+ for (int i = 0; i < _nlayers; i++)
+ {
+ _layers.put(i, new LayerInfo(i));
+ }
+ }
+
+ // plots for GenericHits
+ protected void definePlots()
+ {
+ cd();
+
+ _energy = _aida.cloud1D("Hit: Energy");
+ _hitAvgEnergy = _aida.cloud1D("Hit: Average Energy by Event");
+ _time = _aida.histogram1D("Hit: Time", 100, 0, 50);
+ _timeAvg = _aida.cloud1D("Hit: Time Average");
+ _timeVsSphR = _aida.cloud2D("Hit: Time vs Spherical R");
+ _thetaPhi = _aida.cloud2D("Hit: Theta vs Phi");
+ _xy = _aida.cloud2D("Hit: X vs Y");
+ _zx = _aida.cloud2D("Hit: Z vs X");
+ _zy = _aida.cloud2D("Hit: Z vs Y");
+ _rz = _aida.cloud2D("Hit: R vs Z");
+ _layer = _aida.histogram1D("Hit: Count by Layer Number", _nlayers, 0, _nlayers);
+ _layerEnergy = _aida.histogram1D("Hit: Weighted Energy by Layer Number", _nlayers,
+ 0, _nlayers);
+ _energyEvent = _aida.cloud1D("Event: Total Energy");
+ _hitCount = _aida.cloud1D("Event: Total Hit Count");
+ _hitMinEdep = _aida.cloud1D("Hit: Min Edep");
+ _hitMinEdepOverTot = _aida.cloud1D("Hit: Min Edep over Total");
+ _hitMaxEdep = _aida.cloud1D("Hit: Max Edep");
+ _hitMaxEdepOverTot = _aida.cloud1D("Hit: Max Edep over Total");
+ _hitMinVsMaxEdep = _aida.cloud2D("Hit: Max vs Min Edep");
+ _hitVsTotE = _aida.cloud2D("Event: Energy Total vs Hit Count");
+ _hitMinX = _aida.cloud1D("Hit: Min X");
+ _hitMaxX = _aida.cloud1D("Hit: Max X");
+ _hitMinY = _aida.cloud1D("Hit: Min Y");
+ _hitMaxY = _aida.cloud1D("Hit: Max Y");
+ _hitMinZ = _aida.cloud1D("Hit: Min Z");
+ _hitMaxZ = _aida.cloud1D("Hit: Max Z");
+ _hitMaxR = _aida.cloud1D("Hit: Max R");
+ _hitMinR = _aida.cloud1D("Hit: Min R");
+ _layerVsR = _aida.cloud2D("Layer: # vs R");
+ _layerPercentTotE = _aida.histogram2D(
+ "Layer: Percentage of Energy Total", _nlayers, 0, _nlayers, 100,
+ 0, 1.0);
+ _layerPercentHits = _aida.histogram2D("Layer: Percentage of Hit Count",
+ _nlayers, 0, _nlayers, 100, 0, 1.0);
+ _layerAvgHitEdep = _aida.histogram1D("Layer: Average Hit Edep",
+ _nlayers, 0, _nlayers);
+ _layerAvgEdep = _aida.cloud1D("Layer: Average Energy per Event");
+ _layerAvgNHits = _aida
+ .cloud1D("Layer: Average Number of Hits per Event");
+ _layerAvgEdepVsAvgNHits = _aida
+ .cloud2D("Layer Average Energy vs Average Number of Hits");
+ _layerMaxEdep = _aida.cloud1D("Layer: Max Edep");
+ _layerMinEdep = _aida.cloud1D("Layer: Min Edep");
+ _layerMaxNHits = _aida.cloud1D("Layer: Max # Hits");
+ _layerMinNHits = _aida.cloud1D("Layer: Min # Hits");
+ _layerMaxEOverTot = _aida.cloud1D("Layer: Max Edep Over Total Edep");
+ _layerMinEOverTot = _aida.cloud1D("Layer: Min Edep Over Total Edep");
+ _layerMaxNHitsOverTot = _aida
+ .cloud1D("Layer: Max # Hits Over Total # Hits");
+ _layerMinNHitsOverTot = _aida
+ .cloud1D("Layer: Min # Hits Over Total # Hits");
+ _layerAvgTotE = _aida.histogram1D("Layer: Average Total Energy", _nlayers, 0, _nlayers);
+ _layerAvgTotNHits = _aida.histogram1D("Layer: Average Total # Hits", _nlayers, 0, _nlayers);
+ }
+
+ // set the hit list
+ public void setGenericHitList(List<GenericHit> hits)
+ {
+ this._hits = hits;
+ }
+
+ protected void fill(EventHeader event)
+ {
+ super.fill(event);
+ fill(_hits);
+ }
+
+ private void fill(List<GenericHit> hits)
+ {
+ if ( hits.size() == 0 )
+ return;
+
+ double eventTotE = 0.0;
+ int nhits = 0;
+ double minEdep = 9999.0;
+ double maxEdep = 0;
+ double totTime = 0.0;
+ double maxX = 0;
+ double minX = 999999;
+ double maxY = 0;
+ double minY = 999999;
+ double maxZ = 0;
+ double minZ = 999999;
+ double minR = 999999;
+ double maxR = 0;
+
+ // loop over hits
+ for (GenericHit hit : hits)
+ {
+ // get hit data
+ double x = hit.getX();
+ double y = hit.getY();
+ double z = hit.getZ();
+ double edep = hit.getEnergy();
+ double time = hit.getTime();
+ double theta = hit.getTheta();
+ double phi = hit.getPhi();
+ int layern = hit.getLayer();
+ double cylR = hit.getCylindricalRadius();
+ double sphR = hit.getSphericalRadius();
+
+ // hit energy
+ _energy.fill(edep);
+
+ // hit time
+ _time.fill(time);
+
+ // time vs spherical R
+ _timeVsSphR.fill(time, sphR);
+
+ // hit theta vs. phi
+ _thetaPhi.fill(theta, phi);
+
+ // hit X vs. Y
+ _xy.fill(x, y);
+
+ // Z vs. X
+ _zx.fill(z, x);
+
+ // Z vs. Y
+ _zy.fill(z, y);
+
+ // hit Z vs. cylindrical radius */
+ _rz.fill(z, cylR);
+
+ // check min, max for XYZ
+ if ( x > maxX )
+ {
+ maxX = x;
+ }
+
+ if ( x < minX )
+ {
+ minX = x;
+ }
+
+ if ( y > maxY )
+ {
+ maxY = y;
+ }
+
+ if ( y < minY )
+ {
+ minY = y;
+ }
+
+ if ( z > maxZ )
+ {
+ maxZ = z;
+ }
+
+ if ( z < minZ )
+ {
+ minZ = z;
+ }
+
+ // min, max for cyl R
+ if ( cylR > maxR )
+ {
+ maxR = cylR;
+ }
+
+ if ( cylR < minR )
+ {
+ minR = cylR;
+ }
+
+ // hit layer
+ _layer.fill(hit.getLayer());
+
+ // hit weighted layer energy
+ _layerEnergy.fill(layern, edep);
+
+ // layer vs R
+ _layerVsR.fill(layern, cylR);
+
+ // check max edep
+ if ( edep > maxEdep )
+ {
+ maxEdep = edep;
+ }
+
+ // check min edep
+ if ( edep < minEdep )
+ {
+ minEdep = edep;
+ }
+
+ // fetch the LayerInfo for this hit
+ LayerInfo layerInfo = _layers.get(layern);
+
+ // add hit to layer
+ layerInfo.addHit(hit);
+
+ // incr time cntr (for avg)
+ totTime += time;
+
+ // incr tot E
+ eventTotE += edep;
+
+ // incr num hits
+ ++nhits;
+ }
+
+ // fill pos min, max
+ _hitMaxX.fill(maxX);
+ _hitMinX.fill(minX);
+ _hitMaxY.fill(maxY);
+ _hitMinY.fill(minY);
+ _hitMaxZ.fill(maxZ);
+ _hitMinZ.fill(minZ);
+ _hitMinR.fill(minR);
+ _hitMaxR.fill(maxR);
+
+ // min edep over total
+ _hitMinEdepOverTot.fill(minEdep / eventTotE);
+
+ // max edep over total
+ _hitMaxEdepOverTot.fill(maxEdep / eventTotE);
+
+ // average time
+ _timeAvg.fill(totTime);
+
+ // event energy
+ _energyEvent.fill(eventTotE);
+
+ // event hit count
+ _hitCount.fill(nhits);
+
+ // avg energy per hit
+ double hitAvgE = eventTotE / nhits;
+ _hitAvgEnergy.fill(hitAvgE);
+
+ // min edep
+ _hitMinEdep.fill(minEdep);
+
+ // max edep
+ _hitMaxEdep.fill(maxEdep);
+
+ // min vs max edep
+ _hitMinVsMaxEdep.fill(maxEdep, minEdep);
+
+ // hit count vs total energy
+ _hitVsTotE.fill(eventTotE, nhits);
+
+ // do layer calcs and fill the plots
+ double minLayerE = 9999.0;
+ double maxLayerE = 0.0;
+
+ int minLayerNHits = 99999999;
+ int maxLayerNHits = 0;
+
+ // loop over layers after hit info was inserted
+ for (LayerInfo layerInfo : _layers.values())
+ {
+ // percentage of total edep in this layer
+ layerInfo.setPercentTotalEnergy(eventTotE);
+ _layerPercentTotE.fill(layerInfo.getLayerNumber(), layerInfo
+ .getPercentTotalEnergy());
+
+ // percentage of total hit count in this layer
+ layerInfo.setPercentNHits(nhits);
+ _layerPercentHits.fill(layerInfo.getLayerNumber(), layerInfo
+ .getPercentNHits());
+
+ // average energy in this layer's hit
+ double layerAvgHitEdep = layerInfo.getEdep() / layerInfo.getNHits();
+ _layerAvgHitEdep.fill(layerInfo.getLayerNumber(), layerAvgHitEdep);
+
+ // max E
+ if ( layerInfo.getEdep() > maxLayerE )
+ {
+ maxLayerE = layerInfo.getEdep();
+ }
+
+ // min E
+ if ( layerInfo.getEdep() < minLayerE )
+ {
+ minLayerE = layerInfo.getEdep();
+ }
+
+ // max nhits
+ if ( layerInfo.getNHits() > maxLayerNHits )
+ {
+ maxLayerNHits = layerInfo.getNHits();
+ }
+
+ // min nhits
+ if ( layerInfo.getNHits() < minLayerNHits )
+ {
+ minLayerNHits = layerInfo.getNHits();
+ }
+ }
+
+ // max edep in a layer
+ _layerMaxEdep.fill(maxLayerE);
+
+ // min edep in a layer
+ _layerMinEdep.fill(minLayerE);
+
+ // max nhits in a layer
+ _layerMaxNHits.fill(maxLayerNHits);
+
+ // min nhits in a layer
+ _layerMinNHits.fill(minLayerNHits);
+
+ // average energy in a layer
+ double avgLayerE = eventTotE / _nlayers;
+ _layerAvgEdep.fill(avgLayerE);
+
+ // average # hits in a layer
+ double avgLayerNHits = nhits / _nlayers;
+ _layerAvgNHits.fill(avgLayerNHits);
+
+ // average layer E vs average layer Nhits
+ _layerAvgEdepVsAvgNHits.fill(avgLayerE, avgLayerNHits);
+
+ // maxLayerE / eventTotE
+ _layerMaxEOverTot.fill(maxLayerE / eventTotE);
+
+ // minLayerE / eventTotE
+ _layerMinEOverTot.fill(minLayerE / eventTotE);
+
+ // maxLayerNHits / nhits
+ _layerMaxNHitsOverTot.fill(maxLayerNHits / ((double) nhits));
+
+ // minLayerNHits / nhits
+ _layerMinNHitsOverTot.fill(minLayerNHits / ((double) nhits));
+
+ // increment total energy
+ _totalAvgEnergy += eventTotE;
+
+ // reset layer event data
+ resetLayers();
+ }
+
+ private void resetLayers()
+ {
+ for (LayerInfo layerInfo : _layers.values())
+ {
+ layerInfo.resetEvent();
+ }
+ }
+
+ protected void endEvents(int nevents)
+ {
+ for (int i = 0; i < _nlayers; i++)
+ {
+ LayerInfo layer = _layers.get(i);
+
+ // average total energy in the layer for nevents
+ _layerAvgTotE.fill(i, layer.getAverageTotalEdep(nevents));
+
+ // average n hits in the layer for nevents
+ _layerAvgTotNHits.fill(i, layer.getAverageTotalNHits(nevents));
+
+ // reset layer
+ layer.resetEndData();
+ }
+ }
}
\ No newline at end of file
SlicDiagnostics/src/org/lcsim/slic/diagnostics
diff -u -r1.3 -r1.4
--- LayerInfo.java 5 Jan 2006 03:23:05 -0000 1.3
+++ LayerInfo.java 1 Feb 2006 01:35:09 -0000 1.4
@@ -2,93 +2,104 @@
/*
* @author jeremym
- * @version $Id: LayerInfo.java,v 1.3 2006/01/05 03:23:05 jeremy Exp $
+ * @version $Id: LayerInfo.java,v 1.4 2006/02/01 01:35:09 jeremy Exp $
*/
class LayerInfo
{
- int _layerNum;
- double _edep = 0;
- int _nhits = 0;
- double _percentTotE = 0;
- double _percentNHits = 0;
-// double averageE = 0;
-// double averageNHits = 0;
-
- public LayerInfo(int layerNum)
- {
- this._layerNum = layerNum;
- }
-
- int getLayerNumber()
- {
- return _layerNum;
- }
-
- void addEdep(double edep)
- {
- this._edep += edep;
- }
-
- double getEdep()
- {
- return _edep;
- }
-
- void incrNHits()
- {
- _nhits++;
- }
-
- int getNHits()
- {
- return _nhits;
- }
-
- void setPercentTotalEnergy(double totalEnergy)
- {
- _percentTotE = _edep / totalEnergy;
- }
-
- double getPercentTotalEnergy()
- {
- return _percentTotE;
- }
-
- void setPercentNHits(int totNHits)
- {
- _percentNHits = ((double)_nhits) / ((double)totNHits);
- }
-
- double getPercentNHits()
- {
- return _percentNHits;
- }
-
- void reset()
- {
- _edep = 0;
- _nhits = 0;
- _percentTotE = 0;
- _percentNHits = 0;
- }
-
-// void setAverageEventEnergy(int nevents)
-// {
-// averageE = _edep / (double)nevents;
-// }
-//
-// double getAverageEventEnergy()
-// {
-// return averageE;
-// }
-//
-// void setAverageEventNHits(int nevents)
-// {
-// averageNHits = _nhits / (double)nevents;
-// }
-//
-// double getAverageEventNHits()
-// {
-// return averageNHits;
-// }
+ private int _layerNum = -1;
+ private double _edep = 0;
+ private int _nhits = 0;
+ private double _percentTotE = 0;
+ private double _percentNHits = 0;
+ private int _totNHits;
+ private double _totEdep;
+
+ public LayerInfo(int layerNum)
+ {
+ assert(layerNum >= 0);
+ _layerNum = layerNum;
+ }
+
+ int getLayerNumber()
+ {
+ return _layerNum;
+ }
+
+ private void addEdep(double edep)
+ {
+ _edep += edep;
+ _totEdep += edep;
+ }
+
+ public double getEdep()
+ {
+ return _edep;
+ }
+
+ private void incrNHits()
+ {
+ _nhits++;
+ _totNHits++;
+ }
+
+ public int getNHits()
+ {
+ return _nhits;
+ }
+
+ protected void setPercentTotalEnergy(double totalEnergy)
+ {
+ _percentTotE = _edep / totalEnergy;
+ }
+
+ public double getPercentTotalEnergy()
+ {
+ return _percentTotE;
+ }
+
+ public void setPercentNHits(double totNHits)
+ {
+ _percentNHits = _nhits / totNHits;
+ }
+
+ public double getPercentNHits()
+ {
+ return _percentNHits;
+ }
+
+ public double getAverageHitEdep()
+ {
+ return _edep / _nhits;
+ }
+
+ public double getAverageTotalEdep(int nevents)
+ {
+ return _totEdep / ((double)nevents);
+ }
+
+ public double getAverageTotalNHits(int nevents)
+ {
+ return _totNHits / ((double)nevents);
+ }
+
+ protected void resetEvent()
+ {
+ _edep = 0;
+ _nhits = 0;
+ _percentTotE = 0;
+ _percentNHits = 0;
+ }
+
+ protected void resetEndData()
+ {
+ resetEvent();
+ _totEdep = 0;
+ _totNHits = 0;
+ }
+
+ public void addHit(GenericHit hit)
+ {
+ addEdep(hit.getEnergy());
+ incrNHits();
+ }
}
\ No newline at end of file
