GeomConverter/src/org/lcsim/detector/converter/compact
diff -u -r1.1 -r1.2
--- SiTrackerEndcapConverter.java 15 Oct 2007 20:35:01 -0000 1.1
+++ SiTrackerEndcapConverter.java 17 Oct 2007 01:43:18 -0000 1.2
@@ -1,5 +1,24 @@
package org.lcsim.detector.converter.compact;
+import java.util.ArrayList;
+import java.util.List;
+
+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.ITransform3D;
+import org.lcsim.detector.LogicalVolume;
+import org.lcsim.detector.PhysicalVolume;
+import org.lcsim.detector.Rotation3D;
+import org.lcsim.detector.RotationPassiveXYZ;
+import org.lcsim.detector.Transform3D;
+import org.lcsim.detector.Translation3D;
+import org.lcsim.detector.material.IMaterial;
+import org.lcsim.detector.solids.Trd;
+import org.lcsim.detector.solids.Tube;
import org.lcsim.geometry.compact.Detector;
import org.lcsim.geometry.compact.Subdetector;
import org.lcsim.geometry.subdetector.SiTrackerEndcap;
@@ -8,19 +27,237 @@
* Converter for SiTrackerEndcap.
*
* @author Jeremy McCormick
- * @version $Id: SiTrackerEndcapConverter.java,v 1.1 2007/10/15 20:35:01 jeremy Exp $
+ * @version $Id: SiTrackerEndcapConverter.java,v 1.2 2007/10/17 01:43:18 jeremy Exp $
*/
public class SiTrackerEndcapConverter
implements ISubdetectorConverter
-{
+{
public void convert(Subdetector subdet, Detector detector)
- {
- System.out.println("SiTrackerEndcapConverter.convert");
- }
-
- public Class getSubdetectorType()
- {
- return SiTrackerEndcap.class;
+ {
+ IPhysicalVolume trackingPV = detector.getTrackingVolume();
+ ILogicalVolume trackingLV = trackingPV.getLogicalVolume();
+
+ Element node = subdet.getNode();
+
+ for (Object o : node.getChildren("layer"))
+ {
+ Element layerElement = (Element)o;
+
+ int nwedges;
+ try {
+ nwedges = layerElement.getAttribute("nwedges").getIntValue();
+ }
+ catch (DataConversionException x)
+ {
+ throw new RuntimeException(x);
+ }
+
+ double innerR, outerR, innerZ, thickness;
+ int layern;
+ try {
+ layern = layerElement.getAttribute("id").getIntValue();
+ innerR = layerElement.getAttribute("inner_r").getDoubleValue();
+ outerR = layerElement.getAttribute("outer_r").getDoubleValue();
+ innerZ = layerElement.getAttribute("inner_z").getDoubleValue();
+ thickness = layerElement.getAttribute("thickness").getDoubleValue();
+ }
+ catch (DataConversionException x)
+ {
+ throw new RuntimeException(x);
+ }
+
+ ILogicalVolume layerLV = makeLayer(detector,subdet,innerR,outerR,thickness,nwedges,layerElement);
+
+ double layerZ = innerZ + thickness / 2;
+
+ // Layer PV.
+ ITransform3D layerTrans = new Transform3D(new Translation3D(0,0,layerZ));
+
+ String layerName = layerLV.getName();
+
+ new PhysicalVolume(layerTrans,layerName,layerLV,trackingLV,layern);
+
+ // Layer DE.
+ String layerPath = "/" + trackingPV.getName() + "/" + layerName;
+ IDetectorElement layerDE = new DetectorElement(layerLV.getName(),null,detector.getNavigator().getPath(layerPath));
+
+ //System.out.println(layerDE.getName() + " -> " + layerPath);
+
+ // Wedge DE.
+ for (IPhysicalVolume wedge : layerLV.getDaughters())
+ {
+ String wedgePath = layerPath + "/" + wedge.getName();
+ String wedgeName = subdet.getName() + "_layer" + layern + "_wedge" + wedge.getCopyNumber();
+ //System.out.println(wedgeName + " -> " + wedgePath);
+ IDetectorElement wedgeDE = new DetectorElement(wedgeName,layerDE,detector.getNavigator().getPath(wedgePath));
+
+ // Module DEs.
+ for (IPhysicalVolume module : wedge.getLogicalVolume().getDaughters())
+ {
+ String modulePath = wedgePath + "/" + module.getName();
+ String moduleName = layerName + "_wedge" + wedge.getCopyNumber() + "_module" + module.getCopyNumber();
+ //System.out.println(moduleName + " -> " + modulePath);
+ new DetectorElement(moduleName,wedgeDE,detector.getNavigator().getPath(modulePath));
+ }
+ }
+ }
}
-}
+
+ private ILogicalVolume makeWedge(
+ Detector detector,
+ Subdetector subdet,
+ double innerR,
+ double outerR,
+ double thickness,
+ int nwedges,
+ int layern)
+ {
+ IMaterial material = detector.getTrackingVolume().getLogicalVolume().getMaterial();
+
+ String name = subdet.getName() + "_layer" + layern + "_wedge";
+
+ double dz = (outerR - innerR) / 2;
+ double dy1, dy2;
+ dy1 = dy2 = thickness / 2;
+ double dx1, dx2;
+ double dphi = Math.PI / nwedges;
+ dx1 = innerR * Math.tan(dphi);
+ dx2 = outerR * Math.tan(dphi);
+
+ Trd wedgeTrd = new Trd(name,dx1,dx2,dy1,dy2,dz);
+
+ ILogicalVolume wedgeLV = new LogicalVolume(name, wedgeTrd, material);
+
+ return wedgeLV;
+ }
+
+ private ILogicalVolume makeLayer(
+ Detector detector,
+ Subdetector subdet,
+ double innerR,
+ double outerR,
+ double thickness,
+ int nwedges,
+ Element layerElement
+ )
+ {
+ int layern;
+ try {
+ layern = layerElement.getAttribute("id").getIntValue();
+ }
+ catch (DataConversionException x)
+ {
+ throw new RuntimeException(x);
+ }
+
+ IMaterial material = detector.getTrackingVolume().getLogicalVolume().getMaterial();
+ String layerName = subdet.getName() + "_layer" + layern;
+
+ double dphi = Math.PI / nwedges;
+
+ double tubeInnerR, tubeOuterR;
+ tubeInnerR = innerR;
+ tubeOuterR = outerR / Math.cos(dphi);
+
+ Tube layerTube = new Tube(layerName,tubeInnerR,tubeOuterR,thickness/2);
+
+ // Make the layer LV.
+ ILogicalVolume layerLV = new LogicalVolume(layerName,layerTube,material);
+
+ // Make the wedge LV.
+ ILogicalVolume wedgeLV = makeWedge(detector, subdet, innerR, outerR, thickness, nwedges, layern);
+
+ // Make the modules in the wedge.
+ makeModules(subdet, wedgeLV, layerElement.getChild("module_parameters"), layern);
+
+ // Place the wedges in the layer.
+ double r = (innerR + outerR) / 2;
+ String wedgeName = wedgeLV.getName();
+ for (int i=0; i<nwedges; i++)
+ {
+ double phi = i * 2 * Math.PI / nwedges;
+ double x = r * Math.cos(phi);
+ double y = r * Math.sin(phi);
+
+ Translation3D p = new Translation3D(x,y,0);
+ Rotation3D rot = new RotationPassiveXYZ(-Math.PI/2,0.,Math.PI/2 - phi);
+ Transform3D transform = new Transform3D(p,rot);
+ new PhysicalVolume(
+ transform,
+ "wedge" + i,
+ wedgeLV,
+ layerLV,
+ i);
+ }
+
+ return layerLV;
+ }
+
+
+ private void makeModules(Subdetector subdet, ILogicalVolume wedgeLV, Element moduleElement, int layern)
+ {
+ double r_size;
+ try {
+ r_size = moduleElement.getAttribute("r_size").getDoubleValue();
+ }
+ catch (DataConversionException x)
+ {
+ throw new RuntimeException(x);
+ }
+
+ Trd moduleTrd = (Trd)wedgeLV.getSolid();
+ double dz = ((Trd)wedgeLV.getSolid()).getZHalfLength();
+ double dx1 = moduleTrd.getXHalfLength1();
+ double dx2 = moduleTrd.getXHalfLength2();
+ double dy1 = moduleTrd.getYHalfLength1();
+ double deltax = dx1 - dx2;
+ double zcurr = -dz;
+
+ List<Double> zcenters = new ArrayList<Double>();
+ List<Double> zsizes = new ArrayList<Double>();
+ List<Double> xsizes1 = new ArrayList<Double>();
+ List<Double> xsizes2 = new ArrayList<Double>();
+
+ while (zcurr + r_size <= dz)
+ {
+ zcenters.add(zcurr + r_size/2);
+ zsizes.add(r_size/2);
+ double xsize1 = dx2 + (zcurr + dz)/(2*dz) * deltax;
+ xsizes2.add(xsize1);
+ double xsize2 = dx2 + (zcurr + r_size + dz)/(2*dz) * deltax;
+ xsizes1.add(xsize2);
+ zcurr += r_size;
+ }
+ zsizes.add((dz - zcurr) / 2);
+ zcenters.add(dz - (dz - zcurr) / 2);
+ xsizes2.add(dx2 + (zcurr + dz)/(2*dz) * deltax);
+ xsizes1.add(dx1);
+
+ IMaterial sliceMaterial = wedgeLV.getMaterial();
+
+ for (int i=0; i<zcenters.size(); i++)
+ {
+ //String sliceName = subdet.getName() + "_layer" + layern + "_" + wedgeLV.getName() + "_module" + i;
+ String sliceName = "module" + i;
+
+ Trd sliceTrd = new Trd(sliceName,xsizes1.get(i),xsizes2.get(i),dy1,dy1,zsizes.get(i));
+
+ ILogicalVolume sliceLV = new LogicalVolume(sliceName, sliceTrd, sliceMaterial);
+
+ Transform3D trans = new Transform3D(new Translation3D(0,0,zcenters.get(i)));
+
+ new PhysicalVolume(
+ trans,
+ sliceName,
+ sliceLV,
+ wedgeLV,
+ i);
+ }
+ }
+
+ public Class getSubdetectorType()
+ {
+ return SiTrackerEndcap.class;
+ }
+}
\ No newline at end of file
