"d_E", "phase", "cap_phase", "num_peaks", "original_omega" ] changed_sv_vals = [ 300e-3, 3 * math.pi / 2, 3 * math.pi / 2, 50, RV_param_list["omega"] ] for key, value in zip(changed_SV_params, changed_sv_vals): SV_param_list[key] = value num_harms = 6 start_harm = 1 SV_simulation_options["method"] = "sinusoidal" other_values = { "filter_val": 0.5, "harmonic_range": list(range(start_harm, start_harm + num_harms, 1)), "bounds_val": 20000, } RV = single_electron(None, RV_param_list, simulation_options, other_values, param_bounds) SV = single_electron(None, SV_param_list, SV_simulation_options, other_values, param_bounds) RV.def_optim_list(list(table_names)) SV.def_optim_list([]) SV_simulation_options["no_transient"] = 2 / SV_param_list["omega"] SV_new = single_electron(None, SV_param_list, SV_simulation_options, other_values, param_bounds) timeseries = SV_new.test_vals([], "timeseries") SV_plot_times = SV_new.t_nondim(SV_new.time_vec[SV_new.time_idx]) SV_plot_voltages = SV_new.e_nondim(SV_new.define_voltages()[SV_new.time_idx]) plot_height = max(75 * num_harms, 450)
def apply_slider_changes(n_clicks, *inputs): states = inputs[:-2] table_data = inputs[-2] drop_down_opts = inputs[-1] for i in range(0, len(states)): if states[i] is not None: val = states[i] val = min(val, param_bounds[table_names[i]][1]) val = max(val, param_bounds[table_names[i]][0]) RV.dim_dict[RV.optim_list[i]] = val SV.dim_dict[RV.optim_list[i]] = val SV.dim_dict["original_gamma"] = SV.dim_dict["gamma"] RV.dim_dict["original_gamma"] = RV.dim_dict["gamma"] SV.dim_dict["original_omega"] = SV.dim_dict["omega"] SV.simulation_options["no_transient"] = 2 / SV.dim_dict["omega"] RV.simulation_options["no_transient"] = 2 / RV.dim_dict["omega"] SV.simulation_options["optim_list"] = [] RV.simulation_options["optim_list"] = [] SV.dim_dict["d_E"] = (SV.dim_dict["E_reverse"] - SV.dim_dict["E_start"]) / 2 RV.dim_dict["d_E"] = (RV.dim_dict["E_reverse"] - RV.dim_dict["E_start"]) / 4 RV_new = single_electron(None, RV.dim_dict, RV.simulation_options, RV.other_values, param_bounds) SV_new = single_electron(None, SV.dim_dict, SV.simulation_options, SV.other_values, param_bounds) params = [] ramped_layout = go.Layout(height=plot_height) harmonic_layout = go.Layout(height=plot_height // num_harms, margin={ "pad": 0, "b": 0, "t": 0 }) r_tab_labels = ["r_time", "r_volt", "r_volt_time", "r_fft"] s_tab_labels = ["s_time", "s_volt", "s_volt_time", "s_r_fft"] if n_clicks > 0: timeseries = RV_new.i_nondim(RV_new.test_vals(params, "timeseries")) RV_plot_times = RV_new.t_nondim(RV_new.time_vec[RV_new.time_idx]) RV_plot_voltages = RV_new.e_nondim( RV_new.define_voltages()[RV_new.time_idx]) for q in range(0, len(table_data)): table_data[q]["Value"] = RV_new.dim_dict[table_data[q] ["Parameter"]] SV_timeseries = SV_new.i_nondim(SV_new.test_vals(params, "timeseries")) SV_plot_voltages = SV_new.e_nondim( SV_new.define_voltages()[SV_new.time_idx]) SV_plot_times = SV_new.t_nondim(SV_new.time_vec[SV_new.time_idx]) r_harms = harmonics(list(range(start_harm, start_harm + num_harms)), RV_new.dim_dict["omega"], 0.05) s_harms = harmonics(list(range(start_harm, start_harm + num_harms)), SV_new.dim_dict["omega"], 0.05) SV_harmonics = s_harms.generate_harmonics(SV_plot_times, SV_timeseries, hanning=False) ramped_harmonics = r_harms.generate_harmonics(RV_plot_times, timeseries, hanning=True) r_one_tail_len = (len(r_harms.exposed_f) // 2) + 1 s_one_tail_len = (len(s_harms.exposed_f) // 2) + 1 r_freqs = r_harms.exposed_f[:r_one_tail_len] r_fft = abs(r_harms.exposed_Y[:r_one_tail_len]) s_freqs = s_harms.exposed_f[:s_one_tail_len] s_fft = np.real(s_harms.exposed_Y[:s_one_tail_len]) r_x_args = [RV_plot_times, RV_plot_voltages, RV_plot_times, r_freqs] r_y_args = [timeseries, timeseries, RV_plot_voltages, r_fft] s_x_args = [SV_plot_times, SV_plot_voltages, SV_plot_times, s_freqs] s_y_args = [SV_timeseries, SV_timeseries, SV_plot_voltages, s_fft] r_right_plots = {} s_right_plots = {} for i in range(0, len(r_tab_labels)): r_right_plots[r_tab_labels[i]] = { "data": [ { "x": r_x_args[i], "y": r_y_args[i], "type": "line", "name": "Ramped", "render_mode": "webgl" }, ], "layout": ramped_layout, } s_right_plots[s_tab_labels[i]] = { "data": [ { "x": s_x_args[i], "y": s_y_args[i], "type": "line", "name": "Ramped", "render_mode": "webgl" }, ], "layout": ramped_layout, } return_arg = [r_right_plots] for i in range(0, num_harms): return_arg.append({ "data": [ { "x": RV_plot_times, "y": np.abs(ramped_harmonics[i, :]), "type": "line", "name": "Ramped_harm" + str(i), "render_mode": "webgl" }, ], "layout": harmonic_layout, }) return_arg.append(s_right_plots) for i in range(0, num_harms): return_arg.append({ "data": [ { "x": SV_plot_voltages, "y": np.real(SV_harmonics[i, :]), "type": "line", "name": "sv_harm" + str(i), "render_mode": "webgl" }, ], "layout": harmonic_layout, }) return_arg.append(table_data) return return_arg empty_r_plots = dict( zip(r_tab_labels, [{ "layout": ramped_layout }] * len(r_tab_labels))) empty_s_plots = dict( zip(s_tab_labels, [{ "layout": ramped_layout }] * len(s_tab_labels))) return [empty_r_plots] + [{ "layout": harmonic_layout }] * (num_harms) + [empty_s_plots] + [{ "layout": harmonic_layout }] * (num_harms) + [table_data]
def apply_slider_changes(n_clicks, *inputs): #start=time.time() slider_input_len=len(table_names) states=inputs[:slider_input_len] table_data=inputs[slider_input_len] drop_down_opts=inputs[slider_input_len+1] disp_bins=inputs[slider_input_len+2] freeze_buttons=inputs[slider_input_len+3] adaptive_buttons=inputs[slider_input_len+4] plot_buttons=inputs[slider_input_len+5] #print(disp_bins, freeze_buttons, adaptive_buttons) dispersion_optim_list=[] if drop_down_opts is not None: dispersion_groups={"E_0":["E0_mean", "E0_std"], "k_0":["k0_shape", "k0_scale"], "alpha":["alpha_mean", "alpha_std"]} dispersion_associations={"E0_mean":"E_0", "E0_std":"E_0", "E0_skew":"E_0", "k0_shape":"k_0", "k0_scale":"k_0", "alpha_mean":"alpha", "alpha_std":"alpha"} dispersed_params=list(set([dispersion_associations[key] for key in drop_down_opts if key in dispersion_associations.keys()])) if len(dispersed_params)!=0: dispersion=True for key in dispersed_params: dispersion_optim_list+=dispersion_groups[key] else: dispersion=False params=[] else: dispersion=False params=[] for i in range(0, len(states)): if states[i] is not None: val=states[i] val=min(val, param_bounds[table_names[i]][1]) val=max(val, param_bounds[table_names[i]][0]) RV.dim_dict[RV.optim_list[i]]=val SV.dim_dict[RV.optim_list[i]]=val DCV.dim_dict[RV.optim_list[i]]=val SV.dim_dict["original_gamma"]=SV.dim_dict["gamma"] RV.dim_dict["original_gamma"]=RV.dim_dict["gamma"] DCV.dim_dict["original_gamma"]=DCV.dim_dict["gamma"] SV.dim_dict["original_omega"]=SV.dim_dict["omega"] SV.simulation_options["no_transient"]=2/SV.dim_dict["omega"] RV.simulation_options["no_transient"]=2/RV.dim_dict["omega"] DCV.simulation_options["no_transient"]=False SV.simulation_options["optim_list"]=[] RV.simulation_options["optim_list"]=[] DCV.simulation_options["optim_list"]=[] SV.dim_dict["d_E"]=(SV.dim_dict["E_reverse"]-SV.dim_dict["E_start"])/2 RV.dim_dict["d_E"]=(RV.dim_dict["E_reverse"]-RV.dim_dict["E_start"])/4 RV_new=single_electron(None, RV.dim_dict, RV.simulation_options, RV.other_values, param_bounds) SV_new=single_electron(None, SV.dim_dict, SV.simulation_options, SV.other_values, param_bounds) DCV_new=single_electron(None, DCV.dim_dict, DCV.simulation_options, DCV.other_values, param_bounds) if dispersion==True: #print(dispersion_optim_list) RV_new.simulation_options["dispersion_bins"]=[disp_bins] SV_new.simulation_options["dispersion_bins"]=[disp_bins] DCV_new.simulation_options["dispersion_bins"]=[disp_bins] in_table=dict(zip(dispersion_optim_list, [False]*len(dispersion_optim_list))) RV_new.def_optim_list(dispersion_optim_list) SV_new.def_optim_list(dispersion_optim_list) DCV_new.def_optim_list(dispersion_optim_list) params=[RV.dim_dict[param] for param in dispersion_optim_list] ramped_layout=go.Layout(height=plot_height) harmonic_layout=go.Layout(height=plot_height//num_harms, margin={"pad":0, "b":0, "t":0}) r_tab_labels=["r_time", "r_volt", "r_volt_time", "r_fft"] s_tab_labels=["s_time", "s_volt", "s_volt_time", "s_r_fft"] d_tab_labels=["d_time", "d_volt", "d_volt_time"] if n_clicks>0: deletion_idx=[] if dispersion==False: table_data=table_init for q in range(0, len(table_data)): table_data[q]["Value"]=RV_new.dim_dict[table_data[q]["Parameter"]] if dispersion==True: if table_data[q]["Parameter"] in dispersion_optim_list: in_table[table_data[q]["Parameter"]]=True if table_data[q]["Parameter"] in dispersed_params: deletion_idx.append(q) if dispersion==True: for q in range(0, len(dispersion_optim_list)): if in_table[dispersion_optim_list[q]]==False: table_data.append({"Parameter":dispersion_optim_list[q], "Value":RV_new.dim_dict[dispersion_optim_list[q]]}) for q in range(0, len(deletion_idx)): del table_data[deletion_idx[q]] if "r_freeze" in freeze_buttons: if "r_scipy" in adaptive_buttons: RV_new.update_params(params) V=RV.e_nondim(RV_new.define_voltages()) w0=[0, 0, V[0]] wsol = odeint(RV_new.current_ode_sys, w0, RV.time_vec, rtol=1e-6, atol=1e-6) timeseries=RV_new.i_nondim(wsol[:,0][RV_new.time_idx]) RV_plot_voltages=V[RV_new.time_idx] RV_plot_times=RV_new.t_nondim(RV.time_vec[RV_new.time_idx]) else: timeseries=RV_new.i_nondim(RV_new.test_vals(params, "timeseries")) RV_plot_times=RV_new.t_nondim(RV_new.time_vec[RV_new.time_idx]) RV_plot_voltages=RV_new.e_nondim(RV_new.define_voltages()[RV_new.time_idx]) r_harms=harmonics(list(range(start_harm, start_harm+num_harms)), RV_new.dim_dict["omega"], 0.05) ramped_harmonics=r_harms.generate_harmonics(RV_plot_times, timeseries, hanning=True) r_one_tail_len=(len(r_harms.exposed_f)//2)+1 r_freqs=r_harms.exposed_f[:r_one_tail_len] r_fft=abs(r_harms.exposed_Y[:r_one_tail_len]) if "no_decimation" in plot_buttons: r_x_args=[RV_plot_times, RV_plot_voltages, RV_plot_times[0::10], r_freqs] r_y_args=[timeseries, timeseries, RV_plot_voltages[0::10], r_fft] elif "ramped_rdp" in plot_buttons: simped_line=np.array(rdp_lines.rdp_controller(RV_plot_times, timeseries, max(timeseries)/5)) sorted_idx=np.argsort(simped_line[:,0]) simped_times=simped_line[:,0][sorted_idx] simped_timeseries=simped_line[:,1][sorted_idx] r_x_args=[simped_times, RV_plot_voltages[0::10], RV_plot_times[0::10], decimate(r_freqs, 10)] r_y_args=[simped_timeseries, timeseries[0::10], RV_plot_voltages[0::10], decimate(r_fft, 10)] elif "decimation" in plot_buttons: r_x_args=[x[0::10] for x in [RV_plot_times, RV_plot_voltages, RV_plot_times, r_freqs]] r_y_args=[x[0::10] for x in [timeseries, timeseries, RV_plot_voltages, r_fft]] if "s_freeze" in freeze_buttons: if "s_scipy" in adaptive_buttons: SV_new.update_params(params) V=SV.e_nondim(SV_new.define_voltages()) C=SV_new.test_vals(params, "timeseries") w0=[0, 0, V[0]] wsol = odeint(SV_new.current_ode_sys, w0, SV.time_vec, rtol=1e-6, atol=1e-6) SV_timeseries=SV_new.i_nondim(wsol[:,0][SV_new.time_idx]) SV_plot_voltages=V[SV_new.time_idx] SV_plot_times=SV_new.t_nondim(SV.time_vec[SV_new.time_idx]) else: SV_timeseries=SV_new.i_nondim(SV_new.test_vals(params, "timeseries")) SV_plot_voltages=SV_new.e_nondim(SV_new.define_voltages()[SV_new.time_idx]) SV_plot_times=SV_new.t_nondim(SV_new.time_vec[SV_new.time_idx]) s_harms=harmonics(list(range(start_harm, start_harm+num_harms)), SV_new.dim_dict["omega"], 0.05) SV_harmonics=s_harms.generate_harmonics(SV_plot_times, SV_timeseries, hanning=False) s_one_tail_len=(len(s_harms.exposed_f)//2)+1 s_freqs=s_harms.exposed_f[:s_one_tail_len] s_fft=np.real(s_harms.exposed_Y[:s_one_tail_len]) s_x_args=[SV_plot_times, SV_plot_voltages, SV_plot_times, s_freqs] s_y_args=[SV_timeseries, SV_timeseries, SV_plot_voltages, s_fft] if "d_freeze" in freeze_buttons: if "d_scipy" in adaptive_buttons: DCV_new.update_params(params) V=DCV.e_nondim(DCV_new.define_voltages()) w0=[0, 0, V[0]] wsol = odeint(DCV_new.current_ode_sys, w0, DCV.time_vec, rtol=1e-6, atol=1e-6) DCV_timeseries=DCV_new.i_nondim(wsol[:,0][DCV_new.time_idx]) DCV_plot_voltages=V[DCV_new.time_idx] DCV_plot_times=DCV_new.t_nondim(DCV.time_vec[DCV_new.time_idx]) else: DCV_timeseries=DCV_new.i_nondim(DCV_new.test_vals(params, "timeseries")) DCV_plot_voltages=DCV_new.e_nondim(DCV_new.define_voltages()[DCV_new.time_idx]) DCV_plot_times=DCV_new.t_nondim(DCV_new.time_vec[DCV_new.time_idx]) d_x_args=[running_reduction(x, 10) for x in [DCV_plot_times, DCV_plot_voltages, DCV_plot_times]] d_y_args=[running_reduction(x, 10) for x in [DCV_timeseries, DCV_timeseries, DCV_plot_voltages]] x_labels=["Time(s)", "Voltage(V)", "Time(s)", "Frequency(Hz)"] y_labels=["Current(A)", "Current(A)", "Voltage(V)", "Magnitude"] r_right_plots={} s_right_plots={} d_right_plots={} for i in range(0, len(r_tab_labels)): if "r_freeze" not in freeze_buttons: r_x_plot=[] r_y_plot=[] else: r_x_plot=r_x_args[i] r_y_plot=r_y_args[i] r_right_plots[r_tab_labels[i]]={"data": [ {"x":r_x_plot, "y":r_y_plot , "type": "scattergl", "name":"Current sim", "render_mode":"webgl"}, ], "layout": {"height":plot_height, "xaxis":{"title":{"text":x_labels[i]}}, "yaxis":{"title":{"text":y_labels[i]}}}, } if "s_freeze" not in freeze_buttons: s_x_plot=[] s_y_plot=[] else: s_x_plot=s_x_args[i] s_y_plot=s_y_args[i] s_right_plots[s_tab_labels[i]]={"data": [ {"x":s_x_plot, "y": s_y_plot, "type": "scattergl", "name": "Current sim", "render_mode":"webgl"}, ], "layout": {"height":plot_height, "xaxis":{"title":{"text":x_labels[i]}}, "yaxis":{"title":{"text":y_labels[i]}}}, } if i<len(d_tab_labels): if "d_freeze" not in freeze_buttons: d_x_plot=[] d_y_plot=[] else: d_x_plot=d_x_args[i] d_y_plot=d_y_args[i] d_right_plots[d_tab_labels[i]]={"data": [ {"x":d_x_plot, "y": d_y_plot, "type": "scattergl", "name": "Current sim", "render_mode":"webgl"}, ], "layout": {"height":plot_height, "xaxis":{"title":{"text":x_labels[i]}}, "yaxis":{"title":{"text":y_labels[i]}}}, } harmonics_dict={"ramped":{}, "sinusoidal":{}} for i in range(0, num_harms): xlabel="" ylabel="" b=0 if i==(num_harms-1): xlabel="Time(s)" b=30 if i==num_harms//2: ylabel="Current(A)" if "r_freeze" not in freeze_buttons: r_x_plot=[] r_y_plot=[] else: r_x_plot=RV_plot_times r_y_plot=np.abs(ramped_harmonics[i,:][0::10]) harmonics_dict["ramped"]["ramped_harm_"+str(i)]={"data": [ {"x":r_x_plot, "y":r_y_plot , "type": "line", "name": None, "render_mode":"webgl"}, ], "layout": {"height":plot_height//num_harms, "margin":{"pad":0, "b":b, "t":5},"xaxis":{"title":{"text":xlabel}}, "yaxis":{"title":{"text":ylabel}} }, } for i in range(0, num_harms): xlabel="" ylabel="" b=0 if i==(num_harms-1): xlabel="Voltage(V)" b=40 if i==num_harms//2: ylabel="Current(A)" if "s_freeze" not in freeze_buttons: s_x_plot=[] s_y_plot=[] else: s_x_plot=SV_plot_voltages s_y_plot=np.real(SV_harmonics[i,:]) harmonics_dict["sinusoidal"]["sinusoidal_harm_"+str(i)]=({"data": [ {"x":s_x_plot, "y": s_y_plot, "type": "line", "name": None, "render_mode":"webgl"}, ], "layout": {"height":plot_height//num_harms, "margin":{"pad":0, "b":b, "t":5},"xaxis":{"title":{"text":xlabel}}, "yaxis":{"title":{"text":ylabel}} }, }) #print("simulation_time", time.time()-start) return [r_right_plots]+[s_right_plots]+[d_right_plots]+[harmonics_dict]+[table_data] empty_r_plots=dict(zip(r_tab_labels, [{"layout": ramped_layout}]*len(r_tab_labels))) empty_s_plots=dict(zip(s_tab_labels, [{"layout": ramped_layout}]*len(s_tab_labels))) empty_d_plots=dict(zip(d_tab_labels, [{"layout": ramped_layout}]*len(d_tab_labels))) harmonics_dict={"ramped":{}, "sinusoidal":{}} for i in range(0, num_harms): harmonics_dict["ramped"]["ramped_harm_"+str(i)]={"layout":harmonic_layout} harmonics_dict["sinusoidal"]["sinusoidal_harm_"+str(i)]={"layout":harmonic_layout} return [empty_r_plots]+[empty_s_plots]+[empty_d_plots]+[harmonics_dict]+[table_data]
def apply_slider_changes(n_clicks, drop_down_opts, disp_bins, freeze_buttons, adaptive_buttons, plot_buttons, exp_id, *slider_params): for exp in ["ramped", "sinusoidal", "dcv"]: if exp in exp_id: experiment_type = exp exp_class = class_dict[exp] if (n_clicks > 0) and (experiment_type + "_freeze" in freeze_buttons): if drop_down_opts is not None: dispersion_groups = { "E_0": ["E0_mean", "E0_std"], "k_0": ["k0_shape", "k0_scale"], "alpha": ["alpha_mean", "alpha_std"] } dispersion_associations = { "E0_mean": "E_0", "E0_std": "E_0", "E0_skew": "E_0", "k0_shape": "k_0", "k0_scale": "k_0", "alpha_mean": "alpha", "alpha_std": "alpha" } dispersed_params = list( set([ dispersion_associations[key] for key in drop_down_opts if key in dispersion_associations.keys() ])) if len(dispersed_params) != 0: dispersion = True for key in dispersed_params: dispersion_optim_list += dispersion_groups[key] else: dispersion = False params = [] else: dispersion = False params = [] for i in range(0, len(slider_params)): if slider_params[i] is not None: val = slider_params[i] val = min(val, param_bounds[table_names[i]][1]) val = max(val, param_bounds[table_names[i]][0]) exp_class.dim_dict[RV.optim_list[i]] = val exp_class.dim_dict["original_gamma"] = exp_class.dim_dict["gamma"] exp_class.simulation_options["optim_list"] = [] if experiment_type == "sinusoidal": exp_class.dim_dict["original_omega"] = exp_class.dim_dict["omega"] exp_class.simulation_options[ "no_transient"] = 2 / exp_class.dim_dict["omega"] exp_class.dim_dict["d_E"] = (exp_class.dim_dict["E_reverse"] - exp_class.dim_dict["E_start"]) / 2 elif experiment_type == "ramped": exp_class.simulation_options[ "no_transient"] = 2 / exp_class.dim_dict["omega"] exp_class.dim_dict["d_E"] = (exp_class.dim_dict["E_reverse"] - RV.dim_dict["E_start"]) / 4 elif experiment_type == "dcv": exp_class.simulation_options["no_transient"] = False new_class = single_electron(None, exp_class.dim_dict, exp_class.simulation_options, exp_class.other_values, param_bounds) if dispersion == True: new_class.simulation_options["dispersion_bins"] = [disp_bins] new_class.def_optim_list(dispersion_optim_list) params = [ new_class.dim_dict[param] for param in dispersion_optim_list ] if experiment_type + "_scipy" in adaptive_buttons and dispersion == False: new_class.update_params(params) V = new_class.e_nondim(new_class.define_voltages()) w0 = [0, 0, V[0]] wsol = odeint(new_class.current_ode_sys, w0, new_class.time_vec, rtol=1e-6, atol=1e-6) timeseries = new_class.i_nondim(wsol[:, 0][new_class.time_idx]) plot_voltages = V[new_class.time_idx] plot_times = new_class.t_nondim( new_class.time_vec[new_class.time_idx]) else: timeseries = new_class.i_nondim( new_class.test_vals(params, "timeseries")) plot_times = new_class.t_nondim( new_class.time_vec[new_class.time_idx]) plot_voltages = new_class.e_nondim( new_class.define_voltages()[new_class.time_idx]) if experiment_type != "dcv": harms = harmonics(list(range(start_harm, start_harm + num_harms)), new_class.dim_dict["omega"], 0.05) if experiment_type == "ramped": experiment_harmonics = harms.generate_harmonics(plot_times, timeseries, hanning=True) elif experiment_type == "sinusoidal": experiment_harmonics = harms.generate_harmonics(plot_times, timeseries, hanning=False) one_tail_len = (len(harms.exposed_f) // 2) + 1 freqs = harms.exposed_f[:one_tail_len] fft = abs(harms.exposed_Y[:one_tail_len]) if experiment_type == "ramped": if "no_decimation" in plot_buttons: plot_list = [[plot_times, timeseries], [plot_voltages, timeseries], [plot_times[0::10], plot_voltages[0::10]], [freqs, fft]] elif "ramped_rdp" in plot_buttons: simped_line = np.array( rdp_lines.rdp_controller(plot_times, timeseries, max(timeseries) / 5)) sorted_idx = np.argsort(simped_line[:, 0]) simped_times = simped_line[:, 0][sorted_idx] simped_timeseries = simped_line[:, 1][sorted_idx] plot_list = [[simped_times, simped_timeseries], [plot_voltages[0::10], timeseries[0::10]], [plot_times[0::10], plot_voltages[0::10]], [freqs, fft]] elif "decimation" in plot_buttons: plot_list = [[plot_times[0::10], timeseries[0::10]], [plot_voltages[0::10], timeseries[0::10]], [plot_times[0::10], plot_voltages[0::10]], [freqs[0::10], fft[0::10]]] else: plot_list = [[plot_times, timeseries], [plot_voltages, timeseries], [plot_times, plot_voltages], [freqs, fft]] else: plot_list = [[plot_times[0::10], timeseries[0::10]], [plot_voltages[0::10], timeseries[0::10]], [plot_times[0::10], plot_voltages[0::10]]] non_harm_plots = [{ "figure_object": { "data": [{ "x": plot_list[i][0], "y": plot_list[i][1], "type": "scattergl", "name": "Current sim", "render_mode": "webgl" }], "layout": { "height": plot_height, "xaxis": { "title": { "text": labels[experiment_type]["x"][i] } }, "yaxis": { "title": { "text": labels[experiment_type]["y"][i] } } }, }, "parameters": dict(zip(RV.optim_list, slider_params)) } for i in range(0, len(plot_list))] return_arg = non_harm_plots if experiment_type != "dcv": for i in range(0, num_harms): xlabel = "" ylabel = "" b = 0 if i == (num_harms - 1): xlabel = "Time(s)" b = 30 if i == num_harms // 2: ylabel = "Current(A)" if experiment_type == "ramped": x_plot = plot_times y_plot = np.abs(experiment_harmonics[i, :][0::10]) else: x_plot = plot_voltages y_plot = np.real(experiment_harmonics[i, :]) return_arg.append({ "data": [ { "x": x_plot, "y": y_plot, "type": "line", "name": "Current sim", "render_mode": "webgl" }, ], "layout": { "height": plot_height // num_harms, "margin": { "pad": 0, "b": b, "t": 5 }, "xaxis": { "title": { "text": xlabel } }, "yaxis": { "title": { "text": ylabel } } }, }) return return_arg else: if experiment_type == "dcv": return [{ "figure_object": { "layout": ramped_layout } }] * len(labels["dcv"]["y"]) else: return [{ "figure_object": { "layout": ramped_layout } }] * len(labels["ramped"]["y"]) + [{ "layout": harmonic_layout }] * (num_harms)
'CdlE3': [-0.001, 0.001], 'gamma': [1e-11, 1e-9], 'k_0': [10, 1e3], 'alpha': [0.35, 0.65], "cap_phase": [0, 2 * math.pi], "E0_mean": [0.15, 0.3], "E0_std": [0.001, 0.2], "k0_shape": [0, 5], "k0_loc": [0, 1e4], "k0_scale": [0, 1e4], "k0_range": [1e2, 1e4], 'phase': [0, 2 * math.pi] } noramp_test = single_electron(file_name=None, dim_paramater_dictionary=param_list, simulation_options=simulation_options, other_values=other_values, param_bounds=param_bounds) noramp_test.def_optim_list([ "E0_mean", "E0_std", "k_0", "Ru", "Cdl", "CdlE1", "CdlE2", "gamma", 'omega', "cap_phase", "phase", "alpha" ]) #test simulation with some random params within bounds random_params = np.random.rand(len(noramp_test.optim_list)) #changes numbers distributed according to U(0,1) to position within bound random_params = noramp_test.change_norm_group(random_params, "un_norm") #Simulate using sinusoidal parameters test_sim = noramp_test.test_vals(random_params, "timeseries", test=False) test_voltage = noramp_test.define_voltages() #time, voltage and current are returned in non-dimensional form, so need to redimensionalise dim_current = noramp_test.i_dim(test_sim)
def apply_slider_changes(n_clicks, *inputs): slider_input_len=len(table_names) states=inputs[:slider_input_len] table_data=inputs[slider_input_len] drop_down_opts=inputs[slider_input_len+1] r_button, s_button, d_button=inputs[slider_input_len+2:] for i in range(0, len(states)): if states[i] is not None: val=states[i] val=min(val, param_bounds[table_names[i]][1]) val=max(val, param_bounds[table_names[i]][0]) RV.dim_dict[RV.optim_list[i]]=val SV.dim_dict[RV.optim_list[i]]=val SV.dim_dict["original_gamma"]=SV.dim_dict["gamma"] RV.dim_dict["original_gamma"]=RV.dim_dict["gamma"] SV.dim_dict["original_omega"]=SV.dim_dict["omega"] SV.simulation_options["no_transient"]=2/SV.dim_dict["omega"] RV.simulation_options["no_transient"]=2/RV.dim_dict["omega"] SV.simulation_options["optim_list"]=[] RV.simulation_options["optim_list"]=[] SV.dim_dict["d_E"]=(SV.dim_dict["E_reverse"]-SV.dim_dict["E_start"])/2 RV.dim_dict["d_E"]=(RV.dim_dict["E_reverse"]-RV.dim_dict["E_start"])/4 RV_new=single_electron(None, RV.dim_dict, RV.simulation_options, RV.other_values, param_bounds) SV_new=single_electron(None, SV.dim_dict, SV.simulation_options, SV.other_values, param_bounds) params=[] ramped_layout=go.Layout(height=plot_height) harmonic_layout=go.Layout(height=plot_height//num_harms, margin={"pad":0, "b":0, "t":0}) if n_clicks>0: for q in range(0, len(table_data)): table_data[q]["Value"]=RV_new.dim_dict[table_data[q]["Parameter"]] ramped_x_val, ramped_y_val, r_timeseries, r_times=plot_args(RV_new, r_button, params, "r") sinusoidal_x_val, sinusoidal_y_val, s_timeseries, s_times, s_volts=plot_args(SV_new, s_button, params, "s") #SPACEFORDCV if r_button!="r_x_volt_time": r_harms=harmonics(list(range(start_harm, start_harm+num_harms)), RV_new.dim_dict["omega"], 0.05) ramped_harmonics=r_harms.generate_harmonics(r_times[0::10], r_timeseries[0::10], hanning=True) else: ramped_harmonics=np.zeros((num_harms, len(r_timeseries))) if s_button!="s_x_volt_time": s_harms=harmonics(list(range(start_harm, start_harm+num_harms)), SV_new.dim_dict["omega"], 0.05) SV_harmonics=s_harms.generate_harmonics(s_times, s_timeseries, hanning=False) else: SV_harmonics=np.zeros((num_harms, len(s_timeseries))) return_arg=[{"data": [ {"x":ramped_x_val, "y": ramped_y_val, "type": "line", "name": "Ramped", "render_mode":"webgl"}, ], "layout": ramped_layout, }] for i in range(0, num_harms): return_arg.append({"data": [ {"x":r_times, "y": np.abs(ramped_harmonics[i,:]), "type": "line", "name": "Ramped_harm"+str(i), "render_mode":"webgl"}, ], "layout": harmonic_layout, }) return_arg.append({"data": [ {"x":sinusoidal_x_val, "y": sinusoidal_y_val, "type": "line", "name": "SV", "render_mode":"webgl"}, ], "layout": ramped_layout, }) for i in range(0, num_harms): return_arg.append({"data": [ {"x":s_volts, "y": np.real(SV_harmonics[i,:]), "type": "line", "name": "sv_harm"+str(i), "render_mode":"webgl"}, ], "layout": harmonic_layout, }) return_arg.append(table_data) return return_arg return [{"layout": ramped_layout}]+[{"layout": harmonic_layout}]*(num_harms)+[{"layout": ramped_layout}]+[{"layout": harmonic_layout}]*(num_harms)+[table_data]
} param_bounds = { 'E_0': [-0.1, -0.04], 'omega': [0.95 * param_list['omega'], 1.05 * param_list['omega']], #8.88480830076, # (frequency Hz) 'Ru': [0, 2e3], # (uncompensated resistance ohms) 'Cdl': [0, 1e-3], #(capacitance parameters) 'CdlE1': [-0.05, 0.05], #0.000653657774506, 'CdlE2': [-0.05, 0.05], #0.000245772700637, 'CdlE3': [-0.05, 0.05], #1.10053945995e-06, 'gamma': [0.1 * param_list["original_gamma"], 8 * param_list["original_gamma"]], 'k_0': [0, 7e3], #(reaction rate s-1) 'alpha': [0.498, 0.502], "cap_phase": [0.8 * 3 * math.pi / 2, 1.2 * 3 * math.pi / 2], "E0_mean": [-0.1, -0.04], "E0_std": [1e-4, 0.1], "E0_skew": [-10, 10], "alpha_mean": [0.4, 0.65], "alpha_std": [1e-3, 0.3], "k0_shape": [0, 1], "k0_scale": [0, 1e4], 'phase': [0.8 * 3 * math.pi / 2, 1.2 * 3 * math.pi / 2], } eis = single_electron(None, param_list, simulation_options, other_values, param_bounds) curr = eis.test_vals([], "timeseries") plt.plot(eis.define_voltages(transient=True), curr) plt.show()