Print

Print


Commit in lcsim/src/org/lcsim/util/heprep on MAIN
MCParticleConverter.java+30-291.3 -> 1.4
ReconstructedParticleConverter.java+19-411.1 -> 1.2
TrackConverter.java+10-241.1 -> 1.2
+59-94
3 modified files
Switch event display to use new swimmer

lcsim/src/org/lcsim/util/heprep
MCParticleConverter.java 1.3 -> 1.4
diff -u -r1.3 -r1.4
--- MCParticleConverter.java	15 Jul 2005 21:50:35 -0000	1.3
+++ MCParticleConverter.java	20 Aug 2005 23:25:41 -0000	1.4
@@ -5,19 +5,22 @@
 import hep.graphics.heprep.HepRepType;
 import hep.graphics.heprep.HepRepTypeTree;
 import hep.graphics.heprep.HepRepInstanceTree;
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+import hep.physics.vec.VecOp;
 import java.awt.Color;
 import java.util.List;
 import org.lcsim.event.EventHeader;
 import org.lcsim.event.EventHeader.LCMetaData;
 import org.lcsim.event.MCParticle;
 import org.lcsim.geometry.Detector;
-import org.lcsim.util.swim.HelixSwim;
+import org.lcsim.util.swim.HelixSwimmer;
 
 
 /**
  *
  * @author tonyj
- * @version $Id: MCParticleConverter.java,v 1.3 2005/07/15 21:50:35 ngraf Exp $
+ * @version $Id: MCParticleConverter.java,v 1.4 2005/08/20 23:25:41 tonyj Exp $
  */
 class MCParticleConverter implements HepRepCollectionConverter
 {
@@ -40,7 +43,7 @@
       double ptMinCut = 0.05;
       double rCut = 1.0;
       double[] field = detector.getFieldMap().getField(IP);
-      HelixSwim helix = new HelixSwim(field[2],0,trackingRMax,trackingZMax);
+      HelixSwimmer helix = new HelixSwimmer(field[2]);
       
       HepRepType typeX = factory.createHepRepType(typeTree, name);
       typeX.addAttValue("layer",LCSimHepRepConverter.PARTICLES_LAYER);
@@ -59,19 +62,19 @@
       
       for (MCParticle p : (List<MCParticle>) collection)
       {
-         double[] start = p.getOrigin().v();
-         double[] momentum = p.getMomentum().v();
+         Hep3Vector start = p.getOrigin();
+         Hep3Vector momentum = p.getMomentum();
          double charge = p.getCharge();
          helix.setTrack(momentum, start, (int) charge);
-         double[] stop;
+         Hep3Vector stop;
 
          try
          {
-            stop = p.getEndPoint().v();
+            stop = p.getEndPoint();
             // Workaround for simdet
-            if (stop[0] == 0 && stop[1] == 0 && stop[2] == 0)
+            if (stop.x() == 0 && stop.y() == 0 && stop.z() == 0)
             {
-                if(p.getGeneratorStatus()==MCParticle.FINAL_STATE) stop = helix.swimBy(trackingRMax);
+                if(p.getGeneratorStatus()==MCParticle.FINAL_STATE) stop = helix.getPointAtDistance(trackingRMax);
             }
          }
          catch (RuntimeException x)
@@ -79,57 +82,55 @@
             // Use the helix swimmer to swim to end of tracking region
             if(p.getGeneratorStatus()==MCParticle.FINAL_STATE)
             {
-                stop = helix.swimBy(trackingRMax);
+                stop = helix.getPointAtDistance(trackingRMax);
             }
             else
             {
-                stop = new double[3];
+                stop = new BasicHep3Vector();
             }
          }
          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]);
+            factory.createHepRepPoint(instanceX,start.x(),start.y(),start.z());
+            factory.createHepRepPoint(instanceX,stop.x(),stop.y(),stop.z());
             instanceX.addAttValue("energy",p.getEnergy());
             instanceX.addAttValue("type",p.getType().getName());
          }
          else
          {
-            double pT = Math.sqrt(momentum[0]*momentum[0]+momentum[1]*momentum[1]);
+            double pT = Math.sqrt(momentum.x()*momentum.x()+momentum.y()*momentum.y());
             // 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 r = Math.sqrt(start.x()*start.x()+start.y()*start.y());
             if(pT>ptMinCut || (pT<ptMinCut && r>rCut))
             {
-               double dAlpha = .01; // 1cm
+               double dAlpha = 10; // 1cm
                HepRepInstance instanceX = factory.createHepRepInstance(charged, chargedType);
                instanceX.addAttValue("energy",p.getEnergy());
                instanceX.addAttValue("pdgid",p.getType().getName());
-               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;
+               factory.createHepRepPoint(instanceX,start.x(),start.y(),start.z());
+               double absZ = Math.abs(stop.z());
+               double rSquared = stop.x()*stop.x()+stop.y()*stop.y();
+               Hep3Vector 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];
+                  double d = VecOp.sub(point,stop).magnitudeSquared();
                   
-                  if (d0*d0+d1*d1+d2*d2 < 2)
+                  if (d < 2)
                   {
-                     factory.createHepRepPoint(instanceX,stop[0],stop[1],stop[2]);
+                     factory.createHepRepPoint(instanceX,stop.x(),stop.y(),stop.z());
                      break;
                   }
-                  else if (Math.abs(point[2]) > absZ ||
-                          point[0]*point[0]+point[1]*point[1] > rSquared)
+                  else if (Math.abs(point.z()) > absZ ||
+                          point.x()*point.x()+point.y()*point.y() > rSquared)
                   {
                      break;
                   }
                   else
                   {
-                     point = helix.swimBy(k*dAlpha);
-                     factory.createHepRepPoint(instanceX,point[0],point[1],point[2]);
+                     point = helix.getPointAtDistance(k*dAlpha);
+                     factory.createHepRepPoint(instanceX,point.x(),point.y(),point.z());
                   }
                }
             }

lcsim/src/org/lcsim/util/heprep
ReconstructedParticleConverter.java 1.1 -> 1.2
diff -u -r1.1 -r1.2
--- ReconstructedParticleConverter.java	1 Jul 2005 22:57:12 -0000	1.1
+++ ReconstructedParticleConverter.java	20 Aug 2005 23:25:41 -0000	1.2
@@ -5,19 +5,20 @@
 import hep.graphics.heprep.HepRepType;
 import hep.graphics.heprep.HepRepTypeTree;
 import hep.graphics.heprep.HepRepInstanceTree;
+import hep.physics.vec.Hep3Vector;
 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;
+import org.lcsim.util.swim.HelixSwimmer;
 
 
 /**
  *
  * @author tonyj
- * @version $Id: ReconstructedParticleConverter.java,v 1.1 2005/07/01 22:57:12 tonyj Exp $
+ * @version $Id: ReconstructedParticleConverter.java,v 1.2 2005/08/20 23:25:41 tonyj Exp $
  */
 class ReconstructedParticleConverter implements HepRepCollectionConverter
 {
@@ -38,7 +39,7 @@
       double trackingZMax = detector.getConstants().get("tracking_region_zmax").getValue();
       
       double[] field = detector.getFieldMap().getField(IP);
-      HelixSwim helix = new HelixSwim(field[2],0,trackingRMax,trackingZMax);
+      HelixSwimmer helix = new HelixSwimmer(field[2]);
       
       HepRepType typeX = factory.createHepRepType(typeTree, name);
       typeX.addAttValue("layer",LCSimHepRepConverter.PARTICLES_LAYER);
@@ -57,59 +58,36 @@
       
       for (ReconstructedParticle p : (List<ReconstructedParticle>) collection)
       {
-         double[] start = p.getReferencePoint().v();
-         double[] momentum = p.getMomentum().v();
+         Hep3Vector start =  p.getReferencePoint();
+         Hep3Vector momentum = p.getMomentum();
          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);
+         double distanceToCylinder = helix.getDistanceToCylinder(trackingRMax,trackingZMax);
+         System.out.println("dist="+distanceToCylinder);
          
          if (charge == 0 || field[2] == 0)
          {
+            Hep3Vector stop = helix.getPointAtDistance(distanceToCylinder);
             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]);
+            factory.createHepRepPoint(instanceX,start.x(),start.y(),start.z());
+            factory.createHepRepPoint(instanceX,stop.x(),stop.y(),stop.z());
             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
+         {  
+            double dAlpha = 10; // 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;
+            instanceX.addAttValue("type",p.getType());
+            factory.createHepRepPoint(instanceX,start.x(),start.y(),start.z());
             
             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]);
-               }
+               double d = k*dAlpha;
+               if (d>distanceToCylinder) break;
+               Hep3Vector point = helix.getPointAtDistance(d);
+               factory.createHepRepPoint(instanceX,point.x(),point.y(),point.z());
             }
          }
       }

lcsim/src/org/lcsim/util/heprep
TrackConverter.java 1.1 -> 1.2
diff -u -r1.1 -r1.2
--- TrackConverter.java	14 May 2005 00:26:54 -0000	1.1
+++ TrackConverter.java	20 Aug 2005 23:25:41 -0000	1.2
@@ -5,18 +5,19 @@
 import hep.graphics.heprep.HepRepType;
 import hep.graphics.heprep.HepRepTypeTree;
 import hep.graphics.heprep.HepRepInstanceTree;
+import hep.physics.vec.Hep3Vector;
 import java.util.List;
 import org.lcsim.event.EventHeader;
 import org.lcsim.event.EventHeader.LCMetaData;
 import org.lcsim.event.Track;
 import org.lcsim.geometry.Detector;
-import org.lcsim.util.swim.HelixSwim;
+import org.lcsim.util.swim.HelixSwimmer;
 
 
 /**
  *
  * @author tonyj
- * @version $Id: TrackConverter.java,v 1.1 2005/05/14 00:26:54 tonyj Exp $
+ * @version $Id: TrackConverter.java,v 1.2 2005/08/20 23:25:41 tonyj Exp $
  */
 class TrackConverter implements HepRepCollectionConverter
 {
@@ -37,7 +38,7 @@
       double trackingZMax = detector.getConstants().get("tracking_region_zmax").getValue();
       
       double[] field = detector.getFieldMap().getField(zero);
-      HelixSwim helix = new HelixSwim(field[2],0,trackingRMax,trackingZMax);
+      HelixSwimmer helix = new HelixSwimmer(field[2]);
       
       HepRepType typeX = factory.createHepRepType(typeTree, name);
       typeX.addAttValue("layer", LCSimHepRepConverter.PARTICLES_LAYER);
@@ -46,35 +47,20 @@
       typeX.addAttDef("dedX","de/Dx", "physics", "");
       
       for (Track t : (List<Track>) collection)
-      {
-//            case 1: return d0;
-//            case 2: return phi0;
-//            case 3: return omega;
-//            case 4: return z0;
-//            case 5: return s;
-         double omega = t.getTrackParameter(2);
-         double z0 = t.getTrackParameter(3);
-         double phi = t.getTrackParameter(1);
-         double tanLambda = t.getTrackParameter(4);
-         double d0 = t.getTrackParameter(0);
-         int iCharge = omega<0 ? +1 : -1;
-         double halfpi = Math.PI/2;
-         double[] origin = { d0 * Math.cos(phi + iCharge * halfpi),  d0 * Math.sin(phi + iCharge * halfpi), z0};
-         double pt = field[2]*0.3*.001/Math.abs(omega);
-         double[] momentum = { pt*Math.cos(phi), pt*Math.sin(phi), pt*tanLambda };
-         
-         helix.setTrack(momentum,origin,iCharge);
+      {         
+         helix.setTrack(t);
          
          HepRepInstance instanceX = factory.createHepRepInstance(instanceTree, typeX);
+         double pt = field[2]*0.3*.001/Math.abs(t.getTrackParameter(2));
          instanceX.addAttValue("pT",pt);
          instanceX.addAttValue("dedX",t.getdEdx());
          
-         double dAlpha = .01; // 1cm
+         double dAlpha = 10; // 1cm
          
          for (int k=0;k<200;k++)
          {
-            double[] point = helix.swimBy(k*dAlpha);
-            factory.createHepRepPoint(instanceX,10*point[0],10*point[1],10*point[2]);
+            Hep3Vector point = helix.getPointAtDistance(k*dAlpha);
+            factory.createHepRepPoint(instanceX,point.x(),point.y(),point.z());
          }
       }
    }
CVSspam 0.2.8