diff -N TestSetUpPFA.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ TestSetUpPFA.java	14 Mar 2011 17:34:02 -0000	1.1
@@ -0,0 +1,122 @@

+package org.lcsim.contrib.Cassell.recon;
+
+import org.lcsim.recon.pfa.structural.*;
+import java.util.*;
+import org.lcsim.util.*;
+import org.lcsim.event.*;
+import org.lcsim.util.decision.*;
+import org.lcsim.recon.pfa.identifier.*;
+import org.lcsim.recon.cluster.util.CalorimeterHitTimeCutDecision;
+import org.lcsim.recon.cluster.util.UpperSubLayerDecision;
+import org.lcsim.recon.util.CalorimeterInformation;
+import org.lcsim.geometry.Calorimeter.CalorimeterType;
+
+public class TestSetUpPFA extends Driver {
+
+    //default 250 GeV
+    UnphysicalTrackDecision dec = new UnphysicalTrackDecision();
+    //default input realistic tracks
+    ListFilterDriver fil = new ListFilterDriver(dec,"Tracks", "FilteredTrackList", Track.class);
+    HelixExtrapolator findCluster = new org.lcsim.recon.pfa.identifier.TrackHelixPlusHitExtrapolator();
+    ReclusterDTreeDriver reclusTree = new ReclusterDTreeDriver("DTreeClusters", "UnmatchedTracksAfterAmbigClusterMap", "ReconFSParticles", "MuonTrackClusterMap", findCluster);
+
+    public void setFilterInputTrack(String x){ fil.setInputList(x); }
+    public void setFilterDefaultValue(double x){ dec.setDefaultvalue(x); }
+    public void setFilterOnputTrack(String x){ fil.setOutputList(x); }
+    public void setReclusJetScoreThreshold(double x){ reclusTree.setJetScoreThreshold(x); }
+    public void setReclusJetTolerance(double x){ reclusTree.setJetTolerance(x); }
+    public void setReclusMinScoreForReassignment(double x){ reclusTree.setMinScoreForReassignment(x); }
+    public void setReclusUseMucalBarrel(boolean x){ reclusTree.setUseMucalBarrel(x); }
+    public void setReclusUseMucalEndcap(boolean x){ reclusTree.setUseMucalEndcap(x); }
+    public void setReclusUseAnalogHcalCalibration(boolean x){ reclusTree.setUseAnalogHcalCalibration(x); }
+    public void setReclusPunchThroughLayers(int x){ reclusTree.setPunchThroughLayers(x); }
+    public void setReclusPunchThroughHitMinimum(int x){ reclusTree.setPunchThroughHitMinimum(x); }
+    public void setReclusCheckSharedHitsForPunchThrough(boolean x){ reclusTree.setCheckSharedHitsForPunchThrough(x); }
+    public void setReclusOutputParticleListName(String x){ reclusTree.setOutputParticleListName(x); }
+    private boolean init;
+    private boolean useNewInitialMipFinding = false;
+    public void setUseNewInitialMipFinding(boolean x){useNewInitialMipFinding = x;}
+
+
+    public TestSetUpPFA(){
+        this("Tracks");
+    }
+
+    public TestSetUpPFA(String trackList) {
+	// Filter tracks, removing those with unphysical energy
+	{
+            fil.setInputList(trackList);
+	    add(dec);
+            add(fil);        
+            init = false;
+	}
+    }
+
+    protected void process(EventHeader event)
+    {
+        if(!init)
+        {
+            init = true;
+            CalorimeterInformation ci = CalorimeterInformation.instance();
+            // Filter muon system hits
+
+            {
+                DecisionMakerSingle<CalorimeterHit> upperLayer = new UpperSubLayerDecision();
+                DecisionMakerSingle<CalorimeterHit> lowerLayer = new NotDecisionMakerSingle(upperLayer);
+                DecisionMakerSingle<CalorimeterHit> timeCut = new CalorimeterHitTimeCutDecision(100);
+                AndDecisionMakerSingle<CalorimeterHit> lowerLayerAndTimeCut = new AndDecisionMakerSingle<CalorimeterHit>();
+                lowerLayerAndTimeCut.addDecisionMaker(lowerLayer);
+                lowerLayerAndTimeCut.addDecisionMaker(timeCut);
+                add(new ListFilterDriver(lowerLayerAndTimeCut, ci.getCollectionName(CalorimeterType.MUON_BARREL), "CorrMuonBarrelDigiHits", CalorimeterHit.class));
+                add(new ListFilterDriver(lowerLayerAndTimeCut, ci.getCollectionName(CalorimeterType.MUON_ENDCAP), "CorrMuonEndcapDigiHits", CalorimeterHit.class));
+            }
+
+            // Set up track extrapolation
+            add(findCluster);
+
+            // Set up input lists of calorimeter hits
+            {
+                List<String> recoHitLists = new Vector<String>(); // Hits to use in main clustering
+                List<String> allHitLists = new Vector<String>(); // All hits (used in muon-finding)
+                List<String> mstHitLists = new Vector<String>(); // Hits from subsystems where we have to use MST
+                recoHitLists.add(ci.getDigiCollectionName(CalorimeterType.EM_BARREL));
+                recoHitLists.add(ci.getDigiCollectionName(CalorimeterType.EM_ENDCAP));
+                recoHitLists.add(ci.getDigiCollectionName(CalorimeterType.HAD_BARREL));
+                recoHitLists.add(ci.getDigiCollectionName(CalorimeterType.HAD_ENDCAP));
+                recoHitLists.add("CorrMuonEndcapDigiHits");
+                allHitLists.addAll(recoHitLists);
+                allHitLists.add("CorrMuonBarrelDigiHits");
+                mstHitLists.add(ci.getDigiCollectionName(CalorimeterType.MUON_ENDCAP));
+                TestSetUpDTreeForReclustering setup = new TestSetUpDTreeForReclustering("FilteredTrackList", allHitLists, recoHitLists, mstHitLists, findCluster);
+                setup.setUseNewInitialMipFinding(useNewInitialMipFinding);
+                add(setup);
+            }
+
+            // Set up and run PFA
+            reclusTree.writeExtraEventOutput(false);
+            reclusTree.addInputMips("OldMipsInsideTreesECAL");
+            reclusTree.addInputMips("NewMipsInsideTreesECAL");
+            reclusTree.addInputMips("OldMipsInsideTreesHCAL");
+            reclusTree.addInputMips("NewMipsInsideTreesHCAL");
+            reclusTree.addInputMips("OldMipsInsideTreesMCAL");
+            reclusTree.addInputMips("NewMipsInsideTreesMCAL");
+            reclusTree.addInputMips("PreShowerMipMatchMipClusters");
+            reclusTree.addInputClumps("ClumpsInsideTreesECAL");
+            reclusTree.addInputClumps("ClumpsInsideTreesHCAL");
+            reclusTree.addInputClumps("ClumpsInsideTreesMCAL");
+            reclusTree.addInputBlocks("BlocksInsideTreesECAL");
+            reclusTree.addInputBlocks("BlocksInsideTreesHCAL");
+            reclusTree.addInputBlocks("BlocksInsideTreesMCAL");
+            reclusTree.addInputLeftoverHits("LeftoverHitsInsideTreesECAL");
+            reclusTree.addInputLeftoverHits("LeftoverHitsInsideTreesHCAL");
+            reclusTree.addInputLeftoverHits("LeftoverHitsInsideTreesMCAL");
+            reclusTree.addTrackToClusterMap("MapPreShowerMipTracksToClusterSeeds");
+            reclusTree.addTrackToClusterMap("MapMipClusterTracksToClusterSeeds");
+            reclusTree.addTrackToClusterMap("MapGenClusterTracksToClusterSeeds");
+            reclusTree.addTrackToClusterMap("MapAmbigClusterTracksToClusterSeeds");
+//            reclusTree.setDebug(true);
+            add(reclusTree);
+        }
+        super.process(event);
+    }
+}

diff -N PostTrackingTestReconDriver.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ PostTrackingTestReconDriver.java	14 Mar 2011 17:34:02 -0000	1.1
@@ -0,0 +1,47 @@

+package org.lcsim.contrib.Cassell.recon;
+
+import org.lcsim.digisim.DigiPackageDriver;
+import org.lcsim.recon.pfa.output.FlushReconstructedParticlesDriver;
+import org.lcsim.recon.pfa.structural.SetUpPFA;
+import org.lcsim.recon.util.CalInfoDriver;
+import org.lcsim.util.Driver;
+
+/**
+ * Top-level driver to run UI PFA reconstruction.
+ * 
+ * @author cassell
+ * @version $Id: PostTrackingTestReconDriver.java,v 1.1 2011/03/14 17:34:02 cassell Exp $
+ */
+
+public class PostTrackingTestReconDriver extends Driver
+{
+    private boolean useNewInitialMipFinding = false;
+    TestSetUpPFA setup;
+    public void setUseNewInitialMipFinding(boolean x)
+    {
+        useNewInitialMipFinding = x;
+        setup.setUseNewInitialMipFinding(useNewInitialMipFinding);
+    }
+    /** 
+     * Constructor that sets up daughter drivers. 
+     */
+    public PostTrackingTestReconDriver()
+    {
+        // Cash general calorimeter information
+        add(new CalInfoDriver());
+
+    	// Run digisim.
+        add(new DigiPackageDriver());
+        
+        // Run tracking.
+//        add(new org.lcsim.recon.tracking.seedtracker.trackingdrivers.sidloi2.MainTrackingDriver());
+	
+        // Set up and run PFA.
+        setup = new TestSetUpPFA("Tracks");
+        setup.setUseNewInitialMipFinding(useNewInitialMipFinding);
+        add(setup);
+
+        // Output collections.
+        add(new FlushReconstructedParticlesDriver("DTreeReclusteredParticles", "ReconstructedParticles", "Clusters"));
+    }
+}

diff -N RemoveHitsNearTracks.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ RemoveHitsNearTracks.java	14 Mar 2011 17:34:02 -0000	1.1
@@ -0,0 +1,98 @@

+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.Cassell.recon.photons;;
+import java.util.*;
+import org.lcsim.util.Driver;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.CalorimeterHit;
+import org.lcsim.event.Cluster;
+import org.lcsim.recon.cluster.util.BasicCluster;
+import org.lcsim.recon.cluster.mipfinder.trackxtrap.*;
+import hep.physics.vec.*;
+import org.lcsim.geometry.Calorimeter.CalorimeterType;
+import org.lcsim.util.lcio.LCIOConstants;
+
+/**
+ *
+ * @author cassell
+ */
+public class RemoveHitsNearTracks extends Driver
+{
+    String inName;
+    String outName1;
+    String outName2;
+    String outmapName;
+    List<TrackXtrapInfo> txil;
+    protected double hitDsqCut = 7.*7.;// 2 cells
+    public RemoveHitsNearTracks(String in,String out1,String out2,String outmap)
+    {
+        inName = in;
+        outName1 = out1;
+        outName2 = out2;
+        outmapName = outmap;
+    }
+    protected void process(EventHeader event)
+    {
+        List<Cluster> inCl = event.get(Cluster.class,inName);
+        List<Cluster> outCl1 = new ArrayList<Cluster>();
+        List<Cluster> outCl2 = new ArrayList<Cluster>();
+        Map<Cluster,Cluster> outMap = new HashMap<Cluster,Cluster>();
+        txil = event.get(TrackXtrapInfo.class,"TrackXtrapInfo");
+        List<Hep3Vector> hitpos = new ArrayList<Hep3Vector>();
+        for(TrackXtrapInfo txi:txil)
+        {
+            for(XtrapPosition xi:txi.getPositions())
+            {
+                if( (xi.getCalorimeterType() == CalorimeterType.EM_BARREL)||
+                    (xi.getCalorimeterType() == CalorimeterType.EM_ENDCAP))
+                {
+                    hitpos.add(xi.getPosition());
+                }
+            }
+        }
+        for(Cluster c:inCl)
+        {
+            Cluster cutc = removeHits(c,hitpos);
+            if(c.getCalorimeterHits().size() == cutc.getCalorimeterHits().size())
+            {
+                outCl1.add(cutc);
+            }
+            else
+            {
+                if(cutc.getCalorimeterHits().size() > 0)outCl1.add(cutc);
+                outCl2.add(c);
+                outMap.put(c, cutc);
+            }
+        }
+        int flag = 1<<LCIOConstants.CLBIT_HITS;
+        event.put(outName1, outCl1, Cluster.class, flag );
+        event.put(outName2, outCl2, Cluster.class, flag );
+        event.put(outmapName,outMap);
+    }
+    public Cluster removeHits(Cluster c,List<Hep3Vector> hitpos)
+    {
+        BasicCluster newc = new BasicCluster();
+        newc.addCluster(c);
+        List<CalorimeterHit> remove = new ArrayList<CalorimeterHit>();
+        for(CalorimeterHit h:c.getCalorimeterHits())
+        {
+            Hep3Vector pos = h.getPositionVec();
+            for(Hep3Vector hpos:hitpos)
+            {
+                if(VecOp.sub(hpos, pos).magnitudeSquared() < hitDsqCut)
+                {
+                    remove.add(h);
+                    break;
+                }
+            }
+        }
+        for(CalorimeterHit h:remove)
+        {
+            newc.removeHit(h);
+        }
+        return newc;
+    }
+}

diff -N TestPhotonFinder.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ TestPhotonFinder.java	14 Mar 2011 17:34:02 -0000	1.1
@@ -0,0 +1,162 @@

+/*
+ * RonDTPhotonFinderSid01.java
+ *
+ * Created on February 25, 2008, 10:28 AM
+ *
+ */
+
+package org.lcsim.contrib.Cassell.recon.photons;
+
+import org.lcsim.recon.pfa.photonfinder.*;
+import java.util.*;
+import org.lcsim.util.Driver;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.CalorimeterHit;
+import org.lcsim.event.Cluster;
+import org.lcsim.util.hitmap.HitMap;
+import org.lcsim.recon.cluster.nn.*;
+import org.lcsim.digisim.*;
+import org.lcsim.recon.cluster.util.*;
+import org.lcsim.util.lcio.LCIOConstants;
+import org.lcsim.recon.cluster.directedtree.*;
+import org.lcsim.recon.util.CalorimeterInformation;
+import org.lcsim.geometry.Calorimeter.CalorimeterType;
+
+/**
+ *
+ * @author cassell
+ */
+public class TestPhotonFinder extends Driver
+{
+    String inName;
+    String outHName;
+    String outCName1;
+    String outCName2;
+    String outMapName;
+    HMatrixVars hmv;
+    Sid01DTPhotonFinder finder;
+    String[] clusternames1;
+    String DTclName = "DTEcalClusters";
+    String ReDTclName = "Re"+DTclName;
+    Clusterer clusterer;
+    boolean init;
+    
+    /** Creates a new instance of RonDTPhotonFinderSid01 */
+    public TestPhotonFinder(String in, String outH, String outC1, String outC2)
+    {
+        inName = in;
+        outHName = outH;
+        outCName1 = outC1;
+        outCName2 = outC2;
+        clusterer = new NearestNeighborClusterer(1,1,1,0,0.);
+        hmv = new HMatrixVars();
+        add(hmv);
+        finder = new Sid01DTPhotonFinder(hmv);
+        add(new DigiPackageDriver());
+        add(new DirectedTreeDriver());
+        init = false;
+        clusternames1 = new String[2];
+    }
+    protected void process(EventHeader event)
+    {
+        if(!init)
+        {
+            init = true;
+            CalorimeterInformation ci = CalorimeterInformation.instance();
+            clusternames1[0] = ci.getDigiCollectionName(CalorimeterType.EM_BARREL)+"DTreeClusters";
+            clusternames1[1] = ci.getDigiCollectionName(CalorimeterType.EM_ENDCAP)+"DTreeClusters";
+            add(new CombineClLists(clusternames1,DTclName));
+            add(new RemoveHitsNearTracks(DTclName,"Cut"+DTclName,DTclName+"ForElectrons",outMapName));
+            add(new CoreReclusterDriver("Cut"+DTclName,ReDTclName));
+            add(new CoreReclusterDriver(DTclName+"ForElectrons",ReDTclName+"ForElectrons"));
+        }
+        super.process(event);
+        HitMap inmap = (HitMap) event.get(inName);
+        List<Cluster> inlist = event.get(Cluster.class,ReDTclName);
+        List<Cluster> sublist = new ArrayList<Cluster>();
+        Map<Cluster,Cluster> submap = new HashMap<Cluster,Cluster>();
+        for(Cluster c:inlist)
+        {
+           List<Cluster> nncl = clusterer.createClusters(c.getCalorimeterHits());
+           int maxh = 0;
+           Cluster maxc = null;
+           for(Cluster nnc:nncl)
+           {
+              if(nnc.getCalorimeterHits().size() > maxh)
+              {
+                 maxh = nnc.getCalorimeterHits().size();
+                 maxc = nnc;
+              }
+           }
+           sublist.add(maxc);
+           submap.put(maxc,c);
+        }
+        List<Cluster> subphotons = finder.findPhotons(sublist);
+        List<Cluster> photons = new ArrayList<Cluster>();
+        for(Cluster subp:subphotons)
+        {
+           BasicCluster pc = new BasicCluster();
+           for(Cluster subc:subp.getClusters())
+           {
+              pc.addCluster(submap.get(subc));
+           }
+           photons.add(pc);
+        }
+        int flag = 1<<LCIOConstants.CLBIT_HITS;
+        event.put(outCName1, photons, Cluster.class, flag );
+
+        inlist = event.get(Cluster.class,ReDTclName+"ForElectrons");
+        sublist = new ArrayList<Cluster>();
+        submap = new HashMap<Cluster,Cluster>();
+        for(Cluster c:inlist)
+        {
+           List<Cluster> nncl = clusterer.createClusters(c.getCalorimeterHits());
+           int maxh = 0;
+           Cluster maxc = null;
+           for(Cluster nnc:nncl)
+           {
+              if(nnc.getCalorimeterHits().size() > maxh)
+              {
+                 maxh = nnc.getCalorimeterHits().size();
+                 maxc = nnc;
+              }
+           }
+           sublist.add(maxc);
+           submap.put(maxc,c);
+        }
+        subphotons = finder.findPhotons(sublist);
+        List<Cluster> electrons = new ArrayList<Cluster>();
+        for(Cluster subp:subphotons)
+        {
+           BasicCluster pc = new BasicCluster();
+           for(Cluster subc:subp.getClusters())
+           {
+              pc.addCluster(submap.get(subc));
+           }
+           electrons.add(pc);
+        }
+        event.put(outCName2, electrons, Cluster.class, flag );
+
+
+        HitMap outputHitMap = new HitMap(inmap);
+//   Remove photon hits
+        for (Cluster clus : photons)
+        {
+            for (CalorimeterHit hit : clus.getCalorimeterHits())
+            {
+               Long cellID = new Long(hit.getCellID());
+               outputHitMap.remove(cellID);
+            }
+         }
+        for (Cluster clus : electrons)
+        {
+            for (CalorimeterHit hit : clus.getCalorimeterHits())
+            {
+               Long cellID = new Long(hit.getCellID());
+               outputHitMap.remove(cellID);
+            }
+         }
+         event.put(outHName, outputHitMap);
+    }
+    
+}