def get_response_content(fs):
# precompute some transition matrices
P_drift_selection = pgmsinglesite.create_drift_selection_transition_matrix(
fs.npop, fs.selection_ratio)
MatrixUtil.assert_transition_matrix(P_drift_selection)
P_mutation = pgmsinglesite.create_mutation_transition_matrix(
fs.npop, fs.mutation_ab, fs.mutation_ba)
MatrixUtil.assert_transition_matrix(P_mutation)
# define the R table headers
headers = ['generation', 'number.of.mutants']
# compute the path samples
P = np.dot(P_drift_selection, P_mutation)
mypath = PathSampler.sample_endpoint_conditioned_path(
fs.nmutants_initial, fs.nmutants_final, fs.ngenerations, P)
arr = [[i, nmutants] for i, nmutants in enumerate(mypath)]
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
f_info = ctmcmi.get_mutual_info_known_distn
# define the R table headers
headers = ['log.probability.ratio', 'mutual.information']
# make the array
arr = []
for x in np.linspace(fs.x_min, fs.x_max, 101):
row = [x]
proc = evozoo.AlternatingHypercube_d_1(3)
X = np.array([x])
distn = proc.get_distn(X)
Q = proc.get_rate_matrix(X)
info = f_info(Q, distn, fs.t)
row.append(info)
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def main(args):
# get the end positions,
# forcing the first end position to be 5
# and the last end position to be 898.
incr = (g_nchar - 5) / float(args.nlengths - 1)
stop_positions = [5 + int(i * incr) for i in range(args.nlengths)]
stop_positions[-1] = g_nchar
# run BEAST and create the R stuff
table_string, scripts = get_table_string_and_scripts(
stop_positions, args.nsamples)
# create the comboscript
out = StringIO()
print >> out, 'library(ggplot2)'
print >> out, 'par(mfrow=c(3,1))'
for script in scripts:
print >> out, script
comboscript = out.getvalue()
# create the R output image
device_name = Form.g_imageformat_to_r_function['pdf']
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name)
if retcode:
raise RUtil.RError(r_err)
# write the image data
with open(args.outfile, 'wb') as fout:
fout.write(image_data)
def get_response_content(fs):
# validate and store user input
if fs.x_max <= fs.x_min:
raise ValueError('check the min and max logs')
f_info = divtime.get_fisher_info_known_distn_fast
# define the R table headers
headers = ['log.probability.ratio', 'fisher.information']
# make the array
arr = []
for x in np.linspace(fs.x_min, fs.x_max, 101):
row = [x]
proc = evozoo.DistinguishedCornerPairHypercube_d_1(3)
X = np.array([x])
distn = proc.get_distn(X)
Q = proc.get_rate_matrix(X)
info = f_info(Q, distn, fs.t)
row.append(info)
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def main(args):
# get the end positions,
# forcing the first end position to be 5
# and the last end position to be 898.
incr = (g_nchar - 5) / float(args.nlengths - 1)
stop_positions = [5 + int(i * incr) for i in range(args.nlengths)]
stop_positions[-1] = g_nchar
# run BEAST and create the R stuff
table_string, scripts = get_table_string_and_scripts(
stop_positions, args.nsamples)
# create the comboscript
out = StringIO()
print >> out, 'library(ggplot2)'
print >> out, 'par(mfrow=c(3,1))'
for script in scripts:
print >> out, script
comboscript = out.getvalue()
# create the R output image
device_name = Form.g_imageformat_to_r_function['pdf']
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name)
if retcode:
raise RUtil.RError(r_err)
# write the image data
with open(args.outfile, 'wb') as fout:
fout.write(image_data)
def get_response_content(fs):
M, R = get_input_matrices(fs)
# create the R table string and scripts
headers = [
't', 'mi.true.mut', 'mi.true.mutsel', 'mi.analog.mut',
'mi.analog.mutsel'
]
npoints = 100
t_low = 0.0
t_high = 5.0
t_incr = (t_high - t_low) / (npoints - 1)
t_values = [t_low + t_incr * i for i in range(npoints)]
# get the data for the R table
arr = []
for t in t_values:
mi_mut = ctmcmi.get_mutual_information(M, t)
mi_mutsel = ctmcmi.get_mutual_information(R, t)
mi_analog_mut = ctmcmi.get_ll_ratio_wrong(M, t)
mi_analog_mutsel = ctmcmi.get_ll_ratio_wrong(R, t)
row = [t, mi_mut, mi_mutsel, mi_analog_mut, mi_analog_mutsel]
arr.append(row)
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
f_info = ctmcmi.get_mutual_info_known_distn
# define the R table headers
headers = ['log.probability.ratio', 'mutual.information']
# make the array
arr = []
for x in np.linspace(fs.x_min, fs.x_max, 101):
row = [x]
proc = evozoo.AlternatingHypercube_d_1(3)
X = np.array([x])
distn = proc.get_distn(X)
Q = proc.get_rate_matrix(X)
info = f_info(Q, distn, fs.t)
row.append(info)
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
M, R = get_input_matrices(fs)
# create the R table string and scripts
headers = [
't',
'mi.true.mut',
'mi.true.mutsel',
'mi.analog.mut',
'mi.analog.mutsel']
npoints = 100
t_low = 0.0
t_high = 5.0
t_incr = (t_high - t_low) / (npoints - 1)
t_values = [t_low + t_incr*i for i in range(npoints)]
# get the data for the R table
arr = []
for t in t_values:
mi_mut = ctmcmi.get_mutual_information(M, t)
mi_mutsel = ctmcmi.get_mutual_information(R, t)
mi_analog_mut = ctmcmi.get_ll_ratio_wrong(M, t)
mi_analog_mutsel = ctmcmi.get_ll_ratio_wrong(R, t)
row = [t, mi_mut, mi_mutsel, mi_analog_mut, mi_analog_mutsel]
arr.append(row)
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# precompute some transition matrices
P_drift_selection = pgmsinglesite.create_drift_selection_transition_matrix(
fs.npop, fs.selection_ratio)
MatrixUtil.assert_transition_matrix(P_drift_selection)
P_mutation = pgmsinglesite.create_mutation_transition_matrix(
fs.npop, fs.mutation_ab, fs.mutation_ba)
MatrixUtil.assert_transition_matrix(P_mutation)
# define the R table headers
headers = ['generation', 'number.of.mutants']
# compute the path samples
P = np.dot(P_drift_selection, P_mutation)
mypath = PathSampler.sample_endpoint_conditioned_path(
fs.nmutants_initial, fs.nmutants_final, fs.ngenerations, P)
arr = [[i, nmutants] for i, nmutants in enumerate(mypath)]
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# validate and store user input
if fs.x_max <= fs.x_min:
raise ValueError('check the min and max logs')
f_info = divtime.get_fisher_info_known_distn_fast
# define the R table headers
headers = ['log.probability.ratio', 'fisher.information']
# make the array
arr = []
for x in np.linspace(fs.x_min, fs.x_max, 101):
row = [x]
proc = evozoo.DistinguishedCornerPairHypercube_d_1(3)
X = np.array([x])
distn = proc.get_distn(X)
Q = proc.get_rate_matrix(X)
info = f_info(Q, distn, fs.t)
row.append(info)
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def main(args):
# set up the logger
f = logging.getLogger('toplevel.logger')
h = logging.StreamHandler()
h.setFormatter(logging.Formatter('%(message)s %(asctime)s'))
f.addHandler(h)
if args.verbose:
f.setLevel(logging.DEBUG)
else:
f.setLevel(logging.WARNING)
f.info('(local) permute columns of the alignment')
header_seq_pairs = beasttut.get_456_col_permuted_header_seq_pairs()
f.info('(local) run BEAST serially locally and build the R stuff')
table_string, scripts = get_table_string_and_scripts(
g_start_stop_pairs, args.nsamples, header_seq_pairs)
f.info('(local) create the composite R script')
out = StringIO()
print >> out, 'library(ggplot2)'
print >> out, 'par(mfrow=c(3,1))'
for script in scripts:
print >> out, script
comboscript = out.getvalue()
f.info('(local) run R to create the pdf')
device_name = Form.g_imageformat_to_r_function['pdf']
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name, keep_intermediate=True)
if retcode:
raise RUtil.RError(r_err)
f.info('(local) write the .pdf file')
with open(args.outfile, 'wb') as fout:
fout.write(image_data)
f.info('(local) return from toplevel')
def get_response_content(fs):
f_info = divtime.get_fisher_info_known_distn_fast
requested_triples = []
for triple in g_process_triples:
name, desc, zoo_obj = triple
if getattr(fs, name):
requested_triples.append(triple)
if not requested_triples:
raise ValueError('nothing to plot')
# define the R table headers
r_names = [a.replace('_', '.') for a, b, c in requested_triples]
headers = ['t'] + r_names
# Spend a lot of time doing the optimizations
# to construct the points for the R table.
arr = []
for t in cbreaker.throttled(progrid.gen_binary(fs.start_time,
fs.stop_time),
nseconds=5,
ncount=200):
row = [t]
for python_name, desc, zoo_class in requested_triples:
zoo_obj = zoo_class(fs.d)
df = zoo_obj.get_df()
opt_dep = OptDep(zoo_obj, t, f_info)
if df:
X0 = np.random.randn(df)
xopt = scipy.optimize.fmin(opt_dep,
X0,
maxiter=10000,
maxfun=10000)
# I would like to use scipy.optimize.minimize
# except that this requires a newer version of
# scipy than is packaged for ubuntu right now.
# fmin_bfgs seems to have problems sometimes
# either hanging or maxiter=10K is too big.
"""
xopt = scipy.optimize.fmin_bfgs(opt_dep, X0,
gtol=1e-8, maxiter=10000)
"""
else:
xopt = np.array([])
info_value = -opt_dep(xopt)
row.append(info_value)
arr.append(row)
arr.sort()
npoints = len(arr)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# precompute some transition matrices
P_drift_selection = pgmsinglesite.create_drift_selection_transition_matrix(
fs.npop, fs.selection_ratio)
MatrixUtil.assert_transition_matrix(P_drift_selection)
P_mutation = pgmsinglesite.create_mutation_transition_matrix(
fs.npop, fs.mutation_ab, fs.mutation_ba)
MatrixUtil.assert_transition_matrix(P_mutation)
# define the R table headers
headers = [
'generation',
'number.of.mutants',
'probability',
'log.prob',
]
# compute the transition matrix
P = np.dot(P_drift_selection, P_mutation)
# Compute the endpoint conditional probabilities for various states
# along the unobserved path.
nstates = fs.npop + 1
M = np.zeros((nstates, fs.ngenerations))
M[fs.nmutants_initial, 0] = 1.0
M[fs.nmutants_final, fs.ngenerations-1] = 1.0
for i in range(fs.ngenerations-2):
A_exponent = i + 1
B_exponent = fs.ngenerations - 1 - A_exponent
A = np.linalg.matrix_power(P, A_exponent)
B = np.linalg.matrix_power(P, B_exponent)
weights = np.zeros(nstates)
for k in range(nstates):
weights[k] = A[fs.nmutants_initial, k] * B[k, fs.nmutants_final]
weights /= np.sum(weights)
for k, p in enumerate(weights):
M[k, i+1] = p
arr = []
for g in range(fs.ngenerations):
for k in range(nstates):
p = M[k, g]
if p:
logp = math.log(p)
else:
logp = float('-inf')
row = [g, k, p, logp]
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# legend labels
label_a = 'N=%d mu=%f' % (fs.nstates_a, fs.mu_a)
label_b = 'N=%d mu=%f' % (fs.nstates_b, fs.mu_b)
arr, headers = make_table(fs)
# compute the max value
ymax = math.log(max(fs.nstates_a, fs.nstates_b))
nfifths = int(math.floor(ymax * 5.0)) + 1
ylim = RUtil.mk_call_str('c', 0, 0.2 * nfifths)
# write the R script body
out = StringIO()
print >> out, RUtil.mk_call_str(
'plot',
'my.table$t',
'my.table$alpha',
type='"n"',
ylim=ylim,
xlab='"time"',
ylab='"information"',
main='"comparison of an information criterion for two processes"',
)
# draw some horizontal lines
for i in range(nfifths+1):
print >> out, RUtil.mk_call_str(
'abline',
h=0.2*i,
col='"lightgray"',
lty='"dotted"')
colors = ('darkblue', 'darkred')
for c, header in zip(colors, headers[1:]):
print >> out, RUtil.mk_call_str(
'lines',
'my.table$t',
'my.table$%s' % header,
col='"%s"' % c,
)
legend_names = (label_a, label_b)
legend_name_str = 'c(' + ', '.join('"%s"' % s for s in legend_names) + ')'
legend_col_str = 'c(' + ', '.join('"%s"' % s for s in colors) + ')'
legend_lty_str = 'c(' + ', '.join('1' for s in colors) + ')'
print >> out, RUtil.mk_call_str(
'legend',
'"%s"' % fs.legend_placement,
legend_name_str,
col=legend_col_str,
lty=legend_lty_str,
)
script_body = out.getvalue()
# create the R plot image
table_string = RUtil.get_table_string(arr, headers)
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script_body, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
distn_modes = [x for x in g_ordered_modes if x in fs.distribution]
if not distn_modes:
raise ValueError('no distribution mode was specified')
colors = [g_mode_to_color[m] for m in distn_modes]
arr, headers = make_table(fs, distn_modes)
distn_headers = headers[1:]
# Get the largest value in the array,
# skipping the first column.
arrmax = np.max(arr[:, 1:])
# write the R script body
out = StringIO()
ylim = RUtil.mk_call_str('c', 0, arrmax + 0.1)
sel_str = {
BALANCED: 'balanced',
HALPERN_BRUNO: 'Halpern-Bruno',
}[fs.selection]
print >> out, RUtil.mk_call_str(
'plot',
'my.table$t',
'my.table$%s' % distn_headers[0],
type='"n"',
ylim=ylim,
xlab='""',
ylab='"relaxation time"',
main='"Effect of selection (%s) on relaxation time for %d states"' %
(sel_str, fs.nstates),
)
for c, header in zip(colors, distn_headers):
print >> out, RUtil.mk_call_str(
'lines',
'my.table$t',
'my.table$%s' % header,
col='"%s"' % c,
)
mode_names = [s.replace('_', ' ') for s in distn_modes]
legend_name_str = 'c(' + ', '.join('"%s"' % s for s in mode_names) + ')'
legend_col_str = 'c(' + ', '.join('"%s"' % s for s in colors) + ')'
legend_lty_str = 'c(' + ', '.join(['1'] * len(distn_modes)) + ')'
print >> out, RUtil.mk_call_str(
'legend',
'"%s"' % fs.legend_placement,
legend_name_str,
col=legend_col_str,
lty=legend_lty_str,
)
script_body = out.getvalue()
# create the R plot image
table_string = RUtil.get_table_string(arr, headers)
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script_body, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
f_info = divtime.get_fisher_info_known_distn_fast
requested_triples = []
for triple in g_process_triples:
name, desc, zoo_obj = triple
if getattr(fs, name):
requested_triples.append(triple)
if not requested_triples:
raise ValueError('nothing to plot')
# define the R table headers
r_names = [a.replace('_', '.') for a, b, c in requested_triples]
headers = ['t'] + r_names
# Spend a lot of time doing the optimizations
# to construct the points for the R table.
arr = []
for t in cbreaker.throttled(
progrid.gen_binary(fs.start_time, fs.stop_time),
nseconds=5, ncount=200):
row = [t]
for python_name, desc, zoo_class in requested_triples:
zoo_obj = zoo_class(fs.d)
df = zoo_obj.get_df()
opt_dep = OptDep(zoo_obj, t, f_info)
if df:
X0 = np.random.randn(df)
xopt = scipy.optimize.fmin(
opt_dep, X0, maxiter=10000, maxfun=10000)
# I would like to use scipy.optimize.minimize
# except that this requires a newer version of
# scipy than is packaged for ubuntu right now.
# fmin_bfgs seems to have problems sometimes
# either hanging or maxiter=10K is too big.
"""
xopt = scipy.optimize.fmin_bfgs(opt_dep, X0,
gtol=1e-8, maxiter=10000)
"""
else:
xopt = np.array([])
info_value = -opt_dep(xopt)
row.append(info_value)
arr.append(row)
arr.sort()
npoints = len(arr)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# legend labels
label_a = 'N=%d mu=%f' % (fs.nstates_a, fs.mu_a)
label_b = 'N=%d mu=%f' % (fs.nstates_b, fs.mu_b)
arr, headers = make_table(fs)
# compute the max value
ymax = math.log(max(fs.nstates_a, fs.nstates_b))
nfifths = int(math.floor(ymax * 5.0)) + 1
ylim = RUtil.mk_call_str('c', 0, 0.2 * nfifths)
# write the R script body
out = StringIO()
print >> out, RUtil.mk_call_str(
'plot',
'my.table$t',
'my.table$alpha',
type='"n"',
ylim=ylim,
xlab='"time"',
ylab='"information"',
main='"comparison of an information criterion for two processes"',
)
# draw some horizontal lines
for i in range(nfifths + 1):
print >> out, RUtil.mk_call_str('abline',
h=0.2 * i,
col='"lightgray"',
lty='"dotted"')
colors = ('darkblue', 'darkred')
for c, header in zip(colors, headers[1:]):
print >> out, RUtil.mk_call_str(
'lines',
'my.table$t',
'my.table$%s' % header,
col='"%s"' % c,
)
legend_names = (label_a, label_b)
legend_name_str = 'c(' + ', '.join('"%s"' % s for s in legend_names) + ')'
legend_col_str = 'c(' + ', '.join('"%s"' % s for s in colors) + ')'
legend_lty_str = 'c(' + ', '.join('1' for s in colors) + ')'
print >> out, RUtil.mk_call_str(
'legend',
'"%s"' % fs.legend_placement,
legend_name_str,
col=legend_col_str,
lty=legend_lty_str,
)
script_body = out.getvalue()
# create the R plot image
table_string = RUtil.get_table_string(arr, headers)
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script_body, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
distn_modes = [x for x in g_ordered_modes if x in fs.distribution]
if not distn_modes:
raise ValueError('no distribution mode was specified')
colors = [g_mode_to_color[m] for m in distn_modes]
arr, headers = make_table(fs, distn_modes)
distn_headers = headers[1:]
# Get the largest value in the array,
# skipping the first column.
arrmax = np.max(arr[:,1:])
# write the R script body
out = StringIO()
ylim = RUtil.mk_call_str('c', 0, arrmax + 0.1)
sel_str = {
BALANCED : 'balanced',
HALPERN_BRUNO : 'Halpern-Bruno',
}[fs.selection]
print >> out, RUtil.mk_call_str(
'plot',
'my.table$t',
'my.table$%s' % distn_headers[0],
type='"n"',
ylim=ylim,
xlab='""',
ylab='"relaxation time"',
main='"Effect of selection (%s) on relaxation time for %d states"' % (sel_str, fs.nstates),
)
for c, header in zip(colors, distn_headers):
print >> out, RUtil.mk_call_str(
'lines',
'my.table$t',
'my.table$%s' % header,
col='"%s"' % c,
)
mode_names = [s.replace('_', ' ') for s in distn_modes]
legend_name_str = 'c(' + ', '.join('"%s"' % s for s in mode_names) + ')'
legend_col_str = 'c(' + ', '.join('"%s"' % s for s in colors) + ')'
legend_lty_str = 'c(' + ', '.join(['1']*len(distn_modes)) + ')'
print >> out, RUtil.mk_call_str(
'legend',
'"%s"' % fs.legend_placement,
legend_name_str,
col=legend_col_str,
lty=legend_lty_str,
)
script_body = out.getvalue()
# create the R plot image
table_string = RUtil.get_table_string(arr, headers)
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script_body, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_latex_documentbody(fs):
"""
This is obsolete.
"""
out = StringIO()
table_string, scripts = get_table_string_and_scripts(fs)
for script in scripts:
retcode, r_out, r_err, tikz_code = RUtil.run_plotter(table_string, script, "tikz", width=5, height=5)
if retcode:
raise RUtil.RError(r_err)
print >> out, tikz_code
return out.getvalue()
def main(args):
# check args
if gmpy.popcount(args.ntiles) != 1:
raise ValueError('the number of tiles should be a power of two')
# set up the logger
f = logging.getLogger('toplevel.logger')
h = logging.StreamHandler()
h.setFormatter(logging.Formatter('%(message)s %(asctime)s'))
f.addHandler(h)
if args.verbose:
f.setLevel(logging.DEBUG)
else:
f.setLevel(logging.WARNING)
f.info('(local) read the xml contents')
if args.infile is None:
xmldata = sys.stdin.read()
else:
with open(args.infile) as fin:
xmldata = fin.read()
f.info('(local) modify the log filename and chain length xml contents')
xmldata = beast.set_nsamples(xmldata, args.mcmc_id, args.nsamples)
xmldata = beast.set_log_filename(xmldata, args.log_id, args.log_filename)
xmldata = beast.set_log_logevery(xmldata, args.log_id, args.log_logevery)
f.info('(local) define the hierarchically nested intervals')
start_stop_pairs = tuple(
(a + 1, b) for a, b in beasttiling.gen_hierarchical_slices(
args.tile_width, args.offset, args.tile_width * args.ntiles))
f.info('(local) run BEAST serially locally and build the R stuff')
table_string, full_table_string, scripts = get_table_strings_and_scripts(
xmldata, args.alignment_id, start_stop_pairs, args.nsamples)
if args.full_table_out:
f.info('(local) create the verbose R table')
with open(args.full_table_out, 'w') as fout:
fout.write(full_table_string)
f.info('(local) create the composite R script')
out = StringIO()
print >> out, 'library(ggplot2)'
print >> out, 'par(mfrow=c(3,1))'
for script in scripts:
print >> out, script
comboscript = out.getvalue()
f.info('(local) run R to create the pdf')
device_name = Form.g_imageformat_to_r_function['pdf']
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name, keep_intermediate=True)
if retcode:
raise RUtil.RError(r_err)
f.info('(local) write the .pdf file')
with open(args.outfile, 'wb') as fout:
fout.write(image_data)
f.info('(local) return from toplevel')
def main(args):
# check args
if gmpy.popcount(args.ntiles) != 1:
raise ValueError('the number of tiles should be a power of two')
# set up the logger
f = logging.getLogger('toplevel.logger')
h = logging.StreamHandler()
h.setFormatter(logging.Formatter('%(message)s %(asctime)s'))
f.addHandler(h)
if args.verbose:
f.setLevel(logging.DEBUG)
else:
f.setLevel(logging.WARNING)
f.info('(local) read the xml contents')
if args.infile is None:
xmldata = sys.stdin.read()
else:
with open(args.infile) as fin:
xmldata = fin.read()
f.info('(local) modify the log filename and chain length xml contents')
xmldata = beast.set_nsamples(xmldata, args.mcmc_id, args.nsamples)
xmldata = beast.set_log_filename(xmldata, args.log_id, args.log_filename)
xmldata = beast.set_log_logevery(xmldata, args.log_id, args.log_logevery)
f.info('(local) define the hierarchically nested intervals')
start_stop_pairs = tuple(
(a+1,b) for a, b in beasttiling.gen_hierarchical_slices(
args.tile_width, args.offset, args.tile_width * args.ntiles))
f.info('(local) run BEAST serially locally and build the R stuff')
table_string, full_table_string, scripts = get_table_strings_and_scripts(
xmldata, args.alignment_id, start_stop_pairs, args.nsamples)
if args.full_table_out:
f.info('(local) create the verbose R table')
with open(args.full_table_out, 'w') as fout:
fout.write(full_table_string)
f.info('(local) create the composite R script')
out = StringIO()
print >> out, 'library(ggplot2)'
print >> out, 'par(mfrow=c(3,1))'
for script in scripts:
print >> out, script
comboscript = out.getvalue()
f.info('(local) run R to create the pdf')
device_name = Form.g_imageformat_to_r_function['pdf']
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name, keep_intermediate=True)
if retcode:
raise RUtil.RError(r_err)
f.info('(local) write the .pdf file')
with open(args.outfile, 'wb') as fout:
fout.write(image_data)
f.info('(local) return from toplevel')
def get_latex_documentbody(fs):
"""
This is obsolete.
"""
out = StringIO()
table_string, scripts = get_table_string_and_scripts(fs)
for script in scripts:
retcode, r_out, r_err, tikz_code = RUtil.run_plotter(
table_string, script, 'tikz',
width=5, height=5)
if retcode:
raise RUtil.RError(r_err)
print >> out, tikz_code
return out.getvalue()
def get_response_content(fs):
# get the table string and scripts
table_string, scripts = get_table_string_and_scripts(fs)
# create a comboscript
out = StringIO()
print >> out, "par(mfrow=c(3,1))"
for script in scripts:
print >> out, script
comboscript = out.getvalue()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(table_string, comboscript, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# get the table string and scripts
table_string, scripts = get_table_string_and_scripts(fs)
# create a comboscript
out = StringIO()
print >> out, 'par(mfrow=c(3,1))'
for script in scripts:
print >> out, script
comboscript = out.getvalue()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
f_info = ctmcmi.get_mutual_info_known_distn
requested_triples = []
for triple in g_process_triples:
name, desc, zoo_obj = triple
if getattr(fs, name):
requested_triples.append(triple)
if not requested_triples:
raise ValueError('nothing to plot')
# define the R table headers
headers = ['t']
if fs.log4:
headers.append('log.4')
if fs.log3:
headers.append('log.3')
r_names = [a.replace('_', '.') for a, b, c in requested_triples]
headers.extend(r_names)
# Spend a lot of time doing the optimizations
# to construct the points for the R table.
times = np.linspace(fs.start_time, fs.stop_time, 101)
arr = []
for t in times:
row = [t]
if fs.log4:
row.append(math.log(4))
if fs.log3:
row.append(math.log(3))
for python_name, desc, zoo_obj in requested_triples:
X = np.array([])
info_value = f_info(
zoo_obj.get_rate_matrix(X),
zoo_obj.get_distn(X),
t)
row.append(info_value)
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
Q_mut, Q_sels = get_qmut_qsels(fs)
# compute the statistics
ER_ratios, NSR_ratios, ER_NSR_ratios = get_statistic_ratios(Q_mut, Q_sels)
M = zip(*(ER_ratios, NSR_ratios, ER_NSR_ratios))
column_headers = ('ER.ratio', 'NSR.ratio', 'ER.times.NSR.ratio')
table_string = RUtil.get_table_string(M, column_headers)
nsels = len(Q_sels)
# get the R script
comboscript = get_r_comboscript(nsels, column_headers)
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
Q_mut, Q_sels = get_qmut_qsels(fs)
# compute the statistics
ER_ratios, NSR_ratios, ER_NSR_ratios = get_statistic_ratios(Q_mut, Q_sels)
M = zip(*(ER_ratios, NSR_ratios, ER_NSR_ratios))
column_headers = ('ER.ratio', 'NSR.ratio', 'ER.times.NSR.ratio')
table_string = RUtil.get_table_string(M, column_headers)
nsels = len(Q_sels)
# get the R script
comboscript = get_r_comboscript(nsels, column_headers)
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
f_info = ctmcmi.get_mutual_info_known_distn
requested_triples = []
for triple in g_process_triples:
name, desc, zoo_obj = triple
if getattr(fs, name):
requested_triples.append(triple)
if not requested_triples:
raise ValueError('nothing to plot')
# define the R table headers
headers = ['t']
if fs.log4:
headers.append('log.4')
if fs.log3:
headers.append('log.3')
r_names = [a.replace('_', '.') for a, b, c in requested_triples]
headers.extend(r_names)
# Spend a lot of time doing the optimizations
# to construct the points for the R table.
times = np.linspace(fs.start_time, fs.stop_time, 101)
arr = []
for t in times:
row = [t]
if fs.log4:
row.append(math.log(4))
if fs.log3:
row.append(math.log(3))
for python_name, desc, zoo_obj in requested_triples:
X = np.array([])
info_value = f_info(zoo_obj.get_rate_matrix(X),
zoo_obj.get_distn(X), t)
row.append(info_value)
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def main(args):
# set up the logger
f = logging.getLogger('toplevel.logger')
h = logging.StreamHandler()
h.setFormatter(logging.Formatter('%(message)s %(asctime)s'))
f.addHandler(h)
if args.verbose:
f.setLevel(logging.DEBUG)
else:
f.setLevel(logging.WARNING)
if args.run == 'hpc':
r = RemoteBeast(g_start_stop_pairs, args.nsamples)
f.info('run BEAST remotely')
r.run(verbose=args.verbose)
f.info('(local) build the R table string and scripts')
table_string, scripts = beasttut.get_table_string_and_scripts_from_logs(
g_start_stop_pairs, r.local_log_paths, args.nsamples)
elif args.run == 'serial':
f.info('(local) run BEAST serially locally and build the R stuff')
table_string, scripts = beasttut.get_table_string_and_scripts(
g_start_stop_pairs, args.nsamples)
elif args.run == 'parallel':
f.info('(local) run BEAST locally in parallel and build the R stuff')
table_string, scripts = beasttut.get_table_string_and_scripts_par(
g_start_stop_pairs, args.nsamples)
else:
raise ValueError('invalid execution model')
f.info('(local) create the composite R script')
out = StringIO()
print >> out, 'library(ggplot2)'
print >> out, 'par(mfrow=c(3,1))'
for script in scripts:
print >> out, script
comboscript = out.getvalue()
f.info('(local) run R to create the pdf')
device_name = Form.g_imageformat_to_r_function['pdf']
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name, keep_intermediate=True)
if retcode:
raise RUtil.RError(r_err)
f.info('(local) write the .pdf file')
with open(args.outfile, 'wb') as fout:
fout.write(image_data)
f.info('(local) return from toplevel')
def main(args):
# set up the logger
f = logging.getLogger("toplevel.logger")
h = logging.StreamHandler()
h.setFormatter(logging.Formatter("%(message)s %(asctime)s"))
f.addHandler(h)
if args.verbose:
f.setLevel(logging.DEBUG)
else:
f.setLevel(logging.WARNING)
if args.run == "hpc":
adapter = Adapter(g_start_stop_pairs, args.nsamples)
r = hpcutil.RemoteBrc(adapter)
f.info("run BEAST remotely")
r.run(verbose=args.verbose)
f.info("(local) build the R table string and scripts")
table_string, scripts = beasttut.get_table_string_and_scripts_from_logs(
g_start_stop_pairs, adapter.local_log_paths, args.nsamples
)
elif args.run == "serial":
f.info("(local) run BEAST serially locally and build the R stuff")
table_string, scripts = beasttut.get_table_string_and_scripts(g_start_stop_pairs, args.nsamples)
elif args.run == "parallel":
f.info("(local) run BEAST locally in parallel and build the R stuff")
table_string, scripts = beasttut.get_table_string_and_scripts_par(g_start_stop_pairs, args.nsamples)
else:
raise ValueError("invalid execution model")
f.info("(local) create the composite R script")
out = StringIO()
print >> out, "library(ggplot2)"
print >> out, "par(mfrow=c(3,1))"
for script in scripts:
print >> out, script
comboscript = out.getvalue()
f.info("(local) run R to create the pdf")
device_name = Form.g_imageformat_to_r_function["pdf"]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name, keep_intermediate=True
)
if retcode:
raise RUtil.RError(r_err)
f.info("(local) write the .pdf file")
with open(args.outfile, "wb") as fout:
fout.write(image_data)
f.info("(local) return from toplevel")
def main(args):
# set up the logger
f = logging.getLogger('toplevel.logger')
h = logging.StreamHandler()
h.setFormatter(logging.Formatter('%(message)s %(asctime)s'))
f.addHandler(h)
if args.verbose:
f.setLevel(logging.DEBUG)
else:
f.setLevel(logging.WARNING)
if args.run == 'hpc':
r = RemoteBeast(g_start_stop_pairs, args.nsamples)
f.info('run BEAST remotely')
r.run(verbose=args.verbose)
f.info('(local) build the R table string and scripts')
table_string, scripts = beasttut.get_table_string_and_scripts_from_logs(
g_start_stop_pairs, r.local_log_paths, args.nsamples)
elif args.run == 'serial':
f.info('(local) run BEAST serially locally and build the R stuff')
table_string, scripts = beasttut.get_table_string_and_scripts(
g_start_stop_pairs, args.nsamples)
elif args.run == 'parallel':
f.info('(local) run BEAST locally in parallel and build the R stuff')
table_string, scripts = beasttut.get_table_string_and_scripts_par(
g_start_stop_pairs, args.nsamples)
else:
raise ValueError('invalid execution model')
f.info('(local) create the composite R script')
out = StringIO()
print >> out, 'library(ggplot2)'
print >> out, 'par(mfrow=c(3,1))'
for script in scripts:
print >> out, script
comboscript = out.getvalue()
f.info('(local) run R to create the pdf')
device_name = Form.g_imageformat_to_r_function['pdf']
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, comboscript, device_name, keep_intermediate=True)
if retcode:
raise RUtil.RError(r_err)
f.info('(local) write the .pdf file')
with open(args.outfile, 'wb') as fout:
fout.write(image_data)
f.info('(local) return from toplevel')
def get_response_content(fs):
# create the R table string and scripts
headers = [
'entropy',
'analog']
distributions = []
nstates = 4
npoints = 5000
arr = []
best_pair = None
for i in range(npoints):
weights = [random.expovariate(1) for j in range(nstates)]
total = sum(weights)
distn = [x / total for x in weights]
entropy = -sum(p * math.log(p) for p in distn)
sum_squares = sum(p*p for p in distn)
sum_cubes = sum(p*p*p for p in distn)
analog = math.log(sum_squares / sum_cubes)
row = [entropy, analog]
arr.append(row)
dist = (entropy - 1.0)**2 + (analog - 0.4)**2
if (best_pair is None) or (dist < best_pair[0]):
best_pair = (dist, distn)
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
out = StringIO()
title = ', '.join(str(x) for x in best_pair[1])
print >> out, RUtil.mk_call_str(
'plot',
'my.table$entropy',
'my.table$analog',
pch='20',
main='"%s"' % title)
script = out.getvalue()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
distn_modes = [x for x in g_ordered_modes if x in fs.distribution]
if not distn_modes:
raise ValueError("no distribution mode was specified")
colors = [g_mode_to_color[m] for m in distn_modes]
arr, headers = make_table(fs, distn_modes)
distn_headers = headers[1:]
# Get the largest value in the array,
# skipping the first column.
arrmax = np.max(arr[:, 1:])
# write the R script body
out = StringIO()
ylim = RUtil.mk_call_str("c", 0, arrmax + 0.1)
sel_str = {BALANCED: "f=1/2", HALPERN_BRUNO: "Halpern-Bruno"}[fs.selection]
print >> out, RUtil.mk_call_str(
"plot",
"my.table$t",
"my.table$%s" % distn_headers[0],
type='"n"',
ylim=ylim,
xlab='"time"',
ylab='"expected log L-ratio"',
main='"Effect of selection (%s) on log L-ratio for %d states"' % (sel_str, fs.nstates),
)
for c, header in zip(colors, distn_headers):
print >> out, RUtil.mk_call_str("lines", "my.table$t", "my.table$%s" % header, col='"%s"' % c)
mode_names = [s.replace("_", " ") for s in distn_modes]
legend_name_str = "c(" + ", ".join('"%s"' % s for s in mode_names) + ")"
legend_col_str = "c(" + ", ".join('"%s"' % s for s in colors) + ")"
legend_lty_str = "c(" + ", ".join(["1"] * len(distn_modes)) + ")"
print >> out, RUtil.mk_call_str(
"legend", '"%s"' % fs.legend_placement, legend_name_str, col=legend_col_str, lty=legend_lty_str
)
script_body = out.getvalue()
# create the R plot image
table_string = RUtil.get_table_string(arr, headers)
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(table_string, script_body, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# create the R table string and scripts
headers = ['entropy', 'analog']
distributions = []
nstates = 4
npoints = 5000
arr = []
best_pair = None
for i in range(npoints):
weights = [random.expovariate(1) for j in range(nstates)]
total = sum(weights)
distn = [x / total for x in weights]
entropy = -sum(p * math.log(p) for p in distn)
sum_squares = sum(p * p for p in distn)
sum_cubes = sum(p * p * p for p in distn)
analog = math.log(sum_squares / sum_cubes)
row = [entropy, analog]
arr.append(row)
dist = (entropy - 1.0)**2 + (analog - 0.4)**2
if (best_pair is None) or (dist < best_pair[0]):
best_pair = (dist, distn)
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
out = StringIO()
title = ', '.join(str(x) for x in best_pair[1])
print >> out, RUtil.mk_call_str('plot',
'my.table$entropy',
'my.table$analog',
pch='20',
main='"%s"' % title)
script = out.getvalue()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# create the R table string and scripts
headers = [
'z',
'c.neg2.0',
'c.neg0.5',
'c.0.5',
'c.2.0',
#'c.a',
#'c.b',
#'c.c',
#'c.d',
]
#C = numpy.array([-0.5, -0.2, 0.2, 0.5], dtype=float)
#C = numpy.array([-1.0, -0.4, 0.4, 1.0], dtype=float)
C = numpy.array([-2.0, -0.5, 0.5, 2.0], dtype=float)
Z = numpy.linspace(-5, 5, 101)
# get the data for the R table
arr = []
for z in Z:
row = [z]
for c in C:
rate = 1.0 / kimrecessive.denom_piecewise(c, z*numpy.sign(c))
row.append(rate)
arr.append(row)
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# create the R table string and scripts
headers = [
'z',
'c.neg2.0',
'c.neg0.5',
'c.0.5',
'c.2.0',
#'c.a',
#'c.b',
#'c.c',
#'c.d',
]
#C = numpy.array([-0.5, -0.2, 0.2, 0.5], dtype=float)
#C = numpy.array([-1.0, -0.4, 0.4, 1.0], dtype=float)
C = numpy.array([-2.0, -0.5, 0.5, 2.0], dtype=float)
Z = numpy.linspace(-5, 5, 101)
# get the data for the R table
arr = []
for z in Z:
row = [z]
for c in C:
rate = 1.0 / kimrecessive.denom_piecewise(c, z * numpy.sign(c))
row.append(rate)
arr.append(row)
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# transform the arguments according to the diffusion approximation
mutation_ab = (fs.pop * fs.mutation_ab) / fs.pop_gran
mutation_ba = (fs.pop * fs.mutation_ba) / fs.pop_gran
if mutation_ab > 1 or mutation_ba > 1:
raise Exception('the mutation probability is not small enough '
'for the diffusion approximation to be meaningful')
selection_ratio = 1 + (fs.pop * fs.additive_selection) / fs.pop_gran
npop = fs.pop_gran
ngenerations = fs.ngenerations
nmutants_initial = int(fs.initial_freq * fs.pop_gran)
nmutants_final = int(fs.final_freq * fs.pop_gran)
# precompute some transition matrices
P_drift_selection = pgmsinglesite.create_drift_selection_transition_matrix(
npop, selection_ratio)
MatrixUtil.assert_transition_matrix(P_drift_selection)
P_mutation = pgmsinglesite.create_mutation_transition_matrix(
npop, mutation_ab, mutation_ba)
MatrixUtil.assert_transition_matrix(P_mutation)
# define the R table headers
headers = [
'generation',
'allele.frequency',
'probability',
'log.density',
]
# compute the transition matrix
P = np.dot(P_drift_selection, P_mutation)
# Compute the endpoint conditional probabilities for various states
# along the unobserved path.
nstates = npop + 1
M = np.zeros((nstates, ngenerations))
M[nmutants_initial, 0] = 1.0
M[nmutants_final, ngenerations - 1] = 1.0
for i in range(ngenerations - 2):
A_exponent = i + 1
B_exponent = ngenerations - 1 - A_exponent
A = np.linalg.matrix_power(P, A_exponent)
B = np.linalg.matrix_power(P, B_exponent)
weights = np.zeros(nstates)
for k in range(nstates):
weights[k] = A[nmutants_initial, k] * B[k, nmutants_final]
weights /= np.sum(weights)
for k, p in enumerate(weights):
M[k, i + 1] = p
arr = []
for g in range(ngenerations):
for k in range(nstates):
p = M[k, g]
allele_frequency = k / float(npop)
# Finer gridding needs larger scaling for the density
# because each interval has a smaller support.
density = p * nstates
if density:
log_density = math.log(density)
else:
log_density = float('-inf')
row = [g, allele_frequency, p, log_density]
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot(nstates)
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
# transform the arguments according to the diffusion approximation
mutation_ab = (fs.pop * fs.mutation_ab) / fs.pop_gran
mutation_ba = (fs.pop * fs.mutation_ba) / fs.pop_gran
if mutation_ab > 1 or mutation_ba > 1:
raise Exception(
'the mutation probability is not small enough '
'for the diffusion approximation to be meaningful')
selection_ratio = 1 + (fs.pop * fs.additive_selection) / fs.pop_gran
npop = fs.pop_gran
ngenerations = fs.ngenerations
nmutants_initial = int(fs.initial_freq * fs.pop_gran)
nmutants_final = int(fs.final_freq * fs.pop_gran)
# precompute some transition matrices
P_drift_selection = pgmsinglesite.create_drift_selection_transition_matrix(
npop, selection_ratio)
MatrixUtil.assert_transition_matrix(P_drift_selection)
P_mutation = pgmsinglesite.create_mutation_transition_matrix(
npop, mutation_ab, mutation_ba)
MatrixUtil.assert_transition_matrix(P_mutation)
# define the R table headers
headers = [
'generation',
'allele.frequency',
'probability',
'log.density',
]
# compute the transition matrix
P = np.dot(P_drift_selection, P_mutation)
# Compute the endpoint conditional probabilities for various states
# along the unobserved path.
nstates = npop + 1
M = np.zeros((nstates, ngenerations))
M[nmutants_initial, 0] = 1.0
M[nmutants_final, ngenerations-1] = 1.0
for i in range(ngenerations-2):
A_exponent = i + 1
B_exponent = ngenerations - 1 - A_exponent
A = np.linalg.matrix_power(P, A_exponent)
B = np.linalg.matrix_power(P, B_exponent)
weights = np.zeros(nstates)
for k in range(nstates):
weights[k] = A[nmutants_initial, k] * B[k, nmutants_final]
weights /= np.sum(weights)
for k, p in enumerate(weights):
M[k, i+1] = p
arr = []
for g in range(ngenerations):
for k in range(nstates):
p = M[k, g]
allele_frequency = k / float(npop)
# Finer gridding needs larger scaling for the density
# because each interval has a smaller support.
density = p * nstates
if density:
log_density = math.log(density)
else:
log_density = float('-inf')
row = [g, allele_frequency, p, log_density]
arr.append(row)
# create the R table string and scripts
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot(nstates)
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
M = get_input_matrix(fs)
nstates = len(M)
nsites = fs.nsites
if nstates**nsites > 16:
raise ValueError('the site dependent rate matrix is too big')
# precompute some stuff
M_site_indep = get_site_independent_process(M, nsites)
v = mrate.R_to_distn(M)
v_site_indep = get_site_independent_distn(v, nsites)
if fs.info_fis:
f_info = divtime.get_fisher_info_known_distn_fast
elif fs.info_mut:
f_info = ctmcmi.get_mutual_info_known_distn
else:
raise ValueError('no info type specified')
f_selection = mrate.to_gtr_hb_known_energies
# Spend a lot of time doing the optimizations
# to construct the points for the R table.
arr = []
for t in cbreaker.throttled(progrid.gen_binary(fs.start_time,
fs.stop_time),
nseconds=4,
ncount=100):
row = [t]
# get the site-dependent mutation selection balance information
if fs.dep_balance:
dep_balance = OptDep(M_site_indep, v_site_indep, t, f_info,
f_selection)
X0 = np.random.randn(nstates**nsites - 1)
xopt = scipy.optimize.fmin(dep_balance, X0)
max_dep_balance_info = -dep_balance(xopt)
row.append(max_dep_balance_info)
# for debug
Q_bal, v_bal = dep_balance.get_process(xopt)
print 'dependent balance:'
print max_dep_balance_info
print v_bal
print Q_bal
print
# get the site-independent mutation selection balance information
if fs.indep_balance:
indep_balance = OptIndep(M, v, nsites, t, f_info, f_selection)
X0 = np.random.randn(nstates - 1)
xopt = scipy.optimize.fmin(indep_balance, X0)
max_indep_balance_info = -indep_balance(xopt)
row.append(max_indep_balance_info)
# for debug
Q_bal, v_bal = indep_balance.get_process(xopt)
print 'independent balance:'
print max_indep_balance_info
print v_bal
print Q_bal
print
# get the site-independent mutation process information
if fs.indep_mutation:
indep_mut_info = f_info(M_site_indep, v_site_indep, t)
row.append(indep_mut_info)
# add the data row to the table
arr.append(row)
arr.sort()
npoints = len(arr)
# create the R table string and scripts
headers = ['t']
if fs.dep_balance:
headers.append('max.site.dep.balance')
if fs.indep_balance:
headers.append('max.site.indep.balance')
if fs.indep_mutation:
headers.append('site.indep.mutation')
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
M = get_input_matrix(fs)
nstates = len(M)
nsites = fs.nsites
if nstates ** nsites > 16:
raise ValueError('the site dependent rate matrix is too big')
# precompute some stuff
M_site_indep = get_site_independent_process(M, nsites)
v = mrate.R_to_distn(M)
v_site_indep = get_site_independent_distn(v, nsites)
if fs.info_fis:
f_info = divtime.get_fisher_info_known_distn_fast
elif fs.info_mut:
f_info = ctmcmi.get_mutual_info_known_distn
else:
raise ValueError('no info type specified')
f_selection = mrate.to_gtr_hb_known_energies
# Spend a lot of time doing the optimizations
# to construct the points for the R table.
arr = []
for t in cbreaker.throttled(
progrid.gen_binary(fs.start_time, fs.stop_time),
nseconds=4, ncount=100):
row = [t]
# get the site-dependent mutation selection balance information
if fs.dep_balance:
dep_balance = OptDep(
M_site_indep, v_site_indep, t, f_info, f_selection)
X0 = np.random.randn(nstates ** nsites - 1)
xopt = scipy.optimize.fmin(dep_balance, X0)
max_dep_balance_info = -dep_balance(xopt)
row.append(max_dep_balance_info)
# for debug
Q_bal, v_bal = dep_balance.get_process(xopt)
print 'dependent balance:'
print max_dep_balance_info
print v_bal
print Q_bal
print
# get the site-independent mutation selection balance information
if fs.indep_balance:
indep_balance = OptIndep(
M, v, nsites, t, f_info, f_selection)
X0 = np.random.randn(nstates-1)
xopt = scipy.optimize.fmin(indep_balance, X0)
max_indep_balance_info = -indep_balance(xopt)
row.append(max_indep_balance_info)
# for debug
Q_bal, v_bal = indep_balance.get_process(xopt)
print 'independent balance:'
print max_indep_balance_info
print v_bal
print Q_bal
print
# get the site-independent mutation process information
if fs.indep_mutation:
indep_mut_info = f_info(M_site_indep, v_site_indep, t)
row.append(indep_mut_info)
# add the data row to the table
arr.append(row)
arr.sort()
npoints = len(arr)
# create the R table string and scripts
headers = ['t']
if fs.dep_balance:
headers.append('max.site.dep.balance')
if fs.indep_balance:
headers.append('max.site.indep.balance')
if fs.indep_mutation:
headers.append('site.indep.mutation')
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
def get_response_content(fs):
M = get_input_matrix(fs)
# create the R table string and scripts
headers = ['t']
if fs.show_entropy:
headers.append('ub.entropy')
headers.extend([
'ub.jc.spectral',
'ub.f81.spectral',
'mutual.information',
'lb.2.state.spectral',
'lb.2.state',
'lb.f81',
])
npoints = 100
t_low = fs.start_time
t_high = fs.stop_time
t_incr = (t_high - t_low) / (npoints - 1)
t_values = [t_low + t_incr*i for i in range(npoints)]
# define some extra stuff
v = mrate.R_to_distn(M)
entropy = -np.dot(v, np.log(v))
n = len(M)
gap = sorted(abs(x) for x in np.linalg.eigvals(M))[1]
print 'stationary distn:', v
print 'entropy:', entropy
print 'spectral gap:', gap
M_slow_jc = gap * (1.0 / n) * (np.ones((n,n)) - n*np.eye(n))
M_slow_f81 = gap * np.outer(np.ones(n), v)
M_slow_f81 -= np.diag(np.sum(M_slow_f81, axis=1))
M_f81 = msimpl.get_fast_f81(M)
M_2state = msimpl.get_fast_two_state_autobarrier(M)
M_2state_spectral = -gap * M_2state / np.trace(M_2state)
# get the data for the R table
arr = []
for u in t_values:
# experiment with log time
#t = math.exp(u)
t = u
mi_slow_jc = ctmcmi.get_mutual_information(M_slow_jc, t)
mi_slow_f81 = ctmcmi.get_mutual_information(M_slow_f81, t)
mi_mut = ctmcmi.get_mutual_information(M, t)
mi_2state_spectral = ctmcmi.get_mutual_information(M_2state_spectral, t)
mi_f81 = ctmcmi.get_mutual_information(M_f81, t)
mi_2state = ctmcmi.get_mutual_information(M_2state, t)
row = [u]
if fs.show_entropy:
row.append(entropy)
row.extend([mi_slow_jc, mi_slow_f81,
mi_mut, mi_2state_spectral, mi_2state, mi_f81])
arr.append(row)
# get the R table
table_string = RUtil.get_table_string(arr, headers)
# get the R script
script = get_ggplot()
# create the R plot image
device_name = Form.g_imageformat_to_r_function[fs.imageformat]
retcode, r_out, r_err, image_data = RUtil.run_plotter(
table_string, script, device_name)
if retcode:
raise RUtil.RError(r_err)
return image_data
