lcsim/src/org/lcsim/util/heprep

diff -N ReconstructedParticleConverter.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ ReconstructedParticleConverter.java	1 Jul 2005 22:57:12 -0000	1.1
@@ -0,0 +1,117 @@

+package org.lcsim.util.heprep;
+
+import hep.graphics.heprep.HepRepFactory;
+import hep.graphics.heprep.HepRepInstance;
+import hep.graphics.heprep.HepRepType;
+import hep.graphics.heprep.HepRepTypeTree;
+import hep.graphics.heprep.HepRepInstanceTree;
+import java.awt.Color;
+import java.util.List;
+import org.lcsim.event.EventHeader;
+import org.lcsim.event.EventHeader.LCMetaData;
+import org.lcsim.event.ReconstructedParticle;
+import org.lcsim.geometry.Detector;
+import org.lcsim.util.swim.HelixSwim;
+
+
+/**
+ *
+ * @author tonyj
+ * @version $Id: ReconstructedParticleConverter.java,v 1.1 2005/07/01 22:57:12 tonyj Exp $
+ */
+class ReconstructedParticleConverter implements HepRepCollectionConverter
+{
+   private static final double[] IP = { 0,0,0 };
+   
+   public boolean canHandle(Class k)
+   {
+      return ReconstructedParticle.class.isAssignableFrom(k);
+   }
+   public void convert(EventHeader event, List collection, HepRepFactory factory, HepRepTypeTree typeTree, HepRepInstanceTree instanceTree)
+   {
+      LCMetaData meta = event.getMetaData(collection);
+      String name = meta.getName();
+      int flags = meta.getFlags();
+      Detector detector = event.getDetector();
+      
+      double trackingRMax = detector.getConstants().get("tracking_region_radius").getValue();
+      double trackingZMax = detector.getConstants().get("tracking_region_zmax").getValue();
+      
+      double[] field = detector.getFieldMap().getField(IP);
+      HelixSwim helix = new HelixSwim(field[2],0,trackingRMax,trackingZMax);
+      
+      HepRepType typeX = factory.createHepRepType(typeTree, name);
+      typeX.addAttValue("layer",LCSimHepRepConverter.PARTICLES_LAYER);
+      typeX.addAttValue("drawAs","Line");
+      typeX.addAttDef("energy","Particle Energy", "physics", "");
+      typeX.addAttDef("type","Particle Type", "physics", "");
+      
+      HepRepType neutralType = factory.createHepRepType(typeX, "Neutral");
+      neutralType.addAttValue("color",Color.GREEN);
+      
+      HepRepType chargedType = factory.createHepRepType(typeX, "Charged");
+      chargedType.addAttValue("color",Color.ORANGE);
+      
+      HepRepInstance charged = factory.createHepRepInstance(instanceTree, typeX);
+      HepRepInstance neutral = factory.createHepRepInstance(instanceTree, typeX);
+      
+      for (ReconstructedParticle p : (List<ReconstructedParticle>) collection)
+      {
+         double[] start = p.getReferencePoint().v();
+         double[] momentum = p.getMomentum().v();
+         double charge = p.getCharge();
+         helix.setTrack(momentum, start, (int) charge);
+         double[] stop;
+         
+         // Use the helix swimmer to swim to end of tracking region
+         stop = helix.swimBy(trackingRMax);
+         
+         if (charge == 0 || field[2] == 0)
+         {
+            HepRepInstance instanceX = factory.createHepRepInstance(charge == 0 ? neutral : charged, charge == 0 ? neutralType : chargedType);
+            factory.createHepRepPoint(instanceX,start[0],start[1],start[2]);
+            factory.createHepRepPoint(instanceX,stop[0],stop[1],stop[2]);
+            instanceX.addAttValue("energy",p.getEnergy());
+            instanceX.addAttValue("type",p.getType());
+         }
+         else
+         {
+            double pT = Math.sqrt(momentum[0]*momentum[0]+momentum[1]*momentum[1]);
+            // if particle starts at origin and has no apprecaible pT, don't draw
+            double r = Math.sqrt(start[0]*start[0]+start[1]*start[1]);
+            
+            double dAlpha = .01; // 1cm
+            HepRepInstance instanceX = factory.createHepRepInstance(charged, chargedType);
+            instanceX.addAttValue("energy",p.getEnergy());
+            instanceX.addAttValue("pdgid",p.getType());
+            factory.createHepRepPoint(instanceX,start[0],start[1],start[2]);
+            double absZ = Math.abs(stop[2]);
+            double rSquared = stop[0]*stop[0]+stop[1]*stop[1];
+            double[] point = start;
+            
+            for (int k = 1;k<200;k++)
+            {
+               double d0 = point[0]-stop[0];
+               double d1 = point[1]-stop[1];
+               double d2 = point[2]-stop[2];
+               
+               if (d0*d0+d1*d1+d2*d2 < 2)
+               {
+                  factory.createHepRepPoint(instanceX,stop[0],stop[1],stop[2]);
+                  break;
+               }
+               else if (Math.abs(point[2]) > absZ ||
+                       point[0]*point[0]+point[1]*point[1] > rSquared)
+               {
+                  break;
+               }
+               else
+               {
+                  point = helix.swimBy(k*dAlpha);
+                  factory.createHepRepPoint(instanceX,point[0],point[1],point[2]);
+               }
+            }
+         }
+      }
+   }
+}

\ No newline at end of file