lcsim-contrib/src/main/java/org/lcsim/contrib/SteveMagill
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);
+
+ }
+}