def calculate_aic(eigenworms_matrix_path, shapes_file, coiled_modes_file, num_modes): eigenworms_matrix = np.loadtxt(eigenworms_matrix_path, delimiter=",").astype(np.float32) # Load angle library f = scipy.io.loadmat(shapes_file) thetas_w = ma.array(f["theta_ensemble"]) thetas_w[thetas_w == 0] = ma.masked thetas_library_raw = ma.compress_rows(ma.vstack(thetas_w)) raw_samples = thetas_library_raw[::2] # Load coiled modes library with h5py.File(coiled_modes_file, "r") as mat: refs = list(mat["#refs#"].keys())[1:] tseries_w = [ ma.masked_invalid(np.array(mat["#refs#"][ref]).T)[:, :num_modes] for ref in refs ] modes_library = ma.compress_rows(ma.vstack(tseries_w)) # find indices with larger curvature (on the tail of the distribution of angles that can be solved) indices_curved = np.abs(modes_library[:, 2]) > np.percentile( raw_samples.dot(eigenworms_matrix[:, 2]), 95) curved_samples = modes_library[indices_curved].dot( eigenworms_matrix[:, :num_modes].T) # combine samples thetas_library_combined = np.vstack((curved_samples, raw_samples)) # sample uniformly from various degrees of curvature indices = _uniform_samples( thetas_library_combined.dot(eigenworms_matrix[:, 2])) training_data = thetas_library_combined[indices] aic = [] n_components_range = np.arange(150, 350, 10) for n_components in n_components_range: # Fit a Gaussian mixture with EM try: gmm = GaussianMixture(n_components=n_components) gmm.fit(training_data) aic.append(gmm.aic(training_data)) except: aic.append(np.nan) return np.vstack((n_components_range, aic)).T
def _calculate_values(function, points, dimension, cell_mask=None): """Calculate function values at given reference points :arg function: function to be sampled :arg points: points to be sampled in reference space :arg cell_mask: Masks for cell node list """ import numpy.ma as ma function_space = function.function_space() keys = {1: (0,), 2: (0, 0)} fiat_element = create_element(function_space.ufl_element(), vector_is_mixed=False) elem = fiat_element.tabulate(0, points)[keys[dimension]] cell_node_list = function_space.cell_node_list if cell_mask is not None: cell_mask = np.tile(cell_mask.reshape(-1, 1), cell_node_list.shape[1]) cell_node_list = ma.compress_rows(ma.masked_array(cell_node_list, mask=cell_mask)) data = function.dat.data_ro[cell_node_list] if function.ufl_shape == (): vec_length = 1 else: vec_length = function.ufl_shape[0] if vec_length == 1: data = np.reshape(data, data.shape+(1, )) return np.einsum("ijk,jl->ilk", data, elem)
def norm_smooth3(self, x, smorder=False): # A version of smooth3x that is designed to simply return a smoothed # version of the passed array without, altering any execution state # variables or objects. Was made to solve a problem in whole_spec_plot # where an array seprate from self.sm was needed. if smorder == False: order = self.order else: order = smorder x = ma.compress_rows(x) nelm = np.shape(x)[0] sm = np.zeros((int(math.floor(nelm / 3)), 2)) for i in range(int(math.floor(nelm / 3))): n = 3 * i sm[i, 0] = (x[n, 0] + x[n + 1, 0] + x[n + 2, 0]) / 3 sm[i, 1] = (x[n, 1] + x[n + 1, 1] + x[n + 2, 1]) / 3 return sm if self.state['trimmed'][order] == True: masked = np.empty(np.shape(self.sm[order])) masked.fill(False) for r in range(np.shape(self.spec_trim_points[order])[0]): start = self.spec_trim_points[order][r, 0] end = self.spec_trim_points[order][r, 1] mask = np.empty(np.shape(self.sm[order])) mask[:, 0] = np.logical_and(self.sm[order][:, 0] >= start, self.sm[order][:, 0] <= end) mask[:, 1] = np.logical_and(self.sm[order][:, 0] >= start, self.sm[order][:, 0] <= end) maskednew1 = np.where(mask[:, 0] == True) maskednew2 = np.where(mask[:, 1] == True) masked[maskednew1, 0] = True masked[maskednew2, 1] = True #self.sm[order] = ma.masked_array(self.sm[order], # mask=masked) sm = ma.masked_array(self.sm[order], mask=masked) return sm
def smooth3(self, x, smorder=False): # the order keyword and acompanying if statement allow the function be # called on a specific order (as in plotting) or on the current order # specified by state (as during interacvie normalization). if smorder == False: order = self.order else: order = smorder x = ma.compress_rows(x) nelm = np.shape(x)[0] self.sm[order] = np.zeros((int(math.floor(nelm / 3)), 2)) sm = self.sm[order] for i in range(int(math.floor(nelm / 3))): n = 3 * i sm[i, 0] = (x[n, 0] + x[n + 1, 0] + x[n + 2, 0]) / 3 sm[i, 1] = (x[n, 1] + x[n + 1, 1] + x[n + 2, 1]) / 3 #self.sm[order] = sm self.state['w_smoothed'][order] = True if self.state['trimmed'][order] == True: masked = np.empty(np.shape(self.sm[order])) masked.fill(False) for r in range(np.shape(self.spec_trim_points[order])[0]): start = self.spec_trim_points[order][r, 0] end = self.spec_trim_points[order][r, 1] mask = np.empty(np.shape(self.sm[order])) mask[:, 0] = np.logical_and(self.sm[order][:, 0] >= start, self.sm[order][:, 0] <= end) mask[:, 1] = np.logical_and(self.sm[order][:, 0] >= start, self.sm[order][:, 0] <= end) maskednew1 = np.where(mask[:, 0] == True) maskednew2 = np.where(mask[:, 1] == True) masked[maskednew1, 0] = True masked[maskednew2, 1] = True self.sm[order] = ma.masked_array(self.sm[order], mask=masked)
def _calculate_values(function, points, dimension, cell_mask=None): """Calculate function values at given reference points :arg function: function to be sampled :arg points: points to be sampled in reference space :arg cell_mask: Masks for cell node list """ import numpy.ma as ma function_space = function.function_space() keys = {1: (0, ), 2: (0, 0)} # Such tabulation could be done with FInAT, but that would be more # complicated, and there is no clear benefit to changing. fiat_element = create_base_element( function_space.ufl_element()).fiat_equivalent elem = fiat_element.tabulate(0, points)[keys[dimension]] cell_node_list = function_space.cell_node_list if cell_mask is not None: cell_mask = np.tile(cell_mask.reshape(-1, 1), cell_node_list.shape[1]) cell_node_list = ma.compress_rows( ma.masked_array(cell_node_list, mask=cell_mask)) data = function.dat.data_ro[cell_node_list] if function.ufl_shape == (): vec_length = 1 else: vec_length = function.ufl_shape[0] if vec_length == 1: data = np.reshape(data, data.shape + (1, )) return np.einsum("ijk,jl->ilk", data, elem)
def _calculate_values(function, points, dimension, cell_mask=None): """Calculate function values at given reference points :arg function: function to be sampled :arg points: points to be sampled in reference space :arg cell_mask: Masks for cell node list """ import numpy.ma as ma function_space = function.function_space() keys = {1: (0,), 2: (0, 0)} elem = function_space.fiat_element.tabulate(0, points)[keys[dimension]] cell_node_list = function_space.cell_node_list if cell_mask is not None: cell_mask = np.tile(cell_mask.reshape(-1, 1), cell_node_list.shape[1]) cell_node_list = ma.compress_rows(ma.masked_array(cell_node_list, mask=cell_mask)) data = function.dat.data_ro[cell_node_list] if function.ufl_shape == (): vec_length = 1 else: vec_length = function.ufl_shape[0] if vec_length == 1: data = np.reshape(data, data.shape+(1, )) return np.einsum("ijk,jl->ilk", data, elem)
def norm_smooth3(self, x, smorder=False): # A version of smooth3x that is designed to simply return a smoothed # version of the passed array without, altering any execution state # variables or objects. Was made to solve a problem in whole_spec_plot # where an array seprate from self.sm was needed. if smorder == False: order=self.order else: order = smorder x = ma.compress_rows(x) nelm = np.shape(x)[0] sm = np.zeros( (int(math.floor(nelm/3)),2) ) for i in range(int(math.floor(nelm/3))): n=3*i sm[i,0] = ( x[n,0] + x[n+1,0] + x[n+2,0] ) / 3 sm[i,1] = ( x[n,1] + x[n+1,1] + x[n+2,1] ) / 3 return sm if self.state['trimmed'][order] == True: masked = np.empty(np.shape(self.sm[order])) masked.fill(False) for r in range(np.shape(self.spec_trim_points[order])[0]): start = self.spec_trim_points[order][r,0] end = self.spec_trim_points[order][r,1] mask = np.empty(np.shape(self.sm[order])) mask[:,0] = np.logical_and(self.sm[order][:,0] >= start, self.sm[order][:,0] <= end) mask[:,1] = np.logical_and(self.sm[order][:,0] >= start, self.sm[order][:,0] <= end) maskednew1 = np.where(mask[:,0] == True) maskednew2 = np.where(mask[:,1] == True) masked[maskednew1,0] = True masked[maskednew2,1] = True #self.sm[order] = ma.masked_array(self.sm[order], # mask=masked) sm = ma.masked_array(self.sm[order],mask=masked) return sm
def smooth3(self, x, smorder=False): # the order keyword and acompanying if statement allow the function be # called on a specific order (as in plotting) or on the current order # specified by state (as during interacvie normalization). if smorder == False: order=self.order else: order = smorder x = ma.compress_rows(x) nelm = np.shape(x)[0] self.sm[order] = np.zeros( (int(math.floor(nelm/3)),2) ) sm = self.sm[order] for i in range(int(math.floor(nelm/3))): n=3*i sm[i,0] = ( x[n,0] + x[n+1,0] + x[n+2,0] ) / 3 sm[i,1] = ( x[n,1] + x[n+1,1] + x[n+2,1] ) / 3 #self.sm[order] = sm self.state['w_smoothed'][order] = True if self.state['trimmed'][order] == True: masked = np.empty(np.shape(self.sm[order])) masked.fill(False) for r in range(np.shape(self.spec_trim_points[order])[0]): start = self.spec_trim_points[order][r,0] end = self.spec_trim_points[order][r,1] mask = np.empty(np.shape(self.sm[order])) mask[:,0] = np.logical_and(self.sm[order][:,0] >= start, self.sm[order][:,0] <= end) mask[:,1] = np.logical_and(self.sm[order][:,0] >= start, self.sm[order][:,0] <= end) maskednew1 = np.where(mask[:,0] == True) maskednew2 = np.where(mask[:,1] == True) masked[maskednew1,0] = True masked[maskednew2,1] = True self.sm[order] = ma.masked_array(self.sm[order], mask=masked)
def generate(shapes_file, coiled_modes_file, eigenworms_matrix_path, out_file, num_gaussians): # Load angle library from Greg f = scipy.io.loadmat(shapes_file) thetas_w = ma.array(f["theta_ensemble"]) thetas_w[thetas_w == 0] = ma.masked thetas_library_raw = ma.compress_rows(ma.vstack(thetas_w)) # Load library from Onno mat = h5py.File(coiled_modes_file, "r") refs = list(mat["#refs#"].keys())[1:] tseries_w = [ma.masked_invalid(np.array(mat["#refs#"][ref]).T)[:, :5] for ref in refs] mat.close() modes_library = ma.compress_rows(ma.vstack(tseries_w)) eigenworms_matrix = np.loadtxt(eigenworms_matrix_path, delimiter=",").astype(np.float32) # same number of samples from full theta # raw_samples = thetas_library_raw[np.random.choice(np.arange(len(thetas_library_raw)),np.sum(indices_curved),replace=False)] raw_samples = thetas_library_raw[::2] # find indices with larger curvature indices_curved = np.abs(modes_library[:, 2]) > np.percentile(raw_samples.dot(eigenworms_matrix[:, 2]), 97.5) # get same number of samples from raw angles and projected modes curved_samples = modes_library[indices_curved].dot(eigenworms_matrix[:, :5].T) thetas_library_combined = np.vstack((curved_samples, raw_samples)) indices = uniform_samples(thetas_library_combined.dot(eigenworms_matrix[:, 2])) training_data = thetas_library_combined[indices] # fit gaussian mixture model gmm = GaussianMixture(n_components=num_gaussians) gmm.fit(training_data) # sort according to curvature sorting_indices = np.argsort(np.sum(np.abs(np.diff(gmm.means_, axis=1)), axis=1)) means = gmm.means_[sorting_indices] covariances = gmm.covariances_[sorting_indices] weights = gmm.weights_[sorting_indices] with gzip.open(out_file, "wt") as f: json.dump({"means": means.tolist(), "covariances": covariances.tolist(), "weights": weights.tolist()}, f)
def __ReturnArrayWithDetectedPixels(self, HSV_Image): BinaryArrayOfDetectedPixels = self.__ReturnBinaryArrayOfDetectedPixels( HSV_Image) ArrayOfAllDetecedPlasticPixels = ma.masked_array( (self.HSV_Image), mask=BinaryArrayOfDetectedPixels) height, width, channels = HSV_Image.shape ArrayOfAllDetecedPlasticPixels = np.reshape( ArrayOfAllDetecedPlasticPixels, ((height * width), 3)) ArrayOfAllDetecedPlasticPixels = ma.compress_rows( ArrayOfAllDetecedPlasticPixels) return ArrayOfAllDetecedPlasticPixels
def _filter(varname1, varname2, column, value, operator): """Generates a numpy mask, masks input array, returns compressed output to variables dict""" # To do: generate masks programatically given operator input # Operators are reversed in mask because true values are masked, not false if operator == '==': mask = np.repeat(VARIABLES[varname1][:, column] == value, VARIABLES[varname1].shape[1]) elif operator == '>': mask = np.repeat(VARIABLES[varname1][:, column] <= value, VARIABLES[varname1].shape[1]) elif operator == '>=': mask = np.repeat(VARIABLES[varname1][:, column] < value, VARIABLES[varname1].shape[1]) elif operator == '<': mask = np.repeat(VARIABLES[varname1][:, column] >= value, VARIABLES[varname1].shape[1]) elif operator == '<=': mask = np.repeat(VARIABLES[varname1][:, column] > value, VARIABLES[varname1].shape[1]) VARIABLES[varname2] = ma.compress_rows( ma.array(VARIABLES[varname1], mask=mask))
def plot_x(data, outfile, outformat, args, normalize=False): """Limit plot as a function of the source flavor ratio for each operator texture.""" print('Making X sensitivity plot') dim = args.dimension if dim < 5: normalize = False srcs = args.source_ratios x_arr = np.array([i[0] for i in srcs]) if args.texture is Texture.NONE: textures = [Texture.OEU, Texture.OET, Texture.OUT] else: textures = [args.texture] # Rearrange data structure r_data = np.full( (data.shape[1], data.shape[0], data.shape[2], data.shape[3]), np.nan) for isrc in range(data.shape[0]): for itex in range(data.shape[1]): r_data[itex][isrc] = data[isrc][itex] r_data = ma.masked_invalid(r_data) print(r_data.shape, 'r_data.shape') fig = plt.figure(figsize=(7, 6)) ax = fig.add_subplot(111) ylims = SCALE_BOUNDARIES[dim] if normalize: if dim == 5: ylims = (-24, -8) if dim == 6: ylims = (-12, 8) if dim == 7: ylims = (0, 20) if dim == 8: ylims = (12, 36) else: if dim == 3: ylims = (-28, -22) if dim == 4: ylims = (-35, -26) if dim == 5: SCALE_BOUNDARIES[5] xlims = (0, 1) colour = {0: 'red', 2: 'blue', 1: 'green'} rgb_co = {0: [1, 0, 0], 2: [0, 0, 1], 1: [0.0, 0.5019607843137255, 0.0]} legend_log = [] legend_elements = [] labelsize = 13 largesize = 17 ax.set_xlim(xlims) ax.set_ylim(ylims) xticks = [0, 1 / 3., 0.5, 2 / 3., 1] # xlabels = [r'$0$', r'$\frac{1}{3}$', r'$\frac{1}{2}$', r'$\frac{2}{3}$', r'$1$'] xlabels = [r'$0$', r'$1 / 3$', r'$1/2$', r'$2/3$', r'$1$'] ax.set_xticks([], minor=True) ax.set_xticks(xticks, minor=False) ax.set_xticklabels(xlabels, fontsize=largesize) if dim != 4 or dim != 3: yticks = range(ylims[0], ylims[1], 2) + [ylims[1]] ax.set_yticks(yticks, minor=False) if dim == 3 or dim == 4: yticks = range(ylims[0], ylims[1], 1) + [ylims[1]] ax.set_yticks(yticks, minor=False) # for ymaj in ax.yaxis.get_majorticklocs(): # ax.axhline(y=ymaj, ls=':', color='gray', alpha=0.2, linewidth=1) for xmaj in xticks: if xmaj == 1 / 3.: ax.axvline(x=xmaj, ls='--', color='gray', alpha=0.5, linewidth=0.3) # else: # ax.axvline(x=xmaj, ls=':', color='gray', alpha=0.2, linewidth=1) ax.text((1 / 3.) + 0.01, 0.01, r'$(0.33:0.66:0)_\text{S}$', fontsize=labelsize, transform=ax.transAxes, rotation='vertical', va='bottom') ax.text(0.96, 0.01, r'$(1:0:0)_\text{S}$', fontsize=labelsize, transform=ax.transAxes, rotation='vertical', va='bottom', ha='left') ax.text(0.01, 0.01, r'$(0:1:0)_\text{S}$', fontsize=labelsize, transform=ax.transAxes, rotation='vertical', va='bottom') yl = 0.55 if dim == 3: yl = 0.65 ax.text(0.03, yl, r'${\rm \bf Excluded}$', fontsize=largesize, transform=ax.transAxes, color='g', rotation='vertical', zorder=10) ax.text(0.95, 0.55, r'${\rm \bf Excluded}$', fontsize=largesize, transform=ax.transAxes, color='b', rotation='vertical', zorder=10) for itex, tex in enumerate(textures): print('|||| TEX = {0}'.format(tex)) lims = np.full(len(srcs), np.nan) for isrc, src in enumerate(srcs): x = src[0] print('|||| X = {0}'.format(x)) args.source_ratio = src d = r_data[itex][isrc] if np.sum(d.mask) > 2: continue scales, statistic = ma.compress_rows(d).T lim = get_limit(deepcopy(scales), deepcopy(statistic), args, mask_initial=True) if lim is None: continue if normalize: lim -= np.log10(PLANCK_SCALE[dim]) lims[isrc] = lim lims = ma.masked_invalid(lims) size = np.sum(~lims.mask) if size == 0: continue print('x_arr, lims', zip(x_arr, lims)) if normalize: zeropoint = 100 else: zeropoint = 0 lims[lims.mask] = zeropoint l0 = np.argwhere(lims == zeropoint)[0] h0 = len(lims) - np.argwhere(np.flip(lims, 0) == zeropoint)[0] lims[int(l0):int(h0)] = zeropoint x_arr_a = [x_arr[0] - 0.1] + list(x_arr) x_arr_a = list(x_arr_a) + [x_arr_a[-1] + 0.1] lims = [lims[0]] + list(lims) lims = list(lims) + [lims[-1]] s = 0.2 g = 2 if dim == 3 and tex == Texture.OUT: s = 0.4 g = 4 if dim in (4, 5) and tex == Texture.OUT: s = 0.5 g = 5 if dim == 7 and tex == Texture.OET: s = 1.6 g = 2 if dim == 7 and tex == Texture.OUT: s = 2.0 g = 20 if dim == 8 and tex == Texture.OET: s = 0.8 g = 6 if dim == 8 and tex == Texture.OUT: s = 1.7 g = 8 # ax.scatter(x_arr_a, lims, color='black', s=1) tck, u = splprep([x_arr_a, lims], s=0, k=1) x, y = splev(np.linspace(0, 1, 200), tck) tck, u = splprep([x, y], s=s) x, y = splev(np.linspace(0, 1, 400), tck) y = gaussian_filter(y, sigma=g) ax.fill_between(x, y, zeropoint, color=rgb_co[itex] + [0.3]) # ax.scatter(x, y, color='black', s=1) # ax.scatter(x_arr_a, lims, color=rgb_co[itex], s=8) if itex not in legend_log: legend_log.append(itex) # label = texture_label(tex, dim)[:-1] + r'\:{\rm\:texture}$' label = texture_label(tex, dim)[:-1] + r'\:({\rm this\:work})$' legend_elements.append( Patch(facecolor=rgb_co[itex] + [0.3], edgecolor=rgb_co[itex] + [1], label=label)) LV_lim = np.log10(LV_ATMO_90PC_LIMITS[dim]) if normalize: LV_lim -= np.log10(PLANCK_SCALE[dim]) ax.add_patch( patches.Rectangle((xlims[0], LV_lim[1]), np.diff(xlims), LV_lim[0] - LV_lim[1], fill=False, hatch='\\\\')) if dim in PLANCK_SCALE: ps = np.log10(PLANCK_SCALE[dim]) if normalize and dim == 6: ps -= np.log10(PLANCK_SCALE[dim]) ax.add_patch( Arrow(0.24, -0.009, 0, -5, width=0.12, capstyle='butt', facecolor='purple', fill=True, alpha=0.8, edgecolor='darkmagenta')) ax.add_patch( Arrow(0.78, -0.009, 0, -5, width=0.12, capstyle='butt', facecolor='purple', fill=True, alpha=0.8, edgecolor='darkmagenta')) ax.text(0.26, 0.5, r'${\rm \bf Quantum\:Gravity\:Frontier}$', fontsize=largesize - 2, transform=ax.transAxes, va='top', ha='left', color='purple') if dim > 5: ax.axhline(y=ps, color='purple', alpha=1., linewidth=1.5) cpt = r'c' if dim % 2 == 0 else r'a' if normalize: ft = r'${\rm New\:Physics\:Scale}\:[\:{\rm log}_{10} \left (\mathring{'+cpt+r'}^{(' + \ r'{0}'.format(args.dimension)+r')}\cdot{\rm E}_{\:\rm P}' if dim > 5: ft += r'^{\:' + r'{0}'.format(args.dimension - 4) + r'}' ft += r'\right )\: ]$' fig.text(0.01, 0.5, ft, ha='left', va='center', rotation='vertical', fontsize=largesize) else: fig.text( 0.01, 0.5, r'${\rm New\:Physics\:Scale}\:[\:{\rm log}_{10} \left (\mathring{' + cpt + r'}^{(' + r'{0}'.format(args.dimension) + r')}\:' + get_units(args.dimension) + r'\right )\: ]$', ha='left', va='center', rotation='vertical', fontsize=largesize) ax.set_xlabel( r'${\rm Source\:Composition}\:[\:\left (\:x:1-x:0\:\right )_\text{S}\:]$', labelpad=10, fontsize=largesize) ax.tick_params(axis='x', labelsize=largesize - 1) purple = [0.5019607843137255, 0.0, 0.5019607843137255] # legend_elements.append( # Patch(facecolor=purple+[0.7], edgecolor=purple+[1], label='Planck Scale Expectation') # ) legend_elements.append( Patch(facecolor='none', hatch='\\\\', edgecolor='k', label='IceCube [TODO]')) legend = ax.legend(handles=legend_elements, prop=dict(size=labelsize - 2), loc='upper center', title='Excluded regions', framealpha=1., edgecolor='black', frameon=True, bbox_to_anchor=(0.5, 1)) plt.setp(legend.get_title(), fontsize=labelsize) legend.get_frame().set_linestyle('-') # ybound = 0.14 # if args.data is DataType.REAL: # fig.text(0.7, ybound, r'\bf IceCube Preliminary', color='red', fontsize=13, # ha='center', va='center', zorder=11) # elif args.data is DataType.REALISATION: # fig.text(0.7, ybound-0.05, r'\bf IceCube Simulation', color='red', fontsize=13, # ha='center', va='center', zorder=11) # else: # fig.text(0.7, ybound, r'\bf IceCube Simulation', color='red', fontsize=13, # ha='center', va='center', zorder=11) make_dir(outfile) for of in outformat: print('Saving plot as {0}'.format(outfile + '.' + of)) fig.savefig(outfile + '.' + of, bbox_inches='tight', dpi=150)
def plot_table_sens(data, outfile, outformat, args, show_lvatmo=True): print('Making TABLE sensitivity plot') argsc = deepcopy(args) dims = args.dimensions srcs = args.source_ratios if args.texture is Texture.NONE: textures = [Texture.OET, Texture.OUT] else: textures = [args.texture] if len(srcs) > 3: raise NotImplementedError xlims = (-60, -20) ylims = (0.5, 1.5) colour = {2: 'red', 1: 'blue', 0: 'green'} rgb_co = {2: [1, 0, 0], 1: [0, 0, 1], 0: [0.0, 0.5019607843137255, 0.0]} fig = plt.figure(figsize=(8, 6)) gs = gridspec.GridSpec(len(dims), 1) gs.update(hspace=0.15) first_ax = None legend_log = [] legend_elements = [] for idim, dim in enumerate(dims): print('|||| DIM = {0}'.format(dim)) argsc.dimension = dim gs0 = gridspec.GridSpecFromSubplotSpec(len(textures), 1, subplot_spec=gs[idim], hspace=0) for itex, tex in enumerate(textures): argsc.texture = tex ylabel = texture_label(tex, dim) # if angles == 2 and ian == 0: continue ax = fig.add_subplot(gs0[itex]) if first_ax is None: first_ax = ax ax.set_xlim(xlims) ax.set_ylim(ylims) ax.set_yticks([], minor=True) ax.set_yticks([1.], minor=False) ax.set_yticklabels([ylabel], fontsize=13) ax.yaxis.tick_right() for xmaj in ax.xaxis.get_majorticklocs(): ax.axvline(x=xmaj, ls=':', color='gray', alpha=0.2, linewidth=1) ax.get_xaxis().set_visible(False) if itex == len(textures) - 2: ax.spines['bottom'].set_alpha(0.6) elif itex == len(textures) - 1: ax.text(-0.04, 1.0, '$d = {0}$'.format(dim), fontsize=16, rotation='90', verticalalignment='center', transform=ax.transAxes) # dim_label_flag = False ax.spines['top'].set_alpha(0.6) ax.spines['bottom'].set_alpha(0.6) for isrc, src in enumerate(srcs): print('== src', src) argsc.source_ratio = src if dim in PLANCK_SCALE.iterkeys(): ps = np.log10(PLANCK_SCALE[dim]) if ps < xlims[0]: ax.annotate(s='', xy=(xlims[0], 1), xytext=(xlims[0] + 1, 1), arrowprops={ 'arrowstyle': '->, head_length=0.2', 'lw': 1, 'color': 'purple' }) elif ps > xlims[1]: ax.annotate(s='', xy=(xlims[1] - 1, 1), xytext=(xlims[1], 1), arrowprops={ 'arrowstyle': '<-, head_length=0.2', 'lw': 1, 'color': 'purple' }) else: ax.axvline(x=ps, color='purple', alpha=1., linewidth=1.5) try: scales, statistic = ma.compress_rows( data[idim][isrc][itex]).T except: continue lim = get_limit(deepcopy(scales), deepcopy(statistic), argsc, mask_initial=True) if lim is None: continue ax.axvline(x=lim, color=colour[isrc], alpha=1., linewidth=1.5) ax.add_patch( patches.Rectangle((lim, ylims[0]), 100, np.diff(ylims), fill=True, facecolor=colour[isrc], alpha=0.3, linewidth=0)) if isrc not in legend_log: legend_log.append(isrc) label = r'$\left('+r'{0}'.format(solve_ratio(src)).replace('_',':')+ \ r'\right)_{\text{S}}\:\text{at\:source}$' legend_elements.append( Patch(facecolor=rgb_co[isrc] + [0.3], edgecolor=rgb_co[isrc] + [1], label=label)) if itex == len(textures) - 1 and show_lvatmo: LV_lim = np.log10(LV_ATMO_90PC_LIMITS[dim]) ax.add_patch( patches.Rectangle((LV_lim[1], ylims[0]), LV_lim[0] - LV_lim[1], np.diff(ylims), fill=False, hatch='\\\\')) ax.get_xaxis().set_visible(True) ax.set_xlabel( r'${\rm New\:Physics\:Scale}\:[\:{\rm log}_{10} (\Lambda^{-1}_{d}\:/\:{\rm GeV}^{-d+4})\: ]$', labelpad=5, fontsize=19) ax.tick_params(axis='x', labelsize=16) purple = [0.5019607843137255, 0.0, 0.5019607843137255] if show_lvatmo: legend_elements.append( Patch(facecolor='none', hatch='\\\\', edgecolor='k', label='IceCube, Nature.Phy.14,961(2018)')) legend_elements.append( Patch(facecolor=purple + [0.7], edgecolor=purple + [1], label='Planck Scale Expectation')) legend = first_ax.legend(handles=legend_elements, prop=dict(size=11), loc='upper left', title='Excluded regions', framealpha=1., edgecolor='black', frameon=True) first_ax.set_zorder(10) plt.setp(legend.get_title(), fontsize='11') legend.get_frame().set_linestyle('-') ybound = 0.595 if args.data is DataType.REAL: # fig.text(0.295, 0.684, 'IceCube Preliminary', color='red', fontsize=13, fig.text(0.278, ybound, r'\bf IceCube Preliminary', color='red', fontsize=13, ha='center', va='center', zorder=11) elif args.data is DataType.REALISATION: fig.text(0.278, ybound - 0.05, r'\bf IceCube Simulation', color='red', fontsize=13, ha='center', va='center', zorder=11) else: fig.text(0.278, ybound, r'\bf IceCube Simulation', color='red', fontsize=13, ha='center', va='center', zorder=11) make_dir(outfile) for of in outformat: print('Saving plot as {0}'.format(outfile + '.' + of)) fig.savefig(outfile + '.' + of, bbox_inches='tight', dpi=150)
def plot_statistic(data, outfile, outformat, args, scale_param, label=None): """Make MultiNest factor or LLH value plot.""" print('Making Statistic plot') fig_text = gen_figtext(args) if label is not None: fig_text += '\n' + label print('data', data) print('data.shape', data.shape) print('outfile', outfile) try: scales, statistic = ma.compress_rows(data).T lim = get_limit(deepcopy(scales), deepcopy(statistic), args, mask_initial=True) tck, u = splprep([scales, statistic], s=0) except: return sc, st = splev(np.linspace(0, 1, 1000), tck) scales_rm = sc[sc >= scales[1]] statistic_rm = st[sc >= scales[1]] min_idx = np.argmin(scales) null = statistic[min_idx] # fig_text += '\nnull lnZ = {0:.2f}'.format(null) if args.stat_method is StatCateg.BAYESIAN: reduced_ev = -(statistic_rm - null) elif args.stat_method is StatCateg.FREQUENTIST: reduced_ev = -2 * (statistic_rm - null) fig = plt.figure(figsize=(7, 5)) ax = fig.add_subplot(111) xlims = SCALE_BOUNDARIES[args.dimension] ax.set_xlim(xlims) ax.set_xlabel(r'${\rm log}_{10}\left[\Lambda^{-1}_{'+ \ r'{0}'.format(args.dimension)+r'}'+ \ get_units(args.dimension)+r'\right]$', fontsize=16) if args.stat_method is StatCateg.BAYESIAN: ax.set_ylabel( r'$\text{Bayes\:Factor}\:\left[\text{ln}\left(B_{0/1}\right)\right]$' ) elif args.stat_method is StatCateg.FREQUENTIST: ax.set_ylabel(r'$-2\Delta {\rm LLH}$') # ymin = np.round(np.min(reduced_ev) - 1.5) # ymax = np.round(np.max(reduced_ev) + 1.5) # ax.set_ylim((ymin, ymax)) ax.scatter(scales[1:], -(statistic[1:] - null), color='r') ax.plot(scales_rm, reduced_ev, color='k', linewidth=1, alpha=1, ls='-') if args.stat_method is StatCateg.BAYESIAN: ax.axhline(y=np.log(10**(BAYES_K)), color='red', alpha=1., linewidth=1.2, ls='--') ax.axvline(x=lim, color='red', alpha=1., linewidth=1.2, ls='--') at = AnchoredText(fig_text, prop=dict(size=10), frameon=True, loc=4) at.patch.set_boxstyle("round,pad=0.1,rounding_size=0.5") ax.add_artist(at) make_dir(outfile) for of in outformat: print('Saving as {0}'.format(outfile + '.' + of)) fig.savefig(outfile + '.' + of, bbox_inches='tight', dpi=150)
data = [[ np.nan if cell is '?' else float(cell) for cell in row[DISCARD:]] for row in datareader] # attributeNames: a Mx1 matrix attributeNames = namereader.next()[DISCARD:] # only one row in file so pop from iterable # X: data matrix, rows correspond to N data objects, each of which contains M attributes X = ma.masked_invalid(data) # missing values are masked X_mean = X.mean(0)[np.newaxis,:] # every value is the attributes mean # preprocesses X if INVALID_FIX is ELIM_COMM: # removes data objects with missing values X = ma.compress_rows(X) titlestr += "Rows with missings removed. " filestr += 'rows-with-missings-removed_' elif INVALID_FIX is ELIM_ATTR: # removes attributes with missing values X = ma.compress_cols(X) titlestr += "Attributes with missings removed. " filestr += 'attr-with-missings-removed_' elif INVALID_FIX is FILL_MEAN: # takes mean where masked value otherwise X = np.where(X.mask, X_mean, X) titlestr += "Missings filled with means. " filestr += "missings-filled-w-means_" X_mean = X.mean(0)[np.newaxis,:] # recalculate mean
def two_dim_findpeaks(image, peak_width=None, sigma=None, alpha=2, medfilt_radius=3, max_peak_number=50000, coords_list=[], recursion_level=0, max_peak_width=100): """ """ from copy import deepcopy # do a 2D median filter if medfilt_radius > 0: image = medfilt(image,medfilt_radius) if peak_width is None: peak_width = estimate_peak_width(image,max_peak_width=max_peak_width) # break recursion if peak width estimation fails if peak_width == 0: print "peak width estimated as 0. Skipping iteration." return print "Estimated peak width as %d pixels"%peak_width # draw a circular mask to be used around peaks coords = np.zeros((max_peak_number,2)) image_temp = deepcopy(image) peak_ct=0 # plus 3 is to black out a slightly larger area than the measured # size of the peak so that we don't get edges of peaks turning into # false peaks. #size=peak_width/2+3 size=peak_width/2 mask = draw_mask((size*2,size*2), size, [(size,size)]) # invert the mask to chuck the peak, not the surrounding area. mask = mask==0 if sigma is None: # peaks are some number of standard deviations from mean sigma=np.std(image_temp) # peaks are some set fraction of the max peak height #sigma = np.min(image)+0.2*(np.max(image)-np.min(image)) while True: k = np.argmax(image_temp) j,i = np.unravel_index(k, image_temp.shape) if(image_temp[j,i] >= alpha*sigma): # store the coordinate coords[peak_ct]=[i,j] # set the neighborhood of the peak to zero so we go look elsewhere # for other peaks x = np.arange(i-size, i+size) y = np.arange(j-size, j+size) xv,yv = np.meshgrid(x,y) image_temp[yv.clip(0,image_temp.shape[0]-1), xv.clip(0,image_temp.shape[1]-1) ] *= mask peak_ct+=1 else: break coords = coords[:peak_ct] # add in the heights and peak width heights=np.array([[image[coords[i,1],coords[i,0]],peak_width] for i in xrange(coords.shape[0])]).reshape((-1,2)) sigma = np.std(heights[:,0]) mean = np.mean(heights[:,0]) # filter out junk peaks - anything beyond 5 sigma. heights[:,0] = ma.masked_outside(heights[:,0], mean-(5*sigma), mean+(5*sigma)) coords=np.hstack((coords,heights)) coords=ma.compress_rows(coords) sigma=np.std(image_temp) # smaller fudge factor makes it more sensitive to junk. fudge_factor=1.5 coords_list.append(coords) print "Iteration %d done. %d peaks found." %(recursion_level,coords.shape[0]) if image_temp.max()>sigma*alpha*fudge_factor: print "Recursing..." # we'll determine another peak width in this recursion, because less bright peaks might also be smaller. two_dim_findpeaks(image_temp,alpha=alpha*fudge_factor, recursion_level=recursion_level+1, max_peak_width=peak_width, coords_list=coords_list) return coords_list