emccd-detect 2.6.0__tar.gz → 2.6.2__tar.gz

{emccd_detect-2.6.0 → emccd_detect-2.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emccd_detect
-Version: 2.6.0
+Version: 2.6.2
 Summary: EMCCD detector image simulation
 Author: Joshua Ludwick
 Author-email: Bijan Nemati <bijan.nemati@tellus1.com>, Sam Miller <sam.miller@uah.edu>, Kevin Ludwick <kevin.ludwick@uah.edu>
@@ -25,14 +25,14 @@ Given an input fluxmap, emccd_detect will return a simulated EMCCD detector imag
 
 # Version
 
-The latest version of emccd\_detect is 2.6.0.  Main differences from previous version, 2.5.0: 
-Main differences from previous version:
---cosmic rays are more accurate, more like what the Roman CGI expects to see at L2 (including secondary cosmic ray events due to the shielding surrounding CGI). Almost nothing is hard coded about the cosmic rays. The tail length can be tuned as well.
---Fixed-pattern noise (FPN) is now implemented: 'roman' for Roman FPN found in TVAC, custom input file, or stripe pattern in rows and/or columns. File for Roman FPN included in util folder.
---CIC in gain register ("partial CIC") implemented (defaults to no partial CIC). One can specify particular "hot" gain stages with respect to CIC as well.
---EM gain simulation now conforms to exact binomial branching process instead of the approximate Gamma distribution. fast_gain_mode allows (fine for gain >~ 200) is available and uses the Gamma distribution.
---"Hot" gain stages with respect to EM gain multiplication also implemented. Defaults to None.
---Hot pixel map input available.
+The latest version of emccd\_detect is 2.6.2.  Main differences from previous version, 2.5.0:   
+Main differences from previous version:    
+--cosmic rays are more accurate, more like what the Roman CGI expects to see at L2 (including secondary cosmic ray events due to the shielding surrounding CGI). Almost nothing is hard coded about the cosmic rays. The tail length can be tuned as well.    
+--Fixed-pattern noise (FPN) is now implemented: 'roman' for Roman FPN found in TVAC, custom input file, or stripe pattern in rows and/or columns. File for Roman FPN included in util folder.    
+--CIC in gain register ("partial CIC") implemented (defaults to no partial CIC). One can specify particular "hot" gain stages with respect to CIC as well.    
+--EM gain simulation now conforms to exact binomial branching process instead of the approximate Gamma distribution. fast_gain_mode allows (fine for gain >~ 200) is available and uses the Gamma distribution.    
+--"Hot" gain stages with respect to EM gain multiplication also implemented. Defaults to None.    
+--Hot pixel map input available.    
 
 
 ## Getting Started

{emccd_detect-2.6.0 → emccd_detect-2.6.2}/README.md

@@ -5,14 +5,14 @@ Given an input fluxmap, emccd_detect will return a simulated EMCCD detector imag
 
 # Version
 
-The latest version of emccd\_detect is 2.6.0.  Main differences from previous version, 2.5.0: 
-Main differences from previous version:
---cosmic rays are more accurate, more like what the Roman CGI expects to see at L2 (including secondary cosmic ray events due to the shielding surrounding CGI). Almost nothing is hard coded about the cosmic rays. The tail length can be tuned as well.
---Fixed-pattern noise (FPN) is now implemented: 'roman' for Roman FPN found in TVAC, custom input file, or stripe pattern in rows and/or columns. File for Roman FPN included in util folder.
---CIC in gain register ("partial CIC") implemented (defaults to no partial CIC). One can specify particular "hot" gain stages with respect to CIC as well.
---EM gain simulation now conforms to exact binomial branching process instead of the approximate Gamma distribution. fast_gain_mode allows (fine for gain >~ 200) is available and uses the Gamma distribution.
---"Hot" gain stages with respect to EM gain multiplication also implemented. Defaults to None.
---Hot pixel map input available.
+The latest version of emccd\_detect is 2.6.2.  Main differences from previous version, 2.5.0:   
+Main differences from previous version:    
+--cosmic rays are more accurate, more like what the Roman CGI expects to see at L2 (including secondary cosmic ray events due to the shielding surrounding CGI). Almost nothing is hard coded about the cosmic rays. The tail length can be tuned as well.    
+--Fixed-pattern noise (FPN) is now implemented: 'roman' for Roman FPN found in TVAC, custom input file, or stripe pattern in rows and/or columns. File for Roman FPN included in util folder.    
+--CIC in gain register ("partial CIC") implemented (defaults to no partial CIC). One can specify particular "hot" gain stages with respect to CIC as well.    
+--EM gain simulation now conforms to exact binomial branching process instead of the approximate Gamma distribution. fast_gain_mode allows (fine for gain >~ 200) is available and uses the Gamma distribution.    
+--"Hot" gain stages with respect to EM gain multiplication also implemented. Defaults to None.    
+--Hot pixel map input available.    
 
 
 ## Getting Started

{emccd_detect-2.6.0 → emccd_detect-2.6.2}/emccd_detect/__init__.py

@@ -1,2 +1,2 @@
 # -*- coding: utf-8 -*-
-__version__ = '2.6.0'
+__version__ = '2.6.2'

{emccd_detect-2.6.0 → emccd_detect-2.6.2}/emccd_detect/emccd_detect.py

@@ -36,6 +36,14 @@ except:
 # Partial CIC is observationally degenerate with the effect of surface traps which release a captured trap
 # many pixels downstream.  Probability of capture increases with charge packeet (probability ~1 for ~100e- or higher).
 # Small effect for low to moderate EM gains.  
+
+# NOTE A value of Q=1e-3 was found using maximum likelihood estimation from real 
+# Roman testbed data at a commanded gain of 5000, which serves as a benchmark value. However,
+# the model used for the fit used an approximate form for the partial CIC probability, out of computational necessity, 
+# which used an average gain stage value which was representative of all the stages, 
+# so the fitted value of 1e-3 is physically akin to the middle stages having that value.  It was verified 
+# that this is similar to P/40 for all the stages. 
+
 class EMCCDDetectException(Exception):
     """Exception class for emccd_detect module."""
 
@@ -87,7 +95,8 @@ class EMCCDDetectBase:
         pixel_pitch,
         eperdn,
         nbits,
-        numel_gain_register
+        numel_gain_register,
+        **kwargs
     ):
         # Input checks
         if not isinstance(nbits, (int, np.integer)):
@@ -566,7 +575,7 @@ class EMCCDDetectBase:
         # is effectively performed with sat_tails() afterwards. 
         gain_counts = np.zeros_like(serial_counts)
         if not hasattr(self, 'fast_gain_mode'):
-            self.fast_gain_mode = False # use the fully accurate method
+            self.fast_gain_mode = False # use accurate method in this case
         if not hasattr(self, 'gain_stage_specs'):
             self.gain_stage_specs = None # default value
         all_gain_stage_specs = {n: self.em_gain**(1/self.numel_gain_register) - 1 for n in range(1, self.numel_gain_register+1)}
@@ -574,10 +583,15 @@ class EMCCDDetectBase:
             for num_stages_left in range(1, self.numel_gain_register+1):
                 if num_stages_left in self.gain_stage_specs.keys():
                     all_gain_stage_specs[num_stages_left] = self.gain_stage_specs[num_stages_left]
+        if hasattr(self, 'n1_fast'):
+            n1_fast = False #handle n=1 case using slow, accurate method regardless of gain value
+        else:
+            n1_fast = self.fast_gain_mode # inherent this bool in this case 
         gain_counts = rand_em_gain(
             n_in_array=serial_counts,
             gain_stage_specs=all_gain_stage_specs, 
-            numel_gain_register=self.numel_gain_register, fast_gain_mode=self.fast_gain_mode
+            numel_gain_register=self.numel_gain_register, fast_gain_mode=self.fast_gain_mode,
+            n1_fast=n1_fast
             )
 
         # assuming partial CIC independently propagates through gain register 
@@ -597,7 +611,7 @@ class EMCCDDetectBase:
         # no EM gain(?), so we simulate these effects here.
         # The traps in the gain register are simulated in sat_tails here.
         if not hasattr(self, 'tail_length'):
-            self.tail_length = 40 # default value
+            self.tail_length = int(np.round(self.em_gain*40/1000)) # default value
         gain_counts_tails = sat_tails(gain_counts, self.full_well_serial, self.tail_length)
 
         return gain_counts_tails
@@ -636,13 +650,13 @@ class EMCCDDetectBase:
                     self.fpn = hdul[0].data
             elif self.fpn_path == "roman":
                 if serial_counts.shape[0] == self.meta.data['frame_rows'] and serial_counts.shape[1] == self.meta.data['frame_cols']:
-                    with fits.open(Path(here, 'util', 'FPN_map.fits')) as hdul:
+                    with fits.open(Path(here, 'util', 'fpn_map.fits')) as hdul:
                         frame_data = hdul[0].data
                     self.fpn = frame_data
                 elif serial_counts.shape[0] <= self.meta.data['geom']['image']['rows'] and serial_counts.shape[1] <= self.meta.data['geom']['image']['cols']:
                     #If the area specificed by the user is not full frame then
                     #this code cuts out a portion/the entire image area on the fpn map to apply to amp
-                    with fits.open(Path(here, 'util', 'FPN_map.fits')) as hdul:
+                    with fits.open(Path(here, 'util', 'fpn_map.fits')) as hdul:
                         frame_data = hdul[0].data
                     r0c0 = self.meta.data['geom']['image']['r0c0']
                     subframe_array = frame_data[r0c0[0]:r0c0[0]+serial_counts.shape[0], r0c0[1]:r0c0[1]+serial_counts.shape[1]]
@@ -746,9 +760,11 @@ class EMCCDDetect(EMCCDDetectBase):
     oversample_factor : int
         Factor of oversampling of cosmic Gaussian over which to bin-sum to get 
         pixel values.  Default is 10.
-    tail_length: int
-            Desired tail length of cosmic ray.  Defaults to 40 (what is expected in flight 
-            for the Roman Telescope).
+    tail_length: int or str
+        Desired tail length of cosmic ray (in pixels).  Defaults to 'roman', which gives a 
+        tail length of about 40 for EM gain of 1000 (what is expected in flight 
+        for the Roman Telescope) and shorter lengths for proportionally smaller EM gain.
+        For example, a gain of 500 would mean a tail length of 20 in the 'roman' case.
     pixel_pitch : float
         Distance between pixel centers (m). Defaults to 13e-6.
     eperdn : float
@@ -795,14 +811,15 @@ class EMCCDDetect(EMCCDDetectBase):
         the time for each row to be clocked toward the register). This is used 
         to simulate smear on the image due to clocking during the exposure to 
         light.  Especially useful for shutterless EMCCDs.  If 0, no smear is 
-        simulated.  Defaults to 0 seconds.
-    gain_CIC_Q : float
+        simulated.  Defaults to 223.5e-6 seconds (applicable to the Roman CGI).
+    gain_CIC_Q : float or str
         Probability Q (or mean rate) of production of a clock-induced charge (CIC)
         in a given gain register stage. We call this "partial CIC".  
         Physically, Q < P, where P is the average probability of charge multiplication 
         for a single gain stage, and em_gain = (1+P)^numel_gain_register.  
         To simulate no partial CIC, let this input be 0.
-        Defaults to 0 (no partial CIC simulated).
+        Defaults to 'roman', in which case P/40 is used, which is consistent with data 
+        and gives negligible partial CIC for lower gains as expected.  
     gain_CIC_specs: dict or None
         This input supercedes gain_CIC_Q and renders the value of gain_CIC_Q 
         irrelevant.  This is used for specifying particular "hot" stages which source the 
@@ -827,11 +844,15 @@ class EMCCDDetect(EMCCDDetectBase):
         If a float, it must be between 0 and 1.  If < 0.5, overspill to the row downstream is 
         more likely than upstream overspill.  Defaults to 0.7.  Upstream overspill 
         is more likely for the Roman CGI EMCCDs.
-    fast_gain_mode : bool
+    fast_gain_mode : bool or 'auto'
         If True, a faster but less accurate method (uses Erlang/Gamma distribution for EM gain)
         of simulating the gain register is used.  If False, a slower but more accurate method 
         (marches each pixel through the gain register with binomial distribution) is used.
-        The fast method is quite accurate for em_gain > 200.  Defaults to False.
+        The fast method is quite accurate for em_gain > 200 if the number of incoming particles 
+        to the gain register is n > 1.  If 'auto', both speed and accuracy 
+        are prioritized:  the fast method is used if em_gain > 200 (and n>1) and 'roman' is used for gain_CIC_Q, 
+        and the slow method is used with gain_CIC_Q = 0 (since partial CIC is negligible for low gains) 
+        for em_gain <= 200 (or if n=1 for any gain). Defaults to 'auto'.
     gain_stage_specs: dict or None
         This input is used for specifying particular gain stages which are "hot"
         with respect to the average probability of multiplication, P.  The input 
@@ -882,7 +903,7 @@ class EMCCDDetect(EMCCDDetectBase):
         loc=1590,
         scale=550, 
         oversample_factor=10,
-        tail_length=40,
+        tail_length='roman',
         pixel_pitch=13e-6,
         eperdn=8.2,
         nbits=14,
@@ -891,19 +912,17 @@ class EMCCDDetect(EMCCDDetectBase):
         nonlin_path=None,
         flat_path=None,
         hot_pixel_path=None, 
-        row_read_time=0,  # seconds
-        gain_CIC_Q=0,
+        row_read_time=223.5e-6,  # seconds
+        gain_CIC_Q='roman',
         gain_CIC_specs=None,
         upstream_spill_prob=0.7,
-        fast_gain_mode=False,
+        fast_gain_mode='auto',
         gain_stage_specs=None,
         fpn_path= 'roman',
         bias_sigma_col=35,
-        bias_sigma_row=35
+        bias_sigma_row=35,
+        **kwargs #accommodating other keyword args for backward compatibility
     ):     
-        
-        if tail_length < 0:
-            raise EMCCDDetectException('tail_length cannot be negative.') 
         if row_read_time < 0:
             raise EMCCDDetectException('row_read_time must be >= 0 seconds.')
         if upstream_spill_prob is not None:
@@ -934,10 +953,35 @@ class EMCCDDetect(EMCCDDetectBase):
                 if num_stages_left in gain_stage_specs.keys():
                     all_gain_stage_specs[num_stages_left] = gain_stage_specs[num_stages_left]
         self.avg_gain_P = np.sum(list(all_gain_stage_specs.values()))/numel_gain_register
-        if gain_CIC_Q is not None:
+        # reset what the value is based gain_CIC_specs
+        em_gain = (1+self.avg_gain_P)**numel_gain_register
+        if fast_gain_mode == 'auto':
+            self.n1_fast = False # if n=1, use accurate method no matter what the gain; only defined if 'auto' mode used
+            if em_gain <= 200:
+                fast_gain_mode = False
+                gain_CIC_Q = 0
+                gain_CIC_specs = None
+            else:
+                fast_gain_mode = True
+                gain_CIC_Q = 'roman'
+                gain_CIC_specs = None
+        if type(tail_length) != int and tail_length != 'roman':
+            raise EMCCDDetectException("tail_length should be an integer or \'roman\'.")
+        elif type(tail_length) == int:
+            if tail_length < 0:
+                raise EMCCDDetectException('tail_length cannot be negative.')             
+        elif tail_length == 'roman':
+            gain_avg = (1+self.avg_gain_P)**numel_gain_register
+            tail_length = int(np.round(gain_avg*40/1000))
+        if gain_CIC_Q != 'roman':
             if gain_CIC_Q > self.avg_gain_P:
                 raise EMCCDDetectException('gain_CIC_Q >= P, where em_gain = '
                             '(1+P)^numel_gain_register. gain_CIC_Q must be < P.')
+            self.gain_CIC_Q = gain_CIC_Q
+        elif gain_CIC_Q == 'roman':
+            self.gain_CIC_Q = self.avg_gain_P/40
+        else:
+            raise EMCCDDetectException('gain_CIC_Q must be float or \'roman\'.')
         if gain_CIC_specs is not None:
             if not isinstance(gain_CIC_specs, dict):
                 raise EMCCDDetectException('gain_CIC_specs must either be None or a dictionary.')
@@ -973,9 +1017,8 @@ class EMCCDDetect(EMCCDDetectBase):
         self.row_read_time = row_read_time
         self.flat_path = flat_path
         self.hot_pixel_path = hot_pixel_path
-        self.gain_CIC_Q = gain_CIC_Q
         self.gain_CIC_specs = gain_CIC_specs
-        self.tail_length = tail_length
+        self.tail_length = tail_length 
         self.zff = zff
         self.loc = loc
         self.scale = scale

{emccd_detect-2.6.0 → emccd_detect-2.6.2}/emccd_detect/rand_em_gain.py

@@ -18,7 +18,7 @@ class RandEMGainException(Exception):
     """Exception class for rand_em_gain module."""
 
 
-def rand_em_gain(n_in_array, gain_stage_specs, numel_gain_register, fast_gain_mode=False):
+def rand_em_gain(n_in_array, gain_stage_specs, numel_gain_register, fast_gain_mode=False, n1_fast=False):
     """Generate random numbers according to EM gain pdfs.
 
     Parameters
@@ -37,6 +37,10 @@ def rand_em_gain(n_in_array, gain_stage_specs, numel_gain_register, fast_gain_mo
             of simulating the gain register is used.  If False, a slower but more accurate method 
             (marches each pixel through the gain register with binomial distribution) is used.
             The fast method is quite accurate for EM gain > 200.  Defaults to False.
+    n1_fast : bool, optional
+            If True, the fast method is used for the case of n=1 incoming particles to the gain register.
+            If False, the slow method is used for the case of n=1 incoming particles to the gain register.
+            Defaults to False.
 
     Returns
     -------
@@ -58,21 +62,27 @@ def rand_em_gain(n_in_array, gain_stage_specs, numel_gain_register, fast_gain_mo
     elif em_gain == 1:
         return n_in_array
     else:
-        n_out_array = _apply_gain(n_in_array, gain_stage_specs, numel_gain_register, fast_gain_mode)
+        n_out_array = _apply_gain(n_in_array, gain_stage_specs, numel_gain_register, fast_gain_mode, n1_fast)
         return n_out_array
 
-def _apply_gain(n_in_array, gain_stage_specs, numel_gain_register, fast_gain_mode):
+def _apply_gain(n_in_array, gain_stage_specs, numel_gain_register, fast_gain_mode, n1_fast):
     """Apply a specific EM gain to all nonzero n_in values."""
     # physically, integer values of electrons for Matsuo (Galton-Watson branching process) distribution.  
     # Otherwise, we try to keep e- values as floats since EM gain,
     # k gain, nonlinearity, master flat, etc are calibrated assuming fractions of electrons, and 
     # we can get fractions of electrons here for particular gain values.  So we just round 
     # DN output to integer at the end.
-
+    n_out_array = np.zeros_like(n_in_array)
     if fast_gain_mode:
         avg_P = np.sum(list(gain_stage_specs.values()))/numel_gain_register
         em_gain = (1+avg_P)**numel_gain_register
-        n_out_array = np.random.gamma(n_in_array, em_gain)
+        if n1_fast:
+            n_out_array = np.random.gamma(n_in_array, em_gain)
+        else:
+            the_rest_inds = np.where(n_in_array > 1)
+            n1_inds = np.where(n_in_array == 1)
+            n_out_array[n1_inds] = _rand_pdf(np.round(n_in_array[n1_inds]), gain_stage_specs, numel_gain_register)
+            n_out_array[the_rest_inds] = np.random.gamma(n_in_array[the_rest_inds], em_gain)
     else:
         n_out_array = _rand_pdf(np.round(n_in_array), gain_stage_specs, numel_gain_register) 
 
@@ -90,11 +100,10 @@ def _rand_pdf(n_in, gain_stage_specs, numel_gain_register):
         n_out = n_in.astype(int) 
     except:
         n_out = int(np.round(n_in))
-    rng = np.random.default_rng()
     # reverse list so that you're counting down from stage n to stage 1
     # Stage numbers mean the number of stages remaining 
     for stage, Q in reversed(list(gain_stage_specs.items())):
-        n_out += rng.binomial(n_out, Q)
+        n_out += np.random.binomial(n_out, Q) 
         
         # # trinomial (P1 and P2):
         # t = rng.binomial(n_out, Q)
@@ -311,14 +320,14 @@ def partial_CIC(array_size, gain_stage_specs, numel_gain_register, gain_CIC_Q,
             stage_numbers = np.append(stage_numbers, stage).astype(int)
         
     for i in range(len(stage_numbers)):
-       #gain = (1+P)**stage_numbers[i]
-       # gain_stage_specs is already ordered by construction, which ensures gain branching process is sequential
-       # So we take the first stage_numbers[i] elements of it
-       input_gain_stage_specs =  dict(islice(gain_stage_specs.items(), stage_numbers[i]))
-       inds = np.where(stage_chunks[i] > 0)
-       if inds[0].size > 0: 
-           n_out = rand_em_gain(stage_chunks[i][inds], input_gain_stage_specs, stage_numbers[i])
-           partial_CIC[inds] = partial_CIC[inds] + n_out
+        #gain = (1+P)**stage_numbers[i]
+        # gain_stage_specs is already ordered by construction, which ensures gain branching process is sequential
+        # So we take the first stage_numbers[i] elements of it
+        input_gain_stage_specs =  dict(islice(gain_stage_specs.items(), stage_numbers[i]))
+        inds = np.where(stage_chunks[i] > 0)
+        if inds[0].size > 0: 
+            n_out = rand_em_gain(stage_chunks[i][inds], input_gain_stage_specs, stage_numbers[i])
+            partial_CIC[inds] = partial_CIC[inds] + n_out
     
     return partial_CIC
 
@@ -343,10 +352,10 @@ if __name__ == '__main__':
         plt.yscale('log')
         plt.grid(True)
 
-    
-    #g=5000; n=1; M=604
+    g=1000; n=2; M=600
+    g=200; n=1; M=600
     #g=500; n=2; M=604
-    g=3; n=100; M=604
+    #g=3; n=100; M=604
     #g=3; n=10; M=604
     #g=150; n=10; M=604
     nmax=int(g*n*4)

{emccd_detect-2.6.0 → emccd_detect-2.6.2}/emccd_detect.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emccd_detect
-Version: 2.6.0
+Version: 2.6.2
 Summary: EMCCD detector image simulation
 Author: Joshua Ludwick
 Author-email: Bijan Nemati <bijan.nemati@tellus1.com>, Sam Miller <sam.miller@uah.edu>, Kevin Ludwick <kevin.ludwick@uah.edu>
@@ -25,14 +25,14 @@ Given an input fluxmap, emccd_detect will return a simulated EMCCD detector imag
 
 # Version
 
-The latest version of emccd\_detect is 2.6.0.  Main differences from previous version, 2.5.0: 
-Main differences from previous version:
---cosmic rays are more accurate, more like what the Roman CGI expects to see at L2 (including secondary cosmic ray events due to the shielding surrounding CGI). Almost nothing is hard coded about the cosmic rays. The tail length can be tuned as well.
---Fixed-pattern noise (FPN) is now implemented: 'roman' for Roman FPN found in TVAC, custom input file, or stripe pattern in rows and/or columns. File for Roman FPN included in util folder.
---CIC in gain register ("partial CIC") implemented (defaults to no partial CIC). One can specify particular "hot" gain stages with respect to CIC as well.
---EM gain simulation now conforms to exact binomial branching process instead of the approximate Gamma distribution. fast_gain_mode allows (fine for gain >~ 200) is available and uses the Gamma distribution.
---"Hot" gain stages with respect to EM gain multiplication also implemented. Defaults to None.
---Hot pixel map input available.
+The latest version of emccd\_detect is 2.6.2.  Main differences from previous version, 2.5.0:   
+Main differences from previous version:    
+--cosmic rays are more accurate, more like what the Roman CGI expects to see at L2 (including secondary cosmic ray events due to the shielding surrounding CGI). Almost nothing is hard coded about the cosmic rays. The tail length can be tuned as well.    
+--Fixed-pattern noise (FPN) is now implemented: 'roman' for Roman FPN found in TVAC, custom input file, or stripe pattern in rows and/or columns. File for Roman FPN included in util folder.    
+--CIC in gain register ("partial CIC") implemented (defaults to no partial CIC). One can specify particular "hot" gain stages with respect to CIC as well.    
+--EM gain simulation now conforms to exact binomial branching process instead of the approximate Gamma distribution. fast_gain_mode allows (fine for gain >~ 200) is available and uses the Gamma distribution.    
+--"Hot" gain stages with respect to EM gain multiplication also implemented. Defaults to None.    
+--Hot pixel map input available.    
 
 
 ## Getting Started

{emccd_detect-2.6.0 → emccd_detect-2.6.2}/emccd_detect.egg-info/top_level.txt

@@ -1,5 +1,5 @@
-build
 data
 dist
 docs
 emccd_detect
+gain_stats_comparison

{emccd_detect-2.6.0 → emccd_detect-2.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "emccd_detect"
-version = "2.6.0"
+version = "2.6.2"
 description = "EMCCD detector image simulation"
 readme = "README.md"
 authors = [