1 package org.lcsim.recon.tracking.trflayer;
2
3 import java.util.List;
4 import java.util.ArrayList;
5 import java.util.Iterator;
6 import org.lcsim.recon.tracking.trfutil.Assert;
7 import org.lcsim.recon.tracking.trfbase.Surface;
8 import org.lcsim.recon.tracking.trfbase.HitGenerator;
9 import org.lcsim.recon.tracking.trfbase.VTrack;
10 import org.lcsim.recon.tracking.trfbase.Propagator;
11 import org.lcsim.recon.tracking.trfbase.PropStat;
12 import org.lcsim.recon.tracking.trflayer.Layer;
13 import org.lcsim.recon.tracking.trfbase.Cluster;
14
15 /**
16 * Generic layer simulator. An input track is propagated to each active surface
17 * in a layer and an associated hit generator is used to generate a cluster
18 * and add it to the layer. This class takes shared ownership of the layer,
19 * the hit generators and the propagator. The constructor requires that
20 * the surfaces associated with the hit generators match those of the layer.
21 * Here match means pure_equal. It is up to the hit generator to decide
22 * whether the hit is in bounds.
23 *
24 *@author Norman A. Graf
25 *@version 1.0
26 *
27 **/
28
29
30 public class LayerSimGeneric extends LayerSimulator
31 {
32 // attributes
33
34 // hit generators
35 private List _gens;
36
37 // propagator
38 private Propagator _prop;
39
40 // methods
41
42 //
43
44 /**
45 *constructor for one surface
46 * Requires that generator surface is same as layer surface.
47 *
48 * @param lyr Layer
49 * @param gen HitGenerator
50 * @param prop Propagator
51 */
52 public LayerSimGeneric(Layer lyr, HitGenerator gen, Propagator prop)
53 {
54 super(lyr);
55 _gens = new ArrayList();
56 _gens.add(gen);
57 _prop = prop;
58 Assert.assertTrue( lyr != null );
59 Assert.assertTrue( gen != null );
60 Assert.assertTrue( prop != null );
61 Assert.assertTrue( checkSurfaces(layer(),_gens) );
62 }
63
64 //
65
66 /**
67 *constructor for multiple surfaces
68 * Requires that generator surfaces are the same as the layer surface.
69 *
70 * @param lyr Layer
71 * @param gens List of HitGenerators
72 * @param prop Propagator
73 */
74 public LayerSimGeneric(Layer lyr, List gens, Propagator prop)
75 {
76 super(lyr);
77 _gens = new ArrayList();
78 _gens.add(gens);
79 _prop = prop;
80 Assert.assertTrue( lyr != null );
81 Assert.assertTrue( gens.size() > 0 );
82 Assert.assertTrue( prop != null );
83 Assert.assertTrue( checkSurfaces(layer(),_gens) );
84 }
85
86 //
87
88 /**
89 *return the list of generators
90 *
91 * @return List if HitGenerators
92 */
93 public List generators()
94 {
95 List gens = new ArrayList();;
96
97 for ( Iterator igen=_gens.iterator(); igen.hasNext(); )
98 gens.add( igen.next() );
99 return gens;
100
101 }
102
103 //
104
105 /**
106 *Generate clusters
107 *
108 * @param trv0 VTrack for which to generate clusters
109 * @param mcid MC track ID to associate with track
110 */
111 public void addClusters( VTrack trv0, int mcid)
112 {
113
114 // Fetch the list of layer surfaces.
115 List lsrfs = layer().clusterSurfaces();
116
117 // Loop over surfaces.
118 Iterator ilsrf = lsrfs.iterator();
119 Iterator igen = _gens.iterator();
120 while ( ilsrf.hasNext() )
121 {
122 Surface lsrf = (Surface) ilsrf.next();
123 HitGenerator gen = (HitGenerator) igen.next();
124 Surface gsrf = gen.surface();
125
126 // Propagate track to generator surface.
127 VTrack trv = new VTrack(trv0);
128 PropStat pstat = _prop.vecProp(trv,gsrf);
129 if ( ! pstat.success() ) continue;
130
131 // Generate a cluster and add to layer.
132 Cluster clu = gen.newCluster(trv, mcid);
133 if ( clu != null )
134 layer().addCluster(clu,lsrf);
135
136 } // end loop over surfaces
137
138 }
139
140
141
142 /**
143 * output stream
144 *
145 * @return String representation of this class
146 */
147 public String toString()
148 {
149 StringBuffer sb = new StringBuffer(getClass().getName()+" Generic layer simulator.\n");
150 sb.append("Layer: \n"+ layer() + "\n");
151 sb.append("Propagator: " + _prop + "\n");
152 int size = _gens.size();
153 sb.append("Hit generators (count is " + size + "):");
154 for ( Iterator igen=_gens.iterator(); igen.hasNext(); ) sb.append(igen.next());
155 return sb.toString();
156 }
157
158 //**********************************************************************
159 // Helper functions.
160 //**********************************************************************
161
162 // Return true if the layer and generator surfaces match.
163 private static boolean
164 checkSurfaces( Layer lyr,
165 List gens)
166 {
167 // Retrieve the active layer surfaces.
168 List lsrfs = lyr.clusterSurfaces();
169 if ( lsrfs.size() != gens.size() ) return false;
170 Iterator ilsrf = lsrfs.iterator();
171 Iterator igen = gens.iterator();
172 // Require pure surfaces to match.
173 while ( igen.hasNext() )
174 {
175 Surface lsrf = (Surface) ilsrf.next();
176 HitGenerator gen = (HitGenerator) igen.next();
177 // if ( ! pgen ) return false;
178 Surface gsrf = gen.surface();
179 if ( ! lsrf.pureEqual(gsrf) ) return false;
180 }
181 return true;
182 }
183
184 }
185