def CHART_Running_Annual_Vol_with_Hourly_Samples(frequency,window,trading_hours_per_day): Trading_Hours_in_Trading_Year=252*trading_hours_per_day #Calculates Trading Hours in a year Sample=data['Price'][frequency-1::frequency] #Creates New Sampling list based on frequency input Returns=np.log(Sample) - np.log(Sample.shift(1)) #Calculates Returns on New Sample Running_Variance=Returns.rolling(window).var() #Calculates hourly running variance based on 'window size' input Running_Annual_Vol=np.sqrt(Running_Variance)*np.sqrt(Trading_Hours_in_Trading_Year/frequency) #Place Running Vols and Time Series in DataFrame DF=pd.DataFrame(Sample) DF['Running_Vol']=Running_Annual_Vol #Create Plot DF.Price.plot() plt.legend() plt.ylabel('Yield (%)') DF.Running_Vol.plot(secondary_y=True, style='g',rot=90) plt.xlabel('Date') plt.ylabel('Running Vol') plt.title('10 Year Bund Yield vs Annualized Running Vol (Window Size=200)') plt.legend(bbox_to_anchor=(0.8, 1)) plt.text(0.8, 5.4, "Frequency={}. Window Size={}. Trading Hours per Day={}".format(frequency, window,trading_hours_per_day)) return plt
def plot(cls, data, figure_folder, msg="", suffix=""): fig, ax = plt.subplots() plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.2) x = np.arange(len(data[:])) ax.plot(x, data[:, 0], c="red", linewidth=2, label="agent 01") ax.plot(x, data[:, 1], c="blue", linewidth=2, label="agent 12") ax.plot(x, data[:, 2], c="green", linewidth=2, label="agent 20") plt.ylim([-0.01, 1.01]) plt.text(0, -0.23, "PARAMETERS. {}".format(msg)) ax.legend(fontsize=12, bbox_to_anchor=(1.1, 1.05)) # loc='upper center' ax.set_xlabel("$t$") ax.set_ylabel("Proportion of agents proceeding to indirect exchange") ax.set_title("Money emergence with a basal ganglia model") # Save fig if not exists(figure_folder): mkdir(figure_folder) fig_name = "{}/figure_{}.pdf".format(figure_folder, suffix.split(".p")[0]) plt.savefig(fig_name) plt.close()
def add_comment_with_file_name(fig, file_name): plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5')
def CHART_Running_Annual_Vol_with_Daily_Samples_on_Specific_Time_of_Day(frequency,sampling_time,window,trading_hours_per_day): Original_DAILY_Sample=data['Price'][sampling_time-1::trading_hours_per_day] #Grabs the Hourly Data and Converts it into Daily Data based on Sampling Time of Day AND Trading Hours per Day NEW_Sample=Original_DAILY_Sample[frequency-1::frequency] #Creates New Sampling list based on sampling frequency input Returns=np.log(NEW_Sample) - np.log(NEW_Sample.shift(1)) #Calculates Returns on New Sample Running_Variance=Returns.rolling(window).var() #Calculates daily running variance based on 'window size' input Running_Annual_Vol=np.sqrt(Running_Variance)*np.sqrt(252/frequency) #Place NEW Sampled data (prices) and Running Vols in DataFrame DF=pd.DataFrame(NEW_Sample) DF['Running_Vol']=Running_Annual_Vol #Create Plot DF.Price.plot() plt.legend() #data.Price.plot() plt.ylabel('Yield (%)') DF.Running_Vol.plot(secondary_y=True, style='g',rot=90) plt.xlabel('Date') plt.ylabel('Running Vol') plt.title('10 Year Bund Yield vs Annualized Running Vol ') plt.legend(bbox_to_anchor=(0.8, 1)) plt.text(0.8, 3.5, "Sampling Time={}. Window Size={}. Trading Hours per Day={}".format(sampling_time, window,trading_hours_per_day)) return plt
def plot(cls, data, msg=""): x = np.arange(len(data[:])) plt.plot(x, data[:, 0], c="red", linewidth=2) plt.plot(x, data[:, 1], c="blue", linewidth=2) plt.plot(x, data[:, 2], c="green", linewidth=2) plt.ylim([-0.01, 1.01]) plt.text(0, -0.12, "{}".format(msg)) plt.show()
def plot_fault_framework(fault_framework): fm = fault_framework plt.plot(fm.Y_PC, fm.DEP, '-o') plt.axis('equal') plt.axhline(0, color='black') plt.gca().set_yticks(fm.DEP) plt.gca().set_xticks(fm.Y_PC) plt.grid('on') plt.xlabel('From trench to continent(km)') plt.ylabel('depth (km)') for xi, yi, dip in zip(fm.Y_PC, fm.DEP, fm.DIP_D): plt.text(xi, yi, 'dip = %.1f' % dip) plt.gca().invert_yaxis()
def draw(x, y, x_text, y_text, title): plt.figure(figsize=(30, 5)) plt.plot(x, y, color='red', label='data_check_result') for i in range(1, len(x)): plt.text(x[i], y[i], str((x[i], round(y[i], 4)))) #plt.text(x,y,(x,y),color='red') plt.xlabel(x_text) plt.ylabel(y_text) plt.title(title) plt.grid(True) plt.legend() pic = time.strftime("%Y-%m-%d_%H_%S_%M", time.localtime()) + ".pdf" plt.savefig(pic) plt.show()
def plot_fault_framework(fault_framework): fm = fault_framework plt.plot(fm.Y_PC, fm.DEP, '-o') plt.axis('equal') plt.axhline(0, color='black') plt.gca().set_yticks(fm.DEP) plt.gca().set_xticks(fm.Y_PC) plt.grid('on') plt.xlabel('From trench to continent(km)') plt.ylabel('depth (km)') for xi, yi, dip in zip(fm.Y_PC, fm.DEP, fm.DIP_D): plt.text(xi, yi, 'dip = %.1f'%dip) plt.gca().invert_yaxis()
def profit_firmA_against_profit_firmB(file_name, folder=None): if folder is None: folder = "data/figures" os.makedirs(folder, exist_ok=True) bkp = backup.RunBackup.load(file_name=file_name) parameters = bkp.parameters profit_max = parameters.n_positions * parameters.n_prices * parameters.unit_value x = np.arange(parameters.t_max) y = np.zeros((2, parameters.t_max)) for f in range(2): for t in range(parameters.t_max): y[f, t] = np.mean(bkp.profits[:t + 1, f] / profit_max) # y = np.array([np.mean(for_y[i][t]) for t in range(parameters.t_max)]) # y_err = np.array([np.std(for_y[i][t]) for t in range(parameters.t_max)]) fig = plt.Figure() plt.plot(x, y[0], label="Firm A") plt.plot(x, y[1], label="Firm B") # plt.fill_between(x, y - (y_err / 2), y + (y_err / 2), color="C{}".format(i), alpha=.25) plt.legend() plt.xlabel("t") plt.ylabel("Mean profit") plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') plt.title("Evolution of profits over time ($r={}$)".format( bkp.field_of_view / 2)) plt.tight_layout() plt.savefig("{}/{}_mean_profit.pdf".format(folder, file_name)) plt.show()
def show_prediction_result(image, label_image, clf): size = (8, 8) plt.figure(figsize=(15, 10)) plt.imshow(image, cmap='gray_r') candidates = [] predictions = [] for region in regionprops(label_image): # skip small images # if region.area < 100: # continue # draw rectangle around segmented coins minr, minc, maxr, maxc = region.bbox # make regions square maxwidth = np.max([maxr - minr, maxc - minc]) minr, maxr = int(0.5 * ((maxr + minr) - maxwidth)) - 3, int(0.5 * ((maxr + minr) + maxwidth)) + 3 minc, maxc = int(0.5 * ((maxc + minc) - maxwidth)) - 3, int(0.5 * ((maxc + minc) + maxwidth)) + 3 rect = mpatches.Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=2, alpha=0.2) plt.gca().add_patch(rect) # predict digit candidate = image[minr:maxr, minc:maxc] candidate = np.array(imresize(candidate, size), dtype=float) # invert # candidate = np.max(candidate) - candidate # print im # rescale to 16 in integer candidate = (candidate - np.min(candidate)) if np.max(candidate) == 0: continue candidate /= np.max(candidate) candidate[candidate < 0.2] = 0.0 candidate *= 16 candidate = np.array(candidate, dtype=int) prediction = clf.predict(candidate.reshape(-1)) candidates.append(candidate) predictions.append(prediction) plt.text(minc - 10, minr - 10, "{}".format(prediction), fontsize=50) plt.xticks([], []) plt.yticks([], []) plt.tight_layout() plt.show() return candidates, predictions
def pos_firmA_over_pos_firmB(file_name, folder=None): if folder is None: folder = "data/figures" os.makedirs(folder, exist_ok=True) bkp = backup.RunBackup.load(file_name=file_name) pos = bkp.positions[-1000:] fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(pos[:, 0], pos[:, 1], color="black", alpha=0.05) ax.axvline(0.5, color="white", linewidth=0.5, linestyle="--") ax.axhline(0.5, color="white", linewidth=0.5, linestyle="--") plt.xlim(-1, bkp.parameters.n_positions) plt.ylim(-1, bkp.parameters.n_positions) plt.xticks( range(0, bkp.parameters.n_positions + 1, round(bkp.parameters.n_positions / 5))) plt.yticks( range(0, bkp.parameters.n_positions + 1, round(bkp.parameters.n_positions / 5))) plt.xlabel("Position A") plt.ylabel("Position B") plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') plt.title("$r={:.2f}$".format(bkp.field_of_view / 2)) ax.set_aspect(1) plt.tight_layout() plt.savefig("{}/{}_evo_positions.pdf".format(folder, file_name)) plt.show()
def plot_sites(self, sites, marker='s', color='white', ms=5, text=True, fs=8, offset_X=0, offset_Y=0): lons, lats = vj.sites_db.get_pos(sites) self.basemap.plot(lons, lats, linestyle='None', marker=marker, color=color, ms=ms, latlon=True) if text: lons += offset_X lats += offset_Y x, y = self.basemap(lons, lats) for xi, yi, ti in zip(x, y, sites): plt.text(xi, yi, ti, fontsize=fs)
def plot_overview(self,suffix=''): x=self.x; y=self.y; r=self.radius; cx,cy=self.center.real,self.center.imag ax=plt.axes() plt.scatter(x,y, marker='o', c='b', s=40) plt.axhline(y=0,color='grey', zorder=-1) plt.axvline(x=0,color='grey', zorder=-2) t=linspace(0,2*pi,201) circx=r*cos(t) + cx circy=r*sin(t) + cy plt.plot(circx,circy,'g-') plt.plot([cx],[cy],'gx',ms=12) if self.ZorY == 'Z': philist,flist=[self.phi_a,self.phi_p,self.phi_n],[self.fa,self.fp,self.fn] elif self.ZorY == 'Y': philist,flist=[self.phi_m,self.phi_s,self.phi_r],[self.fm,self.fs,self.fr] for p,f in zip(philist,flist): if f is not None: xpos=cx+r*cos(p); ypos=cy+r*sin(p); xos=0.2*(xpos-cx); yos=0.2*(ypos-cy) plt.plot([0,xpos],[0,ypos],'co-') ax.annotate('{:.3f} Hz'.format(f), xy=(xpos,ypos), xycoords='data', xytext=(xpos+xos,ypos+yos), textcoords='data', #textcoords='offset points', arrowprops=dict(arrowstyle="->", shrinkA=0, shrinkB=10) ) #plt.xlim(0,0.16) #plt.ylim(-0.1,0.1) plt.axis('equal') if self.ZorY == 'Z': plt.xlabel(r'resistance $R$ in Ohm'); plt.ylabel(r'reactance $X$ in Ohm') if self.ZorY == 'Y': plt.xlabel(r'conductance $G$ in Siemens'); plt.ylabel(r'susceptance $B$ in Siemens') plt.title("fitting the admittance circle with Powell's method") tx1='best fit (fmin_powell):\n' tx1+='center at G+iB = {:.5f} + i*{:.8f}\n'.format(cx,cy) tx1+='radius = {:.5f}; '.format(r) tx1+='residue: {:.2e}'.format(self.resid) txt1=plt.text(-r,cy-1.1*r,tx1,fontsize=8,ha='left',va='top') txt1.set_bbox(dict(facecolor='gray', alpha=0.25)) idxlist=self.to_be_annotated('triple') ofs=self.annotation_offsets(idxlist,factor=0.1,xshift=0.15) for i,j in enumerate(idxlist): xpos,ypos = x[j],y[j]; xos,yos = ofs[i].real,ofs[i].imag ax.annotate('{:.1f} Hz'.format(self.f[j]), xy=(xpos,ypos), xycoords='data', xytext=(xpos+xos,ypos+yos), textcoords='data', #textcoords='offset points', arrowprops=dict(arrowstyle="->", shrinkA=0, shrinkB=10) ) if self.show: plt.show() else: plt.savefig(join(self.sdc.plotpath,'c{}_fitted_{}_circle'.format(self.sdc.case,self.ZorY)+suffix+'.png'), dpi=240) plt.close()
print('rmse in training cross-validation:',np.sqrt(-best_cv.best_score_)) #%% final_estimator = best_cv.best_estimator_ # save the final estimator estimator_file = 'wind_power_icing_final_estimator_from_gridsearch.pkl' pickle.dump(final_estimator, open(estimator_file,'wb')) # save the configuration as text file print(final_estimator, file=open('wind_power_icing_final_estimator_config.txt','w')) # now use this estimator on the test data y_test_predicted = final_estimator.predict(X_test) mse_test = metrics.mean_squared_error(y_test, y_test_predicted) rmse_test = np.sqrt(mse_test) print('mse on test data:', mse_test) print('rmse on test data', rmse_test) r2 = np.corrcoef(y_test_predicted, y_test)[0,1]**2 plt.figure() sns.regplot(y_test_predicted, y_test) plt.ylabel('ploss test') plt.xlabel('ploss test predicted') plt.text(0.1,0.9,'R^2={:.2f}'.format(r2), transform = plt.gca().transAxes) plt.text(0.1,0.85,'RMSE={:.2f}'.format(rmse_test), transform = plt.gca().transAxes) plt.text(0.1,0.8,'N={:.2f}'.format(len(y_test)), transform = plt.gca().transAxes) plt.savefig(target_var+'_vs_'+target_var+'_predicted_on_test_set_lead_hour'+str(lead_hour)+'.svg')
# The sequential mode is designed to work with exactly one input tensor and one output tensor. model = Sequential() model.add(SimpleRNN(500, activation='relu', input_shape=(lags, 1))) model.add(Dense(1, activation='linear')) model.compile(optimizer='rmsprop', loss='mse', metrics=['mae']) model.summary() model.fit(g, epochs=500, steps_per_epoch=10, verbose=False) x = np.linspace(-6 * np.pi, 6 * np.pi, 1000) d = transform(x) g_ = TimeseriesGenerator(d, d, length=lags, batch_size=len(d)) f = list(g_)[0][0].reshape((len(d) - lags, lags, 1)) y = model.predict(f, verbose=False) plt.figure(figsize=(10, 6)) plt.plot(x[lags:], d[lags:], label='data', alpha=0.75) plt.plot(x[lags:], y, 'r.', label='pred', ms=3) plt.axvline(-2 * np.pi, c='g', ls='--') plt.axvline(2 * np.pi, c='g', ls='--') plt.text(-15, 22, 'out-of-sample') plt.text(-2, 22, 'in-sample') plt.text(10, 22, 'out-of-sample') plt.legend()
def CHART_Running_Vol_with_Space_Increment_Sampling(increment_in_bp,window,trading_hours_per_day): Trading_Hours_in_Trading_Year=252*trading_hours_per_day #Calculates Trading Hours in a year Increment_Sample=[] #Create a List for the samples Dates_List=[] #Create list for Dates Increment_Sample.append(data['Price'][0]) #Add the first data point in our data Dates_List.append(DATES[0:1]) #Add the first Date Index_List=[1] #Create a list for the index of the samples #Loop to add the element in the list ONLY if its value is more than X bp away from last sample counter=0 #counter to keep track in which hours did we sample for i in data['Price']: counter+=1 if abs(i-np.array(Increment_Sample[-1:]))>=(increment_in_bp/100): Increment_Sample.append(i) Index_List.append(counter) Dates_List.append(DATES[counter]) else: continue #Convert to a DataFrame Increment_Sample=pd.DataFrame(Increment_Sample) #Calculate Returns on NEW sample Returns=np.log(Increment_Sample) - np.log(Increment_Sample.shift(1)) #Calculate Running average distance(in hours) between samples dt=pd.DataFrame([x - Index_List[i - 1] for i, x in enumerate(Index_List)][1:]).rolling(window).mean() # Calculate Running Variance Running_Variance=Returns.rolling(window).var() #Calculates hourly running variance based on 'window size' input #Calculate Annualized Vol based on average distance (in hours) between samples (dt) and the trading hours in a year Annual_Vol=np.sqrt(Running_Variance)*np.sqrt(Trading_Hours_in_Trading_Year/dt) Final_DF=pd.DataFrame(Annual_Vol)#Create dataframe with Running Annual Vol Final_DF['Dates']=Dates_List #Add sampled dates to the dataframe Final_DF.set_index('Dates',inplace=True, drop=True) #Set Dates as the index Final_DF.columns = ['Running_Annual_Vol'] #Assign column name #Create Plot Increment_Sample.columns = ['Price'] #Assign column name Increment_Sample.plot() plt.legend() plt.ylabel('Yield (%)') #plt.plot([], [], ' ', label="Extra label on the legend") #plt.legend() #data.Price.plot() Final_DF.Running_Annual_Vol.plot(secondary_y=True, style='g',rot=90) plt.xlabel('Date') plt.ylabel('Running Vol') plt.title('10 Year Bund Yield vs Annualized Running Vol ') plt.legend(bbox_to_anchor=(.8, 1)) plt.text(0.8, 7.2, "SAMPLING ONLY IF MOVE IS ≥ {} bp. Window Size= {}".format(increment_in_bp, window)) return plt
def plot_fenbi_seq(biIdx, frsBiType, plt=None, color=None): x_fenbi_seq = [] y_fenbi_seq = [] for i in range(len(biIdx)): if biIdx[i] is not None: fenType = -frsBiType if i % 2 == 0 else frsBiType # dt = chanK['enddate'][biIdx[i]] # 缠论k线 dt = chanK.index[biIdx[i]] if chanK_flag else chanK['enddate'][ biIdx[i]] # print i,k_data['high'][dt], k_data['low'][dt] time_long = long( time.mktime( (dt + datetime.timedelta(hours=8)).timetuple()) * 1000000000) # print x_date_list.index(time_long) if time_long in x_date_list else 0 if fenType == 1: if plt is not None: if color is None: plt.text(x_date_list.index(time_long), k_data['high'][dt], str(k_data['high'][dt]), ha='left', fontsize=12) else: col_v = color[0] if fenType > 0 else color[1] plt.text(x_date_list.index(time_long), k_data['high'][dt], str(k_data['high'][dt]), ha='left', fontsize=12, bbox=dict(facecolor=col_v, alpha=0.5)) x_fenbi_seq.append(x_date_list.index(time_long)) y_fenbi_seq.append(k_data['high'][dt]) if fenType == -1: if plt is not None: if color is None: plt.text(x_date_list.index(time_long), k_data['low'][dt], str(k_data['low'][dt]), va='bottom', fontsize=12) else: col_v = color[0] if fenType > 0 else color[1] plt.text(x_date_list.index(time_long), k_data['low'][dt], str(k_data['low'][dt]), va='bottom', fontsize=12, bbox=dict(facecolor=col_v, alpha=0.5)) x_fenbi_seq.append(x_date_list.index(time_long)) y_fenbi_seq.append(k_data['low'][dt]) # bottom_time = None # for k_line_dto in m_line_dto.member_list[::-1]: # if k_line_dto.low == m_line_dto.low: # # get_price返回的日期,默认时间是08:00:00 # bottom_time = k_line_dto.begin_time.strftime('%Y-%m-%d') +' 08:00:00' # break # x_fenbi_seq.append(x_date_list.index(long(time.mktime(datetime.strptime(bottom_time, "%Y-%m-%d %H:%M:%S").timetuple())*1000000000))) # y_fenbi_seq.append(m_line_dto.low) return x_fenbi_seq, y_fenbi_seq
plt.subplot(211) # 令子图subplot(211)成为figure1的当前图 plt.title('Easy as 1,2,3') # 添加subplot 211 的标题 '===========================================' mu, sigma = 100, 15 x = mu + sigma * np.random.randn(10000) # 数据的直方图 n, bins, patches = plt.hist(x, 50, normed=1, facecolor='g', alpha=0.75) plt.xlabel('Smarts') plt.ylabel('Probability') # 添加标题 plt.title('Histogram of IQ') # 添加文字 plt.text(60, .025, r'$\mu=100,\ \sigma=15$') plt.axis([40, 160, 0, 0.03]) plt.grid(True) plt.show() '===========================================' ax = plt.subplot(111) t = np.arange(0.0, 5.0, 0.01) s = np.cos(2 * np.pi * t) line, = plt.plot(t, s, lw=2) plt.annotate( 'local max', xy=(2, 1),
def distance_over_fov(file_name, pool_backup, fig_folder=None): span_ratio = 0.33 if fig_folder is None: fig_folder = "data/figures" os.makedirs(fig_folder, exist_ok=True) parameters = pool_backup.parameters backups = pool_backup.backups n_simulations = parameters.n_simulations n_positions = parameters.n_positions p_max = parameters.p_max # Compute profit max profit_max = n_positions * p_max # Containers x = np.zeros(n_simulations) y = np.zeros(n_simulations) y_err = np.zeros(n_simulations) z = np.zeros(n_simulations) # How many time steps from the end of the simulation are included in analysis span = int(span_ratio * parameters.t_max) for i, b in enumerate(backups): try: # Save the parameter that affected the customers field of view x[i] = b.field_of_view / 2 except AttributeError: x[i] = b.parameters.r # Compute the mean distance between the two firms data = np.absolute(b.positions[-span:, 0] - b.positions[-span:, 1]) / n_positions spacing = np.mean(data) spacing_std = np.std(data) y[i] = spacing y_err[i] = spacing_std # Get mean profits z[i] = np.mean(b.profits[-span:, :]) / profit_max # Plot this fig = plt.figure(figsize=(10, 6)) ax = plt.subplot() ax.set_xlim(-0.01, 1.01) if max(y) < 0.5: ax.set_ylim(-0.01, 0.51) ax.set_xticks(np.arange(0, 1.1, 0.25)) ax.set_yticks(np.arange(0, 0.51, 0.1)) ax.set_xlabel("$r$") ax.set_ylabel("Mean distance") ax.set_title("Mean distance between firms over $r$") # add comment with file name plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') # show random plt.text(0.005, 0.005, file_name, transform=fig.transFigure, fontsize='x-small', color='0.5') abc = ax.scatter(x, y, c=z, zorder=10, alpha=0.25) fig.colorbar(abc, label="Profits") plt.tight_layout() if file_name: plt.savefig("{}/{}.pdf".format(fig_folder, file_name)) plt.show()
sweepFreq_dict["SWEEP_FREQ_C2V"] = False sweepFreq_dict["SWEEP_FREQ_C2C"] = False print(motor_dict) print(sweepFreq_dict) dB, Deg, Freq, max_freq = analyzer.analyze(dot_dat_file_dir, motor_dict, sweepFreq_dict) # for el in (dB, Deg, Freq, max_freq): # print(el) plt.figure(4, figsize=(20, 8)) plt.plot(Freq, dB, '--.', label=data_fname) index, value = analyzer.find_nearest(dB, -3) # find -3dB freq VLBW = Freq[index] plt.text(VLBW, -5, f'{VLBW:.0f} Hz', color='red', fontsize=20) plt.plot([0, max_freq], [-3, -3], 'k--') plt.ylabel('Velocity Closed-loop transfer function amplitude [dB]') plt.xscale('log') plt.xlabel('Frequency [Hz]') plt.legend() # 2. Plot designed Bode plot # plt.figure(4, figsize=(20,8)) mag, phase, omega = MagPhaseOmega index_max_freq = sum(omega / (2 * np.pi) < max_freq) plt.plot((omega / (2 * np.pi))[:index_max_freq], 20 * np.log10(mag[:index_max_freq]), '-.', label=f'designed:$\\delta={delta}$')