View Javadoc

1   package org.lcsim.geometry.subdetector;
2   
3   import java.util.Iterator;
4   import java.util.List;
5   import org.jdom.DataConversionException;
6   import org.jdom.Element;
7   import org.jdom.JDOMException;
8   import hep.graphics.heprep.HepRep;
9   import hep.graphics.heprep.HepRepFactory;
10  import hep.graphics.heprep.HepRepInstance;
11  import hep.graphics.heprep.HepRepInstanceTree;
12  import hep.graphics.heprep.HepRepType;
13  import hep.graphics.heprep.HepRepTypeTree;
14  import org.lcsim.geometry.layer.LayerStack;
15  
16  /**
17   * 
18   * @author tonyj
19   * 
20   */
21  public class MultiLayerTracker extends AbstractTracker
22  {
23      // FIXME: This is a bad way to store geometry data for each layer.
24      private double[] innerR;
25      private double[] outerZ;
26  
27      // FIXME: This duplicates functionality provided by the layering engine.
28      private double[] thickness;
29  
30      public double[] getInnerR()
31      {
32          return ( innerR );
33      }
34  
35      public double[] getOuterZ()
36      {
37          return ( outerZ );
38      }
39  
40      MultiLayerTracker( Element node ) throws JDOMException
41      {
42          super( node );
43          build( node );
44      }
45  
46      public boolean isBarrel()
47      {
48          return true;
49      }
50  
51      private void build( Element node ) throws DataConversionException
52      {
53          List layers = node.getChildren( "layer" );
54          int n = layers.size();
55          innerR = new double[ n ];
56          outerZ = new double[ n ];
57          thickness = new double[ n ];
58          LayerStack layerStack = getLayering().getLayerStack();
59          double prevOuterR = 0;
60          double thisOffset = 0;
61          for ( int i = 0; i < n; i++ )
62          {
63              Element layer = ( Element ) layers.get( i );
64  
65              innerR[ i ] = layer.getAttribute( "inner_r" ).getDoubleValue();
66              outerZ[ i ] = layer.getAttribute( "outer_z" ).getDoubleValue();
67  
68              /* Base offset for this layer */
69              thisOffset = innerR[ i ];
70  
71              /* Subtract the previous outerR to get distance between adjacent layers */
72              thisOffset -= prevOuterR;
73  
74              /* Set next outerR */
75              prevOuterR = innerR[ i ];
76  
77              /* Store the pre-offset into the layer object for distance calcs */
78              layerStack.getLayer( i ).setPreOffset( thisOffset );
79  
80              thickness[ i ] = 0;
81              for ( Iterator iter = layer.getChildren( "slice" ).iterator(); iter.hasNext(); )
82              {
83                  Element slice = ( Element ) iter.next();
84                  thickness[ i ] += slice.getAttribute( "thickness" ).getDoubleValue();
85              }
86  
87              /* Incr next outerR by thickness of this layer */
88              prevOuterR += thickness[ i ];
89          }
90          // System.out.println("layering total thickness = " +
91          // layerStack.getTotalThickness());
92      }
93  
94      public void appendHepRep( HepRepFactory factory, HepRep heprep )
95      {
96          HepRepInstanceTree instanceTree = heprep.getInstanceTreeTop( "Detector", "1.0" );
97          HepRepTypeTree typeTree = heprep.getTypeTree( "DetectorType", "1.0" );
98          HepRepType barrel = typeTree.getType( "Barrel" );
99  
100         HepRepType type = factory.createHepRepType( barrel, getName() );
101         
102         type.addAttValue( "drawAs", "Cylinder" );
103         type.addAttValue( "color", getVisAttributes().getColor() );
104         
105         for ( int i = 0; i < innerR.length; i++ )
106         {
107             HepRepInstance instance = factory.createHepRepInstance( instanceTree, type );
108             instance.addAttValue( "radius", innerR[ i ] );
109             factory.createHepRepPoint( instance, 0, 0, -outerZ[ i ] );
110             factory.createHepRepPoint( instance, 0, 0, outerZ[ i ] );
111 
112             HepRepInstance instance2 = factory.createHepRepInstance( instanceTree, type );
113             instance2.addAttValue( "radius", innerR[ i ] + thickness[ i ] );
114             factory.createHepRepPoint( instance2, 0, 0, -outerZ[ i ] );
115             factory.createHepRepPoint( instance2, 0, 0, outerZ[ i ] );
116         }
117     }
118 }