lcsim/sandbox/RobKutschke/HitTests/v1
diff -N FitAbleInfo.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ FitAbleInfo.java 13 Oct 2007 16:29:47 -0000 1.1
@@ -0,0 +1,210 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Iterator;
+
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.SimTrackerHit;
+import org.lcsim.contrib.onoprien.tracking.hit.DigiTrackerHit;
+import org.lcsim.contrib.onoprien.tracking.hit.TrackerCluster;
+import org.lcsim.contrib.onoprien.tracking.hit.TrackerHit;
+
+
+/**
+ * Collect the various maps into a class that provides unified access.
+ * It is possible for a given MCParticle to have SimTrackerHits but none
+ * of the other hits.
+ *
+ *@author $Author: kutschke $
+ *@version $Id: FitAbleInfo.java,v 1.1 2007/10/13 16:29:47 kutschke Exp $
+ *
+ * Date $Date: 2007/10/13 16:29:47 $
+ *
+ */
+
+
+public class FitAbleInfo {
+
+ private MCParticle mcp = null;
+ private List<SimTrackerHit> shits = null;
+ private List<DigiTrackerHit> digis = null;
+ private List<TrackerCluster> clusters = null;
+ private List<TrackerHit> thits = null;
+
+ // Values of status variable:
+ // -1 - Checking code not yet run.
+ // This happens if there are no tracker hits on the track.
+ // 0 - Checked and all is OK.
+ // else - Some error has occured.
+ private int status = -1;
+
+ // Number of degrees of freedom on the track.
+ private int ndof = 0;
+
+ // Are all clusters on the track composed of only DigiTrackerHits created
+ // by this track and this track alone.
+ private boolean pureclusters = false;
+
+ // Are all clusters on this track composed of a single DigiTrackerHit.
+ // (Needed for defining perfect tracks for debugging fitters).
+ private boolean allsingles = false;
+
+ public FitAbleInfo ( MCParticle p ){
+ mcp = p;
+ }
+
+ public FitAbleInfo ( MCParticle p, List s ){
+ mcp = p;
+ setSimTrackerHit(s);
+ }
+
+ public void setSimTrackerHit(List s){
+ shits = safecopy( SimTrackerHit.class, s);
+ }
+
+ public void setDigiTrackerHit(List d){
+ digis = safecopy( DigiTrackerHit.class,d);
+ }
+
+ public void setTrackerCluster(List c){
+ clusters = safecopy( TrackerCluster.class, c);
+ }
+ public void setTrackerHit(List t){
+ thits = safecopy( TrackerHit.class, t);
+ Initialize();
+ }
+
+ public MCParticle getMCParticle(){
+ return mcp;
+ }
+
+ public List<SimTrackerHit> getSimTrackerHit(){
+
+ // This should not happen.
+ if ( shits == null ){
+ shits = new ArrayList<SimTrackerHit>();
+ }
+ return shits;
+ }
+ public List<DigiTrackerHit> getDigiTrackerHit(){
+
+ // Make an empty list if necessary.
+ if ( digis == null ){
+ digis = new ArrayList<DigiTrackerHit>();
+ }
+ return digis;
+ }
+ public List<TrackerCluster> getTrackerCluster(){
+
+ // Make an empty list if necessary.
+ if ( clusters == null ){
+ clusters = new ArrayList<TrackerCluster>();
+ }
+ return clusters;
+ }
+ public List<TrackerHit> getTrackerHit(){
+
+ // Make an empty list if necessary.
+ if ( thits == null ){
+ thits = new ArrayList<TrackerHit>();
+ }
+
+ return thits;
+ }
+
+ public int getStatus(){
+ return status;
+ }
+ public int getNdof(){
+ return ndof;
+ }
+ public boolean hasPureClusters(){
+ return pureclusters;
+ }
+ public boolean isAllSingles(){
+ return allsingles;
+ }
+
+ // Check type safety before copying.
+ // Need to learn how to do this without generating a compiler warning.
+ private <T> List<T> safecopy( Class<T> type, List l){
+
+ List<T> result = null;
+
+ // Replace this with proper type saftey when I learn now to do it.
+ // Add type safety here when I learn how to do it.
+ Iterator i = l.iterator();
+
+ // If the list is empty it is safe to return it for readonly purposes.
+ // So we do not need to check further in that case.
+
+ if ( i.hasNext() ){
+ Object o = i.next();
+ if ( !type.isAssignableFrom(o.getClass()) ){
+ System.out.println("FitAbleInfo: Error adding list. Expected: "
+ + type.getName() + " Found: "
+ + o.getClass().getName()
+ );
+ }
+ }
+
+ // This is the line that the compiler complains about:
+ result = l;
+
+ return result;
+ }
+
+ // Check for self consistency and compute some properties of the hit lists.
+ private void Initialize(){
+ status = 0;
+
+ // Local, temporary, copies of the hasPureCluster and isAllSingles.
+ // Do not want to set the offical copies to true until the entire track
+ // has been checked and there are ways to break out of the loop without
+ // completing the checks.
+ boolean single = true;
+ boolean match = true;
+
+ for ( TrackerHit hit : thits ){
+ TrackerCluster clus = hit.getCluster();
+ if ( clus == null ) {
+ status = 1;
+ return;
+ }
+ List<DigiTrackerHit> digil = clus.getDigiHits();
+ if ( digil == null ){
+ status = 2;
+ return;
+ }
+ if ( digil.size() == 0 ){
+ status = 3;
+ return;
+ }
+
+ if ( digil.size() != 1 ) single = false;
+
+ for ( DigiTrackerHit digi : digil ){
+ MCParticle mcpp = digi.getMCParticle();
+ if ( !digi.isComposite() ){
+ if ( mcpp != mcp ) match = false;
+ } else{
+ List<DigiTrackerHit> elems = digi.getElementalHits();
+ if ( elems == null ){
+ status = 4;
+ return;
+ }
+ if ( elems.size() == 0 ){
+ status = 5;
+ return;
+ }
+ for ( DigiTrackerHit elem : elems ){
+ MCParticle mcpe = elem.getMCParticle();
+ if ( mcpe != mcp ) match = false;
+ }
+ } // end composite test.
+ } // end loop over DigiTrackerHits
+ } // end loop over TrackerHits
+ if ( match ) pureclusters = true;
+ if ( single ) allsingles = true;
+ }
+
+}
lcsim/sandbox/RobKutschke/HitTests/v1
diff -N HitLoop.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ HitLoop.java 13 Oct 2007 16:29:47 -0000 1.1
@@ -0,0 +1,160 @@
+import java.io.File;
+import java.util.*;
+import java.net.URL;
+import org.lcsim.util.cache.FileCache;
+import org.lcsim.event.*;
+import org.lcsim.util.loop.*;
+import org.lcsim.detector.driver.*;
+//import org.lcsim.contrib.onoprien.tracking.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import hep.aida.*;
+import org.lcsim.event.EventHeader;
+import org.lcsim.units.clhep.SystemOfUnits;
+import org.lcsim.util.Driver;
+import org.lcsim.util.aida.AIDA;
+import org.lcsim.contrib.HansWenzel.Tracking.TrackerHitCheaterDriver;
+import org.lcsim.contrib.onoprien.tracking.clustering.ClusteringDriver;
+import org.lcsim.contrib.onoprien.tracking.clustering.clusterers.NearestNeighborClusterer;
+import org.lcsim.contrib.onoprien.tracking.digitization.DigitizationDriver;
+import org.lcsim.contrib.onoprien.tracking.digitization.Digitizer;
+import org.lcsim.contrib.onoprien.tracking.digitization.diagnostics.DigitizerTest;
+import org.lcsim.contrib.onoprien.tracking.digitization.digitizers.DigitizerSmear;
+import org.lcsim.contrib.onoprien.tracking.geom.SegmentationManager;
+import org.lcsim.contrib.onoprien.tracking.geom.Sensor;
+import org.lcsim.contrib.onoprien.tracking.geom.segmenters.CylindricalBarrelSegmenter;
+import org.lcsim.contrib.onoprien.tracking.geom.segmenters.DiskTrackerToWedgesSegmenter;
+import org.lcsim.contrib.onoprien.tracking.geom.segmenters.DiskTrackerToRingsSegmenter;
+import org.lcsim.contrib.onoprien.tracking.geom.segmenters.SubdetectorBasedSegmenter;
+import org.lcsim.contrib.onoprien.tracking.hit.DigiTrackerHit;
+
+import org.lcsim.contrib.onoprien.tracking.hit.TrackerCluster;
+import org.lcsim.contrib.onoprien.tracking.hit.TrackerHit;
+import org.lcsim.contrib.onoprien.tracking.hitmaking.HitMakingDriver;
+import org.lcsim.contrib.onoprien.tracking.hitmaking.TrackerHitMaker;
+import org.lcsim.contrib.onoprien.tracking.hitmaking.hitmakers.TrackerHitMakerBasic;
+
+
+/**
+ * Main program to run the tests of accessing hits.
+ *
+ *@author $Author: kutschke $
+ *@version $Id: HitLoop.java,v 1.1 2007/10/13 16:29:47 kutschke Exp $
+ *
+ * Date $Date: 2007/10/13 16:29:47 $
+ *
+ */
+
+
+public class HitLoop extends Driver {
+ public HitLoop() {
+ }
+ public static void main(String[] args) throws Exception {
+ LCSimLoop loop = new LCSimLoop();
+
+ // URL location = new URL("http://docdb.fnal.gov/ILC/detsim/datasets/planar/planar_mu_10GeV.slcio");
+ //URL location = new URL("ftp://ftp-lcd.slac.stanford.edu/lcd/ILC/singleParticle/sid01/slcio/slic/mu_100.0GeV_Theta90_SLIC_v2r0p12_sid01.slcio");
+ //FileCache cache = new FileCache();
+ //File input = cache.getCachedFile(location);
+
+ //File input = new File("data/pythiaZhiggs120_uds_4jets-0-500_SLIC_v2r1p6_sid01.slcio");
+ File input = new File("data/pythiaZPoleuds-0-1000_SLIC_v2r0p12_sid01.slcio");
+ // File input = new File("/home/wenzel/sid01/planar_mu.slcio");
+// File input = new File("/home/wenzel/TrackerHitAccessDriver/planar_mu_1gev.slcio");
+ loop.setLCIORecordSource(input);
+
+ SubdetectorBasedSegmenter mainSegmenter = new SubdetectorBasedSegmenter();
+
+ // 25 um pixels in VTX Barrel
+
+ CylindricalBarrelSegmenter vtxBarrelSegmenter = new CylindricalBarrelSegmenter("VertexBarrel");
+ vtxBarrelSegmenter.setStripLength(25.*SystemOfUnits.micrometer);
+ vtxBarrelSegmenter.setStripWidth(25.*SystemOfUnits.micrometer);
+ mainSegmenter.setSegmenter("VertexBarrel", vtxBarrelSegmenter);
+
+ // 10 cm x 25 um strips in outer Tracker Barrel
+
+ CylindricalBarrelSegmenter trackerBarrelSegmenter = new CylindricalBarrelSegmenter("TrackerBarrel");
+ trackerBarrelSegmenter.setStripLength(10.*SystemOfUnits.cm);
+ trackerBarrelSegmenter.setStripWidth(25.*SystemOfUnits.micrometer);
+ mainSegmenter.setSegmenter("TrackerBarrel", trackerBarrelSegmenter);
+
+ // 25 um pixels in VTX Endcap
+
+ DiskTrackerToRingsSegmenter vtxEndcapSegmenter = new DiskTrackerToRingsSegmenter("VertexEndcap");
+ vtxEndcapSegmenter.setStripLength(25.*SystemOfUnits.micrometer);
+ vtxEndcapSegmenter.setStripWidth(25.*SystemOfUnits.micrometer);
+ mainSegmenter.setSegmenter("VertexEndcap", vtxEndcapSegmenter);
+
+ // 15 degrees stereo wedges in Forward Tracker
+
+ DiskTrackerToWedgesSegmenter trackerForwardSegmenter = new DiskTrackerToWedgesSegmenter("TrackerForward");
+ trackerForwardSegmenter.setStripLength(10.*SystemOfUnits.cm);
+ trackerForwardSegmenter.setStripWidth(25.*SystemOfUnits.micrometer);
+ trackerForwardSegmenter.setNumberOfPhiSlices(24);
+ mainSegmenter.setSegmenter("TrackerForward", trackerForwardSegmenter);
+
+ // 15 degrees stereo wedges in outer Tracker Endcap
+
+ DiskTrackerToWedgesSegmenter trackerEndcapSegmenter = new DiskTrackerToWedgesSegmenter("TrackerEndcap");
+ trackerEndcapSegmenter.setNumberOfRadialSlices(new int[]{3,5,8,10});
+ trackerEndcapSegmenter.setStripWidth(25.*SystemOfUnits.micrometer);
+ trackerEndcapSegmenter.setNumberOfPhiSlices(24);
+ mainSegmenter.setSegmenter("TrackerEndcap", trackerEndcapSegmenter);
+
+ SegmentationManager segMan = new SegmentationManager(mainSegmenter);
+ SegmentationManager.setDefaultInstance(segMan);
+
+ // Digitization :
+
+ Digitizer digitizer = new DigitizerSmear();
+
+ DigitizationDriver digitizationDriver = new DigitizationDriver(digitizer);
+ digitizationDriver.set("OUTPUT_MAP_NAME", "DigiTrackerHits");
+ digitizationDriver.set("DIAGNOSTIC_LIST_NAME", "SimToDigiGroups");
+ loop.add(digitizationDriver);
+
+ // Digitizer diagnostics :
+
+ // digitizationDriver.set("DIAGNOSTIC_LIST_NAME", "SimToDigiGroups");
+ //DigitizerTest digitizerTest = new DigitizerTest();
+ //digitizerTest.set("DIAGNOSTIC_LIST_NAME", "SimToDigiGroups");
+ //loop.add(digitizerTest);
+
+ // Clustering :
+
+ ClusteringDriver clusteringDriver = new ClusteringDriver(new NearestNeighborClusterer());
+ clusteringDriver.set("INPUT_MAP_NAME","DigiTrackerHits");
+ clusteringDriver.set("OUTPUT_MAP_NAME","TrackerClusters");
+ loop.add(clusteringDriver);
+ // Hit making :
+
+ TrackerHitMaker hitMaker = new TrackerHitMakerBasic();
+ HitMakingDriver hitMakingDriver = new HitMakingDriver(hitMaker);
+ hitMakingDriver.set("INPUT_MAP_NAME","TrackerClusters");
+ hitMakingDriver.set("OUTPUT_MAP_NAME","NewTrackerHits");
+ loop.add(hitMakingDriver);
+ //
+ // Analyze the result:
+ //
+ //VSAccessDriver vsaccessDriver = new VSAccessDriver();
+ //vsaccessDriver.set("DIGIS_MAP_NAME","DigiTrackerHits");
+ //vsaccessDriver.set("CLUSTERS_MAP_NAME","TrackerClusters");
+ //loop.add(vsaccessDriver);
+
+ // add(new VSHitsAccessDriver());
+ TrackerHitCheaterDriver _TrackerHitCheaterDriver = new TrackerHitCheaterDriver();
+ loop.add(_TrackerHitCheaterDriver);
+ // File output = new File("exampleAnalysisJava.slcio");
+ // loop.add(new LCIODriver(output));
+
+ loop.add( new TrackerHitCheaterAccessDriver() );
+
+ long n = loop.loop(100);
+ loop.dispose();
+ AIDA.defaultInstance().saveAs("plots.aida");
+ }
+}
+
lcsim/sandbox/RobKutschke/HitTests/v1
diff -N TrackerHitCheaterAccessDriver.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ TrackerHitCheaterAccessDriver.java 13 Oct 2007 16:29:47 -0000 1.1
@@ -0,0 +1,256 @@
+//package org.lcsim.contrib.HansWenzel.Tracking;
+import org.lcsim.util.aida.AIDA;
+import hep.aida.IHistogram1D;
+import hep.aida.ICloud1D;
+import hep.aida.ICloud2D;
+
+import hep.physics.particle.properties.ParticleType;
+import java.util.Collections;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.EventHeader.LCMetaData;
+import org.lcsim.util.Driver;
+import hep.aida.ITree;
+import java.io.File;
+import java.net.URL;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+import hep.physics.particle.BasicParticle;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.SimTrackerHit;
+import org.lcsim.contrib.onoprien.tracking.hit.DigiTrackerHit;
+import org.lcsim.contrib.onoprien.tracking.hit.TrackerCluster;
+import org.lcsim.contrib.onoprien.tracking.hit.base.TrackerClusterBasic;
+import org.lcsim.contrib.onoprien.tracking.hit.TrackerHit;
+import org.lcsim.contrib.onoprien.tracking.geom.Sensor;
+import org.lcsim.contrib.onoprien.tracking.geom.sensortypes.Cylinder;
+import org.lcsim.contrib.onoprien.tracking.geom.sensortypes.Ring;
+import org.lcsim.contrib.onoprien.tracking.geom.sensortypes.WedgeSideParallel;
+
+import org.lcsim.detector.IDetectorElement;
+import hep.physics.matrix.SymmetricMatrix;
+
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.Iterator;
+import hep.physics.vec.Hep3Vector;
+import org.lcsim.spacegeom.SpacePoint;
+import org.lcsim.spacegeom.SpaceVector;
+
+
+/**
+ * Driver to access hits.
+ *
+ *@author $Author: kutschke $
+ *@version $Id: TrackerHitCheaterAccessDriver.java,v 1.1 2007/10/13 16:29:47 kutschke Exp $
+ *
+ * Date $Date: 2007/10/13 16:29:47 $
+ *
+ */
+
+public class TrackerHitCheaterAccessDriver extends Driver {
+
+ private AIDA aida = AIDA.defaultInstance();
+
+ private IHistogram1D errorReport = null;
+
+ public TrackerHitCheaterAccessDriver() {
+ errorReport = aida.histogram1D("Error flags", 40, 0., 20.);
+ }
+
+ protected void process(EventHeader event) {
+
+ Map<MCParticle,FitAbleInfo> tracks = getHansHits(event);
+
+ List<MCParticle> hitmcp = new ArrayList<MCParticle>( tracks.keySet() );
+ int ntracks = hitmcp.size();
+
+ // Tracks with 5 hits or more.
+ // And number with only pure clusters and only single hit clusters.
+ int n5 = 0;
+ int n5good = 0;
+
+ // Sum of numbers of simtrackerhits on each track.
+ int sum=0;
+
+ // Some historams of the hits.
+ for ( MCParticle mcp: tracks.keySet() ){
+ FitAbleInfo f = tracks.get(mcp);
+ if ( f.getStatus() > 0 ){
+ aida.histogram1D("Bad Fitable Status",20,0.,10.).fill(f.getStatus());
+ errorReport.fill(8);
+ continue;
+ }
+
+ if ( f.getTrackerHit().size() > 4 ){
+ ++n5;
+ if ( f.hasPureClusters() && f.isAllSingles() ) ++n5good;
+
+ aida.histogram1D("Hits per track",50,0,50).fill(f.getTrackerHit().size());
+ Hep3Vector p = mcp.getMomentum();
+ double pt = Math.sqrt( p.x()*p.x() + p.y()*p.y() );
+ double cz = p.z()/p.magnitude();
+ aida.cloud2D("pt vs cos(theta)",-1).fill(cz,pt);
+ aida.cloud2D("Hits per track vs cz").fill(cz,f.getTrackerHit().size());
+ aida.cloud2D("Hits per track vs pt").fill(pt,f.getTrackerHit().size());
+ aida.histogram1D("Pt",100,0,100).fill(pt);
+ aida.histogram1D("Pt-detail",200,0,2.).fill(pt);
+ aida.histogram1D("Cos(theta)",100,-1.,1.).fill(cz);
+ }
+ sum += f.getSimTrackerHit().size();
+ }
+ aida.histogram1D("Tracks with > 4 hits",100,0,100).fill(n5);
+ aida.histogram1D("Tracks with < 5 hits",100,0,100).fill(ntracks-n5);
+ aida.histogram1D("Tracks with > 4 hits and best status",100,0,100).fill(n5good);
+
+ // As a cross-check, add up all simtracker hits straight from the event.
+ CheckTotals ( event, sum );
+
+ for ( MCParticle mcp: tracks.keySet() ){
+ FitAbleInfo f = tracks.get(mcp);
+
+ if ( f.getStatus() != 0 ) continue;
+ if ( f.getTrackerHit().size() < 5 ) continue;
+
+ // For debugging: index of mcparticle in the map.
+ int idx0 = -1;
+ if ( mcp != null ){
+ idx0 = hitmcp.indexOf(mcp);
+ }
+
+ for ( TrackerHit hit : f.getTrackerHit() ){
+ SpacePoint pos = new SpacePoint(hit.getPosition());
+ double r = pos.rxy();
+ double z = pos.z();
+ aida.cloud2D("Hit: r vs z",-1).fill( z, r );
+ if ( r < 75. ) aida.cloud2D("Hit: r vs z, r<75mm",-1).fill( z, r );
+ if ( r < 225. ) aida.cloud2D("Hit: r vs z, r<225mm",-1).fill( z, r );
+ TrackerCluster clus = hit.getCluster();
+ List<DigiTrackerHit> digis = clus.getDigiHits();
+ aida.histogram1D("Size of Digi List: ",20,0.,10.).fill(digis.size());
+
+ List<TrackerHit> backptr = clus.getTrackerHits();
+ if ( backptr == null ){
+ errorReport.fill(3);
+ continue;
+ }
+ aida.histogram1D("Links from Cluster to TrackerHits",20,0.,10.).fill(backptr.size());
+
+ Sensor sensor = clus.getSensor();
+ if ( sensor == null ){
+ errorReport.fill(4);
+ continue;
+ }
+
+ IDetectorElement ide = sensor.getDetectorElement();
+ if ( ide == null ){
+ errorReport.fill(9);
+ continue;
+ }
+
+ int idxb = ide.getName().indexOf("Barrel");
+
+ Cylinder tmpc = new Cylinder();
+ Ring tmpr = new Ring(1., 10., 0.001, 10., 0.003 );
+ WedgeSideParallel tmpw = new WedgeSideParallel( 1., 10., 0.707, 0.001, true, 0.003);
+
+ Hep3Vector lpos = hit.getLocalPosition();
+ SymmetricMatrix lcov = hit.getLocalCovMatrix();
+
+ System.out.printf( "Sensor: %3d %3d %-6b %-6b %-40s %10.4f %10.4f %10.4f | %10.4f | %10.4f %10.4f %10.4f\n",
+ sensor.getType().getHitDimension(),
+ idxb,
+ sensor.getType().getClass().isInstance(tmpc),
+ sensor.getType().getClass().isInstance(tmpw),
+ ide.getName(),
+ lpos.x(),
+ lpos.y(),
+ lpos.z(),
+ r,
+ Math.sqrt(lcov.diagonal(0)),
+ Math.sqrt(lcov.diagonal(1)),
+ Math.sqrt(lcov.diagonal(2))
+ );
+ }
+ }
+
+
+
+ }
+
+ Map<MCParticle,FitAbleInfo> getHansHits ( EventHeader event ){
+ Map<MCParticle,FitAbleInfo> tracks = new HashMap<MCParticle,FitAbleInfo>();
+
+ //
+ // First get all the stuff we are interested in out of the event:
+ //
+ Map shmap = (Map) event.get("SimTrackerHitMap");
+ if ( shmap != null ){
+ for ( Iterator k = shmap.keySet().iterator(); k.hasNext(); ){
+ MCParticle p = (MCParticle)k.next();
+ List l = (List)shmap.get(p);
+ tracks.put(p, new FitAbleInfo(p,l));
+ }
+ }
+
+ Map dhmap = (Map) event.get("DigiTrackerHitMap");
+ if ( dhmap != null ){
+ for ( Iterator k=dhmap.keySet().iterator(); k.hasNext(); ){
+ MCParticle p = (MCParticle)k.next();
+ List l = (List)dhmap.get(p);
+ if ( tracks.containsKey(p) ){
+ tracks.get(p).setDigiTrackerHit(l);
+ } else{
+ errorReport.fill(5);
+ System.out.println ("Warning .... DigiTrackerHits missing SimTrackerHits.");
+ }
+ }
+ }
+
+ Map clmap = (Map) event.get("TrackerClusterMap");
+ if ( clmap != null ){
+ for ( Iterator k=clmap.keySet().iterator(); k.hasNext(); ){
+ MCParticle p = (MCParticle)k.next();
+ List l = (List)clmap.get(p);
+ if ( tracks.containsKey(p) ){
+ tracks.get(p).setTrackerCluster(l);
+ } else{
+ errorReport.fill(6);
+ System.out.println ("Warning .... TrackerHitClusters missing SimTrackerHits.");
+ }
+
+ }
+ }
+
+ Map thmap = (Map) event.get("TrackerHitMap");
+ if ( thmap != null ){
+ for ( Iterator k=thmap.keySet().iterator(); k.hasNext(); ){
+ MCParticle p = (MCParticle)k.next();
+ List l = (List)thmap.get(p);
+ if ( tracks.containsKey(p) ){
+ tracks.get(p).setTrackerHit(l);
+ } else{
+ errorReport.fill(7);
+ System.out.println ("Warning .... TrackerHits missing SimTrackerHits.");
+ }
+ }
+ }
+ return tracks;
+ }
+
+ // Check that sum of all simtracker hits matches the sum from the FitAbleInfo map.
+ void CheckTotals( EventHeader event, int sum ){
+
+ int sum1 = 0;
+ List<List<SimTrackerHit>> simTrackerHitCollections = event.get(SimTrackerHit.class);
+ for ( List<SimTrackerHit> simTrackerHits : simTrackerHitCollections ){
+ sum1 += simTrackerHits.size();
+ }
+ if ( sum1 != sum ){
+ errorReport.fill(0);
+ System.out.println("Mismatched sum of hits: " + sum + " " + sum1 );
+ }
+ }
+
+
+}