sysrap/tests/stree_test.cc

0001 #include <cstdlib>
0002 #include <iostream>
0003 #include <glm/gtx/string_cast.hpp>
0004
0005 #include "ssys.h"
0006 #include "strid.h"
0007 #include "stree.h"
0008
0009 const char* BASE = getenv("BASE");
0010
0011 void test_get_ancestors(const stree& st)
0012 {
0013     int nidx = ssys::getenvint("NIDX", 1000)  ;
0014     std::vector<int> ancestors ;
0015     st.get_ancestors(ancestors, nidx) ;
0016
0017     std::cout << "st.get_ancestors NIDX " << nidx << " " << stree::Desc(ancestors) << std::endl ;
0018     std::cout << st.desc_nodes(ancestors) << std::endl ;
0019     std::cout << st.desc_node(nidx) << std::endl  ;
0020
0021     std::cout << " st.desc_ancestry " << std::endl ;
0022     std::cout << st.desc_ancestry(nidx, true) << std::endl ;
0023 }
0024
0025 void test_get_nodes(const stree& st)
0026 {
0027     int sidx = ssys::getenvint("SIDX", 0);
0028     unsigned edge = ssys::getenvunsigned("EDGE", 10u);
0029
0030     const char* k = st.subs_freq->get_key(sidx);
0031     unsigned    v = st.subs_freq->get_freq(sidx);
0032
0033     std::vector<int> nodes ;
0034     st.get_nodes(nodes, k );
0035
0036     std::cout << " sidx " << sidx << " k " << k  << " v " << v << " nodes.size" << nodes.size() << std::endl ;
0037     std::cout << st.desc_nodes(nodes, edge) ;
0038
0039
0040     int nidx = nodes[0] ;
0041     std::cout << st.desc_ancestry(nidx, true) << std::endl ;
0042
0043     std::vector<int> progeny ;
0044     st.get_progeny(progeny, nidx );
0045
0046     std::cout << "st.desc_nodes(progeny, 20)" << std::endl << st.desc_nodes(progeny, 20) << std::endl ;
0047
0048     const char* qname = "sWall" ;
0049     int lvid = st.find_lvid(qname) ;
0050     std::cout << " qname " << qname << " lvid " << lvid << std::endl ;
0051
0052     std::vector<int> lvid_nodes ;
0053     st.find_lvid_nodes(lvid_nodes, lvid);
0054     std::cout << "st.desc_nodes(lvid_nodes, 20)" << std::endl << st.desc_nodes(lvid_nodes, 20) << std::endl ;
0055
0056     std::vector<int> progeny_lvn0 ;
0057     st.get_progeny(progeny_lvn0, lvid_nodes[0] );
0058
0059     std::cout << "st.desc_nodes(progeny_lvn0, 1000)" << std::endl << st.desc_nodes(progeny_lvn0, 1000) << std::endl ;
0060 }
0061
0062
0063
0064 void test_find_lvid_node(const stree& st)
0065 {
0066     const char* q_soname = ssys::getenvvar("Q_SONAME", "HamamatsuR12860sMask_virtual")  ;
0067     for(int q_ordinal=0 ; q_ordinal < 10 ; q_ordinal++ )
0068     {
0069         int nidx = st.find_lvid_node(q_soname, q_ordinal );
0070         std::cout << " q_soname " << q_soname << " q_ordinal " << q_ordinal << " nidx " << nidx << std::endl ;
0071
0072         std::string q_spec = sstr::Format_("%s:%d:%d", q_soname, 0, q_ordinal );
0073         int nidx2 = st.find_lvid_node(q_spec.c_str());
0074
0075         std::cout << " q_spec " << q_spec << " nidx2 " << nidx2 << std::endl ;
0076
0077         assert( nidx == nidx2 );
0078     }
0079 }
0080
0081 void test_get_m2w_product_get_w2m_product(const stree& st, const char* q_soname )
0082 {
0083     double delta_cut = 1e-10 ;
0084
0085     std::vector<int> nodes ;
0086     st.find_lvid_nodes(nodes, q_soname);
0087     unsigned num = nodes.size();
0088
0089     glm::tmat4x4<double> m2w(1.) ;
0090     glm::tmat4x4<double> w2m(1.) ;
0091     double delta_max = 0. ;
0092     unsigned count = 0 ;
0093
0094     for(unsigned i=0 ; i < num ; i++ )
0095     {
0096         int nidx = nodes[i] ;
0097         st.get_m2w_product(m2w, nidx, false );
0098         st.get_w2m_product(w2m, nidx, true  );
0099
0100         glm::tmat4x4<double> m2w_w2m = m2w * w2m ;
0101         glm::tmat4x4<double> w2m_m2w = w2m * m2w ;
0102
0103         double delta0 = strid::DiffFromIdentity(m2w_w2m);
0104         double delta1 = strid::DiffFromIdentity(w2m_m2w);
0105         double delta = std::max(delta0, delta1);
0106         if( delta > delta_max ) delta_max = delta ;
0107
0108         if( delta > delta_cut )
0109         {
0110             count += 1 ;
0111             std::cout << " i " << i << " nidx " << nidx << " delta " << std::scientific << delta << std::endl ;
0112             std::cout << strid::Desc_("m2w", "w2m", "m2w_w2m", m2w, w2m, m2w_w2m ) ;
0113         }
0114     }
0115     std::cout
0116         << " soname " << std::setw(50) << q_soname
0117         << " num " << std::setw(7) << num
0118         << " delta_max " << std::setw(10) << std::scientific << delta_max
0119         << " delta_cut " << std::setw(10) << std::scientific << delta_cut
0120         << " count " << std::setw(8) << count
0121         << std::endl
0122         ;
0123 }
0124
0125 void test_get_m2w_product_get_w2m_product(const stree& st)
0126 {
0127     std::vector<std::string> sonames ;
0128     st.get_sub_sonames(sonames) ;
0129     std::cout << "[ test_get_m2w_product_get_w2m_product sonames.size " << sonames.size() << std::endl ;
0130     std::cout << "testing that m2w and w2m product transforms for all instances are inverses of each other " << std::endl ;
0131
0132     for(unsigned i=0 ; i < sonames.size() ; i++)
0133     {
0134         const char* soname = sonames[i].c_str();
0135         test_get_m2w_product_get_w2m_product(st, soname ) ;
0136     }
0137     std::cout << "] test_get_m2w_product_get_w2m_product sonames.size " << sonames.size() << std::endl ;
0138 }
0139
0140 void test_m2w_w2m(const stree& st)
0141 {
0142     std::cout << "test_m2w_w2m : check that all m2w w2m pairs are effective inverses of each other " << std::endl ;
0143     std::cout << "st.m2w.size " << st.m2w.size() << std::endl ;
0144     std::cout << "st.w2m.size " << st.w2m.size() << std::endl ;
0145     assert( st.m2w.size() == st.w2m.size() );
0146     unsigned num = st.m2w.size();
0147
0148     unsigned i0 = 0 ;
0149     unsigned i1 = num ;
0150
0151     double delta_cut = 1e-11 ;
0152     unsigned count = 0 ;
0153     unsigned max_delta_idx = 0 ;
0154     double max_delta = 0. ;
0155
0156     for(unsigned i=i0 ; i < i1 ; i++)
0157     {
0158         assert( i < num );
0159
0160         const glm::tmat4x4<double>& m2w = st.m2w[i] ;
0161         const glm::tmat4x4<double>& w2m = st.w2m[i] ;
0162         const glm::tmat4x4<double>  m2w_w2m = m2w*w2m ;
0163         const glm::tmat4x4<double>  w2m_m2w = w2m*m2w ;
0164
0165         double delta_0 = strid::DiffFromIdentity(m2w_w2m) ;
0166         double delta_1 = strid::DiffFromIdentity(w2m_m2w) ;
0167         double delta   = std::max( delta_0, delta_1 );
0168
0169         if( delta > max_delta )
0170         {
0171             max_delta = delta ;
0172             max_delta_idx = i ;
0173         }
0174
0175         if( delta > delta_cut )
0176         {
0177             count += 1 ;
0178             std::cout
0179                 << " i " << std::setw(7) << i
0180                 << " delta_0 " << std::setw(10) << std::scientific << delta_0
0181                 << " delta_1 " << std::setw(10) << std::scientific << delta_1
0182                 << " delta "   << std::setw(10) << std::scientific << delta
0183                 << " delta_cut "   << std::setw(10) << std::scientific << delta_cut
0184                 << std::endl
0185                 ;
0186
0187             std::cout << strid::Desc_("m2w","w2m","m2w_w2m", m2w, w2m, m2w_w2m ) << std::endl ;
0188             std::cout << strid::Desc_("m2w","w2m","w2m_m2w", m2w, w2m, w2m_m2w ) << std::endl ;
0189         }
0190     }
0191     std::cout
0192         << " i0 " << i0
0193         << " i1 " << i1
0194         << " delta_cut " << std::scientific << delta_cut
0195         << " max_delta " << std::scientific << max_delta
0196         << " count " << count
0197         << " max_delta_idx " << max_delta_idx
0198         << std::endl
0199         ;
0200 }
0201
0202
0203 void test_desc_progeny(const stree& st, const char* qname )
0204 {
0205     std::vector<int> nodes ;
0206     st.find_lvid_nodes(nodes, qname);
0207     std::cout << "st.find_lvid_nodes(nodes, qname)   qname " << qname << " nodes.size " << nodes.size() << std::endl ;
0208     std::cout << "st.desc_nodes(nodes, 20)" << std::endl << st.desc_nodes(nodes, 20) << std::endl ;
0209     std::cout << "st.desc_progeny(nodes[0])" << std::endl << st.desc_progeny(nodes[0]) << std::endl;
0210 }
0211
0212
0213 void test_get_factor_nodes(const stree& st)
0214 {
0215     unsigned num_factor = st.get_num_factor();
0216     std::cout << "test_get_factor_nodes num_factor " << num_factor << std::endl ;
0217
0218     for(unsigned i=0 ; i < num_factor ; i++)
0219     {
0220         std::vector<int> nodes ;
0221         st.get_factor_nodes(nodes, i);
0222         std::cout << std::setw(3) << i << " nodes " << nodes.size() << std::endl ;
0223     }
0224
0225     std::cout << st.desc_factor() << std::endl ;
0226 }
0227
0228 void test_traverse(const stree& st)
0229 {
0230     st.traverse();
0231 }
0232 void test_reorderSensors(stree& st)
0233 {
0234     st.reorderSensors();
0235     st.clear_inst();
0236     st.add_inst();
0237
0238     st.save(BASE, "stree_reorderSensors" );
0239 }
0240
0241 void test_get_sensor_id(const stree& st)
0242 {
0243     std::vector<int> sensor_id ;
0244     st.get_sensor_id(sensor_id);
0245     unsigned num_sensor = sensor_id.size() ;
0246     std::cout << "test_get_sensor_id  num_sensor " << num_sensor << std::endl ;
0247
0248     unsigned edge = 10 ;
0249
0250     int pid = -1 ;
0251     int offset = 0 ;
0252
0253     for(unsigned i=0 ; i < num_sensor  ; i++)
0254     {
0255         int sid = sensor_id[i] ;
0256         int nid = i < num_sensor - 1 ? sensor_id[i+1] : sid ;
0257
0258         bool head = i < edge ;
0259         bool tail = i > (num_sensor - edge) ;
0260         bool tran = std::abs(sid - pid) > 1 || std::abs( sid - nid ) > 1  ;
0261
0262         if(tran) offset = 0 ;
0263         offset += 1 ;
0264
0265         bool post_tran = offset < 5 ;
0266
0267
0268         if( head || tail || tran || post_tran  )
0269         {
0270             std::cout
0271                 << " i " << std::setw(7) << i
0272                 << " sensor_id " << std::setw(7) << sid
0273                 << std::endl ;
0274          }
0275          else if ( i == edge )
0276          {
0277             std::cout  << "..." << std::endl ;
0278          }
0279          pid = sid ;
0280
0281     }
0282 }
0283
0284 void test_desc_m2w_product(const stree& st)
0285 {
0286     int ins_idx = ssys::getenvint("INS_IDX", 1 );
0287     int num_inst = int(st.inst_nidx.size()) ;
0288     if(ins_idx < 0 ) ins_idx += num_inst ;
0289     assert( ins_idx < num_inst );
0290
0291     int nidx = st.inst_nidx[ins_idx] ;
0292     std::cout
0293          << "st.inst_nidx.size " << num_inst
0294          << " ins_idx INS_IDX " << ins_idx
0295          << " nidx " << nidx
0296          << std::endl
0297          ;
0298
0299     bool reverse = false ;
0300     std::cout << st.desc_m2w_product(nidx, reverse) << std::endl ;
0301 }
0302
0303 void test_desc_sub(const stree& st)
0304 {
0305     std::cout << "st.desc_sub(false)" << std::endl << st.desc_sub(false) << std::endl ;
0306     //std::cout << "st.desc_sub(true)"  << std::endl << st.desc_sub(true)  << std::endl ;
0307 }
0308
0309 void test_bd()
0310 {
0311     std::vector<int4> bd ;
0312     bd.push_back( {0,1,2,3} );
0313     bd.push_back( {3,2,1,0} );
0314
0315
0316     const char* fold = "/tmp/stree_test" ;
0317     std::cout << "test_bnd write to " << fold << std::endl ;
0318
0319     const char* BD = "bd.npy" ;
0320
0321     NP::Write<int>(fold, BD, (int*)bd.data(), bd.size(), 4  );
0322
0323     std::vector<int4> bd1 ;
0324     stree::ImportArray<int4, int>( bd1, NP::Load(fold, BD) );
0325
0326     assert( bd1.size() == bd.size() );
0327     assert( bd1 == bd );
0328
0329
0330 }
0331
0332 int main(int argc, char** argv)
0333 {
0334     stree st ;
0335     st.load(BASE);
0336
0337     /*
0338     test_desc_sub(st);
0339     test_m2w_w2m(st);
0340     test_get_m2w_product_get_w2m_product(st) ;
0341     test_get_nodes(st);
0342     test_find_lvid_node(st);
0343     test_desc_progeny(st, "sWall");
0344     test_get_factor_nodes(st);
0345     test_traverse(st);
0346     test_reorderSensors(st);
0347     test_get_sensor_id(st);
0348     test_desc_m2w_product(st);
0349     test_get_ancestors(st);
0350     test_desc_sub(st);
0351     test_get_sensor_id(st);
0352     */
0353
0354
0355     //test_bnd();
0356
0357
0358     return 0 ;
0359 }