EIC code displayed by LXR master/​eic-opticks/​ana/​histype.py	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-04-09 07:48:48

 #!/usr/bin/env python
 #
 # Copyright (c) 2019 Opticks Team. All Rights Reserved.
 #
 # This file is part of Opticks
 # (see https://bitbucket.org/simoncblyth/opticks).
 #
 # Licensed under the Apache License, Version 2.0 (the "License"); 
 # you may not use this file except in compliance with the License.  
 # You may obtain a copy of the License at
 #
 #   http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software 
 # distributed under the License is distributed on an "AS IS" BASIS, 
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
 # See the License for the specific language governing permissions and 
 # limitations under the License.
 #
 
 """
 histype.py: HisType
 ========================
 
 ::
 
 
     LV=box histype.py 
 
     histype.py --det PmtInBox --tag 10 --src torch 
     histype.py --det dayabay  --tag 1  --src torch 
 
 
 ::
 
     export OPTICKS_ANA_DEFAULTS="det=tboolean-box,src=torch,tag=1,pfx=."
 
     cd /tmp
     OPTICKS_EVENT_BASE=tboolean-box histype.py
 
 ::
 
 
     In [21]: from opticks.ana.histype import HisType
 
     In [22]: histype = HisType()
 
     In [25]: histype.code("TO BT AB")
     Out[25]: 1229
 
     In [26]: ab.a.seqhis
     Out[26]: 
     A()sliced
     A([36045, 36045,  2237, ..., 36045, 36045, 36045], dtype=uint64)
 
     In [27]: ab.a.seqhis.shape
     Out[27]: (100000,)
 
     In [29]: np.where(ab.a.seqhis == histype.code("TO BT AB"))[0]
     Out[29]: array([ 2084,  4074, 15299, 20870, 25748, 26317, 43525, 51563, 57355, 61602, 65894, 71978, 77062, 78744, 79117, 86814])
 
     In [30]: np.where(ab.a.seqhis == histype.code("TO BT AB"))[0].shape
     Out[30]: (16,)
 
 
 """
 import os, datetime, logging, sys
 log = logging.getLogger(__name__)
 import numpy as np
 
 from opticks.ana.base import PhotonCodeFlags
 from opticks.ana.seq import SeqType, SeqTable, SeqAna
 from opticks.ana.nbase import count_unique_sorted
 from opticks.ana.nload import A
 
 class HisType(SeqType):
     @classmethod
     def Convert(cls, q):
         """
         :param q:   uint64 (100000, 2)  : 2*64 bits (32 nibbles) of history : for 32 points of history 
         :return qq: int8   (100000, 32) 
 
         Place nibbles from q (2 uint64) into qq (32 int8) doubling bits as NumPy lacks an int4 dtype
 
         HMM: would be simpler if NumPy had uint128 dtype 
 
         ::
 
             q = xf.seq[:,0] 
             s = HisType.Convert(q)
             ss = ht.aflags[s].view("|S%d" % (3*32)) 
 
             n = np.sum( seqnib_(q), axis=1 )   
 
             np.c_[ss, n, np.arange(len(ss))]  
 
             In [36]: np.c_[ss, n, np.arange(len(ss))][n > 16]
             Out[36]: 
             array([[b'TO BT BT BT BT SR SR SR BT BT BT BT BT BT BT BT SA                                              ', b'17', b'204'],
                    [b'TO BR BT BT BT BT SR SR SR BT BT BT BT BT BT BR BT BT BT BT SA                                  ', b'21', b'921'],
                    [b'TO BR BR BT BT BT BT SR SR BT BR BT SR SR SR BT BT BT BT BT BT                                  ', b'21', b'925']], dtype='|S96')
 
         """
         qq = np.zeros( (len(q), 32), dtype=np.int8 )  # 32 bytes for each item, ie 64 nibbles 
         for i in np.arange(16): qq[:,i]    = ( q[:,0] >> np.uint64(4*i) ) & 0xf
         for i in np.arange(16): qq[:,16+i] = ( q[:,1] >> np.uint64(4*i) ) & 0xf
         return qq 
 
     def __init__(self):
         flags = PhotonCodeFlags() 
         SeqType.__init__(self, flags, flags.abbrev)
 
     def seqhis(self, q):
         """
         :param q: uint64  (100000, 2) 
         :return s: "|S96" (100000, 1)
 
         ht.aflags  array([b'   ', b'CK ', b'SI ', b'MI ', b'AB ', ... , b'TO ', b'NA ', b'EX ', b'EC ', ..., dtype='|S3')
 
         """ 
         qq = self.Convert(q)
         return self.aflags[qq].view("|S%d" % (32*3) )  # 32 point slots, 3 characters of ht.aflags abbreviations
 
 
 def test_HistoryTable(ht, seqhis):
      log.info("[")  
 
      #print("ht.labels",ht.labels)
 
      for seq in ht.labels:
          seqs = [seq]
          s_seqhis = list(map(lambda _:seqhis == af.code(_), seqs ))
          psel = np.logical_or.reduce(s_seqhis)      
 
          n = len(seqhis[psel])
          assert n == ht.label2count.get(seq)
          print("%10s %s " % (n, seq )) 
      pass
      log.info("]")  
 
 def test_roundtrip(af):
      log.info("[")
      x=0x8cbbbcd
      l = af.label(x)
      c = af.code(l)
      print("%x %s %x " % ( x,l,c ))
      assert x == c 
      log.info("]")
 
 
 def test_load_SeqTable(ok, af):
      try:
          ph = A.load_("ph",ok.src,ok.tag,ok.det, pfx=ok.pfx)
      except IOError as err:
          log.fatal(err) 
          sys.exit(0)
 
      log.info("loaded ph %s %s shape %s " %  (ph.path, ph.stamp, repr(ph.shape)))
 
      seqhis = ph[:,0,0]
 
      cu = count_unique_sorted(seqhis)
 
      ht = SeqTable(cu, af, smry=True)
       
      
      test_HistoryTable(ht, seqhis)
 
 
 
 def test_HisType(af):
     log.info("[")
     print(af)
     print("af.abbrev.name2abbr",af.abbrev.name2abbr)
     print("af.flags.names",af.flags.names)
     print("af.flags.codes",af.flags.codes)
     print("af.abbr2code",af.abbr2code)
     log.info("]")
 
 
 if __name__ == '__main__':
      from opticks.ana.main import opticks_main
      ok = opticks_main()
 
      af = HisType()
 
      #test_HisType(af)
 
      #test_roundtrip(af)
 
      test_load_SeqTable(ok, af)
 
 
 
 
 
 
 

This page was automatically generated by the 2.3.7 LXR engine. The LXR team