scatterbrane 0.1.0__tar.gz

scatterbrane-0.1.0/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) <2015> <Katherine Rosenfeld and Michael Johnson>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

scatterbrane-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: scatterbrane
+Version: 0.1.0
+Summary: A python module to simulate the effect of anisotropic scattering on astrophysical images.
+Author-email: Katherine Rosenfeld <krosenf@gmail.com>
+License-Expression: MIT
+Project-URL: Documentation, http://krosenfeld.github.io/scatterbrane/
+Keywords: scattering,astronomy,EHT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: astropy
+Requires-Dist: imageio
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file
+
+scatterbrane
+============
+
+A python module for adding realistic scattering to astronomical images.  This version
+represents a very early release so please submit a pull request if you have trouble or
+need help for your application.
+
+For installation instructions and help getting started please see `the documentation <http://krosenfeld.github.io/scatterbrane/>`_.
+
+Installation
+------------
+
+This project now uses ``pyproject.toml`` and `uv <https://docs.astral.sh/uv/>`_ for dependency management.
+
+Install the package and its runtime dependencies with:
+
+.. code-block:: bash
+
+   uv sync
+
+Install the release and development tooling with:
+
+.. code-block:: bash
+
+   uv sync --group dev
+
+Release workflow
+----------------
+
+Version management is handled with ``bump-my-version``. To create a new tagged release:
+
+.. code-block:: bash
+
+   uv run bump-my-version bump patch
+
+This updates the package version, creates a commit, and creates a ``vX.Y.Z`` git tag. Pushing that tag to GitHub triggers the publish workflow for PyPI.
+
+Reference
+---------
+
+`Johnson, M. D., & Gwinn, C. R. 2015, ApJ, 805, 180  <http://adsabs.harvard.edu/abs/2015ApJ...805..180J>`_

scatterbrane-0.1.0/README.rst

@@ -0,0 +1,41 @@
+scatterbrane
+============
+
+A python module for adding realistic scattering to astronomical images.  This version
+represents a very early release so please submit a pull request if you have trouble or
+need help for your application.
+
+For installation instructions and help getting started please see `the documentation <http://krosenfeld.github.io/scatterbrane/>`_.
+
+Installation
+------------
+
+This project now uses ``pyproject.toml`` and `uv <https://docs.astral.sh/uv/>`_ for dependency management.
+
+Install the package and its runtime dependencies with:
+
+.. code-block:: bash
+
+   uv sync
+
+Install the release and development tooling with:
+
+.. code-block:: bash
+
+   uv sync --group dev
+
+Release workflow
+----------------
+
+Version management is handled with ``bump-my-version``. To create a new tagged release:
+
+.. code-block:: bash
+
+   uv run bump-my-version bump patch
+
+This updates the package version, creates a commit, and creates a ``vX.Y.Z`` git tag. Pushing that tag to GitHub triggers the publish workflow for PyPI.
+
+Reference
+---------
+
+`Johnson, M. D., & Gwinn, C. R. 2015, ApJ, 805, 180  <http://adsabs.harvard.edu/abs/2015ApJ...805..180J>`_

scatterbrane-0.1.0/pyproject.toml

@@ -0,0 +1,71 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "scatterbrane"
+dynamic = ["version"]
+description = "A python module to simulate the effect of anisotropic scattering on astrophysical images."
+readme = "README.rst"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Katherine Rosenfeld", email = "krosenf@gmail.com" },
+]
+keywords = ["scattering", "astronomy", "EHT"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Topic :: Scientific/Engineering :: Astronomy",
+]
+dependencies = [
+  "astropy",
+  "imageio",
+  "matplotlib",
+  "numpy",
+  "scipy",
+]
+
+[project.urls]
+Documentation = "http://krosenfeld.github.io/scatterbrane/"
+
+[dependency-groups]
+dev = [
+  "bump-my-version",
+  "build",
+]
+docs = [
+  "sphinx",
+  "sphinx-rtd-theme",
+]
+
+[tool.setuptools]
+packages = ["scatterbrane"]
+
+[tool.setuptools.dynamic]
+version = { attr = "scatterbrane.__version__" }
+
+[tool.bumpversion]
+current_version = "0.1.0"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+allow_dirty = false
+commit = true
+tag = true
+sign_tags = false
+tag_name = "v{new_version}"
+tag_message = "Release {new_version}"
+message = "Bump version: {current_version} -> {new_version}"
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+
+[[tool.bumpversion.files]]
+filename = "scatterbrane/__init__.py"

scatterbrane-0.1.0/scatterbrane/__init__.py

@@ -0,0 +1,4 @@
+__version__ = "0.1.0"
+
+from .brane import Brane
+from .tracks import Target

scatterbrane-0.1.0/scatterbrane/brane.py

@@ -0,0 +1,481 @@
+"""
+.. module:: brane 
+    :platform: Unix
+    :synopsis: Simulate effect of anisotropic scattering.
+
+.. moduleauthor:: Katherine Rosenfeld <krosenf@gmail.com>
+.. moduleauthor:: Michael Johnson
+
+Default settings are appropriate for Sgr A*
+
+Resources:
+Bower et al. (2004, 2006)
+
+"""
+
+from __future__ import print_function
+
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.interpolate import RectBivariateSpline
+from scipy.ndimage.filters import gaussian_filter
+from scipy.ndimage.interpolation import zoom,rotate
+from numpy import (pi,sqrt,log,sin,cos,exp,ceil,arange,
+                  min,abs,ones,radians,dot,transpose,
+                  zeros_like,clip,empty,empty,empty_like,reshape)
+from numpy.fft import fft2,fftfreq
+from astropy.constants import au,pc
+from astropy import units
+import logging
+from scatterbrane import utilities
+
+__all__ = ["Brane"]
+
+class Brane(object):
+  """
+  Scattering simulation object.
+
+  :param model: ``(n, n)``
+    Numpy array of the source image.
+  :param dx: scalar 
+    Resolution element of model in uas.
+  :param nphi: (optional) ``(2, )`` or scalar
+    Number of pixels in a screen.  This may be a tuple specifying the dimensions of a rectangular screen.
+  :param screen_res: (optional) scalar
+    Size of a screen pixel in units of :math:`R_0`.
+  :param wavelength: (optional) scalar
+    Observing wavelength in meters.
+  :param dpc: (optional) scalar
+    Observer-Source distance in parsecs.
+  :param rpc: (optional) scalar
+    Observer-Scatterer distance in parsecs.
+  :param r0: (optional) scalar
+    Phase coherence length along major axis as preset string or in km.
+  :param r_outer: (optional) scalar
+    Outer scale of turbulence in units of :math:`R_0`.
+  :param r_inner: (optional) scalar
+    Inner scale of turbulence in units of :math:`R_0`.
+  :param alpha: (optional) string or scalar
+    Preset string or float to set power-law index for tubulence scaling (e.g., Kolmogorov has :math:`\\alpha= 5/3`)
+  :param anisotropy: (optional) scalar
+    Anisotropy for screen is the EW / NS elongation.
+  :param pa: (optional) scalar
+    Orientation of kernel's major axis, East of North, in degrees.
+  :param live_dangerously: (optional) bool
+    Skip the parameter checks?
+  :param think_positive: (optional) bool
+    Should we enforce that the source image has no negative pixel values?
+
+  :returns: An instance of a scattering simulation.
+
+  :Example:
+
+  .. code-block:: python
+
+    s = Brane(m,dx,nphi=2**12,screen_res=5.,wavelength=3.0e-3,dpc=8.4e3,rpc=5.8e3)
+
+  where ``s`` is the class instance, ``m`` is the image array, ``nphi`` is the number of screen pixels,
+  ``wavelength`` is the observing wavelength.
+
+  .. note:: :math:`R_0` is the phase coherence length and Sgr A* defaults are from Bower et al. (2006).
+  """
+
+  def __init__(self,model,dx,nphi=2**12,screen_res=2,\
+               wavelength=1.3e-3,dpc=8400,rpc=5800,r0 = 'sgra',\
+               r_outer=10000000,r_inner=12,alpha='kolmogorov',\
+               anisotropy=2.045,pa=78,match_screen_res=False,live_dangerously=False,think_positive=False):
+
+    # set initial members
+    self.logger = logging.getLogger(self.__class__.__name__)
+    self.live_dangerously = live_dangerously
+    self.think_positive = think_positive
+
+    self.wavelength = wavelength*1e-3          # observing wavelength in km
+    self.dpc = float(dpc)                      # earth-source distance in pc
+    self.rpc = float(rpc)                      # R: source-scatterer distance in pc
+    self.d   = self.dpc - self.rpc             # D: earth-scatterer distance in pc
+    self.m   = self.d/self.rpc                 # magnification factor (D/R)
+    if r0 == 'sgra':
+        # major axis (EW) phase coherence length in km
+        self.r0  = 3136.67*(1.3e-6/self.wavelength)
+    else:
+        try:
+            self.r0 = float(r0)
+        except:
+            raise ValueError('Bad value for r0')
+    self.anisotropy = anisotropy               # anisotropy for screen = (EW / NS elongation)
+    self.pa = pa                               # orientation of major axis, E of N (or CCW of +y)
+
+    # Fresnel scale in km
+    self.rf = sqrt(self.dpc*pc.to(units.km).value / (2*pi / self.wavelength) * self.m / (1+self.m)**2)
+
+    # compute pixel scale for image
+    if match_screen_res:
+      self.ips = 1
+      self.screen_dx = screen_res * self.r0
+    else:
+      self.screen_dx = screen_res * self.r0                     # size of a screen pixel in km   
+      self.ips = int(ceil(1e-6*dx*self.d*au.to(units.km).value/self.screen_dx)) # image pixel / screen pixel
+
+    # image arrays
+    self.dx = 1e6 * self.ips * (self.screen_dx / (au.to(units.km).value * self.d))  # image pixel scale in uas
+    self.nx = int(ceil(model.shape[-1] * dx / self.dx))          # number of image pixels
+    self.model = model                                           # source model
+    self.model_dx = dx                                           # source model resolution
+    self.iss  = np.array([],dtype=np.float64)                    # scattered image
+    self.isrc = np.array([],dtype=np.float64)                    # source image at same scale as scattered image
+
+    # screen parameters
+    if type(nphi) == int:
+        self.nphi = (nphi,nphi)                                  # size of screen array
+    else:
+        self.nphi = nphi
+    self.nphi = np.asarray(self.nphi)
+    self.r_inner = r_inner                                       # inner turbulence scale in r0
+    self.r_outer = r_outer                                       # outer turbulence scale in r0
+    #self.qmax = 1.*screen_res/r_inner                            # 1 / inner turbulence scale in pix
+    #self.qmin = 1.*screen_res/r_outer                            # 1 / outer tubulence scale in pix
+    if alpha == 'kolmogorov':
+        self.alpha = 5./3
+    else:
+        try:
+            self.alpha = float(alpha)
+        except:
+            raise ValueError('Bad value for alpha')
+
+    # use logger to report
+    self.chatter()
+
+    # includes sanity check
+    self.setModel(self.model,self.model_dx,think_positive=self.think_positive)
+
+  def _checkSanity(self):
+    '''
+    Check that screen parameters are consistent.
+    '''
+
+    # sanity check: is screen large enough?
+    assert np.ceil(self.nx*self.ips)+2 < np.min(self.nphi), \
+          "screen is not large enough: {0} > {1}".\
+          format(int(np.ceil(self.ips*self.nx)+2),np.min(self.nphi))
+
+    # sanity check: is image square?
+    assert self.model.shape[-1] == self.model.shape[-2], \
+        'source image must be square'
+
+    # sanity check: integer number of screen pixels / image pixel?
+    assert self.ips % 1 == 0, 'image/screen pixels should be an integer'
+
+    # is inner turbulence scale larger than r0?
+    #assert 1./self.qmax > self.r0/self.screen_dx, 'turbulence inner scale < r0'
+    assert self.r_inner > 1., 'turbulence inner scale < r0'
+
+    # check image smoothness
+    V = fft2(self.isrc)
+    freq = fftfreq(self.nx,d=self.dx*radians(1.)/(3600*1e6))
+    u = dot(transpose([np.ones(self.nx)]),[freq])
+    v = dot(transpose([freq]),[ones(self.nx)])
+    try:
+        if max(abs(V[sqrt(u*u+v*v) > (1.+self.m)*self.r_inner*self.r0/self.wavelength])) / self.isrc.sum() > 0.01:
+         self.logger.warning('image is not smooth enough:  {0:g} > 0.01'.format(max(abs(V[sqrt(u*u+v*v) > (1.+self.m)*self.r_inner*self.r0/self.wavelength])) / self.isrc.sum()))
+    except ValueError:
+        self.logger.warning('r_inner is too large to test smoothness')
+
+    # is screen pixel smaller than inner turbulence scale?
+    #assert 1./self.qmax >= 1, 'screen pixel > turbulence inner scale'
+    assert self.r_inner*self.r0/self.screen_dx >= 1, 'screen pixel > turbulence inner scale'
+
+    if (self.rf*self.rf/self.r0/(self.ips*self.screen_dx) < 3):
+      self.logger.warning('WARNING: image resolution is approaching Refractive scale')
+
+  def chatter(self):
+    '''
+    Print information about the current scattering simulation where many parameters are cast as integers.
+    '''
+        
+    fmt = "{0:32s} :: "
+    self.logger.info( (fmt + "{1:g}").format('Observing wavelength [mm]',1e6*self.wavelength) )
+    self.logger.info( (fmt + "{1:d}").format('Phase coherence length [km]',int(self.r0))           )
+    self.logger.info( (fmt + "{1:d}").format('Fresnel scale [km]',int(self.rf))                    )
+    self.logger.info( (fmt + "{1:d}").format('Refractive scale [km]',int(self.rf**2/self.r0))     )
+    #self.logger.info( (fmt + "{1:d}").format('Inner turbulence scale [km]',int(self.screen_dx/self.qmax)))
+    self.logger.info( (fmt + "{1:d}").format('Inner turbulence scale [km]',int(self.r_inner*self.r0)))
+    self.logger.info( (fmt + "{1:d}").format('Screen resolution [km]',int(self.screen_dx)))
+    self.logger.info( (fmt + "{1:d} {2:d}").format('Linear filling factor [%,%]',*map(int,100.*self.nx*self.ips/self.nphi)) )
+    self.logger.info( (fmt + "{1:g}").format('Image resolution [uas]',self.dx))
+    self.logger.info( (fmt + "{1:d}").format('Image size',int(self.nx)))
+
+  def _generateEmptyScreen(self):
+    '''
+    Create an empty screen.
+    '''
+    if not self.live_dangerously: self._checkSanity()
+    self.phi = np.zeros(self.nphi)
+
+  def setModel(self,model,dx,think_positive=False):
+    '''
+    Set new model for the source.
+
+    :param model: ``(n, n)``
+      Numpy image array.
+    :param dx: scalar
+      Pixel size in microarcseconds.
+    :param think_positive: (optional) bool
+        Should we enforce that the source image has no negative pixel values?
+    '''
+    self.nx = int(ceil(model.shape[-1] * dx / self.dx))          # number of image pixels
+    self.model = model                                           # source model
+    self.model_dx = dx                                           # source model resolution
+
+    # load source image that has size and resolution compatible with the screen.
+    self.isrc = np.empty(2*(self.nx,))
+    self.think_positive = think_positive
+
+    M = self.model.shape[1]       # size of original image array
+    f_img = RectBivariateSpline(self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\
+                                self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\
+                                self.model)
+
+    xx_,yy_ = np.meshgrid((np.arange(self.nx) - 0.5*(self.nx-1)),\
+                          (np.arange(self.nx) - 0.5*(self.nx-1)),indexing='xy')
+
+      
+    m  = f_img.ev(yy_.flatten(),xx_.flatten()).reshape(2*(self.nx,))
+    self.isrc  = m * (self.dx/self.model_dx)**2     # rescale for change in pixel size
+
+    if self.think_positive:
+      self.isrc[self.isrc < 0] = 0
+
+    if not self.live_dangerously: self._checkSanity()
+
+  def generatePhases(self,seed=None,save_phi=None):
+    '''
+    Generate screen phases.
+
+    :param seed: (optional) scalar
+      Seed for random number generator
+    :param save_phi: (optional) string 
+      To save the screen, set this to the filename.
+    '''
+
+    # check setup
+    if not self.live_dangerously: self._checkSanity()
+
+    # seed the generator
+    if seed != None:
+      np.random.seed(seed=seed)
+
+    # include anisotropy
+    qx2 = dot(transpose([np.ones(self.nphi[0])]),[np.fft.rfftfreq(self.nphi[1])**2])
+    qy2 = dot(transpose([np.fft.fftfreq(self.nphi[0])**2*self.anisotropy**2]),[np.ones(self.nphi[1]//2+1)])
+    rr = qx2+qy2
+    rr[0,0] = 0.02  # arbitrary normalization
+
+    # generating phases with given power spectrum
+    size = rr.shape 
+    qmax2 = (self.r_inner*self.r0/self.screen_dx)**-2
+    qmin2 = (self.r_outer*self.r0/self.screen_dx)**-2
+    phi_t = (1/sqrt(2) * sqrt(exp(-1./qmax2*rr) * (rr + qmin2)**(-0.5*(self.alpha+2.)))) \
+            * (np.random.normal(size=size) + 1j * np.random.normal(size=size))
+
+    # calculate phi
+    self.phi = np.fft.irfft2(phi_t)
+
+    # normalize structure function 
+    nrm = self.screen_dx/(self.r0*sqrt(self._getPhi(1,0)))
+    self.phi *= nrm
+
+    # save screen
+    if save_phi != None:
+      np.save(save_phi,self.phi)
+
+  def _checkDPhi(self,nLag=5):
+    '''
+    Report the phase structure function for various lags.
+
+    :param nLag: (optional) int
+      Number of lags to report starting with 0.
+    '''
+    self.logger.info( "\nEstimates of the phase structure function at various lags:")
+    for i in np.arange(nLag):
+      self.logger.info( "lag ",i, self._getPhi(i,0), self._getPhi(0,i), self._getPhi(i,i))
+
+  def _getPhi(self,lag_x,lag_y):
+    '''
+    Empirical estimate for phase structure function
+
+    :param lag_x: int 
+      Screen pixels to lag in x direction.
+    :param lag_y: int
+      Screen pixels to lag in y direction.
+    '''
+    assert (lag_x < self.nphi[0]) and (lag_x < self.nphi[1]), "lag choice larger than screen array"
+    # Y,X
+    if (lag_x == 0 and lag_y == 0):
+      return 0.
+    if (lag_x == 0):
+      return 1.*((self.phi[:-1*lag_y,:] - self.phi[lag_y:,:])**2).sum()/(self.nphi[0]*(self.nphi[1]-lag_y))
+    if (lag_y == 0):
+      return 1.*((self.phi[:,:-1*lag_x] - self.phi[:,lag_x:])**2).sum()/((self.nphi[0]-lag_x)*self.nphi[1])
+    else:
+      return (1.*((self.phi[:-1*lag_y,:-1*lag_x] - self.phi[lag_y:,lag_x:])**2).sum()/((self.nphi[1]-lag_y)*(self.nphi[0]-lag_x)))
+
+  def readScreen(self,filename):
+    '''
+    Read in screen phases from a file.
+
+    :param filename: string 
+      File containing the screen phases.
+    '''
+    self.phi =  np.fromfile(filename,dtype=np.float64).reshape(self.nphi)
+  
+  def _calculate_dphi(self,move_pix=0):
+    '''
+    Calculate the screen gradient.
+
+    :param move_pix: (optional) int 
+      Number of pixels to roll the screen (for time evolution).
+
+    :returns: ``(nx, nx)``, ``(nx, nx)`` 
+      numpy arrays containing the dx,dy components of the gradient vector.
+
+    .. note:: Includes factors of the Fresnel scale and the result is in units of the source image.
+    '''
+    ips = self.ips                  # number of screen pixels per image pixel
+                                    # -- when this != 1, some sinusoidal signal
+                                    # over time with period of image_resolution
+    nx  = self.nx                   # number of image pixels
+    rf  = self.rf / self.screen_dx  # Fresnel scale in screen pixels
+    assert move_pix < (self.nphi[1] - self.nx*self.ips), 'screen is not large enough'
+    dphi_x = (0.5 * rf * rf / ips ) * \
+            (self.phi[0:ips*nx:ips,2+move_pix:ips*nx+2+move_pix:ips] -
+             self.phi[0:ips*nx:ips,0+move_pix:ips*nx+move_pix  :ips])
+    dphi_y = (0.5 * rf * rf  / ips ) * \
+            (self.phi[2:ips*nx+2:ips,0+move_pix:ips*nx+move_pix:ips] -
+             self.phi[0:ips*nx  :ips,0+move_pix:ips*nx+move_pix:ips])
+
+    self.logger.debug('{0:d},{1:d}'.format(*dphi_x.shape))
+    return dphi_x,dphi_y
+  
+  def scatter(self,move_pix=0,scale=1):
+    '''
+    Generate the scattered image which is stored in the ``iss`` member.
+
+    :param move_pix: (optional) int 
+      Number of pixels to roll the screen (for time evolution).
+    :param scale: (optional) scalar
+      Scale factor for gradient.  To simulate the scattering effect at another 
+      wavelength this is (lambda_new/lambda_old)**2
+    '''
+
+    M = self.model.shape[-1]       # size of original image array
+    N = self.nx                    # size of output image array
+
+    #if not self.live_dangerously: self._checkSanity()
+
+    # calculate phase gradient
+    dphi_x,dphi_y = self._calculate_dphi(move_pix=move_pix)
+
+    if scale != 1:
+        dphi_x *= scale
+        dphi_y *= scale
+
+    xx_,yy = np.meshgrid((np.arange(N) - 0.5*(N-1)),\
+                         (np.arange(N) - 0.5*(N-1)),indexing='xy')
+
+    # check whether we care about PA of scattering kernel
+    if self.pa != None:
+      f_model = RectBivariateSpline(self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\
+                                    self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\
+                                    self.model)
+
+      # apply rotation
+      theta = -(90 * pi / 180) + np.radians(self.pa)     # rotate CW 90 deg, then CCW by PA
+      xx_ += dphi_x
+      yy  += dphi_y
+      xx = cos(theta)*xx_ - sin(theta)*yy
+      yy = sin(theta)*xx_ + cos(theta)*yy
+      self.iss  = f_model.ev(yy.flatten(),xx.flatten()).reshape((self.nx,self.nx))
+
+      # rotate back and clip for positive values for I
+      if self.think_positive:
+          self.iss  = clip(rotate(self.iss,-1*theta/np.pi*180,reshape=False),a_min=0,a_max=1e30) * (self.dx/self.model_dx)**2
+      else:
+          self.iss  = rotate(self.iss,-1*theta/np.pi*180,reshape=False) * (self.dx/self.model_dx)**2
+
+    # otherwise do a faster lookup rather than the expensive interpolation.
+    else:
+      yyi = np.rint((yy+dphi_y+self.nx/2)).astype(np.int) % self.nx
+      xxi = np.rint((xx_+dphi_x+self.nx/2)).astype(np.int) % self.nx
+      if self.think_positive:
+        self.iss = clip(self.isrc[yyi,xxi],a_min=0,a_max=1e30)
+      else:
+        self.iss = self.isrc[yyi,xxi]
+
+
+  def _load_src(self,stokes=(0,),think_positive=True):
+    '''
+    Load the source image from model (changes size and resolution to match the screen).
+
+    :param stokes: (optional) tuple 
+      Stokes parameters to consider. 
+    :param think_positive: (optional) bool
+        Should we enforce that the source image has no negative pixel values?
+    '''
+    M = self.model.shape[1]       # size of original image array
+    N = self.nx                   # size of output image array
+
+    if len(self.model.shape) > 2:
+      self.isrc = np.empty((self.model.shape[-1],N,N))
+    else:
+      self.isrc = np.empty((1,N,N))
+      self.model = np.reshape(self.model,(1,M,M))
+
+    for s in stokes:
+      f_img = RectBivariateSpline(self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\
+                                 self.model_dx/self.dx*(np.arange(M) - 0.5*(M-1)),\
+                                 self.model[s,:,:])
+
+      xx_,yy_ = np.meshgrid((np.arange(N) - 0.5*(N-1)),\
+                        (np.arange(N) - 0.5*(N-1)),indexing='xy')
+
+      
+      m  = f_img.ev(yy_.flatten(),xx_.flatten()).reshape((self.nx,self.nx))
+      res  = m * (self.dx/self.model_dx)**2     # rescale for change in pixel size
+
+      if s == 0 and think_positive:
+        res[res < 0] = 0
+
+      self.isrc[s,:,:]  = res 
+
+    self.model = np.squeeze(self.model)
+    self.isrc = np.squeeze(self.isrc)
+
+  def saveSettings(self,filename):
+    '''
+    Save screen settings to a file.
+
+    :param filename: string 
+      settings filename
+    '''
+    f = open(filename,"w")
+    f.write("wavelength \t {0}\n".format(self.wavelength)) 
+    f.write("dpc \t {0}\n".format(self.dpc))
+    f.write("rpc \t {0}\n".format(self.rpc))
+    f.write("d \t {0}\n".format(self.d))
+    f.write("m \t {0}\n".format(self.m))
+    f.write("r0 \t {0}\n".format(self.r0)) 
+    f.write("anisotropy \t {0}\n".format(self.anisotropy)) 
+    f.write("pa \t {0}\n".format(self.pa))
+    f.write("nphix \t {0}\n".format(self.nphi[0]))        # size of phase screen
+    f.write("nphiy \t {0}\n".format(self.nphi[1]))        # size of phase screen
+    f.write("screen_dx \t {0}\n".format(self.screen_dx))
+    f.write("rf \t {0}\n".format(self.rf))
+    f.write("ips \t {0}\n".format(self.ips))
+    f.write("dx \t {0}\n".format(self.dx))
+    f.write("nx \t {0}\n".format(self.nx))
+    f.write("qmax \t {0}\n".format(self.r_inner))        # inner turbulence scale in r0 
+    f.write("qmin \t {0}\n".format(self.r_outer))        # outer turbulence scale in r0 
+    #f.write("qmax \t {0}\n".format(self.qmax))        # 1./inner turbulence scale in screen pixels
+    #f.write("qmin \t {0}\n".format(self.qmin))        # 1./inner turbulence scale in screen pixels
+    f.close()

scatterbrane-0.1.0/scatterbrane/tracks.py

@@ -0,0 +1,397 @@
+"""
+.. module:: tracks
+    :platform: Unix
+    :synopsis: Lightweight module for generating visibilities and closure phases
+
+.. moduleauthor:: Katheirne Rosenfeld <krosenf@gmail.com>
+.. moduleauthor:: Michael Johnson
+
+"""
+
+from __future__ import print_function
+
+import itertools
+from numpy import (pi,array,cos,sin,cross,dot,asarray,linspace,sum,transpose,dot,exp,angle,
+                    newaxis,prod,flipud,arange,zeros,complex64,abs,radians)
+from numpy.fft import fftshift,fftfreq
+from numpy.linalg import norm
+import logging
+
+__all__ = ["Target"]
+
+class Target(object):
+  '''
+  Class for constructing visibility samples.
+
+  :param wavelength: (optional) 
+    Scalar wavelength in meters.
+  :param position: (optional) ``(2, )`` 
+    A tuple with right ascension and declination of the source in (hours, degrees) or the preset string "sgra".
+  :param obspos: (optional) 
+    A dictionary of observatories and their geocentric positions.
+  :param elevation_cuts: (optional) ``(2, )`` 
+    The upper and lower bound on the observing zenith angle. 
+
+  .. note:: The zenith angle cut corresponds to whether the site can observe the source.  As a result, for functions such as :func:`generateTracks`, the number of uv samples returned will be less than or equal to the number of samples set by the ``times`` argument.  To disable the zenith angle cut you can initialize :class:`Target` with ``zenith_cuts`` = ``[180.,0.]``.
+  '''
+
+  def __init__(self,wavelength=1.3e-3,position='sgra',obspos='eht',zenith_cuts=[75.,0.]):
+
+    if position=='sgra':
+      ra,dec = (17+45./60+40.0409/3600,-1*(29+28.118/3600))
+    else:
+      ra,dec = position
+
+    # observing settings
+    self.dec    = dec
+    self.ra     = ra 
+    self.wavelength = wavelength
+    self.cos_zenith_cuts = cos(radians(zenith_cuts))
+
+    # derived quantities
+    self.target_vec = array([cos(self.dec * pi / 180), 0., sin(self.dec * pi / 180)])
+    self.projU = cross([0.,0.,1.],self.target_vec)
+    self.projU /= norm(self.projU)
+    self.projV = -1.*cross(self.projU,self.target_vec)
+ 
+    # dictionary of observatories and their positions
+    l = self.wavelength # in meters
+    if obspos == 'eht':
+        self.obs = dict([("SMA",array([-5464523.400, -2493147.080, 2150611.750])/l),\
+                     ("SMT",array([-1828796.200, -5054406.800, 3427865.200])/l),\
+                     ("CARMA",array([-2397431.300, -4482018.900, 3843524.500])/l),\
+                     ("LMT",array([-768713.9637, -5988541.7982, 2063275.9472])/l),\
+                     ("ALMA",array([2225037.1851, -5441199.1620, -2479303.4629])/l),\
+                     ("PV",array([5088967.9000, -301681.6000, 3825015.8000])/l),\
+                     ("PDBI",array([4523998.40, 468045.240, 4460309.760])/l),\
+                     ("SPT",array([0.0, 0.0, -6359587.3])/l),\
+                     ("HAYSTACK",array([1492460, -4457299, 4296835])/l),\
+              ]) # in wavelengths
+    else:
+        self.obs = obspos
+        for k in self.obs.iterkeys():
+            self.obs[k] /= l
+
+  def sites(self,s):
+    '''
+    Look up geocentric positions of sites by their string keyword.
+
+    :param s: List of site keys.
+    
+    :returns: Array of site geocentric positions.
+    '''
+    return array([self.obs[s_] for s_ in s])
+
+  def _RR(self,v,theta):
+    '''
+    Rotates the vector v by angle theta.
+
+    :param v: A vector (x,y,z).
+    :param theta: Angle for CCW rotation in radians.
+
+    :returns: Rotated vector (x',y',z')
+    '''
+    return array([cos(theta)*v[0] - sin(theta)*v[1],\
+                  sin(theta)*v[0] + cos(theta)*v[1],\
+                  v[2]])
+
+  def _cosZenith(self,v,theta):
+    ''' 
+    :param v: ``(3, )`` vector.
+    :param theta: Scalar angle in radians.
+
+    :returns: cos(zenith angle) = sin(elevation)
+    '''
+    return dot(self._RR(v,theta),self.target_vec) / (norm(v) * norm(self.target_vec))
+
+
+  def _RRelevcut(self,v,theta):
+    '''
+    Does vector v pass the zenith angle cut?
+
+    :param v: ``(3, )`` vector
+    :param theta: Scalar angle in radians.
+    '''
+    if abs(self._cosZenith(v,theta)-0.5*sum(self.cos_zenith_cuts)) < 0.5*sum([-1,1]*self.cos_zenith_cuts):
+        return True
+    else:
+        return False
+    
+  def generateUV(self,site_pair,theta):
+    '''
+    Generate uv baseline.
+
+    :param site_pair: ``(2, 3)`` 
+      Geocentric (x,y,z) positions of two sites.
+    :param theta: scalar 
+      Angle in radians.
+
+    :returns: ``(2, )`` 
+      A uv point. 
+    '''
+    return array([dot(self._RR(site_pair[0],theta)-self._RR(site_pair[1],theta),self.projU),\
+                  dot(self._RR(site_pair[0],theta)-self._RR(site_pair[1],theta),self.projV)])
+
+  def hour(self,theta):
+    ''' 
+    Convert to UT time.
+
+    :param theta: ``(n, )`` vector of angles in radians.
+
+    :returns: ``(n, )`` vector of times in hours. 
+    '''
+    return (theta / (2. * pi) * 24. + self.ra) % 24
+
+  def theta(self,hour):
+    ''' 
+    Convert from UT to angle.
+
+    :param hour: ``(n, )`` 
+      Vector of times in hours.
+
+    :returns: ``(n, )`` 
+      Vector of angles in radians. 
+    '''
+    return ((hour - self.ra) / 24. * 2. * pi) % (2 * pi)
+
+  def _gst(self,hour):
+    return ((hour-12.) % 24.) - 12.
+
+  def generateTracks(self,sites,times=(0.,24.,int((24.-0.)*60./10.)),return_hour=False):
+    '''
+    Generates uv-samples where the sample rate is to be equally spaced in time. 
+    For instance, if you want samples spaced by 5 minutes ranging from 1 UT to 4 UT 
+    (non-inclusive) you would set ``times`` = ``(1, 4, int((4.-1.)*60./5.))``.  As 
+    another example, you would generate 128 samples separated by 10 seconds if 
+    ``times`` = ``(0., 128*10./3600, 128)``.
+
+    :param sites: ``(num_sites, 3)`` 
+      Numpy array of sites' geocentric positions.
+    :param times: (optional) ``(start, stop, num_samples)`` 
+      Tuple setting the spacing of the uv-samples in time.  The ``start`` and ``stop`` times should be in hours and in the range [0,24].  ``stop`` is non-inclusive.
+    :param return_hour: (optional) bool
+      Return hour of uv samples as second item to unpack.
+
+    :returns: ``(num_measurements, 2)`` 
+      Numpy array with uv samples where ``num_measurements`` :math:`\\leq` ``num_samples``. 
+
+    '''
+
+    times = linspace(times[0],times[1],num=times[2],endpoint=False)
+    uv = []
+    hr = []
+    for h in times:
+        theta = self.theta(h)
+        for baseline in itertools.combinations(sites,2):
+            if self._RRelevcut(baseline[0],theta) and self._RRelevcut(baseline[1],theta):
+                if return_hour:
+                    hr.append(h)
+                    hr.append(h)
+                uv.append(self.generateUV((baseline[0],baseline[1]),theta))
+                uv.append(self.generateUV((baseline[1],baseline[0]),theta))
+
+    if return_hour:
+        return (array(uv),array(hr))
+    else:
+        return asarray(uv)
+
+  def calculateCA(self,img,dx,uvQuadrangle):
+    ''' 
+    Calculate closure amplitudes for numpy arrays of 4 baselines: 
+
+    .. math::
+
+        A_{abcd} = \\frac{|V_{ab}||V_{cd}|}{|V_{ac}||V_{bd}|}
+
+    :param img: ``(n, n)`` 
+      Numpy image array. 
+    :param dx: scalar 
+      Pixel size of image in microarcseconds. 
+    :param uvQuadrangle: ``(num_measurements, 4, 2)`` 
+      The uv samples for which to calculate the closure amplitude. The baseline order along axis=1 should be (ab,cd,ac,bd).  
+
+    :returns: ``(num_measurements, )`` 
+      Closure amplitudes.
+    '''
+
+    # case we are only given one time sample
+    if len(uvQuadrangle.shape) == 2: uvQuadrangle = uvQuadrangle[newxais,:]
+
+    ca = []
+    for quad in uvQuadrangle:
+        v = array([ abs(self.FTElementFast(img,dx,t)) for t in quad ])
+        ca.append( v[0]*v[1]/(v[2]*v[3]) )
+    return asarray(ca)
+
+  def calculateCP(self,img,dx,uvTriangle):
+    ''' 
+    Calculate closure phases for numpy arrays of 3 baselines that should form a closed triangle:
+
+    .. math::
+
+        \\phi_{abc} = \\mathrm{arg}(V_{ab}V_{bc}V_{ca})
+
+    :param img: ``(n, n)`` 
+      Numpy image array. 
+    :param dx: scalar 
+      Pixel size of image in microarcseconds. 
+    :param uvTriangle: ``(num_measurements, 3, 2)`` 
+      The uv samples for which to calculate the closure phase.  The baseline order along axis=1 should be (ab,bc,ca).
+
+    :returns: ``(num_measurements, )`` 
+      Closure phases in radians.
+    '''
+
+    # case where we are only given one time sample
+    if len(uvTriangle.shape) == 2: uvTriangle = uvTriangle[newaxis,:]
+    
+    cp = []
+    for triang in uvTriangle:
+        v = [self.FTElementFast(img,dx,t) for t in triang]
+        cp.append(angle(prod(v)))
+
+    return asarray(cp)
+
+  def calculateBS(self,img,dx,uvTriangle):
+    ''' 
+    Calculate bispectrum for numpy arrays of 3 baselines that should form a closed triangle: 
+
+    .. math::
+
+        B_{abc} = V_{ab}V_{bc}V_{ca}
+
+    :param img: ``(n, n)`` 
+      Image array. 
+    :param dx: scalar 
+      Pixel size of image in microarcseconds. 
+    :param uvTriangle: ``(num_measurements, 3, 2)`` 
+      uv samples for which to calculate the bispectra.  The baseline order along axis=1 should be (ab,bc,ca).
+
+    :returns: ``(num_measurements, )`` 
+      Complex bispectra.
+    '''
+
+    # case where we are only given one time sample
+    if len(uvTriangle.shape) == 2: uvTriangle = uvTriangle[newaxis,:]
+    
+    bs = []
+    for triang in uvTriangle:
+        v = [self.FTElementFast(img,dx,t) for t in triang]
+        bs.append(prod(v))
+
+    return asarray(bs)
+
+  def generateQuadrilateralTracks(self,sites,times=(0.,24.,int((24.-0.)*60./10.)),return_hour=False):
+    '''
+    Generates a quadruplet of uv points for a quadrilateral (a,b,c,d) ensuring that all sites can see the source.  See the docstring for :func:`generateTracks` for notes about the sampling rate.
+
+    **Suggested usage:** Feed the generated `uv` samples to :func:`calculateCA` which will return the closure amplitude quantity.
+
+    :param sites: ``(4, 3)`` 
+      Array of geocentric positions for 4 sites (a,b,c,d).
+    :param times: (optional) ``(start, stop, num_samples)`` 
+      Tuple setting the spacing of the uv-samples in time.  The ``start`` and ``stop`` times should be in hours and in the range [0,24].  ``stop`` is non-inclusive.
+    :param return_hour: (optional) 
+      Return hour of uv samples as second item to unpack.
+
+    :returns: ``(num_measurements, 4, 2)`` 
+      Array where the order of the baselines along the first dimension (axis=1) is (ab, cd, ac, bd).
+    '''
+
+    assert len(sites) == 4, "sites should form a quadrilateral"
+    times = linspace(times[0],times[1],num=times[2],endpoint=False)
+    uv = []
+    hr = []
+    for h in times:
+        theta = self.theta(h)
+        # zenith cut
+        if self._RRelevcut(sites[0],theta) and \
+           self._RRelevcut(sites[1],theta) and \
+           self._RRelevcut(sites[2],theta) and \
+           self._RRelevcut(sites[3],theta):
+            quad = (self.generateUV((sites[0],sites[1]),theta),self.generateUV((sites[2],sites[3]),theta),\
+                    self.generateUV((sites[0],sites[2]),theta),self.generateUV((sites[1],sites[3]),theta))
+            uv.append(quad)
+            if return_hour: hr.append(h)
+
+    if return_hour:
+        return (array(uv),array(hr))
+    else:
+        return asarray(uv)
+
+  def generateTriangleTracks(self,sites,times=(0.,24.,int((24.-0.)*60./10.)),return_hour=False):
+    '''
+    Generates a triplet of uv points for a closed triangle of sites (a,b,c) ensuring that all sites can see the source.  
+    See the docstring for :func:`generateTracks` for notes about the sampling rate.
+
+    **Suggested usage:** Feed the generated UV samples to :func:`calculateBS` or :func:`calculateCP` to calculate closure phase or bispectrum quanities.
+
+    :param sites: ``(3, 3)`` 
+      Array of geocentric positions for 3 sites (a,b,c).
+    :param times: (optional) ``(start, stop, num_samples)`` 
+      Tuple setting the spacing of the uv-samples in time.  The ``start`` and ``stop`` times should be in hours and in the range [0,24].  ``stop`` is non-inclusive.
+    :param return_hour: (optional) 
+      Return hour of uv samples as second item to unpack.
+
+    :returns: ``(num_measurements, 3, 2)`` 
+      Array of uv points where the order of the baselines along the first dimension (axis=1) is (ab,bc,ca).
+    '''
+    assert len(sites) == 3, "sites should form a triangle"
+
+    times = linspace(times[0],times[1],num=times[2],endpoint=False)
+    uv = []
+    hr = []
+    for h in times:
+        theta = self.theta(h)
+        # zenith cut
+        if self._RRelevcut(sites[0],theta) and \
+           self._RRelevcut(sites[1],theta) and \
+           self._RRelevcut(sites[2],theta):
+            triang = array([ self.generateUV((sites[0],sites[1]),theta),\
+                            self.generateUV((sites[1],sites[2]),theta),\
+                            self.generateUV((sites[2],sites[0]),theta) ])
+            uv.append(triang)
+            if return_hour: hr.append(h)
+
+    if return_hour:
+        return (array(uv),array(hr))
+    else:
+        return asarray(uv)
+
+  def calculateVisibilities(self,img,dx,uv):
+    '''
+    Calculate complex visibilities.
+
+    :param img: Image array.
+    :param dx: Pixel size in microarcseconds.
+    :param uv: ``(num_measurements, 2)`` An array of `uv` samples with dimension.
+
+    :returns: ``(num_measurements, )`` Scalar complex visibilities.
+    '''
+
+    # case of only 1 uv point
+    if len(uv.shape) == 1: uv = uv[newaxis,:] 
+
+    num_samples = uv.shape[0]
+    V = zeros(num_samples,dtype=complex64)
+    for i in range(num_samples):
+        V[i] = self.FTElementFast(img,dx,uv[i,:])
+    return V
+
+  def FTElementFast(self,img,dx,baseline):
+    '''
+    Return complex visibility.
+
+    :param img: Image array.
+    :param dx: pixel size in microarcseconds.
+    :param baseline: (u,v) point in wavelengths.
+
+    :returns: complex visibility
+
+    '''
+    nx = img.shape[-1]
+    du = 3600.*1e6/(nx*dx*radians(1.))
+    ind = arange(nx)
+    return sum(img * dot(\
+             transpose([exp(-2*pi*1j/du/nx*baseline[1]*flipud(ind))]),\
+             [exp(-2*pi*1j/du/nx*baseline[0]*ind)]))

scatterbrane-0.1.0/scatterbrane/utilities.py

@@ -0,0 +1,190 @@
+
+"""
+.. module:: utilities
+    :platform: Unix
+    :synopsis: Helpful function for ScatterBrane
+
+.. moduleauthor:: Katherine Rosenfeld <krosenf@gmail.com>
+.. moduleauthor:: Michael Johnson
+
+"""
+from __future__ import print_function
+
+import numpy as np
+from scipy.interpolate import RectBivariateSpline
+from scipy.ndimage.filters import gaussian_filter
+from astropy.io import fits
+
+def smoothImage(img,dx,fwhm):
+    '''
+    Returns Image smoothed by a gaussian kernel.
+
+    :param img: ``(n, n)`` 
+      numpy array
+    :param dx: scalar 
+      Pixel scale in microarcseconds
+    :param fwhm: scalar
+      Gaussian full width at half maximum in microarcseconds
+    '''
+    return gaussian_filter(img,fwhm/(2*np.sqrt(np.log(4)))/dx)
+
+def getCoherenceLength(theta,wavelength=1.3e-3,magnification=0.448):
+    '''
+    :param theta: scalar
+        FWHM of scattering kernel at 1 cm in milli-arcseconds.
+    :param wavelength: (optional) scalar
+        Observing wavelength in meters
+    :param magnification: (optional) scalar
+        Magnification factor (scatterer-observer)/(source-scatterer).
+
+    :returns: scalar
+        Coherence length in km.
+    '''
+    #return (wavelength*1e-3)*np.sqrt(np.log(4))/(np.pi*np.sqrt(1+magnification)**2*np.radians(1e-3/3600*theta*(wavelength*1e2)**2))
+    return (wavelength*1e-3)*np.sqrt(np.log(4))/(np.pi*(1+magnification)*np.radians(1e-3/3600*theta*(wavelength*1e2)**2))
+
+def ensembleSmooth(img,dx,brane,return_kernel=False):
+    '''
+    Generates ensemble averaged image given scattering kernel parameters.
+
+    :param img: ``(n, n)`` 
+      numpy array
+    :param dx: scalar
+      Pixel scale in microarcseconds
+    :param brane: Brane object.
+    :param return_kernel: (optional) bool 
+      Return tuple with uv kernel (:func:`nump.fft.rfft2` format). See :func:`getUVKernel` for an alternate method. 
+    '''
+    nx = img.shape[0]
+
+    # scattering kernel parameters in wavelengths 
+    sigma_maj = brane.wavelength*np.sqrt(np.log(4)) / (np.pi*(1.+brane.m)*brane.r0) / (2*np.sqrt(np.log(4)))
+    sigma_min = sigma_maj / brane.anisotropy
+    v = np.dot(np.transpose([np.fft.fftfreq(nx,d=dx*np.radians(1.)/(3600*1e6))]),[np.ones(nx/2 + 1)])
+    u = np.dot(np.transpose([np.ones(nx)]),[np.fft.rfftfreq(nx,d=dx*np.radians(1.)/(3600*1e6))])
+
+    # rotate
+    if brane.pa != None:
+        theta = np.radians(90-brane.pa)
+    else:
+        theta = np.radians(0.)
+    u_ = np.cos(theta)*u - np.sin(theta)*v
+    v = np.sin(theta)*u + np.cos(theta)*v
+
+    # rotate
+    G = np.exp(-2*np.pi**2*(u_**2*sigma_maj**2 + v**2*sigma_min**2))
+    V = np.fft.rfft2(img)
+
+    if return_kernel:
+        return (np.fft.irfft2(V*G,s=img.shape),G)
+    else:
+        return np.fft.irfft2(V*G,s=img.shape)
+
+def getUVKernel(u,v,brane):
+    '''
+    Get ensemble kernel in visibility plane for specified uv points.  See func:`ensembleSmooth` for an althernate method.
+
+    :param u: ``(n, )`` 
+      Samples of u in units of wavelengths.
+    :param v: ``(n, )`` 
+      Samples of v in units of wavelengths. 
+    :param brane: Brane object 
+
+    :returns: ``(n, )`` Ensemble kernel complex visibility
+    '''
+    # scattering kernel parameters in wavelengths 
+    sigma_maj = brane.wavelength*np.sqrt(np.log(4)) / (np.pi*(1.+brane.m)*brane.r0) / (2*np.sqrt(np.log(4)))
+    sigma_min = sigma_maj / brane.anisotropy
+
+    # rotate
+    if brane.pa != None:
+        theta = np.radians(90-brane.pa)
+    else:
+        theta = np.radians(0.)
+
+    u_ = np.cos(theta)*u - np.sin(theta)*v
+    v_ = np.sin(theta)*u + np.cos(theta)*v
+
+    # rotate and return
+    return np.exp(-2*np.pi**2*(u_**2*sigma_maj**2 + v_**2*sigma_min**2))
+
+
+def loadSettings(filename):
+  '''
+    Loads simulation settings from a file generated by :func:`Brane.save_settings`.
+
+   :param filename: string 
+     File name that contains simulation settings.
+
+   :returns: A dictionary with simulation settings.
+
+  '''
+  return dict(np.genfromtxt(filename,\
+                dtype=[('a','|S10'),('f','float')],delimiter='\t',autostrip=True))
+
+def regrid(a,inx,idx,onx,odx):
+  '''
+    Regrids array with a new resolution and pixel number.
+
+    :param a: ``(n, n)`` 
+      Input numpy image
+    :param inx: int
+      Number of input pixels on a side
+    :param idx: scalar
+      Input resolution element 
+    :param onx: int 
+      Number of output pixels on a side
+    :param odx: scalar
+      Output resolution element 
+
+    :returns: Array regridded to the new resolution and field of view. 
+  '''
+  x = idx * (np.arange(inx) - 0.5 * (inx - 1))
+  f = RectBivariateSpline(x,x,a)
+  x_ = odx * (np.arange(onx) - 0.5 * (onx - 1))
+  xx_,yy_ = np.meshgrid(x_,x_,indexing='xy')
+  m = f.ev(yy_.flatten(),xx_.flatten()).reshape((onx,onx))
+  return m*(odx/idx)**2
+
+def writefits(m,dx,dest='image.fits',obsra=266.4168370833333,obsdec=-29.00781055555555,freq=230e9):
+    '''
+    Write fits file with header.  Defaults are set for Sgr A* at 1.3mm.
+
+    :param m: ``(n, n)``
+      numpy image array
+    :param dx: scalar 
+      Pixel size in microarcseconds
+    :param dest: (optional) string 
+      Output fits file name
+    :param obsra: (optional) scalar 
+      Source right ascension 
+    :param obsdec: (optional) scalar 
+      Source declination
+    '''
+    hdu = fits.PrimaryHDU(m)
+    hdu.header['CDELT1'] = -1*dx*np.radians(1.)/(3600.*1e6)
+    hdu.header['CDELT2'] = dx*np.radians(1.)/(3600.*1e6)
+    hdu.header['OBSRA']  = obsra
+    hdu.header['OBSDEC'] = obsdec
+    hdu.header['FREQ'] = freq
+    hdu.writeto(dest,clobber=True)
+
+def FTElementFast(img,dx,baseline):
+    '''
+    Return complex visibility.
+
+    :param img: ``(n, n)`` 
+      numpy image array 
+    :param dx: scalar 
+      Pixel size in microarcseconds
+    :param baseline: ``(2, )``
+      (u,v) point in wavelengths
+
+    .. note:: To shift center try multipliny by :math:`\\mathrm{exp}(\\pi i u n_x\\Delta_x)` and watch out for the axis orientation.
+    '''
+    nx = img.shape[-1]
+    du = 1./(nx * dx * np.radians(1.)/(3600*1e6)) 
+    ind = np.arange(nx)
+    return np.sum(img * np.dot(\
+             np.transpose([np.exp(-2j*np.pi/du/nx*baseline[1]*np.flipud(ind))]),\
+             [np.exp(-2j*np.pi/du/nx*baseline[0]*ind)]))

scatterbrane-0.1.0/scatterbrane.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: scatterbrane
+Version: 0.1.0
+Summary: A python module to simulate the effect of anisotropic scattering on astrophysical images.
+Author-email: Katherine Rosenfeld <krosenf@gmail.com>
+License-Expression: MIT
+Project-URL: Documentation, http://krosenfeld.github.io/scatterbrane/
+Keywords: scattering,astronomy,EHT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Scientific/Engineering :: Astronomy
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: astropy
+Requires-Dist: imageio
+Requires-Dist: matplotlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Dynamic: license-file
+
+scatterbrane
+============
+
+A python module for adding realistic scattering to astronomical images.  This version
+represents a very early release so please submit a pull request if you have trouble or
+need help for your application.
+
+For installation instructions and help getting started please see `the documentation <http://krosenfeld.github.io/scatterbrane/>`_.
+
+Installation
+------------
+
+This project now uses ``pyproject.toml`` and `uv <https://docs.astral.sh/uv/>`_ for dependency management.
+
+Install the package and its runtime dependencies with:
+
+.. code-block:: bash
+
+   uv sync
+
+Install the release and development tooling with:
+
+.. code-block:: bash
+
+   uv sync --group dev
+
+Release workflow
+----------------
+
+Version management is handled with ``bump-my-version``. To create a new tagged release:
+
+.. code-block:: bash
+
+   uv run bump-my-version bump patch
+
+This updates the package version, creates a commit, and creates a ``vX.Y.Z`` git tag. Pushing that tag to GitHub triggers the publish workflow for PyPI.
+
+Reference
+---------
+
+`Johnson, M. D., & Gwinn, C. R. 2015, ApJ, 805, 180  <http://adsabs.harvard.edu/abs/2015ApJ...805..180J>`_

scatterbrane-0.1.0/scatterbrane.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.rst
+pyproject.toml
+scatterbrane/__init__.py
+scatterbrane/brane.py
+scatterbrane/tracks.py
+scatterbrane/utilities.py
+scatterbrane.egg-info/PKG-INFO
+scatterbrane.egg-info/SOURCES.txt
+scatterbrane.egg-info/dependency_links.txt
+scatterbrane.egg-info/requires.txt
+scatterbrane.egg-info/top_level.txt

scatterbrane-0.1.0/scatterbrane.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

scatterbrane-0.1.0/scatterbrane.egg-info/requires.txt

@@ -0,0 +1,5 @@
+astropy
+imageio
+matplotlib
+numpy
+scipy

scatterbrane-0.1.0/scatterbrane.egg-info/top_level.txt

@@ -0,0 +1 @@
+scatterbrane

scatterbrane-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+