7 added + 2 modified, total 9 files
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon/Cheat
diff -N UIClCheater.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ UIClCheater.java 4 Nov 2010 15:08:49 -0000 1.1
@@ -0,0 +1,91 @@
+package org.lcsim.contrib.Cassell.recon.Cheat;
+import java.util.*;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.Track;
+import org.lcsim.event.ReconstructedParticle;
+import org.lcsim.util.Driver;
+import org.lcsim.contrib.Cassell.recon.analysis.*;
+import org.lcsim.recon.tracking.cheat.TrackMCParticleDriver;
+
+public class UIClCheater extends Driver
+{
+ String outRecon = "UIClReconParticles";
+ String fsp = "ReconFSParticles";
+ String CheatReconFSTrackedname = "TrackedReconFSParticles";
+ String fstr = "UsedTracks";
+ boolean analogHcal = false;
+ String[] cltypes = {"Mips","Clumps","Blocks","Leftovers","Photons"};
+ int[] ncoll = {9,3,4,3,1};
+ String[][] clcoll;
+ TrackMCParticleDriver tmcpd;
+ public UIClCheater(TrackMCParticleDriver x)
+ {
+ clcoll = new String[cltypes.length][9];
+ clcoll[0][0] = "OldMipsInsideTreesECAL";
+ clcoll[0][1] = "OldMipsInsideTreesHCAL";
+ clcoll[0][2] = "OldMipsInsideTreesMCAL";
+ clcoll[0][3] = "NewMipsInsideTreesECAL";
+ clcoll[0][4] = "NewMipsInsideTreesHCAL";
+ clcoll[0][5] = "NewMipsInsideTreesMCAL";
+ clcoll[0][6] = "PreShowerMipMatchMipClusters";
+ clcoll[0][7] = "PreShowerMipMatchSmallClusters";
+ clcoll[0][8] = "MuonClusters";
+ clcoll[1][0] = "ClumpsInsideTreesECAL";
+ clcoll[1][1] = "ClumpsInsideTreesHCAL";
+ clcoll[1][2] = "ClumpsInsideTreesMCAL";
+ clcoll[2][0] = "BlocksInsideTreesECAL";
+ clcoll[2][1] = "BlocksInsideTreesHCAL";
+ clcoll[2][2] = "BlocksInsideTreesMCAL";
+ clcoll[2][3] = "PreShowerMipMatchBlockClusters";
+ clcoll[3][0] = "LeftoverHitsInsideTreesECAL";
+ clcoll[3][1] = "LeftoverHitsInsideTreesHCAL";
+ clcoll[3][2] = "LeftoverHitsInsideTreesMCAL";
+ clcoll[4][0] = "PreliminaryPhotonClustersForDTree";
+ tmcpd = x;
+ ClReconCheater clrc1 = new ClReconCheater("UIClusters",fsp,fstr,tmcpd,outRecon+"1",analogHcal);
+ clrc1.setMinCalhits(1);
+ add(clrc1);
+ ClReconCheater clrc3 = new ClReconCheater("UIClusters",fsp,fstr,tmcpd,outRecon+"3",analogHcal);
+ clrc3.setMinCalhits(3);
+ add(clrc3);
+ ClReconCheater clrc5 = new ClReconCheater("UIClusters",fsp,fstr,tmcpd,outRecon+"5",analogHcal);
+ clrc5.setMinCalhits(5);
+ add(clrc5);
+ }
+
+ protected void process(EventHeader event)
+ {
+ List<MCParticle> fst = event.get(MCParticle.class,CheatReconFSTrackedname);
+ List<MCParticle> fs = event.get(MCParticle.class,fsp);
+ List<Track> utl = new ArrayList<Track>();
+ for(ReconstructedParticle p:event.get(ReconstructedParticle.class,"ReconstructedParticles"))
+ {
+ if(p.getTracks().size() > 0)
+ {
+ utl.add(p.getTracks().get(0));
+ }
+ }
+ event.put(fstr, utl);
+ Map<Track,Cluster> mutcm = (Map<Track,Cluster>) (event.get("MuonTrackClusterMap"));
+ List<Cluster> mucl = new ArrayList<Cluster>(mutcm.values());
+ event.put("MuonClusters",mucl);
+ ClusterPurityPlots cpp = new ClusterPurityPlots(fs,fst);
+ List<Cluster> allc = new ArrayList<Cluster>();
+ for(int i=0;i<cltypes.length;i++)
+ {
+ List<Cluster> cl = new ArrayList<Cluster>();
+ for(int j=0;j<ncoll[i];j++)
+ {
+ cpp.makePlots(clcoll[i][j], event.get(Cluster.class,clcoll[i][j]));
+ cl.addAll(event.get(Cluster.class,clcoll[i][j]));
+ allc.addAll(event.get(Cluster.class,clcoll[i][j]));
+ }
+ cpp.makePlots(cltypes[i],cl);
+ }
+ event.put("UIClusters", allc);
+ cpp.makePlots("UIClusters", allc);
+ super.process(event);
+ }
+}
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon/Cheat
diff -N MakeCheatReconList.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ MakeCheatReconList.java 4 Nov 2010 15:08:49 -0000 1.1
@@ -0,0 +1,217 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.Cassell.recon.Cheat;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.Track;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.ReconstructedParticle;
+import org.lcsim.event.base.BaseReconstructedParticle;
+import java.util.*;
+import hep.physics.vec.*;
+import org.lcsim.event.ParticleID;
+import org.lcsim.recon.cluster.util.*;
+import org.lcsim.event.util.CheatParticleID;
+import org.lcsim.recon.cluster.nn.NearestNeighborClusterer;
+import org.lcsim.recon.tracking.cheat.TrackMCParticleDriver;
+/**
+ *
+ * @author cassell
+ */
+public class MakeCheatReconList
+{
+ Clusterer clusterer;
+ ClusterEnergyCalculator scalc;
+ ClusterEnergyCalculator calc;
+ double pimass = .1395679;
+ ParticleID pippid;
+ ParticleID pimpid;
+ double mumass = .10566;
+ ParticleID muppid;
+ ParticleID mumpid;
+ double emass = .00051;
+ ParticleID eppid;
+ ParticleID empid;
+ double k0lmass = .497671;
+ ParticleID k0lpid;
+ double photonmass = 0.;
+ ParticleID photonpid;
+ ClusterIDCheater cidc;
+ TrackMCParticleDriver tmcm;
+ TraceOrigin to;
+ public MakeCheatReconList(TrackMCParticleDriver tmcd)
+ {
+ this(tmcd,false);
+ }
+ public MakeCheatReconList(TrackMCParticleDriver tmcd, boolean analog)
+ {
+ clusterer = new NearestNeighborClusterer(4,4,2,0,0.);
+ scalc = new QNeutralHadronClusterEnergyCalculator(analog);
+ calc = new QPhotonClusterEnergyCalculator();
+ cidc = new ClusterIDCheater();
+ pippid = new CheatParticleID(211);
+ pimpid = new CheatParticleID(-211);
+ mumpid = new CheatParticleID(13);
+ muppid = new CheatParticleID(-13);
+ empid = new CheatParticleID(11);
+ eppid = new CheatParticleID(-11);
+ photonpid = new CheatParticleID(22);
+ k0lpid = new CheatParticleID(130);
+ tmcm = tmcd;
+ }
+ public List<ReconstructedParticle> makeList(List<Cluster> cl, List<MCParticle> fs, List<Track> tl)
+ {
+ to = new TraceOrigin(fs);
+ List<ReconstructedParticle> rl = new ArrayList<ReconstructedParticle>();
+ Map<MCParticle,List<Cluster>> mcmap = new HashMap<MCParticle,List<Cluster>>();
+ Map<MCParticle,List<Track>> mtmap = new HashMap<MCParticle,List<Track>>();
+ for(Cluster c:cl)
+ {
+ MCParticle p = findMC(c,fs);
+ if(p != null)
+ {
+ if(mcmap.containsKey(p))mcmap.get(p).add(c);
+ else
+ {
+ List<Cluster> ccl = new ArrayList<Cluster>();
+ ccl.add(c);
+ mcmap.put(p,ccl);
+ }
+ }
+ }
+ List<Track> xtra = new ArrayList<Track>();
+ for(Track t:tl)
+ {
+ MCParticle p = findMC(t,fs);
+ if(p != null)
+ {
+ if(mtmap.containsKey(p))mtmap.get(p).add(t);
+ else
+ {
+ List<Track> ttl = new ArrayList<Track>();
+ ttl.add(t);
+ mtmap.put(p,ttl);
+ }
+ }
+ else xtra.add(t);
+ }
+ for(MCParticle p:fs)
+ {
+ if(mtmap.containsKey(p))
+ {
+ Track t = mtmap.get(p).get(0);
+ if(mtmap.get(p).size() > 1)
+ {
+ for(int i=1;i<mtmap.get(p).size();i++)
+ {
+ xtra.add(mtmap.get(p).get(i));
+ }
+ }
+ ReconstructedParticle rp = makeRPFromTrack(t);
+ rp.addTrack(t);
+ if(mcmap.containsKey(p))
+ {
+ for(Cluster c:mcmap.get(p))
+ {
+ rp.addCluster(c);
+ }
+ }
+ rl.add(rp);
+ }
+ else
+ {
+ if(mcmap.containsKey(p))
+ {
+ if(p.getMass() == 0.)rl.add(makePhotonRPFromClusters(mcmap.get(p)));
+ else rl.add(makeNHRPFromClusters(mcmap.get(p)));
+ }
+ }
+ for(Track t:xtra)
+ {
+ rl.add(makeRPFromTrack(t));
+ }
+ }
+ return rl;
+ }
+ public ReconstructedParticle makeRPFromTrack(Track t)
+ {
+ Hep3Vector mom = new BasicHep3Vector(t.getMomentum());
+ double E = Math.sqrt(mom.magnitudeSquared()+pimass*pimass);
+ BaseReconstructedParticle orp = new BaseReconstructedParticle(E,mom);
+ orp.setMass(pimass);
+ orp.setCharge(t.getCharge());
+ ParticleID id = pippid;
+ if(t.getCharge() < 0.)id = pimpid;
+ orp.setReferencePoint(new BasicHep3Vector((t.getReferencePoint())));
+ orp.setParticleIdUsed(id);
+ orp.addParticleID(id);
+ return orp;
+ }
+ public ReconstructedParticle makePhotonRPFromClusters(List<Cluster> cl)
+ {
+ BasicCluster c = new BasicCluster();
+ for(Cluster cc:cl)c.addCluster(cc);
+ double E = calc.getEnergy(c);
+ double M = 0.;
+ List<Cluster> clist = clusterer.createClusters(c.getCalorimeterHits());
+ double[] pos = {0.,0.,0.};
+ int maxhits = 0;
+ for(Cluster ccc:clist)
+ {
+ if(ccc.getCalorimeterHits().size() > maxhits)
+ {
+ pos = ccc.getPosition();
+ maxhits = ccc.getCalorimeterHits().size();
+ }
+ }
+ double norm = Math.sqrt(E*E - M*M)/
+ Math.sqrt(pos[0]*pos[0] + pos[1]*pos[1] + pos[2]*pos[2]);
+ Hep3Vector mom = new BasicHep3Vector(pos[0]*norm, pos[1]*norm, pos[2]*norm);
+ BaseReconstructedParticle nrp = new BaseReconstructedParticle(E,mom);
+ nrp.setMass(M);
+ nrp.setParticleIdUsed(photonpid);
+ nrp.addParticleID(photonpid);
+ nrp.addCluster(c);
+ return nrp;
+ }
+ public ReconstructedParticle makeNHRPFromClusters(List<Cluster> cl)
+ {
+ BasicCluster c = new BasicCluster();
+ for(Cluster cc:cl)c.addCluster(cc);
+ double E = scalc.getEnergy(c);
+ if(E < k0lmass)E = k0lmass;
+ double M = k0lmass;
+ List<Cluster> clist = clusterer.createClusters(c.getCalorimeterHits());
+ double[] pos = {0.,0.,0.};
+ int maxhits = 0;
+ for(Cluster ccc:clist)
+ {
+ if(ccc.getCalorimeterHits().size() > maxhits)
+ {
+ pos = ccc.getPosition();
+ maxhits = ccc.getCalorimeterHits().size();
+ }
+ }
+ double norm = Math.sqrt(E*E - M*M)/
+ Math.sqrt(pos[0]*pos[0] + pos[1]*pos[1] + pos[2]*pos[2]);
+ Hep3Vector mom = new BasicHep3Vector(pos[0]*norm, pos[1]*norm, pos[2]*norm);
+ BaseReconstructedParticle nrp = new BaseReconstructedParticle(E,mom);
+ nrp.setMass(M);
+ nrp.setParticleIdUsed(k0lpid);
+ nrp.addParticleID(k0lpid);
+ nrp.addCluster(c);
+ return nrp;
+
+ }
+ public MCParticle findMC(Cluster c,List<MCParticle> fs)
+ {
+ return cidc.getMCID(fs, c);
+ }
+ public MCParticle findMC(Track t,List<MCParticle> fs)
+ {
+ MCParticle op = tmcm.getMCParticle(t);
+ return to.traceit(op);
+ }
+}
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon/Cheat
diff -N ClReconCheater.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ ClReconCheater.java 4 Nov 2010 15:08:49 -0000 1.1
@@ -0,0 +1,54 @@
+package org.lcsim.contrib.Cassell.recon.Cheat;
+import java.util.*;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.Track;
+import org.lcsim.event.ReconstructedParticle;
+import org.lcsim.util.Driver;
+import org.lcsim.recon.tracking.cheat.TrackMCParticleDriver;
+
+public class ClReconCheater extends Driver
+{
+ String outputReconName;
+ String clusterListName;
+ String fsMCPName;
+ String trackListName;
+ boolean analogHcal;
+ int minCalhits = 5;
+ MakeCheatReconList mcrl;
+ public ClReconCheater(String clname,String fsname,String tlname,TrackMCParticleDriver tmcm,String outname,boolean analog)
+ {
+ outputReconName = outname;
+ clusterListName = clname;
+ fsMCPName = fsname;
+ trackListName = tlname;
+ analogHcal = analog;
+ mcrl = new MakeCheatReconList(tmcm,analog);
+ }
+ public void setMinCalhits(int x){minCalhits = x;}
+ protected void process(EventHeader event)
+ {
+ List<ReconstructedParticle> outl = mcrl.makeList(
+ event.get(Cluster.class,clusterListName),event.get(MCParticle.class,fsMCPName),
+ event.get(Track.class,trackListName));
+ List<ReconstructedParticle> remove = new ArrayList<ReconstructedParticle>();
+ for(ReconstructedParticle p:outl)
+ {
+ if(p.getTracks().size() < 1)
+ {
+ int nchits = 0;
+ for(Cluster c:p.getClusters())
+ {
+ nchits += c.getCalorimeterHits().size();
+ }
+ if(nchits < minCalhits)remove.add(p);
+ }
+ }
+ for(ReconstructedParticle p:remove)
+ {
+ outl.remove(p);
+ }
+ event.put(outputReconName,outl);
+ }
+}
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon/Cheat
diff -N UIClusterLevelCheater.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ UIClusterLevelCheater.java 4 Nov 2010 15:08:49 -0000 1.1
@@ -0,0 +1,296 @@
+package org.lcsim.contrib.Cassell.recon.Cheat;
+import org.lcsim.util.aida.AIDA;
+import java.util.*;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.CalorimeterHit;
+import org.lcsim.event.SimCalorimeterHit;
+import org.lcsim.event.MCParticle;
+import org.lcsim.event.Track;
+import org.lcsim.event.ReconstructedParticle;
+import org.lcsim.event.base.BaseReconstructedParticle;
+import org.lcsim.event.base.MCReconstructedParticle;
+import org.lcsim.util.Driver;
+import org.lcsim.contrib.Cassell.recon.analysis.*;
+import hep.physics.vec.*;
+import org.lcsim.recon.cluster.nn.NearestNeighborClusterer;
+import org.lcsim.recon.cluster.util.*;
+
+public class UIClusterLevelCheater extends Driver
+{
+ private AIDA aida = AIDA.defaultInstance();
+ int ievt;
+ String epre;
+ String hpre;
+ String mpre;
+ String[] EcalCl;
+ String[] HcalCl;
+ String[] McalCl;
+ String inRecon;
+ String outRecon;
+ String fsp;
+ String fstr;
+ ClusterEnergyCalculator scalc;
+ ClusterEnergyCalculator calc;
+ int minCalhits = 5;
+ Clusterer clusterer;
+ Hep3Vector mom;
+ int ncuts = 2;
+ int[] cut = {0,4};
+ Map<MCParticle,List<Cluster>> emap;
+ Map<MCParticle,List<Cluster>> hmap;
+ Map<MCParticle,List<Cluster>> mmap;
+ public UIClusterLevelCheater(String Eprefix,String Hprefix,String Mprefix,
+ String[] ecalcl,String[] hcalcl,String[] mcalcl,
+ String inrecon, String outrecon,String fsmcp,String fsmct)
+ {
+ this(Eprefix,Hprefix,Mprefix,ecalcl,hcalcl,mcalcl,inrecon,outrecon,fsmcp,fsmct,false);
+ }
+ public UIClusterLevelCheater(String Eprefix,String Hprefix,String Mprefix,
+ String[] ecalcl,String[] hcalcl,String[] mcalcl,
+ String inrecon, String outrecon,String fsmcp,String fsmct,boolean analog)
+ {
+ ievt = 0;
+ epre = Eprefix;
+ hpre = Hprefix;
+ mpre = Mprefix;
+ EcalCl = ecalcl;
+ HcalCl = hcalcl;
+ McalCl = mcalcl;
+ inRecon = inrecon;
+ outRecon = outrecon;
+ fsp = fsmcp;
+ fstr = fsmct;
+ scalc = new QPhotonClusterEnergyCalculator();
+ calc = new QNeutralHadronClusterEnergyCalculator(analog);
+ clusterer = new NearestNeighborClusterer(4,4,2,0,0.);
+ }
+ Map<MCParticle,List<Cluster>> getEcalMap(){return emap;}
+ Map<MCParticle,List<Cluster>> getHcalMap(){return hmap;}
+
+ protected void process(EventHeader event)
+ {
+// System.out.println("Entering ClusterLevelCheater.process");
+//
+// Get all the necessary collections from event
+//
+ List<MCParticle> fst = event.get(MCParticle.class,fstr);
+ List<MCParticle> fs = event.get(MCParticle.class,fsp);
+ List<Cluster> ecl = new ArrayList<Cluster>();
+ List<Cluster> hcl = new ArrayList<Cluster>();
+ List<Cluster> mcl = new ArrayList<Cluster>();
+ ClusterPurityPlots cpp = new ClusterPurityPlots(fs,fst);
+ for(int i=0;i<EcalCl.length;i++)
+ {
+ cpp.makePlots(EcalCl[i], event.get(Cluster.class,EcalCl[i]));
+ ecl.addAll(event.get(Cluster.class,EcalCl[i]));
+ }
+ for(int i=0;i<HcalCl.length;i++)
+ {
+ cpp.makePlots(HcalCl[i], event.get(Cluster.class,HcalCl[i]));
+ hcl.addAll(event.get(Cluster.class,HcalCl[i]));
+ }
+ for(int i=0;i<McalCl.length;i++)
+ {
+ cpp.makePlots(McalCl[i], event.get(Cluster.class,McalCl[i]));
+ mcl.addAll(event.get(Cluster.class,McalCl[i]));
+ }
+ List<ReconstructedParticle> inrl = event.get(ReconstructedParticle.class,inRecon);
+ List<ReconstructedParticle>[] outrl = new List[ncuts];
+ for(int i=0;i<ncuts;i++)
+ {
+ outrl[i] = new ArrayList<ReconstructedParticle>();
+ }
+// System.out.println("ClusterLevelCheater: making ClusterPurutyPlots");
+ cpp.makePlots(epre,ecl);
+ emap = cpp.getMap();
+ cpp.makePlots(hpre,hcl);
+ hmap = cpp.getMap();
+ cpp.makePlots(mpre,mcl);
+ mmap = cpp.getMap();
+ for(int i=0;i<ncuts;i++)
+ {
+ for(ReconstructedParticle inrp:inrl)
+ {
+ BaseReconstructedParticle orp;
+ MCParticle p = null;
+ if(inrp.getParticles().size() > 0)
+ {
+ if(inrp.getParticles().get(0) instanceof MCReconstructedParticle)
+ p = ( (MCReconstructedParticle) inrp.getParticles().get(0) ).getMCParticle();
+ else
+ {
+ for(Cluster c:inrp.getClusters())
+ {
+ for(CalorimeterHit h:c.getCalorimeterHits())
+ {
+ if(h instanceof SimCalorimeterHit)
+ {
+ SimCalorimeterHit sh = (SimCalorimeterHit) h;
+ if(sh.getMCParticleCount() == 1)
+ {
+ p = sh.getMCParticle(0);
+ break;
+ }
+ }
+ }
+ if(p != null)break;
+ }
+ }
+ }
+ if(inrp.getCharge() != 0)
+ {
+ orp = new BaseReconstructedParticle(inrp.getEnergy(),inrp.getMomentum());
+ orp.setMass(inrp.getMass());
+ orp.setCharge(inrp.getCharge());
+ orp.setReferencePoint(inrp.getReferencePoint());
+ orp.setParticleIdUsed(inrp.getParticleIDUsed());
+ orp.addParticleID(inrp.getParticleIDUsed());
+ for(Track t:inrp.getTracks()){orp.addTrack(t);}
+ int necl = 0;
+ double maxe = 0.;
+ if(p != null)
+ {
+ if(emap.containsKey(p))
+ {
+ for(Cluster c:emap.get(p))
+ {
+ if(c.getCalorimeterHits().size() > cut[i])
+ {
+ orp.addCluster(c);
+ necl++;
+ if(c.getEnergy() > maxe)maxe = c.getEnergy();
+ }
+ }
+ }
+ aida.profile1D("track/mean # Ecal clusters > "+cut[i]+" hits vs E",100,0.,100.).fill(p.getEnergy(),necl);
+ if(i == 0)aida.profile1D("track/mean max Ecal clusterE vs E",100,0.,100.).fill(p.getEnergy(),maxe);
+ int nhcl = 0;
+ maxe = 0.;
+ if(hmap.containsKey(p))
+ {
+ for(Cluster c:hmap.get(p))
+ {
+ if(c.getCalorimeterHits().size() > i)
+ {
+ orp.addCluster(c);
+ nhcl++;
+ if(c.getEnergy() > maxe)maxe = c.getEnergy();
+ }
+ }
+ }
+ aida.profile1D("track/mean # Hcal clusters > "+cut[i]+" hits vs E",100,0.,100.).fill(p.getEnergy(),nhcl);
+ if(i == 0)aida.profile1D("track/mean max Hcal clusterE vs E",100,0.,100.).fill(p.getEnergy(),maxe);
+ int nmcl = 0;
+ maxe = 0.;
+ if(mmap.containsKey(p))
+ {
+ for(Cluster c:mmap.get(p))
+ {
+ if(c.getCalorimeterHits().size() > i)
+ {
+ orp.addCluster(c);
+ nmcl++;
+ if(c.getEnergy() > maxe)maxe = c.getEnergy();
+ }
+ }
+ }
+ aida.profile1D("track/mean # Mcal clusters > "+cut[i]+" hits vs E",100,0.,100.).fill(p.getEnergy(),nmcl);
+ if(i == 0)aida.profile1D("track/mean max Mcal clusterE vs E",100,0.,100.).fill(p.getEnergy(),maxe);
+ orp.addParticle(inrp.getParticles().get(0));
+ }
+ outrl[i].add(orp);
+ }
+ else if(p != null)
+ {
+ BasicCluster nc = new BasicCluster();
+ double E = 0.;
+ String ntype = "photon/";
+ if(inrp.getMass() != 0.)ntype = "n hadron/";
+ int necl = 0;
+ double maxe = 0.;
+ if(emap.containsKey(p))
+ {
+ for(Cluster c:emap.get(p))
+ {
+ if(c.getCalorimeterHits().size() > cut[i])
+ {
+ nc.addCluster(c);
+ necl++;
+ if(c.getEnergy() > maxe)maxe = c.getEnergy();
+ }
+ }
+ }
+ aida.profile1D(ntype+"mean # Ecal clusters > "+cut[i]+" hits vs E",100,0.,100.).fill(p.getEnergy(),necl);
+ if(i == 0)aida.profile1D(ntype+"mean max Ecal clusterE vs E",100,0.,100.).fill(p.getEnergy(),maxe);
+ int nhcl = 0;
+ maxe = 0.;
+ if(hmap.containsKey(p))
+ {
+ for(Cluster c:hmap.get(p))
+ {
+ if(c.getCalorimeterHits().size() > cut[i])
+ {
+ nc.addCluster(c);
+ nhcl++;
+ if(c.getEnergy() > maxe)maxe = c.getEnergy();
+ }
+ }
+ }
+ aida.profile1D(ntype+"mean # Hcal clusters > "+cut[i]+" hits vs E",100,0.,100.).fill(p.getEnergy(),nhcl);
+ if(i == 0)aida.profile1D(ntype+"mean max Hcal clusterE vs E",100,0.,100.).fill(p.getEnergy(),maxe);
+ int nmcl = 0;
+ maxe = 0.;
+ if(mmap.containsKey(p))
+ {
+ for(Cluster c:mmap.get(p))
+ {
+ if(c.getCalorimeterHits().size() > cut[i])
+ {
+ nc.addCluster(c);
+ nmcl++;
+ if(c.getEnergy() > maxe)maxe = c.getEnergy();
+ }
+ }
+ }
+ aida.profile1D(ntype+"mean # Mcal clusters > "+cut[i]+" hits vs E",100,0.,100.).fill(p.getEnergy(),nmcl);
+ if(i == 0)aida.profile1D(ntype+"mean max Mcal clusterE vs E",100,0.,100.).fill(p.getEnergy(),maxe);
+ if(nc.getCalorimeterHits().size() >= minCalhits)
+ {
+ if(inrp.getMass() == 0.)E = scalc.getEnergy(nc);
+ else E = calc.getEnergy(nc);
+ if(E > inrp.getMass())
+ {
+ List<Cluster> clist = clusterer.createClusters(nc.getCalorimeterHits());
+ double[] pos = {0.,0.,0.};
+ int maxhits = 0;
+ for(Cluster ccc:clist)
+ {
+ if(ccc.getCalorimeterHits().size() > maxhits)
+ {
+ pos = ccc.getPosition();
+ maxhits = ccc.getCalorimeterHits().size();
+ }
+ }
+ double norm = Math.sqrt(E*E - inrp.getMass()*inrp.getMass())/
+ Math.sqrt(pos[0]*pos[0] + pos[1]*pos[1] + pos[2]*pos[2]);
+ mom = new BasicHep3Vector(pos[0]*norm, pos[1]*norm, pos[2]*norm);
+ orp = new BaseReconstructedParticle(E,mom);
+ orp.setMass(inrp.getMass());
+ orp.setCharge(inrp.getCharge());
+ orp.setReferencePoint(inrp.getReferencePoint());
+ orp.setParticleIdUsed(inrp.getParticleIDUsed());
+ orp.addParticleID(inrp.getParticleIDUsed());
+ for(Track t:inrp.getTracks()){orp.addTrack(t);}
+ for(Cluster c:nc.getClusters()){orp.addCluster(c);}
+ outrl[i].add(orp);
+ orp.addParticle(inrp.getParticles().get(0));
+ }
+ }
+ }
+ }
+ event.put(outRecon+"cut"+cut[i],outrl[i]);
+ }
+ ievt++;
+ }
+}
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon
diff -N UICLCFromRecon.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ UICLCFromRecon.java 4 Nov 2010 15:08:49 -0000 1.1
@@ -0,0 +1,70 @@
+package org.lcsim.contrib.Cassell.recon;
+import org.lcsim.contrib.Cassell.recon.Cheat.UIClusterLevelCheater;
+import org.lcsim.contrib.Cassell.recon.analysis.QqbarAnalysisDriver;
+import org.lcsim.util.Driver;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.ReconstructedParticle;
+import java.util.*;
+
+/**
+ *
+ * @author cassell
+ */
+public class UICLCFromRecon extends Driver
+{
+ String PPRPflowRname = "PPRUTReconParticles";
+ String CheatReconFSname = "ReconFSParticles";
+ String CheatReconFSTrackedname = "TrackedReconFSParticles";
+ String[] EClNames = {"EcalMips","EcalClumps","EcalBlocks","EcalLeftovers","Photons"};
+ String[] HClNames = {"HcalMips","HcalClumps","HcalBlocks","HcalLeftovers"};
+ String[] MClNames = {"McalMips","McalClumps","McalBlocks","McalLeftovers"};
+ String ClLevelPFlowRname = "UICheatReconParticles";
+ public UICLCFromRecon()
+ {
+ add(new MakeUsedTrackPPR());
+ add(new UIClusterLevelCheater("EcalClusters","HcalClusters","McalClusters",
+ EClNames,HClNames,MClNames,PPRPflowRname,ClLevelPFlowRname,
+ CheatReconFSname,CheatReconFSTrackedname));
+ }
+ protected void process(EventHeader event)
+ {
+ List<Cluster> eclumps = new ArrayList<Cluster>(event.get(Cluster.class,"ClumpsInsideTreesECAL"));
+ List<Cluster> hclumps = new ArrayList<Cluster>(event.get(Cluster.class,"ClumpsInsideTreesHCAL"));
+ List<Cluster> mclumps = new ArrayList<Cluster>(event.get(Cluster.class,"ClumpsInsideTreesMCAL"));
+ List<Cluster> eblocks = new ArrayList<Cluster>(event.get(Cluster.class,"BlocksInsideTreesECAL"));
+ List<Cluster> hblocks = new ArrayList<Cluster>(event.get(Cluster.class,"BlocksInsideTreesHCAL"));
+ List<Cluster> mblocks = new ArrayList<Cluster>(event.get(Cluster.class,"BlocksInsideTreesMCAL"));
+ List<Cluster> eleft = new ArrayList<Cluster>(event.get(Cluster.class,"LeftoverHitsInsideTreesECAL"));
+ List<Cluster> hleft = new ArrayList<Cluster>(event.get(Cluster.class,"LeftoverHitsInsideTreesHCAL"));
+ List<Cluster> mleft = new ArrayList<Cluster>(event.get(Cluster.class,"LeftoverHitsInsideTreesMCAL"));
+ List<Cluster> emips = new ArrayList<Cluster>(event.get(Cluster.class,"OldMipsInsideTreesECAL"));
+ List<Cluster> hmips = new ArrayList<Cluster>(event.get(Cluster.class,"OldMipsInsideTreesHCAL"));
+ List<Cluster> mmips = new ArrayList<Cluster>(event.get(Cluster.class,"OldMipsInsideTreesMCAL"));
+ emips.addAll(event.get(Cluster.class,"NewMipsInsideTreesECAL"));
+ hmips.addAll(event.get(Cluster.class,"NewMipsInsideTreesHCAL"));
+ mmips.addAll(event.get(Cluster.class,"NewMipsInsideTreesMCAL"));
+ List<Cluster> photons = new ArrayList<Cluster>();
+ for(ReconstructedParticle p:event.get(ReconstructedParticle.class,"ReconstructedParticles"))
+ {
+ if(p.getMass() == 0.)photons.add(p.getClusters().get(0));
+ }
+ emips.addAll(event.get(Cluster.class,"PreShowerMipMatchSmallClusters"));
+ emips.addAll(event.get(Cluster.class,"PreShowerMipMatchMipClusters"));
+ eblocks.addAll(event.get(Cluster.class,"PreShowerMipMatchBlockClusters"));
+ event.put("EcalMips",emips);
+ event.put("HcalMips",hmips);
+ event.put("McalMips",mmips);
+ event.put("EcalBlocks",eblocks);
+ event.put("HcalBlocks",hblocks);
+ event.put("McalBlocks",mblocks);
+ event.put("EcalClumps",eclumps);
+ event.put("HcalClumps",hclumps);
+ event.put("McalClumps",mclumps);
+ event.put("EcalLeftovers",eleft);
+ event.put("HcalLeftovers",hleft);
+ event.put("McalLeftovers",mleft);
+ event.put("Photons",photons);
+ super.process(event);
+ }
+}
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon
diff -N DebugReconDriver2.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ DebugReconDriver2.java 4 Nov 2010 15:08:49 -0000 1.1
@@ -0,0 +1,97 @@
+package org.lcsim.contrib.Cassell.recon;
+import org.lcsim.contrib.Cassell.recon.Cheat.UIClCheater;
+import org.lcsim.contrib.Cassell.recon.Cheat.ClusterLevelCheater;
+import org.lcsim.recon.cheater.*;
+import org.lcsim.util.Driver;
+import org.lcsim.recon.cluster.util.*;
+import org.lcsim.recon.pfa.structural.SetUpPFA;
+import org.lcsim.recon.ui.ReconDriver;
+import org.lcsim.recon.tracking.cheat.TrackMCParticleDriver;
+
+/**
+ *
+ * @author cassell
+ */
+public class DebugReconDriver2 extends Driver
+{
+ String CheatReconRname = "ReconPerfectReconParticles";
+ String PPRPflowRname = "PPRReconParticles";
+ String CheatReconFSname = "ReconFSParticles";
+ String ExtraTracks = "ExtraTracks";
+ String CheatReconFSTrackedname = "TrackedReconFSParticles";
+ String CheatCname = "ReconClusters";
+ String[] EcalNames = {"EcalBarrDigiHits", "EcalEndcapDigiHits"};
+ String[] HcalNames = {"HcalBarrDigiHits", "HcalEndcapDigiHits"};
+ String[] hitNames = {EcalNames[0],EcalNames[1],HcalNames[0],HcalNames[1]};
+ String clusterername = "DTreeClusters";
+ String[] OEClNames = {"EcalBarrDigiHits"+clusterername, "EcalEndcapDigiHits"+clusterername};
+ String[] OHClNames = {"HcalBarrDigiHits"+clusterername, "HcalEndcapDigiHits"+clusterername};
+ String[] REClNames = {"EcalBarrDigiHitsReclustered"+clusterername, "EcalEndcapDigiHitsReclustered"+clusterername};
+ String[] RHClNames = {"HcalBarrDigiHitsReclustered"+clusterername, "HcalEndcapDigiHitsReclustered"+clusterername};
+ String ClLevelPFlowRname = clusterername+"ReconParticles";
+ String[] prefix = {"PPR",clusterername+">2hits",
+ clusterername+">5hits"};
+ String[] rnames = {PPRPflowRname,ClLevelPFlowRname+"cut2",
+ ClLevelPFlowRname+"cut5"};
+ private boolean useNewInitialMipFinding = true;
+ SetUpPFA setup;
+ public void setUseNewInitialMipFinding(boolean x)
+ {
+ useNewInitialMipFinding = x;
+ setup.setUseNewInitialMipFinding(useNewInitialMipFinding);
+ }
+ public DebugReconDriver2()
+ {
+ ReconDriver rd = new ReconDriver();
+ rd.setUseNewInitialMipFinding(useNewInitialMipFinding);
+ add(rd);
+//
+// Do the cheating reconstruction (includes Digisim)
+//
+ CheatReconDriverRealTracking crd = new CheatReconDriverRealTracking();
+ crd.setCheatReconstructedParticleOutputName(CheatReconRname);
+ crd.setCheatFSParticleOutputName(CheatReconFSname);
+ add(crd);
+
+
+
+//
+// Make the perfect pattern recognition pflow reconstructed particles from the
+// Cheat Recon particles
+//
+ PPRDriverRealTracking pprd = new PPRDriverRealTracking(CheatReconRname,PPRPflowRname,ExtraTracks);
+ ClusterEnergyCalculator pcec = new QPhotonClusterEnergyCalculator();
+ pprd.setPhotonClusterEnergyCalculator(pcec);
+ ClusterEnergyCalculator nhcec = new QNeutralHadronClusterEnergyCalculator();
+ pprd.setNeutralHadronClusterEnergyCalculator(nhcec);
+ add(pprd);
+ /*
+//
+// Recluster the Ecal
+//
+ add(new CoreReclusterDriver(OEClNames[0],REClNames[0]));
+ add(new CoreReclusterDriver(OEClNames[1],REClNames[1]));
+//
+// Recluster the Hcal
+//
+ add(new DigitalCoreReclustererDriver(OHClNames[0],RHClNames[0]));
+ add(new DigitalCoreReclustererDriver(OHClNames[1],RHClNames[1]));
+//
+// Add cluster level cheater
+//
+ add(new ClusterLevelCheater("E"+clusterername+"recl","H"+clusterername,REClNames,RHClNames,PPRPflowRname,ClLevelPFlowRname,
+ CheatReconFSname,CheatReconFSTrackedname));
+ *
+ */
+//
+// Add Track to MCP driver
+//
+ TrackMCParticleDriver tmd = new TrackMCParticleDriver();
+ add(tmd);
+ add(new MakeUsedTrackPPR());
+//
+// Add cheating at UI cluster level
+//
+ add(new UIClCheater(tmd));
+ }
+}
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon
diff -N MakeUsedTrackPPR.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ MakeUsedTrackPPR.java 4 Nov 2010 15:08:49 -0000 1.1
@@ -0,0 +1,110 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package org.lcsim.contrib.Cassell.recon;
+import org.lcsim.util.Driver;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.ReconstructedParticle;
+import org.lcsim.event.Track;
+import org.lcsim.event.Cluster;
+import org.lcsim.event.CalorimeterHit;
+import java.util.*;
+import org.lcsim.event.ParticleID;
+import org.lcsim.event.base.BaseReconstructedParticle;
+import org.lcsim.event.util.CheatParticleID;
+import org.lcsim.recon.cluster.util.*;
+import org.lcsim.recon.cluster.nn.NearestNeighborClusterer;
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+import org.lcsim.recon.util.CalInfoDriver;
+
+/**
+ *
+ * @author cassell
+ */
+public class MakeUsedTrackPPR extends Driver
+{
+ double k0lmass = .497671;
+ ParticleID k0lpid;
+ ClusterEnergyCalculator nhcec;
+ int minCalhits = 5;
+ Clusterer clusterer;
+
+ public MakeUsedTrackPPR()
+ {
+ k0lpid = new CheatParticleID(130);
+ nhcec = new QNeutralHadronClusterEnergyCalculator();
+ clusterer = new NearestNeighborClusterer(4,4,2,0,0.);
+ add(new CalInfoDriver());
+
+ }
+ protected void process(EventHeader event)
+ {
+ super.process(event);
+ List<ReconstructedParticle> pfarp = event.get(ReconstructedParticle.class,"ReconstructedParticles");
+ List<ReconstructedParticle> pprrp = event.get(ReconstructedParticle.class,"PPRReconParticles");
+ List<ReconstructedParticle> pprusedt = new ArrayList<ReconstructedParticle>(pprrp);
+ List<Track> used = new ArrayList<Track>();
+ for(ReconstructedParticle p:pfarp)
+ {
+ if(p.getCharge() != 0.)
+ {
+ if(p.getTracks().size() == 1)used.add(p.getTracks().get(0));
+ }
+ }
+ for(ReconstructedParticle p:pprrp)
+ {
+ if(p.getCharge() != 0.)
+ {
+ if(p.getTracks().size() == 1)
+ {
+ if(!used.contains(p.getTracks().get(0)))
+ {
+ pprusedt.remove(p);
+ ReconstructedParticle pp = makeNRPfromRP(p);
+ if(pp != null)pprusedt.add(pp);
+ }
+ }
+ }
+ }
+ event.put("PPRUTReconParticles",pprusedt,ReconstructedParticle.class,0);
+ }
+ public ReconstructedParticle makeNRPfromRP(ReconstructedParticle p)
+ {
+ BasicCluster cc = new BasicCluster();
+ int nh = 0;
+ for(Cluster c:p.getClusters())
+ {
+ for(CalorimeterHit h:c.getCalorimeterHits())
+ {
+ cc.addHit(h);
+ nh++;
+ }
+ }
+ if(nh < minCalhits)return null;
+ double cE = nhcec.getEnergy(cc);
+ if(cE < k0lmass)cE = k0lmass;
+ List<Cluster> clist = clusterer.createClusters(cc.getCalorimeterHits());
+ double[] pos = {0.,0.,0.};
+ int maxhits = 0;
+ for(Cluster ccc:clist)
+ {
+ if(ccc.getCalorimeterHits().size() > maxhits)
+ {
+ pos = ccc.getPosition();
+ maxhits = ccc.getCalorimeterHits().size();
+ }
+ }
+ double norm = Math.sqrt(cE*cE - k0lmass*k0lmass)/
+ Math.sqrt(pos[0]*pos[0] + pos[1]*pos[1] + pos[2]*pos[2]);
+ Hep3Vector mom = new BasicHep3Vector(pos[0]*norm, pos[1]*norm, pos[2]*norm);
+ BaseReconstructedParticle nrp = new BaseReconstructedParticle(cE,mom);
+ nrp.setMass(k0lmass);
+ nrp.setParticleIdUsed(k0lpid);
+ nrp.addParticleID(k0lpid);
+ nrp.addCluster(cc);
+ return nrp;
+ }
+}
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon
diff -u -r1.1 -r1.2
--- TrackMCParticleMatcher.java 4 Oct 2010 13:30:22 -0000 1.1
+++ TrackMCParticleMatcher.java 4 Nov 2010 15:08:49 -0000 1.2
@@ -18,6 +18,7 @@
public class TrackMCParticleMatcher
{
List<LCRelation> lcrl;
+ double frac;
public TrackMCParticleMatcher(List<LCRelation> rl)
{
lcrl = rl;
@@ -52,6 +53,8 @@
maxmc = p;
}
}
+ frac = ((double) maxcnt)/t.getTrackerHits().size();
return maxmc;
}
+ public double getFraction(){return frac;}
}
lcsim-contrib/src/main/java/org/lcsim/contrib/Cassell/recon
diff -u -r1.1 -r1.2
--- TrackMCParticleDriver.java 4 Oct 2010 13:30:22 -0000 1.1
+++ TrackMCParticleDriver.java 4 Nov 2010 15:08:49 -0000 1.2
@@ -19,6 +19,7 @@
public class TrackMCParticleDriver extends Driver
{
Map<Track,MCParticle> tmcmap;
+ Map<Track,Double> fmap;
public TrackMCParticleDriver()
{
@@ -29,13 +30,19 @@
List<LCRelation> rl = event.get(LCRelation.class,"HelicalTrackMCRelations");
TrackMCParticleMatcher m = new TrackMCParticleMatcher(rl);
tmcmap = new HashMap<Track,MCParticle>();
+ fmap = new HashMap<Track,Double>();
for(Track t:tl)
{
tmcmap.put(t, m.getMCParticle(t));
+ fmap.put(t,m.getFraction());
}
}
public MCParticle getMCParticle(Track t)
{
return tmcmap.get(t);
}
+ public double getFraction(Track t)
+ {
+ return fmap.get(t);
+ }
}
CVSspam 0.2.8
