diff --git a/CSG/CSGFoundry.py b/CSG/CSGFoundry.py
deleted file mode 100644
index e1ea5c94c9..0000000000
--- a/CSG/CSGFoundry.py
+++ /dev/null
@@ -1,1170 +0,0 @@
-#!/usr/bin/env python
-import os, sys, re,  numpy as np, logging, datetime
-from configparser import ConfigParser
-from collections import OrderedDict, Counter
-log = logging.getLogger(__name__)
-
-#from opticks.ana.key import keydir
-from opticks.ana.fold import Fold, STR
-from opticks.sysrap.OpticksCSG import CSG_
-
-
-
-class KeyNameConfig(object):
-    """
-    Parses ini file of the below form::
-
-        [key_boundary_regexp]
-        red = (?P<Water_Virtuals>Water/.*/Water$)
-        blue = Water///Acrylic$
-        magenta = Water/Implicit_RINDEX_NoRINDEX_pOuterWaterInCD_pInnerReflector//Tyvek$
-        yellow = DeadWater/Implicit_RINDEX_NoRINDEX_pDeadWater_pTyvekFilm//Tyvek$
-        pink = Air/CDTyvekSurface//Tyvek$
-        cyan = Tyvek//Implicit_RINDEX_NoRINDEX_pOuterWaterInCD_pCentralDetector/Water$
-        orange = Water/Steel_surface//Steel$
-        grey =
-        # empty value is special cased to mean all other boundary names
-
-    Defaults path is $HOME/.opticks/GEOM/cxt_min.ini
-    """
-
-
-    def __init__(self, _path ):
-        path = os.path.expandvars(_path)
-        cfg = ConfigParser()
-        cfg.read(path)
-
-        self._path = _path
-        self.path = path
-        self.cfg = cfg
-
-
-    def __call__(self, _section):
-        sect = self.cfg[_section]
-        bdict = OrderedDict(sect)
-
-        counts = Counter(bdict.values())
-        duplicates = [val for val, count in counts.items() if count > 1]
-
-        if duplicates:
-            log.fatal(f"CSGFoundry.py/KeyNameConfig : Found duplicated values: {duplicates}")
-            sys.exit(1)
-        pass
-
-        return bdict
-
-
-
-
-
-class NameTable(object):
-    def __init__(self, symbol, ix, ixn, d_qix={}, KEY=None):
-        """
-        :param symbol: eg btab or ptab
-        :param ix: large array of indices (eg boundaries or globalPrimIdx)
-        :param ixn: smallish array of names
-        :param d_qix: dict keyed on colors with arrays of ixn indices as values
-        """
-        u, x, c = np.unique(ix, return_index=True, return_counts=True)
-
-        if "KLUDGE" in os.environ:
-            kludge = u != 0xffff
-            u = u[kludge]
-            x = x[kludge]
-            c = c[kludge]
-        pass
-
-        # form array with the keys that each boundary index is grouped into
-        akk = np.repeat("????????????????", len(u))
-        for i in range(len(u)):
-            kk = []
-            for k, qix in d_qix.items():
-                if len(np.where(np.isin(qix, u[i]))[0]) == 1:
-                    kk.append(k)
-                pass
-            pass
-            akk[i] = ",".join(kk)
-        pass
-        n = ixn[u] # IF THIS FAILS FROM 0xffff TRY KLUDGE=1
-        o = np.argsort(c)[::-1]
-
-        _tab = "np.c_[akk, u, c, x, n][o]"
-        tab = eval(_tab)
-
-        self.symbol = symbol
-        self.akk = akk[o]
-        self.u = u[o]
-        self.x = x[o]
-        self.c = c[o]
-        self.n = n[o]
-
-        self.KEY = KEY
-
-        self.d_qix = d_qix
-        self._tab = _tab
-        self.tab = tab
-        self.ixn = ixn
-
-    def get_names(self, k):
-        """
-        print("\n".join(cf.primname[cf.cxtp.d_qix['thistle']]))
-        """
-        return self.ixn[self.d_qix[k]]
-
-    def dump_names(self, k):
-        names = self.get_names(k)
-        print("\n".join(names))
-
-    def __repr__(self):
-        """
-        """
-        vfmt = " %20s : %4d %8d %8d : %s "
-        sfmt = " %20s : %4s %8s %8s : %s "
-        tfmt = " %20s : %4s %8d %8s : %s "
-
-        label = sfmt % ( ".akk", ".u", ".c", ".x", ".n" )
-        lines = []
-        lines.append("[cf.%s KEY:%s" % (self.symbol, self.KEY) )
-        lines.append(label)
-
-        if not self.KEY is None:
-            if self.KEY.startswith("~"):
-                KEY = self.KEY[1:]
-                invert = True
-            else:
-                KEY = self.KEY
-                invert = False
-            pass
-            KK = np.array(self.KEY.split(","))
-            sel = np.where(np.isin(self.tab[:,0], KK, invert=invert))[0]
-        else:
-            sel = slice(None)
-        pass
-
-        ctot = 0
-        for row in self.tab[sel]:
-            akk = row[0]
-            u = int(row[1])
-            c = int(row[2])
-            x = int(row[3])
-            n = row[4]
-
-            line = vfmt % ( akk, u, c, x, n )
-            ctot += c
-            lines.append(line)
-        pass
-        lines.append(label)
-        lines.append(tfmt % ("", "",ctot, "",".ctot"))
-        lines.append("]cf.%s" % self.symbol )
-        self.ctot = ctot
-        return "\n".join(lines)
-
-
-
-class GroupedNameTable(object):
-    def __init__(self, symbol, ix, d_qix, d_anno, cf_ixn, lwid=100):
-        """
-        :param symbol: identifier
-        :param ix: large array of indices
-        :param d_qix: dict keyed on colors with indices array values
-        :param d_anno: dict keyed on colors with label values
-        :param cf_ixn: small array of all names
-        :param lwid: width of the label field
-        """
-        self.symbol = symbol
-        self.ix = ix
-        self.d_qix = d_qix
-        self.d_anno = d_anno
-        self.cf_ixn = cf_ixn
-        self.lwid = lwid
-
-        wdict = {}
-        for k,qix in self.d_qix.items():
-            _w = np.isin( ix, qix )   # bool array indicating which elem of ix are in the qix array
-            w = np.where(_w)[0]       # indices of ix array with ix names matching the regexp
-            wdict[k] = w
-        pass
-        self.wdict = wdict
-
-    def __repr__(self):
-        """
-        """
-        lines = []
-        lines.append("[cf.%s___________________________________" % self.symbol )
-        fmt = " %%15s %%%(lwid)ds nnn:%%4d %%s " % dict(lwid=self.lwid)
-        for k,qix in self.d_qix.items():
-            _w = np.isin( self.ix, qix )   # bool array indicating which elem of bn are in the qbn array
-            w = np.where(_w)[0]       # indices of bn array with boundaries matching the regexp
-            label = self.d_anno[k]
-            nn = self.cf_ixn[qix]
-            line = fmt % (k, label, len(nn), str(qix[:10]))
-            lines.append(line)
-        pass
-        lines.append("]cf.%s_______ cf.%s.d_qix ____________________________" % ( self.symbol, self.symbol) )
-        return "\n".join(lines)
-
-
-
-
-
-
-class CSGObject(object):
-    @classmethod
-    def Label(cls, spc=5, pfx=10):
-        prefix = " " * pfx
-        spacer = " " * spc
-        return prefix + spacer.join(cls.FIELD)
-
-    @classmethod
-    def Fields(cls, bi=False):
-        kls = cls.__name__
-        for i, field in enumerate(cls.FIELD):
-            setattr(cls, field, i)
-            if bi:setattr(builtins, field, i)
-        pass
-
-    @classmethod
-    def Type(cls):
-        cls.Fields()
-        kls = cls.__name__
-        print("%s.Type()" % kls )
-        for i, field in enumerate(cls.FIELD):
-            name = cls.DTYPE[i][0]
-            fieldname = "%s.%s" % (kls, field)
-            print(" %2d : %20s : %s " % (i, fieldname, name))
-        pass
-        print("%s.Label() : " % cls.Label() )
-
-    @classmethod
-    def RecordsFromArrays(cls, a):
-        """
-        :param a: ndarray
-        :return: np.recarray
-        """
-        ra = np.core.records.fromarrays(a.T, dtype=cls.DTYPE )
-        return ra
-
-
-
-class CSGPrim(CSGObject):
-    DTYPE = [
-             ('numNode', '<i4'),
-             ('nodeOffset', '<i4'),
-             ('tranOffset', '<i4'),
-             ('planOffset', '<i4'),
-             ('sbtIndexOffset', '<i4'),
-             ('meshIdx', '<i4'),
-             ('repeatIdx', '<i4'),
-             ('primIdx', '<i4'),
-             ]
-
-    EXTRA = [
-             ('BBMin_x', '<f4'),
-             ('BBMin_y', '<f4'),
-             ('BBMin_z', '<f4'),
-             ('BBMax_x', '<f4'),
-             ('BBMax_y', '<f4'),
-             ('BBMax_z', '<f4'),
-             ('spare32', '<f4'),
-             ('spare33', '<f4'),
-             ]
-
-    FIELD = "nn no to po sb lv ri pi".split()
-    XFIELD = "nx ny nz mx my mz s2 s3".split()
-
-
-
-class CSGNode(CSGObject):
-    DTYPE = [
-             ('p0', '<f4'),
-             ('p1', '<f4'),
-             ('p2', '<f4'),
-             ('p3', '<f4'),
-             ('p4', '<f4'),
-             ('p5', '<f4'),
-             ('boundary', '<i4'),
-             ('index', '<i4'),
-             ('BBMin_x', '<f4'),
-             ('BBMin_y', '<f4'),
-             ('BBMin_z', '<f4'),
-             ('BBMax_x', '<f4'),
-             ('BBMax_y', '<f4'),
-             ('BBMax_z', '<f4'),
-             ('typecode','<i4'),
-             ('comptran','<i4'),
-             ]
-    FIELD = "p0 p1 p2 p3 p4 p5 bn ix nx ny nz mx my mz tc ct".split()
-
-
-
-
-class MM(object):
-    """
-    The input file is now a standard resident of the CSGFoundry directory
-    Note that the input file was formerly created using::
-
-       ggeo.py --mmtrim > $TMP/mm.txt
-
-    """
-    PTN = re.compile("\\d+")
-    def __init__(self, path ):
-        mm = os.path.expandvars(path)
-        mm = open(mm, "r").read().splitlines() if os.path.exists(mm) else None
-        self.mm = mm
-        if mm is None:
-            log.fatal("missing %s, which is now a standard part of CSGFoundry " % path  )
-            sys.exit(1)
-        pass
-
-    def imm(self, emm):
-        return list(map(int, self.PTN.findall(emm)))
-
-    def label(self, emm):
-        imm = self.imm(emm)
-        labs = [self.mm[i] for i in imm]
-        lab = " ".join(labs)
-
-        tilde = emm[0] == "t" or emm[0] == "~"
-        pfx = (  "NOT: " if tilde else "     " )
-
-        if emm == "~0" or emm == "t0":
-            return "ALL"
-        elif imm == [1,2,3,4]:
-            return "ONLY PMT"
-        elif "," in emm:
-            return ( "EXCL: " if tilde else "ONLY: " ) +  lab
-        else:
-            return lab
-        pass
-
-    def __repr__(self):
-        return STR("\n".join(self.mm))
-
-
-class LV(object):
-    PTN = re.compile("\\d+")
-    def __init__(self, path):
-        lv = os.path.expandvars(path)
-        lv = open(lv, "r").read().splitlines() if os.path.exists(lv) else None
-        self.lv = lv
-        if lv is None:
-            log.fatal("missing %s, which is now a standard part of CSGFoundry " % path  )
-            sys.exit(1)
-        pass
-
-    def ilv(self, elv):
-        return list(map(int, self.PTN.findall(elv)))
-
-    def label(self, elv):
-        ilv = self.ilv(elv)
-        mns = [self.lv[i] for i in ilv]
-        mn = " ".join(mns)
-        tilde = elv[0] == "t"
-        lab = ""
-        if elv == "t":
-            lab = "ALL"
-        else:
-            lab = ( "EXCL: " if tilde else "ONLY: " ) + mn
-        pass
-        return lab
-
-    def __str__(self):
-        return "\n".join(self.lv)
-
-    def __repr__(self):
-        return "\n".join(["%3d:%s " % (i, self.lv[i]) for i in range(len(self.lv))])
-
-
-
-class Deprecated_NPFold(object):
-    """
-    HMM opticks.ana.fold.Fold looks more developed than this
-    TODO: eliminate all use of this
-    """
-    INDEX = "NPFold_index.txt"
-
-    @classmethod
-    def IndexPath(cls, fold):
-        return os.path.join(fold, cls.INDEX)
-
-    @classmethod
-    def HasIndex(cls, fold):
-        return os.path.exists(cls.IndexPath(fold))
-
-    @classmethod
-    def Load(cls, *args, **kwa):
-        return cls(*args, **kwa)
-
-    def __init__(self, *args, **kwa):
-        fold = os.path.join(*args)
-        self.fold = fold
-        self.has_index = self.HasIndex(fold)
-
-        if self.has_index:
-            self.load_idx(fold)
-        else:
-            self.load_fts(fold)
-        pass
-
-    def load_fts(self, fold):
-        assert 0
-
-    def load_idx(self, fold):
-        keys = open(self.IndexPath(fold),"r").read().splitlines()
-        aa = []
-        kk = []
-        ff = []
-        subfold = []
-
-        for k in keys:
-            path = os.path.join(fold, k)
-            if k.endswith(".npy"):
-                assert os.path.exists(path)
-                log.info("loading path %s k %s " % (path, k))
-                a = np.load(path)
-                aa.append(a)
-                kk.append(k)
-            else:
-                log.info("skip non .npy path %s k %s " % (path, k))
-            pass
-        pass
-        self.kk = kk
-        self.aa = aa
-        self.ff = ff
-        self.subfold = subfold
-        self.keys = keys
-
-
-    def find(self, k):
-        return self.kk.index(k) if k in self.kk else -1
-
-    def has_key(self, k):
-        return self.find(k) > -1
-
-    def __repr__(self):
-        lines = []
-        lines.append("NPFold %s " % self.fold )
-        for i in range(len(self.kk)):
-            k = self.kk[i]
-            a = self.aa[i]
-            stem, ext = os.path.splitext(os.path.basename(k))
-            path = os.path.join(self.fold, k)
-            lines.append("%10s : %20s : %s " % (stem, str(a.shape), k ))
-        pass
-        return "\n".join(lines)
-
-
-class Deprecated_SSim(object):
-    """
-    HMM: this adds little on top of ana.fold.Fold
-    TODO: get rid of it
-    """
-    BND = "bnd.npy"
-
-
-    @classmethod
-    def Load(cls, simbase):
-        ssdir = os.path.join(simbase, "SSim")
-        log.info("SSim.Load simbase %s ssdir %s " % (simbase,ssdir))
-        sim = Fold.Load(ssdir) if os.path.isdir(ssdir) else None
-        return sim
-
-    def __init__(self, fold):
-        if self.has_key(self.BND):
-            bnpath = os.path.join(fold, "bnd_names.txt")
-            assert os.path.exists(bnpath)
-            bnd_names = open(bnpath,"r").read().splitlines()
-            self.bnd_names = bnd_names
-        pass
-        if hasattr(self, 'bnd_names'):  # names list from NP bnd.names metadata
-             bndnamedict = SSim.namelist_to_namedict(self.bnd_names)
-        else:
-             bndnamedict = {}
-        pass
-        self.bndnamedict = bndnamedict
-        pass
-
-
-
-class CSGFoundry(object):
-    FOLD = os.path.expandvars("$TMP/CSG_GGeo/CSGFoundry")
-    FMT = "   %10s : %20s  : %s "
-
-
-    @classmethod
-    def namelist_to_namedict(cls, namelist):
-        nd = {}
-        if not namelist is None:
-            nd = dict(zip(range(len(namelist)),list(map(str,namelist))))
-        pass
-        return nd
-
-
-    @classmethod
-    def CFBase(cls):
-        """
-        Precedence order for which envvars are used to derive the CFBase folder is:
-
-        1. CFBASE_LOCAL
-        2. CFBASE_ALT
-        3. CFBASE
-        4. GEOM
-
-        This allows scripts such as CSGOptiX/cxt_min.sh to set envvars to control
-        the geometry arrays and meshname.txt etc that is loaded.
-        For example this could be used such that local analysis on laptop can use
-        a geometry rsynced from remote.
-
-        """
-        if "CFBASE_LOCAL" in os.environ:
-            cfbase= os.environ["CFBASE_LOCAL"]
-            note = "via CFBASE_LOCAL"
-        elif "CFBASE_ALT" in os.environ:
-            cfbase= os.environ["CFBASE_ALT"]
-            note = "via CFBASE_ALT"
-        elif "CFBASE" in os.environ:
-            cfbase= os.environ["CFBASE"]
-            note = "via CFBASE"
-        elif "GEOM" in os.environ:
-            KEY = os.path.expandvars("${GEOM}_CFBaseFromGEOM")
-            if KEY in os.environ:
-                cfbase = os.environ[KEY]
-                note = "via GEOM,%s" % KEY
-            else:
-                cfbase = os.path.expandvars("$HOME/.opticks/GEOM/$GEOM")
-                note = "via GEOM"
-            pass
-        else:
-            cfbase = None
-            note = "via NO envvars"
-        pass
-        if cfbase is None:
-            print("CSGFoundry.CFBase returning None, note:%s " % note )
-        else:
-            print("CSGFoundry.CFBase returning [%s], note:[%s] " % (cfbase,note) )
-        pass
-        return cfbase
-
-    @classmethod
-    def Load(cls, cfbase_=None, symbol=None):
-        """
-        :param cfbase_: typically None, but available when debugging eg comparing two geometries
-        """
-        if cfbase_ is None:
-            cfbase = cls.CFBase()
-        else:
-            cfbase = os.path.expandvars(cfbase_)
-        pass
-        log.info("cfbase:%s " % cfbase)
-        if cfbase is None or not os.path.exists(os.path.join(cfbase, "CSGFoundry")):
-            print("ERROR CSGFoundry.CFBase returned None OR non-existing CSGFoundry dir so cannot CSGFoundry.Load" )
-            return None
-        pass
-        assert not cfbase is None
-        cf = cls(fold=os.path.join(cfbase, "CSGFoundry"))
-        cf.symbol = symbol
-        return cf
-
-    @classmethod
-    def FindDirUpTree(cls, origpath, name="CSGFoundry"):
-        """
-        :param origpath: to traverse upwards looking for sibling dirs with *name*
-        :param name: sibling directory name to look for
-        :return full path to *name* directory
-        """
-        elem = origpath.split("/")
-        found = None
-        for i in range(len(elem),0,-1):
-            path = "/".join(elem[:i])
-            cand = os.path.join(path, name)
-            log.debug(cand)
-            if os.path.isdir(cand):
-                found = cand
-                break
-            pass
-        pass
-        return found
-
-    @classmethod
-    def FindDigest(cls, path):
-        if path.find("*") > -1:  # eg with a glob pattern filename element
-            base = os.path.dirname(path)
-        else:
-            base = path
-        pass
-        base = os.path.expandvars(base)
-        return cls.FindDigest_(base)
-
-    @classmethod
-    def FindDigest_(cls, path):
-        """
-        :param path: Directory path in which to look for a 32 character digest path element
-        :return 32 character digest or None:
-        """
-        hexchar = "0123456789abcdef"
-        digest = None
-        for elem in path.split("/"):
-            if len(elem) == 32 and set(elem).issubset(hexchar):
-                digest = elem
-            pass
-        pass
-        return digest
-
-    def __init__(self, fold):
-        self.load(fold)
-        self.meshnamedict = self.namelist_to_namedict(self.meshname)
-        self.primIdx_meshname_dict = self.make_primIdx_meshname_dict()
-
-        self.mokname = "zero one two three four five six seven eight nine".split()
-        self.moknamedict = self.namelist_to_namedict(self.mokname)
-        self.insnamedict = {}
-
-        self.lv = LV(os.path.join(fold, "meshname.txt"))
-        self.mm = MM(os.path.join(fold, "mmlabel.txt"))
-
-        sim = Fold.Load(fold, "SSim")
-
-        try:
-            bdn = sim.stree.standard.bnd_names
-        except AttributeError:
-            bdn = None
-        pass
-        if bdn is None: log.fatal("CSGFoundry fail to access sim.stree.standard.bnd_names : geometry incomplete" )
-        if type(bdn) is np.ndarray: sim.bndnamedict = self.namelist_to_namedict(bdn)
-        pass
-
-        self.kncfg = KeyNameConfig("$HOME/.opticks/GEOM/cxt_min.ini")
-
-        self.bdn_config = self.kncfg("key_boundary_regexp")
-        self.bdn_config_note = self.kncfg("key_boundary_regexp_note")
-
-        self.prn_config = self.kncfg("key_prim_regexp")
-        self.prn_config_note = self.kncfg("key_prim_regexp_note")
-
-        self.bdn = bdn
-        self.sim = sim
-
-        self.npa = self.node.reshape(-1,16)[:,0:6]
-        self.nbd = self.node.view(np.int32)[:,1,2]
-        self.nix = self.node.view(np.int32)[:,1,3]
-        self.nbb = self.node.reshape(-1,16)[:,8:14]
-        self.ntc = self.node.view(np.int32)[:,3,2]
-        self.ncm = self.node.view(np.uint32)[:,3,3] >> 31  # node complement
-        self.ntr = self.node.view(np.uint32)[:,3,3] & 0x7fffffff  # node tranIdx+1
-
-        self.pnn = self.prim.view(np.int32)[:,0,0] # prim num node
-        self.pno = self.prim.view(np.int32)[:,0,1] # prim node offset
-
-
-
-        self.pto = self.prim.view(np.int32)[:,0,2] # prim tran offset
-        self.ppo = self.prim.view(np.int32)[:,0,3] # prim plan offset
-
-        self.crn = self.pno[self.pnn>1]   # node indices of compound roots
-        self.crn_subnum = self.node.view(np.int32)[self.crn,0,0]
-        self.crn_suboff = self.node.view(np.int32)[self.crn,0,1]
-
-
-        self.psb = self.prim.view(np.int32)[:,1,0] # prim sbtIndexOffset
-        self.plv = self.prim.view(np.int32)[:,1,1] # prim lvid/meshIdx
-        self.prx = self.prim.view(np.int32)[:,1,2] # prim ridx/repeatIdx
-        self.pix = self.prim.view(np.int32)[:,1,3] # prim idx
-
-        self.pbb = self.prim.reshape(-1,16)[:,8:14]
-
-
-        self.snp = self.solid[:,1,0].view(np.int32) # solid numPrim
-        self.spo = self.solid[:,1,1].view(np.int32) # solid primOffset
-        self.sce = self.solid[:,2].view(np.float32)
-
-
-
-    def simtrace_boundary_analysis(self, bn, KEY=os.environ.get("KEY", None) ):
-        """
-        Group simtrace intersects according to their boundary indices
-        using groups specified by regexp matching boundary names.
-
-        Typically would have a few hundred boundary names
-        in cf.bdn but potentially millions of simtrace intersects
-        in the bn array.
-
-        :param bn: large array of boundary indices
-        :param KEY: color key OR None
-        :return cxtb,btab:
-        """
-        d_qbn, d_anno = self.Dict_find_name_indices_re_match(self.bdn, self.bdn_config, self.bdn_config_note )
-        btab = NameTable("btab", bn, self.bdn, d_qbn, KEY)
-        cxtb = GroupedNameTable("cxtb", bn, d_qbn, d_anno, self.bdn, lwid=100)
-        self.btab = btab
-        self.cxtb = cxtb
-        return cxtb, btab
-
-    def simtrace_prim_analysis(self, pr, KEY=os.environ.get("KEY", None) ):
-        """
-        Group simtrace intersects according to their primitive indices
-        using groups specified by regexp matching solid names of the prim.
-
-        :param pr: large array of primitive indices
-        :param KEY:
-        :return cxtp, ptab: GroupedNameTable, NameTable
-        """
-        d_qpr, d_anno = self.Dict_find_name_indices_re_match(self.primname, self.prn_config, self.prn_config_note )
-        ptab = NameTable("ptab", pr, self.primname, d_qpr, KEY)
-        cxtp = GroupedNameTable("cxtp", pr, d_qpr, d_anno, self.primname, lwid=50)
-        self.ptab = ptab
-        self.cxtp = cxtp
-        return cxtp, ptab
-
-    @classmethod
-    def Dict_find_name_indices_re_match(cls, names, _nameptn_dict, _namenote_dict ):
-        """
-        :param names: array of names
-        :param _nameptn_dict: label keys, regexp pattern string values
-        :return d: dict with same label keys and arrays of matching names indices
-
-        Names unmatched by the provided regexp values are
-        grouped within the key with a blank value if provided.
-        """
-        d = {}
-        anno = {}
-        matched = np.array([], dtype=np.int64 )
-        unmatched_k = None
-        for k, v in _nameptn_dict.items():
-            if v == '':
-                unmatched_k = k  # usaully grey
-                continue
-            pass
-            qnm, nn, label = cls.Find_name_indices_re_match(names, v)
-            matched = np.concatenate( (matched, qnm) )
-            k_note = _namenote_dict.get(k,"")
-            lab = "%100s ## %s" % ( label, k_note )
-            d[k] = qnm
-            anno[k] = lab
-        pass
-
-        c = dict(matched=matched, all=np.arange(len(names)))
-        c['unmatched'] = np.where(np.isin(c['all'], c['matched'], invert=True ))[0]
-        if not unmatched_k is None:
-            d[unmatched_k] = c['unmatched']
-            anno[unmatched_k] = "OTHER"
-        pass
-        return d, anno
-
-
-    @classmethod
-    def Find_name_indices_re_match(cls, names, _ptn):
-        """
-        :param _ptn: name regexp string
-        :return qnm,nn,label:
-
-        qnm
-           array of names array indices that match the pattern
-        nn
-           array of names matching the pattern
-        label
-           match key when the pattern string includes one eg (?<label>.*$)
-           otherwise the pattern string itself
-
-        Typically would have a few hundred to a few thousand names for a geometry
-        so the slowness of np.vectorize is not a problem.
-
-        Example _ptn::
-
-            .*
-            .*/Vacuum$
-            .*/LatticedShellSteel$
-            .*/Steel$
-            Water/.*/Water$
-            (?P<Water_Virtuals>:Water/.*/Water$)
-            .*/Tyvek$
-
-        """
-        ptn = re.compile(_ptn)
-        _re_match = lambda s:bool(ptn.match(s))
-        re_match = np.vectorize(_re_match)
-
-        def _re_key(s):
-            keys = list(ptn.match(s).groupdict().keys())
-            return keys[0] if len(keys) == 1 else _ptn
-        pass
-        re_key = np.vectorize(_re_key)
-
-        _qnm = re_match(names)      # names array bool name match array
-        qnm = np.where(_qnm)[0]     # indices of names array matching the regexp
-        nn = names[qnm]
-
-        if len(qnm) == 0:
-            log.info("_ptn:[%s] did not match any names" % _ptn )
-            label = "NO_MATCH"
-        else:
-            _kk = re_key(nn)
-            kk = np.unique(_kk)
-            assert len(kk) == 1
-            label = kk[0]
-        pass
-        return qnm, nn, label
-
-
-    def find_primIdx_from_nodeIdx(self, nodeIdx_):
-        """
-        If nodeIdx is valid there should always be exactly
-        one prim in which it appears.
-
-        For example use to lookup primname that contain a selection
-        of nodeIdx::
-
-            In [4]: np.c_[b.primname[np.unique(a.find_primIdx_from_nodeIdx(w))]]
-            Out[4]:
-            array([['NNVTMCPPMTsMask_virtual'],
-                   ['HamamatsuR12860sMask_virtual'],
-                   ['HamamatsuR12860_PMT_20inch_pmt_solid_1_4'],
-                   ['HamamatsuR12860_PMT_20inch_inner_solid_1_4'],
-                   ['base_steel'],
-                   ['uni_acrylic1']], dtype=object)
-
-
-        """
-        a = self
-
-        numNode = a.prim[:,0,0].view(np.int32)
-        nodeOffset = a.prim[:,0,1].view(np.int32)
-
-        primIdx = np.zeros(len(nodeIdx_), dtype=np.int32)
-        for i, nodeIdx in enumerate(nodeIdx_):
-            primIdx[i]  = np.where(np.logical_and( nodeIdx >= nodeOffset, nodeIdx < nodeOffset+numNode ))[0]
-        pass
-        return primIdx
-
-
-    def find_lvid_from_nodeIdx(self, nodeIdx_):
-        """
-        """
-        primIdx = self.find_primIdx_from_nodeIdx(nodeIdx_)
-        return self.prim[primIdx].view(np.int32)[:,1,1]
-
-    def find_lvname_from_nodeIdx(self, nodeIdx_):
-        lvid = self.find_lvid_from_nodeIdx(nodeIdx_)
-        return self.meshname[lvid]
-
-
-
-    def meshIdx(self, primIdx):
-        """
-        Lookup the midx of primIdx prim
-
-        :param primIdx:
-        :return midx:
-        """
-        assert primIdx < len(self.prim)
-        midx = self.prim[primIdx].view(np.uint32)[1,1]
-        return midx
-
-    def make_primIdx_meshname_dict(self):
-        """
-        See notes/issues/cxs_2d_plotting_labels_suggest_meshname_order_inconsistency.rst
-        this method resolved an early naming bug
-
-        CSG/CSGPrim.h::
-
-             95     PRIM_METHOD unsigned  meshIdx() const {           return q1.u.y ; }  // aka lvIdx
-             96     PRIM_METHOD void   setMeshIdx(unsigned midx){     q1.u.y = midx ; }
-
-        """
-        d = {}
-        for primIdx in range(len(self.prim)):
-            midx = self.meshIdx (primIdx)      # meshIdx method with contiguous primIdx argument
-            assert midx < len(self.meshname)
-            mnam = self.meshname[midx]
-            d[primIdx] = mnam
-            #print("CSGFoundry:primIdx_meshname_dict primIdx %5d midx %5d meshname %s " % (primIdx, midx, mnam))
-        pass
-        return d
-
-    def loadtxt(self, path):
-        """
-        When the path contains only a single line using dtype np.object or |S100
-        both result in an object with no length::
-
-            array('solidXJfixture', dtype=object)
-
-        """
-        # both these do not yield an array when only a single line in the file
-        #
-        #a_txt = np.loadtxt(path, dtype=np.object)   # yields single object
-        #a_txt = np.loadtxt(path, dtype="|S100")
-
-        txt = open(path).read().splitlines()
-        a_txt = np.array(txt, dtype=np.str_ )   # formerly np.object
-        return a_txt
-
-
-    def brief(self):
-        symbol = getattr(self, "symbol", "no-symbol")
-        return "CSGFoundry %s cfbase %s " % (symbol, self.cfbase)
-
-    def load(self, fold):
-        cfbase = os.path.dirname(fold)
-        self.cfbase = cfbase
-        self.base = cfbase
-        log.info("load : fold %s cfbase: %s  " % (fold, cfbase) )
-
-        if not os.path.isdir(fold):
-            log.fatal("CSGFoundry folder %s does not exist " % fold)
-            log.fatal("create foundry folder from OPTICKS_KEY geocache with CSG_GGeo/run.sh " )
-            assert 0
-        pass
-
-        names = os.listdir(fold)
-        stems = []
-        stamps = []
-        for name in filter(lambda name:name.endswith(".npy") or name.endswith(".txt"), names):
-            path = os.path.join(fold, name)
-            st = os.stat(path)
-            stamp = datetime.datetime.fromtimestamp(st.st_ctime)
-            stamps.append(stamp)
-            stem = name[:-4]
-            a = np.load(path) if name.endswith(".npy") else self.loadtxt(path)
-            setattr(self, stem, a)
-            stems.append(stem)
-        pass
-
-        min_stamp = min(stamps)
-        max_stamp = max(stamps)
-        now_stamp = datetime.datetime.now()
-        dif_stamp = max_stamp - min_stamp
-        age_stamp = now_stamp - max_stamp
-
-        #print("min_stamp:%s" % min_stamp)
-        #print("max_stamp:%s" % max_stamp)
-        #print("dif_stamp:%s" % dif_stamp)
-        #print("age_stamp:%s" % age_stamp)
-
-        assert dif_stamp.microseconds < 1e6, "stamp divergence detected microseconds %d : so are seeing mixed up results from multiple runs " % dif_stamp.microseconds
-
-        self.stems = stems
-        self.min_stamp = min_stamp
-        self.max_stamp = max_stamp
-        self.age_stamp = age_stamp
-        self.stamps = stamps
-        self.fold = fold
-        self.pr = CSGPrim.RecordsFromArrays(self.prim[:,:2].reshape(-1,8).view(np.int32))
-        self.nf = CSGNode.RecordsFromArrays(self.node.reshape(-1,16).view(np.float32))
-        self.ni = CSGNode.RecordsFromArrays(self.node.reshape(-1,16).view(np.int32))
-
-
-    def desc(self, stem):
-        a = getattr(self, stem)
-        ext = ".txt" if a.dtype == 'O' else ".npy"
-        pstem = "bnd" if stem == "bndname" else stem
-        path = os.path.join(self.fold, "%s%s" % (pstem, ext))
-        return self.FMT % (stem, str(a.shape), path)
-
-    def head(self):
-        return "\n".join(map(str, [self.fold, "min_stamp:%s" % self.min_stamp, "max_stamp:%s" % self.max_stamp, "age_stamp:%s" % self.age_stamp]))
-
-    def body(self):
-        return "\n".join(map(lambda stem:self.desc(stem),self.stems))
-
-    def __repr__(self):
-        return "\n".join([self.head(),self.body()])
-
-    def dump_node_boundary(self):
-        logging.info("dump_node_boundary")
-        node = self.node
-
-        node_boundary = node.view(np.uint32)[:,1,2]
-        ubs, ubs_count = np.unique(node_boundary, return_counts=True)
-
-        for ub, ub_count in zip(ubs, ubs_count):
-            bn = self.bdn[ub] if not self.bdn is None else "-"
-            print(" %4d : %6d : %s " % (ub, ub_count, bn))
-        pass
-
-    def descSolid(self, ridx, detail=True):
-        """
-        After CSGFoundry::dumpSolid
-        """
-        label = self.solid[ridx,0,:4].copy().view("|S16")[0].decode("utf8")
-        numPrim = self.solid[ridx,1,0]
-        primOffset = self.solid[ridx,1,1]
-        prs = self.prim[primOffset:primOffset+numPrim]
-        iprs = prs.view(np.int32)
-
-        lvid = iprs[:,1,1]
-        u_lvid, x_lvid, n_lvid = np.unique( lvid, return_index=True, return_counts = True )
-        lv_one = np.all( n_lvid == 1 )
-
-        lines = []
-        lines.append("CSGFoundry.descSolid ridx %2d label %16s numPrim %6d primOffset %6d lv_one %d " % (ridx,label, numPrim, primOffset, lv_one))
-
-        if detail:
-            if lv_one:
-                for pidx in range(primOffset, primOffset+numPrim):
-                    lines.append(self.descPrim(pidx))
-                pass
-            else:
-                x_order = np.argsort(x_lvid)  # order by prim index of first occurence of each lv
-                for i in x_order:
-                    ulv = u_lvid[i]
-                    nlv = n_lvid[i]
-                    xlv = x_lvid[i]
-                    pidx = primOffset + xlv   # index of the 1st prim with each lv
-                    lines.append(" i %3d ulv %3d xlv %4d nlv %3d : %s " % (i, ulv, xlv, nlv, self.descPrim(pidx) ))
-                pass
-            pass
-        pass
-        return "\n".join(lines)
-
-    def descLV(self, lvid, detail=False):
-        lv = self.prim.view(np.int32)[:,1,1]
-        pidxs = np.where(lv==lvid)[0]
-
-        lines = []
-        lines.append("descLV lvid:%d meshname:%s pidxs:%s" % (lvid, self.meshname[lvid],str(pidxs)))
-        for pidx in pidxs:
-            lines.append(self.descPrim(pidx, detail=detail))
-        pass
-        return STR("\n".join(lines))
-
-    def descLVDetail(self, lvid):
-        return self.descLV(lvid, detail=True)
-
-    def descPrim(self, pidx, detail=False):
-
-        pr = self.prim[pidx]
-        ipr = pr.view(np.int32)
-
-        numNode    = ipr[0,0]
-        nodeOffset = ipr[0,1]
-        repeatIdx  = ipr[1,2]
-        primIdxLocal = ipr[1,3]
-
-        lvid = ipr[1,1]
-        lvn = self.meshname[lvid]
-        tcn = self.descNodeTC(nodeOffset, numNode)
-
-        bnd_ = self.node[nodeOffset:nodeOffset+numNode,1,2].view(np.int32)
-        ubnd_ = np.unique(bnd_)
-        assert len(ubnd_) == 1, "all nodes of prim should have same boundary "
-        ubnd = ubnd_[0]
-        line = "pidx %4d lv %3d pxl %4d : %50s : %s : bnd %s : %s " % (pidx, lvid, primIdxLocal, lvn, tcn, ubnd, self.bdn[ubnd] )
-
-        lines = []
-        lines.append(line)
-        if detail:
-            lines.append(self.descNodeParam(nodeOffset,numNode))
-            lines.append(self.descNodeBB(nodeOffset,numNode))
-            lines.append(self.descNodeBoundaryIndex(nodeOffset,numNode))
-            lines.append(self.descNodeTCTran(nodeOffset,numNode, mask_signbit=False))
-            lines.append(self.descNodeTCTran(nodeOffset,numNode, mask_signbit=True))
-        pass
-        return STR("\n".join(lines))
-
-    def descPrimDetail(self, pidx):
-        return self.descPrim(pidx,detail=True)
-
-    def descNodeFloat(self, nodeOffset, numNode, sli="[:,:6]", label=""):
-        symbol = self.symbol
-        locals()[symbol] = self
-        expr = "%(symbol)s.node[%(nodeOffset)d:%(nodeOffset)d+%(numNode)d].reshape(-1,16)"
-        expr += sli
-        expr = expr % locals()
-        lines = []
-        lines.append("%s # %s " % (expr,label))
-        lines.append(str(eval(expr)))
-        return STR("\n".join(lines))
-
-    def descNodeParam(self, nodeOffset, numNode):
-        return self.descNodeFloat(nodeOffset,numNode,"[:,:6]", "descNodeParam" )
-    def descNodeBB(self, nodeOffset, numNode):
-        return self.descNodeFloat(nodeOffset,numNode,"[:,8:14]", "descNodeBB" )
-
-    def descNodeInt(self, nodeOffset, numNode, sli="[:,6:8]", label="", mask_signbit=False):
-        symbol = self.symbol
-        locals()[symbol] = self
-        expr = "%(symbol)s.node[%(nodeOffset)d:%(nodeOffset)d+%(numNode)d].reshape(-1,16).view(np.int32)"
-        expr += sli
-        if mask_signbit:
-            expr += " & 0x7ffffff "
-        pass
-        expr = expr % locals()
-        lines = []
-        lines.append("%s # %s " % (expr,label))
-        lines.append(str(eval(expr)))
-        return STR("\n".join(lines))
-
-    def descNodeBoundaryIndex(self, nodeOffset, numNode):
-        return self.descNodeInt(nodeOffset,numNode,"[:,6:8]", "descNodeBoundaryIndex" )
-    def descNodeTCTran(self, nodeOffset, numNode, mask_signbit=False):
-        return self.descNodeInt(nodeOffset,numNode,"[:,14:16]", "descNodeTCTran", mask_signbit=mask_signbit )
-
-
-
-
-    def descNodeTC(self, nodeOffset, numNode, sumcut=7):
-        """
-        :param nodeOffset: absolute index within self.node array
-        :param numNode: number of contiguous nodes
-        :param sumcut: number of nodes above which a summary output is returned
-        :return str: representing CSG typecodes
-
-        (nodeOffset,numNode) will normally correspond to the node range of a single prim pidx
-
-        Output examples::
-
-            tcn 1:union 1:union 108:cone 105:cylinder 105:cylinder 0:zero 0:zero
-            tcn 2:intersection 1:union 2:intersection 103:zsphere 105:cylinder 103:!zsphere 105:!cylinder
-            tcn 3(2:intersection) 2(1:union) 4(105:cylinder) 2(103:zsphere) 4(0:zero)
-
-        """
-        nds = self.node[nodeOffset:nodeOffset+numNode].view(np.uint32)
-        neg = ( nds[:,3,3] & 0x80000000 ) >> 31    # complemented
-        tcs  = nds[:,3,2]
-
-        if len(tcs) > sumcut:
-            u_tc, x_tc, n_tc = np.unique(tcs, return_index=True, return_counts=True)
-            x_order = np.argsort(x_tc)  # order by index of first occurence of each typecode
-            tce = []
-            for i in x_order:
-                utc = u_tc[i]
-                ntc = n_tc[i]
-                xtc = x_tc[i]
-                xng = neg[xtc]
-                tce.append( "%d(%d:%s%s)" % (ntc,utc,"!" if xng else "", CSG_.desc(utc) ))
-            pass
-            tcn = " ".join(tce)
-        else:
-            tcn = " ".join(list(map(lambda _:"%d:%s%s" % (tcs[_],"!" if neg[_] else "",CSG_.desc(tcs[_])),range(len(tcs)))))
-        pass
-
-        return "no %5d nn %4d tcn %s tcs %s" % (nodeOffset, numNode, tcn, str(tcs) )
-
-
-
-    def descSolids(self, detail=True):
-        num_solid = len(self.solid)
-        lines = []
-        q_ridx = int(os.environ.get("RIDX", "-1"))
-        for ridx in range(num_solid):
-            if q_ridx > -1 and ridx != q_ridx: continue
-            if detail:
-                lines.append("")
-            pass
-            lines.append(self.descSolid(ridx, detail=detail))
-        pass
-        return STR("\n".join(lines))
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    cf = CSGFoundry.Load()
-    print(cf)
-
-    #cf.dump_node_boundary()
-    #d = cf.primIdx_meshname_dict()
-    #print(d)
-
-    #cf.dumpSolid(1)
-
-
diff --git a/CSG/CSGFoundryTest.sh b/CSG/CSGFoundryTest.sh
deleted file mode 100755
index cd4f8d5cce..0000000000
--- a/CSG/CSGFoundryTest.sh
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/bin/bash -l 
-
-default=remote
-arg=${1:-$default}
-
-if [ "$arg" == "remote" ]; then 
-   export OPTICKS_KEY=$OPTICKS_KEY_REMOTE 
-   export OPTICKS_GEOCACHE_PREFIX=$HOME/.opticks 
-elif [ "$arg" == "old" ]; then 
-   export OPTICKS_KEY=$OPTICKS_KEY_OLD
-elif [ "$arg" == "new" ]; then 
-   export OPTICKS_KEY=$OPTICKS_KEY_NEW
-elif [ "$arg" == "asis" ]; then 
-   echo $msg using OPTICKS_KEY : $OPTICKS_KEY 
-fi 
-
-ipython -i CSGFoundry.py 
-
diff --git a/CSG/csg.sh b/CSG/csg.sh
deleted file mode 100755
index b4581e6285..0000000000
--- a/CSG/csg.sh
+++ /dev/null
@@ -1,96 +0,0 @@
-#!/bin/bash -l 
-
-default=remote
-arg=${1:-$default}
-
-opticks-switch-key $arg 
-
-
-
-msg="=== $BASH_SOURCE :"
-usage(){ cat << EOU
-csg.sh : using test/CSGIntersectSolidTest.cc tests/CSGIntersectSolidTest.py without GEOM envvar 
-=================================================================================================
-
-TODO: factor off common parts of csg_geochain.sh and this script csg.sh 
-
-
-
-Dumping geometry::
-
-   DUMP=1 DEBUG=1 ./csg.sh
-
-
-EOU
-}
-
-
-dx=0
-dy=0
-dz=0
-pho=${PHO:--100} 
-
-case $pho in
-  -*)  echo $msg using regular bicycle spoke photon directions ;; 
-   *)  echo $msg using random photon directions                ;;
-esac
-
-
-#sopr=0:0_YZ
-#sopr=0:0_XYZ
-#sopr=0:3_XY
-#sopr=0:3_XYZ
-#sopr=0:3_XZ
-sopr=0:3_YZ
-
-export VERBOSE=1
-export SOPR=${SOPR:-$sopr}
-
-
-case $SOPR in  
-   *_XZ) cegs=16:0:9:$dx:$dy:$dz:$pho  ;;  
-   *_YZ) cegs=0:16:9:$dx:$dy:$dz:$pho  ;;  
-   *_XY) cegs=16:9:0:$dx:$dy:$dz:$pho  ;;  
-   *_ZX) cegs=9:0:16:$dx:$dy:$dz:$pho  ;;  
-   *_ZY) cegs=0:9:16:$dx:$dy:$dz:$pho  ;;  
-   *_YX) cegs=9:16:0:$dx:$dy:$dz:$pho  ;;  
-   *_XYZ) cegs=9:16:9:$dx:$dy:$dz:$pho ;;  
-       *) echo $msg UNEXPECTED SUFFIX FOR SOPR $SOPR WHICH DOES NOT END WITH ONE OF : _XZ _YZ _XY _ZX _ZY _YX _XYZ  && exit 1   ;; 
-esac
-
-export CEGS=${CEGS:-$cegs}
-
-bin=CSGIntersectSolidTest
-script=tests/CSGIntersectSolidTest.py 
-arg=${1:-run_ana}
-
-
-if [ "${arg/run}" != "$arg" ]; then
-
-    if [ -n "$DEBUG" ]; then 
-        echo $msg running binary $bin under debugger
-        gdb $bin
-        [ $? -ne 0 ] && echo $msg error while running binary $bin under debugger  && exit 1
-    else
-        echo $msg running binary $bin
-        $bin
-        [ $? -ne 0 ] && echo $msg error while running binary $bin  && exit 1
-    fi 
-fi
-
-[ -n "$DUMP" ] && echo $msg early exit as DUMP defined && exit 0 
-
-if [ "${arg/ana}" != "$arg" ]; then
-
-    cfbase_sh=/tmp/CFBASE.sh
-    source $cfbase_sh
-
-    [ -z "$CFBASE" ] && echo $msg ERROR no CFBASE && exit 1 
-    [ -n "$CFBASE" ] && echo $msg using CFBASE $CFBASE from cfbase_sh $cfbase_sh 
-
-    echo $msg running script $script
-    ${IPYTHON:-ipython} --pdb -i $script
-    [ $? -ne 0 ] && echo $msg script error && exit 2
-fi
-
-echo 0 
diff --git a/CSG/csg_geochain.sh b/CSG/csg_geochain.sh
deleted file mode 100755
index 08f25e7211..0000000000
--- a/CSG/csg_geochain.sh
+++ /dev/null
@@ -1,368 +0,0 @@
-#!/bin/bash -l 
-msg="=== $BASH_SOURCE :"
-usage(){ cat << EOU
-csg_geochain.sh : CPU Opticks equivalent to cxs_geochain.sh with OptiX on GPU using test/CSGIntersectSolidTest.cc tests/CSGIntersectSolidTest.py
-==================================================================================================================================================
-
-The idea behind this is to provide a convenient way to test code primarily intended to run on GPU 
-in the more friendly debugging environment of the CPU.::
-
-
-    PUB=unbalanced_ok ./csg_geochain.sh  ana 
-
-
-    IXYZ=4,0,0 ./csg_geochain.sh  ana
-        selecting single genstep with IXYZ 
-
-    IXYZ=5,0,0 ./csg_geochain.sh  ana
-
-    IXYZ=0,6,0 ./csg_geochain.sh  ana      
-
-
-    SPUR=1 GEOM=CylinderFourBoxUnion_YX ./csg_geochain.sh ana
-         56/20997 spurious intersects all exiting the cylinder 
-         within the +Y and -X boxes
-
-         Curious that are no such issues with the other two boxes
-         despite the symmetry. 
-
-         TODO: test with CSG balancing disabled
-
-    SPUR=1 GEOM=AnnulusFourBoxUnion_YX ./csg_geochain.sh ana
-          181/20997 spurious all exiting the cylinder with all 4 boxes
-
-    SPUR=1 IXYZ=-6,0,0 GEOM=AnnulusFourBoxUnion_YX ./csg_geochain.sh ana
-          select single genstep   
-
-    SPUR=1 IXYZ=-6,0,0 IW=17 GEOM=AnnulusFourBoxUnion_YX SAVE_SELECTED_ISECT=1 ./csg_geochain.sh ana
-
-    SELECTED_ISECT=/tmp/selected_isect.npy GEOM=AnnulusFourBoxUnion_YX ./csg_geochain.sh run
-          run again just with selected isects, with CSGRecord enabled 
-          will need to use same geometry to get same results     
-
-    SPUR=1 IXYZ=-6,0,0 IW=17 GEOM=AnnulusFourBoxUnion_YX  ./csg_geochain.sh ana
-
-
-    TMIN=50 ./csg_geochain.sh 
-        NB can only change TMIN at C++ level not ana level 
-
-        Note that TMIN is currently absolute, it is not extent relative like with cxr_geochain.sh  
-        rendereing   
-
-
-    IXYZ=8,0,0 TMIN=50 ./csg_geochain.sh ana
-        at python analysis level the highlighted genstep can be changed using IXYZ 
-        TMIN does nothing at analysis level the intersects from the prior run are loaded and plotted
-           
-    SXYZW=4,4,0,80 ./csg_geochain.sh run
-        re-run with a single photon 
-        do this after recompiling with DEBUG flag allows to see the details of the single photon 
-
-EOU
-}
-
-geom=AltXJfixtureConstruction_YZ
-#geom=AltXJfixtureConstruction_XZ
-#geom=AltXJfixtureConstruction_XY
-#geom=AltXJfixtureConstructionU_XY
-
-
-#geom=UnionBoxSphere_XY
-#geom=UnionListBoxSphere_XY
-#geom=UnionLLBoxSphere_XY
-
-#geom=AnnulusBoxUnion_XY
-#geom=AnnulusTwoBoxUnion_XY
-#geom=AnnulusOtherTwoBoxUnion_XY
-
-#geom=AnnulusFourBoxUnion_XY
-#geom=AnnulusFourBoxUnion_YX
-#geom=CylinderFourBoxUnion_YX
-#geom=AnnulusCrossTwoBoxUnion_YX
-
-#geom=BoxFourBoxUnion_YX
-#geom=BoxFourBoxContiguous_YX
-#geom=SphereWithPhiCutDEV_YX
-
-#geom=BoxCrossTwoBoxUnion_YX
-#geom=BoxThreeBoxUnion_YX
-
-#geom=XJfixtureConstruction_YZ
-#geom=XJfixtureConstruction_XZ
-#geom=XJfixtureConstruction_XY
-
-#geom=iphi_YX
-
-#geom=ithe_XZ
-#geom=ithl_XZ
-
-#geom=ithe_YZ
-#geom=ithl_YZ
-
-#geom=ithe_XYZ
-#geom=ithl_XYZ
-
-#geom=GeneralSphereDEV_XZ
-#geom=GeneralSphereDEV_XYZ
-#geom=GeneralSphereDEV_XZ
-#geom=GeneralSphereDEV_YZ
-#geom=GeneralSphereDEV_XY
-
-#geom=OverlapBoxSphere_XY
-#geom=ContiguousBoxSphere_XY
-#geom=DiscontiguousBoxSphere_XY
-#geom=IntersectionBoxSphere_XY
-
-#geom=OverlapThreeSphere_XY
-#geom=ContiguousThreeSphere_XY
-
-
-catgeom=$(cat ~/.opticks/GEOM.txt 2>/dev/null | grep -v \#) && [ -n "$catgeom" ] && echo $msg catgeom $catgeom override of default geom $geom && geom=$(echo ${catgeom}) 
-export GEOM=${GEOM:-$geom}
-gcn=${GEOM%%_*}   ## name up to the first underscore, assuming use of axis suffix  _XZ _YZ _XY _ZX _ZY _YX 
-
-cfbase=$(SOpticksResourceTest --cfbase)
-
-#  moved this into SOpticksResource::CFBase by adding GEOM envvar sensitivity there 
-#
-#if [ "$(uname)" == "Linux" ] ; then
-#   cfbase=$TMP/GeoChain/$gcn 
-#else
-#   cfbase=$TMP/GeoChain/$gcn 
-#fi 
-
-
-case $gcn in 
-   AnnulusFourBoxUnion)     gridscale=0.1  ;; 
-   AnnulusCrossTwoBoxUnion) gridscale=0.1  ;; 
-  CylinderFourBoxUnion)     gridscale=0.1  ;; 
-   BoxCrossTwoBoxUnion)     gridscale=0.07 ;; 
-   BoxThreeBoxUnion)        gridscale=0.07 ;; 
-   BoxFourBoxUnion)         gridscale=0.07 ;; 
-                     *)     gridscale=0.15 ;;
-esac
-
-case $GEOM in 
-       AnnulusFourBoxUnion_YX) note="see spurious with IXYZ=5,0,0 and 0,6,0 " ;;
-   AnnulusCrossTwoBoxUnion_YX) note="no spurious despite same apparent geom on ray path" ;;
-      CylinderFourBoxUnion_YX) note="see spurious" ;;
-           BoxThreeBoxUnion_YX) note="no spurious" ;; 
-           BoxFourBoxUnion_YX) note="see spurious in the +Y and -X small boxes " ;; 
-          GeneralSphereDEV_XY) note="phicut bug from \"t_cand <  t_min\" that should be \"t_cand <= t_min \" : SPHI selects spurious in bad phi range "  ;;
-                            *) note="" ;;
-esac
-
-case $GEOM in 
-   *_XYZ)   is3d=1 ;; 
-       *)   is3d=0 ;;
-esac
-
-if [ $is3d -eq 1 ]; then 
-   echo $msg is3d for GEOM $GEOM setting NO_GS and EDL 
-   export NO_GS=1
-   export ESL=1
-fi 
-
-
-dx=0
-dy=0
-dz=0
-
-case $GEOM in
-      XJfixtureConstruction*)  dz=1 ;;
-   AltXJfixtureConstruction*)  dz=1 ;;
-esac
-
-DZ=${DZ:-$dz}
-pho=${PHO:--100} 
-
-case $pho in
-  -*)  echo $msg using regular bicycle spoke photon directions ;; 
-   *)  echo $msg using random photon directions                ;;
-esac
-
-case $GEOM in  
-   *_XZ) cegs=16:0:9:$dx:$dy:$DZ:$pho  ;;  
-   *_YZ) cegs=0:16:9:$dx:$dy:$DZ:$pho  ;;  
-   *_XY) cegs=16:9:0:$dx:$dy:$DZ:$pho  ;;  
-   *_ZX) cegs=9:0:16:$dx:$dy:$DZ:$pho  ;;  
-   *_ZY) cegs=0:9:16:$dx:$dy:$DZ:$pho  ;;  
-   *_YX) cegs=9:16:0:$dx:$dy:$DZ:$pho  ;;  
-   *_XYZ) cegs=9:16:9:$dx:$dy:$DZ:$pho ;;  
-       *) echo $msg UNEXPECTED SUFFIX FOR GEOM $GEOM WHICH DOES NOT END WITH ONE OF : _XZ _YZ _XY _ZX _ZY _YX _XYZ  && exit 1   ;; 
-esac
-
-echo $msg GEOM $GEOM gcn $gcn gridscale $gridscale ixiyiz $ixiyiz
-
-
-topline="GEOM=$GEOM ./csg_geochain.sh "
-[ -n "$SPHI" ] && topline="SPHI=$SPHI $topline" 
-[ -n "$IXYZ" ] && topline="IXYZ=$IXYZ $topline" 
-[ -n "$SXYZW" ] && topline="SXYZW=$SXYZW $topline" 
-[ "$DZ" != "0" ] && topline="DZ=$DZ $topline"
-[ -n "$ZOOM" ] && topline="ZOOM=$ZOOM $topline" 
-
-
-cmdline="GEOM=$GEOM ./csg_geochain.sh "
-[ -n "$SPHI" ] && cmdline="SPHI=$SPHI $cmdline" 
-[ -n "$IXYZ" ] && cmdline="IXYZ=$IXYZ $cmdline" 
-[ -n "$SPUR" ] && cmdline="SPUR=$SPUR $cmdline" 
-[ "$DZ" != "0" ] && cmdline="DZ=$DZ $cmdline"
-[ -n "$ZOOM" ] && cmdline="ZOOM=$ZOOM $cmdline" 
-
-export CMDLINE=$cmdline
-export NOTE=$note 
-export GRIDSCALE=${GRIDSCALE:-$gridscale}
-export CEGS=${CEGS:-$cegs}
-export CFBASE=${CFBASE:-$cfbase}  ## moved GEOM sensitivity into SOpticksResource::CFBase : BUT still need this for the script
-export CEGS=${CEGS:-$cegs}
-export TOPLINE="$topline"
-export BOTLINE="$note"
-export THIRDLINE="CEGS=$CEGS"
-
-check_cegs()
-{
-    local msg="=== $FUNCNAME :"
-    IFS=: read -a cegs_arr <<< "$CEGS"
-    local cegs_elem=${#cegs_arr[@]}
-
-    case $cegs_elem in
-       4) echo $msg 4 element CEGS $CEGS ;;
-       7) echo $msg 7 element CEGS $CEGS ;;
-       *) echo $msg ERROR UNEXPECTED $cegs_elem element CEGS $CEGS && return 1  ;;
-    esac
-    return 0 
-}
-
-
-check_cfbase_how_to_create(){ cat << EOH
-
-How to Create CSGFoundry Geometry
-======================================
-
-A. From converted G4VSolid 
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Apply GeoChain conversion to a named geometry::
-
-    b7  # when using OptiX 7
-    cd ~/opticks/GeoChain     # or use "gc" shortcut function 
-    GEOM=${GEOM%%_*} ./translate.sh 
-
-
-B. Directly from CSGSolid/CSGPrim/CSGNode
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Create and persists into CSGFoundry folders one OR all CSGMaker solids::
-
-    cd ~/opticks/CSG
-
-    CSGMakerTest     
-    GEOM=${GEOM%%_*} CSGMakerTest
-
-Alternatively use the script::
-
-    cd ~/opticks/CSG
-    ./CSGMakerTest.sh  # gets GEOM value from ~/.opticks/GEOM.txt if that file exists
-
-
-EOH
-}
-
-
-check_cfbase()
-{
-    local msg="=== $FUNCNAME :"
-    if [ -n "$cfbase" -a ! -d "$cfbase/CSGFoundry" ]; then
-
-       echo $msg : ERROR cfbase $cfbase is defined signalling to use a non-standard CSGFoundry geometry 
-       echo $msg : BUT no such CSGFoundry directory exists 
-       echo $msg :
-       echo $msg : Possibilities: 
-       echo $msg :
-       echo $msg : 1. you intended to use the standard geometry but the GEOM $GEOM envvar does not match any of the if branches 
-       echo $msg : 2. you want to use a non-standard geometry but have not yet created it
-       echo $msg :
-       check_cfbase_how_to_create 
-       return 1
-    fi
-    return 0 
-}
-
-check_cfbase_file()
-{
-    local msg="=== $FUNCNAME :"
-    if [ -n "$cfbase" -a -d "$cfbase/CSGFoundry" -a ! -f "$cfbase/CSGFoundry/meshname.txt" ]; then
-       echo $msg : ERROR cfbase $cfbase is defined and the $cfbase/CSGFoundry directory exists
-       echo $msg : BUT it misses expected files such as $cfbase/CSGFoundry/meshname.txt 
-       echo $msg :
-       check_cfbase_how_to_create 
-       return 1 
-    fi 
-    return 0 
-}
-
-dumpvars(){ for var in $* ; do printf "%20s : %s \n" $var "${!var}" ; done ; }
-
-check_cegs        || exit 1 
-check_cfbase      || exit 1 
-check_cfbase_file || exit 1 
-dumpvars GEOM CEGS GRIDSCALE TOPLINE BOTLINE CFBASE NOTE IXYZ 
-
-bin=CSGIntersectSolidTest
-script=tests/CSGIntersectSolidTest.py 
-
-arg=${1:-run_ana}
-
-if [ "${arg/dump}" != "$arg" ]; then 
-   echo $msg CSGGeometryTest dump
-   CSGGeometryTest
-   exit 0 
-
-elif [ "${arg/run}" != "$arg" ]; then
-
-    if [ -n "$DEBUG" ]; then 
-        echo $msg running binary $bin under debugger
-        gdb $bin
-        [ $? -ne 0 ] && echo $msg error while running binary $bin under debugger  && exit 1
-    else
-        echo $msg running binary $bin
-        $bin
-        [ $? -ne 0 ] && echo $msg error while running binary $bin  && exit 1
-    fi 
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-    echo $msg running script $script
-    ${IPYTHON:-ipython} --pdb -i $script
-    [ $? -ne 0 ] && echo $msg script error && exit 2
-
-    figdir=$cfbase/$bin/$GEOM/figs
-    ls -l $figdir 
-
-    if [ -n "$PUB" ]; then 
-
-       reldir=/env/presentation/CSG/$bin/$GEOM/figs 
-       pubdir=$HOME/simoncblyth.bitbucket.io$reldir
-
-       figname=out.png 
-       pubname=${GEOM}_${PUB}.png       
-
-       echo $msg figdir $figdir
-       echo $msg reldir $reldir
-       echo $msg pubdir $pubdir
-       echo $msg pubname $pubname
-
-       if [ ! -d "$pubdir" ]; then 
-          mkdir -p $pubdir
-       fi  
-
-       cmd="cp $figdir/$figname $pubdir/$pubname"
-       echo $msg cmd $cmd
-       eval $cmd
-       echo $msg add below with a title to s5_background_image.txt for presenation 
-       echo $msg $reldir/$pubname 1280px_720px
-    fi 
-fi
-
-exit 0
diff --git a/CSG/foundry.py b/CSG/foundry.py
deleted file mode 100755
index 6320b23070..0000000000
--- a/CSG/foundry.py
+++ /dev/null
@@ -1,259 +0,0 @@
-#!/usr/bin/env python
-
-import os, sys, logging, codecs, numpy as np
-from opticks.sysrap.OpticksCSG import CSG_ as CSG 
-from complete_binary_tree import layout_tree
-
-
-log = logging.getLogger(__name__)
-
-class BB(object):
-    """
-
-                +--------+       
-                |        | 
-      z1  +--------+     | 
-          |     |  |     |
-          |     +--|-----+   y1  
-          |        |
-      z0  +--------+     y0
-         x0        x1
-    """
-    def __init__(self, bb=[-0.,-0.,-0.,0.,0.,0.]):
-        self.x0 = bb[0]
-        self.y0 = bb[1]
-        self.z0 = bb[2]
-        self.x1 = bb[3]
-        self.y1 = bb[4]
-        self.z1 = bb[5]
-        self.data = bb 
-
-    def __repr__(self):
-        fmt = "%10.3f "
-        fmt = fmt * 6 
-        return fmt % tuple(self.data)
-
-    def include(self, other):
-        if other.x0 < self.x0: self.x0 = other.x0
-        if other.y0 < self.y0: self.y0 = other.y0
-        if other.z0 < self.z0: self.z0 = other.z0
-
-        if other.x1 > self.x1: self.x1 = other.x1
-        if other.y1 > self.y1: self.y1 = other.y1
-        if other.z1 > self.z1: self.z1 = other.z1
-
-
-
-class Tran(object):
-    def __init__(self, idx, tr, it):
-        self.idx = idx
-        self.tr = tr 
-        self.it = it 
-    def __repr__(self):
-        return "\n".join([str(self.idx), repr(self.tr)])
-
-class Node(object):
-    """
-
-                                    1
-                      10                          11
-                100       101               110         111
-             1000 1001 1100 1101        1100 1101     1110 1111
-
-
-    """
-    def __init__(self, item, fd):
-        self.fd = fd 
-        self.tc = item[3,2].view(np.int32)
-        self.tyd = CSG.desc(self.tc)
-        self.ty = self.tyd[:2]
-        self.idx = item[1,3].view(np.int32)
-        self.depth = len("{0:b}".format(self.idx+1)) - 1   # complete binary trees are very special  
-        self.tref = item[3,3].view(np.int32) & 0x7fffffff 
-        self.tidx = self.tref - 1
-        self.cm = bool(item[3,3].view(np.uint32) & 0x80000000 >> 31) 
-        self.bb = BB(item[2:4].ravel()[:6])
-        self.pa = item[0:2].ravel()[:6]
-        self.tr = self.fd.tran[self.tidx] if self.tref > 0 else None
-        self.it = self.fd.itra[self.tidx] if self.tref > 0 else None
-        self.tran = Tran(self.tidx, self.tr, self.it) if self.tidx > -1 else None
-        self.scm = "!" if self.cm else ":"
-        self.label = "%s%s%s" % (1+self.idx,self.scm, self.ty) 
-
-    def __repr__(self):
-        return "Node %2d%s%2s tidx:%5d cm:%1d bb %30s pa %30s " % (1+self.idx,self.scm,self.ty, self.tidx, self.cm, str(self.bb), str(self.pa))   
-    def __str__(self):
-        return self.label
-
-
-class Prim(object):
-    def __init__(self, item, fd):
-        self.fd = fd 
-        self.numNode = item[0,0].view(np.int32)
-        self.nodeOffset = item[0,1].view(np.int32)
-        self.bb = BB(item[2:4].ravel()[:6])
-
-        self.midx = item[1,1].view(np.uint32)
-        self.ridx = item[1,2].view(np.uint32)
-        self.pidx = item[1,3].view(np.uint32)
-        self.mname = self.fd.getName(self.midx)
-
-        levelorder = list(map(lambda item:Node(item, fd), self.fd.node[self.nodeOffset:self.nodeOffset+self.numNode]))
-        self.node = levelorder
-
-    def __repr__(self):
-        return "Prim %3d %5d %30s : %s" % (self.numNode, self.nodeOffset, str(self.bb), self.mname)   
-
-    def __str__(self):
-        return "\n".join([repr(self)]+list(map(repr, self.node))+list(map(lambda n:repr(n.tran), self.node)))
-
-    def __getitem__(self, nodeIdx):
-        return self.node[nodeIdx]
-
-class Solid(object):
-    @classmethod
-    def DecodeLabel(cls, item):
-        return item.tobytes()[:16].split(b'\0')[0].decode("utf-8")     # TODO: test full 8 char label  
-
-    def __init__(self, item, fd):
-        self.item = item  
-        self.fd = fd 
-        self.label = self.DecodeLabel(item)
-        self.numPrim = item[1,0].view(np.int32)
-        self.primOffset = item[1,1].view(np.int32)
-        self.prim = list(map(lambda item:Prim(item, fd), self.fd.prim[self.primOffset:self.primOffset+self.numPrim]))
-        self.ce = item[2].view(np.float32)
-
-    def __repr__(self):
-        return "Solid %10s : %4d %5d  ce %35s  "  % (self.label, self.numPrim, self.primOffset, str(self.ce))
-
-    def __str__(self):
-        return "\n".join([repr(self)]+list(map(repr, self.prim)))
-
-    def __getitem__(self, primIdx):
-        return self.prim[primIdx]
-
-
-class Foundry(object):
-    BASE = "$TMP/CSG_GGeo/CSGFoundry"
-    NAMES = "solid prim node tran itra inst".split()
-    def __init__(self, base=None):
-        if base is None: base = self.BASE  
-        base = os.path.expandvars(base) 
-        for n in self.NAMES+["plan"]:
-            path = os.path.join(base, "%s.npy" % n)
-            if not os.path.exists(path): continue
-            setattr( self, n, np.load(path))
-        pass   
-        self.name = np.loadtxt(os.path.join(base, "name.txt"), dtype=np.object)
-        self.label = list(map(Solid.DecodeLabel, self.solid))
-        self.solids = list(map(lambda item:Solid(item,self), self.solid))
-
-    def __repr__(self):
-        return "\n".join(["Foundry"] + list(map(lambda n:"%10s : %s " % (n,repr(getattr(self, n).shape)), self.NAMES))) 
-
-    def __str__(self):
-        return "\n".join(["Foundry"]+ list(map(repr, self.solids)))
-
-    def getName(self, midx):
-        return self.name[midx]
-
-    def index(self, solid_label):
-        return self.label.index(solid_label) 
-
-    def gt(self):
-        return self.node.view(np.int32)[:,3,3] & 0x7fffffff  
-    def cm(self):
-        return (self.node.view(np.int32)[:,3,3] & 0x80000000) >> 31     # complemented node
-
-
-    def midx(self):
-        return self.prim.view(np.uint32)[:,1,1]  
-    def ridx(self):
-        return self.prim.view(np.uint32)[:,1,2]  
-    def pidx(self):
-        return self.prim.view(np.uint32)[:,1,3]  
-
-
-
-
-    def __getitem__(self, arg):
-        """
-        Access solids nodes prims via string specification::
-
-             fd["d1"]        # solid with label "d1"
-             fd["d1/0"]      # 1st prim
-             fd["d1/0/0"]    # 1st node of 1st prim
-
-        """
-        ret = None
-        elem = arg.split("/")
-
-        solid_label = elem[0] if len(elem) > 0 else None
-        primIdx = int(elem[1]) if len(elem) > 1 else None
-        nodeIdx = int(elem[2]) if len(elem) > 2 else None
-
-        solidIdx = self.index(solid_label) if not solid_label is None else None
-
-        so = None
-        pr = None
-        nd = None
-
-        if not solidIdx is None:
-            so = self.solids[solidIdx]
-        pass  
-        if not so is None and not primIdx is None:
-            pr = so[primIdx]
-        pass
-        if not pr is None and not nodeIdx is None:
-            nd = pr[nodeIdx]
-        pass
-
-        if not nd is None:
-            return nd
-        elif not pr is None:
-            return pr
-        elif not so is None:
-            return so
-        else:
-            return None
-        pass
-        return None
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    fd = Foundry("$TMP/CSG_GGeo/CSGFoundry")
-    print(repr(fd))
-    #print(str(fd))
-    args = sys.argv[1:] if len(sys.argv) > 1 else "r8/0".split()
-
-    p = None
-    n = None
-    s = None
-
-    for arg in args: 
-        obj = fd[arg] 
-        print(arg)
-        print(obj)
-
-        if type(obj) is Prim:
-            p = obj
-        elif type(obj) is Node:
-            n = obj
-        elif type(obj) is Solid:
-            s = obj
-        else:
-            pass
-        pass
-    pass
-
-    if not p is None: 
-        #print("\n".join(map(repr,p.node))) 
-        t = layout_tree(p.node)
-        print("layout_tree")
-        print(t)
-    pass
-       
-
diff --git a/CSG/foundry.sh b/CSG/foundry.sh
deleted file mode 100755
index 131281c503..0000000000
--- a/CSG/foundry.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash -l 
-
-${IPYTHON:-ipython} -i foundry.py $* 
-#${IPYTHON:-ipython} -i foundry_plt.py $* 
-
diff --git a/CSG/tests/CSGFoundryAB.py b/CSG/tests/CSGFoundryAB.py
deleted file mode 100644
index 4c8c5885d5..0000000000
--- a/CSG/tests/CSGFoundryAB.py
+++ /dev/null
@@ -1,626 +0,0 @@
-#!/usr/bin/env python 
-"""
-CSGFoundryAB.py
-=================
-
-"""
-
-import numpy as np, os, textwrap, builtins
-from opticks.ana.fold import Fold, STR
-from opticks.CSG.CSGFoundry import CSGFoundry, CSGPrim, CSGNode
-from opticks.sysrap.stree import sn, snode, stree
-
-
-class CSGFoundryAB(object):
-    def __init__(self, a, b, _ip=0):
-        self.a = a 
-        self.b = b 
-        self.ip = _ip
-
-        self.check_4x4("node")
-        self.check_4x4("prim")
-
-        qwns = "npa nbb pbb".split()
-        for qwn in qwns:
-            self.compare_qwn(qwn)
-        pass
-
-    def _set_ip(self, ip):
-        self._ip = ip 
-
-        a = self.a 
-        b = self.b 
-
-        ann = a.pr.numNode[ip]
-        bnn = b.pr.numNode[ip]
-        ano = a.pr.nodeOffset[ip]
-        bno = b.pr.nodeOffset[ip]
-        alv = a.pr.meshIdx[ip]
-        blv = b.pr.meshIdx[ip]
-        amn = a.meshname[alv]
-        bmn = b.meshname[blv]
-        anode = a.node[ano:ano+ann]  
-        bnode = b.node[bno:bno+bnn]  
-
-        atc = a.ni.typecode[ano:ano+ann]
-        btc = b.ni.typecode[bno:bno+bnn]
-
-        aco = a.ni.comptran[ano:ano+ann] >> 31
-        bco = b.ni.comptran[bno:bno+bnn] >> 31
-
-        self.alv = alv
-        self.blv = blv
-        self.amn = amn
-        self.bmn = bmn
-        self.anode = anode
-        self.bnode = bnode
-        self.atc = atc
-        self.btc = btc
-        self.aco = aco
-        self.bco = bco
-
-    def __repr__(self):
-        return "AB %d alv %s:%s blv %s:%s " % ( self._ip, self.alv, self.amn, self.blv, self.bmn )
-
-    def brief(self):
-        a = self.a
-        b = self.b
-        lines = []
-        lines.append("CSGFoundryAB.brief")
-        lines.append(a.brief())
-        lines.append(b.brief())
-        return "\n".join(lines)
-
-    def _get_ip(self):
-        return self._ip
-
-    ip = property(_get_ip, _set_ip) 
-
-
-    def check_pr(self):
-        a = self.a 
-        b = self.b
-        assert a.pr.dtype.names == b.pr.dtype.names
-
-        lines = []
-        lines.append("CSGFoundryAB.check_pr")
-        expr_ = "len(np.where(a.pr.%(name)s != b.pr.%(name)s )[0])"
-        for name in a.pr.dtype.names:
-            expr = expr_ % locals()  
-            lines.append("%80s : %s " % (expr, eval(expr)))
-        pass
-        return "\n".join(lines) 
-
-    def check_prim_lv(self):
-        a = self.a 
-        b = self.b 
-        a_lv = a.prim.view(np.int32)[:,1,1]  
-        b_lv = b.prim.view(np.int32)[:,1,1]  
-        assert np.all(a_lv==b_lv)    ## same G4VSolid => CSGPrim 
-       
-        assert np.all(np.unique(a_lv)==np.unique(b_lv)) 
-        assert np.all(np.unique(a_lv,return_counts=True)[1]==np.unique(b_lv,return_counts=True)[1]) 
-
-        a_lvu = np.unique(a_lv) 
-        b_lvu = np.unique(b_lv) 
-        assert np.all(np.arange(len(a_lvu))==a_lvu) 
-        assert np.all(np.arange(len(b_lvu))==b_lvu) 
-        assert np.all(a.meshname==b.meshname) 
-
-    def check_node_tr(self):
-        """
-        """
-        a = self.a 
-        b = self.b 
-
-        atr = a.node[:,3,3].view(np.int32) & 0x7fffffff
-        btr = b.node[:,3,3].view(np.int32) & 0x7fffffff
-
-        np.c_[np.unique(atr,return_counts=True)] 
-        np.c_[np.unique(btr,return_counts=True)] 
-
-    def check_node_index(self):
-        """
-        For A the node index increments until 15927, 
-        thats probably the repeated unbalanced nodes 
-        """
-        a = self.a 
-        b = self.b 
-
-        aidx = a.node[:,1,3].view(np.int32)
-        aidx_ = aidx[:15927]  
-        assert np.all( aidx_ == np.arange(len(aidx_)) ) 
-
-        bidx = b.node[:,1,3].view(np.int32)
-        assert np.all( bidx == np.arange(len(bidx)) ) 
-
-
-    def descLVDetail(self, lvid):
-        a = self.a 
-        b = self.b 
-        lines = []
-        lines.append("CSGFoundryAB.descLVDetail")
-        lines.append(a.descLVDetail(lvid))
-        lines.append(b.descLVDetail(lvid))
-        return "\n".join(lines) 
- 
-    def check_prim(self):
-        """
-        np.all(a.prim.view(np.int32)[:,:2].reshape(-1,8)==b.prim.view(np.int32)[:,:2].reshape(-1,8)) 
-        """
-        a = self.a 
-        b = self.b 
-        ab = self
-        setattr(self,"prim_numNode",np.where(a.prim[:,0,0].view(np.int32)!=b.prim[:,0,0].view(np.int32))[0])
-
-        lines = []
-        lines.append("CSGFoundryAB.check_prim")
-        EXPR = filter(None,textwrap.dedent(r"""
-
-        #(numNode,nodeOffset,tranOffset,planOffset)(sbtIndexOffset,meshIdx,repeatIdx,primIdx)
-        a.prim.view(np.int32)[:,:2].reshape(-1,8)
-        b.prim.view(np.int32)[:,:2].reshape(-1,8)
-
-        #(numNode,nodeOffset,tranOffset,planOffset)
-        a.prim[:,0].view(np.int32) 
-        #(numNode,nodeOffset,tranOffset,planOffset)
-        b.prim[:,0].view(np.int32) 
-        len(np.where(a.prim[:,0]!=b.prim[:,0])[0])
-        #numNode
-        len(np.where(a.prim[:,0,0].view(np.int32)!=b.prim[:,0,0].view(np.int32))[0]) 
-        len(ab.prim_numNode)
-        np.c_[np.unique(a.primname[ab.prim_numNode],return_counts=True)]
-        #nodeOffset
-        len(np.where(a.prim[:,0,1].view(np.int32)!=b.prim[:,0,1].view(np.int32))[0]) 
-        #tranOffset
-        len(np.where(a.prim[:,0,2].view(np.int32)!=b.prim[:,0,2].view(np.int32))[0]) 
-        #planOffset
-        len(np.where(a.prim[:,0,3].view(np.int32)!=b.prim[:,0,3].view(np.int32))[0]) 
-        #(sbtIndexOffset,meshIdx,repeatIdx,primIdx)
-        a.prim[:,1].view(np.int32) 
-        #(sbtIndexOffset,meshIdx,repeatIdx,primIdx)
-        b.prim[:,1].view(np.int32) 
-        len(np.where(a.prim[:,1]!=b.prim[:,1])[0])
-
-        # A : (sbtIndexOffset,meshIdx,repeatIdx,primIdx) where prim_numNode discrepant 
-        a.prim[ab.prim_numNode,1].view(np.int32)   
-        # B : (sbtIndexOffset,meshIdx,repeatIdx,primIdx) where prim_numNode discrepant 
-        b.prim[ab.prim_numNode,1].view(np.int32)   
-
-        # A : (numNode,nodeOffset,tranOffset,planOffset) where prim_numNode discrepant
-        a.prim[ab.prim_numNode,0].view(np.int32)  
-
-        # B : (numNode,nodeOffset,tranOffset,planOffset) where prim_numNode discrepant
-        b.prim[ab.prim_numNode,0].view(np.int32)  
-
-        """).split("\n"))
-        for expr in EXPR: 
-            val = str(eval(expr)) if not expr.startswith("#") else "" 
-            fmt = "%-80s \n%s\n" if len(val.split("\n")) > 1 else "%-80s : %s"
-            lines.append(fmt % (expr, val))
-        pass
-        return "\n".join(lines) 
-
-
-    def check_inst(self):
-        a = self.a
-        b = self.b
-        ab = self
-        setattr(self, "inst", np.max(np.abs(a.inst[:,:,:3]-b.inst[:,:,:3]).reshape(-1,12),axis=1))  
-
-        lines = []
-        lines.append("CSGFoundryAB.check_inst")
-        EXPR = filter(None,textwrap.dedent(r"""
-        np.all(a.inst[:,0,3].view(np.int32)==b.inst[:,0,3].view(np.int32)) 
-        np.all(a.inst[:,1,3].view(np.int32)==b.inst[:,1,3].view(np.int32)) 
-        np.all(a.inst[:,2,3].view(np.int32)==b.inst[:,2,3].view(np.int32)) 
-        np.all(a.inst[:,3,3].view(np.int32)==b.inst[:,3,3].view(np.int32)) 
-        np.all(a.inst[:,:,3].view(np.int32)==b.inst[:,:,3].view(np.int32)) 
-        # deviation counts in the 12 floats of the inst transform
-        len(np.where(ab.inst>1e-4)[0])
-        len(np.where(ab.inst>1e-3)[0]) 
-        len(np.where(ab.inst>1e-2)[0]) 
-        """).split("\n"))
-
-        for expr in EXPR: 
-            val = str(eval(expr)) if not expr.startswith("#") else "" 
-            fmt = "%-80s \n%s\n" if len(val.split("\n")) > 1 else "%-80s : %s"
-            lines.append(fmt % (expr, val))
-        pass
-        return "\n".join(lines) 
-
-    def check_solid(self):
-        """
-        [:,1] houses (numPrim, primOffset, type, padding)
-        """
-        a = self.a 
-        b = self.b 
-        lines = []
-        lines.append("CSGFoundryAB.check_solid")
-        EXPR = filter(None,textwrap.dedent(r"""
-        np.all(a.solid[:,1]==b.solid[:,1]) 
-        np.c_[a.solid[:,1,:2],b.solid[:,1,:2]]#(numPrim,primOffset) 
-        """).split("\n"))
-        for expr in EXPR: 
-            val = str(eval(expr)) if not expr.startswith("#") else "" 
-            fmt = "%-80s \n%s\n" if len(val.split("\n")) > 1 else "%-80s : %s"
-            lines.append(fmt % (expr, val))
-        pass
-        return "\n".join(lines) 
-
-    def check_names(self):
-        lines = []
-        lines.append("CSGFoundryAB.check_names")
-        EXPR = filter(None,textwrap.dedent(r"""
-        np.all(a.mmlabel==b.mmlabel) 
-        np.all(a.primname==b.primname) 
-        np.all(a.meshname==b.meshname) 
-        """).split("\n"))
-        for expr in EXPR: 
-            val = str(eval(expr)) if not expr.startswith("#") else "" 
-            fmt = "%-80s \n%s\n" if len(val.split("\n")) > 1 else "%-80s : %s"
-            lines.append(fmt % (expr, val))
-        pass
-        return "\n".join(lines) 
-
-
-
-    def check_4x4(self, name):
-        a = self.a 
-        b = self.b        
-        ab = self
-        am = getattr(a, name)
-        bm = getattr(b, name)
-
-        lines = []
-        lines.append("CSGFoundryAB.check_4x4 %s " % name )
-        lines.append(" a.%s.shape : %s " % (name, str(am.shape)) )
-        lines.append(" b.%s.shape : %s " % (name, str(bm.shape)) )
-        if am.shape == bm.shape:
-            abm = np.max(np.abs(am-bm).reshape(-1,16), axis=1 )
-            setattr(self,name, abm )
-            expr = "len(np.where(ab.%(name)s>0.01)[0])" % locals()
-            lines.append(" %s : %s " % (expr, str(eval(expr))))
-        else:
-            setattr(self,name,None) 
-        pass
-        return STR("\n".join(lines))
-
-    def compare_qwn(self, qwn="npa"):
-        a = self.a 
-        b = self.b        
-        ab = self
-        aq = getattr(a, qwn)
-        bq = getattr(b, qwn)
-        setattr(ab, qwn, np.max(np.abs(aq-bq), axis=1 ))
-   
-
-    def check_tran(self):
-        lines = []
-        lines.append(self.check_4x4("tran"))
-        lines.append(self.check_4x4("itra"))
-        return "\n".join(lines)
-
-
-
-
-def checktran(a, b, ip, order="A" ):
-    """
-    ::
- 
-        at,bt,atran,btran,dtran = checktran(a,b,2000,"S")
-
-        # order A:asis, S:sum_sort, U:unique
-        #
-
-    """
-    ann = a.pr.numNode[ip]
-    bnn = b.pr.numNode[ip]
-
-    ano = a.pr.nodeOffset[ip]
-    bno = b.pr.nodeOffset[ip]
-
-    atr = ( a.ni.comptran[ano:ano+ann] & 0x7fffffff ) - 1  
-    btr = ( b.ni.comptran[bno:bno+bnn] & 0x7fffffff ) - 1 
-
-    at = atr[atr>-1]   # not -1 as thats done above 
-    bt = btr[btr>-1]
-
-    if len(at) == len(bt):
-        if order == "U":
-            atran = np.unique( a.tran[at], axis=0 )  
-            btran = np.unique( b.tran[bt], axis=0 )  
-        elif order == "S":
-            # sort by the sum of the 16 elements 
-            a_tran = a.tran[at]
-            b_tran = b.tran[bt]
-
-            ss_atran = np.argsort(np.sum(a_tran, axis=(1,2)))
-            ss_btran = np.argsort(np.sum(b_tran, axis=(1,2)))
-
-            atran = a_tran[ss_atran]  
-            btran = b_tran[ss_btran]  
-        elif order == "A":
-            atran = a.tran[at]   
-            btran = b.tran[bt] 
-        pass
-        dtran = np.sum( np.abs( atran - btran), axis=(1,2) ) 
-    else:
-        dtran = None
-    pass
-    return at,bt,atran,btran,dtran
- 
-
-
-def checkprim(a, b, ip, dump=False, order="A"):
-    """
-    :param a: cf
-    :param b: cf
-    :param ip: prim index
-    :param dump:
-    :param order: control tran order with one of "ASIS" "SS" "U"
-
-    * A : default 
-    * S : sorting by sum of 16 elements
-    * U : apply np.unique 
- 
-    """
-    fmt = "ip:%(ip)4d " 
-    alv = a.pr.meshIdx[ip]
-    blv = b.pr.meshIdx[ip]
-    slv = "/" if alv == blv else "*"
-    fmt += "lv:%(alv)3d%(slv)s%(blv)3d "
-
-    ann = a.pr.numNode[ip]
-    bnn = b.pr.numNode[ip]
-    snn = "/" if ann == bnn  else "*"
-    fmt += "nn:%(ann)3d%(snn)s%(bnn)3d "
-
-    ano = a.pr.nodeOffset[ip]
-    bno = b.pr.nodeOffset[ip]
-    sno = "/" if ano == bno  else "%"   # not "*" as this is bound to get stuck after first deviation
-    fmt += "no:%(ano)5d%(sno)s%(bno)5d " 
-
-    anode = a.node[ano:ano+ann]  
-    bnode = b.node[bno:bno+bnn]  
-
-    amn = a.meshname[alv]
-    bmn = b.meshname[blv]
-    smn = "/" if amn == bmn  else "*"
-
-    atc = a.ni.typecode[ano:ano+ann]
-    btc = b.ni.typecode[bno:bno+bnn]
-
-    aco = a.ni.comptran[ano:ano+ann] >> 31
-    bco = b.ni.comptran[bno:bno+bnn] >> 31
-
-    at,bt,atran,btran,dtran = checktran(a,b,ip,order=order)
-
-    if not dtran is None:
-        wtran = np.where( dtran > 1e-2 )[0]   # large epsilon to avoid any float/double diffs
-        ltran = len(wtran)
-    else:
-        ltran = -1 
-    pass  
-    stran = ":" if ltran == 0 else "*"
-    fmt += " %(order)s tr%(stran)s%(ltran)2d "
-
-    fmt += "mn:%(amn)40s%(smn)s%(bmn)40s "
-
-
-    if ip == 0: print(fmt)
-    line = fmt % locals()
-    if "*" in line or dump:
-        print(line)
-    pass
-
-    if snn == "/":
-        expr = "np.c_[atran, btran], np.c_[atc, aco, btc, bco], dtran"
-        return expr, np.c_[atran, btran], np.c_[atc, aco, btc, bco], dtran
-    else:
-        return None
-    pass
-
-
-def checkprims(a, b, ip0=-1, ip1=-1, order="A"):
-    """
-    ::
-
-        In [1]: checkprims(a,b)
-         ip:2375  lv: 93/ 93 nn: 15*127 no:15209/15209 mn:        solidSJReceiverFastern/        solidSJReceiverFastern 
-         ip:2376  lv: 93/ 93 nn: 15*127 no:15224%15336 mn:        solidSJReceiverFastern/        solidSJReceiverFastern 
-         ip:2377  lv: 93/ 93 nn: 15*127 no:15239%15463 mn:        solidSJReceiverFastern/        solidSJReceiverFastern 
-         ip:2378  lv: 93/ 93 nn: 15*127 no:15254%15590 mn:        solidSJReceiverFastern/        solidSJReceiverFastern 
-         ip:2379  lv: 93/ 93 nn: 15*127 no:15269%15717 mn:        solidSJReceiverFastern/        solidSJReceiverFastern 
-         ip:2380  lv: 93/ 93 nn: 15*127 no:15284%15844 mn:        solidSJReceiverFastern/        solidSJReceiverFastern 
-         ip:2381  lv: 93/ 93 nn: 15*127 no:15299%15971 mn:        solidSJReceiverFastern/        solidSJReceiverFastern 
-         ip:2382  lv: 93/ 93 nn: 15*127 no:15314%16098 mn:        solidSJReceiverFastern/        solidSJReceiverFastern 
-         ip:3126  lv: 99/ 99 nn: 31*1023 no:23372%24268 mn:                          uni1/                          uni1 
-
-    """
-    if ip0 < 0 and len(a.pr.numNode) == len(b.pr.numNode):
-        ip0 = 0 
-        ip1 = len(a.pr.numNode)
-    pass
-    for i in range(ip0, ip1):
-        checkprim(a,b, i, order=order)
-    pass
-
-
-def eprint(_lines, _globals, _locals ):
-    """
-    Double hash "##" on the line suppresses printing the repr 
-    of the evaluation. 
-
-    Lines are first search for the position of the first "=" character.
-    If present the position is used to extract the key and expression
-    to be evaluated in the scope provided by the arguments. 
-    The key with value is planted into the calling scope using builtins. 
-
-
-    HMM : PARSE NEEDS TO DETECT PARAMETER EQUAL 
-
-    ACTUALLY MAYBE EASIER TO PREFIX WITH "_ =" IF NO "KEY =" prefix is found 
-
-    np.c_[np.unique(a.npa[a.pno[a.pnn>1],0].view(np.int32),return_counts=True)]
-
-
-    TODO : support semicolon on the lines 
-    """
-    lines = list(filter(None, textwrap.dedent(_lines).split("\n") ))
-
-    print("-" * 100)
-    print("\n".join(lines))
-    print("-" * 100)
-
-    for line in lines:
-        eq = line.find("=") 
-        eeq = line.find("==") 
-        no_key = eq == -1 or ( eq > -1 and eq == eeq ) # no "=" or first "=" is from "==" 
-        if no_key: 
-            exp = line
-            val = eval(exp, _globals, _locals )
-            print(exp)
-            print(repr(val))
-        elif eq > -1:
-            key, exp = line[:eq].strip(), line[1+eq:]  # before and after first "="
-            val = eval(exp, _globals, _locals )
-            #print("set [%s] " % key )
-            setattr(builtins, key, val)
-            print(line)
-            if line.find("##") == -1:
-                print(repr(val))
-            pass
-        else:
-            print(line)
-        pass
-    pass       
-    print("-" * 100)
-
-
-
-if __name__ == '__main__':
-
-    np.set_printoptions(edgeitems=10) 
-
-    CSGPrim.Type()
-
-    A = Fold.Load("$A_CFBASE/CSGFoundry", symbol="A")
-    B = Fold.Load("$B_CFBASE/CSGFoundry", symbol="B")
-
-    print(repr(A))
-    print(repr(B))
-
-    a = CSGFoundry.Load("$A_CFBASE", symbol="a")
-    b = CSGFoundry.Load("$B_CFBASE", symbol="b")
-    print(a.brief())
-    print(b.brief())
-
-    ab = CSGFoundryAB(a,b)
-
-    print(ab.check_names())
-    print(ab.check_pr())
-    print(ab.check_prim())
-    print(ab.check_solid())
-    print(ab.check_tran())
-    print(ab.check_inst())
-
-    print(ab.brief())
-
-    a_meshname = np.char.partition(a.meshname.astype("U"),"0x")[:,0]  
-    b_meshname = b.meshname.astype("U")
-    assert np.all( a_meshname == b_meshname ) 
-
-    a_primname = np.char.partition(a.primname.astype("U"),"0x")[:,0]  
-    b_primname = b.primname.astype("U")
- 
-    an = A.SSim.stree._csg.sn
-    bn = B.SSim.stree._csg.sn
-
-
-    a_tc = a.node[:,3,2].view(np.int32)
-    b_tc = b.node[:,3,2].view(np.int32)
-    w_tc = np.where( a_tc != b_tc )[0]
-
-
-    eprint(r"""
-
-    w_solid = np.where( a.solid != b.solid )[0]  ##
-    w_solid.shape
-
-    np.all( a.nbd == b.nbd )  # node boundary : ONLY REMAINING DEVIANT 
-
-    np.all( a.nix == b.nix )  # nodeIdx local to the compound solid 
-    w_nix = np.where(a.nix != b.nix)[0] ## 
-    w_nix.shape
-
-    w_npa3 = np.where( np.abs(a.npa - b.npa) > 1e-3 )[0] ##  node param deviations
-    w_npa3.shape
-
-    w_nbb3 = np.where( np.abs(a.nbb - b.nbb) > 3e-2 )[0]  ## node bbox deviations
-    w_nbb3.shape
-    w_nbb2 = np.where( np.abs(a.nbb - b.nbb) > 1e-2 )[0]  ## node bbox deviations
-    w_nbb2.shape
-
-    w_nbb = np.where( a.nbb != b.nbb )  ##
-    np.abs( a.nbb[w_nbb] - b.nbb[w_nbb] ).max()   # max deviation in bbox 
-    
-
-    np.all( a.ntc == b.ntc )  # node typecode
-    np.all( a.ncm == b.ncm )  # node complement 
-    np.all( a.ntr == b.ntr )  # node transform idx + 1 
-
-    np.all( a.pnn == b.pnn )  # prim numNode
-    np.all( a.pno == b.pno )  # prim nodeOffset
-    np.all( a.pto == b.pto )  # prim tranOffset
-    np.all( a.ppo == b.ppo )  # prim planOffset
-    
-    np.all( a.psb == b.psb )  # prim sbtIndexOffset
-    np.all( a.plv == b.plv )  # prim lvid/meshIdx
-    np.all( a.prx == b.prx )  # prim ridx/repeatIdx
-    np.all( a.pix == b.pix )  # primIdx 
-
-
-    w_pbb3 = np.where( np.abs(a.pbb-b.pbb) > 1e-3 )[0]  ## prim bbox deviations
-    w_pbb3.shape
-
-    w_pbb2 = np.where( np.abs(a.pbb-b.pbb) > 1e-2 )[0]  ## prim bbox deviations
-    w_pbb2.shape
-
-
-    np.all( a.snp == b.snp )  # solid numPrim 
-    np.all( a.spo == b.spo )  # solid primOffset
-
-    np.all( a.sce == b.sce )  # solid center_extent 
-
-    w_sce = np.where( np.abs( a.sce - b.sce ) > 1e-3 )[0]    # solid center_extent
-    w_sce.shape 
-
-    w_npa = np.where( a.npa != b.npa )[0]   ## int32 3,7,15 in first param slot 
-    w_npa.shape   # these are subNum on compound root nodes : and new workflow omits it
-
-    np.all( a.npa == b.npa )  # after setting crn_subnum in b the node param match exactly  
-
-
-    tab = np.c_[np.unique(a.npa[a.pno[a.pnn>1],0].view(np.int32),return_counts=True)] ## subNum picked from node param 0 of compound root nodes
-    tab 
-
-    tab2 = np.c_[np.unique( a.crn_subnum, return_counts=True )]  ## encapsulate subnum using "crn" compound root node  
-    tab2
-
-    _ = np.c_[np.unique(a.pnn[a.pnn>1], return_counts=True )] # looks like subnum same as the prim num nodes
-
-    np.all( a.crn_subnum == b.crn_subnum) 
-    np.all( a.crn_suboff == b.crn_suboff) 
-
-
-    an = A.SSim.extra.GGeo.bnd_names      ## A side still GGeo in charge
-    bn = B.SSim.stree.standard.bnd_names  ## B side using stree 
-    w_bnd_names = np.where( an != bn )[0] ##
-    w_bnd_names
-
-    np.c_[an[w_bnd_names],bn[w_bnd_names]]   # discrepant bnd names
-
-    """, globals(), locals() )
-pass        
-
diff --git a/CSG/tests/CSGFoundryLoadTest.py b/CSG/tests/CSGFoundryLoadTest.py
deleted file mode 100644
index 6267767b85..0000000000
--- a/CSG/tests/CSGFoundryLoadTest.py
+++ /dev/null
@@ -1,184 +0,0 @@
-#!/usr/bin/env python
-"""
-CSGFoundryLoadTest.py
-=======================
-
-This reviews python access to CSGSolid/CSGPrim/CSGNode 
-to assist with development of importing those from stree/snd:: 
-
-    cf.prim.view(np.int32)[:,:2].reshape(-1,8)  
-
-    In [2]: expr
-    Out[2]: 'cf.prim.view(np.int32)[:,:2].reshape(-1,8) '
-
-    In [3]: eval(expr)
-    Out[3]: 
-    array([[    1,     0,     0,     0,     0,   149,     0,     0],
-           [    1,     1,     1,     0,     1,    17,     0,     1],
-           [    1,     2,     2,     0,     2,     2,     0,     2],
-           [    3,     3,     3,     0,     3,     1,     0,     3],
-           [    3,     6,     5,     0,     4,     0,     0,     4],
-
-                nn    no      to    po     so     mx     rx     px
-
-    nn:numNode
-    no:nodeOffset
-    to:tranOffset
-    po:planOffset
-
-    so:sbtIndexOffset
-    mx:meshIdx  : corresponds to lvIdx
-    rx:repeatIdx
-    px:primIdx  
-
-    nn = cf.prim.view(np.int32)[:,0,0]
-
-    In [7]: np.unique( nn, return_counts=True )
-    Out[7]: 
-    (array([  1,   3,   7,  15,  31, 127], dtype=int32),
-     array([ 933,  127, 2130,   12,    1,   56]))
-
-    ## The nn:numNode are all complete binary tree sizes 
-    ## Presumably that means there are no multiunions with subNum/subOffset in use ? 
-
-    In [9]: cf.prim.view(np.int32)[:,0,0].sum()
-    Out[9]: 23547
-
-    In [10]: cf.node.shape
-    Out[10]: (23547, 4, 4)
-
-    In [66]: mx = cf.prim.view(np.int32)[:,1,1] 
-    In [71]: mx.min(), mx.max()
-    Out[71]: (0, 149)
-
-    In [63]: rx = cf.prim.view(np.int32)[:,1,2]  # repeatIndex associating the prim to its solid 
-    In [65]: np.unique(rx, return_counts=True )
-    Out[65]: 
-    (array([0,       1,    2,    3,    4,    5,    6,    7,    8,    9], dtype=int32),
-     array([3089,    5,   11,   14,    6,    1,    1,    1,    1,  130]))
-
-    ## Those unique ridx counts correspond directly to the solid numPrim
-
-    In [98]: cf.solid[:,1,0]
-    Out[98]: array([3089,    5,   11,   14,    6,    1,    1,    1,    1,  130], dtype=int32)
-
-    In [72]: px = cf.prim.view(np.int32)[:,1,3]
-    In [76]: px.min(), px.max(), len(px)
-    Out[76]: (0, 3088, 3259)
-
-
-    In [87]: np.all( np.arange(3089) == px[:3089] )   
-    Out[87]: True
-    # contiguous monotonic up to 3089 : Those are the primIdx for the ridx:0 globals
-
-Beyond 3089 the last 170 prim dont increment the primIdx. 
-Thats because they are the instances, that reset the primIdx back to zero for each::
-
-    In [94]: px[3089:]
-    Out[94]: 
-    array([
-             0,   1,   2,   3,   4,                                                          # ridx:1  (5)
-             0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,                            # ridx:2  (11)  
-             0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,             # ridx:3  (14)
-             0,   1,   2,   3,   4,   5,                                                     # ridx:4  (6)  
-             0,                                                                              # ridx:5  (1)
-             0,                                                                              # ridx:6  (1)
-             0,                                                                              # ridx:7  (1)
-             0,                                                                              # ridx:8  (1)
-             0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,   # ridx:9  (130)
-            16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  
-            32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  
-            48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  
-            64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  
-            80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  
-            96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
-           112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 
-           128, 129]
-           , dtype=int32)
-
-    In [95]: px[3089:].shape
-    Out[95]: (170,)
-
-Looking at cf.solid makes this plain::
-
-    In [51]: cf.solid.view(np.int32)[:,0].copy().view("|S16")
-    Out[51]: 
-    array([[b'r0'],
-           [b'r1'],
-           [b'r2'],
-           [b'r3'],
-           [b'r4'],
-           [b'r5'],
-           [b'r6'],
-           [b'r7'],
-           [b'r8'],
-           [b'r9']], dtype='|S16')
-
-    In [56]: cf.solid.view(np.int32)[:,1]
-    Out[56]: 
-    array([[3089,    0,    0,    0],
-           [   5, 3089,    0,    0],
-           [  11, 3094,    0,    0],
-           [  14, 3105,    0,    0],
-           [   6, 3119,    0,    0],
-           [   1, 3125,    0,    0],
-           [   1, 3126,    0,    0],
-           [   1, 3127,    0,    0],
-           [   1, 3128,    0,    0],
-           [ 130, 3129,    0,    0]], dtype=int32)
-
-         numPrim primOffset 
-
-    In [58]: cf.solid.view(np.int32)[:,1,0].sum()
-    Out[58]: 3259
-
-    In [59]: cf.prim.shape
-    Out[59]: (3259, 4, 4)
-
-
-Associating each prim to its nodes::
-
-    In [102]: pnn = cf.prim.view(np.int32)[:,0,0]
-    In [103]: pno = cf.prim.view(np.int32)[:,0,1]
-
-
-
-* HMM associating the nodes to each solid 
-
-Start of the node index is contiguous monotonic::
-
-    In [14]: ix = cf.node.view(np.int32)[:,1,3] 
-    In [36]: np.all( np.arange(23200) == ix[:23200] )
-    Out[36]: True
-    In [37]: ix.shape
-    Out[37]: (23547,)
-    In [40]: np.all( np.arange(23207) == ix[:23207] )
-    Out[40]: True
-    In [41]: np.all( np.arange(23208) == ix[:23208] )
-    Out[41]: False
-
-"""
-
-import numpy as np, logging
-log = logging.getLogger(__name__)
-from opticks.CSG.CSGFoundry import CSGFoundry, CSGPrim
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree, snode, snd
-
-np.set_printoptions(edgeitems=16)
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    CSGPrim.Type()
-    cf = CSGFoundry.Load()  
-    print(repr(cf))
-
-    stf = Fold.Load(cf.base, "CSGFoundry/SSim/stree") 
-    st = stree(stf)
-    print(repr(st))
-
-    print(cf.descSolids(True))
-    print(cf.descSolids(False))
-
-    
diff --git a/CSG/tests/CSGFoundry_MakeCenterExtentGensteps_Test.py b/CSG/tests/CSGFoundry_MakeCenterExtentGensteps_Test.py
deleted file mode 100644
index 0530824bf9..0000000000
--- a/CSG/tests/CSGFoundry_MakeCenterExtentGensteps_Test.py
+++ /dev/null
@@ -1,56 +0,0 @@
-#!/usr/bin/env python
-"""
-CSGFoundry_MakeCenterExtentGensteps_Test.py
-=============================================
-
-
-Mysterious issue with pvplt_polarized yielding 
-only arrows in one direction. 
-
-When use add_arrows succeed to get them in 
-all directions, but the issue is not resolved. 
-
-With add_arrows it was necessary to tune mag 
-to get something visible depending 
-on the size of the region that is plotted
-
-"""
-import numpy as np
-from opticks.ana.fold import Fold
-from opticks.ana.pvplt import * 
-from opticks.sysrap.sframe import sframe 
-
-import pyvista as pv 
-
-if __name__ == '__main__':
-    t = Fold.Load(symbol="t")
-     
-    print(repr(t))
-
-    gs = t.genstep
-    p = t.photon
-    frame = sframe.Load(t.base)
-    print(frame)
-
-    pos = p[:,0,:3] 
-    mom = p[:,1,:3] 
-    pol = p[:,2,:3] 
-
-    pl = pv.Plotter(window_size=2*np.array([1280, 720]))
-
-    pl.add_points( pos, color="magenta", point_size=1.0 )
-
-    #sphere = pv.Sphere(radius=17800)
-    #pl.add_mesh(sphere, color="white", show_edges=True, style="wireframe")
-
-    pl.add_arrows( pos, mom, mag=50, show_scalar_bar=False, color="red" )
-
-    #pvplt_arrows( pl, pos, mom, factor=1000 )    
-    #pvplt_polarized( pl, pos, mom, pol, factor=2000 )    
-
-
-    pl.show_grid()
-    cp = pl.show()           
-
-
-
diff --git a/CSG/tests/CSGIntersectComparisonTest.py b/CSG/tests/CSGIntersectComparisonTest.py
deleted file mode 100644
index ea0e1bd5e5..0000000000
--- a/CSG/tests/CSGIntersectComparisonTest.py
+++ /dev/null
@@ -1,45 +0,0 @@
-#!/usr/bin/env python
-
-
-import logging
-log = logging.getLogger(__name__)
-import numpy as np
-from opticks.ana.fold import Fold
-
-import matplotlib.pyplot as mp
-from opticks.sysrap.sframe import sframe , X, Y, Z
-from opticks.ana.pvplt import mpplt_simtrace_selection_line, mpplt_hist
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    s = Fold.Load(symbol="s")
-    print(repr(s))
-
-    ab = s.a_simtrace - s.b_simtrace 
-    print(ab.max())
-
-    a_simtrace = s.a_simtrace.reshape(-1,4,4)
-    b_simtrace = s.b_simtrace.reshape(-1,4,4)
-
-    fr = sframe.FakeXZ(e=300) 
-
-    fig, ax = fr.mp_subplots(mp)  
-
-    if not s is None:
-        a_hit = a_simtrace[:,0,3]>0 
-        a_pos = a_simtrace[a_hit][:,1,:3]
-        fr.mp_scatter(a_pos, label="a_pos", s=1 )
-
-        b_hit = b_simtrace[:,0,3]>0 
-        b_pos = b_simtrace[b_hit][:,1,:3]
-        fr.mp_scatter(b_pos, label="b_pos", s=1 )
-
-        #w = np.logical_and( np.abs(s.b_simtrace[:,1,0]) < 10. , np.abs(s.b_simtrace[:,1,2]) < 10. )  
-    pass
- 
-    if not "NOLEGEND" in os.environ:
-        ax.legend()
-    pass
-    fig.show()
-pass
-
diff --git a/CSG/tests/CSGIntersectSolidTest.py b/CSG/tests/CSGIntersectSolidTest.py
deleted file mode 100644
index 6243d08f4c..0000000000
--- a/CSG/tests/CSGIntersectSolidTest.py
+++ /dev/null
@@ -1,650 +0,0 @@
-#!/usr/bin/env python
-"""
-CSGIntersectSolidTest.py
-==========================
-
-
-AnnulusFourBoxUnion
-    notice that spurious intersects all from 2nd circle roots  
- 
-
-IXYZ=-6,0,0 SPUR=1 ./csg_geochain.sh ana
-
-
-
-"""
-import os, logging, numpy as np
-from opticks.ana.fold import Fold
-from opticks.sysrap.SCenterExtentGenstep import SCenterExtentGenstep
-
-from opticks.ana.gridspec import GridSpec, X, Y, Z
-from opticks.ana.npmeta import NPMeta
-from opticks.ana.eget import efloat_, efloatlist_, eint_, eintlist_
-
-
-SIZE = np.array([1280, 720])
-
-log = logging.getLogger(__name__)
-np.set_printoptions(suppress=True, edgeitems=5, linewidth=200,precision=3)
-
-try:
-    import matplotlib.pyplot as mp  
-except ImportError:
-    mp = None
-pass
-#mp = None
-
-try:
-    import vtk
-    import pyvista as pv
-    from pyvista.plotting.colors import hexcolors  
-    themes = ["default", "dark", "paraview", "document" ]
-    pv.set_plot_theme(themes[1])
-except ImportError:
-    pv = None
-    hexcolors = None
-pass
-#pv = None
-
-
-
-def make_arrows(cent, direction, mag=1):
-    direction = direction.copy()
-    if cent.ndim != 2:
-        cent = cent.reshape((-1, 3))
-
-    if direction.ndim != 2:
-        direction = direction.reshape((-1, 3))
-
-    direction[:,0] *= mag
-    direction[:,1] *= mag
-    direction[:,2] *= mag
-
-    pdata = pv.vector_poly_data(cent, direction)
-    # Create arrow object
-    arrow = vtk.vtkArrowSource()
-    arrow.Update()
-    glyph3D = vtk.vtkGlyph3D()
-    glyph3D.SetSourceData(arrow.GetOutput())
-    glyph3D.SetInputData(pdata)
-    glyph3D.SetVectorModeToUseVector()
-    glyph3D.Update()
-
-    arrows = pv.wrap(glyph3D.GetOutput())
-    return arrows
-
-
-
-def lines_rectangle_YX(center, halfside):
-    """
-
-          1                0
-           +------+------+
-           |      |      |
-           |      |      |
-           |- - - + - - -| 
-           |      |      |
-           |      |      |
-           +------+------+
-         2                3
-
-
-         X
-         |
-         +-- Y
-
-    """
-    p0 = np.array( [center[0]+halfside[0], center[1]+halfside[1], center[2] ])
-    p1 = np.array( [center[0]+halfside[0], center[1]-halfside[1], center[2] ])
-    p2 = np.array( [center[0]-halfside[0], center[1]-halfside[1], center[2] ])
-    p3 = np.array( [center[0]-halfside[0], center[1]+halfside[1], center[2] ])
-
-    ll = np.zeros( (4,2,3),  dtype=np.float32 )
-
-    ll[0] = p0, p1
-    ll[1] = p1, p2
-    ll[2] = p2, p3
-    ll[3] = p3, p0
-
-    return ll.reshape(-1,3)
-
-
-def AnnulusFourBoxUnion_YX(pl, opt="+X -X +Y -Y circ", color='cyan', width=1, radius=45.):
-    if opt.find("circ") > -1:
-        arc = pv.CircularArc([0,  radius, 0], [0, radius, 0], [0, 0, 0], negative=True)
-        pl.add_mesh(arc, color='cyan', line_width=1)
-    pass
-    lls = [] 
-    if opt.find("+X") > -1:
-        llpx = lines_rectangle_YX([ 52., 0.,0.],[10.,11.5, 6.5]) 
-        lls.append(llpx)
-    pass
-    if opt.find("-X") > -1:   
-        llnx = lines_rectangle_YX([-52., 0.,0.],[10.,11.5, 6.5]) 
-        lls.append(llnx)
-    pass
-    if opt.find("+Y") > -1:
-        llpy = lines_rectangle_YX([0., 50.,0.],[15.,15.,  6.5])
-        lls.append(llpy)
-    pass
-    if opt.find("-Y") > -1:
-        llny = lines_rectangle_YX([0.,-50.,0.],[15.,15.,  6.5])
-        lls.append(llny)
-    pass
-    for ll in lls:
-        pl.add_lines(ll, color=color, width=width )
-    pass
-
-def ReferenceGeometry(pl):
-    geom = os.environ.get("GEOM",None)
-    if geom is None: return 
-
-    print("ReferenceGeometry for GEOM %s " % geom)
-    if geom == "AnnulusFourBoxUnion_YX":
-        AnnulusFourBoxUnion_YX(pl, opt="+X -X +Y -Y circ")
-    elif geom == "BoxCrossTwoBoxUnion_YX":
-        AnnulusFourBoxUnion_YX(pl, opt="+Y +X")
-    
-
-    else:
-        print("ReferenceGeometry not implemented for GEOM %s " % geom)
-    pass
-
-
-
-class Rays(object):
-    """
-
-    ## different presentation of selected intersects 
-    ## red position points (usually invisible under arrow) and normal arrows    
-
-    #pl.add_arrows( s_ray_origin, s_ray_direction, color="blue", mag=s_t ) 
-    # drawing arrow from ray origins to intersects works, but the arrows are too big 
-    # TODO: find way to do this with different presentation
-    # as it avoids having to python loop over the intersects as done
-    # below which restricts to small numbers  
-    """
-    @classmethod
-    def Draw(cls, pl, p0, p1, n1, n0=None, ori_color="magenta", nrm_color="red", ray_color="blue", ray_width=1, pos_shift=None ):
-        """
-        :param pl: pyvista plotter
-        :param p0: start position
-        :param p1: end position 
-        :param n1: direction vec at end
-        :param n0: direction vec at start or None
-        :param pos_shift: shift vector or None
-        """
-        assert len(p0) == len(p1) 
-
-        if not pos_shift is None:
-            q0 = p0 + pos_shift
-            q1 = p1 + pos_shift
-        else:
-            q0 = p0 
-            q1 = p1 
-        pass
-
-        pl.add_points( q0, color=nrm_color )   
-
-        if not n1 is None:
-            assert len(q0) == len(n1) 
-            pl.add_arrows( q1, n1, color=nrm_color, mag=10 )
-        pass
-
-        if not n0 is None:
-            assert len(q0) == len(n0)
-            pl.add_arrows( q0, n0, color=nrm_color, mag=10 )
-        pass
-
-        ll = np.zeros( (len(q0), 2, 3), dtype=np.float32 )
-        ll[:,0] = q0
-        ll[:,1] = q1
-
-        pl.add_points( q0, color=ori_color, point_size=16.0 )
-        for i in range(len(ll)):
-            pl.add_lines( ll[i].reshape(-1,3), color=ray_color, width=ray_width )
-        pass  
-    pass
-
-
-class CSGRecord(object):
-    @classmethod
-    def Draw0(cls, pl, recs): 
-        """
-        # works but then difficult for labelling 
-        """
-        if len(recs) > 0:
-            arrows = make_arrows( recs[:,2,:3], recs[:,0,:3], mag=10 )
-            pl.add_mesh( arrows, color="pink" )
-            print(arrows)
-        pass
-    @classmethod
-    def Draw1(cls, pl, recs): 
-        """
-        Old record layout 
-        """
-        rec_tloop_nodeIdx_ctrl = rec[3,:3].view(np.int32)
-        arrows = make_arrows( rec_pos, rec_dir, mag=10 )
-        pl.add_mesh( arrows, color="pink" )
-        points = arrows.points 
-        mask = slice(0,1)
-        pl.add_point_labels( points[mask], [ str(rec_tloop_nodeIdx_ctrl) ] , point_size=20, font_size=36 )
-
-    @classmethod
-    def Draw(cls, pl, recs, ray_origin, ray_direction, off): 
-        """
-        :param pl: pyvista plotter
-        :param recs: CSGRecord array for a single ray CSG tree intersection
-        :param ray_origin:
-        :param ray_direction:
-        :param off: normalized vector out of the genstep plane, pointing to viewpoint  
-
-        # less efficient but gives easy access to each arrow position 
-        """
-
-        pos_shifts = []
-        for i in range(len(recs)): 
-            left  = recs[i,0]
-            n_left = left[:3]
-            t_left  = np.abs(left[3])
-
-            right = recs[i,1]
-            n_right = right[:3]
-            t_right = np.abs(right[3])
-
-            tmin = recs[i,3,0] 
-            t_min = recs[i,3,1] 
-            tminAdvanced = recs[i-1,3,2] if i > 0 else 0. 
-  
-            ## tminAdvanced is bit confusing as collected 
-            ## into record prior to the decision  (for leaf looping anyhow) 
-
-            print("CSGRecord.Draw rec %d : tmin %10.4f t_min %10.4f tminAdvanced %10.4f (from prior rec) " % (i, tmin, t_min, tminAdvanced ))
-
-            result = recs[i,4]
-            t_result = np.abs(result[3])
-            n_result = result[:3]
-
-            pos_t_min = ray_origin + t_min*ray_direction                # base 
-            pos_tmin  = ray_origin + tmin*ray_direction                 
-            pos_tminAdvanced = ray_origin + tminAdvanced*ray_direction  
-            pos_left  = ray_origin + t_left*ray_direction
-            pos_right = ray_origin + t_right*ray_direction
-            pos_result = ray_origin + t_result*ray_direction
-
-            pos_shift_0 = float(i*10+0)*off 
-            pos_shift_1 = float(i*10+1)*off 
-            pos_shift_2 = float(i*10+2)*off 
-            pos_shift_3 = float(i*10+3)*off 
-
-            pos_shifts.append(pos_shift_0)
-
-            if tminAdvanced > 0.:
-                Rays.Draw(pl, pos_t_min, pos_tminAdvanced ,  ray_direction, ray_width=4, pos_shift=pos_shift_0, ray_color="green"  )
-            pass
-
-            Rays.Draw(pl, pos_tmin,  pos_left ,  n_left,        ray_width=4, pos_shift=pos_shift_1  )
-            Rays.Draw(pl, pos_tmin,  pos_right,  n_right,       ray_width=4, pos_shift=pos_shift_2  )
-
-            if t_result > 0.:
-                Rays.Draw(pl, pos_tmin,  pos_result, n_result,      ray_width=4, pos_shift=pos_shift_3, ray_color="cyan", nrm_color="cyan"  )
-            pass
-        pass
-        return pos_shifts
-    pass   
-pass 
-
-
-
-
-def apply_phicut(select):
-    print(" SPHI : selecting intersects based on phi angle of the position ") 
-    phi0,phi1 = efloatlist_("SPHI", "0.25,1.75")    
-    cosPhi0,sinPhi0 = np.cos(phi0*np.pi),np.sin(phi0*np.pi)     
-    cosPhi1,sinPhi1 = np.cos(phi1*np.pi),np.sin(phi1*np.pi)     
-    PQ = cosPhi0*sinPhi1 - cosPhi1*sinPhi0 
-    PR = cosPhi0*pos[:,1] - pos[:,0]*sinPhi0
-    QR = cosPhi1*pos[:,1] - pos[:,0]*sinPhi1   #Q ^ R = cosPhi1*d.y - d.x*sinPhi1 
-    select_phi = np.logical_and( PR > 0., QR < 0. ) if PQ > 0. else np.logical_or( PR > 0., QR < 0. )
-    select_phi = np.logical_not( select_phi )
-    count_phi = np.count_nonzero(select_phi)
-    print( "%40s : %d " % ("count_phi", count_phi) )
-    select = np.logical_and( select, select_phi )
-    count_select = np.count_nonzero(select)
-    print("%40s : %d   SPHI %s  phi0 %s phi1 %s PQ %s \n" % ("count_select", count_select, os.environ["SPHI"], phi0, phi1, PQ )) 
-    return select
-pass
-
-def CSGIntersectFold():
-    """
-    eg /tmp/blyth/opticks/GeoChain/nmskSolidMaskTail/CSGIntersectSolidTest/nmskSolidMaskTail_XZ 
-    """
-    identdir = "$GEOM" if "GEOM" in os.environ else "$SOPR" 
-    isectFold = os.path.expandvars("$CFBASE/CSGIntersectSolidTest/%s" % identdir)
-    print("CSGIntersectFolder : %s " % isectFold )
-    return isectFold 
-
-def X4IntersectFold():
-    """
-    eg /tmp/blyth/opticks/extg4/X4IntersectSolidTest/nmskSolidMaskTail_XZ/X4Intersect/
-    """
-    identdir = "$GEOM" if "GEOM" in os.environ else "$SOPR" 
-    isectFold = os.path.expandvars("/tmp/$USER/opticks/extg4/X4IntersectSolidTest/%s/X4Intersect" % identdir)
-    print("X4IntersectFolder : %s " % isectFold )
-    return isectFold 
-
-def select_ixyz_genstep(select, ixyz):
-    """
-    when envvar IXYZ is defined restrict to a single genstep source of photons identified by grid coordinates
-    """
-    ix,iy,iz = ixyz
-    print(isect_gsid)
-    select_isect_gsid = np.logical_and( np.logical_and( isect_gsid[:,0] == ix , isect_gsid[:,1] == iy ), isect_gsid[:,2] == iz )
-    count_isect_gsid = np.count_nonzero(select_isect_gsid) 
-
-    select = np.logical_and( select, select_isect_gsid )
-    count_select = np.count_nonzero(select)
-
-    print("%40s : %d   IXYZ %s  ix:%d iy:%d iz:%d" %   ("count_isect_gsid", count_isect_gsid, os.environ.get("IXYZ",None), ix,iy,iz ))
-    print("%40s : %d  \n" % ("count_select", count_select)) 
-
-    return select
-
-def select_iw_genstep(select, iw ):
-    """
-    when envvar IW is defined restrict to a single photon index, usually used together with IXYZ to pick one intersect
-    by selecting a single intersect as well as single genstep  
-    """
-    select_iw = isect_gsid[:,3] == iw 
-    count_iw = np.count_nonzero(select_iw)
-    select = np.logical_and( select, select_iw )
-    count_select = np.count_nonzero(select)
-
-    print("%40s : %d   IW %s " %   ("count_iw", count_iw, os.environ["IW"] ))
-    print("%40s : %d  \n" % ("count_select", count_select)) 
-
-    return select 
-
-
-
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    pl = pv.Plotter(window_size=SIZE*2 ) 
-
-    if 'EDL' in os.environ:
-        print("EDL : enable_eye_dome_lighting :  improves depth perception with point clouds")
-        pl.enable_eye_dome_lighting()  
-    pass   
-
-    if 'X4' in os.environ:
-        x4_fold_ = X4IntersectFold()
-        x4_cegs = SCenterExtentGenstep(x4_fold_)
-        x4_fold = x4_cegs.fold
-    else:
-        x4_fold = None
-    pass
-
-
-    csg_fold_ = CSGIntersectFold()
-    cegs = SCenterExtentGenstep(csg_fold_)
-    fold = cegs.fold
-    rel_name = "saveCenterExtentGenstepIntersect"
-    recs_path = os.path.join(csg_fold_, rel_name )
-
-
-    gspos = fold.gs[:,5,:3]
-    gsid_ =  fold.gs[:,0,2].view(np.uint32).copy()
-    gsid =  gsid_.view(np.int8).reshape(-1,4)            # q0.u.z (4 packed signed char) 
-
-    no_gs = 'NO_GS' in os.environ 
-    if no_gs:
-        print(" skip gspos points due to NO_GS " )
-    else:
-        pl.add_points( gspos, color="yellow" )
-    pass
-
-    gsmeta = NPMeta(fold.gs_meta)  # TODO cxs_geochain uses genstep_meta : standardize
-    gridspec = GridSpec(fold.peta, gsmeta)
-    axes = gridspec.axes
-    off = gridspec.off
-    print(" gridspec.axes : %s   gridspec.off %s  " % (str(axes), str(off)) )
-
-    gridspec.pv_compose(pl)  ## composition is sensitive to envvars RESET PARA ZOOM
-
-    no_isect = not hasattr(fold, 'isect') 
-    gs_only = 'GS_ONLY' in os.environ
-    quiet = True 
-
-    if no_isect or gs_only:
-       log.fatal("early exit just showing gensteps as no_isect:%s in fold OR gs_only:%d selected by GS_ONLY envvar" % (no_isect, gs_only))
-       pl.show_grid()
-       cp = pl.show()
-       sys.exit(0)
-    pass 
-
-    dir_, t = fold.isect[:,0,:3], fold.isect[:,0,3]   # intersect normal and ray distance 
-    pos, sd = fold.isect[:,1,:3], fold.isect[:,1,3]   # intersect position and surface distance 
-    ray_origin    = fold.isect[:, 2, :3]
-    ray_direction = fold.isect[:, 3, :3]
-
-    if not x4_fold is None: 
-        x4_pos = x4_fold.isect[:,0,:3]   # TODO: standardize isect layout
-    else:
-        x4_pos = None 
-    pass
-
-    isect_gsid_ = fold.isect[:,3,3].copy().view(np.uint32)
-    isect_gsid = isect_gsid_.view(np.int8).reshape(-1,4)   
-    # genstep (ix,iy,iz,iw) from which each intersect originated from, 
-    # iw is photon index within genstep     
-
-    ## bitwise_and to remove bytes holding the photon index, for easier connection to gs level  
-    isect_gsoid_ = np.bitwise_and( fold.isect[:,3,3].view(np.uint32), 0x00ffffff ).copy()
-    isect_gsoid = isect_gsoid_.view(np.int8).reshape(-1,4)  
-    assert np.all( isect_gsid[:,:3]  == isect_gsoid[:,:3] ) 
-
-
-    asd = np.abs(sd)   # absolute distance to surface : should be close to zero for all intersects 
-    asd_cut = efloat_("ASD", 1e-2)
-    select_spurious = asd > asd_cut 
-    select_all = t > 0.
-
-
-    gss_ = np.unique(isect_gsoid_[select_spurious]) 
-    gss = gss_.view(np.int8).reshape(-1,4)         # gensteps which have spurious intersects 
-    gsid_idx = np.where(np.in1d(gsid_, gss_))[0]   # gsid_ indices of      
-    gss_select = np.isin(gsid_, gss_)              # genstep mask selecting gensteps the rays from which have spurious intersects
-
-    if no_gs:
-        print(" skip gspos points due to NO_GS " )
-    else:
-        gss_select_count = np.count_nonzero(gss_select)
-        if gss_select_count > 0:  
-            pl.add_points( gspos[gss_select], color="green" )
-        pass
-        ## gs with spurious intersects presented differently
-    pass
-
-    select = select_all 
-
-    count_all = np.count_nonzero(select_all)
-    count_spurious = np.count_nonzero(select_spurious)
-    cmdline = os.environ.get("CMDLINE", "no-CMDLINE")
-
-    print("\n\n")
-    print(cmdline)
-    print("\n")
-    print( "%40s : %d " % ("count_all", count_all) )
-    print( "%40s : %d " % ("count_spurious", count_spurious) )
-
-    if 'SPHI' in os.environ:
-        select = apply_phicut(select)
-    pass
-
-    if 'SPUR' in os.environ:  # when envvar SPUR is defined restrict to intersects that have sd less than sd_cut  
-        select = np.logical_and( select, select_spurious )
-        count_select = np.count_nonzero(select)
-        print("%40s : %d    SPUR %s " % ("count_spurious", count_spurious, os.environ["SPUR"] ))
-        print("%40s : %d  \n" % ("count_select", count_select)) 
-    pass
-
-    sxyzw = eintlist_("SXYZW", None)   
-    _sxyzw = np.array( sxyzw, dtype=np.int8 ).view(np.uint32)[0] if not sxyzw is None else None
-    _sxyzw_idx = np.where( isect_gsid_ == _sxyzw )  if not _sxyzw is None else None
-
-    ixyz = eintlist_("IXYZ", None)   
-    if not ixyz is None:
-        log.info("select_ixyz_genstep") 
-        select = select_ixyz_genstep(select, ixyz)  
-    pass
-
-    iw = eint_("IW","-1")
-    if iw > -1:
-        log.info("select_iw_genstep") 
-        select = select_iw_genstep(select, iw)  
-    pass
-
-    gsid_label = None 
-    if not ixyz is None and not iw is None:
-        ix,iy,iz = ixyz
-        gsid_label = "gsid_%d_%d_%d_%d" % (ix,iy,iz,iw)     
-        print(" IXYZ/IW defined =>  gsid_label : %s " % gsid_label )
-    elif not sxyzw is None:
-        sx,sy,sz,sw = sxyzw
-        gsid_label = "gsid_%d_%d_%d_%d" % (sx,sy,sz,sw) 
-        print(" SXYZW defined  =>  gsid_label : %s " % gsid_label )
-    pass     
-        
-    if not gsid_label is None: 
-        recs_fold = Fold.Load(recs_path, gsid_label, quiet=True)
-        recs = [] if recs_fold is None else recs_fold.CSGRecord 
-        if len(recs) > 0:
-            print("%40s : %s   recs_fold.base %s " % ("recs", str(recs.shape), recs_fold.base )) 
-        else:
-            if quiet == False:
-                print(" no recs to load at recs_path/gsid_label %s/%s " % (recs_path, gsid_label))
-            pass
-        pass
-    else:
-        recs = []
-    pass
-
-    pos_shifts = []
-    if len(recs) > 0:
-        assert not _sxyzw_idx is None
-        _ray_origin = ray_origin[_sxyzw_idx][0]
-        _ray_direction = ray_direction[_sxyzw_idx][0]
-        pos_shifts = CSGRecord.Draw(pl, recs, _ray_origin, _ray_direction, off )
-    pass
-
-    count_select = np.count_nonzero(select)
-    print("%40s : %d  \n" % ("count_select", count_select)) 
-
-    s_t = t[select]
-    s_pos = pos[select]
-    s_sd = sd[select]
-    s_isect_gsid = isect_gsid[select]
-    s_dir = dir_[select]
-    s_isect = fold.isect[select]
-    s_ray_origin = ray_origin[select]
-    s_ray_direction = ray_direction[select]
-    s_pos_r = np.sqrt(np.sum(s_pos*s_pos, axis=1))  
-
-    s_count = len(s_pos)
-    s_limited = min( s_count, 100 )   
-    # default number of photons per genstep is 100, so this gets all of those when selecting single genstep
-    selected_isect = s_isect[:s_limited]
-
-    print("%40s : %d  \n" % ("s_count", s_count)) 
-    print("%40s : %d  \n" % ("s_limited", s_limited)) 
-    print("%40s : %d  \n" % ("selected_isect", len(selected_isect))) 
-
-    ## sub selection of the selected that are also spurious as judged by signed distance
-
-    select_and_spurious = np.logical_and( select, select_spurious )
-    ss_pos = pos[select_and_spurious]
-    ss_dir = dir_[select_and_spurious]
-    ss_ray_origin = ray_origin[select_and_spurious]
-
-    ss_count = len(ss_pos)
-    ss_limited = min( ss_count, 100 )   
-
-    print("%40s : %d  \n" % ("ss_count", ss_count)) 
-    print("%40s : %d  \n" % ("ss_limited", ss_limited)) 
-
-    def fmt(i):
-        _s_isect_gsid = "SXYZW=%d,%d,%d,%d  " % tuple(s_isect_gsid[i]) 
-        _s_t = " s_t ( %10.4f ) " % s_t[i]
-        _s_pos = " s_pos ( %10.4f %10.4f %10.4f ) " % tuple(s_pos[i])
-        _s_pos_r = " s_pos_r ( %10.4f ) " % s_pos_r[i]
-        _s_sd = " s_sd ( %10.4f ) " % s_sd[i]
-        return " %-20s %s %s %s %s " % (_s_isect_gsid, _s_t, _s_pos, _s_pos_r, _s_sd )
-    pass
-    desc = "\n".join(map(fmt,np.arange(s_limited)))
-    print(desc) 
-    print(" Use IXYZ to select gensteps, IW to select photons within the genstep ")
-
-    log.info( "asd_cut %10.4g sd.min %10.4g sd.max %10.4g num select %d " % (asd_cut, sd.min(), sd.max(), len(s_pos)))
-
-
-    selected_isect_path = "/tmp/selected_isect.npy"
-    key = 'SAVE_SELECTED_ISECT'
-    save_selected_isect = key in os.environ
-    if save_selected_isect and len(selected_isect) > 0 :
-        print(" %s : saving selected_isect to %s " % (key, selected_isect_path)  )
-        np.save( selected_isect_path, selected_isect )
-    else:
-        print(" define key %s to save selected isect to %s " % (key, selected_isect_path ))
-    pass
-
-    if 'PLOT_SELECTED_ONLY' in os.environ:   # normally all positions are plotted not just selected
-        pl.add_points( s_pos, color="white" )
-    else:
-        if len(pos_shifts) == 0:
-            pl.add_points( pos, color="white" )
-        else:
-            for pos_shift in pos_shifts:
-                pl.add_points( pos+pos_shift, color="white" )
-            pass
-        pass
-    pass
-
-    if not x4_pos is None:
-        print("x4_pos %s" % str(x4_pos.shape))
-        pl.add_points( x4_pos+10*off, color="cyan" )  
-    else:
-        print("x4_pos None")
-    pass    
-
-
-    ## different presentation of selected intersects and normals
-    if s_count > 0 and sxyzw is None:
-        Rays.Draw( pl, s_ray_origin[:s_limited], s_pos[:s_limited], s_dir[:s_limited] )
-    pass
-    if ss_count > 0 and sxyzw is None:
-        Rays.Draw( pl, ss_ray_origin[:ss_limited], ss_pos[:ss_limited], ss_dir[:ss_limited], ray_color="yellow", nrm_color="yellow" )
-    pass
-
-    pl.show_grid()
-    ReferenceGeometry(pl)
-    topline = os.environ.get("TOPLINE", "topline")
-    botline = os.environ.get("BOTLINE", "botline")
-    pl.add_text(topline, position="upper_left")
-    pl.add_text(botline, position="lower_left")
-
-    figsdir = os.path.join(csg_fold_, "figs")
-    if not os.path.isdir(figsdir):
-        os.makedirs(figsdir)
-    pass
-
-    outname = "out.png" 
-    outpath = os.path.join(figsdir, outname)
-    print(" outpath : %s " % outpath )
-
-    cp = pl.show(screenshot=outpath)
-
-
diff --git a/CSG/tests/CSGNodeScanTest.py b/CSG/tests/CSGNodeScanTest.py
deleted file mode 100644
index 3741831c5d..0000000000
--- a/CSG/tests/CSGNodeScanTest.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-
-import logging
-log = logging.getLogger(__name__)
-import numpy as np
-from opticks.ana.fold import Fold
-
-import matplotlib.pyplot as mp
-from opticks.sysrap.sframe import sframe , X, Y, Z
-from opticks.ana.pvplt import mpplt_simtrace_selection_line, mpplt_hist
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    s = Fold.Load(symbol="s")
-    print(repr(s))
-
-    s_simtrace = s.simtrace.reshape(-1,4,4)
-    s_geom = os.environ.get("GEOM", "geom")
-
-    fr = sframe.FakeXZ(e=11) 
-
-    fig, ax = fr.mp_subplots(mp)  
-
-    if not s is None:
-        s_hit = s_simtrace[:,0,3]>0 
-        s_pos = s_simtrace[s_hit][:,1,:3]
-        fr.mp_scatter(s_pos, label="%s" % s_geom, s=1 )
-    pass
- 
-    if not "NOLEGEND" in os.environ:
-        ax.legend()
-    pass
-    fig.show()
-
diff --git a/CSG/tests/CSGSimtraceTest.py b/CSG/tests/CSGSimtraceTest.py
deleted file mode 100644
index 24145f939c..0000000000
--- a/CSG/tests/CSGSimtraceTest.py
+++ /dev/null
@@ -1,153 +0,0 @@
-#!/usr/bin/env python
-"""
-CSG/tests/CSGSimtraceTest.py
-===============================
-
-HMM: almost identical to extg4/tests/X4SimtraceTest.py 
-
-TODO: more duplication avoidance but keep distinct mains
-
-"""
-import os, logging, builtins, numpy as np
-log = logging.getLogger(__name__)
-from opticks.ana.fold import Fold 
-
-import matplotlib.pyplot as mp
-from opticks.ana.fold import Fold
-from opticks.sysrap.sframe import sframe , X, Y, Z
-from opticks.CSG.Values import Values 
-from opticks.ana.pvplt import mpplt_simtrace_selection_line, mpplt_hist, mpplt_parallel_lines_auto, mpplt_add_shapes
-from opticks.ana.eget import efloatarray_
-
-
-if __name__ == '__main__':
-
-    #fmt = '[%(asctime)s] p%(process)s {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s'
-    fmt = '{%(pathname)s:%(lineno)d} %(levelname)s - %(message)s'
-    logging.basicConfig(level=logging.INFO, format=fmt)
-
-    SYMBOLS = os.environ.get("SYMBOLS", None)
-    FOLD = os.environ.get("FOLD", None)
-
-    if SYMBOLS is None and not FOLD is None:
-        s = Fold.Load(symbol="s")
-        t = None
-        fr = s.sframe
-        s_label = os.environ["GEOM"]
-        SYMBOLS = "S" 
-        sv = Values.Find("$FOLD", symbol="sv") if not s_label is None else None
-    elif not SYMBOLS is None:
-        log.info("SYMBOLS defined %s proceed with Fold.MultiLoad", SYMBOLS)
-        ff = Fold.MultiLoad()
-        log.info(" ff %s " % str(ff))
-        assert len(ff) > 0 
-        frs = list(filter(None, map(lambda f:f.sframe, ff)))
-        assert len(frs) > 0 
-        fr = frs[0]       ## HMM: picking first frame, maybe need to form composite bbox from all frames ?
-        sv = None
-    else:
-        assert 0 
-    pass
-
-    fig, ax = fr.mp_subplots(mp)  
-
-    if not s is None:
-        s_hit = s.simtrace[:,0,3]>0 
-        s_pos = s.simtrace[s_hit][:,1,:3]
-
-        ## investigate unexpected top cap intersects : FIXED z2cap TYPO
-        ## 
-        ##                                                                    intersect pos x > 120.  t > 0 
-        ## e = np.logical_and( s.simtrace[:,2,0] > 100., np.logical_and( s.simtrace[:,1,0] > 120. , s.simtrace[:,0,3]>0 )) 
-        ## 
-        ## e_ori = s.simtrace[e][:100,2,:3]
-        ## e_dir = s.simtrace[e][:100,3,:3]
-        ## fr.mp_scatter(e_ori, label="e_ori", s=2 ) 
-        ## fr.mp_arrow(  e_ori, 10*e_dir, label="e_ori,e_dir", s=2 ) 
-    pass
-
-    if s_label.startswith("nmskSolidMaskVirtual") and not sv is None: 
-        r1=sv.get("SolidMask.SolidMaskVirtual.rOuter2.mask_radiu_virtual")
-        r2=sv.get("SolidMask.SolidMaskVirtual.rOuter3.mask_radiu_virtual/2")
-        z1=sv.get("SolidMask.SolidMaskVirtual.zPlane2.htop_out/2")
-        z2=sv.get("SolidMask.SolidMaskVirtual.zPlane3.htop_out+MAGIC_virtual_thickness")
-        z0=(z2*r1-z1*r2)/(r1-r2)
-        ax.set_ylim( -240, z0+50 )
-    pass
-
-    mpplt_add_shapes(ax)  # ELLIPSE0 ELLIPSE1 RECTANGLE0 RECTANGLE1
-
-
-    if not s is None and "UNEXPECTED" in os.environ:  
-
-        if s_label.startswith("nmskSolidMaskVirtual"): 
-            w_label, w = "apex glancers",  np.logical_and( np.abs(s.simtrace[:,1,0]) < 220, np.abs(s.simtrace[:,1,2]-98) < 1 ) 
-            #w_label, w = "quadratic precision loss", np.logical_and( np.abs(s.simtrace[:,1,0] - (-214)) < 5, np.abs(s.simtrace[:,1,2] - (115)) < 5 )
- 
-            w_simtrace = s.simtrace[w]
-            w_path = "/tmp/simtrace_sample.npy"
-            np.save(w_path, w_simtrace)
-        else:
-            w = np.logical_and( np.abs(s.simtrace[:,1,2]) > 0.20 , s.simtrace[:,0,3]>0 )  
-            w_simtrace = s.simtrace[w][::10]
-        pass
-        log.info("UNEXPECTED w_simtrace : %s " % str(w_simtrace.shape))
-        w_ori = w_simtrace[:,2,:3]
-        fr.mp_scatter(w_ori, label="w_ori", s=1 )
-        mpplt_simtrace_selection_line(ax, w_simtrace, axes=fr.axes, linewidths=2)
-    pass
-
-    if not s is None:
-        mpplt_parallel_lines_auto( ax, fr.bbox.T, fr.axes, linestyle="dashed" )
-    pass
-    if not s is None and hasattr(s,"genstep") and "GS" in os.environ:
-        s_gs  = s.genstep[:,5,:3]  
-        fr.mp_scatter(s_gs, label="s_gs", s=1 )
-    pass
- 
-    if not s is None and hasattr(s,"simtrace_selection"):
-       sts = s.simtrace_selection 
-    elif not s is None and "SELECTION" in os.environ:
-        #w = np.logical_and( s.simtrace[:,0,3]>0, np.logical_and( s.simtrace[:,1,Z] > -38.9, s.simtrace[:,1,Z] < -20. ))
-        w = s.simtrace[:,1,X] > 264.5
-        wi = np.where(w)[0]  
-        sts = s.simtrace[w][:50]
-    else:
-        sts = None
-    pass  
-
-    if not sts is None:
-        mpplt_simtrace_selection_line(ax, sts, axes=fr.axes, linewidths=2)
-    pass
-
-    d = getattr(s, "CSGDebug_Cylinder", None) if not s is None else None
-
-    log.info("SYMBOLS %s " % str(SYMBOLS))
-    if not SYMBOLS is None:
-        for A in list(SYMBOLS):
-            a = A.lower()
-            if hasattr(builtins, a):
-                fold = getattr(builtins, a)
-                label = getattr(builtins, "%s_label" % a )
-
-            elif a in globals():
-                fold = globals()[a]
-                label = globals()["%s_label" % a]
-            else:
-                log.fatal(" a %s not in builtins or globals " % a )
-                assert 0 
-            pass
-            a_offset = efloatarray_("%s_OFFSET" % A, "0,0,0")
-            log.info("A %s a %s label %s" % ( A, a, label ) )
-            a_hit = fold.simtrace[:,0,3]>0 
-            a_pos = a_offset + fold.simtrace[a_hit][:,1,:3]
-            label = label.split("__")[0] if "__" in label else label
-            fr.mp_scatter(a_pos, label="%s:%s" % (A,label), s=1 )
-            pass
-        pass
-    pass
-    fr.mp_legend()
-    fig.show()
-pass
-
-
diff --git a/CSGOptiX/cxs_min.py b/CSGOptiX/cxs_min.py
deleted file mode 100644
index bfbd5690be..0000000000
--- a/CSGOptiX/cxs_min.py
+++ /dev/null
@@ -1,177 +0,0 @@
-#!/usr/bin/env python
-
-import os, logging, numpy as np
-log = logging.getLogger(__name__)
-
-print("[from opticks.sysrap.sevt import SEvt, SAB")
-from opticks.sysrap.sevt import SEvt, SAB
-print("]from opticks.sysrap.sevt import SEvt, SAB")
-
-
-
-
-TEST = os.environ.get("TEST","")
-PLOT = os.environ.get("PLOT","scatter")
-GLOBAL = int(os.environ.get("GLOBAL","0")) == 1
-MODE = int(os.environ.get("MODE","3"))
-SEL = int(os.environ.get("SEL","0"))
-
-print("before pvplt import MODE:%d " % MODE)
-
-if MODE in [2,3]:
-    from opticks.ana.pvplt import *
-    # HMM this import overrides MODE, so need to keep defaults the same
-pass
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    print("GLOBAL:%d MODE:%d SEL:%d" % (GLOBAL,MODE, SEL))
-
-    a = SEvt.Load("$AFOLD", symbol="a")
-    print(repr(a))
-
-    if "BFOLD" in os.environ:
-        b = SEvt.Load("$BFOLD", symbol="b")
-        print(repr(b))
-        ab = SAB(a,b)
-        print(repr(ab))
-    pass
-
-
-    e = a
-
-    qtab = e.minimal_qtab()  # requires seq array saving to be useful
-    print("qtab")
-    print(qtab)
-
-
-    if hasattr(e.f, 'record'):
-        pp = e.f.record[:,:,0,:3].reshape(-1,3)
-        found = "record"
-    elif hasattr(e.f, 'hit'):
-        pp = e.f.hit[:,0,:3]
-        found = "hit"
-    elif hasattr(e.f, 'photon'):
-        pp = e.f.photon[:,0,:3]
-        found = "photon"
-    elif hasattr(e.f, 'inphoton'):
-        pp = e.f.inphoton[:,0,:3]
-        found = "inphoton"
-    elif hasattr(e.f, 'genstep'):
-        pp = e.f.genstep[:,1,:3]
-        found = "genstep"
-    else:
-        pp = None
-        found = "NONE"
-        pass
-    pass
-
-    assert not pp is None
-
-    gpos = np.ones( [len(pp), 4 ] )
-    gpos[:,:3] = pp
-    lpos = np.dot( gpos, e.f.sframe.w2m )
-    upos = gpos if GLOBAL else lpos
-
-    if MODE in [0,1]:
-        print("not plotting as MODE %d in environ" % MODE )
-    elif MODE == 2:
-        label = "%s : " % ( e.f.base.replace("/data/blyth/opticks/","") )
-        label +=  " : %s " % PLOT
-
-        expl = ""
-        if PLOT.startswith("seqnib") and hasattr(e.f, "seqnib"):
-            expl = "Photon History Step Counts Occurrence in single 1M photon event"
-        elif PLOT.startswith("thit") and hasattr(e.f, "hit"):
-            expl = "Histogram hit times[ns] of all(and step tail) : from  1M photon TORCH event"
-        pass
-        title = "\n".join([label, expl])
-        pl = mpplt_plotter(label=title)
-        fig, axs = pl
-        assert len(axs) == 1
-        ax = axs[0]
-    elif MODE == 3:
-
-        label = "%s : found %s " % ( e.f.base, found )
-        print(label)
-        pl = pvplt_plotter(label)
-        pvplt_viewpoint(pl)   # sensitive to EYE, LOOK, UP envvars
-        pvplt_frame(pl, e.f.sframe, local=not GLOBAL )
-    pass
-
-
-    H,V = 0,2  # X, Z
-
-    if SEL == 1:
-        sel = np.logical_and( np.abs(upos[:,H]) < 500, np.abs(upos[:,V]) < 500 )
-        spos = upos[sel]
-    else:
-        spos = upos
-    pass
-
-    if MODE == 2:
-
-        if PLOT.startswith("scatter"):
-            ax.scatter( spos[:,H], spos[:,V], s=0.1 )
-        elif PLOT.startswith("seqnib") and hasattr(e.f, "seqnib"):
-            seqnib = e.f.seqnib
-
-            bounce = np.arange(len(seqnib))
-            ax.set_aspect('auto')
-            ax.plot( bounce, seqnib )
-            ax.scatter( bounce, seqnib )
-            ax.set_ylabel("Photon counts for step points (0->31)", fontsize=20 )
-
-            cs_seqnib = np.cumsum(seqnib)
-            ax2 = ax.twinx()
-            ax2.plot( bounce, cs_seqnib, linestyle="dashed" )
-            ax2.set_ylabel( "Cumulative counts rising to total of 1M photons", fontsize=20 )
-        elif PLOT.startswith("thit") and hasattr(e.f, "hit"):
-            hit_time = e.f.hit[:,0,3]
-            mn_hit_time = hit_time.min()
-            mx_hit_time = hit_time.max()
-            bins = np.linspace( mn_hit_time, mx_hit_time, 100 )
-
-            hit_time_n,_  = np.histogram(hit_time, bins=bins )
-            ax.set_aspect('auto')
-            ax.plot( bins[:-1], hit_time_n, drawstyle="steps-mid", label="Simulated Hit time [ns]" )
-
-            hit_idx = e.f.hit.view(np.uint32)[:,3,2] & 0x7fffffff
-            hit_nib = a.f.seqnib[hit_idx]   # nibbles of the hits
-
-            cut = 23
-            hit_time_sel = hit_time[hit_nib>cut]
-            sel_time_n, _ = np.histogram(hit_time_sel, bins=bins)
-
-            ax.plot( bins[:-1], sel_time_n, drawstyle="steps-mid", label="Simulated Hit time [ns] for step points > %d " % cut  )
-
-            ax.set_ylabel("Photon counts in simulated time[ns] bins", fontsize=20)
-            ax.set_xlabel("Simulated time[ns]", fontsize=20)
-
-            ax.set_yscale('log')
-            ax.legend()
-            # need the seqnib of each photon so can check times of the big seqnib
-            # PLOT=thit MODE=2 ~/o/cxs_min.sh
-        else:
-            print("PLOT:%s unhandled" % PLOT)
-        pass
-    elif MODE == 3:
-        if PLOT.startswith("scatter"):
-            pl.add_points(spos[:,:3])
-        else:
-            pass
-        pass
-    else:
-        pass
-    pass
-
-    if MODE == 2:
-        fig.show()
-    elif MODE == 3:
-        pl.show()
-    pass
-pass
-
-
-
-
diff --git a/CSGOptiX/cxs_min.sh b/CSGOptiX/cxs_min.sh
deleted file mode 100755
index 79139c2a79..0000000000
--- a/CSGOptiX/cxs_min.sh
+++ /dev/null
@@ -1,739 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-cxs_min.sh : minimal executable and script for shakedown
-============================================================
-
-Uses ~oneline main::
-
-     CSGOptiX::SimulateMain();
-
-Usage::
-
-    ~/o/cxs_min.sh
-    ~/o/cxs_min.sh info
-    ~/o/cxs_min.sh run       ## create SEvt
-    ~/o/cxs_min.sh report    ## summarize SEvt metadata
-
-
-
-This script is used for many purposes in development and testing
-making it require understanding and often editing before use,
-plus the setting of the TEST envvar to select the type of
-test to perform.
-
-This script runs the CSGOptiXSMTest executable which has no Geant4 dependency,
-so it is restricted to purely optical running and loads the persisted CSGFoundry
-from ~/.opticks/GEOM/$GEOM/CSGFoundry using GEOM envvar
-set by ~/.opticks/GEOM/GEOM.sh
-
-This script is most commonly used for "torch" running where initial photons
-are generated in simple patterns and with numbers of photons configured by the
-script. Input photons and input gensteps can also be configured. Small scans
-simulating multiple events with varying numbers of photons can also be configured,
-often simply by selecting a TEST envvar value.
-
-
-Examples::
-
-    TEST=vvlarge_evt ~/o/cxs_min.sh
-         ## caution tries to simulate a billion photons
-         ## for JUNO writes ~12GB of hits
-
-
-
-Debug::
-
-    BP=SEvt::SEvt               ~/opticks/CSGOptiX/cxs_min.sh
-    BP=SEvent::MakeTorchGenstep ~/opticks/CSGOptiX/cxs_min.sh
-
-Analysis/Plotting::
-
-    ~/o/cxs_min.sh grab
-    EVT=A000 ~/o/cxs_min.sh ana
-
-    MODE=2 SEL=1 ~/o/cxs_min.sh ana
-    EVT=A005     ~/o/cxs_min.sh ana
-    EVT=A010     ~/o/cxs_min.sh ana
-
-    PLOT=scatter MODE=3 ~/o/cxs_min.sh pvcap
-
-Monitor for GPU memory leaks::
-
-    ~/o/sysrap/smonitor.sh build_run  # start monitor
-
-    TEST=large_scan ~/o/cxs_min.sh
-
-    # CTRL-C smonitor.sh session sending SIGINT to process which saves smonitor.npy
-
-    ~/o/sysrap/smonitor.sh grab  ## back to laptop
-    ~/o/sysrap/smonitor.sh ana   ## plot
-
-
-pdb1
-   ipython cxs_min.py
-
-pdb0
-   as pdb1 with MODE=0 for no pyvista or matplotlib usage
-   useful for loading/examining the SEvt with ipython
-   from anywhere
-
-EOU
-}
-
-vars=""
-SDIR=$(dirname $(realpath $BASH_SOURCE))
-
-vars="$vars BASH_SOURCE SDIR"
-
-defarg=run_report_info
-
-[ -n "$BP" ] && defarg=dbg
-[ -n "$PLOT" ] && defarg=ana
-
-arg=${1:-$defarg}
-allarg=info_env_fold_run_dbg_meta_report_grab_grep_gevt_du_pdb1_pdb0_AB_ana_pvcap_pvpub_mpcap_mppub
-vars="$vars defarg arg allarg"
-
-
-bin=CSGOptiXSMTest
-script=$SDIR/cxs_min.py
-script_AB=$SDIR/cxs_min_AB.py
-vars="$vars bin script script_AB"
-
-
-External_CFBaseFromGEOM=${GEOM}_CFBaseFromGEOM
-if [ -n "$GEOM" -a -n "${!External_CFBaseFromGEOM}" -a -d "${!External_CFBaseFromGEOM}" -a -f "${!External_CFBaseFromGEOM}/CSGFoundry/prim.npy" ]; then
-    echo $BASH_SOURCE - External GEOM setup detected
-    vv="External_CFBaseFromGEOM ${External_CFBaseFromGEOM}"
-    for v in $vv ; do printf "%40s : %s \n" "$v" "${!v}" ; done
-else
-    ## development source tree usage : where need to often switch between geometries
-    source ~/.opticks/GEOM/GEOM.sh   # sets GEOM envvar, use GEOM bash function to setup/edit
-    #export ${GEOM}_CFBaseFromGEOM=$HOME/.opticks/GEOM/$GEOM
-fi
-
-vars="$vars GEOM"
-
-tmp=/tmp/$USER/opticks
-export TMP=${TMP:-$tmp}
-export EVT=${EVT:-A000}
-export BASE=$TMP/GEOM/$GEOM
-export BINBASE=$BASE/$bin
-export SCRIPT=$(basename $BASH_SOURCE)
-
-vars="$vars TMP EVT BASE BINBASE SCRIPT"
-
-vars="$vars ${GEOM}_CFBaseFromGEOM ${GEOM}_GDMLPathFromGEOM"
-
-# pulled out complicated Resolve_CFBaseFromGEOM.sh from here
-# instead rely on user to setup geometry access envvar
-# in GEOM.sh or elsewhere
-
-knobs()
-{
-   type $FUNCNAME
-
-   local exceptionFlags
-   local debugLevel
-   local optLevel
-
-   #exceptionFlags=STACK_OVERFLOW
-   exceptionFlags=NONE
-
-   #debugLevel=DEFAULT
-   debugLevel=NONE
-   #debugLevel=FULL
-
-   #optLevel=DEFAULT
-   #optLevel=LEVEL_0
-   optLevel=LEVEL_3
-
-
-   #export PIP__max_trace_depth=1
-   export PIP__CreatePipelineOptions_exceptionFlags=$exceptionFlags # NONE/STACK_OVERFLOW/TRACE_DEPTH/USER/DEBUG
-   export PIP__CreateModule_debugLevel=$debugLevel  # DEFAULT/NONE/MINIMAL/MODERATE/FULL   (DEFAULT is MINIMAL)
-   export PIP__linkPipeline_debugLevel=$debugLevel  # DEFAULT/NONE/MINIMAL/MODERATE/FULL
-   export PIP__CreateModule_optLevel=$optLevel      # DEFAULT/LEVEL_0/LEVEL_1/LEVEL_2/LEVEL_3
-
-   #export Ctx=INFO
-   #export PIP=INFO
-   #export CSGOptiX=INFO
-
-
-   #export NPFold__substamp_DUMP=1
-
-
-}
-
-
-#version=0
-#version=1
-version=98   ## set to 98 for low stats debugging
-
-export VERSION=${VERSION:-$version}   ## see below currently using VERSION TO SELECT OPTICKS_EVENT_MODE
-## VERSION CHANGES OUTPUT DIRECTORIES : SO USEFUL TO ARRANGE SEPARATE STUDIES
-
-vars="$vars version VERSION"
-
-
-#test=debug
-#test=ref1
-#test=ref5
-#test=ref8
-#test=ref10
-#test=ref10_multilaunch
-#test=input_genstep
-#test=input_genstep_muon
-
-#test=input_photon_chimney
-#test=input_photon_nnvt
-#test=input_photon_target
-#test=input_photon_wp_pmt
-#test=input_photon_wp_pmt_side
-#test=input_photon_wp_pmt_semi
-#test=input_photon_s_pmt
-#test=input_photon_poolcover
-test=input_photon_poolcover_refine
-
-#test=large_evt
-#test=vlarge_evt
-#test=vvlarge_evt
-#test=medium_scan
-
-export TEST=${TEST:-$test}
-
-
-ctx=${OPTICKS_EVENT_CONTEXT:-Debug_Philox}
-
-export OPTICKS_EVENT_NAME=${ctx}_${TEST}
-
-
-opticks_event_reldir=ALL${VERSION:-0}_${OPTICKS_EVENT_NAME:-none}   ## matches SEventConfig::_DefaultEventReldir OPTICKS_EVENT_RELDIR
-export OPTICKS_EVENT_RELDIR='ALL${VERSION:-0}_${OPTICKS_EVENT_NAME:-none}'  ## this is the default in SEventConfig
-# opticks_event_reldir is resolved here, OPTICKS_EVENT_RELDIR resolved by SEvt/SEventConfig
-
-vars="$vars test TEST opticks_event_reldir OPTICKS_EVENT_RELDIR"
-
-case $TEST in
-ref10_multilaunch) alt_TEST=ref10_onelaunch ;;
-ref10_onelaunch)   alt_TEST=ref10_multilaunch ;;
-esac
-
-alt_opticks_event_reldir=ALL${VERSION:-0}_${alt_TEST}
-vars="$vars alt_TEST alt_opticks_event_reldir"
-
-
-
-export LOGDIR=$BINBASE/$opticks_event_reldir
-export AFOLD=$BINBASE/$opticks_event_reldir/$EVT
-export STEM=${opticks_event_reldir}_${PLOT}
-
-#export BFOLD=$BASE/G4CXTest/ALL0/$EVT
-#export BFOLD=$BASE/jok-tds/ALL0/A001
-#BFOLD_NOTE="comparison with A from another executable"
-
-#export BFOLD=$BINBASE/$alt_opticks_event_reldir/$EVT   # comparison with alt_TEST
-#BFOLD_NOTE="comparison with alt_TEST:$alt_TEST"
-BFOLD_NOTE="defining BFOLD makes python script do SAB comparison"
-
-mkdir -p $LOGDIR
-cd $LOGDIR
-LOGFILE=$bin.log
-
-vars="$vars LOGDIR AFOLD BFOLD BFOLD_NOTE STEM LOGFILE"
-
-
-case $VERSION in
- 0) opticks_event_mode=Minimal ;;
- 1) opticks_event_mode=Hit ;;
- 2) opticks_event_mode=HitPhoton ;;
- 3) opticks_event_mode=HitPhoton ;;
- 4) opticks_event_mode=HitPhotonSeq ;;
- 5) opticks_event_mode=HitSeq ;;
-98) opticks_event_mode=DebugLite ;;
-99) opticks_event_mode=DebugHeavy ;;  # formerly StandardFullDebug
-esac
-
-vars="$vars opticks_event_mode"
-
-
-if [ "$TEST" == "debug" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=1
-   opticks_num_photon=100
-   opticks_running_mode=SRM_TORCH
-   #opticks_max_photon=M1
-
-elif [ "$TEST" == "ref1" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=10
-   opticks_num_photon=M1
-   opticks_running_mode=SRM_TORCH
-   opticks_max_slot=M1
-
-elif [ "$TEST" == "ref5" -o "$TEST" == "ref6" -o "$TEST" == "ref7" -o "$TEST" == "ref8" -o "$TEST" == "ref9" -o "$TEST" == "ref10" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=1
-   opticks_num_photon=M${TEST:3}
-   opticks_running_mode=SRM_TORCH
-   opticks_max_slot=M${TEST:3}
-
-elif [ "$TEST" == "refX" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=1
-   opticks_num_photon=${X:-7500000}
-   opticks_running_mode=SRM_TORCH
-   opticks_max_slot=$opticks_num_photon
-
-elif [ "$TEST" == "ref10_multilaunch" -o "$TEST" == "ref10_onelaunch" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=10
-   opticks_num_photon=M10
-   opticks_running_mode=SRM_TORCH
-
-   #opticks_max_photon=M10
-   #opticks_max_curand=0    # zero loads all states : ready for whopper XORWOW running
-   #opticks_max_curand=M10  # non-zero loads the specified number : this not relevant for PHILOX with default G1 1billion states
-
-   case $TEST in
-      *multilaunch) opticks_max_slot=M1 ;;     ## causes M10 to be done in 10 launches
-        *onelaunch) opticks_max_slot=M10 ;;
-   esac
-   ## Normally leave max_slot as default zero indicating to pick max_slot according to VRAM.
-   ## Are specifying here to compare multilaunch and onelaunch running of the same photons.
-
-elif [ "$TEST" == "tiny_scan" ]; then
-
-   opticks_num_event=10
-   opticks_num_genstep=1x10
-   opticks_num_photon=K1:10
-   opticks_running_mode=SRM_TORCH
-   #opticks_max_photon=M1
-
-elif [ "$TEST" == "large_scan" ]; then
-
-   opticks_num_event=20
-   opticks_num_genstep=1x20
-   opticks_num_photon=H1:10,M2,3,5,7,10,20,40,60,80,100
-   opticks_running_mode=SRM_TORCH
-   #opticks_max_photon=M100
-
-elif [ "$TEST" == "medium_scan" ]; then
-
-   opticks_num_event=12
-   opticks_num_genstep=1x12
-   opticks_num_photon=M1,1,10,20,30,40,50,60,70,80,90,100  # duplication of M1 is to workaround lack of metadata
-   opticks_running_mode=SRM_TORCH
-   #opticks_max_photon=M100
-
-   # Remember multi-launch needs multiple gensteps in order to slice them up
-   # such that each slice fits into VRAM.
-   # So for big photon counts its vital to use multiple genstep.
-
-
-elif [ "$TEST" == "larger_scan" ]; then
-
-   opticks_num_event=22
-   opticks_num_genstep=1x22
-   opticks_num_photon=M1,1,10,20,30,40,50,60,70,80,90,100,110,120,130,140,150,160,170,180,190,200  # duplication of M1 is to workaround lack of metadata
-   opticks_running_mode=SRM_TORCH
-
-   #opticks_max_photon=M200
-
-
-elif [ "$TEST" == "large_evt" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=10
-   opticks_num_photon=M200         ## OOM with TITAN RTX 24G, avoided by multi-launch sliced genstep running
-   opticks_running_mode=SRM_TORCH
-
-   #opticks_max_photon=M200
-   #opticks_max_slot=0              ## zero -> SEventConfig::SetDevice determines MaxSlot based on VRAM
-
-elif [ "$TEST" == "vlarge_evt" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=20
-   opticks_num_photon=M500
-   opticks_running_mode=SRM_TORCH
-   #opticks_max_photon=M200        ## G1 default so no need to set
-   #opticks_max_slot=0              ## zero -> SEventConfig::SetDevice determines MaxSlot based on VRAM
-
-elif [ "$TEST" == "vvlarge_evt" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=40
-   opticks_num_photon=G1
-   opticks_running_mode=SRM_TORCH
-
-elif [ "$TEST" == "input_genstep" ]; then
-
-   opticks_num_event=1000
-   opticks_num_genstep=    # ignored
-   opticks_num_photon=     # ignored ?
-   opticks_running_mode=SRM_INPUT_GENSTEP
-
-   #opticks_max_photon=M1
-
-elif [ "$TEST" == "input_genstep_muon" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=    # ignored
-   opticks_num_photon=     # ignored ?
-   opticks_running_mode=SRM_INPUT_GENSTEP
-
-   #opticks_max_slot=H1     ##
-   opticks_max_slot=M1     ##
-   #opticks_max_slot=M5    ##
-   #opticks_max_slot=M10   ## 3 launches
-   #opticks_max_slot=M1    ## ~34 launches
-   #opticks_max_slot=0     ## whole-in-one
-
-
-elif [ "${TEST:0:12}" == "input_photon" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=    # ignored
-   opticks_num_photon=     # ignored ?
-   opticks_running_mode=SRM_INPUT_PHOTON
-   opticks_max_slot=M3
-
-   if [ "${TEST:12}" == "_chimney" ]; then
-
-      sevt__input_photon_dir=$TMP/SGenerate__test
-
-      opticks_input_photon=SGenerate_ph_disc_K1.npy
-
-      opticks_input_photon_frame=sChimneyLS:0:-2
-      #opticks_input_photon_frame=sChimneyAcrylic
-
-   elif [ "${TEST:12}" == "_nnvt" ]; then
-
-      #sevt__input_photon_dir=/cvmfs/opticks.ihep.ac.cn/.opticks/InputPhotons
-      sevt__input_photon_dir=$HOME/.opticks/InputPhotons
-
-      opticks_input_photon=RainXZ_Z230_100k_f8.npy
-      #opticks_input_photon=RainXZ_Z230_1000_f8.npy      ## ok
-      #opticks_input_photon=RainXZ_Z230_10k_f8.npy       ## ok
-      #opticks_input_photon=RainXZ_Z230_X700_10k_f8.npy  ## X700 to illuminate multiple PMTs
-
-      opticks_input_photon_frame=NNVT:0:0
-      #opticks_input_photon_frame=NNVT:0:50
-      #opticks_input_photon_frame=NNVT:0:1000
-
-   elif [ "${TEST:12}" == "_wp_pmt" ]; then
-
-      sevt__input_photon_dir=$HOME/.opticks/InputPhotons
-      opticks_input_photon=RainXZ_Z230_100k_f8.npy
-      opticks_input_photon_frame=PMT_20inch_veto:0:1000
-
-      #export PIDX=99999
-
-   elif [ "${TEST:12}" == "_wp_pmt_side" ]; then
-
-      sevt__input_photon_dir=$HOME/.opticks/InputPhotons
-      opticks_input_photon=SideZX_X300_100k_f8.npy
-      opticks_input_photon_frame=PMT_20inch_veto:0:1000
-
-   elif [ "${TEST:12}" == "_wp_pmt_semi" ]; then
-
-      sevt__input_photon_dir=$HOME/.opticks/InputPhotons
-      opticks_input_photon=SemiCircleXZ_R-500_100k_f8.npy
-      opticks_input_photon_frame=PMT_20inch_veto:0:1000
-
-   elif [ "${TEST:12}" == "_poolcover" -o "${TEST:12}" == "_poolcover_refine" ]; then
-
-      sevt__input_photon_dir=$HOME/.opticks/InputPhotons
-      #opticks_input_photon=UpXZ1000_f8.npy
-      opticks_input_photon=CircleXZ_R500_100k_f8.npy
-      #opticks_input_photon=CircleXZ_R10_361_f8.npy
-      #opticks_input_photon_frame=3345.569,20623.73,21500
-      opticks_input_photon_frame=3345.569,20623.73,21000
-      #export PIDX=99999
-
-      export SEvt__transformInputPhoton_VERBOSE=1
-      export CSGFoundry__getFrame_VERBOSE=1
-      export CSGFoundry__getFrameE_VERBOSE=1
-
-      if [ "${TEST/refine}" != "$TEST" ]; then
-         export OPTICKS_PROPAGATE_REFINE=1
-      else
-         unset OPTICKS_PROPAGATE_REFINE
-      fi
-
-
-   elif [ "${TEST:12}" == "_s_pmt" ]; then
-
-      sevt__input_photon_dir=$HOME/.opticks/InputPhotons
-      opticks_input_photon=RainXZ_Z230_X25_100k_f8.npy
-      opticks_input_photon_frame=PMT_3inch:0:0
-
-   elif [ "${TEST:12}" == "_target" ]; then
-
-       #opticks_input_photon=GridXY_X700_Z230_10k_f8.npy
-       #opticks_input_photon=GridXY_X1000_Z1000_40k_f8.npy
-
-       #opticks_input_photon_frame=-1
-       #opticks_input_photon_frame=sWorld:0:0
-       opticks_input_photon_frame=sTarget
-
-   else
-       echo $BASH_SOURCE : ERROR TEST [$TEST] SUFFIX AFTER input_photon [${TEST:12}] IS NOT HANDLED
-       exit 1
-   fi
-
-else
-
-   echo $BASH_SOURCE : ERROR TEST $TEST IS NOT HANDLED
-   exit 1
-
-fi
-
-vars="$vars opticks_num_event opticks_num_genstep opticks_num_photon opticks_running_mode opticks_max_slot"
-
-
-#opticks_running_mode=SRM_DEFAULT
-#opticks_running_mode=SRM_INPUT_PHOTON
-#opticks_running_mode=SRM_GUN
-
-
-opticks_start_index=0
-#opticks_max_bounce=31
-opticks_max_bounce=63
-opticks_integration_mode=1
-
-
-
-#opticks_hit_mask=SD
-opticks_hit_mask=EC
-export OPTICKS_HIT_MASK=${OPTICKS_HIT_MASK:-$opticks_hit_mask}
-
-export OPTICKS_NUM_EVENT=${OPTICKS_NUM_EVENT:-$opticks_num_event}
-export OPTICKS_NUM_GENSTEP=${OPTICKS_NUM_GENSTEP:-$opticks_num_genstep}
-export OPTICKS_NUM_PHOTON=${OPTICKS_NUM_PHOTON:-$opticks_num_photon}
-
-export OPTICKS_RUNNING_MODE=${OPTICKS_RUNNING_MODE:-$opticks_running_mode}   # SRM_TORCH/SRM_INPUT_PHOTON/SRM_INPUT_GENSTEP
-export OPTICKS_EVENT_MODE=${OPTICKS_EVENT_MODE:-$opticks_event_mode}         # what arrays are saved eg Hit,HitPhoton,HitPhotonSeq
-
-export OPTICKS_MAX_PHOTON=${OPTICKS_MAX_PHOTON:-$opticks_max_photon}         # no needed much now with PHILOX and multi-launch
-
-export OPTICKS_MAX_BOUNCE=${OPTICKS_MAX_BOUNCE:-$opticks_max_bounce}
-export OPTICKS_START_INDEX=${OPTICKS_START_INDEX:-$opticks_start_index}
-export OPTICKS_INTEGRATION_MODE=${OPTICKS_INTEGRATION_MODE:-$opticks_integration_mode}
-
-
-vars="$vars version VERSION opticks_event_mode OPTICKS_EVENT_MODE OPTICKS_NUM_PHOTON OPTICKS_NUM_GENSTEP OPTICKS_MAX_PHOTON OPTICKS_NUM_EVENT OPTICKS_RUNNING_MODE"
-
-export OPTICKS_MAX_CURAND=$opticks_max_curand  ## SEventConfig::MaxCurand only relevant to XORWOW
-export OPTICKS_MAX_SLOT=$opticks_max_slot      ## SEventConfig::MaxSlot
-vars="$vars OPTICKS_MAX_CURAND OPTICKS_MAX_SLOT"
-
-
-if [ "$OPTICKS_RUNNING_MODE" == "SRM_INPUT_GENSTEP" ]; then
-
-    #igs=$BASE/jok-tds/ALL0/A000/genstep.npy
-    #igs=$BASE/jok-tds/ALL0/A%0.3d/genstep.npy
-    igs=$HOME/.opticks/crash_muon_igs.npy
-
-    if [ "${igs/\%}" != "$igs" ]; then
-        igs0=$(printf "$igs" 0)
-    else
-        igs0=$igs
-    fi
-    [ ! -f "$igs0" ] && echo $BASH_SOURCE : FATAL : NO SUCH PATH : igs0 $igs0 igs $igs && exit 1
-    export OPTICKS_INPUT_GENSTEP=$igs
-    export OPTICKS_START_INDEX=6   ## enabled reproducing photons from original eventID 6 from the igs
-
-
-elif [ "$OPTICKS_RUNNING_MODE" == "SRM_INPUT_PHOTON" ]; then
-
-    ## cf with ipcv : ~/j/InputPhotonsCheck/InputPhotonsCheck.sh
-    # SEventConfig
-    export SEvt__INPUT_PHOTON_DIR=${SEvt__INPUT_PHOTON_DIR:-$sevt__input_photon_dir}
-    export OPTICKS_INPUT_PHOTON=${OPTICKS_INPUT_PHOTON:-$opticks_input_photon};
-    export OPTICKS_INPUT_PHOTON_FRAME=${OPTICKS_INPUT_PHOTON_FRAME:-$opticks_input_photon_frame}
-
-    ippath=${SEvt__INPUT_PHOTON_DIR}/${OPTICKS_INPUT_PHOTON}
-    if [ ! -f "$ippath" ]; then
-        echo $BASH_SOURCE - ERROR ippath [$ippath] DOES NOT EXIST
-        exit 1
-    fi
-
-
-
-    vars="$vars SEvt__INPUT_PHOTON_DIR OPTICKS_INPUT_PHOTON OPTICKS_INPUT_PHOTON_FRAME"
-
-elif [ "$OPTICKS_RUNNING_MODE" == "SRM_TORCH" ]; then
-
-    #export SEvent_MakeGenstep_num_ph=100000  OVERRIDEN BY OPTICKS_NUM_PHOTON
-    #export SEvent__MakeGenstep_num_gs=10     OVERRIDEN BY OPTICKS_NUM_GENSTEP
-
-    #src="rectangle"
-    #src="disc"
-    src="sphere"
-
-    if [ "$src" == "rectangle" ]; then
-        export storch_FillGenstep_pos=0,0,0
-        export storch_FillGenstep_type=rectangle
-        export storch_FillGenstep_zenith=-20,20
-        export storch_FillGenstep_azimuth=-20,20
-    elif [ "$src" == "disc" ]; then
-        export storch_FillGenstep_type=disc
-        export storch_FillGenstep_radius=50
-        export storch_FillGenstep_zenith=0,1       # radial range scale
-        export storch_FillGenstep_azimuth=0,1      # phi segment twopi fraction
-        export storch_FillGenstep_mom=1,0,0
-        export storch_FillGenstep_pos=-80,0,0
-    elif [ "$src" == "sphere" ]; then
-        export storch_FillGenstep_type=sphere
-        export storch_FillGenstep_radius=100    # +ve for outwards
-        export storch_FillGenstep_pos=0,0,0
-        export storch_FillGenstep_distance=1.00 # frac_twopi control of polarization phase(tangent direction)
-    fi
-
-
-
-elif [ "$OPTICKS_RUNNING_MODE" == "SRM_GUN" ]; then
-
-    echo -n
-
-fi
-
-
-
-
-logging(){
-    export CSGFoundry=INFO
-    export CSGOptiX=INFO
-    export QEvt=INFO
-    export QSim=INFO
-    #export SEvt__LIFECYCLE=1
-    export SEvt__GATHER=1
-    export SEvt__SAVE=1
-}
-[ -n "$LOG" ] && logging
-[ -n "$LIFECYCLE" ] && export SEvt__LIFECYCLE=1
-[ -n "$MEMCHECK" ] && export QU__MEMCHECK=1
-[ -n "$MINIMAL"  ] && export SEvt__MINIMAL=1
-[ -n "$MINTIME"  ] && export SEvt__MINTIME=1
-[ -n "$INDEX"  ] && export SEvt__INDEX=1
-[ -n "$RUNMETA"  ] && export SEvt__RUNMETA=1
-[ -n "$CRASH" ] && export CSGOptiX__optixpath=$OPTICKS_PREFIX/ptx/objects-Debug/CSGOptiXOPTIX/CSGOptiX7.ptx
-
-export QRng__init_VERBOSE=1
-export SEvt__MINIMAL=1  ## just output dir
-export SEvt__MINTIME=1  ## minimal timing info from QSim::simulate
-
-#export SEvt__DIRECTORY=1  ## getDir dumping
-#export SEvt__NPFOLD_VERBOSE=1
-#export QSim__simulate_KEEP_SUBFOLD=1
-#export SEvt__transformInputPhoton_VERBOSE=1
-#export CSGFoundry__getFrameE_VERBOSE=1
-#export CSGFoundry__getFrame_VERBOSE=1
-
-
-
-
-if [ "${arg/info}" != "$arg" ]; then
-   for var in $vars ; do printf "%-30s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/env}" != "$arg" ]; then
-    env | grep OPTICKS | perl -n -e 'm/(\S*)=(\S*)/ && printf("%50s : %s\n", $1, $2) ' -
-fi
-
-if [ "${arg/fold}" != "$arg" ]; then
-    echo $AFOLD
-    du -hs $AFOLD/*
-fi
-
-if [ "${arg/run}" != "$arg" -o "${arg/dbg}" != "$arg" ]; then
-
-   knobs
-
-   if [ -f "$LOGFILE" ]; then
-       echo $BASH_SOURCE : run : delete prior LOGFILE $LOGFILE
-       rm "$LOGFILE"
-   fi
-
-   if [ "${arg/run}" != "$arg" ]; then
-       date +"%Y-%m-%d %H:%M:%S.%3N  %N : [$BASH_SOURCE "
-       $bin
-       [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1
-       date +"%Y-%m-%d %H:%M:%S.%3N  %N : ]$BASH_SOURCE "
-   elif [ "${arg/dbg}" != "$arg" ]; then
-       source dbg__.sh
-       dbg__ $bin
-       [ $? -ne 0 ] && echo $BASH_SOURCE dbg error && exit 1
-   fi
-fi
-
-if [ "${arg/meta}" != "$arg" ]; then
-   if [ -f "run_meta.txt" -a -n "$OPTICKS_SCAN_INDEX"  -a -d "$OPTICKS_SCAN_INDEX" ] ; then
-       cp run_meta.txt $OPTICKS_SCAN_INDEX/run_meta.txt
-   fi
-   [ $? -ne 0 ] && echo $BASH_SOURCE meta error && exit 1
-fi
-
-
-if [ "${arg/report}" != "$arg" ]; then
-   sreport
-   [ $? -ne 0 ] && echo $BASH_SOURCE sreport error && exit 1
-fi
-
-if [ "${arg/grab}" != "$arg" ]; then
-    source $OPTICKS_HOME/bin/rsync.sh $LOGDIR
-fi
-
-if [ "${arg/grep}" != "$arg" ]; then
-    source $OPTICKS_HOME/bin/rsync.sh ${LOGDIR}_sreport
-fi
-
-if [ "${arg/gevt}" != "$arg" ]; then
-    source $OPTICKS_HOME/bin/rsync.sh $LOGDIR/$EVT
-fi
-
-
-if [ "${arg/du}" != "$arg" ]; then
-    du -hs $AFOLD/*
-fi
-
-
-if [ "${arg/pdb}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $script
-fi
-
-if [ "${arg/pdz}" != "$arg" ]; then
-    MODE=0 ${IPYTHON:-ipython} --pdb -i $script
-fi
-
-if [ "${arg/AB}" != "$arg" ]; then
-    MODE=0 ${IPYTHON:-ipython} --pdb -i $script_AB
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-    MODE=0 ${PYTHON:-python} $script
-fi
-
-
-
-if [ "$arg" == "pvcap" -o "$arg" == "pvpub" -o "$arg" == "mpcap" -o "$arg" == "mppub" ]; then
-    export CAP_BASE=$AFOLD/figs
-    export CAP_REL=cxs_min
-    export CAP_STEM=$STEM
-    case $arg in
-       pvcap) source pvcap.sh cap  ;;
-       mpcap) source mpcap.sh cap  ;;
-       pvpub) source pvcap.sh env  ;;
-       mppub) source mpcap.sh env  ;;
-    esac
-    if [ "$arg" == "pvpub" -o "$arg" == "mppub" ]; then
-        source epub.sh
-    fi
-fi
diff --git a/CSGOptiX/cxs_min_AB.py b/CSGOptiX/cxs_min_AB.py
deleted file mode 100644
index f4696664a7..0000000000
--- a/CSGOptiX/cxs_min_AB.py
+++ /dev/null
@@ -1,53 +0,0 @@
-#!/usr/bin/env python
-"""
-
-~/o/cxs_min.sh AB 
-
-"""
-
-import os, logging, textwrap, numpy as np
-log = logging.getLogger(__name__)
-
-print("[from opticks.sysrap.sevt import SEvt, SAB")
-from opticks.sysrap.sevt import SEvt, SAB
-print("]from opticks.sysrap.sevt import SEvt, SAB")
-
-
-TEST = os.environ.get("TEST","")
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    a = SEvt.Load("$AFOLD", symbol="a")
-    print(repr(a))
-
-    if "BFOLD" in os.environ:   
-        b = SEvt.Load("$BFOLD", symbol="b") 
-        print(repr(b))
-        ab = SAB(a,b) 
-        print(repr(ab))
-    pass
-
-
-    EXPR = filter(None,textwrap.dedent(r"""
-    np.all( a.f.genstep == b.f.genstep )
-    np.all( a.f.hit == b.f.hit )
-    a.f.hit.shape
-    b.f.hit.shape
-    """).split("\n"))
-
-    for expr in EXPR:
-        val = str(eval(expr)) if not expr.startswith("#") else ""
-        fmt = "%-80s \n%s\n" if len(val.split("\n")) > 1 else "%-80s : %s"
-        print(fmt % (expr, val))
-    pass
-
-    
-
-    e = a 
-    qtab = e.minimal_qtab()
-    print("qtab")
-    print(qtab)
- 
-
diff --git a/CSGOptiX/cxs_min_igs.sh b/CSGOptiX/cxs_min_igs.sh
deleted file mode 100755
index ce950b7cb6..0000000000
--- a/CSGOptiX/cxs_min_igs.sh
+++ /dev/null
@@ -1,227 +0,0 @@
-#!/bin/bash -l 
-usage(){ cat << EOU
-cxs_min_igs.sh : Standalone pure Opticks Optical Propagation using sequence of 1000 input genstep files 
-==========================================================================================================
-
-This was used to hunt down the cause of VRAM memory leak that incremented
-memory usage by 14kb every launch.  See ~/opticks/notes/issues/okjob_GPU_memory_leak.rst 
-
-::
-
-   ~/o/CSGOptiX/cxs_min_igs.sh 
-
-* skipping the launch, dont see the leak : GPU mem stays 1283 MiB
-* with the launch, clear continuous growth from 1283 MiB across 1000 evt 
-* skipping the gather only (not the launch) still leaking the same
-* OPTICKS_MAX_BOUNCE=0 ie only generate, seems no difference to leak 
-* making the launch do "nothing" with rg_dummy : curiously increases the leak by 1.7x
-* scale with MAX_PHOTONS ? NO, changing MAX_PHOTONS makes no difference to size of leak 
-* try default stream for the launch ? perhaps then only one stream for all launches ?
-
-  * BINGO : USING THE DEFAULT STREAM FOR ALL optixLaunch AVOIDS THE LEAK  
-
-
-Forum hunt
-------------
-
-* https://forums.developer.nvidia.com/search?q=optix%20GPU%20memory%20leak%20
-* https://forums.developer.nvidia.com/search?q=optix%20memory%20
-* https://forums.developer.nvidia.com/t/cudastreamcreate-calls-in-optixhello-and-optixtriangle-samples/239688
-
-
-BINGO : Forum message that enabled finding the 14kb/launch VRAM leak
----------------------------------------------------------------------
-
-* https://forums.developer.nvidia.com/t/cudastreamcreate-calls-in-optixhello-and-optixtriangle-samples/239688
-
-CSGOptiX.cc::
-
-    1031     if(DEBUG_SKIP_LAUNCH == false)
-    1032     {
-    1033         CUdeviceptr d_param = (CUdeviceptr)Params::d_param ; ;
-    1034         assert( d_param && "must alloc and upload params before launch");
-    1035 
-    1036         /*
-    1037         // this way leaking 14kb for every launch 
-    1038         CUstream stream ;
-    1039         CUDA_CHECK( cudaStreamCreate( &stream ) );
-    1040         OPTIX_CHECK( optixLaunch( pip->pipeline, stream, d_param, sizeof( Params ), &(sbt->sbt), width, height, depth ) );
-    1041         */
-    1042 
-    1043         // Using the default stream seems to avoid 14k VRAM leak at every launch. 
-    1044         // Does that mean every launch gets to use the same single default stream ?  
-    1045         CUstream stream = 0 ;
-    1046         OPTIX_CHECK( optixLaunch( pip->pipeline, stream, d_param, sizeof( Params ), &(sbt->sbt), width, height, depth ) );
-    1047 
-    1048         CUDA_SYNC_CHECK();
-    1049         // see CSG/CUDA_CHECK.h the CUDA_SYNC_CHECK does cudaDeviceSyncronize
-    1050         // THIS LIKELY HAS LARGE PERFORMANCE IMPLICATIONS : BUT NOT EASY TO AVOID (MULTI-BUFFERING ETC..)  
-    1051     }
-
-
-* https://forums.developer.nvidia.com/t/cudastreamcreate-calls-in-optixhello-and-optixtriangle-samples/239688
-
-kebiro
-Jan 16 '23
-
-Hi,
-
-I have a small suggestion to make.
-
-The above two samples issue a call to cudaStreamCreate() just before the call
-to optixLaunch().
-
-Here is where I see the problem: these two samples in particular are likely to
-act as a starting point for a lot of people, so I imagine that the call to
-cudaStreamCreate() can easily creep into the main loop, potentially causing a
-memory leak if it’s not destroyed. At the very least this happened to me.
-
-So I’d suggest to either add a call to cudaStreamDestroy() just before exiting
-the “launch” block, or just use nullptr as the stream argument for
-optixLaunch().
-
-PS: on a side note I have another question. When running Nsight Compute via
-CLI, it will print context and stream information (e.g. >kernel<, >date<,
-Context 1, Stream 13). Where can I find this information in the GUI?
-
-
-dhart
-Moderator
-Jan 16 '23
-
-Hi @kebiro, welcome!
-
-Thanks for the suggestion, we’ll take it under advisement. We do want to
-explicitly model using CUDA streams and encourage people to know how to work
-with streams as a best practice, but it’s a good point that it’s not being
-explicitly cleaned up in the samples. At the very least maybe we can add a
-comment.
-
-For the Nsight Compute question, I don’t know about context and stream IDs, but
-date and kernel and lots of other stats are available on the Session and
-Details pages, and the kernel to inspect is available in the “Result” drop-down
-near the top left, next to the “Page” drop down.
-
-–
-David.
-
-
-
-Usage
-------
-
-(1) Start eyeballing/recording VRAM usage
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-
-1. Eyeballing nvidia-smi in another terminal::
-
-    nvidia-smi -lms 500
-
-2.  NVML memory recording with smonitor.sh::
-
-    ~/o/sysrap/smonitor.sh       # workstation: ctrl-C after the other terminal GPU process completed
-
-
-(2) Run the pure Opticks simulation using input gensteps (1000 files)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-A large-ish number of events is needed so it runs for long enough (~10 seconds)
-to make a recording.::
-
-   ~/o/CSGOptiX/cxs_min_igs.sh 
-
-
-(3) Stop the smonitor recording
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-ctrl-C the smonitor process writes the smonitor.npy array and exits 
-
-
-(4) Grab the recording and analyse on laptop
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-::
-
-
-    ~/o/sysrap/smonitor.sh grab  # laptop
-
-    START=10 ~/o/sysrap/smonitor.sh ana   # START specifies where to measure gradient from 
-
-    PUB=rg_default_stream START=10 ~/o/sysrap/smonitor.sh ana
-    PUB=rg_default_stream START=10 ~/o/sysrap/smonitor.sh mpcap
-    PUB=rg_default_stream START=10 ~/o/sysrap/smonitor.sh mppub
-
-
-Variations to pin down the leak
-----------------------------------
-
-
-+------------+---------------------------------+--------------------------------------------------------+
-| variation  | (NVML) GPU memory increase      |                                                        |
-|            | across 1000 launches measured   |                                                        |
-|            | at each 0.1 s                   |                                                        |
-+============+=================================+========================================================+
-| rg         |        0.014 GB/s               |                                                        |
-+------------+---------------------------------+--------------------------------------------------------+
-| rg         |        0.016, 0.015 GB/s        | after starting to add eoj cleanup (no change expected) |
-+------------+---------------------------------+--------------------------------------------------------+
-| rg         |        0.014 GB/s               | OPTICKS_MAX_PHOTON M1->k10 makes no difference         |
-+------------+---------------------------------+--------------------------------------------------------+
-| rg         |        0.015 GB/s               | OPTICKS_MAX_PHOTON M1->M10 makes no difference         |
-|            |                                 | other than longer initialization time                  |
-+------------+---------------------------------+--------------------------------------------------------+
-| rg         |        0.000 GB/s               | After adopting the default CUDA Stream for optixLaunch | 
-+------------+---------------------------------+--------------------------------------------------------+
-| rg_dummy   |        0.025, 0.025 GB/s        | 1.7x bigger leak with do-nothing RG ?                  |
-+------------+---------------------------------+--------------------------------------------------------+
-
-
-Question : How to reduce GPU memory increment at each launch ?
-------------------------------------------------------------------
-
-All the geometry+pipeline setup is done once at initialization. 
-So suppose the primary memory thing happening 
-at each launch is arranging stack for all the threads. 
-
-GB and byte differences:: 
-
-    dgb      0.125  (usedGpuMemory_GB[sel][-1]-usedGpuMemory_GB[sel][0]) 
-    db  124780544.000  (usedGpuMemory[sel][-1]-usedGpuMemory[sel][0]) 
-
-    dt        8.760  (t[sel][-1]-t[sel][0]) 
-
-    dgb/dt       0.014  
-    db/dt   14244616.140  
-
-
-Divide by approx 1000 launches, gives ~14kb per launch::
-
-    In [1]: 14244616.140/1000
-    Out[1]: 14244.61614
-
-
-EOU
-}
-
-
-#export OPTIX_FORCE_DEPRECATED_LAUNCHER=1  ## seems no difference re leak 
-#export OPTICKS_NUM_EVENT=3   # reduce from default of 1000 for shakedown
-#export OPTICKS_EVENT_MODE=DebugLite 
-#export QSim__simulate_DEBUG_SKIP_LAUNCH=1 
-#export QSim__simulate_DEBUG_SKIP_GATHER=1 
-#export CSGOptiX__launch_DEBUG_SKIP_LAUNCH=1
-
-#export OPTICKS_MAX_BOUNCE=0  ## seems no difference re leak 
-#export OPTICKS_MAX_PHOTON=M10  ## change from default of 1M 
-
-
-#export PIP__createRaygenPG_DUMMY=1   # replace __raygen__rg with do nothing __raygen__rg_dummy 
-#export PIP=INFO 
-#export LIFECYCLE=1
-
-#export SEvt__MINIMAL=1
-
-
-SDIR=$(dirname $(realpath $BASH_SOURCE))
-TEST=input_genstep $SDIR/cxs_min.sh 
diff --git a/CSGOptiX/cxs_min_scan.sh b/CSGOptiX/cxs_min_scan.sh
deleted file mode 100755
index 8d9d6042bd..0000000000
--- a/CSGOptiX/cxs_min_scan.sh
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/bin/bash -l
-usage(){ cat << EOU
-cxs_min_scan.sh
-=================
-
-This does single event runs with OPTICKS_MAX_BOUNCE varied
-from from 0 to 31 with corresponding OPTICKS_START_INDEX
-such that the actually separate runs are all written
-into a common "run" folder without overwriting event folds.
-
-The run_meta.txt is however overwritten, so used "meta"
-command to copy that into the event folder. But thats in
-the wrong place so would need special casing to use that
-metadata.
-
-How to create plots of launch time vs MAX_BOUNCE
--------------------------------------------------------
-
-::
-
-   ~/opticks/CSGOptiX/cxs_min_scan.sh
-   vi ~/opticks/notes/issues/OPTICKS_MAX_BOUNCE_scanning.rst
-
-Workstation::
-
-    ~/opticks/cxs_min_scan.sh  ## using symbolic link
-
-Laptop::
-
-    ~/opticks/cxs_min.sh grab
-    PLOT=Substamp_ONE_maxb_scan PICK=A ~/opticks/sreport.sh
-    PLOT=Substamp_ONE_maxb_scan PICK=A ~/opticks/sreport.sh mpcap
-    PLOT=Substamp_ONE_maxb_scan PICK=A PUB=expensive_tail ~/opticks/sreport.sh mppub
-
-EOU
-}
-
-SOURCE=$([ -L $BASH_SOURCE ] && readlink $BASH_SOURCE || echo $BASH_SOURCE)
-SDIR=$(cd $(dirname $SOURCE) && pwd)
-script=$SDIR/cxs_min.sh
-
-export OPTICKS_SCANNER=$SOURCE
-export OPTICKS_RUNNING_MODE=SRM_TORCH
-export OPTICKS_NUM_EVENT=1
-export OPTICKS_NUM_PHOTON=H1
-
-ii=$(seq 0 31)
-for i in $ii ; do
-   echo $BASH_SOURCE : i $i
-   export OPTICKS_MAX_BOUNCE=$i
-   export OPTICKS_START_INDEX=$i
-   export OPTICKS_SCAN_INDEX=A$(printf "%0.3d" $i)
-   $script run_meta
-   [ $? -ne 0 ] && echo $BASH_SOURCE : ERROR RUNNING SCRIPT $script && exit 1
-done
-
-exit 0
-
diff --git a/CSGOptiX/cxt_min.py b/CSGOptiX/cxt_min.py
deleted file mode 100644
index 54a20080d8..0000000000
--- a/CSGOptiX/cxt_min.py
+++ /dev/null
@@ -1,601 +0,0 @@
-#!/usr/bin/env python
-"""
-cxt_min.py
-===========
-
-1. loads simtrace SEvt from $MFOLD
-2. checks validity with asserts on the simtrace gensteps
-3. prepare genstep ugrid positions and upos simtrace intersect positions
-   depending on GLOBAL envvar
-4. plot the ugrid and upos points
-
-
-MODE=2
-   use matplotlib 2D plotting, little used now : as lacks flexibility and performance
-
-MODE=3
-   use pyvista 3D plotting.
-   Have previously observed pyvista issue that sometimes start with a blank screen.
-   It is necessary to slighty move the mouse wheel to get the render to appear.
-
-GLOBAL=1
-   leave positions as is resulting in global frame plotting
-
-   With global frame the plane of the genstep rays will often not correspond
-   to the plane of the view causing the geometry to appear squeezed until
-   rotate around with pyvista (MODE:3) manually.
-   For the same reason it is difficult to target using EYE
-   when using GLOBAL frame.
-
-   TODO: provide option to handle EYE,LOOK,UP inputs as local frame
-   even when using GLOBAL frame ?
-
-GLOBAL=0
-   apply the e.f.sframe.w2m (world2model) 4x4 transform to
-   the global positions converting them into the model frame
-
-
-GSGRID=1
-   plot the grid of genstep positions
-
-PRIMTAB=1
-   configure identity coloring and key labelling of intersects to use globalPrimIdx
-   (this succeeded to color both Opticks and Geant4 intersects)
-
-PRIMTAB=0 (default)
-   configure identity coloring and key labelling of intersects to use boundary index
-   (note that when plotting U4Simtrace.h Geant4 simtrace intersects the boundary is
-   currently always zero)
-
-
-KEY=red,white,powderblue
-   select intersects included in the plot according to their key color
-
-KEY=~red,white,powderblue
-   select intersects excluded from the plot according to their key color
-
-
-MODE=3 EYE=0,10000,0
-   EYE controls 3D viewpoint in pyvista plotting using mm length units,
-   NB unlike cxr_min.sh there is currently no target extent scaling so
-   the EYE,LOOK,UP values need to be chosen according to the size
-   of the target geometry
-
-
-TODO: cherry pick from tests/CSGOptiXSimtraceTest.py and simplify
-for minimal simtrace plotting
-
-
-
-
-This python script is also used from ipc InputPhotonCheck, eg::
-
-    ipc env_info ## get into env
-    MODE=3 PRIMTAB=1 GSGRID=1 EYE=0,1000,0  ipc cxt             ## viewpoint 1m offset in Y from center of target frame
-    MODE=3 PRIMTAB=1 GSGRID=1 EYE=0,1000,0 GLOBAL=1 ipc cxt
-
-
-    MODE=3 PRIMTAB=1 GSGRID=1 EYE=0,1000,0 GLOBAL=0 KEY=red,white,powderblue ipc cxt
-    MODE=3 PRIMTAB=1 GSGRID=1 EYE=0,1000,0 GLOBAL=0 KEY=~red,white,powderblue ipc cxt
-
-
-"""
-import os, sys, re, logging, textwrap, numpy as np
-log = logging.getLogger(__name__)
-
-from collections import OrderedDict
-from opticks.ana.fold import Fold
-from opticks.sysrap.sevt import SEvt
-from opticks.ana.p import cf    # load CSGFoundry geometry info
-from opticks.CSG.CSGFoundry import KeyNameConfig
-
-try:
-    from scipy.spatial import KDTree
-except ImportError:
-    KDTree = None
-pass
-
-
-MODE = int(os.environ.get("MODE","2"))
-NORMAL = int(os.environ.get("NORMAL","0"))
-NORMAL_FILTER = int(os.environ.get("NORMAL_FILTER","10000")) # modulo scaledown for normal presentation
-PRIMTAB = int(os.environ.get("PRIMTAB","0"))
-assert PRIMTAB in [0,1]
-
-
-A = int(os.environ.get("A","0"))
-B = int(os.environ.get("B","0"))
-
-
-GLOBAL = 1 == int(os.environ.get("GLOBAL","0"))
-GSGRID = 1 == int(os.environ.get("GSGRID","0"))
-FRAME = 1 == int(os.environ.get("FRAME","0"))
-POINT = np.fromstring(os.environ["POINT"],sep=",").reshape(-1,3) if "POINT" in os.environ else None
-POINTSIZE = float(os.environ.get("POINTSIZE",1.))
-APOINTSIZE = float(os.environ.get("APOINTSIZE",10.))
-BPOINTSIZE = float(os.environ.get("BPOINTSIZE",10.))
-
-
-
-if MODE in [2,3]:
-    import opticks.ana.pvplt as pvp
-pass
-
-
-
-class UniqueTable(object):
-    def __init__(self, symbol, ii, names=None ):
-        u, x, c = np.unique(ii, return_index=True, return_counts=True )
-        o = np.argsort(c)[::-1] ## descending count order
-        nn = names[u] if not names is None else None
-
-        _tab = "np.c_[u,c,x,nn][o]" if not nn is None else "np.c_[u,c,x][o]"
-        tab = eval(_tab)
-
-        self.symbol = symbol
-        self._tab = _tab
-        self.tab = tab
-
-        self.u = u[o]
-        self.x = x[o]
-        self.c = c[o]
-        self.n = nn[o] if not nn is None else None
-
-
-    def __repr__(self):
-       lines =  []
-       lines.append("[%s" % self.symbol)
-       lines.append(repr(self.tab))
-       lines.append("]%s" % self.symbol)
-       return "\n".join(lines)
-
-
-
-
-if __name__ == '__main__':
-
-    logging.basicConfig(
-           level=logging.INFO,
-           format='%(asctime)s - %(message)s',
-           datefmt='%H:%M:%S'   # .%f
-    )
-
-    log.info("GLOBAL:%d MODE:%d" % (GLOBAL,MODE))
-
-    prn_config = KeyNameConfig.Parse("$HOME/.opticks/GEOM/cxt_min.ini", "key_prim_regexp")
-
-
-    if not "MFOLD" in os.environ:
-       print("FATAL cxt_min.py simtrace plotting now needs MFOLD envvar, not the former FOLD : as that is too common")
-    pass
-    e = SEvt.Load("$MFOLD", symbol="e")
-    a = SEvt.Load("$AFOLD", symbol="a") if A == 1 else None
-    b = SEvt.Load("$BFOLD", symbol="b") if B == 1 else None
-
-
-    print(repr(e))
-    if e is None:
-        fmt = "ABORT script as failed to SEvt.Load from MFOLD[%s] GEOM is [%s]"
-        print(fmt % (os.environ.get("MFOLD", None), os.environ.get("GEOM", None)))
-        sys.exit(0)
-    pass
-
-    label = e.f.base
-    sf = e.f.sframe
-    w2m = sf.w2m
-    m2w = sf.m2w
-
-    gs = e.f.genstep
-    st = e.f.simtrace
-
-    gs_pos = gs[:,1]
-    all_one = np.all( gs_pos[:,3] == 1. )    ## W
-    all_zero = np.all( gs_pos[:,:3]  == 0 )  ## XYZ often all zero
-    ## the gs_pos is regarded as a local position in the
-    ## frame defined by the transform in the last 4 quads of the simtrace genstep
-
-    assert all_one  # SHOULD ALWAYS BE 1. [HOMOGENOUS POSITION COORDINATE W :  4th ELEMENT]
-    #assert all_zero # NOT ZERO WHEN USING CE_OFFSET=CE CE_SCALE=1
-    gs_tra = gs[:,2:]
-    assert gs_tra.shape[1:] == (4,4)  ## skip first number of gs dimensions
-
-
-    ggrid = np.zeros( (len(gs), 4 ), dtype=np.float32 )
-    for i in range(len(ggrid)): ggrid[i] = np.dot(gs_pos[i], gs_tra[i])
-    ## np.matmul/np.tensordot/np.einsum can probably do this without the loop
-    lgrid = np.dot( ggrid, w2m )
-    ugrid = ggrid if GLOBAL else lgrid
-
-    st_x = st[:,1,0]
-    st_y = st[:,1,1]
-    st_z = st[:,1,2]
-    st_gp = st[:,2,3].view(np.int32) >> 16
-    st_bn = st[:,2,3].view(np.int32) & 0xffff
-    st_id = st[:,3,3].view(np.int32)
-
-    presel = slice(None)                                        ## ALL
-
-    #presel = st_x < -20000                                     ## x < -20m
-    #presel = np.abs(st_x) < 1000                               ## |x|<1m
-
-    PRESEL = os.environ.get("PRESEL", "")
-    if PRESEL.startswith("PRIM:"):
-        spec = PRESEL[len("PRIM:"):]
-        gps = np.array([], dtype=np.int64)
-        for elem in spec.split(","):
-            if str.isdigit(elem):
-                gps = np.concatenate(gps, int(elem))
-            else:
-                egp = np.unique(np.where( cf.primname == elem ))
-                gps = np.concatenate( (gps, egp) )
-            pass
-        pass
-        gps = np.unique(gps)
-        presel = np.isin(st_gp, gps )
-        pass
-    elif PRESEL == "LPMT":
-        presel = np.logical_and( st_id > 0, st_id < 30000 )
-    elif PRESEL == "SPMT":
-        presel = np.logical_and( st_id >= 30000, st_id < 50000 )
-    elif PRESEL == "PPMT":
-        presel = st_id >= 50000   ## pool PMTS
-    elif PRESEL == "GLOBAL":
-        presel = st_id == 0   ## non-instanced
-    else:
-        presel = slice(None)
-    pass
-
-    #presel = st_gp == 10
-    #presel = st_gp == 2919
-    #presel = st_gp == 2919
-
-
-
-    ust = st[presel]   ## example ust shape (13812151, 4, 4)
-    ## for simtrace layout see sysrap/sevent.h
-
-    _ii = ust[:,3,3].view(np.int32)   ## instanceIndex
-    _gp_bn = ust[:,2,3].view(np.int32)    ## simtrace intersect boundary indices
-    _gp = _gp_bn >> 16      ## globalPrimIdx
-    _bn = _gp_bn & 0xffff   ## boundary
-
-    gnrm = ust[:,0].copy()
-    gpos = ust[:,1].copy()
-
-    gnrm[...,3] = 0.   ## surface normal transforms as vector
-    gpos[...,3] = 1.   ## intersect position transforms as position
-
-    ## transform from global to local frame
-    lnrm = np.dot( gnrm, w2m )
-    lpos = np.dot( gpos, w2m )
-
-    elu_m2w = m2w if GLOBAL else np.eye(4)   ## try to make EYE,LOOK,UP stay local even in GLOBAL
-    _unrm = gnrm if GLOBAL else lnrm
-    _upos = gpos if GLOBAL else lpos
-
-    if "BOXSEL" in os.environ:
-        BOXSEL = np.fromstring(os.environ.get("BOXSEL","-1000,1000,-1000,1000,-1000,1000"),sep=",").reshape(3,2)
-        boxsel = np.all( (_upos[:,:3] > BOXSEL[:,0]) & (_upos[:,:3] < BOXSEL[:,1]), axis=1)
-        upos = _upos[boxsel]
-        unrm = _unrm[boxsel]
-
-        ii = _ii[boxsel]
-        gp = _gp[boxsel]
-        bn = _bn[boxsel]
-    else:
-        upos = _upos
-        unrm = _unrm
-        ii = _ii
-        gp = _gp
-        bn = _bn
-    pass
-
-
-
-
-
-    EXPR = list(map(str.strip,textwrap.dedent(r"""
-    st.shape
-    ust.shape
-    np.c_[np.unique(gp,return_counts=True)]
-    np.c_[np.unique(bn,return_counts=True)]
-    np.c_[np.unique(ii,return_counts=True)]
-    """).split("\n")))
-
-    for expr in EXPR:
-        print(expr)
-        if expr == "" or expr[0] == "#": continue
-        print(repr(eval(expr)))
-    pass
-
-
-
-
-
-
-
-    idtab = UniqueTable("idtab", ii, None)
-    print(repr(idtab))
-
-    gptab = UniqueTable("gptab", gp, cf.primname)
-    print(repr(gptab))
-
-    ## would be good to see the globalPrimIdx that correspond to a boundary
-
-    KEY = os.environ.get("KEY", None)
-    KEY_invert = False
-    if not KEY is None:
-        if KEY.startswith("~"):
-            KEY = KEY[1:]
-            KEY_invert = True
-        pass
-        KK = KEY.split(",")
-    else:
-        KK = None
-    pass
-
-    ## analyse frequencies of occurence of the label integers
-    cxtb, btab = cf.simtrace_boundary_analysis(bn, KEY)
-    print(repr(cxtb))
-    print(repr(btab))
-
-    cxtp, ptab = cf.simtrace_prim_analysis(gp, KEY)
-    print(repr(cxtp))
-    print(repr(ptab))
-
-    cxtable = cxtp if PRIMTAB==1 else cxtb
-
-
-
-    ASLICE = None
-    AIDX = int(os.environ.get("AIDX","0"))
-    if not a is None:
-        if "AFOLD_RECORD_SLICE" in os.environ:
-            ASLICE = os.environ["AFOLD_RECORD_SLICE"]
-            ase = a.q_startswith(ASLICE)
-            g_apos = a.f.record[ase][:,:,0].copy()
-        else:
-            ase = np.where( a.f.record[:,:,3,3].view(np.int32) > 0 )   ## flagmask selection to skip ufilled step point records
-            g_apos = a.f.record[ase][:,0].copy()
-            ## HMM: how to avoid loosing separation between photon records
-        pass
-
-        g_apos[...,3] = 1.  # transform as position
-        l_apos = np.dot( g_apos, w2m )
-        u_apos = g_apos if GLOBAL else l_apos
-    else:
-        g_apos = None
-        l_apos = None
-        u_apos = None
-    pass
-
-    if not b is None:
-        if "BFOLD_RECORD_SLICE" in os.environ:
-            bse = b.q_startswith(os.environ["BFOLD_RECORD_SLICE"])
-            g_bpos = b.f.record[bse][:,:,0].copy()
-        else:
-            bse = np.where( b.f.record[:,:,3,3].view(np.int32) > 0 )   ## flagmask selection to skip ufilled step point records
-            g_bpos = b.f.record[bse][:,0].copy()
-        pass
-        g_bpos[...,3] = 1.  # transform as position
-        l_bpos = np.dot( g_bpos, w2m )
-        u_bpos = g_bpos if GLOBAL else l_bpos
-    else:
-        g_bpos = None
-        l_bpos = None
-        u_bpos = None
-    pass
-
-
-
-    X,Y,Z = 0,1,2
-    H,V = X,Z
-
-
-
-    class SimtracePlot(object):
-        """
-        defined inline as uses::
-
-             KK
-             upos
-             unrm
-             NORMAL_FILTER
-
-        """
-        def __init__(self, pl, cxtable, hide=False):
-            """
-            :param pl: pyvista plotter
-            :param cxtable: analysis of simtrace integer such as boundary or globalPrimIdx
-            """
-            self.cxtable = cxtable
-            pl.enable_point_picking(callback=self, use_picker=True, show_message=False)
-            pcloud = {}
-            pts = {}
-            nrm = {}
-            pcinfo = np.zeros( (len(cxtable.wdict),3), dtype=np.int64 )
-            i = 0
-            keys = np.array(list(cxtable.wdict.keys()))
-            #print("SimtracePlot keys:%s" % str(keys))
-            for k, w in cxtable.wdict.items():
-                if not KK is None:
-                    skip0 = KEY_invert is False and not k in KK
-                    skip1 = KEY_invert is True and k in KK
-                    if skip0: continue
-                    if skip1: continue
-                pass
-                label = self.get_label(k)
-
-                # example KEYOFF "honeydew:0,0,-1000"
-                if os.environ.get("KEYOFF","").startswith(k+":"):
-                    KEYOFF = np.fromstring(os.environ["KEYOFF"][len(k+":"):],sep=",").reshape(3)
-                else:
-                    KEYOFF = np.array([0,0,0], dtype=np.float32)
-                pass
-                pts[k] = upos[w,:3] + KEYOFF
-                nrm[k] = unrm[w,:3]
-                if not hide:
-                    pcloud[k] = pvp.pvplt_add_points(pl, pts[k], color=k, label=label )
-                else:
-                    pcloud[k] = None
-                pass
-                n_verts = pcloud[k].n_verts if not pcloud[k] is None else 0
-                pcinfo[i,0] = n_verts
-                if NORMAL > 0: pvp.pvplt_add_delta_lines(pl, upos[w,:3][::NORMAL_FILTER], 20*unrm[w,:3][::NORMAL_FILTER], color=k, pickable=False )
-                i += 1
-            pass
-            pcinfo[:,1] = np.cumsum(pcinfo[:,0])
-            pcinfo[:,2] = pcinfo[:,0] + pcinfo[:,1] - 1
-            self.pcloud = pcloud
-            self.pcinfo = pcinfo
-            self.keys = keys
-            self.pts = pts
-            self.nrm = nrm
-
-        def get_label(self, k):
-            cxtable = self.cxtable
-            w = cxtable.wdict[k]
-            label = "%15s %8d %s" % (k,len(w),cxtable.d_anno[k])
-            return label
-
-        def __call__(self, picked_point, picker):
-            """
-            """
-            self.picked_point = picked_point
-            self.picker = picker
-
-            pcloud = self.pcloud
-            pcinfo = self.pcinfo
-
-            dataSet = picker.GetDataSet()
-            pointId = picker.GetPointId()
-
-            idx= list(pcloud.values()).index(dataSet)
-            k = list(pcloud.keys())[idx]
-            label = self.get_label(k)
-
-            print("SimtracePlot.__call__ picked_point %s pointId %d idx %d k %s label %s " % (str(picked_point), pointId, idx, k, label) )
-        pass
-    pass
-
-
-
-
-
-    if MODE == 2:
-        pl = pvp.mpplt_plotter(label=label)
-        fig, axs = pl
-        ax = axs[0]
-
-        for k, w in cxtb.wdict.items():
-            if not KEY is None and not k in KK: continue
-            ax.scatter( upos[w,H], upos[w,V], s=0.1, color=k )
-        pass
-
-        if GSGRID: ax.scatter( ugrid[:,H], ugrid[:,V], s=0.1, color="r" )
-
-        #ax.set_ylim(-9000,2000)
-        #ax.set_xlim(-22000, 22000)
-
-        fig.show()
-    elif MODE == 3:
-        pl = pvp.pvplt_plotter(label)
-
-        pvp.pvplt_viewpoint(pl, verbose=True, m2w=elu_m2w)   # sensitive to EYE, LOOK, UP envvars
-
-
-        if FRAME: pvp.pvplt_frame(pl, sf, local=not GLOBAL, pickable=False )
-
-
-        HIDE="HIDE" in os.environ
-        spl = SimtracePlot(pl, cxtable, hide=HIDE)
-
-
-        if "OVERLAP" in os.environ and len(spl.pcloud) == 2 and not KDTree is None:
-            overlap_tol = float(os.environ["OVERLAP"]) # eg 1 0.1 0.01 0.001 or 1e-3
-            assert overlap_tol > 0
-            close_tol = overlap_tol*10
-            print("OVERLAP check overlap_tol : %s close_tol %s " % (overlap_tol, close_tol  ))
-            k0, k1 = list(spl.pts.keys())
-            pt0 = spl.pts[k0]    # eg (547840, 3)
-            pt1 = spl.pts[k1]    # eg (259548, 3)
-            nr0 = spl.nrm[k0]    # eg (547840, 3)
-            nr1 = spl.nrm[k1]    # eg (259548, 3)
-
-
-            log.info("-OVERLAP-form KDTree kt0 pt0.shape %s" % (str(pt0.shape)))
-            kt0 = KDTree(pt0)
-            log.info("-OVERLAP-form KDTree kt1 pt1.shape %s" % (str(pt1.shape)))
-            kt1 = KDTree(pt1)
-
-            # query nearest neighbors between two clouds
-            log.info("-OVERLAP-kt0.query pt1.shape %s " % (str(pt1.shape)))
-            dist_1to0, idx_1to0 = kt0.query(pt1, k=1) # pt1: (259548, 3) dist_1to0: (259548,)  idx_1to0:(259548,)
-            log.info("-OVERLAP-kt0.query.DONE")
-            log.info("-OVERLAP-kt1.query pt0.shape %s " % (str(pt0.shape)))
-            dist_0to1, idx_0to1 = kt1.query(pt0, k=1) #                  dist_0to1: (547840,)
-            log.info("-OVERLAP-kt1.query.DONE")
-
-            close_0 = dist_0to1 < close_tol
-            close_1 = dist_1to0 < close_tol
-
-            close_pt0 = pt0[close_0]
-            close_pt1 = pt1[close_1]
-            close_pt = np.unique(np.vstack([close_pt0, close_pt1]), axis=0)
-
-            all_sd0 = np.sum( (pt0 - pt1[idx_0to1])*nr1[idx_0to1], axis=1 )
-            all_sd1 = np.sum( (pt1 - pt0[idx_1to0])*nr0[idx_1to0], axis=1 )
-
-            close_sd0 = np.sum( (pt0 - pt1[idx_0to1])[close_0]*nr1[idx_0to1][close_0], axis=1 )
-            close_sd1 = np.sum( (pt1 - pt0[idx_1to0])[close_1]*nr0[idx_1to0][close_1], axis=1 )
-
-
-            #overlap_pt0 = pt0[all_sd0 < -overlap_tol]
-            #overlap_pt1 = pt1[all_sd1 < -overlap_tol]
-            overlap_pt0 = pt0[close_0][close_sd0 < -overlap_tol]
-            overlap_pt1 = pt1[close_1][close_sd1 < -overlap_tol]
-
-
-            overlap_pt = np.unique(np.vstack([overlap_pt0, overlap_pt1]), axis=0)
-
-            cegs_npy = os.environ.get("CEGS_NPY","")  # eg /tmp/overlap_pt.npy see SFrameGenstep::MakeCenterExtentGenstep_FromFrame
-            if cegs_npy.endswith(".npy"):
-                np.save(cegs_npy, overlap_pt)
-            pass
-
-            close_label = "close_pt  %s " % (len(close_pt))
-            overlap_label = "overlap_pt  %s " % (len(overlap_pt))
-
-            #pvp.pvplt_add_points(pl, close_pt,   color="yellow", label=close_label,   copy_mesh=True, point_size=5 ) # HUH setting pointsize here effects all points
-            pvp.pvplt_add_points(pl, overlap_pt, color="yellow", label=overlap_label, copy_mesh=True, point_size=5 ) # HUH setting pointsize here effects all points
-        else:
-            close_pd = None
-        pass
-
-
-
-        if GSGRID: pl.add_points(ugrid[:,:3], color="r", pickable=False )
-
-        if not u_apos is None: pvp.pvplt_add_points_adaptive(pl, u_apos, color="red",  label="u_apos" ) # point_size=APOINTSIZE )
-        if not u_bpos is None: pvp.pvplt_add_points_adaptive(pl, u_bpos, color="blue", label="u_bpos" ) # point_size=BPOINTSIZE )
-
-        if not u_apos is None and u_apos.ndim == 3 and not ASLICE is None:
-            num_step_point = len(ASLICE.split())
-            pvp.pvplt_add_contiguous_line_segments( pl, u_apos[AIDX,:num_step_point,:3], point_size=4 )
-        pass
-
-        def callback_click_position(xy):
-            print("callback_click_position xy : %s " % str(xy))
-        pass
-        pl.track_click_position(callback_click_position)
-        if not POINT is None: pl.add_points(POINT, color="r", label="POINT") # point_size=POINTSIZE, render_points_as_spheres=True)
-
-        #pl.reset_camera() # avoids blank start screen, but resets view to include all points - not what want
-
-        cp = pvp.pvplt_show(pl, incpoi=-5, legend=True, title=None )
-    else:
-        pass
-    pass
-pass
-
-
diff --git a/CSGOptiX/cxt_min.sh b/CSGOptiX/cxt_min.sh
deleted file mode 100755
index 9452ef3ec9..0000000000
--- a/CSGOptiX/cxt_min.sh
+++ /dev/null
@@ -1,320 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-cxt_min.sh : Simtrace Geometry Intersect Creation and Plotting
-===============================================================
-
-::
-
-     GSGRID=0 KEY=blue,orange,lightblue cxt_min.sh pdb
-     GSGRID=0 GRID=1 GLOBAL=1 XKEY=blue,orange,lightblue cxt_min.sh pdb
-     GSGRID=0 GRID=1 GLOBAL=1 KEY=blue,lightblue,cornflowerblue cxt_min.sh pdb
-     GSGRID=0 GRID=0 GLOBAL=0 KEY=blue,lightblue,cornflowerblue,orange cxt_min.sh pdb
-
-     GSGRID=0 GRID=0 GLOBAL=0 XKEY=blue,lightblue,cornflowerblue,orange KEY=magenta cxt_min.sh pdb
-     GSGRID=0 GRID=0 GLOBAL=0 KEY=blue,lightblue,cornflowerblue,orange,magenta,tomato cxt_min.sh pdb
-         ## illuminating re the Tyvek:magenta,tomato L shape at top of LowerChimney
-
-     PRIMTAB=1 NORMAL=1 cxt_min.sh pdb
-
-     PRIMTAB=1 NORMAL=1 NORMAL_FILTER=100 KEY=~yellow,green ./cxt_min.sh pdb
-           ## inverted key selection
-
-
-TODO: add option to draw a spinkle of intersect normal direction arrows
-
-
-
-Issue
-------
-
-LOG=1 shows are writing to different dir from MFOLD where python looks::
-
-    /data1/blyth/tmp/GEOM/J25_4_0_opticks_Debug/CSGOptiXTMTest/ALL0_no_opticks_event_name/A000
-    /data1/blyth/tmp/GEOM/J25_4_0_opticks_Debug/CSGOptiXTMTest/PMT_20inch_veto:0:1000/A000
-
-
-
-Coincident surface checking
-------------------------------
-
-Take a very close look, will see color variation as zoom
-in/out when there are coincident intersects with different
-boundaries
-
-
-
-Former label "CSGOptiXTMTest Simtrace minimal executable and script for shakedown"
-but has become the standard simtrace script.
-Uses CSGOptiXTMTest which just does "CSGOptiX::SimtraceMain()".
-
-Envar controls:
-
-GEOM
-   picks the geometry together with ${GEOM}_CFBaseFromGEOM
-
-MOI
-   specify the frame in which simtrace gensteps will be generated,
-   which sets the region where most of the intersects will be found
-
-CEGS
-   "CE-center-extent-Gensteps" specifies orientatation of the grid of
-   gensteps and the number of simtrace rays from each genstep origin
-
-
-Usage pattern assuming analysis python environment with
-matplotlib and/or pyvista on laptop::
-
-   cxt_min.sh info_run               ## on workstation
-   cxt_min.sh grab                   ## on laptop
-   GRID=1 MODE=2 cxt_min.sh ana      ## on laptop
-
-
-Command arguments:
-
-info
-   output many vars
-fold
-   output just $FOLD where simtrace SEvt are persisted
-run
-   executes the CSGOptiXTMTest executable with main being just "CSGOptiX::SimtraceMain()"
-
-   1. loads envvar configured geometry
-   2. generates envvar configured simtrace gensteps
-   3. runs CSGOptiX:simtrace which uses OptiX on GPU to intersect
-      simtrace rays with the gometry, saving them into the simtrace array
-   4. saves SEVt including simtrace array to $FOLD
-
-dbg
-   runs the above under gdb
-
-brab
-   old grab for rsyncing the SEvt FOLD between machines
-grab
-   rsync an SEvt FOLD from remote to local machine
-
-
-pdb
-   ${IPYTHON:-ipython} plotting of simtrace intersects, typically
-   giving 2D cross section through geometry with matplotlib (MODE:2)
-   OR 3D intersect view with pyvista (MODE:3)
-
-ana
-   as above but with ${PYTHON:-python}
-
-
-About IPYTHON/PYTHON ipython/python overrides
------------------------------------------------
-
-"Official" python environments might not include the
-matplotlib/pyvista plotting packages which
-will cause MODE 2/3 to give errors for "pdb" and "ana".
-Workaround this by defining IPYTHON/PYTHON envvars
-to pick a python install (eg from miniconda)
-which does include the plotting libraries.
-
-matplotlib wayland warning but pdb succeeds to plot
-------------------------------------------------------
-
-::
-
-   qt.qpa.plugin: Could not find the Qt platform plugin "wayland" in ""
-
-
-EOU
-}
-
-cd $(dirname $(realpath $BASH_SOURCE))
-script=$(realpath $PWD/cxt_min.py)   ## use python script that is sibling to the bash script
-
-allarg="info_fold_run_dbg_brab_grab_ana"
-
-defarg=info_run_info_pdb
-[ -n "$BP" ] && defarg="info_dbg"
-arg=${1:-$defarg}
-arg2=$2
-
-bin=CSGOptiXTMTest   ## just calls CSGOptiX::SimtraceMain()
-which_bin=$(which $bin)
-
-External_CFBaseFromGEOM=${GEOM}_CFBaseFromGEOM
-if [ -n "$GEOM" -a -n "${!External_CFBaseFromGEOM}" -a -d "${!External_CFBaseFromGEOM}" -a -f "${!External_CFBaseFromGEOM}/CSGFoundry/prim.npy" ]; then
-    ## distributed usage : where have one fixed geometry for each distribution
-    echo $BASH_SOURCE - External GEOM setup detected
-    vv="External_CFBaseFromGEOM ${External_CFBaseFromGEOM}"
-    for v in $vv ; do printf "%40s : %s \n" "$v" "${!v}" ; done
-else
-    ## development source tree usage : where need to often switch between geometries
-    source ~/.opticks/GEOM/GEOM.sh   # sets GEOM envvar, use GEOM bash function to setup/edit
-fi
-
-source $HOME/.opticks/GEOM/MOI.sh 2>/dev/null  ## optionally sets MOI envvar, use MOI bash function to setup/edit
-source $HOME/.opticks/GEOM/CUR.sh 2>/dev/null  ## optionally define CUR_ bash function, for controlling directory for screenshots
-source $HOME/.opticks/GEOM/EVT.sh 2>/dev/null  ## optionally define AFOLD and/or BFOLD for adding event tracks to simtrace plots
-
-tmp=/tmp/$USER/opticks
-TMP=${TMP:-$tmp}
-
-mode=3
-eye=0,10000,0
-
-export MODE=${MODE:-$mode}
-export EYE=${EYE:-$eye}
-
-
-export EVT=${EVT:-A000}
-export BASE=$TMP/GEOM/$GEOM
-export BINBASE=$BASE/$bin
-export LOGDIR=$BINBASE/$MOI
-
-#rel=${MOI:-0}
-rel=ALL0_no_opticks_event_name   ## SOMEHOW THE DIRECTORY WRITTEN TO HAS CHANGED ?
-export MFOLD=$TMP/GEOM/$GEOM/$bin/$rel/$EVT
-
-
-export SCRIPT=$(basename $BASH_SOURCE)
-SCRIPT=${SCRIPT/.sh}
-
-version=1
-VERSION=${VERSION:-$version}
-
-export OPTICKS_EVENT_MODE=DebugLite
-export OPTICKS_INTEGRATION_MODE=1
-
-mkdir -p $LOGDIR
-cd $LOGDIR
-LOGNAME=$bin.log
-
-
-## see SFrameGenstep::StandardizeCEGS for CEGS/CEHIGH [4]/[7]/[8] layouts
-
-export CEGS=16:0:9:2000   # [4] XZ default
-#export CEGS=16:0:9:1000  # [4] XZ default
-#export CEGS=16:0:9:100   # [4] XZ reduce rays for faster rsync
-#export CEGS=16:9:0:1000  # [4] try XY
-
-export CEHIGH_0=-16:16:0:0:-4:4:2000:4
-export CEHIGH_1=-16:16:0:0:4:8:2000:4
-
-#export CEHIGH_0=16:0:9:0:0:10:2000     ## [7] dz:10 aim to land another XZ grid above in Z 16:0:9:2000
-#export CEHIGH_1=-4:4:0:0:-9:9:2000:5   ## [8]
-#export CEHIGH_2=-4:4:0:0:10:28:2000:5  ## [8]
-
-
-
-## base photon count without any CEHIGH for 16:0:9:2000 is (2*16+1)*(2*9+1)*2000 = 1,254,000
-#export CE_OFFSET=CE    ## offsets the grid by the CE
-
-logging(){
-    type $FUNCNAME
-    export CSGOptiX=INFO
-    export QEvt=INFO
-    #export QSim=INFO
-    #export SFrameGenstep=INFO
-    #export CSGTarget=INFO
-    #export SEvt=INFO
-    export SEvt__LIFECYCLE=INFO
-}
-
-debug()
-{
-    type $FUNCNAME
-    export CSGFoundry__getFrameE_VERBOSE=1
-    export SEvt__FRAME=1
-}
-
-[ "$LOG" == "1" ] && logging
-[ "$DBG" == "1" ] && debug
-
-
-_CUR=GEOM/$GEOM/$SCRIPT/${MOI//:/_}
-
-vars="BASH_SOURCE script bin which_bin allarg defarg arg GEOM ${GEOM}_CFBaseFromGEOM MFOLD MOI SCRIPT _CUR LOG LOGDIR BASE CUDA_VISIBLE_DEVICES CEGS TITLE"
-
-## define TITLE based on ana/pdb control envvars
-title="cxt_min.sh pdb"
-ee="LINE GLOBAL PRESEL KEY NORMAL NORMAL_FILTER GRID GSGRID PRIMTAB"
-for e in $ee ; do
-   #printf "%20s : %s \n" "$e" "${!e}"
-   [ -n "${!e}" ] && title="$e=${!e} $title"
-done
-export TITLE="$title"
-
-
-if [ "${arg/info}" != "$arg" ]; then
-   for var in $vars ; do printf "%20s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/fold}" != "$arg" ]; then
-    echo $FOLD
-fi
-
-if [ "${arg/ls}" != "$arg" ]; then
-    ff="MFOLD"
-    for f in $ff ; do printf "%20s : ls -alst %s \n" "$f" "${!f}"  && ls -alst ${!f} ; done
-fi
-
-
-if [ "${arg/run}" != "$arg" -o "${arg/dbg}" != "$arg" ]; then
-
-   if [ -f "$LOGNAME" ]; then
-       echo $BASH_SOURCE : run/dbg : delete prior LOGNAME $LOGNAME
-       rm "$LOGNAME"
-   fi
-
-   if [ "${arg/run}" != "$arg" ]; then
-       $bin
-   elif [ "${arg/dbg}" != "$arg" ]; then
-       source dbg__.sh
-       dbg__ $bin
-   fi
-   [ $? -ne 0 ] && echo $BASH_SOURCE run/dbg error && exit 1
-fi
-
-
-if [ "${arg/brab}" != "$arg" -o "${arg/list}" != "$arg" -o "${arg/pub}" != "$arg" ]; then
-    ## THIS OLD BASE_grab.sh SYNCS TOO MUCH : BUT IT DOES OTHER THINGS LIKE list and pub
-    source BASE_grab.sh $arg
-fi
-
-if [ "${arg/grab}" != "$arg" ]; then
-    source rsync.sh $MFOLD
-fi
-
-
-
-if [ "${arg/open}" != "$arg" ]; then
-    # open to define current context string which controls where screenshots are copied to
-    CUR_open ${_CUR}
-fi
-
-if [ "${arg/pdb}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $script
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-    ${PYTHON:-python} $script
-fi
-
-if [ "${arg/close}" != "$arg" ]; then
-    # close to invalidate the context
-    CUR_close
-fi
-
-if [ "$arg" == "touch"  ]; then
-    if [ -n "$arg2" ]; then
-        CUR_touch "$arg2"
-    else
-        echo $BASH_SOURCE:touch needs arg2 datetime accepted by CUR_touch eg "cxt_min.sh touch 11:00"
-    fi
-fi
-
-if [ "${arg/cfg}" != "$arg" ]; then
-    cfgpath=$(realpath ~/.opticks/GEOM/cxt_min.ini)
-    cmd="vim $cfgpath"
-    echo $cmd
-    eval  $cmd
-fi
-
-
-
-
diff --git a/CSGOptiX/cxt_precision.py b/CSGOptiX/cxt_precision.py
deleted file mode 100644
index 47660ce11e..0000000000
--- a/CSGOptiX/cxt_precision.py
+++ /dev/null
@@ -1,172 +0,0 @@
-#!/usr/bin/env python
-"""
-cxt_precision.py
-==================
-
-
-"""
-import os, sys, re, logging, textwrap, numpy as np
-np.set_printoptions(linewidth=200,edgeitems=20)
-
-log = logging.getLogger(__name__)
-
-from opticks.ana.fold import Fold
-from opticks.sysrap.sevt import SEvt
-import matplotlib.pyplot as mp
-SIZE=np.array([1280, 720])
-
-
-if __name__ == '__main__':
-    r = SEvt.Load("$RFOLD", symbol="r")
-    a = SEvt.Load("$AFOLD", symbol="a")
-
-    RFOLD = os.environ["RFOLD"]
-    AFOLD = os.environ["AFOLD"]
-
-    FIGPATH = os.environ.get("FIGPATH", None)
-
-    iprs = os.environ["OPTICKS_INPUT_PHOTON_RECORD_SLICE"]
-    iprt = os.environ["OPTICKS_INPUT_PHOTON_RECORD_TIME"]
-    opr = int(os.environ.get("OPTICKS_PROPAGATE_REFINE", "0"))
-    oprd = float(os.environ.get("OPTICKS_PROPAGATE_REFINE_DISTANCE", "-1"))
-
-    _title = [
-               "TEST=%s ~/opticks/CSGOptiX/cxt_precision.sh" % os.environ["TEST"],
-               "OPTICKS_INPUT_PHOTON_RECORD_SLICE %s" % iprs,
-               "OPTICKS_INPUT_PHOTON_RECORD_TIME %s" % iprt ,
-               "OPTICKS_PROPAGATE_REFINE %s OPTICKS_PROPAGATE_REFINE_DISTANCE %s" % (opr,oprd)
-             ]
-    title = "\n".join(_title)
-
-    rw = r.q__(iprs)
-    tt = np.arange(*list(map(float,iprt[1:-1].split(":"))))
-
-
-    _nt = "a.f.simtrace.shape[0]//rw.shape[0]"
-    nt = eval(_nt)
-
-    _s = "a.f.simtrace.reshape(-1,nt,4,4)"
-    s = eval(_s)
-
-    _e = "np.linalg.norm((s[:,:,1,:3] - s[:,-1,1,:3][:,np.newaxis]).reshape(-1,3),axis=1).reshape(-1,nt)[:,:-1]"
-    e = eval(_e)
-
-    _d = "s[:,:,0,3][:,:-1]"
-    d = eval(_d)
-
-    _dav = "np.average(d, axis=0)"
-    dav = eval(_dav)
-
-    _eav = "np.average(e, axis=0)"
-    eav = eval(_eav)
-
-    _emx = "np.max(e, axis=0 )"
-    emx = eval(_emx)
-
-    _emn = "np.min(e, axis=0 )"
-    emn = eval(_emn)
-
-    _emd = "np.median(e, axis=0 )"
-    emd = eval(_emd)
-
-
-    EXPR = r"""
-    title
-
-    RFOLD
-    r
-
-    AFOLD  # special simtrace precision run
-    a
-
-    iprs   # OPTICKS_INPUT_PHOTON_RECORD_SLICE
-
-    iprt   # OPTICKS_INPUT_PHOTON_RECORD_TIME
-    tt.shape
-    tt
-
-    a.f.simtrace.shape
-    rw.shape
-    a.f.simtrace.shape[0]//rw.shape[0]     # nt
-    a.f.simtrace.shape[0] % rw.shape[0]    # expect zero
-
-    _s
-    #s
-    s.shape
-
-    _nt
-    nt
-
-    len(tt) == nt
-
-    # distance from intersect positions to last(and most precise) intersect position
-    _e
-    e
-    e.shape
-
-    # distance from origin to intersect
-    _d
-    d
-    d.shape
-
-    _dav   # average over clumps
-    dav
-
-    _eav   # average over clumps
-    eav
-
-    _emx
-    emx
-
-    _emn
-    emn
-
-    _emd
-    emd
-
-    """
-    for expr in list(map(str.strip, textwrap.dedent(EXPR).split("\n"))):
-        print(expr)
-        if expr == "" or expr[0] == "#": continue
-        print(repr(eval(expr)))
-    pass
-
-
-
-
-    fig, ax = mp.subplots(figsize=SIZE/100.)
-    fig.suptitle(title)
-
-
-    ax.scatter( d.ravel(), e.ravel(), s=0.2 )
-
-    #ax.plot( dav, eav, label="avg" )
-    #ax.plot( dav, emn, label="min" )
-
-    ax.plot( dav, emx, label="max" )
-    ax.plot( dav, emd, label="median" )
-
-    ax.axhline(0.05, linestyle='--', label="EPSILON (0.05 mm)")
-
-    ax.set_ylabel("Intersect Error (mm)")
-    ax.set_xlabel("Ray trace distance (mm)")
-
-    #ax.set_xscale('log')
-    ax.set_yscale('log')
-
-    ax.set_ylim( 4e-5, 1.1 )
-
-    ax.legend()
-
-    fig.show()
-
-    if not FIGPATH is None:
-        print("savefig to FIGPATH:%s" % FIGPATH)
-        mp.savefig(FIGPATH)
-    else:
-        print("no-savefig as on FIGPATH")
-    pass
-
-
-
-
diff --git a/CSGOptiX/cxt_precision.sh b/CSGOptiX/cxt_precision.sh
deleted file mode 100755
index e032783c98..0000000000
--- a/CSGOptiX/cxt_precision.sh
+++ /dev/null
@@ -1,144 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-cxt_precision.sh : Simtrace Geometry Intersect Precision Test
-===============================================================
-
-~/o/CSGOptiX/cxt_precision.sh
-
-FIG=1 TEST=input_photon_poolcover        ~/o/CSGOptiX/cxt_precision.sh pdb
-FIG=1 TEST=input_photon_poolcover_refine ~/o/CSGOptiX/cxt_precision.sh pdb
-
-
-EOU
-}
-
-cd $(dirname $(realpath $BASH_SOURCE))
-
-defarg=info_run_pdb
-[ -n "$BP" ] && defarg="info_dbg"
-arg=${1:-$defarg}
-arg2=$2
-
-bin=CSGOptiXTMTest   ## just calls CSGOptiX::SimtraceMain()
-script=cxt_precision.py
-export SCRIPT=cxt_precision
-
-source $HOME/.opticks/GEOM/GEOM.sh   # sets GEOM envvar, use GEOM bash function to setup/edit
-source $HOME/.opticks/GEOM/CUR.sh 2>/dev/null  ## optionally define CUR_ bash function, for controlling directory for screenshots
-source $HOME/.opticks/GEOM/EVT.sh 2>/dev/null  ## optionally define AFOLD and/or BFOLD for adding event tracks to simtrace plots
-
-
-
-
-tmp=/tmp/$USER/opticks
-TMP=${TMP:-$tmp}
-
-
-if [ "$GEOM" == "BigWaterPool" ]; then
-
-    #test=input_photon_poolcover
-    test=input_photon_poolcover_refine
-
-    unset FIGPATH
-    export TEST=${TEST:-$test}
-
-    if [ "$TEST" == "input_photon_poolcover" -o "$TEST" == "input_photon_poolcover_refine" ]; then
-
-        _CUR=GEOM/$GEOM/$SCRIPT/simtrace/input_photon_poolcover_and_refine
-
-        [ -n "$FIG" ] && export FIGPATH=$HOME/Pictures/$(date +"%Y%m%d_%H%M%S").png
-        export RFOLD=/data1/blyth/tmp/GEOM/BigWaterPool/CSGOptiXSMTest/ALL98_Debug_Philox_${TEST}/A000
-        export OPTICKS_INPUT_PHOTON=$RFOLD/record.npy
-
-        case $TEST in
-           input_photon_poolcover)        export OPTICKS_INPUT_PHOTON_RECORD_SLICE="TO BT BT BT SA,TO BT BT SA"  ;;
-           input_photon_poolcover_refine) export OPTICKS_INPUT_PHOTON_RECORD_SLICE="TO BT BT SA"                 ;;
-        esac
-
-        if [ "${TEST/refine}" != "$TEST" ]; then
-            export OPTICKS_PROPAGATE_REFINE=1
-            export OPTICKS_PROPAGATE_REFINE_DISTANCE=5000
-        else
-            unset OPTICKS_PROPAGATE_REFINE
-            unset OPTICKS_PROPAGATE_REFINE_DISTANCE
-        fi
-
-        export OPTICKS_INPUT_PHOTON_RECORD_TIME="[0.1:88.8:-444]"  # -ve step for np.linspace
-
-        ## choose first time to match TO and last time just before the earliest BT
-        ## earliest first intersect r.f.record[rw,1,0,3].min() 88.851036
-        export OPTICKS_EVENT_NAME=Debug_Philox_${TEST}     ## HMM cxt_precision too ?
-        export AFOLD=$TMP/GEOM/$GEOM/$bin/ALL${VERSION:-0}_${OPTICKS_EVENT_NAME}/A000
-    fi
-
-fi
-
-export OPTICKS_EVENT_MODE=DebugLite
-export OPTICKS_INTEGRATION_MODE=1
-
-
-
-logging(){
-    type $FUNCNAME
-    #export CSGOptiX=INFO
-    #export QEvt=INFO
-    #export QSim=INFO
-    #export SFrameGenstep=INFO
-    #export CSGTarget=INFO
-    #export SEvt=INFO
-    export SEvt__LIFECYCLE=INFO
-    export SEvt__SIMTRACE=INFO
-
-    export SRecord__level=3
-
-}
-[ "$LOG" == "1" ] && logging
-
-
-vars="BASH_SOURCE PWD script bin defarg arg GEOM ${GEOM}_CFBaseFromGEOM CUDA_VISIBLE_DEVICES CEGS AFOLD _CUR"
-
-if [ "${arg/info}" != "$arg" ]; then
-   for var in $vars ; do printf "%30s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/open}" != "$arg" ]; then
-    # open to define current context string which controls where screenshots are copied to by ~/j/bin/pic.sh
-    CUR_open ${_CUR}
-fi
-
-if [ "${arg/run}" != "$arg" ]; then
-   $bin
-   [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1
-fi
-
-if [ "${arg/dbg}" != "$arg" ]; then
-   source dbg__.sh
-   dbg__ $bin
-   [ $? -ne 0 ] && echo $BASH_SOURCE run/dbg error && exit 1
-fi
-
-if [ "${arg/pdb}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $script
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-    ${PYTHON:-python} $script
-fi
-
-if [ "${arg/close}" != "$arg" ]; then
-    # close to invalidate the context
-    CUR_close
-fi
-
-if [ "$arg" == "touch"  ]; then
-    if [ -n "$arg2" ]; then
-        CUR_touch "$arg2"
-    else
-        echo $BASH_SOURCE arg2 needs to be a datetime accepted by CUR_touch eg "cxt_precision.sh touch 21:00"
-    fi
-fi
-
-
-
-
-
diff --git a/CSGOptiX/tests/CSGOptiXSimtraceTest.py b/CSGOptiX/tests/CSGOptiXSimtraceTest.py
deleted file mode 100644
index d13d56dc94..0000000000
--- a/CSGOptiX/tests/CSGOptiXSimtraceTest.py
+++ /dev/null
@@ -1,262 +0,0 @@
-#!/usr/bin/env python
-"""
-tests/CSGOptiXSimtraceTest.py
-==============================
-
-* see notes/issues/simtrace-shakedown.rst
-
-
-See also:
-
-csg/tests/CSGFoundry_MakeCenterExtentGensteps_Test.sh
-
-
-This allows interactive visualization of workstation 
-generated intersect data fphoton.npy on remote machines such as 
-user laptops that support pyvista. 
-
-
-FEAT envvar controlling intersect coloring and legend titles
---------------------------------------------------------------
-
-pid
-    uses cf.primIdx_meshname_dict()
-bnd
-    uses cf.sim.bndnamedict
-ins
-    uses cf.insnamedict
-
-    instance identity : less different feature colors normally 
-    but interesting to see what is in which instance and what is in ins0 the global instance, 
-    the legend names are for example : ins37684 ins42990 ins0 ins43029
-
-
-ISEL envvar selects simtrace geometry intersects by their features, according to frequency order
--------------------------------------------------------------------------------------------------------
-
-FEAT=ins ISEL=0
-    only show the instance with the most intersects
-FEAT=ins ISEL=0,1
-    only show the two instances with the most and 2nd most intersects
-FEAT=bnd ISEL=0,1
-    ditto for boundaries
-
-FEAT=pid ISEL=0,1
-
-
-
-pyvista GUI keys
-----------------------
-
-* https://docs.pyvista.org/api/plotting/plotting.html
-
-* to zoom out/in : slide two fingers up/down on trackpad. 
-* to pan : hold down shift and one finger tap-lock, then move finger around  
-
-
-Too many items in the legend
------------------------------
-
-When not using MASK=pos the legend may be filled with feature item lines 
-that are not visible in the frame 
-
-
-FramePhotons vs Photons
----------------------------
-
-Using frame photons is a trick to effectively see results 
-from many more photons that have to pay the costs for transfers etc.. 
-Frame photons lodge photons onto a frame of pixels limiting 
-the maximumm number of photons to handle. 
-
-ISEL allows plotting of a selection of feature values only, picked by descending frequency index
--------------------------------------------------------------------------------------------------
-
-::
-
-    cx ; ./cxs_Hama.sh  grab
-    cx ; ./cxs_Hama.sh  ana 
-
-Old instructions, not recently exercised::
-
-    cx ; ./cxs_grab.sh   ## NO LONGER USED ?
-
-    ISEL=0,1         ./cxs.sh    # ISEL=0,1 picks the 2 most frequent feature values (eg boundaries when FEAT=bnd)
-    ISEL=0,1,2,3,4   ./cxs.sh 
-
-    ISEL=Hama        ./cxs.sh    # select boundaries via strings in the bndnames, assuming FEAT=bnd
-    ISEL=NNVT        ./cxs.sh 
-    ISEL=Pyrex       ./cxs.sh 
-    ISEL=Pyrex,Water ./cxs.sh 
-
-
-"""
-import os, sys, logging, numpy as np
-np.set_printoptions(suppress=True, edgeitems=5, linewidth=200,precision=3)
-log = logging.getLogger(__name__)
-
-from opticks.ana.eget import efloatlist_, elookce_, elook_epsilon_, eint_
-
-SIZE = np.array([1280, 720])   ## SIZE*2 [2560, 1440]
-XCOMPARE_SIMPLE = "XCOMPARE_SIMPLE" in os.environ
-XCOMPARE = "XCOMPARE" in os.environ
-GUI = not "NOGUI" in os.environ
-MP =  not "NOMP" in os.environ 
-PV =  not "NOPV" in os.environ 
-PVGRID = not "NOPVGRID" in os.environ
-LEGEND =  not "NOLEGEND" in os.environ # when not MASK=pos legend often too many lines, so can switch it off 
-SIMPLE = "SIMPLE" in os.environ
-MASK = os.environ.get("MASK", "pos")
-FEAT = os.environ.get("FEAT", "pid" )  
-ALLOWED_MASK = ("pos", "t", "non" )
-assert MASK in ALLOWED_MASK, "MASK %s is not in ALLOWED_MASK list %s " % (MASK, str(ALLOWED_MASK))
-GSPLOT = eint_("GSPLOT", "0")
-PIDX = eint_("PIDX", "0")
-
-
-from opticks.CSG.CSGFoundry import CSGFoundry 
-from opticks.ana.p import *       # including cf loaded from CFBASE
-from opticks.ana.fold import Fold
-from opticks.ana.feature import SimtraceFeatures
-from opticks.ana.simtrace_positions import SimtracePositions
-from opticks.ana.simtrace_plot import SimtracePlot
-from opticks.ana.framegensteps import FrameGensteps
-from opticks.ana.npmeta import NPMeta
-from opticks.sysrap.sframe import sframe , X, Y, Z
-from opticks.ana.pvplt import * 
-
-import matplotlib
-if GUI == False:
-    log.info("set pdf backend as GUI False")
-    matplotlib.use("agg")
-pass
-
-if MP:
-    try:
-        import matplotlib.pyplot as mp
-    except ImportError:
-        mp = None
-    pass
-else:
-    mp = None
-pass
-
-if PV:
-    try:
-        import pyvista as pv
-        themes = ["default", "dark", "paraview", "document" ]
-        pv.set_plot_theme(themes[1])
-    except ImportError:
-        pv = None
-    pass
-else:
-    pv = None
-pass
-
-if GUI == False:
-    log.info("disabling pv as GUI False")
-    pv = None
-pass
-
-
-
-def pvplt_simple(xyz, label):
-    """
-    :param xyz: (n,3) shaped array of positions
-    :param label: to place on plot 
-
-    KEEP THIS SIMPLE : FOR DEBUGGING WHEN LESS BELLS AND WHISTLES IS AN ADVANTAGE
-    """
-    pl = pv.Plotter(window_size=SIZE*2 )  # retina 2x ?
-    pl.add_text( "pvplt_simple %s " % label, position="upper_left")
-    pl.add_points( xyz, color="white" )        
-    pl.show_grid()
-    cp = pl.show() if GUI else None
-    return cp
-
-
-
-def xcompare_simple( pos, x_gpos, x_lpos, local=True ):
-    """
-    :param pos: SimtracePositions instance
-    :param x_gpos: global photon step positions
-    :param x_lpos: local photon step positions
-    """
-    pl = pv.Plotter(window_size=SIZE*2 )  # retina 2x ?
-    if local == False:
-        pl.add_points( pos.gpos[:,:3], color="white" )        
-        pvplt_add_contiguous_line_segments(pl, x_gpos[:,:3])
-    else:
-        pl.add_points( pos.lpos[:,:3], color="white" )        
-        pvplt_add_contiguous_line_segments(pl, x_lpos[:,:3])
-    pass
-    pl.show_grid()
-
-    outpath = "/tmp/xcompare_simple.png" 
-    log.info("outpath %s " % outpath)
-    #pl.screenshot(outpath)  segments
-
-    cp = pl.show(screenshot=outpath) if GUI else None
-    return pl 
-
-
-def simple(pl, pos):
-    """
-    :param pos: SimtracePositions instance
-    """
-    pvplt_simple(pl, pos.gpos[:,:3], "pos.gpos[:,:3]" )
-    pvplt_simple(pl, pos.lpos[:,:3], "pos.lpos[:,:3]" )
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    t = Fold.Load("$CFBASE/CSGOptiXSimtraceTest", symbol="t"); 
-    x = Fold.Load("$CFBASE/CSGOptiXSimTest", symbol="x")
-
-    if not x is None:
-        x_nib = seqnib_(x.seq[:,0])  # valid steppoint records from seqhis count_nibbles
-        x_gpos_ = x.record[PIDX,:x_nib[PIDX],0,:3]  # global frame photon step record positions of single PIDX photon
-        x_gpos  = np.ones( (len(x_gpos_), 4 ), dtype=np.float32 )
-        x_gpos[:,:3] = x_gpos_
-        x_lpos = np.dot( x_gpos, t.sframe.w2m ) 
-    pass
-
-    SimtracePositions.Check(t.simtrace)
-
-    local = True 
-
-    gs = FrameGensteps(t.genstep, t.sframe, local=local, symbol="gs" )  ## get gs positions in target frame
-
-    t_pos = SimtracePositions(t.simtrace, gs, t.sframe, local=local, mask=MASK, symbol="t_pos" )
-
-    if SIMPLE:
-       pl = pvplt_plotter()
-       simple(pl, t_pos)
-       pl.show()
-       raise Exception("SIMPLE done")
-    pass
-    if XCOMPARE_SIMPLE and not x is None:
-       pl = xcompare_simple( t_pos, x_gpos, x_lpos, local=True )
-       #raise Exception("XCOMPARE done")
-    pass
-
-    pf = SimtraceFeatures(t_pos, cf, featname=FEAT, symbol="pf" ) 
-
-    pl = SimtracePlot.MakePVPlotter()
-
-    plt = SimtracePlot(pl, pf.feat, gs, t.sframe, t_pos, outdir=os.path.join(t.base, "figs") )
-
-    if not x is None:       
-        plt.x_lpos = x_lpos   
-    pass
-
-    if not mp is None:
-        plt.positions_mpplt()
-        ax = plt.ax
-    pass
-
-    if not pv is None:
-        plt.positions_pvplt()
-    pass
-pass
diff --git a/CSGOptiX/tests/CXRaindropTest.py b/CSGOptiX/tests/CXRaindropTest.py
deleted file mode 100644
index 599307c644..0000000000
--- a/CSGOptiX/tests/CXRaindropTest.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env python
-import numpy as np
-import sys
-import pyvista as pv
-
-from opticks.ana.pvplt import *
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-from opticks.ana.r import * 
-
-from opticks.sysrap.stag import stag
-tag = stag()
-
-
-PIDX = int(os.environ.get("PIDX","-1"))
-
-if __name__ == '__main__':
-    t = Fold.Load(os.path.expandvars("$FOLD/CXRaindropTest"))
-    r = t.record if hasattr(t,'record') else None
-    p = t.photon if hasattr(t,'photon') else None
-
-    st = stag.Split(t.tag) if hasattr(t,"tag") else None
-
-    if p is None:
-        print("FATAL : no photon loaded from t.base %s " % t.base ) 
-        sys.exit(0)
-    pass
-
-    r_pos = r[:,:,0,:3].reshape(-1,3)
-    r_mom = r[:,:,1,:3].reshape(-1,3)
-    r_pol = r[:,:,2,:3].reshape(-1,3)
-    r_flag = flag__(r.reshape(-1,4,4))
-    r_flag_label = hm.label( r_flag )
-
-    r_cells = make_record_cells( r )
-
-    r_poly = pv.PolyData()
-    r_poly.points = r_pos
-    r_poly.lines = r_cells
-    r_poly["flag_label"] = r_flag_label
-
-    r_tube = r_poly.tube(radius=1)
-    PLOT = "PLOT" in os.environ
-    if PLOT:
-        pl = pvplt_plotter()
-        #pl.add_mesh( r_tube )
-        #pvplt_polarized( pl, r_pos, r_mom, r_pol, factor=60 )
-        #pl.add_point_labels(r_poly, "flag_label", point_size=20, font_size=36)
-        pl.add_points( r_pos )
-        pl.show()
-    pass
-
-
-
-    s = str(p[:10,:3])
-    a = np.array( s.split("\n") + [""] ).reshape(-1,4)
-
-    for i in range(len(a)):
-        if not (PIDX == -1 or PIDX == i): continue
-        if PIDX > -1: print("PIDX %d " % PIDX)
-
-        if not r is None:
-            print("r[i,:,:3]")
-            print(r[i,:,:3])
-            print("\n\nbflagdesc_(r[i,j])")
-            for j in range(len(r[i])):
-                print(bflagdesc_(r[i,j])  )
-            pass
-        pass
-
-        print("\n")
-        print("p")
-        print("\n".join(a[i]))
-        print(bflagdesc_(p[i]))
-        print("\n")
-    pass
-
-
-
-
diff --git a/g4cx/tests/G4CXSimtraceMinTest.py b/g4cx/tests/G4CXSimtraceMinTest.py
deleted file mode 100644
index baeacaf701..0000000000
--- a/g4cx/tests/G4CXSimtraceMinTest.py
+++ /dev/null
@@ -1,136 +0,0 @@
-#!/usr/bin/env python
-"""
-G4CXSimtraceMinTest.py : simtrace plot backdrop with APID, BPID onephotonplot on top 
-=======================================================================================
-
-This is now run by G4CXAppTest.sh with eg::
-
-    APID=62 MODE=2 ~/opticks/g4cx/tests/G4CXAppTest.sh tra
-
-This aims to do similar to G4CXSimtraceTest.py but in a more minimal way,
-drawing on developments from cx/cxs_min.py 
-
-"""
-
-import os, logging, numpy as np
-from opticks.sysrap.sevt import SEvt, SAB
-log = logging.getLogger(__name__)
-
-GLOBAL = int(os.environ.get("GLOBAL","0")) == 1
-MODE = int(os.environ.get("MODE","3"))
-SEL = int(os.environ.get("SEL","0"))
-
-
-if MODE in [2,3]:
-    from opticks.ana.pvplt import *
-    # HMM this import overrides MODE, so need to keep defaults the same 
-pass
-
-
-def onephotonplot(pl, e):
-    if e is None: return 
-    if e.pid < 0: return
-
-    if not hasattr(e,'r'): return
-    if e.r is None: return
-
-    r = e.r 
-    off = e.off
-
-    rpos = r[:,0,:3] + off 
-
-    if MODE == 2:
-        fig, axs = pl  
-        assert len(axs) == 1 
-        ax = axs[0]
-        if True:
-            mpplt_add_contiguous_line_segments(ax, rpos, axes=(H,V), label=None )
-            #self.mp_plab(ax, f)
-        pass
-        #if "nrm" in f.opt:
-        #    self.mp_a_normal(ax, f)  
-        #pass
-    elif MODE == 3:
-        pass
-        pvplt_add_contiguous_line_segments(pl, rpos )
-    pass 
-
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    a = SEvt.Load("$AFOLD", symbol="a")
-    b = SEvt.Load("$BFOLD", symbol="b")
-    t = SEvt.Load("$TFOLD", symbol="t")
-
-    print(repr(a))
-    print(repr(b))
-    print(repr(t))
-
-    ab = SAB(a,b)
-    print(repr(ab))
-
-
-
-    e = t
-
-    label = "APID=%s BPID=%d G4CXSimtraceMinTest.sh  # A:%s B:%s " % (a.pid, b.pid, a.label, b.label )
-
-    if MODE in [0,1]:
-        print("not plotting as MODE %d in environ" % MODE )
-    elif MODE == 2:
-        pl = mpplt_plotter(label=label)
-        fig, axs = pl
-        assert len(axs) == 1
-        ax = axs[0]
-
-        ax.set_xlim(-356,356)
-        ax.set_ylim(-201,201)
-
-    elif MODE == 3:
-        pl = pvplt_plotter(label)
-        pvplt_viewpoint(pl)   # sensitive to EYE, LOOK, UP envvars
-        pvplt_frame(pl, e.f.sframe, local=not GLOBAL )
-    pass
-
-    pp =  e.f.simtrace[:,1,:3]  
-
-    gpos = np.ones( [len(pp), 4 ] ) 
-    gpos[:,:3] = pp
-    lpos = np.dot( gpos, e.f.sframe.w2m )
-    upos = gpos if GLOBAL else lpos
-
-
-    H,V = 0,2  # X, Z
-
-    if SEL == 1:
-        sel = np.logical_and( np.abs(upos[:,H]) < 500, np.abs(upos[:,V]) < 500 )
-        spos = upos[sel]
-    else:
-        spos = upos
-    pass
-
-
-    if MODE == 2:
-        ax.scatter( spos[:,H], spos[:,V], s=0.1 )
-    elif MODE == 3:
-        pl.add_points(spos[:,:3])
-    pass
-
-
-    if not a is None and a.pid > -1:
-        onephotonplot(pl, a)
-    pass 
-    if not b is None and b.pid > -1:
-        onephotonplot(pl, b)
-    pass 
-
-
-    if MODE == 2:
-        fig.show()
-    elif MODE == 3:
-        pl.show()
-    pass
-pass
-
diff --git a/g4cx/tests/G4CXSimulateTest.py b/g4cx/tests/G4CXSimulateTest.py
deleted file mode 100644
index 271dbc5578..0000000000
--- a/g4cx/tests/G4CXSimulateTest.py
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/env python 
-
-import os, numpy as np
-from opticks.ana.fold import Fold
-from opticks.sysrap.xfold import XFold
-from opticks.ana.p import * 
-
-
-if __name__ == '__main__':
-    a = Fold.Load(symbol="a")
-    A = XFold(a, symbol="A") 
-
-    self = A
-
-
-
diff --git a/g4cx/tests/G4CXTest.py b/g4cx/tests/G4CXTest.py
deleted file mode 100644
index bcc9344760..0000000000
--- a/g4cx/tests/G4CXTest.py
+++ /dev/null
@@ -1,266 +0,0 @@
-#!/usr/bin/env python 
-"""
-G4CXTest.py
-============
-
-PICK=AB HSEL="TO BT BT SA" ~/o/G4CXTest_GEOM.sh dna
-
-
-"""
-import os, logging, numpy as np
-from opticks.ana.fold import Fold, IsRemoteSession
-from opticks.sysrap.sevt import SEvt, SAB
-from opticks.ana.p import *  # including cf boundary___
-
-log = logging.getLogger(__name__)
-
-GLOBAL = int(os.environ.get("GLOBAL","0")) == 1
-D = int(os.environ.get("D","3")) 
-MODE = int(os.environ.get("MODE",D)) 
-
-print(" D:%d MODE:%d " % (D, MODE))
-
-
-SEL = os.environ.get("SEL","") 
-POI = int(os.environ.get("POI","-1")) 
-
-PICK = os.environ.get("PICK","AB")
-AIDX = int(os.environ.get("AIDX","0"))
-BIDX = int(os.environ.get("BIDX","0"))
-
-H,V = 0,2  # X, Z
-
-
-if IsRemoteSession():  # HMM: maybe do this inside pvplt ?
-    MODE = 0
-    print("detect fold.IsRemoteSession forcing MODE:%d" % MODE)
-elif MODE in [2,3]:
-    from opticks.ana.pvplt import *  # HMM this import overrides MODE, so need to keep defaults the same 
-pass
-
-
-
-
-def onephotonplot(pl, e ):
-    """
-    :param pl: MODE 2/2 plotter objects
-    :param e: SEvt instance
-    """
-    if e is None: return
-    if e.pid < 0: return
-
-    print("onephotonplot e.pid %d " % e.pid )
-
-    if not hasattr(e,'l'): return
-    if e.l is None: return
-    print("onephotonplot e.pid %d PROCEED " % e.pid )
-
-    rpos =  e.l[:,:3] + e.off
-
-    if MODE == 2:
-        fig, axs = pl
-        assert len(axs) == 1
-        ax = axs[0]
-        if True:
-            mpplt_add_contiguous_line_segments(ax, rpos, axes=(H,V), label=None )
-            #self.mp_plab(ax, f)
-        pass
-        #if "nrm" in f.opt:
-        #    self.mp_a_normal(ax, f)  
-        #pass
-    elif MODE == 3:
-        pass
-        pvplt_add_contiguous_line_segments(pl, rpos )
-    pass
-
-
-
-
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    print("GLOBAL:%d MODE:%d SEL:%s PICK:%s " % (GLOBAL,MODE, SEL, PICK))
-
-    a = SEvt.Load("$AFOLD", symbol="a")
-    print(repr(a))
-    b = SEvt.Load("$BFOLD", symbol="b")
-    print(repr(b))
-
-
-    print(cf)
-
-
-    #sli="[:]"  allowing everything makes for big tables of low stat histories
-    sli="[:15]"
-    at = None if a is None else a.minimal_qtab(sli=sli)  
-    bt = None if b is None else b.minimal_qtab(sli=sli)
-
-    print("at\n",at)
-    print("bt\n",bt)
-
-    if "SAB" in os.environ:
-        ab = SAB(a,b) if not a is None and not b is None else None
-        print(repr(ab))
-    else:
-        print(" ab = SAB(a,b) ## SKIPPED as SAB not on os.environ ")
-    pass
-
-
-    assert PICK in ["A","B","AB","BA", "CF"]
-    if PICK == "A":
-        ee = [a,] 
-    elif PICK == "B":
-        ee = [b,]
-    elif PICK == "AB":
-        ee = [a,b,]
-    elif PICK == "BA":
-        ee = [b,a,]
-    elif PICK == "CF":
-        ee = []
-    pass 
-
-    if len(ee) == 0:
-        log.fatal("set PICK envvar to one of : A,B,AB,BA in order to load SEvt from AFOLD BFOLD " )
-        assert(0)
-    pass
-
-
-    context = "PICK=%s MODE=%d SEL=%s POI=%d ~/opticks/g4cx/tests/G4CXTest.sh ana " % (PICK, MODE, SEL, POI )
-    print(context)
-
-    hsel = None
-    #hsel = "TO BT BT BT SD,TO BT BT BT SA"
-    HSEL = os.environ.get("HSEL", hsel)
-
-
-    for e in ee:
-        ew = e.q_startswith_or_(HSEL) if not HSEL is None else None
-
-        elabel = "%s : %s " % ( e.symbol.upper(), e.f.base )
-        if not ew is None:
-            elabel += " HSEL=%s " % HSEL 
-        pass
-        label = context + " ## " + elabel
-
-        qtab = e.minimal_qtab()
-
-
-        if MODE in [0,1]:
-            print("not plotting as MODE %d in environ" % MODE )
-        elif MODE == 2:
-            pl = mpplt_plotter(label=label)
-            fig, axs = pl
-            assert len(axs) == 1
-            ax = axs[0]
-
-            xlim, ylim = mpplt_focus_aspect()
-            if not xlim is None:
-                ax.set_xlim(xlim) 
-                ax.set_ylim(ylim) 
-            else:
-                log.info("mpplt_focus_aspect not enabled, use eg FOCUS=0,0,100 to enable ")
-            pass 
-
-            #ax.set_xlim(-356,356)
-            #ax.set_ylim(-201,201)
-
-        elif MODE == 3:
-            pl = pvplt_plotter(label)
-            pvplt_viewpoint(pl)   # sensitive to EYE, LOOK, UP envvars
-            pvplt_frame(pl, e.f.sframe, local=not GLOBAL )
-        pass
-
-        #pp = e.f.inphoton[:,0,:3]
-        #pp = e.f.photon[:,0,:3]
-        #pp = e.f.record[:,:,0,:3]
-
-        if POI == -1: 
-            pp = e.f.record[:,:,0,:3]
-        elif POI > -1:
-            pp = e.f.record[:,POI,0,:3]
-        else:
-            pp = None
-        pass   
-
-        ww = pp[ew] if not ew is None else None
-
-        ppf = pp.reshape(-1,3)
-        print("ppf.shape : %s " % repr(ppf.shape) )
-        
-        g_pos = np.ones( [len(ppf), 4 ] ) 
-        g_pos[:,:3] = ppf
-        l_pos = np.dot( g_pos, e.f.sframe.w2m )
-        u_pos = g_pos if GLOBAL else l_pos
-
-
-
-        wwf = ww.reshape(-1,3) if not ww is None else None
-        print("wwf.shape : %s " % repr(wwf.shape) )
-
-        if not wwf is None: 
-            h_pos = np.ones( [len(wwf), 4 ] ) 
-            h_pos[:,:3] = wwf
-            i_pos = np.dot( h_pos, e.f.sframe.w2m )
-            v_pos = h_pos if GLOBAL else i_pos 
-        else:
-            h_pos = None
-            i_pos = None
-            v_pos = None
-        pass
-
-
-
-        if SEL == "1":
-            sel = np.logical_and( np.abs(u_pos[:,H]) < 500, np.abs(u_pos[:,V]) < 500 )
-            s_pos = u_pos[sel]
-        else:
-            s_pos = None
-        pass
-
-
-        if s_pos is None:
-            print("s_pos:None skip plotting : use SEL=1 to plot ")
-        else:
-            if MODE == 2:
-                ax.scatter( s_pos[:,H], s_pos[:,V], s=0.1 )
-            elif MODE == 3:
-                pl.add_points(s_pos[:,:3])
-            else:
-                pass
-            pass
-        pass
-
-        if not v_pos is None:
-            print("v_pos:NOT-None proceed with selected point plotting")
-            if MODE == 2:
-                ax.scatter( v_pos[:,H], v_pos[:,V], s=0.1, c="r" )
-            elif MODE == 3:
-                if len(v_pos) > 0:
-                    pl.add_points(v_pos[:,:3], color="red")
-                else:
-                    print(" SKIP HSEL PLOTTING : pl.add_points(v_pos[:,:3] : AS v_pos EMPTY " )
-                pass 
-            else:
-                pass
-            pass
-        else:
-            print("v_pos:None skip selected point plotting")
-            pass
-        pass
-
-
-        if e.pid > -1: 
-            onephotonplot(pl, e)
-        pass 
-
-
-
-        if MODE == 2:
-            fig.show()
-        elif MODE == 3:
-            pl.show()
-        pass
-    pass    ## ee loop 
-pass
diff --git a/g4cx/tests/G4CXTest.sh b/g4cx/tests/G4CXTest.sh
deleted file mode 100755
index 06ea7f674e..0000000000
--- a/g4cx/tests/G4CXTest.sh
+++ /dev/null
@@ -1,231 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-G4CXTest.sh : Standalone bi-simulation with G4CXApp::Main
-===========================================================
-
-::
-
-    ~/opticks/g4cx/tests/G4CXTest.sh run
-
-    PIDX=552 ~/opticks/g4cx/tests/G4CXTest.sh run ## run with single photon debug
-
-    ~/opticks/g4cx/tests/G4CXTest.sh grab
-
-
-    PICK=B MODE=2 ~/opticks/g4cx/tests/G4CXTest.sh ana
-         2D (matplotlib) plot Geant4 photon histories
-
-
-
-    MODE=2 ./G4CXTest.sh ana
-
-    MODE=2 APID=62 ./G4CXTest.sh tra
-
-
-
-Screen captures
------------------
-
-::
-
-    ~/opticks/g4cx/tests/G4CXTest.sh grab  # from remote
-    PICK=A MODE=2 APID=1000 FOCUS=0,0,80                  ~/opticks/g4cx/tests/G4CXTest.sh ana
-    PICK=A MODE=2 APID=1000 FOCUS=0,0,80                  ~/opticks/g4cx/tests/G4CXTest.sh mpcap
-    PICK=A MODE=2 APID=1000 FOCUS=0,0,80 PUB=Tub3_delta_1 ~/opticks/g4cx/tests/G4CXTest.sh mppub
-
-Input scripts
----------------
-
-
-~/opticks/u4/tests/FewPMT.sh
-    configure geometry
-
-~/opticks/u4/tests/storch_FillGenstep.sh
-    configure torch photons, controlled via LAYOUT and CHECK envvars
-
-
-
-
-
-EOU
-}
-
-SDIR=$(dirname $(realpath $BASH_SOURCE))
-U4TDIR=$(realpath $SDIR/../../u4/tests)
-BINDIR=$(realpath $SDIR/../../bin)
-
-bin=G4CXTest
-ana=$SDIR/G4CXTest.py
-tra=$SDIR/G4CXSimtraceMinTest.py
-
-
-#defarg="info_dbg_ana"
-defarg="info_run_ana"
-[ -n "$BP" ] && defarg="info_dbg_ana"
-arg=${1:-$defarg}
-
-source $HOME/.opticks/GEOM/GEOM.sh
-
-geomscript=$U4TDIR/$GEOM.sh
-if [ -f "$geomscript" ]; then
-    source $geomscript
-else
-    echo $BASH_SOURCE : no geomscript $geomscript
-fi
-
-
-export VERSION=0
-
-tmp=/tmp/$USER/opticks
-export TMP=${TMP:-$tmp}
-
-export OPTICKS_EVENT_NAME=DebugPhiloxShakedownIPH
-export BASE=$TMP/GEOM/$GEOM/$bin
-export EVT=000
-export AFOLD=$BASE/ALL${VERSION}_${OPTICKS_EVENT_NAME}/A${EVT}
-export BFOLD=$BASE/ALL${VERSION}_${OPTICKS_EVENT_NAME}/B${EVT}
-export TFOLD=$BASE/0/p999
-
-if [ -z "$APID" -a -z "$BPID" -a -n "$PIDX" ]; then
-    echo $BASH_SOURCE : PIDX $PIDX is defined and APID BPID are both not defined so setting them to PIDX
-    export APID=$PIDX
-    export BPID=$PIDX
-fi
-
-
-
-#num_photons=1
-#num_photons=10
-#num_photons=100
-#num_photons=1000      # 1k
-#num_photons=10000    # 10k
-#num_photons=50000    # 50k
-num_photons=100000    # 100k
-#num_photons=1000000  # 1M
-
-NUM_PHOTONS=${NUM_PHOTONS:-$num_photons}
-
-export G4CXOpticks__setGeometry_saveGeometry=$HOME/.opticks/GEOM/$GEOM
-
-export OPTICKS_RUNNING_MODE=SRM_TORCH
-export OPTICKS_MAX_BOUNCE=31
-export OPTICKS_EVENT_MODE=DebugLite
-export OPTICKS_INTEGRATION_MODE=3
-
-export OPTICKS_MAX_PHOTON=${NUM_PHOTONS}
-#export OPTICKS_MAX_PHOTON=100000
-
-export SEvent_MakeGenstep_num_ph=${NUM_PHOTONS}
-
-#check=rain_point_xpositive_100
-#check=rain_line
-#check=tub3_side_line
-#check=circle_inwards_100
-#check=circle_outwards_1
-#check=rain_line_205
-#check=rain_down_100
-check=rectangle_inwards
-
-export LAYOUT=one_pmt
-export CHECK=${CHECK:-$check}
-source $U4TDIR/storch_FillGenstep.sh
-echo $BASH_SOURCE : CHECK $CHECK
-env | grep storch
-
-if [ "$storch_FillGenstep_type" == "" ]; then
-    echo $BASH_SOURCE : FATAL : for CHECK $CHECK LAYOUT $LAYOUT GEOM $GEOM
-    exit 1
-fi
-
-
-export U4SensorIdentifierDefault__GLOBAL_SENSOR_BOUNDARY_LIST=$(cat << EOL
-
-    Pyrex/HamamatsuR12860_PMT_20inch_photocathode_mirror_logsurf/HamamatsuR12860_PMT_20inch_photocathode_mirror_logsurf/Vacuum
-    Pyrex/NNVTMCPPMT_PMT_20inch_photocathode_mirror_logsurf/NNVTMCPPMT_PMT_20inch_photocathode_mirror_logsurf/Vacuum
-    Pyrex/PMT_3inch_photocathode_logsurf2/PMT_3inch_photocathode_logsurf1/Vacuum
-    Pyrex/PMT_20inch_veto_photocathode_logsurf2/PMT_20inch_veto_photocathode_logsurf1/Vacuum
-
-    Pyrex/nnvt_photocathode_mirror_logsurf/nnvt_photocathode_mirror_logsurf/Vacuum
-
-EOL
-)
-
-
-
-
-logging(){
-   export Dummy=INFO
-   #export G4CXOpticks=INFO
-   #export X4PhysicalVolume=INFO   # look into sensor boundary to understand lpmtid -1
-   #export QSim=INFO
-   #export QEvt=INFO
-   #export SSim__stree_level=2    # U4Tree/stree level   debugging U4Tree::identifySensitiveGlobals
-   #export SEvt=INFO
-
-   export U4Recorder__PIDX_ENABLED=1
-}
-logging
-
-# dont need to redo the simtrace until geometry changed
-#export U4Recorder__EndOfRunAction_Simtrace=1
-#export CEGS=16:0:9:100
-
-
-vars="BASH_SOURCE SDIR U4TDIR BINDIR GEOM bin ana tra geomscript BASE FOLD AFOLD BFOLD TFOLD PMTSimParamData_BASE"
-
-if [ "${arg/info}" != "$arg" ]; then
-    for var in $vars ; do printf "%20s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/run}" != "$arg" ]; then
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE : run error && exit 1
-fi
-
-if [ "${arg/dbg}" != "$arg" ]; then
-    source dbg__.sh
-    dbg__  $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE : dbg error && exit 2
-fi
-
-if [ "${arg/grab}" != "$arg" ]; then
-    source rsync.sh $BASE
-    [ $? -ne 0 ] && echo $BASH_SOURCE : grab error && exit 3
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $ana
-    [ $? -ne 0 ] && echo $BASH_SOURCE : ana error && exit 4
-fi
-
-if [ "${arg/pdb}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $tra
-    [ $? -ne 0 ] && echo $BASH_SOURCE : tra error && exit 4
-fi
-
-
-if [ "$arg" == "pvcap" -o "$arg" == "pvpub" -o "$arg" == "mpcap" -o "$arg" == "mppub" ]; then
-    cap_ctx=G4CXTest_${GEOM}_${LAYOUT}_${CHECK}
-    case $PICK in
-      A) cap_base=$AFOLD/figs ; cap_stem=${cap_ctx}_A${APID} ;;
-      B) cap_base=$BFOLD/figs ; cap_stem=${cap_ctx}_B${BPID} ;;
-    esac
-    if [ -z "$cap_base" -o -z "$cap_stem" ]; then
-       echo $BASH_SOURCE : ERROR :  pvcap/pvpub/mpcap/mppub require PICK=A or PICK=B : AB OR BA are not allowed
-       exit 2
-    fi
-    export CAP_STEM=$cap_stem   # stem of the .png screencapture
-    export CAP_BASE=$cap_base
-    export CAP_REL=ntds3
-    case $arg in
-       pvcap) source pvcap.sh cap  ;;
-       mpcap) source mpcap.sh cap  ;;
-       pvpub) source pvcap.sh env  ;;
-       mppub) source mpcap.sh env  ;;
-    esac
-    if [ "$arg" == "pvpub" -o "$arg" == "mppub" ]; then
-        source epub.sh
-    fi
-fi
-
-exit 0
diff --git a/g4cx/tests/G4CXTest_GEOM.py b/g4cx/tests/G4CXTest_GEOM.py
deleted file mode 100644
index 3fdbdb6c11..0000000000
--- a/g4cx/tests/G4CXTest_GEOM.py
+++ /dev/null
@@ -1,229 +0,0 @@
-#!/usr/bin/env python
-"""
-G4CXTest_GEOM.py
-======================
-
-This script is intended for simple plotting and 
-statistical SEvt comparison. 
-
-The alternate script G4CXTest.py is used for 
-more detailed plotting such as single photon path 
-illustration. 
-
-::
-
-     PICK=AB HSEL="TO BT BT SA" ~/o/G4CXTest_GEOM.sh ana
-
-
-"""
-import os, logging, textwrap, numpy as np
-from opticks.ana.fold import Fold
-from opticks.sysrap.sevt import SEvt, SAB
-from opticks.ana.nbase import chi2_pvalue
-
-from opticks.ana.p import *  # including cf boundary___
-
-
-MODE = int(os.environ.get("MODE","3"))
-SEL = int(os.environ.get("SEL","0"))
-HSEL = os.environ.get("HSEL","")    # History selection 
-PICK = os.environ.get("PICK","A")
-SAB_ = "SAB" in os.environ
-
-H,V = 0,2  # X, Z
-
-
-
-if MODE in [2,3]:
-    try:
-        import pyvista as pv
-        from opticks.ana.pvplt import pvplt_plotter, pvplt_viewpoint, mpplt_plotter, mpplt_focus_aspect
-    except ImportError:
-        pv = None
-    pass
-else:
-    pv = None
-pass
-
-
-def eprint(expr, _locals, _globals ):
-    print(expr)
-    try:
-       val = eval(expr,_locals,_globals)
-    except AttributeError:
-       val = "eprint:AttributeError"
-    pass
-    print(val)
-pass
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    print("MODE:%s SEL:%s PICK:%s SAB_:%s " % (MODE, SEL, PICK, SAB_) ) 
-
-    if PICK == "A" or PICK == "AB" or SAB_:
-        a = SEvt.Load("$AFOLD", symbol="a")
-        print(repr(a))
-    else: 
-        a = None
-    pass
-
-    if PICK == "B" or PICK == "AB" or SAB_:
-        b = SEvt.Load("$BFOLD", symbol="b")
-        print(repr(b))
-    else:
-        b = None
-    pass
-
-
-    if not HSEL == "":
-        print("doing HSEL [%s] history selection " % HSEL )
-
-        wa = a.q_startswith_or(HSEL) if not a is None else None
-        wa_shape = "-" if wa is None else repr(wa.shape)
-        print("wa.shape %s " % wa_shape)
-
-        wb = b.q_startswith_or(HSEL) if not b is None else None
-        wb_shape = "-" if wb is None else repr(wb.shape)
-        print("wb.shape %s " % wb_shape)
-
-        ra = a.f.record[wa] if not a is None else None
-        ra_shape = "-" if ra is None else repr(ra.shape)
-        print("ra.shape %s " % ra_shape)
-
-        rb = b.f.record[wb] if not b is None else None
-        rb_shape = "-" if rb is None else repr(rb.shape)
-        print("rb.shape %s " % rb_shape)
-
-        ns = len(HSEL.split(" "))
-        st = slice(0,ns)
-        bnd_ra = ra[:,st,3,0].view(np.uint32) >> 16 if not ra is None else None
-        bnd_rb = rb[:,st,3,0].view(np.uint32) >> 16 if not rb is None else None 
-        assert np.all( bnd_rb == 0 ) # unfortunately no boundary info for B, YET  
-
-        lbnd_ra = ra[:,st.stop-1,3,0].view(np.uint32) >> 16 if not ra is None else None
-        u_lbnd_ra, n_lbnd_ra = np.unique(lbnd_ra, return_counts=True) 
-
-        for i in range(len(u_lbnd_ra)):
-            print(" u_lbnd_ra[%2d] %3d   n_lbnd_ra[%2d] %7d   cf.sim.bndnamedict.get(%3d) : %s " % 
-                     ( i, u_lbnd_ra[i], i, n_lbnd_ra[i], u_lbnd_ra[i], cf.sim.bndnamedict.get(u_lbnd_ra[i], "err-bnd") ))
-            pass
-        pass 
-
-
-        rra = np.sqrt(np.sum(ra[:,st,0,:3]*ra[:,st,0,:3],axis=2)) if not ra is None else None
-        rra_shape = "-" if rra is None else repr(rra.shape)  
-        print("rra.shape %s " % rra_shape )
-
-        rrb = np.sqrt(np.sum(rb[:,st,0,:3]*rb[:,st,0,:3],axis=2)) if not rb is None else None
-        rrb_shape = "-" if rrb is None else repr(rrb.shape)  
-        print("rrb.shape %s " % rrb_shape )
-
-    else:
-        print("set HSEL to make history selection ")
-        pass
-    pass 
-   
-    ee = {'A':a, 'B':b} 
-
-    if SAB_: 
-        print("[--- ab = SAB(a,b) ----")
-        ab = None if a is None or b is None else SAB(a,b) 
-        print("]--- ab = SAB(a,b) ----")
-
-        print("[----- repr(ab) ")
-        print(repr(ab))
-        print("]----- repr(ab) ")
-    else:
-        print("ab = SAB(a,b) ## skipped as SAB not in os.environ")
-    pass
-
-
-    # EXPR_ = r"""
-    # np.c_[np.unique(a.q, return_counts=True)] 
-    # np.c_[np.unique(b.q, return_counts=True)] 
-    # """
-    # EXPR = list(filter(None,textwrap.dedent(EXPR_).split("\n")))
-    # for expr in EXPR:eprint(expr, locals(), globals() )
-
-    context = "PICK=%s MODE=%d  ~/opticks/g4cx/tests/G4CXTest_GEOM.sh " % (PICK, MODE )
-    print(context)
-
-    HITONLY = "HITONLY" in os.environ
-
-    for Q in PICK:
-        e = ee.get(Q,None)
-        if e is None:continue
-
-        elabel = "%s : %s " % ( e.symbol.upper(), e.f.base )
-        label = context + " ## " + elabel
-
-
-        if hasattr(e.f, 'hit'): 
-            hit = e.f.hit[:,0,:3]
-        else:
-            hit = None
-        pass
-
-        if hasattr(e.f, 'photon') and not HITONLY: 
-            pos = e.f.photon[:,0,:3]
-        else:
-            pos = None
-        pass
-
-        if hasattr(e.f, 'record') and not HITONLY:
-            sel = np.where(e.f.record[:,:,2,3] > 0) # select on wavelength to avoid unfilled zeros
-            poi = e.f.record[:,:,0,:3][sel]
-        else:
-            poi = None
-        pass
-
-        if MODE == 2:
-            pl = mpplt_plotter(label=label)
-            fig, axs = pl
-            assert len(axs) == 1
-            ax = axs[0]
-
-            xlim, ylim = mpplt_focus_aspect()
-            if not xlim is None:
-                ax.set_xlim(xlim) 
-                ax.set_ylim(ylim) 
-            else:
-                log.info("mpplt_focus_aspect not enabled, use eg FOCUS=0,0,100 to enable ")
-            pass 
-
-            if SEL == 1:
-                #sel = np.logical_and( np.abs(u_pos[:,H]) < 500, np.abs(u_pos[:,V]) < 500 )
-                sel = pos[:,V] > 28000
-
-                u_pos = pos[sel]
-            else:
-                u_pos = pos
-            pass
-
-            ax.scatter( u_pos[:,H], u_pos[:,V], s=0.1 )
-
-            fig.show()
-
-        elif MODE == 3 and not pv is None:
-            pl = pvplt_plotter(label)
-            pvplt_viewpoint(pl) # sensitive EYE, LOOK, UP, ZOOM envvars eg EYE=0,-3,0 
-
-            if not poi is None:
-                pl.add_points( poi, color="green", point_size=3.0 )
-            pass
-            if not pos is None:
-                pl.add_points( pos, color="red", point_size=3.0 )
-            pass
-            if not hit is None:
-                pl.add_points( hit, color="cyan", point_size=3.0 )
-            pass
-
-            if not "NOGRID" in os.environ:
-                pl.show_grid()
-            pass
-            cp = pl.show()
-        pass
-    pass
-        
-
diff --git a/g4cx/tests/G4CXTest_GEOM.sh b/g4cx/tests/G4CXTest_GEOM.sh
deleted file mode 100755
index ae65463679..0000000000
--- a/g4cx/tests/G4CXTest_GEOM.sh
+++ /dev/null
@@ -1,489 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-G4CXTest_GEOM.sh : Standalone optical only bi-simulation with G4CXApp::Main and current GEOM
-================================================================================================
-
-Standalone optical Geant4 initialization is faster than embedded Geant4 + Opticks but still ~120s to voxelize.
-
-
-Usage examples
-----------------
-
-Typically on workstation::
-
-    ~/opticks/g4cx/tests/G4CXTest_GEOM.sh
-    ~/opticks/g4cx/tests/G4CXTest_GEOM.sh dbg
-    LOG=1 BP=G4OpBoundaryProcess::PostStepDoIt ~/opticks/g4cx/tests/G4CXTest_GEOM.sh dbg
-
-    PRECOOKED=1 ~/o/G4CXTest_GEOM.sh
-
-    ~/opticks/g4cx/tests/G4CXTest_GEOM.sh info
-    ~/opticks/g4cx/tests/G4CXTest_GEOM.sh chi2
-
-
-Following inclusion of _${TEST} in LOGDIR can compare different tests easily
------------------------------------------------------------------------------
-
-::
-
-    TEST=jan20 ~/opticks/g4cx/tests/G4CXTest_GEOM.sh chi2
-
-    TEST=feb20 ~/opticks/g4cx/tests/G4CXTest_GEOM.sh chi2  ## small diffs only following DEBUG_TAG switch off from different randoms
-    TEST=ref1  ~/opticks/g4cx/tests/G4CXTest_GEOM.sh chi2  ## same as feb20
-
-
-
-Reporting on the nature of the geometry conversion
-------------------------------------------------------
-
-Q: This is running from GDML, is the force triangulation done ?
-A: probably not without the config::
-
-   export stree__force_triangulate_solid='filepath:$HOME/.opticks/GEOM/${GEOM}_meshname_stree__force_triangulate_solid.txt'
-
-
-TODO: confirmation in metadata of what is triangulated in the geometry, stree level for details and CSGFoundry::descSolidIntent
-for the collective situation
-
-
-The info would be persisted with the stree info, but no persist ? Can be reported by stree::desc_lvid::
-
-     318     const char*      force_triangulate_solid ;
-     319     std::vector<int> force_triangulate_lvid ;
-
-
-
-
-Laptop::
-
-    ~/opticks/g4cx/tests/G4CXTest_GEOM.sh grab
-    EYE=0,-400,0 ~/opticks/g4cx/tests/G4CXTest_GEOM.sh ana
-    ~/opticks/g4cx/tests/G4CXTest_GEOM.sh pvcap
-
-
-Where possible its better to use pure Opticks simulation (no bi-simulation)
-booting from a persisted geometry during testing due to the ~2s initialization time, eg with::
-
-    ~/opticks/CSGOptiX/cxs_min.sh
-
-
-chi2 subcommand uses a faster C++ sseq index comparison implementation of the python/NumPy chi2 calc
----------------------------------------------------------------------------------------------------------
-
-Uses::
-
-   $SDIR/../../sysrap/tests/sseq_index_test.sh info_run_ana
-
-*  ~/opticks/sysrap/tests/sseq_index_test.sh
-
-
-
-storch::generate is used for both GPU and CPU generation
----------------------------------------------------------
-
-* On GPU the generation is invoked at highest level CSGOptiX7.cu:simulate
-* On CPU for example the stack is below, using MOCK_CURAND::
-
-  G4RunManager::BeamOn
-  ...
-  G4RunManager::GenerateEvent
-  G4CXApp::GeneratePrimaries
-  U4VPrimaryGenerator::GeneratePrimaries
-  SGenerate::GeneratePhotons
-  storch::generate
-
-
-
-EOU
-}
-
-SDIR=$(dirname $(realpath $BASH_SOURCE))
-## not the normal cd to the SDIR, as need to cd to LOGDIR but use scripts from SDIR
-
-bin=G4CXTest
-ana_script=$SDIR/G4CXTest_GEOM.py
-dna_script=$SDIR/G4CXTest.py
-
-source $HOME/.opticks/GEOM/GEOM.sh   # set GEOM and associated envvars for finding geometry
-#export ${GEOM}_GDMLPathFromGEOM=$HOME/.opticks/GEOM/$GEOM/origin.gdml
-# no longer needed as using spath::GDMLPathFromGEOM
-
-_cfb=${GEOM}_CFBaseFromGEOM
-cfb=${!_cfb}
-tessname=$cfb/CSGFoundry/tessname.txt
-
-if [ -f "$tessname" ]; then
-    export stree__force_triangulate_solid="filepath:$tessname"
-    export SSim__stree_level=1
-else
-    echo $BASH_SOURCE tessname $tessname DOES NOT EXIST
-fi
-
-
-
-
-
-## CURRENTLY CAN MANUALLY CHECK WHAT IS TRIANGULATED BY UPPING THE LOGGING
-## TODO: some reporting in metadata of which solids are triangulated that gets saved with event metadata
-
-
-#test=small
-test=ref1
-#test=ref5
-#test=large_scan
-TEST=${TEST:-$test}
-
-if [ "$TEST" == "ref1" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=1
-   opticks_num_photon=M1
-   opticks_max_slot=M1
-
-elif [ "$TEST" == "ref5" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=1
-   opticks_num_photon=M5
-   opticks_max_slot=M5
-
-
-elif [ "$TEST" == "one" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=1
-   opticks_num_photon=1
-   opticks_max_slot=1
-
-elif [ "$TEST" == "two" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=1
-   opticks_num_photon=2
-   opticks_max_slot=2
-
-elif [ "$TEST" == "small" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=1
-   opticks_num_photon=H1
-   opticks_max_slot=M1
-
-elif [ "$TEST" == "tiny_scan" ]; then
-
-   opticks_num_event=10
-   opticks_num_genstep=1x10
-   opticks_num_photon=K1:10
-   opticks_max_slot=M1
-
-elif [ "$TEST" == "large_scan" ]; then
-
-   opticks_num_event=20
-   opticks_num_genstep=1x10,10x10
-   opticks_num_photon=H1:10,M2,3,5,7,10,20,40,60,80,100
-   opticks_max_slot=M100
-
-elif [ "$TEST" == "large_evt" ]; then
-
-   opticks_num_event=1
-   opticks_num_genstep=40
-   opticks_num_photon=M180   ## M200 gives OOM with TITAN RTX 24G with debug arrays enabled
-   opticks_max_slot=M180
-
-else
-
-   echo $BASH_SOURCE ERROR TEST $TEST IS NOT HANDLED
-   echo $BASH_SOURCE ERROR TEST $TEST IS NOT HANDLED
-   echo $BASH_SOURCE ERROR TEST $TEST IS NOT HANDLED ... SLEEPING
-   sleep 100
-fi
-
-
-
-version=98
-VERSION=${VERSION:-$version}
-export VERSION    ## used in SEvt output directory name ALL$VERSION
-
-
-ctx=${OPTICKS_EVENT_CONTEXT:-Debug_Philox}
-#export OPTICKS_EVENT_NAME=$ctx  # used by SEventConfig::EventReldir "OPTICKS_EVENT_RELDIR"
-export OPTICKS_EVENT_NAME=${ctx}_${TEST}
-
-
-opticks_event_reldir=ALL${VERSION:-0}_${OPTICKS_EVENT_NAME:-none}
-export OPTICKS_EVENT_RELDIR='ALL${VERSION:-0}_${OPTICKS_EVENT_NAME:-none}'  ## this is the default in SEventConfig
-## above two lines match SEventConfig::_DefaultEventReldir
-## resolution of first line happens here for bash consumption, resolution of 2nd done in SEventConfig
-## HMM: MAYBE SIMPLIFY BY JUST DEFINING RELDIR HERE, BUT THE CODE DEFAULT IS HANDY ?
-
-TMP=${TMP:-/tmp/$USER/opticks}
-
-# /data1/blyth/tmp/GEOM/J25_3_0_Opticks_v0_3_5/G4CXTest/ALL98_Debug_Philox_ref5
-
-export SCRIPT=$(basename $BASH_SOURCE)
-export BASE=$TMP/GEOM/$GEOM
-export LOGDIR=$BASE/$bin/$opticks_event_reldir
-export AFOLD=$LOGDIR/A000
-export BFOLD=$LOGDIR/B000
-#export BFOLD=$TMP/GEOM/$GEOM/CSGOptiXSMTest/ALL/A000  ## TMP OVERRIDE COMPARE A-WITH-A from CSGOptiXSMTest
-
-pick=A
-export PICK=${PICK:-$pick}  ## PICK is only used by ana, not running
-case $PICK in
-    A) FOLD=$AFOLD ;;
-    B) FOLD=$BFOLD ;;
-   AB) FOLD=$AFOLD ;;
-esac
-export FOLD    ## changed sreport to use SREPORT_FOLD to avoid clash
-export STEM=G4CXTest_GEOM_${PICK}
-
-mkdir -p $LOGDIR
-cd $LOGDIR            ## logfile written in invoking directory
-
-
-#export G4CXOpticks__SaveGeometry_DIR=$BASE  ## optionally save geom into BASE for debug
-export G4CXApp__SensDet=PMTSDMgr             ## used for post GDML SensDet hookup
-
-
-
-knobs()
-{
-   type $FUNCNAME
-
-   local exceptionFlags
-   local debugLevel
-   local optLevel
-
-   #exceptionFlags=STACK_OVERFLOW
-   exceptionFlags=NONE
-
-   #debugLevel=DEFAULT
-   debugLevel=NONE
-   #debugLevel=FULL
-
-   #optLevel=DEFAULT
-   #optLevel=LEVEL_0
-   optLevel=LEVEL_3
-
-
-   #export PIP__max_trace_depth=1
-   export PIP__CreatePipelineOptions_exceptionFlags=$exceptionFlags # NONE/STACK_OVERFLOW/TRACE_DEPTH/USER/DEBUG
-   export PIP__CreateModule_debugLevel=$debugLevel  # DEFAULT/NONE/MINIMAL/MODERATE/FULL   (DEFAULT is MINIMAL)
-   export PIP__linkPipeline_debugLevel=$debugLevel  # DEFAULT/NONE/MINIMAL/MODERATE/FULL
-   export PIP__CreateModule_optLevel=$optLevel      # DEFAULT/LEVEL_0/LEVEL_1/LEVEL_2/LEVEL_3
-
-   #export Ctx=INFO
-   #export PIP=INFO
-   #export CSGOptiX=INFO
-}
-knobs
-
-
-case $VERSION in
- 0) opticks_event_mode=Minimal ;;
- 1) opticks_event_mode=Hit ;;
- 2) opticks_event_mode=HitPhoton ;;
- 3) opticks_event_mode=HitPhoton ;;    ## USING 3 FOR LEAK TEST
- 4) opticks_event_mode=HitPhotonSeq ;;
- 5) opticks_event_mode=HitSeq ;;
-98) opticks_event_mode=DebugLite ;;
-99) opticks_event_mode=DebugHeavy ;;
-esac
-
-
-
-
-opticks_start_index=0
-opticks_max_bounce=31
-opticks_integration_mode=3
-
-#opticks_running_mode=SRM_DEFAULT
-opticks_running_mode=SRM_TORCH
-#opticks_running_mode=SRM_INPUT_PHOTON
-#opticks_running_mode=SRM_INPUT_GENSTEP    ## NOT IMPLEMENTED FOR GEANT4
-#opticks_running_mode=SRM_GUN
-
-
-export OPTICKS_NUM_EVENT=${OPTICKS_NUM_EVENT:-$opticks_num_event}
-export OPTICKS_NUM_GENSTEP=${OPTICKS_NUM_GENSTEP:-$opticks_num_genstep}
-export OPTICKS_NUM_PHOTON=${OPTICKS_NUM_PHOTON:-$opticks_num_photon}
-
-export OPTICKS_RUNNING_MODE=${OPTICKS_RUNNING_MODE:-$opticks_running_mode}   # SRM_TORCH/SRM_INPUT_PHOTON/SRM_INPUT_GENSTEP
-export OPTICKS_EVENT_MODE=${OPTICKS_EVENT_MODE:-$opticks_event_mode}         # what arrays are saved eg Hit,HitPhoton,HitPhotonSeq
-
-
-export OPTICKS_MAX_SLOT=${OPTICKS_MAX_SLOT:-$opticks_max_slot}
-export OPTICKS_START_INDEX=${OPTICKS_START_INDEX:-$opticks_start_index}
-export OPTICKS_MAX_BOUNCE=${OPTICKS_MAX_BOUNCE:-$opticks_max_bounce}
-export OPTICKS_INTEGRATION_MODE=${OPTICKS_INTEGRATION_MODE:-$opticks_integration_mode}
-
-
-if [ -n "$PRECOOKED" ]; then
-    ## SPECIAL SETTING TO GET G4CXApp::GeneratePrimaries
-    ## TO USE THE SAME RANDOMS AS CURAND : SO CAN COMPARE
-    ## WITH THE SAME START PHOTONS
-    export SGenerate__GeneratePhotons_RNG_PRECOOKED=1
-    export s_seq__SeqPath_DEFAULT_LARGE=1   ## enable M1, without this are limited to K100
-fi
-
-
-if [ "$OPTICKS_RUNNING_MODE" == "SRM_TORCH" ]; then
-    #export SEvent_MakeGenstep_num_ph=$NUM   ## trumped by OPTICKS_NUM_PHOTON
-    #src="rectangle"
-    #src="disc"
-    src="sphere"
-
-    if [ "$src" == "rectangle" ]; then
-        export storch_FillGenstep_pos=0,0,0
-        export storch_FillGenstep_type=rectangle
-        export storch_FillGenstep_zenith=-20,20
-        export storch_FillGenstep_azimuth=-20,20
-    elif [ "$src" == "disc" ]; then
-        export storch_FillGenstep_type=disc
-        export storch_FillGenstep_radius=50
-        export storch_FillGenstep_zenith=0,1       # radial range scale
-        export storch_FillGenstep_azimuth=0,1      # phi segment twopi fraction
-        export storch_FillGenstep_mom=1,0,0
-        export storch_FillGenstep_pos=-80,0,0
-    elif [ "$src" == "sphere" ]; then
-        export storch_FillGenstep_type=sphere
-        export storch_FillGenstep_radius=100    # +ve for outwards
-        export storch_FillGenstep_pos=0,0,0
-        export storch_FillGenstep_distance=1.00 # frac_twopi control of polarization phase(tangent direction)
-    fi
-
-elif [ "$OPTICKS_RUNNING_MODE" == "SRM_INPUT_PHOTON" ]; then
-    echo -n
-
-    ## UNTESTED
-    export OPTICKS_INPUT_PHOTON=RainXZ_Z230_10k_f8.npy
-    export OPTICKS_INPUT_PHOTON_FRAME=NNVT:0:1000
-
-elif [ "$OPTICKS_RUNNING_MODE" == "SRM_INPUT_GENSTEP" ]; then
-    echo -n
-
-elif [ "$OPTICKS_RUNNING_MODE" == "SRM_GUN" ]; then
-    echo -n
-fi
-
-logging()
-{
-   #export SSim=INFO
-   #export QSim=INFO
-   #export QPMT=INFO
-   #export SEvt=INFO
-   #export U4Recorder=INFO
-   #export U4StepPoint=INFO
-   #export U4Physics=INFO
-   #export CSGFoundry=INFO
-   #export CSGTarget=INFO
-
-   #export U4GDML__VERBOSE=1
-   #export SPMTAccessor__VERBOSE=1
-   #export SEvt__LIFECYCLE=1  ## sparse SEvt debug output, works well alone
-
-   export G4CXOpticks=INFO
-
-}
-[ -n "$LOG" ] && logging
-[ -n "$LIFECYCLE" ] && export SEvt__LIFECYCLE=1
-
-allarg="info_env_run_dbg_report_plot_grab_gevt_chi2_ana_dna_mpcap_mppub_pvcap_pvpub"
-defarg="info_env_run_report_ana"
-#defarg="info_dbg_ana"
-[ -n "$BP" ] && defarg="info_dbg"
-
-arg=${1:-$defarg}
-
-
-
-vars="BASH_SOURCE allarg defarg arg SDIR GEOM ${GEOM}_CFBaseFromGEOM ${GEOM}_GDMLPathFromGEOM bin VERSION"
-vars="$vars TMP BASE PWD"
-vars="$vars OPTICKS_EVENT_NAME OPTICKS_EVENT_RELDIR"
-vars="$vars LOGDIR AFOLD BFOLD CUDA_VISIBLE_DEVICES ana_script dna_script TEST"
-
-
-if [ "${arg/info}" != "$arg" ]; then
-    for var in $vars ; do printf "%50s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/env}" != "$arg" ]; then
-    env | grep OPTICKS | perl -n -e 'm/(\S*)=(\S*)/ && printf("%50s : %s\n", $1, $2) ' -
-fi
-
-if [ "${arg/run}" != "$arg" ]; then
-    rm -f $bin.log
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1
-    pwd
-    ls -alst $bin.log
-fi
-
-if [ "${arg/dbg}" != "$arg" ]; then
-    source dbg__.sh
-    dbg__ $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE dbg error && exit 2
-fi
-
-if [ "${arg/report}" != "$arg" ]; then
-    sreport
-    [ $? -ne 0 ] && echo $BASH_SOURCE sreport error && exit 1
-fi
-
-if [ "${arg/plot}" != "$arg" ]; then
-    runprof=1 $SDIR/../../sysrap/tests/sreport.sh ana
-    [ $? -ne 0 ] && echo $BASH_SOURCE sreport.plot error && exit 1
-fi
-
-if [ "${arg/grab}" != "$arg" ]; then
-    echo $FUNCNAME - grab - WARNING - debug events can be VERY LARGE - use gevt to rsync single event
-    source $SDIR/../../bin/rsync.sh $LOGDIR
-    [ $? -ne 0 ] && echo $BASH_SOURCE grab error && exit 3
-fi
-
-if [ "${arg/gevt}" != "$arg" ]; then
-    source $SDIR/../../bin/rsync.sh $AFOLD
-    source $SDIR/../../bin/rsync.sh $BFOLD
-fi
-
-if [ "${arg/chi2}" != "$arg" ]; then
-    #$SDIR/../../sysrap/tests/sseq_index_test.sh info_run_ana
-    sseq_index_test.sh info_run_ana
-    [ $? -ne 0 ] && echo $BASH_SOURCE sseq_index_test chi2 ERROR && exit 3
-fi
-
-if [ "${arg/pdb}" != "$arg" ]; then
-    export SAB=1
-    PYTHONPATH=$OPTICKS_PREFIX/py ${IPYTHON:-ipython} --pdb -i $ana_script
-    [ $? -ne 0 ] && echo $BASH_SOURCE pdb error with ana_script $ana_script && exit 4
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-    ${PYTHON:-python} $ana_script
-    [ $? -ne 0 ] && echo $BASH_SOURCE ana error with ana_script $ana_script && exit 4
-fi
-
-if [ "${arg/dna}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $dna_script
-    [ $? -ne 0 ] && echo $BASH_SOURCE dna error with dna_script $dna_script && exit 4
-fi
-
-
-
-
-if [ "$arg" == "mpcap" -o "$arg" == "mppub" -o "$arg" == "pvcap" -o "$arg" == "pvpub" ]; then
-    export CAP_BASE=$FOLD/figs
-    export CAP_REL=G4CXTest_GEOM
-    export CAP_STEM=$STEM
-    case $arg in
-       mpcap) source mpcap.sh cap  ;;
-       pvcap) source pvcap.sh cap  ;;
-       mppub) source mpcap.sh env  ;;
-       pvpub) source pvcap.sh env  ;;
-    esac
-    if [ "$arg" == "mppub" -o "$arg" == "pvpub" ]; then
-        source epub.sh
-    fi
-fi
-
-exit 0
diff --git a/g4cx/tests/G4CXTest_raindrop.py b/g4cx/tests/G4CXTest_raindrop.py
deleted file mode 100644
index 5e7bc7dac5..0000000000
--- a/g4cx/tests/G4CXTest_raindrop.py
+++ /dev/null
@@ -1,158 +0,0 @@
-#!/usr/bin/env python
-"""
-G4CXTest_raindrop.py
-======================
-
-
-"""
-import os, logging, textwrap, numpy as np
-from opticks.ana.fold import Fold
-from opticks.sysrap.sevt import SEvt, SAB
-from opticks.ana.nbase import chi2_pvalue
-
-MODE = int(os.environ.get("MODE","3"))
-PICK = os.environ.get("PICK","B")
-
-if MODE in [2,3]:
-    try:
-        import opticks.ana.pvplt as pvp
-    except ImportError:
-        pvp = None
-    pass
-else:
-    pvp = None
-pass
-
-
-def eprint(expr, l, g ):
-    print(expr)
-    try:
-       val = eval(expr,l,g)
-    except AttributeError:
-       val = "eprint:AttributeError"
-    pass
-    print(val)
-pass
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    a = SEvt.Load("$AFOLD", symbol="a")
-    print(repr(a))
-    b = SEvt.Load("$BFOLD", symbol="b")
-    print(repr(b))
-    ee = {'A':a, 'B':b} 
-
-    print("[--- ab = SAB(a,b) ----")
-
-    if not a is None and not b is None:
-        ab = SAB(a,b)
-    else:
-        ab = None
-    pass 
-    print("]--- ab = SAB(a,b) ----")
-
-    print("[----- repr(ab) ")
-    print(repr(ab))
-    print("]----- repr(ab) ")
-
-
-    EXPR_ = r"""
-    np.c_[np.unique(a.q, return_counts=True)] 
-    np.c_[np.unique(b.q, return_counts=True)] 
-    """
-    EXPR = list(filter(None,textwrap.dedent(EXPR_).split("\n")))
-    for expr in EXPR:eprint(expr, locals(), globals() )
-
-
-    #select = "WL"            ## select on wavelength to avoid unfilled zeros
-    #select = "TO BT BT SA"   ## select on photon history
-    select = "TO BT SA,TO BR BT SA" 
-    MSELECT = os.environ.get("SELECT", select )  
-
-    sli = slice(0,100000)   # restrict to 1M to stay interactive
-
-    speed_ = lambda r,i:np.sqrt(np.sum( (r[:,i+1,0,:3]-r[:,i,0,:3])*(r[:,i+1,0,:3]-r[:,i,0,:3]), axis=1))/(r[:,i+1,0,3]-r[:,i,0,3])
-
-    for Q in PICK:
-        e = ee.get(Q,None)
-        if e is None:continue
-
-        for SELECT in MSELECT.split(","):
-            context = "PICK=%s MODE=%d SELECT=\"%s\" ~/opticks/g4cx/tests/G4CXTest_raindrop.sh " % (Q, MODE, SELECT )
-            print(context)
-
-            if SELECT == "WL": 
-                sel = np.where(e.f.record[:,:,2,3] > 0) 
-                sel_p, sel_r = sel  # 2-tuple selecting photon and record points   
-                sel_p = sel_p[sli]
-                sel_r = sel_r[sli]
-            else:
-                sel_p = e.q_startswith(SELECT)  
-                sel_p = sel_p[sli]
-            
-                SELECT_ELEM = SELECT.split()
-                SELECT_POINT = len(SELECT_ELEM)
-            
-                sel_r = slice(0,SELECT_POINT)
-                r = e.f.record[sel_p,sel_r]  
-
-                if "SAVE_SEL" in os.environ:
-                    sel_dir = os.path.join(e.f.base, SELECT.replace(" ", "_") )
-                    if not os.path.isdir(sel_dir):
-                        os.makedirs(sel_dir)
-                    pass
-                    sel_path = os.path.join( sel_dir, "record.npy" )
-                    print("REC=%s ~/o/examples/UseGeometryShader/run.sh" % sel_dir) 
-                    np.save( sel_path, e.f.record[sel_p] )
-                pass
-
-                for i in range(SELECT_POINT-1):
-                    speed = speed_(r,i)
-                    speed_min = speed.min() if len(speed) > 0 else -1 
-                    speed_max = speed.max() if len(speed) > 0 else -1 
-                    fmt = "speed len/min/max for : %d -> %d : %s -> %s : %8d %7.3f %7.3f "
-                    print(fmt % (i,i+1,SELECT_ELEM[i],SELECT_ELEM[i+1],len(speed),speed_min, speed_max ))
-                pass
-
-                if Q == "B": 
-                    kludge = e.f.NPFold_meta.U4Recorder__PreUserTrackingAction_Optical_UseGivenVelocity_KLUDGE
-                    print("e.f.NPFold_meta.U4Recorder__PreUserTrackingAction_Optical_UseGivenVelocity_KLUDGE:%s " % kludge )
-                    print("e.f.NPFold_meta.G4VERSION_NUMBER:%s " % e.f.NPFold_meta.G4VERSION_NUMBER )
-                pass
-            pass
-
-            _pos = e.f.photon[sel_p,0,:3]        ## end position 
- 
-            _beg = e.f.record[sel_p,0,0,:3]      ## begin positions 
-            _poi = e.f.record[sel_p,sel_r,0,:3]  ## all positions 
-
-            print("_pos.shape %s " % str(_pos.shape))
-            print("_beg.shape %s " % str(_beg.shape))
-            print("_poi.shape %s " % str(_poi.shape))
-
-            pos = _pos.reshape(-1,3)
-            beg = _beg.reshape(-1,3)
-            poi = _poi.reshape(-1,3)
-
-            elabel = "%s : %s " % ( e.symbol.upper(), e.f.base )
-            label = context + " ## " + elabel
-
-            if MODE == 3 and not pvp is None:
-                if len(poi) == 0:
-                    print("FAILED TO SELECT ANY POI : SKIP PLOTTING" )
-                else:
-                    pl = pvp.pvplt_plotter(label)
-                    pvp.pvplt_viewpoint(pl) # sensitive EYE, LOOK, UP, ZOOM envvars eg EYE=0,-3,0 
-                    pl.add_points( poi, color="green", point_size=3.0 )
-                    pl.add_points( pos, color="red", point_size=3.0 )
-                    pl.add_points( beg, color="blue", point_size=3.0 )
-                    if not "NOGRID" in os.environ: pl.show_grid()
-                    cp = pl.show()
-                pass
-            pass
-        pass
-    pass
-        
-
diff --git a/g4cx/tests/G4CXTest_raindrop.sh b/g4cx/tests/G4CXTest_raindrop.sh
deleted file mode 100755
index 34e87aa119..0000000000
--- a/g4cx/tests/G4CXTest_raindrop.sh
+++ /dev/null
@@ -1,274 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-G4CXTest_raindrop.sh : Standalone bi-simulation with G4CXApp::Main
-===================================================================
-
-Certain special GEOM strings such as "RaindropRockAirWater"
-are recognized by U4VolumeMaker::PVS_  which is called by U4VolumeMaker::PV
-
-For the configuratuin of the raindrop see U4VolumeMaker::RaindropRockAirWater_Configure
-
-Currently this uses the default torch genstep for the initial photons,
-see storch::FillGenstep for how to customize that.
-
-::
-
-    ~/opticks/g4cx/tests/G4CXTest_raindrop.sh
-    ~/opticks/g4cx/tests/G4CXTest_raindrop_CPU.sh
-
-    B_SIMTRACE=1 G4CXTest_raindrop.sh
-
-
-
-    EYE=0,-400,0 ~/opticks/g4cx/tests/G4CXTest_raindrop.sh ana
-
-    PICK=A MODE=3 SELECT="TO BT BR BR BR BR BT SA" ~/opticks/g4cx/tests/G4CXTest_raindrop.sh
-    PICK=B MODE=3 SELECT="TO BT BR BR SA"          ~/opticks/g4cx/tests/G4CXTest_raindrop.sh ana
-
-    NUM=1000000 PICK=B MODE=3 SELECT="TO BT BR BR BR BR BT SA" ~/opticks/g4cx/tests/G4CXTest_raindrop.sh
-
-EOU
-}
-
-cd $(dirname $(realpath $BASH_SOURCE))
-vars=""
-DIR=$(pwd)
-bin=G4CXTest
-script=G4CXTest_raindrop.py
-simtrace_script=G4CXTest_raindrop_simtrace.py
-
-
-geom=RaindropRockAirWater
-
-if [ -n "$GEOM" -a "$GEOM" != "$geom" ]; then
-   echo $BASH_SOURCE - detected different external GEOM $GEOM geom $geom - do some unset
-   _SScene__initFromTree_addFrames=$SScene__initFromTree_addFrames
-   _stree__force_triangulate_solid=$stree__force_triangulate_solid
-   unset SScene__initFromTree_addFrames
-   unset stree__force_triangulate_solid
-fi
-
-export GEOM=$geom  # GEOM is identifier for a geometry
-
-vars="$vars BASH_SOURCE PWD DIR bin script GEOM"
-
-# THESE ARE NOW THE DEFAULTS
-export U4VolumeMaker_RaindropRockAirWater_RINDEX=0,0,1,1.333
-export U4VolumeMaker_RaindropRockAirWater_MATS=VACUUM,G4_Pb,G4_AIR,G4_WATER
-export U4VolumeMaker_RaindropRockAirWater_HALFSIDE=90
-export U4VolumeMaker_RaindropRockAirWater_DROPSHAPE=Box  # default:Orb  (Box also impl)
-
-if [ -n "$KLUDGE" ]; then
-    export U4Recorder__PreUserTrackingAction_Optical_UseGivenVelocity_KLUDGE=1
-fi
-
-if [ -n "$B_SIMTRACE" ]; then
-    export U4Recorder__EndOfRunAction_Simtrace=1
-    #export SEvt__SIMTRACE=1
-
-    export stree__populate_nidx_prim=1
-
-fi
-
-
-
-if [ "$U4Recorder__PreUserTrackingAction_Optical_UseGivenVelocity_KLUDGE" == "1" ]; then
-    version=1
-else
-    version=0
-fi
-
-export VERSION=$version  # used in the SEvt output directory
-vars="$vars VERSION"
-
-
-#export Local_DsG4Scintillation_DISABLE=1
-export G4CXOpticks__SaveGeometry_DIR=$HOME/.opticks/GEOM/$GEOM
-
-
-
-
-#num=1000
-#num=5000
-#num=H1
-num=M1
-NUM=${NUM:-$num}
-
-## For torch running MUST NOW configure OPTICKS_NUM_PHOTON and OPTICKS_NUM_GENSTEP
-## envvars with the same number of comma delimited values OR just 1 value without comma
-
-export OPTICKS_NUM_PHOTON=$NUM
-export OPTICKS_NUM_GENSTEP=1
-
-export OPTICKS_RUNNING_MODE="SRM_TORCH"
-export OPTICKS_MAX_SLOT=M1
-
-
-vars="$vars OPTICKS_NUM_PHOTON OPTICKS_NUM_GENSTEP OPTICKS_RUNNING_MODE"
-
-
-if [ "$OPTICKS_RUNNING_MODE" == "SRM_TORCH" ]; then
-    #export SEvent_MakeGenstep_num_ph=$NUM   ## NO LONGER USED ?
-
-    #src="rectangle"
-    #src="disc"
-    src="circle_inwards_hemi"
-
-    if [ "$src" == "rectangle" ]; then
-        export storch_FillGenstep_pos=0,0,0
-        export storch_FillGenstep_type=rectangle
-        export storch_FillGenstep_zenith=-20,20
-        export storch_FillGenstep_azimuth=-20,20
-    elif [ "$src" == "disc" ]; then
-        export storch_FillGenstep_type=disc
-        export storch_FillGenstep_radius=50        # radius
-        export storch_FillGenstep_zenith=0,1       # radial range scale
-        export storch_FillGenstep_azimuth=0,1      # phi segment twopi fraction
-        export storch_FillGenstep_mom=1,0,0
-        export storch_FillGenstep_pos=-80,0,0
-    elif [ "$src" == "circle_inwards_hemi" ]; then
-        export storch_FillGenstep_type=circle
-        export storch_FillGenstep_radius=-50    # -ve means inwards
-        export storch_FillGenstep_pos=0,0,50
-        export storch_FillGenstep_azimuth=0.5,1
-    fi
-    vars="$vars src"
-fi
-
-
-#oim=2  # CPU only
-oim=3  # GPU and CPU optical simulation
-export OPTICKS_INTEGRATION_MODE=${OPTICKS_INTEGRATION_MODE:-$oim}
-
-#mode=Minimal
-mode=DebugLite
-export OPTICKS_EVENT_MODE=${OPTICKS_EVENT_MODE:-$mode} # configure what to gather and save via SEvt
-
-
-# below directories match those used by SEvt saving
-# in order to be able to load SEvt into python analysis script
-#
-export TMP=${TMP:-/tmp/$USER/opticks}
-evtfold=$TMP/GEOM/$GEOM
-
-ctx=${OPTICKS_EVENT_CONTEXT:-Debug_Philox}
-export OPTICKS_EVENT_NAME=${ctx}
-reldir=ALL${VERSION}_${OPTICKS_EVENT_NAME}
-
-export AFOLD=$evtfold/$bin/$reldir/A000
-export BFOLD=$evtfold/$bin/$reldir/B000
-export TFOLD=$evtfold/$bin/$reldir/M998   # HMM could use zero now
-
-
-#mode=0 # no plotting
-#mode=2 # matplotlib
-mode=3 # pyvista
-export MODE=${MODE:-$mode}
-
-
-vars="$vars OPTICKS_INTEGRATION_MODE OPTICKS_EVENT_MODE TMP evtfold reldir OPTICKS_EVENT_NAME AFOLD BFOLD TFOLD MODE"
-
-
-event_debug()
-{
-    export SEventConfig=INFO
-    export SEvt__LIFECYCLE=1
-    export SEvt__MINIMAL=1
-    export SEvt=INFO
-    export SEvent=INFO
-
-    type $FUNCNAME
-}
-[ -n "$EVENT_DEBUG" ] && event_debug
-
-logging()
-{
-   export U4Recorder=INFO
-   export U4StepPoint=INFO
-   export U4Physics=INFO
-   #export CSGFoundry=INFO
-   #export CSGTarget=INFO
-}
-[ -n "$LOG" ] && logging
-
-defarg="info_run_ana_cf2"
-#defarg="info_dbg_ana"
-arg=${1:-$defarg}
-
-[ -n "$BP" ] && echo $BASH_SOURCE : override arg to info_dbg as BP $BP is defined && arg=info_dbg
-
-if [ -n "$BP" ]; then
-   DEBUG_GENIDX=10000
-   export U4VPrimaryGenerator__GeneratePrimaries_From_Photons_DEBUG_GENIDX=$DEBUG_GENIDX
-   # for DEBUG_GENIDX > -1 will only generate one photon : for debugging purposes
-   echo $BASH_SOURCE :  DEBUG_GENIDX $DEBUG_GENIDX OPTICKS_NUM_PHOTON $OPTICKS_NUM_PHOTON
-fi
-
-
-vars="$vars CUDA_VISIBLE_DEVICES BP defarg arg"
-
-
-
-if [ "${arg/info}" != "$arg" ]; then
-    for var in $vars ; do printf "%30s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/run}" != "$arg" ]; then
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE : run error && exit 1
-fi
-
-if [ "${arg/dbg}" != "$arg" ]; then
-    source dbg__.sh
-    dbg__ $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE : dbg error && exit 2
-fi
-
-if [ "${arg/grab}" != "$arg" ]; then
-    source rsync.sh $evtfold
-    [ $? -ne 0 ] && echo $BASH_SOURCE : grab error && exit 3
-fi
-
-if [ "${arg/ls}" != "$arg" ]; then
-     ff="AFOLD BFOLD TFOLD"
-     for f in $ff ; do printf "\n\n%s : ls -alst %s \n\n" "$f" "${!f}" && ls -alst ${!f} ; done
-fi
-
-
-if [ "${arg/old}" != "$arg" ]; then
-    export SAVE_SEL=1
-
-    if command -v ${IPYTHON:-ipython} &> /dev/null
-    then
-        ${IPYTHON:-ipython} --pdb -i $script
-    else
-        echo $BASH_SOURCE - IPYTHON NOT AVAILABLE - TRY PYTHON
-        ${PYTHON:-python} -i $script
-    fi
-    [ $? -ne 0 ] && echo $BASH_SOURCE : ana error with script $script && exit 4
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-    ${PYTHON:-python} $script
-    [ $? -ne 0 ] && echo $BASH_SOURCE : ana error with script $script && exit 4
-fi
-
-if [ "${arg/pdb}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $script
-    [ $? -ne 0 ] && echo $BASH_SOURCE : pdb error with script $script && exit 4
-fi
-
-if [ "${arg/tra}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $simtrace_script
-    [ $? -ne 0 ] && echo $BASH_SOURCE : pdb error with simtrace_script $simtrace_script && exit 4
-fi
-
-
-
-
-if [ "${arg/cf2}" != "$arg" ]; then
-    sseq_index_test.sh info_run_ana
-    [ $? -ne 0 ] && echo $BASH_SOURCE : cf2 error && exit 5
-fi
-
-exit 0
diff --git a/g4cx/tests/G4CXTest_raindrop_CPU.sh b/g4cx/tests/G4CXTest_raindrop_CPU.sh
deleted file mode 100755
index 43707e6929..0000000000
--- a/g4cx/tests/G4CXTest_raindrop_CPU.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-
-::
-  
-   ~/o/g4cx/tests/G4CXTest_raindrop_CPU.sh 
-
-
-EOU
-}
-
-cd $(dirname $(realpath $BASH_SOURCE))
-
-OPTICKS_INTEGRATION_MODE=2 ./G4CXTest_raindrop.sh $*
-
-
diff --git a/g4cx/tests/G4CXTest_raindrop_simtrace.py b/g4cx/tests/G4CXTest_raindrop_simtrace.py
deleted file mode 100644
index 916fda5fc7..0000000000
--- a/g4cx/tests/G4CXTest_raindrop_simtrace.py
+++ /dev/null
@@ -1,117 +0,0 @@
-#!/usr/bin/env python
-"""
-G4CXTest_raindrop_simtrace.py
-===============================
-
-Simplify CSGOptiX/cxt_min.py
-
-
-"""
-import os, re, logging, numpy as np
-log = logging.getLogger(__name__)
-
-from opticks.sysrap.sevt import SEvt
-from opticks.ana.p import cf    # load CSGFoundry geometry info
-from opticks.CSG.CSGFoundry import KeyNameConfig
-
-GLOBAL = 1 == int(os.environ.get("GLOBAL","0"))
-GSGRID = 1 == int(os.environ.get("GSGRID","0"))
-FRAME = 1 == int(os.environ.get("FRAME","0"))
-MODE = int(os.environ.get("MODE","2"))
-
-X,Y,Z = 0,1,2
-H,V = X,Z
-
-
-if MODE in [2,3]:
-    import opticks.ana.pvplt as pvp
-pass
-
-if __name__ == '__main__':
-    print("GLOBAL:%d MODE:%d" % (GLOBAL,MODE))
-
-    t = SEvt.Load("$TFOLD", symbol="t")
-    print(repr(t))
-
-    label = t.f.base
-    sf = t.f.sframe
-    w2m = sf.w2m
-    gs = t.f.genstep
-    st = t.f.simtrace
-
-    st_t = st[:,0,3]
-    st_gp_bn = st[:,2,3].view(np.int32)
-    st_gp = st_gp_bn >> 16  # globalPrimIdx
-    st_bn = st_gp_bn & 0xffff   ## boundary
-
-
-    gs_pos = gs[:,1]
-    all_one = np.all( gs_pos[:,3] == 1. )
-    all_zero = np.all( gs_pos[:,:3]  == 0 )
-    assert all_one  # SHOULD ALWAYS BE 1.
-    #assert all_zero # NOT ZERO WHEN USING CE_OFFSET=CE CE_SCALE=1
-    gs_tra = gs[:,2:]
-    assert gs_tra.shape[1:] == (4,4)
-
-    ggrid = np.zeros( (len(gs), 4 ), dtype=np.float32 )
-    for i in range(len(ggrid)): ggrid[i] = np.dot(gs_pos[i], gs_tra[i])
-    ## np.matmul/np.tensordot/np.einsum can probably do this without the loop
-    lgrid = np.dot( ggrid, w2m )
-    ugrid = ggrid if GLOBAL else lgrid
-
-
-
-    #presel = slice(None)
-    #presel = st_t > 0.
-    presel = st_gp > -1
-    #presel = np.logical_and( st_gp > -1, st_t > 0. )
-
-
-
-    ust = st[presel]
-
-    gp_bn = ust[:,2,3].view(np.int32)    ## simtrace intersect boundary indices
-    gp = gp_bn >> 16      ## globalPrimIdx
-    bn = gp_bn & 0xffff   ## boundary
-
-
-    u_gp, n_gp = np.unique(gp, return_counts=True )
-    o_gp = np.argsort(n_gp)[::-1]
-    gp_tab = np.c_[u_gp,n_gp][o_gp]
-    print(repr(gp_tab))
-    u_gp = gp_tab[:,0]
-    n_gp = gp_tab[:,1]
-
-
-    ## simtrace layout see sysrap/sevent.h
-    gpos = ust[:,1].copy()
-    gpos[...,3] = 1.   ## transform as position
-    lpos = np.dot( gpos, w2m )
-    upos = gpos if GLOBAL else lpos
-
-
-
-    if MODE == 3:
-        pl = pvp.pvplt_plotter(label)
-        pvp.pvplt_viewpoint(pl)   # sensitive to EYE, LOOK, UP envvars
-        if FRAME: pvp.pvplt_frame(pl, sf, local=not GLOBAL, pickable=False )
-
-
-        colors = ["red", "green", "blue", "yellow", "magenta", "grey", "white" ]
-
-        for i, g in enumerate(u_gp):
-            w = np.where( gp == g )[0]
-            color = colors[i % len(colors)]
-
-            prn = cf.primname[g] if g > -1 and g < len(cf.primname) else "???"
-
-            label = " gp:%d len(w):%d prn:%s col:%s " % ( g, len(w), prn, color )
-            pvp.pvplt_add_points(pl, upos[w,:3], color=color, label=label )
-        pass
-
-        if GSGRID: pl.add_points(ugrid[:,:3], color="r", pickable=False )
-        cp = pvp.pvplt_show(pl, incpoi=-5, legend=True, title=None )
-    pass
-
-
-
diff --git a/g4cx/tests/G4CXTest_raindrop_simtrace.sh b/g4cx/tests/G4CXTest_raindrop_simtrace.sh
deleted file mode 100755
index 44421bf418..0000000000
--- a/g4cx/tests/G4CXTest_raindrop_simtrace.sh
+++ /dev/null
@@ -1,28 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-G4CXTest_raindrop_simtrace.sh
-==============================
-
-::
-
-   ~/o/g4cx/tests/G4CXTest_raindrop_simtrace.sh
-
-
-Note that definition of the world volume is grotty.
-Probably Geant4 does not like intersecting from
-origins outside world.
-
-EOU
-}
-
-cd $(dirname $(realpath $BASH_SOURCE))
-
-#export CEGS=16:0:9:2000
-export CEGS=11:0:11:2000
-
-defarg=run_tra
-arg=${1:-$defarg}
-
-B_SIMTRACE=1 ./G4CXTest_raindrop.sh $arg
-
-
diff --git a/g4cx/tests/ab.py b/g4cx/tests/ab.py
deleted file mode 100644
index 9fc4e3b23b..0000000000
--- a/g4cx/tests/ab.py
+++ /dev/null
@@ -1,141 +0,0 @@
-#!/usr/bin/env python 
-"""
-ab.py (formerly G4CXSimulateTest_ab.py) : random aligned comparison
-======================================================================
-
-Usage::
-
-   gx
-   ./ab.sh  
-
-
-    In [15]: np.all( A.ts == B.ts2[:,:12,:29] )                                                                                            
-    Out[15]: False
-
-    In [17]: A.ts.shape                                                                                                                    
-    Out[17]: (10000, 12, 29)
-
-    In [18]: B.ts2.shape                                                                                                                   
-    Out[18]: (10000, 13, 29)
-
-
-Warning from comparing different shapes::
-
-    In [16]: np.all( A.ts == B.ts2 )                                                                                                       
-    /Users/blyth/miniconda3/bin/ipython:1: DeprecationWarning: elementwise comparison failed; this will raise an error in the future.
-      #!/Users/blyth/miniconda3/bin/python
-    Out[16]: False
-
-::
-
-    In [19]: np.where( A.ts != B.ts2[:,:12,:29] )                                                                                          
-    Out[19]: 
-    (array([9964, 9964, 9964, 9964, 9964, 9964]),
-     array([ 2,  4,  6,  8, 10, 11]),
-     array([5, 5, 5, 5, 5, 3]))
-
-
-Mis-aligned from truncation ?::
-
-    In [20]: seqhis_(a.seq[9964,0])                                                                                                        
-    Out[20]: 'TO BT SC BR BR BR BR BR BR BR'
-
-    In [21]: seqhis_(b.seq[9964,0])                                                                                                        
-    Out[21]: 'TO BT SC BR BR BR BR BR BR BR'
-
-
-
-"""
-import numpy as np
-import logging
-log = logging.getLogger(__name__)
-
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-from opticks.ana.eprint import eprint, epr, edv
-
-from opticks.sysrap.xfold import XFold
-from opticks.sysrap.ABR import ABR 
-from opticks.sysrap.stag import stag  
-from opticks.u4.U4Stack import U4Stack
-
-np.set_printoptions(edgeitems=16) 
-
-tag = stag()
-stack = U4Stack()
-SLOTS = stag.SLOTS   
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    quiet = True 
-    a = Fold.Load("$A_FOLD", symbol="a", quiet=quiet) if "A_FOLD" in os.environ else None
-    b = Fold.Load("$B_FOLD", symbol="b", quiet=quiet) if "B_FOLD" in os.environ else None
-
-    ## SUSPECT photon element (1,3) is starting uninitialized in input photon running
-    ## forcing the below kludge to be able to compare 
-    np.all( b.record[:,0,1,3] == 0. )                                                                                                    
-    np.all( a.record[:,0,1,3] == 1. )                                                                                                    
-    a.record[:,0,1,3] = 1.   # kludge
-    b.record[:,0,1,3] = 1.   # kludge 
-
-    ab = (not a is None) and (not b is None)
-
-    print("-------- after Fold.Load" )
-
-    A = XFold(a, symbol="A") if not a is None else None
-
-    print("-------- after XFold.A" )
-
-    B = XFold(b, symbol="B") if not b is None else None
-
-    print("-------- after XFold.B" )
-
-    AB = ABR(A,B) if ab else None 
-
-    print("-------- after ABR " )
-
-    if ab: 
-        im = epr("im = np.abs(a.inphoton - b.inphoton).max()", globals(), locals() )  
-        pm = epr("pm = np.abs(a.photon - b.photon).max()",     globals(), locals() )  
-        rm = epr("rm = np.abs(a.record - b.record).max()",     globals(), locals() )  
-        sm = epr("sm = np.all( a.seq[:,0] == b.seq[:,0] )",    globals(), locals() ) 
-        ww = epr("ww = np.where( a.seq[:,0] != b.seq[:,0] )[0]",    globals(), locals() ) 
-
-        we_ = "we = np.where( A.t.view('|S%(SLOTS)s') != B.t2.view('|S%(SLOTS)s') )[0]" % locals()  # eg stag.h/stag::SLOTS = 64 
-        we = epr(we_,  globals(), locals() ) 
-
-        wm_ = "wm = np.where( A.t.view('|S%(SLOTS)s') == B.t2.view('|S%(SLOTS)s') )[0]" % locals()  # eg stag.h/stag::SLOTS = 64 
-        wm = epr(wm_,  globals(), locals() ) 
-
-
-        wa = epr("wa = np.unique(np.where( np.abs(a.record - b.record ) > 0.05 )[0])", globals(), locals() ) 
-
-        print("---0---")
-        eprint("np.all( A.ts == B.ts2 )", globals(), locals() )
-        print("---1---")
-        eprint("np.all( A.ts2 == B.ts )", globals(), locals() )
-        print("---2---")
-
-        assert (a.inphoton - b.inphoton).max() < 1e-3
-        print("---3---")
-
-
-        epr("o = cuss(a.seq[:,0])",  globals(), locals(), rprefix="\n" ) 
-        edv("a.record[w0,1,0,2] - b.record[w0,1,0,2] # point 1 z", globals(), locals())  
-        edv("a.record[w3,1,0,2] - b.record[w3,1,0,2] # point 1 z", globals(), locals())  
-    pass
-
-    print("./U4RecorderTest_ab.sh ## u4t ")
-    w = epr("w = np.unique(np.where( np.abs(a.photon - b.photon) > 0.1 )[0])", globals(), locals() )
-    s = epr("s = a.seq[w,0]", globals(), locals() )  
-    o = epr("o = cuss(s,w)", globals(), locals() , rprefix="\n")
-
-    #epr("w1", globals(), locals() )
-    #abw0 = epr("abw0 = a.photon[w0,:4] - b.photon[w0,:4]", globals(), locals(), rprefix="\n" ) 
-
-    epr("a.base", globals(), locals() )
-    epr("b.base", globals(), locals() )
-pass
-
-
diff --git a/g4cx/tests/cf_G4CXSimtraceTest.py b/g4cx/tests/cf_G4CXSimtraceTest.py
deleted file mode 100644
index f24dd44feb..0000000000
--- a/g4cx/tests/cf_G4CXSimtraceTest.py
+++ /dev/null
@@ -1,131 +0,0 @@
-#!/usr/bin/env python
-"""
-cf_G4CXSimtraceTest.py
-==============================
-
-::
-
-   FOCUS=-257,-39,7 ./cf_gxt.sh 
-
-
-"""
-
-import os, numpy as np, logging
-log = logging.getLogger(__name__)
-from opticks.ana.fold import Fold
-from opticks.CSG.Values import Values 
-from opticks.ana.eget import efloatarray_, efloatlist_
-from opticks.sysrap.sframe import sframe , X, Y, Z
-from opticks.ana.framegensteps import FrameGensteps
-from opticks.ana.pvplt import mpplt_focus
-
-import matplotlib.pyplot as mp
-
-SIZE = np.array([1280, 720]) 
-FOCUS = efloatarray_("FOCUS", "0,0,0")
- 
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    s_geom = os.environ.get("S_GEOM", None)
-    t_geom = os.environ.get("T_GEOM", None)
-    u_geom = os.environ.get("U_GEOM", None)
-    v_geom = os.environ.get("V_GEOM", None)
-
-    s = Fold.Load("$S_FOLD", symbol="s") if not s_geom is None else None
-    t = Fold.Load("$T_FOLD", symbol="t") if not t_geom is None else None
-    u = Fold.Load("$U_FOLD", symbol="u") if not u_geom is None else None
-    v = Fold.Load("$V_FOLD", symbol="v") if not v_geom is None else None
-
-    print(repr(s))
-    print(repr(t))
-    print(repr(u))
-    print(repr(v))
-
-    sv = Values.Find("$S_FOLD", symbol="sv") if not s_geom is None else None
-    tv = Values.Find("$T_FOLD", symbol="tv") if not t_geom is None else None
-    uv = Values.Find("$U_FOLD", symbol="uv") if not u_geom is None else None
-    vv = Values.Find("$V_FOLD", symbol="vv") if not v_geom is None else None
-
-    print(repr(sv))
-    print(repr(tv))
-    print(repr(uv))
-    print(repr(vv))
-
-    local = True 
-    s_gs = FrameGensteps(s.genstep, s.sframe, local=local, symbol="s_gs" ) if not s is None else None
-    t_gs = FrameGensteps(t.genstep, t.sframe, local=local, symbol="t_gs" ) if not t is None else None
-    u_gs = FrameGensteps(u.genstep, u.sframe, local=local, symbol="u_gs" ) if not u is None else None
-    v_gs = FrameGensteps(v.genstep, v.sframe, local=local, symbol="v_gs" ) if not v is None else None
-
-    lim = FrameGensteps.CombineLim( [s_gs, t_gs, u_gs, v_gs] )
-
-    s_frame = s.sframe if not s is None else None
-    t_frame = t.sframe if not t is None else None
-    u_frame = u.sframe if not u is None else None
-    v_frame = v.sframe if not v is None else None
-
-    frame = sframe.CombineFrame( [s_frame, t_frame, u_frame, v_frame ] )
-
-    s_offset = efloatarray_("S_OFFSET", "0,0,0")
-    t_offset = efloatarray_("T_OFFSET", "0,0,0")
-    u_offset = efloatarray_("U_OFFSET", "0,0,0")
-    v_offset = efloatarray_("V_OFFSET", "0,0,0")
-
-    print("S_OFFSET: %s " % repr(s_offset))
-    print("T_OFFSET: %s " % repr(t_offset))
-    print("U_OFFSET: %s " % repr(u_offset))
-    print("V_OFFSET: %s " % repr(v_offset))
-
-
-    s_hit = s.simtrace[:,0,3]>0 if not s is None else None
-    t_hit = t.simtrace[:,0,3]>0 if not t is None else None
-    u_hit = u.simtrace[:,0,3]>0 if not u is None else None
-    v_hit = v.simtrace[:,0,3]>0 if not v is None else None
-
-    s_pos = s_offset + s.simtrace[s_hit][:,1,:3] if not s is None else None
-    t_pos = t_offset + t.simtrace[t_hit][:,1,:3] if not t is None else None
-    u_pos = u_offset + u.simtrace[u_hit][:,1,:3] if not u is None else None
-    v_pos = v_offset + v.simtrace[v_hit][:,1,:3] if not v is None else None
-
-    topline = os.environ.get("TOPLINE", "cf_G4CXSimtraceTest.py")
-    botline = os.environ.get("BOTLINE", "S_OFFSET:%s T_OFFSET:%s U_OFFSET:%s V_OFFSET:%s " % (str(s_offset),str(t_offset), str(u_offset), str(v_offset)))
-    thirdline = os.environ.get("THIRDLINE", "FOCUS:%s " % (str(FOCUS)))
-    title = [topline, botline, thirdline ]
-
-    fig, ax = mp.subplots(figsize=SIZE/100.)
-    fig.suptitle("\n".join(title))
-    ax.set_aspect('equal')
-
-    if not frame is None and not lim is None:
-        H,V = frame.axes       # traditionally H,V = X,Z  but now generalized
-        _H,_V = frame.axlabels
-
-        xlim = lim[H] 
-        ylim = lim[V]
-        xlim, ylim = mpplt_focus(xlim, ylim)
-
-        ax.set_xlim(xlim)
-        ax.set_ylim(ylim)
-        ax.set_xlabel(_H)
-        ax.set_ylabel(_V)
-    pass
-
-    if not s_pos is None:
-        ax.scatter( s_pos[:,0], s_pos[:,2], label="S:%s" % s_geom, s=1 ) 
-    pass
-    if not t_pos is None:
-        ax.scatter( t_pos[:,0], t_pos[:,2], label="T:%s" % t_geom, s=1 ) 
-    pass
-    if not u_pos is None:
-        ax.scatter( u_pos[:,0], u_pos[:,2], label="U:%s" % u_geom, s=1 ) 
-    pass
-    if not v_pos is None:
-        ax.scatter( v_pos[:,0], v_pos[:,2], label="V:%s" % v_geom, s=1 ) 
-    pass
-
-
-    ax.legend()
-    fig.show()
-
diff --git a/g4cx/tests/gx.py b/g4cx/tests/gx.py
deleted file mode 100644
index d8d35d61ed..0000000000
--- a/g4cx/tests/gx.py
+++ /dev/null
@@ -1,73 +0,0 @@
-#!/usr/bin/env python
-"""
-gx.py : examine geometry from G4CXOpticks::saveGeometry 
-==========================================================
-
-"""
-
-import numpy as np
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree
-from opticks.CSG.CSGFoundry import CSGFoundry
-
-
-def desc_sensor(st):
-    """
-    desc_sensor
-        nds :  lv : soname
-       4997 : 106 : HamamatsuR12860_PMT_20inch_inner1_solid_I 
-       4997 : 108 : HamamatsuR12860_PMT_20inch_body_solid_1_4 
-      12615 : 113 : NNVTMCPPMT_PMT_20inch_inner1_solid_head 
-      12615 : 115 : NNVTMCPPMT_PMT_20inch_body_solid_head 
-      25600 : 118 : PMT_3inch_inner1_solid_ell_helper 
-      25600 : 120 : PMT_3inch_body_solid_ell_ell_helper 
-       2400 : 130 : PMT_20inch_veto_inner1_solid 
-       2400 : 132 : PMT_20inch_veto_body_solid_1_2 
-
-
-    In [7]: np.unique( st.nds.sensor_id   )
-    Out[7]: array([    -1,      0,      1,      2,      3, ..., 325595, 325596, 325597, 325598, 325599], dtype=int32)
-
-    In [8]: np.unique( st.nds.sensor_index   )
-    Out[8]: array([   -1,     0,     1,     2,     3, ..., 45607, 45608, 45609, 45610, 45611], dtype=int32)
-
-    In [9]: np.unique( st.nds.sensor_name   )
-    Out[9]: array([-1,  0,  1,  2,  3], dtype=int32)
-
-    """
-    ws = np.where(st.nds.sensor_index > -1 )[0]
-    se = st.nds.sensor_index[ws]
-    xse = np.arange(len(se), dtype=np.int32)    
-    assert np.all( xse == se )  
-    ulv, nlv = np.unique(st.nds.lvid[ws], return_counts=True)
-
-    hfmt = "%7s : %3s : %50s : %s "
-    fmt = "%7d : %3d : %50s : %s " 
-    hdr = hfmt % ("nds", "lv", "soname", "0th" )
-
-    zths = [st.find_lvid_node(ulv[i],0) for i in range(len(ulv))]
-
-    extra = [] 
-    for zth in zths:
-        extra += ["zth:%s" % zth,]
-        extra += [st.desc_nodes( st.get_children(zth, prepend_arg=True),brief=True),]
-    pass
-   
-    head = ["desc_sensor",hdr]
-    body = [fmt % ( nlv[i], ulv[i], st.soname_[ulv[i]], zths[i] ) for i in range(len(ulv))]
-    tail = [hfmt % ( nlv.sum(), "", "", "" ),]
-    return "\n".join(head+body+tail+extra)
-
-
-if __name__ == '__main__':
-    cf = CSGFoundry.Load(symbol="cf")
-    print(cf) 
-
-    f = Fold.Load(cf.base, "CSGFoundry/SSim/stree", symbol="f")
-    st = stree(f)
-
-    print(repr(st))
-    print(desc_sensor(st))
-pass
-        
-
diff --git a/g4cx/tests/gx.sh b/g4cx/tests/gx.sh
deleted file mode 100755
index fa8b92e4f8..0000000000
--- a/g4cx/tests/gx.sh
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/bash -l 
-usage(){ cat << EOU
-gx.sh : python examination of persisted CSGFoundry and stree geometry
-=========================================================================
-
-After a run on workstation that persists into $HOME/.opticks/GEOM/$GEOM::
-
-    GEOM       # laptop, check configured GEOM matches that on workstation
-    GEOM get   # laptop, pullback geometry
-    ~/opticks/g4cx/tests/gx.sh   # laptop, run this script
-
-EOU
-}
-
-SDIR=$(cd $(dirname $BASH_SOURCE) && pwd)
-script=$SDIR/gx.py 
-source $HOME/.opticks/GEOM/GEOM.sh   
-vars="BASH_SOURCE SDIR GEOM script"
-
-defarg="info_ana"
-arg=${1:-$defarg}
-
-if [ "${arg/info}" != "$arg" ]; then
-   for var in $vars ; do printf "%20s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-   ${IPYTHON:-ipython} --pdb -i $script
-   [ $? -ne 0 ] && echo $BASH_SOURCE : ana error && exit 1 
-fi
-exit 0 
-
diff --git a/g4cx/tests/sev.py b/g4cx/tests/sev.py
deleted file mode 100644
index 044c4d5444..0000000000
--- a/g4cx/tests/sev.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-"""
-sev.py
-========
-
-::
-
-    In [11]: iid[hit_ii]
-    Out[11]: 
-    array([[29082,     2,  4938,  4938],
-           [31842,     2,  8753,  8753],
-           [32525,     2,  9656,  9656],
-           [32355,     2,  9485,  9485],
-           [35884,     2, 14395, 14395],
-           ...,
-           [40408,     3,  7566,  7566],
-           [34641,     2, 12663, 12663],
-           [29988,     2,  6174,  6174],
-           [29182,     2,  5082,  5082],
-           [37875,     2, 17165, 17165]], dtype=int32)
-
-    In [18]: np.unique( iid[hit_ii,1], return_counts=True )
-    Out[18]: (array([1, 2, 3], dtype=int32), array([ 138, 2587, 1068]))
-
-
-
-"""
-
-import numpy as np
-from opticks.CSG.CSGFoundry import CSGFoundry
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree
-from opticks.ana.eprint import eprint, epr
-
-if __name__ == '__main__':
-
-
-    cf = CSGFoundry.Load(symbol="cf") 
-    print(repr(cf))
-
-    stf = Fold.Load(cf.base, "CSGFoundry/SSim/stree", symbol="stf")
-    st = stree(stf)
-    print(repr(st))
-
-    ev = Fold.Load("$FOLD",symbol="ev")
-    print(repr(ev))
-
-    hit_ii = ev.hit.view(np.int32)[:,1,3]  # sphoton.iindex
-    print("hit_ii : %s " % str(hit_ii))
-
-    iid = stf.inst_f4[:,:,3].view(np.int32)
-    iid2 = cf.inst[:,:,3].view(np.int32)
-    assert np.all( iid == iid2 ) 
-
-    inst_diff = np.abs(stf.inst_f4[:,:,:3] - cf.inst[:,:,:3]).max() 
-    print(" inst_diff : %s " % inst_diff )
-
-     
-
-
diff --git a/g4cx/tests/sev.sh b/g4cx/tests/sev.sh
deleted file mode 100755
index 79f65d5b1d..0000000000
--- a/g4cx/tests/sev.sh
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/bin/bash -l 
-usage(){ cat << EOU
-sev.sh
-=========
-
-Update geometry, transfer to laptop, load into ipython::
-
-    GEOM get                         
-    ~/opticks/g4cx/tests/sev.sh 
-
-EOU
-}
-
-SDIR=$(cd $(dirname $BASH_SOURCE) && pwd)
-script=$SDIR/sev.py 
-source $HOME/.opticks/GEOM/GEOM.sh 
-export BASE=/tmp/$USER/opticks/GEOM/$GEOM/ntds3
-export FOLD=$BASE/ALL1/p001
-
-defarg="info_ana"
-arg=${1:-$defarg}
-
-vars="BASH_SOURCE GEOM BASE FOLD script" 
-
-if [ "${arg/info}" != "$arg" ]; then 
-   for var in $vars ; do printf "%20s : %s \n" "$var" "${!var}" ; done 
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then 
-   ${IPYTHON:-ipython} --pdb -i $script
-   [ $? -ne 0 ] && echo $BASH_SOURCE : ana error && exit 1 
-fi
-
diff --git a/qudarap/QBndTest.sh b/qudarap/QBndTest.sh
deleted file mode 100755
index 68fadf8a16..0000000000
--- a/qudarap/QBndTest.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash -l 
-
-${IPYTHON:-ipython} --pdb -i tests/QBndTest.py 
diff --git a/qudarap/QSimTest.sh b/qudarap/QSimTest.sh
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/qudarap/__init__.py b/qudarap/__init__.py
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/qudarap/qgs.sh b/qudarap/qgs.sh
deleted file mode 100755
index bc43fb067e..0000000000
--- a/qudarap/qgs.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/bin/bash -l 
-
-name=qgs 
-gcc $name.cc \
-      -std=c++11 \
-       -I/usr/local/cuda/include \
-       -I/usr/local/opticks/include/SysRap \
-         -lstdc++ -o /tmp/$name 
-
-[ $? -ne 0 ] && echo compile error && exit 1
-
-
-/tmp/$name
-[ $? -ne 0 ] && echo run error && exit 2
-
-exit 0 
-
diff --git a/qudarap/tests/QEvtTest.sh b/qudarap/tests/QEvtTest.sh
deleted file mode 100755
index 1f0d9997ed..0000000000
--- a/qudarap/tests/QEvtTest.sh
+++ /dev/null
@@ -1,88 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-QEvtTest.sh
-=============
-
-::
-
-   ~/o/qudarap/tests/QEvtTest.sh
-   ~/o/qudarap/tests/QEvtTest.sh dbg
-
-   TEST=one ~/o/qudarap/tests/QEvtTest.sh
-   BP=cudaMalloc ~/o/qudarap/tests/QEvtTest.sh
-
-
-Simple way to check for GPU memory leaks while running
-a QEvtTest is to run nvidia-smi in another window::
-
-    nvidia-smi -lms 500    # every half second
-
-Fancier way is to use ~/o/sysrap/smonitor.sh
-to collect a memory profile into NumPy array
-for plotting.
-
-EOU
-}
-cd $(dirname $(realpath $BASH_SOURCE))
-source dbg__.sh
-
-
-export GEOM=DummyGEOMForQEvtTest
-
-name=QEvtTest
-
-#test=many
-#test=ALL
-test=loaded
-
-export TEST=${TEST:-$test}
-script0=$name.py
-script1=${name}_${TEST}.py
-
-#export OPTICKS_NUM_EVENT=1000
-#export OPTICKS_NUM_EVENT=100
-export OPTICKS_NUM_EVENT=10
-
-logging(){
-   type $FUNCNAME
-   export QEvt=INFO
-   export QEvt__LIFECYCLE=1
-}
-[ -n "$LOG" ] && logging
-
-defarg="info_run"
-[ -n "$BP" ] && defarg="info_dbg"
-arg=${1:-$defarg}
-
-
-vars="BASH_SOURCE 0 PWD name test TEST defarg arg BP OPTICKS_NUM_EVENT LOG"
-
-if [ "${arg/info}" != "$arg" ]; then
-   for var in $vars ; do printf "%20s : %s\n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/run}" != "$arg" ]; then
-   $name
-   [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1
-fi
-
-if [ "${arg/dbg}" != "$arg" ]; then
-   dbg__ $name
-   [ $? -ne 0 ] && echo $BASH_SOURCE dbg error && exit 2
-fi
-
-if [ "${arg/pdb0}" != "$arg" ]; then
-   ${IPYTHON:-ipython} --pdb -i  $script0
-   [ $? -ne 0 ] && echo $BASH_SOURCE pdb0 error && exit 2
-fi
-
-if [ "${arg/pdb1}" != "$arg" ]; then
-   ${IPYTHON:-ipython} --pdb -i  $script1
-   [ $? -ne 0 ] && echo $BASH_SOURCE pdb1 error && exit 2
-fi
-
-
-
-
-exit 0
-
diff --git a/qudarap/tests/QEvtTest_ALL.sh b/qudarap/tests/QEvtTest_ALL.sh
deleted file mode 100755
index 1d8a0791cd..0000000000
--- a/qudarap/tests/QEvtTest_ALL.sh
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-
-~/o/qudarap/tests/QEvtTest_ALL.sh 
-
-EOU
-}
-cd $(dirname $(realpath $BASH_SOURCE))
-
-tests=$(sed 's/#.*//' << EOT
-
-one
-sliced
-many
-loaded
-checkEvt
-quad6
-
-EOT
-)
-
-source ALL_TEST_runner.sh QEvtTest.sh 
-
-
diff --git a/qudarap/tests/QSimTest.sh b/qudarap/tests/QSimTest.sh
index fd2785e08c..8501215896 100755
--- a/qudarap/tests/QSimTest.sh
+++ b/qudarap/tests/QSimTest.sh
@@ -71,7 +71,7 @@ msg="=== $BASH_SOURCE :"
 #test=propagate_at_surface
 #test=randgaussq_shoot
 
-test=fake_propagate
+test=fill_state_0
 #test=gentorch
 
 #test=smear_normal_sigma_alpha
@@ -153,7 +153,6 @@ random_direction_marsaglia) script=random_direction_marsaglia.py ;;
    propagate_at_multifilm*) script=propagate_at_multifilm.py ;;
 
     lambertian_direction)  script=lambertian_direction.py ;;
-         fake_propagate*)  script=fake_propagate.py ;;
          randgaussq_shoot) script=randgaussq_shoot.py ;;
             smear_normal*) script=smear_normal.py ;;
                         *) script=generic.py      ;;
@@ -341,4 +340,3 @@ if [ "${arg/OLDana}" != "$arg" ]; then
 fi
 
 exit 0
-
diff --git a/qudarap/tests/fake_propagate.py b/qudarap/tests/fake_propagate.py
deleted file mode 100755
index 1a16b026c9..0000000000
--- a/qudarap/tests/fake_propagate.py
+++ /dev/null
@@ -1,143 +0,0 @@
-#!/usr/bin/env python
-
-import os, numpy as np, textwrap
-import logging
-log = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)  
-# non-standard logging config location to catch logging from CSGFoundry
-# OK because this is a "main" script 
-
-from opticks.ana.fold import Fold
-from opticks.ana.pvplt import *
-from opticks.ana.p import * 
-from opticks.ana.r import * 
-
-from opticks.sysrap.sevt import SEvt
-
-
-
-if __name__ == '__main__':
-    fold = os.path.expandvars("$TMP/GEOM/$GEOM/QSimTest/ALL0_fake_propagate/A000")
-    t = SEvt.Load(fold, symbol="t", NEVT=0)
-    print(repr(t))
-
-    PIDX = int(os.environ.get("PIDX","-1"))
-    FONT_SIZE= int(os.environ.get("FONT_SIZE","36"))
-    FACTOR = float(os.environ.get("FACTOR","60"))
-
-
-
-if 0:
-    p = t.f.photon
-    r = t.f.record
-    seq = t.f.seq
-    prd = t.f.prd
-    h = t.f.hit if hasattr(t.f,"hit") else None
-    h_meta = t.f.hit_meta 
-
-
-    ## HMM:makes more sense to put this meta data on the domain, for when no hits
-    #pyhit = hit__(p, hitmask)  # hits selected in python 
-    #assert np.all( pyhit == h ) 
-
-    if not r is None:
-        r_post = r[:,:,0]
-        r_pos = r[:,:,0,:3].reshape(-1,3)   
-        r_mom = r[:,:,1,:3].reshape(-1,3) 
-        r_pol = r[:,:,2,:3].reshape(-1,3) 
-        r_flag = flag__(r.reshape(-1,4,4))  
-
-        r_flag_label = hm.label( r_flag )
-
-        r_cells = make_record_cells( r )
-        # indices into flattened records 
-
-
-        ## try heuristic to arrange viewpoint and scale 
-        ## HMM: how to automate picking the view ? 
-        ## tuple: camera location, focus point, viewup vector
-
-        r_pos_max = np.max( r_pos, axis=0 )  
-        r_pos_min = np.min( r_pos, axis=0 )  
-        r_pos_rng = r_pos_max - r_pos_min
-        r_pos_avg = np.average(r_pos, axis=0 ) 
-        r_pos_vec = np.array( [-1,0,0], dtype=np.float32  )
-        r_pos_scale = r_pos_rng.max()
-        camloc = r_pos_avg + r_pos_scale*r_pos_vec
-        camera_position = [camloc, r_pos_avg, (0,0,1)]
-        os.environ["ZOOM"] = "%g" % (1./r_pos_scale )
-
-
-        PLOT = "PLOT" in os.environ
-        if PLOT:
-            r_poly = pv.PolyData() 
-            r_poly.points = r_pos
-            r_poly.lines = r_cells.ravel()  ## line connectivity array
-
-            r_poly["flag_label"] = r_flag_label
-            r_tube = r_poly.tube(radius=1) 
-
-            pl = pvplt_plotter()
-            pl.add_mesh( r_tube )
-            pvplt_polarized( pl, r_pos, r_mom, r_pol, factor=FACTOR )
-
-            pl.add_point_labels(r_poly, "flag_label", point_size=20, font_size=FONT_SIZE )
-
-            pl.camera_position = camera_position
-
-
-            pl.show() 
-        pass
-    pass
-
-
-    s = str(p[:,:3]) 
-    a = np.array( s.split("\n") + [""] ).reshape(-1,4)
-
-    for i in range(len(a)):
-        if not (PIDX == -1 or PIDX == i): continue 
-        if PIDX > -1: print("PIDX %d " % PIDX) 
-
-        if not r is None:
-            print("r[%(i)d,:,:3]" % locals()) 
-            print(r[i,:,:3]) 
-            print("\n\nbflagdesc_(r[i,j])")
-            for j in range(len(r[i])):
-                expr = "bflagdesc_(r[%(i)d,%(j)d])" % locals()
-                print(expr)
-                print(eval(expr))
-            pass
-        pass
-
-        print("\n") 
-        print("p")
-        print("\n".join(a[i]))
-
-        expr = "bflagdesc_(p[%(i)d]) " % locals()
-        print(expr) 
-        print(eval(expr)) 
-        print("\n") 
-
-        if not seq is None:
-            print(seqhis_(seq[i,0])) 
-            print("\n") 
-        pass
-        print("\n\n") 
-    pass
-
-
-    EXPR = list(filter(None,textwrap.dedent(r"""
-    np.c_[cf.sim.stree.standard.bnd_names]
-    np.all( cf.sim.stree.standard.bnd_names == cf.sim.extra.GGeo.bnd_names )  
-    np.c_[cf.sim.stree.suname[np.char.startswith(cf.sim.stree.suname, "Hama")]]
-    np.c_[cf.sim.stree.suname[np.char.startswith(cf.sim.stree.suname, "NNVT")]]
-    """).split("\n")))
-
-    for expr in EXPR:
-        print(expr)
-        print(eval(expr))
-    pass
-
-
-
-    
diff --git a/sysrap/ABR.py b/sysrap/ABR.py
deleted file mode 100644
index 5a066da100..0000000000
--- a/sysrap/ABR.py
+++ /dev/null
@@ -1,109 +0,0 @@
-#!/usr/bin/env python
-
-class ABR(object):
-    """
-    As this takes a general side by side repr approach it belongs in its own module. 
-    """
-    def __init__(self, A, B, symbol="AB"):
-        self.A = A
-        self.B = B
-        self.symbol = symbol
-
-    def _get_idx(self):
-        return self.A.idx 
-    def _set_idx(self, idx):
-        self.A.idx = idx 
-        self.B.idx = idx 
-    idx = property(_get_idx, _set_idx)
-
-    def _get_flavor(self):
-        return self.A.flavor
-    def _set_flavor(self, flavor):
-        self.A.flavor = flavor 
-        self.B.flavor = flavor 
-    flavor = property(_get_flavor, _set_flavor)
-
-
-    def __call__(self, idx):
-        self.idx = idx
-        self.flavor = "call"
-        return self  
-    def __getitem__(self, idx):
-        self.idx = idx
-        self.flavor = "getitem"
-        return self  
-
-   
-    @classmethod
-    def MaxLen(cls, lines):
-        mx = 0 
-        for i in range(len(lines)):
-            if len(lines[i]) > mx: mx = len(lines[i]) 
-        pass
-        return mx 
-
-    @classmethod
-    def LeftRightPaddedSplit(cls, lhs, rhs):
-        """
-        :param lhs: text delimited by newlines
-        :param rhs: text delimited by newlines
-        :return l,r: lhs and rhs lines padded to be the same length 
-        """
-        l = lhs.split("\n")
-        r = rhs.split("\n") 
-        nl = len(l)
-        nr = len(r)
-        if nl == nr:
-             pass
-        elif nl > nr:
-            r.extend( ["" for _ in range(nl-nr)] )  
-            nr = len(r)
-        elif nr > nl:
-            l.extend( ["" for _ in range(nr-nl)] )  
-            nl = len(l)
-        else:
-            pass
-        pass
-        assert nl == nr 
-        return l, r 
- 
-    @classmethod
-    def SideBySide(cls, lhs, rhs, margin=10):
-        l, r = cls.LeftRightPaddedSplit(lhs, rhs)
-        nl = len(l)
-        nr = len(r)
-        assert nl == nr
-
-        lx_ = cls.MaxLen(l)
-        rx_ = cls.MaxLen(r)
-        lim = 100 
-
-        lx = min(lim,lx_) 
-        rx = min(lim,rx_)
-
-        pass
-        fmt_ = "{:%d}{:%d}"   
-        fmt = fmt_ % (lx+margin, rx+margin)
-
-        lines = []
-        for i in range(nl):
-            line = fmt.format(l[i], r[i])    
-            lines.append(line.rstrip())
-        pass
-        return "\n".join(lines)
-
-    def identification(self):
-        ia  = self.A.identification() if hasattr(self.A, "identification") else ""
-        ib  = self.B.identification() if hasattr(self.B, "identification") else ""
-        return "\n".join(filter(None,[ia,ib]))
-
-    def __repr__(self):
-        return "\n".join([self.identification(), self.SideBySide(repr(self.A), repr(self.B))])
-
-
-if __name__ == '__main__':
-    pass
-
-    
-
-
diff --git a/sysrap/OpticksCSG.py b/sysrap/OpticksCSG.py
deleted file mode 100644
index 66cb1d4dac..0000000000
--- a/sysrap/OpticksCSG.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# generated Tue Feb  7 17:01:08 2023 
-# from /Users/blyth/opticks/sysrap 
-# base OpticksCSG.h stem OpticksCSG 
-# with command :  ../bin/c_enums_to_python.py OpticksCSG.h 
-#0
-class CSG_(object):
-    ZERO = 0
-    OFFSET_LIST = 4
-    OFFSET_LEAF = 7
-    TREE = 1
-    UNION = 1
-    INTERSECTION = 2
-    DIFFERENCE = 3
-    NODE = 11
-    LIST = 11
-    CONTIGUOUS = 11
-    DISCONTIGUOUS = 12
-    OVERLAP = 13
-    LEAF = 101
-    SPHERE = 101
-    BOX = 102
-    ZSPHERE = 103
-    TUBS = 104
-    CYLINDER = 105
-    SLAB = 106
-    PLANE = 107
-    CONE = 108
-    EXBB = 109
-    BOX3 = 110
-    TRAPEZOID = 111
-    CONVEXPOLYHEDRON = 112
-    DISC = 113
-    SEGMENT = 114
-    ELLIPSOID = 115
-    TORUS = 116
-    HYPERBOLOID = 117
-    CUBIC = 118
-    INFCYLINDER = 119
-    OLDCYLINDER = 120
-    PHICUT = 121
-    THETACUT = 122
-    OLDCONE = 123
-    UNDEFINED = 124
-    OBSOLETE = 1000
-    PARTLIST = 1001
-    FLAGPARTLIST = 1002
-    FLAGNODETREE = 1003
-    FLAGINVISIBLE = 1004
-    PMT = 1005
-    ZLENS = 1006
-    PRISM = 1007
-    LAST = 1008
-    D2V={'zero': 0, 'intersection': 2, 'union': 1, 'difference': 3, 'contiguous': 11, 'discontiguous': 12, 'overlap': 13, 'sphere': 101, 'box': 102, 'zsphere': 103, 'tubs': 104, 'cylinder': 105, 'slab': 106, 'plane': 107, 'cone': 108, 'oldcone': 123, 'box3': 110, 'trapezoid': 111, 'convexpolyhedron': 112, 'disc': 113, 'segment': 114, 'ellipsoid': 115, 'torus': 116, 'hyperboloid': 117, 'cubic': 118, 'infcylinder': 119, 'oldcylinder': 120, 'phicut': 121, 'thetacut': 122, 'undefined': 124, 'externalbb': 109, 'obsolete': 1000, 'partlist': 1001, 'flagpartlist': 1002, 'flagnodetree': 1003, 'flaginvisible': 1004, 'pmt': 1005, 'zlens': 1006, 'prism': 1007, 'last': 1008}
-
-
-    @classmethod
-    def raw_enum(cls):
-        return list(filter(lambda kv:type(kv[1]) is int,cls.__dict__.items()))
-
-    @classmethod
-    def enum(cls):
-        return cls.D2V.items() if len(cls.D2V) > 0 else cls.raw_enum()
-
-    @classmethod
-    def desc(cls, typ):
-        kvs = list(filter(lambda kv:kv[1] == typ, cls.enum()))
-        return kvs[0][0] if len(kvs) == 1 else "UNKNOWN"
-
-    @classmethod
-    def descmask(cls, typ):
-        kvs = list(filter(lambda kv:kv[1] & typ, cls.enum())) 
-        return ",".join(map(lambda kv:kv[0], kvs))
-
-    @classmethod
-    def fromdesc(cls, label):
-        kvs = list(filter(lambda kv:kv[0] == label, cls.enum()))
-        return kvs[0][1] if len(kvs) == 1 else -1
-
-
-
diff --git a/sysrap/SABTest.py b/sysrap/SABTest.py
deleted file mode 100644
index 6588d4b2d5..0000000000
--- a/sysrap/SABTest.py
+++ /dev/null
@@ -1,191 +0,0 @@
-#!/usr/bin/env python
-"""
-SABTest.py : analysis script used from SABTest.sh
-==================================================
-
-Started from ~/j/InputPhotonsCheck/InputPhotonsCheck.py
-
-"""
-
-import os, logging, numpy as np
-log = logging.getLogger(__name__)
-os.environ["MODE"] = "3" 
-
-from opticks.sysrap.sevt import SEvt, SAB, SABHit
-from opticks.ana.p import cf
-
-MODE = int(os.environ.get("MODE","3"))
-MODE0 = MODE
-print("SABTest.py initial MODE:%d " % MODE)
-
-
-GLOBAL = int(os.environ.get("GLOBAL","0")) == 1
-PICK = os.environ.get("PICK","A")
-INCPOI = float(os.environ.get("INCPOI","0"))   ## increment pyvista presentation point and line size, often need -5 
-
-
-if MODE in [2,3]:
-    import opticks.ana.pvplt as pvp
-    print(pvp.__doc__)
-    print("after import MODE:%d " % MODE)
-    MODE = MODE0
-    # HMM this import overrides MODE, so need to keep defaults the same
-pass
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    INST_FRAME = int(os.environ.get("INST_FRAME","-1"))
-    if INST_FRAME == -1: 
-        print("INST_FRAME %d : using default sframe saved with the sevt" % INST_FRAME )
-        M2W_OVERRIDE = None
-        W2M_OVERRIDE = None
-    else:
-        print("INST_FRAME %d : W2M_OVERRIDE obtained from cf.inst controlled by envvar INST_FRAME " % INST_FRAME )
-        M2W_OVERRIDE = np.eye(4)
-        M2W_OVERRIDE[:,:3] = cf.inst[INST_FRAME][:,:3]
-        W2M_OVERRIDE = np.linalg.inv(M2W_OVERRIDE)
-    pass
-
-
-    print(__doc__)
-
-    a = SEvt.Load("$AFOLD", symbol="a", W2M=W2M_OVERRIDE)
-    b = SEvt.Load("$BFOLD", symbol="b", W2M=W2M_OVERRIDE)
-    print(repr(a))
-    print(repr(b))
-
-
-    if not a is None and b is None:
-        PICK = "A"
-    elif not b is None and a is None:
-        PICK = "B"
-    else:
-        pass
-    pass
-
-    if not a is None and not b is None:
-        if "SAB" in os.environ:
-            print("[--- ab = SAB(a,b) ----")
-            ab = SAB(a,b)
-            print("]--- ab = SAB(a,b) ----")
-
-            print("[----- repr(ab) ")
-            print(repr(ab))
-            print("]----- repr(ab) ")
-        else:
-            print(" NOT doing ab = SAB(a,b) # do that with : export SAB=1" )
-        pass
-
-        print("[--- abh = SABHit(a,b) ----")
-        abh = SABHit(a,b)
-        print("]--- abh = SABHit(a,b) ----")
-        print("[----- repr(abh) ")
-        print(repr(abh))
-        print("]----- repr(abh) ")
-    pass
-
-    assert PICK in ["A","B","AB","BA", "CF"]
-    if PICK == "A":
-        ee = [a,]
-    elif PICK == "B":
-        ee = [b,]
-    elif PICK == "AB":
-        ee = [a,b,]
-    elif PICK == "BA":
-        ee = [b,a,]
-    elif PICK == "CF":
-        ee = []
-    pass
-
-    context = "PICK=%s MODE=%d  ~/j/jtds/jtds.sh " % (PICK, MODE )
-    print(context)
-
-    pl = None
-    for e in ee:
-        if e is None:continue
-        elabel = "%s : %s " % ( e.symbol.upper(), e.f.base )
-
-        if hasattr(e.f, 'photon'):
-            pos = e.f.photon[:,0,:3]
-        elif hasattr(e.f, 'hit'):
-            pos = e.f.hit[:,0,:3]
-        else:
-            log.info("%s:sevt lacks photon or hit" % e.symbol)
-            pos = None
-        pass
-
-        if hasattr(e.f, 'record'):
-            sel = np.where(e.f.record[:,:,2,3] > 0) # select on wavelength to avoid unfilled zeros
-            poi = e.f.record[:,:,0,:3][sel]
-        else:
-            log.info("%s:sevt lacks record" % e.symbol)
-            poi = None
-        pass
-
-        if hasattr(e.f, 'sframe'):
-            _W2M = e.f.sframe.w2m
-            log.info("%s:sevt has sframe giving _W2M " % e.symbol)
-        else:
-            _W2M = np.eye(4)
-            log.info("%s:sevt lacks sframe" % e.symbol)
-        pass
-
-        W2M = _W2M if W2M_OVERRIDE is None else W2M_OVERRIDE
-
-
-        print("W2M_OVERRIDE (from manual INST_FRAME, no longer typical)\n",W2M_OVERRIDE)
-        print("_W2M(from %s.f.sframe.w2m, now standard)\n" % e.symbol,_W2M)
-        print("W2M\n",W2M)
-
-        if not pos is None:
-            print("transform gpos (from photon or hit array) to lpos using W2M : ie into target frame : GLOBAL %d " % GLOBAL)
-            gpos = np.ones( [len(pos), 4 ] )
-            gpos[:,:3] = pos
-            lpos = np.dot( gpos, W2M )   # hmm unfilled global zeros getting transformed somewhere
-            upos = gpos if GLOBAL else lpos
-        else:
-            upos = None
-        pass
-
-        if not poi is None:
-            print("transform gpoi (from record array) to lpoi using W2M : ie into target frame : GLOBAL %d " % GLOBAL)
-            gpoi = np.ones( [len(poi), 4 ] )
-            gpoi[:,:3] = poi
-            lpoi = np.dot( gpoi, W2M )
-            upoi = gpoi if GLOBAL else lpoi
-        else:
-            upoi = None
-        pass
-
-
-        label = context + " ## " + elabel
-
-        if MODE == 3 and not "SAB" in os.environ:
-            if pvp.pv is None:
-                print("MODE is 3 but pvp.pv is None, get into ana environment first eg with hookup_conda_ok")
-            else:
-                pl = pvp.pvplt_plotter(label)
-                pvp.pvplt_viewpoint(pl) # sensitive EYE, LOOK, UP, ZOOM envvars eg EYE=0,-3,0
-
-                if not upoi is None:
-                    print("add_points green for the upoi : record points ")
-                    pl.add_points( upoi[:,:3], color="green", point_size=3.0 )
-                pass
-                if not upos is None:
-                    print("add_points red  for the upos : photon/hit points ")
-                    pl.add_points( upos[:,:3], color="red", point_size=3.0 )
-                pass
-                pl.show_grid()
-                pl.increment_point_size_and_line_width(INCPOI)
-                cp = pl.show()
-            pass
-        pass
-    pass
-
-
-
-pass
-
-
diff --git a/sysrap/SABTest.sh b/sysrap/SABTest.sh
deleted file mode 100644
index 3df3af8973..0000000000
--- a/sysrap/SABTest.sh
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-SABTest.sh : A-B comparison of persisted Opticks SEvt
-========================================================
-
-A:B comparison of SEvt and plotting is currently done by very 
-many Opticks scripts. Aims of SABTest.sh:
-
-1. replace most of the other A-B comparisons to decrease duplication
-2. work from release, ie do not depend on having source tree
-
-Started from ~/j/InputPhotonsCheck/InputPhotonsCheck.sh
-
-EOU
-}
-
-vv="BASH_SOURCE"
-source $HOME/.opticks/GEOM/GEOM.sh
-vv="$vv GEOM"
-source $HOME/.opticks/GEOM/EVT.sh    
-vv="$vv AFOLD BFOLD"
-
-anascript=SABTest.py
-
-defarg="info_ls_pdb"
-arg=${1:-$defarg}
-
-if [ "${arg/info}" != "$arg" ]; then
-    for v in $vv ; do printf "%30s :  %s\n" "$v" "${!v}" ; done
-fi
-
-if [ "${arg/ls}" != "$arg" ]; then
-    ff="AFOLD BFOLD"
-    for f in $ff ; do echo $f ${!f} && ls -alst ${!f} ; done
-fi
-
-if [ "${arg/pdb}" != "$arg" ]; then
-   ${IPYTHON:-ipython} --pdb -i $(which $anascript)
-   [ $? -ne 0 ] && echo $BASH_SOURCE pdb error
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-   ${PYTHON:-python} $(which $anascript)
-   [ $? -ne 0 ] && echo $BASH_SOURCE ana error
-fi
-
-if [ "${arg/chi2}" != "$arg" ] ; then
-   sseq_index_test.sh info_run_ana
-fi
-
-if [ "${arg/dhi2}" != "$arg" ] ; then
-   # development version of "chi2"
-   unset sseq_index_test__DEBUG
-   #export sseq_index_test__DEBUG=1
-   DEV=1 $HOME/opticks/sysrap/tests/sseq_index_test.sh info_build_run_ana
-fi
-
-
diff --git a/sysrap/SCenterExtentGenstep.py b/sysrap/SCenterExtentGenstep.py
deleted file mode 100644
index cab0f2e5c4..0000000000
--- a/sysrap/SCenterExtentGenstep.py
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/usr/bin/env python
-import numpy as np
-from opticks.ana.fold import Fold
-
-X,Y,Z,W=0,1,2,3
-
-class SCenterExtentGenstep(object):
-
-    @classmethod
-    def Lim(cls, xyz):
-        lim = np.zeros( (3,2), dtype=np.float32 )
-        for A in [X,Y,Z]: lim[A] = [xyz[:,A].min(), xyz[:,A].max() ]
-        return lim 
-
-
-    def __init__(self, path):
-        if path is None:
-            path = "/tmp/$USER/opticks/SCenterExtentGenstep"
-        pass
-
-        fold = Fold.Load(path)
-
-        photons = fold.photons
-        gs = fold.gs
-
-        self.fold = fold
-        self.peta = fold.peta
-        self.gs = gs
-        self.photons = photons
-        self.plim = self.Lim( photons[:,0] )
-        self.glim = self.Lim( gs[:,5] )
-   
-
-if __name__ == '__main__':
-
-
-    #path = os.path.expandvars("$CFBASE/CSGIntersectSolidTest/$GEOM")
-    path = None
-
-    cegs = SCenterExtentGenstep(path)
-
-    peta = cegs.peta
-    gs = cegs.gs 
-    photons = cegs.photons
-
-    print("cegs.plim\n", cegs.plim)
-    print("cegs.glim\n", cegs.glim)
-
-
-
- 
diff --git a/sysrap/SCenterExtentGenstep.sh b/sysrap/SCenterExtentGenstep.sh
deleted file mode 100755
index 6bf7798b52..0000000000
--- a/sysrap/SCenterExtentGenstep.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/bash -l 
-
-
-export CE=1000,0,0,1
-
-SCenterExtentGenstepTest 
-
-${IPYTHON:-ipython} -i SCenterExtentGenstep.py 
-
-
-
-
-
diff --git a/sysrap/SNameTest.sh b/sysrap/SNameTest.sh
deleted file mode 100644
index a01550729a..0000000000
--- a/sysrap/SNameTest.sh
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/bin/bash -l 
-usage(){ cat << EOU
-
-QTYPE=C SNameTest virtual 
-
-
-Default match type is QTYPE=S meaning START::
-
-    epsilon:sysrap blyth$ SNameTest NNVTMCPPMTsMask_virtual0x
-    id.desc()
-    SName::desc numName 141 name[0] sTopRock_domeAir0x578ca70 name[-1] uni10x5832ff0
-     findIndex                                                        NNVTMCPPMTsMask_virtual0x count   1 idx 110
-     findIndices                                                        NNVTMCPPMTsMask_virtual0x idxs.size   1 SName::QTypeLabel START
-    descIndices
-     110 : NNVTMCPPMTsMask_virtual0x5f5f900
-
-
-QTYPE=C uses CONTAIN name matching::
-
-    epsilon:sysrap blyth$ QTYPE=C SNameTest virtual 
-    id.desc()
-    SName::desc numName 141 name[0] sTopRock_domeAir0x578ca70 name[-1] uni10x5832ff0
-     findIndex                                                                          virtual count   0 idx  -1
-     findIndices                                                                          virtual idxs.size   3 SName::QTypeLabel CONTAIN
-    descIndices
-     110 : NNVTMCPPMTsMask_virtual0x5f5f900
-     117 : HamamatsuR12860sMask_virtual0x5f50d40
-     134 : mask_PMT_20inch_vetosMask_virtual0x5f62e40
-
-
-QTYPE=E uses EXACT name matching::
-
-    epsilon:sysrap blyth$ QTYPE=E SNameTest virtual
-    id.desc()
-    SName::desc numName 141 name[0] sTopRock_domeAir0x578ca70 name[-1] uni10x5832ff0
-     findIndex                                                                          virtual count   0 idx  -1
-     findIndices                                                                          virtual idxs.size   0 SName::QTypeLabel EXACT
-    descIndices
-
-    epsilon:sysrap blyth$ QTYPE=E SNameTest NNVTMCPPMTsMask_virtual0x5f5f900
-    id.desc()
-    SName::desc numName 141 name[0] sTopRock_domeAir0x578ca70 name[-1] uni10x5832ff0
-     findIndex                                                 NNVTMCPPMTsMask_virtual0x5f5f900 count   1 idx 110
-     findIndices                                                 NNVTMCPPMTsMask_virtual0x5f5f900 idxs.size   1 SName::QTypeLabel EXACT
-    descIndices
-     110 : NNVTMCPPMTsMask_virtual0x5f5f900
-
-    epsilon:sysrap blyth$ QTYPE=E SNameTest NNVTMCPPMTsMask_virtual0x5f5f90
-    id.desc()
-    SName::desc numName 141 name[0] sTopRock_domeAir0x578ca70 name[-1] uni10x5832ff0
-     findIndex                                                  NNVTMCPPMTsMask_virtual0x5f5f90 count   1 idx 110
-     findIndices                                                  NNVTMCPPMTsMask_virtual0x5f5f90 idxs.size   0 SName::QTypeLabel EXACT
-    descIndices
-
-
-EOU
-}
-
-
-SNameTest $* 
-
-
-
-
-
diff --git a/sysrap/SProp.py b/sysrap/SProp.py
deleted file mode 100755
index dfe018ba0b..0000000000
--- a/sysrap/SProp.py
+++ /dev/null
@@ -1,100 +0,0 @@
-#!/usr/bin/env python
-"""
-SProp.py 
-==========
-
-
-"""
-import os, logging, numpy as np
-from collections import OrderedDict as odict
-log = logging.getLogger(__name__)
-
-class SProp(object):
-    BASE = os.environ.get("NP_PROP_BASE", "/tmp")
-
-    @classmethod
-    def Resolve_(cls, spec):
-        relp = spec.replace(".","/")
-        return os.path.join(cls.BASE, relp) 
-
-    @classmethod
-    def Resolve(cls, spec):
-        return cls.Resolve_(spec) if spec.count(".") > 1 else spec  
-
-    @classmethod
-    def Names(cls, spec):
-        rawnames = os.listdir(cls.Resolve(spec))
-        names = []
-        for name in rawnames: 
-            if name.count(".") == 0:
-                names.append(name)
-            pass
-        pass
-        return names  
-
-    @classmethod
-    def Load(cls, spec):
-        path = cls.Resolve(spec)
-        log.debug(" spec %s path %s " % (spec, path))
-        try:
-            a = np.loadtxt(path, usecols=(0,2)) # skip "*eV" column 
-        except (ValueError, IndexError):
-            a = np.loadtxt(path, dtype=np.object)    
-        pass
-        if os.path.exists(path+".npy"):
-            b = np.load(path+".npy")
-            assert np.all( a == b )
-            log.debug(" path %s matches %s " % (path, path+".npy"))
-        pass 
-        return a 
-
-    def __init__(self, specbase="PMTProperty.R12860.", symbol="hama"):
-        props = odict()
-        specs = []
-        paths = []
-        for name in self.Names(specbase):
-            spec = "%s%s" % ( specbase, name) 
-            path = self.Resolve(spec)
-            props[name] = self.Load(path)
-            specs.append(spec)
-            paths.append(path)
-        pass
-        self.props = props
-        self.specs = specs
-        self.paths = paths 
-        self.specbase = specbase
-        self.symbol = symbol
-
-    def __repr__(self):
-        lines = []
-        lines.append("Prop %s %s " % (self.specbase, self.symbol) )
-        for k, v in self.props.items():
-            lines.append("%35s : %10s : %10s " % ("%s.%s" % (self.symbol, k), str(v.shape), str(v.dtype) ))
-        pass
-        return "\n".join(lines)
-
-    def __getattr__(self, spec):
-        if spec in self.props:
-            return self.props[spec]
-        else:
-            raise AttributeError  
-        pass
- 
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    hama = SProp("PMTProperty.R12860.", symbol="hama")
-    nnvt = SProp("PMTProperty.NNVTMCP.", symbol="nnvt")
-    nnvtq = SProp("PMTProperty.NNVTMCP_HiQE.", symbol="nnvtq")
- 
-    print(repr(hama))
-    print(repr(nnvt))
-    print(repr(nnvtq))
-
-    for symbol in ["hama", "nnvt", "nnvtq"]:
-        expr = "np.c_[%(symbol)s.PHC_RINDEX, %(symbol)s.PHC_KINDEX, %(symbol)s.ARC_RINDEX ] " % locals()   
-        print(expr)
-        print(eval(expr))
-    pass
-    # energy domain consistent within but not between them 
-
diff --git a/sysrap/SProp.sh b/sysrap/SProp.sh
deleted file mode 100755
index 0549110877..0000000000
--- a/sysrap/SProp.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash -l
-
-${IPYTHON:-ipython} --pdb -i SProp.py 
-
-
diff --git a/sysrap/__init__.py b/sysrap/__init__.py
deleted file mode 100644
index a11c1d2a07..0000000000
--- a/sysrap/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-#
-# 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.
-#
-
diff --git a/sysrap/dv.py b/sysrap/dv.py
deleted file mode 100644
index 1a74a80e99..0000000000
--- a/sysrap/dv.py
+++ /dev/null
@@ -1,106 +0,0 @@
-#!/usr/bin/env python
-
-import os, numpy as np
-from opticks.ana.fold import Fold
-from opticks.ana.array_repr_mixin import ArrayReprMixin
-
-class AlignedDV(ArrayReprMixin, object):
-    """
-    Simple deviation comparisons of random aligned arrays 
-
-    In [2]: pdv.dv
-    Out[2]: 
-    array([[   47,   117,  1732,  4412,  2710,   965,    16,     1,     0,     0],
-           [ 2746,  5430,  1724,    96,     4,     0,     0,     0,     0,     0],
-           [ 6404,  2937,   647,    11,     1,     0,     0,     0,     0,     0],
-           [ 9995,     1,     1,     3,     0,     0,     0,     0,     0,     0],
-           [10000,     0,     0,     0,     0,     0,     0,     0,     0,     0]], dtype=uint32)
-
-    """
-    EDGES = np.array( [0.,1e-6,1e-5,1e-4,1e-3, 1e-2, 1e-1, 1, 10, 100, 1000], dtype=np.float32 ) 
-    COLUMN_LABEL = ["%g" % _ for _ in EDGES[1:]]
-
-    POS = 0 
-    TIME = 1 
-    MOM = 2 
-    POL = 3
-    WL = 4 
-
-    ITEMS = (POS, TIME, MOM, POL, WL)
-    ROW_LABEL = ("pos", "time", "mom", "pol", "wl")
-
-    def __init__(self, a, b, arr="photon", symbol=None):
-        """ 
-        :param a: opticks.ana.fold Fold instance
-        :param b: opticks.ana.fold Fold instance
-
-        In [12]: adv[...,0,3].shape
-        Out[12]: (10000,)
-
-        In [13]: bdv[...,0,3].shape
-        Out[13]: (10000, 10)
-        """
-
-        wseq = np.where( a.seq[:,0] == b.seq[:,0] ) 
-        adv = np.abs( getattr(a,arr)[wseq] - getattr(b,arr)[wseq] )  ## for deviations to be meaningful needs to be same history  
-
-
-        ## although ... ellipsis indexing can generalize access between photon and record 
-        ## need to use different np.amax axis args to keep the deviation at photon level, not record level 
-        if arr == "photon":  
-            time = adv[:,0,3] 
-            pos  = np.amax( adv[:,0,:3], axis=1 )  ## amax of the 3 position deviations, so can operate at photon position level, not x,y,z level 
-            mom  = np.amax( adv[:,1,:3], axis=1 )
-            pol  = np.amax( adv[:,2,:3], axis=1 )
-            wl   = adv[:,2,3]
-        elif arr == "record":
-            time = np.amax( adv[:,:,0,3], axis=1 ) 
-            pos  = np.amax( adv[:,:,0,:3], axis=(1,2) )  ## amax of the 3 position deviations, so can operate at photon position level, not x,y,z level 
-            mom  = np.amax( adv[:,:,1,:3], axis=(1,2) )
-            pol  = np.amax( adv[:,:,2,:3], axis=(1,2) )
-            wl   = np.amax( adv[:,:,2,3], axis=1 )
-        else:
-            assert 0, "expecting photon or record not %s " % arr
-        pass
-
-        dv = np.zeros( (len(self.ITEMS),len(self.EDGES)-1), dtype=np.uint32 )
-        dv[self.POS], bins = np.histogram( pos, bins=self.EDGES ) 
-        dv[self.TIME], bins = np.histogram( time, bins=self.EDGES ) 
-        dv[self.MOM], bins = np.histogram( mom, bins=self.EDGES ) 
-        dv[self.POL], bins = np.histogram( pol, bins=self.EDGES ) 
-        dv[self.WL], bins = np.histogram( wl, bins=self.EDGES ) 
-
-        self.symbol = symbol if not symbol is None else "%s.dv" % arr
-        self.pos = pos
-        self.time = time
-        self.mom = mom 
-        self.pol = pol
-        self.wl = wl 
-        self.dv = dv
-
-    def __repr__(self):
-        return self.MakeRepr(self.dv, symbol=self.symbol)
-
-
-class HeaderAB(object):
-    def __init__(self, a, b, cmdline):
-        self.lines = ["A_FOLD : %s " % a.base, "B_FOLD : %s " % b.base, cmdline ]
-    def __repr__(self):
-        return "\n".join(self.lines) 
-
-
-if __name__ == '__main__':
-    a = Fold.Load("$A_FOLD", symbol="a") if "A_FOLD" in os.environ else None
-    b = Fold.Load("$B_FOLD", symbol="b") if "B_FOLD" in os.environ else None
-
-    hdr = HeaderAB(a,b, "./dv.sh   # cd ~/opticks/sysrap")
-    print(hdr)
-
-    pdv = AlignedDV(a,b, arr="photon", symbol="pdv")
-    print(pdv)    
-
-    rdv = AlignedDV(a,b, arr="record", symbol="rdv")
-    print(rdv)    
-
-
-
diff --git a/sysrap/dv.sh b/sysrap/dv.sh
deleted file mode 100755
index fea7fe752e..0000000000
--- a/sysrap/dv.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash -l 
-
-source ../bin/AB_FOLD.sh 
-
-${IPYTHON:-ipython} --pdb -i dv.py $*  
-
-
diff --git a/sysrap/go.sh b/sysrap/go.sh
deleted file mode 100755
index 43207ad518..0000000000
--- a/sysrap/go.sh
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/bin/bash -l
-##
-## 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.
-##
-
-
-opticks-
-
-sdir=$(pwd)
-name=$(basename $sdir)
-#bdir=/tmp/$USER/opticks/$name/build 
-bdir=$(opticks-prefix)/build/$name
-
-#rm -rf $bdir 
-mkdir -p $bdir && cd $bdir && pwd 
-
-cmake $sdir \
-    -DCMAKE_BUILD_TYPE=Debug \
-    -DCMAKE_PREFIX_PATH=$(opticks-prefix)/externals \
-    -DCMAKE_INSTALL_PREFIX=$(opticks-prefix) \
-    -DCMAKE_MODULE_PATH=$(opticks-home)/cmake/Modules
-
-make
-make install   
-
-
diff --git a/sysrap/npd.sh b/sysrap/npd.sh
deleted file mode 100755
index 59091884b8..0000000000
--- a/sysrap/npd.sh
+++ /dev/null
@@ -1,28 +0,0 @@
-#!/bin/bash -l 
-
-msg="=== $BASH_SOURCE :"
-arg=${1:-diff}
-echo $msg arg [$arg] AVAILABLE CMDS : diff, cp 
-hhs="NP.hh NPU.hh"
-
-if [ "$arg" == "diff" ]; then 
-    for hh in $hhs ; do 
-        cmd="diff $HOME/np/$hh $hh"
-        echo $msg $cmd
-        eval $cmd
-        [ $? -ne 0 ] && echo $msg DIFF DETECTED && exit 1  
-    done
-elif [ "$arg" == "cp" ]; then 
-    for hh in $hhs ; do 
-        cmd="cp $HOME/np/$hh $hh"
-        echo $msg $cmd
-        eval $cmd
-        [ $? -ne 0 ] && echo $msg COPY ERROR && exit 2  
-    done
-fi 
-
-
-echo $msg suggested commit message : update NP.hh from https://github.com/simoncblyth/np 
-
-exit 0 
-
diff --git a/sysrap/populate_gl.sh b/sysrap/populate_gl.sh
deleted file mode 100755
index 48f2de9a17..0000000000
--- a/sysrap/populate_gl.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash
-
-cd ~/opticks/sysrap
-#cp -r ../examples/UseShaderSGLFW_SScene_encapsulated/gl/* gl/
-#cp -r ../examples/UseGeometryShader/rec_flying_point_persist gl/
-
-
-
diff --git a/sysrap/sc4u.sh b/sysrap/sc4u.sh
deleted file mode 100755
index 4303a6fa73..0000000000
--- a/sysrap/sc4u.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/bin/bash 
-
-name=sc4u 
-gcc $name.cc -std=c++11 -lstdc++ -I. -I/usr/local/cuda/include -o /tmp/$name 
-[ $? -ne 0 ] && echo compile error && exit 1
-
-/tmp/$name 
-[ $? -ne 0 ] && echo run error && exit 2
-
-ipython -i -c "import numpy as np ; a = np.load('/tmp/p.npy') ; print(a.view(np.int8)) " 
-[ $? -ne 0 ] && echo ana error && exit 3
-
-exit 0 
-
diff --git a/sysrap/sevt.py b/sysrap/sevt.py
deleted file mode 100644
index 3472fd655b..0000000000
--- a/sysrap/sevt.py
+++ /dev/null
@@ -1,1211 +0,0 @@
-#!/usr/bin/env python
-"""
-sevt.py (formerly opticks.u4.tests.U4SimulateTest)
-====================================================
-
-
-"""
-import os, re, logging, textwrap, numpy as np
-log = logging.getLogger(__name__)
-
-from opticks.ana.fold import Fold
-
-print("[from opticks.ana.p import * ")
-from opticks.ana.p import *
-print("]from opticks.ana.p import * ")
-
-from opticks.ana.eget import eslice_
-from opticks.ana.base import PhotonCodeFlags
-from opticks.ana.qcf import QU,QCF,QCFZero
-from opticks.ana.npmeta import NPMeta
-from opticks.ana.hismask import HisMask
-
-hm = HisMask()
-
-pcf = PhotonCodeFlags()
-fln = pcf.fln
-fla = pcf.fla
-
-
-MODE = int(os.environ.get("MODE","2"))
-if MODE > 0:
-    from opticks.ana.pvplt import *
-else:
-    pass
-pass
-
-QLIM=eslice_("QLIM", "0:10")
-
-
-axes = 0, 2  # X,Z
-H,V = axes
-
-
-class SEvt(object):
-    """
-    Higher level wrapper for an Opticks SEvt folder of arrays
-
-    WIP: Concatenation of multiple SEvt, starting from Fold concatenation
-    """
-    @classmethod
-    def Load(cls, *args, **kwa):
-        NEVT = int(kwa.get("NEVT",0))
-        log.info("SEvt.Load NEVT:%d " % NEVT)
-        if NEVT > 0:
-            f = cls.LoadConcat(*args,**kwa)
-        else:
-            f = Fold.Load(*args, **kwa )
-        pass
-        return None if f is None else cls(f, **kwa)
-
-    @classmethod
-    def LoadConcat(cls, *args, **kwa):
-        """
-        HMM maybe should load the separate SEvt and then concat those,
-        rather than trying to concat at the lower Fold level
-        """
-        NEVT = int(kwa.get("NEVT",0))
-        assert NEVT > 0
-        f = Fold.LoadConcat(*args, **kwa)
-        assert hasattr(f, 'ff')
-        return f
-
-    def __init__(self, f, **kwa):
-        """
-        :param f: Fold instance
-        :param kwa: override param, only W2M accepted
-        """
-
-        self.f = f
-        self.symbol = f.symbol
-        self._r = None
-        self.r = None
-        self._a = None
-        self.a = None
-        self._pid = -1
-        self.W2M = kwa.get("W2M", None)
-        print("sevt.init W2M\n", self.W2M )
-
-        self.init_run(f)
-        self.init_meta(f)
-        self.init_fold_meta_timestamp(f)
-        self.init_fold_meta(f)
-        self.init_U4R_names(f)
-        self.init_photon(f)
-        self.init_record(f)
-        self.init_record_sframe(f)
-        self.init_SEventConfig_meta(f)
-        self.init_seq(f)
-        self.init_aux(f)
-        self.init_ee(f)    ## handling of concatenated SEvt is done currently only for ee
-        self.init_aux_t(f)
-        self.init_sup(f)
-        self.init_junoSD_PMT_v2_SProfile(f)
-        self.init_env(f)  # setting pid needs frames so has to be late
-
-    @classmethod
-    def CommonRunBase(cls, f):
-        """
-        :param f: Fold instance
-        :return urun_base: str
-        """
-        run_bases = []
-        if type(f.base) is str:
-            run_base = os.path.dirname(f.base)
-            run_bases.append(run_base)
-        elif type(f.base) is list:
-            for base in f.base:
-                run_base = os.path.dirname(base)
-                if not run_base in run_bases:
-                    run_bases.append(run_base)
-                pass
-        else:
-            pass
-        pass
-        assert len(run_bases) == 1
-        urun_base = run_bases[0]
-        return urun_base
-
-    def init_run(self, f):
-        """
-        HMM the run meta should be same for all of concatenated SEvts
-        """
-        urun_base = self.CommonRunBase(f)
-        urun_path = os.path.join( urun_base, "run.npy" )
-
-        # THIS WAS RECURSING AND LOADING THE n001 and p001 folders
-        #print("[ sevt.init_run Fold.Load urun_path %s loading urun_base %s " % (urun_path,urun_base) )
-        #fp = Fold.Load(urun_base) if os.path.exists(urun_path) else None
-        #print("] sevt.init_run Fold.Load ")
-        #run_meta = not fp is None and getattr(fp,'run_meta', None) != None
-        #self.fp = fp
-
-        urun_meta = os.path.join( urun_base, "run_meta.txt" )
-        run_meta = NPMeta.Load(urun_meta) if os.path.exists(urun_meta) else None
-        has_run_meta = not run_meta is None
-
-        prof2stamp_ = lambda prof:prof.split(",")[0]
-
-        rr_ = [prof2stamp_(run_meta.SEvt__BeginOfRun),
-               prof2stamp_(run_meta.SEvt__EndOfRun  )] if has_run_meta else [0,0]
-
-        rr = np.array(rr_, dtype=np.uint64 )
-
-        self.rr = rr
-        self.run_meta = run_meta
-
-        qwns = ["FAKES_SKIP",]
-        for qwn in qwns:
-            mval = list(map(int,getattr(run_meta, qwn, ["-1"] ) if has_run_meta else ["-2"]))
-            setattr(self, qwn, mval[0] )
-        pass
-
-
-    def init_env(self, f):
-        """
-        """
-        pid = int(os.environ.get("%sPID" % f.symbol.upper(), "-1"))
-        opt = os.environ.get("%sOPT" % f.symbol.upper(), "")
-        off_ = os.environ.get("%sOFF" % f.symbol.upper(), "0,0,0")
-        off = np.array(list(map(float,off_.split(","))))
-        log.info("SEvt.__init__  symbol %s pid %d opt %s off %s " % (f.symbol, pid, opt, str(off)) )
-
-        self.pid = pid
-        self.opt = opt
-        self.off = off
-
-    def init_meta(self, f):
-        """
-        """
-        metakey = os.environ.get("METAKEY", "junoSD_PMT_v2_Opticks_meta" )
-        meta = getattr(f, metakey, None)
-        self.metakey = metakey
-        self.meta = meta
-
-    def init_fold_meta_timestamp(self, f):
-        """
-        """
-        if getattr(f, "NPFold_meta", None) == None: return
-        msrc = f.NPFold_meta
-        if msrc is None: return
-
-        def mts_(key):
-            val = msrc.get_value(key)
-            if val == '': val = "0"
-            return np.uint64(val)
-
-        bor = mts_("T_BeginOfRun")
-        boe = mts_("t_BeginOfEvent")
-        gs0 = mts_("t_setGenstep_0")
-        gs1 = mts_("t_setGenstep_1")
-        gs2 = mts_("t_setGenstep_2")
-        gs3 = mts_("t_setGenstep_3")
-        gs4 = mts_("t_setGenstep_4")
-        gs5 = mts_("t_setGenstep_5")
-        gs6 = mts_("t_setGenstep_6")
-        gs7 = mts_("t_setGenstep_7")
-        gs8 = mts_("t_setGenstep_8")
-        pre = mts_("t_PreLaunch")
-        pos = mts_("t_PostLaunch")
-        eoe = mts_("t_EndOfEvent")
-
-        b2e = eoe - boe
-        ee = np.array([boe, eoe, b2e], dtype=np.uint64 )
-        ett = np.array([bor, boe, gs0, gs1, gs2, gs3, gs4, gs5, gs6, gs7, gs8, pre, pos, eoe], dtype=np.uint64 )
-        ettl = "bor boe gs0 gs1 gs2 gs3 gs4 gs5 gs6 gs7 gs8 pre pos eoe".split()
-        ettd = np.zeros( len(ett), dtype=np.uint64 )
-        ettd[1:] = np.diff(ett)
-
-        ettv = ett.view("datetime64[us]")
-        ettc = np.c_[ettl, ett, ettv.astype("|S26"), ettd/1e6, ettd]
-
-        self.ee = ee
-        self.ett = ett
-        self.ettd = ettd
-        self.ettv = ettv
-        self.ettl = ettl
-        self.ettc = ettc
-
-
-    def init_fold_meta(self, f):
-        """
-        """
-        if getattr(f, "NPFold_meta", None) == None: return
-        msrc = f.NPFold_meta
-        if msrc is None: return
-
-        GEOM = msrc.get_value("GEOM")
-        CHECK = msrc.get_value("CHECK")
-        LAYOUT = msrc.get_value("LAYOUT")
-        VERSION = msrc.get_value("VERSION")
-        if LAYOUT.find(" ") > -1: LAYOUT = ""
-
-        SCRIPT = os.environ.get("SCRIPT", "")
-
-        GEOMList = msrc.get_value("${GEOM}_GEOMList", "")
-        if GEOMList.endswith("GEOMList"): GEOMList = ""
-
-        TITLE = "N=%s %s # %s/%s " % (VERSION, SCRIPT, LAYOUT, CHECK )
-        IDE = list(filter(None,[f.symbol.upper(), GEOM, GEOMList, "N%s"%VERSION, LAYOUT, CHECK]))
-        ID = "_".join(IDE)
-
-        self.CHECK = CHECK
-        self.LAYOUT = LAYOUT
-        self.VERSION = VERSION
-        self.SCRIPT = SCRIPT
-        self.GEOM = GEOM
-        self.GEOMList = GEOMList
-        self.TITLE = TITLE
-        self.IDE = IDE
-        self.ID = ID
-
-    def init_U4R_names(self, f):
-        """
-        Now its an array with UNSET
-        """
-        U4R_names = getattr(f, "U4R_names", None)
-        #SPECS = np.array(U4R_names.lines) if not U4R_names is None else None
-        SPECS = U4R_names if not U4R_names is None else None
-        self.SPECS = SPECS
-
-    @classmethod
-    def Make_flagmask_table(cls, flagmask):
-        """
-
-            In [30]: np.c_[ label, fmtab[:,1] ][:20]
-            Out[30]:
-            array([['TO|BT|SA', '326185'],
-                   ['EC|TO|BT|SD', '312177'],
-                   ['TO|BT|SR|SA', '56805'],
-                   ['TO|BT|BR|SR|SA', '53334'],
-                   ['TO|BT|BR|SA', '42888'],
-                   ['TO|BT|BR|AB', '37716'],
-                   ['EC|TO|BT|BR|SD', '21709'],
-                   ['TO|BT|BR|SA|SC', '20683'],
-                   ['TO|BT|BR|SC|AB', '15776'],
-                   ['EC|TO|BT|BR|SD|SC', '13679'],
-                   ['TO|BT|AB', '12490'],
-                   ['TO|BT|BR|SR|SA|SC', '8668'],
-
-        """
-        _fmtabraw = np.c_[np.unique(flagmask,return_counts=True)]
-        fmtabraw = _fmtabraw[np.argsort(_fmtabraw[:,1])][::-1]
-        label = hm.label(fmtabraw[:,0])
-        fmtab = np.c_[ label, fmtabraw[:,1] ]
-        return fmtab
-
-    def init_photon(self, f):
-        if hasattr(f,'photon') and not f.photon is None:
-            iix = f.photon[:,1,3].view(np.int32)
-            flagmask = f.photon[:,3,3].view(np.int32)
-            fmtab = self.Make_flagmask_table(flagmask)
-        else:
-            iix = None
-            flagmask = None
-            fmtab = None
-        pass
-        self.iix = iix
-        self.flagmask = flagmask
-        self.fmtab = fmtab
-
-
-    def init_record(self, f):
-        """
-        :param f: fold instance
-        """
-        if hasattr(f,'record') and not f.record is None:
-
-            if f.record.dtype.name == 'float32':
-                iir = f.record[:,:,1,3].view(np.int32)
-                idr = f.record[:,:,1,3].view(np.int32)
-            elif f.record.dtype.name == 'float64':
-                iir = f.record[:,:,1,3].view(np.int64)
-                idr = f.record[:,:,1,3].view(np.int64)
-            else:
-                assert False
-            pass
-        else:
-            iir = None
-            idr = None
-        pass
-        self.iir = iir
-        self.idr = idr
-
-    def init_record_sframe(self, f):
-
-        with_sframe = not getattr(f, "sframe", None) is None
-        with_record = not getattr(f, "record", None) is None
-
-        W2M = self.W2M
-
-        if with_sframe and with_record:
-            gpos = np.ones( f.record.shape[:-1] )  ## trim last dimension reducing eg (10000,32,4,4) to (10000, 32, 4)
-            gpos[:,:,:3] = f.record[:,:,0,:3]      ## point positions of all photons
-            w2m = W2M if not W2M is None else f.sframe.w2m
-            lpos = np.dot( gpos, w2m )  ## transform all points from global to local frame
-        else:
-            w2m = W2M if not W2M is None else None
-            gpos = None
-            lpos = None
-        pass
-        self.w2m = w2m
-        self.gpos = gpos
-        self.lpos = lpos
-
-
-
-    def init_SEventConfig_meta(self, f):
-        meta = getattr(f, 'SEventConfig_meta', {})
-
-        ipl = getattr(meta, "InputPhoton", [])
-        ip = ipl[0] if len(ipl)==1 else None
-
-        ipfl = getattr(meta, "InputPhotonFrame", [])
-        ipf = ipfl[0] if len(ipfl)==1 else None
-
-        ipcl = getattr(meta, "InputPhotonCheck", [])
-        ipc = ipc[0] if len(ipcl)==1 else None
-
-        self.ip = ip
-        self.ipf = ipf
-        self.ipc = ipc
-
-
-    def q_find(self, txt="EC", encoding="utf-8"):
-        """
-        :param txt:
-        :return a: array of indices of self.q array elements that contain *txt*
-
-        np.char.find returns -1 when the txt is not found in array elements
-        so adding one makes that zero which is excluded with np.flatnonzero
-
-        Note that because the self.q array elements typically end with blanks
-        it is not useful to implement q_endswith, instead use this q_find
-        to find array indices with elements containing the txt.
-        """
-        return np.flatnonzero(1+np.char.find(self.q, txt.encode(encoding) ))
-
-    def q_find_or(self, txt1="EC", txt2="EX", encoding="utf-8"):
-        return np.flatnonzero(np.logical_or(
-                  1+np.char.find(self.q,txt1.encode(encoding)),
-                  1+np.char.find(self.q,txt2.encode(encoding))
-               ))
-
-    def q_find_or_(self, txts_="EC,EX", delim=",", encoding="utf-8"):
-        txts= txts_.split(delim)
-        aa = []
-        for txt in txts:
-            aa.append( 1+np.char.find(self.q, txt.encode(encoding)))
-        pass
-        return np.flatnonzero(np.logical_or.reduce(aa))
-
-    def q__(self, prefix="TO BT SD", encoding="utf-8"):
-        return self.q_startswith_or_(prefix) if "," in prefix else self.q_startswith(prefix=prefix)
-
-    def q_startswith(self, prefix="TO BT SD", encoding="utf-8"):
-        return np.flatnonzero(np.char.startswith(self.q, prefix.encode(encoding) ))
-
-    def q_startswith_or(self, pfx1="TO BT BT BT SA", pfx2="TO BT BT BT SD", encoding="utf-8"):
-        return np.flatnonzero(np.logical_or(
-                   np.char.startswith(self.q,pfx1.encode(encoding)),
-                   np.char.startswith(self.q,pfx2.encode(encoding))
-               ))
-
-    def q_startswith_or_(self, pfxs_="TO BT BT BT SA,TO BT BT BT SD", delim=",", encoding="utf-8"):
-        """
-        :param pfxs_: delimited string list with potentially multiple history strings
-        :param delim:
-
-        Another way to implement this is with np.any
-        """
-        pfxs = pfxs_.split(delim)
-        aa = []
-        for pfx in pfxs:
-            aa.append( np.char.startswith(self.q, pfx.encode(encoding)))
-        pass
-        return np.flatnonzero(np.logical_or.reduce(aa))
-
-    def init_seq(self, f):
-        """
-
-        +---------------------+----------------------------------------------------------+
-        | a.f.seq.shape       | (1000000, 2, 2)                                          |
-        +---------------------+----------------------------------------------------------+
-        | a.f.seq[:,0].shape  | (1000000, 2)                                             |
-        +---------------------+----------------------------------------------------------+
-        | a.f.seq[0,0]        | array([14748335283153718477, 37762157772], dtype=uint64) |
-        +---------------------+----------------------------------------------------------+
-
-        """
-        symbol = f.symbol
-        qlim = QLIM
-        qtab_ = "np.c_[qn,qi,qu][quo][qlim]"
-
-        if hasattr(f,'seq') and not f.seq is None:
-            q_ = f.seq[:,0]
-            q  = ht.seqhis(q_)  # ht from opticks.ana.p
-            qq = ht.Convert(q_)  # (n,32) int8 : for easy access to nibbles
-            n = np.sum( seqnib_(q_), axis=1 )  # occupied nibbles, ie number of history points
-
-            qu, qi, qn = np.unique(q, return_index=True, return_counts=True)
-            quo = np.argsort(qn)[::-1]
-
-            qtab = eval(qtab_)
-            qtab_ = qtab_.replace("q","%s.q" % symbol)
-
-            nosc = np.ones(len(qq), dtype=np.bool_ )       # start all true
-            nosc[np.where(qq == pcf.SC)[0]] = 0     # knock out photons with scatter in their histories
-
-            nore = np.ones(len(qq), dtype=np.bool_ )       # start all true
-            nore[np.where(qq == pcf.RE)[0]] = 0     # knock out photons with reemission in their histories
-
-            noscab = np.ones(len(qq), dtype=np.bool_ )     # start all true
-            noscab[np.where(qq == pcf.SC)[0]] = 0   # knock out photons with scatter in their histories
-            noscab[np.where(qq == pcf.AB)[0]] = 0   # knock out photons with bulk absorb  in their histories
-        else:
-            q_ = None
-            q = None
-            qq = None
-            n = None
-            qu, qi, qn = None, None, None
-            quo = None
-            qtab = None
-
-            nosc = None
-            nore = None
-            noscab = None
-        pass
-
-        self.q_ = q_
-        self.q = q
-        self.qq = qq
-        self.n = n
-
-        self.qu = qu
-        self.qi = qi
-        self.qn = qn
-
-        self.quo = quo
-        self.qtab = qtab
-
-        self.qlim = qlim
-        self.qtab_ = qtab_
-
-        self.nosc = nosc   # mask of photons without SC in their histories
-        self.nore = nore   # mask of photons without RE in their histories
-        self.noscab = noscab   # mask of photons without SC or AB in their histories
-
-
-
-    def minimal_qtab(self, sli="[:10]", dump=False):
-        """
-        :return qtab: history table in descending count order
-        """
-        e = self
-        uq,iq,nq = np.unique(e.q, return_index=True, return_counts=True)
-        oq = np.argsort(nq)[::-1]
-        expr ="np.c_[nq,iq,uq][oq]%(sli)s" % locals()
-        qtab = eval(expr)
-        if dump:
-            log.info("minimal_qtab : %s " % expr)
-            print(qtab)
-        pass
-        return qtab
-
-    def init_aux(self, f):
-        """
-        Note aux is currently CPU only
-        """
-        if hasattr(f, 'aux') and not f.aux is None:
-            fk = f.aux[:,:,2,2].view(np.uint32)    ## fakemask : for investigating fakes when FAKES_SKIP is disabled
-            spec_ = f.aux[:,:,2,3].view(np.int32)   ## step spec
-            max_point = f.aux.shape[1]   # instead of hardcoding typical values like 32 or 10, use array shape
-            uc4 = f.aux[:,:,2,2].copy().view(np.uint8).reshape(-1,max_point,4) ## see sysrap/spho.h c4/C4Pho.h
-            eph = uc4[:,:,1]          # .y    ProcessHits enum at step point level
-            ep = np.max(eph, axis=1 ) #       ProcessHits enum at photon level
-        else:
-            fk = None
-            spec_ = None
-            uc4 = None
-            eph = None
-            ep = None
-            t = None
-        pass
-        self.fk = fk
-        self.spec_ = spec_
-        self.uc4 = uc4
-        self.eph = eph   # ProcessHits EPH enum at step point level
-        self.ep  = ep    # ProcessHits EPH enum at photon level
-
-    def init_ee(self, f):
-        """
-        microsecond[us] timestamps (UTC epoch) [BeginOfEvent,EndOfEvent,Begin2End]
-
-        For concatenated SEvt the total of all the EndOfEvent-BeginOfEvent
-        is placed into ee[-1]
-
-        TIMING METADATA HAS BEEN MOVED FROM THE PHOTON TO THE FOLD
-        with_ff = not getattr(f, 'ff', None) is None
-        log.info("init_ee with_ff:%d" % (with_ff))
-        if with_ff:
-            kk = f.ff.keys()
-            boe = np.uint64(0)
-            eoe = np.uint64(0)
-            b2e = np.uint64(0)
-            for k in kk:
-                fk = f.ff[k]
-                k_boe = np.uint64(fk.photon_meta.t_BeginOfEvent[0])
-                k_eoe = np.uint64(fk.photon_meta.t_EndOfEvent[0])
-                k_b2e = np.uint64(k_eoe-k_boe)
-                b2e += k_b2e
-            pass
-        else:
-            boe, eoe, b2e = 0,0,0
-        pass
-        self.ee = np.array([boe, eoe, b2e], dtype=np.uint64 )
-        """
-
-    def init_junoSD_PMT_v2_SProfile(self, f):
-        """
-        The timestamps come from sysrap/sstamp.h and are datetime64[us] (UTC) compliant
-
-        pf
-            uint64_t microsecond timestamps collected by SProfile.h
-        pfr
-            uint64_t (last - first) timestamp difference for each SProfile (currently ProcessHits call)
-
-
-        More than 10% of time spent in ProcessHits::
-
-            In [16]: np.sum(a.pfr)/a.ee[-1]
-            Out[16]: 0.10450881266649384
-
-            In [17]: np.sum(b.pfr)/b.ee[-1]
-            Out[17]: 0.11134881257006096
-
-        """
-        if hasattr(f, 'junoSD_PMT_v2_SProfile') and not f.junoSD_PMT_v2_SProfile is None:
-            pf = f.junoSD_PMT_v2_SProfile
-            pfmx = np.max(pf[:,1:], axis=1 )
-            pfmi = pf[:,1]
-            pfr = pfmx - pfmi
-        else:
-            pf = None
-            pfmx = None
-            pfmi = None
-            pfr = None
-        pass
-        self.pf = pf  ## CAUTION: multiple ProcessHits calls per photon, so not in photon index order
-        self.pfmx = pfmx
-        self.pfmi = pfmi
-        self.pfr  = pfr
-
-
-
-    def init_aux_t(self, f):
-        if hasattr(f, 'aux') and not f.aux is None:
-            t = f.aux[:,:,3,:2].copy().view(np.uint64).squeeze()   # step point timestamps
-        else:
-            t = None
-        pass
-        self.t = t      # array of photon step point time stamps (UTC epoch)
-
-    def init_sup(self, f):
-        """
-        sup is CPU only
-
-        photon level beginPhoton endPhoton time stamps from the sup quad4
-        """
-        if hasattr(f,'sup') and not f.sup is None:
-            s0 = f.sup[:,0,:2].copy().view(np.uint64).squeeze()  # SEvt::beginPhoton (xsup.q0.w.x)
-            s1 = f.sup[:,0,2:].copy().view(np.uint64).squeeze()  # SEvt::finalPhoton (xsup.q0.w.y)
-            ss = s1 - s0      # endPhoton - beginPhoton
-
-            f0 = f.sup[:,1,:2].copy().view(np.uint64).squeeze()  # SEvt::finalPhoton (xsup.q1.w.x) t_PenultimatePoint
-            f1 = f.sup[:,1,2:].copy().view(np.uint64).squeeze()  # SEvt::finalPhoton (xsup.q1.w.y) t_LastPoint
-            ff = f1 - f0      # LastPoint - PenultimatePoint
-
-            h0 = f.sup[:,2,:2].copy().view(np.uint64).squeeze()  # SEvt::addProcessHitsStamp(0) (xsup.q2.w.x)
-            h1 = f.sup[:,2,2:].copy().view(np.uint64).squeeze()  # SEvt::addProcessHitsStamp(0) (xsup.q2.w.y)
-            hh = h1 - h0                      # timestamp range of SEvt::AddProcessHitsStamp(0) calls
-            hc = f.sup[:,3,0].view(np.int32)
-
-            i0 = f.sup[:,4,:2].copy().view(np.uint64).squeeze()  # SEvt::addProcessHitsStamp(1) (xsup.q4.w.x)
-            i1 = f.sup[:,4,2:].copy().view(np.uint64).squeeze()  # SEvt::addProcessHitsStamp(1) (xsup.q4.w.y)
-            ii = i1 - i0                      # timestamp range of SEvt::AddProcessHitsStamp(1) calls
-            ic = f.sup[:,5,0].view(np.int32)
-
-            hi0 = i0 - h0
-            hi1 = i1 - h1
-        else:
-            s0 = None
-            s1 = None
-            ss = None
-
-            f0 = None
-            f1 = None
-            ff = None
-
-            h0 = None
-            h1 = None
-            hh = None
-            hc = None
-
-            i0 = None
-            i1 = None
-            ii = None
-            ic = None
-
-            hi0 = None
-            hi1 = None
-        pass
-        if not getattr(self, 't', None) is None and not s0 is None:
-            t0 = s0.min()
-            tt = self.t.copy()
-            tt[np.where( tt != 0 )] -= t0   # subtract earliest time "pedestal", but leave the zeros
-        else:
-            t0 = None
-            tt = None
-        pass
-
-        self.t0 = t0    # scalar : event minimum time stamp (which is minimum s0:beginPhoton timestamp)
-        self.tt = tt    # array of photon step point time stamps relative to t0
-
-        self.s0 = s0    # array of beginPhoton time stamps (UTC epoch)
-        self.s1 = s1    # array of endPhoton time stamps (UTC epoch)
-        self.ss = ss    # array of endPhoton-beginPhoton timestamp differences
-
-        self.f0 = f0    # array of PenultimatePoint timestamps (UTC epoch)
-        self.f1 = f1    # array of LastPoint timestamps (UTC epoch)
-        self.ff = ff    # array of LastPoint-PenultimatePoint timestamp differences
-
-        self.h0 = h0    # array of SEvt::AddProcessHitsStamp(0) range begin (UTC epoch)
-        self.h1 = h1    # array of SEvt::AddProcessHitsStamp(0) range end (UTC epoch)
-        self.hh = hh    # array of SEvt::AddProcessHitsStamp(0) ranges (microseconds [us])
-        self.hc = hc    # array of SEvt::AddProcessHitsStamp(0) call counts for each photon
-
-        self.i0 = i0    # array of SEvt::AddProcessHitsStamp(1) range begin (UTC epoch)
-        self.i1 = i1    # array of SEvt::AddProcessHitsStamp(1) range end (UTC epoch)
-        self.ii = ii    # array of SEvt::AddProcessHitsStamp(1) ranges (microseconds [us])
-        self.ic = ic    # array of SEvt::AddProcessHitsStamp(1) call counts for each photon
-
-        self.hi0 = hi0  # array of range begin SEvt::AddProcessHitsStamp(1)-SEvt::AddProcessHitsStamp(0)
-        self.hi1 = hi1  # array of range end   SEvt::AddProcessHitsStamp(1)-SEvt::AddProcessHitsStamp(0)
-
-    def __repr__(self):
-        fmt = "SEvt symbol %s pid %s opt %s off %s %s.f.base %s "
-        return fmt % ( self.symbol, self.pid, self.opt, str(self.off), self.symbol, self.f.base )
-
-    def _get_pid(self):
-        return self._pid
-    def _set_pid(self, pid):
-        """
-        """
-        f = self.f
-        q = self.q
-        W2M = self.W2M
-        symbol = self.f.symbol
-        if pid > -1 and hasattr(f,'record') and pid < len(f.record):
-            _r = f.record[pid]
-            wl = _r[:,2,3]
-            r = _r[wl > 0]    ## select wl>0 to avoid lots of record buffer zeros, example shape (13, 4, 4)
-
-            g = np.ones([len(r),4])
-            g[:,:3] = r[:,0,:3]
-
-            w2m = W2M if not W2M is None else f.sframe.w2m
-            l = np.dot( g, w2m )
-            ld = np.diff(l,axis=0)
-
-            pass
-            _aux = getattr(f, 'aux', None)
-            _a = None if _aux is None else _aux[pid]
-            if _a is None:
-                a = None
-                ast = "no-ast"
-            else:
-                a = _a[wl > 0]
-                ast = a[:len(a),1,3].copy().view(np.int8)[::4]
-            pass
-            qpid = q[pid][0].decode("utf-8").strip()
-
-            npoi = (len(qpid)+1)//3
-            qkey = " ".join(map(lambda _:"%0.2d"%_, range(npoi)))
-
-            #label = "%s %sPID:%d\n%s " % (qpid, symbol.upper(), pid, qkey)
-            label = "%s\n%s" % (qpid, qkey)
-        else:
-            _r = None
-            r = None
-            _a = None
-            a = None
-            ast = None
-            qpid = None
-            label = ""
-
-            g = None
-            l = None
-            ld = None
-        pass
-        self._pid = pid
-        self._r = _r
-        self.r = r
-        self._a = _a
-        self.a = a
-        self.ast = ast
-        self.qpid = qpid
-        self.label = label
-        self.g = g
-        self.l = l
-        self.ld = ld
-
-    pid = property(_get_pid, _set_pid)
-
-
-    #def _get_w2m(self):
-    #    return self._w2m
-    #
-    #def _set_w2m(self, w2m=None):
-    #    self._w2m = w2m if not w2m is None else f.sframe.w2m
-
-
-
-
-    def spec_(self, i):
-        """
-        ## need np.abs as detected fakes that are not skipped are negated
-        In [10]: np.c_[a.spec[5,:a.n[5]],a.SPECS[np.abs(a.spec[5,:a.n[5]])]]
-        Out[10]:
-        array([['0', 'UNSET'],
-               ['1', 'Water/Water:pInnerWater/pLPMT_Hamamatsu_R12860'],
-               ['2', 'Water/AcrylicMask:pLPMT_Hamamatsu_R12860/HamamatsuR12860pMask'],
-               ['3', 'AcrylicMask/Water:HamamatsuR12860pMask/pLPMT_Hamamatsu_R12860'],
-               ['4', 'Water/Pyrex:pLPMT_Hamamatsu_R12860/HamamatsuR12860_PMT_20inch_log_phys'],
-               ['-5', 'Pyrex/Pyrex:HamamatsuR12860_PMT_20inch_log_phys/HamamatsuR12860_PMT_20inch_body_phys'],
-               ['6', 'Pyrex/Pyrex:HamamatsuR12860_PMT_20inch_body_phys/HamamatsuR12860_PMT_20inch_body_phys']], dtype='<U94')
-
-        In [1]: a.spec_(5)
-        Out[1]:
-        array([['0', 'UNSET'],
-               ['1', 'Water/Water:pInnerWater/pLPMT_Hamamatsu_R12860'],
-               ['2', 'Water/AcrylicMask:pLPMT_Hamamatsu_R12860/HamamatsuR12860pMask'],
-               ['3', 'AcrylicMask/Water:HamamatsuR12860pMask/pLPMT_Hamamatsu_R12860'],
-               ['4', 'Water/Pyrex:pLPMT_Hamamatsu_R12860/HamamatsuR12860_PMT_20inch_log_phys'],
-               ['-5', 'Pyrex/Pyrex:HamamatsuR12860_PMT_20inch_log_phys/HamamatsuR12860_PMT_20inch_body_phys'],
-               ['6', 'Pyrex/Pyrex:HamamatsuR12860_PMT_20inch_body_phys/HamamatsuR12860_PMT_20inch_body_phys']], dtype='<U94')
-
-        In [2]: b.spec_(5)
-        Out[2]:
-        array([['0', 'UNSET'],
-               ['1', 'Water/Water:pInnerWater/pLPMT_Hamamatsu_R12860'],
-               ['2', 'Water/AcrylicMask:pLPMT_Hamamatsu_R12860/HamamatsuR12860pMask'],
-               ['3', 'AcrylicMask/Water:HamamatsuR12860pMask/pLPMT_Hamamatsu_R12860'],
-               ['4', 'Water/Pyrex:pLPMT_Hamamatsu_R12860/HamamatsuR12860_PMT_20inch_log_phys'],
-               ['5', 'Pyrex/Vacuum:HamamatsuR12860_PMT_20inch_log_phys/HamamatsuR12860_PMT_20inch_inner_phys']], dtype='<U93')
-
-        """
-        t = self
-        n = t.n[i]
-        spec = t.spec[i,:n]
-        return np.c_[spec,t.SPECS[np.abs(spec)]]
-
-
-class SABHit(object):
-    def __init__(self, a, b):
-        self.a = a
-        self.b = b
-        assert not a is None and not b is None
-
-    def __repr__(self):
-        a = len(self.a.f.hit) if hasattr(self.a.f, "hit") else 0
-        a_std = np.sqrt(a)
-        a_rel = a_std/a  if a != 0 else 0 # estimate of rel error from sqrt of count, as Poisson
-
-        b = len(self.b.f.hit) if hasattr(self.b.f, "hit") else 0
-        b_std = np.sqrt(b)
-        b_rel = b_std/b if b != 0 else 0  # estimate of rel error from sqrt of count, as Poisson
-
-        ab_rel = a_rel + b_rel # assume uncorrelated : so add relative errors
-        ba_rel = a_rel + b_rel # assume uncorrelated : so add relative errors
-
-        ab = float(a)/float(b) if b != 0 else 0
-        ab_std = (ab_rel)*ab
-
-        ba = float(b)/float(a) if a != 0 else 0
-        ba_std = (ba_rel)*ba
-
-        fmt = "\n\nSABHit  a_nhit : ( %7d +- %4d )  b_nhit:(  %7d +- %4d )  a/b: ( %6.3f +- %6.3f )  b/a: ( %6.3f +- %6.3f)  [assume uncorr.]\n\n"
-        return fmt % ( a, int(a_std), b, int(b_std),  ab, ab_std, ba, ba_std )
-
-
-
-class SAB(object):
-    """
-    Comparison of pairs of SEvt
-
-    This is based on the seq array histories, requiring the SEvt to have been created with
-    OPTICKS_EVENT_MODE such as::
-
-         HitPhotonSeq
-         HitSeq
-
-    See ~/o/cxs_min.sh
-    """
-    def __getitem__(self, sli):
-        self.sli = sli
-        return self
-
-    def __init__(self, a, b):
-
-        self.sli = slice(None)
-        log.info("[")
-        if a.q is None or b.q is None:
-            qcf = None
-            qcf0 = None
-        else:
-            qcf = QCF( a.q, b.q, symbol="qcf")
-            qcf0 = QCFZero(qcf) if "ZERO" in os.environ else None
-        pass
-        if a.meta is None or b.meta is None:
-            meta = None
-        else:
-            meta = NPMeta.Compare( a.meta, b.meta  )
-        pass
-
-        self.a = a
-        self.b = b
-        self.qcf = qcf
-        self.qcf0 = qcf0
-        self.meta = meta
-        log.info("]")
-
-
-    def q_and(self, a_prefix, b_prefix):
-        """
-        :param a_prefix: eg TO BT BT BT BT BT SA
-        :param b_prefix: eg TO BT BT BT BT SA
-        :return wab: indices where self.a.q startswith a_prefix and self.b.q startswith b_prefix
-
-        For example with input photons which start exactly the same this
-        provides a way to look at history migration, eg an extra BT on one side
-        compared to the other
-        """
-        return np.flatnonzero( np.logical_and( np.char.startswith(self.a.q, a_prefix.encode("utf-8")), np.char.startswith(self.b.q, b_prefix.encode("utf-8")) ))
-
-
-    def q_startswith(self, prefix="TO BT BT SA"):
-        """
-        This is a cheating way to find accidentally random aligned photons
-        for debugging purposes.
-        It is especially useful with eg rain_point storch.h where all photons
-        start with same position and direction.
-        """
-        return np.where( np.logical_and( self.a.q == self.b.q, np.char.startswith(self.a.q, prefix.encode("utf-8")) ))
-
-    def __repr__(self):
-        ab = self
-        a = self.a
-        b = self.b
-        qcf = self.qcf
-        qcf0 = self.qcf0
-        meta = self.meta
-
-        lines = []
-        lines.append("SAB")
-
-        if not "BRIEF" in os.environ:
-            lines.append(str(a))
-            lines.append(repr(a.f))
-            lines.append(str(b))
-            lines.append(repr(b.f))
-            if not qcf is None:
-                lines.append("ab.qcf.aqu")
-                lines.append(repr(qcf.aqu))
-                lines.append("ab.qcf.bqu")
-                lines.append(repr(qcf.bqu))
-            pass
-        pass
-        lines.append("a.CHECK : %s " % a.CHECK)
-        lines.append("b.CHECK : %s " % b.CHECK)
-        if not ab.qcf is None:
-            lines.append("ab.qcf[:40]")
-            lines.append(repr(ab.qcf[:40]))
-        pass
-        if not ab.qcf0 is None:
-            lines.append("ab.qcf0[:30])")
-            lines.append(repr(ab.qcf0[:30]))
-        pass
-        if not meta is None:
-            lines.append(str(meta))
-        pass
-        return "\n".join(lines)
-
-
-
-
-class KeyIdx(object):
-    def __init__(self, kk, symbol="msab.ik"):
-        self.kk = kk
-        self.symbol = symbol
-    def __getattr__(self, k):
-        wk = np.where( self.kk == k)[0]
-        return wk[0] if len(wk) == 1 else -1
-    def __repr__(self):
-        kk = self.kk
-        symbol = self.symbol
-        ii = np.arange(len(kk))
-        lines = []
-        lines.append("KeyIdx %s" % symbol)
-        for i, k in enumerate(kk):
-            lines.append("%s.%s = %d " % (symbol, k, i))
-        pass
-        return "\n".join(lines)
-
-class MSAB(object):
-    """
-    Comparison of metadata across NEVT pairs of SEvt
-    Typically NEVT is small, eg 10
-    """
-
-    EXPRS = r"""
-
-    %(sym)s.c_itab[%(sym)s.ik.YSAVE,1].sum()/%(sym)s.c_itab[%(sym)s.ik.YSAVE,0].sum()  # N=1/N=0 FMT:%%10.4f
-
-    %(sym)s.c_itab[%(sym)s.ik.YSAVE,0].sum()/%(sym)s.c_itab[%(sym)s.ik.YSAVE,1].sum()  # N=0/N=1 FMT:%%10.4f
-
-    %(sym)s.c_ftab[0,1].sum()/%(sym)s.c_ftab[0,0].sum()  # ratio of duration totals N=1/N=0 FMT:%%10.4f
-
-    np.diff(%(sym)s.c_ttab)/1e6   # seconds between event starts
-
-    np.diff(%(sym)s.c_ttab)[0,1].sum()/np.diff(%(sym)s.c_ttab)[0,0].sum() # ratio N=1/N=0 FMT:%%10.4f
-
-    np.c_[%(sym)s.c_ttab[0].T].view('datetime64[us]') # SEvt start times (UTC)
-
-    %(sym)s.c2tab  # c2sum, c2n, c2per for each event
-
-    %(sym)s.c2tab[0,:].sum()/%(sym)s.c2tab[1,:].sum() # c2per_tot FMT:%%10.4f
-
-    """
-
-    def __init__(self, NEVT, AFOLD, BFOLD, symbol="%(sym)s"):
-
-        efmt = "%0.3d"
-        assert efmt in AFOLD and efmt in BFOLD
-        self.symbol = symbol
-        self.exprs = list(filter(None,textwrap.dedent(self.EXPRS).split("\n")))
-
-        itabs = []
-        ftabs = []
-        ttabs = []
-
-        first = True
-        kk0 = None
-        skk0 = None
-        ffield0 = None
-        ifield0 = None
-        tfield0 = None
-        c2tab = np.zeros( (3, NEVT)  )
-
-        mab = {}
-
-        print("NEVT:%d" % NEVT)
-        assert( NEVT > 0 )
-
-        for i in range(NEVT):
-
-            afold = AFOLD % i
-            bfold = BFOLD % i
-            a = SEvt.Load(afold,symbol="a", quiet=True)
-            b = SEvt.Load(bfold,symbol="b", quiet=True)
-            if a is None:
-                log.fatal("FAILED TO LOAD SEVT A FROM AFOLD: %s " % afold )
-            pass
-            if b is None:
-                log.fatal("FAILED TO LOAD SEVT B FROM BFOLD: %s " % bfold )
-            pass
-
-            ab = SAB(a,b)
-            mab[i] = ab
-
-
-            kk = ab.meta.kk
-            #print("ab.meta.kk (A,B common keys):%s" % str(kk))
-
-            skk = ab.meta.skk
-            tab = ab.meta.tab
-
-            # metadata fields that look like floats, integers, timestamps
-            ffield = np.unique(np.where(np.char.find(tab,'.') > -1 )[0])
-            ifield = np.unique(np.where( np.logical_and( np.char.str_len( tab ) < 15, np.char.find(tab, '.') == -1 ))[0])
-            tfield = np.unique(np.where( np.logical_and( np.char.str_len( tab ) > 15, np.char.find(tab, '.') == -1 ))[0])
-
-            if first:
-                first = False
-                skk0 = skk
-                kk0 = kk
-                tab0 = tab
-                ffield0 = ffield
-                ifield0 = ifield
-                tfield0 = tfield
-            else:
-                assert np.all( skk == skk0 )
-                assert kk == kk0
-                assert tab.shape == tab0.shape
-                assert np.all( ffield == ffield0 )
-                assert np.all( ifield == ifield0 )
-                assert np.all( tfield == tfield0 )
-            pass
-
-            itab = tab[ifield]
-            ftab = tab[ffield]
-            ttab = tab[tfield]
-
-            itabs.append(itab)
-            ftabs.append(ftab)
-            ttabs.append(ttab)
-
-            if not ab.qcf is None:
-                c2tab[0,i] = ab.qcf.c2sum
-                c2tab[1,i] = ab.qcf.c2n
-                c2tab[2,i] = ab.qcf.c2per
-            pass
-
-            # hmm how to present together with c2sum, c2n, c2per ?
-            if "c2desc" in os.environ:
-                fmt = " %s : %%s " % efmt
-                print( fmt % ( i, ab.qcf.c2desc))
-            else:
-                if "DUMP" in os.environ:print(repr(ab))
-            pass
-        pass
-
-
-        self.c2tab = c2tab
-        self.c2tab_zero = np.all( c2tab == 0. )
-
-        self.mab = mab
-        akk = np.array( list(kk0))
-        ikk = akk[ifield]
-        fkk = akk[ffield]
-        tkk = akk[tfield]
-
-        ik = KeyIdx(ikk, symbol="%s.ik" % self.symbol )
-        fk = KeyIdx(fkk, symbol="%s.fk" % self.symbol )
-        tk = KeyIdx(tkk, symbol="%s.tk" % self.symbol )
-
-        c_itab = np.zeros( (itab.shape[0], itab.shape[1], NEVT ), dtype=np.uint64 )
-        for i in range(len(itabs)):
-            c_itab[:,:,i] = itabs[i]
-        pass
-        c_ftab = np.zeros( (ftab.shape[0], ftab.shape[1], NEVT ), dtype=np.float64 )
-        for i in range(len(ftabs)):
-            c_ftab[:,:,i] = ftabs[i]
-        pass
-        c_ttab = np.zeros( (ttab.shape[0], ttab.shape[1], NEVT ), dtype=np.uint64 )
-        for i in range(len(ttabs)):
-            c_ttab[:,:,i] = ttabs[i]
-        pass
-
-        self.ikk = ikk
-        self.fkk = fkk
-        self.tkk = tkk
-
-        self.ik = ik
-        self.fk = fk
-        self.tk = tk
-
-        self.c_itab = c_itab
-        self.c_ftab = c_ftab
-        self.c_ttab = c_ttab
-
-
-
-    def annotab(self, tabsym, keys, nline=3):
-        """
-        :param tabsym: attribute symbol of table
-        :param keys: array of names for each table item
-        :param nline: number of lines for each table item
-        :return str: annoted table string
-
-        Annotate a numpy array repr with keys
-        TODO: split off into reusable AnnoTab? object
-        """
-        expr = "%%(sym)s.%s" % tabsym
-        lines = []
-        lines.append("\n%s\n" % ( expr % {'sym':self.symbol} ))
-        rawlines = repr(eval(expr % {'sym':"self" })).split("\n")
-        for i, line in enumerate(rawlines):
-            j = i//nline
-            anno = "%2d:%s" % (j,keys[j]) if i % nline == 0 else ""
-            lines.append("%s       %s " % (line, anno ))
-        pass
-        return "\n".join(lines)
-
-    def __repr__(self):
-        lines = []
-        lines.append(self.annotab("c_itab", self.ikk, 3))
-        lines.append(self.annotab("c_ftab", self.fkk, 3))
-        pass
-        fmt_ptn = re.compile("FMT:(.*)\\s*")
-
-        for expr in self.exprs:
-            fmt_match = fmt_ptn.search(expr)
-            fmt = fmt_match.groups()[0].replace("%%","%") if not fmt_match is None else None
-            if "c2tab" in expr and self.c2tab_zero: continue
-            lines.append("\n%s\n" % ( expr % {'sym':self.symbol} ))
-            value = eval( expr % {'sym':"self"} )
-            urep = repr(value) if fmt is None else fmt % value
-            lines.append(urep)
-        pass
-        return "\n".join(lines)
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    FOLD = os.environ.get("FOLD", None)
-    log.info(" -- SEvt.Load FOLD" )
-    a = SEvt.Load(FOLD, symbol="a")   # optional photon histories
-    print(a)
-
-    beg_ = "a.f.record[:,0,0,:3]"
-    beg = eval(beg_)
-
-    end_ = "a.f.photon[:,0,:3]"
-    end = eval(end_)
-
-
-    #label0, ppos0 = None, None
-    label0, ppos0 = "b:%s" % beg_ , beg
-
-    #label0, ppos0 = None, None
-    label1, ppos1 = "r:%s" % end_ , end
-
-
-    HEADLINE = "%s %s" % ( a.LAYOUT, a.CHECK )
-    label = "\n".join( filter(None, [HEADLINE, label0, label1]))
-    print(label)
-
-    if MODE == 0:
-        print("not plotting as MODE 0  in environ")
-    elif MODE == 2:
-        fig, ax = mpplt_plotter(label=label)
-
-        ax.set_ylim(-250,250)
-        ax.set_xlim(-500,500)
-
-        if not ppos0 is None: ax.scatter( ppos0[:,H], ppos0[:,V], s=1, c="b" )
-        if not ppos1 is None: ax.scatter( ppos1[:,H], ppos1[:,V], s=1, c="r" )
-
-        fig.show()
-    elif MODE == 3:
-        pl = pvplt_plotter(label)
-        os.environ["EYE"] = "0,100,165"
-        os.environ["LOOK"] = "0,0,165"
-        pvplt_viewpoint(pl)
-        pl.add_points(ppos0)
-        pl.show()
-    pass
-pass
-
diff --git a/sysrap/sevt_load.py b/sysrap/sevt_load.py
deleted file mode 100644
index ea717c3811..0000000000
--- a/sysrap/sevt_load.py
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/usr/bin/env python
-
-import os, numpy as np
-log = logging.getLogger(__name__)
-from opticks.sysrap.sevt import SEvt
-
-NEVT = int(os.environ.get("NEVT", 0))  # when NEVT>0 SEvt.LoadConcat loads and concatenates the SEvt
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    log.info("FOLD:%s" % os.environ.get("FOLD", "-"))
-    t = SEvt.Load(symbol="t", NEVT=NEVT)
-    print(repr(t))
-
-
-
diff --git a/sysrap/sevt_load.sh b/sysrap/sevt_load.sh
deleted file mode 100755
index 8f01a627c9..0000000000
--- a/sysrap/sevt_load.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash -l 
-
-
-#nevt=0  # 0 for default single Fold loading
-nevt=3  # gt 0 for concat loading 
-export NEVT=${NEVT:-$nevt} 
-
-evt="000"
-[ $NEVT -gt 0 ] && evt="%0.3d"
-
-export GEOM=V0J008
-export BASE=/tmp/$USER/opticks/GEOM/$GEOM/ntds2
-export FOLD=$BASE/ALL0/${EVT:-$evt}
-
-echo $BASH_FOLD : FOLD $FOLD NEVT $NEVT  
-
-${IPYTHON:-ipython} --pdb -i sevt_load.py 
-
-
diff --git a/sysrap/sevt_tt.py b/sysrap/sevt_tt.py
deleted file mode 100644
index 70322cbdb5..0000000000
--- a/sysrap/sevt_tt.py
+++ /dev/null
@@ -1,576 +0,0 @@
-#!/usr/bin/env python
-"""
-sevt_tt.py (formerly u4/tests/U4SimulateTest_tt.py)
-======================================================
-
-Python script (not module) usage from two bash scripts
---------------------------------------------------------
-
-::
-
-    PLOT=STAMP STAMP_ANNO=1 STAMP_LEGEND=1 ~/opticks/u4/tests/tt.sh 
-
-    PLOT=STAMP STAMP_TT=90000,5000 STAMP_ANNO=1 ~/j/ntds/ntds.sh tt 
-
-    PLOT=PHO_AVG ~/j/ntds/ntds.sh tt 
-
-
-PLOT envvar selects what to plot
-----------------------------------
-
-PLOT=STAMP
-   time stamp illustration
- 
-   STAMP_TT=200000,5000 
-   STAMP_TT=200k,5k 
-      control time window of STAMP plot in microseconds [us]
-
-   STAMP_ANNO=1  
-      enable photon index and history annotation  
-
-PLOT=PHO_AVG
-   average beginPhoton->endPhoton CPU time vs photon point count  
-
-PLOT=PHO_HIS
-   histogram of beginPhoton->endPhoton CPU times
-
-   PLOT=PHO_HIS ~/j/ntds/ntds.sh tt
-
-PLOT=PHO_N
-   A, B photon step point counts (fakes must be skipped in A to get a match)
-
-   PLOT=PHO_N ~/j/ntds/ntds.sh tt
-
-
-Dev Notes
-------------
-
-HMM: for reusability, its tempting to 
-just relocate this into sysrap/tests/tt.py 
-as a runnable python script which is used from 
-wherever with bash level envvars controlling the events 
-to be loaded rather than doing python dev to 
-bring in functionality at python level. 
-
-When is this bash in control approach appropriate 
-as opposed to moving into sevt.py ?  
-
-The level of generality determines what is appropriate
-If the functionality really is general and likely 
-to be usable from all over the place then it belongs 
-into sevt.py with python control and flexibility of use.
-
-However if only likely to use functionality from a few places
-pointing at differnt events that doing 
-at bash level seems appropriate and avoids python 
-module development. 
-  
-::
-
-    u4t
-    ./U4SimulateTest.sh tt
-
-    PLOT=STAMP   ~/opticks/u4/tests/tt.sh 
-    PLOT=PHO_HIS ~/opticks/u4/tests/tt.sh 
-    PLOT=PHO_AVG ~/opticks/u4/tests/tt.sh 
-
-
-"""
-import os, numpy as np, textwrap, logging
-log = logging.getLogger(__name__)
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-from opticks.ana.eget import efloatarray_
-from opticks.sysrap.sevt import SEvt
-
-
-SCRIPT = "./U4SimulateTest.sh tt"
-os.environ["SCRIPT"] = SCRIPT 
-LABEL = os.environ.get("LABEL", "U4SimulateTest_tt.py" )
-
-
-N = int(os.environ.get("N", "-1"))
-MODE =  int(os.environ.get("MODE", "2"))
-assert MODE in [0,2,-2,3,-3]
-FLIP = int(os.environ.get("FLIP", "0")) == 1 
-TIGHT = int(os.environ.get("TIGHT", "0")) == 1 
-STAMP_TT = efloatarray_("STAMP_TT", "162307,3000") # "t0,dt"  microseconds 1M=1s 
-
-PLOT = os.environ.get("PLOT", None)
-NEVT = int(os.environ.get("NEVT", 0))  # when NEVT>0 SEvt.LoadConcat loads and concatenates the SEvt
-
-ENVOUT = os.environ.get("ENVOUT", None)
-CAP_STEM = PLOT
-CAP_BASE = None # set below to a.f.base or b.f.base
-
-if MODE != 0:
-    from opticks.ana.pvplt import * 
-    WM = mp.pyplot.get_current_fig_manager()  
-else:
-    WM = None
-pass
-
-
-
-def GetAnnotation(title, EXPRS_, syms):
-    EXPRS = list(filter(None, textwrap.dedent(EXPRS_).split("\n")))
-
-    rlines = [] 
-    rlines.append(title)
-
-    for i,sym in enumerate(syms):
-        for expr_ in EXPRS:
-            label = expr_[expr_.find("#"):] if expr_.find("#") > -1 else ""
-            expr_ = expr_.split("#")[0].strip()
-            expr = expr_ % locals()
-            print(expr) 
-            try:
-                val = eval(expr)
-            except ValueError:
-                log.fatal("FAILED EVAL : %s " % expr )
-                val = "?"
-            pass
-            fmt_ = {}
-            fmt_["str"] = "%30s : %s : %s "  
-            fmt_["int"] = "%30s : %8d : %s "  
-            fmt_["float"] = "%30s : %8.3f : %s "  
-            fmt_[""] = fmt_["float"]
-
-            if type(val) is list: val = " ".join(val)
-            fmt = fmt_.get(type(val).__name__, fmt_["float"] )
-            rlines.append(fmt % ( expr, val, label  ))
-        pass
-        rlines.append("") 
-    pass
-    ranno = "\n".join(rlines)
-    return ranno
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    print("AFOLD:%s" % os.environ.get("AFOLD", "-"))
-    print("BFOLD:%s" % os.environ.get("BFOLD", "-"))
-    print("N:%d " % N )
-
-    if N == -1:
-        a = SEvt.Load("$AFOLD",symbol="a", NEVT=NEVT)
-        b = SEvt.Load("$BFOLD",symbol="b", NEVT=NEVT)
-        syms = ['a','b']
-        evts = [a,b]
-    elif N == 0:
-        a = SEvt.Load("$AFOLD",symbol="a", NEVT=NEVT)
-        b = None
-        syms = ['a']
-        evts = [a,]
-    elif N == 1:
-        a = None
-        b = SEvt.Load("$BFOLD",symbol="b", NEVT=NEVT)
-        syms = ['b']
-        evts = [b,]
-    else:
-        assert(0)
-    pass
-
-    ## CAP_BASE is passed via ENVOUT to the invoking bash script
-    ## to control where the figs folder with screen captures should be 
-    if not a is None:
-        CAP_BASE = a.f.base
-    elif not b is None:
-        CAP_BASE = b.f.base
-    pass
-
-    # concatenated SEvt have list of bases 
-    if type(CAP_BASE) is list: CAP_BASE = CAP_BASE[0]
-
-    if not a is None:print(repr(a))
-    if not b is None:print(repr(b))
-
-
-    if PLOT == "EXPRS":
-        EXPRS = r"""
-        %(sym)s
-        %(sym)s.symbol 
-        w
-        %(sym)s.q[w]
-        %(sym)s.n[w]
-        np.diff(%(sym)s.tt[w])
-        np.c_[%(sym)s.t[w].view("datetime64[us]")] 
-        """ 
-
-        for sym in syms:
-
-            n = eval("%(sym)s.n" % locals() ) 
-            ww = np.where( n > 24)[0] 
-       
-            for w in ww:
-                for e_ in textwrap.dedent(EXPRS).split("\n"):
-                    e = e_ % locals()
-                    print(e) 
-                    if len(e) == 0 or e[0] == "#": continue
-                    print(eval(e))
-                pass
-            pass
-        pass
-    pass
-
-
-    # needs: syms, a, b  
-
-    if PLOT == "PHO_HIS":
-        msg = "histogram of beginPhoton->endPhoton durations"
-        label = "%s : %s" % (PLOT, msg)
-        fig, axs = mpplt_plotter(nrows=1, ncols=1, label=label, equal=False)
-        ax = axs[0]
-        e_ = "%(sym)s.s1 - %(sym)s.s0  # PHO_HIS "
-        
-        #bins = np.logspace( np.log10(0.1),np.log10(500.0), 25 ) 
-        bins = np.linspace( 0, 500, 50 )
-
-        h = {} 
-        for sym in syms: 
-            e = e_ % locals() 
-            h[sym] = np.histogram( eval(e) , bins=bins )   
-            ax.plot( h[sym][1][:-1], h[sym][0], label=e  )
-        pass
-        ax.legend()
-        fig.show()
-    pass
-
-
-    if PLOT == "TABLE":
-
-        HEAD = "np.c_["
-        TAIL = "]"
-        FIELDS = list(filter(None,textwrap.dedent(r"""
-        %(sym)s.s1[w] -  %(sym)s.s0[w]                          # beginPhoton->endPhoton
-        %(sym)s.t[w,0] - %(sym)s.s0[w]                          # beginPhoton->firstPoint 
-        %(sym)s.t[w,%(n_1)s] - %(sym)s.t[w,0]                   # firstPoint->lastPoint 
-        %(sym)s.s1[w] - %(sym)s.t[w,%(n_1)s]                    # lastPoint->endPhoton
-        """).split("\n")))
-
-        LABELS = list(map(lambda _:_[_.find("#")+1:], FIELDS))
-        FIELDS = list(map(lambda _:_[:_.find("#")].strip(), FIELDS))  
-        
-        print("compare first and last point stamp range with beginPhoton endPhoton range")
-
-        nn = np.arange(2,33)
-        for n in nn:  
-            n_1 = int(n - 1)
-            for sym in syms:
-                w_ = "np.where( %(sym)s.n == %(n)s )[0]" % locals()
-                w = eval(w_)
-                expr__ = "".join([HEAD, ",".join(FIELDS), TAIL ])
-                expr_ = expr__ % locals()
-                expr = eval(expr_)
-                label = " ".join(LABELS)
-                if len(expr) == 0: continue 
-
-                print(expr_)
-                print(w_)
-                print(label)
-                print(expr)
-            pass
-        pass
-    pass        
-      
-
-    print(" average photonBegin->photonEnd for different step counts ") 
-    ssa = np.zeros((33,len(syms),4), dtype=np.float64 )
-    for n in range(33):
-        for i,sym in enumerate(syms):
-            w_ = "np.where( %(sym)s.n == %(n)s )[0]" % locals()
-            w = eval(w_)
-            nw = len(w)
-            ss_ = "%(sym)s.ss[%(sym)s.n == %(n)s ]" % locals()
-            ss = eval(ss_) 
-
-            ssa[n,i,0] = n
-            ssa[n,i,1] = nw
-
-            if len(ss) == 0: continue
-
-            ssa[n,i,2] = np.average(ss)
-            ssa[n,i,3] = np.std(ss, ddof=1)/np.sqrt(np.size(ss)) 
-        pass
-    pass
-
-
-    expr_ = "np.c_[ssa.reshape(-1,8)]"
-    print(expr_)
-    print(eval(expr_))
-
-    if PLOT == "PHO_AVG":
-        EXPRS_ = r"""
-        %(sym)s.f.baselabel                        #
-        %(sym)s.FAKES_SKIP                         # from run_meta 
-        np.diff(%(sym)s.rr)[0]/1e6                 # Run
-        %(sym)s.ee[-1]/1e6                         # Evt
-        np.sum(%(sym)s.ss)/1e6                     # Pho 
-        np.sum(%(sym)s.ss)/%(sym)s.ee[-1]          # Pho/Evt
-        """
-        title = "sevt_tt.PHO_AVG.table NEVT:%(NEVT)d ## " % locals()
-        ranno = GetAnnotation(title, EXPRS_, syms )
-        os.environ["RHSANNO"] = "\n".join(filter(lambda line:line.find("##")==-1, ranno.split("\n")))
-        os.environ["RHSANNO_POS"]="0.45,-0.02"
-
-        cut = 10 
-        labelx = "stat_cut:%(cut)d NEVT:%(NEVT)d " % locals()
-        label = "PHO_AVG : average beginPhoton->endPhoton duration [us] vs (step point count - 2)   # " + labelx 
-        print(label)
-
-        fig, axs = mpplt_plotter(nrows=1, ncols=1, label=label, equal=False)
-        ax = axs[0]
-
-        #sl = slice(2,16) 
-        sl = slice(None) 
-        style = {'a':"ro-", 'b':"bo-" }
-        fitstyle = {'a':"r:", 'b':"b:" }
-
-
-        mc = np.zeros( (len(syms), 2), dtype=np.float64 )
-
-
-        for i,sym in enumerate(syms):
-            x_ = ssa[sl,i,0] - 2   # step point count - 2 (so starts from 0)
-            n_ = ssa[sl,i,1]
-            y_ = ssa[sl,i,2]
-            ye_ = ssa[sl,i,3]
-
-            w = np.where( n_ > cut)[0]
-             
-            x = x_[w]
-            y = y_[w]
-            ye = ye_[w] 
-
-            label = "%(sym)s : avg(ss) vs n-2  " % locals()
-
-            #ax.plot( x, y , style[sym], label=label )
-
-            ax.errorbar( x, y,yerr=ye, fmt=style[sym], label=label  )
-
-
-
-            wf = np.where( n_ > 10)[0]  ## only fit points with some stats
-            x = x_[wf]
-            y = y_[wf]
-
-            A = np.vstack([x, np.ones(len(x))]).T
-            m, c = np.linalg.lstsq(A, y, rcond=None)[0]
-            mc[i,0] = m 
-            mc[i,1] = c 
-            ax.plot(x, m*x + c, fitstyle[sym], label='Fit: m %10.3f c %10.3f ' % (m,c) )
-        pass
-        ax.legend()
-        fig.show()
-
-        print(label)
-        expr = "np.c_[mc]"
-        print(expr)
-        print(eval(expr))
-
-        print("ranno")
-        print(ranno)
-    pass
-
-
-    if PLOT == "PHO_N":
-
-        EXPRS_ = r"""
-        %(sym)s.f.baselabel                        #
-        %(sym)s.FAKES_SKIP                         # from run_meta 
-        """
-        title = "sevt_tt.PHO_N.table NEVT:%(NEVT)d ## " % locals()
-        ranno0 = GetAnnotation(title, EXPRS_, syms )
-        ranno = "\n".join(filter(lambda line:line.find("##")==-1, ranno0.split("\n")))
-        os.environ["RHSANNO"] = ranno
-        os.environ["RHSANNO_POS"]="0.1,-0.02"
-
-        a_n, a_nc = np.unique(a.n, return_counts=True) 
-        b_n, b_nc = np.unique(b.n, return_counts=True) 
-         
-        #msg = "consistent when fakes are skipped"
-        msg = "much more in A when fakes not skipped : NEVT:%(NEVT)d" % locals()
-        label = "PHO_N : A(N=0),B(N=1) photon step counts : %s " % msg  
-        fig, axs = mpplt_plotter(nrows=1, ncols=1, label=label, equal=False)
-        ax = axs[0]
-        ax.set_yscale("log")
-        #ax.plot( a_n, a_nc, "ro", label="A"  )
-        #ax.plot( b_n, b_nc, "bo", label="B" )
-
-        ax.errorbar( a_n, a_nc,yerr=np.sqrt(a_nc.astype(np.float64)),fmt="ro-", label="A"  )
-        ax.errorbar( b_n, b_nc,yerr=np.sqrt(b_nc.astype(np.float64)),fmt="bo-", label="B" )
-
-        ax.legend()
-        fig.show()
-    pass 
-
-
-
-
-    if PLOT == "PHO_SCAT":
-        msg = "scatter plot of beginPhoton->endPhoton CPU time vs step point count"
-        label = "%s : %s" % (PLOT, msg)
-
-        fig, axs = mpplt_plotter(nrows=1, ncols=1, label=label, equal=False)
-        ax = axs[0]
-
-        ax.set_ylim(0,1000)
-
-        for i,sym in enumerate(syms):
-            x_ = "%(sym)s.n.astype(np.float64)" % locals() 
-            y_ = "%(sym)s.ss" % locals() 
-            x = eval(x_)
-            y = eval(y_)
-            if i == 1: x += 0.2
-
-            ax.scatter( x[x<16], y[x<16], s=2 )
-        pass
-        ax.legend()
-        fig.show()
-    pass
-
-
-    """ 
-    STAMP NOTES
-
-    HMM: how to annotate the stamp plot with photon indices ?
-
-    For comparibility between A and B it makes more 
-    sense to select based on time stamps rather than photon indices. 
-
-    To find time range with big bouncers::
-        
-         a.s0[np.where(a.n > 20)]-a.ee[0] 
-
-    """
-    if PLOT == "STAMP":
-
-
-        t0 = STAMP_TT[0]
-        t1 = STAMP_TT[0]+STAMP_TT[1] 
-        stt = os.environ.get("STAMP_TT","-") 
-
-        label = "A:lhs, B:rhs :  STAMP_TT=%s #  (t0,t1):(%d,%d)  " % (stt,t0,t1)
-
-        #os.environ["SUBTITLE"] = subtitle 
-        #os.environ["THIRDLINE"] = subtitle 
-
-        fig, axs = mpplt_plotter(nrows=1, ncols=1, label=label, equal=False)
-        ax = axs[0]
-
-        #sl = slice(-100,None,1)  # last 100 photons, which are actually processed first 
-        #sl = slice(1040,1550,1) 
-        sl = slice(None)
-
-        s0_ = {}
-        s1_ = {}
-        tt_ = {}
-        wt_ = {}
-        h0_ = {}
-        h1_ = {}
-        i0_ = {}
-        i1_ = {}
-
-        s0 = {}
-        s1 = {}
-        tt = {} 
-        wt = {} 
-        h0 = {}
-        h1 = {}
-        i0 = {}
-        i1 = {}
-
-        sz = 0.01 
-        xx = {'a':[-0.5, -sz], 'b':[sz,0.5] }
-        zz = {'a':[-0.2, -sz], 'b':[sz,0.2] }
-        yy = {'a':-0.5, 'b':0.20 }
-
-        qwns = "s0 s1 t h0 h1 i0 i1".split()
-        q_expr = "%(sym)s.%(q)s[sl] - %(sym)s.ee[0]" 
-
-        print(" (t0,t1)  (%(t0)d,%(t1)d) " % locals() )
-
-        for i, sym in enumerate(syms): 
-            print("sym:%s" % sym)
-            for j in range(len(qwns)):
-                q = qwns[j]
-                expr = q_expr % locals()
-                t = eval(expr) 
-                w = eval("np.where(np.logical_and(t > t0, t < t1 ))[0]")
-                ws = str(w.shape)
-                qmn = t.min()
-                qmx = t.max()
-                fmt = " %(q)2s  %(expr)22s : (%(qmn)8d,%(qmx)8d) : ws:%(ws)s "  
-                print( fmt % locals() )
-            pass
-        pass
-
-        print(" when all the ws are 0: adjust the time range to find some stamps")
-
-
-        for i, sym in enumerate(syms): 
-            r0 = eval("%(sym)s.rr[0]" % locals())
-            #if i == 1:continue
-            print( "sym:%s r0:%10.3f " % (sym, r0))
-
-            ## where selecting on times greater than zero messes up the indices, 
-            ## so instead just rely on exclusion of crazy times for unfilled cases
-
-            cols = "r b g c m c m".split()
-            assert len(cols) == len(qwns) 
-  
-            for j in range(len(qwns)):
-                q = qwns[j]
-                expr = q_expr % locals()
-                t = eval(expr) 
-                w = eval("np.where(np.logical_and(t > t0, t < t1 ))[0]")
-                # photon indices of times within time window 
-                kk = list(range(len(w)))  
-                xmin,xmax = zz[sym] if q == "t" else xx[sym]
-
-                ax.hlines( t[np.logical_and(t > t0, t < t1 )], xmin, xmax, cols[j], label=expr )
-
-                if "STAMP_ANNO" in os.environ:
-                    for k in kk:
-                        idx = w[k]
-                        anno = "(%s) %s : %d : " % (q, sym.upper(), idx) 
-                        if q == "s0":
-                            his = eval("%(sym)s.q[%(idx)s][0].decode(\"utf-8\").strip()" % locals())  
-                            anno +=  his 
-                        elif q == "h0":
-                            hc = eval("%(sym)s.hc[%(idx)s]" % locals())
-                            anno += " hc:%d " % (hc)
-                        elif q == "i0":
-                            ic = eval("%(sym)s.ic[%(idx)s]" % locals())
-                            hi0 = eval("%(sym)s.hi0[%(idx)s]" % locals())
-                            anno += "ic:%d hi0:%d "% (ic, hi0)
-                        else:
-                            anno = None
-                        pass
-                        if not anno is None:
-                            ax.text( yy[sym], t[idx], anno )
-                        pass
-                    pass
-                pass
-            pass
-        pass
-
-        if "STAMP_LEGEND" in os.environ:
-            ax.legend()
-        pass
-        fig.show()
-    pass
-    if not ENVOUT is None and not CAP_STEM is None and not CAP_BASE is None:
-        envout = "\n".join([
-                       "export ENVOUT_PATH=%s" % ENVOUT,
-                       "export ENVOUT_CAP_STEM=%s" % CAP_STEM,
-                       "export ENVOUT_CAP_BASE=%s" % CAP_BASE,
-                       ""
-                       ]) 
-        open(ENVOUT, "w").write(envout)
-        print(envout)
-    pass
-
- 
diff --git a/sysrap/sframe.py b/sysrap/sframe.py
deleted file mode 100755
index 8c97d18899..0000000000
--- a/sysrap/sframe.py
+++ /dev/null
@@ -1,463 +0,0 @@
-#!/usr/bin/env python
-
-import logging
-log = logging.getLogger(__name__)
-
-from opticks.ana.npmeta import NPMeta
-from opticks.ana.axes import * 
-from opticks.ana.pvplt import mpplt_focus, SIZE
-
-import os, numpy as np
-eary_ = lambda ekey, edef:np.array( list(map(float, os.environ.get(ekey,edef).split(","))) )
-
-from opticks.ana.eget import efloat_
-
-
-class sframe(object):
-    @classmethod
-    def Load(cls, fold=None, name="sframe.npy"):
-        if fold is None:
-            fold = os.environ.get("FOLD", "")
-        pass
-        if fold.endswith(name):
-            path = fold
-        else:   
-            path = os.path.join(fold, name)
-        pass
-        return cls(path)
-
-
-    @classmethod
-    def DetermineAxes(cls, nx, ny, nz):
-        """
-        :param nx:
-        :param nx:
-        :param nx:
-
-        With planar axes the order is arranged to make the longer axis the first horizontal one 
-        followed by the shorter axis as the vertical one.  
-
-            +------+
-            |      |  nz     ->  ( Y, Z )    ny_over_nz > 1 
-            +------+
-               ny
-
-            +------+
-            |      |  ny     ->  ( Z, Y )    ny_over_nz < 1 
-            +------+
-               nz
-
-        """
-        if nx == 0 and ny > 0 and nz > 0:
-            ny_over_nz = float(ny)/float(nz)
-            axes = (Y,Z) if ny_over_nz > 1 else (Z,Y)
-        elif nx > 0 and ny == 0 and nz > 0:
-            nx_over_nz = float(nx)/float(nz)
-            axes = (X,Z) if nx_over_nz > 1 else (Z,X)
-        elif nx > 0 and ny > 0 and nz == 0:
-            nx_over_ny = float(nx)/float(ny)
-            axes = (X,Y) if nx_over_ny > 1 else (Y,X)
-        else:
-            axes = (X,Y,Z)
-        pass
-        return axes
-
-
-    @classmethod
-    def CombineFrame(cls, framelist_):
-        """
-        HMM: probably should do more consistency checks between all the frames 
-        """
-        framelist = list(filter(None, framelist_))
-        axes = None
-        for f in framelist:
-            if axes is None:
-                axes = f.axes
-            else:
-                assert axes == f.axes 
-            pass
-        pass
-        return framelist[0] if len(framelist) > 0 else None
- 
-
-    def __init__(self, path, clear_identity=True ):
-        """
-        Whether clear_identity makes any material difference depends on the identity values. 
-        But it should be done anyhow.  For some identity values they will appear as nan in float.
-        """
-        if path is None:
-            return
-        pass
-
-        metapath = path.replace(".npy", "_meta.txt")
-        if os.path.exists(metapath):
-            meta = NPMeta.Load(metapath)
-        else:
-            meta = None
-        pass   
-        self.meta = meta 
-
-        a = np.load(path)
-        i = a.view(np.int32)
-
-        self.shape = a.shape  # for fold to treat like np.array
-        self.path = path 
-        self.a = a
-        self.i = i
-
-        ce = a[0,0]
-        ix0,ix1,iy0,iy1 = i[0,1,:4]        # q1.i.xyzw
-        iz0,iz1,num_photon = i[0,2,:3]     # q2.i.xyz  
-        gridscale = a[0,2,3]               # q2.f.w
-
-
-        midx, mord, gord = i[0,3,:3]       # q3.i.xyz
-        inst = i[0,3,3]     # q3.i.w
-
-
-
-        self.midx = midx
-        self.mord = mord
-        self.gord = gord
-        self.inst = inst
-         
-        ## replacing ana/gridspec.py:GridSpec
-         
-
-
-        grid = "".join(["ix0 %(ix0)4d ix1 %(ix1)4d ",
-                        "iy0 %(iy0)4d iy1 %(iy1)4d ",
-                        "iz0 %(iz0)4d iz1 %(iz1)4d ",
-                        "num_photon %(num_photon)4d gridscale %(gridscale)10.4f"]) % locals() 
-
-
-
-
-
-
-        self.grid = grid
-        self.ce = ce 
-        self.ix0 = ix0
-        self.ix1 = ix1
-        self.iy0 = iy0
-        self.iy1 = iy1
-        self.iz0 = iz0
-        self.iz1 = iz1
-        self.num_photon = num_photon
-        self.gridscale = gridscale
-
-
-
-        target = "midx %(midx)6d mord %(mord)6d gord %(gord)6d       inst %(inst)7d   " % locals() 
-        self.target = target 
-
-
-        ins_idx_1 = i[1,0,3] - 1   # q0.u.w-1  see sqat4.h qat4::getIdentity qat4::setIdentity
-        gas_idx_1 = i[1,1,3] - 1   # q1.u.w-1 
-        ias_idx_1 = i[1,2,3] - 1   # q2.u.w-1 
-
-        ins_idx_2 = i[2,0,3] - 1   # q0.u.w-1  see sqat4.h qat4::getIdentity qat4::setIdentity
-        gas_idx_2 = i[2,1,3] - 1   # q1.u.w-1 
-        ias_idx_2 = i[2,2,3] - 1   # q2.u.w-1 
-
-        ins_idx_match = ins_idx_1 == ins_idx_2
-        gas_idx_match = gas_idx_1 == gas_idx_2
-        ias_idx_match = ias_idx_1 == ias_idx_2
-
-        if not ins_idx_match: log.warning(f" ins_idx_match {ins_idx_match} ins_idx_1 {ins_idx_1} ins_idx_2 {ins_idx_2} ")
-        if not gas_idx_match: log.warning(f" gas_idx_match {gas_idx_match} gas_idx_1 {gas_idx_1} gas_idx_2 {gas_idx_2} ")
-        if not ias_idx_match: log.warning(f" ias_idx_match {ias_idx_match} ias_idx_1 {ias_idx_1} ias_idx_2 {ias_idx_2} ")
-
-        #assert ins_idx_match
-        #assert gas_idx_match
-        #assert ias_idx_match
-
-        ins_idx = ins_idx_1
-        gas_idx = gas_idx_1
-        ias_idx = ias_idx_1
-        qat4id = "ins_idx %(ins_idx)6d gas_idx %(gas_idx)4d %(ias_idx)4d " % locals()
-
-        self.ins_idx = ins_idx
-        self.gas_idx = gas_idx
-        self.ias_idx = ias_idx
-        self.qat4id = qat4id
-
-        m2w = a[1].copy()
-        w2m = a[2].copy()
-
-        if clear_identity:
-            m2w[0,3] = 0. 
-            m2w[1,3] = 0. 
-            m2w[2,3] = 0. 
-            m2w[3,3] = 1. 
-
-            w2m[0,3] = 0. 
-            w2m[1,3] = 0. 
-            w2m[2,3] = 0. 
-            w2m[3,3] = 1. 
-        pass
-
-        self.m2w = m2w
-        self.w2m = w2m
-        self.id = np.dot( m2w, w2m )  
-
-
-        ins = i[3,0,0]   # aux.q0.i.x  
-        gas = i[3,0,1]
-        ias = i[3,0,2]
-
-        propagate_epsilon = a[3,1,0]   # aux.q1.f.x 
-
-
-        ins_gas_ias = " ins %(ins)6d gas %(gas)4d ias %(ias)4d " % locals()
-
-        self.ins = ins
-        self.gas = gas
-        self.ias = ias
-        self.ins_gas_ias = ins_gas_ias
-        self.propagate_epsilon = propagate_epsilon 
-
-        self.init_grid()
-        self.init_view()
-
-
-    def init_grid(self):
-        """
-        replacing ana/gridspec.py 
-        """
-        gord = self.gord  
-        ix0 = self.ix0 
-        ix1 = self.ix1 
-        iy0 = self.iy0 
-        iy1 = self.iy1 
-        iz0 = self.iz0 
-        iz1 = self.iz1 
-        gridscale = self.gridscale
-        ce = self.ce
-        extent = ce[3]
-        s_extent = "e:%7.3f" % extent 
-
-        nx = (ix1 - ix0)//2   
-        ny = (iy1 - iy0)//2
-        nz = (iz1 - iz0)//2
-        coords = "RTP" if gord == -3 else "XYZ"   ## NB RTP IS CORRECT ORDERING radiusUnitVec:thetaUnitVec:phiUnitVec
-        axes = self.DetermineAxes(nx, ny, nz)
-        other_axis = Axes.OtherAxis(axes)
-        planar = len(axes) == 2 
-
-        bbox = np.zeros( (2,3), dtype=np.float32 )
-        bbox[0] = list(map(float,[ix0,iy0,iz0]))
-        bbox[1] = list(map(float,[ix1,iy1,iz1]))
-        bbox *= gridscale*ce[3]
-
-
-        if planar:
-            H, V = axes
-            axlabels =  coords[H], coords[V]
-            s_bbox = "bb "
-            s_bbox += "  %7.4f %7.4f " % tuple(bbox[0,axes])    
-            s_bbox += "  %7.4f %7.4f " % tuple(bbox[1,axes])    
-        else:
-            H, V, D = axes
-            axlabels =  coords[H], coords[V], coords[D]
-            s_bbox = "bb %7.4f %7.4f %7.4f    %7.4f %7.4f %7.4f " % tuple(bbox.ravel())    
-        pass 
-
-
-        self.nx = nx
-        self.ny = ny
-        self.nz = nz
-        self.coords = coords
-        self.axes = axes 
-        self.other_axis = other_axis
-        self.axlabels = axlabels 
-
-        self.bbox = bbox  # without ce_offset 
-        self.s_bbox = s_bbox 
-
-        self.extent = extent 
-        self.s_extent = s_extent 
-   
-
-
-    def init_view(self):
-        """
-        HMM: input EYE is ignored for planar 
-        """
-        ce = self.ce 
-        axes = self.axes
-        coords = self.coords
-        planar = len(axes) == 2 
-
-        # below default from envvars are overridden for planar data
-        eye = eary_("EYE","1.,1.,1.")
-        up  = eary_("UP","0.,0.,1.")
-        off  = eary_("OFF","0.,0.,1.")
-        look = eary_("LOOK","0.,0.,0.")
-        #look = ce[:3]
-
-        EYES = efloat_("EYES", "6.")   # TODO: why 6 ? how to control FOV to gain more control of this
-        extent = ce[3]
-
-        if planar:
-            H, V = axes
-            up  = Axes.Up(H,V)
-            off = Axes.Off(H,V)
-            eye = look + extent*off*EYES
-        else:
-            H, V, D = axes
-            axlabels =  coords[H], coords[V], coords[D]
-
-            up = XYZ.up
-            off = XYZ.off
-            ## hmm in 3D case makes less sense : better to just use the input EYE
-
-            eye = ce[3]*eye*EYES 
-        pass 
-
-        self.look = look
-        self.up = up
-        self.off = off
-        self.eye = eye 
-        self.thirdline = self.s_bbox + self.s_extent
-
-
-    def pv_compose(self, pl, local=True):
-        """
-        #pl.view_xz()   ## TODO: see if view_xz is doing anything when subsequently set_focus/viewup/position 
-        """
-
-        RESET = "RESET" in os.environ 
-        PARA = "PARA" in os.environ 
-        ZOOM = efloat_("ZOOM", "1.")
-        PVGRID = "PVGRID" in os.environ
-
-        if PARA:
-            pl.camera.ParallelProjectionOn()
-        pass 
-
-        look = self.look if local else self.ce[:3]   ## HMM: same ?
-        eye = look + self.off
-        up = self.up
-
-        ## for reset=True to succeed to auto-set the view, must do this after add_points etc.. 
-        
-        #eye = look + self.off
-
-        look = self.look 
-        eye = self.eye
-        up = self.up
-
-        log.info("frame.pv_compose look:%s eye: %s up:%s  PARA:%s RESET:%d ZOOM:%s  " % (str(look), str(eye), str(up), RESET, PARA, ZOOM ))
-
-        pl.set_focus(    look )
-        pl.set_viewup(   up )
-        pl.set_position( eye, reset=RESET )   ## for reset=True to succeed to auto-set the view, must do this after add_points etc.. 
-        pl.camera.Zoom(ZOOM)
-
-        if PVGRID:
-            pl.show_grid()
-        pass
-
-
-
-    def __repr__(self):
-
-        l_ = lambda k,v:"%-12s : %s" % (k, v) 
-
-        return "\n".join(
-                  [ 
-                    l_("sframe",""),
-                    l_("path",self.path), 
-                    l_("meta",repr(self.meta)), 
-                    l_("ce", repr(self.ce)), 
-                    l_("grid", self.grid), 
-                    l_("bbox", repr(self.bbox)), 
-                    l_("target", self.target), 
-                    l_("qat4id", self.qat4id), 
-                    l_("m2w",""), repr(self.m2w), "", 
-                    l_("w2m",""), repr(self.w2m), "", 
-                    l_("id",""),  repr(self.id) ,
-                    l_("ins_gas_ias",self.ins_gas_ias)  
-                   ])
-
-
-    @classmethod
-    def FakeXZ(cls, e=10):
-        path = None
-        fr = cls(path)
-        fr.axes = X,Z
-        fr.axlabels = "X","Z"
-        fr.bbox = np.array( [[-e,-e,-e],[e,e,e]] )
-        return fr 
-
-
-    def mp_subplots(self, mp):
-        pass
-        H,V = self.axes 
-        _H,_V = self.axlabels
-
-        xlim = self.bbox[:,H]  
-        ylim = self.bbox[:,V]  
-
-        log.info("mp_subplots xlim %s ylim %s " % (str(xlim), str(ylim)))  
-        #xlim, ylim = mpplt_focus(xlim, ylim)
-
-        topline = os.environ.get("TOPLINE", "sframe.py:mp_subplots:TOPLINE")
-        botline = os.environ.get("BOTLINE", "sframe.py:mp_subplots:BOTLINE")
-        thirdline = getattr(self, "thirdline", "thirdline" )
-
-        title = [topline, botline, thirdline]
-
-        fig, ax = mp.subplots(figsize=SIZE/100.)
-        fig.suptitle("\n".join(title))
-    
-        ax.set_aspect('equal')
-        ax.set_xlim(xlim)
-        ax.set_ylim(ylim)
-        ax.set_xlabel(_H)
-        ax.set_ylabel(_V)
-
-        self.fig = fig
-        self.ax = ax
-
-        return fig, ax
-
-    def mp_scatter(self, pos, **kwa):
-        assert pos.ndim == 2 and pos.shape[1] == 3
-        H,V = self.axes 
-        self.ax.scatter( pos[:,H], pos[:,V], **kwa)
-
-    def mp_arrow(self, pos, mom, **kwa):
-        assert pos.ndim == 2 and pos.shape[1] == 3
-        assert mom.ndim == 2 and mom.shape[1] == 3
-        assert len(pos) == len(mom)
-        H,V = self.axes 
-
-        for i in range(len(pos)):
-            self.ax.arrow( pos[i,H], pos[i,V], mom[i,H], mom[i,V] )
-        pass
-
-
-    def mp_legend(self):
-        NOLEGEND = "NOLEGEND" in os.environ
-        LSIZ = float(os.environ.get("LSIZ",50))
-        LOC = os.environ.get("LOC", "upper right")
-        log.info("mp_legend LSIZ %s LOC %s NOLEGEND %s " % (LSIZ,LOC,NOLEGEND) )
-        if not NOLEGEND:
-            lgnd = self.ax.legend(loc=LOC)
-            for handle in lgnd.legendHandles:
-                handle.set_sizes([LSIZ])
-            pass
-        pass
-
-
- 
-
-if __name__ == '__main__':
-
-    fr = sframe.Load()
-    print(fr)
-
-     
-
diff --git a/sysrap/sframe.sh b/sysrap/sframe.sh
deleted file mode 100755
index a3641756d4..0000000000
--- a/sysrap/sframe.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash -l 
-
-export FOLD=/tmp/$USER/opticks/CSG/CSGFoundry_MakeCenterExtentGensteps_Test
-${IPYTHON:-ipython} --pdb -i sframe.py 
-
-
diff --git a/sysrap/sfreq.py b/sysrap/sfreq.py
deleted file mode 100644
index 85d156f6da..0000000000
--- a/sysrap/sfreq.py
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/usr/bin/env python
-
-import os, numpy as np
-from opticks.ana.fold import Fold
-
-class fold(object):
-    pass
-
-class sfreq(object):
-    @classmethod
-    def CreateFromArray(cls, a):
-        usub, nsub = np.unique(a, return_counts=True )
-        f = fold()
-        f.key = usub
-        f.val = nsub 
-        return cls(f, sort=True) 
-
-    @classmethod
-    def ArrayFromFile(cls, base=None, name="subs.txt"):
-        if base is None:
-            base = os.environ.get("FOLD", None)
-        pass
-        path = os.path.join(base, name)
-        a = np.loadtxt(path, dtype="|S32" )  
-        return a 
-
-    @classmethod
-    def CreateFromFile(cls, base=None, name="subs.txt"):
-        a = cls.ArrayFromFile(base=base, name=name)
-        return cls.CreateFromArray(a)
-
-    def __init__(self, f, sort=True):
-        order = np.argsort(f.val)[::-1] if sort else slice(None)
-        okey = f.key[order]  
-        oval = f.val[order]
-        subs = list(map(lambda _:_.decode("utf-8"), okey.view("|S32").ravel() ))  
-        vals = list(map(int, oval)) 
-
-        self.f = f   # without the sort 
-        self.okey = okey 
-        self.oval = oval 
-        self.subs = subs
-        self.vals = vals
-        self.order = order
-
-
-    def find_index(self, key):
-        key = key.encode() if type(key) is str else key
-        assert type(key) is bytes
-        ii = np.where( self.okey.view("|S32") == key )[0]     ## hmm must use okey to feel the sort
-        assert len(ii) == 1
-        return int(ii[0])
-
-    def desc_key(self, key):
-        idx = self.find_index(key)
-        return self.desc_idx(idx)
-
-    def desc_idx(self, idx):
-        return "sf %3d : %7d : %s." % (idx, self.vals[idx], self.subs[idx]) 
-
-    def __repr__(self):
-        return "\n".join(self.desc_idx(idx) for idx in range(len(self.subs))) 
-
-    def __str__(self):
-        return str(self.f)
-
-
-if __name__ == '__main__':
-    sf = sfreq.CreateFromFile()
-    print(repr(sf))
-
-
-
-
-
diff --git a/sysrap/sfreq.sh b/sysrap/sfreq.sh
deleted file mode 100755
index 87add41c62..0000000000
--- a/sysrap/sfreq.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/bash -l 
-
-export FOLD=/tmp/$USER/opticks/U4TreeTest
-
-${IPYTHON:-ipython} --pdb -i $(dirname $BASH_SOURCE)/sfreq.py 
-
diff --git a/sysrap/smath.py b/sysrap/smath.py
deleted file mode 100644
index e66a961e68..0000000000
--- a/sysrap/smath.py
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env python
-
-import numpy as np
-
-def rotateUz(d, u):
-    """
-    :param d:  array of vectors with shape (n,3)
-    :param u:  array of single vector with shape (3,)
-    :return d1: array of vectors with shape (n,3)
-
-    NumPy translation of smath.h rotateUz::
-
-        inline SMATH_METHOD void smath::rotateUz(float3& d, const float3& u )
-        {
-            float up = u.x*u.x + u.y*u.y ;
-            if (up>0.f)
-            {
-                up = sqrt(up);
-                float px = d.x ;
-                float py = d.y ;
-                float pz = d.z ;
-                d.x = (u.x*u.z*px - u.y*py)/up + u.x*pz;
-                d.y = (u.y*u.z*px + u.x*py)/up + u.y*pz;
-                d.z =    -up*px +                u.z*pz;
-            }
-            else if (u.z < 0.f )
-            {
-                d.x = -d.x;
-                d.z = -d.z;
-            }
-        }
-
-    """
-    assert u.shape == (3,)
-    assert d.shape == (len(d),3)
-    d1 = np.zeros( (len(d),3 ), dtype=d.dtype )
-
-    up =  u[0]*u[0] + u[1]*u[1]
-    if up > 0.:
-       up = np.sqrt(up)
-       px = d[:,0]
-       py = d[:,1]
-       pz = d[:,2]
-       d1[:,0] = (u[0]*u[2]*px - u[1]*py)/up + u[0]*pz
-       d1[:,1] = (u[1]*u[2]*px + u[0]*py)/up + u[1]*pz
-       d1[:,2] = -up*px + u[2]*pz
-    elif u[2] < 0.:
-       d1[:,0] = -d[:,0]
-       d1[:,1] =  d[:,1]  # diff as returning not inplace changing
-       d1[:,2] = -d[:,2]
-    pass
-    return d1
-
-
-def rotateUz_(d, u):
-    """
-    :param d:  array of single vector with shape (3,)
-    :param u:  array of vectors with shape (n,3)
-    :return d1: array of vectors with shape (n,3)
-
-    THIS NEEDS MORE TESTING
-    """
-    assert u.shape == (len(u),3)
-    assert d.shape == (3,)
-    d1 = np.zeros( (len(u),3 ), dtype=d.dtype )
-
-    _up =  u[:,0]*u[:,0] + u[:,1]*u[:,1]
-    wp = np.where( _up > 0. )
-    wn = np.where( np.logical_and( _up <= 0., u[:,2] < 0. ))
-
-    up = np.zeros( (len(u),), dtype=d.dtype )
-    up[wp] = np.sqrt(_up)
-    px = d[0]
-    py = d[1]
-    pz = d[2]
-
-    d1[wp,0] = (u[wp,0]*u[wp,2]*px - u[wp,1]*py)/up + u[wp,0]*pz
-    d1[wp,1] = (u[wp,1]*u[wp,2]*px + u[wp,0]*py)/up + u[wp,1]*pz
-    d1[wp,2] = -up[wp]*px + u[wp,2]*pz
-
-    d1[wn,0] = -d[0]
-    d1[wn,1] =  d[1]
-    d1[wn,2] = -d[2]
-
-    return d1
-
-
-def test_rotateUz():
-    s = np.sqrt(0.5, dtype=np.float64)
-    u = np.array([s,0,-s], dtype=s.dtype)
-    d = np.array([[1,0,0],[s,s,0],[0,1,0],[-s,s,0],[-1,0,0],[-s,-s,0],[0,-1,0],[s,-s,0],[1,0,0]], dtype=s.dtype )
-    d1 = rotateUz( d, u )
-
-    print("u\n",u)
-    print("d\n",d)
-    print("d1\n",d1)
-
-
-
-if __name__ == '__main__':
-
-    s = np.sqrt(0.5, dtype=np.float64)
-    u = np.array([[1,0,0],[s,s,0],[0,1,0],[-s,s,0],[-1,0,0],[-s,-s,0],[0,-1,0],[s,-s,0],[1,0,0]], dtype=s.dtype )
-    d = np.array([s,0,-s], dtype=s.dtype)
-    d1 = rotateUz_( d, u )
-
-    print("u\n",u)
-    print("d\n",d)
-    print("d1\n",d1)
-
-
diff --git a/sysrap/smonitor.py b/sysrap/smonitor.py
deleted file mode 100644
index 7a2c1db68f..0000000000
--- a/sysrap/smonitor.py
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/usr/bin/env python
-"""
-smonitor.py 
-============
-
-~/o/sysrap/smonitor.sh ana
-
-"""
-
-import os, numpy as np
-import matplotlib.pyplot as mp
-SIZE=np.array([1280, 720])
-
-if __name__ == '__main__':
-    mon = np.load("smonitor.npy").astype(np.int64) 
-
-    stamp = mon[:,0]
-    device = mon[:,1]
-    free = mon[:,2]
-    total = mon[:,3]
-    used = mon[:,4]
-    pid = mon[:,5]
-    usedGpuMemory = mon[:,6]
-    proc_count = mon[:,7] 
-
-    t = (stamp - stamp[0])/1e6 
-    usedGpuMemory_GB = usedGpuMemory/1e9 
-    total_GB = total/1e9  
-    free_GB = free/1e9  
-    used_GB = used/1e9
-
-    u_device = np.unique(device)
-    u_total = np.unique(total)
-    u_pid = np.unique(pid)
-    u_proc_count = np.unique(proc_count)
-
-    assert len(u_device) == 1 
-    assert len(u_total) == 1    
-    assert len(u_pid) == 1    
-
-    _device = u_device[0]
-    _total = u_total[0]/1e9
-    _pid = u_pid[0]
-    _proc_count = u_proc_count[0]
-
-    assert _proc_count == 1 
-
-    delta_usedGpuMemory_GB = np.diff( usedGpuMemory_GB ) 
-    w_delta_usedGpuMemory_GB = np.where( delta_usedGpuMemory_GB > 0.001 )[0]
-
-    auto_start = w_delta_usedGpuMemory_GB[2] if len(w_delta_usedGpuMemory_GB) > 2 else 0
-    env_start = int(os.environ["START"]) if "START" in os.environ else 0
-    start = env_start if env_start > 0 else auto_start
-    message = "auto_start:%(auto_start)2d START:%(env_start)2d start:%(start)2d " % locals()
-
-
-    idx = np.arange( len(usedGpuMemory_GB) )  
-    sel = slice(start, None) 
-
-    expr = "np.c_[idx[sel], t[sel], usedGpuMemory_GB[sel], usedGpuMemory[sel] ]"
-    print(expr)
-    print(eval(expr))
-
-    _dgb = "(usedGpuMemory_GB[sel][-1]-usedGpuMemory_GB[sel][0])"
-    dgb = eval(_dgb)
-    print("dgb %10.3f  %s " % ( dgb, _dgb )) 
-
-    _db = "(usedGpuMemory[sel][-1]-usedGpuMemory[sel][0])"
-    db = eval(_db)
-    print("db  %10.3f  %s " % ( db, _db )) 
-
-
-
-    _dt = "(t[sel][-1]-t[sel][0])"
-    dt = eval(_dt)
-    print("dt   %10.3f  %s " % ( dt, _dt )) 
-    print("dgb/dt  %10.3f  " % (dgb/dt))
-    print("db/dt   %10.3f  " % (db/dt))
-
-    
-    deg = 1  # linear   
-    pfit = np.polyfit(t[sel], usedGpuMemory_GB[sel], deg)
-    linefit = np.poly1d(pfit)
-    linefit_label = "line fit:  slope %10.3f [GB/s] intercept %10.3f " % (linefit.coef[0], linefit.coef[1])
- 
-    headline = "smonitor.sh device %(_device)s total_GB %(_total)4.1f pid %(_pid)s " % locals()
-    publine = "%s : %s " % (message, os.environ.get("PUB", "no-PUB" ))
-    title = "\n".join([headline, linefit_label, publine])
-    print(title)
-
-    fig, ax = mp.subplots(figsize=SIZE/100.)
-    fig.suptitle(title)
-
-    ax.set_yscale('log') 
-
-    ax.plot( t, total_GB , label="total_GB" )
-    ax.plot( t, free_GB , label="free_GB" )
-    ax.plot( t, used_GB , label="used_GB" )
-
-    #ax.plot( t, usedGpuMemory_GB , label="proc.usedGpuMemory_GB"  )
-    ax.scatter( t, usedGpuMemory_GB, label="proc.usedGpuMemory_GB"  )
-    ax.plot( t[sel], linefit(t[sel]), label=linefit_label )
-
-
-    ax.legend()    
-    fig.show()    
-          
-
diff --git a/sysrap/smonitor.sh b/sysrap/smonitor.sh
deleted file mode 100755
index 07688dcf17..0000000000
--- a/sysrap/smonitor.sh
+++ /dev/null
@@ -1,108 +0,0 @@
-#!/bin/bash 
-usage(){ cat << EOU
-smonitor.sh : NVML based GPU memory monitor
-=============================================
-
-Usage:
-
-1. start the monitor process in one tab::
- 
-    ~/o/sysrap/smonitor.sh   # builds and starts runloop 
-
-2. start the GPU memory using job in another tab
-
-3. once the job has completed, ctrl-C the monitor process
-   which catches the SIGINT signal and saves the memory 
-   profile into smonitor.npy array  
-
-4. make a plot::
-
-    ~/o/sysrap/smonitor.sh grab
-    ~/o/sysrap/smonitor.sh ana 
-
-
-5. screen capture the plot with annotation 
-
-    ~/o/sysrap/smonitor.sh mpcap 
-    PUB=cxs_min_igs_with_rg_dummy ~/o/sysrap/smonitor.sh mppub 
-
-
-EOU
-}
-
-SDIR=$(dirname $(realpath $BASH_SOURCE))
-
-name=smonitor
-
-vars="BASH_SOURCE SDIR PWD name TMP FOLD CUDA_PREFIX CUDA_TARGET bin"
-
-cuda_prefix=/usr/local/cuda-11.7
-CUDA_PREFIX=${CUDA_PREFIX:-$cuda_prefix}
-CUDA_TARGET=$CUDA_PREFIX/targets/x86_64-linux
-
-tmp=/tmp/$USER/opticksGG
-TMP=${TMP:-$tmp}
-export FOLD=$TMP/$name
-mkdir -p $FOLD
-
-bin=$FOLD/$name
-script=$SDIR/$name.py 
-
-cd $FOLD
-LOGDIR=$PWD
-
-#stem=smonitor_okjob
-stem=smonitor_cxs_min_igs
-pub=no-PUB
-export STEM=${STEM:-$stem}
-export PUB=${PUB:-$pub}
-
-export smonitor__SLEEP_US=100000  # 0.1s 
-
-
-defarg="info_build_run"
-arg=${1:-$defarg}
-
-if [ "${arg/info}" != "$arg" ]; then 
-    for var in $vars ; do printf "%25s : %s \n" "$var" "${!var}" ; done
-fi 
-
-if [ "${arg/build}" != "$arg" ]; then 
-    gcc $SDIR/$name.cc -std=c++11 -lstdc++ \
-         -I$SDIR \
-         -I$CUDA_TARGET/include \
-         -L$CUDA_TARGET/lib \
-         -lnvidia-ml  \
-         -o $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE build error && exit 1 
-fi 
-
-if [ "${arg/run}" != "$arg" ]; then 
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 2 
-fi 
-
-if [ "${arg/grab}" != "$arg" ]; then 
-    source $OPTICKS_HOME/bin/rsync.sh $LOGDIR
-    [ $? -ne 0 ] && echo $BASH_SOURCE grab error && exit 3 
-fi 
-
-if [ "${arg/ana}" != "$arg" ]; then 
-    ${IPYTHON:-ipython} --pdb -i $script 
-    [ $? -ne 0 ] && echo $BASH_SOURCE ana error && exit 4
-fi 
-
-if [ "$arg" == "mpcap" -o "$arg" == "mppub" ]; then
-    export CAP_BASE=$FOLD/figs
-    export CAP_REL=smonitor
-    export CAP_STEM=${STEM}_${PUB}
-    case $arg in  
-       mpcap) source mpcap.sh cap  ;;  
-       mppub) source mpcap.sh env  ;;  
-    esac
-    if [ "$arg" == "mppub" ]; then 
-        source epub.sh 
-    fi  
-fi 
-
-exit 0
diff --git a/sysrap/sn_check.py b/sysrap/sn_check.py
deleted file mode 100644
index ed4342a502..0000000000
--- a/sysrap/sn_check.py
+++ /dev/null
@@ -1,121 +0,0 @@
-#!/usr/bin/env python
-"""
-sn_check.py
-============
-
-
-"""
-
-import numpy as np
-
-class snd_check(object):
-    def __init__(self, f, symbol="c"):
-        lvn = f.soname_names
-        snd = f.csg.node
-        snd_fields = snd.shape[1]
-        assert snd_fields == 17
-        self.snd = snd
-
-
-class sn_check(object):
-    def __init__(self, f, symbol="c"):
-        lvn = f.soname_names
-        sn = f._csg.sn
-        sn_fields = sn.shape[1]
-        assert sn_fields in [17,19]
-        with_child = sn_fields == 19
-
-        s_pa = f._csg.s_pa
-        s_tv = f._csg.s_tv
-        s_bb = f._csg.s_bb
-
-        self.sn = sn
-        self.sn_fields = sn_fields
-        self.with_child = with_child
-
-        self.s_pa = s_pa
-        self.s_tv = s_tv
-        self.s_bb = s_bb
-
-
-        lv = sn[:,2]
-        tv = sn[:,3]
-        pa = sn[:,4]
-        bb = sn[:,5]
-        parent = sn[:,6]
-
-        if with_child:
-            pass
-        else:
-            left = sn[:,7]
-            right = sn[:,8]
-
-            self.left = left
-            self.right = right
-            self.ucheck("left")
-            self.ucheck("right")
-            self.check_left()
-            self.check_right()
-        pass
-
-        self.lvn = lvn
-        self.symbol = symbol
-
-        self.lv = lv
-        self.tv = tv
-        self.pa = pa
-        self.bb = bb
-        self.parent = parent
-
-        for field in "lv tv pa bb parent".split():
-            self.ucheck(field)
-        pass
-        self.check_ulv()
-        self.check_utv()
-        self.check_upa()
-        self.check_ubb()
-        self.check_parent()
-
-    def ucheck(self, field="lv"):
-        uchk = np.unique(getattr(self,field), return_counts=True)
-        setattr(self, "u%(field)s" % locals(), uchk[0] )
-        setattr(self, "n%(field)s" % locals(), uchk[1] )
-
-    def check_ulv(self):
-        assert np.all( self.ulv == np.arange(len(self.ulv)) )
-    def check_utv(self):
-        assert self.utv.max() < len(self.s_tv), "integrity of transform refs"
-    def check_upa(self):
-        assert self.upa.max() < len(self.s_pa), "integrity of param refs"
-    def check_ubb(self):
-        assert self.ubb.max() < len(self.s_bb), "integrity of bbox refs"
-    def check_parent(self):
-        assert self.parent.max() < len(self.sn), "integrity of parent node refs"
-        # assert np.all( self.nparent[1:] == 1 )
-        # not fulfilled by the virtual mask polycone
-
-    def check_left(self):
-        assert self.left.max() < len(self.sn), "integrity of left node refs"
-        assert np.all( self.nleft[1:] == 1 )
-    def check_right(self):
-        assert self.right.max() < len(self.sn), "integrity of right node refs"
-        assert np.all( self.nright[1:] == 1 )
-
-
-    def __repr__(self):
-        sym = self.symbol
-        #locals()[sym] = self   ## curious locals worked with older python, now need globals
-        globals()[sym] = self
-        expr = "np.c_[%(sym)s.ulv, %(sym)s.nlv, %(sym)s.lvn[%(sym)s.ulv]][np.where(%(sym)s.nlv>5)]" % locals()
-        lines = []
-        lines.append("opticks.sysrap.sn_check")
-        lines.append(expr)
-        lines.append(str(eval(expr)))
-        lines.append("# NB raw nodes from G4VSolid, not complete binary tree counts")
-        return "\n".join(lines)
-
-if __name__ == '__main__':
-    print("klop")
-pass
-
-
diff --git a/sysrap/sphotonlite.py b/sysrap/sphotonlite.py
deleted file mode 100644
index 149d49f0f4..0000000000
--- a/sysrap/sphotonlite.py
+++ /dev/null
@@ -1,258 +0,0 @@
-"""
-opticks/sysrap/sphotonlite.py
-==============================
-
-::
-
-    f = Fold.Load(symbol="f")
-    from opticks.sysrap.sphotonlite import SPhotonLite
-    p = SPhotonLite.view(f.photonlite)  # photonlite shape (N,4) uint32
-
-"""
-from __future__ import annotations
-import logging
-log = logging.getLogger(__name__)
-
-import numpy as np
-from opticks.ana.fold import append_fields
-
-EFFICIENCY_COLLECT = 0x1 << 13
-
-
-class SPhotonLite:
-    """
-    Structured view of the 16-byte ``sphotonlite`` record.
-
-    The binary layout (little-endian, 16 B total) is:
-
-        0-1   : identity   (u2)
-        2-3   : hitcount   (u2)
-        4-7   : time       (f4)
-        8-9   : lposfphi   (u2)  → normalised to lposfphi_f  (f4)
-       10-11  : lposcost   (u2)  → normalised to lposcost_f  (f4)
-       12-15  : flagmask   (u4)
-
-    All public API is provided as **class-methods** – no instance needed.
-    """
-
-    # ------------------------------------------------------------------
-    # 2. The dtype – defined once, reused everywhere
-    # ------------------------------------------------------------------
-    DTYPE = np.dtype(
-        [
-            ("identity", "<u2"),   # offset 0
-            ("hitcount", "<u2"),   # offset 2
-            ("time", "<f4"),       # offset 4
-            ("lposfphi", "<u2"),   # offset 8
-            ("lposcost", "<u2"),   # offset 10
-            ("flagmask", "<u4"),   # offset 12
-        ],
-        align=True,
-    )
-    assert DTYPE.itemsize == 16, f"expected 16 B, got {DTYPE.itemsize}"
-
-    # ------------------------------------------------------------------
-    # 3. Helper: uint16 → float in [0, 1] (exact, no rounding error)
-    # ------------------------------------------------------------------
-    @classmethod
-    def unpack_uint16_to_float(cls, u16: np.ndarray) -> np.ndarray:
-        """0xffff → 1.0, 0 → 0.0 (exact, no rounding error)"""
-        return u16.astype(np.float32) / 0xFFFF
-
-    # ------------------------------------------------------------------
-    # 4. Core conversion: uint32[N,4] → structured array
-    # ------------------------------------------------------------------
-    @classmethod
-    def view_(cls, buf: np.ndarray) -> np.ndarray:
-        """
-        Convert a ``uint32`` buffer of shape ``(..., 4)`` into a flat
-        structured array with the extra float fields ``lposfphi_f``
-        and ``lposcost_f``.
-
-        Parameters
-        ----------
-        buf : np.ndarray
-            Must be ``dtype=uint32`` and ``buf.shape[-1] == 4``.
-
-        Returns
-        -------
-        np.ndarray
-            Flat (1-D) structured array.
-        """
-        if buf.dtype != np.uint32:
-            raise TypeError(f"buf must be uint32, got {buf.dtype}")
-        if buf.shape[-1] != 4:
-            raise ValueError(f"last dimension must be 4, got {buf.shape[-1]}")
-
-        rec = buf.view(cls.DTYPE).reshape(-1)
-
-
-        fphi = cls.unpack_uint16_to_float(rec["lposfphi"])
-        cost = cls.unpack_uint16_to_float(rec["lposcost"])
-
-        phi = ( fphi * 2.0 - 1. ) * np.pi  # scuda.h:phi_from_fphi
-        cos = np.arccos(cost)
-
-        rec = append_fields(
-            rec
-            ,
-            [
-               "lposfphi_f",
-               "lposcost_f",
-               "phi",
-               "cost",
-               "cos"
-            ]
-            ,
-            [
-                fphi,
-                cost,
-                phi,
-                cost,
-                cos
-            ]
-            ,
-            [
-            np.float32,
-            np.float32,
-            np.float32,
-            np.float32,
-            np.float32,
-            ]
-            ,
-            usemask=False,
-        )
-        return rec
-
-    @classmethod
-    def view(cls, buf: np.ndarray) -> np.recarray:
-        rec = cls.view_(buf)
-        return rec.view(np.recarray)
-
-
-    # ------------------------------------------------------------------
-    # 6. Pretty-print a few records (useful in notebooks / REPL)
-    # ------------------------------------------------------------------
-
-    @classmethod
-    def pprint(cls, rec: np.ndarray, n: int = 5) -> None:
-        """Print the first *n* records in a readable table."""
-        print(rec[:n])
-
-    # ------------------------------------------------------------------
-    # 7. Optional: create an *empty* array of a given length
-    # ------------------------------------------------------------------
-    @classmethod
-    def empty(cls, size: int) -> np.ndarray:
-        """Return a zero-filled structured array of length *size*."""
-        return np.zeros(size, dtype=cls.DTYPE)
-
-
-
-
-
-
-class SPhotonLite_Merge:
-    """
-    Select hits and merge them using a NumPy implementation
-    that follows the thrust::reduce_by_key based approach
-    of sysrap/SPM.cu SPM::merge_partial_select
-
-    For a small number of photons (eg M1)
-    this precisely duplicates in python the hit selection and merging
-    done with the CUDA impl
-
-    """
-
-    def __init__(self, tw=1.0, select_mask = EFFICIENCY_COLLECT ):
-        self.tw = tw
-        self.select_mask = select_mask
-
-    def __call__(self, _pl):
-        """
-        :param _pl: raw photonlite input array
-        :return hlm: raw hitlitemerged array
-
-        Q: If this is applied twice or more, does the hlm array stay the same ?
-        A: It should do. YES IT DOES STAY THE SAME
-        """
-        log.info("[ photonlite.shape %s " % (repr(_pl.shape),) )
-
-        tw = self.tw
-        select_mask = self.select_mask
-
-        # Step 1: Filter hits
-        flagmask = _pl[:,3]
-
-        select = (flagmask & select_mask) != 0
-        if not np.any(select): return np.zeros(0, dtype=_pl.dtype )
-
-        _hl = _pl[select]
-        # _hl = _pl[ np.where( _pl[:,3] & (0x1 << 13) )]
-
-        # Step 2: Build 64-bit key: (pmt_id << 48) | bucket
-        identity = _hl[:,0] & 0xFFFF                    # lower 16 bits = PMT ID
-        time = _hl[:,1].view(np.float32)
-        bucket = np.floor(time / tw).astype(np.uint64)
-        key = (identity.astype(np.uint64) << 48) | bucket
-
-        # key = ( ( _hl[:,0] & 0xFFFF ).astype(np.uint64) << 48 ) | np.floor( _hl[:,1].view(np.float32)/1. ).astype(np.uint64)
-
-        # Step 3: Sort by key (exactly what Thrust does internally)
-
-        log.info("-argsort[")
-        sort_idx = np.argsort(key, kind='stable')  # stable = same as thrust::stable_sort_by_key
-        log.info("-argsort]")
-        key_sorted = key[sort_idx]
-        _hl_sorted = _hl[sort_idx]
-
-
-        # Step 4: Find group boundaries
-        log.info("-diff[")
-        key_diff = np.diff(key_sorted, prepend=key_sorted[0]-1)     # force first group start
-        log.info("-diff]")
-        group_start = np.where(key_diff != 0)[0]
-
-        # Number of output groups
-        n_groups = len(group_start)
-
-        # Step 5: Reduce each group (vectorized version of sphotonlite_reduce_op)
-        hlm = np.zeros( (n_groups,4), dtype=_pl.dtype )
-
-        # Take first hit in group as base (like your CUDA reduce does with 'a')
-        first_in_group = group_start
-
-        hlm[:] = _hl_sorted[first_in_group]
-
-        # Now reduce the rest of each group
-
-        log.info("-reducing n_groups %d [" % (n_groups,) )
-        for i in range(n_groups):
-            start = group_start[i]
-            end = group_start[i+1] if i+1 < n_groups else len(key)
-
-            if end - start == 1:
-                continue
-
-            group_slice = slice(start, end)
-
-            # min time
-            hlm[i,1] = np.min(_hl_sorted[group_slice,1].view(np.float32)).view(np.uint32)
-
-            # OR all flagmasks
-            hlm[i,3] |= np.bitwise_or.reduce(_hl_sorted[group_slice,3])
-
-            all_identity = _hl_sorted[group_slice,0] & 0xffff
-
-            # sum hitcounts
-            sum_hitcount = np.sum(_hl_sorted[group_slice,0] >> 16, dtype=np.uint32)
-            hlm[i,0] = sum_hitcount << 16 | all_identity[0]
-        pass
-        log.info("-reducing n_groups %d ]" % (n_groups,) )
-        log.info("] hlm.shape %s " % ( repr(hlm.shape), ))
-        return hlm
-    pass
-pass
-
-
-
diff --git a/sysrap/stag.py b/sysrap/stag.py
deleted file mode 100755
index 185c949261..0000000000
--- a/sysrap/stag.py
+++ /dev/null
@@ -1,275 +0,0 @@
-#!/usr/bin/env python 
-
-import numpy as np
-import os, re, logging
-log = logging.getLogger(__name__)
-from collections import OrderedDict as odict 
-
-
-class stag_item(object):
-    @classmethod
-    def Placeholder(cls):
-        return cls(-1,"placeholder","ERROR" )
-
-    def __init__(self, code, name, note=""):
-        self.code = code
-        self.name = name
-        self.note = note
-
-    def __str__(self):
-        return "%2d : %10s : %s " % (self.code, self.name, self.note)
-    def __repr__(self):
-        return "%2d : %10s" % (self.code, self.name)
-
-
-class stag(object):
-    """
-    # the below NSEQ, BITS, ... param need to correspond to stag.h static constexpr 
-    """
-    enum_ptn = re.compile("^\s*(\w+)\s*=\s*(.*?),*\s*?$")
-    note_ptn = re.compile("^\s*static constexpr const char\* (\w+)_note = \"(.*)\" ;\s*$")
-
-    PATH = "$OPTICKS_PREFIX/include/sysrap/stag.h" 
-
-    NSEQ = 4   ## must match stag.h:NSEQ 
-    BITS = 4   ## must match stag.h:BITS
-    MASK = ( 0x1 << BITS ) - 1 
-    SLOTMAX = 64//BITS
-    SLOTS = SLOTMAX*NSEQ
-
-
-    @classmethod
-    def NumStarts(cls, tg):
-        ns = np.zeros( (len(tg)), dtype=np.uint8 ) 
-        for i in range(len(tg)):
-            starts = np.where( tg[i] == tg[0,0] )[0] 
-            ns[i] = len(starts)
-        pass
-        return ns 
- 
-
-    @classmethod
-    def StepSplit(cls, tg, fl=None):
-        """
-        Hmm maybe StepFold is clearer name 
-
-        :param tg: unpacked tag array of shape (n, SLOTS)
-        :param fl: None or flat array of shape (n, SLOTS)
-        :return tgs OR (tgs,fls): step split arrays of shape (n, max_starts, max_slots) 
-
-        In [4]: at[0]
-        Out[4]: array([ 1,  2,  9, 10,  1,  2,  9, 10,  1,  2, 11, 12,  0,  0,  0,  0], dtype=uint8)
-
-        In [8]: ats[0]
-        Out[8]: 
-        array([[ 1,  2,  9, 10,  0,  0,  0,  0,  0,  0],
-               [ 1,  2,  9, 10,  0,  0,  0,  0,  0,  0],
-               [ 1,  2, 11, 12,  0,  0,  0,  0,  0,  0],
-               [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0]], dtype=uint8)
-
-        """
-        if not fl is None:
-            assert fl.shape == tg.shape 
-        pass
-
-        max_starts = 0   ## corresponds to the maximum number of steps of all photons 
-        max_slots = 0 
-        for i in range(len(tg)):
-            starts = np.where( tg[i] == tg[0,0] )[0] # indices of where the very first tag appears in this photons tags 
-            if len(starts) > max_starts: max_starts = len(starts)
-            ends = np.where( tg[i] == 0 )[0] 
-            end = ends[0] if len(ends) > 0 else len(tg[i])  
-            mkr = np.concatenate( (starts, np.array((end,))) )
-            mkr_slots = np.diff(mkr).max()  
-            if mkr_slots > max_slots: max_slots = mkr_slots  
-        pass
-        print("max_starts:%s max_slots:%d" % (max_starts, max_slots))
-
-        tgs = np.zeros((len(tg), max_starts, max_slots), dtype=np.uint8)
-        fls = np.zeros((len(tg), max_starts, max_slots), dtype=np.float32) if not fl is None else None
-
-        for i in range(len(tg)):
-            starts = np.where( tg[i] == tg[0,0] )[0] 
-            ends = np.where( tg[i] == 0 )[0] 
-            end = ends[0] if len(ends) > 0 else len(tg[i])  
-            ## above handles when the tags do not get to zero due to collection truncation
-
-            for j in range(len(starts)):
-                st = starts[j]
-                en = starts[j+1] if j+1 < len(starts) else end
-                tgs[i, j,0:en-st] = tg[i,st:en] 
-                if not fls is None:
-                    fls[i, j,0:en-st] = fl[i,st:en] 
-                pass
-            pass
-        pass
-        return tgs if fls is None else tgs,fls         
-
-
-
-    @classmethod
-    def Unpack(cls, tag):
-        """
-        :param tag: (n, NSEQ) array of bitpacked tag enumerations
-        :return tg: (n, SLOTS) array of unpacked tag enumerations
-
-        Usage::
-
-            # apply stag.Unpack to both as same stag.h bitpacking is used
-            at = stag.Unpack(a.tag) if hasattr(a,"tag") else None
-            bt = stag.Unpack(b.tag) if hasattr(b,"tag") else None
-
-        """
-        assert tag.shape == (len(tag), cls.NSEQ)
-
-        st = np.zeros( (len(tag), cls.SLOTS), dtype=np.uint8 )   
-        for i in range(cls.NSEQ):
-            for j in range(cls.SLOTMAX):
-                st[:,i*cls.SLOTMAX+j] = (tag[:,i] >> (cls.BITS*j)) & cls.MASK
-            pass
-        pass
-        return st 
-
-    def __init__(self, path=PATH):
-        path = os.path.expandvars(path)
-        lines = open(path, "r").read().splitlines()
-        self.path = path 
-        self.lines = lines 
-        self.items = []
-        self.parse()
-
-    def find_item(self, name):
-        for item in self.items:
-            if item.name == name: return item
-        pass
-        return None 
-
-    def parse(self):
-        self.code2item = odict()
-        self.name2item = odict()
-        for line in self.lines:
-            enum_match = self.enum_ptn.match(line)
-            note_match = self.note_ptn.match(line)
-            if enum_match:
-                name, val = enum_match.groups() 
-                pfx = "stag_"
-                assert name.startswith(pfx) 
-                sname = name[len(pfx):]
-                code = int(val)
-                item = stag_item(code, sname, "") 
-                self.items.append(item)
-                self.code2item[code] = item
-                self.name2item[sname] = item
-                log.debug("%40s : name:%20s  sname:%10s val:%10s code:%d " % (line,name,sname,val, code) )
-            elif note_match:
-                name, note = note_match.groups()
-                item = self.find_item(name)
-                assert not item is None
-                item.note = note 
-                log.debug(" note %10s : %s " % (name, note))
-            pass
-            pass
-        pass
-
-    def old_label(self, st):
-        d = self.d
-        label_ = lambda _:repr(d.get(_,stag_item.Placeholder()))
-        ilabel_ = lambda _:"%2d : %s" % ( _, label_(st[_])) 
-        return "\n".join(map(ilabel_, range(len(st))))
-
-
-    def __call__(self, code):
-        return self.code2item.get(code,stag_item.Placeholder())
- 
-    def label(self, st, fl=None):
-        """
-        :param st: array of stag enumeration codes
-        :param fl: None or array of flat uniform rands of shape shape as st 
-        """
-        if not fl is None:
-            assert st.shape == fl.shape
-        pass
-
-        lines = [] 
-        num_zero = 0 
-
-        for i in range(len(st)):
-            code = st[i]
-            flat = fl[i] if not fl is None else None
-            item = self(code)
-            it = repr(item)
-            assert item.code == code
-            if code == st[0] and i > 0:
-                lines.append("")   
-            pass
-            label = "%2d : %s " % (i, it) if fl is None else "%2d : %10.4f : %s" % (i, flat, it)
-            lines.append(label)
-            if code == 0:
-                num_zero += 1 
-                if num_zero == 2: break 
-            pass 
-        pass
-        return "\n".join(lines)
-
-    def __str__(self):
-        return "\n".join(self.lines)
-
-    def __repr__(self):
-        return "\n".join(list(map(repr,self.items)))  
-
-
-
-
-def test_label():
-   tag = stag()
-   #print(tag) 
-   print(repr(tag))
-
-   st = np.array([[ 1,  2,  9, 10,  1,  2, 11, 12,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-                  [ 1,  2,  9, 10,  1,  2, 11, 12,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0],
-                  [ 1,  2,  9, 10,  1,  2, 11, 12,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]], dtype=np.uint8)
-
-   print(tag.label(st[0,:10]))
-
-
-def test_StepSplit():
-    from numpy import array, uint8
-    at = array(
-      [[ 1,  2,  9, 10,  1,  2,  9, 10,  1,  2, 11, 12,  0,  0,  0,  0],
-       [ 1,  2,  9, 10,  1,  2,  9, 10,  1,  2, 11, 12,  0,  0,  0,  0],
-       [ 1,  2,  9, 10,  1,  2,  9, 10,  1,  2, 11, 12,  0,  0,  0,  0]], dtype=uint8)
-
-    x_ats = array(
-      [[[ 1,  2,  9, 10,  0,  0,  0,  0,  0,  0],
-        [ 1,  2,  9, 10,  0,  0,  0,  0,  0,  0],
-        [ 1,  2, 11, 12,  0,  0,  0,  0,  0,  0],
-        [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0]],
-
-       [[ 1,  2,  9, 10,  0,  0,  0,  0,  0,  0],
-        [ 1,  2,  9, 10,  0,  0,  0,  0,  0,  0],
-        [ 1,  2, 11, 12,  0,  0,  0,  0,  0,  0],
-        [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0]],
-
-       [[ 1,  2,  9, 10,  0,  0,  0,  0,  0,  0],
-        [ 1,  2,  9, 10,  0,  0,  0,  0,  0,  0],
-        [ 1,  2, 11, 12,  0,  0,  0,  0,  0,  0],
-        [ 0,  0,  0,  0,  0,  0,  0,  0,  0,  0]]], dtype=uint8)
-
-    ats = stag.StepSplit(at)
-    assert np.all( ats == x_ats )
-
-
-
-
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-  
-    #test_label()
-    #test_StepSplit()
-
-    #test_PFold()
-
-         
diff --git a/sysrap/stag.sh b/sysrap/stag.sh
deleted file mode 100755
index e55e79cb3a..0000000000
--- a/sysrap/stag.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash -l 
-
-export A_FOLD=/tmp/$USER/opticks/GeoChain/BoxedSphere/CXRaindropTest
-export B_FOLD=/tmp/$USER/opticks/U4RecorderTest
-export FOLD=$A_FOLD
-
-${IPYTHON:-ipython} --pdb -i stag.py 
diff --git a/sysrap/stree.py b/sysrap/stree.py
deleted file mode 100644
index 45b6440b37..0000000000
--- a/sysrap/stree.py
+++ /dev/null
@@ -1,594 +0,0 @@
-#!/usr/bin/env python
-"""
-stree.py
-==========
-
-TODO: improve stree.py repr
-
-"""
-
-import os, numpy as np, logging, builtins
-log = logging.getLogger(__name__)
-from opticks.ana.fold import Fold
-from opticks.sysrap.sfreq import sfreq
-from opticks.sysrap.OpticksCSG import CSG_
-
-
-class STR(str):
-    """STR inherits from str and changes the repr to provide the str : useful for interactive ipython"""
-    def __repr__(self):
-        return str(self)
-
-
-class sobject(object):
-    @classmethod
-    def Label(cls, spc=5, pfx=10):
-        prefix = " " * pfx
-        spacer = " " * spc
-        return prefix + spacer.join(cls.FIELD)
-
-    @classmethod
-    def Fields(cls, bi=False):
-        kls = cls.__name__
-        for i, field in enumerate(cls.FIELD):
-            setattr(cls, field, i)
-            if bi:setattr(builtins, field, i)
-        pass
-
-    @classmethod
-    def Type(cls):
-        cls.Fields()
-        kls = cls.__name__
-        print("%s.Type()" % kls )
-        for i, field in enumerate(cls.FIELD):
-            name = cls.DTYPE[i][0]
-            fieldname = "%s.%s" % (kls, field)
-            print(" %2d : %20s : %s " % (i, fieldname, name))
-        pass
-        print("%s.Label() : " % cls.Label() )
-
-    @classmethod
-    def RecordsFromArrays(cls, a):
-        """
-        :param a: ndarray
-        :return: np.recarray
-        """
-        ra = np.core.records.fromarrays(a.T, dtype=cls.DTYPE )
-        return ra
-
-    @classmethod
-    def Doc(cls):
-        assert len(cls.FIELD) == len(cls.DTYPE)
-        lines = []
-        for i in range(len(cls.FIELD)):
-            line = "%2d : %2s : %15s : %s " % (i, cls.FIELD[i], cls.DTYPE[i][0], cls.DTYPE[i][1] )
-            lines.append(line)
-        pass
-        return STR("\n".join(lines))
-
-
-
-
-class sn(sobject):
-    """
-    sn.h CSG constituent node, assuming the default WITH_CHILD
-    """
-    DTYPE = [
-             ('typecode', '<i4'),
-             ('complement', '<i4'),
-             ('lvid', '<i4'),
-             ('xform', '<i4'),
-             ('param', '<i4'),
-             ('aabb', '<i4'),
-             ('parent', '<i4'),
-             ('sibdex', '<i4'),
-             ('num_child', '<i4'),
-             ('first_child', '<i4'),
-             ('next_sibling', '<i4'),
-             ('index', '<i4'),
-             ('depth', '<i4'),
-             ('note',  '<i4'),
-             ('coincide',  '<i4'),
-             ('label0', '<i4'),
-             ('label1', '<i4'),
-             ('label2', '<i4'),
-             ('label3', '<i4'),
-             ]
-
-    FIELD = "tc cm lv xf pa bb pr sx nc fc ns ix dp nt l0 l1 l2 l3".split()
-
-
-
-
-
-
-
-class snd(sobject):
-    """
-    snd.hh CSG constituent node
-    """
-    DTYPE = [
-             ('index', '<i4'),
-             ('depth', '<i4'),
-             ('sibdex', '<i4'),
-             ('parent', '<i4'),
-             ('num_child', '<i4'),
-             ('first_child', '<i4'),
-             ('next_sibling', '<i4'),
-             ('lvid', '<i4'),
-             ('typecode', '<i4'),
-             ('param', '<i4'),
-             ('aabb', '<i4'),
-             ('xform', '<i4'),
-             ]
-
-    FIELD = "ix dp sx pt nc fc sx lv tc pm bb xf".split()
-
-
-class snode(sobject):
-    """
-    Volume structure node
-    """
-    DTYPE = [
-             ('index', '<i4'),
-             ('depth', '<i4'),
-             ('sibdex', '<i4'),
-             ('parent', '<i4'),
-             ('num_child', '<i4'),
-             ('first_child', '<i4'),
-             ('next_sibling', '<i4'),
-             ('lvid', '<i4'),
-             ('copyno', '<i4'),
-             ('sensor_id', '<i4'),
-             ('sensor_index', '<i4'),
-             ('repeat_index', '<i4'),
-             ('repeat_ordinal', '<i4'),
-             ('boundary', '<i4'),
-             ('sensor_name', '<i4')
-             ]
-
-    FIELD = "ix dp sx pt nc fc sx lv cp se sx ri ro bd sn".split()
-
-    @classmethod
-    def Desc(cls, rec):
-        """
-        :param rec:  single rec eg obtained by nds[0]
-        :return str: formatted description
-        """
-        return "snode ix:%7d dh:%2d sx:%5d pt:%7d nc:%5d fc:%7d ns:%7d lv:%3d cp:%7d se:%7d." % tuple(rec)
-
-    @classmethod
-    def Brief(cls, rec):
-        return "snode ix:%7d dh:%2s nc:%5d lv:%3d se:%7d." % (rec.index, rec.depth, rec.num_child, rec.lvid, rec.sensor_id)
-
-
-class sfactor(sobject):
-    """
-    Just handles the first four fields, not the |S32 digest
-    """
-    DTYPE = [
-              ( 'index', '<i4'),
-              ( 'freq',  '<i4'),
-              ( 'sensors',  '<i4'),
-              ( 'subtree',  '<i4')
-            ]
-    FIELD = "ix fr se su".split()
-
-
-class stree(object):
-    @classmethod
-    def MakeTxtArray(cls, lines):
-        maxlen = max(list(map(len, lines)))
-        ta = np.array( lines, dtype="|S%d" % maxlen )
-        return ta
-
-    def __init__(self, f, symbol="st"):
-
-        #sff = Fold.Load(f.base,"subs_freq",  symbol="sf")
-        sff = f.subs_freq if getattr( f, "subs_freq", None ) != None else None
-
-        sf = None if sff is None else sfreq(sff)
-        nds = None if f.nds is None else snode.RecordsFromArrays(f.nds)
-        rem = None if f.rem is None else snode.RecordsFromArrays(f.rem)
-        csg = None if f._csg is None else sn.RecordsFromArrays(f._csg.sn)
-        # FAIL ABOVE MAY BE INCONSISTENT WITH_CHILD ASSUMPTION
-
-        factor = None if f.factor is None else sfactor.RecordsFromArrays(f.factor[:,:4])
-        #soname_ = None if len(f.soname.lines) == 0  else self.MakeTxtArray(f.soname.lines)
-        soname_ = f.soname_names
-
-        self.sf = sf
-        self.f = f
-        self.symbol = symbol
-        self.nds = nds
-        self.rem = rem
-        self.csg = csg
-        self.factor = factor
-        self.raw_subs = None
-        self.soname_ = soname_
-
-    def find_lvid(self, q_soname, starting=True):
-        """
-        Pedestrian way to find string in a list
-        """
-        lines = self.f.soname.lines
-        lvid = -1
-        for i,soname in enumerate(lines):
-            match = soname.startswith(q_soname) if starting else soname == q_soname
-            if match:
-                lvid = i
-                break
-            pass
-        pass
-        return lvid
-
-    def find_lvid_(self, q_soname_, starting=True ):
-        """
-        find array indices starting or exactly matching q_soname
-        unlike the above this returns an array with all matching indices
-        """
-        q_soname = q_soname_.encode() if type(q_soname_) is str else q_soname_
-        assert type(q_soname) is bytes
-        if starting:
-            ii = np.where( np.core.defchararray.find(self.soname_, q_soname) == 0  )[0]
-        else:
-            ii = np.where( self.soname_ == q_soname )[0]
-        pass
-        return ii
-
-    def find_lvid_nodes(self, arg):
-        """
-        :param arg: integer lvid or string soname used to obtain lvid
-        :return: array of indices of all nodes with the specified lvid index or solid name
-        """
-        if type(arg) in [int, np.int32, np.int64, np.uint32, np.uint64]:
-            lvid = int(arg)
-        elif type(arg) is str or type(arg) is bytes:
-            ii = self.find_lvid_(arg)
-            assert len(ii) > 0
-            lvid = int(ii[0])
-            if len(ii) > 1:
-               log.warning("multiple lvid %s correspond to arg:%s using first %s " % (str(ii), arg, lvid))
-            pass
-        else:
-            print("arg %s unhandled %s " % (arg, type(arg)))
-            assert(0)
-        pass
-        return np.where( self.nds.lvid == lvid )[0]
-
-    def find_lvid_node( self, arg, ordinal=0 ):
-        nn = self.find_lvid_nodes(arg)
-        return nn[ordinal]
-
-
-    def get_children(self, nidx, prepend_arg=False):
-        """
-        This is a direct translation of the C++ stree::get_children
-        which will inevitably be slow in python.
-        HMM: how to do this in a more numpy way ?
-        """
-        children = []
-        if prepend_arg:
-            children.append(nidx)
-        pass
-        nd = self.nds[nidx]
-        assert nd.index == nidx
-        ch = nd.first_child
-        while ch > -1:
-           child = self.nds[ch]
-           assert child.parent == nd.index
-           children.append(child.index)
-           ch = child.next_sibling
-        pass
-        return children
-
-    def get_progeny_r(self, nidx, progeny):
-        """
-        :param nidx: node index
-        :param progeny: in/out list of node indices
-
-        Recursively collects node indices of progeny beneath nidx,
-        not including nidx itself.
-        """
-        children = self.get_children(nidx)
-        progeny.extend(children)
-        for nix in children:
-            self.get_progeny_r(nix, progeny)
-        pass
-
-    def get_progeny(self, nidx):
-        progeny = []
-        self.get_progeny_r(nidx, progeny)
-        return np.array(progeny)
-
-    def get_soname(self, nidx):
-        lvid = self.get_lvid(nidx)
-        return self.f.soname[lvid] if lvid > -1 and lvid < len(self.f.soname) else None ;
-
-    def get_sub(self, nidx):
-        return self.f.subs[nidx] if nidx > -1 else None ;
-
-    def get_depth(self, nidx):
-        return self.nds[nidx].depth if nidx > -1 else  -1 ;
-
-    def get_parent(self, nidx):
-        return self.nds[nidx].parent if nidx > -1 else  -1 ;
-
-    def get_lvid(self, nidx):
-        return self.nds[nidx].lvid if nidx > -1 else  -1 ;
-
-    def get_transform(self, nidx):
-        return self.f.trs[nidx] if nidx > -1 and nidx < len(self.f.trs) else None
-
-    def get_ancestors(self, nidx):
-        ancestors = []
-        parent = self.get_parent(nidx)
-        while parent > -1:
-            ancestors.append(parent)
-            parent = self.get_parent(parent)
-        pass
-        ancestors.reverse()
-        return ancestors
-
-    def __repr__(self):
-        return repr(self.f)
-    def __str__(self):
-        return str(self.f)
-
-    @classmethod
-    def DepthSpacer(cls, dep, depmax=15):
-        fmt = "|S%d" % depmax
-        spc = np.zeros( (depmax,), dtype=np.int8 )
-        spc[:] = ord(" ")
-        spc[dep] = ord("+")
-        return spc.view(fmt)[0].decode()
-
-    def desc_node(self, nidx, brief=False):
-        return self.desc_node_(nidx, self.sf, brief=brief)
-
-    def desc_nodes(self, nodes, brief=False):
-        return "\n".join([self.desc_node(nix, brief=brief) for nix in nodes])
-
-    def desc_node_(self, nidx, sf, brief=False):
-
-        nd = self.nds[nidx]
-        dep = self.get_depth(nidx)
-        spc = self.DepthSpacer(dep)
-        ndd = snode.Brief(nd) if brief else snode.Desc(nd)
-        sub = "skip-sub" # self.get_sub(nidx)
-        sfd = "skip-sfd" # "" if sf is None else sf.desc_key(sub)
-        son = "skip-son" # self.get_soname(nidx)
-        return " ".join([spc,ndd,sfd,son])
-
-    def desc_nodes_(self, nodes, sf):
-        return "\n".join( [self.desc_node_(nix, sf) for nix in nodes])
-
-    def make_freq(self, nodes):
-        assert type(nodes) is np.ndarray
-        if self.raw_subs is None:
-            path = os.path.join(self.f.base, "subs.txt")
-            self.raw_subs = np.loadtxt( path, dtype="|S32")
-        pass
-        ssub = self.raw_subs[nodes]
-        ssf = sfreq.CreateFromArray(ssub)
-        return ssf
-
-
-    def desc_boundary_stats(self):
-        """
-        Counts of volumes with each boundary
-
-        desc_boundary_stats
-        u_bd, n_bd = np.unique( st.nds.boundary, return_counts=True  )
-           0 :    0 :      1 : Galactic///Galactic
-           1 :    1 :      3 : Galactic///Rock
-           2 :    2 :      1 : Rock///Galactic
-           3 :    3 :      1 : Rock//Implicit_RINDEX_NoRINDEX_pDomeAir_pDomeRock/Air
-           4 :    4 :      1 : Rock///Rock
-           5 :    5 :      1 : Rock//Implicit_RINDEX_NoRINDEX_pExpHall_pExpRockBox/Air
-           6 :    6 :      1 : Air/Implicit_RINDEX_NoRINDEX_pExpHall_pPoolCover//Steel
-         ...
-         108 :  108 :   4997 : Pyrex/HamamatsuR12860_PMT_20inch_photocathode_mirror_logsurf/HamamatsuR12860_PMT_20inch_photocathode_mirror_logsurf/Vacuum
-         109 :  109 :   4997 : Vacuum/HamamatsuR12860_PMT_20inch_dynode_plate_opsurface//Steel
-         110 :  110 :   4997 : Vacuum/HamamatsuR12860_PMT_20inch_outer_edge_opsurface//Steel
-         111 :  111 :   4997 : Vacuum/HamamatsuR12860_PMT_20inch_inner_edge_opsurface//Steel
-
-
-        """
-        lines = []
-        lines.append("desc_boundary_stats")
-        st = self
-        lines.append("u_bd, n_bd = np.unique( st.nds.boundary, return_counts=True  )")
-        u_bd, n_bd = np.unique( st.nds.boundary, return_counts=True )
-
-        for i in range(len(u_bd)):
-            u = u_bd[i]
-            n = n_bd[i]
-            line = " %3d : %4d : %6d : %s " % (i, u, n, st.f.standard.bd_names[u] )
-            lines.append(line)
-        pass
-        return STR("\n".join(lines))
-
-
-    def desc_remainder(self):
-        lines = []
-        lines.append("desc_remainder")
-        st = self
-        u_lv, n_lv = np.unique( st.rem.lvid, return_counts=True  )
-        lines.append("u_lv, n_lv = np.unique( st.rem.lvid, return_counts=True  )")
-
-        for i in range(len(u_lv)):
-            u = u_lv[i]
-            n = n_lv[i]
-            line = " %3d : %4d : %6d : %s " % (i, u, n, st.f.soname[u] )
-            lines.append(line)
-        pass
-        return "\n".join(lines)
-
-
-    def desc_csg(self, lvid=105):
-        """
-        In [8]: snd.Label(3,8), n[n[:,snd.lv] == 105]
-        Out[8]:
-        ('        ix   dp   sx   pt   nc   fc   sx   lv   tc   pm   bb   xf',
-         array([[483,   4,   0, 484,   0,  -1,  -1, 105, 105, 294, 294,  -1],
-                [484,   3,   0, 486,   1, 483, 485, 105,  11,  -1,  -1,  -1],
-                [485,   3,   1, 486,   0,  -1,  -1, 105, 103, 295, 295, 183],
-                [486,   2,   0, 488,   2, 484, 487, 105,   1,  -1,  -1,  -1],
-                [487,   2,   1, 488,   0,  -1,  -1, 105, 105, 296, 296, 184],
-                [488,   1,   0, 495,   2, 486, 494, 105,   1,  -1,  -1,  -1],
-                [489,   4,   0, 490,   0,  -1,  -1, 105, 105, 297, 297,  -1],
-                [490,   3,   0, 492,   1, 489, 491, 105,  11,  -1,  -1,  -1],
-                [491,   3,   1, 492,   0,  -1,  -1, 105, 103, 298, 298, 186],
-                [492,   2,   0, 494,   2, 490, 493, 105,   1,  -1,  -1,  -1],
-                [493,   2,   1, 494,   0,  -1,  -1, 105, 105, 299, 299, 187],
-                [494,   1,   1, 495,   2, 492,  -1, 105,   1,  -1,  -1, 188],
-                [495,   0,  -1,  -1,   2, 488,  -1, 105,   3,  -1,  -1,  -1]], dtype=int32))
-
-        In [9]: st.f.soname[105]
-        Out[9]: 'HamamatsuR12860Tail0x61b5500'
-        """
-        csg = self.get_csg(lvid)
-        lines = []
-        lines.append("desc_csg lvid:%d st.f.soname[%d]:%s " % (lvid,lvid,self.get_lv_soname(lvid)))
-        lines.append(snd.Label(3,8))
-        lines.append("%s" % repr(csg))
-        return "\n".join(lines)
-
-    def get_csg(self, lvid):
-        st = self
-        n = st.f._csg.sn
-        return n[n[:,sn.lv] == lvid]
-
-    def get_csg_typecode(self, lvid):
-        n = self.get_csg(lvid)
-        return n[:,sn.tc]
-
-
-    def get_numSolid(self):
-        return 1+len(self.factor)
-
-    def get_numPrim(self, ridx):
-        return len(self.rem) if ridx == 0 else self.factor[ridx-1].subtree
-
-    def get_lvid(self, ridx):
-        """
-        :param ridx:
-        :return lvid: array of meshIdx
-
-        In [3]: ridx = 1 ; st.nds.lvid[st.nds.repeat_index == ridx][:st.factor[ridx-1].subtree]
-        Out[3]: array([133, 131, 129, 130, 132], dtype=int32)
-
-        In [4]: ridx = 2 ; st.nds.lvid[st.nds.repeat_index == ridx][:st.factor[ridx-1].subtree]
-        Out[4]: array([128, 118, 119, 127, 126, 120, 125, 121, 122, 123, 124], dtype=int32)
-
-        In [9]: st.nds.lvid[st.nds.repeat_index == 0].shape
-        Out[9]: (3089,)
-        """
-        st = self
-        return st.nds.lvid[st.nds.repeat_index == ridx] if ridx == 0 else st.nds.lvid[st.nds.repeat_index == ridx][:st.factor[ridx-1].subtree]
-
-    def get_lv_soname(self, lv):
-        return str(self.soname_[lv])    # former .decode("utf-8")
-
-    def descSolid(self, ridx, detail=False):
-        """
-        cf with CSGFoundry.descSolid
-        """
-        numPrim = self.get_numPrim(ridx)
-        lvid = self.get_lvid(ridx)
-        u_lvid, n_lvid = np.unique(lvid, return_counts=True )
-        n_lvid_one = np.all( n_lvid == 1 )
-        p_lvid = lvid if n_lvid_one else u_lvid  # present in original order when not "unique" summarizing
-        pass
-        lines = []
-        lines.append("stree.descSolid ridx %3d numPrim %5d lvid %s n_lvid_one %d" % (ridx, numPrim, str(lvid), n_lvid_one))
-        if detail:
-            lines.append("")
-            for pass_ in [0,1]:
-                for i in range(len(p_lvid)):
-                    ulv = p_lvid[i]
-                    nlv = n_lvid[i]
-                    lvn = self.get_lv_soname(ulv)
-                    csg = self.get_csg(ulv)
-                    tc  = self.get_csg_typecode(ulv)
-                    assert len(csg) == len(tc)
-                    tcn = " ".join(list(map(lambda _:"%d:%s"%(_,CSG_.desc(_)), tc)))
-                    if pass_ == 1:
-                        lines.append("")
-                    pass
-                    lines.append(" lv:%3d nlv:%2d %50s csg %2d tcn %s " % (ulv, nlv, lvn, len(csg), tcn  ))
-                    if pass_ == 1:
-                        lines.append(self.desc_csg(ulv))
-                    pass
-                pass
-            pass
-        pass
-        return "\n".join(lines)
-
-    def descSolids(self, detail=False):
-        lines = []
-        numSolid = self.get_numSolid()
-        lines.append("stree.descSolids numSolid:%d detail:%d " % (numSolid,detail) )
-
-        q_ridx = int(os.environ.get("RIDX","-1"))
-        for ridx in range(numSolid):
-            if q_ridx > -1 and ridx != q_ridx: continue
-            lines.append(self.descSolid(ridx, detail=detail))
-            if detail:
-                lines.append("")
-            pass
-        pass
-        return "\n".join(lines)
-
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-    f = Fold.Load(symbol="f")
-
-    st = stree(f)
-    print(repr(st))
-
-    nidx = os.environ.get("NIDX", 13)
-
-    ancestors = st.get_ancestors(nidx)
-    print("NIDX %d ancestors: %s " % (nidx, repr(ancestors)) )
-    print("st.desc_nodes(ancestors)")
-    print(st.desc_nodes(ancestors))
-
-    so = os.environ.get("SO", "sBar")
-    lvs = st.find_lvid_(so)
-    print("SO %s lvs %s" % (so, str(lvs)))
-
-    for lv in lvs:
-        bb = st.find_lvid_nodes(lv)
-        b = int(bb[0])
-        print("lv:%d bb=st.find_lvid_nodes(lv)  bb:%s b:%s " % (lv, str(bb),b))
-
-        anc = st.get_ancestors(b)
-        print("b:%d anc=st.get_ancestors(b) anc:%s " % (b, str(anc)))
-
-        print("st.desc_nodes(anc, brief=True))")
-        print(st.desc_nodes(anc, brief=True))
-        print("st.desc_nodes([b], brief=True))")
-        print(st.desc_nodes([b], brief=True))
-    pass
-
-
-
-if 0:
-    progeny = st.get_progeny(nidx)
-    print("NIDX %d progeny: %s " % (nidx, repr(progeny)) )
-    #print("st.desc_nodes(progeny)")
-    #print(st.desc_nodes(progeny))
-
-    psf = st.make_freq(progeny)
-    print("st.desc_nodes_(progeny, psf)")
-    print(st.desc_nodes_(progeny, psf))
-
-    np.set_printoptions(edgeitems=600)
-
-    print("st.f.trs[progeny].reshape(-1,16)")
-    print(st.f.trs[progeny].reshape(-1,16))
diff --git a/sysrap/stree.sh b/sysrap/stree.sh
deleted file mode 100755
index ccd36451d9..0000000000
--- a/sysrap/stree.sh
+++ /dev/null
@@ -1,10 +0,0 @@
-#!/bin/bash -l 
-
-
-export FOLD=/tmp/$USER/opticks/U4TreeTest
-
-${IPYTHON:-ipython} --pdb  -i $(dirname $BASH_SOURCE)/stree.py 
-
-
-
-
diff --git a/sysrap/tests/CSG_Test.py b/sysrap/tests/CSG_Test.py
deleted file mode 100644
index 6e15b4e5e5..0000000000
--- a/sysrap/tests/CSG_Test.py
+++ /dev/null
@@ -1,48 +0,0 @@
-#!/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.
-#
-
-"""
-To regenerate the OpticksCSG.py::
-
-    sysrap-;sysrap-cd 
-    c_enums_to_python.py OpticksCSG.h  # check 
-    c_enums_to_python.py OpticksCSG.h > OpticksCSG.py 
-
-
-"""
-from opticks.sysrap.OpticksCSG import CSG_
-
-
-if __name__ == '__main__':
-
-     for k, v in CSG_.raw_enum():
-         vv = getattr(CSG_, k)
-         print k, v, vv
-
-
-
-     for i in range(20):
-         d = CSG_.desc(i)
-         i2 = CSG_.fromdesc(d)
-
-         print "%3d %15s %d " % (i, d, i2)
-
-
-
diff --git a/sysrap/tests/GetXF.py b/sysrap/tests/GetXF.py
deleted file mode 100644
index cf147ebd0a..0000000000
--- a/sysrap/tests/GetXF.py
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env python
-
-import numpy as np
-from opticks.ana.fold import Fold
-
-from opticks.sysrap.stree import snd
-
-if __name__ == '__main__':
-    t = Fold.Load("$FOLD/GetXF", symbol="t")
-    print(repr(t))
-pass
-
-
diff --git a/sysrap/tests/SEvt_Lifecycle_Test.py b/sysrap/tests/SEvt_Lifecycle_Test.py
deleted file mode 100644
index 91fd8c07d6..0000000000
--- a/sysrap/tests/SEvt_Lifecycle_Test.py
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/usr/bin/env python
-
-import os, numpy as np
-from opticks.sysrap.sevt import SEvt
-from opticks.ana.fold import Fold
-
-if __name__ == '__main__':
-    f = Fold.Load(symbol="f")
-    print(repr(f))
-
-    a = SEvt.Load("$FOLD",symbol="a")
-    print(repr(a))
-
diff --git a/sysrap/tests/cfcf.py b/sysrap/tests/cfcf.py
deleted file mode 100644
index 8d29c576ab..0000000000
--- a/sysrap/tests/cfcf.py
+++ /dev/null
@@ -1,95 +0,0 @@
-#!/usr/bin/env python
-
-import numpy as np
-from numpy.linalg import multi_dot
-
-from opticks.ana.fold import Fold
-from opticks.CSG.CSGFoundry import CSGFoundry 
-from opticks.ana.eprint import eprint, epr
-from opticks.sysrap.stree import stree
-
-
-def check_inverse_pair(f, a_="inst", b_="iinst" ):
-    """
-    :param f: Fold instance
-     
-    CAUTION : this clears the identity info prior to checking transforms
-    """
-    a = getattr(f, a_)
-    b = getattr(f, b_)
-
-    a[:,:,3] = [0.,0.,0.,1.]
-    b[:,:,3] = [0.,0.,0.,1.]
-
-    assert len(a) == len(b)
-
-    chk = np.zeros( (len(a), 4, 4) )   
-    for i in range(len(a)): chk[i] = np.dot( a[i], b[i] )   
-    chk -= np.eye(4)
-
-    print("check_inverse_pair :  %s %s " % (a_, b_))
-    print(chk.min(), chk.max())
-
-
-def compare_f_with_cf(f, cf ):
-    print("compare_f_with_cf")
-    eprint("(cf.inst - f.inst_f4).max()", globals(), locals())  
-    eprint("(cf.inst - f.inst_f4).min()", globals(), locals())  
-
-
-def check_inst(f, cf):
-
-    eprint("np.abs(cf.inst-f.inst_f4).max()", globals(), locals() ) 
-    w = epr("w = np.where( np.abs(cf.inst-f.inst_f4) > 0.0001 )",  globals(), locals() )
-
-    check_inverse_pair(f, "inst", "iinst" )
-    check_inverse_pair(f, "inst_f4", "iinst_f4" )
-    compare_f_with_cf(f, cf ) 
-
-    a_inst = cf.inst.copy() 
-    b_inst = f.inst_f4.copy() 
-
-    print("a_inst[-1]")
-    print(a_inst[-1])
-    print("b_inst[-1]")
-    print(b_inst[-1])
-
-
-
-if __name__ == '__main__':
-
-    acf = CSGFoundry.Load("$A_CFBASE")
-    print(acf)
-
-    bcf = CSGFoundry.Load("$B_CFBASE")
-    print(bcf)
-
-    """
-
-        node :        (23518, 4, 4)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/node.npy 
-         itra :         (8159, 4, 4)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/itra.npy 
-     meshname :               (139,)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/meshname.txt 
-         meta :                 (7,)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/meta.txt 
-     primname :              (3248,)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/primname.txt 
-      mmlabel :                (10,)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/mmlabel.txt 
-         tran :         (8159, 4, 4)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/tran.npy 
-         inst :        (48477, 4, 4)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/inst.npy 
-        solid :           (10, 3, 4)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/solid.npy 
-         prim :         (3248, 4, 4)  : /tmp/blyth/opticks/ntds3_aug5/G4CXOpticks/CSGFoundry/prim.npy 
-    """
-
-    eprint("np.all( acf.node == bcf.node )", globals(), locals() )  
-    eprint("np.all( acf.itra == bcf.itra )", globals(), locals() )
-    eprint("np.all( acf.meshname == bcf.meshname )", globals(), locals() )
-    #eprint("np.all( acf.meta == bcf.meta)" , globals(), locals() )
-    eprint("np.all( acf.primname == bcf.primname )", globals(), locals() )
-    eprint("np.all( acf.mmlabel == bcf.mmlabel )", globals(), locals() ) 
-    eprint("np.all( acf.tran == bcf.tran )", globals(), locals() )
-    eprint("np.all( acf.inst == bcf.inst )", globals(), locals() )
-    eprint("np.all( acf.inst[:,:,:3] == bcf.inst[:,:,:3] ) ", globals(), locals(), tail=" exclude 4th column" )
-    eprint("np.all( acf.solid == bcf.solid )", globals(), locals() )
-    eprint("np.all( acf.prim == bcf.prim ) ", globals(), locals() )
-
-
-
-
diff --git a/sysrap/tests/cfcf.sh b/sysrap/tests/cfcf.sh
deleted file mode 100755
index 6edecd31ca..0000000000
--- a/sysrap/tests/cfcf.sh
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/bin/bash -l 
-
-export STBASE=/tmp/$USER/opticks/ntds3/G4CXOpticks
-export STBASE_aug5=/tmp/$USER/opticks/ntds3_aug5/G4CXOpticks
-
-
-export A_CFBASE=$STBASE_aug5
-export B_CFBASE=$STBASE
-
-arg=ana
-
-
-if [ "${arg/ana}" != "$arg" ]; then 
-    ${IPYTHON:-ipython} --pdb -i cfcf.py 
-    [ $? -ne 0 ] && echo $BASH_SOURCE ana error && exit 2 
-fi 
-
-exit 0 
-
diff --git a/sysrap/tests/sframe_test.py b/sysrap/tests/sframe_test.py
deleted file mode 100644
index 6375ae3dcd..0000000000
--- a/sysrap/tests/sframe_test.py
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/env python
-
-import numpy as np
-from opticks.sysrap.sframe import sframe
-
-if __name__ == '__main__':
-    print("python sframe.Load")
-    sf = sframe.Load()
-    print(sf)
-
-
-
diff --git a/sysrap/tests/smath_test.py b/sysrap/tests/smath_test.py
deleted file mode 100644
index cd6d0e921d..0000000000
--- a/sysrap/tests/smath_test.py
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/usr/bin/env python
-
-import os, textwrap, numpy as np
-from opticks.ana.fold import Fold, EXPR_
-from opticks.sysrap.smath import rotateUz
-
-if __name__ == '__main__':
-    f = Fold.Load(symbol="f")
-    print(repr(f))
-
-    u = f.rotateUz[0,0]
-    assert np.all( f.rotateUz[:,0] == u )
-
-    d = f.rotateUz[:,1]
-    d1 = f.rotateUz[:,2]
-    d1p = rotateUz(d, u)
-
-    for expr in EXPR_(r"""
-u
-d      # original direction from C++
-d1     # C++ rotateUz
-d1p    # py rotateUz
-d1 - d1p
-(d1 - d1p).min()
-(d1 - d1p).max()
-"""):
-        print(expr)
-        if expr == "" or expr[0] == "#": continue
-        print(repr(eval(expr)))
-    pass
-pass
-
-
diff --git a/sysrap/tests/stree_create_test.py b/sysrap/tests/stree_create_test.py
deleted file mode 100644
index 342666ac55..0000000000
--- a/sysrap/tests/stree_create_test.py
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env python
-
-import numpy as np
-from numpy.linalg import multi_dot
-
-from opticks.ana.fold import Fold
-from opticks.ana.eprint import eprint, epr
-from opticks.sysrap.stree import stree, snode, snd
-
-if __name__ == '__main__':
-
-    snode.Type()
-    snd.Type()
-
-    f = Fold.Load("$FOLD/stree", symbol="f")
-    print(repr(f))
-
-    st = stree(f)
-    print(repr(st))
-
-
-
diff --git a/sysrap/tests/stree_load_test.py b/sysrap/tests/stree_load_test.py
deleted file mode 100644
index 916a601bec..0000000000
--- a/sysrap/tests/stree_load_test.py
+++ /dev/null
@@ -1,228 +0,0 @@
-#!/usr/bin/env python
-"""
-stree_load_test.py
-====================
-
-::
-
-    In [14]: np.unique( st.rem.num_child, return_index=True, return_counts=True  )
-    Out[14]:
-    (array([    0,     1,     2,     3,     4,    54,    63,  4521, 46276], dtype=int32),
-     array([   4,    2,    0,    6,   14, 2328,   12,  204, 2326]),
-     array([2884,    7,   65,    3,  126,    1,    1,    1,    1]))
-
-
-    In [18]: np.unique( st.rem.lvid, return_counts=True  )
-    Out[18]:
-    (array([  0,   1,   2,   3,   4,   5,   6,   7,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,
-             42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
-             80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97, 102, 103, 123, 124, 125, 126, 127, 128, 135, 136, 137, 138], dtype=int32),
-     array([  1,   1,   1,   1,   1,   1,   1,   1, 126,  63,   1,   1,   1,   1,  10,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  10,  30,  30,
-             30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,  30,
-             30,  30,  30,  30,  30,  30,  30,  30,  30,  30,   2,  36,   8,   8,   1,   1, 370, 220,  56,  56,   1,   1,   1,   1,   1,   1,   1,   1,   1,   1]))
-
-
-
-    In [8]: np.unique(f.nds[:,11], return_counts=True )  # repeat_index:11
-    Out[8]:
-    (array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32),
-     array([  3089, 128000,  88305,  34979,  14400,    590,    590,    590,    590,  65520]))
-
-    In [13]: np.unique( st.nds.repeat_index, return_counts=True )
-    Out[13]:
-    (array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32),
-     array([  3089, 128000, 138765,  69958,  14400,    590,    590,    590,    590,  65520]))
-
-
-    In [17]: np.unique( st.nds.lvid[st.nds.repeat_index == 1], return_index=True, return_counts=True )
-    Out[17]:
-    (array([129, 130, 131, 132, 133], dtype=int32),
-     array([2, 3, 1, 4, 0]),                        ## index starts from zero, because have selected only the one ridx
-     array([25600, 25600, 25600, 25600, 25600]))
-
-    In [22]: st.nds.lvid[st.nds.repeat_index == 1].reshape(-1,5)
-    Out[22]:
-    array([[133, 131, 129, 130, 132],
-           [133, 131, 129, 130, 132],
-           [133, 131, 129, 130, 132],
-           [133, 131, 129, 130, 132],
-           [133, 131, 129, 130, 132],
-           [133, 131, 129, 130, 132],
-           [133, 131, 129, 130, 132],
-
-
-    In [8]: np.unique( st.csg.typecode, return_counts=True )
-    Out[8]:
-    (array([  1,   2,   3,  11, 101, 103, 105, 108, 110], dtype=int32),
-     array([199,   1,  30,  20,   7,  27,  97,  10, 246]))
-
-
-
-
-
-
-    CSGFoundry.dumpSolid ridx  1 label               r1 numPrim      5 primOffset   3089
-     so_primIdx 3089 numNode    3 nodeOffset 23207 meshIdx 133 repeatIdx   1 primIdx2   0 : PMT_3inch_pmt_solid
-     so_primIdx 3090 numNode    1 nodeOffset 23210 meshIdx 131 repeatIdx   1 primIdx2   1 : PMT_3inch_body_solid_ell_ell_helper
-     so_primIdx 3091 numNode    1 nodeOffset 23211 meshIdx 129 repeatIdx   1 primIdx2   2 : PMT_3inch_inner1_solid_ell_helper
-     so_primIdx 3092 numNode    1 nodeOffset 23212 meshIdx 130 repeatIdx   1 primIdx2   3 : PMT_3inch_inner2_solid_ell_helper
-     so_primIdx 3093 numNode    1 nodeOffset 23213 meshIdx 132 repeatIdx   1 primIdx2   4 : PMT_3inch_cntr_solid
-
-
-
-    In [18]: np.unique( st.nds.lvid[st.nds.repeat_index == 2], return_index=True, return_counts=True )
-    Out[18]:
-    (array([118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], dtype=int32),
-     array([ 1,  2,  5,  7,  8,  9, 10,  6,  4,  3,  0]),
-     array([12615, 12615, 12615, 12615, 12615, 12615, 12615, 12615, 12615, 12615, 12615]))
-
-
-    In [26]: st.f.factor[:,:4]
-    Out[26]:
-    array([[    0, 25600, 25600,     5],
-           [    1, 12615, 12615,    11],
-           [    2,  4997,  4997,    14],
-           [    3,  2400,  2400,     6],
-           [    4,   590,     0,     1],
-           [    5,   590,     0,     1],
-           [    6,   590,     0,     1],
-           [    7,   590,     0,     1],
-           [    8,   504,   504,   130]], dtype=int32)
-
-
-
-
-
-    In [16]: np.unique( st.nds.lvid[st.nds.repeat_index == 2], return_counts=True )
-    Out[16]:
-    (array([118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128], dtype=int32),
-     array([12615, 12615, 12615, 12615, 12615, 12615, 12615, 12615, 12615, 12615, 12615]))
-
-
-
-
-
-    In [9]: snode.Label(6,11), f.nds[f.nds[:,ri] == 1 ]
-    Out[9]:
-    ('           ix      dp      sx      pt      nc      fc      sx      lv      cp      se      sx      ri      bd',
-     array([[194249,      6,  20675,  67846,      2, 194250, 194254,    122, 300000,     -1,     -1,      1,     26],
-            [194250,      7,      0, 194249,      2, 194251, 194253,    120,      0,     -1,     -1,      1,     29],
-            [194251,      8,      0, 194250,      0,     -1, 194252,    118,      0,     -1,     -1,      1,     36],
-            [194252,      8,      1, 194250,      0,     -1,     -1,    119,      0,     -1,     -1,      1,     37],
-            [194253,      7,      1, 194249,      0,     -1,     -1,    121,      0,     -1,     -1,      1,     24],
-            [194254,      6,  20676,  67846,      2, 194255, 194259,    122, 300001,     -1,     -1,      1,     26],
-            [194255,      7,      0, 194254,      2, 194256, 194258,    120,      0,     -1,     -1,      1,     29],
-            [194256,      8,      0, 194255,      0,     -1, 194257,    118,      0,     -1,     -1,      1,     36],
-            [194257,      8,      1, 194255,      0,     -1,     -1,    119,      0,     -1,     -1,      1,     37],
-            [194258,      7,      1, 194254,      0,     -1,     -1,    121,      0,     -1,     -1,      1,     24],
-
-
-
-    n = st.f._csg.node
-
-    In [8]: snd.Label(3,8), n[n[:,snd.lv] == 105]
-    Out[8]:
-    ('        ix   dp   sx   pt   nc   fc   sx   lv   tc   pm   bb   xf',
-     array([[483,   4,   0, 484,   0,  -1,  -1, 105, 105, 294, 294,  -1],
-            [484,   3,   0, 486,   1, 483, 485, 105,  11,  -1,  -1,  -1],
-            [485,   3,   1, 486,   0,  -1,  -1, 105, 103, 295, 295, 183],
-            [486,   2,   0, 488,   2, 484, 487, 105,   1,  -1,  -1,  -1],
-            [487,   2,   1, 488,   0,  -1,  -1, 105, 105, 296, 296, 184],
-            [488,   1,   0, 495,   2, 486, 494, 105,   1,  -1,  -1,  -1],
-            [489,   4,   0, 490,   0,  -1,  -1, 105, 105, 297, 297,  -1],
-            [490,   3,   0, 492,   1, 489, 491, 105,  11,  -1,  -1,  -1],
-            [491,   3,   1, 492,   0,  -1,  -1, 105, 103, 298, 298, 186],
-            [492,   2,   0, 494,   2, 490, 493, 105,   1,  -1,  -1,  -1],
-            [493,   2,   1, 494,   0,  -1,  -1, 105, 105, 299, 299, 187],
-            [494,   1,   1, 495,   2, 492,  -1, 105,   1,  -1,  -1, 188],
-            [495,   0,  -1,  -1,   2, 488,  -1, 105,   3,  -1,  -1,  -1]], dtype=int32))
-
-
-    In [9]: print(st.desc_csg(18))
-    desc_csg lvid:18 st.f.soname[18]:GLw1.up10_up11_FlangeI_Web_FlangeII0x59f4850
-            ix   dp   sx   pt   nc   fc   sx   lv   tc   pm   bb   xf
-    array([[ 32,   2,   0,  34,   0,  -1,  33,  18, 110,  25,  25,  -1],
-           [ 33,   2,   1,  34,   0,  -1,  -1,  18, 110,  26,  26,   5],
-           [ 34,   1,   0,  36,   2,  32,  35,  18,   1,  -1,  -1,  -1],
-           [ 35,   1,   1,  36,   0,  -1,  -1,  18, 110,  27,  27,   6],
-           [ 36,   0,  -1,  -1,   2,  34,  -1,  18,   1,  -1,  -1,  -1]], dtype=int32)
-
-
-
-"""
-
-import numpy as np
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree, snode, sn   # formerly used snd
-
-np.set_printoptions(edgeitems=16)
-
-def test_bd(st):
-    print("u_bd, n_bd = np.unique( st.nds.boundary, return_counts=True ) ")
-    u_bd, n_bd = np.unique( st.nds.boundary, return_counts=True )
-    for i in range(len(u_bd)):
-        u = u_bd[i]
-        n = n_bd[i]
-        print(" %3d : %4d : %6d : %s " % (i, u, n, st.f.bd_names[u] ))
-    pass
-    print(st.desc_boundary())
-
-def test_rem(st):
-    print("u_lv, n_lv = np.unique( st.rem.lvid, return_counts=True  )")
-    u_lv, n_lv = np.unique( st.rem.lvid, return_counts=True  )
-    for i in range(len(u_lv)):
-        u = u_lv[i]
-        n = n_lv[i]
-        print(" %3d : %4d : %6d : %s " % (i, u, n, st.f.soname_names[u] ))
-    pass
-
-    print(st.desc_remainder())
-
-
-def test_csg(st):
-    print("[---test_csg" )
-    print(" count total csg nodes for each lv : ie number of nodes in every subtree ")
-    print("u_cl, n_cl = np.unique( st.f._csg.sn[:,sn.lv], return_counts=True)")
-    u_cl, n_cl = np.unique( st.f._csg.sn[:,sn.lv], return_counts=True)
-    for i in range(len(u_cl)):
-        u = u_cl[i]
-        n = n_cl[i]
-        print(" %3d : %4d : %6d : %s " % (i, u, n, st.f.soname_names[u] ))
-    pass
-    print("]---test_csg" )
-
-
-if __name__ == '__main__':
-
-    snode.Type()
-    sn.Type()     # formerly snd
-
-
-    print("[--f = Fold.Load")
-    f = Fold.Load(symbol="f")
-    print("]--f = Fold.Load")
-
-    print("[--repr(f)")
-    print(repr(f))
-    print("]--repr(f)")
-
-    print("[--st = stree(f)")
-    st = stree(f)
-    print("]--st = stree(f)")
-
-    print("[--repr(st)")
-    print(repr(st))
-    print("]--repr(st)")
-
-    #test_bd(st)
-    #test_rem(st)
-
-    test_csg(st)
-
-    print("[--st.descSolids")
-    print(st.descSolids(True))
-    print(st.descSolids(False))
-    print("]--st.descSolids")
-
-
-
diff --git a/sysrap/tests/stree_load_test_csg.py b/sysrap/tests/stree_load_test_csg.py
deleted file mode 100644
index f8346c5a00..0000000000
--- a/sysrap/tests/stree_load_test_csg.py
+++ /dev/null
@@ -1,66 +0,0 @@
-#!/usr/bin/env python
-"""
-stree_load_test_csg.py 
-=======================
-
-
-::
-
-    In [15]: label,n[n[:,lv]==60]
-    Out[15]: 
-    ('        ix   dp   sx   pt   nc   fc   ns   lv   tc   pa   bb   xf',
-     array([[242,   2,   0, 244,   0,  -1, 243,  60, 110, 151, 151,  -1],
-            [243,   2,   1, 244,   0,  -1,  -1,  60, 110, 152, 152,  89],
-            [244,   1,   0, 246,   2, 242, 245,  60,   1,  -1,  -1,  -1],
-            [245,   1,   1, 246,   0,  -1,  -1,  60, 110, 153, 153,  90],
-            [246,   0,  -1,  -1,   2, 244,  -1,  60,   1,  -1,  -1,  -1]], dtype=int32))
-
-
-    int index ;        // ix
-    int depth ;        // dp 
-    int sibdex ;       // sx 
-    int parent ;       // pt 
-
-    int num_child ;    // nc
-    int first_child ;  // fc 
-    int next_sibling ; // ns
-    int lvid ;         // lv
-
-    int typecode ;     // tc
-    int param ;        // pa
-    int aabb ;         // bb
-    int xform ;        // xf 
-
-"""
-
-import numpy as np
-import builtins
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree
-
-np.set_printoptions(edgeitems=16) 
-
-
-
-if __name__ == '__main__':
-
-    f = Fold.Load(symbol="f")
-    print(repr(f))
-
-    n = f.node
-
-    fields = "ix dp sx pt nc fc ns lv tc pa bb xf".split()
-    for i, fi in enumerate(fields): setattr(builtins, fi, i)
-    label = " " * 8 + "   ".join(fields)
-    print(label)
-   
-
-    assert np.all( np.arange(len(n)) == n[:,ix] )  
-    assert np.all( n[:,dp] > -1 )    
-    assert np.all( n[:,dp] < 10 )    
-
-
-     
-
-
-
diff --git a/sysrap/tests/stree_py_test.py b/sysrap/tests/stree_py_test.py
deleted file mode 100644
index d81d3f6b86..0000000000
--- a/sysrap/tests/stree_py_test.py
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/usr/bin/env python
-
-import os, logging, numpy as np
-log = logging.getLogger(__name__)
-
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    BASE = os.path.expandvars("$HOME/.opticks/GEOM/$GEOM/CSGFoundry/SSim/stree")
-    f = Fold.Load(BASE, symbol="f")
-    print(repr(f))
-
-    st = stree(f, symbol="st")
-    print(repr(st))
-
-    print("f:fold f.base %s   st:stree " % f.base )
-
diff --git a/sysrap/tests/stree_sensor_test.py b/sysrap/tests/stree_sensor_test.py
deleted file mode 100644
index fbce90dcfc..0000000000
--- a/sysrap/tests/stree_sensor_test.py
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/usr/bin/env python 
-"""
-stree_sensor_test.py
-======================
-
-Count the repeat_index nodes, checking consistent with product of instance count 
-and subtree nodes within each instance::
-
-    In [4]: np.unique( st.nds.repeat_index, return_counts=True )
-    Out[4]: 
-    (array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32),
-     array([  3089, 128000,  88305,  34979,  14400,    590,    590,    590,    590,  65520]))
-
-    In [7]: st.f.factor[:,:4]
-    Out[7]: 
-    array([[    0, 25600, 25600,     5],
-           [    1, 12615, 12615,     7],
-           [    2,  4997,  4997,     7],
-           [    3,  2400,  2400,     6],
-           [    4,   590,     0,     1],
-           [    5,   590,     0,     1],
-           [    6,   590,     0,     1],
-           [    7,   590,     0,     1],
-           [    8,   504,     0,   130]], dtype=int32)
-
-    In [10]: np.c_[st.f.factor[:,:4], st.f.factor[:,1]*st.f.factor[:,3]]
-    Out[10]: 
-    array([[     0,  25600,  25600,      5, 128000],
-           [     1,  12615,  12615,      7,  88305],
-           [     2,   4997,   4997,      7,  34979],
-           [     3,   2400,   2400,      6,  14400],
-           [     4,    590,      0,      1,    590],
-           [     5,    590,      0,      1,    590],
-           [     6,    590,      0,      1,    590],
-           [     7,    590,      0,      1,    590],
-           [     8,    504,      0,    130,  65520]], dtype=int32)
-
-"""
-import numpy as np
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree 
-
-if __name__ == '__main__':
-    f = Fold.Load("$BASE/stree", symbol="f")
-    st = stree(f)
-    print(repr(st))
-pass
diff --git a/sysrap/tests/stree_test.py b/sysrap/tests/stree_test.py
deleted file mode 100644
index e754406df0..0000000000
--- a/sysrap/tests/stree_test.py
+++ /dev/null
@@ -1,109 +0,0 @@
-#!/usr/bin/env python
-
-import numpy as np
-from numpy.linalg import multi_dot
-
-from opticks.ana.fold import Fold
-from opticks.CSG.CSGFoundry import CSGFoundry 
-from opticks.ana.eprint import eprint, epr
-from opticks.sysrap.stree import stree
-
-
-def check_inverse_pair(f, a_="inst", b_="iinst" ):
-    """
-    :param f: Fold instance
-
-    * Now avoided clearing the identity by taking a copy 
-    * This demonstrates the necessity for double precision transforms
-
-    """
-    a = getattr(f, a_).copy()
-    b = getattr(f, b_).copy()
-
-    a[:,:,3] = [0.,0.,0.,1.]
-    b[:,:,3] = [0.,0.,0.,1.]
-
-    assert len(a) == len(b)
-
-    chk = np.zeros( (len(a), 4, 4) )   
-    for i in range(len(a)): chk[i] = np.dot( a[i], b[i] )   
-    chk -= np.eye(4)
-
-    print("check_inverse_pair :  %s %s " % (a_, b_))
-    print(chk.min(), chk.max())
-
-
-def compare_f_with_cf(f, cf ):
-    print("\n[compare_f_with_cf")
-    eprint("(cf.inst[:,:,:3] - f.inst_f4[:,:,:3]).max()", globals(), locals())  
-    eprint("(cf.inst[:,:,:3] - f.inst_f4[:,:,:3]).min()", globals(), locals())  
-    eprint("np.all( cf.inst[:,:,3].view(np.int32)  == f.inst_f4[:,:,3].view(np.int32))", globals(), locals()) 
-    print("]compare_f_with_cf\n")
-
-
-def check_inst(f, cf):
-    print("\n[check_inst(f,cf) : comparing f:stree inst(from U4Tree) with cf:CSGFoundry inst (via CSG_GGeo) ")
-
-    eprint("np.abs(cf.inst[:,:,:3]-f.inst_f4[:,:,:3]).max()", globals(), locals() ) 
-    w = epr("w = np.where( np.abs(cf.inst[:,:,:3]-f.inst_f4[:,:,:3]) > 0.0001 )",  globals(), locals() )
-
-    check_inverse_pair(f, "inst", "iinst" )
-    check_inverse_pair(f, "inst_f4", "iinst_f4" )
-    compare_f_with_cf(f, cf ) 
-
-    a_inst = cf.inst.copy() 
-    b_inst = f.inst_f4.copy() 
-
-    print("a_inst[-1]")
-    print(a_inst[-1])
-    print("b_inst[-1]")
-    print(b_inst[-1])
-
-    print("\n]check_inst(f,cf)")
-
-def check_sensor(st):
-    """
-    dsid = np.diff(sid) 
-    np.where( dsid != 1 )    (array([17611, 43211]),)
-
-    In [40]: sid[17607:17618]
-    Out[40]: array([ 17607,  17608,  17609,  17610,  17611, 300000, 300001, 300002, 300003, 300004, 300005], dtype=int32)
-
-    In [42]: sid[43205:43220]
-    Out[42]: array([325593, 325594, 325595, 325596, 325597, 325598, 325599,  30000,  30001,  30002,  30003,  30004,  30005,  30006,  30007], dtype=int32)
-
-    """
-    ws = np.where( st.nds.sensor_id > -1 )[0]  
-
-    sidx_ = st.nds.sensor_index[ws]   
-    sidx = sidx_[np.argsort(sidx_)]  
-    x_sidx = np.arange(len(sidx), dtype=np.int32) 
-    assert np.all( sidx == x_sidx ), "check sensor_idx contiguous from 0"   
-
-    sid = st.nds.sensor_id[ws]  
-    usid = np.unique(sid)
-    assert len(usid) == len(sid), "check sensor_id are all unique"
-    
-
-
-
-if __name__ == '__main__':
-
-    cf = CSGFoundry.Load()
-    print(cf)
-
-    f = Fold.Load(symbol="f")
-    print(repr(f))
-
-    g_fold = os.path.join(os.path.dirname(f.base), "GGeo/stree") 
-    print("g_fold:%s" % g_fold)
-    g = Fold.Load(g_fold,symbol="g") 
-    print(repr(g))
-
-    st = stree(f)
-    print(repr(st))
-
-    check_inst(f, cf)
-    #check_sensor(st)
-
-
diff --git a/sysrap/xfold.py b/sysrap/xfold.py
deleted file mode 100644
index e987d3a208..0000000000
--- a/sysrap/xfold.py
+++ /dev/null
@@ -1,174 +0,0 @@
-#!/usr/bin/env python 
-
-import numpy as np
-import os, re, logging
-log = logging.getLogger(__name__)
-
-from opticks.ana.fold import Fold
-from opticks.sysrap.stag import stag 
-from opticks.u4.U4Stack import U4Stack 
-from opticks.ana.p import *
-
-
-class XFold(object):
-    tag = stag()
-    stack = U4Stack()
-
-    @classmethod
-    def BaseSymbol(cls, xf):
-        """  
-        :param xf: Fold instance
-        :return symbol: "A" or "B" : A for Opticks, B for Geant4  
-        """
-        CX = xf.base.find("CX") > -1  
-        U4 = xf.base.find("U4") > -1  
-        assert CX ^ U4  # exclusive-OR
-        symbol = "A" if CX else "B"
-        return symbol
-
-    @classmethod
-    def Ident(cls, x):
-        bsym = cls.BaseSymbol(x)
-        ident = cls.tag if bsym == "A" else cls.stack
-        return ident 
-
-    def __init__(self, x, symbol=None):
-        """
-        :param x: Fold instance, eg either a or b 
-        """
-        t = stag.Unpack(x.tag) if hasattr(x,"tag") else None
-        f = getattr(x, "flat", None)
-        n = stag.NumStarts(t) if not t is None else None
-        log.info("XFold before stag.StepSplit")
-        ts,fs = stag.StepSplit(t,x.flat) if not t is None else None
-        log.info("XFold after stag.StepSplit")
-        ident = self.Ident(x)        
-
-        xsymbol = self.BaseSymbol(x)
-        if xsymbol == "B":
-            t2 = self.stack.make_stack2tag_mapped(t) 
-            ts2 = self.stack.make_stack2tag_mapped(ts) 
-        elif xsymbol == "A":
-            t2 = self.stack.make_tag2stack_mapped(t) 
-            ts2 = self.stack.make_tag2stack_mapped(ts) 
-        else:
-            assert 0
-        pass 
-        if symbol != xsymbol:
-            log.error("using unconventional symbol %s xsymbol %s " % (symbol, xsymbol))
-        pass 
-        #assert symbol == xsymbol 
-
-        self.x = x       # Fold instance, called x because it is usually "a" or "b"
-        self.t = t       # (num_photon, SLOTS)  : unpacked consumption tag/stack enumeration integers
-        self.f = f       # (num_photon, SLOTS)  : uniform rand 
-        self.n = n       # (num_photon,)        : number of steps 
-        self.t2 = t2     # (num_photon, SLOTS)  : native enumeration mapped to the other enumeration
-
-        self.ts = ts     # (num_photon, 7, 10)  : 7 is example max_steps which should match A.n.max(), 10 is example max rand per step input  
-        self.fs = fs     # (num_photon, 7, 10)  : flat random values split by steps  
-        self.ts2 = ts2   # (num_photon, 7, 10)  : native enumeration mapped to the other enumeration 
-
-        self.ident = ident  # A:stag OR B:U4Stack instance for providing names to enumeration codes
-        self.symbol = symbol
-        self.xsymbol = xsymbol
-        self.idx = 0 
-        self.flavor = ""
-
-    def __call__(self, idx):
-        self.idx = idx 
-        self.flavor = "call"
-        return self
-
-    def __getitem__(self, idx):
-        self.idx = idx 
-        self.flavor = "getitem"
-        return self
-
-    def header(self):
-        idx = self.idx 
-        seqhis = seqhis_(self.x.seq[idx,0])
-        return "%s(%d) : %s" % (self.symbol, idx, seqhis)
-
-    def rbnd__(self):
-        return boundary___(self.x.record[self.idx])
-    def rori__(self):
-        return orient___(self.x.record[self.idx]) 
-    def rpri__(self):
-        return primIdx___(self.x.record[self.idx])   
-    def rins__(self):
-        return instanceId__(self.x.record[self.idx])   
-
-
-    def rbnd_(self): 
-        bb_ = self.rbnd__()
-        oo_ = self.rori__()
-        pp_ = self.rpri__()
-        ii_ = self.rins__()
-        assert bb_.shape == oo_.shape
-        assert bb_.shape == pp_.shape
-        assert bb_.shape == ii_.shape
-
-        wp = np.where( bb_ > 0 )  # mask boundary zero to skip unsets 
-        bb = bb_[wp] 
-        oo = oo_[wp] 
-        pp = pp_[wp]
-        ii = ii_[wp]
-
-        pm = ["+","-"]
-        lines = [ "%s %-40s %-50s"%(pm[oo[i]],cf.sim.bndnamedict.get(bb[i]), cf.primIdx_meshname_dict.get(pp[i])) for i in range(len(bb))]
-
-        lines += [""]
-        lines += ["- : against the normal (ie inwards from omat to imat)"]
-        lines += ["+ : with the normal (ie outwards from imat to omat)"] 
-        return lines 
-
-
-    def rbnd(self):
-        return "\n".join(self.rbnd_())
-
-    def content(self):
-        lines = []
-        members = "t t2 n ts fs ts2".split()
-        for mem in members:
-            arr = getattr(self, mem) 
-            name = "%s.%s" % ( self.symbol, mem)
-            line = "%10s : %s " % (name, str(arr.shape))
-            lines.append(line)
-        pass
-        return "\n".join(lines)
-
-    def body(self):
-        return self.ident.label(self.t[self.idx],self.f[self.idx])
-
-    def identification(self):
-        return "%s : %s" % (self.symbol, self.x.base) 
-
-    def call_repr(self):
-        return "\n".join([self.header(), self.content(), self.body()]) 
-
-    def getitem_repr(self):
-        return "\n".join([self.header(), self.rbnd()])
-
-    def __repr__(self):
-        if self.flavor == "call":
-            rep = self.call_repr()
-        elif self.flavor == "getitem":
-            rep = self.getitem_repr()
-        else:
-            rep = self.call_repr()
-        pass
-        return rep 
-
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
- 
-    a = Fold.Load("$A_FOLD", symbol="a")
-    b = Fold.Load("$B_FOLD", symbol="b")
-    A = XFold(a, symbol="A")
-    B = XFold(b, symbol="B")
-
-
diff --git a/sysrap/xfold.sh b/sysrap/xfold.sh
deleted file mode 100755
index b980d6f265..0000000000
--- a/sysrap/xfold.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash -l 
-
-export A_FOLD=/tmp/$USER/opticks/GeoChain/BoxedSphere/CXRaindropTest
-export B_FOLD=/tmp/$USER/opticks/U4RecorderTest
-export FOLD=$A_FOLD
-
-${IPYTHON:-ipython} --pdb -i xfold.py 
diff --git a/u4/tests/PIDX.sh b/u4/tests/PIDX.sh
deleted file mode 100755
index 57f9c8302c..0000000000
--- a/u4/tests/PIDX.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash -l 
-
-DIR=$(dirname $BASH_SOURCE)
-export U4Recorder=INFO
-export U4Recorder__ClassifyFake_FindPV_r=1
-
-
-N=0 PIDX=${PIDX:-128} $DIR/U4SimulateTest.sh run
-
-
-
diff --git a/u4/tests/U4RecorderTest.py b/u4/tests/U4RecorderTest.py
deleted file mode 100644
index 2918418111..0000000000
--- a/u4/tests/U4RecorderTest.py
+++ /dev/null
@@ -1,207 +0,0 @@
-#!/usr/bin/env python 
-"""
-U4RecorderTest.py
-==================
-
-::
-
-     18 struct spho
-     19 {
-     20     int gs ; // 0-based genstep index within the event
-     21     int ix ; // 0-based photon index within the genstep
-     22     int id ; // 0-based photon identity index within the event 
-     23     int gn ; // 0-based reemission index incremented at each reemission 
-
-
-"""
-import numpy as np
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-
-from opticks.sysrap.stag import stag  
-from opticks.u4.U4Stack import U4Stack
-stack = U4Stack()
-
-
-def check_pho_labels(l):
-    """ 
-    :param l: spho labels 
-
-    When reemission is enabled this would fail for pho0 (push_back labels)
-    but should pass for pho (labels slotted in by event photon id)
-
-    1. not expecting gaps in list of unique genstep index gs_u 
-       as there should always be at least one photon per genstep
-
-    2. expecting the photon identity index to be unique within event, 
-       so id_c should all be 1, otherwise likely a labelling issue
-
-    """
-    gs, ix, id_, gn = l[:,0], l[:,1], l[:,2], l[:,3]
-
-    gs_u, gs_c = np.unique(gs, return_counts=True ) 
-    np.all( np.arange( len(gs_u) ) == gs_u )       
-
-    id_u, id_c = np.unique( id_, return_counts=True  )  
-    all_one =  np.all( id_c == 1 )  
-
-    if not all_one: print("check_pho_labels all_one FAIL")
-    #assert all_one
-
-    ix_u, ix_c = np.unique( ix, return_counts=True )  
-
-    gn_u, gn_c = np.unique( gn, return_counts=True )  
-    print(gn_u)
-    print(gn_c)
-
-
-def parse_slice(ekey):
-    if not ekey in os.environ: return slice(None)
-    elem = os.environ[ekey].split(":")    
-    start = None if elem[0] == "" else int(elem[0])
-    stop = None if elem[1] == "" else int(elem[1])
-    step = None if elem[2] == "" else int(elem[2])
-    return slice(start, stop, step) 
-
-
-
-if __name__ == '__main__':
-
-    t = Fold.Load() 
-    PIDX = int(os.environ.get("PIDX","-1"))
-    print(t)
-
-    if "RECS_PLOT" in os.environ:
-        """
-        RECS_PLOT=1 ./U4RecorderTest.sh ana 
-
-
-        RECS_PLOT=1 SEQHIS="TO BT BT SA" RSLI="0::4" ./U4RecorderTest.sh ana 
-            select photons with one history and then just plot the first record step 
-
-        RECS_PLOT=1 SEQHIS="TO BT BT SA" RSLI="1::4" ./U4RecorderTest.sh ana 
-            expected to show positions of first BT
-
-            np.all(np.tile(np.arange(4),100)[slice(0,None,4)]==0)    
-            np.all(np.tile(np.arange(4),100)[slice(1,None,4)]==1)    
-            np.all(np.tile(np.arange(4),100)[slice(2,None,4)]==2)  
-            np.all(np.tile(np.arange(4),100)[slice(3,None,4)]==3)  
-
-        RECS_PLOT=1 SEQHIS="TO BT BT SA" RSLI="2::4" ./U4RecorderTest.sh ana 
-
-        RECS_PLOT=1 SEQHIS="TO BT BT SA" RSLI="3::4" ./U4RecorderTest.sh ana 
-
-        RECS_PLOT=1 SEQHIS="TO BT BT SA" IREC=2 ./U4RecorderTest.sh ana 
-
-
-        RECS_PLOT=1 SEQHIS="TO BT BT BT BT BT SA" IREC=1 ./U4RecorderTest.sh ana 
-
-        RECS_PLOT=1 SEQHIS="TO BT BT BT BT BT SA" ./U4RecorderTest.sh ana 
-             plot all step points 
-
-        """
-        from opticks.ana.pvplt import * 
-        pl = pvplt_plotter(label="dump all record point positions")      
-        if "SEQHIS" in os.environ: 
-            #w_sel = np.where( t.seq[:,0] == cseqhis_("TO BT BT SA") )[0]
-            w_sel = np.where( t.seq[:,0] == cseqhis_(os.environ["SEQHIS"]) )[0]
-        else:
-            w_sel = slice(None)
-        pass 
-
-        if "RSLI" in os.environ:
-            ## This way of selecting record points is overly complicated, much better 
-            ## to use the more direct IREC approach. 
-            w_rec = np.where( t.record[w_sel,:,3,3].view(np.int32) != 0 )
-            #recs = t.record[w_rec]   ## flattens step points to give shape eg (35152, 4, 4) where 8788*4  = 35152 
-            ## the above would be an error as it is using w_sel sub-selection indices as if they were full array indices. 
-            recs = t.record[w_sel][w_rec]
-            ## To correctly use a where selection the base selection must be the same as that 
-            ## used to create the where selection. 
-            rsli = parse_slice("RSLI")            
-            rpos = recs[rsli,0,:3]   
-        elif "IREC" in os.environ:
-            ## using IREC is a simpler more direct way of selecting step points  
-            irec = int(os.environ["IREC"])
-            rpos = t.record[w_sel, irec, 0,:3]
-        else:
-            w_rec = np.where( t.record[w_sel,:,3,3].view(np.int32) != 0 )   
-            ## Above w_rec skips unfilled record points.  
-            ## Notice that for w_sel slice(None) for example w_rec is selecting 
-            ## different numbers of step points for each photon : so the below rpos contains 
-            ## all positions from all step points within the w_sel selection. This includes 
-            ## bulk scatter and absorption points. 
-            ## TODO: find way to do similar but select based on the flag of the step points 
-            ## so can color plots according to the flag. 
-            rpos = t.record[w_sel][w_rec][:,0,:3]
-        pass
-
-        pl.add_points(rpos)   
-        pl.show()
-    pass
-
-
-
-
-    # pho: labels are collected within U4Recorder::PreUserTrackingAction 
-    l = t.pho if hasattr(t, "pho") else None      # labels slotted in using spho::id
-    check_pho_labels(l)
-
-    gs, ix, id_, gn = l[:,0], l[:,1], l[:,2], l[:,3] 
-
-    st = stag.Unpack(t.tag) if hasattr(t,"tag") else None
-
-    p = t.photon if hasattr(t, "photon") else None
-    r = t.record if hasattr(t, "record") else None
-    seq = t.seq if hasattr(t, "seq") else None
-    nib = seqnib_(seq[:,0])  if not seq is None else None
-
-    lim = min(len(p), 3)
-    for i in range(lim):
-        if not (PIDX == -1 or PIDX == i): continue 
-        if PIDX > -1: print("PIDX %d " % PIDX) 
-        print("r[%d,:,:3]" % i)
-        print(r[i,:nib[i],:3]) 
-        print("\n\nbflagdesc_(r[%d,j])" % i)
-        for j in range(nib[i]):
-            print(bflagdesc_(r[i,j]))   
-        pass
-
-        #print("ridiff_(r[%d])*1000." % i)
-        #print(ridiff_(r[i])*1000.)   
-
-        print("\n") 
-        print("p[%d]" % i)
-        print(p[i])
-        print("\n") 
-        print("bflagdesc_(p[%d])" % i)
-        print(bflagdesc_(p[i])) 
-        print("\n") 
-        if not seq is None:
-            print("seqhis_(seq[%d,0]) nib[%d]  " % (i,i) ) 
-            print(" %s : %s "% ( seqhis_(seq[i,0]), nib[i] ))
-            print("\n")
-        pass
-        print("\n\n")
-    pass
-    idx = p.view(np.uint32)[:,3,2] 
-    check_idx = np.all( np.arange( len(p) ) == idx ) 
-    if not check_idx: print("check_idx FAIL")
-    #assert check_idx
-
-    flagmask_u, flagmask_c = np.unique(p.view(np.uint32)[:,3,3], return_counts=True)    
-    print("flagmask_u:%s " % str(flagmask_u))
-    print("flagmask_c:%s " % str(flagmask_c))
-
-    #print("\n".join(seqhis_( t.seq[:,0] ))) 
-    for i in range(lim):
-        print("%4d : %s " % (i, seqhis_(t.seq[i,0])))
-    pass
-
-    seq_u, seq_c = np.unique(seq[:,0], return_counts=True)  
-    for i in range(len(seq_u)):
-        print("%4d : %4d : %20s  " % (i, seq_c[i], seqhis_(seq_u[i]) ))
-    pass
-    print("t.base : %s " %  t.base)
-pass
-
diff --git a/u4/tests/U4RecorderTest_ab.py b/u4/tests/U4RecorderTest_ab.py
deleted file mode 100644
index 3db228e595..0000000000
--- a/u4/tests/U4RecorderTest_ab.py
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/usr/bin/env python 
-"""
-U4RecorderTest_ab.py
-======================
-
-Usage::
-
-   cd ~/opticks/u4/tests   # u4t
-   ./U4RecorderTest_ab.sh  
-
-"""
-import numpy as np
-
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-from opticks.ana.eprint import eprint, epr
-
-from opticks.sysrap.xfold import XFold
-from opticks.sysrap.stag import stag  
-from opticks.u4.U4Stack import U4Stack
-
-np.set_printoptions(edgeitems=16) 
-
-tag = stag()
-stack = U4Stack()
-
-
-if __name__ == '__main__':
-
-    quiet = True 
-    a = Fold.Load("$A_FOLD", symbol="a", quiet=quiet) if "A_FOLD" in os.environ else None
-    b = Fold.Load("$B_FOLD", symbol="b", quiet=quiet) if "B_FOLD" in os.environ else None
-
-    print("-------- after Fold.Load" )
-
-    A = XFold(a, symbol="A") if not a is None else None
-    B = XFold(b, symbol="B") if not b is None else None
-
-    print("-------- after XFold" )
-
-
-    ab = (not a is None) and (not b is None)
-    if ab: 
-        im = epr("im = np.abs(a.inphoton - b.inphoton).max()", globals(), locals() )  
-        pm = epr("pm = np.abs(a.photon - b.photon).max()",     globals(), locals() )  
-        rm = epr("rm = np.abs(a.record - b.record).max()",     globals(), locals() )  
-        sm = epr("sm = np.all( a.seq[:,0] == b.seq[:,0] )",    globals(), locals() )  
-
-        eprint("np.all( A.ts == B.ts2 )", globals(), locals() )
-        eprint("np.all( A.ts2 == B.ts )", globals(), locals() )
-
-        assert (a.inphoton - b.inphoton).max() < 1e-5 
-        #assert np.all( A.ts == B.ts2 ) 
-        #assert np.all( A.ts2 == B.ts )  
-    pass
-
-    print("./U4RecorderTest_ab.sh ## u4t ")
-    w = epr("w = np.unique(np.where( np.abs(a.photon - b.photon) > 0.1 )[0])", globals(), locals() )
-    s = epr("s = a.seq[w,0]", globals(), locals() )  
-    o = epr("o = cuss(s,w)", globals(), locals() , rprefix="\n")
-
-    #epr("w1", globals(), locals() )
-    #abw0 = epr("abw0 = a.photon[w0,:4] - b.photon[w0,:4]", globals(), locals(), rprefix="\n" ) 
-
-    epr("a.base", globals(), locals() )
-    epr("b.base", globals(), locals() )
-
-
-
-
-
diff --git a/u4/tests/U4SimtraceSimpleTest.py b/u4/tests/U4SimtraceSimpleTest.py
deleted file mode 100644
index fdde1456a2..0000000000
--- a/u4/tests/U4SimtraceSimpleTest.py
+++ /dev/null
@@ -1,475 +0,0 @@
-#!/usr/bin/env python
-"""
-U4SimtraceSimpleTest.py
-=========================
-
-envvars
----------
-
-FOLD, SFOLD
-    mandatory first geometry 
-TFOLD
-    optional second geometry  
-AFOLD
-    optional first simulation photon histories
-BFOLD
-    optional second simulation photon histories
-
-"sibling" classes
---------------------
-
-U4SimtraceTest
-   intersection geometry  
-
-SEvt
-   photon histories 
-
-"""
-import os, logging, numpy as np
-log = logging.getLogger(__name__)
-
-from collections import OrderedDict as odict 
-from opticks.ana.fold import Fold
-from opticks.ana.pvplt import *
-from opticks.ana.p import * 
-from opticks.ana.eget import eintarray_, efloatarray_
-from opticks.sysrap.sevt import SEvt 
-
-
-COLORS = "red green blue cyan magenta yellow pink orange purple lightgreen".split()
-GCOL = "grey"
-
-TIGHT = int(os.environ.get("TIGHT", "0")) == 1 
-SZ = float(os.environ.get("SZ",3))
-REVERSE = int(os.environ.get("REVERSE","0")) == 1
-size = np.array([1280, 720])
-X,Y,Z = 0,1,2
-
-
-# use eg FOCUS=0,0,100 to select part of view with aspect ratio preserved
-#XLIM=efloatarray_("XLIM","0,0")
-#YLIM=efloatarray_("YLIM","0,0")
-
-FOLD = os.environ.get("FOLD", None)
-SFOLD = os.environ.get("SFOLD", None)
-TFOLD = os.environ.get("TFOLD", None)
-AFOLD = os.environ.get("AFOLD", None)
-BFOLD = os.environ.get("BFOLD", None)
-
-N = int(os.environ.get("VERSION","-1")) 
-GEOM = os.environ.get("GEOM", "DummyGEOM")
-GEOMList = os.environ.get("%s_GEOMList" % GEOM, "DummyGEOMList") 
-FOCUS = os.environ.get("FOCUS", "")
-
-APID = int(os.environ.get("APID", -1 ))
-BPID = int(os.environ.get("BPID", -1 ))
-AOPT = os.environ.get("AOPT", "")
-BOPT = os.environ.get("BOPT", "")
-
-
-
-topline = "N=%d " % N
-
-if len(FOCUS) > 0:
-   topline += " FOCUS=%s " % FOCUS
-pass
-
-
-if APID > -1: topline += "APID=%d " % APID
-if len(AOPT) > 0: topline += "AOPT=%s " % AOPT
-
-if BPID > -1: topline += "BPID=%d " % BPID
-if len(BOPT) > 0: topline += "BOPT=%s " % BOPT
-
-topline += " ./U4SimtraceSimpleTest.sh ana   # %s/%s " % (GEOM, GEOMList)
-
-TOPLINE = os.environ.get("TOPLINE",topline )
-BOTLINE = os.environ.get("BOTLINE","%s" % SFOLD )
-THIRDLINE = os.environ.get("THIRDLINE", "APID:%d BPID:%d " % (APID,BPID) )
-
-AXES = np.array(list(map(int,os.environ.get("AXES","0,2").split(","))), dtype=np.int8 )
-H,V = AXES
-
-log = logging.getLogger(__name__)
-np.set_printoptions(suppress=True, edgeitems=5, linewidth=200,precision=3)
-
-
-class U4SimtraceSimpleTest(object):
-    """
-    MAYBE: come up with a better name for this and relocate into ana or SysRap for reuse
-    ACTUALLY this is using trs names, so its not as general as first thought ... 
-    it is limited to small test geometries. 
-
-    The more general GPU simtrace deserves more attention than this one.
-
-    HMM: there are developments elsewhere that are close to this, MAYBE: consolidate
-    """
-    @classmethod
-    def Load(cls, fold, **kwa):
-        if fold is None: return None
-        if int(kwa.get("NEVT",0)) > 0:
-            f = Fold.LoadConcat(fold,**kwa) 
-        else:
-            f = Fold.Load(fold, **kwa )
-        pass
-        return None if f is None else cls(f)
-
-
-    def __repr__(self):
-        return "U4SimtraceSimpleTest %s:%s " % (self.symbol, self.fold.base)
-
-    def __init__(self, fold):
-        """
-        Note the container fold Loads subfold for each of the trs_names 
-        """
-        trs_names = np.loadtxt( os.path.join(fold.base, "trs_names.txt"), dtype=np.object )
-
-        sfs = odict()
-        for i, name in enumerate(trs_names):
-            sfs[name] = Fold.Load(fold.base, name,"p001",  symbol="%s%0.2d" % (fold.symbol,i) )
-        pass  # Fold for each solid 
-
-        symbol = fold.symbol
-
-        kvol = "%sVOL" % symbol.upper()
-        vol = eintarray_(kvol)
-
-        self.fold = fold 
-        self.trs_names = trs_names
-        self.sfs = sfs
-        self.opp = []
-        self.kvol = kvol 
-        self.vol = vol 
-        self.symbol = symbol
-
-    def geoplot(self, pl):
-        """
-        :param pl: either tuple of (fig,ax) for MODE 2 or pyvista pl for MODE 3
-        """
-        fig, ax = None, None
-        if MODE == 2:
-            fig, axs = pl
-            assert len(axs) == 1 
-            ax = axs[0]
-        elif MODE == 2:
-            pass
-        pass 
-
-        trs = self.fold.trs
-        trs_names = self.trs_names
-        sfs = self.sfs
-        vol = self.vol
-        kvol = self.kvol
-
-        vsel = len(vol) > 0   # selecting volumes by index from eg SVOL envvar
-        num = len(trs_names)
-
-        if vsel:
-            print("mp_geoplot : volume selection %s vol %s num %d " % (kvol, str(vol), num )) 
-        pass
-
-        for j in range(num):
-            i = num - 1 - j  if REVERSE else j
-
-            soname = trs_names[i] ## solid name for every transform, lots of repeated solid names 
-
-            if vsel:
-                if i in vol: 
-                    print(" %s PROCEED i %d soname %s " % (kvol, i, soname)) 
-                else:
-                    print(" %s SKIP    i %d soname %s " % (kvol, i, soname)) 
-                    continue
-                pass
-            pass
-
-            sf = sfs[soname]
-
-            if not getattr(sf, 'simtrace', None) is None:
-                _lpos = sf.simtrace[:,1].copy()
-                _lpos[:,3] = 1
-            else:
-                 print("missing simtrace for soname:%s " % soname)
-                 continue
-            pass
-
-            gspo = sf.genstep[:,5,:3]
-            if "GENSTEP" in os.environ:
-                if MODE == 2:
-                    ax.scatter( gspo[:,H], gspo[:,V], s=SZ, color="black" )
-                elif MODE == 3:
-                    pl.add_points( gspo[:,:3], color=color, label=label)  
-                pass
-            pass
-            
-
-            tr = np.float32(trs[i])
-            tr[:,3] = [0,0,0,1]   ## fixup 4th column, as may contain identity info
-
-            dori = np.sqrt(np.sum(_lpos[:,:3]*_lpos[:,:3],axis=1))
-            lpos = _lpos[dori>0]    # exclude points at local origin, misses 
-
-            gpos = np.dot( lpos, tr )
-            pass
-            color = COLORS[ i % len(COLORS)]
-
-            label = str(soname)
-            if label[0] == "_": label = label[1:]   # seems labels starting "_" have special meaning to mpl, causing problems
-            label = label.replace("solid","s")
-
-            if MODE == 2:
-                ax.scatter( gpos[:,H], gpos[:,V], s=SZ, color=color, label=label )
-            elif MODE == 3:
-                pl.add_points( gpos[:,:3], color=color, label=label)  
-            pass
-        pass
-
-        if MODE == 2:
-            xlim, ylim = mpplt_focus_aspect()
-            if not xlim is None:
-                ax.set_xlim(xlim) 
-                ax.set_ylim(ylim) 
-            else:
-                log.info("mpplt_focus_aspect not enabled, use eg FOCUS=0,0,100 to enable ")
-            pass 
-
-            if 'POINT' in os.environ: # ADD POINT OR POINTS SPECIFIED BY TRIPLETS 
-                point = efloatarray_("POINT", "0,0,0").reshape(-1,3)
-                ax.scatter( point[:,H], point[:,V], s=SZ, color="red", label="POINT" )
-            pass
-
-            if 'LINE' in os.environ:
-                line = efloatarray_("LINE", "1,2,3,10,20,30,100,200,300").reshape(-1,3)
-                ax.plot( line[:,H], line[:,V], "ro-" )
-            pass
-
-            if TIGHT:
-                ax.axis('off')
-                fig.tight_layout()
-            pass
-
-        elif MODE == 3:
-            pass
-        pass
-
-
-    def show(self, pl ):
-        if MODE == 2:
-            self.mp_show(pl)
-        elif MODE == 3:
-            self.pv_show(pl)
-        pass
-  
-    def pv_show(self, pl):
-        cp = pl.show()
-        print(cp)
-
-    def mp_show(self, pl): 
-
-        fig, axs = pl
-        assert len(axs) == 1 
-        ax = axs[0]
-
-        #ax.set_xlim(-60,60)  # use FOCUS=0,0,100
-        #ax.set_ylim(-100,100)
-
-        locs = ["upper left","lower left", "upper right"]
-        LOC = os.environ.get("LOC",locs[0])
-        print("LOC : %s " % LOC)
-        if LOC == "skip" or LOC == "":
-            print("skip legend as LOC:[%s] " % LOC)
-        else:
-            ax.legend(loc=LOC,  markerscale=4)
-        pass
-
-        thirdline = ""
-        subtitle = ""
-
-        num_opp = len(self.opp)
-
-        if num_opp == 2:
-            a,b = self.opp
-            thirdline = a.label 
-            subtitle  = b.label
-        else:
-            ## eg "TO BT SA\n00 01 02"
-            for one in self.opp:
-                print("one.label:%s " % one.label)
-                thirdline += one.label 
-            pass 
-        pass
-
-        subtitle = os.environ.get("SUBTITLE", "")
-        print("mp_show num_opp:%d subtitle:%s " % (num_opp, subtitle) )
-        
-        # adjust the position of the title, to legibly display 4 lines      
-        TOF = float(os.environ.get("TOF","0.99")) 
-
-        #suptitle = "\n".join([TOPLINE,BOTLINE,thirdline]) 
-        suptitle = TOPLINE 
-
-
-        fig.suptitle(suptitle, family="monospace", va="top", y=TOF, fontweight='bold' )
-
-        hv_thirdline = efloatarray_("HV_THIRDLINE","-0.05,1.02") 
-        hv_subtitle = efloatarray_("HV_SUBTITLE","1.05,-0.12") 
-        assert len(hv_thirdline) == 2 
-        assert len(hv_subtitle) == 2 
-
-        ax.text( hv_thirdline[0],  hv_thirdline[1], thirdline, va='bottom', ha='left', family="monospace", fontsize=12, transform=ax.transAxes)
-        ax.text( hv_subtitle[0],  hv_subtitle[1], subtitle, va='bottom', ha='right', family="monospace", fontsize=12, transform=ax.transAxes)
-
-        print("mp_show suptitle:[%s]" % suptitle ) 
-        print("mp_show thirdline:[%s] HV_THIRDLINE:%s"  % (thirdline, str(hv_thirdline)) ) 
-        print("mp_show subtitle:[%s]  HV_SUBTITLE:%s"   % (subtitle,  str(hv_subtitle)) ) 
-
-        fig.show()
-
-    def onephotonplot(self, pl, f): 
-        """
-        :param pl:  plotting machinery 
-        :param f: expecting SEvt object with photon history, 
-                  NB pid must be set to +ve integer selecting the photon to plot anything  
-        """
-        if f is None: return 
-        if f.pid < 0: return
-
-        self.opp.append(f)
-
-        if not hasattr(f,'r'): return
-        if f.r is None: return
-
-        r = f.r 
-        off = f.off
-
-        rpos = r[:,0,:3] + off
-
-        if MODE == 2:
-            fig, axs = pl 
-            assert len(axs) == 1 
-            ax = axs[0]
-            if True:
-                mpplt_add_contiguous_line_segments(ax, rpos, axes=(H,V), label=None )
-                self.mp_plab(ax, f)
-            pass
-            if "nrm" in f.opt:
-                self.mp_a_normal(ax, f) 
-            pass
-        elif MODE == 3:
-            pass
-            pvplt_add_contiguous_line_segments(pl, rpos )
-        pass 
-
-    def mp_plab(self, ax, f, backgroundcolor=None ):
-        """
-        point labels
-        """
-        r = f.r
-        a = f.a 
-        ast = f.ast
-        hv = r[:,0,(H,V)]
-
-        if backgroundcolor == None:
-            backgroundcolor = os.environ.get("BGC", None)
-        pass
-        for i in range(len(r)):
-
-            if "idx" in f.opt:
-                plab = str(i)
-            elif "ast" in f.opt:
-                plab = chr(ast[i])
-            else:
-                plab = None
-            pass 
-            if plab is None: continue
-
-            dx,dy = 0,0
-
-            if "pdy" in f.opt: dy = 10
-            if "ndy" in f.opt: dy = -10
-
-            print("mp_plab: f.opt %s %10.4f %10.4f " % (f.opt, dx, dy))
-
-            if backgroundcolor is None:
-                ax.text(dx+hv[i,0],dy+hv[i,1], plab, fontsize=15 )
-            else:
-                ax.text(dx+hv[i,0],dy+hv[i,1], plab, fontsize=15, backgroundcolor=backgroundcolor )
-            pass
-            ## POINT-BY-POINT LABELS
-        pass
-
-
-
-    def mp_a_normal(self, ax, f):
-        """
-        Access customBoundaryStatus char 
-
-        t.aux[261,:32,1,3].copy().view(np.int8)[::4].copy().view("|S32")
-
-        """
-        if not hasattr(f,'r'): return
-        if not hasattr(f,'a'): return
-        if f.r is None: return
-
-        r = f.r 
-        a = f.a 
-        sc = float(os.environ.get("NRM","80"))
-        #cbs = a[:len(a),1,3].copy().view(np.int8)[::4]
-        #assert len(cbs) == len(a)
-
-        ast = f.ast 
-        assert len(ast) == len(a) == len(r)
-
-
-        for i in range(len(a)):
-            nrm = a[i,3,:3]  
-            pos = r[i,0,:3]   
-            npos = pos - sc*nrm/2
-            #mpplt_add_line(ax, pos-sc*nrm, pos+sc*nrm, AXES )   
-            ax.arrow( npos[H], npos[V], sc*nrm[H], sc*nrm[V], head_width=10, head_length=10, fc='k', ec='k' )
-        pass
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    fold = SFOLD if not SFOLD is None else FOLD
-
-    log.info(" -- U4SimtraceSimpleTest.Load FOLD/SFOLD fold:%s" % fold  )
-    s = U4SimtraceSimpleTest.Load(fold, symbol="s")    # mandatory first geometry 
-    assert not s is None
-
-
-    log.info(" -- U4SimtraceSimpleTest.Load TFOLD" )
-    t = U4SimtraceSimpleTest.Load(TFOLD, symbol="t")   # optional second geometry 
-    ## SFOLD, TFOLD and s, t correspond to intersection geometries from U4SimtraceTest
-
-
-    log.info(" -- SEvt.Load AFOLD" )
-    a = SEvt.Load(AFOLD, symbol="a")   # optional photon histories 
-    log.info(" -- SEvt.Load BFOLD" )
-    b = SEvt.Load(BFOLD, symbol="b")
-    ## AFOLD, BFOLD and a, b are photon histories from SEvt 
-
-    if not a is None: print('a',a.qtab_,"\n",a.qtab)
-    if not b is None: print('b',b.qtab_,"\n",b.qtab)
-
-
-    pl = plotter(label="U4SimtraceSimpleTest.py")  # MODE:2 (fig,ax)  MODE:3 pv plotter
-
-    if not pl is None:
-        s.geoplot(pl)
-        if not t is None: t.geoplot(pl)
-
-        s.onephotonplot(pl, a)   # must set APID to int index of photon for this to do anything
-        s.onephotonplot(pl, b)   # must set BPID to int index of photon for this to do anything
-
-        s.show(pl)
-    pass 
-
-
-
-pass
-
-
-
diff --git a/u4/tests/U4SimtraceSimpleTest.sh b/u4/tests/U4SimtraceSimpleTest.sh
deleted file mode 100755
index 9ab4b133b6..0000000000
--- a/u4/tests/U4SimtraceSimpleTest.sh
+++ /dev/null
@@ -1,125 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-U4SimtraceSimpleTest.sh
-=========================
-
-Split from U4SimtraceTest.sh as that has PMTSim_standalone complications
-
-Uses U4SimtraceSimpleTest.cc which creates Geant4 geometry
-with U4VolumeMaker::PV depending on GEOM envvar
-and scans the geometry using U4SimtraceSimpleTest::scan
-saving the intersects into the folder configured with FOLD envvar.
-
-
-Commands
------------
-
-run/dbg
-    simtrace intersects against geometry
-ana
-    presentation of simtrace intersects using python matplotlib OR pyvista
-mpcap/pvcap
-    screenshot current matplotlib/pyvista window with chrome cropped
-mppub/pvpub
-    publication by copying matplotlib/pyvista screenshot png into presentation tree
-
-
-
-P[blyth@localhost tests]$ l $TMP/GEOM/RaindropRockAirWater/U4SimtraceSimpleTest/*_solid/B000/simtrace.npy
-198752 -rw-rw-r--. 1 blyth blyth 203520128 Apr  3 17:26 /data/blyth/opticks/GEOM/RaindropRockAirWater/U4SimtraceSimpleTest/VACUUM_solid/B000/simtrace.npy
-198752 -rw-rw-r--. 1 blyth blyth 203520128 Apr  3 17:26 /data/blyth/opticks/GEOM/RaindropRockAirWater/U4SimtraceSimpleTest/G4_Pb_solid/B000/simtrace.npy
-198752 -rw-rw-r--. 1 blyth blyth 203520128 Apr  3 17:26 /data/blyth/opticks/GEOM/RaindropRockAirWater/U4SimtraceSimpleTest/G4_AIR_solid/B000/simtrace.npy
-198752 -rw-rw-r--. 1 blyth blyth 203520128 Apr  3 17:26 /data/blyth/opticks/GEOM/RaindropRockAirWater/U4SimtraceSimpleTest/G4_WATER_solid/B000/simtrace.npy
-P[blyth@localhost tests]$ 
-
-P[blyth@localhost tests]$ cat /data/blyth/opticks/GEOM/RaindropRockAirWater/U4SimtraceSimpleTest/0/trs_names.txt 
-VACUUM_solid
-G4_Pb_solid
-G4_AIR_solid
-G4_WATER_solid
-
-
-EOU
-}
-
-cd $(dirname $(realpath $BASH_SOURCE))
-
-DIR=$PWD
-bin=U4SimtraceSimpleTest
-geom=RaindropRockAirWater
-evt=000
-eye=0,1000,0   # +Y 1000mm
-
-#cegs=16:0:9:1000   # default used from SFrameGenstep::MakeCenterExtentGensteps
-cegs=16:0:9:5000    # increase photon count for more precise detail
-
-#export GEOM=${GEOM:-$geom}
-export GEOM=$geom
-
-tmp=/tmp/$USER/opticks
-export TMP=${TMP:-$tmp}
-
-export BASE=$TMP/GEOM/$GEOM/$bin
-export FOLD=$BASE   ## controls where the U4SimtraceSimpleTest.cc writes trs
-
-export EVT=${EVT:-$evt}
-export EYE=${EYE:-$eye}       # not extent scaled, just mm
-export CEGS=${CEGS:-$cegs}
-export CEHIGH_0=-1:1:0:0:7:8:1000:4
-
-
-logging()
-{
-   type $FUNCNAME
-   export U4VolumeMaker=INFO
-}
-[ -n "$LOG" ] && logging
-
-
-log=$bin.log
-
-defarg="run_ana"
-arg=${1:-$defarg}
-
-
-if [ "${arg/info}" != "$arg" ]; then
-    vv="arg defarg GEOM FOLD"
-    for v in $vv ; do printf "%20s : %s \n" "$v" "${!v}" ; done
-fi 
-
-if [ "${arg/run}" != "$arg" ]; then
-    [ -f "$log" ] && rm $log
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1
-    [ -f "$log" ] && echo $BASH_SOURCE rename log $log to logN $logN && mv $log $logN
-fi
-
-if [ "${arg/dbg}" != "$arg" ]; then
-    [ -f "$log" ] && rm $log
-    source $DIR/../../bin/dbg__.sh
-    dbg__ $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE dbg error && exit 2
-fi
-
-if [ "${arg/ana}" != "$arg"  ]; then
-    [ "$arg" == "nana" ] && export MODE=0
-    ${IPYTHON:-ipython} --pdb -i $DIR/$bin.py
-    [ $? -ne 0 ] && echo $BASH_SOURCE ana error && exit 3
-fi
-
-if [ "$arg" == "pvcap" -o "$arg" == "pvpub" -o "$arg" == "mpcap" -o "$arg" == "mppub" ]; then
-    export CAP_BASE=$FOLD/figs
-    export CAP_REL=U4SimtraceSimpleTest
-    export CAP_STEM=$GEOM
-    case $arg in
-       pvcap) source pvcap.sh cap  ;;
-       mpcap) source mpcap.sh cap  ;;
-       pvpub) source pvcap.sh env  ;;
-       mppub) source mpcap.sh env  ;;
-    esac
-    if [ "$arg" == "pvpub" -o "$arg" == "mppub" ]; then
-        source epub.sh
-    fi
-fi
-
-exit 0
diff --git a/u4/tests/U4SimtraceTest.py b/u4/tests/U4SimtraceTest.py
deleted file mode 100644
index 8804a8ac40..0000000000
--- a/u4/tests/U4SimtraceTest.py
+++ /dev/null
@@ -1,475 +0,0 @@
-#!/usr/bin/env python
-"""
-U4SimtraceTest.py
-====================
-
-envvars
----------
-
-FOLD, SFOLD
-    mandatory first geometry 
-TFOLD
-    optional second geometry  
-AFOLD
-    optional first simulation photon histories
-BFOLD
-    optional second simulation photon histories
-
-"sibling" classes
---------------------
-
-U4SimtraceTest
-   intersection geometry  
-
-SEvt
-   photon histories 
-
-"""
-import os, logging, numpy as np
-log = logging.getLogger(__name__)
-
-from collections import OrderedDict as odict 
-from opticks.ana.fold import Fold
-from opticks.ana.pvplt import *
-from opticks.ana.p import * 
-from opticks.ana.eget import eintarray_, efloatarray_
-from opticks.sysrap.sevt import SEvt 
-
-
-COLORS = "red green blue cyan magenta yellow pink orange purple lightgreen".split()
-GCOL = "grey"
-
-TIGHT = int(os.environ.get("TIGHT", "0")) == 1 
-SZ = float(os.environ.get("SZ",3))
-REVERSE = int(os.environ.get("REVERSE","0")) == 1
-size = np.array([1280, 720])
-X,Y,Z = 0,1,2
-
-
-# use eg FOCUS=0,0,100 to select part of view with aspect ratio preserved
-#XLIM=efloatarray_("XLIM","0,0")
-#YLIM=efloatarray_("YLIM","0,0")
-
-FOLD = os.environ.get("FOLD", None)
-SFOLD = os.environ.get("SFOLD", None)
-TFOLD = os.environ.get("TFOLD", None)
-AFOLD = os.environ.get("AFOLD", None)
-BFOLD = os.environ.get("BFOLD", None)
-
-N = int(os.environ.get("VERSION","-1")) 
-GEOM = os.environ.get("GEOM", "DummyGEOM")
-GEOMList = os.environ.get("%s_GEOMList" % GEOM, "DummyGEOMList") 
-FOCUS = os.environ.get("FOCUS", "")
-
-APID = int(os.environ.get("APID", -1 ))
-BPID = int(os.environ.get("BPID", -1 ))
-AOPT = os.environ.get("AOPT", "")
-BOPT = os.environ.get("BOPT", "")
-
-
-
-topline = "N=%d " % N
-
-if len(FOCUS) > 0:
-   topline += " FOCUS=%s " % FOCUS
-pass
-
-
-if APID > -1: topline += "APID=%d " % APID
-if len(AOPT) > 0: topline += "AOPT=%s " % AOPT
-
-if BPID > -1: topline += "BPID=%d " % BPID
-if len(BOPT) > 0: topline += "BOPT=%s " % BOPT
-
-topline += " ./U4SimtraceTest.sh ana   # %s/%s " % (GEOM, GEOMList)
-
-TOPLINE = os.environ.get("TOPLINE",topline )
-BOTLINE = os.environ.get("BOTLINE","%s" % SFOLD )
-THIRDLINE = os.environ.get("THIRDLINE", "APID:%d BPID:%d " % (APID,BPID) )
-
-AXES = np.array(list(map(int,os.environ.get("AXES","0,2").split(","))), dtype=np.int8 )
-H,V = AXES
-
-log = logging.getLogger(__name__)
-np.set_printoptions(suppress=True, edgeitems=5, linewidth=200,precision=3)
-
-
-class U4SimtraceTest(object):
-    """
-    MAYBE: come up with a better name for this and relocate into ana or SysRap for reuse
-    ACTUALLY this is using trs names, so its not as general as first thought ... 
-    it is limited to small test geometries. 
-
-    The more general GPU simtrace deserves more attention than this one.
-
-    HMM: there are developments elsewhere that are close to this, MAYBE: consolidate
-    """
-    @classmethod
-    def Load(cls, fold, **kwa):
-        if fold is None: return None
-        if int(kwa.get("NEVT",0)) > 0:
-            f = Fold.LoadConcat(fold,**kwa) 
-        else:
-            f = Fold.Load(fold, **kwa )
-        pass
-        return None if f is None else cls(f)
-
-
-    def __repr__(self):
-        return "U4SimtraceTest %s:%s " % (self.symbol, self.fold.base)
-
-    def __init__(self, fold):
-        """
-        Note the container fold Loads subfold for each of the trs_names 
-        """
-        trs_names = np.loadtxt( os.path.join(fold.base, "trs_names.txt"), dtype=np.object )
-
-        sfs = odict()
-        for i, name in enumerate(trs_names):
-            sfs[name] = Fold.Load(fold.base, name,"p001",  symbol="%s%0.2d" % (fold.symbol,i) )
-        pass  # Fold for each solid 
-
-        symbol = fold.symbol
-
-        kvol = "%sVOL" % symbol.upper()
-        vol = eintarray_(kvol)
-
-        self.fold = fold 
-        self.trs_names = trs_names
-        self.sfs = sfs
-        self.opp = []
-        self.kvol = kvol 
-        self.vol = vol 
-        self.symbol = symbol
-
-    def geoplot(self, pl):
-        """
-        :param pl: either tuple of (fig,ax) for MODE 2 or pyvista pl for MODE 3
-        """
-        fig, ax = None, None
-        if MODE == 2:
-            fig, axs = pl
-            assert len(axs) == 1 
-            ax = axs[0]
-        elif MODE == 2:
-            pass
-        pass 
-
-        trs = self.fold.trs
-        trs_names = self.trs_names
-        sfs = self.sfs
-        vol = self.vol
-        kvol = self.kvol
-
-        vsel = len(vol) > 0   # selecting volumes by index from eg SVOL envvar
-        num = len(trs_names)
-
-        if vsel:
-            print("mp_geoplot : volume selection %s vol %s num %d " % (kvol, str(vol), num )) 
-        pass
-
-        for j in range(num):
-            i = num - 1 - j  if REVERSE else j
-
-            soname = trs_names[i] ## solid name for every transform, lots of repeated solid names 
-
-            if vsel:
-                if i in vol: 
-                    print(" %s PROCEED i %d soname %s " % (kvol, i, soname)) 
-                else:
-                    print(" %s SKIP    i %d soname %s " % (kvol, i, soname)) 
-                    continue
-                pass
-            pass
-
-            sf = sfs[soname]
-
-            if not getattr(sf, 'simtrace', None) is None:
-                _lpos = sf.simtrace[:,1].copy()
-                _lpos[:,3] = 1
-            else:
-                 print("missing simtrace for soname:%s " % soname)
-                 continue
-            pass
-
-            gspo = sf.genstep[:,5,:3]
-            if "GENSTEP" in os.environ:
-                if MODE == 2:
-                    ax.scatter( gspo[:,H], gspo[:,V], s=SZ, color="black" )
-                elif MODE == 3:
-                    pl.add_points( gspo[:,:3], color=color, label=label)  
-                pass
-            pass
-            
-
-            tr = np.float32(trs[i])
-            tr[:,3] = [0,0,0,1]   ## fixup 4th column, as may contain identity info
-
-            dori = np.sqrt(np.sum(_lpos[:,:3]*_lpos[:,:3],axis=1))
-            lpos = _lpos[dori>0]    # exclude points at local origin, misses 
-
-            gpos = np.dot( lpos, tr )
-            pass
-            color = COLORS[ i % len(COLORS)]
-
-            label = str(soname)
-            if label[0] == "_": label = label[1:]   # seems labels starting "_" have special meaning to mpl, causing problems
-            label = label.replace("solid","s")
-
-            if MODE == 2:
-                ax.scatter( gpos[:,H], gpos[:,V], s=SZ, color=color, label=label )
-            elif MODE == 3:
-                pl.add_points( gpos[:,:3], color=color, label=label)  
-            pass
-        pass
-
-        if MODE == 2:
-            xlim, ylim = mpplt_focus_aspect()
-            if not xlim is None:
-                ax.set_xlim(xlim) 
-                ax.set_ylim(ylim) 
-            else:
-                log.info("mpplt_focus_aspect not enabled, use eg FOCUS=0,0,100 to enable ")
-            pass 
-
-            if 'POINT' in os.environ: # ADD POINT OR POINTS SPECIFIED BY TRIPLETS 
-                point = efloatarray_("POINT", "0,0,0").reshape(-1,3)
-                ax.scatter( point[:,H], point[:,V], s=SZ, color="red", label="POINT" )
-            pass
-
-            if 'LINE' in os.environ:
-                line = efloatarray_("LINE", "1,2,3,10,20,30,100,200,300").reshape(-1,3)
-                ax.plot( line[:,H], line[:,V], "ro-" )
-            pass
-
-            if TIGHT:
-                ax.axis('off')
-                fig.tight_layout()
-            pass
-
-        elif MODE == 3:
-            pass
-        pass
-
-
-    def show(self, pl ):
-        if MODE == 2:
-            self.mp_show(pl)
-        elif MODE == 3:
-            self.pv_show(pl)
-        pass
-  
-    def pv_show(self, pl):
-        cp = pl.show()
-        print(cp)
-
-    def mp_show(self, pl): 
-
-        fig, axs = pl
-        assert len(axs) == 1 
-        ax = axs[0]
-
-        #ax.set_xlim(-60,60)  # use FOCUS=0,0,100
-        #ax.set_ylim(-100,100)
-
-        locs = ["upper left","lower left", "upper right"]
-        LOC = os.environ.get("LOC",locs[0])
-        print("LOC : %s " % LOC)
-        if LOC == "skip" or LOC == "":
-            print("skip legend as LOC:[%s] " % LOC)
-        else:
-            ax.legend(loc=LOC,  markerscale=4)
-        pass
-
-        thirdline = ""
-        subtitle = ""
-
-        num_opp = len(self.opp)
-
-        if num_opp == 2:
-            a,b = self.opp
-            thirdline = a.label 
-            subtitle  = b.label
-        else:
-            ## eg "TO BT SA\n00 01 02"
-            for one in self.opp:
-                print("one.label:%s " % one.label)
-                thirdline += one.label 
-            pass 
-        pass
-
-        subtitle = os.environ.get("SUBTITLE", "")
-        print("mp_show num_opp:%d subtitle:%s " % (num_opp, subtitle) )
-        
-        # adjust the position of the title, to legibly display 4 lines      
-        TOF = float(os.environ.get("TOF","0.99")) 
-
-        #suptitle = "\n".join([TOPLINE,BOTLINE,thirdline]) 
-        suptitle = TOPLINE 
-
-
-        fig.suptitle(suptitle, family="monospace", va="top", y=TOF, fontweight='bold' )
-
-        hv_thirdline = efloatarray_("HV_THIRDLINE","-0.05,1.02") 
-        hv_subtitle = efloatarray_("HV_SUBTITLE","1.05,-0.12") 
-        assert len(hv_thirdline) == 2 
-        assert len(hv_subtitle) == 2 
-
-        ax.text( hv_thirdline[0],  hv_thirdline[1], thirdline, va='bottom', ha='left', family="monospace", fontsize=12, transform=ax.transAxes)
-        ax.text( hv_subtitle[0],  hv_subtitle[1], subtitle, va='bottom', ha='right', family="monospace", fontsize=12, transform=ax.transAxes)
-
-        print("mp_show suptitle:[%s]" % suptitle ) 
-        print("mp_show thirdline:[%s] HV_THIRDLINE:%s"  % (thirdline, str(hv_thirdline)) ) 
-        print("mp_show subtitle:[%s]  HV_SUBTITLE:%s"   % (subtitle,  str(hv_subtitle)) ) 
-
-        fig.show()
-
-    def onephotonplot(self, pl, f): 
-        """
-        :param pl:  plotting machinery 
-        :param f: expecting SEvt object with photon history, 
-                  NB pid must be set to +ve integer selecting the photon to plot anything  
-        """
-        if f is None: return 
-        if f.pid < 0: return
-
-        self.opp.append(f)
-
-        if not hasattr(f,'r'): return
-        if f.r is None: return
-
-        r = f.r 
-        off = f.off
-
-        rpos = r[:,0,:3] + off
-
-        if MODE == 2:
-            fig, axs = pl 
-            assert len(axs) == 1 
-            ax = axs[0]
-            if True:
-                mpplt_add_contiguous_line_segments(ax, rpos, axes=(H,V), label=None )
-                self.mp_plab(ax, f)
-            pass
-            if "nrm" in f.opt:
-                self.mp_a_normal(ax, f) 
-            pass
-        elif MODE == 3:
-            pass
-            pvplt_add_contiguous_line_segments(pl, rpos )
-        pass 
-
-    def mp_plab(self, ax, f, backgroundcolor=None ):
-        """
-        point labels
-        """
-        r = f.r
-        a = f.a 
-        ast = f.ast
-        hv = r[:,0,(H,V)]
-
-        if backgroundcolor == None:
-            backgroundcolor = os.environ.get("BGC", None)
-        pass
-        for i in range(len(r)):
-
-            if "idx" in f.opt:
-                plab = str(i)
-            elif "ast" in f.opt:
-                plab = chr(ast[i])
-            else:
-                plab = None
-            pass 
-            if plab is None: continue
-
-            dx,dy = 0,0
-
-            if "pdy" in f.opt: dy = 10
-            if "ndy" in f.opt: dy = -10
-
-            print("mp_plab: f.opt %s %10.4f %10.4f " % (f.opt, dx, dy))
-
-            if backgroundcolor is None:
-                ax.text(dx+hv[i,0],dy+hv[i,1], plab, fontsize=15 )
-            else:
-                ax.text(dx+hv[i,0],dy+hv[i,1], plab, fontsize=15, backgroundcolor=backgroundcolor )
-            pass
-            ## POINT-BY-POINT LABELS
-        pass
-
-
-
-    def mp_a_normal(self, ax, f):
-        """
-        Access customBoundaryStatus char 
-
-        t.aux[261,:32,1,3].copy().view(np.int8)[::4].copy().view("|S32")
-
-        """
-        if not hasattr(f,'r'): return
-        if not hasattr(f,'a'): return
-        if f.r is None: return
-
-        r = f.r 
-        a = f.a 
-        sc = float(os.environ.get("NRM","80"))
-        #cbs = a[:len(a),1,3].copy().view(np.int8)[::4]
-        #assert len(cbs) == len(a)
-
-        ast = f.ast 
-        assert len(ast) == len(a) == len(r)
-
-
-        for i in range(len(a)):
-            nrm = a[i,3,:3]  
-            pos = r[i,0,:3]   
-            npos = pos - sc*nrm/2
-            #mpplt_add_line(ax, pos-sc*nrm, pos+sc*nrm, AXES )   
-            ax.arrow( npos[H], npos[V], sc*nrm[H], sc*nrm[V], head_width=10, head_length=10, fc='k', ec='k' )
-        pass
-
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    fold = SFOLD if not SFOLD is None else FOLD
-
-    log.info(" -- U4SimtraceTest.Load FOLD/SFOLD fold:%s" % fold  )
-    s = U4SimtraceTest.Load(fold, symbol="s")    # mandatory first geometry 
-    assert not s is None
-
-
-    log.info(" -- U4SimtraceTest.Load TFOLD" )
-    t = U4SimtraceTest.Load(TFOLD, symbol="t")   # optional second geometry 
-    ## SFOLD, TFOLD and s, t correspond to intersection geometries from U4SimtraceTest
-
-
-    log.info(" -- SEvt.Load AFOLD" )
-    a = SEvt.Load(AFOLD, symbol="a")   # optional photon histories 
-    log.info(" -- SEvt.Load BFOLD" )
-    b = SEvt.Load(BFOLD, symbol="b")
-    ## AFOLD, BFOLD and a, b are photon histories from SEvt 
-
-    if not a is None: print('a',a.qtab_,"\n",a.qtab)
-    if not b is None: print('b',b.qtab_,"\n",b.qtab)
-
-
-    pl = plotter(label="U4SimtraceTest.py")  # MODE:2 (fig,ax)  MODE:3 pv plotter
-
-    if not pl is None:
-        s.geoplot(pl)
-        if not t is None: t.geoplot(pl)
-
-        s.onephotonplot(pl, a)   # must set APID to int index of photon for this to do anything
-        s.onephotonplot(pl, b)   # must set BPID to int index of photon for this to do anything
-
-        s.show(pl)
-    pass 
-
-
-
-pass
-
-
-
diff --git a/u4/tests/U4SimtraceTest.sh b/u4/tests/U4SimtraceTest.sh
deleted file mode 100755
index 4feb2699fe..0000000000
--- a/u4/tests/U4SimtraceTest.sh
+++ /dev/null
@@ -1,251 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-U4SimtraceTest.sh
-=====================
-
-Uses U4SimtraceTest.cc which creates Geant4 geometry
-with U4VolumeMaker::PV depending on GEOM envvar
-and scans the geometry using U4SimtraceTest::scan
-saving the intersects into the folder configured with FOLD envvar.
-
-In addition to plotting intersects showing geometry this 
-can also show photon paths from U4SimulateTest.
-
-
-
-FewPMT.sh/tub3LogicalPMT::
-
-    MODE=2 FOCUS=0,0,80 ~/opticks/u4/tests/U4SimtraceTest.sh ana
-
-    MODE=2 ~/opticks/u4/tests/U4SimtraceTest.sh
-
-TODO
-------
-
-* add metadata checks that plotted U4SimulateTest photons are from a geometry matching the U4SimtraceTest geometry
-
-
-Commands
------------
-
-run/dbg
-    simtrace intersects against geometry
-ana
-    presentation of simtrace intersects using python matplotlib OR pyvista
-mpcap/pvcap
-    screenshot current matplotlib/pyvista window with chrome cropped
-mppub/pvpub
-    publication by copying matplotlib/pyvista screenshot png into presentation tree
-
-
-Workflow to add plots to presentations
------------------------------------------
-
-1. check matplotlib window plot and annotations are presentable::
-
-     APID=2563 AOPT=idx N=0 SUBTITLE="7:SD at vac/vac" ./U4SimtraceTest.sh ana
-
-2. whilst some part of the matplotlib window is still visible, in a separate tab run::
-
-       u4t ; ./U4SimtraceTest.sh mpcap
-
-   * If capture environment depends on envvars make sure that is consistent with above command
-   * NB have to click on the matplotlib window (so it must be visible before running mpcap), that
-     turns it blue targetting the window screen capture
-
-3. publish that, coping the .png into presentation tree::
-
-     u4t ; PUB=2563_Unphysical_SD_in_vacuum ./U4SimtraceTest.sh mppub
-     ## ensure PUB is a distinct identifier
-
-4. reference the .png by copy/paste the "s5p_line" from the output of the above step
-   into ~/env/presentation/s5_background_image.txt (use presentation-e)
-   and reference that by adding a presentation page with matching title
-
-5. it is good to include the primary commandline from step 1 in the presentation, even if
-   not presented, in order to allow reproducing the plot
-
-
-
-Suggested Workflow To Find Photons to Compare and plot
---------------------------------------------------------
-
-Use two U4SimulateTest.sh sessions for N=0 and N=1::
-
-    u4t
-    N=0 POM=1 ./U4SimulateTest.sh    ## "a" in Simtrace session
-    N=1 POM=1 ./U4SimulateTest.sh    ## "b" in Simtrace session
-
-And a third U4SimtraceTest.sh session::
-
-    u4t
-    N=1 ./U4SimtraceTest.sh ana
-
-Check a and b in simtrace session::
-
-    In [1]: a.f.base, b.f.base
-    Out[1]:
-    ('/tmp/blyth/opticks/GEOM/FewPMT/U4SimulateTest/ALL0',
-     '/tmp/blyth/opticks/GEOM/FewPMT/U4SimulateTest/ALL1')
-
-Pick some APID, BPID expected to be similar by comparing
-histories as visible in the first two sessions (eg np.c_[np.arange(40),q[:40]] ).
-Use AOFF or BOFF to offset to make similar paths visible, eg AOFF=0,0,10
-Keep starting and stopping the third session as change APID, BPID (-ve disables)::
-
-    APID=17 BPID=7  N=1 ./U4SimtraceTest.sh ana
-
-Examples
------------
-
-::
-
-    N=0 ./U4SimtraceTest.sh
-    N=1 ./U4SimtraceTest.sh
-
-    APID=173 PLAB=1 BGC=yellow ./U4SimtraceTest.sh ana
-
-Z-changing big bouncers::
-
-    N=0 APID=256 PLAB=1 BGC=white ./U4SimtraceTest.sh ana
-    N=1 APID=261 PLAB=1 BGC=white ./U4SimtraceTest.sh ana
-
-Grab the custom boundary status for each point::
-
-    In [25]: t.aux[261,:32,1,3].copy().view(np.int8)[::4].copy().view("|S32")
-    Out[25]: array([b'TTTZNZRZNZA'], dtype='|S32')
-
-::
-
-    N=0 APID=726 BPID=-1 AOPT=nrm FOCUS=0,10,185 ./U4SimtraceTest.sh ana
-    N=1 APID=-1 BPID=726 BOPT=nrm FOCUS=0,10,185 ./U4SimtraceTest.sh ana
-
-
-two_pmt::
-
-    FOCUS=0,0,255 ./U4SimtraceTest.sh ana
-
-    N=0 APID=813 AOPT=idx BGC=yellow FOCUS=0,0,255 ./U4SimtraceTest.sh ana
-    N=0 APID=813 AOPT=ast BGC=yellow FOCUS=0,0,255 ./U4SimtraceTest.sh ana
-
-    N=1 BPID=748 BOPT=ast,nrm BGC=yellow FOCUS=0,0,255 ./U4SimtraceTest.sh ana
-    N=1 BPID=150 BOPT=nrm,ast BGC=yellow FOCUS=0,0,255 ./U4SimtraceTest.sh ana
-
-
-MODE 3 pyvista 3D plotting::
-
-    MODE=3 EYE=0,-1000,0 LOOK=0,0,0 UP=0,0,1 ./U4SimtraceTest.sh ana
-
-Questions
------------
-
-Q: Where is the N envvar to control natural geometry acted upon ?
-A: j/PMTSim/IGeomManager.h:IGeomManager::declProp interprets envvar to set values::
-
-    epsilon:tests blyth$ grep UseNaturalGeometry *.*
-    FewPMT.sh:export hama_UseNaturalGeometry=$version
-    FewPMT.sh:export nnvt_UseNaturalGeometry=$version
-
-
-Q: Where is the SEventConfig::IsRGModeSimtrace flipped ?
-
-
-EOU
-}
-
-DIR=$(dirname $BASH_SOURCE)
-bin=U4SimtraceTest
-apid=-1
-bpid=-1
-geom=FewPMT
-evt=000
-eye=0,1000,0   # +Y 1000mm
-
-#cegs=16:0:9:1000   # default used from SFrameGenstep::MakeCenterExtentGensteps
-cegs=16:0:9:5000    # increase photon count for more precise detail
-
-export VERSION=${N:-0}
-export GEOM=${GEOM:-$geom}
-
-tmp=/tmp/$USER/opticks
-export TMP=${TMP:-$tmp}
-
-export GEOMFOLD=$TMP/GEOM/$GEOM
-export BASE=$GEOMFOLD/$bin
-
-export FOLD=$BASE/$VERSION   ## controls where the U4SimtraceTest.cc executable writes intersects
-
-export EVT=${EVT:-$evt}
-export AFOLD=$GEOMFOLD/U4SimulateTest/ALL0/$EVT
-export BFOLD=$GEOMFOLD/U4SimulateTest/ALL1/$EVT   # SEL1 another possibility
-export APID=${APID:-$apid}                        # APID for photons from ALL0
-export BPID=${BPID:-$bpid}                        # BPID for photons from ALL1
-
-export EYE=${EYE:-$eye}       # not extent scaled, just mm
-export CEGS=${CEGS:-$cegs}
-export CEHIGH_0=-1:1:0:0:7:8:1000:4
-
-
-geomscript=$DIR/$GEOM.sh
-if [ -f "$geomscript" ]; then
-    source $geomscript
-else
-    echo $BASH_SOURCE : no geomscript $geomscript
-fi
-
-# GEOMList for the GEOM is set for example in the FewPMT.sh geomscript
-_GEOMList=${GEOM}_GEOMList
-GEOMList=${!_GEOMList}
-
-echo $BASH_SOURCE GEOMList : $GEOMList
-
-
-logging()
-{
-   type $FUNCNAME
-   export U4VolumeMaker=INFO
-}
-[ -n "$LOG" ] && logging
-
-
-log=${bin}.log
-logN=${bin}_$VERSION.log
-
-defarg="run_ana"
-arg=${1:-$defarg}
-
-if [ "${arg/run}" != "$arg" ]; then
-    [ -f "$log" ] && rm $log
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1
-    [ -f "$log" ] && echo $BASH_SOURCE rename log $log to logN $logN && mv $log $logN
-fi
-
-if [ "${arg/dbg}" != "$arg" ]; then
-    [ -f "$log" ] && rm $log
-    dbg__ $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE dbg error && exit 2
-fi
-
-if [ "${arg/ana}" != "$arg"  ]; then
-    [ "$arg" == "nana" ] && export MODE=0
-    ${IPYTHON:-ipython} --pdb -i $DIR/$bin.py
-    [ $? -ne 0 ] && echo $BASH_SOURCE ana error && exit 3
-fi
-
-if [ "$arg" == "pvcap" -o "$arg" == "pvpub" -o "$arg" == "mpcap" -o "$arg" == "mppub" ]; then
-    export CAP_BASE=$FOLD/figs
-    export CAP_REL=U4SimtraceTest
-    export CAP_STEM=$GEOM
-    case $arg in
-       pvcap) source pvcap.sh cap  ;;
-       mpcap) source mpcap.sh cap  ;;
-       pvpub) source pvcap.sh env  ;;
-       mppub) source mpcap.sh env  ;;
-    esac
-    if [ "$arg" == "pvpub" -o "$arg" == "mppub" ]; then
-        source epub.sh
-    fi
-fi
-
-exit 0
diff --git a/u4/tests/U4SimtraceTest_one_pmt.sh b/u4/tests/U4SimtraceTest_one_pmt.sh
deleted file mode 100755
index c592c77501..0000000000
--- a/u4/tests/U4SimtraceTest_one_pmt.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash -l 
-
-arg=${1:-ana}
-
-LAYOUT=one_pmt
-N=${N:-1}
-
-export TOPLINE="N=$N LAYOUT=$LAYOUT FOCUS=0,10,185 ./U4SimtraceTest.sh"
-TOPLINE="$TOPLINE $arg"
-eval $TOPLINE
-
-
diff --git a/u4/tests/U4SimtraceTest_two_pmt.sh b/u4/tests/U4SimtraceTest_two_pmt.sh
deleted file mode 100755
index d07b080235..0000000000
--- a/u4/tests/U4SimtraceTest_two_pmt.sh
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/bin/bash -l 
-
-arg=${1:-ana}
-
-sym=A
-SYM=${SYM:-$sym}
-
-case $SYM in 
-  A) N=0 ;;
-  B) N=1 ;;
-esac
-
-if [ "$SYM" == "A" ]; then 
-
-  pid=813
-
-elif [ "$SYM" == "B" ]; then 
-
-  #pid=748
-  pid=892
-
-fi 
-
-
-#opt=ast,nrm
-opt=idx,nrm
-
-
-
-export TOPLINE="N=$N ${SYM}PID=$pid ${SYM}OPT=$opt BGC=yellow FOCUS=0,0,255 ./U4SimtraceTest.sh"
-TOPLINE="$TOPLINE $arg"
-eval $TOPLINE
-
-
diff --git a/u4/tests/U4SimtraceTest_two_pmt_cf.sh b/u4/tests/U4SimtraceTest_two_pmt_cf.sh
deleted file mode 100755
index f16ba8ea23..0000000000
--- a/u4/tests/U4SimtraceTest_two_pmt_cf.sh
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/bash -l 
-usage(){ cat << EOU
-U4SimtraceTest_two_pmt_cf.sh
-==============================
-
-Melange : presenting two photons A,B from two geometries S,T 
-
-Uses SVOL, TVOL to select volumes to present:
-
-* SVOL : N=0 PMT on left 
-* TVOL : N=1 PMT on right 
-
-
-
-EOU
-}
-
-arg=${1:-ana}
-
-N=1
-
-apid=-973
-bpid=-903
-
-opt=ast,nrm
-#opt=idx,nrm
-
-
-export SVOL=0,1,13:24
-export TVOL=2:11
-
-# ndy/pdy : to offset the labels
-
-export TOPLINE="N=$N APID=$apid AOPT=$opt BPID=$bpid BOPT=$opt BGC=yellow FOCUS=0,0,255 ./U4SimtraceTest.sh"
-TOPLINE="$TOPLINE $arg"
-eval $TOPLINE
-
-
diff --git a/u4/tests/U4SimulateTest.sh b/u4/tests/U4SimulateTest.sh
deleted file mode 100755
index cb7bca0f02..0000000000
--- a/u4/tests/U4SimulateTest.sh
+++ /dev/null
@@ -1,323 +0,0 @@
-#!/bin/bash -l 
-usage(){ cat << EOU
-U4SimulateTest.sh
-===================
-
-Covering the PMT*POM quadrants (POM:PMT Optical Model)::
-
-    u4t
-
-    N=0 POM=0 ./U4SimulateTest.sh   # unnatural geom , traditional POM 
-    N=1 POM=0 ./U4SimulateTest.sh   # natural geom   , traditional POM
-
-    N=0 POM=1 ./U4SimulateTest.sh   # unnatural geom , multifilm POM 
-    N=1 POM=1 ./U4SimulateTest.sh   # natural geom   , multifilm POM
-
-
-Analysis loading saved results::
-
-    PID=726 ./U4SimulateTest.sh nana
-
-    N=1 MODE=0 ./U4SimulateTest.sh ph  # no GUI with NumPy 
-    N=1 MODE=2 ./U4SimulateTest.sh ph  # 2D GUI with matplotlib
-    N=1 MODE=3 ./U4SimulateTest.sh ph  # 3D GUI with pyvista
-
-
-Rerunning single photons off the same g4state is a bit delicate to arrange.
-This incantation succeeds to rerun the N=0 big bouncer with N=1::
-
-     u4t                       ## cd ~/opticks/u4/tests
-
-     vi U4SimulateTest.sh      ## switch to running_mode=SRM_G4STATE_SAVE
-
-     N=0 ./U4SimulateTest.sh   ## saves g4state into /tmp/blyth/opticks/GEOM/hamaLogicalPMT/U4SimulateTest/ALL0
-
-     vi U4SimulateTest.sh      ## switch to running_mode=SRM_G4STATE_RERUN for PID 726 
-    
-     N=1 ./U4SimulateTest.sh   ## saves to /tmp/blyth/opticks/GEOM/hamaLogicalPMT/U4SimulateTest/SEL1
-
-
-After that can compare timings::
-
-    ./U4SimulateTest.sh cf 
-
-EOU
-}
-
-DIR=$(cd $(dirname $BASH_SOURCE) && pwd)
-bin=U4SimulateTest
-
-
-export VERSION=${N:-0}
-source $HOME/.opticks/GEOM/GEOM.sh  # set GEOM : this script was used for FewPMT tests
-origin=$HOME/.opticks/GEOM/$GEOM/origin.gdml
-if [ -f "$origin" ]; then
-   export ${GEOM}_GDMLPathFromGEOM=$origin
-fi 
-
-
-
-
-
-geomscript=$DIR/$GEOM.sh 
-
-if [ -f "$geomscript" ]; then  
-    source $geomscript
-else
-    echo $BASH_SOURCE : no geomscript $geomscript
-fi 
-
-## moved LAYOUT and FAKES control inside geomscript so its in common 
-## between U4SimulateTest.sh and U4SimtraceTest.sh 
-## makes sense for everything that is very GEOM specific to be within the geomscript
-
-_GEOMList=${GEOM}_GEOMList
-GEOMList=${!_GEOMList}
-
-
-export BASE=/tmp/$USER/opticks/GEOM/$GEOM/$bin
-
-## process DISABLE/ENABLE controlling u4/tests/U4Physics.cc U4Physics::ConstructOp
-export Local_G4Cerenkov_modified_DISABLE=1
-export Local_DsG4Scintillation_DISABLE=1
-#export G4OpAbsorption_DISABLE=1
-#export G4OpRayleigh_DISABLE=1
-#export G4OpBoundaryProcess_DISABLE=1
-
-export U4App__PRIMARY_MODE=torch  # hmm seems iphoton and torch do same thing internally 
-export BeamOn=${BeamOn:-1}
-export U4Recorder__PIDX_ENABLED=1 
-#export U4Recorder__UserSteppingAction_Optical_ClearNumberOfInteractionLengthLeft=1  ## makes easier to randmn align 
-
-
-
-evt=n001
-export EVT=${EVT:-$evt}       # used for FOLD envvars
-
-
-
-
-# python ana level presentation 
-export LOC=skip
-
-log=${bin}.log
-logN=${bin}_$VERSION.log
-
-#num_photons=1
-#num_photons=10
-#num_photons=100
-#num_photons=1000      # 1k
-num_photons=10000    # 10k
-#num_photons=50000    # 50k 
-#num_photons=100000   # 100k
-#num_photons=1000000  # 1M
-
-NUM_PHOTONS=${NUM_PHOTONS:-$num_photons}
-
-if [ -n "$RERUN" ]; then 
-   export OPTICKS_G4STATE_RERUN=$RERUN
-   running_mode=SRM_G4STATE_RERUN
-else
-   running_mode=SRM_G4STATE_SAVE  
-fi 
-
-case $running_mode in 
-   SRM_G4STATE_SAVE)  reldir=ALL$VERSION ;; 
-   SRM_G4STATE_RERUN) reldir=SEL$VERSION ;; 
-esac
-
-## sysrap/SEventConfig 
-export OPTICKS_RUNNING_MODE=$running_mode   # see SEventConfig::RunningMode
-export OPTICKS_MAX_BOUNCE=31                # can go upto 31 now that extended sseq.h 
-export OPTICKS_EVENT_MODE=DebugLite
-export OPTICKS_G4STATE_SPEC=${NUM_PHOTONS}:38       # default is only 1000:38 to keep state files small 
-
-export SEvent_MakeGenstep_num_ph=${NUM_PHOTONS}
-source $DIR/storch_FillGenstep.sh 
-
-
-loglevel(){
-   export U4VolumeMaker=INFO
-   export U4Recorder=INFO
-   export U4Physics=INFO
-   export junoPMTOpticalModel=INFO
-   export junoPMTOpticalModelSimple=INFO
-   #export SEvt=INFO     ## thus is exceedingly verbose
-   export SEventConfig=INFO
-   export ShimG4OpAbsorption=INFO
-   export ShimG4OpRayleigh=INFO
-}
-
-
-if [ "$running_mode" == "SRM_G4STATE_RERUN" ]; then 
-   echo $BASH_SOURCE : switch on logging when doing single photon RERUN
-   loglevel  
-else
-   #echo $BASH_SOURCE : switch on some logging anyhow : THIS WILL BE VERBOSE
-   #export junoPMTOpticalModel=INFO
-
-   export U4Physics=INFO
-   export U4Recorder=INFO
-   #export SEvt=INFO
-fi 
-
-
-if [ -n "$SIMTRACE" ]; then
-   export U4Recorder__EndOfRunAction_Simtrace=1  
-   export SFrameGenstep=INFO
-fi 
-
-
-## analysis modes beginning with n: nfs/ncf/naf/nph are NumPy only (without matplotlib and pyvista)
-## envout is used to communicate from some python scripts back into this bash script 
-## this only makes sense for single N=0, N=1 running 
-
-export ENVOUT=/tmp/$USER/opticks/U4SimulateTest/envout.sh
-mkdir -p $(dirname $ENVOUT)
-
-export FOLD=$BASE/$reldir/$EVT
-export AFOLD=$BASE/ALL0/$EVT     ## for comparisons 
-export BFOLD=$BASE/ALL1/$EVT
-
-
-
-
-vars="BASH_SOURCE GEOM _GEOMList GEOMList BASE EVT FOLD NUM_PHOTONS script"
-
-
-
-
-
-
-
-
-
-
-defarg="run_ph"
-#defarg="run_mt"
-[ -n "$BP" ] && defarg="dbg"
-
-arg=${1:-$defarg}
-[ "${arg:0:1}" == "n" ] && export MODE=0
-
-if [ "${arg/fs}" != "$arg" -o "${arg/nfs}" != "$arg" ]; then
-    script=$DIR/${bin}_fs.py  
-elif [ "${arg/cf}" != "$arg" -o "${arg/ncf}" != "$arg" ]; then
-    script=$DIR/${bin}_cf.py 
-elif [ "${arg/af}" != "$arg" -o "${arg/naf}" != "$arg" ]; then
-    script=$DIR/${bin}_af.py 
-elif [ "${arg/ph}" != "$arg" -o "${arg/nph}" != "$arg" ]; then
-    script=$DIR/${bin}_ph.py 
-elif [ "${arg/mt}" != "$arg" -o "${arg/nmt}" != "$arg" ]; then
-    script=$DIR/${bin}_mt.py 
-elif [ "${arg/fk}" != "$arg" -o "${arg/nfk}" != "$arg" ]; then
-    script=$DIR/${bin}_fk.py 
-elif [ "${arg/ck}" != "$arg" -o "${arg/nck}" != "$arg" ]; then
-    script=$DIR/${bin}_ck.py 
-elif [ "${arg/pr}" != "$arg" -o "${arg/npr}" != "$arg" ]; then
-    script=$DIR/${bin}_pr.py 
-elif [ "${arg/tt}" != "$arg" -o "${arg/ntt}" != "$arg" ]; then
-    script=$OPTICKS_HOME/sysrap/sevt_tt.py 
-elif [ "${arg/__}" != "$arg" -o "${arg/n__}" != "$arg" ]; then
-    script=$DIR/${bin}.py 
-fi 
-
-
-if [ "${arg/info}" != "$arg" ]; then
-    for var in $vars ; do printf "%-30s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/run}" != "$arg" ]; then
-    [ -f "$log" ] && rm $log 
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1 
-    [ -f "$log" ] && echo $BASH_SOURCE rename log $log to logN $logN && mv $log $logN    
-fi 
-
-
-if [ "$arg" == "dbg" ]; then
-   bp=MixMaxRng::flat
-   #bp="$bp G4OpBoundaryProcess::DielectricMetal"
-   #bp="$bp G4OpBoundaryProcess::ChooseReflection"
-   #bp="$bp G4OpBoundaryProcess::DoAbsorption"
-   #bp="$bp G4OpBoundaryProcess::DoReflection"
-   #export BP=${BP:-$bp}
-fi 
-
-if [ "${arg/dbg}" != "$arg" ]; then
-    [ -f "$log" ] && rm $log 
-    gdb__ $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE dbg error && exit 2
-fi 
-
-if [ -n "$script" -a -f "$script" ]; then 
-    ${IPYTHON:-ipython} --pdb -i $script 
-    [ $? -ne 0 ] && echo $BASH_SOURCE script $script error && exit 4
-else
-    echo $BASH_SOURCE no ana script $script is defined OR does not exist for arg $arg 
-fi 
-
-
-if [ -f "$ENVOUT" ]; then 
-    if [ "$arg" == "pvcap" -o "$arg" == "pvpub" -o "$arg" == "mpcap" -o "$arg" == "mppub" ]; then
-        echo $BASH_SOURCE : detected that python wrote ENVOUT $ENVOUT : sourcing this
-        cat $ENVOUT
-        source $ENVOUT
-        env | grep ENVOUT 
-    else
-        echo $BASH_SOURCE : remove prior ENVOUT $ENVOUT 
-        rm $ENVOUT
-    fi 
-fi
-
-
-notes(){ cat << EON
-ENVOUT COMMUNICATION FROM PYTHON BACK TO BASH
------------------------------------------------
-
-The U4SimulateTest_pr.py script writes ENVOUT 
-
-
-NOTICE HOW ENVOUT COMMUNICATION RELIES ON OVERLAPPED RUNNING OF THIS BASH SCRIPT
-
-1. IPYTHON PLOTTING RUNS AND WRITES THE ENVOUT FILE, POPS UP THE GUI WINDOW AND BLOCKS
-
-2. THEN IN A DIFFERENT TAB THE MPCAP/MPPUB IS RUN THAT SOURCES THE ENVOUT
-   IN ORDER TO CONFIGURE CAPTURE NAMING
-
-3. FINALLY THE FIRST PYTHON PLOTTER SESSION IS EXITED THAT CLEANS UP THE ENVOUT FILE.  
-
-So the ENVOUT file just contains the config for the currently displayed plot, and 
-should only exist when a plot is being displayed. More than one plot of the same 
-type displayed at the same time is not handled. 
-
-EON
-}
-
-if [ "$arg" == "pvcap" -o "$arg" == "pvpub" -o "$arg" == "mpcap" -o "$arg" == "mppub" ]; then
-    if [ -n "$ENVOUT_VERSION" ]; then
-        echo $BASH_SOURCE picking up ENVOUT_VERSION $ENVOUT_VERSION 
-        VERSION=$ENVOUT_VERSION
-    fi 
-
-    if [ -n "$ENVOUT_CAP_STEM" ]; then
-        echo $BASH_SOURCE picking up ENVOUT_CAP_STEM $ENVOUT_CAP_STEM 
-        export CAP_STEM=$ENVOUT_CAP_STEM
-    else
-        export CAP_STEM=$GEOM
-    fi 
-
-    export CAP_BASE=$BASE/$VERSION/figs
-    export CAP_REL=U4SimulateTest
-    case $arg in  
-       pvcap) source pvcap.sh cap  ;;  
-       mpcap) source mpcap.sh cap  ;;  
-       pvpub) source pvcap.sh env  ;;  
-       mppub) source mpcap.sh env  ;;  
-    esac
-    if [ "$arg" == "pvpub" -o "$arg" == "mppub" ]; then 
-        source epub.sh 
-    fi  
-fi 
-
-exit 0 
diff --git a/u4/tests/U4SimulateTest_cf.py b/u4/tests/U4SimulateTest_cf.py
deleted file mode 100644
index ebe2747237..0000000000
--- a/u4/tests/U4SimulateTest_cf.py
+++ /dev/null
@@ -1,126 +0,0 @@
-#!/usr/bin/env python
-"""
-U4SimulateTest_cf.py
-========================
-
-"""
-
-import os, numpy as np
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-from opticks.ana.nbase import chi2  
-from opticks.ana.qcf import QU,QCF,QCFZero
-
-from opticks.u4.tests.ModelTrigger_Debug import ModelTrigger_Debug       
-from opticks.sysrap.sevt import SEvt
-
-hist_ = lambda _:_.strip().decode("utf-8")   
-
-
-NOGUI = "NOGUI" in os.environ
-MODE = int(os.environ.get("MODE", 0))
-if not NOGUI:
-    from opticks.ana.pvplt import * 
-pass
-
-APID = int(os.environ.get("APID", -1))
-BPID = int(os.environ.get("BPID", -1))
-
-GEOM = os.environ.get("GEOM", "DummyGEOM")
-GEOMList = os.environ.get("%s_GEOMList" % GEOM, "DummyGEOMList") 
-
-
-if __name__ == '__main__':
-
-    print("APID:%d" % (APID))
-    print("BPID:%d" % (BPID))
-
-    a = SEvt.Load("$AFOLD", symbol="a")
-    b = SEvt.Load("$BFOLD", symbol="b")
-
-    #print(repr(a))
-    #print(repr(b))
-
-    amt = ModelTrigger_Debug.Create(a.f, symbol="amt", publish=False)  # publish:True crashing 
-    bmt = ModelTrigger_Debug.Create(b.f, symbol="bmt", publish=False)  # publish:True crashing 
-    if (amt is None) or (bmt is None):
-        print(" missing ModelTrigger_Debug amt:%s bmt:%s " % ( amt, bmt) )
-        IMPL = "NoMTD"
-    else:
-        assert( amt.IMPL == bmt.IMPL )
-        IMPL = amt.IMPL
-    pass
-
-
-    check_sevt = True
-    if check_sevt:
-        aq_ = a.f.seq[:,0]    #  shape eg (1000, 2, 2)
-        bq_ = b.f.seq[:,0]     
-        assert np.all( aq_ == a.q_ )
-        assert np.all( bq_ == b.q_ )
-
-        an = np.sum( seqnib_(aq_), axis=1 )     ## occupied nibbles across both sets of 16 from the two 64 bit ints 
-        bn = np.sum( seqnib_(bq_), axis=1 )   
-        assert np.all( an == a.n ) 
-        assert np.all( bn == b.n ) 
-
-        aq = ht.seqhis(aq_)  # "|S96"  32 point slots * 3 chars for each abbr eg "BT " 
-        bq = ht.seqhis(bq_) 
-
-        assert np.all( aq == a.q)
-        assert np.all( bq == b.q)
-
-        if 'SPECS' in os.environ:
-            a_st_ = a.f.aux[:,:,2,3].view(np.int32)
-            a_st = a.SPECS[a_st_]
-
-            b_st_ = b.f.aux[:,:,2,3].view(np.int32)
-            b_st = b.SPECS[b_st_]
-
-            assert np.all( a.spec == a_st )
-            assert np.all( b.spec == b_st )
-        pass
-    pass
-
-
-
-    PID_DESC = "Dumping PID history and step specs with record position, time"
-    if APID > -1:
-        print("APID:%d # %s " % (APID,PID_DESC)  )
-        exprs = "a.q[APID] np.c_[a.spec[APID,:a.n[APID]]] a.f.record[APID,:a.n[APID],0]"
-        for expr in exprs.split(): 
-            print(expr)
-            print(repr(eval(expr)))
-            print(".") 
-        pass
-    pass 
-    if BPID > -1:
-        print("BPID:%d # %s " % (BPID, PID_DESC) )
-        exprs = "b.q[BPID] np.c_[b.spec[APID,:b.n[BPID]]] b.f.record[BPID,:b.n[BPID],0]"
-        for expr in exprs.split(): 
-            print(expr)
-            print(repr(eval(expr))) 
-            print(".") 
-        pass
-    pass 
-
-
-    assert( a.CHECK == b.CHECK )
-    CHECK = a.CHECK
-
-    assert( a.LAYOUT == b.LAYOUT )
-    LAYOUT = a.LAYOUT
-
-    HEADLINE = "./U4SimulateTest.sh cf ## PMT Geometry : A(N=0) Unnatural+FastSim, B(N=1) Natural geometry  "
-    print("\n%s" % HEADLINE)
-    print("GEOM/GEOMList/IMPL/LAYOUT/CHECK : %s/%s/%s/%s/%s " % (GEOM, GEOMList, IMPL, LAYOUT, CHECK) )
-
-    qcf = QCF(a.q, b.q, symbol="qcf")
-
-    print(qcf.aqu)
-    print(qcf.bqu)
-    print(qcf)
-
-    #qcf0 = QCFZero(qcf)
-    #print(qcf0)
-
diff --git a/u4/tests/U4SimulateTest_ck.py b/u4/tests/U4SimulateTest_ck.py
deleted file mode 100644
index 1e22fb2998..0000000000
--- a/u4/tests/U4SimulateTest_ck.py
+++ /dev/null
@@ -1,72 +0,0 @@
-#!/usr/bin/env python
-"""
-U4SimulateTest_ck.py
-======================
-
-"""
-import os, logging, numpy as np
-log = logging.getLogger(__name__)
-
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-from opticks.sysrap.sevt import SEvt
-
-MODE = int(os.environ.get("MODE","2"))
-if MODE > 0:
-    from opticks.ana.pvplt import * 
-else:
-    pass
-pass
-
-axes = 0, 2  # X,Z
-H,V = axes 
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    FOLD = os.environ.get("FOLD", None)
-    log.info(" -- SEvt.Load FOLD" )
-    a = SEvt.Load(FOLD, symbol="a")   # optional photon histories 
-    print(a)
-
-    beg_ = "a.f.record[:,0,0,:3]"
-    beg = eval(beg_)
-
-    end_ = "a.f.photon[:,0,:3]"
-    end = eval(end_)
-
-
-    #label0, ppos0 = None, None
-    label0, ppos0 = "b:%s" % beg_ , beg
-
-    #label0, ppos0 = None, None
-    label1, ppos1 = "r:%s" % end_ , end
-
-
-    HEADLINE = "%s %s" % ( a.LAYOUT, a.CHECK )
-    label = "\n".join( filter(None, [HEADLINE, label0, label1]))
-    print(label)
-
-    if MODE == 0:
-        print("not plotting as MODE 0  in environ")
-    elif MODE == 2:
-        fig, ax = mpplt_plotter(label=label)
-
-        ax.set_ylim(-250,250)
-        ax.set_xlim(-500,500)
-
-        if not ppos0 is None: ax.scatter( ppos0[:,H], ppos0[:,V], s=1, c="b" )  
-        if not ppos1 is None: ax.scatter( ppos1[:,H], ppos1[:,V], s=1, c="r" )  
-
-        fig.show()
-    elif MODE == 3:
-        pl = pvplt_plotter(label)
-        os.environ["EYE"] = "0,100,165"
-        os.environ["LOOK"] = "0,0,165"
-        pvplt_viewpoint(pl)
-        pl.add_points(ppos0)
-        pl.show()
-    pass
-pass
-
diff --git a/u4/tests/U4SimulateTest_fk.py b/u4/tests/U4SimulateTest_fk.py
deleted file mode 100644
index b85ea498ee..0000000000
--- a/u4/tests/U4SimulateTest_fk.py
+++ /dev/null
@@ -1,102 +0,0 @@
-#!/usr/bin/env python
-
-import os, logging, numpy as np
-log = logging.getLogger(__name__)
-
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-from opticks.sysrap.sevt import SEvt
-
-MODE = int(os.environ.get("MODE","2"))
-if MODE > 0:
-    from opticks.ana.pvplt import * 
-else:
-    pass
-pass
-
-axes = 0, 2  # X,Z
-H,V = axes 
-
-
-if __name__ == '__main__':
-    logging.basicConfig(level=logging.INFO)
-
-    FOLD = os.environ.get("FOLD", None)
-    log.info(" -- SEvt.Load FOLD" )
-    a = SEvt.Load(FOLD, symbol="a")   # optional photon histories 
-    print(a)
-
-    SPECS = np.array(a.f.U4R_names.lines)
-    st_ = a.f.aux[:,:,2,3].view(np.int32)
-    st = SPECS[st_]
-
- 
-    w_fk_ = "np.where(a.fk>0)"
-    w_fk = eval(w_fk_)
-    print(w_fk_,"\n",w_fk) 
-
-    w_fk8_ = "np.where(a.fk==8)"
-    w_fk8 = eval(w_fk8_)
-    print(w_fk8_,"\n",w_fk8) 
-
-
-    tab_fk_ = "np.c_[np.unique(a.fk,return_counts=True)]"  
-    tab_fk  = eval(tab_fk_)
-    print(tab_fk_,"\n",tab_fk) 
-     
-    qqtab_fk_ =  "np.c_[np.unique(a.qq[w_fk], return_counts=True)]"
-    qqtab_fk = eval(qqtab_fk_)  
-    print(qqtab_fk_,"\n",qqtab_fk) 
-
-    post_fk_ = "a.f.record[tuple(w_fk[0]),tuple(w_fk[1]),0]"
-    post_fk = eval(post_fk_)  
-    print(post_fk_,"\n",post_fk) 
-
-    post_fk8_ = "a.f.record[tuple(w_fk8[0]),tuple(w_fk8[1]),0] # FAKE_MANUAL all on midline "
-    post_fk8 = eval(post_fk8_)  
-    print(post_fk8_,"\n",post_fk8) 
-
-    tab_st_fk_ = "np.c_[np.unique(st[w_fk],return_counts=True)]"
-    tab_st_fk = eval(tab_st_fk_)
-    print(tab_st_fk_,"\n",tab_st_fk) 
-
-    tab_st_fk8_ = "np.c_[np.unique(st[w_fk8],return_counts=True)]"
-    tab_st_fk8 = eval(tab_st_fk8_)
-    print(tab_st_fk8_,"\n",tab_st_fk8_) 
-  
-
-
-    #label0, ppos0 = None, None
-    label0, ppos0 = "b:%s" % post_fk_ , post_fk[:,:3]
-
-    #label1, ppos1 = None, None
-    label1, ppos1 = "r:%s" % post_fk8_ ,post_fk8
-
-
-    HEADLINE = "%s %s" % ( a.LAYOUT, a.CHECK )
-    label = "\n".join( filter(None, [HEADLINE, label0, label1]))
-    print(label)
-
-    if MODE == 0:
-        print("not plotting as MODE 0  in environ")
-    elif MODE == 2:
-        fig, axs = mpplt_plotter(label=label)
-        assert len(axs) == 1 
-        ax = axs[0]
-
-        ax.set_ylim(-250,250)
-        ax.set_xlim(-500,500)
-
-        if not ppos0 is None: ax.scatter( ppos0[:,H], ppos0[:,V], s=1 )  
-        if not ppos1 is None: ax.scatter( ppos1[:,H], ppos1[:,V], s=1, c="r" )  
-
-        fig.show()
-    elif MODE == 3:
-        pl = pvplt_plotter(label)
-        os.environ["EYE"] = "0,100,165"
-        os.environ["LOOK"] = "0,0,165"
-        pvplt_viewpoint(pl)
-        pl.add_points(ppos0)
-        pl.show()
-    pass
-pass
diff --git a/u4/tests/U4SimulateTest_mt.py b/u4/tests/U4SimulateTest_mt.py
index 14fd7f9e6f..8d7f03e2fd 100644
--- a/u4/tests/U4SimulateTest_mt.py
+++ b/u4/tests/U4SimulateTest_mt.py
@@ -6,7 +6,7 @@
 ::
 
     u4t
-    ./U4SimulateTest.sh mt
+    python U4SimulateTest_mt.py
 
 """
 import os, textwrap, numpy as np
@@ -33,7 +33,7 @@
 TO = TORCH.bit_length()
 
 N = int(os.environ.get("VERSION", "-1"))
-CMDLINE = "N=%d ./U4SimulateTest.sh mt" % N
+CMDLINE = "N=%d python U4SimulateTest_mt.py" % N
 
 TEST = os.environ.get("TEST", "Manual")
 GEOM = os.environ.get("GEOM", "DummyGEOM")
diff --git a/u4/tests/U4SimulateTest_ph.py b/u4/tests/U4SimulateTest_ph.py
index c8c769a992..0270f2a3e0 100644
--- a/u4/tests/U4SimulateTest_ph.py
+++ b/u4/tests/U4SimulateTest_ph.py
@@ -6,8 +6,7 @@
 ::
 
     u4t
-    ./U4SimulateTest.sh ph
-    ./U4SimulateTest.sh nph
+    python U4SimulateTest_ph.py
 
 """
 import os, numpy as np
@@ -17,7 +16,7 @@
 LABEL = os.environ.get("LABEL", "U4SimulateTest_ph.py" )
 N =  int(os.environ.get("VERSION", "-1"))
 VERSION = N 
-CMDLINE = "N=%d ./U4SimulateTest.sh ph" % N
+CMDLINE = "N=%d python U4SimulateTest_ph.py" % N
 
 MODE =  int(os.environ.get("MODE", "2"))
 assert MODE in [0,2,3]
diff --git a/u4/tests/U4SimulateTest_pr.py b/u4/tests/U4SimulateTest_pr.py
deleted file mode 100644
index 0d4f19955c..0000000000
--- a/u4/tests/U4SimulateTest_pr.py
+++ /dev/null
@@ -1,188 +0,0 @@
-#!/usr/bin/env python
-"""
-U4SimulateTest_pr.py
-========================
-
-::
-
-    u4t
-    ./U4SimulateTest.sh pr
-    ./U4SimulateTest.sh npr
-
-"""
-import os, numpy as np
-from opticks.ana.fold import Fold
-from opticks.ana.p import * 
-from opticks.sysrap.sevt import SEvt
-
-
-SCRIPT = "./U4SimulateTest.sh pr"
-os.environ["SCRIPT"] = SCRIPT 
-ENVOUT = os.environ.get("ENVOUT", None)
-
-
-N = int(os.environ.get("N", "-1"))
-MODE =  int(os.environ.get("MODE", "2"))
-assert MODE in [0,2,-2,3,-3]
-FLIP = int(os.environ.get("FLIP", "0")) == 1 
-TIGHT = int(os.environ.get("TIGHT", "0")) == 1 
-
-if MODE != 0:
-
-    from opticks.ana.pvplt import * 
-    WM = mp.pyplot.get_current_fig_manager()  
-else:
-    WM = None
-pass
-
-if __name__ == '__main__':
-
-    if N == -1:
-        a = SEvt.Load("$AFOLD",symbol="a")
-        b = SEvt.Load("$BFOLD",symbol="b")
-        syms = ['a','b']
-    elif N == 0:
-        a = SEvt.Load("$AFOLD",symbol="a")
-        b = None
-        syms = ['a']
-    elif N == 1:
-        a = None
-        b = SEvt.Load("$BFOLD",symbol="b")
-        syms = ['b']
-    else:
-        assert(0)
-    pass
-
-    if not a is None:print(repr(a))
-    if not b is None:print(repr(b))
- 
-    print( "MODE:%d" % (MODE) )
-
-    if FLIP == False:
-        H,V = 0, 2        # customary X, Z 
-    else:
-        H,V = 2, 0        # flipped   Z, X 
-    pass
-    
-    scale = 0.8 if TIGHT else 1.0
-
-    LIM = { 
-            0:np.array([-500,500])*scale,
-            1:np.array([-500,500])*scale,
-            2:np.array([-250,250])*scale
-          }
-
-
-    #ppos0_ = "None"
-    #ppos0_ = "pos #   "
-    ppos0_ = "t.f.record[:,0,0,:3] # 0-position   "
-
-    #ppos1_ = "None"
-    ppos1_ = "t.f.record[:,1,0,:3] # 1-position   "
-
-    #ppos2_ = "None"
-    ppos2_ = "t.f.record[t.n>2,2,0,:3] # 2-position   "
-
-    #ppos3_ = "None"
-    ppos3_ = "t.f.photon[:,0,:3]"
-
-    tlabel_ = "t.TITLE"  
-    tid_ = "t.ID"  
-    version_ = "t.VERSION"  
-
-
-    elem = []
-    if not ppos0_ is "None": elem.append("b:%s" % ppos0_)
-    if not ppos1_ is "None": elem.append("r:%s" % ppos1_)
-    if not ppos2_ is "None": elem.append("g:%s" % ppos2_)
-    if not ppos3_ is "None": elem.append("c:%s" % ppos3_)
-
-    ppos0 = {}
-    ppos1 = {}
-    ppos2 = {}
-    ppos3 = {}
-    tlabel = {}
-    tid = {}
-    version = {}
-
-    for i,sym in enumerate(syms):
-        t = eval(sym)
-        ppos0[sym] = eval(ppos0_)
-        ppos1[sym] = eval(ppos1_) 
-        ppos2[sym] = eval(ppos2_) 
-        ppos3[sym] = eval(ppos3_) 
-        tlabel[sym] = eval(tlabel_) 
-        tid[sym] = eval(tid_) 
-        version[sym] = eval(version_) 
-    pass
-
-    if MODE == 0:
-        print("not plotting as MODE 0  in environ")
-    elif MODE == 2:
-        for sym in syms:
-            if TIGHT: 
-                label = tlabel[sym]
-            else:
-                label = "\n".join([tlabel[sym]] + elem)
-            pass
-            fig, axs = mpplt_plotter(nrows=1, ncols=1, label=label)
-            ax = axs[0]
-            ax.set_ylim(*LIM[V])
-            ax.set_xlim(*LIM[H])
-            if TIGHT:ax.axis('off')
-
-            if not ppos0[sym] is None: ax.scatter( ppos0[sym][:,H], ppos0[sym][:,V], s=1, c="b" )  
-            if not ppos1[sym] is None: ax.scatter( ppos1[sym][:,H], ppos1[sym][:,V], s=1, c="r" )  
-            if not ppos2[sym] is None: ax.scatter( ppos2[sym][:,H], ppos2[sym][:,V], s=1, c="g" )  
-            if not ppos3[sym] is None: ax.scatter( ppos3[sym][:,H], ppos3[sym][:,V], s=1, c="c" )  
-            pass
-            if TIGHT:fig.tight_layout()
-
-            if not ENVOUT is None:
-                envout = "\n".join([
-                               "export ENVOUT_PATH=%s" % ENVOUT,
-                               "export ENVOUT_SYM=%s" % sym,
-                               "export ENVOUT_TID=%s" % tid[sym],
-                               "export ENVOUT_CAP_STEM=%s" % tid[sym],
-                               "export ENVOUT_VERSION=%s" % version[sym],
-                               ""
-                               ]) 
-                open(ENVOUT, "w").write(envout)
-                print(envout)
-            pass
-            fig.show()
-        pass
-
-        if len(syms) > 1:
-            print("WARNING : MULTIPLE FIGS SHOWN : PROBABLY WINDOWS ARE OVERLAPPED")
-        pass
-
-
-
-    elif MODE == -2:
-        ## TRYING TO SHOW MORE THAN ONE PLOT GIVES SUBPLOTS TOO SMALL 
-        ## ITS MORE USEFUL TO POP UP TWO WINDOWS AS DONE ABOVE 
-        fig, axs = mpplt_plotter(nrows=1, ncols=2, label=label)
-        for i,ax in enumerate(axs):
-            sym = syms[i]
-
-            ax.set_ylim(*LIM[V])
-            ax.set_xlim(*LIM[H])
-            if TIGHT:ax.axis('off')
-
-            if not ppos0[sym] is None: ax.scatter( ppos0[sym][:,H], ppos0[sym][:,V], s=1, c="b" )  
-            if not ppos1[sym] is None: ax.scatter( ppos1[sym][:,H], ppos1[sym][:,V], s=1, c="r" )  
-            if not ppos2[sym] is None: ax.scatter( ppos2[sym][:,H], ppos2[sym][:,V], s=1, c="g" )  
-            if not ppos3[sym] is None: ax.scatter( ppos3[sym][:,H], ppos3[sym][:,V], s=1, c="c" )  
-        pass
-        if TIGHT:fig.tight_layout()
-        fig.show()
-    elif MODE == 3:
-        pl = pvplt_plotter(label)
-        os.environ["EYE"] = "0,100,165"
-        os.environ["LOOK"] = "0,0,165"
-        pvplt_viewpoint(pl)
-        pl.add_points(ppos )
-        pl.show()
-    pass
-pass
diff --git a/u4/tests/U4TreeCreateSSimTest.py b/u4/tests/U4TreeCreateSSimTest.py
deleted file mode 100644
index 7096a67c5f..0000000000
--- a/u4/tests/U4TreeCreateSSimTest.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-"""
-U4TreeCreateSSimTest.py
-=====================
-"""
-
-import numpy as np, textwrap
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree, snode
-
-np.set_printoptions(edgeitems=16)
-
-if __name__ == '__main__':
-    f = Fold.Load("$FOLD/SSim/stree", symbol="f")
-    print(repr(f))
-    snode.Fields(bi=True)  # bi:True exports field indices into builtins scope
-
-    EXPR = r"""
-    f.nds.shape
-    snode.Label(5,6)         # field label spacing and initial offset 
-    ri,ro                    # (repeat_index, repeat_ordinal) 
-    f.nds[f.nds[:,ri] == 1]  # structural nodes with repeat_index of 1 
-    snode.Label(5,6)         # field label spacing and initial offset  
-    snode.Doc()
-    """
-
-    for expr in list(filter(None,textwrap.dedent(EXPR).split("\n"))):
-        print(expr)
-        if len(expr) == 0 or expr[0] == "#": continue
-        print(eval(expr))
-    pass
-
-
-
-
-
diff --git a/u4/tests/U4TreeCreateSSimTest.sh b/u4/tests/U4TreeCreateSSimTest.sh
deleted file mode 100755
index 3be373bd5c..0000000000
--- a/u4/tests/U4TreeCreateSSimTest.sh
+++ /dev/null
@@ -1,107 +0,0 @@
-#!/bin/bash 
-usage(){ cat << EOU
-U4TreeCreateSSimTest.sh  : loads GEOM configured geometry, runs U4Tree::Create populating SSim/stree.h, saves to FOLD  
-==============================================================================================================================
-
-::
-
-    GEOM # edit geometry identifier
-    ~/o/u4/tests/U4TreeCreateSSimTest.sh 
-    TEST=pick_lvid_ordinal_node ~/o/u4/tests/U4TreeCreateSSimTest.sh 
-
-EOU
-}
-
-SDIR=$(dirname $(realpath $BASH_SOURCE))
-
-
-bin=U4TreeCreateSSimTest 
-defarg="info_run_ana"
-arg=${1:-$defarg}
-
-
-test=find_lvid
-#test=NONE
-export TEST=${TEST:-$test}
-
-
-loglevels(){
-   #export U4VolumeMaker=INFO
-   #export U4Solid=INFO
-   export DUMMY=INFO
-}
-loglevels
-
-
-#export U4TreeBorder__FLAGGED_ISOLID=HamamatsuR12860sMask_virtual0x61b0510
-#export U4Tree__IsFlaggedSolid_NAME=HamamatsuR12860sMask_virtual
-
-#export SSim__stree_level=0 
-#export sn__uncoincide_dump_lvid=107 
-#export sn__uncoincide_dump_lvid=106
-
-
-#export U4Tree__DISABLE_OSUR_IMPLICIT=1   ## TEMPORAILY TO SEE IF OSUR EXPLAINS ALL BOUNDARY DEVIATION
-#export U4Polycone__DISABLE_NUDGE=1 
-
-
-
-source $HOME/.opticks/GEOM/GEOM.sh
-[ -z "$GEOM" ] && echo $BASH_SOURCE FATAL GEOM $GEOM must be defined && exit 1  
-
-gdmlpath=$HOME/.opticks/GEOM/$GEOM/origin.gdml
-
-if [ -f "$gdmlpath" ]; then
-   export ${GEOM}_GDMLPath=$gdmlpath
-else
-   echo $BASH_SOURCE : GEOM $GEOM LACKS gdmlpath $gdmlpath : ASSUME USING ANOTHER GEOMETRY SOURCE APPROACH  
-fi 
-
-tmp=/tmp/$USER/opticks
-TMP=${TMP:-$tmp}
-fold=$TMP/$bin/$GEOM
-mkdir -p $fold
-
-export FOLD=$fold   # where SSim saved/loaded 
-
-script=$SDIR/$bin.py 
-
-vars="BASH_SOURCE TEST SDIR bin GEOM gdmlpath tmp TMP FOLD script"
-
-if [ "${arg/info}" != "$arg" ]; then 
-    for var in $vars ; do printf "%30s : %s \n" "$var" "${!var}" ; done 
-fi 
-
-
-if [ "${arg/clean}" != "$arg" ]; then 
-    cd $TMP && rm -rf U4TreeCreateSSimTest  # hardcode directory name for safety 
-    [ $? -ne 0 ] && echo $BASH_SOURCE clean error && exit 1 
-fi 
-
-
-if [ "${arg/run}" != "$arg" ]; then 
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1 
-fi 
-
-if [ "${arg/build}" != "$arg" ]; then 
-    echo $BASH_SOURCE : FATAL bin $bin IS BUILD BY STANDARD u4 OM : NOT THIS SCRIPT && exit 1
-fi 
-
-if [ "${arg/load}" != "$arg" ]; then 
-    $bin load
-    [ $? -ne 0 ] && echo $BASH_SOURCE load error && exit 2 
-fi 
-
-if [ "${arg/dbg}" != "$arg" ]; then 
-    dbg__ $bin 
-    [ $? -ne 0 ] && echo $BASH_SOURCE dbg error && exit 3
-fi 
-
-if [ "${arg/ana}" != "$arg" ]; then 
-    ${IPYTHON:-ipython} --pdb -i $script
-    [ $? -ne 0 ] && echo $BASH_SOURCE ana error && exit 4
-fi 
-
-exit 0 
-
diff --git a/u4/tests/U4TreeCreateTest.py b/u4/tests/U4TreeCreateTest.py
deleted file mode 100644
index 11af06edca..0000000000
--- a/u4/tests/U4TreeCreateTest.py
+++ /dev/null
@@ -1,74 +0,0 @@
-#!/usr/bin/env python
-"""
-U4TreeCreateTest.py
-=====================
-"""
-
-import numpy as np, textwrap
-from opticks.ana.fold import Fold
-from opticks.sysrap.stree import stree, snode
-from opticks.sysrap.sn_check import sn_check
-
-np.set_printoptions(edgeitems=16)
-
-if __name__ == '__main__':
-    f = Fold.Load("$FOLD/stree", symbol="f")
-    print(repr(f))
-    snode.Fields(bi=True)  # bi:True exports field indices into builtins scope
-    print(snode.Label(6,11),"\n", f.nds[f.nds[:,ri] == 1 ])
-
-    prim_nidx = f.prim_nidx[:,0] ## nidx values of every prim [globalPrimIdx(0-based, contiguous)]
-    assert( np.all( prim_nidx > -1 ) )
-    prim_nidx_tab = np.c_[np.unique(prim_nidx, return_counts=True)]
-    assert( np.all( prim_nidx_tab[:,1] == 1 ) )
-
-    nidx_prim = f.nidx_prim[:,0] ## prim values of every nidx [lots of repeats from instancing]
-    assert( np.all( nidx_prim > -1 ) )
-    nidx_prim_tab = np.c_[np.unique(nidx_prim, return_counts=True)]
-    assert( len(nidx_prim_tab) == len(prim_nidx) )
-
-
-    c = sn_check(f, symbol="c")
-    print(repr(c))
-
-    sn = f._csg.sn
-    s_tv = f._csg.s_tv
-    s_pa = f._csg.s_pa
-    s_bb = f._csg.s_bb
-
-    if hasattr(f, 'csg'):
-        snd = f.csg.node
-        xform = f.csg.xform
-        param = f.csg.param
-        aabb = f.csg.aabb
-
-        EXPR = r"""
-        np.all( snd == sn )
-        np.all( xform == s_tv )
-        np.all( param == s_pa )
-        np.all( aabb == s_bb )
-        """
-    else:
-        snd = None
-        xform = None
-        param = None
-        aabb = None
-
-        EXPR = r"""
-        sn
-        s_tv
-        s_pa
-        s_bb
-        """
-    pass
-
-    for expr in list(filter(None,textwrap.dedent(EXPR).split("\n"))):
-        print(expr)
-        if expr[0] == "#": continue
-        print(eval(expr))
-    pass
-
-
-
-
-
diff --git a/u4/tests/U4TreeCreateTest.sh b/u4/tests/U4TreeCreateTest.sh
deleted file mode 100755
index 33e190ec6b..0000000000
--- a/u4/tests/U4TreeCreateTest.sh
+++ /dev/null
@@ -1,104 +0,0 @@
-#!/bin/bash
-usage(){ cat << EOU
-U4TreeCreateTest.sh  : loads geometry, runs U4Tree::Create populating stree.h, saves to FOLD
-==============================================================================================
-
-The geometry may be loaded by various means including from GDML or j/PMTSim via U4VolumeMaker::
-
-    ~/o/u4/tests/U4TreeCreateTest.sh
-
-To update the stree impl used by U4TreeCreateTest it is necessary to
-build and install both sysrap and u4::
-
-     sy;om;u4;om
-
-See also U4Polycone_test.sh which avoids slow rebuild after changing WITH macros
-by directly compiling the needed SysRap sources and not using the full SysRap library.
-
-EOU
-}
-
-cd $(dirname $(realpath $BASH_SOURCE))
-SDIR=$PWD
-
-bin=U4TreeCreateTest
-script=$bin.py
-
-export TMP=${TMP:-/tmp/$USER/opticks}
-export FOLD=$TMP/$bin
-
-
-
-defarg="info_run_ana"
-arg=${1:-$defarg}
-
-logging()
-{
-   type $FUNCNAME
-   export U4VolumeMaker=INFO
-   export U4Solid=INFO
-   #export stree__level=1
-   export DUMMY=INFO
-}
-[ -n "$LOG" ] && logging
-
-
-# extra logging for some bits of geometry ?
-#export U4TreeBorder__FLAGGED_ISOLID=HamamatsuR12860sMask_virtual0x61b0510
-export U4Solid__IsFlaggedLVID=0
-#export U4Solid__IsFlaggedName=sDeadWater
-
-
-source $HOME/.opticks/GEOM/GEOM.sh
-
-_CFB=${GEOM}_CFBaseFromGEOM
-CFB=${!_CFB}
-xgdmlpath=$CFB/origin.gdml
-
-if [ -n "$CFB" -a -d "$CFB" -a -f "$CFB/origin.gdml" ]; then
-    note="binary $bin is expected to load $xgdmlpath"
-else
-    note="NOT using CFBaseFromGEOM resolution"
-fi
-
-
-vars="BASH_SOURCE SDIR defarg arg bin GEOM _CFB CFB xgdmlpath note TMP FOLD script"
-
-
-if [ "${arg/info}" != "$arg" ]; then
-    for var in $vars ; do printf "%30s : %s \n" "$var" "${!var}" ; done
-fi
-
-if [ "${arg/clean}" != "$arg" ]; then
-    cd $TMP && rm -rf U4TreeCreateTest  # hardcode directory name for safety
-    [ $? -ne 0 ] && echo $BASH_SOURCE clean error && exit 1
-    cd $SDIR
-fi
-
-if [ "${arg/run}" != "$arg" ]; then
-    $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE run error && exit 1
-fi
-
-if [ "${arg/load}" != "$arg" ]; then
-    $bin load
-    [ $? -ne 0 ] && echo $BASH_SOURCE load error && exit 2
-fi
-
-if [ "${arg/dbg}" != "$arg" ]; then
-    source dbg__.sh
-    dbg__ $bin
-    [ $? -ne 0 ] && echo $BASH_SOURCE dbg error && exit 3
-fi
-
-if [ "${arg/ana}" != "$arg" ]; then
-    ${PYTHON:-python} $script
-    [ $? -ne 0 ] && echo $BASH_SOURCE ana error && exit 4
-fi
-
-if [ "${arg/pdb}" != "$arg" ]; then
-    ${IPYTHON:-ipython} --pdb -i $script
-    [ $? -ne 0 ] && echo $BASH_SOURCE pdb error && exit 5
-fi
-
-exit 0
diff --git a/u4/tests/cf.sh b/u4/tests/cf.sh
deleted file mode 100755
index 45520eeb6e..0000000000
--- a/u4/tests/cf.sh
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/bin/bash -l 
-usage(){ cat << EOU
-cf.sh  : runs U4SimulateTest.sh twice with N=0 and N=1 and Chi2 compares histories
-======================================================================================
-
-::
-
-    u4t                              # cd ~/opticks/u4/tests 
-
-    APID=475 BPID=476 ./cf.sh cf     # dump single photons and chi2 compare
-
-    ./cf.sh run_cf                   # create SEvt and compare histories  
-
-    POM=0 ./cf.sh                    # traditional stop at photocathode 
-
-    NUM_PHOTONS=50000 POM=0 ./cf.sh 
-
-
-EOU
-}
-
-defarg="run_cf"
-#defarg="cf"
-arg=${1:-$defarg}
-
-if [ "${arg/run}" != "$arg" ]; then 
-   N=0 ./U4SimulateTest.sh run
-   [ $? -ne 0 ] && echo $BASH_SOURCE N=0 RUN ERROR && exit 1
-
-   N=1 ./U4SimulateTest.sh run
-   [ $? -ne 0 ] && echo $BASH_SOURCE N=1 RUN ERROR && exit 2
-fi 
-
-if [ "${arg/cf}" != "$arg" ]; then 
-   C2CUT=30 ./U4SimulateTest.sh cf
-   [ $? -ne 0 ] && echo $BASH_SOURCE cf ANA ERROR && exit 3
-fi
-
-exit 0 
-
-
diff --git a/u4/tests/ck.sh b/u4/tests/ck.sh
deleted file mode 100755
index caec5a7060..0000000000
--- a/u4/tests/ck.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash -l
-
-N=0 ./U4SimulateTest.sh ck 
diff --git a/u4/tests/fk.sh b/u4/tests/fk.sh
deleted file mode 100755
index 1f0b02dab2..0000000000
--- a/u4/tests/fk.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/bin/bash -l
-
-N=0 ./U4SimulateTest.sh fk
-
-
diff --git a/u4/tests/mt.sh b/u4/tests/mt.sh
deleted file mode 100755
index fff9866391..0000000000
--- a/u4/tests/mt.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/bash -l 
-
-defarg="run_mt"
-arg=${1:-$defarg}
-
-N=${N:-0} ./U4SimulateTest.sh $arg
-
-
diff --git a/u4/tests/ph.sh b/u4/tests/ph.sh
deleted file mode 100755
index b4ba588082..0000000000
--- a/u4/tests/ph.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/bash -l 
-
-#defarg="ph"
-defarg="run_ph"
-#defarg="dbg"
-
-arg=${1:-$defarg}
-
-N=${N:-1} ./U4SimulateTest.sh $arg
-
-
diff --git a/u4/tests/pr.sh b/u4/tests/pr.sh
deleted file mode 100755
index 1f1c3f9d14..0000000000
--- a/u4/tests/pr.sh
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/bin/bash -l 
-usage(){ cat << EON
-pr.sh
-======
-
-When just looking at plots can use argumentless invokation
-which will pop up two windows for N=0 and N=1::
-
-   ./pr.sh 
-
-When capturing screenshots for presentation need to use N=0 or N=1 
-for the auto-book-keeping to work, eg::
-
-    N=0 ./pr.sh 
-    N=1 ./pr.sh 
-
-Then whilst each window is showing::
-
-    ./pr.sh mpcap 
-    PUB="some_comment" ./pr.sh mppub
-
-EON
-}
-
-DIR=$(dirname $BASH_SOURCE)
-#export TIGHT=1
-
-#defarg="run_pr"
-defarg="pr"
-arg=${1:-$defarg}
-
-$DIR/U4SimulateTest.sh $arg
-
diff --git a/u4/tests/tt.sh b/u4/tests/tt.sh
deleted file mode 100755
index 03fa191ddf..0000000000
--- a/u4/tests/tt.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-#!/bin/bash -l
-usage(){ cat << EOU
-tt.sh 
-======
-
-::
-
-   PLOT=STAMP STAMP_ANNO=1 ~/opticks/u4/tests/tt.sh 
-   PLOT=STAMP STAMP_ANNO=1 STAMP_TT=100000,1000 ~/opticks/u4/tests/tt.sh 
-
-
-
-EOU
-}
-
-DIR=$(dirname $BASH_SOURCE)
-N=-1 $DIR/U4SimulateTest.sh tt
diff --git a/u4/tests/viz.sh b/u4/tests/viz.sh
deleted file mode 100755
index c670514892..0000000000
--- a/u4/tests/viz.sh
+++ /dev/null
@@ -1,83 +0,0 @@
-#!/bin/bash -l 
-
-usage(){ cat << EOU
-viz.sh
-========
-
-Use qi first indices of each history as APID/BPID indices to viz::
-
-    In [1]: a.qtab_,a.qtab
-    Out[1]: 
-    ('np.c_[qn,qi,qu][quo]',
-     array([[b'900', b'0', b'TO BT SR BT SA                                                                                  '],
-            [b'93', b'12', b'TO BT SA                                                                                        '],
-            [b'2', b'600', b'TO BT SR BT AB                                                                                  '],
-            [b'2', b'239', b'TO BR SA                                                                                        '],
-            [b'1', b'484', b'TO BT SR BR SR BT SA                                                                            '],
-            [b'1', b'938', b'TO BT SR AB                                                                                     '],
-            [b'1', b'964', b'TO BT AB                                                                                        ']], dtype='|S96'))
-
-    epsilon:tests blyth$ APID=484 ./viz.sh 
-
-Find some big bouncer BPID to look at::
-
-    In [4]: np.c_[np.where(b.n>5)[0], b.q[b.n>5]]
-    Out[4]: 
-    array([[b'56', b'TO BT BR BR BR BT SA                                                                            '],
-           [b'865', b'TO BT BT BR BR SR SR SR SR SR SR SR SA                                                          '],
-           [b'877', b'TO BT BT BR BR SR SR SA                                                                         '],
-           [b'896', b'TO BT BT BR SR SR SR SR SR SR SA                                                                '],
-           [b'943', b'TO BT BT BR SR SR SR SR SR SA                                                                   '],
-           ...,
-           [b'9057', b'TO BT BT BR SR SR SR SR SR SA                                                                   '],
-           [b'9073', b'TO BT BT BR SR SR SR SR SR BR SA                                                                '],
-           [b'9076', b'TO BT BT BR SR SR SR SR SR SR SR SR BT BT SA                                                    '],
-           [b'9092', b'TO BT BT BR SR SR SR SR SR SR SR BR BR BR BR SA                                                 '],
-           [b'9107', b'TO BT BT BT BT SA                                                                               ']], dtype='|S96')
-
-
-
-
-Photons with "SC" scatter out of the plane, use pyvista 3D plotting with::
-
-   MODE=3 BPID=... ./viz.sh 
-
-
-Adjusting view and annotation for viaibility::
-
-    APID=10 FOCUS=0,0,260 TIGHT=1 ./viz.sh 
-
-    BPID=9092 BOPT=idx,pdy FOCUS=0,0,280 TIGHT=1 HV_THIRDLINE=0.5,0.97  ./viz.sh 
-
-
-
-EOU
-}
-
-
-DIR=$(dirname $BASH_SOURCE)
-
-defarg="ana"
-arg=${1:-$defarg}
-script=$DIR/U4SimtraceTest.sh
-aopt=idx
-bopt=idx
-
-if [ -n "$APID" -a -n "$BPID" ]; then 
-    N=1 APID=$APID BPID=$BPID $script $arg
-elif [ -n "$APID" ]; then
-    N=0 APID=$APID AOPT=${AOPT:-$aopt} $script $arg
-elif [ -n "$BPID" ]; then
-    N=1 BPID=$BPID BOPT=${BOPT:-$bopt} $script $arg
-elif [ "$arg" == "runboth" ]; then
-    N=0 $script run
-    N=1 $script run
-else
-    N=${N:-1} $script $arg
-fi 
-
-
-
-
-
-