Commit in lcsim-contrib/src/main/java/org/lcsim/contrib/SteveMagill on MAIN | |||
PFACSClusdMJetDriver.java | +644 | added 1.1 |
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); + + } +}
Use REPLY-ALL to reply to list
To unsubscribe from the LCD-CVS list, click the following link:
https://listserv.slac.stanford.edu/cgi-bin/wa?SUBED1=LCD-CVS&A=1