eic-opticks/sysrap/OpticksPhoton.hh

0001 #pragma once
0002 /**
0003 OpticksPhoton.hh
0004 =================
0005
0006 The STANDALONE subset of methods can be used header only.
0007
0008 **/
0009
0010 #include <cassert>
0011 #include <vector>
0012 #include <map>
0013 #include <string>
0014 #include <iostream>
0015 #include <sstream>
0016
0017 #ifdef WITH_SLOG
0018 #include "plog/Severity.h"
0019 #endif
0020
0021 #include "OpticksPhoton.h"
0022
0023 #ifdef STANDALONE
0024 struct OpticksPhoton
0025 #else
0026 #include "SYSRAP_API_EXPORT.hh"
0027 struct SYSRAP_API OpticksPhoton
0028 #endif
0029 {
0030 #ifdef WITH_SLOG
0031     static const plog::Severity LEVEL ;
0032 #endif
0033     static constexpr const char* ZERO_ = ".";
0034     static constexpr const char* CERENKOV_ = "CERENKOV";
0035     static constexpr const char* SCINTILLATION_ = "SCINTILLATION" ;
0036     static constexpr const char* TORCH_ = "TORCH" ;
0037     static constexpr const char* MISS_ = "MISS" ;
0038     static constexpr const char* BULK_ABSORB_ = "BULK_ABSORB" ;
0039     static constexpr const char* BULK_REEMIT_ = "BULK_REEMIT" ;
0040     static constexpr const char* BULK_SCATTER_ = "BULK_SCATTER" ;
0041     static constexpr const char* SURFACE_DETECT_ = "SURFACE_DETECT" ;
0042     static constexpr const char* SURFACE_ABSORB_ = "SURFACE_ABSORB" ;
0043     static constexpr const char* SURFACE_DREFLECT_ = "SURFACE_DREFLECT" ;
0044     static constexpr const char* SURFACE_SREFLECT_ = "SURFACE_SREFLECT" ;
0045     static constexpr const char* BOUNDARY_REFLECT_ = "BOUNDARY_REFLECT" ;
0046     static constexpr const char* BOUNDARY_TRANSMIT_ = "BOUNDARY_TRANSMIT" ;
0047     static constexpr const char* NAN_ABORT_ = "NAN_ABORT" ;
0048     static constexpr const char* EFFICIENCY_CULL_ = "EFFICIENCY_CULL" ;
0049     static constexpr const char* EFFICIENCY_COLLECT_ = "EFFICIENCY_COLLECT" ;
0050     static constexpr const char* BAD_FLAG_ = "BAD_FLAG" ;
0051     static constexpr const char* DEFER_FSTRACKINFO_ = "DEFER_FSTRACKINFO" ;
0052
0053     static constexpr const char* _ZERO              = "  " ;
0054     static constexpr const char* _CERENKOV          = "CK" ;
0055     static constexpr const char* _SCINTILLATION     = "SI" ;
0056     static constexpr const char* _TORCH             = "TO" ;
0057     static constexpr const char* _MISS              = "MI" ;
0058     static constexpr const char* _BULK_ABSORB       = "AB" ;
0059     static constexpr const char* _BULK_REEMIT       = "RE" ;
0060     static constexpr const char* _BULK_SCATTER      = "SC" ;
0061     static constexpr const char* _SURFACE_DETECT    = "SD" ;
0062     static constexpr const char* _SURFACE_ABSORB    = "SA" ;
0063     static constexpr const char* _SURFACE_DREFLECT  = "DR" ;
0064     static constexpr const char* _SURFACE_SREFLECT  = "SR" ;
0065     static constexpr const char* _BOUNDARY_REFLECT  = "BR" ;
0066     static constexpr const char* _BOUNDARY_TRANSMIT = "BT" ;
0067     static constexpr const char* _NAN_ABORT         = "NA" ;
0068     static constexpr const char* _EFFICIENCY_COLLECT = "EC" ;
0069     static constexpr const char* _EFFICIENCY_CULL    = "EX" ;
0070     static constexpr const char* _BAD_FLAG           = "XX" ;
0071     static constexpr const char* _DEFER_FSTRACKINFO  = "YY" ;
0072
0073     static bool IsTerminalFlag(const unsigned flag);
0074     static bool IsBoundaryFlag(const unsigned flag);
0075     static bool IsBulkFlag(const unsigned flag);
0076     static bool IsLiveFlag(const unsigned flag);
0077     static bool IsReflectFlag(const unsigned flag);
0078     static bool IsTransmitFlag(const unsigned flag);
0079     static bool IsSurfaceDetectOrAbsorbFlag(const unsigned flag);
0080     static bool IsSurfaceDetectFlag(const unsigned flag);
0081     static bool IsDetectFlag(const unsigned flag);
0082
0083     static bool HasCerenkovFlag(const unsigned flagmask);
0084     static bool HasScintillationFlag(const unsigned flagmask);
0085     static bool HasTorchFlag(const unsigned flagmask);
0086
0087     static const char* Flag(  const unsigned flag);
0088     static const char* Abbrev(const unsigned flag);
0089     static void FlagAbbrevPairs( std::vector<std::pair<const char*, const char*>>& pairs ) ;
0090     static std::string FlagSequence(const unsigned long long seqhis, bool abbrev=true, int highlight=-1);
0091
0092     template<typename T>
0093     static std::string FlagSequence_(const T* seqhis, unsigned nseq, bool abbrev=true, int highlight=-1);
0094     // added the underscore as distinguishing by value or pointer is asking for confusion
0095
0096     static std::string FlagMaskLabel(const unsigned mskhis, bool abbrev=true);
0097
0098 #ifdef STANDALONE
0099 #else
0100     static const char* flag2color ;
0101
0102     static unsigned EnumFlag(unsigned bitpos);
0103     static unsigned BitPos(unsigned flag);
0104     static unsigned AbbrevToFlag( const char* abbrev );
0105     static unsigned long long AbbrevToFlagSequence( const char* abbseq, char delim=' ');
0106
0107     static unsigned GetFlagMask(const char* abbrseq, char delim=',');
0108     static unsigned AbbrevSequenceToMask( const char* abbseq, char delim=' ');
0109     static void AbbrevToFlagValSequence( unsigned long long& seqhis, unsigned long long& seqval, const char* seqmap, char edelim=' ') ;
0110
0111     static unsigned PointVal1( const unsigned long long& seqval , unsigned bitpos );
0112     static unsigned PointFlag( const unsigned long long& seqhis , unsigned bitpos );
0113     static const char* PointAbbrev( const unsigned long long& seqhis , unsigned bitpos );
0114 #endif
0115 };
0116
0117
0118
0119 inline bool OpticksPhoton::IsTerminalFlag(const unsigned flag) // static : AB SA SD MI
0120 {
0121     return (flag & (BULK_ABSORB | SURFACE_ABSORB | SURFACE_DETECT | MISS | EFFICIENCY_COLLECT | EFFICIENCY_CULL )) != 0 ;
0122 }
0123 inline bool OpticksPhoton::IsBoundaryFlag(const unsigned flag) // static :  SD SA DR SR BR BT
0124 {
0125     return (flag & (SURFACE_DETECT | SURFACE_ABSORB | SURFACE_DREFLECT | SURFACE_SREFLECT | BOUNDARY_REFLECT | BOUNDARY_TRANSMIT | EFFICIENCY_COLLECT | EFFICIENCY_CULL )) != 0 ;
0126 }
0127 inline bool OpticksPhoton::IsBulkFlag(const unsigned flag) // static : AB SC RE TO CK SI
0128 {
0129     return (flag & (BULK_ABSORB | BULK_SCATTER | BULK_REEMIT | TORCH | CERENKOV | SCINTILLATION )) != 0 ;
0130 }
0131 inline bool OpticksPhoton::IsLiveFlag(const unsigned flag) // static : SC BT BR DR SR RE
0132 {
0133     return (flag & (BULK_SCATTER | BOUNDARY_TRANSMIT | BOUNDARY_REFLECT | SURFACE_DREFLECT | SURFACE_SREFLECT | BULK_REEMIT )) != 0 ;
0134 }
0135 inline bool OpticksPhoton::IsReflectFlag(const unsigned flag) // static : BR DR SR
0136 {
0137     return (flag & (BOUNDARY_REFLECT | SURFACE_DREFLECT | SURFACE_SREFLECT)) != 0 ;
0138 }
0139 inline bool OpticksPhoton::IsTransmitFlag(const unsigned flag) // static : BT
0140 {
0141     return flag == BOUNDARY_TRANSMIT ;
0142 }
0143 inline bool OpticksPhoton::IsSurfaceDetectOrAbsorbFlag(const unsigned flag) // static : SD SA
0144 {
0145     return (flag & (SURFACE_DETECT | SURFACE_ABSORB)) != 0  ;
0146 }
0147 inline bool OpticksPhoton::IsSurfaceDetectFlag(const unsigned flag) // static : SD
0148 {
0149     return flag == SURFACE_DETECT ;
0150 }
0151 inline bool OpticksPhoton::IsDetectFlag(const unsigned flag) // static : SD EC EX
0152 {
0153     return (flag & (SURFACE_DETECT | EFFICIENCY_COLLECT | EFFICIENCY_CULL )) != 0 ;
0154 }
0155
0156
0157
0158
0159 inline bool OpticksPhoton::HasCerenkovFlag(const unsigned flagmask)
0160 {
0161     return ( flagmask & CERENKOV ) != 0 ;
0162 }
0163 inline bool OpticksPhoton::HasScintillationFlag(const unsigned flagmask)
0164 {
0165     return ( flagmask & SCINTILLATION ) != 0 ;
0166 }
0167 inline bool OpticksPhoton::HasTorchFlag(const unsigned flagmask)
0168 {
0169     return ( flagmask & TORCH ) != 0 ;
0170 }
0171
0172
0173
0174
0175
0176
0177
0178
0179
0180
0181
0182
0183 /**
0184 OpticksPhoton::Flag
0185 --------------------
0186
0187 **/
0188
0189
0190 inline const char* OpticksPhoton::Flag(const unsigned int flag)
0191 {
0192     const char* s = 0 ;
0193     switch(flag)
0194     {
0195         case 0:                s=ZERO_;break;
0196         case CERENKOV:         s=CERENKOV_;break;
0197         case SCINTILLATION:    s=SCINTILLATION_ ;break;
0198         case MISS:             s=MISS_ ;break;
0199         case BULK_ABSORB:      s=BULK_ABSORB_ ;break;
0200         case BULK_REEMIT:      s=BULK_REEMIT_ ;break;
0201         case BULK_SCATTER:     s=BULK_SCATTER_ ;break;
0202         case SURFACE_DETECT:   s=SURFACE_DETECT_ ;break;
0203         case SURFACE_ABSORB:   s=SURFACE_ABSORB_ ;break;
0204         case SURFACE_DREFLECT: s=SURFACE_DREFLECT_ ;break;
0205         case SURFACE_SREFLECT: s=SURFACE_SREFLECT_ ;break;
0206         case BOUNDARY_REFLECT: s=BOUNDARY_REFLECT_ ;break;
0207         case BOUNDARY_TRANSMIT:s=BOUNDARY_TRANSMIT_ ;break;
0208         case TORCH:            s=TORCH_ ;break;
0209         case NAN_ABORT:        s=NAN_ABORT_ ;break;
0210         case EFFICIENCY_CULL:    s=EFFICIENCY_CULL_ ;break;
0211         case EFFICIENCY_COLLECT: s=EFFICIENCY_COLLECT_ ;break;
0212         case DEFER_FSTRACKINFO:  s=DEFER_FSTRACKINFO_ ; break ;
0213         default:               s=BAD_FLAG_  ;
0214         //std::cerr << "OpticksPhoton::Flag BAD_FLAG [" << flag << "]" << std::hex << flag << std::dec << std::endl ;
0215     }
0216     return s;
0217 }
0218
0219 inline const char* OpticksPhoton::Abbrev(const unsigned int flag)
0220 {
0221     const char* s = 0 ;
0222     switch(flag)
0223     {
0224         case 0:                s=_ZERO;break;
0225         case CERENKOV:         s=_CERENKOV;break;
0226         case SCINTILLATION:    s=_SCINTILLATION ;break;
0227         case MISS:             s=_MISS ;break;
0228         case BULK_ABSORB:      s=_BULK_ABSORB ;break;
0229         case BULK_REEMIT:      s=_BULK_REEMIT ;break;
0230         case BULK_SCATTER:     s=_BULK_SCATTER ;break;
0231         case SURFACE_DETECT:   s=_SURFACE_DETECT ;break;
0232         case SURFACE_ABSORB:   s=_SURFACE_ABSORB ;break;
0233         case SURFACE_DREFLECT: s=_SURFACE_DREFLECT ;break;
0234         case SURFACE_SREFLECT: s=_SURFACE_SREFLECT ;break;
0235         case BOUNDARY_REFLECT: s=_BOUNDARY_REFLECT ;break;
0236         case BOUNDARY_TRANSMIT:s=_BOUNDARY_TRANSMIT ;break;
0237         case TORCH:            s=_TORCH ;break;
0238         case NAN_ABORT:        s=_NAN_ABORT ;break;
0239         case EFFICIENCY_COLLECT: s=_EFFICIENCY_COLLECT ;break;
0240         case EFFICIENCY_CULL:    s=_EFFICIENCY_CULL ;break;
0241         case DEFER_FSTRACKINFO:  s=_DEFER_FSTRACKINFO ; break ;
0242         default:               s=_BAD_FLAG  ;
0243
0244         //    std::cerr << "OpticksPhoton::Abbrev BAD_FLAG [" << flag << "]" << std::hex << flag << std::dec << std::endl ;
0245         //    OpticksPhoton::AbbrevToFlag does a "lazy lookup" trying all flags against abb string
0246         //    so getting bad flag is to be expected
0247     }
0248     return s;
0249 }
0250
0251
0252
0253
0254 inline void OpticksPhoton::FlagAbbrevPairs( std::vector<std::pair<const char*, const char*>>& pairs )
0255 {
0256     typedef std::pair<const char*,const char*> KV ;
0257     pairs.push_back(KV(CERENKOV_ , _CERENKOV));
0258     pairs.push_back(KV(SCINTILLATION_ , _SCINTILLATION));
0259     pairs.push_back(KV(TORCH_ , _TORCH));
0260     pairs.push_back(KV(MISS_ , _MISS));
0261     pairs.push_back(KV(BULK_ABSORB_ , _BULK_ABSORB));
0262     pairs.push_back(KV(BULK_REEMIT_ , _BULK_REEMIT));
0263     pairs.push_back(KV(BULK_SCATTER_ , _BULK_SCATTER));
0264     pairs.push_back(KV(SURFACE_DETECT_ , _SURFACE_DETECT));
0265     pairs.push_back(KV(SURFACE_ABSORB_ , _SURFACE_ABSORB));
0266     pairs.push_back(KV(SURFACE_DREFLECT_ , _SURFACE_DREFLECT));
0267     pairs.push_back(KV(SURFACE_SREFLECT_ , _SURFACE_SREFLECT));
0268     pairs.push_back(KV(BOUNDARY_REFLECT_ , _BOUNDARY_REFLECT));
0269     pairs.push_back(KV(BOUNDARY_TRANSMIT_ , _BOUNDARY_TRANSMIT));
0270     pairs.push_back(KV(NAN_ABORT_ , _NAN_ABORT));
0271     pairs.push_back(KV(EFFICIENCY_CULL_ , _EFFICIENCY_CULL));
0272     pairs.push_back(KV(EFFICIENCY_COLLECT_ , _EFFICIENCY_COLLECT));
0273     pairs.push_back(KV(DEFER_FSTRACKINFO_ , _DEFER_FSTRACKINFO));
0274
0275     // HMM: no _BAD_FLAG abbrev ?
0276 }
0277
0278
0279 inline std::string OpticksPhoton::FlagSequence(const unsigned long long seqhis, bool abbrev, int highlight)
0280 {
0281     return FlagSequence_<unsigned long long>(&seqhis, 1, abbrev, highlight );
0282 }
0283
0284 template<typename T>
0285 inline std::string OpticksPhoton::FlagSequence_(const T* seqhis, unsigned nseq, bool abbrev, int highlight)
0286 {
0287     assert(sizeof(T)*8 == 16*4);
0288     unsigned hi = highlight < 0 ? 16*nseq : highlight ;
0289
0290     std::stringstream ss ;
0291
0292     for(unsigned i=0 ; i < nseq ; i++)
0293     for(unsigned j=0 ; j < 16   ; j++)
0294     {
0295         unsigned long long f = (seqhis[i] >> j*4) & 0xF ;
0296         unsigned int flg = f == 0 ? 0 : 0x1 << (f - 1) ;
0297         if(j == hi) ss << "[" ;
0298         ss << ( abbrev ? Abbrev(flg) : Flag(flg) ) ;
0299         if(j == hi) ss << "]" ;
0300         ss << " " ;
0301     }
0302     return ss.str();
0303 }
0304
0305
0306 /**
0307 OpticksPhoton::FlagMaskLabel  (formerly FlagMask)
0308 --------------------------------------------------
0309
0310 A string labelling the bits set in the mskhis is returned.
0311
0312 **/
0313
0314 inline std::string OpticksPhoton::FlagMaskLabel(const unsigned mskhis, bool abbrev)
0315 {
0316     std::vector<const char*> labels ;
0317     unsigned lastBit = 17 ;
0318     assert( __MACHINERY == 0x1 << lastBit );
0319
0320     for(unsigned n=0 ; n <= lastBit ; n++ )
0321     {
0322         unsigned flag = 0x1 << n ;
0323         if(mskhis & flag) labels.push_back( abbrev ? Abbrev(flag) : Flag(flag) );
0324     }
0325     unsigned nlab = labels.size() ;
0326
0327     std::stringstream ss ;
0328     for(unsigned i=0 ; i < nlab ; i++ ) ss << labels[i] << ( i < nlab - 1 ? "|" : ""  ) ;
0329     return ss.str();
0330 }
0331
0332
0333
0334
0335