Пример #1
0
def write_rad_field():

    from myscience import calc_radiation_field

    # Define filenames
    # ------------
    DIR_DUST = '/d/bip3/ezbc/multicloud/data/dust_temp/'
    DIR_RAD = '/d/bip3/ezbc/multicloud/data/radiation_field/'
    FILENAME_TEMPERATURE = DIR_DUST + 'multicloud_dust_temp_5arcmin.fits'
    FILENAME_TEMPERATURE_ERROR = DIR_DUST + \
            'multicloud_dust_temp_error_5arcmin.fits'
    FILENAME_BETA = DIR_DUST + 'multicloud_dust_beta_5arcmin.fits'
    FILENAME_BETA_ERROR = DIR_DUST + 'multicloud_dust_beta_error_5arcmin.fits'
    FILENAME_RAD = DIR_RAD + 'multicloud_rad_field_5arcmin.fits'
    FILENAME_RAD_ERROR = DIR_RAD + 'multicloud_rad_field_error_5arcmin.fits'

    # Get the data
    # ------------
    temp_data, temp_header = fits.getdata(FILENAME_TEMPERATURE, header=True)
    temp_error_data = fits.getdata(FILENAME_TEMPERATURE_ERROR)
    beta_data, beta_header = fits.getdata(FILENAME_BETA, header=True)
    beta_error_data = fits.getdata(FILENAME_BETA_ERROR)

    # Calculate the radiation field
    # -----------------------------
    rad_field, rad_field_error = calc_radiation_field(
        temp_data,
        T_dust_error=temp_error_data,
        beta=beta_data,
        beta_error=beta_error_data)

    # convert Mathis field to Draine field
    rad_field /= 1.48

    # create rad field header
    rad_field_header = beta_header.copy()
    rad_field_header['BUNIT'] = ''

    # Write the radiation field to fits file
    fits.writeto(FILENAME_RAD,
                 rad_field,
                 header=rad_field_header,
                 clobber=True)
    fits.writeto(
        FILENAME_RAD_ERROR,
        rad_field_error,
        header=rad_field_header,
        clobber=True,
    )
def write_rad_field():

    from myscience import calc_radiation_field

    # Define filenames
    # ------------
    DIR_DUST = '/d/bip3/ezbc/multicloud/data/dust_temp/'
    DIR_RAD = '/d/bip3/ezbc/multicloud/data/radiation_field/'
    FILENAME_TEMPERATURE = DIR_DUST + 'multicloud_dust_temp_5arcmin.fits'
    FILENAME_TEMPERATURE_ERROR = DIR_DUST + \
            'multicloud_dust_temp_error_5arcmin.fits'
    FILENAME_BETA = DIR_DUST + 'multicloud_dust_beta_5arcmin.fits'
    FILENAME_BETA_ERROR = DIR_DUST + 'multicloud_dust_beta_error_5arcmin.fits'
    FILENAME_RAD = DIR_RAD + 'multicloud_rad_field_5arcmin.fits'
    FILENAME_RAD_ERROR = DIR_RAD + 'multicloud_rad_field_error_5arcmin.fits'

    # Get the data
    # ------------
    temp_data, temp_header = fits.getdata(FILENAME_TEMPERATURE, header=True)
    temp_error_data = fits.getdata(FILENAME_TEMPERATURE_ERROR)
    beta_data, beta_header = fits.getdata(FILENAME_BETA, header=True)
    beta_error_data = fits.getdata(FILENAME_BETA_ERROR)

    # Calculate the radiation field
    # -----------------------------
    rad_field, rad_field_error = calc_radiation_field(temp_data,
                                                      T_dust_error=temp_error_data,
                                                      beta=beta_data,
                                                      beta_error=beta_error_data)

    # convert Mathis field to Draine field
    rad_field /= 1.48

    # create rad field header
    rad_field_header = beta_header.copy()
    rad_field_header['BUNIT'] = ''

    # Write the radiation field to fits file
    fits.writeto(FILENAME_RAD, rad_field, header=rad_field_header, clobber=True)
    fits.writeto(FILENAME_RAD_ERROR, rad_field_error, header=rad_field_header,
                 clobber=True,)
def run_mc_simulations_cores(core_dict, wcs_header, temp_data, temp_error_data,
        beta_data, beta_error_data, N_mc=10):

    from myscience import calc_radiation_field

    # core_dict with core region-dependent values needs to be different because
    # core_dict with cloud-averaged parameters is used in a different
    # function...
    # this was poor planning
    #core_dict = core_dict.copy()

    for core_name in core_dict:
        # load cloud regions
        vertices_wcs = core_dict[core_name]['region_vertices']

        # Format vertices to be 2 x N array
        #vertices_wcs = np.array((vertices_wcs[0], vertices_wcs[1]))

        # Make a galactic coords object and convert to Ra/dec
        coords_fk5 = SkyCoord(vertices_wcs[0] * u.deg,
                              vertices_wcs[1] * u.deg,
                              frame='fk5',
                              )

        # convert to pixel
        coords_pixel = np.array(coords_fk5.to_pixel(wcs_header))

        # write data to dataframe
        vertices_pix = np.array((coords_pixel[1], coords_pixel[0])).T

        core_dict[core_name]['region_vertices_pix'] = vertices_pix

        # Mask pixels outside of the region
        region_mask = np.logical_not(myg.get_polygon_mask(temp_data,
                                                          vertices_pix))
        core_dict[core_name]['cloud_region_mask'] = region_mask

        # Grab the temperatures
        if 0:
            core_dict[core_name]['dust_temps'] = temp_data[~region_mask]
            core_dict[core_name]['dust_temp_errors'] = \
                temp_error_data[~region_mask]

        # adjust vertices to get errors on mean T_dust
        cloud = core_dict[core_name]['cloud']
        temp_mc = np.empty(N_mc)
        temp_error_mc = np.empty(N_mc)
        beta_mc = np.empty(N_mc)
        beta_error_mc = np.empty(N_mc)
        rad_mc = np.empty(N_mc)
        rad_error_mc = np.empty(N_mc)

        for j in xrange(N_mc):
            if j != 0:
                new_vertices_wcs = vertices_wcs + \
                                   np.random.normal(scale=1.0 / 60.0 * 5,
                                                    size=vertices_wcs.shape)
            else:
                new_vertices_wcs = vertices_wcs

            # Make a galactic coords object and convert to Ra/dec
            coords_fk5 = SkyCoord(new_vertices_wcs[0] * u.deg,
                                  new_vertices_wcs[1] * u.deg,
                                  frame='fk5',
                                  )

            # convert to pixel
            coords_pixel = np.array(coords_fk5.to_pixel(wcs_header))

            # write data to dataframe
            vertices_pix = np.array((coords_pixel[1],
                                     coords_pixel[0])).T

            # Mask pixels outside of the region
            region_mask = \
                    np.logical_not(myg.get_polygon_mask(temp_data,
                                                        vertices_pix))

            if 0:
                import matplotlib.pyplot as plt
                plt.imshow(region_mask, origin='lower')
                plt.title(core_name)
                plt.show()

            # Get the region's temperature
            if j == 0:
                temps = temp_data[~region_mask]
                betas = beta_data[~region_mask]
                rads = calc_radiation_field(temps,
                                         beta=betas,
                                         )

            # grab relevant pixels of core region
            temp_sim = temp_data[~region_mask]
            temp_error_sim = temp_error_data[~region_mask]
            beta_sim = beta_data[~region_mask]
            beta_error_sim = beta_error_data[~region_mask]

            # simulate new observation of temperature and beta
            temp_sim += np.random.normal(0, scale=temp_error_sim,)
            beta_sim += np.random.normal(0, scale=beta_error_sim,)

            # Calculate the radiation field
            # -----------------------------
            rad_field = \
                calc_radiation_field(temp_sim,
                                     beta=beta_sim,
                                     )

            # Grab the median values of temp, beta, and rad field
            temp_mc[j] = np.median(temp_sim)
            beta_mc[j] = np.median(beta_sim)
            rad_mc[j] = np.median(rad_field)

        # Calculate average temp
        #core_dict[core_name]['dust_temp_median'] = \
        #    np.nanmean(temp_data[~region_mask])
        #core_dict[core_name]['dust_temp_median_error'] = \
        #    np.sqrt(np.nansum(temp_error_data[~region_mask]**2)) / \
        #        temp_error_data[~region_mask].size
        dust_temp_median, mc_error = mystats.calc_cdf_error(temp_mc)
        dust_temp_median_error = np.mean(mc_error)
        dust_beta_median, mc_error = mystats.calc_cdf_error(beta_mc)
        dust_beta_median_error = np.mean(mc_error)
        rad_field_draine_median, mc_error = mystats.calc_cdf_error(rad_mc)
        #rad_field_draine_median_error = np.mean(mc_error)
        rad_field_draine_median_error = np.std(rads)

        # calculate habing field from draine:
        rad_field_habing_median = rad_field_draine_median * 1.71
        rad_field_habing_median_error = rad_field_draine_median_error * 1.71
        rad_field_mathis_median = rad_field_draine_median * 1.48
        rad_field_mathis_median_error = rad_field_draine_median_error * 1.48

        # write results to cloud
        core_dict[core_name]['region_values'] = \
                {
                 'dust_temp_median': dust_temp_median,
                 'dust_temp_median_error': dust_temp_median_error,
                 'dust_temps': temps,
                 'dust_beta_median': dust_beta_median,
                 'dust_beta_median_error': dust_beta_median_error,
                 'dust_betas': betas,
                 'rad_field_draine_median': rad_field_draine_median,
                 'rad_field_draine_median_error': \
                    rad_field_draine_median_error,
                 'rad_field_habing_median': rad_field_habing_median,
                 'rad_field_habing_median_error': \
                    rad_field_habing_median_error,
                 'rad_field_mathis_median': rad_field_mathis_median,
                 'rad_field_mathis_median_error': \
                    rad_field_mathis_median_error,
                 'rad_field_map': rads,
                 }

    return core_dict
def run_mc_simulations(core_dict, wcs_header, temp_data, temp_error_data,
        beta_data, beta_error_data, N_mc=10):

    from myscience import calc_radiation_field

    cloud_props = {}
    for core_name in core_dict:
        # load cloud regions
        core_dict = add_cloud_region(core_dict)
        vertices_wcs = core_dict[core_name]['cloud_region_vertices'].T

        # Format vertices to be 2 x N array
        #vertices_wcs = np.array((vertices_wcs[0], vertices_wcs[1]))

        # Make a galactic coords object and convert to Ra/dec
        coords_fk5 = SkyCoord(vertices_wcs[0] * u.deg,
                              vertices_wcs[1] * u.deg,
                              frame='fk5',
                              )

        # convert to pixel
        coords_pixel = np.array(coords_fk5.to_pixel(wcs_header))

        # write data to dataframe
        vertices_pix = np.array((coords_pixel[1], coords_pixel[0])).T

        core_dict[core_name]['cloud_region_vertices_pix'] = vertices_pix

        # Mask pixels outside of the region
        region_mask = np.logical_not(myg.get_polygon_mask(temp_data,
                                                          vertices_pix))
        core_dict[core_name]['cloud_region_mask'] = region_mask

        # Grab the temperatures
        core_dict[core_name]['dust_temps'] = temp_data[~region_mask]
        core_dict[core_name]['dust_temp_errors'] = \
            temp_error_data[~region_mask]

        # adjust vertices to get errors on mean T_dust
        cloud = core_dict[core_name]['cloud']
        temp_mc = np.empty(N_mc)
        temp_error_mc = np.empty(N_mc)
        beta_mc = np.empty(N_mc)
        beta_error_mc = np.empty(N_mc)
        rad_mc = np.empty(N_mc)
        rad_error_mc = np.empty(N_mc)
        if cloud not in cloud_props:
            for j in xrange(N_mc):
                if j != 0:
                    new_vertices_wcs = vertices_wcs + \
                                       np.random.normal(scale=1.0,
                                                        size=vertices_wcs.shape)
                else:
                    new_vertices_wcs = vertices_wcs

                # Make a galactic coords object and convert to Ra/dec
                coords_fk5 = SkyCoord(new_vertices_wcs[0] * u.deg,
                                      new_vertices_wcs[1] * u.deg,
                                      frame='fk5',
                                      )

                # convert to pixel
                coords_pixel = np.array(coords_fk5.to_pixel(wcs_header))

                # write data to dataframe
                vertices_pix = np.array((coords_pixel[1],
                                         coords_pixel[0])).T

                # Mask pixels outside of the region
                region_mask = \
                        np.logical_not(myg.get_polygon_mask(temp_data,
                                                            vertices_pix))

                # Get the region's temperature
                if j == 0:
                    temps = temp_data[~region_mask]
                    betas = beta_data[~region_mask]
                    rads = calc_radiation_field(temps,
                                             beta=betas,
                                             )

                # simulate new observation of temperature and beta
                temp_sim = temp_data + np.random.normal(0,
                                                        scale=temp_error_data,)
                beta_sim = beta_data + np.random.normal(0,
                                                        scale=beta_error_data,)

                # Calculate the radiation field
                # -----------------------------
                rad_field = \
                    calc_radiation_field(temp_sim,
                                         beta=beta_sim,
                                         )

                # Grab the median values of temp, beta, and rad field
                temp_mc[j] = np.median(temp_sim[~region_mask])
                beta_mc[j] = np.median(beta_sim[~region_mask])
                rad_mc[j] = np.median(rad_field[~region_mask])

            # Calculate average temp
            #core_dict[core_name]['dust_temp_median'] = \
            #    np.nanmean(temp_data[~region_mask])
            #core_dict[core_name]['dust_temp_median_error'] = \
            #    np.sqrt(np.nansum(temp_error_data[~region_mask]**2)) / \
            #        temp_error_data[~region_mask].size
            dust_temp_median, mc_error = mystats.calc_cdf_error(temp_mc)
            dust_temp_median_error = np.mean(mc_error)
            dust_beta_median, mc_error = mystats.calc_cdf_error(beta_mc)
            dust_beta_median_error = np.mean(mc_error)
            rad_field_draine_median, mc_error = mystats.calc_cdf_error(rad_mc)
            rad_field_draine_median_error = np.mean(mc_error)

            # calculate habing field from draine:
            rad_field_habing_median = rad_field_draine_median * 1.71
            rad_field_habing_median_error = rad_field_draine_median_error * 1.71
            rad_field_mathis_median = rad_field_draine_median * 1.48
            rad_field_mathis_median_error = rad_field_draine_median_error * 1.48


            # write results to cloud
            cloud_props[cloud] = \
                    {
                     'dust_temp_median': dust_temp_median,
                     'dust_temp_median_error': dust_temp_median_error,
                     'dust_temps': temps,
                     'dust_beta_median': dust_beta_median,
                     'dust_beta_median_error': dust_beta_median_error,
                     'dust_betas': betas,
                     'rad_field_draine_median': rad_field_draine_median,
                     'rad_field_draine_median_error': \
                        rad_field_draine_median_error,
                     'rad_field_habing_median': rad_field_habing_median,
                     'rad_field_habing_median_error': \
                        rad_field_habing_median_error,
                     'rad_field_mathis_median': rad_field_mathis_median,
                     'rad_field_mathis_median_error': \
                        rad_field_mathis_median_error,
                     'rad_field_map': rads,
                     }

        else:
            core_dict[core_name]['dust_temp_median'] = \
                cloud_props[cloud]['dust_temp_median']
            core_dict[core_name]['dust_temp_median_error'] = \
                cloud_props[cloud]['dust_temp_median_error']

        # copy cloud params to core dict
        for param_name in cloud_props[cloud]:
            core_dict[core_name][param_name] = \
                    np.copy(cloud_props[cloud][param_name])

    return cloud_props, core_dict
def add_model_params(core_dict):

    from myscience import calc_radiation_field, calc_temperature
    import myscience.sternberg14 as mys14
    import myscience.krumholz09 as myk09

    ''' need the following parameters

    Cloud Name} &
        Core Name} &
        Alternate Name} &
        $T_{\rm dust}$} &
        $U$} &
        \aG} &
        \phicnm} &
        \hisd\ Threshold} &
        $n$} &
        $T_{\rm CNM}$} \\
    '''

    clouds_printed = []
    for core_name in core_dict:
        core = core_dict[core_name]

        temp = core['dust_temp_median']
        temp_error = core['dust_temp_median_error']
        core['rad_field'], core['rad_field_error'] = \
                calc_radiation_field(temp,
                                     T_dust_error=temp_error)

        cloud = core_dict[core_name]['cloud']

        #rad_error = np.sort((calc_radiation_field(temp + temp_error),
        #                     calc_radiation_field(temp - temp_error)))
        #core['rad_field_error'] = rad_error
        for param in core['sternberg']:
            if type(core['sternberg'][param]) is tuple:
                core['sternberg'][param] = np.array(core['sternberg'][param])
        for param in core['krumholz']:
            if type(core['krumholz'][param]) is tuple:
                core['krumholz'][param] = np.array(core['krumholz'][param])

        # Sternberg params
        # =======================================================================
        # calculate n_H and error
        # -----------------------------------------------------------------------
        core['n_H'], core['n_H_error'] = \
                mys14.calc_n_H(I_UV=core['rad_field_draine_median'],
                         alphaG=core['sternberg']['alphaG'],
                         phi_g=core['sternberg']['phi_g'],
                         Z_g=core['sternberg']['Z'],
                         I_UV_error=core['rad_field_draine_median_error'],
                         alphaG_error=core['sternberg']['alphaG_error'],
                         Z_g_error=core['sternberg']['Z_error'],
                         )

        core['w'], core['w_error'] = \
                mys14.calc_w(phi_g=core['sternberg']['phi_g'],
                       phi_g_error=core['sternberg']['phi_g_error'],
                       Z_g=core['sternberg']['Z'],
                       Z_g_error=core['sternberg']['Z_error'],
                       )

        core['chi_s14'], core['chi_s14_error'] = \
                mys14.calc_chi(alphaG=core['sternberg']['alphaG'],
                               alphaG_error=core['sternberg']['alphaG_error'],
                               w=core['w'],
                               w_error=core['w_error'],
                               )

        #if core['n_H'] <= 0:
        #    core['n_H'] = 10

        #core['n_H_error'] = [0.1 * core['n_H'], 0.1 * core['n_H']]

        if 0:
            core['T_H'] = calc_temperature(n_H=core['n_H'],
                                           pressure=3000.0) / 1000.0
            core['T_H_error'] = np.array([0.1 * core['T_H'], 0.1 * core['T_H']])
            T_H_error = np.sort((calc_temperature(core['n_H'] - \
                                  core['n_H_error'][1]),
                                 calc_temperature(core['n_H'] + \
                                  core['n_H_error'][0])))
            core['T_H_error'] = T_H_error / 1000.0
            if abs(core['T_H_error'][0]) > core['T_H']:
                core['T_H_error'][0] = core['T_H']

        pressure = 3700.0
        pressure_error = (1200.0, 1200.0)
        core['T_H'], core['T_H_error'] = \
                calc_temperature(n_H=core['n_H'],
                                 pressure=pressure,
                                 pressure_error=pressure_error,
                                 n_H_error=core['n_H_error'])

        core['T_H'] /= 1000.0
        core['T_H_error'] = np.array(core['T_H_error']) / 1000.0

        # Krumholz params
        # =======================================================================
        krumholz_pressure_calc = True
        if krumholz_pressure_calc:
            # get the minimum CNM density, calculate n_CNM with phi_CNM, then
            # calculate temperature given galactic pressure between WNM and CNM

            #print('Cloud:', cloud)
            #print('Krumholz rad habing field:', core['rad_field_habing_median'])
            #print('Krumholz rad draine field:', core['rad_field_draine_median'])

            n_min, n_min_error = \
                myk09.calc_n_min(G_0=core['rad_field_draine_median'],
                               G_0_error=core['rad_field_draine_median_error'],
                               Z=1.0,
                               calc_error=True,
                               )
            phi_cnm = core['krumholz']['phi_cnm']
            phi_cnm_error = core['krumholz']['phi_cnm_error']
            Z = core['krumholz']['Z']
            Z_error = core['krumholz']['Z_error']
            sigma_d = core['krumholz']['sigma_d']
            sigma_d_error = core['krumholz']['sigma_d_error']
            core['n_cnm'] = n_min * phi_cnm
            core['n_cnm_error'] = ((phi_cnm * n_min_error)**2 + \
                                   (n_min * phi_cnm_error)**2)**0.5

            if 0:
                if cloud == 'perseus':
                    print 'habing median', core['rad_field_habing_median']
                    print 'phi_cnm', phi_cnm
                    print 'n_cnm', core['n_cnm']

            #print core['n_cnm_error']

            core['T_cnm'], core['T_cnm_error'] = \
                calc_temperature(n_H=core['n_cnm'],
                                 pressure=pressure,
                                 pressure_error=pressure_error,
                                 n_H_error=core['n_cnm_error'])

            core['chi'], core['chi_error'] =\
                myk09.calc_chi(phi_cnm=phi_cnm,
                               phi_cnm_error=phi_cnm_error,
                               Z=Z,
                               Z_error=Z_error,
                               sigma_d=sigma_d,
                               sigma_d_error=sigma_d_error,
                               )

        else:
            core['T_cnm'], core['T_cnm_error'] = \
                    myk09.calc_T_cnm(core['krumholz']['phi_cnm'],
                        phi_cnm_error=core['krumholz']['phi_cnm_error'],
                        calc_error=True,
                        )

            core['n_cnm'], core['n_cnm_error'] = \
                    myk09.calc_n_cnm(G_0=(core['rad_field'] / 1.7),
                             G_0_error=(core['rad_field_error'] / 1.7),
                             T_cnm=core['T_cnm'],
                             T_cnm_error=core['T_cnm_error'],
                             calc_error=True,
                             )


        core['T_cnm'], core['T_cnm_error'] = \
            calc_temperature(n_H=core['n_cnm'],
                             pressure=pressure,
                             pressure_error=pressure_error,
                             n_H_error=core['n_cnm_error'])



        core['alt_name'] = get_alt_name(core_name)