View Javadoc

1   package org.lcsim.geometry.subdetector;
2   
3   import org.jdom.Element;
4   import org.jdom.JDOMException;
5   import hep.graphics.heprep.HepRep;
6   import hep.graphics.heprep.HepRepFactory;
7   import hep.graphics.heprep.HepRepInstance;
8   import hep.graphics.heprep.HepRepInstanceTree;
9   import hep.graphics.heprep.HepRepType;
10  import hep.graphics.heprep.HepRepTypeTree;
11  import org.lcsim.geometry.layer.LayerStack;
12  
13  import java.util.Iterator;
14  import java.util.List;
15  import org.jdom.DataConversionException;
16  
17  /**
18   * @author Tony Johnson
19   * @author Jeremy McCormick <jeremym@slac.stanford.edu>
20   * @version $Id: DiskTracker.java,v 1.14 2010/12/03 01:21:39 jeremy Exp $
21   */
22  public class DiskTracker extends AbstractTracker
23  {
24      private double[] innerR;
25      private double[] outerR;
26      private double[] innerZ;
27      private double[] thickness;
28  
29      public double[] getInnerR()
30      {
31          return ( innerR );
32      }
33  
34      public double[] getOuterR()
35      {
36          return ( outerR );
37      }
38  
39      public double[] getInnerZ()
40      {
41          return ( innerZ );
42      }
43  
44      public double[] getThickness()
45      {
46          return ( thickness );
47      }
48  
49      DiskTracker( Element node ) throws JDOMException
50      {
51          super( node );
52          build( node );
53      }
54  
55      public boolean isEndcap()
56      {
57          return true;
58      }
59  
60      private void build( Element node ) throws DataConversionException
61      {
62          List layers = node.getChildren( "layer" );
63          int n = layers.size();
64          innerR = new double[ n ];
65          outerR = new double[ n ];
66          innerZ = new double[ n ];
67  
68          thickness = new double[ n ];
69          LayerStack layerStack = getLayering().getLayerStack();
70          double prevOuterZ = 0;
71          double thisOffset = 0;
72          for ( int i = 0; i < n; i++ )
73          {
74              Element layer = ( Element ) layers.get( i );
75              innerR[ i ] = layer.getAttribute( "inner_r" ).getDoubleValue();
76              outerR[ i ] = layer.getAttribute( "outer_r" ).getDoubleValue();
77              innerZ[ i ] = layer.getAttribute( "inner_z" ).getDoubleValue();
78  
79              /* Base offset for this layer */
80              thisOffset = innerZ[ i ];
81  
82              /* Subtract the previous outerZ to get distance between adjacent layers */
83              thisOffset -= prevOuterZ;
84  
85              /* Set next outerZ */
86              prevOuterZ = innerZ[ i ];
87  
88              /* Store the pre-offset into the layer object for distance calcs */
89              layerStack.getLayer( i ).setPreOffset( thisOffset );
90  
91              thickness[ i ] = 0;
92              for ( Iterator iter = layer.getChildren( "slice" ).iterator(); iter.hasNext(); )
93              {
94                  Element slice = ( Element ) iter.next();
95                  thickness[ i ] += slice.getAttribute( "thickness" ).getDoubleValue();
96              }
97  
98              /* Incr next outerZ by thickness of this layer */
99              prevOuterZ += thickness[ i ];
100         }
101 
102         // System.out.println("DiskTracker total thickness=" +
103         // getLayering().getThickness());
104     }
105 
106     public void appendHepRep( HepRepFactory factory, HepRep heprep )
107     {
108         HepRepInstanceTree instanceTree = heprep.getInstanceTreeTop( "Detector", "1.0" );
109         HepRepTypeTree typeTree = heprep.getTypeTree( "DetectorType", "1.0" );
110         HepRepType endcap = typeTree.getType( "Endcap" );
111 
112         HepRepType type = factory.createHepRepType( endcap, getName() );
113         type.addAttValue( "drawAs", "Cylinder" );
114 
115         type.addAttValue( "color", getVisAttributes().getColor() );
116 
117         double flip = 1;
118         for ( ;; )
119         {
120             for ( int i = 0; i < innerR.length; i++ )
121             {
122                 HepRepInstance instance = factory.createHepRepInstance( instanceTree, type );
123                 instance.addAttValue( "radius", innerR[ i ] );
124                 factory.createHepRepPoint( instance, 0, 0, flip * innerZ[ i ] );
125                 factory.createHepRepPoint( instance, 0, 0, flip * ( innerZ[ i ] + thickness[ i ] ) );
126 
127                 HepRepInstance instance2 = factory.createHepRepInstance( instanceTree, type );
128                 instance2.addAttValue( "radius", outerR[ i ] );
129                 factory.createHepRepPoint( instance2, 0, 0, flip * innerZ[ i ] );
130                 factory.createHepRepPoint( instance2, 0, 0, flip * ( innerZ[ i ] + thickness[ i ] ) );
131             }
132             if ( !getReflect() || flip < 0 )
133                 break;
134             flip = -1;
135         }
136     }
137 }