chanter 0.0.1__py3-none-any.whl

chanter/__init__.py

@@ -0,0 +1,4 @@
+from .model_galaxy import modelgalaxy
+from .galaxy_fitter import galaxyfitter
+
+from . import utils

chanter/galaxy_fitter.py

@@ -0,0 +1,118 @@
+import numpy as np
+from nautilus import Sampler
+from .model_galaxy import modelgalaxy
+from .utils import filter_set
+import time
+
+
+class galaxyfitter(object):
+
+    # Generative function for the likelihood (calls model galaxy)
+    def gen_phot(self, fit_instruc, filt_files):
+        """ Linear function.
+
+        Parameters
+        ----------
+        
+        par : numpy.ndarray
+            Free parameters.
+        """
+        model = modelgalaxy(fit_instruc)
+        wavs, flux = model.get_spectrum()
+        effwavs, phot = model.get_photometry(wavs, flux, filt_files)
+        return phot
+
+    # Liklihood function for a certain point in parameter space
+    def log_likelihood(self, data, gen_func, filt_files, param_dict):
+        """ Return the natural logarithm of the Likelihood. Constructed from a single gaussian.
+
+        Parameters
+        ----------
+
+        data :  numpy.ndarray
+            Dataset containing x, y and y_uncert values arranged in 3 rows.
+
+        gen_func : function
+            Generative function used to model the data.
+
+        params : numpy.ndarray
+            Free parameters of the generative model.
+        """
+
+        # Given Data
+        yi, yisig = data[0], data[1]
+
+        exp = {}
+        exp["age"] = param_dict["age"]
+        exp["tau"] = param_dict["tau"]
+        exp["massformed"] = param_dict["massformed"]
+        #exp["metallicity"] = param_dict["metallicity"]        # Z/Z_oldsolar
+        dust = {}
+        dust["type"] = "Calzetti"
+        dust["Av"] = param_dict["Av"]
+        fit_instruc = {}
+        fit_instruc["redshift"] = param_dict["redshift"]
+        fit_instruc["exponential"] = exp   
+        fit_instruc["dust"] = dust
+
+
+        # Likelihood of belonging to the 'good' gaussian
+        log_li = np.log((1/(np.sqrt(2*np.pi*(yisig**2))))) + ((-(yi - gen_func(fit_instruc, filt_files))**2) / (2*(yisig**2)))
+
+        # Sum likelihood and take logarithm (note sometimes recieve underflow error due to small likelihoods)
+        log_l_total = np.sum(log_li)
+        
+        return(log_l_total)
+
+    # Fit an array of photometry, output the best galaxy parameters
+    def fit(self, photdata, prior, filt_files):
+
+        filt = filter_set(filt_files)
+        effwavs = filt.eff_wavs
+
+        # Run fitter
+        t0 = time.time()
+
+        print('Computing '+str(id)+'...')
+        # Load data
+        dat= photdata.T
+        dat[0] = 2.99792458E-05 * ((1e-6 * dat[0]) / ((effwavs)**2))
+        dat[1] = 2.99792458E-05 * ((1e-6 * dat[1]) / ((effwavs)**2))
+
+        # Run the nested sampler over the likelihood function
+        sampler = Sampler(prior, lambda param_dict: self.log_likelihood(dat, self.gen_phot, filt_files, param_dict))
+        success = sampler.run(verbose=True, discard_exploration=True, timeout=1800)
+
+        # Plot results
+        points, log_w, log_l = sampler.posterior()
+
+        dic = {}
+        # Plot bestfit
+        for i in range(len(prior.keys)):
+            key = prior.keys[i]
+            points_i = points.T[i]
+            samples = np.random.choice(points_i, size = points_i.shape[0], p=np.exp(log_w))
+            dic[key + "_50"] = np.percentile(samples, 50)
+
+        exp = {}
+        exp["age"] = dic['age_50']
+        exp["tau"] = dic['tau_50']
+        exp["massformed"] = dic['massformed_50']
+        dust = {}
+        dust["type"] = "Calzetti"
+        dust["Av"] = dic['Av_50']
+        fit_instructions = {}
+        fit_instructions["redshift"] = dic['redshift_50']
+        fit_instructions["exponential"] = exp   
+        fit_instructions["dust"] = dust
+
+        print('Finished in ' + str(time.time() - t0)+ ' seconds.')
+        print(' ')
+
+        return fit_instructions
+
+
+
+
+
+

chanter/model_galaxy.py

@@ -0,0 +1,257 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from astropy.cosmology import Planck13  # Planck 2013
+from astropy.io import fits
+from spectres import spectres
+from .utils import filter_set
+
+
+# Load SSPs and resample
+def resample_ssp_wavs(target_wavs):
+
+    grid_raw_ages = np.zeros((master_base.shape[0], master_base.shape[1], target_wavs.shape[0]+1))
+    grid_raw_ages[:, :, 0] = master_base[:, :, 0]
+    grid_raw_ages[:, 0, 1:] = target_wavs
+
+    old_wavs = master_base[0][0][1:]
+
+    for i in range(master_base.shape[0]):
+        for j in range(1, master_base.shape[1]):
+            
+            old_flux = master_base[i][j][1:]
+            new_wavs = target_wavs
+            new_flux = spectres(new_wavs, old_wavs, old_flux, fill=0)
+            grid_raw_ages[i, j, 1:] = new_flux
+
+    grid_raw_ages[0].T[0, 1:] = grid_raw_ages[0].T[0, 1:] / 1e9
+
+    return grid_raw_ages
+
+def resample_igm_grid(wavs):
+    # Import IGM grid
+    raw_igm_grid = fits.open('chanter/chanter/grids/d_igm_grid_inoue14.fits')[1].data
+    igm_wavelengths = np.arange(1.0, 1225.01, 1.0)
+
+    # Resample in wavelength
+    grid = np.zeros((raw_igm_grid.shape[0], wavs.shape[0]))
+
+    for i in range(raw_igm_grid.shape[0]):
+        
+        old_wavs = igm_wavelengths
+        old_trans = raw_igm_grid[i]
+        new_wavs = wavs
+        new_trans = spectres(new_wavs, old_wavs, old_trans)
+        grid[i] = new_trans
+    
+    return grid
+
+
+hdul = fits.open('chanter/chanter/grids/ssps.fits')
+master_base = np.array((hdul[1].data, hdul[2].data, hdul[3].data, hdul[4].data, hdul[5].data, hdul[6].data, hdul[7].data))
+
+rest_target_wavs = np.arange(100., 50000., 10.)
+grid = resample_ssp_wavs(rest_target_wavs)
+igm_grid = resample_igm_grid(rest_target_wavs)
+
+
+'''
+# !!AGE RESAMPLING NOT WORKING!!
+
+def resample_ssp_ages(grid_raw_ages, target_ages):
+
+    grid = np.zeros((grid_raw_ages.shape[0], target_ages.shape[0]+1, grid_raw_ages.shape[2]))
+    grid[:, 0, :] = grid_raw_ages[0, 0, :]
+    grid[:, 1:, 0] = target_ages
+
+    old_ages = grid_raw_ages[0].T[0, 1:] / 1e9
+
+    for i in range(grid_raw_ages.shape[0]):
+        for j in range(1, grid_raw_ages.shape[2]):
+
+            old_age_flux = grid_raw_ages[i].T[j, 1:]
+            new_ages = target_ages
+            new_age_flux = spectres(new_ages, old_ages, old_age_flux, fill=0)
+            grid[i].T[j, 1:] = new_age_flux
+
+    return grid
+
+num_agebins = 100
+target_ages = np.linspace(0, Planck13.age(0).value, num_agebins)
+grid = resample_ssp_ages(grid_resampled, target_ages)
+'''
+
+
+
+class modelgalaxy(object):
+    
+
+    def __init__(self, fit_instructions):
+        self.fit_instructions = fit_instructions
+        self.universe_age = Planck13.age(0).value
+        self.lookback_time = Planck13.lookback_time(self.fit_instructions["redshift"]).value
+
+    
+    def sfr(self, age, ageform, tau, massformed):
+        
+        # Create exp time
+        t = ageform - age
+        sfr = np.exp(-t/ tau)
+        # Enforce no SF before ageform
+        sfr[t<0]=0
+        # Normalise to massformed
+        tdiff = np.diff(age)
+        area = np.sum(tdiff * sfr[:-1])
+        if area!=0:
+            sfr = sfr * ((10**massformed) / area)
+        else:
+            sfr  = sfr * 0
+
+        if ageform + self.lookback_time > self.universe_age:
+            sfr *= 0
+            
+        return sfr
+
+
+    def calzetti_dust(self, wavs):
+        """ Calculate the ratio A(lambda)/A(V) for the Calzetti et al.
+        (2000) attenuation curve. """
+
+        A_lambda = np.zeros_like(wavs)
+
+        wavs_mic = wavs*10**-4
+
+        mask1 = (wavs < 1200.)
+        mask2 = (wavs < 6300.) & (wavs >= 1200.)
+        mask3 = (wavs < 31000.) & (wavs >= 6300.)
+
+        A_lambda[mask1] = ((wavs_mic[mask1]/0.12)**-0.77
+                           * (4.05 + 2.695*(- 2.156 + 1.509/0.12
+                                            - 0.198/0.12**2 + 0.011/0.12**3)))
+
+        A_lambda[mask2] = (4.05 + 2.695*(- 2.156
+                                         + 1.509/wavs_mic[mask2]
+                                         - 0.198/wavs_mic[mask2]**2
+                                         + 0.011/wavs_mic[mask2]**3))
+
+        A_lambda[mask3] = 2.659*(-1.857 + 1.040/wavs_mic[mask3]) + 4.05
+
+        A_lambda /= 4.05
+
+        return A_lambda
+    
+
+    def transmission_neutral(self, wavs):
+        trans = 10**(-self.fit_instructions["dust"]["Av"]*self.calzetti_dust(wavs) / 2.5)
+        return trans
+    
+    def transmission_igm(self, redshift):
+
+        max_redshift=10.
+        igm_redshifts = np.arange(0.0, max_redshift + 0.01, 0.01)
+
+        """ Get the IGM transmission at a given redshift. """
+
+        redshift_mask = (igm_redshifts < redshift)
+        zred_ind = igm_redshifts[redshift_mask].shape[0]
+
+        zred_fact = ((redshift - igm_redshifts[zred_ind-1])
+                     / (igm_redshifts[zred_ind]
+                        - igm_redshifts[zred_ind-1]))
+
+        if zred_ind == 0:
+            zred_ind += 1
+            zred_fact = 0.
+
+        weights = np.array([[1. - zred_fact, zred_fact]])
+
+        igm_trans = np.sum(weights.T*igm_grid[zred_ind-1:zred_ind+1], axis=0)
+
+        igm_trans[np.isnan(igm_trans)] = 1.
+
+        return igm_trans
+
+
+    def redshift_effects(self, wavs, lum):
+
+        obswavs = (1+self.fit_instructions["redshift"]) * wavs
+        lum_distance = Planck13.luminosity_distance(self.fit_instructions["redshift"]).value
+        lum = 3.826e33 * lum # change luminosity units to erg/s
+        lum_distance = lum_distance * 1e6 * 3.086e16 * 100 # change distance units to cm
+        flux = lum / (4 * np.pi * (1+self.fit_instructions["redshift"]) * (lum_distance**2)) # * IGM transmission function
+        return obswavs, flux
+
+
+    def get_spectrum(self):
+
+        # Get model spectra, use a single population
+        ssp_age = grid[0].T[0, 1:]
+        wavs = grid[0, 0, 1:]
+        fluxes = grid[4, 1:, 1:]
+
+        
+        agebinwidths = np.diff(ssp_age)
+        sfrs = self.sfr(ssp_age[1:], self.fit_instructions["exponential"]["age"], self.fit_instructions["exponential"]["tau"], self.fit_instructions["exponential"]["massformed"])
+        ssps = fluxes[1:]
+        trans_neutral = self.transmission_neutral(wavs)
+        trans_igm = self.transmission_igm(self.fit_instructions["redshift"])
+
+        # Find the total product
+        lums = (np.array(([(agebinwidths * sfrs)])).T * ssps) * trans_neutral
+        lumtot = np.sum(lums, axis=0)
+
+        lumtot *= trans_igm
+
+        # Add in the effects of ISM dust attenuation (calzetti)
+        obswavs, obsflux = self.redshift_effects(wavs, lumtot)
+
+        self.wavs = obswavs
+        self.flux = obsflux
+
+        return obswavs, obsflux
+    
+
+    def get_photometry(self, wavs, flux, filt_list):
+        filt = filter_set(filt_list)
+        filt.resample_filter_curves(wavs)
+        effwavs = filt.eff_wavs
+        phot = filt.get_photometry(flux, 0)
+        return effwavs, phot
+    
+
+    def plot_spec(self, ax, kwargs):
+
+        #effwavs, phot = self.get_photometry(self.wavs, self.flux)
+
+        self.get_spectrum()
+
+        ax.step(self.wavs, self.flux, **kwargs)
+        ax.set_ylabel('Observed Flux / erg s$^{-1}$ cm$^{-2}$ Å$^{-1}$')
+        ax.set_xlabel('Observed Wavelength / Å')
+    
+
+    
+    def plot_sfh(self):
+        ssp_age = grid[0].T[0, 1:]        
+        sfrs = self.sfr(ssp_age, self.fit_instructions["exponential"]["age"], self.fit_instructions["exponential"]["tau"], self.fit_instructions["exponential"]["massformed"])
+        fig, ax = plt.subplots()
+        ax.set_xlabel('Age / Gyr')
+        ax.set_ylabel(' Star Formation / M$_{sun}$ Gyr$^{-1}$')
+        ax.plot((self.universe_age-self.lookback_time) - ssp_age, sfrs/1e9, color='black')
+        ax.invert_xaxis()
+        ax.set_ylim(0, )
+        return fig, ax
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+

chanter/utils/__init__.py

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

chanter/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