lcsim-contrib/src/main/java/org/lcsim/contrib/SteveMagill
diff -N PFACSClusdMJetDriver.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ PFACSClusdMJetDriver.java 14 Feb 2012 17:55:06 -0000 1.1
@@ -0,0 +1,644 @@
+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.recon.cluster.nn.*;
+
+public class PFACSClusdMJetDriver extends Driver
+{
+
+ public PFACSClusdMJetDriver()
+ {
+
+// use DIGISIM - makes threshold and timing cuts from steering file CCAL001.steer
+ 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);
+
+// try mst clusterer here to see if it crosses detector boundaries
+// double mstthr = 90.;
+// MSTClusterDriver mstclus = new MSTClusterDriver();
+// mstclus.addInputHitMap("AllScDigiHitMap");
+// mstclus.setThreshold(mstthr);
+// mstclus.setClusterName("MSTClusters");
+// add(mstclus);
+
+// 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 = ("aMCGenFSParticles");
+// gcfs.setCollectionName(gfname);
+// add(gcfs);
+
+// CreateFinalStateMCParticleList scfs = new CreateFinalStateMCParticleList("Sim");
+// String sfname = ("aMCSimFSParticles");
+// scfs.setCollectionName(sfname);
+// add(scfs);
+
+ // get perfect tracks
+// String tempTname = "aTempCheatTracks";
+// String tempPname = "aTempCheatParticles";
+// 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 = ("ReconTracksToMCP");
+ 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("AllTrackRecoParticles");
+ add(trpdriver);
+
+// UTILITY Algorithm - Track Extrapolation routine, gets positions of charged particles
+// 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 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);
+
+// Don't need to cluster cerenkov hits for this application - will use the subset of hits
+// in the Cerenkov collection that are also in the Sintillator clusters
+// To use independent Cerenkov clusters to correct Scintillator clusters, need a cluster
+// link algorithm that links Scintillator and Cerenkov clusters
+// Cluster cherenkov hits with Nearest Neighbor clusterer, 1113 is default
+// not really needed since using maps linking SC and CH hits
+// int cedU = 1;
+// int cedV = 1;
+// int cedLayer = 1;
+// int cencells = 3; // for NN, 3 means number of hits at least 4 in cluster
+// double cethresh = 0.000001;
+// NearestNeighborClusterDriver NNCedriver = new NearestNeighborClusterDriver(cedU, cedV, cedLayer, cencells, cethresh);
+// String[] cnhhitcollnames = {"Ceren_EcalBarrDigiHits","Ceren_EcalEndcapDigiHits"};
+// String[] cnhhitecollnames = {"ChEBHits","ChEECHits"};
+// NNCedriver.setCollectionNames(cnhhitecollnames);
+// NNCedriver.setClusterNameExtension("NNCClus");
+// add(NNCedriver);
+
+// int chdU = 1;
+// int chdV = 1;
+// int chdLayer = 1;
+// int chncells = 3; // for NN, 3 means number of hits at least 4 in cluster
+// double chthresh = 0.000001;
+// NearestNeighborClusterDriver NNChdriver = new NearestNeighborClusterDriver(chdU, chdV, chdLayer, chncells, chthresh);
+// String[] cnhhitcollnames = {"Ceren_HcalBarrDigiHits","Ceren_HcalEndcapDigiHits"};
+// String[] cnhhithcollnames = {"ChHBHits","ChHECHits"};
+// NNChdriver.setCollectionNames(cnhhithcollnames);
+// NNChdriver.setClusterNameExtension("NNCClus");
+// add(NNChdriver);
+
+// combine cerenkov clusters into a single cluster list
+// String[] incList = {"ChEBHitsNNCClus","ChHBHitsNNCClus","ChEECHitsNNCClus","ChHECHitsNNCClus"};
+// String outcList = "AllNNCClus";
+// CombineClLists cclcdriver = new CombineClLists(incList,outcList);
+// add(cclcdriver);
+
+// 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)
+// following are not very useful - the correction for electron and photon scintillator clusters
+// is negligible (1.00), and only hadron clusters need corrections
+ 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);
+
+// make clusters into reconstructed particles for input to jet algorithm
+// at this point, this includes all clusters with at least 4 hits, not including any
+// mip clusters that might have been formed with 4 or more hits - can improve this by
+// performing this step after track cal cluster association which would then combine
+// mip clusters, core clusters, etc into TrackCALClusters
+ int minhits = 4;
+ double minE = 0.0;
+ ClusterToRPDriver clrpdriver = new ClusterToRPDriver(minhits,minE);
+ String CorrClusRPName = ("CorrClusRecoParticles");
+ clrpdriver.setClusterNames(CorrclusName);
+ clrpdriver.setRecoParticleName(CorrClusRPName);
+ add(clrpdriver);
+
+// 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 (Core clusters removed)
+ 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);
+// if Core clusters found, use modified cluster list to avoid double counting of cores
+ clpdriver.setInputClusterList(ModclusName);
+ 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);
+
+// 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
+// This routine takes as input all clusters and forms final track call cluster matches
+// based on iterative proximity and E/p measures. It starts by including mips, cores,
+// ILSPs, and IPTracks merged with the track to form a candidate cluster, finalized if E/p
+// is OK. Then it tries to link NP and IPNeu clusters by iterating in proximity and E/p.
+ 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 track shower clusters
+ TrShCompDriver tshcd = new TrShCompDriver();
+ tshcd.setTrMipClusName("TMClusters");
+ tshcd.setTrCalClusMap(trccmapname);
+ tshcd.setTrCoreClusName("TCClusters");
+ tshcd.setTrPointClusName("ILSPClusters");
+ tshcd.setTrShowerClusName("TrackCALClusters");
+ add(tshcd);
+
+// combine all remaining clusters into one list
+ String[] infcList = {"IPPhoClusters","ShowerClustersLeft","UnAssocCalClusters"};
+ String outfcList = "FPFACorrClus";
+ CombineClLists fcomdriver = new CombineClLists(infcList,outfcList);
+ add(fcomdriver);
+
+// Make final PFA RPs from final clusters and final tracks
+ int pminhits = 8;
+ double pminE = 0.100;
+ ClusterToRPDriver fclrpdriver = new ClusterToRPDriver(pminhits,pminE);
+ String FClusRPName = "FPFAClusRPs";
+ fclrpdriver.setClusterNames(outfcList);
+ fclrpdriver.setRecoParticleName(FClusRPName);
+ add(fclrpdriver);
+
+ TrackToRPDriver trrpdriver = new TrackToRPDriver();
+ String FTrackRPName = "FPFATrackRPs";
+ trrpdriver.setInputTrackList("TrCalTracks");
+ trrpdriver.setTrRPName(FTrackRPName);
+ add(trrpdriver);
+
+// Combine into single RP list
+ String[] inrpList = {"FPFAClusRPs","FPFATrackRPs"};
+ String outrpList = "CSPFARecoParticles";
+ CombineRPLists rpcomdriver = new CombineRPLists(inrpList,outrpList);
+ add(rpcomdriver);
+
+ // try to merge em and had clusters for scintillator signal in barrel
+// double distee = 0.075;
+// double disthh = 0.075;
+// double disteh = 0.075;
+// int nhmerg = 10;
+// ClMergeDriver emhdriver = new ClMergeDriver(distee,disthh,disteh,nhmerg);
+// String emname = ("Edep_EcalBarrDigiHitsNNSClus");
+// String hadname = ("Edep_HcalBarrDigiHitsNNSClus");
+// String mergname = ("MergedEHSBClus");
+// emhdriver.setInputEMClusterName(emname);
+// emhdriver.setInputHADClusterName(hadname);
+// emhdriver.setOutputClusterName(mergname);
+// add(emhdriver);
+
+ // try to merge em and had clusters for scintillator signal in endcap
+// double distee = 0.075;
+// double disthh = 0.075;
+// double disteh = 0.075;
+// int nhmerg = 10;
+// ClMergeDriver emhecdriver = new ClMergeDriver(distee,disthh,disteh,nhmerg);
+// String emecname = ("Edep_EcalEndcapDigiHitsNNSClus");
+// String hadecname = ("Edep_HcalEndcapDigiHitsNNSClus");
+// String mergecname = ("MergedEHSECClus");
+// emhecdriver.setInputEMClusterName(emecname);
+// emhecdriver.setInputHADClusterName(hadecname);
+// emhecdriver.setOutputClusterName(mergecname);
+// add(emhecdriver);
+
+ // try to merge em and had clusters for cherenkov signal in barrel
+// double cdistee = 0.075;
+// double cdisthh = 0.075;
+// double cdisteh = 0.075;
+// int cnhmerg = 5;
+// ClMergeDriver cemhdriver = new ClMergeDriver(cdistee,cdisthh,cdisteh,cnhmerg);
+// String cemname = ("ChEBHitsNNCClus");
+// String chadname = ("ChHBHitsNNCClus");
+// String cmergname = ("MergedEHChBClus");
+// cemhdriver.setInputEMClusterName(cemname);
+// cemhdriver.setInputHADClusterName(chadname);
+// cemhdriver.setOutputClusterName(cmergname);
+// add(cemhdriver);
+
+ // try to merge em and had clusters for cherenkov signal in endcap
+// double cdistee = 0.075;
+// double cdisthh = 0.075;
+// double cdisteh = 0.075;
+// int cnhmerg = 5;
+// ClMergeDriver cemhecdriver = new ClMergeDriver(cdistee,cdisthh,cdisteh,cnhmerg);
+// String cemecname = ("ChEECHitsNNCClus");
+// String chadecname = ("ChHECHitsNNCClus");
+// String cmergecname = ("MergedEHChECClus");
+// cemhecdriver.setInputEMClusterName(cemecname);
+// cemhecdriver.setInputHADClusterName(chadecname);
+// cemhecdriver.setOutputClusterName(cmergecname);
+// add(cemhecdriver);
+
+// now link scintillator and cherenkov had clusters by map
+// double ldist = 0.05;
+// SChClLinkDriver linkdriver = new SChClLinkDriver(ldist);
+// String linkmap = ("SChHClusMap");
+// linkdriver.setInputScinClusterName("AllNNSClus");
+// linkdriver.setInputCherClusterName("AllNNCClus");
+// linkdriver.setOutputLinkMapName(linkmap);
+// add(linkdriver);
+
+// link these jets with track jets
+// double ctdist = 0.7;
+// STrJetLinkDriver cstdriver = new STrJetLinkDriver(ctdist);
+// String cstlinkmap = ("CSTrJetMap");
+// cstdriver.setInputScinJetName("CorrRPJets");
+// cstdriver.setInputTrackJetName("TrRPJets");
+// cstdriver.setOutputLinkMapName(cstlinkmap);
+// add(cstdriver);
+
+// calculate (di)jet mass with these jets
+// CorrRPdijetm codjm = new CorrRPdijetm();
+// codjm.setInputScinJets("CorrRPJets");
+// codjm.setSTJetMap(cstlinkmap);
+// codjm.setTJetDMMap("TJetDMMap");
+// add(codjm);
+
+// find jets with MC Reco Particles
+// JetDriver mcjet = new JetDriver();
+// mcjet.setInputCollectionName(mcrpname);
+// mcjet.setOutputCollectionName("MCRPJets");
+// JetFinder tworealjets = new FixNumberOfJetsFinder(2); // uses Jade by default
+// mcjet.setFinder(tworealjets);
+// DurhamJetFinder ktjet = new DurhamJetFinder(0.02);
+// JetFinder twoktjets = new FixNumberOfJetsFinder(2,ktjet);
+// mcjet.setFinder(twoktjets);
+// JetFinder sixrealjets = new FixNumberOfJetsFinder(6);
+// PFAjet.setFinder(sixrealjets);
+ // for Durham jet, ycut = 0.25 at ZPole, 0.01 at 500 GeV ZZ
+// JetFinder rktjet = new DurhamJetFinder(0.1025);
+// mcjet.setFinder(rktjet);
+// add(mcjet);
+
+ // now link scintillator and cherenkov jets by map
+// double jdist = 0.7;
+// SChJetLinkDriver jlinkdriver = new SChJetLinkDriver(jdist);
+// String jlinkmap = ("SChJetMap");
+// jlinkdriver.setInputScinJetName("SClusRPJets");
+// jlinkdriver.setInputCherJetName("CClusRPJets");
+// jlinkdriver.setOutputLinkMapName(jlinkmap);
+// add(jlinkdriver);
+
+// link scin jets and track jets
+// double ctdist = 0.7;
+// STrJetLinkDriver cstdriver = new STrJetLinkDriver(ctdist);
+// String cstlinkmap = ("STrJetMap");
+// cstdriver.setInputScinJetName("SClusRPJets");
+// cstdriver.setInputTrackJetName("TrRPJets");
+// cstdriver.setOutputLinkMapName(cstlinkmap);
+// add(cstdriver);
+
+// calculate (di)jet mass with these jets
+// CorrRPdijetm codjm = new CorrRPdijetm();
+// codjm.setInputScinJets("SClusRPJets");
+// codjm.setSTJetMap(cstlinkmap);
+// codjm.setTJetDMMap("TJetDMMap");
+// add(codjm);
+
+ // link track jets and scintillator jets by map
+// STrJetLinkDriver tlinkdriver = new STrJetLinkDriver(jdist);
+// String tlinkmap = ("STrJetMap");
+// tlinkdriver.setInputScinJetName("SClusRPJets");
+// tlinkdriver.setInputTrackJetName("TrRPJets");
+// tlinkdriver.setOutputLinkMapName(tlinkmap);
+// add(tlinkdriver);
+
+// MCRPdijetm djm = new MCRPdijetm();
+// djm.setInputJets("MCRPJets");
+// add(djm);
+
+// SRPdijetm sdjm = new SRPdijetm();
+// sdjm.setInputScChJetMap(jlinkmap);
+// sdjm.setInputScinJets("SClusRPJets");
+// sdjm.setDeltaMCorr("TrDelM");
+// add(sdjm);
+
+ }
+}