def AllStars(Nside, filter=None): """ Plot all stars in one map. And make a distribution of the distance to the stars. Input: Nside, filter """ print('Plot all stars in map with filter = {}'.format(filter)) f = h5py.File('SPC_Nside_{}.h5'.format(Nside), 'r') pixcoord = np.asarray(f['Healpix coordinates']) f.close() Npix = hp.nside2npix(Nside) print('Plot all stars with Nside=', Nside) # Find a way to add intensity if filter != None: # Add intensity. With filters, Green, Blue, Red and their mean: print('Include magnitude as weights, with green, blue, red and mean') w = Tools.AddIntensity(filter) Map, b = np.histogram(pixcoord, Npix, weights=w) print('Map with {} filter'.format(filter)) logmap = np.log(Map) logmap[np.isinf(logmap)] = -60 hp.mollview(logmap, coord=['C', 'G'], nest=False, title='All stars in {} filter, Nside = {}'.format( filter, Nside), unit='Nstars') plt.savefig('Figures2/AllStars_{}_Nside{}.png'.format(filter, Nside)) else: # Map of all stars, No filters print('No filters') m, b = Tools.Map(pixcoord, Npix) hp.mollview(m, coord=['C', 'G'], nest=False, title='All stars, Nside = {}'.format(Nside), unit='Nstars') plt.savefig('Figures2/AllStars_Nside{}.png'.format(Nside)) plt.show()
def DistributeDistance(Nside, Nmaps=None, Rmax=5e4, Rmin=0.1, Bin_seq=None, cutoff=None, filter=None, h=False, OverError=False): """ Distribute distance of the stars, also apply the sky coordinate. Input: - Nside, int-scalar or list. Not array - Nmaps, optional, Number of maps to generate - Rmax, scalar, distance [pc] to generate maps up to, start from zero, default = 5e4 pc used with Nmaps - Rmin, scalar, distance [pc] to generate maps up to, start from zero, default = 0.1 pc used with Nmaps - Bin_seq, optional, list of bin edges, manually made - cutoff, optional, int-scalar, upper limit of bin edge to iterate up to. Used with Bin_seq - filter, optional, str, either 'mean', 'G', 'B', 'R'. Used in call for AddIntensity() function, default is 'None' - h, optional, bool, if True create histograms of the stellar distribution of distance. Else maps - OverError, bool If True also apply the errors for stars with over error, percentile > 1. Else no computation ov over error """ if (Bin_seq == None) and (Nmaps == None): """ No bins and no Nmaps. Abort """ print('No bin sequence and no Nmaps as input argument.') sys.exit() # Read files f1 = h5py.File('Distance.h5', 'r') dist = np.asarray(f1['distance']) f1.close() dist_err = Tools.DistError(dist) # check for nan values in dist: ii = Tools.NoDistance(dist) dist = dist[ii] dist_err = dist_err[ii] print('Length of data:', len(dist)) # radial distance rad_dist = np.abs(dist) Nside_old = 0 # Distance percentile: percentile = dist_err / rad_dist percentile = np.nan_to_num(percentile) # Add intesity: if filter != None: print('Load weights') weight = Tools.AddIntensity(filter) weight = weight[ii] else: print('Use no filter') weight = np.ones(len(rad_dist)) # Test input parameters if (Bin_seq != None) and (Nmaps != None): """ Have both bin seq. and Nmaps, then use Nmaps as default. """ print('Input both Bin_seq and Nmaps. Use Nmaps.') Bin_seq = None if Bin_seq == None: """ Use Nmaps, no Bin sequence input Nmaps, Rmax, Rmin, rad_dist, dist_err, percentile, weight, ii """ print('Use {} numbers of maps to map the star distribution'.format( Nmaps)) size = (Rmax - Rmin) / Nmaps Bins = np.arange(Rmin, Rmax + 10, size) print('Bin size: {}, bin edges:'.format(size)) print(Bins) inte_ind = np.where(percentile > 0.01) uu_ind, ll_ind = [], [] over_ind = np.where((percentile > 1) & (percentile < 10) & (rad_dist < 100 * Bins[-1]) & (rad_dist > Bins[-1])) over_ind = over_ind[0] OverUncer = percentile[over_ind] # Loop over the the number of maps for i in range(Nmaps): print('=============') ind = np.where((rad_dist > Bins[i]) & (rad_dist <= Bins[i + 1])) print('Bin number {}'.format(i)) rad = rad_dist[ind] # Find appropriate Nside Ns, Npix = Tools.Find_Nside(Nside, len(rad)) print('Use Nside:', Nside) # load pix coordinate for the given Nside if Ns == Nside_old: pass else: # read file print('read file for Nside {}'.format(Ns)) f2 = h5py.File('SPC_Nside_{}.h5'.format(Ns), 'r') pixcoord = np.asarray(f2['Healpix coordinates']) f2.close() pixcoord = pixcoord[ii] #### # Apply error: if filter == None: pass else: w, pixel, rad, iup = Tools.ApplyErrorNmaps( Nmaps, i, ind, Bins, pixcoord, rad_dist, dist_err, percentile, weight, uu_ind, over_ind, OverError) uu_ind = iup # end apply error if test # call plotting Tools.PlotMaps(pixel, Ns, Npix, w, rad, Bins, i, filter) Nside_old = Ns ################## # end Nmaps part if Nmaps == None: """ Use Bin_seq, no Nmaps as input. Bin_seq, Cutoff, rad_dist, dist_err, percentile, weight, ii, filter """ print('Manually defined bins to map the stars, with bin edges:') print(Bin_seq) # test cut off if cutoff == None: cutoff = len(Bin_seq) if cutoff < 1: print('Cut off too low. Exit') sys.exit() if cutoff > len(Bin_seq): print('Cut off too high. Exit') sys.exit() else: print( 'Use {} bins in distributing the stars after distance.'.format( cutoff - 1)) # Need the indexes going into each bin # Cut off at different distances, able to plot at each distance. Do not save the data for each distance inte_ind = np.where(percentile > 0.01) uu_ind, ll_ind = [], [] over_ind = np.where((percentile > 1) & (percentile < 10) & (rad_dist < 100 * Bin_seq[-1]) & (rad_dist > Bin_seq[-1])) over_ind = over_ind[0] OverUncer = percentile[over_ind] # Loop over the the number of maps for i in range(len(Bin_seq) - 1): print('==================') ind = np.where((rad_dist >= Bin_seq[i]) & (rad_dist < Bin_seq[i + 1])) rad = rad_dist[ind] print('Bin number {}'.format(i)) # Find an approproate Nside: Ns, Npix = Tools.Find_Nside(Nside, len(rad)) # load pix coordinate for the given Nside if Ns == Nside_old: pass else: # read file print('read file for Nside {}'.format(Ns)) f2 = h5py.File('SPC_Nside_{}.h5'.format(Ns), 'r') pixcoord = np.asarray(f2['Healpix coordinates']) f2.close() pixcoord = pixcoord[ii] ### # call Apply error if filter == None: pass else: # Apply error: pix, w, rad, iup = Tools.ApplyErrorBinSeq( Bin_seq, i, ind, pixcoord, rad_dist, dist_err, percentile, weight, uu_ind, over_ind, cutoff, OverError) uu_ind = iup # end apply error testing # Plotting Tools.PlotMaps(pix, Ns, Npix, w, rad, Bin_seq, i, filter) Nside_old = Ns if i == cutoff - 1: print('Cut off reached') break ###### plt.show()
def IntensityMapping(Nside, filter=None): """ Distribute stars after their magnitude. Find which stars that have a magnitude within a range and plot the star in each magnitude range. Plot also weighted with respect to magnitude Input: - Nside, scalar - filter, string, either 'mean', 'G', 'BP', 'RP'. """ f1 = h5py.File('SPC_Nside_{}.h5'.format(Nside), 'r') pixcoord = np.asarray(f1['Healpix coordinates']) f1.close() if filter != None: f3 = h5py.File('Distance.h5', 'r') dist = np.asarray(f3['distance']) f3.close() dist = np.nan_to_num(dist) ii = np.nonzero(dist) rad = np.abs(dist[ii]) else: pass #### w = Tools.AddIntensity(filter) if filter == None: f2 = h5py.File('Mean_Mag_G.h5', 'r') Mag = np.asarray(f2['mean_mag_G']) f2.close() n = np.isnan(Mag) ifnan = np.where(n == True) Mag[ifnan] = ZP_green else: Mag = -np.log10(w) Npix = hp.nside2npix(Nside) N = len(Mag) Bins = [26, 20, 15, 10, 5, np.min(Mag) * 0.9] ind0 = np.where( (Mag <= min(Bins))) # Check for stars with magnitude stronger than 0 for i in range(len(Bins) - 1): print('Magnitude range: {} to {}'.format(Bins[i], Bins[i + 1])) ind = np.where((Mag < Bins[i]) & (Mag >= Bins[i + 1])) if filter == None: m, b = Tools.Map(pixcoord[ind], Npix) logmap = np.log10(m) logmap[np.isinf(logmap)] = 0 hp.mollview(logmap, coord=['C', 'G'], nest=False, title='Magnitude form {} mag to {} mag'.format( Bins[i], Bins[i + 1]), unit='Nstars') plt.savefig('Figures2/Mag_dist_Nside{}.png'.format(Nside)) if filter != None: Map, b = np.histogram(pixcoord[ind], Npix, weights=w[ind]) logMap = np.log10(Map) logMap[np.isinf(logMap)] = -Bins[i] hp.mollview(logMap, coord=['C', 'G'], nest=False, title='Weighted for mag {} to {}'.format( Bins[i], Bins[i + 1]), unit='Nstars') plt.savefig('Figures2/wMag_{}_Nside{}.png'.format(filter, Nside)) plt.figure('hist {}'.format(i - 1)) plt.hist(rad[ind], 100) plt.xlabel('pc') plt.gca().set_xscale('log') plt.gca().set_yscale('log') plt.savefig('Figures2/mag_distribution_{}.png'.format(filter)) plt.show()