def filter_by_final_increment(anm_ener, final_ener, T):
filt_anm_ener = []
filt_final_ener = []
threshold_ener = MetropolisMCSimulator.energy_for_probability(0.1, T)
for i in range(len(anm_ener)):
if final_ener[i] < threshold_ener:
filt_anm_ener.append(anm_ener[i])
filt_final_ener.append(final_ener[i])
return filt_anm_ener, filt_final_ener, threshold_ener
if experiment_details["prefix"] == "IC":
raw_data, data_len = load_ic_data(os.path.join(workspace,
folder_name,
options.folder),
skip_first = 15)
# Start processing
modes = raw_data["modes"]
_mode_frequencies = get_mode_frequencies(modes,
os.path.join(workspace, folder_name, "info",
nmd_file_name[experiment_details["prefix"]])
)
energy_increments = process_energy_differences(raw_data)
rmsd_increments = process_after_perturb_rmsd(raw_data)
acc_mean_and_avg = MetropolisMCSimulator(energy_increments).perform_simulation(
min(100,len(energy_increments)), 20, 300)
# Fill all data structure
all_data[ENERGY_LABEL].extend(energy_increments)
all_data[RMSD_LABEL].extend(rmsd_increments)
all_data["Mode"].extend(modes)
all_data["time_per_step"].extend(raw_data["time_per_step"])
all_data[p1].extend([v1]*data_len)
all_data[p2].extend([v2]*data_len)
# Fill the other structures
acceptances[v1,v2] = acc_mean_and_avg
avg_rmsd[v1,v2] = (numpy.mean(rmsd_increments),
numpy.std(rmsd_increments))
avg_energy[v1,v2] = numpy.mean(energy_increments)
std_energy[v1,v2] = numpy.std(energy_increments)
folders = [
"IC_dispFact_0.65_dm_1", "IC_dispFact_0.65_dm_2",
"IC_dispFact_0.65_dm_3", "IC_dispFact_0.65_dm_4",
"IC_dispFact_0.65_dm_5", "IC_dispFact_0.65_dm_6",
"IC_dispFact_0.65_dm_7", "IC_dispFact_0.65_dm_8",
"IC_dispFact_0.65_dm_9", "IC_dispFact_0.65_dm_10"
]
distances = {}
for folder in folders:
raw_data, min_len = load_single_proc_data(options.sim_type,
os.path.join(folder, "info"))
energy_increments = process_energy_differences(raw_data)
mc = MetropolisMCSimulator(energy_increments)
who_is_accepted = mc.who_is_accepted(options.temperature)
coords = numpy.reshape(raw_data["coords_after"],
(len(raw_data["coords_after"]),
len(raw_data["coords_after"][0]) / 3, 3))
distances[folder] = calc_distances(coords, range(
len(coords))) #who_is_accepted[:150])
sns.set_style("whitegrid")
row_len = 4
col_len = 3
folders.extend(["IC_dispFact_0.65_dm_10", "IC_dispFact_0.65_dm_10"])
f, axes = prepare_subplots(row_len, col_len)
for i, folder in enumerate(folders):
data_folder,
"perturb_energy_before.log",
"final_energy.log", # Energy of the whole step
"initial_cc.log",
"after_minimization_cc.log",
"step_time.log")
if experiment_details["prefix"] == "IC":
raw_data, min_len = load_ic_data(data_folder, max_samples)
# skip first frame (usually an outlayer)
#print "DBG", min_len-1, len(modes), len(process_modes(experiment_details["prefix"], modes, 10))
energy_increments = process_energy_differences(raw_data)
rmsd_increments = process_after_perturb_rmsd(raw_data)
mc = MetropolisMCSimulator(energy_increments)
acceptances[T][v1, v2] = mc.perform_simulation(
min(200, len(energy_increments)), 40, T)
avg_energy[T][v1, v2] = numpy.mean(energy_increments)
std_energy[T][v1, v2] = numpy.std(energy_increments)
avg_rmsd[T][v1, v2] = numpy.mean(rmsd_increments)
std_rmsd[T][v1, v2] = numpy.std(rmsd_increments)
p1_keys.append(v1)
p2_keys.append(v2)
# Rmsf calculations
rmsf_coords = numpy.reshape(
raw_data["coords_after"],
(len(raw_data["coords_after"]),
len(raw_data["coords_after"][0]) / 3, 3))
rmsf[T][v1,
# skip first frame (usually an outlayer)
energy_increments = process_energy_differences(raw_data)[1:]
rmsd_increments = process_after_perturb_rmsd(raw_data)[1:]
# Coordinates reshape for rmsf
rmsf_coords = numpy.reshape(
raw_data["coords_after"],
(len(raw_data["coords_after"]),
len(raw_data["coords_after"][0]) / 3, 3))
acceptances[dataset["prefix"]][T, v1, v2] = []
rmsd[dataset["prefix"]][T, v1, v2] = []
rmsf[dataset["prefix"]][T, v1, v2] = []
for num_steps in range(step_granularity, max_samples + 1,
step_granularity):
# Acceptance calc.
mc = MetropolisMCSimulator(energy_increments[0:num_steps])
acceptances[dataset["prefix"]][T, v1, v2].append(
mc.perform_simulation(
min(num_steps / 2, len(energy_increments)), 40, T))
# Rmsf calculations
_rmsf = coords_rmsf(rmsf_coords[0:num_steps])
rmsf[dataset["prefix"]][T, v1,
v2].append(rms(rmsf_ref, _rmsf))
# RMSD avg. calc
rmsd[dataset["prefix"]][T, v1, v2].append(
(numpy.mean(rmsd_increments[0:num_steps]),
numpy.std(rmsd_increments[0:num_steps])))
pickle.dump(
(acceptances, rmsf, rmsd),
open(os.path.join(options.results_folder, "per_step_data"),
if sim_type == "CC" :
label = "CC ANM step"
data_range = (-1.5, 39)
data_range = (-2, 60)#ubi
axis = axes[1]
color = colors[1]
else:
label = "IC"
data_range = (-140, 177)
data_range = (-65, 400)#ubi
axis = axes[0]
color = colors[0]
print label, numpy.mean(energy_increments), numpy.std(energy_increments)
print "Ratio", calc_ratio(energy_increments)
print "Acceptance", MetropolisMCSimulator(energy_increments).perform_simulation(5000,200,300)
axis.hist(energy_increments,
#energy_increments[energy_increments < numpy.mean(energy_increments)+(numpy.std(energy_increments)*3)],
bins =100,
range = data_range,
label = label,
alpha = 0.75,
normed=True,
color = color)
axis.legend()
# plt.xlabel("Energy increment (kcal / mol)")
# plt.legend()
# plt.show()
# Then calculate the "full pele stuff too"
create_directory(options.results_folder)
if options.num_procs > 1:
raw_data, min_lens = load_data_from_multiple_processors(options.sim_type,
options.num_procs,
data_folder,
10)
else:
raw_data, min_len = load_single_proc_data(options.sim_type, data_folder, 10)
####################
# Acceptance
####################
energy_increments = process_energy_differences(raw_data)
mc = MetropolisMCSimulator(energy_increments)
acc = mc.perform_simulation(min(200,len(energy_increments)), 40, options.temperature)
print "Acceptance ", acc
open(os.path.join(options.results_folder,"acceptance.txt"),"w").write("%.3f (%.3f)"%acc)
print "Energy avg.", numpy.mean(energy_increments), numpy.std(energy_increments)
print "Energy median",numpy.median(energy_increments)
# ####################
# # Rmsf
# ####################
# rmsf_coords = numpy.reshape(raw_data["coords_after"], (len(raw_data["coords_after"]),
# len(raw_data["coords_after"][0])/3,
# 3))
# who_is_accepted = mc.who_is_accepted(options.temperature)
# rmsf = coords_rmsf(rmsf_coords[who_is_accepted])