def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) reps = len(sim_collections[0]._reps) reps_converged = [False for i in range(reps)] for rep in range(reps): for sim_collection in sim_collections: ops = sim_collection.get_reps_data('ops')[rep] stacked_pairs = ops['numstackedpairs'] fully_stacked = np.where( stacked_pairs == args.fully_stacked_pairs)[0] if len(fully_stacked) == 0: continue steps_since_fully_stacked = len(stacked_pairs) - fully_stacked[0] if steps_since_fully_stacked > args.prod_steps: reps_converged[rep] = True break if np.all(reps_converged): print(1) else: print(0)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) for sim_collection in sim_collections: for rep in sim_collection._reps: ops = sim_collection.get_reps_data('ops', concatenate=False) runs = len(ops[rep]) for run in range(runs): run_filebase = sim_collection.get_filebase(run, rep) states_filename = '{}.states'.format(run_filebase) states = np.loadtxt(states_filename)[:, :args.scaffold_domains] states = states == 2 ops = datatypes.OrderParams.from_file(run_filebase) for i in range(args.scaffold_domains): tag = 'domainstate{}'.format(i) if tag in ops.tags: ops[tag] = states[:, i] else: ops.add_column(tag, states[:, i]) ops.to_file(run_filebase)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) traj_file = files.TxtTrajInpFile(args.traj_filename, system_file) ref_ext = args.ref_filename.split('.')[-1] if ref_ext == 'json': ref_file = files.JSONStructInpFile(args.ref_filename) elif ref_ext == 'trj': ref_file = files.TxtTrajInpFile(args.ref_filename, system_file) ref_config = np.array(ref_file.chains(args.step)) ref_positions = config_process.center_on_origin(ref_config) aligned_positions, rmsds = config_process.align_positions( traj_file, ref_config) np.savetxt(args.outfile, rmsds)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) traj_file = files.TxtTrajInpFile(args.traj_filename, system_file) rgs = config_process.calc_radius_of_gyration(traj_file) np.savetxt(args.out_file, rgs)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) decor_outs = decorrelate.DecorrelatedOutputs(sim_collections, all_conditions) decor_outs.read_decors_from_files() mbarw = mbar_wrapper.MBARWrapper(decor_outs) mbarw.perform_mbar() out_filebase = create_output_filepathbase(args) tag_pairs = parse_tag_pairs(args.tag_pairs) for tag_pair in tag_pairs: mbarw.calc_2d_lfes(tag_pair[0], tag_pair[1], all_conditions, out_filebase) mbarw.calc_all_expectations(out_filebase) mbarw.calc_1d_lfes(all_conditions, out_filebase, xtag='bias') # Hacky shit all_tags = decor_outs.all_series_tags for tag in all_tags: if 'staplestates' in tag: mbarw.calc_2d_lfes(tag, 'numfullyboundstaples', all_conditions, out_filebase) if 'adj-d' in tag: mbarw.calc_2d_lfes(tag, 'dist-sum', all_conditions, out_filebase)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) tag = 'numfullyboundstaples' for sim_collection in sim_collections: staple_states = sim_collection.get_reps_data('staplestates', concatenate=False) for rep in sim_collection._reps: runs = len(staple_states[rep]) for run in range(runs): back_ops_filebase = sim_collection.get_filebase(run, rep) back_ops = datatypes.OrderParams.from_file(back_ops_filebase) total_staples = staple_states[rep][run]._data[1:, :].sum( axis=0) if tag in back_ops.tags: back_ops[tag] = total_staples else: back_ops.add_column(tag, total_staples) back_ops.to_file(back_ops_filebase)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) traj_file = files.TxtTrajInpFile(args.traj_filename, system_file) dists = config_process.calc_end_to_end_dists(traj_file) np.savetxt(args.out_file, dists)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) for sim_collection in sim_collections: ops_series_runs = sim_collection.get_reps_data('ops') filtered_steps = [] for ops_series in ops_series_runs: if ops_series == 0: continue for step in range(ops_series.steps): filter_step = True for tag, value in zip(args.tags, args.values): if ops_series[tag][step] != value: filter_step = False break filtered_steps.append(step) if filtered_steps != []: print(sim_collection.conditions.fileformat) print(filtered_steps)
def main(): args = parse_args() sys_inp_file = files.JSONStructInpFile(args.sys_filename) traj_file = files.TxtTrajInpFile(args.trj_filename, sys_inp_file) chains = traj_file.get_chains(args.step) sys_out_filename = '{}.json'.format(args.out_filebase) sys_out_file = files.JSONStructOutFile(sys_out_filename, sys_inp_file) sys_out_file.write(chains)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) inp_filebase = create_input_filepathbase(args) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, inp_filebase, system_file) staple_lengths = system_file._staple_lengths out_filebase = create_output_filepathbase(args) conds = conditions.SimConditions( { 'temp': args.temp, 'staple_m': args.staple_m, 'bias': biases.NoBias() }, fileformatter, staple_lengths) # Expecations along OP slices mbarws = [] all_decor_outs = [] sampled_ops = [] for i in range(1, args.assembled_op + 1): sim_collections = create_simplesim_collections(args, inp_filebase, all_conditions) decor_outs = decorrelate.SimpleDecorrelatedOutputs( sim_collections, all_conditions) decor_outs.read_decors_from_files() filtered_count = decor_outs.filter_collections(args.tag, i) if filtered_count == 0: continue sampled_ops.append(i) all_decor_outs.append(decor_outs) mbarw = mbar_wrapper.MBARWrapper(decor_outs) mbarw.perform_mbar() mbarws.append(mbarw) # Calculate expectations across selected order parameter all_tags = [] for i in range(1, args.staple_types + 1): all_tags.append('staples{}'.format(i)) all_tags.append('staplestates{}'.format(i)) for i in range(args.scaffold_domains): all_tags.append('domainstate{}'.format(i)) aves, stds = calc_reduced_expectations(conds, mbarws, all_decor_outs, all_tags) aves = np.concatenate([[sampled_ops], np.array(aves).T]) aves_file = files.TagOutFile('{}-{}.aves'.format(out_filebase, args.tag)) aves_file.write([args.tag] + all_tags, aves.T) stds = np.concatenate([[sampled_ops], np.array(stds).T]) stds_file = files.TagOutFile('{}-{}.stds'.format(out_filebase, args.tag)) stds_file.write([args.tag] + all_tags, stds.T)
def main(): args = parse_cl() origami = files.JSONStructInpFile(args.system_file) binding_h = [] binding_s = [] misbinding_h = [] misbinding_s = [] for chain_i in origami.sequences: for seq_i in chain_i: seq_i_revcomp = nn.calc_complementary_sequence(seq_i)[::-1] for chain_j in origami.sequences: for seq_j in chain_j: if seq_i_revcomp == seq_j: h, s = nn.calc_hybridization_enthalpy_and_entropy( seq_i, args.cation_M) binding_h.append(nn.remove_energy_units(h)) binding_s.append(nn.remove_energy_units(s)) else: seqs = nn.find_longest_contig_complement(seq_i, seq_j) seqs_h = [] seqs_s = [] for seq in seqs: h, s = nn.calc_hybridization_enthalpy_and_entropy( seq, args.cation_M) seqs_h.append(h) seqs_s.append(s) if len(seqs) == 0: misbinding_h.append(0) misbinding_s.append(0) else: misbinding_h.append( nn.remove_energy_units(np.mean(seqs_h))) misbinding_s.append( nn.remove_energy_units(np.mean(seqs_s))) sbinding_h = [] sbinding_s = [] for staple in origami.sequences[1:]: seq = '' for s in staple: seq += s h, s = nn.calc_hybridization_enthalpy_and_entropy(seq, args.cation_M) sbinding_h.append(nn.remove_energy_units(h)) sbinding_s.append(nn.remove_energy_units(s)) print('Average bound domain hybridization enthalpy: ', np.mean(binding_h)) print('Average bound domain hybridization entropy: ', np.mean(binding_s)) print('Average misbound domain hybridization enthalpy: ', np.mean(misbinding_h)) print('Average misbound domain hybridization entropy: ', np.mean(misbinding_s)) print('Average staple hybridization enthalpy: ', np.mean(sbinding_h)) print('Average staple domain hybridization entropy: ', np.mean(sbinding_s))
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) conditions_map = construct_conditions_map(args) fileformatter = construct_fileformatter() all_conditions = conditions.AllSimConditions( conditions_map, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) enums = outputs.EnumCollection(inp_filebase, all_conditions) out_filebase = create_output_filepathbase(args) enums.calc_all_1d_means(out_filebase)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) decor_outs = decorrelate.DecorrelatedOutputs(sim_collections, all_conditions) decor_outs.perform_decorrelation(args.skip) decor_outs.apply_masks() decor_outs.write_decors_to_files()
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) domain_pairs = parse_domain_pairs(args.domain_pairs) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) for sim_collection in sim_collections: for rep in sim_collection._reps: ops = sim_collection.get_reps_data('ops', concatenate=False) runs = len(ops[rep]) for run in range(runs): run_filebase = sim_collection.get_filebase(run, rep) trj_filename = '{}.trj'.format(run_filebase) trj_file = files.TxtTrajInpFile(trj_filename, system_file) ops = datatypes.OrderParams.from_file(run_filebase) all_dists = [[] for i in range(len(domain_pairs))] for i, step in enumerate(trj_file): config = np.array(step[0]['positions']) for j, domain_pair in enumerate(domain_pairs): pos_i = config[domain_pair[0]] pos_j = config[domain_pair[1]] all_dists[j].append( config_process.calc_dist(pos_i, pos_j)) for domain_pair, dists in zip(domain_pairs, all_dists): dist_tag = 'dist-d{}-d{}'.format(domain_pair[0], domain_pair[1]) if dist_tag in ops.tags: ops[dist_tag] = dists else: ops.add_column(dist_tag, dists) adj_tag = 'adj-d{}-d{}'.format(domain_pair[0], domain_pair[1]) adj_sites = np.array(dists) == 1 if adj_tag in ops.tags: ops[adj_tag] = adj_sites else: ops.add_column(adj_tag, adj_sites) dist_sum = np.sum(all_dists, axis=0) tag = 'dist-sum' if tag in ops.tags: ops[tag] = dist_sum else: ops.add_column(tag, dist_sum) ops.to_file(run_filebase)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) inp_filebase = create_input_filepathbase(args) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, inp_filebase, system_file) sim_collections = create_simplesim_collections(args, inp_filebase, all_conditions) tag = 'numfullyboundstaples' for sim_collection in sim_collections: staple_states = sim_collection.get_data('staplestates') back_ops = datatypes.OrderParams.from_file(sim_collection.filebase) total_staples = staple_states._data[1:, :].sum(axis=0) if tag in back_ops.tags: back_ops[tag] = total_staples else: back_ops.add_column(tag, total_staples) back_ops.to_file(sim_collection.filebase)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) decor_outs = decorrelate.DecorrelatedOutputs( sim_collections, all_conditions) decor_outs.read_decors_from_files() mbarw = mbar_wrapper.MBARWrapper(decor_outs) mbarw.perform_mbar() out_filebase = create_output_filepathbase(args) mbarw.calc_all_expectations(out_filebase) for smult in args.stack_mults: reduced_conditions = construct_variable_temp_conditions( args, smult, fileformatter, system_file) reduced_out_filebase = '{}-{}'.format(out_filebase, smult) mbarw.calc_1d_lfes(reduced_conditions, reduced_out_filebase)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) inp_filebase = create_input_filepathbase(args) fileformatter = construct_fileformatter() all_conditions = construct_conditions( args, fileformatter, inp_filebase, system_file) sim_collections = create_simplesim_collections(args, inp_filebase, all_conditions) for sim_collection in sim_collections: states_filename = '{}.states'.format(sim_collection.filebase) states = np.loadtxt(states_filename)[:, :args.scaffold_domains] states = states == 2 ops = datatypes.OrderParams.from_file(sim_collection.filebase) for i in range(args.scaffold_domains): tag = 'domainstate{}'.format(i) if tag in ops.tags: ops[tag] = states[:, i] else: ops.add_column(tag, states[:, i]) ops.to_file(sim_collection.filebase)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) staple_lengths = all_conditions._staple_lengths inp_filebase = create_input_filepathbase(args) mbarws = [] all_decor_outs = [] sampled_ops = [] for i in range(1, args.assembled_op + 1): sim_collections = outputs.create_sim_collections( inp_filebase, all_conditions, args.reps) decor_outs = decorrelate.DecorrelatedOutputs(sim_collections, all_conditions) decor_outs.read_decors_from_files(data_only=True) filtered_count = decor_outs.filter_collections(args.tag, i) if filtered_count == 0: continue sampled_ops.append(i) all_decor_outs.append(decor_outs) mbarw = mbar_wrapper.MBARWrapper(decor_outs) mbarw.perform_mbar() mbarws.append(mbarw) out_filebase = create_output_filepathbase(args) # Calculate expectations across selected order parameter conds = conditions.SimConditions( { 'temp': args.temp, 'staple_m': args.staple_m, 'bias': biases.NoBias() }, fileformatter, staple_lengths) all_tags = [] for i in range(1, args.staple_types + 1): all_tags.append('staples{}'.format(i)) all_tags.append('staplestates{}'.format(i)) for i in range(args.scaffold_domains): all_tags.append('domainstate{}'.format(i)) aves, stds = calc_reduced_expectations(conds, mbarws, all_decor_outs, all_tags) aves = np.concatenate([[sampled_ops], np.array(aves).T]) aves_file = files.TagOutFile('{}-{}.aves'.format(out_filebase, args.tag)) aves_file.write([args.tag] + all_tags, aves.T) stds = np.concatenate([[sampled_ops], np.array(stds).T]) stds_file = files.TagOutFile('{}-{}.stds'.format(out_filebase, args.tag)) stds_file.write([args.tag] + all_tags, stds.T) # Hacky calculation for plotting a melting temperature LFE curve sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) decor_outs = decorrelate.DecorrelatedOutputs(sim_collections, all_conditions) decor_outs.read_decors_from_files() mbarw = mbar_wrapper.MBARWrapper(decor_outs) mbarw.perform_mbar() values = decor_outs.get_concatenated_series(args.tag) decor_enes = decor_outs.get_concatenated_datatype('enes') decor_ops = decor_outs.get_concatenated_datatype('ops') decor_staples = decor_outs.get_concatenated_datatype('staples') bins = list(set(values)) bins.sort() value_to_bin = {value: i for i, value in enumerate(bins)} bin_index_series = [value_to_bin[i] for i in values] bin_index_series = np.array(bin_index_series) conds = conditions.SimConditions( { 'temp': args.temp, 'staple_m': args.staple_m, 'bias': biases.NoBias() }, fileformatter, staple_lengths) lfes, lfe_stds = calc_lfes(mbarw, conds, bins, bin_index_series, decor_enes, decor_ops, decor_staples) header = np.array(['ops', args.temp]) lfes_filebase = '{}_{}-lfes-melting'.format(out_filebase, args.tag) lfes_file = files.TagOutFile('{}.aves'.format(lfes_filebase)) lfes = np.concatenate([[bins], [lfes]]).T lfes_file.write(header, lfes) stds_file = files.TagOutFile('{}.stds'.format(lfes_filebase)) lfe_stds = np.concatenate([[bins], [lfe_stds]]).T stds_file.write(header, lfe_stds)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, system_file) staple_lengths = all_conditions._staple_lengths inp_filebase = create_input_filepathbase(args) sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) decor_outs = decorrelate.DecorrelatedOutputs( sim_collections, all_conditions) decor_outs.read_decors_from_files() mbarw = mbar_wrapper.MBARWrapper(decor_outs) mbarw.perform_mbar() out_filebase = create_output_filepathbase(args) values = decor_outs.get_concatenated_series(args.tag) decor_enes = decor_outs.get_concatenated_datatype('enes') decor_ops = decor_outs.get_concatenated_datatype('ops') decor_staples = decor_outs.get_concatenated_datatype('staples') bins = list(set(values)) bins.sort() value_to_bin = {value: i for i, value in enumerate(bins)} bin_index_series = [value_to_bin[i] for i in values] bin_index_series = np.array(bin_index_series) conds = conditions.SimConditions({'temp': args.guess_temp, 'staple_m': args.staple_m, 'bias': biases.NoBias()}, fileformatter, staple_lengths) melting_temp = minimize(squared_barrier_diff, args.guess_temp, args=(mbarw, values, bins, bin_index_series, decor_enes, decor_ops, decor_staples, conds)).x[0] lfes, lfe_stds = calc_lfes(mbarw, conds, bins, bin_index_series, decor_enes, decor_ops, decor_staples) barrier_height = np.around(calc_forward_barrier_height(lfes), decimals=3) barrier_i = find_barrier(lfes) melting_temp = '{:.3f}'.format(np.around(melting_temp, decimals=3)) print('Estimated melting temperature: {} K'.format(melting_temp)) print('Barrier height: {:.3f} kT'.format(barrier_height)) print('Barrier peak: {:.3f}'.format(bins[barrier_i])) header = np.array(['ops', melting_temp]) lfes_filebase = '{}_{}-lfes-melting'.format(out_filebase, args.tag) lfes_file = files.TagOutFile('{}.aves'.format(lfes_filebase)) lfes = np.concatenate([[bins], [lfes]]).T lfes_file.write(header, lfes) stds_file = files.TagOutFile('{}.stds'.format(lfes_filebase)) lfe_stds = np.concatenate([[bins], [lfe_stds]]).T stds_file.write(header, lfe_stds) # Calculated 2D LFEs tag2 = 'numfulldomains' decor_op_pairs = list(zip(decor_outs.get_concatenated_series(args.tag), decor_outs.get_concatenated_series(tag2))) bins = list(set(decor_op_pairs)) value_to_bin = {value: i for i, value in enumerate(bins)} bin_index_series = [value_to_bin[i] for i in decor_op_pairs] bin_index_series = np.array(bin_index_series) lfes, lfe_stds = calc_lfes(mbarw, conds, bins, bin_index_series, decor_enes, decor_ops, decor_staples) header = np.array([args.tag, tag2, melting_temp]) lfes_filebase = '{}_{}-{}-lfes-melting'.format( out_filebase, args.tag, tag2) bins = np.array(bins).reshape(len(bins), 2) lfes = np.concatenate([bins, np.array(lfes, ndmin=2).T], axis=1) lfes_file = files.TagOutFile('{}.aves'.format(lfes_filebase)) lfes_file.write(header, lfes) lfe_stds = np.concatenate([bins, np.array(lfe_stds, ndmin=2).T], axis=1) stds_file = files.TagOutFile('{}.stds'.format(lfes_filebase)) stds_file.write(header, lfe_stds) # Calculate expectations along the selected OP mbarws = [] all_decor_outs = [] sampled_ops = [] for i in range(1, args.assembled_op + 1): sim_collections = outputs.create_sim_collections(inp_filebase, all_conditions, args.reps) decor_outs = decorrelate.DecorrelatedOutputs( sim_collections, all_conditions) decor_outs.read_decors_from_files(data_only=True) filtered_count = decor_outs.filter_collections(args.tag, i) if filtered_count == 0: continue sampled_ops.append(i) all_decor_outs.append(decor_outs) mbarw = mbar_wrapper.MBARWrapper(decor_outs) mbarw.perform_mbar() mbarws.append(mbarw) out_filebase = create_output_filepathbase(args) # Calculate expectations across selected order parameter all_tags = [] for i in range(1, args.staple_types + 1): all_tags.append('staples{}'.format(i)) all_tags.append('staplestates{}'.format(i)) for i in range(args.scaffold_domains): all_tags.append('domainstate{}'.format(i)) aves, stds = calc_reduced_expectations( conds, mbarws, all_decor_outs, all_tags) aves = np.concatenate([[sampled_ops], np.array(aves).T]) aves_file = files.TagOutFile('{}-{}.aves'.format(out_filebase, args.tag)) aves_file.write([args.tag] + all_tags, aves.T) stds = np.concatenate([[sampled_ops], np.array(stds).T]) stds_file = files.TagOutFile('{}-{}.stds'.format(out_filebase, args.tag)) stds_file.write([args.tag] + all_tags, stds.T)
def main(): args = parse_args() system_file = files.JSONStructInpFile(args.system_filename) inp_filebase = create_input_filepathbase(args) fileformatter = construct_fileformatter() all_conditions = construct_conditions(args, fileformatter, inp_filebase, system_file) staple_lengths = system_file._staple_lengths sim_collections = create_simplesim_collections(args, inp_filebase, all_conditions) decor_outs = decorrelate.SimpleDecorrelatedOutputs(sim_collections, all_conditions) decor_outs.read_decors_from_files() mbarw = mbar_wrapper.MBARWrapper(decor_outs) mbarw.perform_mbar() out_filebase = create_output_filepathbase(args) conds = conditions.SimConditions( { 'temp': args.temp, 'staple_m': args.staple_m, 'bias': biases.NoBias() }, fileformatter, staple_lengths) all_tags = decor_outs.all_conditions.condition_tags aves = [] stds = [] for tag in decor_outs.all_series_tags: all_tags.append(tag) series = decor_outs.get_concatenated_series(tag) ave, std = mbarw.calc_expectation(series, conds) aves.append(ave) stds.append(std) # Hack calculate LFEs values = decor_outs.get_concatenated_series(tag) decor_enes = decor_outs.get_concatenated_datatype('enes') decor_ops = decor_outs.get_concatenated_datatype('ops') bins = list(set(values)) bins.sort() value_to_bin = {value: i for i, value in enumerate(bins)} bin_index_series = [value_to_bin[i] for i in values] bin_index_series = np.array(bin_index_series) rpots = utility.calc_reduced_potentials(decor_enes, decor_ops, conds) lfes, lfe_stds = mbarw._mbar.computePMF(rpots, bin_index_series, len(bins)) # Hack write LFEs to file header = np.array(['ops', args.temp]) lfes_filebase = '{}_{}-lfes-melting'.format(out_filebase, tag) lfes_file = files.TagOutFile('{}.aves'.format(lfes_filebase)) lfes = np.concatenate([[bins], [lfes]]).T lfes_file.write(header, lfes) stds_file = files.TagOutFile('{}.stds'.format(lfes_filebase)) lfe_stds = np.concatenate([[bins], [lfe_stds]]).T stds_file.write(header, lfe_stds) # Hack to write expectations to file aves_file = files.TagOutFile('{}.aves'.format(out_filebase)) cond_char_values = conds.condition_to_characteristic_value cond_values = [v for k, v in sorted(cond_char_values.items())] aves_file.write(all_tags, [np.concatenate([cond_values, np.array(aves)])]) stds_file = files.TagOutFile('{}.stds'.format(out_filebase)) stds_file.write(all_tags, [np.concatenate([cond_values, np.array(stds)])])