diff -N DiskTrackerConverter.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ DiskTrackerConverter.java	24 Mar 2007 01:02:32 -0000	1.1
@@ -0,0 +1,169 @@

+package org.lcsim.detector.converter.compact;
+
+import hep.physics.vec.BasicHep3Vector;
+
+import org.lcsim.detector.DetectorElement;
+import org.lcsim.detector.ILogicalVolume;
+import org.lcsim.detector.LogicalVolume;
+import org.lcsim.detector.PhysicalVolume;
+import org.lcsim.detector.Rotation3D;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.detector.material.IMaterial;
+import org.lcsim.detector.material.MaterialStore;
+import org.lcsim.detector.solids.Tube;
+import org.lcsim.geometry.Detector;
+import org.lcsim.geometry.Subdetector;
+import org.lcsim.geometry.layer.Layer;
+import org.lcsim.geometry.layer.LayerSlice;
+import org.lcsim.geometry.layer.Layering;
+import org.lcsim.geometry.subdetector.DiskTracker;
+
+/**
+ * Convert a DiskTracker to the detailed geometry description.
+ * 
+ * @author Jeremy McCormick <[log in to unmask]>
+ *
+ */
+public class DiskTrackerConverter
+implements ISubdetectorConverter
+{
+    public void convert( Subdetector subdet, Detector detector)
+    {        
+        ILogicalVolume trackingVolume = detector.getTrackingVolume().getLogicalVolume();
+
+        DiskTracker tracker = (DiskTracker)subdet;
+
+        subdet.setParent(detector);
+
+        Layering layering = tracker.getLayering();
+        String name = tracker.getName();
+
+        DetectorElement endcapPos = new DetectorElement(name + "_positive");
+        endcapPos.setParent(tracker);
+
+        DetectorElement endcapNeg=null;
+        if ( tracker.getReflect() )
+        {
+            endcapNeg = new DetectorElement(name + "_negative");
+            endcapNeg.setParent(tracker);
+        }
+
+        Rotation3D reflect = new Rotation3D();
+        reflect.setPassiveEuler(Math.PI,0,0);
+             
+        int sensorNum=0;
+
+        for (int i=0; i<layering.getNumberOfLayers(); i++)
+        {
+            Layer layer = layering.getLayer(i);
+
+            double layerInnerRadius = tracker.getInnerR()[i];
+            double layerOuterRadius = tracker.getOuterR()[i];
+            double layerInnerZ = tracker.getInnerZ()[i];
+
+            Tube layerTube = new Tube(
+                    name + "_layer" + i,
+                    layerInnerRadius,
+                    layerOuterRadius,
+                    layer.getThickness());
+
+            LogicalVolume layerLV = new LogicalVolume(
+                    name + "_layer" + i,
+                    layerTube,
+                    detector.getGeometry().getLogicalVolume().getMaterial()
+            );
+
+            // Layer in positive z.
+            new PhysicalVolume(
+                    new Transform3D(
+                            new BasicHep3Vector(
+                                    0,
+                                    0,
+                                    layerInnerZ + layer.getThickness() )),
+                    name + "_positive_layer" + i,
+                    layerLV,
+                    trackingVolume,
+                    i);           
+
+            // Reflected layer in negative z.
+            if ( tracker.getReflect() )
+            {                                 
+                new PhysicalVolume(
+                        new Transform3D(
+                                new BasicHep3Vector(
+                                        0.,
+                                        0.,                                       
+                                        -layerInnerZ - layer.getThickness()
+                                ), 
+                                reflect
+                        ),
+                        name + "_negative_layer" + i,
+                        layerLV,
+                        trackingVolume,
+                        i);                                       
+            }                 
+
+            double sliceZ = -layer.getThickness();
+            for (int j=0; j<layer.getNumberOfSlices(); j++)
+            {
+                LayerSlice slice = layer.getSlice(j);
+                double sliceThickness = slice.getThickness();
+                IMaterial sliceMaterial = 
+                    MaterialStore.getInstance().get(slice.getMaterial().getName());
+
+                Tube sliceTube = 
+                    new Tube(name + "_layer" + i + "_slice"+j,
+                            layerInnerRadius,
+                            layerOuterRadius,
+                            sliceThickness);
+
+                LogicalVolume sliceLV =
+                    new LogicalVolume(
+                            name + "_layer" + i + "_slice"+j,
+                            sliceTube,
+                            sliceMaterial);
+
+                sliceZ += sliceThickness;
+
+                new PhysicalVolume(
+                        new Transform3D(
+                                new BasicHep3Vector(
+                                        0,
+                                        0,
+                                        sliceZ )),
+                        "slice" + j,
+                        sliceLV,
+                        layerLV,
+                        j);   
+                
+                sliceZ += sliceThickness;
+
+                if ( slice.isSensitive() )
+                {                    
+                    String path = "/tracking_region/" + name + "_positive_layer" +i + "/slice" + j;
+
+                    new DetectorElement(
+                            name + "_positive_sensor" + sensorNum,
+                            endcapPos,
+                            path);
+
+                    if ( tracker.getReflect() )
+                    {
+                        path = "/tracking_region/" + name + "_negative_layer" +i + "/slice" + j;
+                        new DetectorElement(
+                                name + "_negative_sensor" + sensorNum,
+                                endcapNeg,
+                                path);
+                    }                    
+                    
+                    ++sensorNum;
+                }
+            }
+        }
+    }
+
+    public Class getSubdetectorType()
+    {
+        return DiskTracker.class;
+    }
+}

diff -N DiskTrackerTest.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ DiskTrackerTest.java	24 Mar 2007 01:02:32 -0000	1.1
@@ -0,0 +1,111 @@

+package org.lcsim.detector.converter.compact;
+
+import hep.physics.vec.BasicHep3Vector;
+import hep.physics.vec.Hep3Vector;
+
+import java.io.InputStream;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.lcsim.detector.IDetectorElement;
+import org.lcsim.detector.IPhysicalVolumeNavigator;
+import org.lcsim.detector.IPhysicalVolumePath;
+import org.lcsim.geometry.Detector;
+import org.lcsim.geometry.GeometryReader;
+
+/**
+ * 
+ * Perform tests on the detailed geometry of an 
+ * 
+ * @see org.lcsim.geometry.subdetector.DiskTracker 
+ * 
+ * @author Jeremy McCormick <[log in to unmask]>
+ *
+ */
+public class DiskTrackerTest
+extends TestCase
+{
+    private Detector detector;
+    
+    public DiskTrackerTest(String name)
+    {
+        super(name);
+    }
+    
+    public static junit.framework.Test suite()
+    {
+        return new TestSuite(DiskTrackerTest.class);
+    }
+    
+    private static final String resource = 
+        "/org/lcsim/detector/converter/compact/DiskTrackerTest.xml";
+    
+    public void setUp()
+    {
+        InputStream in = 
+            this.getClass().
+            getResourceAsStream(resource);
+        
+        GeometryReader reader = new GeometryReader();
+        
+        try {
+            detector = reader.read(in);
+        }
+        catch ( Throwable x )
+        {
+            throw new RuntimeException(x);
+        }
+    }
+
+    /**
+     * Scan the geometry with some points along the z axis.
+     * Check that the points are within the correct geometric
+     * volumes and DetectorElements.
+     */
+    public void testZPointScan()
+    {                     
+        IPhysicalVolumeNavigator navigator = detector.getNavigator();
+              
+        double[] zpoints = new double[] {
+                20.1,
+                10.1,
+                0.,
+                -10.1,
+                -20.1
+        };                                      
+        
+        String[] pathAnswerKey = new String[] {                
+                "/tracking_region/DiskTracker_positive_layer1/slice0",
+                "/tracking_region/DiskTracker_positive_layer0/slice0",
+                "/tracking_region",
+                "/tracking_region/DiskTracker_negative_layer0/slice0",
+                "/tracking_region/DiskTracker_negative_layer1/slice0"                
+        };
+        
+        String[] deAnswerKey = new String[] {
+                "DiskTracker_positive_sensor1",
+                "DiskTracker_positive_sensor0",
+                "DiskTrackerTest",
+                "DiskTracker_negative_sensor0",
+                "DiskTracker_negative_sensor1"                
+        };
+                
+        for ( int i=0; i<zpoints.length; i++ )
+        {           
+            Hep3Vector zpoint = new BasicHep3Vector(0,0,zpoints[i]);
+            
+            IPhysicalVolumePath path = navigator.getPath(zpoint);
+
+            assertTrue(
+                    "Wrong path <" + pathAnswerKey[i] + "> at z = " + zpoints[i] + " !!!",
+                    path.toString().equals(pathAnswerKey[i])
+                    );
+            
+            IDetectorElement srch = detector.findDetectorElement(zpoint);
+
+            assertTrue("Wrong DE <" + srch.getName() + "> at z = " + zpoints[i] + " !!!",
+                    srch.getName().equals(deAnswerKey[i]));
+        }
+    }   
+}

\ No newline at end of file