catsim-test 0.0.5__cp313-cp313-manylinux_2_31_x86_64.whl

gecatsim/pyfiles/CommonTools.py

@@ -0,0 +1,445 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+import ctypes
+
+import json
+import os
+import struct
+import importlib
+import numpy as np
+
+'''
+Common tool functions.
+Mingye Wu, GE Research
+'''
+
+
+def check_value(a):
+    #return
+    print(type(a).__name__)
+    if type(a) is np.ndarray:
+        print(a.shape, a.dtype)
+    print(a,'\n')
+
+
+def make_col(a):
+    a = a.reshape(a.size, 1)
+    return a
+
+
+def feval(func_name, *args):
+    module_paths = [
+        func_name,
+        f"gecatsim.pyfiles.{func_name}",
+        f"gecatsim.pyfiles.FlatPanel.{func_name}"
+    ]
+
+    module = None
+    for path in module_paths:
+        try:
+            module = importlib.import_module(path)
+            break
+        except ModuleNotFoundError:
+            continue
+
+    if module is None:
+        raise ImportError(f"Could not import module: {func_name}. Tried paths: {module_paths}")
+
+    # Extract the function name (the part after the last dot)
+    func_name_only = func_name.split('.')[-1]
+
+    try:
+        func = getattr(module, func_name_only)
+    except AttributeError:
+        raise AttributeError(f"Function '{func_name_only}' not found in module '{module.__name__}'")
+
+    return func(*args)
+
+
+def load_C_lib():
+    lib_path = my_path.paths["lib"]
+    my_path.add_dir_to_path(lib_path)
+
+    # load C/C++ lib
+    ll = ctypes.cdll.LoadLibrary
+    if os.name == "nt":     # Check for Windows OS
+        libFile = "libcatsim64.dll"
+    else:
+        if os.uname()[0] == 'Darwin':    # Check for Mac OS;
+            libFile = "libcatsim_macos.so"
+        else:
+            libFile = "libcatsim.so"
+    clib = ll(os.path.join(lib_path, libFile))
+    
+    return clib
+
+
+class emptyCFG:
+    pass
+
+
+class PathHelper:
+    def __init__(self):
+        self._base_dir = os.getcwd()
+        # Locate paths of lib and data.
+        self.paths = {}
+        self.paths["main"] = os.path.dirname(os.path.abspath(__file__))
+        self.paths["top"] = os.path.split(self.paths["main"])[0]
+        self.paths["bowtie"] = os.path.join(self.paths["top"], 'bowtie')
+        self.paths["cfg"] = os.path.join(self.paths["top"], 'cfg')
+        self.paths["dose"] = os.path.join(self.paths["top"], 'dose')
+        self.paths["dose_data"] = os.path.join(self.paths["top"], 'dose', 'data')
+        self.paths["focal_spot"] = os.path.join(self.paths["top"], 'focal_spot')
+        self.paths["lib"] = os.path.join(self.paths["top"], 'lib')
+        self.paths["material"] = os.path.join(self.paths["top"], 'material')
+        self.paths["phantom"] = os.path.join(self.paths["top"], 'phantom')
+        self.paths["response_matrix"] = os.path.join(self.paths["top"], 'response_matrix')
+        self.paths["scatter"] = os.path.join(self.paths["top"], 'scatter')
+        self.paths["spectrum"] = os.path.join(self.paths["top"], 'spectrum')
+        self.extra_search_paths = []
+        self.read_catsim_init()
+
+    def base(self, *args):
+        return os.path.join(self._base_dir, *args)
+
+    def add_search_path(self, path):
+        if not os.path.isdir(path):
+            print(f"***WARNING: {path} does not exist.")
+        if path not in self.extra_search_paths:
+            self.extra_search_paths.append(path)
+
+    def find(self, key, filename, extension):
+        path = self.paths[key]
+
+        # check fully-qualified path and/or current directory first
+        if os.path.isfile(filename):
+            return filename
+
+        if os.path.isfile(f"{filename}{extension}"):
+            return f"{filename}{extension}"
+
+        # check user-defined search paths BEFORE default paths
+        for p in self.extra_search_paths:
+            # if we want to limit the depth at some point, then we might want to use the walkDir module
+            # https://walkdir.readthedocs.io/en/stable/
+            for p2, dirs, files in os.walk(p):
+                if os.path.isfile(os.path.join(p2, filename)):
+                    return os.path.join(p2, filename)
+                elif os.path.isfile(os.path.join(p2, f"{filename}{extension}")):
+                    return os.path.join(p2, f"{filename}{extension}")
+                elif os.path.isfile(os.path.join(p2, key, filename)):
+                    return os.path.join(p2, key, filename)
+                elif os.path.isfile(os.path.join(p2, key, f"{filename}{extension}")):
+                    return os.path.join(p2, key, f"{filename}{extension}")
+
+        # check path and its subdirectories
+        for p2, dirs, files in os.walk(path):
+            if os.path.isfile(os.path.join(p2, filename)):
+                return os.path.join(p2, filename)
+            elif os.path.isfile(os.path.join(p2, f"{filename}{extension}")):
+                return os.path.join(p2, f"{filename}{extension}")
+
+        # exhausted all the paths to search and could not find the file
+        raise Exception("Cannot find %s or %s%s" %(filename, filename, extension))
+
+    def find_dir(self, key, dir_name):
+        path = self.paths[key]
+
+        # check fully-qualified path and/or current directory first
+        if os.path.isdir(dir_name):
+            return dir_name
+
+        # check user-defined search paths BEFORE default paths
+        for p in self.extra_search_paths:
+            if os.path.isdir(os.path.join(p, dir_name)):
+                return os.path.join(p, dir_name)
+            elif os.path.isdir(os.path.join(p, key, dir_name)):
+                return os.path.join(p, key, dir_name)
+
+        if os.path.isdir(os.path.join(path, dir_name)):
+            return os.path.join(path, dir_name)
+        # exhausted all the paths to search and could not find the file
+        raise Exception("Cannot find directory %s" % (dir_name))
+
+    def read_catsim_init(self):
+        cwd_init_file = os.path.join(self._base_dir, ".gecatsim")
+        self.read_catsim_file(cwd_init_file)
+
+        if os.name == "nt":
+            # on my PC with a C: and D: drive
+            # HOMEDIR=D:\Users\USERNAME
+            # USERPROFILE=c:\Users\USERNAME
+            if "HOMEDIR" in os.environ:
+                user_home = os.environ.get("HOMEDIR")
+                root_init_file = os.path.join(user_home, ".gecatsim")
+                self.read_catsim_file(root_init_file)
+
+            if "USERPROFILE" in os.environ:
+                user_home = os.environ.get("USERPROFILE")
+                root_init_file = os.path.join(user_home, ".gecatsim")
+                self.read_catsim_file(root_init_file)
+        else:
+            # on Linux & Mac, HOME is home directory of the user
+            if "HOME" in os.environ:
+                user_home = os.environ.get("HOME")
+                root_init_file = os.path.join(user_home, ".gecatsim")
+                self.read_catsim_file(root_init_file)
+
+    def read_catsim_file(self, filename):
+        if os.path.isfile(filename):
+            try:
+                with open(filename, "r") as f:
+                    init = json.load(f)
+            except BaseException as err:
+                print(f"***WARNING: Unable to read file: {filename} as json: {err=}, {type(err)=}")
+            else:
+                if "search_paths" in init:
+                    for p in init["search_paths"]:
+                        self.add_search_path(p)
+                else:
+                    print(f"***WARNING: search_paths entry not found in {filename}")
+
+    @staticmethod
+    def add_dir_to_path(dir_name):
+        if dir_name not in os.environ["PATH"]:
+            os.environ["PATH"] = f'{dir_name};{os.environ["PATH"]}'
+
+    @staticmethod
+    def linux_style_path(filename):
+        return filename.replace("\\", "/")
+
+
+class CFG:
+    def __init__(self, *para):
+        # initialize cfg: defaults, paths, and C lib
+        cfg = source_cfg("Phantom_Default")
+        cfg = source_cfg("Scanner_Default", cfg)
+        cfg = source_cfg("Protocol_Default", cfg)
+        cfg = source_cfg("Physics_Default", cfg)
+        cfg = source_cfg("Recon_Default", cfg)
+        cfg.resultsName = "simulation_test"
+
+        if not hasattr(cfg, 'clib'):
+            cfg.clib = load_C_lib()
+        
+        # source cfgFiles if para are defined
+        # note: the later cfgFile overrides the former ones
+        for cfgFile in para:
+            cfg = source_cfg(cfgFile, cfg)
+        
+        self.pass_cfg_to_self(cfg)
+
+    def pass_cfg_to_self(self, cfg):
+        # add or override cfg attributes to self
+        for name1, value1 in vars(cfg).items():
+            if not hasattr(self, name1):
+                setattr(self, name1, value1)
+            else:
+                for name2, value2 in eval("vars(cfg.%s).items()" % name1):
+                    setattr(getattr(self, name1), name2, value2)
+            
+    def load(self, cfgFile):
+        cfg = source_cfg(cfgFile)
+        self.pass_cfg_to_self(cfg)
+
+
+def source_cfg(*para):
+    '''
+    First para must be cfg filename.
+    Second para is optional, if defined and is cfg, attr will be added to cfg.
+    Calling source_cfg(cfg_file, cfg) will add or override attributes to cfg.
+    '''
+    # find cfg file
+    cfg_file = my_path.find("cfg", para[0], ".cfg")
+
+    # cfg is initialized before sourcing cfg_file
+    if len(para)<2:
+        cfg = emptyCFG()
+    else:
+        cfg = para[1]
+        
+    # initialize structs in cfg and structs
+    attrList = ['sim', 'det', 'detNew', 'src', 'srcNew', 'spec', 'protocol', 'scanner', 'phantom', 'physics', 'recon', 'dose']
+    
+    for attr in attrList:
+        # Ensure cfg has the attribute
+        if not hasattr(cfg, attr):
+            setattr(cfg, attr, emptyCFG())
+
+        # Define the variable in the local scope if not already defined
+        if attr not in locals():
+            globals()[attr] = emptyCFG()
+            # exec("%s = emptyCFG()" % attr)  # globals()[attr] = ... is more explicit and safer for dynamic variable creation
+        
+    # execute scripts in cfg file
+    exec(open(cfg_file).read())
+    
+    # add or override the attributes in the original cfg
+    for attr in attrList:
+        for name, value in eval("vars(%s).items()" % attr):
+            setattr(getattr(cfg, attr), name, value)
+    
+    return cfg
+    
+def vectornorm(xyz):
+    if xyz.shape[0]!=3:
+        print('ERROR : argument of vectornorm has to be of size 3 x n');
+        return
+    else:
+        norms = np.sqrt(np.square(xyz).sum(axis=0))
+        norms = make_col(norms)
+        return norms
+
+
+def overlap(x0, y0, x1, b0=None, b1=None):
+    if x0 is not None and len(x0)>0:
+        n0 = len(x0)  # length
+        b0 = get_vector_boundaries(x0)  # boundaries
+    elif b0 is not None and len(b0)>1:
+        n0 = len(b0)-1
+        if isinstance(b0,list):
+            b0 = np.array(b0)
+    else:
+        raise Exception("overlap arguments need either x0 or b0 (boundary)")
+    
+    if x1 is not None and len(x1)>0:
+        n1 = len(x1)
+        b1 = get_vector_boundaries(x1)
+    elif b1 is not None and len(b1)>1:
+        n1 = len(b1)-1
+        if isinstance(b1,list):
+            b1 = np.array(b1)
+    else:
+        raise Exception("overlap arguments need either x1 or b1 (boundary)")
+    
+    # default
+    y1 = np.zeros(b1[0:-1].shape)
+    
+    # pre-loop, find the start boundaries
+    i = -1
+    j = 0
+    previous = b1[j]
+    while b0[i+1] <= previous:
+        i += 1
+        if i>=n0:
+            return y1
+    if i == -1:
+        i = 0
+        previous = b0[i]
+        while b1[j+1] <= previous:
+            j += 1
+            if j >= n1:
+                return y1    
+    
+    # main loop
+    while j < n1:
+        if b0[i+1] < b1[j+1]:
+            y1[j] += y0[i]*(b0[i+1]-previous)/(b1[j+1]-b1[j])
+            previous = b0[i+1]
+            i += 1
+            if i >= n0:
+                return y1
+        else:
+            y1[j] += y0[i]*(b1[j+1]-previous)/(b1[j+1]-b1[j])
+            previous = b1[j+1]
+            j += 1  
+    
+    return y1
+
+
+def get_vector_boundaries(x):
+    # x can be scalar, vector, or [n, 1] array
+    
+    if len(x) == 1:
+        b = np.array([x*(1-1e-6), x*(1+1e-6)])
+    else:
+        b = (x[0:-1]+x[1:])/2
+        b = np.concatenate(([x[0]-0.5*(x[1]-x[0])], b, [x[-1]+0.5*(x[-1]-x[-2])]))
+    return b
+
+def overlap2d(oldimg, old_pos_x, old_pos_y, pos_x, pos_y):
+    nrows=len(old_pos_x)
+    ncols=len(old_pos_y)
+    nrows2=len(pos_x)
+    ncols2=len(pos_y)
+    a, b = oldimg.shape
+    if a != nrows or b != ncols:
+      print('ERROR: dimensions of image dont agree with dimensions of coords !')
+      exit()
+    
+    # RESAMPLE EACH ROW
+    tmpimg = np.zeros((nrows,ncols2))
+    for row in range(nrows):
+      tmpimg[row] = overlap(old_pos_y, oldimg[row], pos_y)
+    
+    # RESAMPLE EACH COL
+    newimg = np.zeros((nrows2,ncols2))
+    for col in range(ncols2):
+      newimg[:,col] = overlap(old_pos_x, tmpimg[:,col], pos_x)
+
+    return newimg
+
+def rawread(fname, dataShape, dataType):
+    # dataType is for numpy, ONLY allows: 'float'/'single', 'double', 'int'/'int32', 'uint'/'uint32', 'int8', 'int16' 
+    #          they are single, double, int32, uin32, int8, int16
+    with open(fname, 'rb') as fin:
+        data = fin.read()
+    
+    # https://docs.python.org/3/library/struct.html
+    switcher = {'float': ['f', 4, np.single], 
+                'single': ['f', 4, np.single], 
+                'double': ['d', 8, np.double], 
+                'int': ['i', 4, np.int32], 
+                'uint': ['I', 4, np.uint32],  
+                'int32': ['i', 4, np.int32], 
+                'uint32': ['I', 4, np.uint32], 
+                'int8': ['b', 1, np.int8], 
+                'int16': ['h', 2, np.int16]}
+    fmt = switcher[dataType]
+    data = struct.unpack("%d%s" % (len(data)/fmt[1], fmt[0]), data)
+    
+    data = np.array(data, dtype=fmt[2])
+    if dataShape:
+        data = data.reshape(dataShape)
+    
+    return data
+
+def rawwrite(fname, data):
+    with open(fname, 'wb') as fout:
+        fout.write(data)
+
+
+def conv2(img, h, mode='same'):
+    h = np.rot90(h, 2) # rotate 180 degree
+    img_row, img_col = img.shape
+    h_row, h_col = h.shape
+    if mode == 'full':
+        zeroPad = np.zeros((h_row-1, img_col))
+        extImg = np.vstack((zeroPad, img, zeroPad))
+        zeroPad = np.zeros((extImg.shape[0], h_col-1))
+        extImg = np.column_stack((zeroPad, extImg, zeroPad))
+    elif mode == 'same':
+        zeroPad = np.zeros((int(h_row/2), img_col))
+        extImg = np.vstack((zeroPad, img, zeroPad))
+        zeroPad = np.zeros((extImg.shape[0], int(h_col/2)))
+        extImg = np.column_stack((zeroPad, extImg, zeroPad))
+    else:
+        extImg = img
+    
+    row_start, row_end = 0, extImg.shape[0]-h.shape[0]+1
+    col_start, col_end = 0, extImg.shape[1]-h.shape[1]+1
+    img_conv = np.zeros((row_end, col_end))
+    for r in range(row_start, row_end):
+        for c in range(col_start, col_end):
+            cur_region = extImg[r:r+h_row, c:c+h_col]
+            img_conv[r, c] = np.sum(cur_region * h)
+    
+    if mode == 'same':
+        if h_row%2 == 0:
+            img_conv = img_conv[1:,:]
+        if h_col%2 == 0:
+            img_conv = img_conv[:,1:]
+    
+    return img_conv
+
+
+my_path = PathHelper()

gecatsim/pyfiles/Detection_DAS.py

@@ -0,0 +1,25 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+#import numpy as np
+from gecatsim.pyfiles.CommonTools import *
+import sys
+#from catsim.pyfiles.Detection_Lag import Detection_Lag
+
+def Detection_DAS(viewIn, viewId, cfg):
+
+    # to be consisten with spectrum_heel, gain factors should be indexed from cathode end to anode end
+    if hasattr(cfg.scanner.detectionGain, "__len__"):
+        if len(cfg.scanner.detectionGain) != cfg.scanner.detectorRowCount:
+            print("Error! detectionGain should have the same length as row count\n")
+            sys.exit(1)
+        else:
+            # based on plot, viewIn is flatten of [col, row]
+            tmp = np.tile(cfg.scanner.detectionGain, cfg.scanner.detectorColCount)
+            viewOut = np.float32(viewIn*tmp)
+    else:
+        viewOut = viewIn*cfg.scanner.detectionGain
+    
+    eNoise = np.float32(np.random.randn(viewIn.size)*cfg.sim.eNoise)
+    viewOut += eNoise.reshape(viewIn.shape)
+    
+    return viewOut

gecatsim/pyfiles/Detection_EI.py

@@ -0,0 +1,84 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+import numpy as np
+from gecatsim.pyfiles.GetMu import GetMu
+from gecatsim.pyfiles.randpf import randpf
+from gecatsim.pyfiles.CommonTools import *
+
+def Detection_EI(cfg, viewId, subViewId):
+
+    Evec = cfg.sim.Evec
+        
+    # detection efficiency
+    if viewId == cfg.sim.startViewId and subViewId == 0:
+        # detector prefilter
+        cfg.sim.Wvec = feval(cfg.physics.prefilterCallback, cfg)
+        
+        # detector absorption
+        detectorMu = GetMu(cfg.scanner.detectorMaterial, Evec)
+        detEff = 1-np.exp(-0.1*cfg.scanner.detectorDepth/np.cos(cfg.det.betas)*detectorMu)
+
+        np.multiply(cfg.sim.Wvec, detEff, out=cfg.sim.Wvec)
+        
+    # Apply energy-dependent detection efficiency
+    np.multiply(cfg.thisSubView, cfg.sim.Wvec,  out=cfg.thisSubView)
+    
+    # scatter cross-talk
+    if cfg.physics.crosstalkCallback:
+        cfg.thisSubView = feval(cfg.physics.crosstalkCallback, cfg.thisSubView, cfg)
+        
+    # quantum noise
+    if cfg.sim.enableQuantumNoise:
+        cfg.thisSubView = randpf(cfg.thisSubView)
+        
+    # merge energies
+    thisSubView = cfg.thisSubView.dot(Evec)
+        
+    # lag
+    if cfg.physics.lagCallback:
+        thisSubView = feval(cfg.physics.lagCallback, thisSubView, viewId, subViewId, cfg)
+
+    # accumulate subviews
+    if subViewId == 0:
+        cfg.thisView = thisSubView
+    else:
+        cfg.thisView += thisSubView
+        
+    # for final subview
+    if subViewId == cfg.sim.subViewCount-1:
+        # optical cross-talk
+        if cfg.physics.opticalCrosstalkCallback:
+            cfg.thisView = feval(cfg.physics.opticalCrosstalkCallback, cfg.thisView, cfg)
+        
+        # DAS
+        cfg.thisView = feval(cfg.physics.DASCallback, cfg.thisView, viewId, cfg)
+    
+    return cfg
+
+
+# if __name__ == "__main__":
+#
+#     cfg = source_cfg("./cfg/default.cfg")
+#
+#     cfg.sim.startViewId = 0
+#     cfg.sim.stopViewId = 2
+#     cfg.sim.enableQuantumNoise = 1
+#     cfg.sim.subViewCount = 1
+#     cfg.det.totalNumCells = 5
+#     cfg.det.cosBetas = np.ones([cfg.det.totalNumCells, 1], dtype=np.single)
+#
+#     cfg = feval(cfg.protocol.spectrumCallback, cfg)
+#
+#     cfg.thisSubView = np.float32(np.random.random([cfg.det.totalNumCells, cfg.sim.Evec.size])*100)
+#     cfg.thisSubView[1:4, 3:5] = 0
+#     viewId = 0
+#     subViewId = 0
+#
+#     check_value(cfg.sim.Evec)
+#     check_value(cfg.thisSubView)
+#
+#     cfg = Detection_EI(cfg, viewId, subViewId)
+#     check_value(cfg.sim.Wvec)
+#     check_value(cfg.thisView)
+    
+    

gecatsim/pyfiles/Detection_Flux.py

@@ -0,0 +1,47 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+
+import numpy as np
+import numpy.matlib as nm
+from gecatsim.pyfiles.CommonTools import *
+
+def Detection_Flux(cfg):
+    '''
+    Compute the photon flux at the detector per cell per subview
+    Flux dim: [pixel, Ebin] ([col, row, Ebin])
+    Note: the unit of spectrum: photons per mAs per mm^2 at 1-m distance
+          and spec.Ivec is already scaled to mA and view time, i.e. mAs
+    Mingye Wu, GE Research
+    
+    '''
+    ###------- offset scan, flux = 0
+    #if hasattr(cfg, 'sim.isOffsetScan') and cfg.sim.isOffsetScan:
+    if cfg.sim.isOffsetScan:
+        cfg.detFlux = np.zeros([cfg.det.totalNumCells, cfg.spec.nEbin], dtype=np.single)
+        return cfg
+    
+    ###------- air or phantom scan
+    detActiveArea = cfg.det.activeArea*np.cos(cfg.det.betas) # mm^2
+    #detActiveArea = nm.repmat(detActiveArea, 1, cfg.spec.nEbin)
+    
+    distanceFactor = np.square(1000/cfg.det.rayDistance) # mm
+    #distanceFactor = nm.repmat(distanceFactor, 1, cfg.spec.nEbin)
+    
+    cfg.spec.netIvec = cfg.spec.Ivec*cfg.src.filterTrans
+    cfg.detFlux = np.multiply(cfg.spec.netIvec.astype(np.single, copy=False), np.single(detActiveArea*distanceFactor))
+    
+    return cfg
+
+# if __name__ == "__main__":
+#
+#     cfg = source_cfg("./cfg/default.cfg")
+#
+#     cfg.sim.isOffsetScan = 0
+#
+#     cfg = feval(cfg.scanner.detectorCallback, cfg)
+#     cfg = feval(cfg.scanner.focalspotCallback, cfg)
+#     cfg = feval(cfg.physics.rayAngleCallback, cfg)
+#     cfg = feval(cfg.protocol.spectrumCallback, cfg)
+#     cfg = feval(cfg.protocol.filterCallback, cfg)
+#
+#     cfg = Detection_Flux(cfg)
+#     check_value(cfg.detFlux)

gecatsim/pyfiles/Detection_Lag.py

@@ -0,0 +1,28 @@
+# Copyright 2024, GE Precision HealthCare. All rights reserved. See https://github.com/xcist/main/tree/master/license
+import numpy as np
+
+# only the previous view matters
+def Detection_Lag(thisView, viewId, subViewId, cfg):
+    tau1, tau2 = cfg.physics.lag_taus
+    alpha1, alpha2 = cfg.physics.lag_alphas
+    dt = 1000.*cfg.protocol.rotationTime/cfg.protocol.viewsPerRotation # in ms
+    dt /= cfg.physics.viewSampleCount
+
+    unaccounted = 1 - alpha1 - alpha2
+    invintegral = alpha1*(1.0 - np.exp(-dt/2/tau1)) + alpha2*(1.0 - np.exp(-dt/2/tau2)) + unaccounted
+
+    if viewId == cfg.protocol.startViewId and subViewId == 0:
+        if cfg.sim.isAirScan:
+            cfg.memview1 = thisView*np.exp(-dt/2/tau1)/(1-np.exp(-dt/tau1))
+            cfg.memview2 = thisView*np.exp(-dt/2/tau2)/(1-np.exp(-dt/tau2))
+        #else cfg.sim.isPhantomScan:
+        else:
+            cfg.memview1 = 0
+            cfg.memview2 = 0
+        #return thisView*invintegral
+
+    outview = invintegral*thisView + (alpha1*(1.0 - np.exp(-dt/tau1)))*cfg.memview1 + (alpha2*(1.0 - np.exp(-dt/tau2)))*cfg.memview2
+    cfg.memview1 = (cfg.memview1 * np.exp(-dt/tau1) + thisView*np.exp(-dt/2/tau1))
+    cfg.memview2 = (cfg.memview2 * np.exp(-dt/tau2) + thisView*np.exp(-dt/2/tau2))
+
+    return outview