eic-opticks/sysrap/OpticksPhoton.cc

0001 #include <iostream>
0002 #include <iomanip>
0003 #include <string>
0004 #include <vector>
0005
0006 #include "OpticksPhoton.h"
0007 #include "OpticksPhoton.hh"
0008
0009 #include "SBit.hh"
0010 #include "sstr.h"
0011
0012 #ifdef WITH_SLOG
0013 #include "SLOG.hh"
0014 const plog::Severity OpticksPhoton::LEVEL = SLOG::EnvLevel("OpticksPhoton", "DEBUG");
0015 #endif
0016 const char* OpticksPhoton::flag2color = R"LITERAL(
0017     {
0018         "CERENKOV":"white",
0019         "SCINTILLATION":"white",
0020         "TORCH":"white",
0021         "MISS":"grey",
0022         "BULK_ABSORB":"red",
0023         "BULK_REEMIT":"green",
0024         "BULK_SCATTER":"blue",
0025         "SURFACE_DETECT":"purple",
0026         "SURFACE_ABSORB":"orange",
0027         "SURFACE_DREFLECT":"pink",
0028         "SURFACE_SREFLECT":"magenta",
0029         "BOUNDARY_REFLECT":"yellow",
0030         "BOUNDARY_TRANSMIT":"cyan",
0031         "NAN_ABORT":"grey",
0032         "EFFICIENCY_COLLECT":"pink",
0033         "EFFICIENCY_CULL":"red"
0034     }
0035 )LITERAL";
0036
0037
0038
0039
0040
0041
0042 unsigned OpticksPhoton::EnumFlag(unsigned bitpos)
0043 {
0044     return bitpos == 0 ? 0 : 0x1 << (bitpos - 1) ;
0045 }
0046
0047 unsigned OpticksPhoton::BitPos(unsigned flag)
0048 {
0049     return SBit::ffs(flag)  ;
0050 }
0051
0052 /**
0053 OpticksPhoton::AbbrevToFlag
0054 ----------------------------
0055
0056 Returns lowest flag which has an abbreviation matching the argument or zero if not found.
0057
0058 **/
0059 unsigned OpticksPhoton::AbbrevToFlag( const char* abbrev )
0060 {
0061     unsigned flag = 0 ;
0062     if(!abbrev) return flag ;
0063
0064     for(unsigned f=0 ; f < 32 ; f++)
0065     {
0066         flag = EnumFlag(32-1-f) ; // <-- reverse order so unfound -> 0
0067         if(strcmp(Abbrev(flag), abbrev) == 0) break ;
0068     }
0069     return flag ;
0070 }
0071
0072 /**
0073 OpticksPhoton::AbbrevToFlagSequence
0074 -------------------------------------
0075
0076 Converts seqhis string eg "TO SR SA" into bigint 0x8ad
0077
0078 **/
0079
0080 unsigned long long OpticksPhoton::AbbrevToFlagSequence( const char* abbseq, char delim)
0081 {
0082    std::vector<std::string> elem ;
0083    sstr::Split(abbseq,  delim, elem );
0084
0085    unsigned long long seqhis = 0 ;
0086    for(unsigned i=0 ; i < elem.size() ; i++)
0087    {
0088        unsigned flag = AbbrevToFlag( elem[i].c_str() );
0089        unsigned bitpos = BitPos(flag) ;
0090        unsigned long long shift = i*4 ;
0091        seqhis |= ( bitpos << shift )  ;
0092    }
0093    return seqhis ;
0094 }
0095
0096
0097 /**
0098 OpticksPhoton::GetFlagMask (formerly GetHitMask)
0099 ----------------------------------------------------
0100
0101 Used by SEventConfig::HitMask()
0102
0103    GetFlagMask("SD,EC",',')
0104
0105
0106 **/
0107
0108 unsigned OpticksPhoton::GetFlagMask(const char* abbrseq, char delim) // static
0109 {
0110     return AbbrevSequenceToMask( abbrseq, delim );
0111 }
0112
0113 /**
0114 OpticksPhoton::AbbrevSequenceToMask
0115 ------------------------------------
0116
0117
0118
0119 **/
0120
0121 unsigned OpticksPhoton::AbbrevSequenceToMask( const char* abbseq, char delim)  // static
0122 {
0123    std::vector<std::string> elem ;
0124    sstr::Split(abbseq,  delim, elem );
0125
0126    unsigned mask = 0 ;
0127
0128    for(unsigned i=0 ; i < elem.size() ; i++)
0129    {
0130        const char* abb = elem[i].c_str() ;
0131        unsigned flag = AbbrevToFlag( abb );
0132        //std::cout << " abb " << std::setw(6) << abb << " flag " << flag << std::endl ;
0133
0134        mask |= flag  ;
0135    }
0136    return mask ;
0137 }
0138
0139 /**
0140
0141 OpticksPhoton::AbbrevToFlagValSequence
0142 --------------------------------------
0143
0144 Convert seqmap string into two bigints,
0145 map values are 1-based, zero signifies None.
0146
0147 =====================  =============  ===========
0148 input seqmap             seqhis         seqval
0149 =====================  =============  ===========
0150 "TO:0 SR:1 SA:0"          0x8ad          0x121
0151 "TO:0 SC: SR:1 SA:0"      0x8a6d        0x1201
0152 =====================  =============  ===========
0153
0154 **/
0155
0156 void OpticksPhoton::AbbrevToFlagValSequence( unsigned long long& seqhis, unsigned long long& seqval, const char* seqmap, char edelim)
0157 {
0158    seqhis = 0ull ;
0159    seqval = 0ull ;
0160
0161    std::vector<std::pair<std::string, std::string> > ekv ;
0162    char kvdelim=':' ;
0163    sstr::ekv_split( ekv, seqmap, edelim, kvdelim );
0164
0165    for(unsigned i=0 ; i < ekv.size() ; i++ )
0166    {
0167        std::string skey = ekv[i].first ;
0168        std::string sval = ekv[i].second ;
0169
0170        unsigned flag = AbbrevToFlag( skey.c_str() );
0171        unsigned bitpos = BitPos(flag) ;
0172
0173        unsigned val1 = sval.empty() ? 0 : 1u + std::atoi( sval.c_str() ) ;
0174
0175        unsigned long long ishift = i*4 ;
0176
0177        seqhis |= ( bitpos << ishift )  ;
0178        seqval |= ( val1 << ishift )  ;
0179
0180 #ifdef WITH_SLOG
0181        LOG(debug)
0182                    << "["
0183                    <<  skey
0184                    << "] -> ["
0185                    <<  sval << "]"
0186                    << ( sval.empty() ? "EMPTY" : "" )
0187                    << " val1 " << val1
0188                     ;
0189 #endif
0190     }
0191
0192 }
0193
0194
0195
0196 unsigned OpticksPhoton::PointVal1( const unsigned long long& seqval , unsigned bitpos )
0197 {
0198     return (seqval >> bitpos*4) & 0xF ;
0199 }
0200
0201
0202 unsigned OpticksPhoton::PointFlag( const unsigned long long& seqhis , unsigned bitpos )
0203 {
0204     unsigned long long f = (seqhis >> bitpos*4) & 0xF ;
0205     unsigned flg = f == 0 ? 0 : 0x1 << (f - 1) ;
0206     return flg ;
0207 }
0208
0209 const char* OpticksPhoton::PointAbbrev( const unsigned long long& seqhis , unsigned bitpos )
0210 {
0211     unsigned flg = PointFlag(seqhis, bitpos );
0212     return Abbrev(flg);
0213 }
0214
0215
0216