def tradeoffs_setup(lock=True): box1 = IntText(value = 20, description='Euler steps') if lock: box2 = BoundedFloatText(value = 2.2, description='predict value', max=6) else: box2 = BoundedFloatText(value = 2.2, description='predict value') return box1, box2
def create_check_radio_boxes(self): labels = dict() for k_name, v in self.properties_and_values.items(): if len(v) == 3: label = v[2] elif MetaPropertiesType.TEXT.value == v[0].value and len(v) == 2: label = v[1] else: label = k_name labels[k_name] = label if MetaPropertiesType.UNIQUE.value == v[0].value: # radiobutton self.radiobuttons[k_name] = RadioButtons(name=k_name, options=v[1], disabled=False, indent=False) elif MetaPropertiesType.COMPOUND.value == v[0].value: # checkbox self.checkboxes[k_name] = [Checkbox(False, indent=False, name=k_name, description=prop_name) for prop_name in v[1]] elif MetaPropertiesType.CONTINUE.value == v[0].value: self.bounded_text[k_name] = BoundedFloatText(value=v[1][0], min=v[1][0], max=v[1][1]) elif MetaPropertiesType.TEXT.value == v[0].value: self.box_text[k_name] = Textarea(disabled=False) return labels
def plot_growth_interactive(): # interact(plot_growth, mass_ratio=FloatSlider(min=0.005, max=0.1, step=.002, description='$m/M$', value = 0.001)) interact(plot_growth, mass_ratio=BoundedFloatText(min=0.001, max=0.1, step=0.001, description='$m/M$', value=0.001))
def test_player_link_to_ipywidgets(): traj = pt.datafiles.load_tz2() view = nv.show_pytraj(traj) int_text = IntText(2) float_text = BoundedFloatText(40, min=10) HBox([int_text, float_text]) link((int_text, 'value'), (view.player, 'step')) link((float_text, 'value'), (view.player, 'delay')) assert view.player.step == 2 assert view.player.delay == 40 float_text.value = 100 assert view.player.delay == 100 float_text.value= 0.00 # we set min=10 assert view.player.delay == 10
def test_player_link_to_ipywidgets(): traj = pt.datafiles.load_tz2() view = nv.show_pytraj(traj) int_text = IntText(2) float_text = BoundedFloatText(40, min=10) HBox([int_text, float_text]) link((int_text, 'value'), (view.player, 'step')) link((float_text, 'value'), (view.player, 'delay')) nt.assert_equal(view.player.step, 2) nt.assert_equal(view.player.delay, 40) float_text.value = 100 nt.assert_equal(view.player.delay, 100) float_text.value = 0.00 # we set min=10 nt.assert_equal(view.player.delay, 10)
def vis(self, oracle=False, oracle_res=4): """ optionally save all predicted files through output writer """ assert not self.mp_distributed from panoptic.vis import Visualizer from ipywidgets import interactive, BoundedIntText, BoundedFloatText from IPython.display import display model, loader = self.model, self.val_loader dset, pcv = loader.dataset, model.pcv vis_engine = Visualizer(cfg, dset.meta, pcv) vis_engine.display_stdout_and_err_in_curr_cell() def logic(inx, hmap_thresh): _, segments_info, img, pan_gt_mask = dset.pan_getitem(inx) if oracle: sem_pd, vote_pd = gt_tsr_res_reduction( oracle_res, self.gt_prod_handle, dset.meta, pcv, pan_gt_mask, segments_info ) else: # sem_pd, _ = gt_tsr_res_reduction( # oracle_res, self.gt_prod_handle, # dset.meta, pcv, pan_gt_mask, segments_info # ) sem_pd, vote_pd = model.infer( dset[inx][0].unsqueeze(0).cuda(), softmax_normalize=True ) # img = _downsample_PIL(img) # rtchange if cfg.data.dataset.params['caffe_mode']: img = np.array(img)[:, :, ::-1] pan_gt_mask = _downsample_PIL(pan_gt_mask) vis_engine.vis( img, pan_gt_mask, segments_info, sem_pd, vote_pd, self.gt_prod_handle, model.criteria, hmap_thresh ) wdgt = interactive( logic, inx=BoundedIntText( min=0, max=len(dset) - 1, step=1 ), hmap_thresh=BoundedFloatText( value=cfg.pcv.hmap_thresh, min=0, max=1000.0, step=0.2, description='ws_thresh' ) ) wdgt.children[-1].layout.height = '1300px' display(wdgt) return vis_engine
def __init__(self, signal_components: dict): """ Summary: Object constructor. """ super().__init__(signal_components, "butter_smoother") wbft_fc = BoundedFloatText(description="fc:", value=0.05, min=0, max=0.5, step=0.01, disabled=False) self.add_options([wbft_fc])
class Foreground(object): style = {'description_width': '200px'} layout = {'width': '300px'} widgets = { 'foreground': BoundedFloatText(value=1, min=0, max=1e6, step=0.1, description='foreground counts (elec/s/pix)'), } params = ('foreground', ) def __init__(self): """ """ for key, widget in self.widgets.items(): widget.style = self.style widget.layout = self.layout self.widget = VBox([self.widgets['foreground']])
def interact_with_plot_all_outputs(sa_dict, demo=False, manual=True): """ This function adds the ability to interactively adjust all of the plotting.make_plot() arguments. Parameters ---------- sa_dict : dict a dictionary with all the sensitivity analysis results. demo : bool, optional plot only few outcomes for demo purpose. Returns ------- Interactive widgets to control plot """ min_val_box = BoundedFloatText(value=0.01, min=0, max=1, description='Min value:') top_box = IntText(value=20, description='Show top:') stacks = Checkbox( description='Show stacked plots:', value=True, ) error_bars = Checkbox(description='Show error bars:', value=True) log_axis = Checkbox(description='Use log axis:', value=True) # get a list of all the parameter options key = sa_dict.keys()[0] param_options = list(sa_dict[key][0].Parameter.values) highlighted = SelectMultiple(description="Choose parameters to highlight", options=param_options, value=[]) return interact(plot_all_outputs, sa_dict=fixed(sa_dict), demo=fixed(demo), min_val=min_val_box, top=top_box, stacked=stacks, error_bars=error_bars, log_axis=log_axis, highlighted_parameters=highlighted, __manual=manual)
def travel_time_fun(): center = [-43.51876443245584, 172.66858981519297] m = GroundwaterMap(basemap=basemaps.Esri.WorldImagery, center=center, zoom=14) t = IntSlider(value=100, description=r'$t_t$ [day]', min=10, max=365, step=20, continuous_update=False, layout=Layout(max_width='250px')) Q = FloatSlider(value=100, description=r'pumping [L/s]', min=0, max=200, step=20, continuous_update=False, layout=Layout(max_width='250px')) q = FloatSlider(value=1.5, description=r'$dh/dx$ [m/km]', min=0.5, max=3, step=0.5, continuous_update=False, layout=Layout(max_width='270px')) th = BoundedFloatText(value=135, min=0, max=180, description='flow dir. [$^{\circ}$]', layout=Layout(max_width='150px')) m.add_well(center) m.configure(widgets={ 't': t, 'Q': Q, 'q': q, 'th': th }, func=partial(m.travel_time, 1.e-4, 0.03, 10.)) return VBox([m, HBox([Q, t, q, th])])
def __init__(self, signal_components: dict, parent=None): """ Summary: Object constructor. Arguments : signal_components - dictionary with the signal/components names """ super().__init__(signal_components, peak_detector_widget._type, parent) # Add specific options wbit_aggregate = BoundedIntText(description="aggregate:", value=0, min=0, step=1, disabled=False) wcb_filter_by_angle = Checkbox(value=False, description='filter_by_angle:', disabled=False) wbit_min_duration = BoundedIntText(description="min_duration:", value=-1, min=-1, step=1, disabled=False) wbit_min_increase = BoundedFloatText(description="min_increase:", value=-1, min=-1, step=1, disabled=False) self.add_options([ wbit_min_duration, wbit_min_increase, wcb_filter_by_angle, wbit_aggregate ])
def __init__(self): # micron_units = HTMLMath(value=r"$\mu M$") micron_units = Label( 'micron') # use "option m" (Mac, for micro symbol) # micron_units = Label('microns') # use "option m" (Mac, for micro symbol) constWidth = '180px' # tab_height = '400px' tab_height = '500px' # tab_layout = Layout(width='900px', # border='2px solid black', # tab_layout = Layout(width='850px', # border='2px solid black', # height=tab_height, overflow_y='scroll',) # np_tab_layout = Layout(width='800px', # border='2px solid black', # height='350px', overflow_y='scroll',) # my_domain = [0,0,-10, 2000,2000,10, 20,20,20] # [x,y,zmin, x,y,zmax, x,y,zdelta] # label_domain = Label('Domain ($\mu M$):') label_domain = Label('Domain (micron):') stepsize = 10 self.xmin = FloatText( step=stepsize, # description='$X_{min}$', description='Xmin', layout=Layout(width=constWidth), ) self.ymin = FloatText( step=stepsize, description='Ymin', layout=Layout(width=constWidth), ) self.zmin = FloatText( step=stepsize, description='Zmin', layout=Layout(width=constWidth), ) self.xmax = FloatText( step=stepsize, description='Xmax', layout=Layout(width=constWidth), ) self.ymax = FloatText( step=stepsize, description='Ymax', layout=Layout(width=constWidth), ) self.zmax = FloatText( step=stepsize, description='Zmax', layout=Layout(width=constWidth), ) # description='$Time_{max}$', self.tmax = BoundedFloatText( min=0., max=100000000, step=stepsize, description='Max Time', layout=Layout(width=constWidth), ) self.xdelta = BoundedFloatText( min=1., description='dx', # '∆x', # Mac: opt-j for delta layout=Layout(width=constWidth), ) self.ydelta = BoundedFloatText( min=1., description='dy', layout=Layout(width=constWidth), ) self.zdelta = BoundedFloatText( min=1., description='dz', layout=Layout(width=constWidth), ) """ self.tdelta = BoundedFloatText( min=0.01, description='$Time_{delta}$', layout=Layout(width=constWidth), ) """ """ self.toggle2D = Checkbox( description='2-D', layout=Layout(width=constWidth), ) def toggle2D_cb(b): if (self.toggle2D.value): #zmin.disabled = zmax.disabled = zdelta.disabled = True zmin.disabled = True zmax.disabled = True zdelta.disabled = True else: zmin.disabled = False zmax.disabled = False zdelta.disabled = False self.toggle2D.observe(toggle2D_cb) """ x_row = HBox([self.xmin, self.xmax, self.xdelta]) y_row = HBox([self.ymin, self.ymax, self.ydelta]) z_row = HBox([self.zmin, self.zmax, self.zdelta]) self.omp_threads = BoundedIntText( min=1, description='# threads', layout=Layout(width=constWidth), ) # self.toggle_prng = Checkbox( # description='Seed PRNG', style={'description_width': 'initial'}, # e.g. 'initial' '120px' # layout=Layout(width=constWidth), # ) # self.prng_seed = BoundedIntText( # min = 1, # description='Seed', # disabled=True, # layout=Layout(width=constWidth), # ) # def toggle_prng_cb(b): # if (toggle_prng.value): # self.prng_seed.disabled = False # else: # self.prng_seed.disabled = True # self.toggle_prng.observe(toggle_prng_cb) #prng_row = HBox([toggle_prng, prng_seed]) self.toggle_svg = Checkbox( description='Cells', # SVG layout=Layout(width='150px')) # constWidth = '180px' # self.svg_t0 = BoundedFloatText ( # min=0, # description='$T_0$', # layout=Layout(width=constWidth), # ) self.svg_interval = BoundedIntText( min=1, max= 99999999, # TODO: set max on all Bounded to avoid unwanted default description='every', layout=Layout(width='160px'), ) def toggle_svg_cb(b): if (self.toggle_svg.value): # self.svg_t0.disabled = False self.svg_interval.disabled = False else: # self.svg_t0.disabled = True self.svg_interval.disabled = True self.toggle_svg.observe(toggle_svg_cb) self.toggle_mcds = Checkbox( # value=False, description='Subtrates', # Full layout=Layout(width='180px'), ) # self.mcds_t0 = FloatText( # description='$T_0$', # disabled=True, # layout=Layout(width=constWidth), # ) self.mcds_interval = BoundedIntText( min=0, max=99999999, description='every', # disabled=True, layout=Layout(width='160px'), ) def toggle_mcds_cb(b): if (self.toggle_mcds.value): # self.mcds_t0.disabled = False #False self.mcds_interval.disabled = False else: # self.mcds_t0.disabled = True self.mcds_interval.disabled = True self.toggle_mcds.observe(toggle_mcds_cb) #svg_output_row = HBox([toggle_svg, svg_t0, svg_interval]) #mat_output_row = HBox([toggle_mcds, mcds_t0, mcds_interval]) # svg_mat_output_row = HBox([self.toggle_svg, self.svg_interval, self.toggle_mcds, self.mcds_interval]) svg_mat_output_row = HBox([ Label('Plots:'), self.toggle_svg, HBox([self.svg_interval, Label('min')]), self.toggle_mcds, HBox([self.mcds_interval, Label('min')]) ]) #write_config_row = HBox([write_config_button, write_config_file]) #run_sim_row = HBox([run_button, run_command_str, kill_button]) # run_sim_row = HBox([run_button, run_command_str]) # run_sim_row = HBox([run_button.w]) # need ".w" for the custom RunCommand widget label_blankline = Label('') # toggle_2D_seed_row = HBox([toggle_prng, prng_seed]) # toggle2D box_layout = Layout(border='1px solid') # box_layout = Layout(border='1px solid', height='500px') # domain_box = VBox([label_domain,x_row,y_row,z_row], layout=box_layout) domain_box = VBox([label_domain, x_row, y_row], layout=box_layout) self.tab = VBox([ domain_box, # label_blankline, HBox([self.tmax, Label('min')]), self.omp_threads, svg_mat_output_row, # HBox([self.substrate[3], self.diffusion_coef[3], self.decay_rate[3] ]), ]) # output_dir, toggle_2D_seed_
plt.scatter(corrupted[apples][:, 0], corrupted[apples][:, 1], color="red", alpha=0.7) plt.scatter(corrupted[pears][:, 0], corrupted[pears][:, 1], color="green", alpha=0.7) ax_2.set_xlabel("yellowness") ax_2.set_ylabel("symmetry") plt.show() @interact(b=BoundedFloatText(value=str(g_bias), min=min_b, max=max_b, description="Enter $b$:"), w1=BoundedFloatText(value="0", min=min_w1, max=max_w1, description="Enter $w_1$:"), w2=BoundedFloatText(value="0", min=min_w2, max=max_w2, description="Enter $w_2$:"), learning_rate=Dropdown( options=["0.01", "0.05", "0.1", "0.5", "1", "5", "10"], value="0.01", description="Learning rate: ")) def learning_curve_for_starting_point(b, w1, w2, learning_rate=0.1): w = np.array([b, w1, w2]).reshape(X_corrupted.shape[1], 1)
def _create_input_widgets(self) -> None: self._input["smiles"] = Text(description="SMILES", continuous_update=False) self._input["smiles"].observe(self._show_mol, names="value") display(self._input["smiles"]) self._output["smiles"] = Output( layout={"border": "1px solid silver", "width": "50%", "height": "180px"} ) display(self._output["smiles"]) self._input["stocks"] = [ Checkbox( value=True, description=key, style={"description_width": "initial"}, layout={"justify": "left"}, ) for key in self.finder.stock.items ] list_ = [Label("Limit atom occurrences")] self._input["stocks_atom_count_on"] = [] self._input["stocks_atom_count"] = [] current_criteria = self.finder.stock.stop_criteria.get("counts", {}) for atom in ["C", "O", "N"]: chk_box = Checkbox( value=atom in current_criteria, description=atom, layout={"justify": "left", "width": "80px"}, style={"description_width": "initial"}, ) self._input["stocks_atom_count_on"].append(chk_box) inpt = BoundedIntText( value=current_criteria.get(atom, 0), min=0, layout={"width": "80px"}, ) self._input["stocks_atom_count"].append(inpt) list_.append(HBox([chk_box, inpt])) box_stocks = VBox( [Label("Stocks")] + self._input["stocks"] + list_, layout={"border": "1px solid silver"}, ) self._input["policy"] = widgets.Dropdown( options=self.finder.expansion_policy.items, description="Expansion Policy:", style={"description_width": "initial"}, ) self._input["filter"] = widgets.Dropdown( options=["None"] + self.finder.filter_policy.items, description="Filter Policy:", style={"description_width": "initial"}, ) max_time_box = self._make_slider_input("time_limit", "Time (min)", 1, 120) self._input["time_limit"].value = self.finder.config.time_limit / 60 max_iter_box = self._make_slider_input( "iteration_limit", "Max Iterations", 100, 2000 ) self._input["iteration_limit"].value = self.finder.config.iteration_limit self._input["return_first"] = widgets.Checkbox( value=self.finder.config.return_first, description="Return first solved route", ) vbox = VBox( [ self._input["policy"], self._input["filter"], max_time_box, max_iter_box, self._input["return_first"], ] ) box_options = HBox([box_stocks, vbox]) self._input["C"] = FloatText(description="C", value=self.finder.config.C) self._input["max_transforms"] = BoundedIntText( description="Max steps for substrates", min=1, max=6, value=self.finder.config.max_transforms, style={"description_width": "initial"}, ) self._input["cutoff_cumulative"] = BoundedFloatText( description="Policy cutoff cumulative", min=0, max=1, value=self.finder.config.cutoff_cumulative, style={"description_width": "initial"}, ) self._input["cutoff_number"] = BoundedIntText( description="Policy cutoff number", min=1, max=1000, value=self.finder.config.cutoff_number, style={"description_width": "initial"}, ) self._input["filter_cutoff"] = BoundedFloatText( description="Filter cutoff", min=0, max=1, value=self.finder.config.filter_cutoff, style={"description_width": "initial"}, ) self._input["exclude_target_from_stock"] = widgets.Checkbox( value=self.finder.config.exclude_target_from_stock, description="Exclude target from stock", ) box_advanced = VBox( [ self._input["C"], self._input["max_transforms"], self._input["cutoff_cumulative"], self._input["cutoff_number"], self._input["filter_cutoff"], self._input["exclude_target_from_stock"], ] ) children = [box_options, box_advanced] tab = widgets.Tab() tab.children = children tab.set_title(0, "Options") tab.set_title(1, "Advanced") display(tab)
class Galaxy(object): """ """ style = {'description_width': '200px'} layout = {'width': '300px'} widgets = { 'redshift': BoundedFloatText(value=1, min=0, max=10, step=0.1, description="Redshift"), 'bulge_scale': BoundedFloatText(value=0.5, min=0, max=10, step=0.1, description="Bulge scale (arcsec)"), 'disk_scale': BoundedFloatText(value=0.3, min=0, max=10, step=0.1, description="Disk scale (arcsec)"), 'bulge_fraction': BoundedFloatText(value=.5, min=0, max=1, step=0.1, description="Bulge fraction"), 'axis_ratio': BoundedFloatText(value=1, min=0.01, max=1, step=0.1, description="Axis ratio"), 'pa': BoundedFloatText(value=0, min=-180, max=180, step=10, description="Position angle"), 'iso': Checkbox(value=True, description="Isotropize"), 'half_light_radius': HBox([Label("Half-light radius (arcsec): "), Label(value="0")]), 'velocity_dispersion': BoundedFloatText(value=0, min=0, max=1000, step=0.1, description="Velocity dispersion (km/s)"), 'flux_ha': BoundedFloatText( value=2, min=0, max=1000, step=0.1, description='Flux H$\\alpha$ 6565 ($10^{-16}$ erg/cm2/s):'), 'n2_ha_ratio': BoundedFloatText(value=0, min=0, max=10, step=0.1, description='NII/H$\\alpha$:'), 'flux_n2a': BoundedFloatText(value=0, min=0, max=1000, step=0.1, description='Flux NIIa 6550 ($10^{-16}$ erg/cm2/s):'), 'flux_n2b': BoundedFloatText(value=0, min=0, max=1000, step=0.1, description='Flux NIIb 6585 ($10^{-16}$ erg/cm2/s):'), 'flux_hb': BoundedFloatText(value=0, min=0, max=1000, step=0.1, description='Flux Hb 4863 ($10^{-16}$ erg/cm2/s):'), 'flux_o3a': BoundedFloatText( value=0, min=0, max=1000, step=0.1, description='Flux OIIIa 4960 ($10^{-16}$ erg/cm2/s):'), 'flux_o3b': BoundedFloatText( value=0, min=0, max=1000, step=0.1, description='Flux OIIIb 5008 ($10^{-16}$ erg/cm2/s):'), 'flux_s2a': BoundedFloatText(value=0, min=0, max=1000, step=0.1, description='Flux SIIa 6718 ($10^{-16}$ erg/cm2/s):'), 'flux_s2b': BoundedFloatText(value=0, min=0, max=1000, step=0.1, description='Flux SIIb 6733 ($10^{-16}$ erg/cm2/s):'), 'flux_o2': BoundedFloatText(value=0, min=0, max=1000, step=0.1, description='Flux OII 3727 ($10^{-16}$ erg/cm2/s):'), 'flux_s3a': BoundedFloatText( value=0, min=0, max=1000, step=0.1, description='Flux SIIIa 9069 ($10^{-16}$ erg/cm2/s):'), 'flux_s3b': BoundedFloatText( value=0, min=0, max=1000, step=0.1, description='Flux SIIIb 9531 ($10^{-16}$ erg/cm2/s):'), } params = ('redshift', 'bulge_scale', 'disk_scale', 'bulge_fraction', 'axis_ratio', 'pa', 'iso', 'velocity_dispersion', 'flux_ha', 'flux_n2a', 'flux_n2b', 'flux_hb', 'flux_o3a', 'flux_o3b', 'flux_s2a', 'flux_s2b', 'flux_o2', 'flux_s3a', 'flux_s3b') def __init__(self): for key, widget in self.widgets.items(): widget.style = self.style widget.layout = self.layout self.widgets['bulge_scale'].observe(self.compute_radius, names='value') self.widgets['disk_scale'].observe(self.compute_radius, names='value') self.widgets['bulge_fraction'].observe(self.compute_radius, names='value') self.widgets['axis_ratio'].observe(self.compute_radius, names='value') self.widgets['flux_ha'].observe(self.flux_ha_change, names='value') self.widgets['n2_ha_ratio'].observe(self.n2_ha_ratio_change, names='value') self.widgets['flux_n2a'].observe(self.flux_n2a_change, names='value') self.widgets['flux_n2b'].observe(self.flux_n2b_change, names='value') self.widgets['flux_s2a'].observe(self.flux_s2a_change, names='value') self.widgets['flux_s2b'].observe(self.flux_s2b_change, names='value') self.widgets['flux_o3a'].observe(self.flux_o3a_change, names='value') self.widgets['flux_o3b'].observe(self.flux_o3b_change, names='value') self.compute_radius() title = HTML("<h2>Galaxy</h2>") n2box = HBox([ self.widgets['n2_ha_ratio'], self.widgets['flux_n2a'], self.widgets['flux_n2b'] ]) s2box = HBox([self.widgets['flux_s2a'], self.widgets['flux_s2b']]) o3box = HBox([self.widgets['flux_o3a'], self.widgets['flux_o3b']]) hbbox = HBox([self.widgets['flux_hb']]) o2box = HBox([self.widgets['flux_o2']]) s3box = HBox([self.widgets['flux_s3a'], self.widgets['flux_s3b']]) elements = [] elements += [self.widgets['redshift']] sizebox = VBox([ self.widgets['bulge_scale'], self.widgets['disk_scale'], self.widgets['bulge_fraction'], self.widgets['axis_ratio'], self.widgets['pa'], self.widgets['iso'] ]) elements += [ HTML("<b>Size</b>"), HBox([sizebox, self.widgets['half_light_radius']]) ] elements += [ HTML("<b>Emission lines</b>"), self.widgets['velocity_dispersion'], self.widgets['flux_ha'], n2box, s2box, hbbox, o3box, o2box, s3box ] self.widget = VBox(elements) def compute_radius(self, change=None): """ """ radius = bulgy_disk_radius( np.array([self.widgets['bulge_scale'].value]), np.array([self.widgets['disk_scale'].value]), np.array([self.widgets['bulge_fraction'].value]), np.array([self.widgets['axis_ratio'].value]), 0.5)[0] self.widgets['half_light_radius'].children[1].value = "%3.2f" % radius def n2_ha_ratio_change(self, change): y = self.widgets['n2_ha_ratio'].value * self.widgets['flux_ha'].value self.widgets['flux_n2a'].value = y / 4. self.widgets['flux_n2b'].value = y * 3 / 4. flux_ha_change = n2_ha_ratio_change def flux_n2b_change(self, change): self.widgets['flux_n2a'].value = self.widgets['flux_n2b'].value / 3. self.widgets['n2_ha_ratio'].value = ( self.widgets['flux_n2a'].value + self.widgets['flux_n2b'].value) / self.widgets['flux_ha'].value def flux_n2a_change(self, change): self.widgets['flux_n2b'].value = self.widgets['flux_n2a'].value * 3. self.widgets['n2_ha_ratio'].value = ( self.widgets['flux_n2a'].value + self.widgets['flux_n2b'].value) / self.widgets['flux_ha'].value def flux_s2b_change(self, change): self.widgets['flux_s2a'].value = self.widgets['flux_s2b'].value def flux_s2a_change(self, change): self.widgets['flux_s2b'].value = self.widgets['flux_s2a'].value def flux_o3b_change(self, change): self.widgets['flux_o3a'].value = self.widgets['flux_o3b'].value / 3. def flux_o3a_change(self, change): self.widgets['flux_o3b'].value = self.widgets['flux_o3a'].value * 3. def flux_s3b_change(self, change): self.widgets['flux_s3a'].value = self.widgets['flux_s3b'].value
class Analysis(object): style = {'description_width': '200px'} layout = {'width': '400px'} widgets = { 'zmeas_template_file': Dropdown(options=get_template_files(), description='Spec templates file'), 'extraction_sigma': BoundedFloatText(value=2, min=0, max=100, step=0.1, description='Extraction kernel width (pixels)'), 'zmin': BoundedFloatText(value=0, min=0, max=10, step=0.1, description='Redshift grid min'), 'zmax': BoundedFloatText(value=3, min=0, max=10, step=0.1, description='Redshift grid max'), 'zstep': BoundedFloatText(value=0.001, min=0, max=0.01, step=0.0005, description='Redshift grid step'), 'templ_res': BoundedIntText(value=5, min=1, max=100, step=1, description='Resolution parameter'), 'ztol': BoundedFloatText(value=0.01, min=0.0001, max=1, step=0.0005, description='Redshift error tolerance'), 'output': Output(layout={'width': '800px'}), } params = ('zmeas_template_file', 'extraction_sigma', 'zmin', 'zmax', 'zstep', 'ztol', 'templ_res') def __init__(self): """ """ for key, widget in self.widgets.items(): widget.style = self.style widget.layout = self.layout self.widgets['output'].layout = {'width': '800px'} self.widgets['zmeas_template_file'].observe(self.show_template_table, names='value') elements = [] elements += [ HTML('<b>Extraction</b>'), self.widgets['extraction_sigma'] ] elements += [ HTML('<b>Redshift measurement</b>'), self.widgets['zmeas_template_file'], self.widgets['zmin'], self.widgets['zmax'], self.widgets['zstep'], self.widgets['templ_res'], self.widgets['ztol'] ] bot = VBox( [HTML('<b>Spec templates table</b>'), self.widgets['output']], layout={ 'width': '800px', 'display': 'flex' }) top = VBox(elements, layout={'width': '800px', 'display': 'flex'}) self.widget = VBox([top, bot], layout={'width': '800px'}) self.show_template_table() def show_template_table(self, change=None): with self.widgets['output']: clear_output() display(Label(self.widgets['zmeas_template_file'].value)) self.template_path = os.path.join( TEMPLATE_DIR, self.widgets['zmeas_template_file'].value) table = pandas.read_csv(self.template_path, sep=",") display(table)
def __init__(self, name, init_value, max_value=100): self.label = Label(value=name, layout=Layout(width='120px')) self.float_text = BoundedFloatText(min=0, max=max_value, value=init_value, layout=Layout(width='120px')) super().__init__(children=[self.label, self.float_text])
def load_UI(self): '''Setting up the interactive visualization tool''' # UI elements range_slider = IntRangeSlider(value=[1, self.time_window], min=1, max=self.time_window, description="Range: ", continuous_update=False) view_ftr_i = IntSlider(min=1, max=self.num_features, default_value=2, description="View Feature: ", continuous_update=False) self.modify_ftr_i = IntSlider(min=1, max=self.num_features, default_value=2, description="Mod Feature: ", continuous_update=False) uniform_slider = FloatSlider(value=0, min=-1, max=1, step=0.05, description='Value:', continuous_update=False) radio_button_uni = RadioButtons(options=[('Positive Weights', 1), ('Negative Weights', -1)], description='Affect:') select_target = BoundedFloatText( value=(self.min_target + self.max_target) / 2, min=self.min_target, max=self.max_target, layout={'width': '150px'}) radio_button_xyz7 = RadioButtons(options=[ ('Present (' + str(self.forecast_window) + '-last values)', 0), ('Future (' + str(self.forecast_window) + '-next values)', 1) ], description='Affect:') enable_iPCA = Checkbox(value=False, description='Enable iPCA') iml_method = ToggleButtons(options=['LioNets', 'Lime']) self.forecast = Dropdown(options=[('Neural', 6), ('Static', 7), ('N-Beats', 8)], description="Forecast: ") mod = Dropdown(options=[('Original', 0), ('Uniform', 1), ('Mean (Local)', 2), ('Mean (Global)', 3), ('Zeros', 4), ('Noise', 5), ('Forecast (Neural)', 6), ('Forecast (Static)', 7), ('Forecast (N-Beats)', 8), ('Forecast (XYZ7)', 9)], description="Mods: ") jsdlink((self.modify_ftr_i, 'value'), (view_ftr_i, 'value')) # UI layout interpretable_settings = HBox( [Label('Interpretation method:'), iml_method, enable_iPCA]) enable_iPCA.layout.margin = '0 0 0 -50px' interpretable_settings.layout.margin = '20px 0 20px 0' standard_settings = VBox([self.modify_ftr_i, view_ftr_i]) xyz7_settings = VBox([ HBox([Label('Desired Target:'), select_target]), radio_button_xyz7 ]) xyz7_settings.layout.margin = '0 0 0 30px' self.opt1_settings = VBox([mod]) self.opt2_settings = VBox([mod, range_slider]) self.opt3_settings = HBox([ VBox([mod, range_slider]), VBox([uniform_slider, radio_button_uni]) ]) self.opt4_settings = HBox([VBox([mod, self.forecast]), xyz7_settings]) self.mod_settings = VBox([]) ui = VBox([ interpretable_settings, HBox([standard_settings, self.mod_settings]) ]) # Starting the interactive tool inter = interactive_output( self.plot_feature, { 'ftr_i': view_ftr_i, 'mod_ftr_i': self.modify_ftr_i, 'mod': mod, 'rng_sldr': range_slider, 'uni_sldr': uniform_slider, 'rd_btn_uni': radio_button_uni, 'select_target': select_target, 'rd_btn_xyz7': radio_button_xyz7, 'forecast_optns': self.forecast, 'iml_method': iml_method, 'enable_ipca': enable_iPCA }) display(ui, inter)
def _create_input_widgets(self): self._input["smiles"] = Text(description="SMILES", continuous_update=False) self._input["smiles"].observe(self._show_mol, names="value") display(self._input["smiles"]) self._output["smiles"] = Output( layout={"border": "1px solid silver", "width": "50%", "height": "180px"} ) display(self._output["smiles"]) self._input["stocks"] = [ Checkbox(value=True, description=key, layout={"justify": "left"}) for key in self.finder.stock.available_stocks() ] box_stocks = VBox( [Label("Stocks")] + self._input["stocks"], layout={"border": "1px solid silver"}, ) self._input["policy"] = widgets.Dropdown( options=self.finder.policy.available_policies(), description="Neural Policy:", style={"description_width": "initial"}, ) max_time_box = self._make_slider_input("time_limit", "Time (min)", 1, 120) self._input["time_limit"].value = self.finder.config.time_limit / 60 max_iter_box = self._make_slider_input( "iteration_limit", "Max Iterations", 100, 2000 ) self._input["iteration_limit"].value = self.finder.config.iteration_limit self._input["return_first"] = widgets.Checkbox( value=self.finder.config.return_first, description="Return first solved route", ) vbox = VBox( [ self._input["policy"], max_time_box, max_iter_box, self._input["return_first"], ] ) box_options = HBox([box_stocks, vbox]) self._input["C"] = FloatText(description="C", value=self.finder.config.C) self._input["max_transforms"] = BoundedIntText( description="Max steps for substrates", min=1, max=6, value=self.finder.config.max_transforms, style={"description_width": "initial"}, ) self._input["cutoff_cumulative"] = BoundedFloatText( description="Policy cutoff cumulative", min=0, max=1, value=self.finder.config.cutoff_cumulative, style={"description_width": "initial"}, ) self._input["cutoff_number"] = BoundedIntText( description="Policy cutoff number", min=1, max=1000, value=self.finder.config.cutoff_number, style={"description_width": "initial"}, ) self._input["exclude_target_from_stock"] = widgets.Checkbox( value=self.finder.config.exclude_target_from_stock, description="Exclude target from stock", ) box_advanced = VBox( [ self._input["C"], self._input["max_transforms"], self._input["cutoff_cumulative"], self._input["cutoff_number"], self._input["exclude_target_from_stock"], ] ) children = [box_options, box_advanced] tab = widgets.Tab() tab.children = children tab.set_title(0, "Options") tab.set_title(1, "Advanced") display(tab)
def __init__(self, controller: TwittipediaController): self.controller = controller title = HTML(value="<h1>Twittipedia</h1>", description="", disabled=False) # Twitter twitter_title = HTML(value="<b>Tweets</b>", description="", disabled=False) self.query_field = Text(value="", placeholder="Search or enter username", description="", disabled=False, layout=dict(width="auto")) self.query_field.observe(self._query_field_changed, names="value") self.number_of_tweets_field = BoundedIntText( value=DEFAULT_NUMBER_OF_TWEETS, min=1, max=100, step=1, description="", disabled=False, layout=dict(width="auto")) self.number_of_tweets_field.observe( self._number_of_tweets_field_changed, names="value") number_of_tweets_label = Label(value="most recent tweets", disabled=False, layout=dict(width="auto")) number_of_tweets_field_with_label = HBox( (self.number_of_tweets_field, number_of_tweets_label)) self.search_tweets_button = Button(description="Search Tweets", disabled=True, button_style="primary", tooltip="", icon="", layout=dict(width="auto")) self.load_tweets_from_user_button = Button( description="Load Tweets from User", disabled=True, button_style="", tooltip="", icon="", layout=dict(width="auto")) self.twitter_search_buttons = [ self.load_tweets_from_user_button, self.search_tweets_button ] for button in self.twitter_search_buttons: button.on_click(self._twitter_search_button_pressed) twitter_search_buttons_box = Box(self.twitter_search_buttons, layout=dict( justify_content="flex-end", flex_flow="row wrap", )) self.reset_and_clear_tweets_button = Button( description="Reset and Clear Tweets", disabled=True, button_style="danger", tooltip="", icon="", layout=dict(width="auto")) self.reset_and_clear_tweets_button.on_click( self._reset_and_clear_tweets_button_pressed) self.twitter_buttons = self.twitter_search_buttons \ + [self.reset_and_clear_tweets_button] twitter_buttons_box = Box( (self.reset_and_clear_tweets_button, twitter_search_buttons_box), layout=dict( justify_content="space-between", flex_flow="row wrap", )) twitter_box = VBox( (twitter_title, self.query_field, number_of_tweets_field_with_label, twitter_buttons_box)) # Wikipedia search wikipedia_title = HTML(value="<b>Wikipedia Search</b>", description="", disabled=False) self.wikipedia_options = [] self.term_frequency_scaling_parameter_field = BoundedFloatText( value=DEFAULT_TERM_FREQUENCY_SCALING_PARAMETER_VALUE, min=0, max=100, step=0.1, description="", disabled=False, layout=dict(width="auto")) self.term_frequency_scaling_parameter_field.observe( self._term_frequency_scaling_parameter_field_changed, names="value") self.wikipedia_options.append({ "label": "$k_1$${{}}=$", "field": self.term_frequency_scaling_parameter_field, "explanation": "$k_1 \ge 0$" }) self.document_length_scaling_parameter_field = BoundedFloatText( value=DEFAULT_DOCUMENT_LENGTH_SCALING_PARAMETER_VALUE, min=0, max=1, step=0.01, description="", disabled=False, layout=dict(width="auto")) self.document_length_scaling_parameter_field.observe( self._document_length_scaling_parameter_field_changed, names="value") self.wikipedia_options.append({ "label": "$b$${{}}=$", "field": self.document_length_scaling_parameter_field, "explanation": "$0 \le b$${} \le 1$" }) wikipedia_options_box = Box( (VBox([ Label(value=option["label"]) for option in self.wikipedia_options ], layout=dict(align_items="flex-end")), VBox([option["field"] for option in self.wikipedia_options], ), VBox([ Label(value="(" + option["explanation"] + ")") for option in self.wikipedia_options ]))) self.search_wikipedia_button = Button( description="Search Wikipedia with Tweets", disabled=True, button_style="primary", tooltip="", icon="", layout=dict(width="auto")) self.search_wikipedia_button.on_click( self._search_wikipedia_button_pressed) self.reset_and_clear_wikipedia_results_button = Button( description="Reset and Clear Results", disabled=True, button_style="danger", tooltip="", icon="", layout=dict(width="auto")) self.reset_and_clear_wikipedia_results_button.on_click( self._reset_and_clear_wikipedia_results_button_pressed) self.wikipedia_buttons = [ self.reset_and_clear_wikipedia_results_button, self.search_wikipedia_button ] wikipedia_buttons_box = Box(self.wikipedia_buttons, layout=dict( justify_content="space-between", flex_flow="row wrap", )) wikipedia_box = VBox( (wikipedia_title, wikipedia_options_box, wikipedia_buttons_box)) # Result views results_title = HTML(value="<b>Results</b>", description="", disabled=True) self.results_box = VBox([DEFAULT_RESULTS_WIDGET]) self.results = None # Together self.buttons = self.twitter_buttons + self.wikipedia_buttons search_box = VBox((twitter_box, wikipedia_box), # layout=dict(max_width="600px") ) results_box = VBox((results_title, self.results_box)) self.widget = VBox((title, search_box, results_box)) self._reset_and_clear_tweets()
class TwittipediaView: def __init__(self, controller: TwittipediaController): self.controller = controller title = HTML(value="<h1>Twittipedia</h1>", description="", disabled=False) # Twitter twitter_title = HTML(value="<b>Tweets</b>", description="", disabled=False) self.query_field = Text(value="", placeholder="Search or enter username", description="", disabled=False, layout=dict(width="auto")) self.query_field.observe(self._query_field_changed, names="value") self.number_of_tweets_field = BoundedIntText( value=DEFAULT_NUMBER_OF_TWEETS, min=1, max=100, step=1, description="", disabled=False, layout=dict(width="auto")) self.number_of_tweets_field.observe( self._number_of_tweets_field_changed, names="value") number_of_tweets_label = Label(value="most recent tweets", disabled=False, layout=dict(width="auto")) number_of_tweets_field_with_label = HBox( (self.number_of_tweets_field, number_of_tweets_label)) self.search_tweets_button = Button(description="Search Tweets", disabled=True, button_style="primary", tooltip="", icon="", layout=dict(width="auto")) self.load_tweets_from_user_button = Button( description="Load Tweets from User", disabled=True, button_style="", tooltip="", icon="", layout=dict(width="auto")) self.twitter_search_buttons = [ self.load_tweets_from_user_button, self.search_tweets_button ] for button in self.twitter_search_buttons: button.on_click(self._twitter_search_button_pressed) twitter_search_buttons_box = Box(self.twitter_search_buttons, layout=dict( justify_content="flex-end", flex_flow="row wrap", )) self.reset_and_clear_tweets_button = Button( description="Reset and Clear Tweets", disabled=True, button_style="danger", tooltip="", icon="", layout=dict(width="auto")) self.reset_and_clear_tweets_button.on_click( self._reset_and_clear_tweets_button_pressed) self.twitter_buttons = self.twitter_search_buttons \ + [self.reset_and_clear_tweets_button] twitter_buttons_box = Box( (self.reset_and_clear_tweets_button, twitter_search_buttons_box), layout=dict( justify_content="space-between", flex_flow="row wrap", )) twitter_box = VBox( (twitter_title, self.query_field, number_of_tweets_field_with_label, twitter_buttons_box)) # Wikipedia search wikipedia_title = HTML(value="<b>Wikipedia Search</b>", description="", disabled=False) self.wikipedia_options = [] self.term_frequency_scaling_parameter_field = BoundedFloatText( value=DEFAULT_TERM_FREQUENCY_SCALING_PARAMETER_VALUE, min=0, max=100, step=0.1, description="", disabled=False, layout=dict(width="auto")) self.term_frequency_scaling_parameter_field.observe( self._term_frequency_scaling_parameter_field_changed, names="value") self.wikipedia_options.append({ "label": "$k_1$${{}}=$", "field": self.term_frequency_scaling_parameter_field, "explanation": "$k_1 \ge 0$" }) self.document_length_scaling_parameter_field = BoundedFloatText( value=DEFAULT_DOCUMENT_LENGTH_SCALING_PARAMETER_VALUE, min=0, max=1, step=0.01, description="", disabled=False, layout=dict(width="auto")) self.document_length_scaling_parameter_field.observe( self._document_length_scaling_parameter_field_changed, names="value") self.wikipedia_options.append({ "label": "$b$${{}}=$", "field": self.document_length_scaling_parameter_field, "explanation": "$0 \le b$${} \le 1$" }) wikipedia_options_box = Box( (VBox([ Label(value=option["label"]) for option in self.wikipedia_options ], layout=dict(align_items="flex-end")), VBox([option["field"] for option in self.wikipedia_options], ), VBox([ Label(value="(" + option["explanation"] + ")") for option in self.wikipedia_options ]))) self.search_wikipedia_button = Button( description="Search Wikipedia with Tweets", disabled=True, button_style="primary", tooltip="", icon="", layout=dict(width="auto")) self.search_wikipedia_button.on_click( self._search_wikipedia_button_pressed) self.reset_and_clear_wikipedia_results_button = Button( description="Reset and Clear Results", disabled=True, button_style="danger", tooltip="", icon="", layout=dict(width="auto")) self.reset_and_clear_wikipedia_results_button.on_click( self._reset_and_clear_wikipedia_results_button_pressed) self.wikipedia_buttons = [ self.reset_and_clear_wikipedia_results_button, self.search_wikipedia_button ] wikipedia_buttons_box = Box(self.wikipedia_buttons, layout=dict( justify_content="space-between", flex_flow="row wrap", )) wikipedia_box = VBox( (wikipedia_title, wikipedia_options_box, wikipedia_buttons_box)) # Result views results_title = HTML(value="<b>Results</b>", description="", disabled=True) self.results_box = VBox([DEFAULT_RESULTS_WIDGET]) self.results = None # Together self.buttons = self.twitter_buttons + self.wikipedia_buttons search_box = VBox((twitter_box, wikipedia_box), # layout=dict(max_width="600px") ) results_box = VBox((results_title, self.results_box)) self.widget = VBox((title, search_box, results_box)) self._reset_and_clear_tweets() def _disable_twitter_buttons(self): for button in self.twitter_buttons: button.disabled = True def _enable_twitter_buttons(self): for button in self.twitter_buttons: button.disabled = False def _disable_twitter_search_buttons(self): for button in self.twitter_search_buttons: button.disabled = True def _enable_twitter_search_buttons(self): for button in self.twitter_search_buttons: button.disabled = False def _disable_wikipedia_buttons(self): for button in self.wikipedia_buttons: button.disabled = True def _enable_wikipedia_buttons(self): for button in self.wikipedia_buttons: button.disabled = False def _disable_all_buttons(self): for button in self.buttons: button.disabled = True def _enable_all_buttons(self): for button in self.buttons: button.disabled = False def _reset_and_clear_tweets(self): self.query_field.value = "" self.number_of_tweets_field.value = \ DEFAULT_NUMBER_OF_TWEETS self.results_box.children = [DEFAULT_RESULTS_WIDGET] self._disable_twitter_buttons() self.search_wikipedia_button.disabled = True self._reset_and_clear_wikipedia_results() def _reset_and_clear_wikipedia_results(self): self.term_frequency_scaling_parameter_field.value = \ DEFAULT_TERM_FREQUENCY_SCALING_PARAMETER_VALUE self.document_length_scaling_parameter_field.value = \ DEFAULT_DOCUMENT_LENGTH_SCALING_PARAMETER_VALUE self._clear_wikipedia_results() self.reset_and_clear_wikipedia_results_button.disabled = True def _clear_wikipedia_results(self): if isinstance(self.results, list): for result in self.results: if "articles" in result: result["articles"].value = "" def _query_field_changed(self, notification): if notification.type == "change": query = notification.new if query: self.reset_and_clear_tweets_button.disabled = False self.search_tweets_button.disabled = False else: self.reset_and_clear_tweets_button.disabled = True self.search_tweets_button.disabled = True is_username, username = check_twitter_username(query) if is_username: self.load_tweets_from_user_button.disabled = False else: self.load_tweets_from_user_button.disabled = True def _number_of_tweets_field_changed(self, notification): if notification.type == "change": number_of_tweets = notification.new if number_of_tweets == DEFAULT_NUMBER_OF_TWEETS: self.reset_and_clear_tweets_button.disabled = True else: self.reset_and_clear_tweets_button.disabled = False def _term_frequency_scaling_parameter_field_changed(self, notification): if notification.type == "change": term_frequency_scaling_parameter = notification.new if term_frequency_scaling_parameter == \ DEFAULT_TERM_FREQUENCY_SCALING_PARAMETER_VALUE: self.reset_and_clear_wikipedia_results_button.disabled = True else: self.reset_and_clear_wikipedia_results_button.disabled = False def _document_length_scaling_parameter_field_changed(self, notification): if notification.type == "change": document_length_scaling_parameter = notification.new if document_length_scaling_parameter == \ DEFAULT_DOCUMENT_LENGTH_SCALING_PARAMETER_VALUE: self.reset_and_clear_wikipedia_results_button.disabled = True else: self.reset_and_clear_wikipedia_results_button.disabled = False def _twitter_search_button_pressed(self, button): query = self.query_field.value count = self.number_of_tweets_field.value if button is self.search_tweets_button: twitter_method = "search" query_string = f"Searching for recent tweets matching \"{query}\"..." elif button is self.load_tweets_from_user_button: twitter_method = "user_timeline" username = query.lstrip("@") query_string = f"Loading tweets from @{username}..." self.results_box.children = [HTML(f"<i>{query_string}</i>")] self._disable_all_buttons() self.controller.search_tweets(query=query, twitter_method=twitter_method, count=count) self._enable_twitter_buttons() def _reset_and_clear_tweets_button_pressed(self, button): self._reset_and_clear_tweets() def _reset_and_clear_wikipedia_results_button_pressed(self, button): self._reset_and_clear_wikipedia_results() def _search_wikipedia_button_pressed(self, button): k_1 = self.term_frequency_scaling_parameter_field.value b = self.document_length_scaling_parameter_field.value self._disable_all_buttons() self.controller.search_wikipedia(k_1=k_1, b=b) self._enable_all_buttons() def show_tweets(self, tweets): self.results = [] for tweet in tweets: result = { "tweet": Output(layout=dict(width="50%")), "articles": HTML(layout=dict(width="50%")) } self.results.append(result) with result["tweet"]: display(IPHTML(tweet.as_html(hide_thread=True))) self.results_box.children = [ HBox((result["tweet"], result["articles"])) for result in self.results ] display( IPHTML( '<script id="twitter-wjs" type="text/javascript" async defer src="//platform.twitter.com/widgets.js"></script>' )) self.search_wikipedia_button.disabled = False def show_articles_for_tweet_number(self, i, formatted_results): if isinstance(self.results, list) \ and i < len(self.results) \ and "articles" in self.results[i] \ and isinstance(self.results[i]["articles"], HTML): self.results[i]["articles"].value = formatted_results
class Survey(object): style = {'description_width': '200px'} layout = {'width': '350px'} widgets = { 'config': Dropdown(options=configurations.keys(), description='Configurations:'), 'exp_time': BoundedFloatText(value=565, min=0, max=1e6, step=5, description='Exposure time (sec)'), 'nexp_red': BoundedIntText(value=4, min=0, max=1000, step=1, description='Number of red exposures'), 'nexp_blue': BoundedIntText(value=0, min=0, max=1000, step=1, description='Number of blue exposures'), } params = ('exp_time', 'nexp_red', 'nexp_blue') def __init__(self): """ """ self._set_custom = True for key, widget in self.widgets.items(): widget.style = self.style widget.layout = self.layout self.update(**configurations[self.widgets['config'].value]) self.widgets['config'].observe(self.change_config, names='value') for key, widget in self.widgets.items(): if key in ['config']: continue widget.observe(self.modify, names='value') elements = [ self.widgets['config'], HTML('<b>Exposure</b>'), self.widgets['exp_time'], self.widgets['nexp_red'], self.widgets['nexp_blue'] ] self.widget = VBox(elements) def update(self, **kwargs): """ """ for key, value in kwargs.items(): if key in self.widgets: self.widgets[key].value = value def change_config(self, change): """ """ self._set_custom = False key = change['new'] self.update(**configurations[key]) self._set_custom = True def modify(self, change): """ """ if not self._set_custom: return self.widgets['config'].value = 'custom'
def __init__(self): micron_units = Label( 'micron') # use "option m" (Mac, for micro symbol) constWidth = '180px' tab_height = '500px' label_domain = Label('Domain (micron):') stepsize = 10 self.xmin = FloatText( step=stepsize, # description='$X_{min}$', description='Xmin', layout=Layout(width=constWidth), ) self.ymin = FloatText( step=stepsize, description='Ymin', layout=Layout(width=constWidth), ) self.zmin = FloatText( step=stepsize, description='Zmin', layout=Layout(width=constWidth), ) self.xmax = FloatText( step=stepsize, description='Xmax', layout=Layout(width=constWidth), ) self.ymax = FloatText( step=stepsize, description='Ymax', layout=Layout(width=constWidth), ) self.zmax = FloatText( step=stepsize, description='Zmax', layout=Layout(width=constWidth), ) # description='$Time_{max}$', self.tmax = BoundedFloatText( min=0., max=100000000, step=stepsize, description='Max Time', layout=Layout(width=constWidth), ) self.xdelta = BoundedFloatText( min=1., description='dx', # '∆x', # Mac: opt-j for delta layout=Layout(width=constWidth), ) self.ydelta = BoundedFloatText( min=1., description='dy', layout=Layout(width=constWidth), ) self.zdelta = BoundedFloatText( min=1., description='dz', layout=Layout(width=constWidth), ) x_row = HBox([self.xmin, self.xmax, self.xdelta]) y_row = HBox([self.ymin, self.ymax, self.ydelta]) z_row = HBox([self.zmin, self.zmax, self.zdelta]) self.omp_threads = BoundedIntText( min=1, description='# threads', layout=Layout(width=constWidth), ) self.toggle_svg = Checkbox( description='Cells', # SVG layout=Layout(width='150px')) # constWidth = '180px' self.svg_interval = BoundedIntText( min=1, max= 99999999, # TODO: set max on all Bounded to avoid unwanted default description='every', layout=Layout(width='160px'), ) def toggle_svg_cb(b): if (self.toggle_svg.value): # self.svg_t0.disabled = False self.svg_interval.disabled = False else: # self.svg_t0.disabled = True self.svg_interval.disabled = True self.toggle_svg.observe(toggle_svg_cb) self.toggle_mcds = Checkbox( description='Subtrates', # Full layout=Layout(width='180px'), ) self.mcds_interval = BoundedIntText( min=0, max=99999999, description='every', layout=Layout(width='160px'), ) def toggle_mcds_cb(b): if (self.toggle_mcds.value): self.mcds_interval.disabled = False else: self.mcds_interval.disabled = True self.toggle_mcds.observe(toggle_mcds_cb) svg_mat_output_row = HBox([ Label('Plots:'), self.toggle_svg, HBox([self.svg_interval, Label('min')]), self.toggle_mcds, HBox([self.mcds_interval, Label('min')]) ]) label_blankline = Label('') label_substrates = Label('Substrates:') self.substrate = [] self.diffusion_coef = [] self.decay_rate = [] width_cell_params_units = '510px' width_cell_params_units = '380px' disable_substrates_flag = False self.substrate.append( HBox([ BoundedFloatText( min=0, step=0.1, disabled=True, value=38, description='o2: ', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units))) self.substrate.append( HBox([ BoundedFloatText( min=0, step=0.1, disabled=True, value=1, description='Glc: ', layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units))) self.substrate.append( HBox([ BoundedFloatText( min=0, step=0.1, disabled=True, value=7.25, description='H+: ', layout=Layout(width=constWidth), ), Label('pH') ], layout=Layout(width=width_cell_params_units))) self.substrate.append( HBox([ BoundedFloatText( min=0, step=0.1, disabled=True, value=1.0, description='ECM: ', layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units))) width_cell_params_units = '450px' width_cell_params_units = '400px' self.diffusion_coef.append( HBox([ BoundedFloatText( min=0, max=999999, step=10.0, description='diffusion coef', disabled=disable_substrates_flag, layout=Layout(width=constWidth), ), Label('micron^2/min') ], layout=Layout(width=width_cell_params_units))) self.diffusion_coef.append( HBox([ BoundedFloatText( min=0, max=999999, step=10.0, description='diffusion coef', disabled=disable_substrates_flag, layout=Layout(width=constWidth), ), Label('micron^2/min') ], layout=Layout(width=width_cell_params_units))) self.diffusion_coef.append( HBox([ BoundedFloatText( min=0, max=999999, step=10.0, description='diffusion coef', disabled=disable_substrates_flag, layout=Layout(width=constWidth), ), Label('micron^2/min') ], layout=Layout(width=width_cell_params_units))) width_cell_params_units = '400px' width_cell_params_units = '380px' self.decay_rate.append( HBox([ BoundedFloatText( min=0, step=0.01, description='decay rate', disabled=disable_substrates_flag, layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) self.decay_rate.append( HBox([ BoundedFloatText( min=0, step=0.00001, description='decay rate', disabled=disable_substrates_flag, layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) self.decay_rate.append( HBox([ BoundedFloatText( min=0, step=0.01, description='decay rate', disabled=disable_substrates_flag, layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) box_layout = Layout(border='1px solid') domain_box = VBox([label_domain, x_row, y_row, z_row], layout=box_layout) substrates_box = VBox([ label_substrates, HBox([ self.substrate[0], self.diffusion_coef[0], self.decay_rate[0] ]), HBox([ self.substrate[1], self.diffusion_coef[1], self.decay_rate[1] ]), HBox([ self.substrate[2], self.diffusion_coef[2], self.decay_rate[2] ]) ], layout=box_layout) self.tab = VBox([ domain_box, HBox([self.tmax, Label('min')]), self.omp_threads, svg_mat_output_row, ]) # output_dir, toggle_2D_seed_
class Instrument(object): """ """ style = {'description_width': '150px'} layout = {'width': '250px'} widgets = { 'config': Dropdown(options=configurations.keys(), description='Configurations:'), 'collecting_surface_area': BoundedFloatText(value=10000, min=0, max=1e6, step=10, description='Collecting area (cm2)'), 'pix_size': BoundedFloatText(value=0.3, min=0, max=10, step=0.1, description='Pixel size (arcsec)'), 'pix_disp': BoundedFloatText(value=13.4, min=0, max=100, step=0.1, description='Dispersion (A/pixel)'), 'psf_amp': BoundedFloatText(value=0.781749, min=0, max=1, step=0.05, description='PSF amplitude'), 'psf_sig1': BoundedFloatText(value=0.84454, min=0, max=20, step=0.1, description='PSF sigma 1 (pixels)'), 'psf_sig2': BoundedFloatText(value=3.6498, min=0, max=20, step=0.1, description='PSF sigma 2 (pixels)'), 'readnoise': BoundedFloatText(value=8.87, min=0, max=100, step=0.1, description='read noise (electrons)'), 'darkcurrent': BoundedFloatText(value=0.019, min=0, max=100, step=0.1, description='dark current (elec/s/pix)'), 'transmission_red': Dropdown(options=get_transmission_files(), description='Red grism transmission'), 'transmission_blue': Dropdown(options=get_transmission_files(), description='Blue grism transmission'), 'radius1': Label(), 'radius2': Label(), } params = ('collecting_surface_area', 'pix_size', 'pix_disp', 'psf_amp', 'psf_sig1', 'psf_sig2', 'readnoise', 'darkcurrent', 'transmission_red', 'transmission_blue') def __init__(self): self._set_custom = True for key, widget in self.widgets.items(): widget.style = self.style widget.layout = self.layout self.update(**configurations[self.widgets['config'].value]) self.widgets['config'].observe(self.change_config, names='value') self.widgets['transmission_red'].observe(self.plot_transmission, names='value') self.widgets['transmission_blue'].observe(self.plot_transmission, names='value') self.widgets['psf_amp'].observe(self.plot_psf, names='value') self.widgets['psf_sig1'].observe(self.plot_psf, names='value') self.widgets['psf_sig2'].observe(self.plot_psf, names='value') for key, widget in self.widgets.items(): if key in ['config', 'transmission_red', 'transmission_blue']: continue widget.observe(self.modify, names='value') self.figs = [go.FigureWidget(), go.FigureWidget()] self.figs[0].update_layout(xaxis_title='Wavelength (microns)', yaxis_title='Throughput', width=500, height=200, margin=dict(l=0, r=0, t=0, b=0, pad=0), autosize=True) self.figs[1].update_layout(xaxis_title='Radius (pixels)', yaxis_title='PSF', width=500, height=200, margin=dict(l=0, r=0, t=0, b=0, pad=0), autosize=True) title = HTML('<h2>Instrument<h2>') elements = [] elements.append(self.widgets['config']) elements += [ HTML('<b>Optics</b>'), self.widgets['collecting_surface_area'], self.widgets['pix_size'], self.widgets['pix_disp'], self.widgets['transmission_red'], self.widgets['transmission_blue'] ] elements += [ HTML('<b>PSF</b>'), self.widgets['psf_amp'], self.widgets['psf_sig1'], self.widgets['psf_sig2'] ] elements += [ HTML('<b>Detector</b>'), self.widgets['readnoise'], self.widgets['darkcurrent'] ] self.widget = HBox([ VBox(elements), VBox(self.figs + [self.widgets['radius1'], self.widgets['radius2']]) ]) self.plot_transmission() self.plot_psf() def update(self, **kwargs): """ """ for key, value in kwargs.items(): if key in self.widgets: self.widgets[key].value = value def change_config(self, change): """ """ self._set_custom = False key = change['new'] self.update(**configurations[key]) self._set_custom = True def modify(self, change): """ """ if not self._set_custom: return self.widgets['config'].value = 'custom' def plot_transmission(self, change=None): """ """ if change: self.widgets['config'].value = 'custom' colors = {'transmission_red': 'red', 'transmission_blue': 'blue'} fig = self.figs[0] fig.data = [] for key in ['transmission_red', 'transmission_blue']: if not self.widgets[key].value: continue if self.widgets[key].value == 'none': continue path = os.path.join(TRANSMISSION_DIR, self.widgets[key].value) if not os.path.exists(path): continue x, y = np.loadtxt(path, unpack=True) sel, = np.where(y > (y.max() / 10.)) a = max(0, sel[0] - 10) b = min(len(x), sel[-1] + 10) x = x[a:b] y = y[a:b] fig.add_scatter(x=x / 1e4, y=y, name=self.widgets[key].value, line_color=colors[key]) def plot_psf(self, change=None): """ """ if change: self.widgets['config'].value = 'custom' sig1 = self.widgets['psf_sig1'].value sig2 = self.widgets['psf_sig2'].value amp = self.widgets['psf_amp'].value PSF = psf.PSF_model(amp, sig1, sig2) r1 = PSF.radius(0.5) r2 = PSF.radius(0.8) self.widgets['radius1'].value = "PSF 50%%-radius: %3.2f pixels" % r1 self.widgets['radius2'].value = "PSF 80%%-radius: %3.2f pixels" % r2 x = np.linspace(0, np.ceil(PSF.radius(0.95)), 100) y = np.array(PSF.prof(x)) yinteg = np.array(PSF.evaluate(x)) fig = self.figs[1] fig.data = [] fig.add_scatter(x=x, y=y / y.max(), name='Profile') fig.add_scatter(x=x, y=yinteg, name='Integrated') def get_lambda_range(self, key, thresh=2): """""" path = os.path.join(TRANSMISSION_DIR, self.widgets[key].value) x, y = np.loadtxt(path, unpack=True) sel = y > (y.max() * 1. / thresh) x = x[sel] return x.min(), x.max() def get_config_list(self): """ """ config_list = [] for key in 'transmission_red', 'transmission_blue': if not self.widgets[key].value or self.widgets[key].value == 'none': continue config = {} config['collecting_surface_area'] = self.widgets[ 'collecting_surface_area'].value config['pix_size'] = self.widgets['pix_size'].value config['pix_disp'] = [1, self.widgets['pix_disp'].value, 1] config['psf_amp'] = self.widgets['psf_amp'].value config['psf_sig1'] = self.widgets['psf_sig1'].value config['psf_sig2'] = self.widgets['psf_sig2'].value config['readnoise'] = self.widgets['readnoise'].value config['darkcurrent'] = self.widgets['darkcurrent'].value config['transmission_path'] = os.path.join(TRANSMISSION_DIR, self.widgets[key].value) config['lambda_range'] = self.get_lambda_range(key) config_list.append(config) return config_list
def create_param_widget(self, param, value): from ipywidgets import Layout, HBox children = (HBox(),) if isinstance(value, bool): from ipywidgets import Label, ToggleButton p = Label(value=param, layout=Layout(width='10%')) t = ToggleButton(description=str(value), value=value) def on_bool_change(change): t.description = str(change['new']) self.params[self._method][param] = change['new'] self.replot_peaks() t.observe(on_bool_change, names='value') children = (p, t) elif isinstance(value, float): from ipywidgets import FloatSlider, FloatText, BoundedFloatText, \ Label from traitlets import link p = Label(value=param, layout=Layout(flex='0 1 auto', width='10%')) b = BoundedFloatText(value=0, min=1e-10, layout=Layout(flex='0 1 auto', width='10%'), font_weight='bold') a = FloatText(value=2 * value, layout=Layout(flex='0 1 auto', width='10%')) f = FloatSlider(value=value, min=b.value, max=a.value, step=np.abs(a.value - b.value) * 0.01, layout=Layout(flex='1 1 auto', width='60%')) l = FloatText(value=f.value, layout=Layout(flex='0 1 auto', width='10%'), disabled=True) link((f, 'value'), (l, 'value')) def on_min_change(change): if f.max > change['new']: f.min = change['new'] f.step = np.abs(f.max - f.min) * 0.01 def on_max_change(change): if f.min < change['new']: f.max = change['new'] f.step = np.abs(f.max - f.min) * 0.01 def on_param_change(change): self.params[self._method][param] = change['new'] self.replot_peaks() b.observe(on_min_change, names='value') f.observe(on_param_change, names='value') a.observe(on_max_change, names='value') children = (p, l, b, f, a) elif isinstance(value, int): from ipywidgets import IntSlider, IntText, BoundedIntText, \ Label from traitlets import link p = Label(value=param, layout=Layout(flex='0 1 auto', width='10%')) b = BoundedIntText(value=0, min=1e-10, layout=Layout(flex='0 1 auto', width='10%'), font_weight='bold') a = IntText(value=2 * value, layout=Layout(flex='0 1 auto', width='10%')) f = IntSlider(value=value, min=b.value, max=a.value, step=1, layout=Layout(flex='1 1 auto', width='60%')) l = IntText(value=f.value, layout=Layout(flex='0 1 auto', width='10%'), disabled=True) link((f, 'value'), (l, 'value')) def on_min_change(change): if f.max > change['new']: f.min = change['new'] f.step = 1 def on_max_change(change): if f.min < change['new']: f.max = change['new'] f.step = 1 def on_param_change(change): self.params[self._method][param] = change['new'] self.replot_peaks() b.observe(on_min_change, names='value') f.observe(on_param_change, names='value') a.observe(on_max_change, names='value') children = (p, l, b, f, a) container = HBox(children) return container
def __init__(self): constWidth = '180px' #width_cell_params_units = '240px' width_cell_params_units = '270px' self.cell_name = Text( value='untreated cancer', disabled=False, description='Cell line name', style={'description_width': 'initial'}, ) #------------------------------- label_cycle = Label('Cycle:') self.max_birth_rate = HBox( [ BoundedFloatText( min=0, step=0.0001, description='max birth rate', style={'description_width': 'initial'}, layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units)) self.o2_proliferation_saturation = HBox( [ BoundedFloatText( min=0, step=0.1, description='o2: prolif sat', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units)) self.o2_proliferation_threshold = HBox( [ BoundedFloatText( min=0, step=0.1, description='prolif thresh', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units)) self.o2_reference = HBox([ BoundedFloatText( min=0, step=0.1, description='ref', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units)) self.glucose_proliferation_reference = HBox( [ BoundedFloatText( min=0, step=0.1, description='Glc: prolif ref', layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) self.glucose_proliferation_saturation = HBox( [ BoundedFloatText( min=0, step=0.1, description='prolif sat', layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) self.glucose_proliferation_threshold = HBox( [ BoundedFloatText( min=0, step=0.1, description='prolif thresh', layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) #------------------------------- label_necrosis = Label('Necrosis:') self.max_necrosis_rate = HBox( [ BoundedFloatText( min=0, step=0.001, description='max rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units)) self.o2_necrosis_threshold = HBox( [ BoundedFloatText( min=0, step=0.1, description='o2: thresh', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units)) self.o2_necrosis_max = HBox( [ BoundedFloatText( min=0, step=0.1, description='max', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units)) #------------------------------- label_apoptosis = Label('Apoptosis:') self.apoptosis_rate = HBox( [ BoundedFloatText( min=0, step=0.00001, description='rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units)) #------------------------------- # TODO: enforce sum=1 label_metabolism = Label('Metabolism (must sum to 1):') # TODO: assert these next 2 values sum to 1.0 self.relative_aerobic_effects = HBox( [ BoundedFloatText( min=0, max=1, step=0.1, disabled=True, description= 'Aerobic', #style={'description_width': 'initial'}, layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) self.relative_glycolytic_effects = HBox( [ BoundedFloatText( min=0, max=1, step=0.1, disabled=True, description= 'Glycolytic', #style={'description_width': 'initial'}, layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) #------------------------------- label_motility = Label('Motility:') self.is_motile = Checkbox( description='motile', disabled=False, layout=Layout(width=constWidth), ) self.bias = HBox( [ BoundedFloatText( max=1, step=0.01, description= 'bias', # style={'description_width': 'initial'}, layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) # speed_units = HTMLMath(value=r"$\frac{\mu M^2}{min}$") speed_units = Label( 'micron/min') # use "option m" (Mac, for micro symbol) self.speed = HBox([ BoundedFloatText( min=0, step=0.1, description='speed', layout=Layout(width=constWidth), ), speed_units ], layout=Layout(width=width_cell_params_units)) self.persistence_time = HBox( [ BoundedFloatText( min=0, step=0.1, description='persistence time', layout=Layout(width=constWidth), ), Label('min') ], layout=Layout(width=width_cell_params_units)) # constWidt = '180px' self.gradient_substrate_index = BoundedIntText( min=0, value=0, disabled=False, description='substrate index', style={'description_width': 'initial'}, layout=Layout(width='160px'), ) self.negative_taxis = RadioButtons( options={ "grad": 0, "-grad": 1 }, # {u"\u2207" : 0, "-" + u"\u2207" : 1}, value=0, disabled=True, description='', ) self.is_motile.observe(self.is_motile_cb) #------------------------------- label_mechanics = Label('Mechanics:') self.max_relative_adhesion_distance = HBox( [ BoundedFloatText( min=0, step=0.1, #max=1, description= 'Max adhesion distance', # style={'description_width': 'initial'}, layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) self.adhesion_strength = HBox( [ BoundedFloatText( min=0, step=0.1, #max=1, description= 'Adhesion strength', # style={'description_width': 'initial'}, layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) self.repulsion_strength = HBox( [ BoundedFloatText( min=0, step=0.1, #max=1, description= 'Repulsion strength', # style={'description_width': 'initial'}, layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units)) #------------------------------- label_hypoxia = Label('Hypoxia:') self.o2_hypoxic_threshold = HBox( [ BoundedFloatText( min=0, step=0.1, description='o2: threshold', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units)) self.o2_hypoxic_response = HBox( [ BoundedFloatText( min=0, step=0.1, description='response', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units)) self.o2_hypoxic_saturation = HBox( [ BoundedFloatText( min=0, step=0.1, description='saturation', layout=Layout(width=constWidth), ), Label('mmHg') ], layout=Layout(width=width_cell_params_units)) #------------------------------- label_secretion = Label('Secretion:') self.uptake_rate = [] self.secretion_rate = [] self.saturation_density = [] self.uptake_rate.append( HBox([ BoundedFloatText( min=0, step=0.1, description='o2: uptake rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) self.uptake_rate.append( HBox([ BoundedFloatText( min=0, step=0.01, description='Glc: uptake rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) self.uptake_rate.append( HBox([ BoundedFloatText( min=0, step=0.1, description='H+: uptake rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) self.uptake_rate.append( HBox([ BoundedFloatText( min=0, step=0.1, description='ECM: uptake rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) self.uptake_rate.append( HBox([ BoundedFloatText( min=0, step=0.1, description='NP1: uptake rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) self.uptake_rate.append( HBox([ BoundedFloatText( min=0, step=0.1, description='NP2: uptake rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) for idx in range(6): self.secretion_rate.append( HBox([ BoundedFloatText( min=0, step=0.1, description='secretion rate', layout=Layout(width=constWidth), ), Label('1/min') ], layout=Layout(width=width_cell_params_units))) self.saturation_density.append( HBox([ BoundedFloatText( min=0, step=0.1, description='saturation', layout=Layout(width=constWidth), ), ], layout=Layout(width=width_cell_params_units))) row1 = HBox([self.max_birth_rate]) row2 = HBox([ self.o2_proliferation_saturation, self.o2_proliferation_threshold, self.o2_reference ]) row2b = HBox([ self.glucose_proliferation_reference, self.glucose_proliferation_saturation, self.glucose_proliferation_threshold ]) row3 = HBox([self.max_necrosis_rate]) row4 = HBox([self.o2_necrosis_threshold, self.o2_necrosis_max]) row_secretion = [] for idx in range(2): row_secretion.append( HBox([ self.uptake_rate[idx], self.secretion_rate[idx], self.saturation_density[idx] ])) # row12 = HBox([self.uptake_rate[1], self.secretion_rate[1], self.saturation_density[1] ]) # row13 = HBox([self.uptake_rate3, self.secretion_rate3, self.saturation_density3 ]) # row14 = HBox([self.uptake_rate4, self.secretion_rate4, self.saturation_density4 ]) # row15 = HBox([self.uptake_rate5, self.secretion_rate5, self.saturation_density5 ]) # row16 = HBox([self.uptake_rate6, self.secretion_rate6, self.saturation_density6 ]) box_layout = Layout(border='1px solid') cycle_box = VBox([label_cycle, row1, row2, row2b], layout=box_layout) necrosis_box = VBox([label_necrosis, row3, row4], layout=box_layout) apoptosis_box = VBox( [label_apoptosis, HBox([self.apoptosis_rate])], layout=box_layout) metabolism_box = VBox([ label_metabolism, HBox([ self.relative_aerobic_effects, self.relative_glycolytic_effects ]) ], layout=box_layout) motility_box = VBox([ HBox([ label_motility, self.is_motile, self.gradient_substrate_index, self.negative_taxis, ]), HBox([self.bias, self.speed, self.persistence_time]), ], layout=box_layout) mechanics_box = VBox([ label_mechanics, HBox([ self.max_relative_adhesion_distance, self.adhesion_strength, self.repulsion_strength ]) ], layout=box_layout) hypoxia_box = VBox([ label_hypoxia, HBox([ self.o2_hypoxic_threshold, self.o2_hypoxic_response, self.o2_hypoxic_saturation ]) ], layout=box_layout) secretion_box = VBox([ label_secretion, HBox([ self.uptake_rate[0], self.secretion_rate[0], self.saturation_density[0] ]), HBox([ self.uptake_rate[1], self.secretion_rate[1], self.saturation_density[1] ]), HBox([ self.uptake_rate[2], self.secretion_rate[2], self.saturation_density[2] ]), HBox([ self.uptake_rate[3], self.secretion_rate[3], self.saturation_density[3] ]), HBox([ self.uptake_rate[4], self.secretion_rate[4], self.saturation_density[4] ]), HBox([ self.uptake_rate[5], self.secretion_rate[5], self.saturation_density[5] ]) ], layout=box_layout) self.tab = VBox([ self.cell_name, cycle_box, necrosis_box, apoptosis_box, metabolism_box, motility_box, mechanics_box, hypoxia_box, secretion_box, ]) #,row13,row14,row15,row16])
class ConfigTab(object): def __init__(self): # micron_units = HTMLMath(value=r"$\mu M$") micron_units = Label( 'micron') # use "option m" (Mac, for micro symbol) # micron_units = Label('microns') # use "option m" (Mac, for micro symbol) constWidth = '180px' # tab_height = '400px' tab_height = '500px' # tab_layout = Layout(width='900px', # border='2px solid black', # tab_layout = Layout(width='850px', # border='2px solid black', # height=tab_height, overflow_y='scroll',) # np_tab_layout = Layout(width='800px', # border='2px solid black', # height='350px', overflow_y='scroll',) # my_domain = [0,0,-10, 2000,2000,10, 20,20,20] # [x,y,zmin, x,y,zmax, x,y,zdelta] # label_domain = Label('Domain ($\mu M$):') label_domain = Label('Domain (micron):') stepsize = 10 disable_domain = False self.xmin = FloatText( step=stepsize, # description='$X_{min}$', description='Xmin', disabled=disable_domain, layout=Layout(width=constWidth), ) self.ymin = FloatText( step=stepsize, description='Ymin', disabled=disable_domain, layout=Layout(width=constWidth), ) self.zmin = FloatText( step=stepsize, description='Zmin', disabled=disable_domain, layout=Layout(width=constWidth), ) self.xmax = FloatText( step=stepsize, description='Xmax', disabled=disable_domain, layout=Layout(width=constWidth), ) self.ymax = FloatText( step=stepsize, description='Ymax', disabled=disable_domain, layout=Layout(width=constWidth), ) self.zmax = FloatText( step=stepsize, description='Zmax', disabled=disable_domain, layout=Layout(width=constWidth), ) # description='$Time_{max}$', self.tmax = BoundedFloatText( min=0., max=100000000, step=stepsize, description='Max Time', layout=Layout(width=constWidth), ) self.xdelta = BoundedFloatText( min=1., description='dx', # '∆x', # Mac: opt-j for delta disabled=disable_domain, layout=Layout(width=constWidth), ) self.ydelta = BoundedFloatText( min=1., description='dy', disabled=disable_domain, layout=Layout(width=constWidth), ) self.zdelta = BoundedFloatText( min=1., description='dz', disabled=disable_domain, layout=Layout(width=constWidth), ) """ self.tdelta = BoundedFloatText( min=0.01, description='$Time_{delta}$', layout=Layout(width=constWidth), ) """ """ self.toggle2D = Checkbox( description='2-D', layout=Layout(width=constWidth), ) def toggle2D_cb(b): if (self.toggle2D.value): #zmin.disabled = zmax.disabled = zdelta.disabled = True zmin.disabled = True zmax.disabled = True zdelta.disabled = True else: zmin.disabled = False zmax.disabled = False zdelta.disabled = False self.toggle2D.observe(toggle2D_cb) """ x_row = HBox([self.xmin, self.xmax, self.xdelta]) y_row = HBox([self.ymin, self.ymax, self.ydelta]) z_row = HBox([self.zmin, self.zmax, self.zdelta]) self.omp_threads = BoundedIntText( min=1, max=4, description='# threads', layout=Layout(width=constWidth), ) # self.toggle_prng = Checkbox( # description='Seed PRNG', style={'description_width': 'initial'}, # e.g. 'initial' '120px' # layout=Layout(width=constWidth), # ) # self.prng_seed = BoundedIntText( # min = 1, # description='Seed', # disabled=True, # layout=Layout(width=constWidth), # ) # def toggle_prng_cb(b): # if (toggle_prng.value): # self.prng_seed.disabled = False # else: # self.prng_seed.disabled = True # self.toggle_prng.observe(toggle_prng_cb) #prng_row = HBox([toggle_prng, prng_seed]) self.toggle_svg = Checkbox( description='Cells', # SVG layout=Layout(width='150px')) # constWidth = '180px' # self.svg_t0 = BoundedFloatText ( # min=0, # description='$T_0$', # layout=Layout(width=constWidth), # ) # self.svg_interval = BoundedIntText( self.svg_interval = BoundedFloatText( min=1, max= 99999999, # TODO: set max on all Bounded to avoid unwanted default description='every', layout=Layout(width='160px'), ) # self.mcds_interval = BoundedIntText( self.mcds_interval = BoundedFloatText( min=1, max=99999999, description='every', # disabled=True, layout=Layout(width='160px'), ) # don't let this be > mcds interval def svg_interval_cb(b): if (self.svg_interval.value > self.mcds_interval.value): self.svg_interval.value = self.mcds_interval.value self.svg_interval.observe( svg_interval_cb) # BEWARE: when fill_gui, this sets value = 1 ! # don't let this be < svg interval def mcds_interval_cb(b): if (self.mcds_interval.value < self.svg_interval.value): self.mcds_interval.value = self.svg_interval.value self.mcds_interval.observe( mcds_interval_cb) # BEWARE: see warning above def toggle_svg_cb(b): if (self.toggle_svg.value): # self.svg_t0.disabled = False self.svg_interval.disabled = False else: # self.svg_t0.disabled = True self.svg_interval.disabled = True self.toggle_svg.observe(toggle_svg_cb) self.toggle_mcds = Checkbox( # value=False, description='Subtrates', # Full layout=Layout(width='180px'), ) # self.mcds_t0 = FloatText( # description='$T_0$', # disabled=True, # layout=Layout(width=constWidth), # ) def toggle_mcds_cb(b): if (self.toggle_mcds.value): # self.mcds_t0.disabled = False #False self.mcds_interval.disabled = False else: # self.mcds_t0.disabled = True self.mcds_interval.disabled = True self.toggle_mcds.observe(toggle_mcds_cb) svg_mat_output_row = HBox([ Label('Plots:'), self.toggle_svg, HBox([self.svg_interval, Label('min')]), self.toggle_mcds, HBox([self.mcds_interval, Label('min')]) ]) # to sync, do this # svg_mat_output_row = HBox( [Label('Plots:'), self.svg_interval, Label('min')]) #write_config_row = HBox([write_config_button, write_config_file]) #run_sim_row = HBox([run_button, run_command_str, kill_button]) # run_sim_row = HBox([run_button, run_command_str]) # run_sim_row = HBox([run_button.w]) # need ".w" for the custom RunCommand widget label_blankline = Label('') # toggle_2D_seed_row = HBox([toggle_prng, prng_seed]) # toggle2D box_layout = Layout(border='1px solid') # domain_box = VBox([label_domain,x_row,y_row,z_row], layout=box_layout) domain_box = VBox([label_domain, x_row, y_row], layout=box_layout) self.tab = VBox([ domain_box, # label_blankline, HBox([self.tmax, Label('min')]), self.omp_threads, svg_mat_output_row, # HBox([self.substrate[3], self.diffusion_coef[3], self.decay_rate[3] ]), ]) # output_dir, toggle_2D_seed_ # ], layout=tab_layout) # output_dir, toggle_2D_seed_ # Populate the GUI widgets with values from the XML def fill_gui(self, xml_root): self.xmin.value = float(xml_root.find(".//x_min").text) self.xmax.value = float(xml_root.find(".//x_max").text) self.xdelta.value = float(xml_root.find(".//dx").text) self.ymin.value = float(xml_root.find(".//y_min").text) self.ymax.value = float(xml_root.find(".//y_max").text) self.ydelta.value = float(xml_root.find(".//dy").text) self.zmin.value = float(xml_root.find(".//z_min").text) self.zmax.value = float(xml_root.find(".//z_max").text) self.zdelta.value = float(xml_root.find(".//dz").text) self.tmax.value = float(xml_root.find(".//max_time").text) self.omp_threads.value = int(xml_root.find(".//omp_num_threads").text) if xml_root.find(".//full_data//enable").text.lower() == 'true': self.toggle_mcds.value = True else: self.toggle_mcds.value = False # self.mcds_interval.value = int(xml_root.find(".//full_data//interval").text) self.mcds_interval.value = float( xml_root.find(".//full_data//interval").text) # NOTE: do this *after* filling the mcds_interval, directly above, due to the callback/constraints on them if xml_root.find(".//SVG//enable").text.lower() == 'true': self.toggle_svg.value = True else: self.toggle_svg.value = False # self.svg_interval.value = int(xml_root.find(".//SVG//interval").text) self.svg_interval.value = float(xml_root.find(".//SVG//interval").text) # Read values from the GUI widgets and generate/write a new XML def fill_xml(self, xml_root): # print('config.py fill_xml() !!!!!') # TODO: verify template .xml file exists! # TODO: verify valid type (numeric) and range? xml_root.find(".//x_min").text = str(self.xmin.value) xml_root.find(".//x_max").text = str(self.xmax.value) xml_root.find(".//dx").text = str(self.xdelta.value) xml_root.find(".//y_min").text = str(self.ymin.value) xml_root.find(".//y_max").text = str(self.ymax.value) xml_root.find(".//dy").text = str(self.ydelta.value) xml_root.find(".//z_min").text = str(self.zmin.value) xml_root.find(".//z_max").text = str(self.zmax.value) xml_root.find(".//dz").text = str(self.zdelta.value) xml_root.find(".//max_time").text = str(self.tmax.value) xml_root.find(".//omp_num_threads").text = str(self.omp_threads.value) xml_root.find(".//SVG").find(".//enable").text = str( self.toggle_svg.value) xml_root.find(".//SVG").find(".//interval").text = str( self.svg_interval.value) xml_root.find(".//full_data").find(".//enable").text = str( self.toggle_mcds.value) xml_root.find(".//full_data").find(".//interval").text = str( self.mcds_interval.value) # user_details = ET.SubElement(root, "user_details") # ET.SubElement(user_details, "PhysiCell_settings", name="version").text = "devel-version" # ET.SubElement(user_details, "domain") # ET.SubElement(user_details, "xmin").text = "-100" # tree = ET.ElementTree(root) # tree.write(write_config_file.value) # tree.write("test.xml") # TODO: verify can write to this filename # tree.write(write_config_file.value) def get_num_svg_frames(self): if (self.toggle_svg.value): return int(self.tmax.value / self.svg_interval.value) else: return 0 def get_num_substrate_frames(self): if (self.toggle_mcds.value): return int(self.tmax.value / self.mcds_interval.value) else: return 0
#svg_tab = widgets.VBox([svg_dir, svg_anim], layout=tab_layout) #--------------------- #============ Cells tab =================== cell_name = widgets.Text( value='untreated cancer', description='Cell line name', style={'description_width': 'initial'}, ) #------- label_cycle = widgets.Label('Cycle:') # no worky: ,style={'font_weight': 'bold'}) # NOTE: by adopting the cell0_max_birth_rate = HBox([BoundedFloatText ( min=0, #value = 0.0079, description='Max birth rate', style={'description_width': 'initial'}, layout = Layout(width = constWidth3), ), min_inv_units], layout=Layout(width='300px')) width_cell_params_units = '230px' cell0_o2_prolif_sat = HBox([BoundedFloatText ( min=0, description='$O_2$: Prolif sat', layout = Layout(width = constWidth), ), mmHg_units], layout=Layout(width=width_cell_params_units)) cell0_o2_prolif_thresh = HBox([BoundedFloatText ( min=0, description='Prolif thresh', layout = Layout(width = constWidth), ), mmHg_units], layout=Layout(width=width_cell_params_units))
class ConfigTab(object): # def __init__(self): def __init__(self, xml_root): # micron_units = HTMLMath(value=r"$\mu M$") micron_units = Label('micron') # use "option m" (Mac, for micro symbol) # micron_units = Label('microns') # use "option m" (Mac, for micro symbol) constWidth = '180px' # tab_height = '400px' tab_height = '500px' # tab_layout = Layout(width='900px', # border='2px solid black', # tab_layout = Layout(width='850px', # border='2px solid black', # height=tab_height, overflow_y='scroll',) # np_tab_layout = Layout(width='800px', # border='2px solid black', # height='350px', overflow_y='scroll',) # my_domain = [0,0,-10, 2000,2000,10, 20,20,20] # [x,y,zmin, x,y,zmax, x,y,zdelta] # label_domain = Label('Domain ($\mu M$):') label_domain = Label('Domain (micron):') stepsize = 10 disable_domain = False self.xmin = FloatText(step=stepsize, # description='$X_{min}$', description='Xmin', disabled = disable_domain, layout=Layout(width=constWidth), ) self.ymin = FloatText(step=stepsize, description='Ymin', disabled = disable_domain, layout=Layout(width=constWidth), ) self.zmin = FloatText(step=stepsize, description='Zmin', disabled = disable_domain, layout=Layout(width=constWidth), ) self.xmax = FloatText(step=stepsize, description='Xmax', disabled = disable_domain, layout=Layout(width=constWidth), ) self.ymax = FloatText(step=stepsize, description='Ymax', disabled = disable_domain, layout=Layout(width=constWidth), ) self.zmax = FloatText(step=stepsize, description='Zmax', disabled = disable_domain, layout=Layout(width=constWidth), ) self.toggle_virtual_walls = Checkbox( description='Virtual walls', layout=Layout(width='350px') ) # description='$Time_{max}$', self.tmax = BoundedFloatText( min=0., max=100000000, step=stepsize, description='Max Time', layout=Layout(width=constWidth), ) self.xdelta = BoundedFloatText( min=1., description='dx', # '∆x', # Mac: opt-j for delta disabled = disable_domain, layout=Layout(width=constWidth), ) self.ydelta = BoundedFloatText( min=1., description='dy', disabled = disable_domain, layout=Layout(width=constWidth), ) self.zdelta = BoundedFloatText( min=1., description='dz', disabled = disable_domain, layout=Layout(width=constWidth), ) """ self.tdelta = BoundedFloatText( min=0.01, description='$Time_{delta}$', layout=Layout(width=constWidth), ) """ """ self.toggle2D = Checkbox( description='2-D', layout=Layout(width=constWidth), ) def toggle2D_cb(b): if (self.toggle2D.value): #zmin.disabled = zmax.disabled = zdelta.disabled = True zmin.disabled = True zmax.disabled = True zdelta.disabled = True else: zmin.disabled = False zmax.disabled = False zdelta.disabled = False self.toggle2D.observe(toggle2D_cb) """ x_row = HBox([self.xmin, self.xmax, self.xdelta]) y_row = HBox([self.ymin, self.ymax, self.ydelta]) z_row = HBox([self.zmin, self.zmax, self.zdelta]) self.omp_threads = BoundedIntText( min=1, max=4, description='# threads', layout=Layout(width=constWidth), ) # self.toggle_prng = Checkbox( # description='Seed PRNG', style={'description_width': 'initial'}, # e.g. 'initial' '120px' # layout=Layout(width=constWidth), # ) # self.prng_seed = BoundedIntText( # min = 1, # description='Seed', # disabled=True, # layout=Layout(width=constWidth), # ) # def toggle_prng_cb(b): # if (toggle_prng.value): # self.prng_seed.disabled = False # else: # self.prng_seed.disabled = True # self.toggle_prng.observe(toggle_prng_cb) #prng_row = HBox([toggle_prng, prng_seed]) self.toggle_svg = Checkbox( description='Cells', # SVG layout=Layout(width='150px') ) # constWidth = '180px' # self.svg_t0 = BoundedFloatText ( # min=0, # description='$T_0$', # layout=Layout(width=constWidth), # ) self.svg_interval = BoundedFloatText( min=0.001, max=99999999, # TODO: set max on all Bounded to avoid unwanted default description='every', layout=Layout(width='160px'), ) self.mcds_interval = BoundedFloatText( min=0.001, max=99999999, description='every', # disabled=True, layout=Layout(width='160px'), ) # don't let this be > mcds interval def svg_interval_cb(b): if (self.svg_interval.value > self.mcds_interval.value): self.svg_interval.value = self.mcds_interval.value self.svg_interval.observe(svg_interval_cb) # BEWARE: when fill_gui, this sets value = 1 ! # don't let this be < svg interval def mcds_interval_cb(b): if (self.mcds_interval.value < self.svg_interval.value): self.mcds_interval.value = self.svg_interval.value self.mcds_interval.observe(mcds_interval_cb) # BEWARE: see warning above def toggle_svg_cb(b): if (self.toggle_svg.value): # self.svg_t0.disabled = False self.svg_interval.disabled = False else: # self.svg_t0.disabled = True self.svg_interval.disabled = True self.toggle_svg.observe(toggle_svg_cb) self.toggle_mcds = Checkbox( # value=False, description='Subtrates', # Full layout=Layout(width='180px'), ) # self.mcds_t0 = FloatText( # description='$T_0$', # disabled=True, # layout=Layout(width=constWidth), # ) def toggle_mcds_cb(b): if (self.toggle_mcds.value): # self.mcds_t0.disabled = False #False self.mcds_interval.disabled = False else: # self.mcds_t0.disabled = True self.mcds_interval.disabled = True self.toggle_mcds.observe(toggle_mcds_cb) svg_mat_output_row = HBox([Label('Plots:'),self.toggle_svg, HBox([self.svg_interval,Label('min')]), self.toggle_mcds, HBox([self.mcds_interval,Label('min')]) ]) # to sync, do this # svg_mat_output_row = HBox( [Label('Plots:'), self.svg_interval, Label('min')]) #write_config_row = HBox([write_config_button, write_config_file]) #run_sim_row = HBox([run_button, run_command_str, kill_button]) # run_sim_row = HBox([run_button, run_command_str]) # run_sim_row = HBox([run_button.w]) # need ".w" for the custom RunCommand widget label_blankline = Label('') # toggle_2D_seed_row = HBox([toggle_prng, prng_seed]) # toggle2D def upload_done_cb(w, name): # Do something with the files here... # We just print their names print("%s uploaded" % name) # reset clears and re-enables the widget for more uploads # You may want to do this somewhere else, depending on your GUI w.reset() if (hublib_flag): self.csv_upload= FileUpload( '', 'Upload cells positions (.csv) from your local machine', dir='data', cb=upload_done_cb, maxsize='1M', # layout=Layout(width='350px') ) self.toggle_cells_csv = Checkbox( description='Enable .csv', layout=Layout(width='280px') ) # layout=Layout(width='350px') ) def toggle_cells_csv_cb(b): # why can't I disable this widget?! # print('---- toggle_cells_csv_cb') if (hublib_flag): if (self.toggle_cells_csv.value): # self.csv_upload.w.disabled = False self.csv_upload.visible = True else: self.csv_upload.visible = False self.toggle_cells_csv.observe(toggle_cells_csv_cb) box_layout = Layout(border='1px solid') if (hublib_flag): upload_cells_hbox = HBox([self.csv_upload.w, self.toggle_cells_csv] , layout=Layout(border='1px solid', width='420px')) else: upload_cells_hbox = HBox([self.toggle_cells_csv] , layout=Layout(border='1px solid', width='420px')) # domain_box = VBox([label_domain,x_row,y_row,z_row], layout=box_layout) uep = xml_root.find(".//options//virtual_wall_at_domain_edge") if uep: domain_box = VBox([label_domain,x_row,y_row, self.toggle_virtual_walls], layout=box_layout) else: domain_box = VBox([label_domain,x_row,y_row], layout=box_layout) uep = xml_root.find(".//options//virtual_wall_at_domain_edge") if uep: self.tab = VBox([domain_box, HBox([self.tmax, Label('min')]), self.omp_threads, svg_mat_output_row, label_blankline, # HBox([self.csv_upload.w, self.toggle_cells_csv]), upload_cells_hbox, # HBox([self.substrate[3], self.diffusion_coef[3], self.decay_rate[3] ]), # ], layout=tab_layout) # output_dir, toggle_2D_seed_ ]) else: self.tab = VBox([domain_box, HBox([self.tmax, Label('min')]), self.omp_threads, svg_mat_output_row, ]) # Populate the GUI widgets with values from the XML def fill_gui(self, xml_root): self.xmin.value = float(xml_root.find(".//x_min").text) self.xmax.value = float(xml_root.find(".//x_max").text) self.xdelta.value = float(xml_root.find(".//dx").text) self.ymin.value = float(xml_root.find(".//y_min").text) self.ymax.value = float(xml_root.find(".//y_max").text) self.ydelta.value = float(xml_root.find(".//dy").text) self.zmin.value = float(xml_root.find(".//z_min").text) self.zmax.value = float(xml_root.find(".//z_max").text) self.zdelta.value = float(xml_root.find(".//dz").text) uep = xml_root.find(".//options//virtual_wall_at_domain_edge") if uep and (uep.text.lower() == 'true'): self.toggle_virtual_walls.value = True else: self.toggle_virtual_walls.value = False self.tmax.value = float(xml_root.find(".//max_time").text) self.omp_threads.value = int(xml_root.find(".//omp_num_threads").text) if xml_root.find(".//full_data//enable").text.lower() == 'true': self.toggle_mcds.value = True else: self.toggle_mcds.value = False self.mcds_interval.value = float(xml_root.find(".//full_data//interval").text) # NOTE: do this *after* filling the mcds_interval, directly above, due to the callback/constraints on them if xml_root.find(".//SVG//enable").text.lower() == 'true': self.toggle_svg.value = True else: self.toggle_svg.value = False self.svg_interval.value = float(xml_root.find(".//SVG//interval").text) # if xml_root.find(".//initial_conditions//cell_positions").attrib["enabled"].lower() == 'true': uep = xml_root.find(".//initial_conditions//cell_positions") if uep: if uep.attrib["enabled"].lower() == 'true': self.toggle_cells_csv.value = True else: self.toggle_cells_csv.value = False self.toggle_cells_csv.description = xml_root.find(".//initial_conditions//cell_positions//filename").text # Read values from the GUI widgets and generate/write a new XML def fill_xml(self, xml_root): # print('config.py fill_xml() !!!!!') # TODO: verify template .xml file exists! # TODO: verify valid type (numeric) and range? xml_root.find(".//x_min").text = str(self.xmin.value) xml_root.find(".//x_max").text = str(self.xmax.value) xml_root.find(".//dx").text = str(self.xdelta.value) xml_root.find(".//y_min").text = str(self.ymin.value) xml_root.find(".//y_max").text = str(self.ymax.value) xml_root.find(".//dy").text = str(self.ydelta.value) xml_root.find(".//z_min").text = str(self.zmin.value) xml_root.find(".//z_max").text = str(self.zmax.value) xml_root.find(".//dz").text = str(self.zdelta.value) if xml_root.find(".//options//virtual_wall_at_domain_edge"): xml_root.find(".//options//virtual_wall_at_domain_edge").text = str(self.toggle_virtual_walls.value).lower() xml_root.find(".//max_time").text = str(self.tmax.value) xml_root.find(".//omp_num_threads").text = str(self.omp_threads.value) xml_root.find(".//SVG").find(".//enable").text = str(self.toggle_svg.value) xml_root.find(".//SVG").find(".//interval").text = str(self.svg_interval.value) xml_root.find(".//full_data").find(".//enable").text = str(self.toggle_mcds.value) xml_root.find(".//full_data").find(".//interval").text = str(self.mcds_interval.value) # uep.find('.//cell_definition[1]//phenotype//mechanics//options//set_absolute_equilibrium_distance').attrib['enabled'] = str(self.bool1.value) # xml_root.find(".//initial_conditions//cell_positions").attrib["enabled"] = str(self.toggle_cells_csv.value) uep = xml_root.find(".//initial_conditions//cell_positions") if uep: uep.attrib["enabled"] = str(self.toggle_cells_csv.value) # user_details = ET.SubElement(root, "user_details") # ET.SubElement(user_details, "PhysiCell_settings", name="version").text = "devel-version" # ET.SubElement(user_details, "domain") # ET.SubElement(user_details, "xmin").text = "-100" # tree = ET.ElementTree(root) # tree.write(write_config_file.value) # tree.write("test.xml") # TODO: verify can write to this filename # tree.write(write_config_file.value) def get_num_svg_frames(self): if (self.toggle_svg.value): return int(self.tmax.value/self.svg_interval.value) else: return 0 def get_num_substrate_frames(self): if (self.toggle_mcds.value): return int(self.tmax.value/self.mcds_interval.value) else: return 0
def build_options(self): grid = GridspecLayout(10, 2) options_map = {} style = {'description_width': '60%', 'width': 'auto'} # feature feature = Combobox(description='Feature to plot:', style=style, options=list(self.feature_names), ensure_option=True, value=self.feature_names[0]) options_map['feature'] = feature # num_grid_points num_grid_points = BoundedIntText( value=10, min=1, max=999999, step=1, description='Number of grid points:', style=style, description_tooltip='Number of grid points for numeric feature') options_map['num_grid_points'] = num_grid_points # grid_type grid_type = Dropdown( description='Grid type:', options=['percentile', 'equal'], style=style, description_tooltip='Type of grid points for numeric feature') options_map['grid_type'] = grid_type # cust_range cust_range = Checkbox(description='Custom grid range', value=False) options_map['cust_range'] = cust_range # range_min range_min = FloatText( description='Custom range minimum:', style=style, description_tooltip= 'Percentile (when grid_type="percentile") or value (when grid_type="equal") ' 'lower bound of range to investigate (for numeric feature)\n' ' - Enabled only when custom grid range is True and variable with grid points is None', disabled=True) options_map['range_min'] = range_min # range_max range_max = FloatText( description='Custom range maximum:', style=style, description_tooltip= 'Percentile (when grid_type="percentile") or value (when grid_type="equal") ' 'upper bound of range to investigate (for numeric feature)\n' ' - Enabled only when custom grid range is True and variable with grid points is None', disabled=True) options_map['range_max'] = range_max # cust_grid_points cust_grid_points = UpdatingCombobox( options_keys=self.globals_options, description='Variable with grid points:', style=style, description_tooltip= 'Name of variable (or None) with customized list of grid points for numeric feature', value='None', disabled=True) cust_grid_points.lookup_in_kernel = True options_map['cust_grid_points'] = cust_grid_points # set up disabling of range inputs, when user doesn't want custom range def disable_ranges(change): range_min.disabled = not change['new'] range_max.disabled = not change['new'] cust_grid_points.disabled = not change['new'] # but if the cust_grid_points has a value filled in keep range_max and range_min disabled if cust_grid_points.value != 'None': range_max.disabled = True range_min.disabled = True cust_range.observe(disable_ranges, names=['value']) # set up disabling of range_max and range_min if user specifies custom grid points def disable_max_min(change): if change['new'] == 'None': range_max.disabled = False range_min.disabled = False else: range_max.disabled = True range_min.disabled = True cust_grid_points.observe(disable_max_min, names=['value']) # set up links between upper and lower ranges def set_ranges(change): if grid_type.value == 'percentile': if change['owner'] == range_min or change[ 'owner'] == num_grid_points: range_max.value = max( range_max.value, range_min.value + num_grid_points.value) if change['owner'] == range_max: range_min.value = min( range_min.value, range_max.value - num_grid_points.value) else: if change['owner'] == range_min: range_max.value = max(range_max.value, range_min.value) if change['owner'] == range_max: range_min.value = min(range_min.value, range_max.value) range_min.observe(set_ranges, names=['value']) range_max.observe(set_ranges, names=['value']) num_grid_points.observe(set_ranges, names=['value']) # center center = Checkbox(description='Center the plot', value=True) options_map['center'] = center # plot_pts_dist plot_pts_dist = Checkbox(description='Plot data points distribution', value=True) options_map['plot_pts_dist'] = plot_pts_dist # x_quantile x_quantile = Checkbox(description='X-axis as quantiles', value=False) options_map['x_quantile'] = x_quantile # show_percentile show_percentile = Checkbox(description='Show precentile buckets', value=False) options_map['show_percentile'] = show_percentile # lines lines = Checkbox(description='Plot lines - ICE plot', value=False) options_map['lines'] = lines # frac_to_plot frac_to_plot = BoundedFloatText( description='Lines to plot:', value=1, description_tooltip= 'How many lines to plot, can be a integer or a float.\n' ' - integer values higher than 1 are interpreted as absolute amount\n' ' - floats are interpreted as fraction (e.g. 0.5 means half of all possible lines)', style=style, disabled=True) options_map['frac_to_plot'] = frac_to_plot # cluster cluster = Checkbox(description='Cluster lines', value=False, disabled=True) options_map['cluster'] = cluster # n_cluster_centers n_cluster_centers = BoundedIntText( value=10, min=1, max=999999, step=1, description='Number of cluster centers:', style=style, description_tooltip='Number of cluster centers for lines', disabled=True) options_map['n_cluster_centers'] = n_cluster_centers # cluster method cluster_method = Dropdown( description='Cluster method', style=style, options={ 'KMeans': 'accurate', 'MiniBatchKMeans': 'approx' }, description_tooltip='Method to use for clustering of lines', disabled=True) options_map['cluster_method'] = cluster_method # set up disabling of lines related options def disable_lines(change): frac_to_plot.disabled = not change['new'] cluster.disabled = not change['new'] n_cluster_centers.disabled = not (change['new'] and cluster.value) cluster_method.disabled = not (change['new'] and cluster.value) lines.observe(disable_lines, names=['value']) # set up disabling of clustering options def disable_clustering(change): n_cluster_centers.disabled = not (cluster.value and change['new']) cluster_method.disabled = not (cluster.value and change['new']) cluster.observe(disable_clustering, names=['value']) grid[0, :] = feature grid[1, 0] = num_grid_points grid[1, 1] = grid_type grid[2, 0] = cust_range grid[2, 1] = cust_grid_points grid[3, 0] = range_min grid[3, 1] = range_max grid[4, 0] = center grid[4, 1] = plot_pts_dist grid[5, 0] = x_quantile grid[5, 1] = show_percentile grid[6, :] = lines grid[7, :] = frac_to_plot grid[8, :] = cluster grid[9, 0] = n_cluster_centers grid[9, 1] = cluster_method return options_map, grid
def __init__(self, xml_root): # micron_units = HTMLMath(value=r"$\mu M$") micron_units = Label('micron') # use "option m" (Mac, for micro symbol) # micron_units = Label('microns') # use "option m" (Mac, for micro symbol) constWidth = '180px' # tab_height = '400px' tab_height = '500px' # tab_layout = Layout(width='900px', # border='2px solid black', # tab_layout = Layout(width='850px', # border='2px solid black', # height=tab_height, overflow_y='scroll',) # np_tab_layout = Layout(width='800px', # border='2px solid black', # height='350px', overflow_y='scroll',) # my_domain = [0,0,-10, 2000,2000,10, 20,20,20] # [x,y,zmin, x,y,zmax, x,y,zdelta] # label_domain = Label('Domain ($\mu M$):') label_domain = Label('Domain (micron):') stepsize = 10 disable_domain = False self.xmin = FloatText(step=stepsize, # description='$X_{min}$', description='Xmin', disabled = disable_domain, layout=Layout(width=constWidth), ) self.ymin = FloatText(step=stepsize, description='Ymin', disabled = disable_domain, layout=Layout(width=constWidth), ) self.zmin = FloatText(step=stepsize, description='Zmin', disabled = disable_domain, layout=Layout(width=constWidth), ) self.xmax = FloatText(step=stepsize, description='Xmax', disabled = disable_domain, layout=Layout(width=constWidth), ) self.ymax = FloatText(step=stepsize, description='Ymax', disabled = disable_domain, layout=Layout(width=constWidth), ) self.zmax = FloatText(step=stepsize, description='Zmax', disabled = disable_domain, layout=Layout(width=constWidth), ) self.toggle_virtual_walls = Checkbox( description='Virtual walls', layout=Layout(width='350px') ) # description='$Time_{max}$', self.tmax = BoundedFloatText( min=0., max=100000000, step=stepsize, description='Max Time', layout=Layout(width=constWidth), ) self.xdelta = BoundedFloatText( min=1., description='dx', # '∆x', # Mac: opt-j for delta disabled = disable_domain, layout=Layout(width=constWidth), ) self.ydelta = BoundedFloatText( min=1., description='dy', disabled = disable_domain, layout=Layout(width=constWidth), ) self.zdelta = BoundedFloatText( min=1., description='dz', disabled = disable_domain, layout=Layout(width=constWidth), ) """ self.tdelta = BoundedFloatText( min=0.01, description='$Time_{delta}$', layout=Layout(width=constWidth), ) """ """ self.toggle2D = Checkbox( description='2-D', layout=Layout(width=constWidth), ) def toggle2D_cb(b): if (self.toggle2D.value): #zmin.disabled = zmax.disabled = zdelta.disabled = True zmin.disabled = True zmax.disabled = True zdelta.disabled = True else: zmin.disabled = False zmax.disabled = False zdelta.disabled = False self.toggle2D.observe(toggle2D_cb) """ x_row = HBox([self.xmin, self.xmax, self.xdelta]) y_row = HBox([self.ymin, self.ymax, self.ydelta]) z_row = HBox([self.zmin, self.zmax, self.zdelta]) self.omp_threads = BoundedIntText( min=1, max=4, description='# threads', layout=Layout(width=constWidth), ) # self.toggle_prng = Checkbox( # description='Seed PRNG', style={'description_width': 'initial'}, # e.g. 'initial' '120px' # layout=Layout(width=constWidth), # ) # self.prng_seed = BoundedIntText( # min = 1, # description='Seed', # disabled=True, # layout=Layout(width=constWidth), # ) # def toggle_prng_cb(b): # if (toggle_prng.value): # self.prng_seed.disabled = False # else: # self.prng_seed.disabled = True # self.toggle_prng.observe(toggle_prng_cb) #prng_row = HBox([toggle_prng, prng_seed]) self.toggle_svg = Checkbox( description='Cells', # SVG layout=Layout(width='150px') ) # constWidth = '180px' # self.svg_t0 = BoundedFloatText ( # min=0, # description='$T_0$', # layout=Layout(width=constWidth), # ) self.svg_interval = BoundedFloatText( min=0.001, max=99999999, # TODO: set max on all Bounded to avoid unwanted default description='every', layout=Layout(width='160px'), ) self.mcds_interval = BoundedFloatText( min=0.001, max=99999999, description='every', # disabled=True, layout=Layout(width='160px'), ) # don't let this be > mcds interval def svg_interval_cb(b): if (self.svg_interval.value > self.mcds_interval.value): self.svg_interval.value = self.mcds_interval.value self.svg_interval.observe(svg_interval_cb) # BEWARE: when fill_gui, this sets value = 1 ! # don't let this be < svg interval def mcds_interval_cb(b): if (self.mcds_interval.value < self.svg_interval.value): self.mcds_interval.value = self.svg_interval.value self.mcds_interval.observe(mcds_interval_cb) # BEWARE: see warning above def toggle_svg_cb(b): if (self.toggle_svg.value): # self.svg_t0.disabled = False self.svg_interval.disabled = False else: # self.svg_t0.disabled = True self.svg_interval.disabled = True self.toggle_svg.observe(toggle_svg_cb) self.toggle_mcds = Checkbox( # value=False, description='Subtrates', # Full layout=Layout(width='180px'), ) # self.mcds_t0 = FloatText( # description='$T_0$', # disabled=True, # layout=Layout(width=constWidth), # ) def toggle_mcds_cb(b): if (self.toggle_mcds.value): # self.mcds_t0.disabled = False #False self.mcds_interval.disabled = False else: # self.mcds_t0.disabled = True self.mcds_interval.disabled = True self.toggle_mcds.observe(toggle_mcds_cb) svg_mat_output_row = HBox([Label('Plots:'),self.toggle_svg, HBox([self.svg_interval,Label('min')]), self.toggle_mcds, HBox([self.mcds_interval,Label('min')]) ]) # to sync, do this # svg_mat_output_row = HBox( [Label('Plots:'), self.svg_interval, Label('min')]) #write_config_row = HBox([write_config_button, write_config_file]) #run_sim_row = HBox([run_button, run_command_str, kill_button]) # run_sim_row = HBox([run_button, run_command_str]) # run_sim_row = HBox([run_button.w]) # need ".w" for the custom RunCommand widget label_blankline = Label('') # toggle_2D_seed_row = HBox([toggle_prng, prng_seed]) # toggle2D def upload_done_cb(w, name): # Do something with the files here... # We just print their names print("%s uploaded" % name) # reset clears and re-enables the widget for more uploads # You may want to do this somewhere else, depending on your GUI w.reset() if (hublib_flag): self.csv_upload= FileUpload( '', 'Upload cells positions (.csv) from your local machine', dir='data', cb=upload_done_cb, maxsize='1M', # layout=Layout(width='350px') ) self.toggle_cells_csv = Checkbox( description='Enable .csv', layout=Layout(width='280px') ) # layout=Layout(width='350px') ) def toggle_cells_csv_cb(b): # why can't I disable this widget?! # print('---- toggle_cells_csv_cb') if (hublib_flag): if (self.toggle_cells_csv.value): # self.csv_upload.w.disabled = False self.csv_upload.visible = True else: self.csv_upload.visible = False self.toggle_cells_csv.observe(toggle_cells_csv_cb) box_layout = Layout(border='1px solid') if (hublib_flag): upload_cells_hbox = HBox([self.csv_upload.w, self.toggle_cells_csv] , layout=Layout(border='1px solid', width='420px')) else: upload_cells_hbox = HBox([self.toggle_cells_csv] , layout=Layout(border='1px solid', width='420px')) # domain_box = VBox([label_domain,x_row,y_row,z_row], layout=box_layout) uep = xml_root.find(".//options//virtual_wall_at_domain_edge") if uep: domain_box = VBox([label_domain,x_row,y_row, self.toggle_virtual_walls], layout=box_layout) else: domain_box = VBox([label_domain,x_row,y_row], layout=box_layout) uep = xml_root.find(".//options//virtual_wall_at_domain_edge") if uep: self.tab = VBox([domain_box, HBox([self.tmax, Label('min')]), self.omp_threads, svg_mat_output_row, label_blankline, # HBox([self.csv_upload.w, self.toggle_cells_csv]), upload_cells_hbox, # HBox([self.substrate[3], self.diffusion_coef[3], self.decay_rate[3] ]), # ], layout=tab_layout) # output_dir, toggle_2D_seed_ ]) else: self.tab = VBox([domain_box, HBox([self.tmax, Label('min')]), self.omp_threads, svg_mat_output_row, ])