sysrap/tests/squadTest.cc

0001 // ./squadTest.sh
0002
0003 #include "scuda.h"
0004 #include "squad.h"
0005
0006 void test_qvals_float()
0007 {
0008     float  v1 ;
0009     float2 v2 ;
0010     float3 v3 ;
0011     float4 v4 ;
0012
0013     qvals( v1, "TMIN", "0.6" );
0014     qvals( v2, "CHK", "100.5   -200.1" );
0015     qvals( v3, "EYE", ".4,.2,.1" );
0016     qvals( v4, "LOOK", ".4,.2,.1,1" );
0017
0018     std::cout << "v1 " << v1 << std::endl ;
0019     std::cout << "v2 " << v2 << std::endl ;
0020     std::cout << "v3 " << v3 << std::endl ;
0021     std::cout << "v4 " << v4 << std::endl ;
0022 }
0023
0024
0025 void test_qvals_int()
0026 {
0027     int  v1 ;
0028     int2 v2 ;
0029     int3 v3 ;
0030     int4 v4 ;
0031
0032     qvals( v1, "I1", "101" );
0033     qvals( v2, "I2", "101   -202" );
0034     qvals( v3, "I3", "101 202 303" );
0035     qvals( v4, "I4", "101 -202 +303 -404" );
0036
0037     std::cout << "v1 " << v1 << std::endl ;
0038     std::cout << "v2 " << v2 << std::endl ;
0039     std::cout << "v3 " << v3 << std::endl ;
0040     std::cout << "v4 " << v4 << std::endl ;
0041 }
0042
0043
0044 void test_qvals_float3_x2()
0045 {
0046     float3 mom ;
0047     float3 pol ;
0048     qvals(mom, pol, "MOM_POL", "1,0,0,0,1,0" );
0049
0050     std::cout << "mom " << mom << std::endl ;
0051     std::cout << "pol " << pol << std::endl ;
0052 }
0053
0054 void test_qvals_float4_x2()
0055 {
0056     float4 momw ;
0057     float4 polw ;
0058     qvals(momw, polw, "MOMW_POLW", "1,0,0,1,0,1,0,1" );
0059
0060     std::cout << "momw " << momw << std::endl ;
0061     std::cout << "polw " << polw << std::endl ;
0062 }
0063
0064 void test_quad4_ephoton()
0065 {
0066     quad4 p ;
0067     p.ephoton();
0068     std::cout << p.desc() << std::endl ;
0069 }
0070
0071 void test_qenvint()
0072 {
0073    int num = qenvint("NUM", "-1");
0074    std::cout << " num " << num << std::endl ;
0075 }
0076
0077 void test_quad4_normalize_mom_pol()
0078 {
0079     quad4 p ;
0080     p.zero() ;
0081     p.q1.f = make_float4( 1.f, 1.f, 1.f, 1.f );
0082     p.q2.f = make_float4( 1.f, 1.f, 0.f, 1.f );
0083
0084     std::cout << p.desc() << std::endl ;
0085     p.normalize_mom_pol();
0086     std::cout << p.desc() << std::endl ;
0087
0088 }
0089
0090 void test_quad2_eprd()
0091 {
0092     quad2 prd = quad2::make_eprd();
0093     std::cout << " prd.desc " << prd.desc() << std::endl ;
0094 }
0095
0096 void test_qvals_float4_vec(bool normalize_)
0097 {
0098     std::vector<float4> v ;
0099     qvals(v, "SQUADTEST_F4V", "0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4.5,4.5,4.5,4.5", normalize_ );
0100     for(unsigned i=0 ; i < v.size() ; i++) std::cout << v[i] << std::endl ;
0101 }
0102
0103 void test_quad4_set_flags_get_flags()
0104 {
0105     quad4 p ;
0106     p.zero();
0107
0108     unsigned MISSING = ~0u ;
0109     unsigned boundary0 = MISSING ;
0110     unsigned identity0 = MISSING ;
0111     unsigned idx0 = MISSING ; ;
0112     unsigned flag0 = MISSING ; ;
0113     float orient0 = 0.f ;
0114
0115     p.get_flags(boundary0, identity0, idx0, flag0, orient0 );
0116
0117     assert( boundary0 == 0u );
0118     assert( identity0 == 0u );
0119     assert( idx0 == 0u );
0120     assert( flag0 == 0u );
0121     assert( orient0 == 1.f );
0122
0123     unsigned boundary1, identity1, idx1, flag1 ;
0124     float orient1 ;
0125
0126     // test maximum values of the fields
0127     boundary1 = 0xffffu ;
0128     identity1 = 0xffffffffu ;
0129     idx1      = 0x7fffffffu ;  // bit 31 used for orient
0130     flag1     = 0xffffu ;
0131     orient1   = -1.f ;
0132
0133     p.set_flags(boundary1, identity1, idx1, flag1, orient1 );
0134
0135     unsigned boundary2, identity2, idx2, flag2  ;
0136     float orient2 ;
0137
0138     p.get_flags(boundary2 , identity2 , idx2 , flag2, orient2  );
0139
0140     std::cout
0141         << " idx1 " << std::hex << idx1
0142         << " idx2 " << std::hex << idx2
0143         << std::dec
0144         << std::endl
0145         ;
0146
0147     assert( boundary2 == boundary1 );
0148     assert( identity2 == identity1 );
0149     assert( idx2 == idx1 );
0150     assert( flag2 == flag1 );
0151     assert( orient2 == orient1 );
0152 }
0153
0154 void test_quad4_set_flag_get_flag()
0155 {
0156     quad4 p ;
0157     p.zero();
0158
0159     unsigned flag0[2] ;
0160     flag0[0] = 1024 ;
0161
0162     p.set_flag( flag0[0] );
0163     p.get_flag( flag0[1] );
0164     assert( flag0[0] == flag0[1] );
0165     assert( p.q3.u.w == 1024 );
0166
0167     unsigned flag1[2] ;
0168     flag1[0] = 2048 ;
0169
0170     p.set_flag( flag1[0] );
0171     p.get_flag( flag1[1] );
0172     assert( flag1[0] == flag1[1] );
0173
0174     assert( p.q3.u.w == (1024 | 2048) );
0175 }
0176
0177 void test_quad4_set_idx_set_prd_get_idx_get_prd()
0178 {
0179     quad4 p ;
0180     {
0181         p.zero();
0182         unsigned idx[2] ;
0183         idx[0] = 0x7fffffff ;
0184         p.set_idx(idx[0]);
0185         p.get_idx(idx[1]);
0186         assert( idx[0] == idx[1] );
0187     }
0188     {
0189         p.zero();
0190         unsigned idx[2] ;
0191         unsigned boundary[2];
0192         unsigned identity[2];
0193         float orient[2] ;
0194
0195         idx[0] = 0x7fffffff ;
0196         boundary[0] = 0xffff ;
0197         identity[0] = 0xffffffff ;
0198         orient[0] = -1.f ;
0199
0200         p.set_idx(idx[0]);
0201         p.set_prd( boundary[0], identity[0], orient[0] );
0202         p.get_idx(idx[1]);
0203         assert( idx[0] == idx[1] );
0204
0205         p.get_prd( boundary[1], identity[1], orient[1] );
0206         assert( boundary[0] == boundary[1] );
0207         assert( identity[0] == identity[1] );
0208         assert( orient[0] == orient[1] );
0209
0210         p.get_idx(idx[1]);
0211         assert( idx[0] == idx[1] );
0212     }
0213 }
0214
0215 void test_quad4_idx_orient()
0216 {
0217     quad4 p ;
0218     p.zero();
0219
0220     unsigned idx[2] ;
0221     float orient[2] ;
0222
0223     for(unsigned i=0 ; i < 1000 ; i++)
0224     {
0225         idx[0] = i ;
0226         idx[1] = 0 ;
0227
0228         orient[0] = i % 2 == 0 ? -1.f : 1.f ;
0229         orient[1] = 0.f ;
0230
0231         p.set_idx(idx[0]);
0232         p.set_orient( orient[0] );
0233
0234         p.get_idx(idx[1]);
0235         p.get_orient(orient[1]);
0236
0237         assert( idx[0] == idx[1] );
0238         assert( orient[0] == orient[1] );
0239     }
0240 }
0241
0242 void test_qselector()
0243 {
0244     unsigned hitmask = 0xdeadbeef ;
0245     qselector<quad4> selector(hitmask) ;
0246
0247     quad4 p ;
0248     p.zero();
0249
0250     bool select_0 = selector(p) ; assert( select_0 == false );
0251
0252     p.q3.u.w = ~0u ;                                              // all bits set
0253     bool select_1 = selector(p) ; assert( select_1 == true );
0254
0255     p.q3.u.w = hitmask  ;
0256     bool select_2 = selector(p) ; assert( select_2 == true );
0257
0258     p.q3.u.w = hitmask & 0x7fffffff ;                            // knock out one bit from the 0xd
0259     bool select_3 = selector(p) ; assert( select_3 == false );
0260 }
0261
0262 void test_union1()
0263 {
0264     quad q ;
0265
0266     q.f.x = 0.f ;
0267     q.f.y = 0.f ;
0268     q.f.z = 0.f ;
0269     q.f.w = 1.f ;
0270
0271     std::cout
0272         << " q.f.x " << std::setw(10) << q.f.x
0273         << " q.i.x " << std::setw(10) << q.i.x
0274         << std::endl
0275         << " q.f.y " << std::setw(10) << q.f.y
0276         << " q.i.y " << std::setw(10) << q.i.y
0277         << std::endl
0278         << " q.f.z " << std::setw(10) << q.f.z
0279         << " q.i.z " << std::setw(10) << q.i.z
0280         << std::endl
0281         << " q.f.w " << std::setw(10) << q.f.w
0282         << " q.i.w " << std::setw(10) << q.i.w
0283         << std::endl
0284         ;
0285
0286     assert( q.i.w == 1065353216  );
0287     assert( q.u.w == 1065353216u );
0288 }
0289
0290 void test_set_v()
0291 {
0292     quad4 p ;
0293     p.zero();
0294
0295     double src[4] = {1., 2., 3., 4. } ;
0296     const double* s = &src[0] ;
0297
0298     p.set_v(0, s, 1);
0299     p.set_v(1, s, 2);
0300     p.set_v(2, s, 3);
0301     p.set_v(3, s, 4);
0302
0303     std::cout << p << std::endl ;
0304 }
0305
0306
0307 int main(int argc, char** argv)
0308 {
0309     /*
0310     test_qvals_float();
0311     test_qvals_int();
0312     test_qvals_float3_x2();
0313     test_qvals_float4_x2();
0314     test_qenvint();
0315     test_quad4_normalize_mom_pol();
0316     test_quad4_ephoton();
0317     test_quad2_eprd();
0318     test_qvals_float4_vec(false);
0319     test_qvals_float4_vec(true);
0320     test_quad4_set_flags_get_flags();
0321     test_quad4_set_flag_get_flag();
0322     test_quad4_set_idx_set_prd_get_idx_get_prd();
0323     test_quad4_idx_orient();
0324     test_qselector();
0325     test_qphoton();
0326     test_union1();
0327     */
0328
0329     test_set_v();
0330
0331
0332     return 0 ;
0333 }