1 /*
2 * HitZPlane2_Test.java
3 *
4 * Created on July 24, 2007, 11:03 PM
5 *
6 * $Id: HitZPlane2_Test.java,v 1.1.1.1 2010/04/08 20:38:00 jeremy Exp $
7 */
8
9 package org.lcsim.recon.tracking.trfzp;
10
11 import java.util.ArrayList;
12 import java.util.List;
13 import junit.framework.TestCase;
14 import org.lcsim.recon.tracking.trfbase.ETrack;
15 import org.lcsim.recon.tracking.trfbase.Hit;
16 import org.lcsim.recon.tracking.trfbase.HitDerivative;
17 import org.lcsim.recon.tracking.trfbase.HitError;
18 import org.lcsim.recon.tracking.trfbase.HitVector;
19 import org.lcsim.recon.tracking.trfbase.TrackError;
20 import org.lcsim.recon.tracking.trfbase.TrackVector;
21 import org.lcsim.recon.tracking.trfutil.Assert;
22
23 /**
24 *
25 * @author Norman Graf
26 */
27 public class HitZPlane2_Test extends TestCase
28 {
29 private boolean debug;
30 // calculate hm from a track vector
31 static HitVector calc_hm(TrackVector vec)
32 {
33 double x_track = vec.get(SurfZPlane.IX);
34 double y_track = vec.get(SurfZPlane.IY);
35
36 return new HitVector( x_track, y_track );
37 }
38
39 // calculate dhm from error matrix
40 static HitError calc_dhm(TrackError err)
41 {
42 double exx_track = err.get(SurfZPlane.IX,SurfZPlane.IX);
43 double exy_track = err.get(SurfZPlane.IX,SurfZPlane.IY);
44 double eyy_track = err.get(SurfZPlane.IY,SurfZPlane.IY);
45
46 return new HitError( exx_track, exy_track, eyy_track);
47 }
48
49 // compare HitError and error matrix of the cluster
50
51 static boolean hiteqsm( HitError lhs, HitError rhs)
52 {
53 if ( lhs.size() != rhs.size() || lhs.size()!=2 ) return false;
54 return ( (lhs.get(0,0) == rhs.get(ClusZPlane2.IX,ClusZPlane2.IX)) &&
55 (lhs.get(0,1) == rhs.get(ClusZPlane2.IX,ClusZPlane2.IY)) &&
56 (lhs.get(1,1) == rhs.get(ClusZPlane2.IY,ClusZPlane2.IY)) );
57 }
58
59 // compare HitVector and vector of the cluster
60
61 static boolean hiteqvec( HitVector lhs, HitVector rhs)
62 {
63 if ( lhs.size() != rhs.size() || lhs.size()!=2 ) return false;
64 return ( (lhs.get(0) == rhs.get(ClusZPlane2.IX)) &&
65 (lhs.get(1) == rhs.get(ClusZPlane2.IY)) );
66 }
67
68
69 //**********************************************************************
70
71 /** Creates a new instance of HitZPlane2_Test */
72 public void testHitZPlane2()
73 {
74 String component = "HitZPlane2";
75 String ok_prefix = component + " (I): ";
76 String error_prefix = component + " test (E): ";
77
78 if(debug) System.out.println( ok_prefix
79 + "-------- Testing component " + component
80 + ". --------" );
81
82
83 int IX = ClusZPlane2.IX;
84 int IY = ClusZPlane2.IY;
85
86
87 if(debug) System.out.println( ok_prefix + "Test cluster constructors." );
88 List mcids = new ArrayList();
89 mcids.add(new Integer(1));
90 mcids.add(new Integer(2));
91
92 double zpos1 = 10.0;
93 double x1 = 1.0;
94 double y1 = 1.1;
95 HitError dhm1 = new HitError(2);
96 dhm1.set(ClusZPlane2.IX,ClusZPlane2.IX, 0.02);
97 dhm1.set(ClusZPlane2.IX,ClusZPlane2.IY, 0.01);
98 dhm1.set(ClusZPlane2.IY,ClusZPlane2.IY, 0.03);
99 SurfZPlane szp1 = new SurfZPlane(zpos1);
100 ClusZPlane2 hcp1 = new ClusZPlane2(zpos1,x1,y1,dhm1.get(ClusZPlane2.IX,ClusZPlane2.IX),dhm1.get(ClusZPlane2.IY,ClusZPlane2.IY),dhm1.get(ClusZPlane2.IX,ClusZPlane2.IY));
101 ClusZPlane2 hcp1a = new ClusZPlane2(zpos1,x1,y1,dhm1.get(ClusZPlane2.IX,ClusZPlane2.IX),dhm1.get(ClusZPlane2.IY,ClusZPlane2.IY),dhm1.get(ClusZPlane2.IX,ClusZPlane2.IY),mcids);
102
103 Assert.assertTrue( hcp1.equals(hcp1a));
104 Assert.assertTrue(hcp1.x() == x1 );
105 Assert.assertTrue(hcp1.y() == y1 );
106 Assert.assertTrue(hcp1.dX2() == 0.02 );
107 Assert.assertTrue(hcp1.dY2() == 0.03 );
108 Assert.assertTrue(hcp1.dXdY() == 0.01 );
109 Assert.assertTrue(hcp1a.x() == x1 );
110 Assert.assertTrue(hcp1a.y() == y1 );
111 Assert.assertTrue(hcp1a.dX2() == 0.02 );
112 Assert.assertTrue(hcp1a.dY2() == 0.03 );
113 Assert.assertTrue(hcp1a.dXdY() == 0.01 );
114 Assert.assertTrue(hcp1.mcIds().size()==0);
115 Assert.assertTrue(hcp1a.mcIds().size()==2);
116
117 if(debug) System.out.println( hcp1 );
118
119 double zpos2 = 20.0;
120 double x2 = 2.0;
121 double y2 = 2.2;
122 HitVector hm2 = new HitVector(2);
123 hm2.set(ClusZPlane2.IX, x2);
124 hm2.set(ClusZPlane2.IY, y2);
125 HitError dhm2 = new HitError(2);
126 dhm2.set(ClusZPlane2.IX,ClusZPlane2.IX, 0.022);
127 dhm2.set(ClusZPlane2.IX,ClusZPlane2.IY, 0.012);
128 dhm2.set(ClusZPlane2.IY,ClusZPlane2.IY, 0.032);
129 ClusZPlane2 hcp2 = new ClusZPlane2(zpos2,x2,y2,dhm2.get(ClusZPlane2.IX,ClusZPlane2.IX),dhm2.get(ClusZPlane2.IY,ClusZPlane2.IY),dhm2.get(ClusZPlane2.IX,ClusZPlane2.IY));
130 ClusZPlane2 hcp2a = new ClusZPlane2(zpos2,x2,y2,dhm2.get(ClusZPlane2.IX,ClusZPlane2.IX),dhm2.get(ClusZPlane2.IY,ClusZPlane2.IY),dhm2.get(ClusZPlane2.IX,ClusZPlane2.IY),mcids);
131
132 Assert.assertTrue(hcp2.equals(hcp2a));
133 Assert.assertTrue(hcp2.mcIds().size()==0);
134 Assert.assertTrue(hcp2a.mcIds().size()==2);
135 Assert.assertTrue(hcp2.x() == x2 );
136 Assert.assertTrue(hcp2.y() == y2 );
137 Assert.assertTrue(hcp2.dX2() == 0.022 );
138 Assert.assertTrue(hcp2.dY2() == 0.032 );
139 Assert.assertTrue(hcp2.dXdY() == 0.012 );
140 Assert.assertTrue(hcp2a.x() == x2 );
141 Assert.assertTrue(hcp2a.y() == y2 );
142 Assert.assertTrue(hcp2a.dX2() == 0.022 );
143 Assert.assertTrue(hcp2a.dY2() == 0.032 );
144 Assert.assertTrue(hcp2a.dXdY() == 0.012 );
145
146 HitVector hm1 = new HitVector(2);
147 hm1.set(ClusZPlane2.IX, x1);
148 hm1.set(ClusZPlane2.IY, y1);
149 ClusZPlane2 hcp3 = new ClusZPlane2(zpos1,x1,y1,dhm1.get(ClusZPlane2.IX,ClusZPlane2.IX),dhm1.get(ClusZPlane2.IY,ClusZPlane2.IY),dhm1.get(ClusZPlane2.IX,ClusZPlane2.IY));
150 ClusZPlane2 hcp3a = new ClusZPlane2(zpos1,x1,y1,dhm1.get(ClusZPlane2.IX,ClusZPlane2.IX),dhm1.get(ClusZPlane2.IY,ClusZPlane2.IY),dhm1.get(ClusZPlane2.IX,ClusZPlane2.IY),mcids);
151
152 ClusZPlane2 hcp3b = new ClusZPlane2(hcp3a);
153 ClusZPlane2 hcp3c = new ClusZPlane2(hcp3);
154
155 Assert.assertTrue(hcp3.x() == x1 );
156 Assert.assertTrue(hcp3.y() == y1 );
157 Assert.assertTrue(hcp3.dX2() == 0.02 );
158 Assert.assertTrue(hcp3.dY2() == 0.03 );
159 Assert.assertTrue(hcp3.dXdY() == 0.01 );
160 Assert.assertTrue(hcp3a.x() == x1 );
161 Assert.assertTrue(hcp3a.y() == y1 );
162 Assert.assertTrue(hcp3a.dX2() == 0.02 );
163 Assert.assertTrue(hcp3a.dY2() == 0.03 );
164 Assert.assertTrue(hcp3a.dXdY() == 0.01 );
165
166 // test two diferent constructors
167 Assert.assertTrue(hcp3b.equals(hcp3a));
168 Assert.assertTrue(hcp3.equals(hcp3c));
169 Assert.assertTrue(hcp3.mcIds().size()==0);
170 Assert.assertTrue(hcp3a.mcIds().size()==2);
171 Assert.assertTrue(hcp3c.mcIds().size()==0);
172 Assert.assertTrue(hcp3b.mcIds().size()==2);
173
174 Assert.assertTrue( hcp3.equals(hcp1) );
175
176 //********************************************************************
177
178 if(debug) System.out.println( ok_prefix + "Test cluster type ID." );
179 if(debug) System.out.println( hcp1.type() );
180 if(debug) System.out.println( hcp2.type() );
181 Assert.assertTrue( hcp1.type() != null );
182 Assert.assertTrue( hcp1.type().equals(hcp2.type()) );
183
184 //********************************************************************
185
186 if(debug) System.out.println( ok_prefix + "Test cluster accessors." );
187 if(debug) System.out.println( hcp1 );
188 if(debug) System.out.println( hcp1.surface() );
189
190 Assert.assertTrue( hcp1.surface().equals(szp1) );
191
192 //********************************************************************
193
194 if(debug) System.out.println( ok_prefix + "Generate a hit." );
195 TrackVector vec = new TrackVector();
196 TrackError err = new TrackError();
197 HitDerivative der_expect = new HitDerivative(2);
198 der_expect.set(0,0, 1.);
199 der_expect.set(1,1, 1.);
200 vec.set(SurfZPlane.IX, 1.1);
201 vec.set(SurfZPlane.IY, 40.0);
202 err.set(SurfZPlane.IX,SurfZPlane.IX, 0.04);
203 err.set(SurfZPlane.IX,SurfZPlane.IY, 0.03);
204 err.set(SurfZPlane.IY,SurfZPlane.IY, 0.02);
205 ETrack tre1 = new ETrack(szp1.newPureSurface(),vec,err);
206 List tclus11 = hcp1.predict(tre1,hcp1);
207 Assert.assertTrue( tclus11.size() == 1 );
208 Hit pre11 = (Hit)tclus11.get(0);
209 double maxdiff = 1.e-12;
210 if(debug) System.out.println( pre11.size() );
211 Assert.assertTrue( pre11.size() == 2);
212 if(debug) System.out.println( pre11.measuredVector() );
213 Assert.assertTrue( (( HitZPlane2)pre11).x() == pre11.predictedVector().get(IX) );
214 Assert.assertTrue( (( HitZPlane2)pre11).y() == pre11.predictedVector().get(IY) );
215 Assert.assertTrue( (( HitZPlane2)pre11).dX2() == pre11.predictedError().get(IX,IX) );
216 Assert.assertTrue( (( HitZPlane2)pre11).dY2() == pre11.predictedError().get(IY,IY) );
217 Assert.assertTrue( (( HitZPlane2)pre11).dXdY() == pre11.predictedError().get(IX,IY) ); Assert.assertTrue( hiteqvec(pre11.measuredVector(), hm1) );
218 if(debug) System.out.println( pre11.measuredError() );
219 Assert.assertTrue( hiteqsm(pre11.measuredError(), dhm1) );
220 if(debug) System.out.println( pre11.predictedVector() );
221 Assert.assertTrue( pre11.predictedVector().equals(calc_hm(vec)) );
222 if(debug) System.out.println( pre11.predictedError() );
223 Assert.assertTrue( pre11.predictedError().equals(calc_dhm(err)) );
224 if(debug) System.out.println( pre11.dHitdTrack() );
225 Assert.assertTrue( pre11.dHitdTrack().equals(der_expect) );
226 if(debug) System.out.println( pre11.differenceVector() );
227 Assert.assertTrue( Math.abs(pre11.differenceVector().get(0) -
228 calc_hm(vec).get(0) + hm1.get(0)) < maxdiff );
229 Assert.assertTrue( Math.abs(pre11.differenceVector().get(1) -
230 calc_hm(vec).get(1) + hm1.get(1)) < maxdiff );
231
232 //********************************************************************
233
234 if(debug) System.out.println( ok_prefix + "Generate hit for a different track."
235 );
236 vec.set(SurfZPlane.IX, 1.2);
237 ETrack tre2 = new ETrack(szp1.newPureSurface(),vec,err);
238 List tclus12 = hcp1.predict(tre2,hcp1);
239 Assert.assertTrue( tclus12.size() == 1 );
240 Hit pre12 = (Hit)tclus12.get(0);
241 if(debug) System.out.println( pre12.size() );
242 Assert.assertTrue( pre12.size() == 2);
243 if(debug) System.out.println( pre12.measuredVector() );
244 Assert.assertTrue( hiteqvec(pre12.measuredVector(), hm1) );
245 if(debug) System.out.println( pre12.measuredError() );
246 Assert.assertTrue( hiteqsm(pre12.measuredError(), dhm1) );
247 if(debug) System.out.println( pre12.predictedVector() );
248 Assert.assertTrue( pre12.predictedVector().equals(calc_hm(vec)) );
249 if(debug) System.out.println( pre12.predictedError() );
250 Assert.assertTrue( pre12.predictedError().equals(calc_dhm(err)) );
251 if(debug) System.out.println( pre12.dHitdTrack() );
252 Assert.assertTrue( pre12.dHitdTrack().equals(der_expect) );
253 if(debug) System.out.println( pre12.differenceVector() );
254 Assert.assertTrue( Math.abs(pre12.differenceVector().get(0) -
255 calc_hm(vec).get(0) + hm1.get(0)) < maxdiff );
256 Assert.assertTrue( Math.abs(pre12.differenceVector().get(1) -
257 calc_hm(vec).get(1) + hm1.get(1)) < maxdiff );
258 // same cluster ==> same hit (even though track changes)
259 Assert.assertTrue( pre11.equals(pre11) );
260 Assert.assertTrue( ! ( pre11.notEquals(pre11) ) );
261 Assert.assertTrue( pre11.equals(pre12) );
262
263 //********************************************************************
264
265 if(debug) System.out.println( ok_prefix + "Generate hit for a different cluster."
266 );
267 List tclus22 = hcp2.predict(tre2,hcp2);
268 Assert.assertTrue( tclus22.size() == 1 );
269 Hit pre22 = (Hit)tclus22.get(0);
270 if(debug) System.out.println( pre22.size() );
271 Assert.assertTrue( pre22.size() == 2);
272 if(debug) System.out.println( pre22.measuredVector() );
273 Assert.assertTrue( hiteqvec(pre22.measuredVector(), hm2) );
274 if(debug) System.out.println( pre22.measuredError() );
275 Assert.assertTrue( hiteqsm(pre22.measuredError(), dhm2) );
276 if(debug) System.out.println( pre22.predictedVector() );
277 Assert.assertTrue( pre22.predictedVector().equals(calc_hm(vec)) );
278 if(debug) System.out.println( pre22.predictedError() );
279 Assert.assertTrue( pre22.predictedError().equals(calc_dhm(err)) );
280 if(debug) System.out.println( pre22.dHitdTrack() );
281 Assert.assertTrue( pre22.dHitdTrack().equals(der_expect) );
282 if(debug) System.out.println( pre22.differenceVector() );
283 Assert.assertTrue( Math.abs(pre22.differenceVector().get(0) -
284 calc_hm(vec).get(0) + hm2.get(0)) < maxdiff );
285 Assert.assertTrue( Math.abs(pre22.differenceVector().get(1) -
286 calc_hm(vec).get(1) + hm2.get(1)) < maxdiff );
287 // different cluster ==> different hit
288 Assert.assertTrue( pre22.notEquals(pre11) );
289 Assert.assertTrue( ! ( pre22.equals(pre11) ) );
290 Assert.assertTrue( pre22.notEquals(pre12) );
291
292 //********************************************************************
293
294 if(debug) System.out.println( ok_prefix + "Update hit." );
295 if(debug) System.out.println( pre11 );
296 pre11.update(tre2);
297 if(debug) System.out.println( pre11 );
298 Assert.assertTrue( pre11.size() == 2);
299 if(debug) System.out.println( pre11.measuredVector() );
300 Assert.assertTrue( hiteqvec(pre11.measuredVector(), hm1) );
301 if(debug) System.out.println( pre11.measuredError() );
302 Assert.assertTrue( hiteqsm(pre11.measuredError(), dhm1) );
303 if(debug) System.out.println( pre11.predictedVector() );
304 Assert.assertTrue( pre11.predictedVector().equals(calc_hm(vec)) );
305 if(debug) System.out.println( pre11.predictedError() );
306 Assert.assertTrue( pre11.predictedError().equals(calc_dhm(err)) );
307 if(debug) System.out.println( pre11.dHitdTrack() );
308 Assert.assertTrue( pre11.dHitdTrack().equals(der_expect) );
309 if(debug) System.out.println( pre11.differenceVector() );
310 Assert.assertTrue( Math.abs(pre11.differenceVector().get(0) -
311 calc_hm(vec).get(0) + hm1.get(0)) < maxdiff );
312 Assert.assertTrue( Math.abs(pre11.differenceVector().get(1) -
313 calc_hm(vec).get(1) + hm1.get(1)) < maxdiff );
314 //********************************************************************
315
316 if(debug) System.out.println( ok_prefix + "Check hit type and equality." );
317 if(debug) System.out.println( HitZPlane2.staticType());
318 if(debug) System.out.println( pre11.type() );
319 if(debug) System.out.println( pre12.type() );
320 Assert.assertTrue( pre11.type() != null );
321 Assert.assertTrue( pre11.type().equals(HitZPlane2.staticType()) );
322 Assert.assertTrue( pre11.type().equals(pre12.type()) );
323
324
325 //********************************************************************
326
327 if(debug) System.out.println( ok_prefix
328 + "------------- All tests passed. -------------" );
329
330 //********************************************************************
331 }
332
333 }