eic-opticks/sysrap/SComp.h

0001 #pragma once
0002 /**
0003 SComp.h : naming array components of QEvt/SEvt
0004 =============================================================
0005
0006 NB: the old OpticksEvent analog of this is SComponent.hh
0007
0008 **/
0009
0010 #include <string>
0011 #include <vector>
0012 #include <sstream>
0013 #include <cstring>
0014 #include <bitset>
0015 #include "SYSRAP_API_EXPORT.hh"
0016
0017 struct NP ;
0018
0019 enum {
0020     SCOMP_UNDEFINED      = 0x1 <<  0,
0021     SCOMP_GENSTEP        = 0x1 <<  1,
0022     SCOMP_PHOTON         = 0x1 <<  2,
0023     SCOMP_RECORD         = 0x1 <<  3,
0024     SCOMP_REC            = 0x1 <<  4,
0025     SCOMP_SEQ            = 0x1 <<  5,
0026     SCOMP_PRD            = 0x1 <<  6,
0027     SCOMP_SEED           = 0x1 <<  7,
0028     SCOMP_HIT            = 0x1 <<  8,
0029     SCOMP_SIMTRACE       = 0x1 <<  9,
0030     SCOMP_DOMAIN         = 0x1 << 10,
0031     SCOMP_INPHOTON       = 0x1 << 11,
0032     SCOMP_TAG            = 0x1 << 12,
0033     SCOMP_FLAT           = 0x1 << 13,
0034     SCOMP_ISECT          = 0x1 << 14,
0035     SCOMP_FPHOTON        = 0x1 << 15,
0036     SCOMP_PIXEL          = 0x1 << 16,
0037     SCOMP_G4STATE        = 0x1 << 17,
0038     SCOMP_AUX            = 0x1 << 18,
0039     SCOMP_SUP            = 0x1 << 19,
0040     SCOMP_PHO            = 0x1 << 20,
0041     SCOMP_GS             = 0x1 << 21,
0042     SCOMP_PHOTONLITE     = 0x1 << 22,
0043     SCOMP_HITLITE        = 0x1 << 23,
0044     SCOMP_HITLOCAL       = 0x1 << 24,
0045     SCOMP_PHOTONLOCAL    = 0x1 << 25,
0046     SCOMP_HITLITEMERGED  = 0x1 << 26,
0047     SCOMP_HITMERGED      = 0x1 << 27
0048 };
0049
0050 struct SYSRAP_API SCompProvider
0051 {
0052     virtual const char* getTypeName() const = 0 ;
0053     virtual std::string getMeta() const = 0 ;
0054     virtual NP* gatherComponent(unsigned comp) const = 0 ;
0055 };
0056
0057 struct SYSRAP_API SComp
0058 {
0059     static constexpr const char* NONE_ = "" ;
0060     static constexpr const char* ALL_ = "genstep,photon,record,rec,seq,prd,seed,hit,simtrace,domain,inphoton,tag,flat" ;
0061     static constexpr const char* UNDEFINED_ = "undefined" ;
0062
0063     static constexpr const char* GENSTEP_   = "genstep" ;
0064     static constexpr const char* PHOTON_    = "photon" ;
0065     static constexpr const char* RECORD_    = "record" ;
0066     static constexpr const char* REC_       = "rec" ;
0067     static constexpr const char* SEQ_       = "seq" ;
0068     static constexpr const char* PRD_       = "prd" ;
0069     static constexpr const char* SEED_      = "seed" ;
0070     static constexpr const char* HIT_       = "hit" ;
0071     static constexpr const char* SIMTRACE_  = "simtrace" ;
0072     static constexpr const char* DOMAIN_    = "domain" ;
0073     static constexpr const char* INPHOTON_  = "inphoton" ;
0074     static constexpr const char* TAG_       = "tag" ;
0075     static constexpr const char* FLAT_      = "flat" ;
0076
0077     static constexpr const char* ISECT_     = "isect" ;
0078     static constexpr const char* FPHOTON_   = "fphoton" ;
0079     static constexpr const char* PIXEL_     = "pixel" ;
0080     static constexpr const char* G4STATE_   = "g4state" ;
0081     static constexpr const char* AUX_       = "aux" ;
0082     static constexpr const char* SUP_       = "sup" ;
0083     static constexpr const char* PHO_       = "pho" ;
0084     static constexpr const char* GS_        = "gs" ;
0085     static constexpr const char* PHOTONLITE_ = "photonlite" ;
0086     static constexpr const char* HITLITE_    = "hitlite" ;
0087     static constexpr const char* HITLOCAL_   = "hitlocal" ;
0088     static constexpr const char* PHOTONLOCAL_ = "photonlocal" ;
0089     static constexpr const char* HITLITEMERGED_ = "hitlitemerged" ;
0090     static constexpr const char* HITMERGED_     = "hitmerged" ;
0091
0092     static bool Match(const char* q, const char* n );
0093     static unsigned    Comp(const char* name);
0094     static const char* Name(unsigned comp);
0095     static std::string Desc(unsigned mask);
0096     static std::string Desc(const std::vector<unsigned>& comps);
0097     static void CompList(std::vector<unsigned>& comps, const char* names, char delim=',');
0098     static void CompListAll( std::vector<unsigned>& comps );
0099     static void CompListMask(std::vector<unsigned>& comps, unsigned mask );
0100     static int  CompListCount(unsigned mask );
0101     static unsigned    Mask(const char* names, char delim=',');
0102
0103
0104     static bool IsGenstep( unsigned mask){ return mask & SCOMP_GENSTEP ; }
0105     static bool IsPhoton(  unsigned mask){ return mask & SCOMP_PHOTON ; }
0106     static bool IsRecord(  unsigned mask){ return mask & SCOMP_RECORD ; }
0107     static bool IsRec(     unsigned mask){ return mask & SCOMP_REC ; }
0108     static bool IsSeq(     unsigned mask){ return mask & SCOMP_SEQ ; }
0109     static bool IsPrd(     unsigned mask){ return mask & SCOMP_PRD ; }
0110     static bool IsSeed(    unsigned mask){ return mask & SCOMP_SEED ; }
0111     static bool IsHit(     unsigned mask){ return mask & SCOMP_HIT ; }
0112     static bool IsSimtrace(unsigned mask){ return mask & SCOMP_SIMTRACE ; }
0113     static bool IsDomain(  unsigned mask){ return mask & SCOMP_DOMAIN ; }
0114     static bool IsInphoton(unsigned mask){ return mask & SCOMP_INPHOTON ; }
0115     static bool IsTag(     unsigned mask){ return mask & SCOMP_TAG ; }
0116     static bool IsFlat(    unsigned mask){ return mask & SCOMP_FLAT ; }
0117     static bool IsIsect(   unsigned mask){ return mask & SCOMP_ISECT ; }
0118     static bool IsFphoton( unsigned mask){ return mask & SCOMP_FPHOTON ; }
0119     static bool IsPixel(   unsigned mask){ return mask & SCOMP_PIXEL ; }
0120     static bool IsG4State( unsigned mask){ return mask & SCOMP_G4STATE ; }
0121     static bool IsAux(     unsigned mask){ return mask & SCOMP_AUX ; }
0122     static bool IsSup(     unsigned mask){ return mask & SCOMP_SUP ; }
0123     static bool IsPho(     unsigned mask){ return mask & SCOMP_PHO ; }
0124     static bool IsGS(      unsigned mask){ return mask & SCOMP_GS ; }
0125     static bool IsPhotonLite(  unsigned mask){ return mask & SCOMP_PHOTONLITE ; }
0126     static bool IsHitLite(     unsigned mask){ return mask & SCOMP_HITLITE ; }
0127     static bool IsHitLocal(    unsigned mask){ return mask & SCOMP_HITLOCAL ; }
0128     static bool IsPhotonLocal( unsigned mask){ return mask & SCOMP_PHOTONLOCAL ; }
0129     static bool IsHitLiteMerged( unsigned mask){ return mask & SCOMP_HITLITEMERGED ; }
0130     static bool IsHitMerged(     unsigned mask){ return mask & SCOMP_HITMERGED ; }
0131
0132 };
0133
0134 inline bool SComp::Match(const char* q, const char* n )
0135 {
0136     return q && strcmp( q, n ) == 0 ;
0137 }
0138
0139 inline unsigned SComp::Comp(const char* name)
0140 {
0141     unsigned comp = SCOMP_UNDEFINED ;
0142     if(Match(name, GENSTEP_))  comp = SCOMP_GENSTEP ;
0143     if(Match(name, PHOTON_))   comp = SCOMP_PHOTON ;
0144     if(Match(name, RECORD_))   comp = SCOMP_RECORD ;
0145     if(Match(name, REC_))      comp = SCOMP_REC ;
0146     if(Match(name, SEQ_))      comp = SCOMP_SEQ ;
0147     if(Match(name, PRD_))      comp = SCOMP_PRD ;
0148     if(Match(name, SEED_))     comp = SCOMP_SEED ;
0149     if(Match(name, HIT_))      comp = SCOMP_HIT ;
0150     if(Match(name, SIMTRACE_)) comp = SCOMP_SIMTRACE ;
0151     if(Match(name, DOMAIN_))   comp = SCOMP_DOMAIN ;
0152     if(Match(name, INPHOTON_)) comp = SCOMP_INPHOTON ;
0153     if(Match(name, TAG_))      comp = SCOMP_TAG ;
0154     if(Match(name, FLAT_))     comp = SCOMP_FLAT ;
0155     if(Match(name, ISECT_))    comp = SCOMP_ISECT ;
0156     if(Match(name, FPHOTON_))  comp = SCOMP_FPHOTON ;
0157     if(Match(name, PIXEL_))    comp = SCOMP_PIXEL ;
0158     if(Match(name, G4STATE_))  comp = SCOMP_G4STATE ;
0159     if(Match(name, AUX_))      comp = SCOMP_AUX ;
0160     if(Match(name, SUP_))      comp = SCOMP_SUP ;
0161     if(Match(name, PHO_))      comp = SCOMP_PHO ;
0162     if(Match(name, GS_))       comp = SCOMP_GS ;
0163     if(Match(name, PHOTONLITE_)) comp = SCOMP_PHOTONLITE ;
0164     if(Match(name, HITLITE_))    comp = SCOMP_HITLITE ;
0165     if(Match(name, HITLOCAL_))   comp = SCOMP_HITLOCAL ;
0166     if(Match(name, PHOTONLOCAL_))   comp = SCOMP_PHOTONLOCAL ;
0167     if(Match(name, HITLITEMERGED_)) comp = SCOMP_HITLITEMERGED ;
0168     if(Match(name, HITMERGED_))     comp = SCOMP_HITMERGED ;
0169     return comp ;
0170 }
0171 inline const char* SComp::Name(unsigned comp)
0172 {
0173     const char* s = nullptr ;
0174     switch(comp)
0175     {
0176         case SCOMP_UNDEFINED: s = UNDEFINED_  ; break ;
0177         case SCOMP_GENSTEP:   s = GENSTEP_    ; break ;
0178         case SCOMP_PHOTON:    s = PHOTON_     ; break ;
0179         case SCOMP_RECORD:    s = RECORD_     ; break ;
0180         case SCOMP_REC:       s = REC_        ; break ;
0181         case SCOMP_SEQ:       s = SEQ_        ; break ;
0182         case SCOMP_PRD:       s = PRD_        ; break ;
0183         case SCOMP_SEED:      s = SEED_       ; break ;
0184         case SCOMP_HIT:       s = HIT_        ; break ;
0185         case SCOMP_SIMTRACE:  s = SIMTRACE_   ; break ;
0186         case SCOMP_DOMAIN:    s = DOMAIN_     ; break ;
0187         case SCOMP_INPHOTON:  s = INPHOTON_   ; break ;
0188         case SCOMP_TAG:       s = TAG_        ; break ;
0189         case SCOMP_FLAT:      s = FLAT_       ; break ;
0190         case SCOMP_ISECT:     s = ISECT_      ; break ;
0191         case SCOMP_FPHOTON:   s = FPHOTON_    ; break ;
0192         case SCOMP_PIXEL:     s = PIXEL_      ; break ;
0193         case SCOMP_G4STATE:   s = G4STATE_    ; break ;
0194         case SCOMP_AUX:       s = AUX_        ; break ;
0195         case SCOMP_SUP:       s = SUP_        ; break ;
0196         case SCOMP_PHO:       s = PHO_        ; break ;
0197         case SCOMP_GS:        s = GS_         ; break ;
0198         case SCOMP_PHOTONLITE:s = PHOTONLITE_ ; break ;
0199         case SCOMP_HITLITE:   s = HITLITE_    ; break ;
0200         case SCOMP_HITLOCAL:  s = HITLOCAL_   ; break ;
0201         case SCOMP_PHOTONLOCAL:  s = PHOTONLOCAL_   ; break ;
0202         case SCOMP_HITLITEMERGED:   s = HITLITEMERGED_    ; break ;
0203         case SCOMP_HITMERGED:   s = HITMERGED_    ; break ;
0204     }
0205     return s ;
0206 }
0207 inline std::string SComp::Desc(unsigned mask)
0208 {
0209     // curious using vector of const char* gives undefined symbol link errors : something funny with "static constexpr const char*" ?
0210     std::vector<std::string> names ;
0211     if( mask & SCOMP_GENSTEP )  names.push_back(GENSTEP_) ;
0212     if( mask & SCOMP_PHOTON )   names.push_back(PHOTON_) ;
0213     if( mask & SCOMP_RECORD )   names.push_back(RECORD_) ;
0214     if( mask & SCOMP_REC )      names.push_back(REC_)  ;
0215     if( mask & SCOMP_SEQ )      names.push_back(SEQ_) ;
0216     if( mask & SCOMP_PRD )      names.push_back(PRD_) ;
0217     if( mask & SCOMP_SEED )     names.push_back(SEED_) ;
0218     if( mask & SCOMP_HIT )      names.push_back(HIT_) ;   // CAUTION : HIT MUST STAY AFTER PHOTON IN THE NAMES
0219     if( mask & SCOMP_SIMTRACE ) names.push_back(SIMTRACE_) ;
0220     if( mask & SCOMP_DOMAIN )   names.push_back(DOMAIN_) ;
0221     if( mask & SCOMP_INPHOTON ) names.push_back(INPHOTON_) ;
0222     if( mask & SCOMP_TAG )      names.push_back(TAG_) ;
0223     if( mask & SCOMP_FLAT )     names.push_back(FLAT_) ;
0224     if( mask & SCOMP_ISECT )    names.push_back(ISECT_) ;
0225     if( mask & SCOMP_FPHOTON )  names.push_back(FPHOTON_) ;
0226     if( mask & SCOMP_PIXEL )    names.push_back(PIXEL_) ;
0227     if( mask & SCOMP_G4STATE )  names.push_back(G4STATE_) ;
0228     if( mask & SCOMP_AUX )      names.push_back(AUX_) ;
0229     if( mask & SCOMP_SUP )      names.push_back(SUP_) ;
0230     if( mask & SCOMP_PHO )      names.push_back(PHO_) ;
0231     if( mask & SCOMP_GS )       names.push_back(GS_) ;
0232     if( mask & SCOMP_PHOTONLITE ) names.push_back(PHOTONLITE_) ;
0233     if( mask & SCOMP_HITLITE )    names.push_back(HITLITE_) ;   // CAUTION : HITLITE MUST STAY AFTER PHOTONLITE (?)
0234     if( mask & SCOMP_HITLOCAL )   names.push_back(HITLOCAL_) ;   // CAUTION : HITLOCAL MUST STAY AFTER HIT
0235     if( mask & SCOMP_PHOTONLOCAL )   names.push_back(PHOTONLOCAL_) ;   // CAUTION : PHOTONLOCAL MUST STAY AFTER PHOTON
0236     if( mask & SCOMP_HITLITEMERGED ) names.push_back(HITLITEMERGED_) ;
0237     if( mask & SCOMP_HITMERGED ) names.push_back(HITMERGED_) ;
0238
0239     std::stringstream ss ;
0240     for(unsigned i=0 ; i < names.size() ; i++) ss << names[i] << ( i < names.size() - 1 ? "," : "" );
0241     std::string s = ss.str();
0242     return s ;
0243 }
0244 inline std::string SComp::Desc(const std::vector<unsigned>& comps)
0245 {
0246     std::stringstream ss ;
0247     for(unsigned i=0 ; i < comps.size() ; i++) ss << Name(comps[i]) << ( i < comps.size() - 1 ? "," : "" );
0248     std::string s = ss.str();
0249     return s ;
0250 }
0251
0252
0253 /**
0254 SComp::CompList
0255 ----------------
0256
0257 1. Split *names* using the *delim*
0258 2. collect into *comps* vector the unsigned int corresponding to each name
0259
0260 **/
0261
0262 inline void SComp::CompList(std::vector<unsigned>& comps, const char* names, char delim )
0263 {
0264     if(!names) return ;
0265     std::stringstream ss;
0266     ss.str(names)  ;
0267     std::string s;
0268     while (std::getline(ss, s, delim)) comps.push_back( Comp(s.c_str()) ) ;
0269 }
0270
0271 inline void SComp::CompListAll(std::vector<unsigned>& comps )
0272 {
0273     CompList(comps, ALL_, ',' );
0274 }
0275
0276 inline void SComp::CompListMask(std::vector<unsigned>& comps, unsigned mask )
0277 {
0278     std::bitset<32> msk(mask);
0279     for(unsigned i=0 ; i < msk.size() ; i++) if(msk[i]) comps.push_back( 0x1 << i ) ;
0280 }
0281 inline int SComp::CompListCount(unsigned mask )
0282 {
0283     std::vector<unsigned> comps;
0284     CompListMask(comps, mask);
0285     return comps.size() ;
0286 }
0287
0288
0289 /**
0290 SComp::Mask
0291 -------------
0292
0293 1. Use *CompList* to collect into *comps* vector the unsigned int corresponding to each name from *delim* *names*
0294 2. return the bitwise-OR of all the comp integers
0295
0296 **/
0297
0298
0299 inline unsigned SComp::Mask(const char* names, char delim)
0300 {
0301     std::vector<unsigned> comps ;
0302     CompList(comps, names, delim );
0303     unsigned mask = 0 ;
0304     for(unsigned i=0 ; i < comps.size() ; i++)  mask |= comps[i] ;
0305     return mask ;
0306 }
0307
0308
0309
0310