From 726b95cbabe9ddac11f5bfb1226b243cb735ccbd Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Mon, 16 Oct 2023 17:47:05 -0400
Subject: [PATCH 01/15] added vfrac constraint

---
 ehtim/imager.py                   | 34 ++++++++++++++---
 ehtim/imaging/pol_imager_utils.py | 61 ++++++++++++++++++++++---------
 2 files changed, 73 insertions(+), 22 deletions(-)

diff --git a/ehtim/imager.py b/ehtim/imager.py
index 6d285c35..cb2eab4b 100644
--- a/ehtim/imager.py
+++ b/ehtim/imager.py
@@ -50,7 +50,7 @@
 
 
 DATATERMS_POL = ['pvis', 'm', 'pbs','vvis']
-REGULARIZERS_POL = ['msimple', 'hw', 'ptv','l1v','l2v','vtv','vtv2']
+REGULARIZERS_POL = ['msimple', 'hw', 'ptv','l1v','l2v','vtv','vtv2','vflux']
 
 GRIDDER_P_RAD_DEFAULT = 2
 GRIDDER_CONV_FUNC_DEFAULT = 'gaussian'
@@ -93,7 +93,6 @@ def __init__(self, obs_in, init_im,
         self._out_list = []
         self._out_list_epsilon = []
         self._out_list_scattered = []
-        self._flux_list = {}
         self._reg_term_list = []
         self._dat_term_list = []
         self._clipfloor_list = []
@@ -102,6 +101,8 @@ def __init__(self, obs_in, init_im,
         self._maxit_list = []
         self._stop_list = []
         self._flux_list = []
+        self._pflux_list = []
+        slef._vflux_list = []
         self._snrcut_list = []
         self._debias_list = []
         self._systematic_noise_list = []
@@ -110,7 +111,7 @@ def __init__(self, obs_in, init_im,
         self._weighting_list = []
 
         # Regularizer/data terms for the next imaging iteration
-        self.reg_term_next = reg_term  # e.g. [('simple',1), ('l1',10), ('flux',500), ('cm',500)]
+        self.reg_term_next = reg_term   # e.g. [('simple',1), ('l1',10), ('flux',500), ('cm',500)]
         self.dat_term_next = data_term  # e.g. [('amp', 1000), ('cphase',100)]
 
         # Observations, frequencies
@@ -135,6 +136,9 @@ def __init__(self, obs_in, init_im,
         else:
             self.flux_next = flux
 
+        self.pflux_next = kwargs.get('pflux', self.prior_next.lin_polfrac()*self.prior_next.total_flux())
+        self.vflux_next = kwargs.get('vflux', self.prior_next.circ_polfrac()*self.prior_next.total_flux())
+                
         # Polarization
         self.pol_next = kwargs.get('pol', self.init_next.pol_prim)
 
@@ -753,6 +757,22 @@ def flux_last(self):
             return
         return self._flux_list[-1]
 
+    def pflux_last(self):
+        """Return last total linear polarimetric flux constraint.
+        """
+        if self.nruns == 0:
+            print("No imager runs yet!")
+            return
+        return self._pflux_list[-1]
+
+    def vflux_last(self):
+        """Return last total circular polarimetric flux constraint.
+        """
+        if self.nruns == 0:
+            print("No imager runs yet!")
+            return
+        return self._vflux_list[-1]
+
     def clipfloor_last(self):
         """Return last clip floor.
         """
@@ -1175,7 +1195,8 @@ def make_reg_dict(self, imcur):
         
             # Polarimetric regularizer
             if regname in REGULARIZERS_POL:
-                reg = polutils.polregularizer(imcur, self._embed_mask, self.flux_next,
+                reg = polutils.polregularizer(imcur, self._embed_mask, 
+                                              self.flux_next, self.pflux_next, self.vflux_next,
                                               self.prior_next.xdim, self.prior_next.ydim,
                                               self.prior_next.psize, regname,
                                               norm_reg=self.norm_reg, beam_size=self.beam_size,
@@ -1265,7 +1286,8 @@ def make_reggrad_dict(self, imcur):
 
             # Polarimetric regularizer
             if regname in REGULARIZERS_POL:
-                reg = polutils.polregularizergrad(imcur, self._embed_mask, self.flux_next,
+                reg = polutils.polregularizergrad(imcur, self._embed_mask, 
+                                                  self.flux_next, self.pflux_next, self.vflux_next,
                                                   self.prior_next.xdim, self.prior_next.ydim,
                                                   self.prior_next.psize, regname,
                                                   norm_reg=self.norm_reg, beam_size=self.beam_size,
@@ -1970,6 +1992,8 @@ def _append_image_history(self, outim, logstr):
         self._systematic_cphase_noise_list.append(self.systematic_cphase_noise_next)
         self._snrcut_list.append(self.snrcut_next)
         self._flux_list.append(self.flux_next)
+        self._pflux_list.append(self.pflux_next)
+        self._vflux_list.append(self.vflux_next)        
         self._pol_list.append(self.pol_next)
         self._clipfloor_list.append(self.clipfloor_next)
         self._maxset_list.append(self.clipfloor_next)
diff --git a/ehtim/imaging/pol_imager_utils.py b/ehtim/imaging/pol_imager_utils.py
index eaddaef6..8c729e1e 100644
--- a/ehtim/imaging/pol_imager_utils.py
+++ b/ehtim/imaging/pol_imager_utils.py
@@ -61,7 +61,7 @@
 STOP = 1.e-100 # convergence criterion
 
 DATATERMS_POL = ['pvis', 'm', 'pbs','vvis']
-REGULARIZERS_POL = ['msimple', 'hw', 'ptv','l1v','l2v','vtv','v2tv2']
+REGULARIZERS_POL = ['msimple', 'hw', 'ptv','l1v','l2v','vtv','v2tv2','vflux']
 
 nit = 0 # global variable to track the iteration number in the plotting callback
 
@@ -680,6 +680,8 @@ def polregularizer(imtuple, mask, flux, xdim, ydim, psize, stype, **kwargs):
         reg = -stv_pol(imtuple, flux, xdim, ydim, psize, pol_trans, 
                        norm_reg=norm_reg, beam_size=beam_size)
     # circular
+    elif stype == 'vflux':
+        reg = -svflux(imtuple, vflux, norm_reg=norm_reg)    
     elif stype == "l1v":
         reg = -sl1v(imtuple, flux, pol_trans, norm_reg=norm_reg)
     elif stype == "l2v":
@@ -723,6 +725,8 @@ def polregularizergrad(imtuple, mask, flux, xdim, ydim, psize, stype, **kwargs):
                 reggrad = np.array((reggrad[0][mask],reggrad[1][mask],reggrad[2][mask]))
 
     # circular
+    elif stype == 'vflux':
+        reg = -svfluxgrad(imtuple, vflux, pol_trans, norm_reg=norm_reg)        
     elif stype == "l1v":
         reggrad = -sl1vgrad(imtuple, flux, pol_trans, pol_solve=pol_solve, norm_reg=norm_reg)
     elif stype == "l2v":
@@ -1527,10 +1531,33 @@ def stv_pol_grad(imtuple, flux, nx, ny, psize, pol_trans=True, pol_solve=(0,1,1)
 
 # circular polarization
 # TODO check!!
-def sl1v(imtuple, flux, pol_trans=True, norm_reg=NORM_REGULARIZER):
+def svflux(imtuple, vflux, pol_trans=True, norm_reg=NORM_REGULARIZER):
+    """Total flux constraint
+    """
+    if norm_reg: norm = np.abs(vflux)**2
+    else: norm = 1
+    
+    vimage = make_v_image(imtuple, pol_trans) 
+    
+    out = -(np.sum(vimage) - vflux)**2
+    return out/norm
+
+
+def svfluxgrad(imtuple, vflux, pol_trans=True, norm_reg=NORM_REGULARIZER):
+    """Total flux constraint gradient
+    """
+    if norm_reg: norm = np.abs(vflux)**2
+    else: norm = 1
+    
+    vimage = make_v_image(imtuple, pol_trans) 
+
+    out = -2*(np.sum(vimage) - vflux)*np.ones(len(vimage))
+    return out / norm
+    
+def sl1v(imtuple, vflux, pol_trans=True, norm_reg=NORM_REGULARIZER):
     """L1 norm regularizer on V
     """
-    if norm_reg: norm = flux
+    if norm_reg: norm = np.abs(vflux)
     else: norm = 1
 
     vimage = make_v_image(imtuple, pol_trans) 
@@ -1538,10 +1565,10 @@ def sl1v(imtuple, flux, pol_trans=True, norm_reg=NORM_REGULARIZER):
     return l1/norm
 
 
-def sl1vgrad(imtuple, flux, pol_trans=True, pol_solve=(0,0,0,1),  norm_reg=NORM_REGULARIZER):
+def sl1vgrad(imtuple, vflux, pol_trans=True, pol_solve=(0,0,0,1),  norm_reg=NORM_REGULARIZER):
     """L1 norm gradient
     """
-    if norm_reg: norm = flux
+    if norm_reg: norm = np.abs(flux)
     else: norm = 1
      
     iimage = imtuple[0]    
@@ -1570,10 +1597,10 @@ def sl1vgrad(imtuple, flux, pol_trans=True, pol_solve=(0,0,0,1),  norm_reg=NORM_
     
     return out/norm
     
-def sl2v(imtuple, flux, pol_trans=True, norm_reg=NORM_REGULARIZER):
+def sl2v(imtuple, vflux, pol_trans=True, norm_reg=NORM_REGULARIZER):
     """L1 norm regularizer on V
     """
-    if norm_reg: norm = flux
+    if norm_reg: norm = np.abs(vflux**2)
     else: norm = 1
 
     iimage = imtuple[0]    
@@ -1582,10 +1609,10 @@ def sl2v(imtuple, flux, pol_trans=True, norm_reg=NORM_REGULARIZER):
     return l2/norm
 
 
-def sl2vgrad(imtuple, flux, pol_trans=True, pol_solve=(0,0,0,1), norm_reg=NORM_REGULARIZER):
+def sl2vgrad(imtuple, vflux, pol_trans=True, pol_solve=(0,0,0,1), norm_reg=NORM_REGULARIZER):
     """L2 norm gradient
     """
-    if norm_reg: norm = flux
+    if norm_reg: norm = np.abs(vflux**2)
     else: norm = 1
 
     iimage = imtuple[0]    
@@ -1614,12 +1641,12 @@ def sl2vgrad(imtuple, flux, pol_trans=True, pol_solve=(0,0,0,1), norm_reg=NORM_R
             
     return out/norm    
 
-def stv_v(imtuple, flux, nx, ny, psize, pol_trans=True, 
+def stv_v(imtuple, vflux, nx, ny, psize, pol_trans=True, 
           norm_reg=NORM_REGULARIZER, beam_size=None, epsilon=0.):
     """Total variation of I*vfrac"""
     
     if beam_size is None: beam_size = psize
-    if norm_reg: norm = flux*psize / beam_size
+    if norm_reg: norm = np.abs(vflux)*psize / beam_size
     else: norm = 1
 
     vimage = make_v_image(imtuple, pol_trans)
@@ -1631,12 +1658,12 @@ def stv_v(imtuple, flux, nx, ny, psize, pol_trans=True,
     S = -np.sum(np.sqrt(np.abs(im_l1 - im)**2 + np.abs(im_l2 - im)**2+epsilon))
     return S/norm
 
-def stv_v_grad(imtuple, flux, nx, ny, psize, pol_trans=True, pol_solve=(0,0,0,1), 
+def stv_v_grad(imtuple, vflux, nx, ny, psize, pol_trans=True, pol_solve=(0,0,0,1), 
              norm_reg=NORM_REGULARIZER, beam_size=None, epsilon=0.):
     """Total variation gradient"""
 
     if beam_size is None: beam_size = psize
-    if norm_reg: norm = flux*psize / beam_size
+    if norm_reg: norm = np.abs(vflux)*psize / beam_size
     else: norm = 1
 
     iimage = imtuple[0]   
@@ -1694,7 +1721,7 @@ def stv_v_grad(imtuple, flux, nx, ny, psize, pol_trans=True, pol_solve=(0,0,0,1)
 
     return out/norm
 
-def stv2_v(imtuple, flux, nx, ny, psize, pol_trans=True, 
+def stv2_v(imtuple, vflux, nx, ny, psize, pol_trans=True, 
            norm_reg=NORM_REGULARIZER, beam_size=None):
     """Squared Total variation of I*vfrac
     """
@@ -1702,7 +1729,7 @@ def stv2_v(imtuple, flux, nx, ny, psize, pol_trans=True,
     if beam_size is None:
         beam_size = psize
     if norm_reg:
-        norm = psize**4 * flux**2 / beam_size**4
+        norm = psize**4 * np.abs(vflux**2) / beam_size**4
     else:
         norm = 1
 
@@ -1715,14 +1742,14 @@ def stv2_v(imtuple, flux, nx, ny, psize, pol_trans=True,
     out = -np.sum((im_l1 - im)**2 + (im_l2 - im)**2)
     return out/norm
 
-def stv2_v_grad(imtuple, flux, nx, ny, psize, pol_trans=True, pol_solve=(0,0,0,1), 
+def stv2_v_grad(imtuple, vflux, nx, ny, psize, pol_trans=True, pol_solve=(0,0,0,1), 
                norm_reg=NORM_REGULARIZER, beam_size=None):
     """Squared Total variation gradient
     """
     if beam_size is None:
         beam_size = psize
     if norm_reg:
-        norm = psize**4 * flux**2 / beam_size**4
+        norm = psize**4 * np.abs(vflux**2) / beam_size**4
     else:
         norm = 1
 

From 585351c15bbb785ed8e4c1e8498197e9bff9fe71 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Tue, 17 Oct 2023 19:23:43 -0400
Subject: [PATCH 02/15] fixed dtype=object issue for latest numpy in selfcal

---
 ehtim/calibrating/network_cal.py  | 13 +++---
 ehtim/calibrating/self_cal.py     |  3 +-
 ehtim/imager.py                   |  8 ++--
 ehtim/imaging/pol_imager_utils.py | 71 ++++++++++++++++++++-----------
 4 files changed, 59 insertions(+), 36 deletions(-)

diff --git a/ehtim/calibrating/network_cal.py b/ehtim/calibrating/network_cal.py
index 814253e9..8fa1cedc 100644
--- a/ehtim/calibrating/network_cal.py
+++ b/ehtim/calibrating/network_cal.py
@@ -124,13 +124,12 @@ def network_cal(obs, zbl, sites=[], zbl_uvdist_max=ZBLCUTOFF, method="amp", mini
     # loop over scans and calibrate
     tstart = time.time()
     if processes > 0:  # with multiprocessing
-        scans_cal = pool.map(get_network_scan_cal,
-                             [[i, len(scans), scans[i],
-                               zbl, sites, cluster_data, obs.polrep, pol,
-                               method, pad_amp, gain_tol,
-                               caltable, show_solution, debias, msgtype]
-                              for i in range(len(scans))
-                              ])
+        scans_cal = np.array(pool.map(get_network_scan_cal, [[i, len(scans), scans[i],
+                                                              zbl, sites, cluster_data, obs.polrep, pol,
+                                                              method, pad_amp, gain_tol,
+                                                              caltable, show_solution, debias, msgtype
+                                                             ] for i in range(len(scans))]),
+                                                             dtype=object)
     else:  # without multiprocessing
         for i in range(len(scans)):
             obsh.prog_msg(i, len(scans), msgtype=msgtype, nscan_last=i - 1)
diff --git a/ehtim/calibrating/self_cal.py b/ehtim/calibrating/self_cal.py
index 42acd7a3..90d8e9d9 100644
--- a/ehtim/calibrating/self_cal.py
+++ b/ehtim/calibrating/self_cal.py
@@ -165,7 +165,8 @@ def self_cal(obs, im, sites=[], pol='I', apply_singlepol=False, method="both",
                                                               show_solution, pad_amp, gain_tol,
                                                               debias, caltable, msgtype,
                                                               use_grad
-                                                              ] for i in range(len(scans))]))
+                                                              ] for i in range(len(scans))]),
+                                                              dtype=object)
 
     else:  # run on a single core
         for i in range(len(scans)):
diff --git a/ehtim/imager.py b/ehtim/imager.py
index cb2eab4b..bae00748 100644
--- a/ehtim/imager.py
+++ b/ehtim/imager.py
@@ -102,7 +102,7 @@ def __init__(self, obs_in, init_im,
         self._stop_list = []
         self._flux_list = []
         self._pflux_list = []
-        slef._vflux_list = []
+        self._vflux_list = []
         self._snrcut_list = []
         self._debias_list = []
         self._systematic_noise_list = []
@@ -136,8 +136,10 @@ def __init__(self, obs_in, init_im,
         else:
             self.flux_next = flux
 
-        self.pflux_next = kwargs.get('pflux', self.prior_next.lin_polfrac()*self.prior_next.total_flux())
-        self.vflux_next = kwargs.get('vflux', self.prior_next.circ_polfrac()*self.prior_next.total_flux())
+        # set polarimetric flux values equal to Stokes I flux by default
+        # used in regularizer normalization
+        self.pflux_next = kwargs.get('pflux', flux)
+        self.vflux_next = kwargs.get('vflux', flux)
                 
         # Polarization
         self.pol_next = kwargs.get('pol', self.init_next.pol_prim)
diff --git a/ehtim/imaging/pol_imager_utils.py b/ehtim/imaging/pol_imager_utils.py
index 8c729e1e..27063965 100644
--- a/ehtim/imaging/pol_imager_utils.py
+++ b/ehtim/imaging/pol_imager_utils.py
@@ -217,21 +217,19 @@ def chisq2grad(imtuple):
 
     # Define the regularizer and regularizer gradient
     def reg1(imtuple):
-        return polregularizer(imtuple, embed_mask, flux, 
+        return polregularizer(imtuple, embed_mask, flux, flux, flux,
                               Prior.xdim, Prior.ydim, Prior.psize, s1, **kwargs)
-        return polregularizer(imtuple, embed_mask, Prior.xdim, Prior.ydim, Prior.psize, s1, 
-                              pol_trans=pol_trans,norm_reg=norm_reg)
 
     def reg1grad(imtuple):
-        return polregularizergrad(imtuple, embed_mask, flux, 
+        return polregularizergrad(imtuple, embed_mask, flux, flux, flux,
                                   Prior.xdim, Prior.ydim, Prior.psize, s1, **kwargs)
 
     def reg2(imtuple):
-        return polregularizer(imtuple, embed_mask, flux, 
+        return polregularizer(imtuple, embed_mask, flux, flux, flux,
                               Prior.xdim, Prior.ydim, Prior.psize, s2, **kwargs)
 
     def reg2grad(imtuple):
-        return  polregularizergrad(imtuple, embed_mask, flux, 
+        return  polregularizergrad(imtuple, embed_mask, flux, flux, flux, 
                                    Prior.xdim, Prior.ydim, Prior.psize, s2, **kwargs)
 
 
@@ -663,7 +661,7 @@ def polchisqgrad(imtuple, A, data, sigma, dtype, ttype='direct',
     return chisqgrad
 
 
-def polregularizer(imtuple, mask, flux, xdim, ydim, psize, stype, **kwargs):
+def polregularizer(imtuple, mask, flux, pflux, vflux, xdim, ydim, psize, stype, **kwargs):
 
     norm_reg = kwargs.get('norm_reg', NORM_REGULARIZER)
     pol_trans = kwargs.get('pol_trans', True)
@@ -683,25 +681,25 @@ def polregularizer(imtuple, mask, flux, xdim, ydim, psize, stype, **kwargs):
     elif stype == 'vflux':
         reg = -svflux(imtuple, vflux, norm_reg=norm_reg)    
     elif stype == "l1v":
-        reg = -sl1v(imtuple, flux, pol_trans, norm_reg=norm_reg)
+        reg = -sl1v(imtuple, vflux, pol_trans, norm_reg=norm_reg)
     elif stype == "l2v":
-        reg = -sl2v(imtuple, flux, pol_trans, norm_reg=norm_reg)
+        reg = -sl2v(imtuple, vflux, pol_trans, norm_reg=norm_reg)
     elif stype == "vtv":
         if np.any(np.invert(mask)):
             imtuple = embed_pol(imtuple, mask, randomfloor=True)
-        reg = -stv_v(imtuple, flux, xdim, ydim, psize, pol_trans, 
+        reg = -stv_v(imtuple, vflux, xdim, ydim, psize, pol_trans, 
                      norm_reg=norm_reg, beam_size=beam_size)
     elif stype == "vtv2":
         if np.any(np.invert(mask)):
             imtuple = embed_pol(imtuple, mask, randomfloor=True)
-        reg = -stv2_v(imtuple, flux, xdim, ydim, psize, pol_trans, 
+        reg = -stv2_v(imtuple, vflux, xdim, ydim, psize, pol_trans, 
                       norm_reg=norm_reg, beam_size=beam_size)                               
     else:
         reg = 0
 
     return reg
 
-def polregularizergrad(imtuple, mask, flux, xdim, ydim, psize, stype, **kwargs):
+def polregularizergrad(imtuple, mask, flux, pflux, vflux, xdim, ydim, psize, stype, **kwargs):
 
     norm_reg = kwargs.get('norm_reg', NORM_REGULARIZER)
     pol_trans = kwargs.get('pol_trans', True)
@@ -726,22 +724,22 @@ def polregularizergrad(imtuple, mask, flux, xdim, ydim, psize, stype, **kwargs):
 
     # circular
     elif stype == 'vflux':
-        reg = -svfluxgrad(imtuple, vflux, pol_trans, norm_reg=norm_reg)        
+        reggrad = -svfluxgrad(imtuple, vflux, pol_trans, pol_solve=pol_solve, norm_reg=norm_reg)        
     elif stype == "l1v":
-        reggrad = -sl1vgrad(imtuple, flux, pol_trans, pol_solve=pol_solve, norm_reg=norm_reg)
+        reggrad = -sl1vgrad(imtuple, vflux, pol_trans, pol_solve=pol_solve, norm_reg=norm_reg)
     elif stype == "l2v":
-        reggrad = -sl2vgrad(imtuple, flux, pol_trans, pol_solve=pol_solve, norm_reg=norm_reg)    
+        reggrad = -sl2vgrad(imtuple, vflux, pol_trans, pol_solve=pol_solve, norm_reg=norm_reg)    
     elif stype == "vtv":
         if np.any(np.invert(mask)):
             imtuple = embed_pol(imtuple, mask, randomfloor=True)
-        reggrad = -stv_v_grad(imtuple, flux, xdim, ydim, psize, pol_trans,
+        reggrad = -stv_v_grad(imtuple, vflux, xdim, ydim, psize, pol_trans,
                               pol_solve=pol_solve, norm_reg=norm_reg, beam_size=beam_size)
         if np.any(np.invert(mask)):
             reggrad = np.array((reggrad[0][mask],reggrad[1][mask],reggrad[2][mask],reggrad[3][mask]))
     elif stype == "vtv2":
         if np.any(np.invert(mask)):
             imtuple = embed_pol(imtuple, mask, randomfloor=True)
-        reggrad = -stv2_v_grad(imtuple, flux, xdim, ydim, psize, pol_trans, 
+        reggrad = -stv2_v_grad(imtuple, vflux, xdim, ydim, psize, pol_trans, 
                                pol_solve=pol_solve, norm_reg=norm_reg, beam_size=beam_size)
         if np.any(np.invert(mask)):
             reggrad = np.array((reggrad[0][mask],reggrad[1][mask],reggrad[2][mask],reggrad[3][mask]))
@@ -1543,16 +1541,39 @@ def svflux(imtuple, vflux, pol_trans=True, norm_reg=NORM_REGULARIZER):
     return out/norm
 
 
-def svfluxgrad(imtuple, vflux, pol_trans=True, norm_reg=NORM_REGULARIZER):
+def svfluxgrad(imtuple, vflux, pol_trans=True,  pol_solve=(0,0,0,1), norm_reg=NORM_REGULARIZER):
     """Total flux constraint gradient
     """
     if norm_reg: norm = np.abs(vflux)**2
     else: norm = 1
     
+
+    iimage = imtuple[0]    
+    zeros  =  np.zeros(len(iimage))
     vimage = make_v_image(imtuple, pol_trans) 
+    grad = -2*(np.sum(vimage) - vflux)*np.ones(len(vimage))
+
+        
+    if pol_trans:
+
+        # dS/dI Numerators
+        if pol_solve[0]!=0:
+            igrad = (vimage/iimage)*grad
+        else:
+            igrad = zeros
+
+        # dS/dv numerators
+        if pol_solve[3]!=0:
+            vgrad = iimage*grad
+        else: 
+            vgrad=zeros
+
 
-    out = -2*(np.sum(vimage) - vflux)*np.ones(len(vimage))
-    return out / norm
+        out = np.array((igrad, zeros, zeros, vgrad))
+    else:
+        raise Exception("polarimetric representation %s not added to pol gradient yet!" % pol_trans)            
+    
+    return out/norm
     
 def sl1v(imtuple, vflux, pol_trans=True, norm_reg=NORM_REGULARIZER):
     """L1 norm regularizer on V
@@ -1568,7 +1589,7 @@ def sl1v(imtuple, vflux, pol_trans=True, norm_reg=NORM_REGULARIZER):
 def sl1vgrad(imtuple, vflux, pol_trans=True, pol_solve=(0,0,0,1),  norm_reg=NORM_REGULARIZER):
     """L1 norm gradient
     """
-    if norm_reg: norm = np.abs(flux)
+    if norm_reg: norm = np.abs(vflux)
     else: norm = 1
      
     iimage = imtuple[0]    
@@ -1584,7 +1605,7 @@ def sl1vgrad(imtuple, vflux, pol_trans=True, pol_solve=(0,0,0,1),  norm_reg=NORM
         else:
             igrad = zeros
 
-        # dS/dm numerators
+        # dS/dv numerators
         if pol_solve[3]!=0:
             vgrad = iimage*grad
         else: 
@@ -1628,7 +1649,7 @@ def sl2vgrad(imtuple, vflux, pol_trans=True, pol_solve=(0,0,0,1), norm_reg=NORM_
         else:
             igrad = zeros
 
-        # dS/dm numerators
+        # dS/dv numerators
         if pol_solve[3]!=0:
             vgrad = iimage*grad
         else: 
@@ -1706,7 +1727,7 @@ def stv_v_grad(imtuple, vflux, nx, ny, psize, pol_trans=True, pol_solve=(0,0,0,1
         else:
             igrad = zeros
 
-        # dS/dm numerators
+        # dS/dv numerators
         if pol_solve[3]!=0:
             vgrad = iimage*grad
         else: 
@@ -1787,7 +1808,7 @@ def stv2_v_grad(imtuple, vflux, nx, ny, psize, pol_trans=True, pol_solve=(0,0,0,
         else:
             igrad = zeros
 
-        # dS/dm numerators
+        # dS/dv numerators
         if pol_solve[3]!=0:
             vgrad = iimage*grad
         else: 

From f8d21115cfe871371abb025a41ad6e47936ebc8a Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Thu, 1 Feb 2024 16:16:52 -0500
Subject: [PATCH 03/15] added ignore_pzero_date option

---
 ehtim/calibrating/pol_cal.py        |   3 +-
 ehtim/io/load.py                    |  13 +-
 ehtim/obsdata.py                    |   7 +-
 ehtim/observing/obs_simulate.py     |  11 +-
 tutorials/space_vlbi_tutorial.ipynb | 190 ++++++++--------------------
 5 files changed, 80 insertions(+), 144 deletions(-)

diff --git a/ehtim/calibrating/pol_cal.py b/ehtim/calibrating/pol_cal.py
index 46f1f145..5a310c3d 100644
--- a/ehtim/calibrating/pol_cal.py
+++ b/ehtim/calibrating/pol_cal.py
@@ -65,7 +65,8 @@ def leakage_cal(obs, im=None, sites=[], leakage_tol=.1, pol_fit=['RL', 'LR'], dt
            fft_pad_factor (float): zero pad the image to fft_pad_factor * image size in FFT
 
            show_solution (bool): if True, display the solution as it is calculated
-
+           obs_apply (Obsdata): apply the solution to another observation
+           
        Returns:
            (Obsdata): the calibrated observation, with computed leakage values added to the obs.tarr
     """
diff --git a/ehtim/io/load.py b/ehtim/io/load.py
index ffd1ca6b..8e38a4f5 100644
--- a/ehtim/io/load.py
+++ b/ehtim/io/load.py
@@ -1003,9 +1003,11 @@ def load_obs_txt(filename, polrep='stokes'):
     return out
 
 # TODO can we save new telescope array terms and flags to uvfits and load them?
+# TODO uv coordinates, multiply by IF freqs and not header FREQ? 
 def load_obs_uvfits(filename, polrep='stokes', flipbl=False,
                     allow_singlepol=True, force_singlepol=None,
                     channel=all, IF=all, remove_nan=False,
+                    ignore_pzero_date=True,
                     trial_speedups=False):
     """Load observation data from a uvfits file.
 
@@ -1019,6 +1021,9 @@ def load_obs_uvfits(filename, polrep='stokes', flipbl=False,
            channel (list): list of channels to average in the import. channel=all averages all
            IF (list): list of IFs to  average in  the import. IF=all averages all
            remove_nan (bool): whether or not to remove entries with nan data
+           
+           ignore_pzero_date (bool): if True, ignore the offset parameters in DATE field 
+                                     TODO: what is the correct behavior per AIPS memo 117?
        Returns:
            obs (Obsdata): Obsdata object loaded from file
     """
@@ -1243,7 +1248,7 @@ def load_obs_uvfits(filename, polrep='stokes', flipbl=False,
         jd1zero = header["PZERO%d"%(paridx)]
     else:
         jd1zero = 0.0
-    if "PSCAL%d"%(paridx) in header.keys():
+    if "PSCAL%d"%(paridx+1) in header.keys():
         jd2scal = header["PSCAL%d"%(paridx+1)]
     else:
         jd2scal = 1.0
@@ -1252,6 +1257,12 @@ def load_obs_uvfits(filename, polrep='stokes', flipbl=False,
     else:
         jd2zero = 0.0
     
+    if ignore_pzero_date:
+        if jd1zero!=0. or jd2zero!=0.:
+            print("Warning! ignoring nonzero header PZERO values for DATE. Check your observation mjd/times!")
+        jd1zero = 0.
+        jd2zero = 0.
+        
     jds = jd1scal * data['DATE'][mask].astype('d') + jd1zero
     jds += jd2scal * data['_DATE'][mask].astype('d') + jd2zero
 
diff --git a/ehtim/obsdata.py b/ehtim/obsdata.py
index 08e2e1cb..33b57fa0 100644
--- a/ehtim/obsdata.py
+++ b/ehtim/obsdata.py
@@ -4758,6 +4758,7 @@ def load_txt(fname, polrep='stokes'):
 
 def load_uvfits(fname, flipbl=False, remove_nan=False, force_singlepol=None,
                 channel=all, IF=all, polrep='stokes', allow_singlepol=True,
+                ignore_pzero_date=True,
                 trial_speedups=False):
     """Load observation data from a uvfits file.
 
@@ -4769,7 +4770,10 @@ def load_uvfits(fname, flipbl=False, remove_nan=False, force_singlepol=None,
            force_singlepol (str): 'R' or 'L' to load only 1 polarization
            channel (list): list of channels to average in the import. channel=all averages all
            IF (list): list of IFs to  average in  the import. IF=all averages all IFS
-
+           remove_nan (bool): whether or not to remove entries with nan data
+           
+           ignore_pzero_date (bool): if True, ignore the offset parameters in DATE field 
+                                     TODO: what is the correct behavior per AIPS memo 117?
        Returns:
            obs (Obsdata): Obsdata object loaded from file
     """
@@ -4777,6 +4781,7 @@ def load_uvfits(fname, flipbl=False, remove_nan=False, force_singlepol=None,
     return ehtim.io.load.load_obs_uvfits(fname, flipbl=flipbl, force_singlepol=force_singlepol,
                                          channel=channel, IF=IF, polrep=polrep,
                                          remove_nan=remove_nan, allow_singlepol=allow_singlepol,
+                                         ignore_pzero_date=ignore_pzero_date,
                                          trial_speedups=trial_speedups)
 
 
diff --git a/ehtim/observing/obs_simulate.py b/ehtim/observing/obs_simulate.py
index 42635fe0..1d3d2e6a 100644
--- a/ehtim/observing/obs_simulate.py
+++ b/ehtim/observing/obs_simulate.py
@@ -757,9 +757,10 @@ def make_jones(obs, opacitycal=True, ampcal=True, phasecal=True, dcal=True,
 
         # Assemble the Jones Matrices and save to dictionary
         j_matrices = {times[j]: np.array([
-            [np.exp(-1j*fr_angle[j])*gainR[j], np.exp(1j*(fr_angle[j]+fr_angle_D[j]))*dR*gainR[j]],
-            [np.exp(-1j*(fr_angle[j]+fr_angle_D[j]))*dL *
-             gainL[j], np.exp(1j*fr_angle[j])*gainL[j]]
+            [np.exp(-1j*fr_angle[j])*gainR[j], 
+             np.exp(1j*(fr_angle[j]+fr_angle_D[j]))*dR*gainR[j]],
+            [np.exp(-1j*(fr_angle[j]+fr_angle_D[j]))*dL*gainL[j],
+             np.exp(1j*fr_angle[j])*gainL[j]]
         ])
             for j in range(len(times))
         }
@@ -1078,8 +1079,8 @@ def apply_jones_inverse(obs, opacitycal=True, dcal=True, frcal=True, verbose=Tru
 
        Args:
            opacitycal (bool): if False, estimated opacity terms are applied in the inverse gains
-           dcal (bool): if False, estimated inverse d-terms applied to the inverse Jones matrices
-           frcal (bool): if False, inverse feed rotation angle terms are applied to Jones matrices.
+           dcal (bool): if False, estimated d-terms applied to the inverse Jones matrices
+           frcal (bool): if False, feed rotation angle terms are applied to Jones matrices.
            verbose (bool): print updates and warnings
 
        Returns:
diff --git a/tutorials/space_vlbi_tutorial.ipynb b/tutorials/space_vlbi_tutorial.ipynb
index 526b742b..7fdbbac4 100644
--- a/tutorials/space_vlbi_tutorial.ipynb
+++ b/tutorials/space_vlbi_tutorial.ipynb
@@ -3,14 +3,14 @@
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "80df3aa1",
+   "id": "7c57f0f5",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Welcome to eht-imaging! v 1.2.4 \n",
+      "Welcome to eht-imaging! v 1.2.7 \n",
       "\n"
      ]
     }
@@ -26,14 +26,14 @@
   {
    "cell_type": "code",
    "execution_count": 2,
-   "id": "061e425a",
+   "id": "b2e78161",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "60083.827770977245\n"
+      "60275.79784521178\n"
      ]
     }
    ],
@@ -44,8 +44,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "c1f03554",
+   "execution_count": 3,
+   "id": "b6a02745",
    "metadata": {
     "scrolled": true
    },
@@ -54,12 +54,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Loading text image:  ./models/jason_mad_eofn.txt\n"
+      "Loading text image:  ../models/jason_mad_eofn.txt\n"
      ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAR8AAAD0CAYAAACioyK4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAABs1UlEQVR4nO29e5hlV1nn/1mnTl26urpS6XQ6TUhCE3IjEA03RxmUoKCMog4iznAR8DI4KCjy4+IPR0dxBpEBxWe8DSo3UUdxwPmhKCoQROUWbgEChBBz6XSSSqVSqa6uPn3q1Fm/P9Z+z37PqrX2XvucfeqcDvU+z3nO3muv2957re/+vu9611rGWsue7Mme7MluS2PcFdiTPdmTr0/ZA5892ZM9GYvsgc+e7MmejEX2wGdP9mRPxiJ74LMne7InY5E98NmTPdmTscge+OzJnoxBjDGPM8bcZIx5QcV0zzPGnDDGHA1ce44x5lPGmOuMMW80xpi66jsK2QOfPdmTXRZjzNOBnwXur5judcBRYCFw7ZHAG4HvAr4JeDTwk8PWdZSyBz57sie7L5+01j4bOFEx3W9Za18TufZjwPustSvW2i7wFuA/D1PJUcse+OzJnuyyWGuPxa5latXHjDEfNsb8iTFmMSUd8Djgy+r8BuARxph9w9d4NLIHPnuyJxMixph/C/w68L3W2icCd2TnKXIe/WrcGmCAQ3XWsU7ZA5892ZPJkRcA77XW3pOd/wnwnAqG49BEzYk1OjfHXYE92ZM96ckFwJXGmGuz8yZwN3AOsFKSdhlYUudLODC6JxR5EmQPfPZkTyZHbgduttb+lAQYYw5Za8uAB+CTwOXq/Ergi9baUzXXsTbZU7v2ZE8mR94GfI8x5mwAY8zlwHsT0/4B8N3GmHOMMQ2cCvd7o6hkXWL21vPZkz3ZXTHGPAbnk3M1cBdwg7X2B7JrzwVeDGwCbeCnrbU3Ztd+DPhh4InAx3FD669R+T4HeBnQBf4ReLmd4A6+Bz57sid7MhbZU7v2ZE/2ZCxSaHCeNqYWWlSEcKnoNwqUHAfydkeUb9m9dL3/YWQceYzquYVk2HZRpa4NYMvaysPhT33qU+3KSoodGj71qU+931r71KpljFpGPto17IscFUCMi/IVlbubHWwY0fcwaJ0lj9T0jSHK2m3ZjbqurKxw3XWfSIprzNREOhqOFHyGZTwPFLaTKqG6DdOIQ52gDuCoM78zCVQmSyxn+pMbGnwG6cwPFOCpuyOXlTFMOTEgqrPeVdlM1XS7BVRd6mHso6/r1zH4VH1BZ7p9pw7bFQzPZlLzSAGbQQGjSIYBoUkBoDJJucfR13USnsTgMjD4jAJ4JlUlGhVjqgOEJB/9tR4k/0kBoUkBoCL20/COBwWg4dqVBTpD5TBumRiD8yiBZ9C8Rw2GdXX4lE4yTsNu1Twng1Wkq1/jYWNfpzaf0AsZpqNO4ojWbrKwuhuv32lGof5UlVGwoElRwaCc4YymnpNy94NJJfA5U0Bn2LzHof7VrfYIANVpoK5D6mZBX78A9HXCfFJofVXZA57Ry6Q2zUE64niYRfWRr92t56S+4TQpBZ+6gWe37Ci7nbYumaQv+SilbjXsTHlu9baxM+GO41IIPqP0ixmF1OEWP24AOrObU3UZRA2bdADanXp8nY52jcqxcBJkNMOiw5V9puQ/qNQJQGeaDN6uvk5sPiKTDDqjLqduUNqtZlP39IxRSV1ljcJfaRDZ83Aul2TwOVOYy25L2VBwatxRSF2deRIB6IHEfgaXM/sJ1DLaNU5VZTfLqSq7yW6G8espk91kE3UyoHF3zdHWoT61yxhzF/17fp0LfM1a+321FBCRWka7Qo1zNwFhEgzF45BQ00thYpPm+zOoTFp9qsoETa94t7W2t7WyMeY3gU/XlXlMCu+/6jB7Q/12W2R+U0qc1N+kyzie97hsa+OSYe93tM+rnpbsAc8U8L3Au+uvb79UHu2adIZR9zQFLZN677s9GXOUjOOBOPReJMO1qZHc3ZOBj1lrq+4jX1lGPtr1QJJxqZUpIh0tZvsZ92TRSck7Vh5DlllkcxvN/VSy+Rwyxlynzt9srX1zJO5zgD8apmapsjfaNaBMkp2pzOD/QAGJmNTFfvznNYwX/+4AUHKOK9bax5ZFMsbMA48HfmSYWqXKwAbnPTlz5ExkKeMEtqptfjx9ZCROht8P/JW1drvujEOyq9MrRi2jGmLeTRkVW/l6BqBxAFmM/UCdrLn26RXPAf5r3ZnG5IzZq30cX8GqjWTQRhVKE8vnTPFYnjQpuvdRqdCxMhvqf1KmVxhjDgEXWms/VVumJXJGgM84O0xRw6xzOkBd8VNGvVLiVZVJZz8PTKn1yfwQ8Gd1ZlgmQ4127UajONMa3iBsiYppiiT1HY0ChCYdgMqYyChkdOBZL/Ox1v5ObZklytDTK0YFDpMEOqNWv8bZ+Ot+hw90pjJZdtDxPGljzBHgGcCjgfNwj+Vu4Hrg/1hrb0vJp9TDebcedhWfzDPBE7nOujUivyrph7leVcZpqK8rXp0yujJ331ffGPPzwOeApwGbOMD5DHACeBLwCWPM6zJP6UKpZdPAQW6vapqi+CHVpexrX1UGza9utSql3JhqsduOe3uMKpf667/7i4kZY16VFXqRtfZ0JE4T+E/AfwP+36L8xmJwrhN4holXFyAMm1+ZmjasGpcCzmeSDWhSyqsq9dZvLIuJ/W9r7a0lcS6y1v6uMeaissx2nYWOCngGkbrzHia/YetSpJLFwmL51CmTZSMZv9T7PHZd7XpxQpy3A6TYfXa1bUwS8Oy2pNxLmWpZNnKlj2N2Ij9uzMeozoaxm43s6wvsdh18nm2MuSB20Rjza8C/Sc1s197VpAJPUYceR0MuazIxdSl2PSTjAKFxPc8UOTM/cqJ27Sr43A/8oTHmQh1ojGkaY/4YeBHw71Mz2xWbz6QCD1TzLh4kr2HyS7H16DhlBmjfrlN2jhceyrOqDGNbSrWZ7LZ7wXhkLLtXfHdW6FuMMT9irb3DGLMI/CVwBXCNtfbTqZmN/GM0qcCTahsZNK9h8iuT1GcUA6Wq57G8Rzn8P6zstnvBbufvZNeZz6a19hjwY8BbjTHfAvwzcBj4Zmvtp40xh1MzG/oZpQyB15HXMJLSSVJYi5++CMDGpbL5ErIBFZ376apKlfsf5DmdSbao0Rv1dx18/swYY4A7gBcCfwysAN8GHDPGNKgwRWNkaleVWx4F6KS+4NROUhZWZ3lVRateKapaSN0KqV7DqEh+vlXqU5eklD9JbK2ajGWo/Yn063oGOArcM0hmtYPPOEFnmK+oPq5SrzrYwiDig0wIgGL+RylA46ffDRvPpNpiJgt0tOz60/oc8NKC6wb4jdTMCsGn7Cvq3/o4gGdQG01R+iIWEerQo7IvlD2jMhCJ3Ucq0MQY0SBSl7H4TJPR3c9YmM8rrLUfLopgjHlFamalzEffXhE7mETgGcX1mLpVF30PPe+qz7aqCljGmvw6jZoFlcWrUodJBbN6VM1dH+36WlkEa+0/ABhjjlprbymKW0nt8hvmIDJq4BnUhjNM+YMAUEq+ZWpTTPR7KnpOMeZUBYCqMONQ+iKZVOCYDBkL83lmZnD+DWttOxQhm1D6n4CHUPfcrnEDT5WRqmGulfmJ+Md1AVAK00xRBUNAUmQkL4of+uhUAfmiUbjYdR0vln5S2U/oOY+m/F0Hn/8BvBq43RjzaeBm3Gx2CxzAAc5jcVMs/ktZZrUYnFMewW4CTx1DnFU6Vx0AFAMQv6yijpjCZMqYUBHwDNqJUtSosuvDtp9B1ZzJNTbvPvOx1lrgvxtj3gI8Hbeez0U4Q/My8AHgp1LX8zkjllGFavaXsrCi61W+pqHzKoZoXV6RulXVDlQGHilMqChtWfkxqRtkBgGlVMZVt4yG/dSbozHmx3Hb5lhgEXhJyMBsrb0TGHrlwzMCfAYBnmFVsbKvdOh8WONzDHRSQMg/j9lr8MJjz7YItIryTZGitLHnP4rOW5bnIPbD3WNKtS8g/0zgO4Bvs9ZuG2N+BDhSWwEBGRp8dkvl0pICALHzomtVbBqxMqsyn5j4wBACihATSS0zxGZC4DIsAJXZp6qwoNSwKrKb9qD6y6p1tOsXgR+SPbustW+tM/OQTK5Km0kVhjMs+0kBnAb9nTXGdmL5l9XJzzv2K4tTJMMa02PPIEX8+EV1DoUP8t5S6lRHnrvbmeqb1Z7Nx3o4cLUx5kPGmI8YY35iRBXvyVBOhnVKkWqRcp4KPLE0KcyhrJHGOmvoeuzZhhiPThtjHXV+VXVZIebjXxuk/KL3vRsqV6w+o05TryQ/lbK92o/ijMZPB56Mmyj6CWPM/dba/11HTUOS5GQYe8h1N3b/ODVsWOApSlMlfhFDSC3HF/8ZdwPHof8ytcYXv+6p790HoFCclHLLQKgM6HZTfQpJ6nv16zl4nSvZfMr2ap/FVe1/ZmrXncaYPwJ+FIiCjzHm8cAPZ+l/Bnge8DvZqFipJNl8RvlS6/56VAGqlLJT0sbYT1W1LCZlgFN0XNbYy4A6ZcQrBgZVpAxw/PNxA1CVtjO6OtWW833Z/90q7BgFC4NlatkrgffiVi/cBM4F3gi8LKXQkY92jXo0IZXNFKlHRWWGACQVeGLpY/X1w6uCTkjTT9f8y59LVQBKkTL1sSoATYr47aL+eta6mNhXceBxGLgxCzsXOF6Q5oeBb7TWbhhjPpQxpl8yxnwotdCRg0+o8VRJG0tXlYWEwopsMn6cIhAqKrOovKKyRXwAioFQ1V9IfFWrqL4h21SVL32snBRgK+rM4wCkQVT4eupYTy7W2tPGmHfgFgn7J2PMfuA/AL9anMxuyLEKn0ktdyDwGdSeMEicOkDG/4+xkVCcFPApC/PTh66LmEAY5G93UNDpRMJR+YXqU/QFD6lkfpqq3SOk7oXKjtVpNyTlIxIKr7eetXs4vxz4PWPMp3DN5W3AOwvi32iMeSvwFmCfMeYxODZ0Q2qBQ2+XDIM/gqpMIAVc/LAi8BkWeKoAo4DKVCReURjsZDzbVBtsbRAHolBZVb/mIfuSTjcICBUBUBEw7SYgpTLF0Uh9d2mtPYkDj1T5adzaPX+HMzh/BHgHxev99Ekp+AzDWgZNN6jqlAo6g8ZJATzNXHygKYuzHUijRQNPkxw8ioBIgEaDT5N+AOp4+fvisxEdHgOvUB5l+fvpzxQAGkT0vQ0uY73Dx+CmWPwEzj50T+ool0gh+KSAA1TX8WNhsfNB/svChgEnHRYCkhgoxa6H1JVQGXLuA48+D7GaIibUUcdl77FqhwmxoCptJWRXGpUM0qaL0o9exrKkhpb3Ai+01n4WN6m0sgyldqVej8UbBnz8DpwKSFVAqSxPX5UqA6YQYwqdi4RUNcgZktRRQEifhxhPyO7TUOHyH7oXXdeYjacbOB4UgEJxqzChKmXFPowpYFxFamVn1kJn1xcT0/IRa+2OxeKNMddYa69NyaCy2jUswodYQdG1sn85rit+qF7DSAyYRAz9QwUxidUvxH7kvEO/SqaBKARAqLCiOsPODl/2zKoATiz/0H8ovd/B65SJyq87VubzPmPMzwP/H24zQZHXAo9PySBJ7RrmAcW+KqFrVZhP0X9RXUL02u9ARY3d/9IaciYSyktfi9WJwPUGDjSMF6bVNxHf5qPPtyLHmg0JUOmfBiZdT19C9wz9zynGlPz79c9TAWgoBlEgwzCnkYsFtscKPr+V/f+KF55s9xlqqH3QNCmMxz8fFAhDdoOihh2KF/r36+cDEORvYVvF943Ksa835EAjoOmfixTZgKayMDnW4NNRcTXwtOkHIP08dP3wrqWwoSrdJeU9laUblcTaYdk911c3O27m82Fr7ZP8QGPM+1MzSFa7BkX3VKCpwpBi4rMXSZvy8gdlQA3165AzlSJVRH8aYnajmISAyL8P2MmGNJjINVHLtskBRzMhDUJ+HeRf513EbkLvJkWKQK2I/YwCgMoYWxEgjQQm7FjB5zsj4U9NzWBgD+c62c+wtDXWsFO+liGQCtXND2vQn7+OJ+AScxiEnQZozYhi4KIZ03R2rZn9ZrLrEt7IEna7OchssVO1agMt9dOg46tjmgXpZ6GZFl6cEOv08yiTEAD5x2XpQnWpU3Zd9bLjZT7W2q3IpQ8A356SR2XwqYMBDaM6DdIIdZyyxljUYEMqYOjYTxc6l9EpeQG+HcdPq0FmHtgH7GvA3BzMzLj/ZpZZt5v/tFlAPpTdrhso6XRgqwObHTiJm9zTivx8W5BIiOGF2ElIBgWg0HlRWCy/KvUp+yCVSe3sxzLW0S5jTJcK9p2QVBpqr0v18qXIPlDEaPxjv8wqrCcWVtS5NOsp6mR+GZo5Qc6QLP1g1Mj+Z4E59dvfhKUlOLAAi4s58DQarj222+4nIAPumsQRYOp0HDhtd+DEBpxYh1bbgdBJYI0clIQhtQmrWjH1L6QqhZ5JioTe6SBMqix/Pywl3e7L2G0+Hwf+ozo/G/huYDU1g+QlNep8wEWNVUuMhVQxOKaAgt+QY/9yXHQ9Jn49pMyOCp/CAZGAzgxuP5KzgKW5fpYzN+cA6NAhFyYijEbARf/rONtdx4RMA/bPw8YG3L8O003Hhk6sw/FlWMeBzwYOjASItI3Ivz/NMovAJvYei95z2YenKqMpyn+iZfyjXU+y1rbU+a3AZ40xfwX8XkoGu7KAfNmXsSidjpP6qEMdIVRWqhoVOg6BUFEZ2rDspzM4W80Uit0AC8B8w4HM4cPuf2bGMZiZGdi/4MJmZ3KVCxy4nG47RtNu9zOcdju/1mo5oGk0svzmXT7drstzbs7FabVgfR3uIgcgASUNQqlAEwLhqpKihqXUZZByQ/8p9ahXxs58Drv9A3syCzwSuCI1g0orGQ7DgIpUqyIpe5kpdSoCnRiohMLlvEk/cITmY/nXJQ9/moXkJ/ac/Ti2s7jgWM1CploJ+IiKpcFGwGN2vgHz+2HjBPetOjZT+FwaMJVVdH7e5T3VhJMbrl0vLLhftwsHD8LCCqxvOOA5jvtv4ViRsCEoH/FKbUdlqhzeeWrHr1NVC+VbVo/aAGq84HML/a5oW7hNBF+ZmsFI1nBO+cqlMp6qjzekIjW9c31cBDaxcH8kKsRuiMTX4NUgNyDPkbOcsw/CeYfh6FF3vm/egQDz+2Fmmp4BZ22Nu29rs7bmgOPw4S77Fqc4tQm33Qa3H4OtDBHa2X+365ILYM3NueOlJQdyjQbcehusZuA1N+eAaWnJ/dptd23fXY4FncAxoo3sfvzh+VBH9wEo9R2HQCeUd0hiKlzV8lOvpeY9MHxY6+jr+OTvrbXfNUwGlZZRjYFBEUgUfQVTy41J6IX7DKXphaWoUFVAJzaxVMdvesdNnJo1jQOdhUZuv7n4YsdyDh2CA4dmHCLMzEJnyyHH+jobq20WDs6wvdlmfR1uuQU2N7OyG2usrsLyMmy08vp0yZ0dxbA908jVuMXFHHxklGxmxgHP/LxT3TY23P/iIjys6VSx1XV3Dys4MNqg3zCt34UPSjE7WCqbTVW75DqROFU/cv5HJ/UD7ZczNG8ZL/N5kx9gjPk14H2hjQZDUovaNSyQVKXL+jgGFE3v378eyqPoWsy7WCQEPL4vjv6JbWcpU6/OPx8uuMCBz+zhs1yPbzRgbhY6266nNxqcXm/z1Rthfr5NtwsrK3D8uPvf2HRMREaoxOlR6u131qkuTLdc+PwGzGeLZs43XPF66B5cFWZmHDPb7sJCF6ZnYGEDFlpOFZuh3x5UxFQ0AKUyoVBbKQKylPSpZQwiVYEtWcbs5wO8AvgbL+z3cQuQfXNKBklqV9HXKpQmJFXTFBmki9hJM3JMIH5RmM9uQsDjOxH65YrTnwyXz6jj+YbrxBdmgPPQi2HhgiVnXJnbB91tWLvf0Y31dY7d1OK8ww4Abr7ZMZvtrhudWluD1ZYDHktuf9mkf2qHvgepyxa5h/MJOe/C9IZTBxfW4KxsaH+744zcZy06trXdcaDZPB/2H4eZFbgny3uVfoO0/+xC79dnBbE2EwKrELiG8iUQt6gMP69BQSgmQ8HHGMDHGPO87PCIOhaZB5ZS8xqI+cS+CmWG4RQJvfQYQyn6xYCnKN9QPH8tHZHQchk+y5kmB50ZcqPy4gKcdwQedjFccQWcfdEBOHQOLBxw6lX7NKyusnHbKguH90OrxddugrvvcurVnXfBvSu5A6A4B4rBVw+BQz7NQhwbDTsB4RT9M+wl7zXgjg7MrThj+IkNBzpbbTj3MFx0ERw75gBpdgYW7oK5rrv3+8jVMH8eGcRZkbSBFADSxzHACbXPVACqIin9IOV6kljGxXx+JPt/kDoWOQH8XGpGpcxHS+xljGrUQI6H/fn5hvIPHVex8fgsR1QrAaA5nPF2cRGOHIFLL4PLL4Ppiy/M7DrT0N5y+lPrNHb9BPcsw3bnJK2WM/LefgxObcI9K+4tn6KfXcicLejvjAI60qEhPAXE97KW6RiS1z7gZAdO3JLZqhZcXVZXXfyZGadCmlWY7bh7b+IASOoJO+0/WjSQpIJDEfOpCjgp5enjWJtKLWfw+tja/HyMMW/DbRyo5Wlqgfi81GwyqTHmtdbaVw9TbrKfzzBAlPoF8eOVMRofYPx4oXyLgE3CfJ8cPwwvXEBnGsdsNODMAHPZqJLYdi67DC688gBc8GAHPJ2OozRr97N1fKXnpby+nhmON9zv+HGnXmmms0X/M9f1tKqewji67GQVGqS0yGx4mXd2Egd49wLnAJvH4dhxl35uzqlk5x12oLR/Bcx6bmQXEQDS9dLvI6Y6FYnPfAZh2eOQocquebTLWntNxfhB4DHGvM5am8R+kpmP3xCqPLgUQIp9QWJgUwZAobxCZfnpU5ax8I3JMnIlToKiak03Yd+c64yHDrmh80sugbOueJALmN/nMtzYcPRh8xTT5x9iemWF5eXMse8uR4bW193olczmE7al7ynWmYT56GMNQPKv2ZClPz/dzAXETgKLwEGAlsPRSy7JyFsLHtqE6dWcAa2Rq2FNLy8tVUAhxJRix1Xz9supci1UTu1AN0aDszFmAefT82icrUfkahJVr0pD7SJlX6QiY3FIQhS2jPGE4vlhRfn7cctAxx82jxmSBXTEQ1gDzxVXZGrWkfOg0XD0ZmPD9VbRWVZWOHbMGXRXVpwxeXPTtbOZrEX7C3/p32lyBiPvQdb0kWe4pZ5BaLQJ+gEI+kHC92rexjlGTq26eq+vu1+zCYfmYWqzP29t9/HzFikCCT+vqgA0STJwvWoe7TLG/B7wCNz34fXW2rLN//4XboPBhwGvw3WJ78KtbJgkSczHf9laiq6VjYzp9DEASVWz/PMy8NGgAnEnQJ/lNOg3Hms1a2am/ydqyEUXweVXNpy+dejcHHg2N+Guu52BeWkJ5vdz58du5Us3OMbTajmNTHxx9IRQ8cXZ7uTLYIiRWEaw9MqFkLMeASOR2HsyKlyvUyT/LXIGdBJodWD1+pyRzQMHl+C8Gdhey599F9fCdfm6HkVdyq+nDzxVQKcKuyo6H5ukg88hY8x16vzN1to3q/MvAR+01n7SGPM44EPGmCdki8PH5EHW2ucYY55krX17FvYHxpi/SK1UZebjP/gUy37s5RUxHalc6JqfPpRHKH8/LMRupgPHRSNY4qgn3sJyPD/vnAUfejFccNl+uOJyN4zeaDjDcmcLNk464Dl6FNZPcO91t3DTTY4MmYbLT9qXXiZDz9XqdvtnsHe77plv4cDhJM44Le9JA4o2Toc+NAJSAlihjQvb5EvJbuLmoy1mz6YFtNfcpNgLDkIjM0yLnWpT5eNPUC0yIuvjUPwQAA3KfoqAJwaEoTxiZQ/FXdLBZ8Va+9jYRWvtr6njTxpj/hq3Jc6LCvKU71fDGHOhtfZ2Y8zZwDekViqZ+QxjSA6lKQKesh+Jx37+cl6kYk3R74msfwI4c/SDzvSMU7M08Bw86BjPBZfMOUceAR6Zdt7pOJvPwXPg+J3cd9sJbr7ZkaFGw9mKGvpGMhGQ2epkrEety2M1AHXdBNL9HQcGMgdL2FGXnX5KWk1DHYvK5hukdfsQ47fE2YcD6Q1cgc2mA6Fuy6mGMvyu8ynzgEZdIxAvxbZTpbNXYTy6faWWMbzBeWTK5G04FaxIbjTGvBj4I+CLxpgvA5cA9TOf0INPUau0FIHFIOCj//28QuWVqVgh50AZweobNp/rBx2Z7DkzA7NzzuflyBF4yFEcqzl8rpsi0T7tvJW7XRd5YQE2T3H7DSc4fjwHHgExCAOQAI9eFMz/yfSI/RkQnWrBXMd5H4Pr6C3yZVSF1UiDCAHQdHYea/LbWZ4SR/LYAJobcP5h96xOrLl4FlcfYV7yHoo+ejEwqtvWk9quywBpJIwHat06xxjzSmvt61XQeTiH9YLi7U+p9F8FHgfcBPxlarlDD7WXAVDo6+EDRGgKhB+3CHjK2FFoJrmvYvlsx7fniJ+Or17p45mZ3I/nwotwNp7zz8+cBzu54QacjeeWW7jns3ewspIvbaEX/IKcxcj6O3449NuEYoyo0YDptpsGsYRTxe7DeSLLes4ienEz/9npRejx0jSya3qRl/3ZtTY5+TuxAdMdl5eOW9SW9DU/jr6WqmINw4D8sFAb1/mPjJ/Ut4bzy4wxb7PWLhtjHgp8P/B9RQmMMV8D/sJa+6psn65rqxaaDD6DSIyVlDGaVHrr5xvyak5VsQy5c6BM+JRhc1m8S8BmesapRRp0JOzQoQx4jh6FIw9yUyVEZEo5227a+c1f6y17Md3MwcVnNL6tR8fTar/PkmTJjG1yRtVswkzb/YTVrZP7DonnM+o5CQgZ8gaj2ZLx/sGpYGLTsVleN9+cPZ8LYOsWB4Bn4/6h3/aUon7hxfGPB5UiYJkoqW+06w3Ae4wxHdz34sUJk0OXrbWvGqbQSuATahCxl5MKPH6aMjZDSZwQyITOY/OvBHS0c6AAy+xcbtvRqpacLyw41sORBzlr88JCPjtT1rFob8H6/XDjV7j7tjat1k5jsr8QWGh1Qm1wluynmvn6PJADlS/NphuJarRzlXKNfH2eLtlCeSqNsB8BoKJOrnfE6JUJ3NaG7WW49BI3xWRpw4HUVhZXWKdmYWV2H99QPoyalaLiVbkektrgosahdmvtG3AAVEU+Yoy51Fr7VR1ojPlba+1TUzIYiPkUfYmK1KyqqlUMdELpNJhAtVEs6YC930w/29Hq1VSz37gsACT+PLNHlvJVwGZmoKEsTd2uA54vf5l7jrVZXXX+MK1W/wqDPuiEAAj6gQeAjuv0WuWabua45y+nOt2EhU7/wvRilPZnpOtVowTI9QiYiK9uiBuAANH9HeepvbiYqYmbDvj8taFDEmp3qaCT0k1TGU/sQ5haTm0y3lnt3wT8pDHmK/TvWHp1aga1ql1FTCYUp4zZhPIpYjvSIXy20yRs1/FVrPnmToYzEwAa/d9s5uspn3V4JvPX2ZcZb0ze87tdWLkHbrmFe4+1uHvZrZO8udkPNu12uUE5tDOFSE8l857jVkc9vwa0u/l5EzdELiAk87CEBQkDCs1z84ffxYFRq0+ncarVAdzQ//K6A5+FBVjYhHPZ6fEs/0WsR8SPl2r3iYkPKJJnqOxYmE4zEhn/Xu3nAT/lhRnchNMkqQ18qoBMGdsJ5RcrQzpPCHh850A9erWD8QTYjgYY/ZtSx9OZM+HBgzgHwoUDzs4zM5uhVPa/eRLW1theXmV11S1VKk6E2wH7DfSDjL4eNECTA4W2xUx18lGoWQnrhg3MM+Qd9zT5khv+EHhsiZGuSqPrIUboaRV3fT3zhVqE7rpLs5HVIcR+yth2t+A8lkbyDYUXtWc5H0Ttqk3Gv4D8K6217/UDjTG3pmZQC/jEXlQK4MTyoCBejPVohqPBxlexZBRrjp17X4WYzVSmushI1LQGnnk49xCYQwcdAi0uOuYzM+2AR+ZvrZ6GzVNsbORqlgDHVANso9881GnkpKnRcGAADqxEzeoEgGc7cOyLze4d8nwlHPUcp3EMSPxyrBdPP1+9kK/2+dlSacTZcQa4fR0uxC3L0WrBajt/JzJ9Q0sRoPijXVWkCpNJSR+rZ/0wMfZNA99rjNkPPA23wcrbgcsSpmX0pPbRrqIvR0i9KtKfQ2lDPwGWstUDZQKodhTUbEezG93xpxp5uLYBibo1e3C/YzudrSyCsJ5p58V8151w09fYuvl21tZcZzON/iFyCBuURRWbaed2oUY7Z9y9+PSzFOn8Wm3SzEPitHAtR0+fEPuLPEcBdBkNE7VIZJZ8pBByG0+LfK6Z7iYdsrWf1/MBwINZ+Ao7546lgEHqaFfKdf3v5y/XQix916FgjNslG2O+BTeP6w5cl3on8EZjzB+r6RaFUgl8Ur8IIebjXw+BTixtDHCE3Wg1S3+NZ9S5nvgp0yI06AizMV5lTQB4pj0Aotl0wNPKvFYaDWhMZVTmNLROw/LdrK46HxetquvhcemIRR+0qQZsZ2m2u85242+FLCqPD0DiUyOqkVVppukfKt+mfxlWCYOdi8RPk4OEMFBtX+uQg5A4N86RbcGz4Zhjo+GMz6J6NdnZ4VMk9ug06JTlVYUNDaJ61QIZ419G9XXAt1trP2+M+ZC1dtMY89247ZLrB58yCbGaVFUrdlyUn++JLAAjQCSN2Gc9euH0KcVydpSpVCxfLdNg5CzBWRdtGPebmYHmdB6p23XG5Hb/ELg/WVTUMW1s9lV7qet2p39UShz9BHDEGbCjfhJPq0t6mFuG2LfIVTK9XIgAkZQraeUjMJP9z5IvpXE6K0dUsk1yUOoC5xyE9gJs3uJ2wpAPhGZXofahjdr+RytkA0plPaEy/HiDgE7tMl7wsdbaz8txFtDJtlFOkmTwSf1alL2YMtZTxnxi/jkhNctXuXpgpI3HAeARFqTnagnwSFyJMzWXPcLFRbjoIc7uI7af9pZbE+OuO9nebPeYzXQzV60a9DMeYWGw07AsgNRquVGyZhPm2pnhmpzd6B1Ft+mfTCogJMumTpP75OwjH1KfU+ECFvL85lReYm8SJiWGalHXIFf3BKAEhITl6G18DrSyGfL0ez9Lm9D/frgPQiHAqcp6igBrGAAaGjbGP9p12hjzfJy6BYAx5unsfG1RSQKf0EMO6eJlzKcsbixtU/1r244AkKEcfHrqgAIeo4BH2M90M1ettD1oyntSppGFSQZiAJrfn3s1b5yA226Fm29mZcWxGulo0D+CpRmOZkXyL86H4NJLu+vZjLJrU+TeyGJ0Bve+BISEhQhYCWCdJne0FJCReAI02isclb/488j7E8D3FzzT56KC3XWXG3afn4f9Ledi2yIf8i9qO11yFuUDjq9qpY6ApYbraylgUjtPGe9o14uAv8Kt64MxZh03IfV7UzMoBZ+iBx8DoBj7iYFMKG0q8GgAagT+NfPRapQYkgV0tColoDM/r9QzxUaaTecHNCW0ZWY6Q6npzMdnKvNkXofjd3LPMbexn6TV7EYYT8jIrFlPp+NUNtm+WPyBJK7YVGTJU3EA9Nf00c9aAOM0uYF4IYvb8/ImBylhQHP0ezpD/2Jm8k60EToEBCb7v3UNLm4638zV1Xy5VrH7hIy9eHlpAPJVLw1GBJ4F7MwzFk/XoQpLisnA7GnMNh9r7c3GmKuAfwNcANwOfNzadCt4IfikPpiil1EUHopXBDy+yiXHof9pddwEmo3+USxhPRp4BHB8Q7Rp5B8ZbQNqNHC9/9AhWDrbjXItLNDb5G/hADSbvUnsQJ99ScoVf59uN1+1UNQr+W1swMlN5x+00cpHnk6z068Gdo4uyfC3iDCkBv1b7bRwS3AsZtdExZJpEAIy8+QgJ6DXUXXR9ZCPgYCgGMDFPnQK57Jw4UVuzeqVtRzcQkPuDXVcBky6DikG5xCwTayM1+Yj0iCfvuev0lIotRqcpSYh0CkLS2E8Ai56hKvovy+uAhvNeny2o50LJa7G8q0OzHRzQ7Xtgmk0HNtpNp3a1ToFy/fA8Ttgba03Y12meglz2e4647f497QzZrOy4sCm0cj25FqF1U0HDpvkUyCE7RSxGy2aRWx54dLJBVzk+gK5KiZD88IwxAYkolU8iQP5h0Lbhjo4hgMOyFZX4Y5j7lwm9DZVuqL70uFlzCfV4DxIHJ+lETivVcY71P4o4N3A+bgZMkvAHcaYHyhZAbEnlcGn7KtRxnJ0WArwCJj4TMd3JvT/8cMU8EAYeGQSqY6n7S7grvfuI2NFOYWaApMZYdbW4Pidzu6jyhObk7b1CPNptVyy5WXXGRsNWF1zG/HdR676CPj4fjc+CxAjsQ8SujOi0onpSNtvIN9LXhuzxaooeQjrErVPgAb1PmQETo++2Sz/5Q04dZNbC2keZ/zW0zmkrFB7il0PMZ8YAKUAj1/OIFIbXIzf4Py/gFcDf2at7RpjpoBn4XYtfVxKBgMznxCg6OMqLMcHHf0LMR0fhEINQYdrxiOAIR7KGni0bUd7EovI9emZ3BYz1dvQfL9DMttxatfSkgOjuTn2z7fY2HDAIpNQFxYc01lbgzuOu/24Otmky+Vl5/G7Qv+mewI+6+R7YYWmIoQAXMLFjuPba1Dn2o/H4j5p+8jZjwYfyMHGn2QKOTA26fc50gbibnYvM518wunamivvVODeisDHP46NeKWoYGVxffAmcj4SGb+fT9ta+6d5dew28E5jzE+kZlAJfIoAR84HAZ0Y8GiQgf5lHULlx+osjoP+iNaschjs+c5khl+9NIW20czMuPTttsMcDp/ngObQOXDeg4Fpt1LW/Dy0t9hab/XWZJ6f67n89HalWFuD+1bh/nVnzzl+V77f+hrO72Wd/tnh0vlDwCP3LKNE/ruYId+6RoBIqwu6Q21kx6dxACTz4FrqR5aPSGzOl7YD+cuxah+kpaXMo3st2yE1cH+6nn6Y/hWNeMXSQzEzKmNfIRkZOI0XfD5vjLnSWnuDBBhjHgF8Up3/prX2Z2IZJINP6KtSFj/2klIBSVuvfEtWSh16th/FevwpErMKeLpZL2w01OrYCnj0SFVb9JL5fS6zpSXgCO4bvuaMNst3s77u8l2Yd3i03c13HV1bc8f3r+cgdJyc1awAy/QvOaGBItb0YuFiwBXwEeAp+qJvkKtHh7JrMudLq2fagC3vTqtbOs8u/W3jNHlD7HmR49Qvn7nF2lU3EifV7uO3b58pTZyMb7tkkUcCnzXGfBFnFTgIXAZ83BjzwSzO1cBw4BMCnlgjCDWQOsJ88Ru0H6enrinQmQoYl/1lS4E+u5CeULrd7V8Tp9OBqc1TDonm9uH4wQbcsww338yJm1cAt67YvvlsxGqDngomS2rcu5LtddWFYzi2s0b/zqQhY2ZV0eqVAEeLfruQPMumSrOZHc/gRsHED0eDj0xlgdxGB/2sx3+n8kERNWybfLRP+xvhpQsxm6KPmNRD5zMIuNTJdoaHjZEuIJ8ih4D/VHC9dHmNSkPtjZLwWB6pPx1ffzlj0g3E0V/fBvkol/jmzAZGtLSzn5xrtUt7F2uP6EYD59tz8CBMzeC6aW6hPrDofHOaTTjdcmAj6pbN1DtZTOx4162+fZydy5pCHY21/7lJhxUA0cZp3aHJ/sXQPYUDn1ly+4+IqF9aVdZGZs1CtL+WnFvcSN/mposvzoyxD1ERi2kE4vjHRZKSd1UZ1tDdJyNgPsaYS4EbgKdk6zIXSXBJDS+/e4uuD2VwLmItIWaUwpZSxDds+qCo8/FnpM8WAE9I9MqB4MCrV24DZ2g+eBD3ne7gumWWcH4/041T2E63t9+69ulZW4Obb3N7n9+Kcw8NjWSNSiRvf6Kob3+T8A36vcWbKq0AiAyRh7bl2SJnpHpkUs+aP35XbqTWw+1Q3H589uOHo44HeaaxMoskdL2+91nvXu2ZvIb+70m89Ajw6GVUy8Cpss1nEKQuA6mYaMNkg/Ce4yJ6W5w+9pMxFX+nidhQOlka2+1fUbDRcOmnGnncqZmGG55ZXMSNB2W8obvtkKbrtsmRXZFlA4tGw41ofe0m+BROYdZsZzeAx5cuuXon3s0SLgxJDNDCfppe2gb9zqACOPIvk1b9ZU8g33RwDfckD9A/MRj6gUivogg7gSYEnlWlKE99HXba41DhI5GamU+2U+kGzrMjJf73Ab8GPJRcy/ZfS6FUsvmkAkgZC0oBH71msBZ53CGVTPLrm0+UAc9sAHj8tZBFNNORIfd98w44trvOxLO4iDMyLx6Apjz7DrAC6ydcps1pTrdavakVBxYdqN11F3z2s/A53OK3YmAeF/CISOeRT5/u7HKthRv+niUHEL3+jsxklzTiBCnLqwqo+e/dZvncT3+jlDagfb5iksKAYuxH1ydmD4q11aoMqJ53W/tQ+y8DLwSekhj/14FXANfTv2DCn0ZTeJJs8/GBo0xS1LBQOZA3EH8HBZ/9aAnafho54Miwug88vTIDDGi7q1YtVE+q2YSzlnDTJ3rb4UjNT7vNAdunoXWqtzuFTNtYXoYvfAFu6jrGo4fOffVnHCIqj35X+usvs9HFGCzgI+AU8rG3Xh760yhxxeCsJ7H6bS7kTe1LkUo2jM0lxPxj72m06pbONDnXwr3ajTH/DviitfaYMckzJD5vrX2PH2iMeV5qBgMxHzlOVZ/KJKaXaxXLL98X2dJXZApl55GZ6UrVkomcU42dy1YAfSNd4tUshuiFBWDxLOdEuHkqA59peu503S5snOT0RqcHPPPzzsbzlRvhI7e5IXQ94qRHtcYpWnUIvVs9B2wfOzujMM8YOOi4WoQ5CXj5Hx2fhYXEbzd+eFGcIilTt0KSCkAD95tq2yVH92o3xjSAVwE/ULEGrzXGvBpH4LU71puAR6dkMND0ijrZTxENlmt6ic+yETBJ20Rta5zdpTgQQj4tptPNF+3SwNNsOsBoqickq2YcWMQxm/V1Z2zudmFKeEs2m319HXB5zM4BzSbX/mWHD97glGqZSS5MYjeAJzX/Bv2jYE0VLmrZprom4bqDQ27n0WEx5irq5oHst58cjHzWM4zBuAy4UvNJkZF/SOpRu54NvN9au1ox3TOAnyX/joqcl5pBKfiEWI++VpX1hL5Avo7tN+Kq0sD59Ez7o1qeHT+0E6hpuO1zdFpwx7LmzHYHuustphtTLoP2aZgWf1/TS9RowPSiGx67/cYWN9/sHAdFpZQOLl/91KZUZK9IiZ+SvwCQfh8dFS6/oga0reL5+es6WS+e2Ir0PmFGxY3lE5Iy+05K3LJ2HjM2h+pYGyDZ2ka7vhV4pDHmu7LzI8CbjDG3Wmu/vyDd04EHW2tXdKAx5rdTC67s51Nkt4nFD0mZHu4Dkv5ihoyHejJpk8zG08wXAQsZl/XypWK6kaH5fWpIfarh2MvCgstPRq7OmT/tEm2ecqtgyXzsObdv1/R8Ew6eA6v3ct11sNLKlTOxrdRh5ylSIwbNVwMO9LOPBsX1lnciNruQvUfsO+LYqJd+lVn10yqdvN+Ol4+uaxEI+HWrS/y8ikAoVJfhCh/+Tqy1fXOxjDG3AC9N8PP5BM5s6cvfpZadbPMpAqIygNHnqRLLUzc6DUh6r6oman1l+m08vm3HH2KXPdjlnCyv/ZkKttV26+rsm8OBzPx+x3xsB4z4+uDsQYfPg8UDbN92B5+93rEeWZhL23uqNqHUDlRHJxOQnKG/k0v9FUb37D1is4l98WW4HfIFxfT700uiyL+k00CVwnykXroeobZVpI7pX90sZnCbD9hu8qh2qRhjvgl4PTnzebe19jUFSdaAjxpjPky/zecFwP9NKTNZ7ZLjGOAMwnCqlK3zEtDRdgRxbJslX/ZU/HX8RdljhuUZT9XqdHKbzfw8ffuoz87h5nX1psrLKtEZ+Mztcwai5bu58cY+3+eeSAceRC3aDQl1NG338b2WoX/p1DbFTh/+rhhdddy3EJyXTi9KVgQGRbZE/7yKeuaXVaRujUTlkvxqzNBa+wngmgpJfhD4W9w0i0MqfC4cfackqV2pqpb/hanKdGJMKfTl8lUu8ZKdITcyhwBHliqFHHQ0+EC/Giasp9HIvZPnMhWst1Zzo0G+Mc+mYz2LB2Bxka3PfpEbb3TRZggv4jUs8ymyYUg5dYi8U7H7CAD5oofM9XVJKx7O4IBEwEQWrIecGWnwkWVh5ZmFOncRg9F18K/F1KLQxzYEKEVlj+JjYS10y4YURyu/Y639FT/QGPOzqRkMzHyKpOv9p0rM2KwZj8i2CtNrOYtfDuSjWBp8QhNIZS0fCdvOUOHAonMmnJvL5ht1HBgdWMSpW0099takNyFgacmpXDiHwttuc3VVStnAz6hX9wHi1mFX6gZ+Ok4L+rZM1nFCH6oydqCXUxX1LAbaoTr5956qcpV9eGPpqgLQoGqXBTpjBB8BHmPMebgRrs8DDWvtb6TmUXjvRS+g6CVKA/C/ULEflDdCaXjyvPWyoTLXaBYHPjK6pddAlqVLfbVL72Ah4babG53Fq1k8nWdm+o3RbrH4Ns7vtwtky2vMzcItt3D8uAOuBm6JCD1toSo7HFZS7HRFEnuv+pp4QJ+iX52KgZBmU3Pka0Nv4sZwW/S7Wkj5VdqWf+9F95YSF4rfW6wOtUrGfFJ+oxBjzBFjzN8DdwLvwW18+6lsmkaSlLbBmFrli98IywDIT+Pn4+cl57G1ins+JxnwyHrIGnj0jg8CNOJ4qJdOla2M5+fd+VZmMxLwmWri3mrHzd1yC/Os4bx39sOBg04lO3Y7y8uu3NhUkYENjjVIKosNdaLQe5Tj09nPBwldpl+uwfn2nI0DoA6wSr5gme/97LetUFn6Pv1/XYciVpLyka0KMjEgriqazRf9RiT/C7eG8znAbdbaNeA7gV9NzSDZ5hMT3YFCDVQoc9HLjhmWY3RYj3KJ/UDPKRJVq912ToR9Db+bR/R3KhXVa3Ym9+mBfL8tWX+5h3CdjtsK+a67ncfzQ44ChwG3uuF2281mP9V1dTxF3pl2k/GUSexZayl7Z774RmF5/4b+ES0BDtmo8Pxs6ZOVzX5jvIBPlQ+ZX18f7MtAR7f/lHJi+Y3iXVsLNQ52DSKL1trfBTDGyI6ly5nHdJIMvKRGCHRCL1aAJ1RQDHT0cQjQdKPoqVs4TBB/nk7H7WOu5wn11gjqwPRcDj5TSlWbnnGTSGV0S4+KiRH79GaX2bk2dLZg82S2R9f95H7LTZib7Rm4dV3FOK6nC0yCVLULhWxyM8RBQqRnm8vO9ejWHHDeYXe+semeUYude9H7DokEjkPPNtQ+Yx+40Ie3DODkWhEbqhOIxrxzzqwx5hJr7U0SYIy5iP5VdQtlYPCBnS879rCbBXHLwMaPGwKfnot/NweMUCPto92KyeiFw2az0S3ZFVRvYSwsqdVy140Ylrpdx4A4RW+4feNkb4fRaXD7hnXzzfya5At3TZKksFPNDKSTyUJkMmLlr74Yszf5gwh6wq+8V5l0GrL1iITaV0htKgOEMrtYVZVrVPgw/lVU+WXg08aYTwIPN8a8F7eB4LNTMxgIfIqYTkikPel5QD7olJXlizAZPRTbxalZ+uur5/pLugb5THUZ3WpmYbJ0htiNTMObV9RVHUQiNZvO0XD7FEwtAauwvs6pbP3R6Qzgmu38XqfJZ4aHvuLjliJVTFiOfu5N+ne30EDRe+bk762hrou0gNuXYV8jn1emVbNu4Dj2sfLbVAqDiTGesnR+2G6oX+PYOccY84vZ4Z9Ya99vjPlG3HY5X8HtWPoSa+0tqflVAp9UnTmWNgRaVfOVeLIM5ww5sOivrQYgnU68n/Vi8Nsd6Db7PZlPZ0ZmPRN+MwOTmd6QVcZ4FlRmzAGPgcecYOHP3UJuvdUU266++7I668WyOhSDcNlz2U3RgNJV51PsBAjoB58ZcpVLRJ6BrGa43c29wGWqhWay+qMSYzx44X6cEJDEGI8fPwZ8sXxHIuPZOefpuAXhVwGstf8KvHbQzJLAx2cqIlU6i26kVcoKxRfbjV4rWBqjbBusQUikt/ynxopMZLtkGVrvrWDYzV9yK7MWTzWz7Xi61u1OOjPtQGjzJOzfyEqZdpsQKifG+XmY23Sdb4u8M8oqgGVtKQTQg34MUqToXWmblajVYp/R6q4GHgEYuVftqT6H2x1V9uo6QT/4dNkJQFDcXkJgEnpGRWlCbRgvLCajxoYxOBmuWWv/sSiCMeaahHlhQAXmEwKC1IcrDSf0ZQo1Ht2xut6/fGFd987XbdRfQmnY/jyw3gJYzXxFw24339VCGM12J/frgRx8tjrOB2i+m82A1xusr9/vhtz33w2swKmvYebnWFxsOY/r7De/2U/tB7X7hNKkANgwosvUtjYBn5PZvzBQH3j0O4P++VwLOB/9pQW4Y8MBUJv+Ifsie0/ZM4w9G79thYDHLzPGeGKMKJRmWBnTnoFLxpgnUbyg5BuBR6VkVlntgmqdRYOH/vnAQkGY/PuNWTeSEODoPASwZKkNzXpmZ3LWoz2i5Rzcv6wBJHaf6U42WaJ1ytGa9XV48AlgCfadC5dcypEjn+fYsTyPZgP2dfPtaOQ+6gKOUQCQzwx8O5sYmzvkGxz6cUXd0nt5ie3H4j4MBxczdrjhrsnyq3oeWezeiliP/7Hz84jFRcUNAVAdrGeYdzWGofZvBD5QEqeeNZxjYFP1gRUBUFF8X3zwEfiVRatiDUKnk6U2tIgNSAavevXo7vzJcP7pNkyLsVknYB23f9phOHwuBw86n6FWy6UxDdjfdSxhEdepNulnhoPKKD6Efof02Zo8847377+rGZxLhKxy2KB/uY0ObrWATif3jg4Nr4cYiA8eRe2q6B5D6YrYTCxuarnDyJhGuz5srX1SUQRjzIdSM6ts8xlUUilprBzdmBvkdh+BWRmO1VQe8i+ttvfoYXNRuRqNfLcKCW94TAdy8Nlqy+JjWWayD/LpFZg9DMzD4fM455CbCyY7nE43Yb7jvHjl679CPqGyykTT3Wx72r7TN7uE3N7jG5l91qO5un7PC1mczQ6c6LhF5GWpVn/kLAQ8obqmfjBj6laorJjKFwobuVjnZrbLksJqfiA1s2RMCQFHla+Cjl80VBorT4OPOKpJvNCoiF6+U2wN/n5d4jgoQKSX35Ctc/S6PzI1Q88Rc8CT7dW1sQHHj4O9CbgbLr6YhcsezLmH3OX9827V1YNz+Zo3UzgGNE/5l8BnjqMWv3EI6xHmI0CkAahLP/DIiKSwHhFRzfYDlwBHF+GsOQc2Yu8pW+UxpJL7LA3iz61M3QoBEJHzYcOqisWpXSm/GuWhxphfNMZcEq2XtaEFxoJS2c+nCCx8KaOxvi4eSyeNQy+doRuW71DoL0bVUxUaTu3xZ7br9Xv8TQKn5vpZkW3k4NOT5pQLWF115wcPwlmHYHofHD3K0aN3cOON+az4xUVYajmwPImbkIG6B3/Xtt0AGr+MRuB/nhxsxE2gSz9QaOPyTBbfZz16gEA80+WDsEn/bq2xD1XKV7NIfdei7Vc+4IR+RK5XkaE/IOMxOL8g+y/ciTRVSm0+w6hbMYBJaUwhPV6G13WlpXFql37pFCGVq69+3X7g6XQcyMjGgNooLSNg4ABMgGqqMZXpYtlGgY0GbJyAs9rAPrjics77hq+y8C/LrK259DMzcLAJrY7rtPtx7Gcd1/G07WecwKPPheWIi5OwH1mNUWxWElcY0iz9rEf7Xs3h7hucTexE2w2x+ypXkcok/zEWE7o33S6LPpD+cYqUqV91vU8Luz7Ubq39cJ35lWLLsA8r9gJialxIdKPShmZpyLJ2jF5DRt5Lb0/wTL3SToO9cru5OrXVzmfA6/WANCvaVmEAvU0DJeHxO+G+24AFuPDfwLd/B5de5hiPANr++dwjWDbUW6B/9Gu3JNR5/WcujCdkH9FGZmE9s/QzJSlHHBHncOt1XrLkViBptdyCwCfZCTxdlR7veJhnVWTrKQKgGPspk1rBKGM+dc1qN8a8xBjzAWPMB40xnzfGvGTQqqVKssEZyr8oVfIKje7or5LfMOS4NzmU/hXw9DYtPuuZot+244v474i9BxxLEoYD/epYp5Mv07Gvu52Pycsk0651hT16CcwszMzw8Cvg7rscOWo2HRCdm33t17J7WMSNk62SD8X7z2jU4j9vAZ45FSYGZ70GtWY88yqNVoHF61zU4EXcc1hbc9sHhQzNRe0sdpxyj2WgE1Oz8NJQcH2UYi11Lyb248BTspnplwJfMsZ8PFtedSQykJ9P0bUqIKSpekj8RhKy9+hdD0JqYs/2k13Y7tIbxQIHKuLN3G7nGwlCPvze8ZhOo5GTnN7npX0639ai0XBezzfeCIcPQ3OKqSsv4/ANN7K87MqYydYcO3c5t39Af4fzF5cfdYMuAh6tSolXtoCEBp459ZOBAe3bY7N4B4HFBRe+seFUzpM48PHXtQ4BcEhtKmt7sbg+yyFyzb8+LOsZVmq2+fywtXYZwFr7VWPMfcBR3C4VpWKM2eeS2lZp5ExqZ/epL6LoCwM72U8IeAR8/CUc9DINOk2v/G7+rxce02qXxBF1TP+2OrnfjkOlrVwvE5TbPAU3fsV91g8dgsc+jodenC3Bmsn8PJy76OZ6zeE2yzsbZ4A+SP+WxCF7Rl0SYpgCPLL6ogaiNo6ptMhZjMRdIL8fGemCfCRSvJkvPugey8lNWOk6tneC/iF7H4DqegY6nzOR9UC+hnNdKxlaa6+XY2PMM3Cv+O9i8Y0xzzfG/LUxZi7zer4HWDPG/GDqPVQe7UoRn4GEGImEF7Ef3UimvHg+6/Gl59Hs5W27bua7sJqtjHYI6EB+DSLMp50D1Xa7y5Q4G87tc1x486SLPO9WM2RuFi54MAsXHWRpaZX7VqGdEaSlJThvPd9SZw5YUvev1RA9bUGewTASs6EIyAjL0TYfAR55bxqk5smBJ1vNGuh/P/tx4Doz4wB8bc2xng0c89GTg8vuM8R+Qvfmh8vPH0mrg/WE6joqMKrbw9kYcxXwZ7jX9EPZ6oQx+VHgmdbaljHml4H/DHwEeBfwFynljQR8UkTTXP0Sy4BIp/WnUmjGA7m9obdjqWoF292dKpcsodFbRJ5+4NlSapdmRPtaLUdjZqZz1UsKu+02B0iPfCRcfDFXX73K6RY99WtuDs455HwTWziwEXtIF9ehW+QdVIbhhwUhv+PGVCfdWX1VSzMe+cnolrA1mRRKFjaPU7dkStyqciosG90qqr8fHkujGQ+EAWYY1rObUkHtOmSMuU6dv9la+2Y/krX288CVxphHAX9jjPm+ApvPVmYfeghu59J3AhhjTkTi75Ck6RUpskO18cKK2E+snCJA2g7EE9GbzfU6aLd/sqheCVUMyJ1OZjtu5JsLQsCxkFxV29yEubkWpjntwKejPY6A5bth+R5X4NGjLHznLN/U/Wf+5V+cW1CzCeccdOXZVbg1Sy2G23ly/xl5hsIY9fMpsz2UMUthMIvqfEGV1SafBqJBSgOPsCUNPNrZcz9OnZydc8/u3g3nMLKm8tZ1C91PEaOJxfFVStj5DFNAKOVaKO4opOLWOSvW2sem520/Y4z5a+CngedGohljzDNx+3e9JQs4jPv2JEltzCcGLkVxYuwnJnqIHe9Y/oMA1823w9F7r/eWYW7123mmmjnQaIDScWRh+lPZ/765073MbbsD7Q6ms0XPGL28DAfPhgsezIFvfgSXLH+RL3zBgVez6dSvbhc6a3AXrlP2RvJxnVbUsC65zUWPGhY9Q90BfSaiGY5eY6iblSHlSJo5lS6maun5dlNk6lamZk414O51t+3BMrlHswafUN1Tw2P37dsLdfvDu+ZLipo1CCMaFJzq3DrHGHMOcI219v+o4JO4ZheTnwRegzPXvcEYcwR4K25h+SSpVe1KYTuxsDL2o7dPmfKu+RJqaI1uZpzOEjUzIDINByqy5CnAjAIdyFU0GZKX0a5WC05tQnsB9rXbPX8fmXi6n7Zb96fdhltucbafix4CV1/Nw5pNlpY+xwc/mDOupaWszI2sXPIRrxnyOVByLvYgDT6h6QjCZORfnosAyYJ6XnJde1sLKIgNSIPOLDuBR0QGCfbjlss4+6ADnrU1Bzqr9INoFYnZq1LCQ8Djh9XBesok5YMdlXo9nA8Av2CM+Rtr7aYx5lzg3+O2Tw4Xb+1XgP+ggu4C/l2VQkdu80kFIAkvOhfx7WxF76DXWLwWIyqY2G+2O/llf5NBcSrU+7yfVmpXqwXzbZhu5uxnu5Ov9dxud1k7dpIHta931x//b+Hpz+ScQ+dwyW0f5MYbHbDNzLgRoGYTptfcM7qHHGD0yJfYZOQauA6smYo8Z22fEc9kuS7h+jkK6MiYach/R0az9LHOQz4Q8zgD+uHD7v7W1uD2tgOfda+u/nsLSVUW5Nt5/B/ef4zdjIL1DCs1gs9dwHuBDxhj2rhX9hbgd2IJjDHfAzwDx4Aux+3P3sAN2Sd5Qley+aSgdBW2E/oa6Z9uMLKtbkhi+r7e68kX2Q4HMrUqi9tUrGer02/78V+2DLkLCC02O5gZ90jFaC0qX7sN9y13OPuGL7mL3/wtcPXVPOql23R//cPccIMbhRP/n6kmzK441nAfjiXIsxCVSI9GyX2L0Vr7ymibjsTX1zVj0k4avgE6dOwvhqaPZ4BzM5tWo+E0z7vaDlC1kdl/1zqvbiBfv6yY8VmLZoYxthP6D+WxG8BSJnVul5z55vxC9kuV/wf4mWy061dx6ta/AK8DviUlg6GcDKtQxqJG5McrYzI+KGmRES7o3wfcB6BGxl6mGq7Ty/XeFIquG0qHfkOzyHbHXRfgkc0E96uSTm7AdjYxdX7effVbrZM8qPNZt93yZZfClQ/nMT90Owvvu5lPfMKVNdWEAwuubo0VmO26jryKU8T1TqD6mcDOmea9+1VxOvSrZ/4z1xNHY+AjzoOxji8G67MWHZNbW3PAs4wzMIudp4zhFIFOUTzNeERCrKco3L/mh49bxrxvV9da+/nMyPwNwNOstV1jzKnUDIZSu8rUp9i1GAAV0eLQV8qXELsSx7Yp75oBGh03S10c4HrqiFK1kHOvUO2cKOAj2/D0Zmhvujjz825IfWXF/TY32zys8VHnD3TlI+A7v5PLO3/D8vKtHDuWq4Tz885OMrMBC62cBa1ldRWVRY+v6WfvdzwNODqddmIUp0Lt56Nnp4uNR5avDYkYsg8vuueysQF3bubAo4fVfdFsJyQhsElRxVIAZ1DWMw5gmoCtc2azrZF/GPjjDHjEDJgkI7X5FAGNSKiDNNS/n5/erVSzTuk8suxGV8WH/o4iW+50skxFPZP1dWRkayoDk+1urn7pdZ23Og5gZL6W2JBkJG16xhmkWy2nSsl6Y7fdBmtrLS5b/gQH1tedD9AjH8m3/scOn/mrO7jpJrciK7h94WdnYLEDC+tuKY4TOHvJOk59EfD0VQu/s/nPXew4TfrtSQIyGoSETcnz0//6+TZx1stzF+HIEQe2x9fdyNYaua+SDzwp/ShmUC6L5z+TGAj5UvQxrEsGzms8i4lpeSXwWzhC/qxstOsvcPu2J8muGJxF9AhUrBEVvfBtdqoT+kuvVS7IgcqSAwso4Mlky4vbyVSvrTZsK7Dpu69ublQW5iPsR7MgcHmtr+dr+ayvu07ZaMAlfJkDGyfh/AfBRRfxqMfeSafT5ctfdvkK4IktaL4NBzZgoe2sgifIt2Fu4RZc98EoJNqALXYbMWRrW5L++aJXjhTP7CNHcoBeW4Njq3AH5Yyn91wjdQ39x+5Lg0+oPaWy6xhYldV3N2Tc2yVbaz+K2yRQyxOq5DE0+KSwm1jcVPXLvxZiM7Gyuuo4Fl9mxU+RqyHb3Vz90VsmhxYfE18dWS9ofj7fCUP2ANvYcOAxN+fWdBYA6nTggo3bedAlq3DRhXDRRVy2egutFty/DveuwImNPH9xD5hTc83Wu84WdIp+8BEjesguph0xZaRqipzx6HDY2Zn1FkXikX34MJx/vrvX5WW4a83tJHcvO/2F8PKDcEceBnj8/KuU68cbr4YTljGrXRhjno1Tuxq4YfefB34hdXLp2KZXFDWm0NdJsx5hOTqvkF1H6LYsWYqK07PvkDvE6T2nGlkv0Vsp+4uRiU1I1hDTe4GJ747kcbLlwGZ+3rGDTiczwt7lwGl9/SRHjn+Zsy46i7MuOMC3HjoFzSaf/0SLL3zBxZXyZmacKiblzG1kHtrdnWsbyb3tMLhHnpt+L3LNH1TRI0ZTODVradHd7623wX2rsNx147fr7Jw6karK6LqkqO9+vFh5RR83CuJMCuuB8dt8st1Lvws3l+vZ1to1Y8wNuFGv56fkUTrUnsJqqrCfFJEXHlMdNKtJyUukQa5eCdOB/l0U+gAvM0hDNudLZabnirVa/fYecMxJryHUaDi2IwxocdGlX1mBe5bdyNjaGpy/fj+HD8PskSW46CFc1biJmZmTXH+9u35azbrvsaA5tYsq/R7ZnW78WYY6dehZC3hpL+fzmu7+2m13P82mu787NpyKdQL3789SHwR4QtdC91EFeIiE4V3T5/71sUqNQ+0DypOBb7PWbhtjvh/AWvtWY8xzUzOodXpFkYTUrSLA8huGXjhMg0Qsb79OYvPRZWvVQY+K9S3F0c3jQw46en2g7a4DINNwRupemc38XEBpc9MBw8GD+a4ZMr1D7EcbG3BhZ42FuX0wv49LLjkJwLFjroO3MhYlvkryMw3HsqaauQd3z1Gyq5wkA89anpF+tvJ8BHi08fnoUVfWvasu3/V1WGk5w7J4Lcsk1LKO7EuRqhVrR/LzgdYvtyrjGTvIRGQEi4lVlSlrbZ8FxBjTwI1hJEkp+NTNakRSGZU/JCzLcEK/EdnPU67ppyMAIyqXqHHaG1gYkV4JERzraWYFC+BAvpFgp+NGtqzq5LIRoQDV/LwLX1+ntynh/Hw+HWNrwx3LJhhLX76T847Ag47A5d+8xIOPrTn204Lrr3cqm9idZOKrgJxvp2oSByINwnopWmkcTZz95yFLzl7VbDr/nVbLscNja86uc4IceFLVLJ/BhP7963IcMi6HyvTLqwJCfh1D56nX6pYxM59/Nsb8A/B24OxsDaBnA9emZrBrNp+qICbxdUMQuw/0TyhtBtKJnUcvrQo58Phl6cYmS0Y0VTma+eidS/11f8CBh4RNz+Tq11bGRubmHADp/eFPt3OnxnbbGZtXVuDOu+D2g3DkyBqLiw6Iphbm6HZbnHs4W5+o44Do+PG8Hr5fUl+d2dlRfbeFReDoBTmozc25qR/gZuPfdBOsrjvQuY+doKP9jso6fBErjqld8p8KPEUsRl/vePEmmfmM2eD8auBVOK/oC4DXAm8D/kdqBqXgM0rWE/p6adENokM+qVKzGfHpEUbUUNf8fERC4COsCPrXHZ5V4TJdQo+C6QUMRfVpbOZ5z83BdjYMLxsSykJasniZLGy/hWM14PI83XBq2H2rDoiOHIEHnQ/nHmqxbx4efH4OXjKSdnIzByTZqgdydU8DptzD+jp9+x5KfhddlC1xuu7ir6+7fFZW4M5u7qmsh/hjIFAGPIOwHv/9yb+EyX9KPUJxQzJJYDTmofYO8N+zX0+MMUu4plEqYx/tShENQKJ6yXMPrd2sz3VjEUfCafoBSG/not+nlDWdXdcTSyHv4MJ4ROURluEDFOTnc3OuI6+v50Pz7WxIvtvN9pTP8pMh9fvXnd1ncTHb+2vJlXnoEOybd2HCusDlv7DgjsVGJGrXdDN3hjx+PJsaMu/iiDooZW9uZjPR2/mKgy3185ex1e/MBwFfUsHHv6ZZsbSNkKqUqiJVTTtuGfdoF/RsPIdxvEC4wP8GHp+SftfBpwh0ygzQvWHwQFzNiPzREF+tELtO14sr/wJMLfo9fyEHH39lRL0Avd5qZ6vjvJSlw0O+IqI4JIqf0NxcbvM5qYbvBdQ6G/momADW3JxbF1rAZH4+B72ppitbGJl4W4s9SozdBw/mANpuwz0redzNbr6Rn6hWHXJDsoC/zz5CDKKMzcTCQtdjwBNSmYoYTQoj8vObCBmz2mWMeRFuyY393qVkPrar4FP0VYNiW4BcF/aj48Tsbj4I6afiT84U0UPwbZw6IQAUWpRM160LdDv9UzH0PDHp8LrRCOPpdBxACKB0Og6UTMMBS3DnDHJ1aW7OAY8wHb0FkJyf3HR2JVGtJOx0K89zcxPW227aRit7Hm12+g/pUawi0PHfQRXAicXxQce306DOi0CJQJwzgfVANto13ukVLwO+HbjeWntaAo0x/yeepF9GAj6hxhZqVEX2Hskn1IgEgKRh+wAk/E/E9/KVNB0vnqQVz2DI1S4pTy9KNuVVvLeTRhe6akb8lmJCvqOigEerBZ12DiS9iattON2BRsuB0HQzt82InFaqkWwhJjuviuhND/Vxu8uOdYA6ONAVkNEG5I73C6lXvqSympRzDTwh3yVdh0FAJyaTCEZjntX+BWvtJwPhL0vNoFbwSXlBRWCTkq8GIO2dK2DSVOchRpT6ZWvgOqC/ZQ9dtdpf1zETEVFBxFsapYb57EdE++bIVA2gt7PF2prbWLCN2/Gi2YFmK1vvJ5tD1ui6a8K2ZGVGq26y2+3vtHrLoTY5y/OH3P3/MsDRHwQdFjr2n3dRmK9mxYDHj+/Xzw87E1kPjGe7ZE8+aoz5LeBvcY7sIm8CHp2SQS1+PmV6cpm6lVpmiNKHXP81YIQMz6FzLboDbZHbfkz2k8Q9w2e3v+Fq1W1aqWGwk/1or2gBJVnETLyXwalCp1VdGh3HiJrkjow9n6Nuzlj0yKAGlS45AMmWzbpDx9hNiCmUMZdYWIpIOSHGVZQmBDJ+nDIA8+swUTL+ofZfxs2g+R4v/LzUDJKYTxEYVBV/xGIQSWEt2qYTsh2JlNmLxLgqnV5G2noPzquM9gruLdPRhdlMDRPfH8gBRozFkAOQHioXR8RONx/WBqcONgDT6Xe21KCiDcIxZ0KfDen5YKmAE3uG/nHo3ZWxF2FnMZuSn0/Kf6q6NckyZvB5n7X2GX6gMebtqRkkq1113mfZqFaq6LjaziOAI2G+JzSEQcd61wSAxOlQ8p/LwsUTuqmuT9G/Qp9MWdjG2XS2u7BPVVy8kmUZDnBqmG3mRudGwxmSzaZTuzbIjcC6nrH7knsLgVAMeEKdO/VjUceHKlXNip2nAs+ZCkB1Tq8wxkwDP4VbNN7ghs7/i7X2AwXJ/lsgn5fgllFNkl0b7YoZl1MadBmNFrDRHsl6LlfM/iNg46/K17PZkHds3/6j5nHuyE/SSIeWOm7hAMVu9k9AlZEmASC9vY8Yj7tdB0rzDTDd3NdG1CX/meCFacDxgUregaV/IXh/6RL/mZdJKI7PgELg4QOPHKeUF2sfft5lIDbpUrPN58HAzwBXW2vvN8Y8Bfi/xpjLrbV3RNK8ETfapeXzwB8yKX4+Mf0/9esYAhmtSunrvg9QyP4j7MUHmyIAkjpr+4+AXUx0Z5fznnNkF2ba/fX0AUjAqdmE7WzUq5nZh/Z1+o3J/mLwug5yLyHQ0ffr34+etlIEWH6ZKedF8WJsJ8TE/HzKPlC7wXp814IyGbj8em0+J4BftNbeD2Ct/XtjTAsHIu/SEY0x35YdLhljvpX+AeN9wFmphdY+q70IbKrYeTTApMTV5feGxdkJIiGRcjQASfkCYMKe2jiHO+hfWlREe0trNUfUPhnOlrRSpqh3p9vOPqQ9nLVzovj3zKh6Qf8Kgf799raNVvcVAkVfxdJ19zuVBjB9LcZo/LAYMBSpWUW2u2FYz7ikShsPpq9pqN1aey/wR3JujBHV655AdLHpHAHe4V1bp2C7HV8GBp+yr9mgw+mhF1LWYHzw6dIPQJCzG9/245flA5DE0f5cOl9ZTF1m0Ovh9q4KE2CQuWiQgw8qvpQ13XG/ZiMfztdsT2wzTfIdR8U3x/d58u/XB6AiCS0mVkWKVBwfEIq8lWPAE/ovUuUmDYAGlYpb5yTt1a7kibidu/9xZ7n2oQDGmLdYa380uQYBKQSfOl/QIOynioTAK3RzvgOi1K0sT1l+Q9iQ2IAgn9ii0+jyYmqDzyoEqJo4JjODW8aj2e1/dgJukp/eO0tGwvQ+6f79+Me+A6b+Dy3D6qdLBYIQU/GH8kPD6EXAU6ZqyX8nkOZMlwpqV/Je7caYOdwM9RdYa6MlxIDHGPNSa+2bUsraFYNzw/vXErs7/ZUvo/ISLg2socL1vCyJrwFwW537s9p1mb7Bs0H/pEo9AXXb+5djVJiAjLY3yajTafJRM5naIesqC3PzbVTCgGAnAIU6ZMyYHAKd0DVfiphH6HoIcIZhO6GyQ0ynqL2dSaAkGx3UKZm69WbgN6y1nyqJewj4MeCh9I+/PBXnaFgqu2ZwTh3VKruW2rh1Y/KNqRqA/Hg+K9LiA5CARxcHPH1G5YBIuIBMl357kIgMeUsZM+Te28Jyeg6PXn2kFWgA0mAs+ev6pIBL7F5SOrcGcB94/PQpLDQFhPy6xRjYmSwjuI83Ap+w1r7LGDMLnGetvS0S9y9xUwA/R97c8I4LZVeZj39cRYoaUqxh+uqXDzYioREcfa7ja6Ouz3IESEJg4jMQse1oFUrfgy6nk8WdzY6nyYfEQ3UWFVFEA5BIKvDo6yHQKvtg+L8Q2ymTqsATA8TUzjosC9oNFuW3p2HFGPMqXNN5mzFmAbgI+CHglyJJpqy1vnczxphPp5Y5CvNLMPNUW0/qUKr/4EMNXRp5aPREdwA9z8kSNtKKCBjIyJfM+tbr28jIU8jmousleemfeB5LfBneP0m+ls4p4ntgico4Q76lcQyoYsAjz6AMeLT4DDf0DvQkVf8dxmyCsffq1z/l58f1JdY+R9lJhgGQKvddJMaYy3DOgS/BDbufAL5YkuzDxpiLAuGPTqo8u6R2pb68oni6IfsqVOwhS5hu7L4NyM9vmp2g2VX/MvojLEfqpD2pxY4Uerjb3rFmSXrYXTq8HgXToCWgMkVu6/H32tJ5ixHblxDw6HD/uYqqp8Em1rl9oPGNyakqVgrb8eP7bSLWPkb69R2h1Ml8rLU3UmxxAMAY80F12gB+0hhzI/0TS6/GzfsqldLRLv8r5EsdwJIiKY2qDOml8ccASFShKdLqq4e1xdajQch/ftrIHZrKoe8D+oFI7yd/mhx4ZsmN1xrMGqpO8u8DX0itFADUoIs6l7S+S4IPMIOoVzovP1+/nqnAU1ZuDIDOBAP0GOr3IPqnT7zVu26yOEmSNKs95XqokxUNrVd5uWWUOQZIfufSDCI0CiYgVGYDgp12HL07hmZAfdvwBERAocjIK2Vp5iIsZwsHRrLTqDCuhncfhtxmJCAmtqBYmdp4rp+d1DsFcPx3E1OrYyAC4XdLIE1smY/Qua5LCgOaNDDSvmO7KK+01r63KIIx5tbUzEamdqXad1K/TLHGDDsboR8ey08vkSpxpWNCeCRKwFSDhV+usIotVYZ2KMQ7jo2OSZ6yjbOE6WUwWuQMqIkDJDkOAZq8cKmj1D009yumAvqdPXSu658yZJ4KPgTSxMqNpdXXfACaNJApkt2upwYeY8xvWWtfHIjzodT8ds3moxlQyldGS6hh+o0kxnxicf2w0IPwQUarUtq2o+vm11fYlICPv84QhOeb+Xlp36OQ1/QWOfAI6OkvY+yZ6rx8gAkBTozZVFFz/P9YPjHQiaVLYTuh/ELqJ+xsI1WAadQgVvdo1wDyHGPMlYFwCywD77fWvq0og5GCTx12Hp1XrKEVMZ9YIwhR7RgAiaT4v/hf5Kb6N+QGbX/+mZ9HkWijtwYRbQj361sEdrrOMcAp+sXqHFJ7dXlljAcvHZG4sfYQyuNMNTCHZMzgI7PX3wWsAufgluT4MM7/50XGmIdZa38hlsGuLiCfIlVHQAich9LFxF+Own8gPkg1yG07vmig8+spgKNVMWFQITak6xSb4qA7t9hyQh5eIXucLymMpIiVxAYmqgBOGYD4aUJLiaQAV6i+ZyIojRl8LgeeaK3tTXvMllX9c2vtvzfG/E/gI7hNBYNSO/iEjM0pjT8kRcxH22bK0sbK1gxFdwgBhzIJDcn7oqd86CU/NAD5apmWENvS6lcR4BXVNyYx4CjLK8Y2ysAmBHpFdZN3H4pfBjz+tRQAGkb1GqWMyeCs5XwNPJls4ZwTsdaeNsZsFGUwEuZTx1ck1JDkxfu+ObG0ZY3GD2t7534ZRQ2vqNNDPwjJuQ9CMoIlcUK2IC2+3SlWl0FVjiJ2E8o7FWxCDKqsQ2vQCT3rKsCj45ypDGgCbD5fMsb8NfAnwApwLvAc4IvGmCbwo5Q8zl1dyTA1TooK5QNLUVx9HlMPYvlrJhcDxFBeum76WgyEtFqm1TG/zn5ZOo50SmFZ+rxMVYrVPVRu7FmU/fx4/r2EpCgvv16x8yoSAqBJYTu+jLlOLwR+CfgVnG/PncCfA6/BjXtsAz9blIGxNr4ikTEmebkiX93SQ8zawOpLGTUuKyP21fcbaYxSx/71bHJ/baAyBlXW4ULiq6n+/enyY66oIae/qp09JCFQLmI4qXWoAjyxpWLrAJ4YCKd+qGKSWhdrbal3sS+HjNk5sSoi74BPpS6pMawYYx5krb0zJe5YDc5VgCcUVgQuKXE1K/D/O17a0JrNuhP5tpdYPYrq5wNNxztvsBMo/WMKwv16ptbLPy5SncoYT6iMWD3kPcTS1cV4Qmxn0mXcaldgXpc4+I93r/YQbS0STef1eVn8IjUgtbwyANKdRjOgGMCkAFDKeQhcioAndC2Wf6ye/nnRfVVlQEV18aXIQzqWx7AdMQRA/gdhnJ09JLtdH2PMF4DHW2vXgVsi0ZK1pVrBxx/ZSpGyhhkKK7Jh+MASe0ExwAlJR/1rVVLXL4UhxOLFzsvCYyAfewcpYFJWrxTw8Y9j+YbqV5XtpOSbKmUApGXcYDSm0a7vyYAH4IPW2if7EYwx/5Ca2VinV2iJvfiiuPr6oOxHpw2pYyId+gEtNDcsln9RRw+dp96L38FTVLFYnYqOY9dSQTZ07l+LsaayPOoGgCoANG7ZbfCz1up5W7cbY15trX2tF2cHIMWkFvApsjmkvDTd2FJfciob0HHLrpUBkIR31fXQAyzraKE4RWmK1NGqKk1MUkAoBVCrAoRmOlXzGFXnq/IhHJeM2+YDfDPw08NkMDY/nyoqRogZxMJTOr7OQ4eH1LZYnh12AlaVoWm/PmX1TskjlraKpIJNlbzLRiQnCXh0/mXteNyq15jB59MElogyxrzOWvtzKRmMfbSrLtbjA0FqHj6QFY2Ewc4G54NPlQYbs0vV1QFTG2cVYKzy0QjFqQI6KXX7epUJYD73Ap/IbDz3q/AfAsYDPmVGT4h3tkHorp82lIc/DF7GevR5DID8snV4DIRCql3oXlKlCvikgsMwZZTFC6lYRXmMG3iqfMzGIXU+C2PM44A/Bf5b2Wz0TJ4J/C1wMPuJzIWj75TawGeQka6QxF74oJ0g5H8TUr9CoJQyIqbThJawKHousfJ0WEyqgMkwbGWY8iVezKZT9f7G8aWfVACqc7TLGPN0HJjcXxZXye9Ya38lkFehV7OWkdp8ythPF7inwMN6TwaTB5vcYTak1vlSBKgxKWKoGlxCKlaozKL6lMUfp4zT7lNjuZ+01r7HGHNtagINPMaYfbjdLDastb+Rmseu23z8B3aO11GgmPnE7D36F8oj9OUt85Op+l+lnr6E0hV11hT2EJO6O0uI0RTZdHYLeOpiLZPIfmpeQP5YSjxjzAzwIuAS4B+stf/XGPMHwAvcZfMp4D9Ya/81Jb+R2XxCktroYnaZUPyYKpTSYAZVtVKlSM0LAWVROSGbVEr5obzr6kg+uKSoVlVVwHEDzyRLhWdTda/2mPw+8DTgq8DzjDFvBi4AfjCrzjOBNwDPSMlsLE6GVVSBMlZRZIupYhcpGuUquxZr6CEbji4vRT0tkzKgLQLpqhIDllSGs5vAU7dMGphVZD7Je7WXyOOBy6y19xpjLgc+gdvVtAVgjPkr4KOpmdU+vaKKDGp4TI1TpT5+Jy0aZh+GHel7DoHPMO4GOn1M7avSMWN2nKL/WP2qqlPDAsgkAcWoZAzTK+6y1t4LYK39ijHm8wI8WVjXGLOZmtnQ4BP74vuyW1+OEAOqEjcVeGKSwoD88utkJ6H8/eMqYWWMpkoeRWlSrqXKqNrZJLGfMfn5dIwxhnxVly3vvJLUNr2iSIUo6rRFDTlF5dLxQo2j6pe+zIZUBEb+cUgkzrAqRew+5V10vZ8fL3Y+aJxh0qVc2w0pe3cxGdeI1xjKfCL9hMswBAEb+WhXDBCGUaeKykhlPjEQG0T98sNidY8BVVWVrSh/ueYDz7DAUBbngQI8clzUblKN/aOUOpmPMeYxwBtxWx3/nDHm+6y1PxCI+jngpUVZAZM31F720up+WTEQKuokdQBP7OsZA56iOqeKBpimOo6BT10gMCgjGqbMPcmlrudmrf0UcE1C1FdYaz9cFMEY84rUcnfV4JxiTxhUfNbRAH7rrW/lIUeP9sV79tOexsmTJ5mdneXXf+/3uPSKK2g2m7zm1a/mg3//933pq6paBOL5kmJHKqP/ZV9m/V90HDpPkSoAcyYAT+x+hmU/o5bdfnbW2tK1elLiiOwK80npLHWVA/2d+Xuf9KRemJaf+6VfwhjDk7/lW3jYpZfygY99jMc8/OHcs7w8kN0H73qKYboIePzjsny0jEKtrXq9zvL3ZKdMwNY5Q0ttAD7IsPaoJNSBdZg1hh/+8R/nnX/4hwB87atf5XOf+Qz/8bnP7cX10+n/sjBf5fGlaIjdN7IX/fy0oWtlABiSlHsouj4pwKMHQgapR+q1cYBolV1lJ1VGynx8VlAWF+pDQ8nvN373d7niEY9gc2OD33z96/mna6/loRdfzDmHDnHjl7/ci//lG27gUY99bF+9dZ1f/upXc8GFF/KyF72IBnBgaYmvLC/z0AMHePErX8kTrrkGgFObm7zihS/k7jvvZMoY/vtv/zZXXHUVttvl5htv5L/+zM9wajN3hQixJn2tDDxSmdMoWc4gMqoRot1Uh8bdscdd/rAycdsl1/lAv/KlL/HhD36Qz153HY9+7GN574c+xL97whPYv38/AOv355N4719b44or833vfdXqyquu4p+uvbYX/oirr+amr3yFU6dPc/999/H07/gOAJ71/Ofz87/2a7z4ec/j25/6VC44epSnf+u3AvCH734355x7LsduvTUKNEVgHQPoso5cxR5TlNck22++Hnx7fNkDHyb35bzx9a/v1e3T113H3/31X/OCn/gJ3vXOdwKg9ywzgDE7faXkBV951VX89pve1Au76uqr+cLnPkcXOHb77bznQx9iqtHgwOIi0zNuo521++7jiquu4glPfjL//IEP8JPPehbtdrvnkRUbVStiQxDvEF3cCx0UPIpkUPVk1DIqtWrSZQIWExtahsKN2GhOisTsMnXrqjrvY7fdxoUPeQh3Ly8DTnUSOWtpiXuycF+mp6d56MMexheuv75Xt0d84zdy/Wc/y9FLLuEP//zP+cVXvIKnPfGJvPqlL2Xf/Dxd4BMf+xgvf+EL+alXvYqP33or//nlL8cYU2i30f+hMP0v9xWyQ4Xuf9JkmMaXYs95oMuZbvMZy/urYn8Y5uH97Cv6XQ4OnXcedx0/zr9+7Wus3nsvl15+ee/aFVdeyWc++Ulg50O54uEP5/gdd3Dy1KlefZ5wzTVc/7nP8Y2PehQn1tf51HXX0QWmpqd7dT+wuMg/XXstz3zKU3j6Ndfwg89/Ps943vOi9R0GgHwpAqSYFD3vUTWU1Hwb3m9YqdKuJrEDy2hXym9SZej3OKhvT9FxKI9BEP0lL3sZ5557Ll3gIUeP8j3f//38yR/9EdZa3v77v89zf/RHAbj4kku46uqr+fM//uNgPo/8hm/g3MOHeejFFzM3N8d/+ZVf4SFHj3LbLbdw0003sXT22Tzs0kvpAt/+1Kf26vzdT386z33hC+kC/3rzzdx57BhTU1OlRmT/f5hOV6SCVX2eowSgst8gMomgUafsMZ8ECT2IFLAZVn7zDW/gT9/zHv722mt5x7vexctf/GL++R//kS7wq5mfzz989KO85U//lB971rNYvvvuILN4xFVX8Q/vfz9/e+21fP6mm9g4cYJjt9/Oy3/+5/ncZz7DG177Wt7zd3/Hn/zlX7KwsMDhI0f4nbe/nY9/9KNc85Sn8O4PfID3f/zj/OvXvsafveMdpQ0jBDz++TB+U8M822FU7d2USe50dcgDYajd2IJlTI0xhWuchr5QTXWtSEIqQSiszoYdGiUKiV+n97zvfbztD/6A97z73YXpivx2UtQnP9+iZ6MBSOi1vlbU+IZtkKPIs04pq8ugdR3Enpki1trKs8JnjLHnJsY9Dp+qaT2fWqX2ofYu9QJGnfn5ecXy1iNMDRzz+cqXvtTXqQmk9Tt/FUnx6fHPQ7ahWLo6wSFU11H57VSVSajDbsgDYbRr7Pt2pcYbFwAtLS1x7uHD3PTVr/aFw2hAKJSfFhlK9wFHA1GRnW2YeoXyqivfPakuk2xMTpGJcTJMocqjdCQjkv/a2hrnzM72hfmdbBgQ6qrrZWqhnDe9sJjqVgREgwBFqlF6XAA0anvXKNtgVdljPjVI1SHPuoZZQ/n44UUdqYxhhIbC62BCIRWryG6kRQOdjlt3Ix4HAI0aeCZRzvT7GRn4jOorUcRSRpG/31l9gCliNDofP2wQQAqBTAzwYmwqVM9QHcvKL6vzqIAtJGd6JxxE9phPjaI7QUqHHHZELJR/zBY0KAD55fgdsgoIpYKJLidW1zJ1zA8rKiM13qg6ShW7YV3lTYrqtQc+BZL6orQBdxggGbZRFBmjhwGgovzL8tbiA1BsKL2O5+DnU2UkLgXY65BJ7Hy7WadJvP8qMpY1nMvi71ZZReWX5RMCICivf6o6VpTWN3ansMBh1bAUgAnVIQUcB3nnVW2FDzR5ICwmVgv4DMNYhmU9o5YiMBrG36UMuEIqUuhZ+SyoqJ4hhpVioC6qsx8/VHaVOF+PhuNBZM/mQ3+jHhQ86gSgukAs1RBbBBxVytJ5hfLz44dsNj4AxTq6X94gjCiUf1WgKcujTP1MkVF00En5UJ7p4LMrz/BMpchV6lI0/F2lvFCZMXUrdBzKr+w+YkP1KUP8RffZqBCnrF57slO6ib9JlULmM8ickz3Zkz3ZFXk/cCgx7sooKzKoFE4s3ZM92ZM9GZXsMds92ZM9GYvsgc+e7MmejEX2wGdP9mRPxiJ74LMne7InY5E98NmTPdmTscj/D2WvdmEbqvdBAAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -69,15 +69,6 @@
      },
      "output_type": "display_data"
     },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -97,15 +88,15 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
-   "id": "e6e07306",
+   "execution_count": 4,
+   "id": "156e58b9",
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "loaded spacecraft ephemeris ./arrays/ephemeris/TESS\n"
+      "loaded spacecraft ephemeris ../arrays/ephemeris/TESS\n"
      ]
     }
    ],
@@ -116,8 +107,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
-   "id": "820b2774",
+   "execution_count": 5,
+   "id": "78fdd8a3",
    "metadata": {},
    "outputs": [
     {
@@ -127,7 +118,7 @@
        "       'CARMA', 'KP', 'GLT', 'TESS'], dtype='<U32')"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -139,8 +130,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
-   "id": "e8621596",
+   "execution_count": 6,
+   "id": "8d0c3235",
    "metadata": {},
    "outputs": [
     {
@@ -152,7 +143,7 @@
        "       dtype='<U69')}"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -164,13 +155,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "b901b837",
+   "execution_count": 9,
+   "id": "fb7070c0",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1296x432 with 3 Axes>"
       ]
@@ -179,15 +170,6 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -197,8 +179,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
-   "id": "6be62fca",
+   "execution_count": 10,
+   "id": "9231cf6b",
    "metadata": {},
    "outputs": [
     {
@@ -224,13 +206,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "id": "d5b7bfde",
+   "execution_count": 11,
+   "id": "386a8734",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -242,16 +224,7 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -260,15 +233,6 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -279,17 +243,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "e1283deb",
+   "execution_count": 12,
+   "id": "b04175ae",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'GEO': [60053.91684552315, 1, 0, 0, 0, 0]}"
+       "{'GEO': [60275.79784521178, 1, 0, 0, 0, 0]}"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -310,13 +274,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "id": "d4fed862",
+   "execution_count": 13,
+   "id": "2e613927",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABHcAAAD0CAYAAAARxMp+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/OQEPoAAAACXBIWXMAAAsTAAALEwEAmpwYAABAo0lEQVR4nO3dfZycVX3w/89JAkkIiWShZFPRRAT8QYQkFSsTbAithXqrLZQWRSJasBsQEay4C2il+ABJxBrUAju3tIiJVfvLTZTyu5tYaxIhiyImPCS0BEuSYtkbZMNNQp5Icn5/XLNhdndmH2bn6Zr9vF+vfTHXuZ6+M2zmzHz3nO8JMUYkSZIkSZKUTqNqHYAkSZIkSZJKZ3JHkiRJkiQpxUzuSJIkSZIkpZjJHUmSJEmSpBQzuSNJkiRJkpRiJnckSZIkSZJSbEytA6g3xxxzTJw+ffqQz3vllVeYMGFC+QOqAGOtjDTFCqXH+8gjj/wmxvhbFQhJSr2R0IdAuuI11sqwD5EqYyT0I2mKFdIV70iI1X6kOJM7vUyfPp1f/OIXQz5v9erVzJs3r/wBVYCxVkaaYoXS4w0hbC1/NFJjGAl9CKQrXmOtDPsQqTJGQj+SplghXfGOhFjtR4pzWpYkSZIkSVKKmdyRJEmSJElKMZM7kiRJkiRJKWZyR5IkSZIkKcVM7kiSJEmSJKWYq2Wp6jo6Oli8eDEbNmwgxsjkyZN56aWX2LNnD2PHjj20HWNkzJgxHDhwoM++3tvjx4/nmmuuoaWlpdZPT5IkSZKkqjK5o4ro6OjgnnvuYdOmTWzbto09e/Yc2tfZ2dnj2K1bt/a7PdhjFyxYwBe+8AXGjBlzKPkzbdo0TjnlFC655BIymcxwnpIkSZIkSXXJ5I7KIpvNctddd7Fv3z46Ozv7JHCq5dlnn+2xvXXrVtauXcudd95JU1MTEydONOEjSZIkSWooJndUkvypVS+++CI7duyodUgD6urqoqurq0fCp7m5mTPOOIPW1lYTPZIkSZKkVKppcieEMB74GbAqxnhtCGEccCvwa+BEYGGM8ancsfOB2cAB4FcxxvZc+3Tgr4GngenAp2KMO0MIo4CbgR259rtijA9V79k1nmw2y2233UZnZyddXV1luWZzczPNzc3Dqrmzbdu2kuPp7OxkxYoVrFixgubmZiZPnmztHilF7EckScNhPyKpUdR65M4XgfV529cA22KMi0MIpwJ3Ab8XQjgOuBaYHWOMIYSHQwj/FmPcDNwJfC7G+PMQwlVAG8mb64XApBjjdSGEJuChEMLJMcYDVXx+qdc9Qmft2rUlJ1Cam5sPPR5qHZzVq1czb968Ae+RPy2sO/kDfev79Kd7OtmCBQu49tprOe6440z0SPXPfkSSNBz2I5IaQs2WQg8hfAh4EHgmr/k9QAdAjPFxYGYIYRJwLvBIjDHmjusA3h1COAw4G3g41/5g7hq9r9UF7AFmVOwJNZCOjg7OP/98pk6dypw5c1ixYsWgEzvHHXcc06dPZ9q0aZx33nmsW7eO55577tDPli1bWLNmDXfccUdZp0G1tLTws5/9jPXr1/PMM88cut+6des477zzmD59+qFRQoOxY8cOnnzySRYsWMDRRx/NKaecQjabLVu8kobPfkSSNBz2I5IaSU1G7oQQTgFOjjHeEEI4LW/XsSTDFru9nGsr1n4MsDvvTba7vb9rFYqnBWgBmDJlCqtXrx7yc9q5c2dJ59VCsVg3btxINpvlscceG/S1Jk6cyGGHHcbEiRO54IILeN/73tdj/969e4f1upTjdb366qt7bG/cuJHvfve7bNq0aVBJq+5aPQsWLOD666/nIx/5SJ/nWa5Yqylt8Ur56qkfGWl9CKQrXmOtjDTFKhViP1I7aYoV0hWvsY5stZqWdT6wJ4RwHfBO4PAQwjXA88DEvOMm5dqeB07o1f408BtgfAgh5N5Qu4+nn2v1EWPMAlmA008/PQ5mGlBvg50+VA96x5rNZrnlllvYsmXLoM6fOHFi1aYsVeJ1nTdvHldeeSXQc8n2J554YsBkT1dXF3/7t3/Ld77zHW666aYezz9NvwOQvnilXuqmHxlpfQikK15jrYw0xSoVYT9SI2mKFdIVr7GObDVJ7sQYv9T9OFe07MgY45Lc4wzw09wc10djjC+HEFYCV+W9aWaAr8cYXw0h/AR4O/Bz4Ezg/tyl7wfmAt/OzXEdB2ys1nOsd91JjX/913/l6aefHvD4pqYmpkyZ0nA1aDKZTI/pYYMtGt1dm+fGG2/sk+SRVHn2I5Kk4bAfkdRoar1a1gUkb3iHhxAuAm4Dbg0hfJYkM34ZQIzx2RDCrcBXQwgHgG/mipcBXA58LoRwDvBG4K9y7d8HZocQbsy1X2LxskR7ezvf+973eG30aHHTpk3jhhtuGDHJi5aWlkPPdTDFpPOTPB/84AfNPktVZj8iSRoO+xFJjaKmyZ0Y43Jgea/mK4scuxRYWqB9C3BpgfaDJJXqlZPNZrnxxhsHtYLU3LlzWbhwYVmLHqdNJpPh3nvvBQZ+7To7O4tO15JUOfYjkqThsB+R1ChqtlqWqiebzTJ16lQWLFjQb2Knqanp0ApXa9asGdGJnd5aWlp47rnnaG9v73fFre6RPLNnz6ajo6OKEUqSJEmSRiqTOw2so6ODWbNmDZjUOfnkk2lvb+fFF1/k3nvvNanTj8EmeTZs2MCcOXM466yzTPJIkiRJkirK5E6DamtrY86cOTz66KNFj5k1axbr1q1j06ZNTiMaosEmedauXcucOXNoa3NEriRJkiSpMkzuNKD58+ezePHiovubmppob29n/fr1jtIZpvwkT1NTU9HjFi9e7FQtSZIkSVJFmNxpIN3TsJYtW1Zwf3NzM+3t7SxfvtyROmXW0tLC8uXLaW1tLXpM91QtR/FIkiRJksrJ5E6DGGgaVmtrK88995xJnQpbtGgR69atY+7cuUWPcRSPJEmSJKmcTO6kXPdonf6mYbW3t7No0aIqRjWyZTIZ1qxZw7p165g5c2bBYxzFI0mSJEkqF5M7KTbQaJ3ugsmO1qmNTCbDhg0b+p2qtXjxYs4999wqRiVJkiRJajQmd1JqoKLJra2tFkyuE91TtYqN4lm1ahUnnXSS07QkSZIkSSUxuZMyAxVN7h6t4zSs+jLQKJ7Nmzdz5plnks1mqxyZJEmSJCntTO6kSDab5cwzz+y3aLKjdepb9yieE044oc++GCMLFiywDo8kSZIkaUhM7qRENptlwYIFxBgL7rdocnpkMhk2b97MOeecU3D/4sWLmT9/fpWjkiRJkiSllcmdFGhra2PBggUF91k0Ob1WrlxZdJrWsmXLTPBIkiRJkgbF5E6d669wstOw0m/RokW0t7cX3Lds2TJX0pIkSZIkDcjkTh2bP39+0cLJra2tTsNqEC0tLbS3txNC6LNv1apVJngkSZIkSf0yuVOnTOyMLC0tLTz44IMFl0s3wSNJkiRJ6o/JnTrU1tZWMLEzdepUlzlvYN3LpRcqtGyCR5IkSZJUjMmdOtPW1lawxs6oUaNYvny59XVGgJUrV5rgkSRJkiQNmsmdOlIssTN16lQeeOABEzsjiAkeSZIkSdJgmdypE8USOyEER+yMUP0leFwmXZIkSZLUzeROHSiW2AG48847TeyMYMUSPMuWLTPBI0mSJEkCTO7UXEdHR9HETnt7Oy0tLVWOSPWmvwRPW1tbDSKSJEmSJNUTkzs19rGPfaxgu4kd5Vu5ciWzZs3q07548WKy2Wz1A5IkSZIk1Q2TOzU0f/58NmzY0KfdxI4Kuf322wu2X3755XR0dFQ5GkmSJElSvTC5UyPz589n2bJlfdpbW1tN7KigTCZDe3t7n/YYI1dccUUNIpIkSZIk1QOTOzXQ1tZWMLEzc+ZMFi1aVIOIlBYtLS0FEzyPPvqoBZYlSZIkaYQyuVNlxQoojxo1ijvuuKMGESltWlpaaG1t7dNugWVJkiRJGplM7lRZoQLKU6dO5YEHHnDJcw3aokWLihZYtv6OJEmSJI0sJneqqK2trWAB5eXLl5vY0ZAVK7Bs/R1JkiRJGllM7lRJselYra2tJnZUkmIFlh999FGnZ0mSJEnSCGJyp0quu+66Pm0WUNZwFau/4/QsSZIkSRo5TO5UQUdHB2vXru3TbgFllUOx+juFEoqSJEmSpMZjcqcKChVRnjt3rtOxVDaF6u+sXbvW0TuSJEmSNAKY3KmwYkWUFy5cWP1g1LAymQxz587t025xZUmSJElqfCZ3KsgiyqqmQglDiytLkiRJUuMbU6sbhxDeDHwR+CVwHPBijPHzIYQmYCHwn8CJwA0xxv+TO+fTwCRgMrAqxvjDXPss4ErgGeBY4NoY4/4QwjjgVuDXuWstjDE+Va3naBFlVVMmk6G1tbVPQnHx4sWcd955JhTVUEZCHyJJqhz7EUmNpmbJHaAJ+G6M8QcAIYRNIYT7gb8E/jXG+P0QwvtI3hA/FEJ4B3B2jPF/hBDGAE+GENYALwNLgXfFGDtDCF8BPgzcBVwDbIsxLg4hnJpr+71qPDmLKKsWFi1axKpVq/pMBbzuuutYs2ZNbYKSKqOh+xBJUsXZj0hqKDWblhVjfLj7zTQvlleA9wDdVWAfzG0DvLe7Pca4H3gSOAs4HhgfY+wscM578s55HJgZQphUkSfUi0WUVSsWV9ZI0Oh9iCSpsuxHJDWaWo7cOSSEcD6wMsb47yGEY4EduV0vA5Nz2fFjSd5Eydt3LPBC3vH57eT+W2jfy73u3wK0AEyZMoXVq1cP+Tns3Lnz0Hn33XdfwSLKF154YUnXLrf8WOudsZbm1FNP5fHHH+/Rdvnll3Pbbbcd2q6neKXhaLQ+JA3SFK+xVkaaYpUGYj9SXWmKFdIVr7GObDVP7oQQzgbOJhm2CPA8MBF4iWRO6/bcnNXu9m6TcscWa2eAfYfEGLNAFuD000+P8+bNG/LzWL16Nd3nXXTRRX32t7a2cuWVVw75upWQH2u9M9bStLe3M2fOnB5tjz32GGPHjj00eqye4pVK1Yh9SBqkKV5jrYw0xSr1x36k+tIUK6QrXmMd2Wq6WlYI4T3AucDVQHMIIQPcD3TPXTozt01+ewjhMOBkYC1JsbPdIYTmAc45FXg0xtgjU15u2WyWzs7OHm3Nzc0WUVZVFVsavVCRbymtGrEPkSRVj/2IpEZSy9Wy3gZ8D/gF8BNgAvB3wA3AohDCScCbgWsBYowPhRB+EkK4maRC/adijC/lrjUf+FIIYSswGvhW7ja3AbeGED4LnABcVunndeONN/Zpu+mmmyp9W6mPhQsX9hm90117x9pPSrtG7UMkSdVhPyKp0dQsuRNjfAQ4ssjuvyxyzpeLtG+gwJtljHE3ybKEVVFs1E5LS0u1QpAO6R6903vVNlfOUiNoxD5EklQ99iOSGk1Np2U1GkftqN4sXLiwT5srZ0mSJElSYzG5Uyb33Xefo3ZUd6y9I0mSJEmNz+ROmXznO9/p0+aoHdWDYqN3Nm7cWINoJEmSJEnlZnKnDDo6OvqM2mlqanLUjupCsdE7K1eurEE0kiRJkqRyM7lTBosXL+7TVujLtFQrhUbvbNq0qQaRSJIkSZLKzeROGaxfv75PW2traw0ikQrLZDJMmzatR9uvfvUrCytLkiRJUgMwuTNMHR0dbN26tUfbrFmzyGQyNYpIKmz27Nl92gqNOpMkSZIkpYvJnWEq9OX4jDPOqEEkUv8KjSZbu3ZtDSKRJEmSJJWTyZ1hKvTl+JJLLqlBJFL/Ck3N6urqIpvN1igiSZIkSVI5mNwZhmw2S1dXV4+26dOnOyVLdeuGG27o03bbbbfVIBJJkiRJUrmY3BmGJUuW9Gm7/vrrqx+INEgtLS00NTX1aOudoJQkSZIkpYvJnWHYvn17j+2mpiZaWlpqFI00OG9961t7bHd2drpqliRJkiSlmMmdEnV0dNDZ2dmjrfeXZqkenXLKKX3aXDVLkiRJktLL5E6JCn0ZLvSlWao3hQp+P/TQQzWIRJIkSZJUDiZ3SlToy7CrZCkNMpkMzc3NPdqcmiVJkiRJ6WVypwSFpmQ1NTW5SpZS44wzzujTds8999QgEkmSJEnScJncKUGhL8FOyVKatLa29mnbtGlTDSKRJEmSJA2XyZ0SFPoS/IEPfKAGkUilyWQyfZZE37ZtW42ikSRJkiQNh8mdEmzdurXHdnNzMzNmzKhRNFJ5vPjii7UOQZIkSZJUApM7Jejq6qp1CNKwTZw4scf2jh07yGazNYpGkiRJklQqkztDlM1m2bFjR4+23tNbpDS44IIL+rTdddddNYhEkiRJkjQcJneGqNCX36uvvroGkUjD8773vY/jjjuuR9u+fftqFI0kSZIkqVQmd4ao95ff17/+9bS0tNQoGml4xowZ02P7pZdeqk0gkiRJkqSSmdwZou3bt/fY7v3lWOURI+zZAwcPwoEDtY6mce3Zs6ffbUlKsxhrHYEkKc3sR5QmAyZ3QgiTQwjvCCHMCyEcX42g6tnevXv73VZpYoQf/xguvxxOPRXGjYMjj4QNG2DsWJg+HS68EO65B3bvrnW0jWPs2LE9tp2WJSmt9u+HFStgwQJ461uTfmT0aHjkEZg4EX73d+HTn4YHHvDDuiSpr5dfhm9+Ez7wAXjTm+Cww2DUqKQfOeYYeNe74ItfhKefrnWkUmFFkzshhCNDCN8Gfgl8Dfgi8M8hhF+EEN5WrQDrzbhx4/rd1tAcOADf+Aa84Q1w3nnQ3g5PPAH79iX7Ykz+u3Ur/NM/wZVXwrHHwlVXgSt3D9/s2bN7bHd1dblilsouhPAHIYTlIYQnQwhbQghrQwhXhxAc+qhh27kTPve5pG+45BLIZmHjRti797Ukzs6d8PDD8JWvwB/9ERx/fHKcI0Ol+mcfokrbuhU+8hFoboZrroHvfQ+2bEn+aNDtxReTP0R//vPJH6IzGfjXf61RwFIR/Y3c+QLwtzHGN8UY3xFjfGeM8RTgHOAvQgivr06I9WV//r9y4KijjqpNIA3g3/8dZs2Ctjb49a+TD98D2bkz+clm4YQT4Ac/qHiYDa21tbVP22233VaDSNSoQghXAO8D7gD+FHgXcG1u97dCCE4PVsl+8pOkL/jyl2H7dui1mGUfMcIrryQf2v/qr+Btb4OnnqpKqJJKYB+iSjp4EG6/HU45BZYuTWYHvPJK/+e8+mpSOuKhh+BP/gQuuggsWal6UTDjnXujvDHG+HLvfTHGrhDCVcCkSgdXb7LZLM8++2yPtsMPP7xG0aTb//pf8KEPJW+ipQyP37cv+fngB+HDH05G/4yyex+yTCZDU1MTXV1dh9ryH0vDketL/iPGeEeB3T8PIbwBOBH4j+pGprSLMRmt85WvlD5V95VX4PHHYfbsZMrvBReUN0ZJw2MfokravRv++I+howN27SrtGrt2wb33JiN41qxJkkRSLRX8OhxjPFgosQMQQrg0Jv5vZUOrP0uWLOnTdtlll1U/kJRbvhzmz0/eEIdb92DXLvjWt+CjH7WGQqkmTpzYY7t3HR6pVLm+5N8K7QshnB5j/K8Yox/KNWStrfC3fzv8GmwHDyb9yIc+BN//fnlik1Qe9iGqlD17kvo5Dzww8Eidgezdm0zZmjMHnnyyPPFJpRpwrmoI4SbgI8ABIJCM2Pn7yoZVn3b3+hTZ1NTkMuhD9Nhjr43YKZddu5K5saeeCp/8ZPmuO1JMnjyZrVu39tiWyi2E8DvAh4GJJH3JqcDpNQ1KqfT3fw933FH6X1oL2b0b/uIvkilev/M75buupPKwD1E5XXoprF+fJHnKIcakGPNZZ8HmzfC615XnutJQDWYiy+8A02OMx8cY3wSM2KEqvevrvPGNb6xNICn16qvw539evjfSfLt2wWc+k7yhamhe6jVRuPe2VCZfB34CfAu4G9hQy2CUTv/1X/CJTwz/L62F7NqV9FEuGijVJfsQlcX99yc1O8u9+m6MSd23j3+8vNeVhmIwyZ31QP6SUCN28sv27dv73Vb/br0Vnn22ctOn9u5NpntpaPb0yrb13pbK5JEY44oY45oY4xpgYa0DUvpcemnyXl8pnZ3wpS9V7vqSSmYfomHbvTtZVbGcIz/z7dmT1BVdvboy15cGMpglBF8AfhNC+D+8Ni3r6IpGVaf29vpE2Xtbxe3fn6xmUqk3U0hqJzzxBDz6KMycWbn7NJreNXasuaMK+UkI4VvAr3Lbc0lWPZEGZfPmpD5Cr0Ury2rXLliyBG64AXwrlOqKfYiG7Xvfq/zozF274AtfgHnzKnsfqZDBjNz5E+C386Zl/VWFY6pb48aN63dbxf3wh5X9QN5t71746lcrf59G0rvGjjV3VCGfBn4JbM39vFTTaJQ6X/saHDhQ+fscPJj85VVSXbEP0bAtWgQ7d1b+PuvWQV45S6lqBjNyp6PXylhbKhRL3etdc6f3tor79reTeaiVduBAshrXP/wDhFD5+zUCa+6oSjbEGG/r3gghPFjLYJQ+3/1uUrut0nbuTPqQiy6q/L0kDZp9iIZl2zbYsqV697v3XrjmmurdT/UhhDAVuJYkAT0aeAtJ/uReYDFwOLAqd3gT8J8xxiUhhHFAK3AYyUJWvwV8PzcNddAGk9z5wxDCfOAZkmlZbwTePJSb1FII4V3AnwLPAzHGeFOp17LmTul+/vPq3evAgaTopvWuB8eaO6qSA7nVF7uH1L8P+PMaxjNo5exHVJoXXkhWIqmW9eurdy9Jg2IfomH5xS/g8MMrs7BLb3v2wJo1JnfqXQghA8wDVscYO8pwvXHAD4E/jTH+V67tcOA7McafhxBWA0fGGP8mt+9o4P/Jnf4PwP8bY1ye2zcGWBlCuDbGOOhPJYNJ7mwB3p+3/dHBXrzWQghHAHcCM2KMe0MIy0MIfxBj/HEp17PmTml27oTnn6/e/Q47DB55xOTOYFlzR1XyTmAF8KbcdlPtQhm8cvcjuWuWL8Ayy48t5lW/7x1zjJEQwqGfGGOP47vP6X29/PN636dQ2+jRo4kxcuDAwVwx/tEk6zoczB3Z33YEAp/+dH5Uo0j+TnWg3+3f/OYAo0fDqFGjCCFw4MCBQ7HntxWKu9hzLPb65O/rPreQQv8/el+zXtRrXEo1+5DXrlm+AMusUF9RaN9g+pDuc3q/DxdrH6jt1Vf7f9/vb7u1NfLamkKDO3/Fir79CAzcr/T3HHu/NvmvXff2wYMHDx1T7L24WF9fTyodVy6x82OSkTT7cv8uh5vgeQ+wpTuxAxBj3Af8WYH7NwOXxxj/JoRwHPCuGONFeeftDyF8G/gE8BeDDWAwyZ2vxBgPzRoMITw22IvXgQywNcbYnYV5kORFL+kN1Zo7pXnhhaQwZTVq7kAybL+ayaS0mzx5MlvzJgZbc0cVcnWMcW33Rgjh1FoGMwRl7Ufq+UM5FP8wVai92IfxUq5VTP6H1FzLELdjrxUaB3/+wYN97x9jLBBTX4N5jsN5fer1w3i37i8cUhnZh5DePqTQvoH6kO5jCr3nFmofbNvQ+5GD9LzE8PqRwfYrA/U3hV7PwUrD+3MV+pF5JImd0SRToeYBw03uHA90dm+EEKYBFwFnAlflms8OISwBjgD+O9c2Lf+8PJ3ACUMJYDDJnSuAh3MBvh1YBPzTUG5SQ8cC+ZVeXs619RBCaAFaAKZMmcLqIuvXjR49us9297E7d+4sel69qXase/cmVeMH8Xm4j+OO28mtt64e0jkhQFNT9ZchTNPvALwW77Zt23q0b9u2LVXPQ6nx+8BaODTU9EYK/CWjDg3Yjwy2D5FGEv8dqMwatg8B+xGpkAr/O1gN7CNJ7Lya2x6uXwHv6N7IDZBZGELYAhyZa/5JjPHa3HSt43Jt24DmAtdrBp4dSgCDSe4cE0K4lGQJ9A8D9w3lBjX2PDAxb3tSrq2HGGMWyAKcfvrpcV6Rtev29xp6sn//frqPXb16NcXOqzfVjvW55+C880qb43rrrau59tp5QzpnwgT4xjfgz6s8EztNvwPwWryv9qpQ+uqrr6bqeSg1LgwhLCPpSL/La51cvRuwHxlsHyKNJP47UJk1bB8C9iNSIZX8dxBj7Agh/AFlrLkD3A98JoQwPca4BSAkw+1G9z4wxrgvhNAZQvj9GOO/hRB+HEK4oFfNnQ8BnxlKAAMmd2KMfxxC+HPgYmAOMGMoN6ixDmBaCGFsbjjkmcDtpV7MmjulaW6u7spVo0fDKadU735pN2HCBHbkLWU2YcKEGkajBvanJH+VfC9wJclStmlQ1n6kv5oq9aARa+6EQN7UrMHXWhg1ypo7parXuJRq9iGkqw+Bxqm5M2pU5ODBodXcKdSPgDV3BqsaceUSOuVI6nRfb28I4b1AWwhhO8mHkhOAu4GjgbnA4SGEz+ZOOYIkYf1vwEdy580i+WWaDPxNjPGhocRQNLkTQvj7/E2SVbJuB04FTh/KTWolxrgrhHAF8LUQwgvAY8MpYGbNndKEADNmJFXqq2HXLjjttOrcqxE0NzfT2dnZY1sqlxDC3LzNVcBJJJ3WdcBf1iSoISh3P5K7Zp+2tI78q5b9+5NRmfv2Df3cL3956CNAZ8yAJ54Y+r2GK02/B2mKVellH1LwmgXb0/Rvshax/uxncM45pa28uHjx0PqRUaPgk5+EW28d+r2Gy9+D2ooxPgdcU2T37/dz3h5g2Cvp9Tdy5yDw7bztu3P//dBwb1pNMcYfAT8qx7WOOuqofrdV3B/9ETz+eFJ/p9Le8hYw7zZ4L730Ur/b0jB9FXiU5I8EAF0kf51ISzHMsvYjKs2YMTB7dvLhvNIOOyz5AiCpLtiHqCxmzqze4i4TJsDvF/0aL1VOf8mdq2OMr/RuDCGUbehS2mzfvr3fbRXX0gJf/nLl73PkkXDttZW/TyPZ06sYUu9taZg+EWN8sHdjrkC/NGif+hRcdhns2DHwscMxejRceWVl7yFp0OxDVBbjxsH8+fD3f1/5JM/YsXDuuZW9h1TIqEKNIYRRJMWA+hQryxX/+VgI4a0Vj67OWHOndG94A/ze71W+9k6M8P73V/YejWbs2LH9bkulyvUlkwrtizE+HEI4PoRwcpXDUkqdd14ygqeSQoC3vx3e/ObK3kfSwOxDVG7XXJOMzqyk8ePh6quTPxRI1VbwY1KM8WAI4W7gRyGE54BfA/uBJmAm8NUYYw1mo9eWNXeGZ8mS5EPz7t2Vuf6ECXDLLcmbqgZv8uTJbN26tce2VA65vuS3QwhZ4J/p2ZdkgJOBS2oYolLksMOSfuRjH4NX+owrLo9x45LVFiXVnn2Iyu3kk+HP/gz+6Z9KW8V3MCZNSpJIUi0UHLkDEGN8iqSi+98Bm4H/Bv43MC/G+K3qhFdfrLkzPDNmwPXXwxFHlP/ao0cn13co/dBZc0eVFGO8i6R+258D/xP4DtAK/Ab4SKzXZRpUlz70ITjjjMr85fWII5JpvRbkl+qHfYjK7RvfSMo4VML48fCP/1i560sD6XeAc4zxIPDj3M+I17vGTv4KQxqc66+HVauSlbPKlTEPAV73Ovj+95Pq9Boaa+6o0mKMPwV+Wus4lH4hwLJlMGsWPP885K34OizjxiXFNv/6r8tzPUnlYx+icpo0CVasSArn79pVvusecQR8/ONw9tnlu6Y0VH4VHoLQq2BMZ2cnHR0jtr50ScaMgX/5l+RDdDlmtY0aBUcdBT/9KUybNvzrjUTW3JGUJlOmwLp1cOyx5anBM24cnHpq8oeHStdikCTV3plnJgmecs0mOOIIuPRSWLiwPNeTSjVgcieE8MfVCCQNZs2a1aftnnvuqX4gKTdhAqxenRQ+Hs6b6oQJyQfyRx6BU04pW3gjTu8aO9bckVTv3vQm+OUvkylaEyaUfp3x4+Gii2DtWofRS9JI8od/mHwfef3rS6/XOXp08l1m4UL42tcqv3CMNJDBjNz5bAhhcQhhRsWjqXOtra192jZt2lSDSNJv3Di4+274wQ+Sv8JOnDj4c484InkTvvHGJLHzpjdVLMwRYdu2bT22rbkjKQ2mTk2SMkuWJImZoSRnjjwSfvu34f77k2VxXR9Bkkaet78dNm+Gv/zLpB8YbF/QndQ5/XR4/HG46ioTO6oPg0nufBj4G+CsEMLfhRDeV9mQ6lcmk6G5ublHW/4qQxq6d70Lnn0WvvUteMc7kiH2kyb1fHPtbhs7NllS/eab4b//Gz79aZcZHK5sNktXV1ePtvEuN6YKCCF8P4TwutzjU0MI3691TEq/EOCjH03q73zjG8kozu4+Y/z45HEIyeieiROTaVdnnQXf+x5s22ZtBCkt7ENUKePHw223wdat8JnPJH90PvzwpJ7n2LHJd40Qkj5kwoTXRnw+8AA89BAcf3ytn4H0msHMVh8NHAD2AnOAaSGEc4CfxhhH/Bvr3r17ax1C6o0ZA+efn/zs3AkbNsD69fCb3yR/mf3iF5PpV297W/KGq/K56667+rRd4/qNqozfBh4IIVwcY3wshPBorQNS4xg/Hj784eSnux95/HF4+eVkyP1tt8Hs2fDWtyYf2iWljn2IKurYY+Gzn01+nn8+mR3w1FOwe3fSj7S3J99FTjjBBVxUvwaT3FkKTAT+GbgwxrgZIISwCBhxyZ1xvcbr9d7W8Bx5JLzznckPJHNhP/jBmobU0Pbt29dj+7jjjqOlpaVG0ajB/Qi4F1gWQlgIuHytKqJQP/L+99c0JEnDZx+iqjn2WHj3u5MfSPqRefNqGZE0OIPJO/4HMCvGeHVeYudwoEz1xdPlqKOO6rG9f//+2gQilUHv+jpjyrH0jFTYeGATcBZwCfCXtQ1HkpQi9iGSNIDBJHc+GGPckd8QY9wXY7yqQjHVtcN7jed+9tlnyWazNYpGGp49e/b0uy2V0XPA9BhjF/BuwDdOSdJg2YdI0gAGTO7EGA9UI5C0uOyyy/q0LVmypPqBSGXQe1rW2LFjaxSJGl2M8bYY49O5xwdjjLfUOiZJUjrYh0jSwCwHNUQtLS00NTX1aNu9e3eNopFKd9999/VZKWv27Nk1ikaSJEmSVCqTOyV44xvf2GP7sMMOq1EkUumWL1/ep621tbUGkUiSJEmShsPkTgl6L3++efNmNm7cWKNopNL0HrXT1NREJpOpUTSSJEmSpFKZ3CnBW97ylj5t//iP/1iDSKTSdHR0sGNHjzrpTJw4sUbRSJIkSZKGw+ROCQpNXfnVr35Vg0ik0txzzz192qy3I0mSJEnpZHKnBJlMhubm5h5tvVcdkurZpk2b+rRZb0eSJEmS0snkTolOOumkHttdXV10dHTUKBppaJ566qke283NzdbbkSRJkqSUMrlTolNOOaVP2+LFi2sQiTQ0HR0ddHZ29mgbO3ZsjaKRJEmSJA2XyZ0SXXLJJX3aHnrooRpEIg1NoSSk9XYkSZIkKb1M7pSoUN2dzs5Op2ap7m3YsKFPm/V2JEmSJCm9TO4MwxlnnNGnzalZqmcdHR1s2bKlR9usWbOstyNJkiRJKWZyZxgKjXZYv359DSKRBqdQ8rFQklKSJEmSlB4md4Yhk8kwa9asHm1bt251apbq1tq1a/u0FaofJUmSJElKD5M7w+TULKVFNpulq6urR9u0adOckiVJkiRJKWdyZ5gKjXooNDpCqrVbbrmlT9sNN9xQg0gkSZIkSeVkcmeYMpkM06dP79HW1dVFNputTUBSAYUKKU+cOJGWlpbaBCRJkiRJKhuTO2Vw/fXX92m7+eabaxCJVFihqYKnnXZaDSKRJEmSJJWbyZ0yaGlpYeLEiT3aLKysevLQQw/1abvoootqEIkkSZIkqdxM7pTJzJkz+7Rdd911NYhE6imbzdLZ2dmjbe7cucyYMaNGEUmSJEmSysnkTpl84AMf6NO2du1aR++o5goVUl64cGENIpEkSZIkVYLJnTKZMWMGc+fO7dPusuiqpUKFlJubm13+XJIkSZIayJha3DSE8FVgF7ATmAlcE2PszO37NDAJmAysijH+MNc+C7gSeAY4Frg2xrg/hDAOuBX4NXAisDDG+FTunPnAbOAA8KsYY3sln9fChQuZM2dOj7ZCtU6kaik0NfCMM86oQSRS+TRqHyJJqg77EUmNqCbJHeCVGONnAUIIbcBngKtCCO8Azo4x/o8QwhjgyRDCGuBlYCnwrhhjZwjhK8CHgbuAa4BtMcbFIYRTc22/F0I4DrgWmB1jjCGEh0MI/xZj3FypJ5XJZJg7dy5r16491NbZ2Uk2m3XJaVVdR0dHj9/Fbq2trTWIRiqrhuxDJElVYz8iqeHUZFpW95tpXgw7c4/fC3TkjtkPPAmcBRwPjO/OqAMPAu/JPX5P3jmPAzNDCJOAc4FHYowxd1wH8O6KPKE8hWqZ3HjjjZW+rdTHFVdc0adt7ty5TslS6jVyHyJJqjz7EUmNqGIjd0IIK4EpBXZ9Lm9441HAOcAFuX3HkryJdns51/YCsKNAe/c5hfYVay8UawvQAjBlyhRWr17d73MrZOfOnYfOa25u7rE6UWdnJxdddBELFiwY8nUrIT/Wemespbnvvvt49NFH+7RfeOGFh2Ksp3il3kZyH5IGaYrXWCsjTbFqZLIfqV9pihXSFa+xjmwVS+7EGM/tb38I4XXA3wGXxhi7cs3PAxPzDpuUayvWPtA5J/Rqf7pIrFkgC3D66afHefPm9Rd6QatXr6b7vJtuuqlPIue73/0un/jEJ+pi1ER+rPXOWEtz0UUX9WlrbW3lyiuvPLRdT/FKvY3kPiQN0hSvsVZGmmLVyGQ/Ur/SFCukK15jHdlqMi0rhHAMyZtpa4zxmRBCd7b8fiCTO+Yw4GRgLfCfwO4QQnPuuDNzx/Y+51Tg0Rjjy8BK4G0hhJA7LgP874o+sZyWlhZmzpzZp71QcVup3Nra2nqMHINkNNmiRYtqFJFUXo3eh0iSKst+RFIjqlVB5VW5ey/Lvd/tAJbHGB8KIfwkhHAzSYX6T8UYX4JD1ea/FELYCowGvpW71m3ArSGEz5Jkxy8DiDE+G0K4FfhqCOEA8M1qFjC74447+qyctXbtWjo6Oupi9I4aU0dHB4sXL+7TftNNN9UgGqliGr4PkSRVlP2IpIZTk+ROjPF3+tn35SLtG8i9WfZq302yLGGhc5aSVLavukIrZwF87GMfY/369bUISSNAodFhs2bNcrU2NZSR0IdIkirHfkRSI6rJtKyRotDKWRs2bGD+/Pk1iEaNrtjS57fffnsNopEkSZIkVYvJnQrKZDK0trb2aV+2bBltbW01iEiNzKXPJUmSJGlkMrlTYYsWLSpYXHnx4sV0dHTUICI1ovnz5xdc+rzQ6DFJkiRJUmMxuVMFd9xxB68Vyn/Nxz72sRpEo0bT1tbGsmXL+rS3trY6akeSJEmSRgCTO1WQyWS48847+7Rv2LDB6VkalmKrY82aNculzyVJkiRphDC5UyUtLS0F6+84PUvDUajODlhEWZIkSZJGEpM7VVSs/o7Ts1SKtra2gnV22tvbnY4lSZIkSSOIyZ0qu+OOO/q0uTy6hqrYdKzW1lZaWlpqEJEkSZIkqVZM7lSZy6NruDo6Orjgggv6tFtnR5IkSZJGJpM7NeDy6CpVR0cH73znO3nuuef67LPOjiRJkiSNTCZ3asTl0VWKK664goMHD/Zpd9lzSZIkSRq5TO7USH/Lo5977rk1iEj1bv78+QULKF988cVOx5IkSZKkEczkTg0VWx591apVJnjUw/z581m2bFmf9osvvpilS5fWICJJkiRJUr0wuVNjixYt4uKLL+7TvmrVKlfQEpAseV4osTNr1iwTO5IkSZIkkzv1YOnSpZxzzjl92pctW2aCZ4TLZrMFlzwfNWqUBZQlSZIkSYDJnbqxcuVKTjjhhD7tLpE+cmWzWRYsWNCnferUqTzwwAMWUJYkSZIkASZ36so999zDqFF9/5csXrzYBM8I09bWVjCxA7B8+XITO5IkSZKkQ0zu1JFMJsMDDzzA1KlT++xbvHixRZZHiLa2toJTscAlzyVJkiRJfZncqTOZTIbly5cTQuizz1W0Gt9AiR2XPJckSZIk9WZypw5lMhnuvPPOogmeWbNm0dHRUYPIVEnz588vmthpb283sSNJkiRJKsjkTp1qaWnhwQcf5MQTT+yz79FHH+XMM88km83WIDJVwvz58wsudw5JYqelpaXKEUmSJEmS0sLkTh3LZDI89dRTBZdJjzGyYMECEzwp19HRwezZs03sSJIkSZJKZnInBVauXMnFF19ccN+CBQtcSSulstksc+bMYcOGDX32hRBM7EiSJEmSBsXkTkosXbq0aILHlbTSp7+lzmfOnMmDDz5oYkeSJEmSNCgmd1Jk6dKltLa2Fty3atUqTjzxRAst17nuaVjFCidffPHFbNiwweXOJUmSJEmDZnInZRYtWkR7e3vBlbSefvpp5syZ4zStOtXW1lZ0GhYkiZ2lS5dWNyhJkiRJUuqZ3Emh/lbSgmSalsul14+BRusAtLa2mtiRJEmSJJXE5E5K9beSFiTLpTuKp/b6K5oMSX2ddevWsWjRouoGJkmSJElqGCZ3Um7lypVF6/BAMopn6tSpLpleA/0VTYZktI71dSRJkiRJw2VypwEsWrSIdevWMWvWrIL7Ozs7WbBggVO1qiSbzTJ16tSi07AcrSNJkiRJKieTOw0ik8mwfv36fkfxdE/Vuvrqq03yVMDGjRuZPXs2CxYsoLOzs+AxroYlSZIkSSo3kzsNZqBRPACPPfaY9XjKqKOjg7POOouPf/zjRWvrgEWTJUmSJEmVYXKnAXWP4mlvb6e5ubnocdbjGZ7upM6cOXNYu3Zt0eOchiVJkiRJqiSTOw2spaWF5557rt+pWt31eEzyDF42m+WUU04ZMKnT3NxMe3u707AkSZIkSRVlcmcE6J6qNXfu3KLHdCd5jj76aM4//3xr8vTS0dHB+eefz9FHH82CBQt48skn+z2+tbWV5557jpaWlipFKEmSJEkaqUzujBCZTIY1a9awbt06jj/++KLHdXV1sWLFCubMmcNZZ5014pM8+VOvVqxYQVdXV7/Hz5071ylYkiRJkqSqGlOrG4cQPgN8MsZ4TF7bfGA2cAD4VYyxPdc+Hfhr4GlgOvCpGOPOEMIo4GZgR679rhjjQ7lz3gX8KfA8EGOMN1XnmdW3TCbDXXfdxVNPPcWNN95YdFUngLVr1zJnzhyam5tpamri6quvHhEjUTo6Orjnnnt46KGH+i2QnG/u3LlceOGFXHnllZUNTtIh9iOSpOGwH5HUSGoycieEMA9o6tV2HHAtcG2MsRX4aAjhxNzuO4H2GOMtwBNA9zJPFwKTYoxfyrXdE0IYHUI4InfOJ2OMfwOcFkL4g8o+q3TprsczUNFlSKZsbdq0qaGnbXVPu5o6dSpz5szhzjvvHDCxc8IJJ3D55Zezbt061qxZw4wZM6oTrCT7EUnSsNiPSGo0VU/uhBCmAO8Hvt5r17nAIzHGmNvuAN4dQjgMOBt4ONf+IPCe3OP35I4jxtgF7AFmABlga4xxb4FzlCc/yTNt2rQBj8+ftjV16lRmzJiR2kLM2WyWd7zjHZx00kmHpl31N5Kp2/Tp02lvb2fz5s3ccccdFkuWqsx+RJI0HPYjkhpRRaZlhRBWAlMK7Poc8CckGfHX9dp3LMlwxm4v59qOAXbnvcl2t/d3zm8VaS8WbwvQAjBlyhRWr15d7NCidu7cWdJ5tVAo1pNOOom7776bjRs30t7ezuOPPz7gdTo7Ow8VYr722ms59thj2b9/P294wxv4wAc+UJaRLOV6XTdu3MjKlSvZsmULL7zwAi+//DK7du0a0jVOO+00WlpaDj2v3nGl6XcA0hevRpY09SMjrQ+BdMVrrJWRplg1MtmP1K80xQrpitdYR7aKJHdijOcWag8hnA68CiwAJgPjQwjXActJ5qKekHf4JJI5rb/JHRdyb6iTcseS++/EXuc8D8Qi7cXizQJZgNNPPz3OmzdvUM8z3+rVqynlvFroL9Z58+Zx5ZVXHqo7s2nTJp544okBCwnv2LGDHTuS/mvr1q088MADnHjiiezbt4+9e/eWXLOnlNe1o6ODxYsX8x//8R+MHTv2UBKqFNOnT2fWrFm0trYOOEInTb8DkL54NbKkqR8ZaX0IpCteY62MNMWqkcl+pH6lKVZIV7zGOrJVtaByjPEXwC/gUFGyy2KMC3Pbu4Gr8t40M8DXY4yvhhB+Arwd+DlwJnB/7pL3A3OBb4cQmoBxwEZgLDAthDA2NxTyTOD2Kj3NhpDJZHokM7LZLDfffDNbt24d9DU2b9586HH3CJ/Pf/7zjBkzhr179zJu3DiOOuootm/f3mP78MMP57LLLuuTCMpmsyxZsoTt27cXPXc4iZxuzc3NnHHGGYNK6EiqLvsRSdJw2I9IalQ1WS0rhHACcDlJBvyzwFdjjM+GEG4FvhpCOAB8M8bYnR24HPhcCOEc4I3AX+Xavw/MDiHcmGu/JMZ4ANgVQrgC+FoI4QXgsRjjj6v3DBtPS0sLLS0tQx7R09uvf/3rQR3385//nOuvv57Jkyezf/9+duzYMeR7DdbrX/96Jk2axFve8hYTOlJK2I9IkobDfkRSo6lJcifG+DS5SvS92pcCSwscvwW4tED7QV6rVN9734+AH5UhXOUpNKJnyZIl7N69m8MOO6zHaJ3h6urqqkhCp3t1sJG0vLvUaOxHJEnDYT8iqdHUJLmjxtE9oqdb73o327dvp6ur61A9nmrrrvsTQhh07RxJkiRJktLE5I7KKpPJcO+99/Zpz2az3HXXXezbt69PnZz87f379/Pss8/2e4+mpiYmTZpUsObO9u3bTeRIkiRJkkYUkzuqit4jfPqTP9Vr9OjR7N+/34SNJEmSJElFmNxR3clPBLlEniRJkiRJ/RtV6wAkSZIkSZJUOpM7kiRJkiRJKWZyR5IkSZIkKcVM7kiSJEmSJKWYyR1JkiRJkqQUCzHGWsdQV0IILwBbSzj1GOA3ZQ6nUoy1MtIUK5Qe77QY42+VOxipEYyQPgTSFa+xVoZ9iFQBI6QfSVOskK54R0Ks9iNFmNwpkxDCL2KMp9c6jsEw1spIU6yQvnilRpa2f49pitdYKyNNsUojQZr+TaYpVkhXvMY6sjktS5IkSZIkKcVM7kiSJEmSJKWYyZ3yydY6gCEw1spIU6yQvnilRpa2f49pitdYKyNNsUojQZr+TaYpVkhXvMY6gllzR5IkSZIkKcUcuSNJkiRJkpRiY2odQL0LIXwG+GSM8Zi8tvnAbOAA8KsYY3uufTrw18DTwHTgUzHGnSGEUcDNwI5c+10xxody57wL+FPgeSDGGG8qIcavAruAncBM4JoYY2du36eBScBkYFWM8Ye59lnAlcAzwLHAtTHG/SGEccCtwK+BE4GFMcan+nvelVKO16aEe74Z+CLwS+A44MUY4+dDCE3AQuA/SV6XG2KM/yd3Ttle4xJjHg/8LHfva0v5f1jK766kgaWhD8ldp+H6kVr0Ibn72o/Yj0hlk4Z+pBH7kNz97EcGF699SL2IMfpT5AeYB3wF+E1e23HABl6b0vYwcGLu8b8Av5t7fBXwhdzjDwC35x43AU8Bo4EjSH6Bx+b2LQf+oIQ4v5j3uA34eu7xO4D/L/d4DLAZeB0QgCeA5ty+rwCX5R5fB7TmHp8K/HSg512h174sr00J93078Cd525uAtwF3Ahfm2t4HfLvcr/EwYv4K8C3g1lL/Hw71d7fS/x/88acRfkhJH5I7t6H6kXK+NiXc237EfsQff8ryQ0r6ERqsD8ld335k8PHah9TJj9OyigghTAHeD3y9165zgUdi7jcM6ADeHUI4DDib5JcU4EHgPbnH78kdR4yxC9gDzAAywNYY494C5wxajPGzeZujSLLmAO/Nu+9+4EngLOB4YHzMZdT7ifVxYGYIYVKx5z3UWIegLK/NUMUYH44x/iCvaRTwCnmvS69YyvkaD1kI4UO5az+T1zyk/4cl/u5K6kea+pDcdRutH6lJHwL2IwPEaj8iDVKa+pEG7EPAfmRQ7EPqy4ielhVCWAlMKbDrc8CfANeSZD3zHUsyLKzby7m2Y4Ddeb+s3e39nfNbRdqHFGt8bdjdUcA5wAV5932ywPVf6Oe+xWIt1l4p1b5fHyGE84GVMcZ/DyHkx/MyMDmEMIbyvsYvDzG+U4CTY4w3hBBOy9s11P+HpfzuSiNemvqQgeJtwH6kLt677Ef6vZY04qWpHxlhfUh/cVRVPfcj9iH1Z0Qnd2KM5xZqDyGcDrwKLCCZtzg+hHAdyXC854ET8g6fRDJk7ze540LuF3NS7lhy/53Y65zngVikfdCx5sX8OuDvgEtzWc3+7lusfaBzCj3vSukvxooLIZxNkkG+plc8L+Vi2R6T+arlfI2H6nxgT+53853A4SGEa/q5fjl/d6URL019SH/x5sXdSP1Izd+77EfsR6SBpKkfGWF9SH9xVE0K+hH7kDrjtKwCYoy/iDFeHmNcCNxBkklcGGPcDKwE3hZCCLnDM8D/jjG+CvyEZI4kwJnA/bnH9+eOI1cIaxywkWSI2bQQwtgC5wxaCOEYkjfT1hjjMyGE7mx5/n0PA04G1pIU4dodQmgeINZTgUdjjC8Xe95DjXUIyvLalCKE8B6SYYNXA80hhAx5rwvFX6/hvsZDEmP8Uozx87nf0weAn8cYl/Rz/XL+7koqIm19SO66jdaP1KwPAfuRfmK1H5EGIW39SAP2IWA/MiD7kPrTXcxIBYQQTgAuB64AbgG+GmN8JSRVvk8nqfL9VOxZ5ftzJP+Q3gj8VXytyvctJFXk3wj8z/hahfo/BP6MZNjcq7G0CvW/JBmF1Z0l3xFjfF9u36dJMv6TSf7x5FdOvwrYSlKcqrty+niS6ubPkWRWb449q5v3ed6VUo7XpoR7vg1YA/wi1zSBpLP6IbCI5PV6M3Bd7FmdviyvcYkxX0BSBf/wXKwril2/nL+7kvqXlj4kd52G60dq0Yfk7ms/Yj8ilUVa+pFG7ENy97MfGVy89iF1wuSOJEmSJElSijktS5IkSZIkKcVM7kiSJEmSJKWYyR1JkiRJkqQUM7kjSZIkSZKUYiZ3JElSQwghjK6Ha0iSJFWbyR3VDT+US5JKFUJ4C/ClEMLEEMJdIYS7S7zUkSGEJSGESWUMT5KUAn4fUZqZ3FFd8EO5JKlUuQ/S3wJujjHuAL5d6rVijP8XuAe4vUzhSZJSwO8jSjuTO6o5P5RLkooJIYwJIXw/hPBoCOG0EMIpIYSHQwjn5R12NtAZY3y5wPn3hRDuDiH8bgjheyGEn4UQvhhC+LcQwidCCF8IIfxzCOHz3efEGH8JvDOEcHTln6Ekqdb8PqJGMKbWAaixhRCuBz4H/BFwOvAHwDUxxqfyDuv3QznwIsmb46eA6cCPgDnACuC3gNnAL2OMn4PkQ3kI4Z0hhKNjjC9W6KlJkqogxrg/hPBR4FFgM8kfptbEGFfkHTYD+HXvc0MIFwI/iDF+M7fdBqwh6ZcmAf8NHAvsArbk2rs9D5wEdJT3GUmSqsnvIxopTO6oomKMt4QQxgDzgX3ABTHG3b0O80O5JKmoGOPLIYR/Bi4GxpL8dTXfWGB/r7Z3AtOA+3q1PxNjPAi8FEJ4Psa4EyCEcLDXca8C48sRvySpdvw+opHCaVmqhi8BvwdsKvBGCsU/lF9B8qaZ75kY48EY40vA8zHGnbkP6X4ol6TG9nXg48BbY4yP99r3X0BTr7YHgfcCl4QQfreE+zUB20o4T5JUf/w+ooZnckfVcD6wELgyhHB8gf1+KJck9Ss3fP7XwL8U2P0vwEyAEMJY4EPAqSR/iV0LfD+E8H7go8C0EMLZIYSPAK8LIZwfQjg/9/ijuWs0AbtjjE9X+GlJkqrD7yNqeE7LUkWFEC4lyXi/F/h94N4QwidijGvyDvsX4Prc8cU+lLfl2qaFEM4mGWr/utwHcnKPPxpj/KYfyiWpsYQQxsYY95IMee89zYoY4/YQwldDCB+PMX4DuCxv98+BT+Qefw/4bN6+u/Me35u71yjgC8CCsj0BSVLN+H1EI0WIMdY6BokQwl8AE3IfyodznVEkQ/fvjjE+XJbgJEk1FUL4BrAbeCTG+N1+jjstxvjYMO91FDAxxvhfw7mOJCld/D6itDO5o7rhh3JJkiRJteL3EaWZyR1JkiRJkqQUs6CyJEmSJElSipnckSRJkiRJSjGTO5IkSZIkSSlmckeSJEmSJCnFTO5IkiRJkiSl2P8PI5gU0bvSYmsAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 1296x432 with 3 Axes>"
       ]
@@ -325,15 +289,6 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -343,8 +298,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "d7d5e30f",
+   "execution_count": 14,
+   "id": "c70e1ab0",
    "metadata": {
     "scrolled": true
    },
@@ -367,13 +322,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
-   "id": "aee5190a",
+   "execution_count": 15,
+   "id": "4b37cb3b",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -385,16 +340,7 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -403,15 +349,6 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -422,13 +359,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
-   "id": "c2d36a3a",
+   "execution_count": 16,
+   "id": "b114c47a",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1296x432 with 3 Axes>"
       ]
@@ -437,15 +374,6 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -465,8 +393,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
-   "id": "3c351462",
+   "execution_count": 17,
+   "id": "6008afc9",
    "metadata": {},
    "outputs": [
     {
@@ -480,7 +408,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -492,16 +420,7 @@
     },
     {
      "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAENCAYAAAAMmd6uAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAAcH0lEQVR4nO3de5xdZX3v8c83GZJAEgKBECM5EgSk3A5gok31FCZWEbWAYMFKhaa2J+f0KMYej4UehUZ7rFgPCi/FaixXuVUKhYMmgAWmCBpIIrcAIlQJd0IgkAzkPr/zx1pD9uyZ2XvtmX1be33fr9e8Ms/aa+39eybz+s7az17reRQRmJlZ5xvT6gLMzKw5HPhmZgXhwDczKwgHvplZQTjwzcwKoqvVBVSy5557xqxZs1pdRlO8/vrrTJw4sdVlNFxR+gnua6fKQ19Xrly5NiKmlW9v68CfNWsWK1asaHUZTdHT00N3d3ery2i4ovQT3NdOlYe+Slo91HYP6ZiZFYQD38ysIBz4ZmYF4cA3MysIB76ZWUE48M3MCsKBb2ZWEA58M7OCcOCbmRWEA9/MrCAc+GZmBeHANzMrCAe+mVlBOPDNzArCgW9mVhAOfDOzgnDgm5kVhAPfzKwgHPhmZgXhwDczKwgHvplZQTjwzcwKwoFvZlYQDnwzs4Jw4JuZFYQD38ysIBz4ZmYF4cA3MysIB76ZWUE48M3MCsKBb2ZWEA58M7OCcOCbmRVEWwf+Q2tgnwtaXYWZWWdo68Dv59A3Mxu9pge+pAMkbZXU3ezXNjMrslac4X8F2NKC1zUzK7SmBr6kdwG9wEu1HnvVQ/Wvx8ysSJp9hv/l9KtmFy6vcyVmZgXT1awXkvQh4OGIeEZSpf0WAAsAxs2cnW4NXtywnZ6euxpfaIv09vbS09PT6jIarij9BPe1U+W5r00JfEljgDOBk6rtGxGLgcUA4982J9JnQGO66O7ublyRLdbT09PR/etXlH6C+9qp8tzXZg3pnArcEhGvjPQJoo7FmJkVUbOGdH4fOFTSB9P2W4DzJa2OiBOyPEE48c3MRqUpgR8R/620LelJ4HMR0ZP9OepclJlZwTT7ssx3S+phxxn+OdmPbVhZZmaF0LSrdAAi4l6geyTHjs3FJBBmZu0rNzGam0LNzNpUbnJ0S1+rKzAzy7fcBL6vyzQzG53cBL5P8M3MRic3ge8TfDOz0clN4INnzDQzG41cBf5Xf9bqCszM8itXgd+7tdUVmJnlV64C38zMRs6Bb2ZWEA58M7OCcOCbmRWEA9/MrCAc+GZmBeHANzMrCAe+mVlBtHXgjxs7sL3PlNbUYWbWCdo68Hcqq276xNbUYWbWCdo68LdsH9h+bkNr6jAz6wRtHfjlUyJv2j7kbmZmlkFbB77K2hPGDrmbmZll0N6BX5b4XW1drZlZe2vrCN1Wtq7hyxtbU4eZWSdo68AvH9IZW77BzMwya+vAH1MW8JPGtaYOM7NO0NaBX37j1d6TW1OHmVknaOvAH981sL3/Hq2pw8ysE7R14O8+Yce4/VjBxw5qbT1mZnnW1oG/aRtsT+++2h7w2NrW1mNmlmdtHfivbR7YXvpEa+owM+sEbR34U8a3ugIzs85Rc+BLmtqIQoYydWc46m072nc+BV+7q1mvbmbWWTIFvqRJkn4g6Q1guaQ9JP1c0n4Nro+nXhvYvtnDOmZmI5L1DP97wCvAe4HnIuJl4M+Ab2d9IUlnSLpN0u2SHpJ0Rpbjjt2/ctvMzLLpqr4LAHtHxCcBJG0FiIjHJNVy7+tfAB+IiDWSDgAelXRPRNxb6aDyVa686pWZ2chkPcOfUD52L2k3oJY1qE6LiDUAEfE4sA6YVe2g8itzfKWOmdnIZA38fwR+JekiYF9J3wZ+SQ1DOhHxYP/3kj4G9AK3Vjvu4GmV22Zmlo0iyteVGmZH6b3AnwIzgaeBSyPiFzW9mHQY8M8k7wxOiYh7hthnAbAAYPr06bOP/cZK7njlrSRzZwbzpj7H/P/0eC0vmwu9vb1MmjSp1WU0XFH6Ce5rp8pDX+fNm7cyIuaUb886hk9E3A3cXbpN0pyIWFHDczwEHCzpSGCppOPLx/AjYjGwGGDOnDkxbre9k4+Lk1dk3G570929d9aXzI2enh66u7tbXUbDFaWf4L52qjz3ddjAl3RUhuPPB95Z64tGxH2SfgJ8FvhkpX33nFi5bWZm2VQ6w78FeCH9PkiGcjaSnG9PBSYBq7O8iKQ9gO6IuK5k8+vp81R06LTKbTMzy6bSh7Y3RcS+EbEv8APgYxExJd02BTgJuCrj60wGzpa0C4CkacBHgduqHbjqpcptMzPLZtgz/Ig4paT5gYj4WtnjN0r6q4yv8wJwE3CbpC3AbsDFwHerHfjS65XbZmaWTdYPbfeQ9O7SD1gl/R4ZhmQAImITcHb6ZWZmLZA18M8iOTt/AVgLTAP2Ak6peFQdlK9b7nXMzcxGJlPgR8RSSbOAjwAzgOeBn6Rz6jSUr9IxM6uPWq7Dfxm4vHSbpA9FxNK6V1XCV+mYmdVHpsCXdPowD50FNDTwe54c3D71sEa+oplZZ8p6hn8BcH9JezfgAGB5nesZ5MXXK7fNzCybzIEfEYtKN0jan2TK44aaOxPuf3Fg28zMapdptszysE+3PQFkmX5hVDZsqdw2M7Nsso7hn1O2aTxwKMmUCw3lG6/MzOoj65DOXwI3l7S3AL8guVu2oaZNrNw2M7Nssgb+P0TEt0o3SBoTEX0NqGmAyeMqt83MLJusK17NGmLbjyR9a4jtdbXsmcptMzPLJmvgD7ryPSL+CBi0okq9TZ9YuW1mZtlUHNKRdAfJB7NHSLq97OFdqh1fD/vuXrltZmbZVAvsS9N/ZwCXlT22ASj/I1B3j5TNf+8hHTOzkakY+BFxGYCk30bEneWPS5oBvNqY0hIHT4M7n9rRfnANrHweZs9o5KuamXWerGP4T0p6W/kXcF3VI0dp1/ED230B1z3a6Fc1M+s8lRYxXwW8JyLWA0+SjOWXT0ff8Buv5s6EsYLtDX8lM7POVukM/yNp2APcHhFjI2JM6RdwR6MLnD0DjnvHwG2+Ft/MrHbDBn5ErC75/v3D7PaFulc0hFc2DmyXf5BrZmbVVRrSyTIx2vnAO+tWzTCm7ly5bWZm1VW6SucWkqUMKy0jO72+5Qztt69WbpuZWXWVAn9JRHys0sGSGn6VDsD4sZXbZmZWXaUx/EFhr8Q0SRpun0bYfULltpmZVZfpOnxJUyVdCWwEXgA2SrpC0tSGVpcqvyLTV2iamdUu641XlwG9wPtJFj45hiT8L29QXQM8vb5y28zMqss6+dn0iDiupP0ocKekextQ0yCvbqrcNjOz6rKe4T8raZfSDZImAqtL2n9Wz8JKHTC1ctvMzKrLeoa/Frhf0k+AdcBUkmGd20rWu50PXFL3CoH1myu3zcysuqyB/4cka9ruln4B3ANMSr8AGnbtzLixldtmZlZd1sD/bkT8XaUdJJ1dh3rMzKxBMo3hDxf2ks6ttk89PLuhctvMzKrLdIYvaT/g88Dbgf65KgUcDpzVmNJ22LK9ctvMzKrLOqRzPdADXAtsS7cJOLMBNQ3iMXwzs9HLfJVORCws3yjp4SwHS9oJ+DTwUZI/FOOAL0XEbVmO33X8wGGc8lWwzMysuqzX4V8q6YT02vtS/zvj8XsDC4ETIuJo4BzgRkl7Zzn4+Q2V22ZmVl3WwN8ILAbWS9qefvUBx2c8fgNwTkS8BhARPwU2Ae/JdPCWym0zM6su65DOucACYBUDx/CvznJwRLwM/LC/nc62OQ7ItHZVX1Rum5lZdVkDf1VE3Fi+UdLpI3zdo0mmZbhzhMebmVmNFFH9dFnSmcAM4KckwzP9zo+ImpY4lDQBuB04IyJWDvH4ApJ3E0yfPn32Nddcw4IH3stmukjeVATj2cbiw++u5WXbXm9vL5MmTaq+Y84VpZ/gvnaqPPR13rx5KyNiTvn2rIHfPw9+uekRscsQ24d7HpFMtXxTRFxbbf85c+bEihUrOOhCeGPbju27dMGjn876qvnQ09NDd3d3q8touKL0E9zXTpWHvkoaMvCzDukMudyhpB/XWMd5wL0Rca2k8SR/MJ6qdtCmbZXbZmZWXdapFd4Me0njJZ0k6RrgfVlfKB0W6iK5xHMSsB/wqUyvX6VtZmbVZV3icCdJx6fLHK4BLgL6gOcyHv8Okit9ziD5DGADkOmmLYD9d6/cNjOz6oYd0pHUBXwQOIXkDtltJFMs/AZ4d0RslfThLC8SEb8m+cR1RE48CP7h5wPbZmZWm0pj+C+lj98EnAYsTUP+9ojYChARS5pQI3NnwoQu2LoddhqbtM3MrDaVAv8z7LiTtv+ayJaYPQOuOgmue7RVFZiZ5d+wgR8RVwJXStoVOAG4WFIvMFXSmIjok/ShiFjarGKvezQ5y7/u0eQPwOwZzXplM7P8q3pZZkSsJ5kW4YeSppCM518haRvJXDj7N7TC1LJnkrDfHsD2pO3ANzPLLut1+ACkk59dBlwmaXeSO2abYu7MZPwej+ObmY1ITYFfKiLWSTq6nsVUMnsG/O1RsPQJ+ND+Prs3M6vViAMf3hzuaYqVz8OX70yGde59Dg7c06FvZlaLrPPht1zpGP7WdAzfzMyyy03gz50JY8ck14aOHeMxfDOzWuUm8M3MbHRyE/jLnoHtfcnEadv7PKRjZlar3AS+h3TMzEYnN4FvZmajk5vA95COmdno5CbwPaRjZjY6uQl8MzMbndwEvod0zMxGJzeB7yEdM7PRyU3gm5nZ6OQm8D2kY2Y2OrkJfA/pmJmNTm4C38zMRic3gb/sGdi2PRnS2ebpkc3MapabwN99AvSl3/elbTMzyy43gb9u045iBax6qZXVmJnlT24Cf+5M6BqbfB/AtY8kyx6amVk2uQn82TPg5IN3tD2Ob2ZWm9wEPsCh03Z873F8M7Pa5Crw//VXldtmZja8XAX+U+srt83MbHi5Cvy5e1dum5nZ8HIV+BPHVW6bmdnwchX4j79cuW1mZsNrauBLepekJyTNH8nx6zZWbpuZ2fC6mvVCkk4ETgZeG+lz7L4zsK6sbWZmmTTzDH95RJwKbBjpE2zYUrltZmbDa1rgR8So74t9sXdg+6kRv1cwMyueXH1oO3n8wPbrW+Gqh1pTi5lZ3jRtDD8rSQuABQDTp0+np6fnzce2bpwDTCSZLxMguPLedbz15QebXWbd9fb2DuhrpypKP8F97VR57mvbBX5ELAYWA8yZMye6u7vffGy3Z+G5taV7i/33nkrpPnnV09PTEf2opij9BPe1U+W5r7ka0nl2iI97H17T/DrMzPIoV4G/dfvgba9ubn4dZmZ51LTAlzRbUg9wBHCWpOtrfY5j9hu87RXffGVmlknTxvAjYiXQPZrnuOBYWPI4bOnbsW17wD4XJN+vXjiaZzcz62y5GtIB2GdKhccuaF4dZmZ5k7vA/9SRra7AzCyfchf4px7W6grMzPIpd4Ffje+8NTMbWi4D/6MHDv/Yxfc1rw4zszzJZeBfcOzwj/m6fDOzoeUy8AEm7TT09pfe8LCOmdlQchv4MyYN/5iHdczMBstt4PvyTDOz2rTdbJlZ9V+eufQJePDFgWP3h+zVmprMzNpZbs/wIQn9qTsP/qDWM2iamQ2W68AH6Hly8LbH18G+F8DK55tejplZ28p94HfPGnp7H3DSjxz6Zmb9ch/4la7JBzj3rubUYWbW7nIf+Atvrvz48ueaU4eZWbvLfeDf8Fjlx6M5ZZiZtb3cB34WJ1zT6grMzFov14FfbTin3wMvNrYOM7M8yHXg/+TxbPt5WMfMLOeBv7Wv+j5mZpbIbeB7XN7MrDa5DPyFN8P9NY7LZx3vNzPrVLkM/FueGP6xscNsr3b5pplZp8tl4E8eP3jbGGD1QvjNQjhg96GPO/x7DS3LzKyt5TLw/2ru4G3Hl6xz+2+nD33cq5s99m9mxZXL+fD758L/5jJ4fQscs1/1OXX6Peipk82soHIZ+JCEfn/wD+WI6UN/sNvni/LNrKByOaSTxY1/DF0a+jFfsWNmRdSxgQ8wadzQ22/0FTtmVkAdHfjDLY4S+CzfzIont2P4WVxw7PDX39/w2I7HBDy5sGllmZm1REef4QPMnFx9nwBmXdDwUszMWqrjA//uT2XbzxfvmFmn6/jAh+QO3Cx+5zuNrcPMrJUKEfiQLfQ3bm98HWZmrdLRH9qWW70Q9vFYveXUyufh+yvg4ZeSIcgp42H9Zti8HcaNTdpb0u/L/x03Fj5+SOWbFdvBCdfAqjVw6F7JvTRWX4UKfLO8Wvk8fPxfBi768+yGgfuUt8vd/yKctwz22mX4Pwxr3oD1m2BLzYsLHQUP1HpM5VpLT84E7NwFY7TjZ7DTmIHf9wVs68tW+6Sd4Iu/3/5/AOutcIH/0QOHv1RzuFk2zVpt2TP1WeFt7RvJV/0Nc1t7nQTwxraB2zZvH/r7LHq3wt/cnnxfpNBXRPtenyLpJWB1vZ+3a4/9ZmnC5CnS2C4EBMS2zRu3vrDqkXq/Vg32BNa28PWbpSj9hDr2VeMnT+yadsCBkhqbrAXTt7l3/bY1j2VcHftNefgd3icippVvbOvALxJJKyJiTqvraLSi9BPc106V574W5iodM7Oic+CbmRWEA799LG51AU1SlH6C+9qpcttXj+GbmRWEz/DNzArCgW9mVhAO/CaRNEHSpZKWSVoh6Zhh9jtO0q2Sbpf0S0mfbXato5W1ryX77yTpcUmLmlRiXdTST0nvkXSbpDslPSLpjGbWOlo1/P5OlvRDScsl3ZseM6nZ9Y6WpHdJekLS/Cr7/YmklenP5Lx2v0+icHfattAiks9M5kp6B7BM0kERUb7U+reAkyPiPklvAR6WtDoibmx2waOwiGx97bcA2Ktp1dXPIjL0U9K+wPnAhyNiraRDgIwTd7eNRWT7Pz0b2AeYS3KD7G3Al4CzmlnsaEg6ETgZeK3KfocC5wGHAq+Q9PV/ABc2usaR8hl+E0gaA/wFcBFARPwauA/45BC7XxgR96X7vQDcAVQ8Q24nNfaV9OzvFOD/NavGeqixn/8TuCQi1qb7PhwRn29WraNVY18PAe6NiO0R0QfcCxzZrFrrZHlEnApUmZ2IPweWRMTatK8XA/+94dWNggO/Od4O7AH8qmTbI8Cgu/Ui4ltlmyYALzWutLrL3NfU54FvA3mbnLqWfv4BME7SEkl3S/q/kiY0o8g6qaWvS4D3SZooaRfgfcA9jS+xfiLimYy7vovBP5NDJO1c/6rqw4HfHNPTf0vfIr5KlWEMSbuS/FJd0piyGiJzXyVNA46KiH9pQl31Vsv/6SySM7/TgW7gYJIhnrzI3NeIuBDoAX4DPAn8EvhKQ6trnekM/pmIZK6dtuTAb67ymx6qfcDzdeArEVH3CeSaIEtfzwa+2oRaGilLP8cDV6Vv/beShP38dKgkT6r2VdIXgcNJxvHfRvLuYH7DK2udoW5katsPbvP2C5dXa9J/dyvZtlvJ9kEkLQC2pmdMeZKpr5LeDuwbEbc3p6y6q+X/dB1Q+uHmMyR/BNr2TLBMLX39LPD9iNgUEZuA7wF/19DqWmcNg38mQRsPwTrwm+M/SD7FP7Bk28HA8qF2Tq8SmAcsTNsHNLrAOsra16OBt0rqkdQDHEty1tuTXtXS7mr5P72fgcMf04AtwMuNKq7OaunrOGBrSXsrMLlxpbXUcgb/TB6OiI0tqqcqB34TpJ/g/4D0Urw0wI8ArpR0UHp99tj0saNIzpI+A0xMr2L5UksKH4GsfY2ISyJidkR0R0Q3cDNwadr+bavqz6qW/9N0v0+kH2KSHnNFROTig+oa+/pvwMeVAk4ludIs9yTtKelnkqamm/4J+LCkPdLhufkk72jalgO/eRYBkrQMuBr4RHrZ5RTgd4Cd0v2uJvlgby3JZWEbSMZD82QR2fqKpHFlZ/jXN7/cEVtEhn5GxD8DV5Bcu343yRVJn2tFwaOwiGz/p58mGcNeRnJ1ThfJfRa5IWl2+jt5BHBWye/kziR93QUgIlYB/wu4laSv9wPfbXK5NfHkaWZmBeEzfDOzgnDgm5kVhAPfzKwgHPhmZgXhwDczKwgHvplZg2WdX3+I406XtEHSrCEemyzpivQS0kw8H76ZWQNlnV9/iOPOBd4ABi0gI2kKcD3weC3P6TN8sxKSPiDpfkkh6d/TFaqWS/prSaU3jC2R1N26Si1Hss6vX+47ETHcTKPbgD8iucEtMwe+WYmI+Ck77oL9g4g4iuQu4PcBN5TMcPnHwL9Xe750bqD5DSjVcqLS/PrpkM2y9OTiqnRK9KrHRcTrEbGu1loc+GZVRMTLJPOkzCNd5Ski1odvU7dRkPRe4JvAcRFxNPBs2m4YB761FUn/R9L5Je2Zkl4fzdzxknZNh2j2LNl2sKQX07HQqtJ5Y24BTpb0BUkvKF10XdIYSf8o6a50COif0hWfvsaO+Vh6JH0k3f8cJYvU3y7px5Lemm5fIOlJSddI+r6SReyXlK6OJWk/SUvTM8JfSPpy2WO3po/9TNJ7Rvozs6aYD9wUEf3TKV8F/Ek66VxD+ENbazdHAqUrYB1OMuVs30ifMCLWS3qaZPraO9PNXwW+HhG1fJD2JPDBiDhOyULk/Y4FZkXEfwGQ9K/AtIj4G0m/RzIL6KUl+68jGS6KdLjn68BpEbE4Df//SrIw9mvAg8CJwNXpjJQ3pXVflv6xehj4W0ldwI+Bb0TExZL+M3C7pH0jotaxY2uOmcDBJVfZdJGsm7AHyeSJdefAt3ZzBHBOSftwktAbrVXAQcCdkn4XeCfJOHwthnuXsQ44TNIHgNuAT5DMdz+cp4E70nctu5LMIV/qnv7xWUmrgP71AeYC+wNXAkTEa5I+nj72u8B+wA/Txx6U9CzwhySzW1r7eRr4TUR8un+DpD37F7tvBA/pWNuQtBfJOqEPl2w+HHigbL+edIhmqK+7hnn6VSRn+AB/DyyKiM01ljgLeKJ8Y0T8gmQK4DOB1SRT5g75tlzJXPI/Ar6QfiD8OdLpdkusL/l+Ezv+IMwE1kXEtpLXvrvksQB+qh2Lyownmb7Y2tOlwEck7Q4g6UCSd3AN4zN8aycHA4+nS+ORDlPMo2yO8XTBlFqtAk6T9H7gLcDltRwsaQZwDMli5OWPTQF6ImKJpP1IFnN5lqEXnz8SWB8R/atF7TTEPsN5GthdUld/6Es6iGSo6WmSJTG7S+qaCIx4KMzqQ9Js4Dx2fJ5zfEScFBE/l/QlYKmkN0jeFf5pyXF/DpyWNq+RtKT0Mk1J1wKHAW9J/8D/dUTcW6kWB761EwG7pEHfB3yDZDnAeg3pHExydv/FWlabUrLC0SVAD+mQSZkTSdYzPT8i/kPSM0D/ClAbSPp0AMm7gKtJQvsdEfFrkvH/rO4heYdxKnB5WtePSIan7gGeknRSRFyf/gxvIHm38cAwz2dNEBErSRY1GuqxK0gWxxnqsYuAiyo878m11uLAt3ZyF0m4/wp4imRpvGdGcr3xEB4hObN/KiJuGG6ndBz+G2nztvSKiV1IPkg+LyL6JH2BJKg3pR8G3wV8U9LxJHdFPsiOdxAXA+eSXJFxZkT8UtLfA7dKegB4geQM7XKSdwbzgQmS/pJkZaz+1/l1RFwl6TjgO+nZ3xjgMxGxNa39OOBCSQvTxy6JCIe9vckrXpmZFYQ/tDUzKwgHvplZQTjwzcwKwoFvZlYQDnwzs4Jw4JuZFYQD38ysIBz4ZmYF8f8BaBZ+EoYC/gYAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
@@ -510,15 +429,6 @@
       "needs_background": "light"
      },
      "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<Figure size 432x288 with 0 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
     }
    ],
    "source": [
@@ -528,6 +438,14 @@
     "obs3.plotall('u','v',conj=True, rangex=[1.e11,-1.e11],rangey=[-1.e11,1.e11]);\n",
     "obs3.plotall('uvdist','amp');"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2c26531c",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {

From 8ef556f2d4da9e39e1ec9e9d19cd752edfcdd00d Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Thu, 1 Feb 2024 20:07:36 -0500
Subject: [PATCH 04/15] added polcal_new

---
 ehtim/__init__.py                |   1 +
 ehtim/calibrating/__init__.py    |   1 +
 ehtim/calibrating/pol_cal.py     |   1 -
 ehtim/calibrating/pol_cal_new.py | 513 +++++++++++++++++++++++++++++++
 4 files changed, 515 insertions(+), 1 deletion(-)
 create mode 100644 ehtim/calibrating/pol_cal_new.py

diff --git a/ehtim/__init__.py b/ehtim/__init__.py
index 59193c80..c560c12d 100644
--- a/ehtim/__init__.py
+++ b/ehtim/__init__.py
@@ -29,6 +29,7 @@
 from ehtim.calibrating.network_cal import network_cal as netcal
 from ehtim.calibrating.self_cal import self_cal as selfcal
 from ehtim.calibrating.pol_cal import *
+from ehtim.calibrating.pol_cal_new import *
 from ehtim.calibrating import pol_cal
 from ehtim.calibrating import network_cal
 from ehtim.calibrating import self_cal
diff --git a/ehtim/calibrating/__init__.py b/ehtim/calibrating/__init__.py
index 54308926..ede0bd27 100644
--- a/ehtim/calibrating/__init__.py
+++ b/ehtim/calibrating/__init__.py
@@ -9,6 +9,7 @@
 from . import self_cal
 from . import network_cal
 from . import pol_cal
+from . import pol_cal_new
 from . import polgains_cal
 
 from ..const_def import *
diff --git a/ehtim/calibrating/pol_cal.py b/ehtim/calibrating/pol_cal.py
index 5a310c3d..d317ba35 100644
--- a/ehtim/calibrating/pol_cal.py
+++ b/ehtim/calibrating/pol_cal.py
@@ -66,7 +66,6 @@ def leakage_cal(obs, im=None, sites=[], leakage_tol=.1, pol_fit=['RL', 'LR'], dt
 
            show_solution (bool): if True, display the solution as it is calculated
            obs_apply (Obsdata): apply the solution to another observation
-           
        Returns:
            (Obsdata): the calibrated observation, with computed leakage values added to the obs.tarr
     """
diff --git a/ehtim/calibrating/pol_cal_new.py b/ehtim/calibrating/pol_cal_new.py
new file mode 100644
index 00000000..877b96f4
--- /dev/null
+++ b/ehtim/calibrating/pol_cal_new.py
@@ -0,0 +1,513 @@
+# pol_cal.py
+# functions for D-term calibration
+# new version that should be faster (2024)
+#
+#    Copyright (C) 2024 Andrew Chael
+#
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+from __future__ import division
+from __future__ import print_function
+
+from builtins import str
+from builtins import range
+from builtins import object
+
+import numpy as np
+import scipy.optimize as opt
+import matplotlib.pyplot as plt
+import time
+
+import ehtim.imaging.imager_utils as iu
+import ehtim.observing.obs_simulate as simobs
+import ehtim.const_def as ehc
+
+MAXIT = 10000  # maximum number of iterations in self-cal minimizer
+NHIST = 50   # number of steps to store for hessian approx
+MAXLS = 40   # maximum number of line search steps in BFGS-B
+STOP = 1e-6  # convergence criterion
+
+###################################################################################################
+# Polarimetric Calibration
+###################################################################################################
+
+# TODO - other chi^2 terms, not just 'vis'?
+# TODO - do we want to start with some nonzero D-term initial guess? 
+# TODO - option to not frcal?
+# TODO - pass other kwargs to the chisq? 
+# TODO - handle gain cal == False, read in gains from a caltable
+
+def leakage_cal_new(obs, im, sites=[], leakage_tol=.1, rescale_leakage_tol=False,
+                    pol_fit=['RL', 'LR'], dtype='vis',
+                    minimizer_method='L-BFGS-B', 
+                    ttype='direct', fft_pad_factor=2, 
+                    use_grad=True,
+                    show_solution=True):
+    """Polarimetric calibration (detects and removes polarimetric leakage,
+       based on consistency with a given image)
+
+       Args:
+           obs (Obsdata): The observation to be calibrated
+           im (Image): the reference image used for calibration
+
+           sites (list): list of sites to include in the polarimetric calibration.
+                         empty list calibrates all sites
+
+           leakage_tol (float): leakage values exceeding this value will be disfavored by the prior
+           rescale_leakage_tol (bool): if True, properly scale leakage tol for number of sites 
+                                       (not done correctly in old version)
+           
+           pol_fit (list): list of visibilities to use; e.g., ['RL','LR'] or ['RR','LL','RL','LR']
+
+           minimizer_method (str): Method for scipy.optimize.minimize (e.g., 'CG', 'BFGS')
+           ttype (str): if "fast" or "nfft" use FFT to produce visibilities. Else "direct" for DTFT
+           fft_pad_factor (float): zero pad the image to fft_pad_factor * image size in FFT
+
+           use_grad (bool): if True, use gradients in minimizer
+           
+           show_solution (bool): if True, display the solution as it is calculated
+
+           
+       Returns:
+           (Obsdata): the calibrated observation, with computed leakage values added to the obs.tarr
+    """
+    
+    if not(obs.ampcal and obs.phasecal):
+        raise Exception("obs must be amplitude and phase calibrated before leakage_cal! (TODO: generalize)")
+        
+        
+    tstart = time.time()
+
+    mask = []     # TODO: add image masks? 
+    dtype = 'vis' # TODO: add other data terms? 
+    
+    # Do everything in a circular basis
+    im_circ = im.switch_polrep('circ')
+    obs_circ = obs.copy().switch_polrep('circ')
+
+    # Check to see if the field rotation is corrected
+    if obs_circ.frcal is False:
+        print("Field rotation angles have not been corrected. Correcting now...")
+        obs_circ.data = simobs.apply_jones_inverse(obs_circ, frcal=False, dcal=True, opacitycal=True, verbose=False)
+        obs_circ.frcal = True 
+
+    # List of all sites present in the observation. Make sure they are all in the tarr
+    allsites = list(set(np.hstack((obs_circ.data['t1'], obs_circ.data['t2']))))
+    for site in allsites:
+        if not (site in obs_circ.tarr['site']):
+            raise Exception("site %s not in obs.tarr!"%site)
+            
+    if len(sites) == 0:
+        print("No stations specified for leakage calibration: defaulting to calibrating all sites !")
+        sites = allsites
+    # only include sites that are present in obs.tarr
+    sites = [s for s in sites if s in allsites]
+    site_index = [list(obs_circ.tarr['site']).index(s) for s in sites]
+    
+    # TODO do we want to start with some nonzero D-terms? 
+    # Set all leakage terms in obs_circ to zero
+    # (we will only correct leakage for those sites with new solutions)
+    for j in range(len(obs_circ.tarr)):
+        if obs_circ.tarr[j]['site'] in sites:
+            continue
+        obs_circ.tarr[j]['dr'] = obs_circ.tarr[j]['dl'] = 0.0j
+
+    print("Finding leakage for sites:", sites)
+
+    print("Precomputing visibilities...")    
+    # get stations
+    t1 = obs_circ.unpack('t1')['t1']
+    t2 = obs_circ.unpack('t2')['t2']
+    
+    # index sites in t1, t2 position. If no calibrated site is used in a baseline, -1
+    idx1 = np.array([sites.index(t) if (t in sites) else -1 for t in t1])
+    idx2 = np.array([sites.index(t) if (t in sites) else -1 for t in t2])
+        
+    # get real data and sigmas
+    # TODO add other chisqdata parameters? 
+    # TODO modify chisqdata function to have the option to return samples? 
+    
+    (vis_RR, sigma_RR, _) = iu.chisqdata(obs_circ, im_circ, mask=mask, dtype=dtype, pol='RR',
+                                         ttype=ttype, fft_pad_factor=fft_pad_factor)
+    (vis_LL, sigma_LL, _) = iu.chisqdata(obs_circ, im_circ, mask=mask, dtype=dtype, pol='LL',
+                                         ttype=ttype, fft_pad_factor=fft_pad_factor)
+    (vis_RL, sigma_RL, _) = iu.chisqdata(obs_circ, im_circ, mask=mask, dtype=dtype, pol='RL',
+                                         ttype=ttype, fft_pad_factor=fft_pad_factor)
+    (vis_LR, sigma_LR, _) = iu.chisqdata(obs_circ, im_circ, mask=mask, dtype=dtype, pol='LR',
+                                         ttype=ttype, fft_pad_factor=fft_pad_factor)
+
+    # get simulated data (from simple Fourier transform)
+    obs_sim = im_circ.observe_same_nonoise(obs_circ, 
+                                           ttype=ttype, fft_pad_factor=fft_pad_factor, 
+                                           zero_empty_pol=True,verbose=False)
+                                           
+    (ft_RR, _, _) = iu.chisqdata(obs_sim, im_circ, mask=mask, dtype=dtype, pol='RR',
+                                 ttype=ttype, fft_pad_factor=fft_pad_factor)
+    (ft_LL, _, _) = iu.chisqdata(obs_sim, im_circ, mask=mask, dtype=dtype, pol='LL',
+                                 ttype=ttype, fft_pad_factor=fft_pad_factor)
+    (ft_RL, _, _) = iu.chisqdata(obs_sim, im_circ, mask=mask, dtype=dtype, pol='RL',
+                                 ttype=ttype, fft_pad_factor=fft_pad_factor)
+    (ft_LR, _, _) = iu.chisqdata(obs_sim, im_circ, mask=mask, dtype=dtype, pol='LR',
+                                 ttype=ttype, fft_pad_factor=fft_pad_factor)
+                                                                              
+    # field rotation angles 
+    el1 = obs_circ.unpack(['el1'], ang_unit='rad')['el1']
+    el2 = obs_circ.unpack(['el2'], ang_unit='rad')['el2']
+    par1 = obs_circ.unpack(['par_ang1'], ang_unit='rad')['par_ang1']
+    par2 = obs_circ.unpack(['par_ang2'], ang_unit='rad')['par_ang2']
+
+    fr_elev1 = np.array([obs_circ.tarr[obs_circ.tkey[o['t1']]]['fr_elev'] for o in obs.data])
+    fr_elev2 = np.array([obs_circ.tarr[obs_circ.tkey[o['t2']]]['fr_elev'] for o in obs.data])
+    fr_par1  = np.array([obs_circ.tarr[obs_circ.tkey[o['t1']]]['fr_par']  for o in obs.data])
+    fr_par2  = np.array([obs_circ.tarr[obs_circ.tkey[o['t2']]]['fr_par']  for o in obs.data])
+    fr_off1  = np.array([obs_circ.tarr[obs_circ.tkey[o['t1']]]['fr_off']  for o in obs.data])
+    fr_off2  = np.array([obs_circ.tarr[obs_circ.tkey[o['t2']]]['fr_off']  for o in obs.data])
+
+    fr1 = fr_elev1*el1 + fr_par1*par1 + fr_off1*np.pi/180.
+    fr2 = fr_elev2*el2 + fr_par2*par2 + fr_off2*np.pi/180.
+
+    Delta = fr1 - fr2
+    Phi = fr1 + fr2
+
+    # TODO: read in gains from caltable? 
+    # gains
+    GR1 = np.ones(fr1.shape)
+    GL1 = np.ones(fr1.shape)
+    GR2 = np.ones(fr2.shape)
+    GL2 = np.ones(fr2.shape)
+        
+    if not(len(Delta)==len(vis_RR)==len(sigma_LL)==len(ft_RR)==len(t1)):
+        raise Exception("not all data columns the right length in pol_cal!")
+    Nvis = len(vis_RR)
+    
+    # define the error function
+    def chisq_total(Dpar):
+        # all the D-terms as complex numbers. If const_fpol, fpol is the last parameter.
+        D = Dpar.astype(np.float64).view(dtype=np.complex128)
+
+        # current D-terms for each baseline, zero for stations not calibrated (TODO faster?)
+        DR1 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t1])
+        DL1 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t1])
+        
+        DR2 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t2])
+        DL2 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t2])
+        
+        # rotate the D-terms by twice the field rotation
+        # TODO: for now, use explicit phase terms
+#        DR1 = np.exp(2j*fr1)*DR1
+#        DL1 = np.exp(-2j*fr1)*DL1 
+#        DR2 = np.exp(2j*fr2)*DR2
+#        DL2 = np.exp(-2j*fr2)*DL2
+        
+        # simulated visibilities and chisqs with leakage
+        chisq_RR = chisq_LL = chisq_RL = chisq_LR = 0.0
+        if 'RR' in pol_fit:
+            vis_RR_leak = ft_RR + DR1*DR2.conj()*np.exp(2j*Delta)*ft_LL + DR1*np.exp(2j*fr1)*ft_LR + DR2.conj()*np.exp(-2j*fr2)*ft_RL
+            vis_RR_leak *= GR1*GR2.conj()
+            
+            chisq_RR = np.sum(np.abs(vis_RR - vis_RR_leak)**2 / (sigma_RR**2))
+            chisq_RR = chisq_RR / (2.*Nvis)
+        if 'LL' in pol_fit:
+            vis_LL_leak = ft_LL + DL1*DL2.conj()*np.exp(-2j*Delta)*ft_RR + DL1*np.exp(-2j*fr1)*ft_RL + DL2.conj()*np.exp(2j*fr2)*ft_LR
+            vis_LL_leak *= GL1*GL2.conj()
+            
+            chisq_LL = np.sum(np.abs(vis_LL - vis_LL_leak)**2 / (sigma_LL**2))
+            chisq_LL = chisq_LL / (2.*Nvis)
+        if 'RL' in pol_fit:
+            vis_RL_leak = ft_RL + DR1*DL2.conj()*np.exp(2j*Phi)*ft_LR + DR1*np.exp(2j*fr1)*ft_LL + DL2.conj()*np.exp(2j*fr2)*ft_RR          
+            vis_RL_leak *= GR1*GL2.conj()  
+            
+            chisq_RL = np.sum(np.abs(vis_RL - vis_RL_leak)**2 / (sigma_RL**2))
+            chisq_RL = chisq_RL / (2.*Nvis)
+        if 'LR' in pol_fit:
+            vis_LR_leak = ft_LR + DL1*DR2.conj()*np.exp(-2j*Phi)*ft_RL + DL1*np.exp(-2j*fr1)*ft_RR + DR2.conj()*np.exp(-2j*fr2)*ft_LL                       
+            vis_LR_leak *= GL1*GR2.conj()
+                 
+            chisq_LR = np.sum(np.abs(vis_LR - vis_LR_leak)**2 / (sigma_LR**2))            
+            chisq_LR = chisq_LR / (2.*Nvis)
+            
+        chisq_tot = (chisq_RR + chisq_LL + chisq_RL + chisq_LR)/len(pol_fit)
+        return chisq_tot
+        
+    def errfunc(Dpar):
+        # chi-squared        
+        chisq_tot = chisq_total(Dpar)
+        
+        # prior on the D terms
+        # TODO 
+        prior = np.sum((np.abs(Dpar)**2)/(leakage_tol**2))
+        if rescale_leakage_tol:
+            prior = prior / (len(Dpar))
+            
+        return  chisq_tot + prior             
+
+    # define the error function gradient
+
+    def errfunc_grad(Dpar):
+        
+        chisqgrad = np.zeros(len(Dpar))
+        priorgrad = np.zeros(len(Dpar))
+                
+        # all the D-terms as complex numbers.
+        # stored in groups of 4 per site [Re(DR), Im(DR), Re(DL), Im(DL)]
+        D = Dpar.astype(np.float64).view(dtype=np.complex128)
+
+        # current D-terms for each baseline, zero for stations not calibrated (TODO faster?)
+        DR1 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t1])
+        DL1 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t1])
+        
+        DR2 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t2])
+        DL2 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t2])
+       
+        # residual and dV/dD terms
+        if 'RR' in pol_fit:
+            vis_RR_leak = GR1*GR2.conj()*(ft_RR + DR1*DR2.conj()*ft_LL + DR1*ft_LR + DR2.conj()*ft_RL)
+
+            resid_RR = (vis_RR - vis_RR_leak).conj() 
+
+            dRR_dReDR1 = DR2.conj()*np.exp(2j*Delta)*ft_LL + np.exp(2j*fr1)*ft_LR
+            dRR_dReDR1 *= GR1*GR2.conj()
+            dRR_dImDR1 = 1j*dRR_dReDR1
+            
+            dRR_dReDR2 = DR1*np.exp(2j*Delta)*ft_LL + np.exp(-2j*fr2)*ft_RL
+            dRR_dReDR2 *= GR1*GR2.conj()
+            dRR_dImDR2 = -1j*dRR_dReDR2            
+
+        if 'LL' in pol_fit:
+            vis_LL_leak = ft_LL + DL1*DL2.conj()*np.exp(-2j*Delta)*ft_RR + DL1*np.exp(-2j*fr1)*ft_RL + DL2.conj()*np.exp(2j*fr2)*ft_LR
+
+            resid_LL = (vis_LL - vis_LL_leak).conj() 
+
+            dLL_dReDL1 = DL2.conj()*np.exp(-2j*Delta)*ft_RR + np.exp(-2j*fr1)*ft_RL
+            dLL_dReDL1 *= GL1*GL2.conj()
+            dLL_dImDL1 = 1j*dLL_dReDL1
+            
+            dLL_dReDL2 = DL1*np.exp(-2j*Delta)*ft_RR + np.exp(2j*fr2)*ft_LR
+            dLL_dReDL2 *= GL1*GL2.conj()
+            dLL_dImDL2 = -1j*dLL_dReDL2            
+
+        if 'RL' in pol_fit:
+            vis_RL_leak = GR1*GL2.conj()*(ft_RL + DR1*DL2.conj()*ft_LR + DR1*ft_LL + DL2.conj()*ft_RR)            
+
+            resid_RL = (vis_RL - vis_RL_leak).conj() 
+
+            dRL_dReDR1 = DL2.conj()*np.exp(2j*Phi)*ft_LR + np.exp(2j*fr1)*ft_LL
+            dRL_dReDR1 *= GR1*GL2.conj()
+            dRL_dImDR1 = 1j*dRL_dReDR1
+            
+            dRL_dReDL2 = DR1*np.exp(2j*Phi)*ft_LR + np.exp(2j*fr2)*ft_RR
+            dRL_dReDL2 *= GR1*GL2.conj()
+            dRL_dImDL2 = -1j*dRL_dReDL2            
+            
+        if 'LR' in pol_fit:
+            vis_LR_leak = GL1*GR2.conj()*(ft_LR + DL1*DR2.conj()*ft_RL + DL1*ft_RR + DR2.conj()*ft_LL)                        
+
+            resid_LR = (vis_LR - vis_LR_leak).conj() 
+
+            dLR_dReDL1 = DR2.conj()*np.exp(-2j*Phi)*ft_RL + np.exp(-2j*fr1)*ft_RR
+            dLR_dReDL1 *= GL1*GR2.conj()
+            dLR_dImDL1 = 1j*dLR_dReDL1
+            
+            dLR_dReDR2 = DL1*np.exp(-2j*Phi)*ft_RL + np.exp(-2j*fr2)*ft_LL
+            dLR_dReDR2 *= GL1*GR2.conj()
+            dLR_dImDR2 = -1j*dLR_dReDR2            
+                    
+        # gradients, sum over baselines
+        # TODO remove for loop with some fancy vectorization? 
+        for isite in range(len(sites)):
+            mask1 = (idx1 == isite)
+            mask2 = (idx2 == isite)
+            
+            # Re(DR)
+            grad= 0
+            if 'RR' in pol_fit:
+                terms = -1 * np.real(resid_RR[mask1] * dRR_dReDR1[mask1]) / (sigma_RR[mask1]**2)
+                grad += np.sum(terms)/Nvis
+
+                terms = -1 * np.real(resid_RR[mask2] * dRR_dReDR2[mask2]) / (sigma_RR[mask2]**2)
+                grad += np.sum(terms)/Nvis                            
+          
+            if 'RL' in pol_fit:
+                terms = -1 * np.real(resid_RL[mask1] * dRL_dReDR1[mask1]) / (sigma_RL[mask1]**2)
+                grad += np.sum(terms)/Nvis
+          
+            if 'LR' in pol_fit: 
+                terms = -1 * np.real(resid_LR[mask2] * dLR_dReDR2[mask2]) / (sigma_LR[mask2]**2)
+                grad += np.sum(terms)/Nvis            
+          
+            chisqgrad[4*isite] += grad/len(pol_fit)
+            
+            # Im(DR)
+            grad= 0
+            if 'RR' in pol_fit:
+                terms = -1 * np.real(resid_RR[mask1] * dRR_dImDR1[mask1]) / (sigma_RR[mask1]**2)
+                grad += np.sum(terms)/Nvis
+
+                terms = -1 * np.real(resid_RR[mask2] * dRR_dImDR2[mask2]) / (sigma_RR[mask2]**2)
+                grad += np.sum(terms)/Nvis                            
+          
+            if 'RL' in pol_fit:
+                terms = -1 * np.real(resid_RL[mask1] * dRL_dImDR1[mask1]) / (sigma_RL[mask1]**2)
+                grad += np.sum(terms)/Nvis
+          
+            if 'LR' in pol_fit: 
+                terms = -1 * np.real(resid_LR[mask2] * dLR_dImDR2[mask2]) / (sigma_LR[mask2]**2)
+                grad += np.sum(terms)/Nvis            
+                
+            chisqgrad[4*isite+1] += grad/len(pol_fit)
+            
+            # Re(DL)
+            grad= 0
+            if 'LL' in pol_fit:
+                terms = -1 * np.real(resid_LL[mask1] * dLL_dReDL1[mask1]) / (sigma_LL[mask1]**2)
+                grad += np.sum(terms)/Nvis
+
+                terms = -1 * np.real(resid_LL[mask2] * dLL_dReDL2[mask2]) / (sigma_LL[mask2]**2)
+                grad += np.sum(terms)/Nvis                            
+
+            if 'RL' in pol_fit: 
+                terms = -1 * np.real(resid_RL[mask2] * dRL_dReDL2[mask2]) / (sigma_RL[mask2]**2)
+                grad += np.sum(terms)/Nvis          
+                          
+            if 'LR' in pol_fit:
+                terms = -1 * np.real(resid_LR[mask1] * dLR_dReDL1[mask1]) / (sigma_LR[mask1]**2)
+                grad += np.sum(terms)/Nvis
+                      
+            chisqgrad[4*isite+2] += grad/len(pol_fit)
+            
+            # Im(DL)
+            grad= 0
+            if 'LL' in pol_fit:
+                terms = -1 * np.real(resid_LL[mask1] * dLL_dImDL1[mask1]) / (sigma_LL[mask1]**2)
+                grad += np.sum(terms)/Nvis
+
+                terms = -1 * np.real(resid_LL[mask2] * dLL_dImDL2[mask2]) / (sigma_LL[mask2]**2)
+                grad += np.sum(terms)/Nvis                            
+
+            if 'RL' in pol_fit: 
+                terms = -1 * np.real(resid_RL[mask2] * dRL_dImDL2[mask2]) / (sigma_RL[mask2]**2)
+                grad += np.sum(terms)/Nvis        
+                          
+            if 'LR' in pol_fit:
+                terms = -1 * np.real(resid_LR[mask1] * dLR_dImDL1[mask1]) / (sigma_LR[mask1]**2)
+                grad += np.sum(terms)/Nvis
+                    
+            chisqgrad[4*isite+3] += grad/len(pol_fit)
+
+
+        # gradient of the prior
+        priorgrad = 2*Dpar / (leakage_tol**2)
+        if rescale_leakage_tol:
+            priorgrad = priorgrad / (len(Dpar))
+            
+        return  chisqgrad + priorgrad      
+
+    # Gradient test - remove!
+    def test_grad(Dpar):
+        grad_ana = errfunc_grad(Dpar)
+        grad_num1 = np.zeros(len(Dpar))
+        for i in range(len(Dpar)):
+            dd = 1.e-8
+            Dpar_dd = Dpar.copy()
+            Dpar_dd[i] += dd
+            grad_num1[i] = (errfunc(Dpar_dd) - errfunc(Dpar))/dd
+        grad_num2 = np.zeros(len(Dpar))
+        for i in range(len(Dpar)):
+            dd = -1.e-8
+            Dpar_dd = Dpar.copy()
+            Dpar_dd[i] += dd
+            grad_num2[i] = (errfunc(Dpar_dd) - errfunc(Dpar))/dd
+                        
+        plt.close('all')
+        plt.ion()
+        plt.figure()
+        plt.plot(np.arange(len(Dpar)), grad_ana, 'ro')
+        plt.plot(np.arange(len(Dpar)), grad_num1, 'b.')     
+        plt.plot(np.arange(len(Dpar)), grad_num2, 'bx')   
+        plt.xticks(np.arange(0,len(Dpar),4), sites)
+                
+        plt.figure()
+        zscal = 1.e-32*np.min(np.abs(grad_ana)[grad_ana!=0])
+        plt.plot(np.arange(len(Dpar)), 100-100*(grad_num1+zscal)/(grad_ana+zscal),'b.') 
+        plt.plot(np.arange(len(Dpar)), 100-100*(grad_num2+zscal)/(grad_ana+zscal),'bx') 
+        plt.xticks(np.arange(0,len(Dpar),4), sites)
+        plt.ylim(-1,1)
+        plt.show()
+        return
+      
+#    Dpar_guess = .1*np.random.randn(len(sites)*4)
+#    test_grad(Dpar_guess)
+    
+    print("Calibrating D-terms...")    
+    # Now, we will finally minimize the total error term. We need two complex leakage terms for each site
+    if minimizer_method=='L-BFGS-B':
+        optdict = {'maxiter': MAXIT,
+                   'ftol': STOP, 'gtol': STOP,
+                   'maxcor': NHIST, 'maxls': MAXLS}
+    else:
+        optdict = {'maxiter': MAXIT}  
+        
+    Dpar_guess = np.zeros(len(sites)*2, dtype=np.complex128).view(dtype=np.float64)
+    if use_grad:                   
+        res = opt.minimize(errfunc, Dpar_guess, method=minimizer_method, options=optdict, jac=errfunc_grad)
+    else:
+        res = opt.minimize(errfunc, Dpar_guess, method=minimizer_method, options=optdict)    
+
+    print(errfunc(Dpar_guess),errfunc(res.x))
+    
+    # get solution
+    Dpar_fit  =  res.x.astype(np.float64)
+    D_fit = Dpar_fit.view(dtype=np.complex128)  # all the D-terms (complex)
+
+    # Apply the solution
+    obs_out = obs_circ.copy() # TODO or overwrite directly?
+    for isite in range(len(sites)):
+        obs_out.tarr['dr'][site_index[isite]] = D_fit[2*isite]
+        obs_out.tarr['dl'][site_index[isite]] = D_fit[2*isite+1]
+    obs_out.data = simobs.apply_jones_inverse(obs_out, dcal=False, frcal=True, opacitycal=True, verbose=False)
+    obs_out.dcal = True
+
+    # Re-populate any additional leakage terms that were present
+    for j in range(len(obs_out.tarr)):
+        if obs_out.tarr[j]['site'] in sites:
+            continue
+        obs_out.tarr[j]['dr'] = obs.tarr[j]['dr']
+        obs_out.tarr[j]['dl'] = obs.tarr[j]['dl']
+
+    # TODO are these diagnostics correct? 
+    if show_solution:
+
+        chisq_orig = chisq_total(Dpar_fit*0)
+        chisq_new  = chisq_total(Dpar_fit)
+
+        print("Original chi-squared: {:.4f}".format(chisq_orig))
+        print("New chi-squared: {:.4f}\n".format(chisq_new))
+        for isite in range(len(sites)):
+            print(sites[isite])
+            print('   D_R: {:.4f}'.format(D_fit[2*isite]))
+            print('   D_L: {:.4f}\n'.format(D_fit[2*isite+1]))
+
+    tstop = time.time()
+    print("\nleakage_cal time: %f s" % (tstop - tstart))
+
+
+    obs_out = obs_out.switch_polrep(obs.polrep)
+
+
+    return obs_out
+    
+    
+
+

From 78baf04c1d3fa6894161b336208988213830c6c7 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Thu, 1 Feb 2024 20:27:05 -0500
Subject: [PATCH 05/15] updated gradient in polcal_new

---
 ehtim/calibrating/pol_cal_new.py | 81 ++++++++++++++++++--------------
 1 file changed, 45 insertions(+), 36 deletions(-)

diff --git a/ehtim/calibrating/pol_cal_new.py b/ehtim/calibrating/pol_cal_new.py
index 877b96f4..75ec780b 100644
--- a/ehtim/calibrating/pol_cal_new.py
+++ b/ehtim/calibrating/pol_cal_new.py
@@ -255,11 +255,10 @@ def errfunc(Dpar):
 
     # define the error function gradient
 
-    def errfunc_grad(Dpar):
+    def chisq_total_grad(Dpar):
         
         chisqgrad = np.zeros(len(Dpar))
-        priorgrad = np.zeros(len(Dpar))
-                
+
         # all the D-terms as complex numbers.
         # stored in groups of 4 per site [Re(DR), Im(DR), Re(DL), Im(DL)]
         D = Dpar.astype(np.float64).view(dtype=np.complex128)
@@ -384,7 +383,9 @@ def errfunc_grad(Dpar):
             if 'LR' in pol_fit:
                 terms = -1 * np.real(resid_LR[mask1] * dLR_dReDL1[mask1]) / (sigma_LR[mask1]**2)
                 grad += np.sum(terms)/Nvis
-                      
+          
+
+                
             chisqgrad[4*isite+2] += grad/len(pol_fit)
             
             # Im(DL)
@@ -403,10 +404,18 @@ def errfunc_grad(Dpar):
             if 'LR' in pol_fit:
                 terms = -1 * np.real(resid_LR[mask1] * dLR_dImDL1[mask1]) / (sigma_LR[mask1]**2)
                 grad += np.sum(terms)/Nvis
+          
+
                     
             chisqgrad[4*isite+3] += grad/len(pol_fit)
+                    
 
-
+        return chisqgrad
+        
+    def errfunc_grad(Dpar):
+        # gradient of the chi^2
+        chisqgrad = chisq_total_grad(Dpar)
+        
         # gradient of the prior
         priorgrad = 2*Dpar / (leakage_tol**2)
         if rescale_leakage_tol:
@@ -415,37 +424,37 @@ def errfunc_grad(Dpar):
         return  chisqgrad + priorgrad      
 
     # Gradient test - remove!
-    def test_grad(Dpar):
-        grad_ana = errfunc_grad(Dpar)
-        grad_num1 = np.zeros(len(Dpar))
-        for i in range(len(Dpar)):
-            dd = 1.e-8
-            Dpar_dd = Dpar.copy()
-            Dpar_dd[i] += dd
-            grad_num1[i] = (errfunc(Dpar_dd) - errfunc(Dpar))/dd
-        grad_num2 = np.zeros(len(Dpar))
-        for i in range(len(Dpar)):
-            dd = -1.e-8
-            Dpar_dd = Dpar.copy()
-            Dpar_dd[i] += dd
-            grad_num2[i] = (errfunc(Dpar_dd) - errfunc(Dpar))/dd
-                        
-        plt.close('all')
-        plt.ion()
-        plt.figure()
-        plt.plot(np.arange(len(Dpar)), grad_ana, 'ro')
-        plt.plot(np.arange(len(Dpar)), grad_num1, 'b.')     
-        plt.plot(np.arange(len(Dpar)), grad_num2, 'bx')   
-        plt.xticks(np.arange(0,len(Dpar),4), sites)
-                
-        plt.figure()
-        zscal = 1.e-32*np.min(np.abs(grad_ana)[grad_ana!=0])
-        plt.plot(np.arange(len(Dpar)), 100-100*(grad_num1+zscal)/(grad_ana+zscal),'b.') 
-        plt.plot(np.arange(len(Dpar)), 100-100*(grad_num2+zscal)/(grad_ana+zscal),'bx') 
-        plt.xticks(np.arange(0,len(Dpar),4), sites)
-        plt.ylim(-1,1)
-        plt.show()
-        return
+#    def test_grad(Dpar):
+#        grad_ana = errfunc_grad(Dpar)
+#        grad_num1 = np.zeros(len(Dpar))
+#        for i in range(len(Dpar)):
+#            dd = 1.e-8
+#            Dpar_dd = Dpar.copy()
+#            Dpar_dd[i] += dd
+#            grad_num1[i] = (errfunc(Dpar_dd) - errfunc(Dpar))/dd
+#        grad_num2 = np.zeros(len(Dpar))
+#        for i in range(len(Dpar)):
+#            dd = -1.e-8
+#            Dpar_dd = Dpar.copy()
+#            Dpar_dd[i] += dd
+#            grad_num2[i] = (errfunc(Dpar_dd) - errfunc(Dpar))/dd
+#                        
+#        plt.close('all')
+#        plt.ion()
+#        plt.figure()
+#        plt.plot(np.arange(len(Dpar)), grad_ana, 'ro')
+#        plt.plot(np.arange(len(Dpar)), grad_num1, 'b.')     
+#        plt.plot(np.arange(len(Dpar)), grad_num2, 'bx')   
+#        plt.xticks(np.arange(0,len(Dpar),4), sites)
+#                
+#        plt.figure()
+#        zscal = 1.e-32*np.min(np.abs(grad_ana)[grad_ana!=0])
+#        plt.plot(np.arange(len(Dpar)), 100-100*(grad_num1+zscal)/(grad_ana+zscal),'b.') 
+#        plt.plot(np.arange(len(Dpar)), 100-100*(grad_num2+zscal)/(grad_ana+zscal),'bx') 
+#        plt.xticks(np.arange(0,len(Dpar),4), sites)
+#        plt.ylim(-1,1)
+#        plt.show()
+#        return
       
 #    Dpar_guess = .1*np.random.randn(len(sites)*4)
 #    test_grad(Dpar_guess)

From db49a20b5eed56119839166c253ffb203f35fe28 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Fri, 2 Feb 2024 11:45:59 -0500
Subject: [PATCH 06/15] fixed feed rotation angle bug in new polcal

---
 ehtim/calibrating/pol_cal_new.py | 156 +++++++++++--------------------
 1 file changed, 53 insertions(+), 103 deletions(-)

diff --git a/ehtim/calibrating/pol_cal_new.py b/ehtim/calibrating/pol_cal_new.py
index 75ec780b..cd1b1f31 100644
--- a/ehtim/calibrating/pol_cal_new.py
+++ b/ehtim/calibrating/pol_cal_new.py
@@ -204,13 +204,6 @@ def chisq_total(Dpar):
         DR2 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t2])
         DL2 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t2])
         
-        # rotate the D-terms by twice the field rotation
-        # TODO: for now, use explicit phase terms
-#        DR1 = np.exp(2j*fr1)*DR1
-#        DL1 = np.exp(-2j*fr1)*DL1 
-#        DR2 = np.exp(2j*fr2)*DR2
-#        DL2 = np.exp(-2j*fr2)*DL2
-        
         # simulated visibilities and chisqs with leakage
         chisq_RR = chisq_LL = chisq_RL = chisq_LR = 0.0
         if 'RR' in pol_fit:
@@ -257,71 +250,57 @@ def errfunc(Dpar):
 
     def chisq_total_grad(Dpar):
         
-        chisqgrad = np.zeros(len(Dpar))
-
-        # all the D-terms as complex numbers.
-        # stored in groups of 4 per site [Re(DR), Im(DR), Re(DL), Im(DL)]
-        D = Dpar.astype(np.float64).view(dtype=np.complex128)
-
-        # current D-terms for each baseline, zero for stations not calibrated (TODO faster?)
-        DR1 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t1])
-        DL1 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t1])
-        
-        DR2 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t2])
-        DL2 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t2])
-       
-        # residual and dV/dD terms
+       # residual and dV/dD terms
         if 'RR' in pol_fit:
-            vis_RR_leak = GR1*GR2.conj()*(ft_RR + DR1*DR2.conj()*ft_LL + DR1*ft_LR + DR2.conj()*ft_RL)
+            vis_RR_leak = ft_RR + DR1*DR2.conj()*np.exp(2j*Delta)*ft_LL + DR1*np.exp(2j*fr1)*ft_LR + DR2.conj()*np.exp(-2j*fr2)*ft_RL
+            vis_RR_leak *= GR1*GR2.conj()
 
             resid_RR = (vis_RR - vis_RR_leak).conj() 
 
             dRR_dReDR1 = DR2.conj()*np.exp(2j*Delta)*ft_LL + np.exp(2j*fr1)*ft_LR
             dRR_dReDR1 *= GR1*GR2.conj()
-            dRR_dImDR1 = 1j*dRR_dReDR1
             
             dRR_dReDR2 = DR1*np.exp(2j*Delta)*ft_LL + np.exp(-2j*fr2)*ft_RL
             dRR_dReDR2 *= GR1*GR2.conj()
-            dRR_dImDR2 = -1j*dRR_dReDR2            
 
         if 'LL' in pol_fit:
             vis_LL_leak = ft_LL + DL1*DL2.conj()*np.exp(-2j*Delta)*ft_RR + DL1*np.exp(-2j*fr1)*ft_RL + DL2.conj()*np.exp(2j*fr2)*ft_LR
+            vis_LL_leak *= GL1*GL2.conj()
 
             resid_LL = (vis_LL - vis_LL_leak).conj() 
 
             dLL_dReDL1 = DL2.conj()*np.exp(-2j*Delta)*ft_RR + np.exp(-2j*fr1)*ft_RL
             dLL_dReDL1 *= GL1*GL2.conj()
-            dLL_dImDL1 = 1j*dLL_dReDL1
-            
+
             dLL_dReDL2 = DL1*np.exp(-2j*Delta)*ft_RR + np.exp(2j*fr2)*ft_LR
             dLL_dReDL2 *= GL1*GL2.conj()
-            dLL_dImDL2 = -1j*dLL_dReDL2            
+
 
         if 'RL' in pol_fit:
-            vis_RL_leak = GR1*GL2.conj()*(ft_RL + DR1*DL2.conj()*ft_LR + DR1*ft_LL + DL2.conj()*ft_RR)            
+            vis_RL_leak = ft_RL + DR1*DL2.conj()*np.exp(2j*Phi)*ft_LR + DR1*np.exp(2j*fr1)*ft_LL + DL2.conj()*np.exp(2j*fr2)*ft_RR          
+            vis_RL_leak *= GR1*GL2.conj()  
 
             resid_RL = (vis_RL - vis_RL_leak).conj() 
 
             dRL_dReDR1 = DL2.conj()*np.exp(2j*Phi)*ft_LR + np.exp(2j*fr1)*ft_LL
             dRL_dReDR1 *= GR1*GL2.conj()
-            dRL_dImDR1 = 1j*dRL_dReDR1
-            
+    
             dRL_dReDL2 = DR1*np.exp(2j*Phi)*ft_LR + np.exp(2j*fr2)*ft_RR
             dRL_dReDL2 *= GR1*GL2.conj()
-            dRL_dImDL2 = -1j*dRL_dReDL2            
+
             
         if 'LR' in pol_fit:
-            vis_LR_leak = GL1*GR2.conj()*(ft_LR + DL1*DR2.conj()*ft_RL + DL1*ft_RR + DR2.conj()*ft_LL)                        
+            vis_LR_leak = ft_LR + DL1*DR2.conj()*np.exp(-2j*Phi)*ft_RL + DL1*np.exp(-2j*fr1)*ft_RR + DR2.conj()*np.exp(-2j*fr2)*ft_LL                       
+            vis_LR_leak *= GL1*GR2.conj()
 
             resid_LR = (vis_LR - vis_LR_leak).conj() 
 
             dLR_dReDL1 = DR2.conj()*np.exp(-2j*Phi)*ft_RL + np.exp(-2j*fr1)*ft_RR
             dLR_dReDL1 *= GL1*GR2.conj()
-            dLR_dImDL1 = 1j*dLR_dReDL1
-            
+ 
             dLR_dReDR2 = DL1*np.exp(-2j*Phi)*ft_RL + np.exp(-2j*fr2)*ft_LL
             dLR_dReDR2 *= GL1*GR2.conj()
-            dLR_dImDR2 = -1j*dLR_dReDR2            
+
                     
         # gradients, sum over baselines
         # TODO remove for loop with some fancy vectorization? 
@@ -329,87 +308,58 @@ def chisq_total_grad(Dpar):
             mask1 = (idx1 == isite)
             mask2 = (idx2 == isite)
             
-            # Re(DR)
-            grad= 0
+            # DR
+            regrad = 0
+            imgrad = 0
             if 'RR' in pol_fit:
-                terms = -1 * np.real(resid_RR[mask1] * dRR_dReDR1[mask1]) / (sigma_RR[mask1]**2)
-                grad += np.sum(terms)/Nvis
-
-                terms = -1 * np.real(resid_RR[mask2] * dRR_dReDR2[mask2]) / (sigma_RR[mask2]**2)
-                grad += np.sum(terms)/Nvis                            
+                terms = -1 * resid_RR[mask1] * dRR_dReDR1[mask1] / (sigma_RR[mask1]**2)
+                regrad += np.sum(np.real(terms))/Nvis
+                imgrad += -1*np.sum(np.imag(terms))/Nvis
+                
+                terms = -1 * resid_RR[mask2] * dRR_dReDR2[mask2] / (sigma_RR[mask2]**2)
+                regrad += np.sum(np.real(terms))/Nvis
+                imgrad += np.sum(np.imag(terms))/Nvis
           
             if 'RL' in pol_fit:
-                terms = -1 * np.real(resid_RL[mask1] * dRL_dReDR1[mask1]) / (sigma_RL[mask1]**2)
-                grad += np.sum(terms)/Nvis
+                terms = -1 * resid_RL[mask1] * dRL_dReDR1[mask1] / (sigma_RL[mask1]**2)
+                regrad += np.sum(np.real(terms))/Nvis
+                imgrad += -1*np.sum(np.imag(terms))/Nvis
           
             if 'LR' in pol_fit: 
-                terms = -1 * np.real(resid_LR[mask2] * dLR_dReDR2[mask2]) / (sigma_LR[mask2]**2)
-                grad += np.sum(terms)/Nvis            
+                terms = -1 * resid_LR[mask2] * dLR_dReDR2[mask2] / (sigma_LR[mask2]**2)
+                regrad += np.sum(np.real(terms))/Nvis
+                imgrad += np.sum(np.imag(terms))/Nvis
           
-            chisqgrad[4*isite] += grad/len(pol_fit)
-            
-            # Im(DR)
-            grad= 0
-            if 'RR' in pol_fit:
-                terms = -1 * np.real(resid_RR[mask1] * dRR_dImDR1[mask1]) / (sigma_RR[mask1]**2)
-                grad += np.sum(terms)/Nvis
-
-                terms = -1 * np.real(resid_RR[mask2] * dRR_dImDR2[mask2]) / (sigma_RR[mask2]**2)
-                grad += np.sum(terms)/Nvis                            
-          
-            if 'RL' in pol_fit:
-                terms = -1 * np.real(resid_RL[mask1] * dRL_dImDR1[mask1]) / (sigma_RL[mask1]**2)
-                grad += np.sum(terms)/Nvis
-          
-            if 'LR' in pol_fit: 
-                terms = -1 * np.real(resid_LR[mask2] * dLR_dImDR2[mask2]) / (sigma_LR[mask2]**2)
-                grad += np.sum(terms)/Nvis            
-                
-            chisqgrad[4*isite+1] += grad/len(pol_fit)
-            
-            # Re(DL)
-            grad= 0
-            if 'LL' in pol_fit:
-                terms = -1 * np.real(resid_LL[mask1] * dLL_dReDL1[mask1]) / (sigma_LL[mask1]**2)
-                grad += np.sum(terms)/Nvis
-
-                terms = -1 * np.real(resid_LL[mask2] * dLL_dReDL2[mask2]) / (sigma_LL[mask2]**2)
-                grad += np.sum(terms)/Nvis                            
-
-            if 'RL' in pol_fit: 
-                terms = -1 * np.real(resid_RL[mask2] * dRL_dReDL2[mask2]) / (sigma_RL[mask2]**2)
-                grad += np.sum(terms)/Nvis          
+            chisqgrad[4*isite] += regrad  # Re(DR)
+            chisqgrad[4*isite+1] += imgrad  # Im(DR)
                           
-            if 'LR' in pol_fit:
-                terms = -1 * np.real(resid_LR[mask1] * dLR_dReDL1[mask1]) / (sigma_LR[mask1]**2)
-                grad += np.sum(terms)/Nvis
-          
-
-                
-            chisqgrad[4*isite+2] += grad/len(pol_fit)
-            
-            # Im(DL)
-            grad= 0
+            # DL
+            regrad = 0
+            imgrad = 0
             if 'LL' in pol_fit:
-                terms = -1 * np.real(resid_LL[mask1] * dLL_dImDL1[mask1]) / (sigma_LL[mask1]**2)
-                grad += np.sum(terms)/Nvis
-
-                terms = -1 * np.real(resid_LL[mask2] * dLL_dImDL2[mask2]) / (sigma_LL[mask2]**2)
-                grad += np.sum(terms)/Nvis                            
+                terms = -1 * resid_LL[mask1] * dLL_dReDL1[mask1] / (sigma_LL[mask1]**2)
+                regrad += np.sum(np.real(terms))/Nvis
+                imgrad += -1*np.sum(np.imag(terms))/Nvis
 
+                terms = -1 * resid_LL[mask2] * dLL_dReDL2[mask2] / (sigma_LL[mask2]**2)
+                regrad += np.sum(np.real(terms))/Nvis
+                imgrad += np.sum(np.imag(terms))/Nvis
+          
             if 'RL' in pol_fit: 
-                terms = -1 * np.real(resid_RL[mask2] * dRL_dImDL2[mask2]) / (sigma_RL[mask2]**2)
-                grad += np.sum(terms)/Nvis        
+                terms = -1 * resid_RL[mask2] * dRL_dReDL2[mask2] / (sigma_RL[mask2]**2)
+                regrad += np.sum(np.real(terms))/Nvis
+                imgrad += np.sum(np.imag(terms))/Nvis
                           
             if 'LR' in pol_fit:
-                terms = -1 * np.real(resid_LR[mask1] * dLR_dImDL1[mask1]) / (sigma_LR[mask1]**2)
-                grad += np.sum(terms)/Nvis
-          
-
-                    
-            chisqgrad[4*isite+3] += grad/len(pol_fit)
+                terms = -1 * resid_LR[mask1] * dLR_dReDL1[mask1] / (sigma_LR[mask1]**2)
+                regrad += np.sum(np.real(terms))/Nvis
+                imgrad += -1*np.sum(np.imag(terms))/Nvis
+                
+            chisqgrad[4*isite+2] += regrad  # Re(DL)
+            chisqgrad[4*isite+3] += imgrad  # Im(DL)
+           
+        chisqgrad /= len(pol_fit)
                     
-
         return chisqgrad
         
     def errfunc_grad(Dpar):

From 9363d57bd7c42049541b16999c5e54318f469fc9 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Fri, 2 Feb 2024 12:14:50 -0500
Subject: [PATCH 07/15] fixed another bug in the dterm cal gradient

---
 ehtim/calibrating/pol_cal_new.py | 67 +++++++++++++++++++-------------
 1 file changed, 39 insertions(+), 28 deletions(-)

diff --git a/ehtim/calibrating/pol_cal_new.py b/ehtim/calibrating/pol_cal_new.py
index cd1b1f31..7a2a51cc 100644
--- a/ehtim/calibrating/pol_cal_new.py
+++ b/ehtim/calibrating/pol_cal_new.py
@@ -247,10 +247,21 @@ def errfunc(Dpar):
         return  chisq_tot + prior             
 
     # define the error function gradient
-
     def chisq_total_grad(Dpar):
+        chisqgrad = np.zeros(len(Dpar))
+
+        # all the D-terms as complex numbers.
+        # stored in groups of 4 per site [Re(DR), Im(DR), Re(DL), Im(DL)]
+        D = Dpar.astype(np.float64).view(dtype=np.complex128)
+
+        # current D-terms for each baseline, zero for stations not calibrated (TODO faster?)
+        DR1 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t1])
+        DL1 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t1])
         
-       # residual and dV/dD terms
+        DR2 = np.asarray([D[2*sites.index(s)] if s in sites else 0. for s in t2])
+        DL2 = np.asarray([D[2*sites.index(s)+1] if s in sites else 0. for s in t2])
+       
+        # residual and dV/dD terms
         if 'RR' in pol_fit:
             vis_RR_leak = ft_RR + DR1*DR2.conj()*np.exp(2j*Delta)*ft_LL + DR1*np.exp(2j*fr1)*ft_LR + DR2.conj()*np.exp(-2j*fr2)*ft_RL
             vis_RR_leak *= GR1*GR2.conj()
@@ -302,7 +313,7 @@ def chisq_total_grad(Dpar):
             dLR_dReDR2 *= GL1*GR2.conj()
 
                     
-        # gradients, sum over baselines
+        # to get gradients, sum over baselines
         # TODO remove for loop with some fancy vectorization? 
         for isite in range(len(sites)):
             mask1 = (idx1 == isite)
@@ -312,23 +323,23 @@ def chisq_total_grad(Dpar):
             regrad = 0
             imgrad = 0
             if 'RR' in pol_fit:
-                terms = -1 * resid_RR[mask1] * dRR_dReDR1[mask1] / (sigma_RR[mask1]**2)
-                regrad += np.sum(np.real(terms))/Nvis
-                imgrad += -1*np.sum(np.imag(terms))/Nvis
+                terms = resid_RR[mask1] * dRR_dReDR1[mask1] / (sigma_RR[mask1]**2)
+                regrad += -1*np.sum(np.real(terms))
+                imgrad +=    np.sum(np.imag(terms))
                 
-                terms = -1 * resid_RR[mask2] * dRR_dReDR2[mask2] / (sigma_RR[mask2]**2)
-                regrad += np.sum(np.real(terms))/Nvis
-                imgrad += np.sum(np.imag(terms))/Nvis
+                terms = resid_RR[mask2] * dRR_dReDR2[mask2] / (sigma_RR[mask2]**2)
+                regrad += -1*np.sum(np.real(terms))
+                imgrad += -1*np.sum(np.imag(terms))
           
             if 'RL' in pol_fit:
-                terms = -1 * resid_RL[mask1] * dRL_dReDR1[mask1] / (sigma_RL[mask1]**2)
-                regrad += np.sum(np.real(terms))/Nvis
-                imgrad += -1*np.sum(np.imag(terms))/Nvis
+                terms = resid_RL[mask1] * dRL_dReDR1[mask1] / (sigma_RL[mask1]**2)
+                regrad += -1*np.sum(np.real(terms))
+                imgrad +=    np.sum(np.imag(terms))
           
             if 'LR' in pol_fit: 
-                terms = -1 * resid_LR[mask2] * dLR_dReDR2[mask2] / (sigma_LR[mask2]**2)
-                regrad += np.sum(np.real(terms))/Nvis
-                imgrad += np.sum(np.imag(terms))/Nvis
+                terms = resid_LR[mask2] * dLR_dReDR2[mask2] / (sigma_LR[mask2]**2)
+                regrad += -1*np.sum(np.real(terms))
+                imgrad += -1*np.sum(np.imag(terms))
           
             chisqgrad[4*isite] += regrad  # Re(DR)
             chisqgrad[4*isite+1] += imgrad  # Im(DR)
@@ -337,28 +348,28 @@ def chisq_total_grad(Dpar):
             regrad = 0
             imgrad = 0
             if 'LL' in pol_fit:
-                terms = -1 * resid_LL[mask1] * dLL_dReDL1[mask1] / (sigma_LL[mask1]**2)
-                regrad += np.sum(np.real(terms))/Nvis
-                imgrad += -1*np.sum(np.imag(terms))/Nvis
+                terms = resid_LL[mask1] * dLL_dReDL1[mask1] / (sigma_LL[mask1]**2)
+                regrad += -1*np.sum(np.real(terms))
+                imgrad +=    np.sum(np.imag(terms))
 
-                terms = -1 * resid_LL[mask2] * dLL_dReDL2[mask2] / (sigma_LL[mask2]**2)
-                regrad += np.sum(np.real(terms))/Nvis
-                imgrad += np.sum(np.imag(terms))/Nvis
+                terms = resid_LL[mask2] * dLL_dReDL2[mask2] / (sigma_LL[mask2]**2)
+                regrad += -1*np.sum(np.real(terms))
+                imgrad += -1*np.sum(np.imag(terms))
           
             if 'RL' in pol_fit: 
-                terms = -1 * resid_RL[mask2] * dRL_dReDL2[mask2] / (sigma_RL[mask2]**2)
-                regrad += np.sum(np.real(terms))/Nvis
-                imgrad += np.sum(np.imag(terms))/Nvis
+                terms = resid_RL[mask2] * dRL_dReDL2[mask2] / (sigma_RL[mask2]**2)
+                regrad += -1*np.sum(np.real(terms))
+                imgrad += -1*np.sum(np.imag(terms))
                           
             if 'LR' in pol_fit:
-                terms = -1 * resid_LR[mask1] * dLR_dReDL1[mask1] / (sigma_LR[mask1]**2)
-                regrad += np.sum(np.real(terms))/Nvis
-                imgrad += -1*np.sum(np.imag(terms))/Nvis
+                terms = resid_LR[mask1] * dLR_dReDL1[mask1] / (sigma_LR[mask1]**2)
+                regrad += -1*np.sum(np.real(terms))
+                imgrad +=    np.sum(np.imag(terms))
                 
             chisqgrad[4*isite+2] += regrad  # Re(DL)
             chisqgrad[4*isite+3] += imgrad  # Im(DL)
            
-        chisqgrad /= len(pol_fit)
+        chisqgrad /= (Nvis*len(pol_fit))
                     
         return chisqgrad
         

From be88e1f9abff6f6bbb080b3f9fcb7a9dcbd11b0d Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Fri, 2 Feb 2024 12:21:04 -0500
Subject: [PATCH 08/15] added apply_solution argument to new polcal

---
 ehtim/calibrating/pol_cal_new.py | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/ehtim/calibrating/pol_cal_new.py b/ehtim/calibrating/pol_cal_new.py
index 7a2a51cc..eac9841d 100644
--- a/ehtim/calibrating/pol_cal_new.py
+++ b/ehtim/calibrating/pol_cal_new.py
@@ -54,7 +54,7 @@ def leakage_cal_new(obs, im, sites=[], leakage_tol=.1, rescale_leakage_tol=False
                     minimizer_method='L-BFGS-B', 
                     ttype='direct', fft_pad_factor=2, 
                     use_grad=True,
-                    show_solution=True):
+                    show_solution=True, apply_solution=True):
     """Polarimetric calibration (detects and removes polarimetric leakage,
        based on consistency with a given image)
 
@@ -78,7 +78,7 @@ def leakage_cal_new(obs, im, sites=[], leakage_tol=.1, rescale_leakage_tol=False
            use_grad (bool): if True, use gradients in minimizer
            
            show_solution (bool): if True, display the solution as it is calculated
-
+           apply_solution (bool): if True, apply the solution to the Obsdata, otherwise just return in tarr
            
        Returns:
            (Obsdata): the calibrated observation, with computed leakage values added to the obs.tarr
@@ -441,15 +441,22 @@ def errfunc_grad(Dpar):
     Dpar_fit  =  res.x.astype(np.float64)
     D_fit = Dpar_fit.view(dtype=np.complex128)  # all the D-terms (complex)
 
-    # Apply the solution
+    # fill in the new D-terms to the tarr
     obs_out = obs_circ.copy() # TODO or overwrite directly?
-    for isite in range(len(sites)):
+    for isite in range(len(sites)):     
         obs_out.tarr['dr'][site_index[isite]] = D_fit[2*isite]
         obs_out.tarr['dl'][site_index[isite]] = D_fit[2*isite+1]
-    obs_out.data = simobs.apply_jones_inverse(obs_out, dcal=False, frcal=True, opacitycal=True, verbose=False)
-    obs_out.dcal = True
 
+    # Apply the solution
+    if apply_solution:
+        obs_out.data = simobs.apply_jones_inverse(obs_out, dcal=False, frcal=True, opacitycal=True, verbose=False)
+        obs_out.dcal = True
+    else:
+        obs_out.dcal = False
+        
     # Re-populate any additional leakage terms that were present
+    # NOTE we don't want to do this above, in case we want to ignore these terms in apply_jones inverse
+    # TODO can we do this better? 
     for j in range(len(obs_out.tarr)):
         if obs_out.tarr[j]['site'] in sites:
             continue
@@ -458,7 +465,6 @@ def errfunc_grad(Dpar):
 
     # TODO are these diagnostics correct? 
     if show_solution:
-
         chisq_orig = chisq_total(Dpar_fit*0)
         chisq_new  = chisq_total(Dpar_fit)
 
@@ -475,7 +481,6 @@ def errfunc_grad(Dpar):
 
     obs_out = obs_out.switch_polrep(obs.polrep)
 
-
     return obs_out
     
     

From d3e4408b164bfcfd204dd3a629b2f96e5800b654 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Fri, 2 Feb 2024 14:43:20 -0500
Subject: [PATCH 09/15] modified comp_plots

---
 ehtim/plotting/comp_plots.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ehtim/plotting/comp_plots.py b/ehtim/plotting/comp_plots.py
index 35894962..9862a44b 100644
--- a/ehtim/plotting/comp_plots.py
+++ b/ehtim/plotting/comp_plots.py
@@ -745,7 +745,7 @@ def plotall_obs_im_cphases(obs, imlist,
     else:
         nplots = len(uniqueclosure_tri)
         ncols = 4
-        nrows = nplots / ncols
+        nrows = np.ceil(nplots / ncols).astype(int)
         show = False
         fig = plt.figure(figsize=(nrows*20, 40))
 
@@ -755,7 +755,7 @@ def plotall_obs_im_cphases(obs, imlist,
     nplot = 0
     for c in range(0, len(uniqueclosure_tri)):
         cphases_obs_tri = obs.cphase_tri(uniqueclosure_tri[c][0],
-                                         uniqueclosure_tri[c][1],
+                                         uniqueclosure_tri[cs][1],
                                          uniqueclosure_tri[c][2],
                                          vtype=vtype, ang_unit='deg', cphases=cphases_obs)
 
@@ -780,7 +780,7 @@ def plotall_obs_im_cphases(obs, imlist,
                 ax = False
 
             else:
-                ax = plt.subplot2grid((nrows, ncols), (nplot/ncols, nplot % ncols), fig=fig)
+                ax = plt.subplot2grid((nrows, ncols), (nplot//ncols, nplot % ncols), fig=fig)
                 axislabels = False
 
             f = plot_cphase_obs_compare(obs_all,

From 600410ec601bd0089372fb7aaeb7c8f0712ae5f9 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Fri, 16 Feb 2024 12:34:27 -0500
Subject: [PATCH 10/15] fixed deprecation issues with rex

---
 ehtim/features/rex.py               | 183 ++++++++++++++++++----------
 tutorials/space_vlbi_tutorial.ipynb |   7 +-
 2 files changed, 125 insertions(+), 65 deletions(-)

diff --git a/ehtim/features/rex.py b/ehtim/features/rex.py
index 1eb2b9a3..aa3455c2 100644
--- a/ehtim/features/rex.py
+++ b/ehtim/features/rex.py
@@ -286,7 +286,7 @@ def anglemask(x, y):
         # Polarization brightness ratio
         # AC TODO FOR PAPER VIII ANALYSIS
         self.RingAsymPol = (0., 0.)
-        if len(self.im.qvec) > 0 and len(self.im.uvec) > 0:
+        if len(self.profilesP)>0 and len(self.im.qvec) > 0 and len(self.im.uvec) > 0:
             pvec = np.sqrt(self.im.qvec**2 + self.im.uvec**2)
             pvec_C = (self.im.qvec + 1j*self.im.uvec)
 
@@ -381,17 +381,28 @@ def calc_ringangle_asymmetry(self, prof):
 
     def plot_img(self, postprocdir=POSTPROCDIR, save_png=False):
         plt.figure()
-        plt.contour(self.xs, self.ys, self.imarr, colors='k')
+        
+        fovx = self.im.fovx()/ehc.RADPERUAS
+        fovy = self.im.fovy()/ehc.RADPERUAS
+        xsplot = self.xs - fovx/2.
+        ysplot = self.ys - fovy/2.
+        x0plot = self.x0 - fovx/2.
+        y0plot = self.y0 - fovy/2.
+        
+        plt.pcolormesh(xsplot,ysplot,self.imarr,cmap='afmhot')
+        plt.contour(xsplot,ysplot, self.imarr, colors='k',levels=5)        
+        
         plt.xlabel(r"-RA ($\mu$as)")
         plt.ylabel(r"Dec ($\mu$as)")
-        plt.plot(self.x0, self.y0, 'r*', markersize=20)
+      
+        plt.plot(x0plot,y0plot, 'r*', markersize=20)
 
-        for theta in np.linspace(0, 2*np.pi, 100):
-            plt.plot(self.x0 + np.cos(theta) * self.RingSize1[0]/2,
-                     self.y0 + np.sin(theta) * self.RingSize1[0]/2,
-                     'r*', markersize=1)
-
-        plt.axes().set_aspect('equal', 'datalim')
+        thetas = np.linspace(0, 2*np.pi, 100)
+        plt.plot(x0plot+ np.cos(thetas) * self.RingSize1[0]/2,
+                 y0plot + np.sin(thetas) * self.RingSize1[0]/2,
+                 'r-', markersize=1)
+                         
+        #plt.axes().set_aspect('equal', 'datalim')
 
         if save_png:
             dirname = os.path.basename(os.path.dirname(self.imname))
@@ -472,9 +483,9 @@ def plot_unwrapped(self, postprocdir=POSTPROCDIR, save_png=False,
 
         # labels
         if xlabel:
-            plt.xlabel(r"r$ \\theta $ ($^\circ$)", size=labelsize)
+            plt.xlabel(r"$\theta $ ($^\circ$)", size=labelsize)
         if ylabel:
-            plt.ylabel(r"r$r$ ($\mu$as)", size=labelsize)
+            plt.ylabel(r"$r$ ($\mu$as)", size=labelsize)
 
         xticklabels = np.arange(0, 360, 60)
         xticks = (360/imarr.shape[1])*xticklabels
@@ -523,7 +534,7 @@ def plot_profs(self, postprocdir=POSTPROCDIR, save_png=False, colors=ehc.SCOLORS
         plt.figure()
         plt.xlabel(r"distance from center ($\mu$as)")
         plt.ylabel(r"$T_{\rm b}$")
-        plt.ylim([0, 1])
+        #plt.ylim([0, 1])
         plt.xlim([-10, 60])
         plt.title('All Profiles')
         for j in range(len(self.profiles)):
@@ -563,7 +574,7 @@ def plot_prof_band(self, postprocdir=POSTPROCDIR, save_png=False,
 
         plt.yticks(yticks, yticklabels)
 
-        plt.ylim([0, 11])
+        #plt.ylim([0, 11])
         plt.xlim([-55, 55])
 
         # cut the ring in half orthagonal to the position angle
@@ -585,7 +596,7 @@ def plot_prof_band(self, postprocdir=POSTPROCDIR, save_png=False,
         tho_l1 = np.flip(np.percentile(np.array(prof_half_1), 25, axis=0))
         tho_u1 = np.flip(np.percentile(np.array(prof_half_1), 75, axis=0))
 
-        ax.plot(radii, tho_m/1.e9, 'b-', linewidth=2, color=color)
+        ax.plot(radii, tho_m/1.e9, ls='-', linewidth=2, color=color)
         ax.fill_between(radii, tho_l/1.e9, tho_u/1.e9, alpha=.2, edgecolor=None, facecolor=color)
         ax.fill_between(radii, tho_l1/1.e9, tho_u1/1.e9, alpha=.4, edgecolor=None, facecolor=color)
 
@@ -597,7 +608,7 @@ def plot_prof_band(self, postprocdir=POSTPROCDIR, save_png=False,
         tho_l1 = np.percentile(np.array(prof_half_2), 25, axis=0)
         tho_u1 = np.percentile(np.array(prof_half_2), 75, axis=0)
 
-        ax.plot(radii, tho_m/1.e9, 'b-', linewidth=2, color=color)
+        ax.plot(radii, tho_m/1.e9, ls='-', linewidth=2, color=color)
         ax.fill_between(radii, tho_l/1.e9, tho_u/1.e9, alpha=.2, edgecolor=None, facecolor=color)
         ax.fill_between(radii, tho_l1/1.e9, tho_u1/1.e9, alpha=.4, edgecolor=None, facecolor=color)
 
@@ -623,7 +634,7 @@ def plot_meanprof(self, postprocdir=POSTPROCDIR, save_png=False, color='k'):
                  color=color, linestyle='--', linewidth=1)
         plt.xlabel(r"distance from center ($\mu$as)")
         plt.ylabel(r"Flux (mJy/$\mu$as$^2$)")
-        plt.ylim([0, 1])
+        #plt.ylim([0, 1])
         plt.xlim([-10, 60])
         plt.title('Mean Profile')
         if save_png:
@@ -770,12 +781,39 @@ def findCenter(im,
 
     print("nrays", nrays_search, "nrs", nrs_search, "fov", fov_search, "n", n_search)
 
+    rs = np.linspace(0, rmax_search, nrs_search)
+    dr = rs[-1] - rs[-2]
+    thetas = np.linspace(0, 2*np.pi, nrays_search)
+    factor = 3.254e13/(im.rf**2 * im.psize**2)  # convert to brightness temperature
+    imarr = im.imvec.reshape(im.ydim, im.xdim)[::-1] * factor  # in brightness temperature K
+    xs = np.arange(im.xdim)*im.psize/ehc.RADPERUAS
+    ys = np.arange(im.ydim)*im.psize/ehc.RADPERUAS
+
+    # TODO: test fiducial images with linear?
+    #iminterp = scipy.interpolate.interp2d(ys, xs, imarr, kind='cubic')
+    iminterp = scipy.interpolate.interp2d(ys, xs, imarr, kind='linear')
+    #iminterp = scipy.interpolate.RegularGridInterpolator((ys,xs),imarr)
     def objFunc(pos):
         (x0, y0) = pos
-        profiles = compute_ring_profile(im, x0, y0, nrays=nrays_search, nrs=nrs_search,
-                                        rmin=rmin, rmax=rmax, flux_norm=flux_norm)
-
-        mean, std = profiles.RingSize1
+        diameters = []
+        for j in range(nrays_search):
+            xxs = x0 - rs*np.sin(thetas[j])
+            yys = y0 + rs*np.cos(thetas[j])
+            prof = np.array([iminterp(xxs[i], yys[i])[0] for i in np.arange(len(rs))])
+            
+            args = np.argsort(prof)
+            pkpos = args[-1]
+            pk = rs[pkpos]
+            vpk = prof[pkpos]
+            if pkpos > 0 and pkpos < nrs_search-1:
+                vals = [prof[pkpos-1], prof[pkpos], prof[pkpos+1]]
+                pk, vpk = quad_interp_radius(pk, dr, vals)
+            
+            diameters.append(2*np.abs(pk))
+                    
+        # ring size
+        mean,std = (np.mean(diameters), np.std(diameters))
+        
         if mean < rmin_search or mean > rmax_search:
             return np.inf
         else:
@@ -795,7 +833,58 @@ def objFunc(pos):
 
     return res
 
-
+def FindProfile(im, blur=0, pol_profs=False,
+                imsize=IMSIZE, npix=NPIX, rmin=RMIN, rmax=RMAX, nrays=NRAYS, nrs=NRS,
+                rmin_search=RPRIOR_MIN, rmax_search=RPRIOR_MAX,
+                nrays_search=NRAYS_SEARCH, nrs_search=NRS_SEARCH,
+                thresh_search=THRESH, fov_search=FOVP_SEARCH, n_search=NSEARCH,
+                flux_norm=NORMFLUX,center=False):
+    """find the best ring profile for an image object and save results
+    """
+    
+    im_raw = im.copy()
+    # blur image if requested
+    if blur > 0:
+        im_raw = im_raw.blur_circ(blur*ehc.RADPERUAS, blur*ehc.RADPERUAS)
+
+    # center image and regrid to uniform pixel size and fox
+    if center:
+        im = di.center_core(im_raw) # TODO -- why isn't this working? 
+    else:
+        im = im_raw
+
+    im_search = im.regrid_image(imsize, npix)
+    im = im.regrid_image(imsize, npix)
+
+    # blur image if requested
+    # if blur > 0:
+    #    im_search = im_search.blur_circ(blur*ehc.RADPERUAS)
+    #    im = im.blur_circ(blur*ehc.RADPERUAS)
+
+    # blur and threshold image FOR SEARCH ONLY
+    # if blur==0:
+    #    im_search = im.blur_circ(BLUR_VALUE_MIN*ehc.RADPERUAS)
+    # else:
+    #    im_search = im.copy()
+
+    # threshold the search image to 5% of the maximum
+    im_search.imvec[im_search.imvec < thresh_search*np.max(im_search.imvec)] = 0
+
+    # find center
+    res = findCenter(im_search, rmin=rmin, rmax=rmax,
+                     rmin_search=rmin_search,  rmax_search=rmax_search,
+                     nrays_search=nrays_search, nrs_search=nrs_search,
+                     fov_search=fov_search, n_search=n_search, flux_norm=flux_norm)
+                     
+    # compute profiles using the original (regridded, flux centroid centered) image
+    print("compute profile")
+    pp = compute_ring_profile(im, res[0], res[1], nrs=nrs, nrays=nrays,
+                              rmin=rmin, rmax=rmax, flux_norm=flux_norm,
+                              pol_profs=pol_profs)
+    pp.calc_meanprof_and_stats()  
+    
+    return pp    
+                       
 def FindProfileSingle(imname, postprocdir,
                       save_files=False, blur=0, aipscc=False, tag='',
                       rerun=True, return_pp=True,
@@ -804,7 +893,7 @@ def FindProfileSingle(imname, postprocdir,
                       nrays_search=NRAYS_SEARCH, nrs_search=NRS_SEARCH,
                       thresh_search=THRESH, fov_search=FOVP_SEARCH, n_search=NSEARCH,
                       flux_norm=NORMFLUX,center=False):
-    """find the best ring profile for an image and save results
+    """find the best ring profile for an image fits file and save results
     """
 
     dirname = os.path.basename(os.path.dirname(imname))
@@ -816,51 +905,21 @@ def FindProfileSingle(imname, postprocdir,
     # print("nrays",nrays_search,"nrs",nrs_search,"fov",fov_search)
     with ploop.HiddenPrints():
 
+        # load image
         im_raw = load_image(imname, aipscc=aipscc)
 
-        # blur image if requested
-        if blur > 0:
-            im_raw = im_raw.blur_circ(blur*ehc.RADPERUAS, blur*ehc.RADPERUAS)
-
-        # center image and regrid to uniform pixel size and fox
-        if center:
-            im = di.center_core(im_raw) # TODO -- why isn't this working? 
-        else:
-            im = im_raw
-
-        im_search = im.regrid_image(imsize, npix)
-        im = im.regrid_image(imsize, npix)
-
-        # blur image if requested
-        # if blur > 0:
-        #    im_search = im_search.blur_circ(blur*ehc.RADPERUAS)
-        #    im = im.blur_circ(blur*ehc.RADPERUAS)
-
-        # blur and threshold image FOR SEARCH ONLY
-        # if blur==0:
-        #    im_search = im.blur_circ(BLUR_VALUE_MIN*ehc.RADPERUAS)
-        # else:
-        #    im_search = im.copy()
-
-        # threshold the search image to 5% of the maximum
-        im_search.imvec[im_search.imvec < thresh_search*np.max(im_search.imvec)] = 0
-
-        # find center
-        res = findCenter(im_search, rmin=rmin, rmax=rmax,
-                         rmin_search=rmin_search,  rmax_search=rmax_search,
+        # calculate profile
+        pp = FindProfile(im, blur=blur, 
+                         imsize=imsize, npix=npix, rmin=rmin, rmax=rmax, nrays=nrays, nrs=nrs,
+                         rmin_search=rmin_search, rmax_search=rmax_search,
                          nrays_search=nrays_search, nrs_search=nrs_search,
-                         fov_search=fov_search, n_search=n_search, flux_norm=flux_norm)
+                         thresh_search=thresh_search, fov_search=fov_search, n_search=n_search,
+                         flux_norm=flux_norm,center=center)
 
-        # compute profiles using the original (regridded, flux centroid centered) image
-        print("compute profile")
-        pp = compute_ring_profile(im, res[0], res[1], nrs=nrs, nrays=nrays,
-                                  rmin=rmin, rmax=rmax, flux_norm=flux_norm,
-                                  pol_profs=True)
-        pp.calc_meanprof_and_stats()
-        pp.imname = imname
 
-        print("save files")
+        # save files
         if save_files:
+            print("save files")
             dirname = os.path.basename(os.path.dirname(imname))
             if not os.path.exists(postprocdir + '/' + dirname):
                 subprocess.call(['mkdir', postprocdir + '/' + dirname])
@@ -963,7 +1022,7 @@ def FindProfiles(foldername, postprocdir, processes=-1,
                  thresh_search=THRESH, fov_search=FOVP_SEARCH, n_search=NSEARCH,
                  flux_norm=NORMFLUX
                  ):
-    """find profiles for all images  in a directory
+    """find profiles for all image fits files in a directory
     """
 
     foldername = os.path.abspath(foldername)
diff --git a/tutorials/space_vlbi_tutorial.ipynb b/tutorials/space_vlbi_tutorial.ipynb
index 7fdbbac4..b6db59e2 100644
--- a/tutorials/space_vlbi_tutorial.ipynb
+++ b/tutorials/space_vlbi_tutorial.ipynb
@@ -10,7 +10,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Welcome to eht-imaging! v 1.2.7 \n",
+      "Warning: No NFFT installed!\n",
+      "Welcome to eht-imaging! v 1.2.6a0 \n",
       "\n"
      ]
     }
@@ -450,7 +451,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -464,7 +465,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.3"
+   "version": "3.10.12"
   }
  },
  "nbformat": 4,

From 5ed3f71e1b378f7c7d641f4afbed1b6e027a4dd9 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Fri, 16 Feb 2024 12:36:12 -0500
Subject: [PATCH 11/15] minor fix to rex

---
 ehtim/features/rex.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ehtim/features/rex.py b/ehtim/features/rex.py
index aa3455c2..c12e727c 100644
--- a/ehtim/features/rex.py
+++ b/ehtim/features/rex.py
@@ -479,7 +479,7 @@ def plot_unwrapped(self, postprocdir=POSTPROCDIR, save_png=False,
         plt.axvline(x=rhloc, color=angcolor, linewidth=1, linestyle=':')
 
         # bright peak point
-        plt.plot([self.abspk_loc_ang], [self.abspk_loc_rad], 'kx', mew=2, ms=6, color=pkcolor)
+        plt.plot([self.abspk_loc_ang], [self.abspk_loc_rad], marker='x', mew=2, ms=6, color=pkcolor)
 
         # labels
         if xlabel:

From 2d15216911c7c6f8e2e7c8efc93338c19f4d7208 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Thu, 22 Feb 2024 15:42:19 -0500
Subject: [PATCH 12/15] fixed bug in chisqgrad_vvis

---
 ehtim/imaging/pol_imager_utils.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ehtim/imaging/pol_imager_utils.py b/ehtim/imaging/pol_imager_utils.py
index 27063965..e34f4d6e 100644
--- a/ehtim/imaging/pol_imager_utils.py
+++ b/ehtim/imaging/pol_imager_utils.py
@@ -965,7 +965,7 @@ def chisqgrad_vvis(imtuple, Amatrix, v, sigmap, pol_trans=True,pol_solve=(0,1,1)
     iimage = imtuple[0]
     vimage = make_v_image(imtuple, pol_trans)
     vsamples = np.dot(Amatrix, vimage)
-    pdiff = (v - vsamples) / (sigmav**2)
+    vdiff = (v - vsamples) / (sigmav**2)
     zeros =  np.zeros(len(iimage))
         
     if pol_trans:

From 4f9fc12850d949da1b620b0fe3d7e7b661478a60 Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Tue, 19 Mar 2024 23:46:01 -0400
Subject: [PATCH 13/15] fixed bug in orth_chi

---
 ehtim/image.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/ehtim/image.py b/ehtim/image.py
index c43b0d45..c0608186 100644
--- a/ehtim/image.py
+++ b/ehtim/image.py
@@ -769,10 +769,13 @@ def orth_chi(self):
         """
         im = self.copy()
         if im.polrep == 'stokes':
+            im.qvec *= -1
             im.uvec *= -1
         elif im.polrep == 'circ':
-            im.lrvec = np.conjugate(im.rlvec)
-            im.rlvec = np.conjugate(im.rlvec)
+            im.lrvec *= -1# np.conjugate(im.rlvec)
+            im.rlvec *= -1#np.conjugate(im.rlvec)
+            #im.lrvec = np.conjugate(im.rlvec)
+            #im.rlvec = np.conjugate(im.rlvec)
 
         return im
 

From f8714cc4a972177572b455fa7a0058c65314e5bd Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Tue, 19 Mar 2024 23:53:21 -0400
Subject: [PATCH 14/15] removed flip_chi

---
 ehtim/image.py | 19 -------------------
 ehtim/movie.py | 27 ++++-----------------------
 2 files changed, 4 insertions(+), 42 deletions(-)

diff --git a/ehtim/image.py b/ehtim/image.py
index c0608186..a40ef93a 100644
--- a/ehtim/image.py
+++ b/ehtim/image.py
@@ -740,25 +740,6 @@ def switch_polrep(self, polrep_out='stokes', pol_prim_out=None):
 
         return newim
 
-    def flip_chi(self):
-        """Flip between the different conventions for measuring the EVPA (E of N vs N of E).
-
-           Args:
-
-           Returns:
-               (Image): image with flipped EVPA
-        """
-
-        im = self.copy()
-        if im.polrep == 'stokes':
-            im.qvec *= -1
-
-        elif im.polrep == 'circ':
-            im.lrvec = -np.conjugate(im.lrvec)
-            im.rlvec = -np.conjugate(im.rlvec)
-
-        return im
-
     def orth_chi(self):
         """Rotate the EVPA 90 degrees
 
diff --git a/ehtim/movie.py b/ehtim/movie.py
index bd8f8ffb..d0855e15 100644
--- a/ehtim/movie.py
+++ b/ehtim/movie.py
@@ -708,25 +708,6 @@ def switch_polrep(self, polrep_out='stokes', pol_prim_out=None):
 
         return newmov
 
-    def flip_chi(self):
-        """Flip between the different conventions for measuring the EVPA (E of N vs N of E).
-
-           Args:
-
-           Returns:
-               (Image): movie with flipped EVPA
-        """
-
-        mov = self.copy()
-        if mov.polrep == 'stokes':
-            mov.qframes *= [-qvec for qvec in mov.qframes]
-
-        elif mov.polrep == 'circ':
-            mov.lrframes *= [-np.conjugate(lrvec) for lrvec in mov.lrframes]
-            mov.rlframes *= [-np.conjugate(rlvec) for rlvec in mov.rlframes]
-
-        return mov
-
     def orth_chi(self):
         """Rotate the EVPA 90 degrees
 
@@ -737,11 +718,11 @@ def orth_chi(self):
         """
         mov = self.copy()
         if mov.polrep == 'stokes':
-            mov.qframes *= [-uvec for uvec in mov.vframes]
-
+            mov.qframes *= -1
+            mov.uframes *= -1
         elif mov.polrep == 'circ':
-            mov.lrframes *= [np.conjugate(lrvec) for lrvec in mov.lrframes]
-            mov.rlframes *= [np.conjugate(rlvec) for rlvec in mov.rlframes]
+            mov.lrframes *= -1
+            mov.rlframes *= -1
 
         return mov
 

From 76d8bcc8288aaf13322a58544c9aed0f11f9935b Mon Sep 17 00:00:00 2001
From: Andrew Chael <achael@princeton.edu>
Date: Fri, 19 Apr 2024 18:12:09 -0400
Subject: [PATCH 15/15] updated README

---
 README.rst            | 26 +++++++++++++++-----------
 ehtim/features/rex.py | 19 +++++++++++--------
 ehtim/image.py        |  3 ++-
 setup.py              |  2 +-
 4 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/README.rst b/README.rst
index 018832f1..455c17cb 100644
--- a/README.rst
+++ b/README.rst
@@ -10,7 +10,7 @@ The package contains several primary classes for loading, simulating, and manipu
 Installation
 ------------
 
-The latest stable version (`1.2.7 <https://github.com/achael/eht-imaging/releases/tag/v1.2.7>`_) is available on `PyPi <https://pypi.org/project/ehtim/>`_. Simply install pip and run
+The latest stable version (`1.2.8 <https://github.com/achael/eht-imaging/releases/tag/v1.2.7>`_) is available on `PyPi <https://pypi.org/project/ehtim/>`_. Simply install pip and run
 
 .. code-block:: bash
 
@@ -86,16 +86,8 @@ Let us know if you use ehtim in your publication and we'll list it here!
 
 - First M87 Event Horizon Telescope Results IV: Imaging the Central Supermassive Black Hole, `EHTC et al. 2019 <https://arxiv.org/abs/1906.11241>`_
 
-- VLBI Imaging of black holes via second moment regularization, `Issaoun et al. 2019b <https://arxiv.org/pdf/1908.01296.pdf>`_
-
-- Using evolutionary algorithms to model relativistic jets: Application to NGC 1052, `Fromm et al. 2019 <https://arxiv.org/pdf/1904.00106.pdf>`_
-
 - EHT-HOPS Pipeline for Millimeter VLBI Data Reduction, `Blackburn et al. 2019 <https://arxiv.org/pdf/1903.08832>`_
 
-- Multi-wavelength torus-jet model for Sagittarius A*, `Vincent et al. 2019 <https://arxiv.org/pdf/1902.01175>`_
-
-- How to tell an accreting boson star from a black hole, `Olivares et al. 2020 <https://arxiv.org/abs/1809.08682>`_
-
 - Discriminating Accretion States via Rotational Symmetry in Simulated Polarimetric Images of M87, `Palumbo et al. 2020 <https://arxiv.org/pdf/2004.01751.pdf>`_
 
 - SYMBA: An end-to-end VLBI synthetic data generation pipeline, `Roelofs et al. 2020 <https://arxiv.org/pdf/2004.01161.pdf>`_
@@ -114,8 +106,6 @@ Let us know if you use ehtim in your publication and we'll list it here!
 
 - A D-term Modeling Code (DMC) for Simultaneous Calibration and Full-Stokes Imaging of VLBI Data, `Pesce et al. 2021 <https://iopscience.iop.org/article/10.3847/1538-3881/abe3f8/pdf>`_
 
-- Polarization Images of Accretion Flows around Supermassive BLack Holes: Imprints of Toroidal Field Structure, `Tsunetoe et al. 2021 <https://watermark.silverchair.com/psab054.pdf?token=AQECAHi208BE49Ooan9kkhW_Ercy7Dm3ZL_9Cf3qfKAc485ysgAAAsUwggLBBgkqhkiG9w0BBwagggKyMIICrgIBADCCAqcGCSqGSIb3DQEHATAeBglghkgBZQMEAS4wEQQMdrsOAaUsDGsDHa2cAgEQgIICeMLAC3MR9Ld7lYRP4iEip8FSTz3TTR4K_yaxhw9kPthLhZLq4Zxs8_b7EyY8BywyYn6jUVlNM1czBskta4icw9YOQf2WX-2SkBGlQo7EdpZmHStribHPOF3ZtF4YA1dWNfzrXMFSR-ZZZW9iAfUFhKhgsyc0AY1O0rJLIAvlYPBE8SEAFUpV4Ck2nV-j-u_lyqe3CZcNO_tNB4fdE1x1HwhVWb_rxyC6n13hJhCJI7U3UJ5Q2u6dNH2BS4SUzet3JZ9RvIr9GkkSRRfdp0EDwNw6aG9TpAf8B-Fu7oW_NI7w_Jvh8kZBGzhnHisZ8acBRoMwbdHMv3cHqEUY5SKcYXVYART-z0QY_MJgxCoa4KDPG6rHl52Vf-eXJaYCmL4Y7xVas_hyPeUNk9TbhPqz4c8kOceb_BTo5oC5AFnwIIKw8kWmvwL7ofkcYmsrTlo0zWtgJ1I6lU7S1wxgD2JzRDg4gtVFdIcapB8q6ZhWWcBEvmwZ9Ad39UbH-hi4VZC8-IvzbvHNqfaifGsw1yvI86uNSu-iMY5ce0vAcZijbkVpAsbkvKGD6wP_T6OczWzayk13gegLvV2wZImleSWNFKO6cOpQSTKy2TbChWuYITc_tW3wUK-QOhjsdoB4V7SvXk_9d-bvjvBflRqDEUN5P8Yj4hpDpJYty4nxGJ4K6IWkyDRt_EZ2k9SOuwgXRZXxWA4tfJvKzvab8sRFqh98EcFNqDyAs_RZt1IVDch9GVl8X1VEbdD7MSzmw04kB-5U0l8HfmgBZyXs_i2hHUKesh1oUShTLUGcx86HApZXjtA4tSJct5CD8fvk_Vim2i5xx1_xGnBt3k7Z>`_
-
 - Using space-VLBI to probe gravity around Sgr A*, `Fromm et al. 2021 <https://www.aanda.org/articles/aa/pdf/2021/05/aa37335-19.pdf>`_
 
 - Persistent Non-Gaussian Structure in the Image of Sagittarius A* at 86 GHz, `Issaoun et al. 2021 <https://iopscience.iop.org/article/10.3847/1538-4357/ac00b0/pdf>`_
@@ -128,6 +118,20 @@ Let us know if you use ehtim in your publication and we'll list it here!
 
 - Unravelling the Innermost Jet Structure of OJ 287 with the First GMVA+ALMA Observations, `Zhao et al. 2022 <https://arxiv.org/pdf/2205.00554.pdf>`_
 
+- First Sagittarius A* Event Horizon Telescope Results. III: Imaging of the Galactic Center Supermassive Black Hole, `EHTC et al. 2022 <https://arxiv.org/pdf/2311.09479.pdf>`_
+
+- Resolving the Inner Parsec of the Blazar J1924-2914 with the Event Horizon Telescope, `Issaoun et al. 2022 <https://arxiv.org/pdf/2208.01662.pdf>`_
+
+- The Event Horizon Telescope Image of the Quasar NRAO 530, `Jorstad et al. 2023 <https://arxiv.org/pdf/2302.04622.pdf>`_
+
+- First M87 Event Horizon Telescope Results. IX. Detection of Near-horizon Circular Polarization, `EHTC et al. 2023 <https://arxiv.org/pdf/2311.10976.pdf>`_
+
+- Filamentary structures as the origin of blazar jet radio variability, `Fuentes et al. 2023 <https://arxiv.org/pdf/2311.01861.pdf>`_
+
+- The persistent shadow of the supermassive black hole of M 87. I. Observations, calibration, imaging, and analysis, `EHTC et al. 2023 <https://ui.adsabs.harvard.edu/abs/2024A%26A...681A..79E/abstract>`_
+
+- Parsec-scale evolution of the gigahertz-peaked spectrum quasar PKS 0858-279, `Kosogorov et al. 2024 <https://arxiv.org/pdf/2401.03603.pdf>`_
+
 oifits Documentation
 --------------------
 
diff --git a/ehtim/features/rex.py b/ehtim/features/rex.py
index c12e727c..62fafd31 100644
--- a/ehtim/features/rex.py
+++ b/ehtim/features/rex.py
@@ -75,7 +75,8 @@
 
 class Profiles(object):
 
-    def __init__(self, im, x0, y0, profs, thetas, rmin=RMIN, rmax=RMAX, flux_norm=NORMFLUX,
+    def __init__(self, im, x0, y0, profs, thetas, rmin=RMIN, rmax=RMAX, 
+                 interptype='cubic',flux_norm=NORMFLUX,
                  profsQ=[], profsU=[]):
 
         self.x0 = x0
@@ -103,7 +104,7 @@ def __init__(self, im, x0, y0, profs, thetas, rmin=RMIN, rmax=RMAX, flux_norm=NO
 
         self.xs = np.arange(im.xdim)*im.psize/ehc.RADPERUAS
         self.ys = np.arange(im.ydim)*im.psize/ehc.RADPERUAS
-        self.interp = scipy.interpolate.interp2d(self.ys, self.xs, self.imarr, kind='cubic')
+        self.interp = scipy.interpolate.interp2d(self.ys, self.xs, self.imarr, kind=interptype)
 
         self.profiles = np.array(profs)
         self.profilesQ = np.array(profsQ)
@@ -709,7 +710,8 @@ def quad_interp_radius(r_max, dr, val_list):
 
 def compute_ring_profile(im, x0, y0, title="",
                          nrays=NRAYS, nrs=NRS, rmin=RMIN, rmax=RMAX,
-                         flux_norm=NORMFLUX, pol_profs=False):
+                         flux_norm=NORMFLUX, pol_profs=False,
+                         interptype='cubic'):
     """compute a ring profile  given a center location
     """
 
@@ -722,7 +724,7 @@ def compute_ring_profile(im, x0, y0, title="",
     ys = np.arange(im.ydim)*im.psize/ehc.RADPERUAS
 
     # TODO: test fiducial images with linear?
-    interp = scipy.interpolate.interp2d(ys, xs, imarr, kind='cubic')
+    interp = scipy.interpolate.interp2d(ys, xs, imarr, kind=interptype)
 
     def ringVals(theta):
         xxs = x0 - rs*np.sin(theta)
@@ -742,8 +744,8 @@ def ringVals(theta):
     if len(im.qvec) > 0 and len(im.uvec > 0) and pol_profs:
         qarr = im.qvec.reshape(im.ydim, im.xdim)[::-1] * factor  # in brightness temperature K
         uarr = im.uvec.reshape(im.ydim, im.xdim)[::-1] * factor  # in brightness temperature K
-        interpQ = scipy.interpolate.interp2d(ys, xs, qarr, kind='cubic')
-        interpU = scipy.interpolate.interp2d(ys, xs, uarr, kind='cubic')
+        interpQ = scipy.interpolate.interp2d(ys, xs, qarr, kind=interptype)
+        interpU = scipy.interpolate.interp2d(ys, xs, uarr, kind=interptype)
 
         def ringValsQ(theta):
             xxs = x0 - rs*np.sin(theta)
@@ -765,8 +767,9 @@ def ringValsU(theta):
             valsU = ringValsU(thetas[j])
             profsU.append(valsU)
 
-    profiles = Profiles(im, x0, y0, profs, thetas, rmin=rmin, rmax=rmax, flux_norm=flux_norm,
-                        profsQ=profsQ, profsU=profsU)
+    
+    profiles = Profiles(im, x0, y0, profs, thetas, rmin=rmin, rmax=rmax, interptype=interptype,
+                        flux_norm=flux_norm,profsQ=profsQ, profsU=profsU)
 
     return profiles
 
diff --git a/ehtim/image.py b/ehtim/image.py
index a40ef93a..90e98664 100644
--- a/ehtim/image.py
+++ b/ehtim/image.py
@@ -2563,7 +2563,8 @@ def observe(self, array, tint, tadv, tstart, tstop, bw,
                stabilize_scan_phase (bool): if True, random phase errors are constant over scans
                stabilize_scan_amp (bool): if True, random amplitude errors are constant over scans
                neggains (bool): if True, force the applied gains to be <1
-
+               
+               tau (float): the base opacity at all sites, or a dict giving one opacity per site
                taup (float): the fractional std. dev. of the random error on the opacities
                gainp (float): the fractional std. dev. of the random error on the gains
                               or a dict giving one std. dev. per site
diff --git a/setup.py b/setup.py
index 6df6362c..73b50c19 100755
--- a/setup.py
+++ b/setup.py
@@ -7,7 +7,7 @@ def read(fname):
 if __name__ == "__main__":
     setup(name="ehtim",
 
-          version = "1.2.7",
+          version = "1.2.8",
 
           author = "Andrew Chael",
           author_email = "achael@princeton.edu",