diff -N SingPiTSDriver.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ SingPiTSDriver.java	14 Feb 2012 19:38:38 -0000	1.1
@@ -0,0 +1,464 @@

+package org.lcsim.contrib.SteveMagill;
+
+import org.lcsim.util.*;
+import org.lcsim.recon.cluster.util.*;
+import org.lcsim.digisim.DigiSimDriver;
+import org.lcsim.digisim.SimCalorimeterHitsDriver;
+import org.lcsim.util.hitmap.HitListToHitMapDriver;
+import org.lcsim.util.hitmap.HitMapToHitListDriver;
+import org.lcsim.event.util.CreateFinalStateMCParticleList;
+import org.lcsim.recon.cluster.nn.*;
+import org.lcsim.recon.cluster.mst.*;
+import org.lcsim.recon.cluster.fixedcone.*;
+import org.lcsim.recon.tracking.cheat.CheatTrackDriver;
+import org.lcsim.mc.fast.tracking.MCFastTracking;
+
+public class SingPiTSDriver extends Driver
+{
+       
+   public SingPiTSDriver()
+   {
+       
+//  use DIGISIM - with steering file to do threshold, timing cuts
+       add(new CalHitMapDriver());
+       DigiSimDriver digi = new DigiSimDriver();
+//       String dsteer = ("C:\\LC Data\\CCAL002M10.steer");
+       String dsteer = ("G:\\LC Data\\CCAL002M50.steer");
+       digi.setSteeringFile(dsteer);
+       add(digi);
+       add(new SimCalorimeterHitsDriver());
+
+//  make subdetector hitmaps from DigiSim scintillator collections
+       HitListToHitMapDriver ebhitmap = new HitListToHitMapDriver();
+       ebhitmap.addInputList("Edep_EcalBarrDigiHits");
+       ebhitmap.setOutput("ScEBarrhitmap");
+       add(ebhitmap);
+       HitListToHitMapDriver hbhitmap = new HitListToHitMapDriver();
+       hbhitmap.addInputList("Edep_HcalBarrDigiHits");
+       hbhitmap.setOutput("ScHBarrhitmap");
+       add(hbhitmap);
+       HitListToHitMapDriver eehitmap = new HitListToHitMapDriver();
+       eehitmap.addInputList("Edep_EcalEndcapDigiHits");
+       eehitmap.setOutput("ScEEndcaphitmap");
+       add(eehitmap);
+       HitListToHitMapDriver hehitmap = new HitListToHitMapDriver();
+       hehitmap.addInputList("Edep_HcalEndcapDigiHits");
+       hehitmap.setOutput("ScHEndcaphitmap");
+       add(hehitmap);
+
+//  Can make a combined hitmap for the digisim output hits - now have 5 hitmaps,
+//  1 for each cal subdetector and 1 with all hits
+       HitListToHitMapDriver digiHitMap = new HitListToHitMapDriver();
+       digiHitMap.addInputList("Edep_EcalBarrDigiHits");
+       digiHitMap.addInputList("Edep_EcalEndcapDigiHits");
+       digiHitMap.addInputList("Edep_HcalBarrDigiHits");
+       digiHitMap.addInputList("Edep_HcalEndcapDigiHits");
+       digiHitMap.setOutput("AllScDigiHitMap");
+       add(digiHitMap);
+
+//  Convert to hit collection for display
+       HitMapToHitListDriver testlist = new HitMapToHitListDriver();
+       testlist.setInputHitMap("AllScDigiHitMap");
+       testlist.setOutputList("AllScDigiHits");
+       add(testlist);
+
+//  Same thing for DigiSim cherenkov hits
+       HitListToHitMapDriver ebchitmap = new HitListToHitMapDriver();
+       ebchitmap.addInputList("Ceren_EcalBarrDigiHits");
+       ebchitmap.setOutput("ChEBarrhitmap");
+       add(ebchitmap);
+       HitListToHitMapDriver hbchitmap = new HitListToHitMapDriver();
+       hbchitmap.addInputList("Ceren_HcalBarrDigiHits");
+       hbchitmap.setOutput("ChHBarrhitmap");
+       add(hbchitmap);
+       HitListToHitMapDriver eechitmap = new HitListToHitMapDriver();
+       eechitmap.addInputList("Ceren_EcalEndcapDigiHits");
+       eechitmap.setOutput("ChEEndcaphitmap");
+       add(eechitmap);
+       HitListToHitMapDriver hechitmap = new HitListToHitMapDriver();
+       hechitmap.addInputList("Ceren_HcalEndcapDigiHits");
+       hechitmap.setOutput("ChHEndcaphitmap");
+       add(hechitmap);
+
+//  Can make a combined hitmap for the digisim output hits - now have 5 hitmaps,
+//  1 for each cal subdetector and 1 with all hits
+       HitListToHitMapDriver cdigiHitMap = new HitListToHitMapDriver();
+       cdigiHitMap.addInputList("Ceren_EcalBarrDigiHits");
+       cdigiHitMap.addInputList("Ceren_EcalEndcapDigiHits");
+       cdigiHitMap.addInputList("Ceren_HcalBarrDigiHits");
+       cdigiHitMap.addInputList("Ceren_HcalEndcapDigiHits");
+       cdigiHitMap.setOutput("AllChDigiHitMap");
+       add(cdigiHitMap);
+
+//  Convert to hit collection for display
+       HitMapToHitListDriver ctestlist = new HitMapToHitListDriver();
+       ctestlist.setInputHitMap("AllChDigiHitMap");
+       ctestlist.setOutputList("AllChDigiHits");
+       add(ctestlist);
+
+//  make some maps linking cellID to CalHits for each collection (facillitates cluster
+//  linking later)
+       IDHitMapDriver semidmap = new IDHitMapDriver();
+       String[] semidnames = {"Edep_EcalBarrDigiHits","Edep_EcalEndcapDigiHits"};
+       String semidoutmap = "ScEMIDMap";
+       semidmap.setInHitnames(semidnames);
+       semidmap.setOutMapname(semidoutmap);
+       add(semidmap);
+
+       IDHitMapDriver cemidmap = new IDHitMapDriver();
+       String[] cemidnames = {"Ceren_EcalBarrDigiHits","Ceren_EcalEndcapDigiHits"};
+       String cemidoutmap = "ChEMIDMap";
+       cemidmap.setInHitnames(cemidnames);
+       cemidmap.setOutMapname(cemidoutmap);
+       add(cemidmap);
+
+       IDHitMapDriver shadidmap = new IDHitMapDriver();
+       String[] shadidnames = {"Edep_HcalBarrDigiHits","Edep_HcalEndcapDigiHits"};
+       String shadidoutmap = "ScHADIDMap";
+       shadidmap.setInHitnames(shadidnames);
+       shadidmap.setOutMapname(shadidoutmap);
+       add(shadidmap);
+
+       IDHitMapDriver chadidmap = new IDHitMapDriver();
+       String[] chadidnames = {"Ceren_HcalBarrDigiHits","Ceren_HcalEndcapDigiHits"};
+       String chadidoutmap = "ChHADIDMap";
+       chadidmap.setInHitnames(chadidnames);
+       chadidmap.setOutMapname(chadidoutmap);
+       add(chadidmap);
+
+       //  try to make one map for all cerenkov hits
+       IDHitMapDriver cidmap = new IDHitMapDriver();
+       String[] cidnames = {"Ceren_EcalBarrDigiHits","Ceren_EcalEndcapDigiHits","Ceren_HcalBarrDigiHits","Ceren_HcalEndcapDigiHits"};
+       String cidoutmap = "ChIDMap";
+       cidmap.setInHitnames(cidnames);
+       cidmap.setOutMapname(cidoutmap);
+       add(cidmap);
+
+//  Try using my copy of CheatReconDriver - only had to change definition of DigiSim input
+       MyCheatReconDriver mycheater = new MyCheatReconDriver();
+       String CheatReconRname = "MyCheatPerfectReconParticles";
+       String CheatReconFSname = "ReconFSParticles";
+       mycheater.setCheatReconstructedParticleOutputName(CheatReconRname);
+       mycheater.setCheatFSParticleOutputName(CheatReconFSname);
+       add(mycheater);
+
+//  Make a list of MCParticles to be considered - this gets final states from generator
+//  eventually replace with Perfect DR objects for each simulated detector
+//       CreateFinalStateMCParticleList gcfs = new CreateFinalStateMCParticleList("Gen");
+//       String gfname = ("MCGenFSParticles");
+//       gcfs.setCollectionName(gfname);
+//       add(gcfs);
+
+//       CreateFinalStateMCParticleList scfs = new CreateFinalStateMCParticleList("Sim");
+//       String sfname = ("MCSimFSParticles");
+//       scfs.setCollectionName(sfname);
+//       add(scfs);
+
+       //  get perfect tracks
+//       String tempTname = "TempCheatTracks";
+//       String tempPname = "TempCheatParticles";
+//       add(new CheatTrackDriver(tempTname, tempPname));
+
+//       String tracklist = ("PerfectTracks");
+       String tracklist = ("ReconTracks");
+//       MCFastTracking mcft = new MCFastTracking();
+//       mcft.setFSList(tempPname);
+//       mcft.setFSList(gfname);
+//       mcft.setOutputList(tracklist);
+//       add(mcft);
+
+//  check MC for qqbar M and E and make MC Particle jets if generated this way
+//  make the perfect DR objects into perfect ReconstructedParticles
+//  Also calculates deltaM from true MC tracks
+//       MCqqbarME mcme = new MCqqbarME();
+//       String mcrpname = ("MCFSRecoParticles");
+//       mcme.setMCParticleName(gfname);
+//       mcme.setMCRecoParticleName(mcrpname);
+//       add(mcme);
+
+//  this gets MC info for cheated tracks using LCRelation
+       MCTrPropertyDriver mtprop = new MCTrPropertyDriver();
+       String mtrelation = ("TracksToMCP");
+       mtprop.setTrackName(tracklist);
+       mtprop.setTrMCRelationName(mtrelation);
+       add(mtprop);
+
+//  make a track to RP routine so jet finding can be done with tracks only
+       TrackToRPDriver trpdriver = new TrackToRPDriver();
+       trpdriver.setInputTrackList(tracklist);
+       trpdriver.setTrRPName("TrackRecoParticles");
+       add(trpdriver);
+
+//  for single particles, can check energy sums of all hits to compare with that
+//  from clusters
+       double scal = 1.0042;
+       double ccal = 7692.3;
+//  Poly fit results for CCAL02, 1/50 mip thresholds, 100 ns timing
+//                                My p3     p1     p2   Hans p3
+       double csp1 = 0.506;  //    .506     .315   .677   .524
+       double csp2 = 0.608;  //    .608     .684  -.439   .380
+       double csp3 = -1.050;  // -1.050    0.000   .762  -.605
+       double csp4 = 0.935;  //    .935    0.000  0.000   .665
+       String[] schnames = {"Edep_EcalBarrDigiHits","Edep_EcalEndcapDigiHits","Edep_HcalBarrDigiHits","Edep_HcalEndcapDigiHits"};
+       String[] chhnames = {"Ceren_EcalBarrDigiHits","Ceren_EcalEndcapDigiHits","Ceren_HcalBarrDigiHits","Ceren_HcalEndcapDigiHits"};       
+       CorrScHitDriver cshdriver = new CorrScHitDriver(scal, ccal, csp1, csp2, csp3, csp4);
+       cshdriver.setInputScHitNames(schnames);
+       cshdriver.setInputChHitNames(chhnames);
+       add(cshdriver);
+
+//  UTILITY Algorithm - Track Extrapolation routine 
+//  Input     Track list
+//  Output    Track/Spacepoint map linking track to its extrapolated coordinate at layer 0 of ECAL
+//            Track/Spacepoint map linking track to its extrapolated coordinate at layer 0 of HCAL
+//            Track/Spacepoint map linking track to its extrapolated coordinate at users choice
+       int layer = 1;  //  for BGO, shower max is beginning of layer 1 (for CCAL02, 25 layers 0-24)
+       String tre0name = ("TrackXE0Map");  //  map for extrapolation layer 0 of ECAL
+       String trshmname = ("TrackXShMaxMap");  //  map for extrapolation to shower max or other using argument
+       String trh0name = ("TrackXH0Map");  //  map for extrapolation to layer 0 of HCAL
+       TrkXPosDriver txpdriver = new TrkXPosDriver(layer);
+       txpdriver.setInputTrackList(tracklist);
+       txpdriver.setTrackECAL0Map(tre0name);
+       txpdriver.setTrackShMaxMap(trshmname);
+       txpdriver.setTrackHCAL0Map(trh0name);
+       add(txpdriver);
+
+//  PFA MIP FINDER - first algorithm for charged particle track shower association
+//  get mip hits - use cerenkov light to find mip trace and interaction point
+//  this calorimeter has large visible back-scattering since no non-active absorber
+//  interaction layer is embedded in the shower and found by directional light going
+//  forward - back-scattered particles may be too slow to emit cerenkov light anyway?
+//  Input     CalorimeterHits after digitization (DigiSim)
+//  Output    Mip Cluster for a track
+//            Track/Mip Cluster map linking track to its mip cluster
+//            Track/Interaction Spacepoint map linking track to coordinate of first shower interaction
+//            modified hit maps (make names inputs here)
+       double dminE = 0.052;  // 0.052 is 21 cell window (5x5 without 4 corners)
+       double dminH = 2*dminE;
+       double dminTrC = 0.033;  // .033 gets 1 cell distance in both EM and HAD
+       double mincd = 2.75;  // min density to make mip (def 3.5)
+       TrMipDriver TMdriver = new TrMipDriver(dminE, dminH, dminTrC, mincd);
+       String[] tmcollnames = {"Ceren_EcalBarrDigiHits","Ceren_HcalBarrDigiHits","Ceren_EcalEndcapDigiHits","Ceren_HcalEndcapDigiHits"};
+       String MipClusList = "TMClusters";
+       String tmmapname = "TrackMipClusMap";  // map of track mip cluster match
+       String tilmapname = "TrackILPosMap";  //  map of track interaction spacepoint
+       TMdriver.setCollectionNames(tmcollnames);
+       TMdriver.setMipClusterListName(MipClusList);
+       TMdriver.setTrackMipClusMap(tmmapname);
+       TMdriver.setTrackILPosMap(tilmapname);
+       TMdriver.setInputTrackList(tracklist);
+       add(TMdriver);
+
+//  Diagnostic routine checks results from mip finder
+       TrMipClusDiagDriver tmcdriver = new TrMipClusDiagDriver();
+       tmcdriver.setTrMipClusName(MipClusList);
+       add(tmcdriver);
+
+//  make modified Ceren hit collections from hitmaps modified by mip finder
+       HitMapToHitListDriver eblist = new HitMapToHitListDriver();
+       eblist.setInputHitMap("ChEBarrhitmap");
+       eblist.setOutputList("ChEBHits");
+       add(eblist);
+       HitMapToHitListDriver eeclist = new HitMapToHitListDriver();
+       eeclist.setInputHitMap("ChEEndcaphitmap");
+       eeclist.setOutputList("ChEECHits");
+       add(eeclist);
+       HitMapToHitListDriver hblist = new HitMapToHitListDriver();
+       hblist.setInputHitMap("ChHBarrhitmap");
+       hblist.setOutputList("ChHBHits");
+       add(hblist);
+       HitMapToHitListDriver heclist = new HitMapToHitListDriver();
+       heclist.setInputHitMap("ChHEndcaphitmap");
+       heclist.setOutputList("ChHECHits");
+       add(heclist);
+
+//  make modified Scin hit collections from hitmaps modified by mip finder
+       HitMapToHitListDriver seblist = new HitMapToHitListDriver();
+       seblist.setInputHitMap("ScEBarrhitmap");
+       seblist.setOutputList("ScEBHits");
+       add(seblist);
+       HitMapToHitListDriver seeclist = new HitMapToHitListDriver();
+       seeclist.setInputHitMap("ScEEndcaphitmap");
+       seeclist.setOutputList("ScEECHits");
+       add(seeclist);
+       HitMapToHitListDriver shblist = new HitMapToHitListDriver();
+       shblist.setInputHitMap("ScHBarrhitmap");
+       shblist.setOutputList("ScHBHits");
+       add(shblist);
+       HitMapToHitListDriver sheclist = new HitMapToHitListDriver();
+       sheclist.setInputHitMap("ScHEndcaphitmap");
+       sheclist.setOutputList("ScHECHits");
+       add(sheclist);
+
+//  CLUSTER Algorithms - after mip finding on cells, cluster remaining cells in both
+//  cerenkov and scintillator collections
+//  NN Arguments  dU neighbor distance in layer U-axis, dV neighbor distance in layer V-axis,
+//                dLayer neighbor layer distance, ncells min number of hits per cluster greater
+//                than this (integer) number, thresh min raw energy threshold to keep cluster
+//                Example 1 1 1 3 means adjacent cells in each direction with a minimum of 4
+//                hits per cluster (min number needed to define principal axes of cluster)
+//  Output        Cluster lists named by input hits with defined extension
+//  Cluster Cerenkov and Scintillator hits separately
+       int sedU = 1;
+       int sedV = 1;
+       int sedLayer = 1;
+       int sencells = 3;  // for NN, 3 means number of hits at least 4 in cluster
+       double sethresh = 0.001;
+       NearestNeighborClusterDriver NNSedriver = new NearestNeighborClusterDriver(sedU, sedV, sedLayer, sencells, sethresh);
+//       String[] snhhitecollnames = {"Edep_EcalBarrDigiHits","Edep_EcalEndcapDigiHits"};
+       String[] snhhitecollnames = {"ScEBHits","ScEECHits"};
+       NNSedriver.setCollectionNames(snhhitecollnames);
+       NNSedriver.setClusterNameExtension("NNSClus");
+       add(NNSedriver);
+
+       int shdU = 1;
+       int shdV = 1;
+       int shdLayer = 1;
+       int shncells = 3;  // for NN, 3 means number of hits at least 4 in cluster
+       double shthresh = 0.001;
+       NearestNeighborClusterDriver NNShdriver = new NearestNeighborClusterDriver(shdU, shdV, shdLayer, shncells, shthresh);
+//       String[] snhhithcollnames = {"Edep_HcalBarrDigiHits","Edep_HcalEndcapDigiHits"};
+       String[] snhhithcollnames = {"ScHBHits","ScHECHits"};
+       NNShdriver.setCollectionNames(snhhithcollnames);
+       NNShdriver.setClusterNameExtension("NNSClus");
+       add(NNShdriver);
+       
+//  combine scintillator clusters into a single cluster list
+//       String[] inList = {"Edep_EcalBarrDigiHitsNNSClus","Edep_HcalBarrDigiHitsNNSClus","Edep_EcalEndcapDigiHitsNNSClus","Edep_HcalEndcapDigiHitsNNSClus"};
+       String[] inList = {"ScEBHitsNNSClus","ScHBHitsNNSClus","ScEECHitsNNSClus","ScHECHitsNNSClus"};
+       String outList = "AllNNSClus";
+       CombineClLists ccldriver = new CombineClLists(inList,outList);
+       add(ccldriver);
+
+//  C/S POLYNOMIAL ENERGY CORRECTION on scintillator clusters
+//  Correct scintillator clusters with C/S ratio using map linking C hits to S hits
+//  Inputs - scintillator calibration factor, cerenkov calib factor, scintillator cluster
+//           correction factor, cerenkov cluster correction factor, polynomial values from
+//           fit (pa1-pa4)
+       double scalib = 1.0042;  //  electron energy calibration factor for scintillator (scalib*raw energy)
+       double ccalib = 7692.3;  //  electron energy calibration factor for cerenkov  (ccalib*raw energy)
+       double scclus = 1.00;  //  correction factor for cluster algorithm on scintillator (scclus*raw energy)
+       double chclus = 1.00;  //  correction factor for cluster algorithm on cerenkov (cclus*raw energy)
+//  Poly fit results for CCAL02, 1/50 mip thresholds, 100 ns timing
+//                                My p3     p1     p2   Hans p3
+       double pa1 = 0.506;  //    .506     .315   .677   .524
+       double pa2 = 0.608;  //    .608     .684  -.439   .380
+       double pa3 = -1.050;  // -1.050    0.000   .762  -.605
+       double pa4 = 0.935;  //    .935    0.000  0.000   .665
+       CorrScClusDriver csdriver = new CorrScClusDriver(scalib, ccalib, pa1, pa2, pa3, pa4, scclus, chclus);
+       String CorrclusName = ("CorrNNSClus");
+       csdriver.setInputClusterNames("AllNNSClus");
+       csdriver.setOutputClusterNames(CorrclusName);
+       csdriver.setCHIDMapName(cidoutmap);
+       add(csdriver);
+
+//  Get Esum for all clusters for this particle
+       CorrClusEsumDriver ccedriver = new CorrClusEsumDriver();
+       ccedriver.setInputClusName(CorrclusName);
+//       ccedriver.setInputClusName("AllNNSClus");
+       add(ccedriver);
+
+//  PFA CORE CLUSTER FINDER - get clusters on track extrapolation first
+//  This algorithm associates clusters to extrapolated tracks using the same distance
+//  parameter as the mip finder, but compared to clusters, not hits.  A modified cluster
+//  list is returned with the core clusters removed since these clusters have very high
+//  purity.
+       double maxcor = 0.033;  //  same distance parameter as in mip finder
+       String CoreclusName = ("TCClusters");  //  name of found Core Cluster list
+       String ModclusName = ("ModCorrClusters");  //  name of modified input cluster list
+       String tcmapname = ("TrCoreClusMap");  //  map linking core clusters to track
+       TrCoreDriver TCdriver = new TrCoreDriver(maxcor);
+       TCdriver.setInputTrackList(tracklist);
+       TCdriver.setInputClusterList(CorrclusName);
+       TCdriver.setModClusterList(ModclusName);
+       TCdriver.setOutCoreClusterList(CoreclusName);
+       TCdriver.setTrackILPosMap(tilmapname);  // can use IL pos if mip finder done, or use other track xtrap maps
+       TCdriver.setTrackCoreClusMap(tcmapname);
+       add(TCdriver);
+
+//  Diagnostic routine checks results from core cluster finder
+       TrCoreClusDiagDriver tccdriver = new TrCoreClusDiagDriver();
+       tccdriver.setTrCoreClusName(CoreclusName);
+       add(tccdriver);
+
+//  PFA CLUSTER POINTING ALGORITHM - find clusters pointed at interaction spacepoint of shower
+//  Cluster Pointing algorithm here - requires mip finding first (or other extrapolated track link)
+//  ILSP clusters are good candidates for track association, IP clusters usually photons,
+//  NP clusters don't point, probably fragments of hadrons, so need to separate charged particle
+//  fragments from neutrals using some other measure
+       double mdisip = 0.10;  // for ippho .2 gets most photons but may be too large for DR?
+       double mdisil = 0.033;  // for ilsp points to within same distance as cores, mips
+       double mdiscl = 0.099; // for npil in trackshower routine, 3 iterations of .033 is 0.099
+       ClPointDriver clpdriver = new ClPointDriver(mdisip,mdisil,mdiscl);
+       clpdriver.setInputClusterList(ModclusName);
+//       clpdriver.setInputClusterList(CorrclusName);
+       String[] clpnames = {"ILSPClusters","IPClusters","NPClusters"};
+       String[] subipnames = {"IPTrackClusters","IPPhoClusters","IPNeuClusters"};
+       String[] subnpnames = {"NPILClusters","NPAClusters"};
+       String tilspname = ("TrackILSPClusMap");
+       String tiptname = ("TrackIPTrackClusMap");
+       clpdriver.setOutPointClusterLists(clpnames);
+       clpdriver.setSubIPClusterLists(subipnames);
+       clpdriver.setSubNPClusterLists(subnpnames);
+       clpdriver.setTrackILPosMap(tilmapname);
+       clpdriver.setTrILSPMap(tilspname);
+       clpdriver.setTrIPTMap(tiptname);
+       add(clpdriver);
+
+       //  remove ILSP clusters from list of clusters - they are associated with tracks
+//       ClusterListToHitMapDriver ilspdriver = new ClusterListToHitMapDriver();
+//       ilspdriver.addInputList("ILSPClusters");
+//       ilspdriver.setOutputHitMap("ILSPHitMap");
+//       add(ilspdriver);
+//       HitMapSubtractDriver ilspsubdriver = new HitMapSubtractDriver();
+//       ilspsubdriver.setFirstHitMap(allem);
+//       ilspsubdriver.setSecondHitMap("ILSPHitMap");
+//       ilspsubdriver.setOutputHitMap(allem);
+//       add(ilspsubdriver);
+
+       //  remove IPPhoClusters also
+//       ClusterListToHitMapDriver ippdriver = new ClusterListToHitMapDriver();
+//       ippdriver.addInputList("IPPhoClusters");
+//       ippdriver.setOutputHitMap("IPPHitMap");
+//       add(ippdriver);
+//       HitMapSubtractDriver ipsubdriver = new HitMapSubtractDriver();
+//       ipsubdriver.setFirstHitMap(allem);
+//       ipsubdriver.setSecondHitMap("IPPHitMap");
+//       ipsubdriver.setOutputHitMap(allem);
+//       add(ipsubdriver);
+
+//  combine cluster lists of remaining clusters to check for track match
+       String[] incList = {"IPNeuClusters","NPClusters"};
+       String outcList = "RevModCorrClus";
+       CombineClLists comdriver = new CombineClLists(incList,outcList);
+       add(comdriver);
+
+//  TRACK CAL ASSOCIATION ALGORITHM - associates clusters to track using E/p and
+//  previous evaluations
+       String trshclus = "TrackCALClusters";  // includes mips, cores, ILSPs, and showers
+       String trccmapname = "TrackCalClusMap";  //  map linking tracks to clusters if found
+       double minsep = 0.033; // starts at distance parameter for cores, mips and iterates
+       int nloop = 5;  // default 5
+       double cres = 0.20;  // cal res stoch factor 0.7 for rpc, 0.5 for scint, 0.2 for crystal
+       double mintp = 2.0;  // 1 GeV is default (means min eop for rpc is 0.3)
+       TrShowerDriver TrShdriver = new TrShowerDriver(minsep, nloop, cres, mintp);
+       TrShdriver.setInputClusterList(outcList);
+       TrShdriver.setOutputClusterList(trshclus);
+       TrShdriver.setTrackMipClusMap(tmmapname);
+       TrShdriver.setTrackILPosMap(tilmapname);
+       TrShdriver.setTrackCoreClusMap(tcmapname);
+       TrShdriver.setTrackILSPClusMap(tilspname);
+       TrShdriver.setTrackIPTrClusMap(tiptname);
+       TrShdriver.setTrackCalClusMap(trccmapname);
+       add(TrShdriver);
+
+//  check clusters found for tracks
+//       TrShCompDriver tscdriver = new TrShCompDriver();
+//       tscdriver.setTrMipClusName("TMClusters");
+//       tscdriver.setTrCoreClusName("TCClusters");
+//       tscdriver.setTrPointClusName("ILSPClusters");
+//       tscdriver.setTrShowerClusName("TrackShowerClusters");
+//       tscdriver.setTrCalClusMap("TrackCalClusMap");
+//       add(tscdriver);
+
+   }
+}