Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-04-09 07:49:14 

0001 // om-;TEST=OpticksPhotonTest om-t    ## faster building when just making changes to this test
0002 #include <cstring>
0003 #include <csignal>
0004 #include "OPTICKS_LOG.hh"
0005 #include "sstr.h"
0006 #include "ssys.h"
0007 #include "spath.h"
0008 #include "NPX.h"
0009 
0010 #include "OpticksPhoton.h"
0011 #include "OpticksPhoton.hh"
0012 
0013 
0014 int test_FlagAbbrevPairs()
0015 {
0016     LOG(info);
0017     typedef std::pair<const char*, const char*> KV ;
0018     std::vector<KV> pairs ;
0019 
0020     OpticksPhoton::FlagAbbrevPairs(pairs);
0021 
0022     for(unsigned i=0 ; i < pairs.size() ; i++)
0023     {
0024         const KV& kv = pairs[i] ;
0025         std::cout
0026             << std::setw(4) << kv.second
0027             << std::setw(20) << kv.first
0028             << std::endl
0029             ;
0030     }
0031     return 0 ;
0032 }
0033 
0034 
0035 int test_FlagMask_0()
0036 {
0037     LOG(info);
0038     for(unsigned i=0 ; i < 16 ; i++)
0039     {
0040         unsigned msk = 0x1 << i ;
0041         std::cout
0042                   << " ( 0x1 << " << std::setw(2) << i << " ) "
0043                   << " (i+1) " << std::setw(2) << std::hex << (i + 1) << std::dec
0044                   << " " << std::setw(2)  << OpticksPhoton::FlagMaskLabel(msk, true)
0045                   << " " << std::setw(20) << OpticksPhoton::FlagMaskLabel(msk, false)
0046                   << " " << std::setw(6) << std::hex << msk << std::dec
0047                   << " " << std::setw(6) << std::dec << msk << std::dec
0048                   << std::endl
0049                   ;
0050 
0051     }
0052     return 0 ;
0053 }
0054 
0055 int test_FlagMask_1()
0056 {
0057     LOG(info);
0058     std::vector<unsigned> vmsk = { 0x5840, 0x5850, 0x5c40, 0x5940, 0x5860,  } ;
0059 
0060     for(unsigned i=0 ; i < vmsk.size() ; i++)
0061     {
0062         unsigned msk = vmsk[i] ;
0063         std::cout
0064             << std::setw(10) << std::hex << msk << std::dec
0065             << " flagmask(abbrev) " << std::setw(20) << OpticksPhoton::FlagMaskLabel(msk, true)
0066             << " flagmask " << OpticksPhoton::FlagMaskLabel(msk, false)
0067             << std::endl
0068             ;
0069     }
0070     return 0 ;
0071 }
0072 
0073 int test_GetFlagMask()
0074 {
0075     std::cout << "[GetFlagMask\n" ;
0076 
0077     char delim = ',' ;
0078     std::vector<std::string> msks = { "SD", "EC", "EX", "EC,SD", "EX,SD", "EC,SA" } ;
0079 
0080     int num_msk = msks.size();
0081     for(int i=0 ; i < num_msk ; i++)
0082     {
0083         const char* _msk = msks[i].c_str();
0084         unsigned msk = OpticksPhoton::GetFlagMask(_msk, delim);
0085 
0086         std::cout
0087             << " _msk " << std::setw(10) << _msk
0088             << " msk  " << std::setw(10) << std::hex << msk << std::dec
0089             << " " << OpticksPhoton::FlagMaskLabel(msk, true )
0090             << " " << OpticksPhoton::FlagMaskLabel(msk, false )
0091             << "\n"
0092             ;
0093     }
0094     std::cout << "]GetFlagMask\n" ;
0095     return 0 ;
0096 }
0097 
0098 
0099 
0100 int test_AbbrevToFlag()
0101 {
0102     LOG(info);
0103     for(unsigned f=0 ; f < 32 ; f++ )
0104     {
0105         unsigned flag = OpticksPhoton::EnumFlag(f);
0106         const char* abbrev = OpticksPhoton::Abbrev(flag) ;
0107         unsigned flag2 = OpticksPhoton::AbbrevToFlag( abbrev );
0108         unsigned f2 = OpticksPhoton::BitPos(flag2) ;
0109         bool bad_flag = strcmp(abbrev, OpticksPhoton::_BAD_FLAG) == 0 ;
0110 
0111         std::cout
0112               << " f " << std::setw(4) << f
0113               << " flag EnumFlag(f) " << std::setw(10) << flag
0114               << " abbrev Abbrev(flag)   " << std::setw(3) << abbrev
0115               << " flag2 AbbrevToFlag( abbrev ) " << std::setw(10) << flag2
0116               << " f2 BitPos(flag2) " << std::setw(4) << f2
0117               << " bad_flag " << bad_flag
0118               << std::endl
0119               ;
0120 
0121         if(bad_flag) break ;   // only the last so not continue
0122         assert( flag2 == flag );
0123         assert( f2 == f );
0124     }
0125 
0126 
0127     unsigned flag_non_existing = OpticksPhoton::AbbrevToFlag("ZZ") ;
0128     bool flag_non_existing_expect = flag_non_existing == 0 ;
0129     assert( flag_non_existing_expect );
0130     if(!flag_non_existing_expect ) std::raise(SIGINT);
0131 
0132     unsigned flag_NULL = OpticksPhoton::AbbrevToFlag(NULL) ;
0133     bool flag_NULL_expect = flag_NULL == 0 ;
0134     assert( flag_NULL_expect );
0135     if(!flag_NULL_expect) std::raise(SIGINT);
0136 
0137 
0138     return 0 ;
0139 }
0140 
0141 int test_AbbrevToFlagSequence(const char* abbseq)
0142 {
0143     unsigned long long seqhis = OpticksPhoton::AbbrevToFlagSequence(abbseq);
0144     std::string abbseq2 = OpticksPhoton::FlagSequence( seqhis );
0145     const char* abbseq2_ = sstr::TrimTrailing(abbseq2.c_str());
0146 
0147     bool match = strcmp( abbseq2_ , abbseq) == 0 ;
0148 
0149     LOG(match ? info : fatal)
0150            << " abbseq [" << abbseq << "]"
0151            << " seqhis " << std::setw(16) << std::hex << seqhis << std::dec
0152            << " abbseq2 [" << abbseq2_ << "]"
0153            ;
0154 
0155     assert(match);
0156     return 0 ;
0157 }
0158 
0159 int test_AbbrevToFlagSequence()
0160 {
0161     LOG(info);
0162     test_AbbrevToFlagSequence("TO SR SA");
0163     test_AbbrevToFlagSequence("TO SC SR SA");
0164     //test_AbbrevToFlagSequence("TO ZZ SC SR SA");
0165     return 0 ;
0166 }
0167 
0168 
0169 
0170 int test_AbbrevToFlagValSequence(const char* seqmap, const char* x_abbseq, unsigned long long x_seqval)
0171 {
0172     unsigned long long seqhis(0ull) ;
0173     unsigned long long seqval(0ull) ;
0174 
0175     OpticksPhoton::AbbrevToFlagValSequence(seqhis, seqval, seqmap );
0176 
0177     unsigned long long x_seqhis = OpticksPhoton::AbbrevToFlagSequence(x_abbseq) ;
0178 
0179     bool seqhis_match = seqhis == x_seqhis  ;
0180     bool seqval_match = seqval == x_seqval  ;
0181 
0182     LOG( seqhis_match ? info : fatal )
0183             << " seqmap " << std::setw(20) << seqmap
0184             << " seqhis " << std::setw(16) << std::hex << seqhis << std::dec
0185             << " x_seqhis " << std::setw(16) << std::hex << x_seqhis << std::dec
0186             << " x_abbseq " << x_abbseq
0187             ;
0188 
0189     LOG( seqval_match ? info : fatal )
0190             << " seqmap " << std::setw(20) << seqmap
0191             << " seqval " << std::setw(16) << std::hex << seqval << std::dec
0192             << " x_seqval " << std::setw(16) << std::hex << x_seqval << std::dec
0193             ;
0194 
0195     assert( seqhis_match ) ;
0196     assert( seqval_match ) ;
0197     return 0 ;
0198 }
0199 
0200 
0201 int test_AbbrevToFlagValSequence()
0202 {
0203     LOG(info);
0204     test_AbbrevToFlagValSequence("TO:0 SR:1 SA:0", "TO SR SA", 0x121ull );
0205 
0206     //test_AbbrevToFlagValSequence("TO:0 SC: SR:1 SA:0", "TO SC SR SA", 0x1201ull );   // migrated imp does like empties
0207     //test_AbbrevToFlagValSequence("TO:0 SC:0 SR:1 SA:0", "TO SC SR SA", 0x1201ull );  // but this fails seqval match
0208     return 0 ;
0209 }
0210 
0211 int test_PointAbbrev()
0212 {
0213     LOG(info);
0214     unsigned long long seqhis = 0x4ad ;
0215     for(unsigned p=0 ; p < 5 ; p++) LOG(info) << p << " " << OpticksPhoton::PointAbbrev(seqhis, p ) ;
0216     return 0 ;
0217 }
0218 int test_PointVal1()
0219 {
0220     LOG(info);
0221     unsigned long long seqval = 0x121 ;
0222     for(unsigned p=0 ; p < 5 ; p++) LOG(info) << p << " " << OpticksPhoton::PointVal1(seqval, p ) ;
0223     return 0 ;
0224 }
0225 
0226 int test_AbbrevSequenceToMask()
0227 {
0228     LOG(info);
0229     const char* abrseq = "TO,SD,BT" ;
0230     unsigned x_mask = TORCH | SURFACE_DETECT | BOUNDARY_TRANSMIT ;
0231     char delim = ',' ;
0232     unsigned mask = OpticksPhoton::AbbrevSequenceToMask( abrseq, delim );
0233 
0234     bool mask_expect =  mask == x_mask ;
0235     assert( mask_expect ) ;
0236     if(!mask_expect) std::raise(SIGINT);
0237 
0238     LOG(info)
0239           << " abrseq " << abrseq
0240           << " mask " << mask
0241           ;
0242     return 0 ;
0243 }
0244 
0245 
0246 
0247 int test_Abbrev_Flag()
0248 {
0249     LOG(info);
0250     unsigned lastBit = 17 ;
0251     for(unsigned n=0 ; n <= lastBit ; n++ )
0252     {
0253         unsigned flag = 0x1 << n ;
0254         std::cout
0255             << " n " << std::setw(10) << n
0256             << " (0x1 << n) " << std::setw(10) << flag
0257             << " OpticksPhoton::Flag " << std::setw(20) << OpticksPhoton::Flag(flag)
0258             << " OpticksPhoton::Abbrev " << std::setw(20) << OpticksPhoton::Abbrev(flag)
0259             << std::endl
0260             ;
0261     }
0262 
0263     return 0 ;
0264 }
0265 
0266 int test_load_seq()
0267 {
0268     const char* _path = "$TMP/GEOM/$GEOM/G4CXTest/ALL0/p001/seq.npy" ;
0269     const char* path = spath::Resolve(_path) ;
0270     NP* a = NP::LoadIfExists(path);
0271     std::cout
0272         << "OpticksPhotonTest:test_load_seq"
0273         << std::endl
0274         << " _path " << _path
0275         << std::endl
0276         << " path  " << path
0277         << std::endl
0278         << " a " << ( a ? a->sstr() : "-" )
0279         << std::endl
0280          ;
0281     if(a == nullptr) return 0 ;
0282 
0283     const uint64_t* aa = a->cvalues<uint64_t>();
0284     int num = a->shape[0] ;
0285     int edge = 10 ;
0286 
0287     for(int i=0 ; i < num ; i++)
0288     {
0289         if( i < edge || i > (num - edge) )
0290             std::cout << OpticksPhoton::FlagSequence_( aa + 4*i, 2 ) << std::endl ;
0291         else if( i == edge )
0292             std::cout << "..." << std::endl ;
0293     }
0294     return 0 ;
0295 }
0296 
0297 
0298 
0299 
0300 
0301 int main(int argc, char** argv)
0302 {
0303     OPTICKS_LOG(argc, argv);
0304     LOG(info) << " sysrap.OpticksPhotonTest " ;
0305 
0306     const char* TEST = ssys::getenvvar("TEST", "ALL");
0307     bool ALL = strcmp(TEST, "ALL") == 0 ;
0308 
0309     int rc = 0 ;
0310 
0311     if(ALL||0==strcmp(TEST, "FlagAbbrevPairs"))         rc += test_FlagAbbrevPairs() ;
0312     if(ALL||0==strcmp(TEST, "FlagMask_0"))              rc += test_FlagMask_0() ;
0313     if(ALL||0==strcmp(TEST, "FlagMask_1"))              rc += test_FlagMask_1() ;
0314     if(ALL||0==strcmp(TEST, "GetFlagMask"))             rc += test_GetFlagMask() ;
0315     if(ALL||0==strcmp(TEST, "AbbrevToFlag"))            rc += test_AbbrevToFlag() ;
0316     if(ALL||0==strcmp(TEST, "AbbrevToFlagSequence"))    rc += test_AbbrevToFlagSequence() ;
0317     if(ALL||0==strcmp(TEST, "AbbrevToFlagValSequence")) rc += test_AbbrevToFlagValSequence() ;
0318     if(ALL||0==strcmp(TEST, "PointAbbrev"))             rc += test_PointAbbrev() ;
0319     if(ALL||0==strcmp(TEST, "PointVal1"))               rc += test_PointVal1() ;
0320     if(ALL||0==strcmp(TEST, "AbbrevSequenceToMask"))    rc += test_AbbrevSequenceToMask() ;
0321     if(ALL||0==strcmp(TEST, "Abbrev_Flag"))             rc += test_Abbrev_Flag() ;
0322     if(ALL||0==strcmp(TEST, "load_seq"))                rc += test_load_seq() ;
0323 
0324     return rc ;
0325 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!