mimical 0.0.1__py3-none-any.whl

mimical/__init__.py

@@ -0,0 +1,5 @@
+from . import fitting
+from . import plotting
+
+
+from .fitting import BOGfit

mimical/fitting/__init__.py

@@ -0,0 +1,3 @@
+from .fitter import BOGfit
+from .prior_handler import priorHandler
+

mimical/fitting/fitter.py

@@ -0,0 +1,187 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import petrofit as pf
+from astropy.convolution.utils import discretize_model
+import corner
+from nautilus import Sampler
+import time
+import os
+from astropy.modeling import models
+import pandas as pd
+
+from .prior_handler import priorHandler
+from ..plotting import Plotter
+
+from ..utils import filter_set
+
+dir_path = os.getcwd()
+if not os.path.isdir(dir_path + "/bogout"):
+    os.system('mkdir ' + dir_path + "/bogout")
+    os.system('mkdir ' + dir_path + "/bogout/plots")
+    os.system('mkdir ' + dir_path + "/bogout/posteriors")
+
+
+
+class BOGfit(object):
+    """ Bayesian Observer of Galaxies - Fit.
+    Fits multi-filter images of galaxies simultaeneously using Petrofit and Nautilus
+    by specifying either an individual filter dependency for model parameters or
+    a user-specified order polynomial. By default a Sersic profile is used however any
+    Astropy model can be specified.
+
+    Parameters
+    ----------
+
+    id : str
+        An ID for the fitting run. Only really used for output files.
+
+    images : array
+        A 3D array of image data with slices for each filter. Each image
+        must be the same shape.
+
+    filt_list : list - str
+        A list of path strings to the filter transmission curve files, relative
+        to the current working directory. Must be in ascending order with effective wavelength.
+
+    psfs : array
+        A 3D array of normalised PSF images with slices for each filter. Each PSF image
+        must be the same shape, and the same shape as the data images.
+
+    astropy_model : array
+        Astropy Fittable2DModel used to model the image data. The subsequent prior must include
+        only and all parameters in the astropy_model.parameters variable, as well as a 'psf_pa' parameter.
+
+    user_prior : dict
+        The user specified prior which set out the priors for the model parameters
+        and passes information about whether to let these vary for each filter or
+        whether they follow an order-specified polynomial relationship.
+    """
+
+
+    def __init__(self, id, images, filt_list, psfs, user_prior, astropy_model=models.Sersic2D(), pool=None):
+        
+        self.id = id
+
+        print(f"Fitting object {id}")
+        self.images = images
+        self.psfs = psfs
+        self.user_prior = user_prior
+        self.astropy_model = astropy_model
+
+        # Using the filter files, find the name of the filters and the effective wavelengths.
+        self.filter_names = [x.split('/')[-1] for x in filt_list]
+        self.wavs = filter_set([dir_path+'/'+x for x in filt_list]).eff_wavs / 1e4
+
+        # Initiate the prior handler object, used to parse and translate priors and parameters.
+        self.prior_handler = priorHandler(user_prior, self.filter_names, self.wavs)
+
+        # Translate user specified prior into a prior parseable by nautlius.
+        self.fitter_prior = self.prior_handler.translate()
+        print(f"Fitting with parameters: {self.fitter_prior.keys}")
+
+        self.t0 = time.time()
+        self.calls = 0
+
+        self.pool = pool
+
+
+
+
+    def lnlike(self, param_dict):
+        """ Returns the log-likelihood for a given parameter vector. """
+
+        # Translate parameter vector into model parameters in each filter.
+        pars = self.prior_handler.revert(param_dict, self.wavs)
+
+        # Define empty arrays for models and rms images.
+        models = np.zeros_like(self.images)
+        rms = np.zeros_like(self.images)
+    
+        # Loop over filters
+        for i in range(len(self.wavs)):
+            # Update the model and evaluate over a pixel grid.
+            self.convolved_models[i].parameters = pars[i]
+            model = discretize_model(model=self.convolved_models[i], 
+                                     x_range=[0,self.images[i].shape[1]], 
+                                     y_range=[0,self.images[i].shape[0]], 
+                                     mode='center')
+
+            # If, for whatever reason, the model has NaNs, set to zero and blow up errors.
+            if np.isnan(np.sum(model)):
+                models[i] = np.zeros_like(model)
+                rms[i] = np.zeros_like(model) + 1e99
+
+            # Else, append to respective arrays.
+            else:
+                models[i] = model
+                rms[i] = param_dict['rms'] + (param_dict['rms_sersic']*np.sqrt(np.abs(model)))
+                #rms[i] += 1.483 * median_abs_deviation(self.images[i].flatten())
+
+
+        # Broadcast the 3D data and model arrays and sum through the resulting 3D log-likelihood array.
+        log_like_array = np.log((1/(np.sqrt(2*np.pi*(rms**2))))) + ((-(self.images - models)**2) / (2*(rms**2)))
+        log_like = np.sum(log_like_array.flatten())
+
+        # Print calls
+        self.calls+=1
+        if not self.calls % 100:
+            #print('Time % 100: ' + str(time.time()-self.t0))
+            self.t0 = time.time()
+
+        return(log_like)
+
+
+
+
+    def fit(self):
+        """ Runs the Nautlius sampler to fit models, and processes its output. """
+
+        # Define empty models for each filter
+        sersic_model = self.astropy_model
+        self.convolved_models = []
+        for i in range(len(self.wavs)):
+            self.convolved_models.append(pf.PSFConvolvedModel2D(sersic_model, psf=self.psfs[i], oversample=(self.images.shape[2]/2, self.images.shape[1]/2, 15, 10)))
+
+        # Check that the user specified prior contains the same parameters as the user specified model.
+        if list(self.convolved_models[0].param_names) != list(self.user_prior.keys()):
+            raise Exception("Prior labels do not match model parameters.")
+        
+
+        if os.path.isfile(dir_path+'/bogout/posteriors' + f'/{self.id}.txt'):
+            samples = pd.read_csv(dir_path+'/bogout/posteriors' + f'/{self.id}.txt', delimiter=' ').to_numpy()
+        
+        else:
+            # Run sampler
+            t0 = time.time()
+            #sampler = Sampler(self.fitter_prior, self.lnlike, n_live=400, filepath= dir_path+'/bogout'+f'/{self.id}.hdf5', resume=True, pool=self.pool)
+            sampler = Sampler(self.fitter_prior, self.lnlike, n_live=400, pool=self.pool)
+            sampler.run(verbose=True, timeout=2700)
+            print(f"Sampling time (minutes): {(time.time()-t0)/60}")
+
+            # Sample the posterior information
+            points, log_w, log_l = sampler.posterior()
+
+            # Plot and save the corner plot
+            corner.corner(points, weights=np.exp(log_w), bins=20, labels=np.array(self.fitter_prior.keys), color='purple', plot_datapoints=False, range=np.repeat(0.999, len(self.fitter_prior.keys)))
+            plt.savefig(dir_path+'/bogout/plots' + f'/corner_{self.id}.pdf', bbox_inches='tight')
+
+            # Sample an appropriately weighted posterior for representative samples.
+            n_post = 10000
+            indices = np.random.choice(np.arange(points.shape[0]), size = n_post, p=np.exp(log_w))
+            samples = points[indices]
+            samples_df = pd.DataFrame(data=samples, columns=self.fitter_prior.keys)
+            samples_df.to_csv(dir_path+'/bogout/posteriors' + f'/{self.id}.txt', sep=' ', index=False)
+
+
+        # Plot and save the median-parameter fit
+        Plotter().plot_median(self.images, self.wavs, self.convolved_models, samples, list(self.fitter_prior.keys), self.prior_handler)
+        plt.savefig(dir_path+'/bogout/plots' + f'/{self.id}_best_model.pdf', bbox_inches='tight')
+
+        # Return the median-parameter model
+        fit_dic = dict(zip((np.array((list(self.fitter_prior.keys)))+"_50").tolist(), np.median(samples, axis=0).tolist()))
+
+        print("Finished.")
+        print(" ")
+
+        return fit_dic
+   

mimical/fitting/prior_handler.py

@@ -0,0 +1,98 @@
+from nautilus import Prior
+from scipy.stats import norm
+import numpy as np
+
+class priorHandler(object):
+    """ Contains functions for translating BOGfit priors into 
+    Nautlius priors and translating Nautilus samples into model
+    paremeters in each filter.
+
+    Parameters
+    ----------
+
+    user_prior : dict
+        The user specified prior which set out the priors for the model parameters
+        and passes information about whether to let these vary for each filter or
+        whether they follow an order-specified polynomial relationship.
+
+    filter_names : list - str
+        A list of filter names e.g., [F356W, F444W, ...]
+
+    wavs : array
+        A 1D array of effective wavelengths corresponding to each filter.
+    
+    """
+
+
+    def __init__(self, user_prior, filter_names, wavs):
+        self.user_prior = user_prior
+        self.filter_names = filter_names
+        self.wavs = wavs
+
+
+    def translate(self):
+        """ Translate a BOGfit prior into a Nautilus prior."""
+        # Initiate Nautlius prior
+        prior = Prior()
+
+        # Loop over model parameters
+        for key in self.user_prior.keys():
+            param_prior_traits = self.user_prior[key]
+            param_prior_dist = param_prior_traits[0]
+            param_fit_type = param_prior_traits[1]
+
+            # If user specifies 'Individual', add a fitter free-parameter for each filter.
+            if param_fit_type == "Individual":
+                for i in range(len(self.wavs)):
+                    prior.add_parameter(f'{key}_{self.filter_names[i]}', dist=param_prior_dist)
+            
+            # If user specifies 'Polynomial', add a fitter free-parameter for each coefficient. 
+            # e.g., For order 0, only one free-parameter is included for the whole fitting run a.k.a constant between filters.
+            # e.g., For order 1, two free-parameter are included for the whole fitting run a.k.a straight-line relationship  with effective wavelength.
+            # The lowest wavelength is chosen as the origin.
+            elif param_fit_type == "Polynomial":
+                prior.add_parameter(key+f'_C0', dist=param_prior_dist)
+                poly_order = param_prior_traits[2]
+                higher_order_dist = norm(loc=0, scale=1) # Priors for gradients, higher-order coefficients.
+                for i in range(1,poly_order+1):
+                    prior.add_parameter(key+f'_C{i}', dist=higher_order_dist)
+
+            else:
+                raise Exception("Fitting type not supported, please choose either 'Individual' or 'Polynomial'.")
+
+        # Add free-parameters for a constant RMS background noise and constant Sersic poisson uncertainty scaling.
+        prior.add_parameter(f'rms', dist=(0,1))
+        prior.add_parameter(f'rms_sersic', dist=(0,100))
+        
+        return prior
+
+
+    def revert(self, param_dict, wavs):
+        """ Translate a Nautilus sample into a model parameters for each filter."""
+
+        # Empty parameter array
+        params_final = np.zeros((len(self.wavs), len(self.user_prior.keys())))
+
+        # Loop over model parameters
+        keys = list(self.user_prior.keys())
+        for i in range(len(keys)):
+            param_prior_traits = self.user_prior[keys[i]]
+            param_fit_type = param_prior_traits[1]
+
+            # If individual, add the Nautilus sample for each filter
+            if param_fit_type == "Individual":
+                for j in range(len(self.wavs)):
+                    params_final[j,i] = param_dict[f"{keys[i]}_{self.filter_names[j]}"]
+            
+            # If polynomial, calculate the expected parameter in each filter given its effective wavlength
+            elif param_fit_type == "Polynomial":
+                poly_order = param_prior_traits[2]
+                coeffs = np.zeros(poly_order+1)
+                for k in range(poly_order+1):
+                    coeffs[k] = param_dict[f"{keys[i]}_C{k}"]
+                polywavs = np.power(np.tile(wavs-wavs[0], (poly_order+1,1)).T, np.arange(poly_order+1))
+                comps = coeffs * polywavs
+                comps_summed = np.sum(comps, axis=1)
+                params_final[:,i] =comps_summed        
+
+        return params_final

mimical/plotting/__init__.py

@@ -0,0 +1 @@
+from .plotting import Plotter

mimical/plotting/plotting.py

@@ -0,0 +1,72 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from astropy.convolution.utils import discretize_model
+from tqdm import tqdm
+
+class Plotter(object):   
+
+    def plot_best(self, images, wavs, convolved_models, samples, fitter_keys, prior_handler):
+
+        fig,axes=plt.subplots(3, images.shape[0], figsize=(images.shape[0],3))
+        
+        # Get median Nautilus parameters and transalte into median model parameters.
+        param_dict = dict(zip(fitter_keys, np.median(samples, axis=0)))
+        pars = prior_handler.revert(param_dict, wavs)
+
+        for i in range(len(wavs)):
+            convolved_models[i].parameters = pars[i]
+            model = discretize_model(model=convolved_models[i], 
+                                    x_range=[0,images[i].shape[1]], 
+                                    y_range=[0,images[i].shape[0]], 
+                                    mode='center')
+            
+
+            v = np.percentile(images[-1], 99.9)
+
+            axes[0,i].imshow(images[i], vmax=v, vmin=-v)
+            axes[0,i].set_axis_off()
+
+            axes[1,i].imshow(model, vmax=v, vmin=-v)
+            axes[1,i].set_axis_off()
+
+            axes[2,i].imshow(images[i]-model, vmax=v, vmin=-v)
+            axes[2,i].set_axis_off()
+
+
+    def plot_median(self, images, wavs, convolved_models, samples, fitter_keys, prior_handler):
+
+        fig,axes=plt.subplots(3, images.shape[0], figsize=(images.shape[0],3))
+        
+
+        models = np.zeros((samples.shape[0], *images.shape))
+
+        print("Computing median model image...")
+        for j in tqdm(range(samples.shape[0])):
+            # Get median Nautilus parameters and transalte into median model parameters.
+            param_dict = dict(zip(fitter_keys, samples[j]))
+            pars = prior_handler.revert(param_dict, wavs)
+
+            for k in range(len(wavs)):
+                convolved_models[k].parameters = pars[k]
+                model = discretize_model(model=convolved_models[k], 
+                                        x_range=[0,images[k].shape[1]], 
+                                        y_range=[0,images[k].shape[0]], 
+                                        mode='center')
+                models[j,k] = model
+
+
+        median_models = np.median(models, axis=0)
+
+        for i in range(len(wavs)):
+
+            v = np.percentile(images[-1], 99.9)
+
+            axes[0,i].imshow(images[i], vmax=v, vmin=-v)
+            axes[0,i].set_axis_off()
+
+            axes[1,i].imshow(median_models[i], vmax=v, vmin=-v)
+            axes[1,i].set_axis_off()
+
+            axes[2,i].imshow(images[i]-median_models[i], vmax=v, vmin=-v)
+            axes[2,i].set_axis_off()
+

mimical/utils/__init__.py

@@ -0,0 +1 @@
+from .filter_set import filter_set

mimical/utils/filter_set.py

@@ -0,0 +1,175 @@
+import numpy as np
+
+
+class filter_set(object):
+    """ Class for loading and manipulating sets of filter curves. This
+    is where integration over filter curves to get photometry happens.
+
+    Parameters
+    ----------
+
+    filt_list : list
+        List of strings containing paths from the working directory to
+        files where filter curves are stored. The filter curve files
+        should contain an array of wavelengths in Angstroms followed by
+        a column of relative transmission values.
+    """
+
+    def __init__(self, filt_list):
+        self.filt_list = filt_list
+        self.wavelengths = None
+        self._load_filter_curves()
+        self._calculate_min_max_wavelengths()
+        self._calculate_effective_wavelengths()
+
+    def _load_filter_curves(self):
+        """ Loads filter files for the specified filt_list and truncates
+        any zeros from either of their edges. """
+
+        self.filt_dict = {}
+
+        for filt in self.filt_list:
+                self.filt_dict[filt] = np.loadtxt(filt, usecols=(0, 1))
+
+
+    def _calculate_min_max_wavelengths(self):
+        """ Finds the min and max wavelength values across all of the
+        filter curves. """
+
+        self.min_phot_wav = 9.9*10**99
+        self.max_phot_wav = 0.
+
+        for filt in self.filt_list:
+            min_wav = (self.filt_dict[filt][0, 0]
+                       - 2*(self.filt_dict[filt][1, 0]
+                       - self.filt_dict[filt][0, 0]))
+
+            max_wav = (self.filt_dict[filt][-1, 0]
+                       + 2*(self.filt_dict[filt][-1, 0]
+                       - self.filt_dict[filt][-2, 0]))
+
+            if min_wav < self.min_phot_wav:
+                self.min_phot_wav = min_wav
+
+            if max_wav > self.max_phot_wav:
+                self.max_phot_wav = max_wav
+
+    def _calculate_effective_wavelengths(self):
+        """ Calculates effective wavelengths for each filter curve. """
+
+        self.eff_wavs = np.zeros(len(self.filt_list))
+
+        for i in range(len(self.filt_list)):
+            filt = self.filt_list[i]
+            dlambda = self.make_bins(self.filt_dict[filt][:, 0])[1]
+            filt_weights = dlambda*self.filt_dict[filt][:, 1]
+            self.eff_wavs[i] = np.sqrt(np.sum(filt_weights*self.filt_dict[filt][:, 0])
+                                       / np.sum(filt_weights
+                                       / self.filt_dict[filt][:, 0]))
+            
+
+
+    def make_bins(self, midpoints, make_rhs=False):
+        """ A general function for turning an array of bin midpoints into an
+        array of bin left hand side positions and bin widths. Splits the
+        distance between bin midpoints equally in linear space.
+
+        Parameters
+        ----------
+
+        midpoints : numpy.ndarray
+            Array of bin midpoint positions
+
+        make_rhs : bool
+            Whether to add the position of the right hand side of the final
+            bin to bin_lhs, defaults to false.
+        """
+
+        bin_widths = np.zeros_like(midpoints)
+        if make_rhs:
+            bin_lhs = np.zeros(midpoints.shape[0]+1)
+            bin_lhs[0] = midpoints[0] - (midpoints[1]-midpoints[0])/2
+            bin_widths[-1] = (midpoints[-1] - midpoints[-2])
+            bin_lhs[-1] = midpoints[-1] + (midpoints[-1]-midpoints[-2])/2
+            bin_lhs[1:-1] = (midpoints[1:] + midpoints[:-1])/2
+            bin_widths[:-1] = bin_lhs[1:-1]-bin_lhs[:-2]
+
+        else:
+            bin_lhs = np.zeros_like(midpoints)
+            bin_lhs[0] = midpoints[0] - (midpoints[1]-midpoints[0])/2
+            bin_widths[-1] = (midpoints[-1] - midpoints[-2])
+            bin_lhs[1:] = (midpoints[1:] + midpoints[:-1])/2
+            bin_widths[:-1] = bin_lhs[1:]-bin_lhs[:-1]
+
+        return bin_lhs, bin_widths
+    
+
+    def resample_filter_curves(self, wavelengths):
+        """ Resamples the filter curves onto a new set of wavelengths
+        and creates a 2D array of filter curves on this sampling. """
+
+        self.wavelengths = wavelengths  # Wavelengths for new sampling
+
+        # Array containing filter profiles on new wavelength sampling
+        self.filt_array = np.zeros((wavelengths.shape[0], len(self.filt_list)))
+
+        # Array containing the width in wavelength space for each point
+        self.widths = self.make_bins(wavelengths)[1]
+
+        for i in range(len(self.filt_list)):
+            filt = self.filt_list[i]
+            self.filt_array[:, i] = np.interp(wavelengths,
+                                              self.filt_dict[filt][:, 0],
+                                              self.filt_dict[filt][:, 1],
+                                              left=0, right=0)
+            
+    def get_photometry(self, spectrum, redshift, unit_conv=None):
+        """ Calculates photometric fluxes. The filters are first re-
+        sampled onto the same wavelength grid with transmission values
+        blueshifted by (1+z). This is followed by an integration over
+        the observed spectrum in the rest frame:
+
+        flux = integrate[(f_lambda*lambda*T(lambda*(1+z))*dlambda)]
+        norm = integrate[(lambda*T(lambda*(1+z))*dlambda))]
+        photometry = flux/norm
+
+        lambda:            rest-frame wavelength array
+        f_lambda:          observed spectrum
+        T(lambda*(1+z)):   transmission of blueshifted filters
+        dlambda:           width of each wavelength bin
+
+        The integrals over all filters are done in one array operation
+        to improve the speed of the code.
+        """
+
+        if self.wavelengths is None:
+            raise ValueError("Please use resample_filter_curves method to set"
+                            + " wavelengths before calculating photometry.")
+
+        redshifted_wavs = self.wavelengths*(1. + redshift)
+
+        # Array containing blueshifted filter curves
+        filters_z = np.zeros_like(self.filt_array)
+
+        # blueshift filter curves to sample right bit of rest frame spec
+        for i in range(len(self.filt_list)):
+            filters_z[:, i] = np.interp(redshifted_wavs, self.wavelengths,
+                                        self.filt_array[:, i],
+                                        left=0, right=0)
+
+        # Calculate numerator of expression
+        flux = np.expand_dims(spectrum*self.widths*self.wavelengths, axis=1)
+        flux = np.sum(flux*filters_z, axis=0)
+
+        # Calculate denominator of expression
+        norm = filters_z*np.expand_dims(self.widths*self.wavelengths, axis=1)
+        norm = np.sum(norm, axis=0)
+
+        photometry = np.squeeze(flux/norm)
+
+        # This is a little dodgy as pointed out by Ivo, it should depend
+        # on the spectral shape however only currently used for UVJ mags
+        if unit_conv == "cgs_to_mujy":
+            photometry /= (10**-29*2.9979*10**18/self.eff_wavs**2)
+
+        return photometry

mimical-0.0.1.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: mimical
+Version: 0.0.1
+Summary: Sersic Fitting
+Author: Struan Stevenson
+Author-email: struan.stevenson@ed.ac.uk
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: astropy
+Requires-Dist: matplotlib
+Requires-Dist: nautilus-sampler
+Requires-Dist: petrofit
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: summary
+
+# Mimical (Modelling the Intensity of Multiply Imaged CelestiAl light)
+

mimical-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+mimical/__init__.py,sha256=jPAlI6xX4U07RG_3_BUtr34CN_jQmzuqgduf2QpCAhE,74
+mimical/fitting/__init__.py,sha256=AVsW3xF_8s267G2EZAO7mqrr99Vdg8_AIIBwJkouvoY,68
+mimical/fitting/fitter.py,sha256=QDI0piD7BIpXoP9vrdy5d-kHa8KCgYywfOyKvtAoW0E,7680
+mimical/fitting/prior_handler.py,sha256=yXvxbohS6f94CMRyeIViFc83hRYAj82IZNA5mzhMSRw,4193
+mimical/plotting/__init__.py,sha256=I1ZpQA48g-YPkqwrDGgTrqaTxDUgR8n0mbBX0MdbZtU,30
+mimical/plotting/plotting.py,sha256=OWTR-uOT4UpBw0XcKpl_uFSODuEdcfw7nIk3Sf1cOGY,2646
+mimical/utils/__init__.py,sha256=yolMgYFpvXoHuyV-ijGo26SQ0_niw0gz__iAFgdiQiY,35
+mimical/utils/filter_set.py,sha256=EITLa2c3FG3n1-v7KatKRwHCRyfZ4TTjsi_WM7Bz64k,6819
+mimical-0.0.1.dist-info/METADATA,sha256=wFUCBu6XeHIvu1Ty82NsUYdGoo0vvC_WhCQ8Z1jx6yI,512
+mimical-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mimical-0.0.1.dist-info/top_level.txt,sha256=z6HTYpsoNjLUFayXjn8WyjX8C1mIbZw8Arb334cUbwc,8
+mimical-0.0.1.dist-info/RECORD,,

mimical-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mimical-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mimical