def save_timecourses(session_ids, factin_filename='results/melki_factin_timecourses.dat', pi_filename='results/melki_pi_timecourses.dat'): dbs = database.DBSession() sessions = [dbs.query(database.Session).get(sid) for sid in session_ids] cooperativities = [s.parameters['release_cooperativity'] for s in sessions] cooperativities, sessions = zip(*sorted(zip(cooperativities, sessions))) times = None factin_values = [] pi_values = [] for session in sessions: run = session.experiments[0].runs[0] times, fvals, ferrors = run.analyses['factin'] times, pvals, perrors = run.analyses['Pi'] factin_values.append(fvals) pi_values.append(pvals) factin_rows = zip(*([times] + factin_values)) pi_rows = zip(*([times] + pi_values)) _write_results(factin_filename, factin_rows, 'Time (s)', 'F-actin (uM)', 'Release Cooperativitiy', cooperativities) _write_results(pi_filename, pi_rows, 'Time (s)', '[Pi] (uM)', 'Release Cooperativitiy', cooperativities)
def main(session_filename, objective_name, polling_period, plot): db_session = database.DBSession() with job_control.process('controller', db_session) as process: try: session, par_spec = factories.controllers.load_complete_session( db_session, session_filename) par_name, par_guess = _par_from_spec(par_spec) population = fitting_controller.SimplePopulation( dbs=db_session, session=session, parameter_name=par_name, parameter_guess=par_guess, objective_name=objective_name, process=process, plot=plot) c = fitting_controller.SimpleFitController( dbs=db_session, session=session, population=population, polling_period=polling_period, process=process) c.run() except: logger.exception('Exception in controller main.') raise
def vectorial_save(session_id, rate_filename='results/melki_vectorial_rate.dat'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) sample_size = (session.parameters['number_of_simulations'] * session.parameters['number_of_filaments']) fractional_error = 1 / numpy.sqrt(sample_size) best_run = None best_fit = None for run in session.experiments[0].runs: run_fit = run.get_objective('pi_fit') if run_fit is None: continue if not best_run or best_fit > run.get_objective('pi_fit'): best_run = run best_fit = run.get_objective('pi_fit') best_rate = best_run.parameters['release_rate'] statistical_error = best_rate * fractional_error row = ('Inf', best_rate, statistical_error, best_run.get_objective('halftime'), best_run.get_objective('halftime_error')) _small_writer(rate_filename, [row], [ 'rho', 'release_rate', 'naive statistical error', 'halftime', 'halftime_error' ])
def plot_nearest_fit_timecourse(session_id, alpha=0.01): rates, chi2s = get_xy(session_id) rate_pack, k_pack, c_pack = fit_xy(rates, chi2s, alpha) import bisect xi = bisect.bisect(rates, rate_pack[0]) nearest_rate = rates[xi] dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) runs = session.experiments[0].runs nearest_run = None for run in runs: if run.parameters['release_rate'] == nearest_rate: nearest_run = run break t, fact, p, fe, pe = _get_timecourses(nearest_run) f_data = data.load_data( 'experimental_data/melki_fievez_carlier_1996/factin_concentration.dat') p_data = data.load_data( 'experimental_data/melki_fievez_carlier_1996/phosphate_concentration.dat' ) import pylab f = pylab.figure() a = f.add_subplot(1, 1, 1) a.plot(f_data[0], f_data[1], 'k-', label='[F] Data') a.plot(p_data[0], p_data[1], 'k--', label='[Pi] Data') a.plot(t, fact, 'b-', label='[F] Sim') a.plot(t, p, 'b--', label='[Pi] Sim') a.set_ylim([0, 35])
def session_fits(session_id, fit_length=50, output_filename='results/check_fit.dat', write=True): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) runs = session.experiments[0].runs data = [] for run in runs: parameter = run.parameters['release_rate'] fitness = run.get_objective('pi_fit') if fitness is not None: data.append((parameter, fitness)) fit_sorted_data = sorted(data, key=operator.itemgetter(1)) px, py = zip(*fit_sorted_data[:fit_length]) coeffs, R, n, svs, rcond = scipy.polyfit(px, py, 2, full=True) x, y = zip(*sorted(data)) peak = float(-coeffs[1] / (2 * coeffs[0])) fit = float(R / fit_length) if write: p = scipy.polyval(coeffs, x) header = '# Parabola peak at %s\n# Parabola R^2/n = %s\n' rows = zip(x, y, p) _small_writer(output_filename, rows, ['release_rate', 'pi_fit', 'parabola'], header=header % (peak, fit)) return session.parameters.get('release_cooperativity'), peak, fit
def save_qof(session_ids, alpha=0.01, cooperative_filename='results/depoly_cooperative_qof.dat', vectorial_filename='results/depoly_vectorial_qof.dat'): dbs = database.DBSession() coop_results = [] vec_results = None for sid in session_ids: session = dbs.query(database.Session).get(sid) chi2, chi2_min, chi2_max, chi2_pct = _get_qof(session, alpha) # chi2, chi2_min, chi2_max, chi2_pct = _get_dumb_qof(session, alpha) cooperativity = session.parameters.get('release_cooperativity') if cooperativity is not None: coop_results.append( [cooperativity, chi2, chi2_min, chi2_max, chi2_pct]) else: vec_results = [chi2, chi2_min, chi2_max, chi2_pct] if coop_results: coop_results.sort() _small_writer( cooperative_filename, coop_results, ['Cooperativity', 'Chi^2', 'Min CI', 'Max CI', '% Error'], header="# Cooperative quality of fit for Jegou 2011\n") if vec_results: _small_writer(vectorial_filename, [vec_results], ['Chi^2', 'Min CI', 'Max CI', '% Error'], header="# Vectorial quality of fit for Jegou 2011\n")
def fnc_plot(session_id, x_range=0.1, alpha=0.01, num_parabola_points=500, interactive=True, output_filename=None): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) x, y = get_xy(session_id, target='f_fit', parameter='filament_tip_concentration') # min_x = x[0] # max_x = x[-1] # filtered_x = x # filtered_y = y imin = numpy.argmin(y) xmin = x[imin] min_x = (1 - x_range) * xmin max_x = (1 + x_range) * xmin indices = numpy.intersect1d(numpy.argwhere(min_x < x), numpy.argwhere(max_x > x)) filtered_x = x.take(indices) filtered_y = y.take(indices) rate_pack, k_pack, c_pack = fit_xy(filtered_x, filtered_y, alpha) def f(x, r, k, c): return k * (x - r)**2 + c par_x_vals = numpy.linspace(min_x, max_x, num_parabola_points) par_y_vals = f(par_x_vals, rate_pack[0], k_pack[0], c_pack[0]) from . import plot_util f = plot_util.figure(interactive=interactive) top_axes = f.add_subplot(2, 1, 1) top_axes.plot(x, y, 'r.') top_axes.set_xlabel(r'Filament Number Concentration [$\mu$M]') top_axes.set_ylabel('Chi^2 Fit to Melki Data') top_axes.axvline(rate_pack[0], 0, 1, color='g', linestyle=':') # top_axes.set_yscale('log') top_axes.xaxis.major.formatter.set_powerlimits((0, 0)) # top_axes.set_xlim(0, x[-1]) bot_axes = f.add_subplot(2, 1, 2) bot_axes.plot(filtered_x, filtered_y, 'ro') bot_axes.plot(par_x_vals, par_y_vals, 'b-') bot_axes.set_xlabel(r'Filament Number Concentration [$\mu$M]') bot_axes.set_ylabel('Chi^2 Fit to Melki Data') bot_axes.axvline(rate_pack[0], 0, 1, color='g', linestyle='-') bot_axes.axvline(rate_pack[1], 0, 1, color='g', linestyle=':') bot_axes.axvline(rate_pack[2], 0, 1, color='g', linestyle=':') bot_axes.xaxis.major.formatter.set_powerlimits((0, 0)) bot_axes.set_xlim(min_x, max_x) top_axes.set_title(r'FNC = %.3e $\mu$M +/- %.3f%%' % (rate_pack[0], rate_pack[-1]))
def save_timecourse(session_id, experiment_index=0, run_index=0, timecourse_filename='results/copoly_timecourse.dat'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) run = session.experiments[experiment_index].runs[run_index] ftc = run.all_parameters['filament_tip_concentration'] seed_concentration = run.all_parameters['seed_concentration'] # length_data = run.analyses['length'] # # convert to [factin] # factin_data = measurements.add_number(measurements.scale(length_data, ftc), # -seed_concentration) factin_data = run.analyses['factin'] pi_data = run.analyses['Pi'] # File output columns are "time [factin] (error) [pi] (error)" combined_data = _combine_timecourse_data(factin_data, pi_data) _write_results(timecourse_filename, combined_data, 'Time (s)', 'Concentration (uM)', 'Data', ['[F-actin]', '[F-actin] error', '[Pi]', '[Pi] error'])
def save_lagtimes( session_ids, cooperative_output_filename='results/fnc_cooperative_lagtimes.dat', vectorial_output_filename='results/fnc_vectorial_lagtimes.dat'): dbs = database.DBSession() fncs = None vectorial_lagtimes = None all_lagtimes = [] for sid in session_ids: session = dbs.query(database.Session).get(sid) cooperativity, fncs, lagtimes = get_lagtimes(session) s_lagtimes = scale_lagtimes(lagtimes) if cooperativity is not None: all_lagtimes.append((cooperativity, s_lagtimes)) else: vectorial_lagtimes = s_lagtimes if all_lagtimes: all_lagtimes.sort() cooperativities, cooperative_lagtimes = zip(*all_lagtimes) # cooperative_lagtimes = numpy.array(cooperative_lagtimes) rhos = ['%.0e' % c for c in cooperativities] rows = zip(fncs, *cooperative_lagtimes) _write_results(cooperative_output_filename, rows, 'FNC', 'Lagtime', 'Release Cooperativity', rhos) if vectorial_lagtimes is not None: _small_writer(vectorial_output_filename, zip(fncs, vectorial_lagtimes), ['fnc', 'lagtime'], header='# Lagtime for vectorial model.\n')
def _plot_nf_timecourse(session_id, axes=None, alpha=None, color=None): rates, chi2s = get_xy(session_id) rate_pack, k_pack, c_pack = fit_xy(rates, chi2s, alpha) import bisect xi = bisect.bisect(rates, rate_pack[0]) nearest_rate = rates[xi] dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) runs = session.experiments[0].runs nearest_run = None for run in runs: if run.parameters['release_rate'] == nearest_rate: nearest_run = run break t, f, p, fe, pe = _get_timecourses(nearest_run) cooperativity = session.parameters.get('release_cooperativity', None) if cooperativity is not None: label = r'$\rho_d$ = %.2e' % cooperativity else: label = 'Vectorial' axes.plot(t, f, color + '-', label=label) axes.plot(t, p, color + '--')
def _extract_fnc_fits(session_id): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) e = session.experiments[0] fncs = _get_fnc_mesh(e) obj_bind = e.objectives['factin_fit'] fits = [] for fnc in fncs: obj_q = dbs.query(database.Objective).filter_by(bind=obj_bind) runs_q = obj_q.join(database.Run) par_q = runs_q.join(database.RunParameter).filter_by( name='filament_tip_concentration').filter( database.RunParameter.value.like(fnc)) best_fit = None for objective in par_q: this_fit = objective.value if best_fit is None or this_fit < best_fit: best_fit = this_fit fits.append(best_fit) return fncs, fits
def save_qof(numerator_session_ids, denominator_session_ids, alpha=0.01, cooperative_output_filename='results/fnc_cooperative_qof.dat', vectorial_output_filename='results/fnc_vectorial_qof.dat'): TARGET = 620.69 / 166.7 # about 3.72 dbs = database.DBSession() n_rows = [] for nsid in numerator_session_ids: session = dbs.query(database.Session).get(nsid) n_rows.append(_get_single_lagtime(session)) d_rows = [] for dsid in denominator_session_ids: session = dbs.query(database.Session).get(dsid) d_rows.append(_get_single_lagtime(session)) n_rows.sort() d_rows.sort() coop_results = [] vec_results = None for nrow, drow in zip(n_rows, d_rows): nrho, nval, nerr, nnum = nrow drho, dval, derr, dnum = drow if nrho != drho: raise RuntimeError("Numerator and Denominator FNCs don't match.") # if nnum != dnum: # raise RuntimeError("Numerator and Denominator simulation counts don't match.") qof = (nval / dval - TARGET)**2 fit_std_error = numpy.sqrt((nerr / dval)**2 + (nval * derr / dval**2)**2) t = scipy.stats.t.ppf(1 - alpha / 2, min(nnum, dnum) - 1) ci_size = t * fit_std_error if nrho is not None: coop_results.append( (nrho, qof, qof - ci_size, qof + ci_size, ci_size / qof * 100)) else: vec_results = (qof, qof - ci_size, qof + ci_size, ci_size / qof * 100) if coop_results: coop_results.sort() _small_writer( cooperative_output_filename, coop_results, ['Cooperativity', 'Chi^2', 'Min CI', 'Max CI', '% Error'], header="# Cooperative quality of fit for Carlier 86\n") if vec_results: _small_writer(vectorial_output_filename, [vec_results], ['Chi^2', 'Min CI', 'Max CI', '% Error'], header="# Vectorial quality of fit for Carlier 86\n")
def save_halftimes(session_id, halftime_filename='results/fnc_halftimes.dat'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) fnc_mesh, cooperativities, halftime_results = _get_halftimes( session, concentration_name='filament_tip_concentration') _write_results(halftime_filename, _create_rows(fnc_mesh, halftime_results), 'FNC', 'Halftime', 'Release Cooperativity', cooperativities)
def get_cc_d(session_id): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) run = session.experiments[0].runs[0] cc = run.get_objective('final_ATP_concentration') D = run.get_objective('diffusion_coefficient') cooperativity = run.all_parameters.get(parameter) return cooperativity, cc, D
def main(): db_session = database.DBSession() with job_control.process('test', db_session) as process: logger.debug('Test debug message.') logger.info('Test info message.') logger.warn('Test warn message.') logger.error('Test error message.') logger.critical('Test critical message.') try: foo_raises() except: logger.exception('Apparently I can catch exceptions too!')
def ht_v_fil(session_id, output_filename='results/ht_v_numfil.dat'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) rows = [] for run in session.experiments[0].runs: numfils = run.all_parameters['number_of_filaments'] halftime = run.get_objective('halftime') row = numfils, halftime rows.append(row) _small_writer(output_filename, sorted(rows), ['release rate', 'pi halftime'])
def single(session_id, objective_name='halftime', output_filename='results/fnc_halftimes.dat'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) results = _get_objective_v_concentration( session, concentration_name='filament_tip_concentration', objective_name=objective_name) _small_writer(output_filename, results, ['fnc', 'halftime'])
def main(idle_timeout, retry_delay): db_session = database.DBSession() with job_control.process('worker', db_session) as process: stop_time = time.time() + idle_timeout while time.time() < stop_time: job = job_control.get_job(process.id, db_session) if job: run_support.run_job(job, db_session) job.complete = True stop_time = time.time() + idle_timeout else: time.sleep(retry_delay)
def get_xy(session_id, target='pi_fit', parameter='release_rate'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) runs = session.experiments[0].runs pairs = sorted([(r.get_objective(target), r.parameters[parameter]) for r in runs if r.get_objective(target) is not None], key=operator.itemgetter(1)) y_values, x_values = zip(*pairs) x_values = numpy.array(x_values) y_values = numpy.array(y_values) return x_values, y_values
def extract_fits(session_ids, output_filename='results/fit_rates.dat', fit_length=50): dbs = database.DBSession() rows = [] for session_id in session_ids: rows.append( session_fits(session_id, fit_length=fit_length, write=False)) rows.sort() _small_writer(output_filename, rows, ['release_cooperativity', 'release_rate', 'parabola R2'])
def _save_vectorial(session_id, halftime_name='halftime', fraction_name=None, output_filename=None): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) fractions, halftimes = _get_halftimes(session, halftime_name=halftime_name, fraction_name=fraction_name) rows = zip(fractions, halftimes) _small_writer(output_filename, rows, [fraction_name, 'pi halftime'])
def save_mean(sid, filename): dbs = database.DBSession() session = dbs.query(database.Session).get(sid) e = session.experiments[0] polymerization_duration = e.all_parameters['polymerization_duration'] simulation_duration = e.all_parameters['simulation_duration'] sample_period = e.all_parameters['sample_period'] times = numpy.arange( 0, simulation_duration - polymerization_duration + float(sample_period) / 2, sample_period) values = _get_timecourse(e.runs[0], times, polymerization_duration) rows = zip(times, values) _small_writer(filename, rows, ['times', 'mean_filament_length'])
def save_vs_parameter(session_id, output_filename='results/cc_d_tip.dat', parameter='barbed_tip_release_rate'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) results = [] for run in session.experiments[0].runs: results.append(get_cc_d_run(run, parameter=parameter)) results.sort() _small_writer(output_filename, results, [ parameter, 'Critical Concentration (uM)', 'Diffusion Coefficient (mon/s^2)' ])
def console_main(): # Make plotting interactive pylab.ion() # Prepare and drop into iPython shell. namespace = { 'database': database, 'db_session': database.DBSession(), 'numpy': numpy, 'pylab': pylab, 'job_control': job_control, 'visualization': visualization } shell = IPShellEmbed(argv=[], banner=banner) shell(local_ns=namespace)
def save_fits(session_id, output_filename='results/sample_rates.dat', objective_name='pi_fit', parameter_name='release_rate'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) rows = [] for run in session.experiments[0].runs: rate = run.parameters[parameter_name] fit = run.get_objective(objective_name) halftime = run.get_objective('halftime') halftime_error = run.get_objective('halftime_error') if fit is not None: rows.append((rate, fit, halftime, halftime_error)) _small_writer( output_filename, sorted(rows), [parameter_name, objective_name, 'pi halftime', 'pi halftime error'])
def main(filter_by_time=False, start_time=None, stop_time=None, min_level=None, level_name=None, process_type=None, process_id=None, follow=False, polling_period=None, use_color=True): disp = display.LogDisplayer(use_color=use_color) # NOTE We only need a read-only session. # I don't know whether SQLA supports that. if filter_by_time: start_time = dateutil.parser.parse(start_time) if stop_time: stop_time = dateutil.parser.parse(stop_time) if start_time > stop_time: start_time = None else: start_time = None stop_time = None db_session = database.DBSession() with db_session.transaction: last_id = disp.print_all( make_query(0, start_time, stop_time, min_level, level_name, process_type, process_id, db_session)) if follow: while True: if stop_time and datetime.datetime.now() > stop_time: break time.sleep(polling_period) with db_session.transaction: this_id = disp.print_all( make_query(last_id, start_time, stop_time, min_level, level_name, process_type, process_id, db_session)) if this_id: last_id = this_id
def _save_halftimes(session_ids, fraction_name=None, output_filename=None): dbs = database.DBSession() fractions = None cooperativities = [] halftimes = [] for session_id in session_ids: session = dbs.query(database.Session).get(session_id) fractions, session_halftimes = _get_halftimes( session, fraction_name=fraction_name) cooperativities.append(session.parameters['release_cooperativity']) halftimes.append(session_halftimes) cooperativities, halftimes = zip(*sorted(zip(cooperativities, halftimes))) rows = zip(*([fractions] + list(halftimes))) _write_results(output_filename, rows, fraction_name, 'Halftime', 'Release Cooperativity', cooperativities)
def _get_best_tc(session_id, alpha): rates, chi2s = get_xy(session_id) rate_pack, k_pack, c_pack = fit_xy(rates, chi2s, alpha) import bisect xi = bisect.bisect(rates, rate_pack[0]) nearest_rate = rates[xi] dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) runs = session.experiments[0].runs nearest_run = None for run in runs: if run.parameters['release_rate'] == nearest_rate: nearest_run = run break t, f, p, fe, pe = _get_timecourses(nearest_run) cooperativity = session.parameters.get('release_cooperativity', None) return cooperativity, t, f, p
def save_timecourses(session_id, output_filename='results/carlier_86_timecourses.dat'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) run = session.experiments[0].runs[0] times, atp_vals, atp_errors = run.analyses['F_ATP'] times, adppi_vals, adppi_errors = run.analyses['F_ADPPi'] times, adp_vals, adp_errors = run.analyses['F_ADP'] times, pi_vals, pi_errors = run.analyses['Pi'] times, length_vals, length_errors = run.analyses['length'] rows = zip(times, length_vals, atp_vals, adppi_vals, adp_vals, pi_vals) _small_writer(output_filename, rows, [ 'Time (s)', 'length', 'F-ATP-actin', 'F-ADPPi-actin', 'F-ADP-actin', '[Pi] uM' ])
def save(session_id, output_filename='results/depolymerization_timecourses.dat'): dbs = database.DBSession() session = dbs.query(database.Session).get(session_id) e = session.experiments[0] polymerization_duration = e.all_parameters['polymerization_duration'] simulation_duration = e.all_parameters['simulation_duration'] sample_period = e.all_parameters['sample_period'] times = numpy.arange( 0, simulation_duration - polymerization_duration + float(sample_period) / 2, sample_period) values = [] for run in session.experiments[0].runs: values.append(_get_timecourse(run, times, polymerization_duration)) tv = numpy.transpose(values) results = numpy.vstack((times, values)) results = numpy.transpose(results) _small_writer(output_filename, results, ['times', 'filament_length'])