Пример #1
0
    def gal_model_calcs(self):
        '''
        Read in galaxy SEDs, regrid them, calculate the model flux in each
        filter for each redshift.
        '''
        print('Using %ld gal templates over %ld redshifts'
              % (self._n_gal_template, self.nz))

        self.zstep = (self.zmax - self.zmin) / (self.nz - 1)

        model_flux_gals = np.zeros(
            (self.n_filter, self._n_gal_template * self.nz))

        for i in xrange(self._n_gal_template):

            sed_length = get_file_length(i, self.gals_sed_input)

            p_lam, p_val = read_file(i, self.gals_sed_input)

            for j in xrange(self.nz):
                z = self.zmin + j * self.zstep
                for k in xrange(self.n_filter):
                    p_val_fine = regrid_sed(
                        z, p_lam, p_val, self.filter_lgth_fine[k],
                        sed_length, self.filter_lamb_fine[k])
                    mod_val = integrate_sed(
                        self.filter_lgth_fine[k], p_val_fine,
                        self.filter_lamb_fine[k], self.filter_thru_fine[k])

                    model_flux_gals[k][j + i * self.nz] = mod_val

        self.model_flux_gals = model_flux_gals
Пример #2
0
    def star_model_calcs(self):
        '''
        Read in star SEDs, regrid them, calculate the model flux in each filter
        for each redshift.
        '''
        print('Using %ld star templates' % self._n_star_template)

        model_flux_stars = np.zeros((self.n_filter, self._n_star_template))

        for i in xrange(self._n_star_template):
            sed_length = get_file_length(i, self.stars_sed_input)

            p_lam, p_val = read_file(i, self.stars_sed_input)

            for k in xrange(self.n_filter):
                p_val_fine = regrid_sed(
                    0.0, p_lam, p_val, self.filter_lgth_fine[k],
                    sed_length, self.filter_lamb_fine[k])

                mod_val = integrate_sed(
                    self.filter_lgth_fine[k], p_val_fine,
                    self.filter_lamb_fine[k], self.filter_thru_fine[k])

                model_flux_stars[k][i] = mod_val

        self.model_flux_stars = model_flux_stars
Пример #3
0
    def filter_calcs(self):
        '''
        Reads in the models seds and filter throughput response curves,
        regrids the filters onto a finer grid for interpolation,
        and calls a routine to calculate the filter flux zero-points.
        Testing indicates details of regridding and interpolation scheme
        is not very important.
        '''
        sed_length = 0

        self.n_filter = get_num_files(self.filters_input)

        if self.n_filter < 2:
            raise ValueError

        print('Found %d Filters' % self.n_filter)

        self._n_star_template = get_num_files(self.stars_sed_input)
        self._n_gal_template = get_num_files(self.gals_sed_input)

        # find the longest SED file among the bunch
        # first the star SEDs
        for i in xrange(self._n_star_template):
            n = get_file_length(i, self.stars_sed_input)
            if n * 2 > sed_length:
                sed_length = n * 2

        # do the same for the galaxies
        for i in xrange(self._n_gal_template):
            n = get_file_length(i, self.gals_sed_input)
            if n * 2 > sed_length:
                sed_length = n * 2

        self.filter_lgth_fine = np.zeros(self.n_filter)
        self.norm = np.zeros(self.n_filter)
        self.filter_lamb_fine = {}
        self.filter_thru_fine = {}

        for i in xrange(self.n_filter):
            n = get_file_length(i, self.filters_input)
            filter_length = n
            regrid_factor = np.round(float(sed_length) / float(n))

            filter_lgth_fine = n * regrid_factor

            filt_lamb, filt_thru = read_file(i, self.filters_input)

            filter_lamb_fine, filter_thru_fine = \
                regrid_filter(filt_lamb, filt_thru,
                              filter_length, filter_lgth_fine)

            norm = calc_normalization(filter_lamb_fine, filter_thru_fine,
                                      filter_lgth_fine)

            print("Filter %ld has (AB) zeropoint flux normalization: %f"
                  % (i, norm))

            self.filter_lgth_fine[i] = filter_lgth_fine
            self.norm[i] = norm
            self.filter_lamb_fine[i] = filter_lamb_fine
            self.filter_thru_fine[i] = filter_thru_fine