diff -N GenericHit.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ GenericHit.java	27 Jul 2005 00:43:59 -0000	1.1
@@ -0,0 +1,117 @@

+/*
+ * GenericHit.java
+ *
+ * Created on July 26, 2005, 10:45 AM
+ */
+
+package org.lcsim.slic.diagnostics;
+
+import static java.lang.Math.PI;
+import static java.lang.Math.sqrt;
+import static java.lang.Math.atan2;
+import static java.lang.Math.atan;
+
+/**
+ *
+ * @author jeremym
+ */
+class GenericHit
+{
+    private double energy;
+    private double[] position;
+    private int layer;
+    private double time;
+    public enum HitType
+    { TRACKER, CALORIMETER };
+    HitType hitType;
+    String collName;
+    
+    GenericHit(HitType hitType, String collName, double energy, double[] position, int layer, double time)
+    {
+        this.hitType = hitType;
+        this.collName = collName;
+        this.energy = energy;
+        this.position = position;
+        this.layer = layer;
+        this.time = time;
+    }
+    
+    double getEnergy()
+    {
+        return energy;
+    }
+    
+    double[] getPosition()
+    {
+        return position;
+    }
+    
+    double getX()
+    {
+        return position[0];
+    }
+    
+    double getY()
+    {
+        return position[1];
+    }
+    
+    double getZ()
+    {
+        return position[2];
+    }
+    
+    int getLayer()
+    {
+        return layer;
+    }
+    
+    double getTime()
+    {
+        return time;
+    }
+    
+    HitType getType()
+    {
+        return hitType;
+    }
+    
+    String getCollectionName()
+    {
+        return collName;
+    }
+    
+    double getSphericalRadius()
+    {
+        return sqrt(getX() * getX() + getY() * getY() + getZ() * getZ());
+    }
+    
+    double getCylindricalRadius()
+    {
+        return sqrt(getX() * getX() + getY() * getY());
+    }
+    
+    public double getPhi()
+    {
+        double phi = atan2(getX(), getY() );
+        
+        if ( phi < 0 )
+        {
+            phi += 2 * PI;
+        }
+        
+        return phi;
+    }
+    
+    public double getTheta()
+    {
+        double theta = atan(getCylindricalRadius() / getZ());
+        
+        if ( theta < 0 )
+        {
+            theta += PI;
+        }
+        
+        return theta;
+    }
+}

\ No newline at end of file

diff -N GenericHitPlots.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ GenericHitPlots.java	27 Jul 2005 00:44:00 -0000	1.1
@@ -0,0 +1,180 @@

+/*
+ * SingleHitCollectionPlots.java
+ *
+ * Created on July 26, 2005, 10:44 AM
+ */
+
+package org.lcsim.slic.diagnostics;
+
+import java.util.List;
+
+import org.lcsim.util.aida.AIDA;
+import hep.aida.ICloud1D;
+import hep.aida.ICloud2D;
+import hep.aida.ITree;
+import org.lcsim.event.EventHeader.LCMetaData;
+import org.lcsim.geometry.Subdetector;
+import org.lcsim.geometry.subdetector.SubdetectorIDDecoder;
+
+/**
+ *
+ * @author jeremym
+ */
+class GenericHitPlots
+{
+    AIDA aida = org.lcsim.util.aida.AIDA.defaultInstance();
+    
+    String collName;
+    ITree tree;
+    
+    /* plots */
+    ICloud1D energy;
+    ICloud1D energyEvent;
+    ICloud1D time;
+    ICloud2D thetaPhi;
+    ICloud2D xy;
+    ICloud2D rz;
+    ICloud1D layer;
+    ICloud1D hitCount;
+    ICloud1D hitAvgEnergy;
+    ICloud1D layerEnergy;
+    ICloud1D layerHitCount;
+    
+    double[] layerE;
+    int[] layerHits;
+    
+    int nlayers = 0;
+    double eventTotEnergy = 0;
+    
+    LCMetaData meta;
+    
+    /** Creates a new instance of SingleHitCollectionPlots */
+    public GenericHitPlots(LCMetaData meta)
+    {
+        /* set MetaData ref */
+        this.meta = meta;
+        
+        /* set name */
+        this.collName = meta.getName();
+        
+        /* set n layers */
+        nlayers = ((SubdetectorIDDecoder)meta.getIDDecoder()).getSubdetector().getLayering().getLayerCount();
+        
+        /* define energy per layer array */
+        layerE = new double[nlayers];
+        
+        /* define # hits per layer array */
+        layerHits = new int[nlayers];
+        
+        /* set ref to AIDA tree */
+        tree = aida.tree();
+        
+        /* make dir for these plots (if doesn't exist) */
+        makeDir();
+        
+        /* define plots for this coll */
+        definePlots();
+    }
+    
+    private void makeDir()
+    {
+        try
+        {
+            tree.mkdir("/" + collName);
+        }
+        catch (Exception e)
+        {
+            System.out.println("collName already exists: " + collName);
+        }
+    }
+    
+    /* plots for generic hits */
+    private void definePlots()
+    {
+        tree.cd("/" + collName);
+        energy = aida.cloud1D("hitEnergy_cloud1D");
+        hitAvgEnergy = aida.cloud1D("hitAvgEnergy_cloud1D");
+        time = aida.cloud1D("hitTime_cloud1D");
+        thetaPhi = aida.cloud2D("hitThetaPhi_cloud2D");
+        xy = aida.cloud2D("hitXY_cloud2D");
+        rz = aida.cloud2D("hitRZ_cloud2D");
+        layer = aida.cloud1D("hitLayer_cloud1D");
+        energyEvent = aida.cloud1D("eventEnergy_cloud1D");
+        hitCount = aida.cloud1D("eventNumHits_cloud1D");
+        layerEnergy = aida.cloud1D("layersAvgEnergyEvent_cloud1D");
+        layerHitCount = aida.cloud1D("layersAvgHitCountEvent_cloud1D");
+        tree.cd("..");
+    }
+    
+    public void fill(List<GenericHit> hits)
+    {
+        eventTotEnergy = 0;
+        int nhits = 0;
+        
+        if ( hits.size() != 0 )
+        {
+            tree.cd("/" + collName);
+            
+            for ( GenericHit hit : hits )
+            {
+                /* hit energy */
+                energy.fill(hit.getEnergy() );
+                
+                /* hit time */
+                time.fill(hit.getTime() );
+                
+                /* hit theta vs. phi */
+                thetaPhi.fill(hit.getTheta(), hit.getPhi() );
+                
+                /* hit X vs. Y */
+                xy.fill(hit.getX(), hit.getY() );
+                
+                /* hit cyl radius vs. Z */
+                rz.fill(hit.getCylindricalRadius(), hit.getZ() );
+                
+                /* layer energy */
+                layerE[hit.getLayer()] += hit.getEnergy();
+                
+                /* layer # hits */
+                layerHits[hit.getLayer()] += 1;
+                
+                /* incr tot E */
+                eventTotEnergy += hit.getEnergy();
+                
+                ++nhits;
+            }
+            
+            /* event energy */
+            energyEvent.fill(eventTotEnergy);
+            
+            /* event hit count */
+            hitCount.fill(nhits);
+            
+            /* avg energy per hit */
+            double hitAvgE = eventTotEnergy / nhits;
+            hitAvgEnergy.fill(hitAvgE);
+            
+            /* fill layer plots from arrays */
+            for ( int i=0; i < this.nlayers; i++)
+            {
+                /* energy by layer */
+                layerEnergy.fill(i, layerE[i]);
+                
+                /* hit count by layer*/
+                layerHitCount.fill(i, (double)layerHits[i]);
+            }
+            
+            /* reset layer arrays */
+            layerEnergy.fill(0);
+            layerHitCount.fill(0);
+            
+            tree.cd("..");
+        }
+    }
+    
+    /* return total energy from last event processed */
+    public double getEventEnergy()
+    {
+        return eventTotEnergy;
+    }
+}

diff -u -r1.1 -r1.2
--- SlicDiagnosticsDriver.java	26 Jul 2005 00:05:07 -0000	1.1
+++ SlicDiagnosticsDriver.java	27 Jul 2005 00:44:00 -0000	1.2
@@ -8,14 +8,23 @@

 
 import java.util.List;
 import java.util.ArrayList;

+import java.util.Map;
+import java.util.HashMap;
+
+import org.freehep.application.Application;
+import org.freehep.application.studio.Studio;
+import org.freehep.record.loop.SequentialRecordLoop;
+import org.freehep.record.source.SequentialRecordSource;

 
 import org.lcsim.util.aida.AIDA;

+import hep.aida.ICloud1D;

 import org.lcsim.util.Driver;
 import org.lcsim.event.EventHeader;
 import org.lcsim.event.EventHeader.LCMetaData;
 import org.lcsim.event.SimTrackerHit;
 import org.lcsim.event.SimCalorimeterHit;
 import org.lcsim.geometry.IDDecoder;

+import org.lcsim.event.EventHeader.LCMetaData;

 
 /**
  *

@@ -24,95 +33,158 @@

 public class SlicDiagnosticsDriver extends Driver
 {
     private AIDA aida = AIDA.defaultInstance();

+    String fileName = "slicDiagnostics.aida";    
+    
+    Map<String, GenericHitPlots> singleCollPlots = new HashMap<String,GenericHitPlots>();

-    //private List<String> calHitColls = new ArrayList<String>();
-    //private List<String> trkHitColls = new ArrayList<String>();    
-    List<BasicHit> hits;

+    int nEvents = 0;
+    
+    ICloud1D eventTotalEnergy;
+    
+    double eventEnergy = 0;

     
     /** Creates a new instance of SlicDiagnosticsDriver */
     public SlicDiagnosticsDriver()

-    {}

+    {
+        eventTotalEnergy = aida.cloud1D("eventEnergy_cloud1D");
+    }

     
     protected void process(EventHeader event)

-    {

+    {        
+        /* proc tracker colls */

         processTrackerCollections(event);

-        processCalorimeterCollections(event);

+        
+        /* proc cal colls */
+        processCalorimeterCollections(event);        
+        
+        /* event total energy */
+        eventEnergy = 0;
+        for ( GenericHitPlots plots : singleCollPlots.values() )
+        {
+            eventEnergy += plots.getEventEnergy();
+        }
+        
+        eventTotalEnergy.fill(eventEnergy);
+        
+        /* incr tot n events */
+        ++nEvents;                   

     }
     

-    private void processTrackerCollections(EventHeader event)

+    private GenericHitPlots getSingleHitCollectionPlots(LCMetaData meta)

     {

-        List<List<SimTrackerHit>> simTrackerHitCollections = event.get(SimTrackerHit.class);
-        System.out.println("simTrackerHitColls: " + simTrackerHitCollections.size() );

+        if ( singleCollPlots.get(meta.getName()) == null )
+        {
+            singleCollPlots.put(meta.getName(), new GenericHitPlots(meta) );
+        }

+        return singleCollPlots.get(meta.getName());
+    }
+    
+    private void processTrackerCollections(EventHeader event)
+    {
+        List<List<SimTrackerHit>> simTrackerHitCollections = event.get(SimTrackerHit.class);        

         for ( List<SimTrackerHit> simTrackerHits : simTrackerHitCollections )
         {
             LCMetaData meta = event.getMetaData(simTrackerHits);

-            System.out.println(meta.getName() );

+            GenericHitPlots plots = getSingleHitCollectionPlots(meta);
+            List<GenericHit> hits = makeTrackerHits(simTrackerHits, meta);
+            plots.fill(hits);

         }
     }
     
     private void processCalorimeterCollections(EventHeader event)
     {

-        List<List<SimCalorimeterHit>> simCalorimeterHitCollections = event.get(SimCalorimeterHit.class);        
-        System.out.println("simCalHitColls: " + simCalorimeterHitCollections.size() );                
-        

+        List<List<SimCalorimeterHit>> simCalorimeterHitCollections = event.get(SimCalorimeterHit.class);                

         for ( List<SimCalorimeterHit> simCalorimeterHits : simCalorimeterHitCollections)
         {
             LCMetaData meta = event.getMetaData(simCalorimeterHits);

-            System.out.println(meta.getName());

+            GenericHitPlots plots = getSingleHitCollectionPlots(meta);
+            List<GenericHit> hits = makeCalorimeterHits(simCalorimeterHits, meta);
+            plots.fill(hits);

         }
     }
     

-    private GenericHit makeBasicHit(SimCalorimeterHit calorimeterHit, LCMetaData meta)

+    private List<GenericHit> makeTrackerHits(List<SimTrackerHit> trackerHits, LCMetaData meta)
+    {
+        List<GenericHit> genericHits = new ArrayList<GenericHit>();
+        for (SimTrackerHit trackerHit : trackerHits)
+        {
+            GenericHit genericHit = makeTrackerHit(trackerHit, meta);
+            genericHits.add(genericHit);
+        }
+        return genericHits;
+    }
+    
+    private List<GenericHit> makeCalorimeterHits(List<SimCalorimeterHit> calHits, LCMetaData meta)
+    {
+        List<GenericHit> genericHits = new ArrayList<GenericHit>();
+        for (SimCalorimeterHit calHit : calHits)
+        {
+            GenericHit genericHit = makeCalorimeterHit(calHit, meta);
+            genericHits.add(genericHit);
+        }
+        return genericHits;
+    }
+    
+    private GenericHit makeCalorimeterHit(SimCalorimeterHit calorimeterHit, LCMetaData meta)

     {
         IDDecoder decoder = meta.getIDDecoder();
         decoder.setID(calorimeterHit.getCellID() );

-        int layer = decoder.getLayer();        

+        int layer = decoder.getLayer();

-        return new GenericHit( 

+        return new GenericHit(

                 GenericHit.HitType.CALORIMETER,
                 meta.getName(),
                 calorimeterHit.getEnergy(),
                 calorimeterHit.getPosition(),
                 layer,
                 calorimeterHit.getContributedTime(0) // smallest time???

-                ); 
-    }            

+                );
+    }

-    private GenericHit makeBasicHit(SimTrackerHit trackerHit, LCMetaData meta)

+    private GenericHit makeTrackerHit(SimTrackerHit trackerHit, LCMetaData meta)

     {
         IDDecoder decoder = meta.getIDDecoder();
         decoder.setID(trackerHit.getCellID() );
         int layer = decoder.getLayer();
         

-        return new GenericHit( 

+        return new GenericHit(

                 GenericHit.HitType.TRACKER,
                 meta.getName(),
                 trackerHit.getdEdx(),
                 trackerHit.getPoint(),
                 layer,

-                trackerHit.getTime() 

+                trackerHit.getTime()

                 );

-    }    

+    }

-    private class GenericHit

+    protected void startOfData()

     {

-        private double energy;
-        private double[] position;
-        private int layer;
-        private double time;
-        enum HitType { TRACKER, CALORIMETER };
-        HitType hitType;
-        String collName;
-        
-        GenericHit(HitType hitType, String collName, double energy, double[] position, int layer, double time)
-        {            
-            this.hitType = hitType;
-            this.collName = collName;
-            this.energy = energy;
-            this.position = position;
-            this.layer = layer;
-            this.time = time;

+        if ( Application.getApplication() != null)
+        {
+            SequentialRecordLoop loop = (SequentialRecordLoop) ((Studio) Application.getApplication()).getLookup().lookup(SequentialRecordLoop.class);
+            
+            if ( loop != null )
+            {
+                SequentialRecordSource source = loop.getRecordSource();
+                if ( source != null )
+                {
+                    fileName = source.getSourceName();
+                }
+            }
+        }
+    }
+    
+    protected void endOfData()
+    {
+        //System.out.println("endOfData");
+        try
+        {
+            aida.saveAs(fileName);
+        }
+        catch (Exception e)
+        {
+            throw new RuntimeException("Problem committing tree.", e);

         }
     }
 }

diff -u -r1.1 -r1.2
--- SlicDiagnosticsTest.java	26 Jul 2005 00:05:07 -0000	1.1
+++ SlicDiagnosticsTest.java	27 Jul 2005 00:44:00 -0000	1.2
@@ -30,15 +30,16 @@

         LCSimLoop loop = new LCSimLoop();
         loop.setLCIORecordSource(file);
         loop.add(new SlicDiagnosticsDriver());

-//        loop.loop(-1);
-        loop.loop(1);

+        loop.loop(-1);
+//        loop.loop(5);

         loop.dispose();
     }
     
     public void testSlicDiagnostics() throws Exception
     {

-        runTestFile("http://www.lcsim.org/test/lcio/muons_SLIC_v1r9p1_sidmay05.slcio");
-        runTestFile("http://www.lcsim.org/test/lcio/muons_SLIC_v1r9p1_sidmay05_np.slcio");

+        //runTestFile("http://www.lcsim.org/test/lcio/muons_SLIC_v1r9p1_sidmay05.slcio");
+        //runTestFile("http://www.lcsim.org/test/lcio/muons_SLIC_v1r9p1_sidmay05_np.slcio");
+        runTestFile("file:/nfs/slac/g/lcd/mc/prj/data/public_data/ILC/singleParticle/sidaug05/slcio/slic/muon_Theta1-179_1-50GeV_SLIC_v1r9p3_sidaug05.slcio");

     }
         
     public SlicDiagnosticsTest(String testName)