diff -N PolyhedraBarrelCalorimeter2Converter.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ PolyhedraBarrelCalorimeter2Converter.java	3 May 2010 18:01:40 -0000	1.1
@@ -0,0 +1,364 @@

+package org.lcsim.detector.converter.compact;
+
+import static java.lang.Math.PI;
+import static java.lang.Math.tan;
+
+import java.util.Iterator;
+
+import org.jdom.Attribute;
+import org.jdom.DataConversionException;
+import org.jdom.Element;
+import org.lcsim.detector.DetectorElement;
+import org.lcsim.detector.IDetectorElement;
+import org.lcsim.detector.ILogicalVolume;
+import org.lcsim.detector.IPhysicalVolume;
+import org.lcsim.detector.IRotation3D;
+import org.lcsim.detector.ITransform3D;
+import org.lcsim.detector.ITranslation3D;
+import org.lcsim.detector.LogicalVolume;
+import org.lcsim.detector.PhysicalVolume;
+import org.lcsim.detector.RotationPassiveXYZ;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.detector.Translation3D;
+import org.lcsim.detector.identifier.ExpandedIdentifier;
+import org.lcsim.detector.identifier.IExpandedIdentifier;
+import org.lcsim.detector.identifier.IIdentifier;
+import org.lcsim.detector.identifier.IIdentifierHelper;
+import org.lcsim.detector.material.IMaterial;
+import org.lcsim.detector.material.MaterialStore;
+import org.lcsim.detector.solids.Box;
+import org.lcsim.detector.solids.Trd;
+import org.lcsim.geometry.compact.Detector;
+import org.lcsim.geometry.compact.Subdetector;
+import org.lcsim.geometry.layer.Layer;
+import org.lcsim.geometry.layer.Layering;
+import org.lcsim.geometry.subdetector.PolyhedraBarrelCalorimeter2;
+
+/**
+ * 
+ * This converter makes a detailed geometry for the
+ * {@link org.lcsim.geometry.subdetector.PolyhedraBarrelCalorimeter2}
+ * subdetector type.
+ * 
+ * @author Jeremy McCormick <[log in to unmask]>
+ * @version $Id: PolyhedraBarrelCalorimeter2Converter.java,v 1.1 2010/05/03 18:01:40 jeremy Exp $
+ */
+public class PolyhedraBarrelCalorimeter2Converter extends AbstractSubdetectorConverter
+{
+    public void convert(Subdetector subdet, Detector detector)
+    {
+        // Subdetector parameters.
+        int sysId = subdet.getSystemID();
+        String subdetName = subdet.getName();
+        PolyhedraBarrelCalorimeter2 cal = (PolyhedraBarrelCalorimeter2) subdet;
+        int nsides = cal.getNumberOfSides();
+        double innerR = cal.getInnerR();
+        Layering layering = cal.getLayering();
+        double thickness = layering.getThickness();
+        double z = cal.getZLength();
+
+        // Gap size.
+        double gap = 0;
+        if (subdet.getNode().getAttribute("gap") != null)
+        {
+            try
+            {
+                gap = subdet.getNode().getAttribute("gap").getDoubleValue();
+            }
+            catch (DataConversionException e)
+            {
+                throw new RuntimeException(e);
+            }
+        }
+
+        // Get the gap material or use air as the default.
+        IMaterial air = MaterialStore.getInstance().get("Air");
+        IMaterial gapMaterial = air;
+        if (subdet.getNode().getAttribute("material") != null)
+        {
+            gapMaterial = MaterialStore.getInstance().get(
+                    subdet.getNode().getAttributeValue("material"));
+        }
+
+        // Parameters for trd stave.
+        double innerAngle = Math.PI * 2 / nsides;
+        double halfInnerAngle = innerAngle / 2;
+        double innerFaceLength = innerR * tan(halfInnerAngle) * 2;
+        double rmax = innerR + thickness;
+        double outerFaceLength = rmax * tan(halfInnerAngle) * 2;
+        double sectCenter = innerR + thickness / 2;
+        double layerOuterAngle = (PI - innerAngle) / 2;
+        double layerInnerAngle = (PI / 2 - layerOuterAngle);
+
+        // Make outer stave trd.
+        Trd staveTrdOuter = new Trd(
+                                    subdet.getName() + "_stave_trap_outer",
+                                    innerFaceLength / 2,
+                                    outerFaceLength / 2,
+                                    z / 2,
+                                    z / 2,
+                                    thickness / 2);
+
+        // Make outer stave volume.
+        ILogicalVolume staveOuterLogicalVolume = new LogicalVolume(
+                                                                   subdetName + "_stave_outer",
+                                                                   staveTrdOuter,
+                                                                   gapMaterial);
+
+        // Make inner stave trd.
+        Trd staveTrdInner = new Trd(
+                                    subdet.getName() + "_stave_trap_inner",
+                                    innerFaceLength / 2 - gap,
+                                    outerFaceLength / 2 - gap,
+                                    z / 2,
+                                    z / 2,
+                                    thickness / 2);
+
+        // Make inner stave volume.
+        ILogicalVolume staveInnerLogicalVolume = new LogicalVolume(
+                                                                   subdetName + "_stave_inner",
+                                                                   staveTrdInner,
+                                                                   air);
+
+        // Place inner stave inside of outer. 
+        new PhysicalVolume(
+                           new Transform3D(),
+                           subdetName,
+                           staveInnerLogicalVolume,
+                           staveOuterLogicalVolume,
+                           0);
+
+        // Layer parameters.
+        double staveThickness = thickness;
+        int layerNumber = 0;
+        double layerZ = -(staveThickness / 2);
+        double layerX = staveTrdInner.getXHalfLength1() * 2;
+
+        // Loop over layer elements.
+        for (Iterator i = subdet.getNode().getChildren("layer").iterator(); i.hasNext();)
+        {
+            Element layer_element = (Element) i.next();
+
+            // Get the layer from the layering engine.
+            Layer layer = layering.getLayer(layerNumber);
+
+            // Get number of times to repeat this layer.
+            int repeat;
+            try
+            {
+                repeat = (int) layer_element.getAttribute("repeat").getDoubleValue();
+            }
+            catch (Exception x)
+            {
+                throw new RuntimeException(x);
+            }
+
+            // Loop over repeats for this layer.
+            for (int j = 0; j < repeat; j++)
+            {
+                // Name of the layer.
+                String layerName = subdetName + "_stave_layer" + layerNumber;
+
+                // Layer thickness, which is Z in the trd coordinate system.
+                double layerThickness = layer.getThickness();
+
+                // Layer position in Z within the stave.
+                layerZ += layerThickness / 2;
+
+                // Position of layer.
+                ITranslation3D layer_position = new Translation3D(0, 0, layerZ);
+
+                // Layer box.
+                Box layerBox = new Box(layerName + "_box", layerX / 2, z / 2, layerThickness / 2);
+
+                // Layer volume.
+                ILogicalVolume layerVolume = new LogicalVolume(layerName, layerBox, air);
+
+                // Starting Z of slice.
+                double sliceZ = -(layerThickness / 2);
+
+                // Slice ID.
+                int sliceNumber = 0;
+
+                // Create the slices within the layer.
+                for (Iterator k = layer_element.getChildren("slice").iterator(); k.hasNext();)
+                {
+                    Element sliceElement = (Element) k.next();
+
+                    String sliceName = layerName + "_slice" + sliceNumber;
+
+                    // Sensitivity.
+                    boolean sensitive = false;
+                    try
+                    {
+                        if (sliceElement.getAttribute("sensitive") != null)
+                        {
+                            Attribute s = sliceElement.getAttribute("sensitive");
+                            sensitive = s != null && s.getBooleanValue();
+                        }
+                    }
+                    catch (Exception x)
+                    {
+                        throw new RuntimeException(x);
+                    }
+
+                    // Thickness of slice.
+                    double sliceThickness;
+                    try
+                    {
+                        sliceThickness = sliceElement.getAttribute("thickness").getDoubleValue();
+                    }
+                    catch (Exception x)
+                    {
+                        throw new RuntimeException(x);
+                    }
+
+                    // Increment Z position to place next slice.
+                    sliceZ += sliceThickness / 2;
+
+                    // Get the slice material.
+                    IMaterial sliceMaterial = MaterialStore.getInstance().get(
+                            sliceElement.getAttributeValue("material"));
+
+                    // Slice position.
+                    ITranslation3D slicePosition = new Translation3D(0, 0, sliceZ);
+                    ITransform3D sliceTrans = new Transform3D(slicePosition);
+
+                    // Slice box.
+                    Box sliceBox = new Box(
+                                           sliceName + "_box",
+                                           layerX / 2,
+                                           z / 2,
+                                           sliceThickness / 2);
+
+                    // Slice volume.
+                    ILogicalVolume sliceVolume = new LogicalVolume(
+                                                                   sliceName,
+                                                                   sliceBox,
+                                                                   sliceMaterial);
+
+                    // Slice placement.
+                    PhysicalVolume slicePlacement = new PhysicalVolume(
+                                                                       sliceTrans,
+                                                                       sliceName,
+                                                                       sliceVolume,
+                                                                       layerVolume,
+                                                                       sliceNumber);
+
+                    // Set sensitivity.
+                    if (sensitive)
+                        slicePlacement.setSensitive(true);
+
+                    // Increment z position.
+                    sliceZ += sliceThickness / 2;
+
+                    // Increment slice ID.
+                    ++sliceNumber;
+                }
+
+                // Layer PhysicalVolume.
+                new PhysicalVolume(
+                                   new Transform3D(layer_position),
+                                   layerName,
+                                   layerVolume,
+                                   staveInnerLogicalVolume,
+                                   layerNumber);
+
+                // Increment the layer X dimension.
+                layerX += layerThickness * tan(layerInnerAngle) * 2;
+
+                // Increment the layer Z position.
+                layerZ += layerThickness / 2;
+
+                // Increment the layer number.
+                ++layerNumber;
+            }
+        }
+
+        // Place staves and make DetectorElements for them.
+        for (int i = 0; i < nsides; i++)
+        {
+            // Compute stave position and rotation parameters.
+            double phi = -(2 * Math.PI * ((double) i) / nsides - Math.PI / 2);
+            double zc = -phi + Math.PI / 2;
+            double x = sectCenter * Math.cos(phi);
+            double y = sectCenter * Math.sin(phi);
+
+            // Make stave position and rotation.
+            ITranslation3D trans = new Translation3D(x, y, 0);
+            IRotation3D rotate = new RotationPassiveXYZ(Math.PI / 2, 0, zc);
+            ITransform3D transform = new Transform3D(trans, rotate);
+
+            // Stave placement.
+            String name = subdetName + "_module" + i;
+            new PhysicalVolume(transform, name, staveOuterLogicalVolume, detector
+                    .getDetectorElement().getGeometry().getLogicalVolume(), i);
+
+            // Stave DetectorElement.
+            new DetectorElement(
+                                subdet.getName() + "_module" + i,
+                                subdet.getDetectorElement(),
+                                "/" + name);
+        }
+
+        // Get the identifier helper for the subdetector for ID packing.
+        IIdentifierHelper helper = cal.getDetectorElement().getIdentifierHelper();
+
+        // Create DetectorElements for sensitive slices.
+
+        // Loop over outer staves.
+        for (IDetectorElement outerStave : subdet.getDetectorElement().getChildren())
+        {
+            // Loop over inner staves (just one per outer stave).
+            for (IPhysicalVolume innerStave : outerStave.getGeometry().getLogicalVolume()
+                    .getDaughters())
+            {
+                // Get the stave number.
+                int staveNum = outerStave.getGeometry().getPhysicalVolume().getCopyNumber();
+
+                // Loop over the layer placements.
+                for (IPhysicalVolume layer : innerStave.getLogicalVolume().getDaughters())
+                {
+                    // Loop over the slice placements.
+                    for (IPhysicalVolume slice : layer.getLogicalVolume().getDaughters())
+                    {
+                        // Create a new expanded identifier with correct number of fields.
+                        IExpandedIdentifier expId = new ExpandedIdentifier(helper
+                                .getIdentifierDictionary().getNumberOfFields());
+
+                        // Fill in the identifier field values from the geometry values.
+                        expId.setValue(helper.getFieldIndex("system"), sysId);
+                        expId.setValue(helper.getFieldIndex("barrel"), 0);
+                        expId.setValue(helper.getFieldIndex("module"), outerStave.getGeometry()
+                                .getPhysicalVolume().getCopyNumber());
+                        expId.setValue(helper.getFieldIndex("layer"), layer.getCopyNumber());
+                        expId.setValue(helper.getFieldIndex("slice"), slice.getCopyNumber());
+
+                        // Pack the identifier.
+                        IIdentifier id = helper.pack(expId);
+
+                        // Make a DetectorElement if the slice is sensitive.
+                        if (slice.isSensitive())
+                        {
+                            new DetectorElement(
+                                                subdetName + "_module" + staveNum + "_layer" + layer
+                                                        .getCopyNumber() + "_slice" + slice
+                                                        .getCopyNumber(),
+                                                outerStave,
+                                                "/" + outerStave.getGeometry().getPhysicalVolume()
+                                                        .getName() + "/" + innerStave.getName() + "/" + layer
+                                                        .getName() + "/" + slice.getName(),
+                                                id);
+                        }
+                    }
+                }
+            }
+        }
+
+    }
+
+    public Class getSubdetectorType()
+    {
+        return PolyhedraBarrelCalorimeter2.class;
+    }
+}

\ No newline at end of file

diff -N PolyhedraBarrelCalorimeter2HepRepTest.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ PolyhedraBarrelCalorimeter2HepRepTest.java	3 May 2010 18:01:40 -0000	1.1
@@ -0,0 +1,56 @@

+package org.lcsim.detector.converter.compact;
+
+import java.io.InputStream;
+
+import junit.framework.TestCase;
+
+import org.lcsim.detector.converter.heprep.DetectorElementToHepRepConverter;
+import org.lcsim.geometry.Detector;
+import org.lcsim.geometry.GeometryReader;
+import org.lcsim.util.test.TestUtil.TestOutputFile;
+
+/**
+ * 
+ * Write a HepRep for the {@link org.lcsim.geometry.subdetector.PolyhedraBarrelCalorimeter2}
+ * subdetector type.
+ * 
+ * @author Jeremy McCormick <[log in to unmask]>
+ * @version $Id: PolyhedraBarrelCalorimeter2HepRepTest.java,v 1.1 2010/05/03 18:01:40 jeremy Exp $
+ */
+public class PolyhedraBarrelCalorimeter2HepRepTest extends TestCase 
+{   
+    Detector detector;
+    
+    private static final String resource = 
+        "/org/lcsim/geometry/subdetector/PolyhedraBarrelCalorimeter2Test.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);
+        }               
+    }
+    
+    public void testWriteHepRep()
+    {
+        try 
+        {
+            DetectorElementToHepRepConverter.writeHepRep((new TestOutputFile("PolyhedraBarrelCalorimeter2Test.heprep")).getPath());
+        }
+        catch (Exception x)
+        {
+            throw new RuntimeException(x);
+        }
+    }
+}