1 /*
2 * HitXYPlane2_Test.java
3 *
4 * Created on July 24, 2007, 10:24 PM
5 *
6 * $Id: HitXYPlane2_Test.java,v 1.1.1.1 2010/04/08 20:38:00 jeremy Exp $
7 */
8
9 package org.lcsim.recon.tracking.trfxyp;
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 HitXYPlane2_Test extends TestCase
28 {
29 private boolean debug;
30
31 // calculate hm from a track vector
32 static HitVector calc_hm(TrackVector vec)
33 {
34 double v_track = vec.get(SurfXYPlane.IV);
35 double z_track = vec.get(SurfXYPlane.IZ);
36
37 return new HitVector( v_track, z_track );
38 }
39
40 // calculate dhm from error matrix
41 static HitError calc_dhm(TrackError err)
42 {
43 double evv_track = err.get(SurfXYPlane.IV,SurfXYPlane.IV);
44 double evz_track = err.get(SurfXYPlane.IV,SurfXYPlane.IZ);
45 double ezz_track = err.get(SurfXYPlane.IZ,SurfXYPlane.IZ);
46
47 return new HitError( evv_track, evz_track, ezz_track);
48 }
49
50 // compare HitError and error matrix of the cluster
51
52 static boolean hiteqsm( HitError lhs, HitError rhs)
53 {
54 if ( lhs.size() != rhs.size() || lhs.size()!=2 ) return false;
55 return ( (lhs.get(0,0) == rhs.get(ClusXYPlane2.IV,ClusXYPlane2.IV)) &&
56 (lhs.get(0,1) == rhs.get(ClusXYPlane2.IV,ClusXYPlane2.IZ)) &&
57 (lhs.get(1,1) == rhs.get(ClusXYPlane2.IZ,ClusXYPlane2.IZ)) );
58 }
59
60 // compare HitVector and vector of the cluster
61
62 static boolean hiteqvec( HitVector lhs, HitVector rhs)
63 {
64 if ( lhs.size() != rhs.size() || lhs.size()!=2 ) return false;
65 return ( (lhs.get(0) == rhs.get(ClusXYPlane2.IV)) &&
66 (lhs.get(1) == rhs.get
67 (ClusXYPlane2.IZ)) );
68 }
69 /** Creates a new instance of HitXYPlane2_Test */
70 public void testHitXYPlane2()
71 {
72 String component = "HitXYPlane2";
73 String ok_prefix = component + " (I): ";
74 String error_prefix = component + " test (E): ";
75
76 if(debug) System.out.println( ok_prefix
77 + "-------- Testing component " + component
78 + ". --------" );
79
80 if(debug) System.out.println( ok_prefix + "Test cluster constructors." );
81
82 int IV = ClusXYPlane2.IV;
83 int IZ = ClusXYPlane2.IZ;
84
85
86 List mcids = new ArrayList();
87 mcids.add(new Integer(1));
88 mcids.add(new Integer(2));
89
90 double dist1 = 10.0;
91 double phi1 = Math.PI/3.;
92 double v1 = 1.0;
93 double z1 = 1.1;
94 HitError dhm1 = new HitError(2);
95 dhm1.set(ClusXYPlane2.IV,ClusXYPlane2.IV, 0.02);
96 dhm1.set(ClusXYPlane2.IV,ClusXYPlane2.IZ, 0.01);
97 dhm1.set(ClusXYPlane2.IZ,ClusXYPlane2.IZ, 0.03);
98 SurfXYPlane szp1 = new SurfXYPlane(dist1,phi1);
99 ClusXYPlane2 hcp1 = new ClusXYPlane2(dist1,phi1,v1,z1,dhm1.get(ClusXYPlane2.IV,ClusXYPlane2.IV),dhm1.get(ClusXYPlane2.IZ,ClusXYPlane2.IZ),dhm1.get(ClusXYPlane2.IV,ClusXYPlane2.IZ));
100 ClusXYPlane2 hcp1a = new ClusXYPlane2(dist1,phi1,v1,z1,dhm1.get(ClusXYPlane2.IV,ClusXYPlane2.IV),dhm1.get(ClusXYPlane2.IZ,ClusXYPlane2.IZ),dhm1.get(ClusXYPlane2.IV,ClusXYPlane2.IZ),mcids);
101
102 Assert.assertTrue(hcp1.equals(hcp1a));
103 Assert.assertTrue(hcp1.v() == v1 );
104 // Assert.assertTrue(hcp1.get_dhm().equals(dhm1) );
105 // Assert.assertTrue(hcp1.get_hm().equals(HitVector(v1,z1)) );
106 Assert.assertTrue(hcp1.z() == z1 );
107 Assert.assertTrue(hcp1.dV2() == 0.02 );
108 Assert.assertTrue(hcp1.dZ2() == 0.03 );
109 Assert.assertTrue(hcp1.dVdZ() == 0.01 );
110 Assert.assertTrue(hcp1a.v() == v1 );
111 Assert.assertTrue(hcp1a.z() == z1 );
112 Assert.assertTrue(hcp1a.dV2() == 0.02 );
113 Assert.assertTrue(hcp1a.dZ2() == 0.03 );
114 Assert.assertTrue(hcp1a.dVdZ() == 0.01 );
115 Assert.assertTrue(hcp1.mcIds().size()==0);
116 Assert.assertTrue(hcp1a.mcIds().size()==2);
117
118 double dist2 = 20.0;
119 double phi2 = Math.PI/5.;
120 double v2 = 2.0;
121 double z2 = 2.2;
122 HitVector hm2 = new HitVector(2);
123 hm2.set(ClusXYPlane2.IV, v2);
124 hm2.set(ClusXYPlane2.IZ, z2);
125 HitError dhm2 = new HitError(2);
126 dhm2.set(ClusXYPlane2.IV,ClusXYPlane2.IV, 0.022);
127 dhm2.set(ClusXYPlane2.IV,ClusXYPlane2.IZ, 0.012);
128 dhm2.set(ClusXYPlane2.IZ,ClusXYPlane2.IZ, 0.032);
129 /*
130 ClusXYPlane2 hcp2 = new ClusXYPlane2(dist2,phi2,v2,z2,dhm2);
131 ClusXYPlane2 hcp2a = new ClusXYPlane2(dist2,phi2,v2,z2,dhm2);
132 Assert.assertTrue( hcp2.equals(hcp2a) );
133 // ClusterPtr phcp2 = &hcp2;
134 Assert.assertTrue(hcp2.get_v() == v2 );
135 Assert.assertTrue(hcp2.get_z() == z2 );
136 Assert.assertTrue(hcp2.get_dv2() == 0.022 );
137 Assert.assertTrue(hcp2.get_dz2() == 0.032 );
138 Assert.assertTrue(hcp2.get_dvdz() == 0.012 );
139 Assert.assertTrue(hcp2a.get_v() == v2 );
140 Assert.assertTrue(hcp2a.get_z() == z2 );
141 Assert.assertTrue(hcp2a.get_dv2() == 0.022 );
142 Assert.assertTrue(hcp2a.get_dz2() == 0.032 );
143 Assert.assertTrue(hcp2a.get_dvdz() == 0.012 );
144 */
145 HitVector hm1 = new HitVector(2);
146 hm1.set(ClusXYPlane2.IV, v1);
147 hm1.set(ClusXYPlane2.IZ, z1);
148
149 ClusXYPlane2 hcp1b = new ClusXYPlane2(hcp1);
150 if(debug) System.out.println( ok_prefix + "test copy constructor");
151
152 Assert.assertTrue( hcp1b.equals(hcp1) );
153 //********************************************************************
154 ClusXYPlane2 hcp2 = new ClusXYPlane2(dist2,phi2,v2,z2,dhm2.get(ClusXYPlane2.IV,ClusXYPlane2.IV),dhm2.get(ClusXYPlane2.IZ,ClusXYPlane2.IZ),dhm2.get(ClusXYPlane2.IV,ClusXYPlane2.IZ),mcids);
155
156 if(debug) System.out.println( ok_prefix + "Test cluster type ID." );
157 if(debug) System.out.println( hcp1.type() );
158 if(debug) System.out.println( hcp2.type() );
159 Assert.assertTrue( hcp1.type() != null );
160 Assert.assertTrue( hcp1.type().equals(hcp2.type()) );
161
162 //********************************************************************
163
164 if(debug) System.out.println( ok_prefix + "Test cluster accessors." );
165 if(debug) System.out.println( hcp1 );
166 if(debug) System.out.println( hcp1.surface() );
167 Assert.assertTrue( hcp1.surface().equals(szp1) );
168
169 //********************************************************************
170
171 if(debug) System.out.println( ok_prefix + "Generate a hit." );
172 TrackVector vec = new TrackVector();
173 TrackError err = new TrackError();
174 HitDerivative der_expect = new HitDerivative(2);
175 der_expect.set(0,0, 1.);
176 der_expect.set(1,1, 1.);
177 vec.set(SurfXYPlane.IV, 1.1);
178 vec.set(SurfXYPlane.IZ, 40.0);
179 err.set(SurfXYPlane.IV,SurfXYPlane.IV, 0.04);
180 err.set(SurfXYPlane.IV,SurfXYPlane.IZ, 0.03);
181 err.set(SurfXYPlane.IZ,SurfXYPlane.IZ, 0.02);
182 ETrack tre1 = new ETrack(szp1.newPureSurface(),vec,err);
183 List tclus11 = hcp1.predict(tre1,hcp1);
184 Assert.assertTrue( tclus11.size() == 1 );
185 Hit pre11 = (Hit) tclus11.get(0);
186 double maxdiff = 1.e-12;
187 if(debug) System.out.println( pre11.size() );
188 Assert.assertTrue( pre11.size() == 2);
189 if(debug) System.out.println( pre11.measuredVector() );
190 Assert.assertTrue( ((HitXYPlane2)pre11).v() == pre11.predictedVector().get(IV) );
191 Assert.assertTrue( ((HitXYPlane2)pre11).z() == pre11.predictedVector().get(IZ) );
192 Assert.assertTrue( ((HitXYPlane2)pre11).dV2() == pre11.predictedError().get(IV,IV) );
193 Assert.assertTrue( ((HitXYPlane2)pre11).dZ2() == pre11.predictedError().get(IZ,IZ) );
194 Assert.assertTrue( ((HitXYPlane2)pre11).dVdZ() == pre11.predictedError().get(IZ,IV) );
195 Assert.assertTrue( hiteqvec(pre11.measuredVector(), hm1) );
196 if(debug) System.out.println( pre11.measuredError() );
197 Assert.assertTrue( hiteqsm(pre11.measuredError(), dhm1) );
198 if(debug) System.out.println( pre11.predictedVector() );
199 Assert.assertTrue( pre11.predictedVector().equals(calc_hm(vec)) );
200 if(debug) System.out.println( pre11.predictedError() );
201 Assert.assertTrue( pre11.predictedError().equals(calc_dhm(err)) );
202 if(debug) System.out.println( pre11.dHitdTrack() );
203 Assert.assertTrue( pre11.dHitdTrack().equals(der_expect) );
204 if(debug) System.out.println( pre11.differenceVector() );
205 Assert.assertTrue( Math.abs(pre11.differenceVector().get(0) -
206 calc_hm(vec).get(0) + hm1.get(0)) < maxdiff );
207 Assert.assertTrue( Math.abs(pre11.differenceVector().get(1) -
208 calc_hm(vec).get(1) + hm1.get(1)) < maxdiff );
209 //********************************************************************
210
211 if(debug) System.out.println( ok_prefix + "Generate hit for a different track."
212 );
213 vec.set(SurfXYPlane.IV, 1.2);
214 ETrack tre2 = new ETrack(szp1.newPureSurface(),vec,err);
215 List tclus12 = hcp1.predict(tre2,hcp1);
216 Assert.assertTrue( tclus12.size() == 1 );
217 Hit pre12 = (Hit)tclus12.get(0);
218 if(debug) System.out.println( pre12.size() );
219 Assert.assertTrue( pre12.size() == 2);
220 if(debug) System.out.println( pre12.measuredVector() );
221 Assert.assertTrue( hiteqvec(pre12.measuredVector(), hm1) );
222 if(debug) System.out.println( pre12.measuredError() );
223 Assert.assertTrue( hiteqsm(pre12.measuredError(), dhm1) );
224 if(debug) System.out.println( pre12.predictedVector() );
225 Assert.assertTrue( pre12.predictedVector().equals(calc_hm(vec)) );
226 if(debug) System.out.println( pre12.predictedError() );
227 Assert.assertTrue( pre12.predictedError().equals(calc_dhm(err)) );
228 if(debug) System.out.println( pre12.dHitdTrack() );
229 Assert.assertTrue( pre12.dHitdTrack().equals(der_expect) );
230 if(debug) System.out.println( pre12.differenceVector() );
231 Assert.assertTrue( Math.abs(pre12.differenceVector().get(0) -
232 calc_hm(vec).get(0) + hm1.get(0)) < maxdiff );
233 Assert.assertTrue( Math.abs(pre12.differenceVector().get(1) -
234 calc_hm(vec).get(1) + hm1.get(1)) < maxdiff );
235 // same cluster ==> same hit (even though track changes)
236 Assert.assertTrue( pre11.equals(pre11) );
237 Assert.assertTrue( ! ( pre11.notEquals(pre11) ) );
238 Assert.assertTrue( pre11.equals(pre12) );
239
240 //********************************************************************
241
242 if(debug) System.out.println( ok_prefix + "Generate hit for a different cluster."
243 );
244 List tclus22 = hcp2.predict(tre2,hcp2);
245 Assert.assertTrue( tclus22.size() == 1 );
246 Hit pre22 = (Hit)tclus22.get(0);
247 if(debug) System.out.println( pre22.size() );
248 Assert.assertTrue( pre22.size() == 2);
249 if(debug) System.out.println( pre22.measuredVector() );
250 Assert.assertTrue( hiteqvec(pre22.measuredVector(), hm2) );
251 if(debug) System.out.println( pre22.measuredError() );
252 Assert.assertTrue( hiteqsm(pre22.measuredError(), dhm2) );
253 if(debug) System.out.println( pre22.predictedVector() );
254 Assert.assertTrue( pre22.predictedVector().equals(calc_hm(vec)) );
255 if(debug) System.out.println( pre22.predictedError() );
256 Assert.assertTrue( pre22.predictedError().equals(calc_dhm(err)) );
257 if(debug) System.out.println( pre22.dHitdTrack() );
258 Assert.assertTrue( pre22.dHitdTrack().equals(der_expect) );
259 if(debug) System.out.println( pre22.differenceVector() );
260 Assert.assertTrue( Math.abs(pre22.differenceVector().get(0) -
261 calc_hm(vec).get(0) + hm2.get(0)) < maxdiff );
262 Assert.assertTrue( Math.abs(pre22.differenceVector().get(1) -
263 calc_hm(vec).get(1) + hm2.get(1)) < maxdiff );
264 // different cluster ==> different hit
265 Assert.assertTrue( pre22.notEquals(pre11) );
266 Assert.assertTrue( ! ( pre22.equals(pre11) ) );
267 Assert.assertTrue( pre22.notEquals(pre12) );
268
269 //********************************************************************
270
271 if(debug) System.out.println( ok_prefix + "Update hit." );
272 if(debug) System.out.println( pre11 );
273 pre11.update(tre2);
274 if(debug) System.out.println( pre11 );
275 Assert.assertTrue( pre11.size() == 2);
276 if(debug) System.out.println( pre11.measuredVector() );
277 Assert.assertTrue( hiteqvec(pre11.measuredVector(), hm1) );
278 if(debug) System.out.println( pre11.measuredError() );
279 Assert.assertTrue( hiteqsm(pre11.measuredError(), dhm1) );
280 if(debug) System.out.println( pre11.predictedVector() );
281 Assert.assertTrue( pre11.predictedVector().equals(calc_hm(vec)) );
282 if(debug) System.out.println( pre11.predictedError() );
283 Assert.assertTrue( pre11.predictedError().equals(calc_dhm(err)) );
284 if(debug) System.out.println( pre11.dHitdTrack() );
285 Assert.assertTrue( pre11.dHitdTrack().equals(der_expect) );
286 if(debug) System.out.println( pre11.differenceVector() );
287 Assert.assertTrue( Math.abs(pre11.differenceVector().get(0) -
288 calc_hm(vec).get(0) + hm1.get(0)) < maxdiff );
289 Assert.assertTrue( Math.abs(pre11.differenceVector().get(1) -
290 calc_hm(vec).get(1) + hm1.get(1)) < maxdiff );
291 //********************************************************************
292
293 if(debug) System.out.println( ok_prefix + "Check hit type and equality." );
294 if(debug) System.out.println( HitXYPlane2.staticType());
295 if(debug) System.out.println( pre11.type() );
296 if(debug) System.out.println( pre12.type() );
297 Assert.assertTrue( pre11.type() != null );
298 Assert.assertTrue( pre11.type().equals(HitXYPlane2.staticType()) );
299 Assert.assertTrue( pre11.type().equals(pre12.type()) );
300
301
302 //********************************************************************
303
304 if(debug) System.out.println( ok_prefix
305 + "------------- All tests passed. -------------" );
306 }
307
308 }