def test_helix_contacts_dcd(tmpdir):
"""See if we can determine native contacts for helix backbone sequences"""
output_directory = tmpdir.mkdir("output")
# Replica exchange settings
number_replicas = 12
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
# Load in cgmodel
cgmodel = pickle.load(open(f"{data_path}/stored_cgmodel.pkl", "rb"))
# Create list of pdb trajectories to analyze
# For fraction_native_contacts vs. T, we use state trajectories.
# However, we can test with the replica pdbs:
dcd_file_list = []
for i in range(len(temperature_list)):
dcd_file_list.append(f"{data_path}/replica_{i+1}.dcd")
# Load in native structure file:
native_structure_file = f"{structures_path}/medoid_0.dcd"
# Determine native contacts:
native_contact_list, native_contact_distances, opt_seq_spacing = get_helix_contacts(
cgmodel,
native_structure_file,
backbone_type_name='bb',
)
def test_native_contacts_dcd(tmpdir):
"""See if we can determine native contacts and classify folded vs. unfolded states"""
output_directory = tmpdir.mkdir("output")
# Replica exchange settings
number_replicas = 12
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
# Load in cgmodel
cgmodel = pickle.load(open(f"{data_path}/stored_cgmodel.pkl", "rb"))
# Create list of pdb trajectories to analyze
# For fraction_native_contacts vs. T, we use state trajectories.
# However, we can test with the replica pdbs:
dcd_file_list = []
for i in range(len(temperature_list)):
dcd_file_list.append(f"{data_path}/replica_{i+1}.dcd")
# Load in native structure file:
native_structure_file = f"{structures_path}/medoid_0.dcd"
# Set cutoff parameters:
# Cutoff for native structure pairwise distances:
native_contact_cutoff = 3.5 * unit.angstrom
# Tolerance for current trajectory distances:
native_contact_tol = 1.2
# Determine native contacts:
native_contact_list, native_contact_distances, contact_type_dict = get_native_contacts(
cgmodel,
native_structure_file,
native_contact_cutoff,
)
# Determine native contact fraction of current trajectories:
Q, Q_avg, Q_stderr, decorrelation_spacing = fraction_native_contacts(
cgmodel,
dcd_file_list,
native_contact_list,
native_contact_distances,
native_contact_tol=native_contact_tol,
)
plot_native_contact_fraction(
temperature_list,
Q_avg,
Q_stderr,
plotfile=f"{output_directory}/Q_vs_T.pdf",
)
assert os.path.isfile(f"{output_directory}/Q_vs_T.pdf")
def test_bootstrap_native_contacts_expectation_dcd(tmpdir):
"""Test bootstrapping of native contacts expectation, based on helix contacts"""
output_directory = tmpdir.mkdir("output")
output_data = os.path.join(data_path, "output.nc")
# Replica exchange settings
number_replicas = 12
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
# Load in cgmodel
cgmodel = pickle.load(open(f"{data_path}/stored_cgmodel.pkl", "rb"))
# Create list of pdb trajectories to analyze
# For fraction_native_contacts vs. T, we use state trajectories.
# However, we can test with the replica pdbs:
dcd_file_list = []
for i in range(len(temperature_list)):
dcd_file_list.append(f"{data_path}/replica_{i+1}.dcd")
# Load in native structure file:
native_structure_file = f"{structures_path}/medoid_0.dcd"
# Determine native contacts:
native_contact_list, native_contact_distances, opt_seq_spacing = get_helix_contacts(
cgmodel,
native_structure_file,
backbone_type_name='bb',
)
full_T_list, Q_values, Q_uncertainty, sigmoid_results_boot = bootstrap_native_contacts_expectation(
cgmodel,
dcd_file_list,
native_contact_list,
native_contact_distances,
output_data=output_data,
frame_begin=100,
sample_spacing=20,
native_contact_tol=1.2,
num_intermediate_states=1,
n_trial_boot=10,
conf_percent='sigma',
plotfile=f'{output_directory}/native_contacts_boot.pdf',
)
assert os.path.isfile(f'{output_directory}/native_contacts_boot.pdf')
def signac_bonded_distributions(job):
# Make alpha-theta ramachandran plots:
output_directory = os.path.join(job.workspace(), "output")
# Load in trajectory stats:
analysis_stats = pickle.load(open(job.fn("analysis_stats.pkl"), "rb"))
# Load in cgmodel:
cgmodel = pickle.load(open(job.fn("stored_cgmodel.pkl"), "rb"))
traj_file_list = []
number_replicas = 36
min_temp = 200.0 * unit.kelvin
max_temp = 500.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
for i in range(number_replicas):
traj_file_list.append(f"{output_directory}/state_{i+1}.dcd")
bond_hist_data = calc_bond_length_distribution(
cgmodel,
traj_file_list,
frame_start=analysis_stats["production_start"],
temperature_list=temperature_list,
plotfile=f"{output_directory}/bonds_all_states.pdf")
angle_hist_data = calc_bond_angle_distribution(
cgmodel,
traj_file_list,
frame_start=analysis_stats["production_start"],
temperature_list=temperature_list,
plotfile=f"{output_directory}/angles_all_states.pdf")
bond_hist_data = calc_torsion_distribution(
cgmodel,
traj_file_list,
frame_start=analysis_stats["production_start"],
temperature_list=temperature_list,
plotfile=f"{output_directory}/torsions_all_states.pdf")
def test_optimize_Q_helix_tol_dcd(tmpdir):
"""Test the helix native contact tolerance optimization workflow"""
output_directory = tmpdir.mkdir("output")
output_data = os.path.join(data_path, "output.nc")
# Replica exchange settings
number_replicas = 12
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
# Load in cgmodel
cgmodel = pickle.load(open(f"{data_path}/stored_cgmodel.pkl", "rb"))
# Create list of pdb trajectories to analyze
# For expectation fraction native contacts, we use replica trajectories:
dcd_file_list = []
for i in range(len(temperature_list)):
dcd_file_list.append(f"{data_path}/replica_{i+1}.dcd")
# Load in native structure file:
native_structure_file = f"{structures_path}/medoid_0.dcd"
(opt_seq_spacing, native_contact_tol, opt_results, Q_expect_results,
sigmoid_param_opt, sigmoid_param_cov) = optimize_Q_tol_helix(
cgmodel,
native_structure_file,
dcd_file_list,
num_intermediate_states=0,
output_data=output_data,
frame_begin=100,
frame_stride=20,
verbose=True,
plotfile=f'{output_directory}/native_contacts_helix_opt.pdf',
backbone_type_name='bb',
brute_step=0.2,
)
assert os.path.isfile(f'{output_directory}/native_contacts_helix_opt.pdf')
def signac_calc_heat_capacity(job):
# Calculate heat capacity curve
# Job settings
output_directory = os.path.join(job.workspace(), "output")
output_data = os.path.join(output_directory, "output.nc")
# Replica exchange simulation settings.
#These must match the simulations that are being analyzed.
number_replicas = 36
min_temp = 100 * unit.kelvin
max_temp = 500.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
# Load in trajectory stats:
analysis_stats = pickle.load(open(job.fn("analysis_stats.pkl"), "rb"))
# Read the simulation coordinates for individual temperature replicas
C_v, dC_v, new_temperature_list = get_heat_capacity(
temperature_list,
output_data=output_data,
frame_begin=analysis_stats["production_start"],
sample_spacing=analysis_stats["energy_decorrelation"],
num_intermediate_states=1,
plot_file=f"{output_directory}/heat_capacity.pdf",
)
# Save C_v data to data file:
job.data['C_v'] = C_v._value
job.data['dC_v'] = dC_v._value
job.data['T_list_C_v'] = new_temperature_list._value
print(
f"T({new_temperature_list[0].unit}) Cv({C_v[0].unit}) dCv({dC_v[0].unit})"
)
for i, C in enumerate(C_v):
print(
f"{new_temperature_list[i]._value:>8.2f}{C_v[i]._value:>10.4f} {dC_v[i]._value:>10.4f}"
)
def test_optimize_Q_cut_dcd(tmpdir):
"""Test the native contact cutoff optimization workflow"""
output_directory = tmpdir.mkdir("output")
output_data = os.path.join(data_path, "output.nc")
# Replica exchange settings
number_replicas = 12
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
# Load in cgmodel
cgmodel = pickle.load(open(f"{data_path}/stored_cgmodel.pkl", "rb"))
# Create list of pdb trajectories to analyze
# For expectation fraction native contacts, we use replica trajectories:
dcd_file_list = []
for i in range(len(temperature_list)):
dcd_file_list.append(f"{data_path}/replica_{i+1}.dcd")
# Load in native structure file:
native_structure_file = f"{structures_path}/medoid_0.dcd"
(native_contact_cutoff, native_contact_tol, opt_results, Q_expect_results, \
sigmoid_param_opt, sigmoid_param_cov, contact_type_dict) = optimize_Q_cut(
cgmodel,
native_structure_file,
dcd_file_list,
num_intermediate_states=0,
output_data=output_data,
frame_begin=100,
frame_stride=200,
verbose=True,
plotfile=f'{output_directory}/native_contacts_opt.pdf',
minimizer_options={'seed':17, 'maxiter':3, 'atol':0.2},
)
assert os.path.isfile(f'{output_directory}/native_contacts_opt.pdf')
def signac_run_replica_exchange(job):
# Run replica exchange simulation for current job parameters
# Job settings
output_directory = os.path.join(job.workspace(), "output")
if not os.path.exists(output_directory):
os.mkdir(output_directory)
overwrite_files = True # overwrite files.
# Replica exchange simulation settings
total_simulation_time = 0.05 * unit.nanosecond
simulation_time_step = 10.0 * unit.femtosecond
total_steps = int(np.floor(total_simulation_time / simulation_time_step))
output_data = os.path.join(output_directory, "output.nc")
number_replicas = 36
min_temp = 100.0 * unit.kelvin
max_temp = 500.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
exchange_frequency = 100 # Number of steps between exchange attempts
collision_frequency = 5 / unit.picosecond
include_bond_forces = True
include_bond_angle_forces = True
include_nonbonded_forces = True
include_torsion_forces = True
constrain_bonds = False
mass = 100.0 * unit.amu
# mass and charge are defaults.
bb = {
"particle_type_name": "bb",
"sigma": job.sp.sigma_bb * unit.nanometer,
"epsilon": job.sp.epsilon_bb * unit.kilojoules_per_mole,
"mass": mass
}
sc = {
"particle_type_name": "sc",
"sigma": job.sp.sigma_sc * unit.nanometer,
"epsilon": job.sp.epsilon_sc * unit.kilojoules_per_mole,
"mass": mass
}
# Monomer definition
A = {
"monomer_name": "A",
"particle_sequence": [bb, sc],
"bond_list": [[0, 1]],
"start": 0,
"end": 0,
}
sequence = 24 * [A]
# Bond definitions
bond_lengths = {
"default_bond_length": job.sp.equil_bond_length * unit.nanometer
}
bond_force_constants = {
"default_bond_force_constant":
job.sp.k_bond * unit.kilojoule_per_mole / unit.nanometer /
unit.nanometer
}
# Bond angle definitions
bond_angle_force_constants = {
"default_bond_angle_force_constant":
job.sp.k_angle * unit.kilojoule_per_mole / unit.radian / unit.radian
}
equil_bond_angles = {
"default_equil_bond_angle": job.sp.equil_bond_angle * unit.degrees
}
# torsion angle definitions
torsion_force_constants = {
"default_torsion_force_constant":
0.0 * unit.kilojoule_per_mole,
"bb_bb_bb_bb_torsion_force_constant":
job.sp.k_torsion * unit.kilojoule_per_mole
}
torsion_phase_angles = {
"sc_bb_bb_sc_torsion_phase_angle": 0 * unit.degrees,
"bb_bb_bb_bb_torsion_phase_angle":
job.sp.torsion_phase_angle * unit.degrees,
"bb_bb_bb_sc_torsion_phase_angle": 0 * unit.degrees,
}
torsion_periodicities = {
"sc_bb_bb_sc_torsion_periodicity": job.sp.torsion_periodicity,
"bb_bb_bb_bb_torsion_periodicity": job.sp.torsion_periodicity,
"bb_bb_bb_sc_torsion_periodicity": job.sp.torsion_periodicity,
}
# Get initial positions from local file
pdb_path = os.path.join(proj_directory, "24mer_1b1s_initial_structure.pdb")
positions = PDBFile(pdb_path).getPositions()
# Build a coarse grained model
cgmodel = CGModel(
particle_type_list=[bb, sc],
bond_lengths=bond_lengths,
bond_force_constants=bond_force_constants,
bond_angle_force_constants=bond_angle_force_constants,
torsion_force_constants=torsion_force_constants,
equil_bond_angles=equil_bond_angles,
torsion_phase_angles=torsion_phase_angles,
torsion_periodicities=torsion_periodicities,
include_nonbonded_forces=include_nonbonded_forces,
include_bond_forces=include_bond_forces,
include_bond_angle_forces=include_bond_angle_forces,
include_torsion_forces=include_torsion_forces,
constrain_bonds=constrain_bonds,
sequence=sequence,
positions=positions,
monomer_types=[A],
)
# store the cg model so that we can do various analyses.
cgmodel.export(job.fn("stored_cgmodel.pkl"))
if not os.path.exists(output_data) or overwrite_files == True:
run_replica_exchange(
cgmodel.topology,
cgmodel.system,
cgmodel.positions,
friction=collision_frequency,
temperature_list=temperature_list,
simulation_time_step=simulation_time_step,
total_simulation_time=total_simulation_time,
exchange_frequency=exchange_frequency,
output_data=output_data,
)
else:
print("Replica output files exist")
# Job settings
output_directory = "output"
if not os.path.exists(output_directory):
os.mkdir(output_directory)
overwrite_files = True # overwrite files.
# Replica exchange simulation settings
total_simulation_time = 20.0 * unit.nanosecond
simulation_time_step = 10.0 * unit.femtosecond
total_steps = int(np.floor(total_simulation_time / simulation_time_step))
output_data = os.path.join(output_directory, "output.nc")
number_replicas = 12
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp, number_replicas)
exchange_frequency = 100 # Number of steps between exchange attempts
include_bond_forces = True
include_bond_angle_forces = True
include_nonbonded_forces = True
include_torsion_forces = True
constrain_bonds = False
bond_length = 0.2 * unit.nanometer # reference length unit
# Particle definitions
r_min = 1.5 * bond_length # Lennard-Jones potential r_min
# Factor of /(2.0**(1/6)) is applied to convert r_min to sigma
sigma = r_min / (2.0**(1.0 / 6.0))
epsilon = 1.0 * unit.kilojoules_per_mole
def test_expectations_fraction_contacts_dcd(tmpdir):
"""See if we can determine native contacts expectations as a function of T"""
output_directory = tmpdir.mkdir("output")
# Replica exchange settings
number_replicas = 12
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
# Load in cgmodel
cgmodel = pickle.load(open(f"{data_path}/stored_cgmodel.pkl", "rb"))
# Create list of pdb trajectories to analyze
# For expectation fraction native contacts, we use replica trajectories:
dcd_file_list = []
for i in range(len(temperature_list)):
dcd_file_list.append(f"{data_path}/replica_{i+1}.dcd")
# Load in native structure file:
native_structure_file = f"{structures_path}/medoid_0.dcd"
# Set cutoff parameters:
# Cutoff for native structure pairwise distances:
native_contact_cutoff = 3.5 * unit.angstrom
# Tolerance for current trajectory distances:
native_contact_tol = 1.2
# Get native contacts:
native_contact_list, native_contact_distances, contact_type_dict = get_native_contacts(
cgmodel,
native_structure_file,
native_contact_cutoff,
)
Q, Q_avg, Q_stderr, decorrelation_spacing = fraction_native_contacts(
cgmodel,
dcd_file_list,
native_contact_list,
native_contact_distances,
frame_begin=100,
native_contact_tol=native_contact_tol,
)
# Determine how many folding transitions each replica underwent:
# plot Q_avg vs. frame
plot_native_contact_timeseries(
Q,
frame_begin=100,
time_interval=1 * unit.picosecond,
plot_per_page=3,
plotfile=f"{output_directory}/Q_vs_time.pdf",
figure_title="Native contact fraction",
)
assert os.path.isfile(f"{output_directory}/Q_vs_time.pdf")
output_data = os.path.join(data_path, "output.nc")
num_intermediate_states = 1
results = expectations_fraction_contacts(
Q,
frame_begin=100,
output_data=output_data,
num_intermediate_states=num_intermediate_states,
)
plot_native_contact_fraction(
results["T"],
results["Q"],
results["dQ"],
plotfile=f"{output_directory}/Q_expect_vs_T.pdf",
)
assert os.path.isfile(f"{output_directory}/Q_expect_vs_T.pdf")
# Test sigmoid fitting function on Q_expect_vs_T data:
param_opt, param_cov = fit_sigmoid(
results["T"],
results["Q"],
plotfile=f"{output_directory}/Q_vs_T_fit.pdf",
)
assert os.path.isfile(f"{output_directory}/Q_vs_T_fit.pdf")
def test_expectations_fraction_contacts_pdb(tmpdir):
"""See if we can determine native contacts expectations as a function of T"""
output_directory = tmpdir.mkdir("output")
# Replica exchange settings
number_replicas = 12
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
# Load in cgmodel
cgmodel = pickle.load(open(f"{data_path}/stored_cgmodel.pkl", "rb"))
# Create list of pdb trajectories to analyze
# For expectation fraction native contacts, we use replica trajectories:
pdb_file_list = []
for i in range(len(temperature_list)):
pdb_file_list.append(f"{data_path}/replica_{i+1}.pdb")
# Load in native structure file:
native_structure_file = f"{structures_path}/medoid_0.pdb"
# Set cutoff parameters:
# Cutoff for native structure pairwise distances:
native_contact_cutoff = 3.5 * unit.angstrom
# Tolerance for current trajectory distances:
native_contact_tol = 1.2
# Get native contacts:
native_contact_list, native_contact_distances, contact_type_dict = get_native_contacts(
cgmodel,
native_structure_file,
native_contact_cutoff,
)
Q, Q_avg, Q_stderr, decorrelation_spacing = fraction_native_contacts(
cgmodel,
pdb_file_list,
native_contact_list,
native_contact_distances,
frame_begin=100,
native_contact_tol=native_contact_tol,
)
# Determine how many folding transitions each replica underwent:
# plot Q vs. frame
plot_native_contact_timeseries(
Q,
frame_begin=100,
time_interval=1 * unit.picosecond,
plot_per_page=3,
plotfile=f"{output_directory}/Q_vs_time.pdf",
figure_title="Native contact fraction",
)
assert os.path.isfile(f"{output_directory}/Q_vs_time.pdf")
output_data = os.path.join(data_path, "output.nc")
num_intermediate_states = 1
results = expectations_fraction_contacts(
Q,
frame_begin=100,
output_data=output_data,
num_intermediate_states=num_intermediate_states,
)
plot_native_contact_fraction(
results["T"],
results["Q"],
results["dQ"],
plotfile=f"{output_directory}/Q_expect_vs_T.pdf",
)
assert os.path.isfile(f"{output_directory}/Q_expect_vs_T.pdf")
# Test free energy of folding:
# Cutoff for native contact fraction folded vs. unfolded states:
Q_folded = 0.50
full_T_list, deltaF_values, deltaF_uncertainty = expectations_free_energy(
Q,
Q_folded,
temperature_list,
frame_begin=100,
output_data=output_data,
num_intermediate_states=num_intermediate_states,
)
plot_free_energy_results(full_T_list,
deltaF_values,
deltaF_uncertainty,
plotfile=f"{output_directory}/free_energy.pdf")
assert os.path.isfile(f"{output_directory}/free_energy.pdf")
# Test free energy fitting / derivative calculation:
ddeltaF_out, d2deltaF_out, spline_tck = get_free_energy_derivative(
deltaF_values['state0_state1'],
full_T_list,
plotfile=f"{output_directory}/ddeltaF_dT.pdf",
)
assert os.path.isfile(f"{output_directory}/ddeltaF_dT.pdf")
# Test entropy/enthalpy of folding calculation:
S_folding, H_folding = get_entropy_enthalpy(
deltaF_values,
full_T_list,
)
# Test free energy / entropy / enthalpy bootstrapping calculation:
# From bootstrapping:
(full_T_list_boot, deltaF_values_boot, deltaF_uncertainty_boot, \
deltaS_values_boot, deltaS_uncertainty_boot, \
deltaH_values_boot, deltaH_uncertainty_boot) = bootstrap_free_energy_folding(
Q,
Q_folded,
frame_begin=100,
sample_spacing=2,
output_data=output_data,
num_intermediate_states=num_intermediate_states,
n_trial_boot=10,
conf_percent='sigma',
plotfile_dir=output_directory,
)
assert os.path.isfile(f"{output_directory}/free_energy_boot.pdf")
assert os.path.isfile(f"{output_directory}/entropy_boot.pdf")
assert os.path.isfile(f"{output_directory}/enthalpy_boot.pdf")
# With specified confidence interval:
(full_T_list_boot, deltaF_values_boot, deltaF_uncertainty_boot, \
deltaS_values_boot, deltaS_uncertainty_boot, \
deltaH_values_boot, deltaH_uncertainty_boot) = bootstrap_free_energy_folding(
Q,
Q_folded,
frame_begin=100,
sample_spacing=2,
output_data=output_data,
num_intermediate_states=num_intermediate_states,
n_trial_boot=10,
conf_percent=80,
plotfile_dir=output_directory,
)
assert os.path.isfile(f"{output_directory}/free_energy_boot.pdf")
assert os.path.isfile(f"{output_directory}/entropy_boot.pdf")
assert os.path.isfile(f"{output_directory}/enthalpy_boot.pdf")
def test_run_replica_exchange(tmpdir):
"""
Run a short replica exchange MD simulation of a 24mer 1b1s model
Test replica exchange processing (write pdb files)
Test heat capacity analysis code
Test physical validation code
"""
global_context_cache.platform = openmm.Platform.getPlatformByName("CPU")
# Set output directory
# In pytest we need to use a temp directory
# tmpdir is a fixture - hence we need to pass it into test function, not import it
output_directory = tmpdir.mkdir("output")
# Replica exchange simulation settings
total_simulation_time = 1.0 * unit.picosecond
simulation_time_step = 5.0 * unit.femtosecond
total_steps = int(np.floor(total_simulation_time / simulation_time_step))
output_data = os.path.join(output_directory, "output.nc")
number_replicas = 4
min_temp = 200.0 * unit.kelvin
max_temp = 300.0 * unit.kelvin
temperature_list = get_temperature_list(min_temp, max_temp,
number_replicas)
exchange_frequency = 10 # Number of steps between exchange attempts
# Coarse grained model settings
include_bond_forces = True
include_bond_angle_forces = True
include_nonbonded_forces = True
include_torsion_forces = True
constrain_bonds = False
# Bond definitions
bond_length = 1.5 * unit.angstrom
bond_lengths = {
"bb_bb_bond_length": bond_length,
"bb_sc_bond_length": bond_length,
"sc_sc_bond_length": bond_length,
}
bond_force_constant = 1000 * unit.kilojoule_per_mole / unit.nanometer / unit.nanometer
bond_force_constants = {
"bb_bb_bond_force_constant": bond_force_constant,
"bb_sc_bond_force_constant": bond_force_constant,
"sc_sc_bond_force_constant": bond_force_constant,
}
# Particle definitions
mass = 100.0 * unit.amu
r_min = 1.5 * bond_length # Lennard-Jones potential r_min
# Factor of /(2.0**(1/6)) is applied to convert r_min to sigma
sigma = r_min / (2.0**(1.0 / 6.0))
epsilon = 0.5 * unit.kilojoule_per_mole
bb = {
"particle_type_name": "bb",
"sigma": sigma,
"epsilon": epsilon,
"mass": mass
}
sc = {
"particle_type_name": "sc",
"sigma": sigma,
"epsilon": epsilon,
"mass": mass
}
# Bond angle definitions
bond_angle_force_constant = 100 * unit.kilojoule_per_mole / unit.radian / unit.radian
bond_angle_force_constants = {
"bb_bb_bb_bond_angle_force_constant": bond_angle_force_constant,
"bb_bb_sc_bond_angle_force_constant": bond_angle_force_constant,
}
# OpenMM requires angle definitions in units of radians
bb_bb_bb_equil_bond_angle = 120.0 * unit.degrees
bb_bb_sc_equil_bond_angle = 120.0 * unit.degrees
equil_bond_angles = {
"bb_bb_bb_equil_bond_angle": bb_bb_bb_equil_bond_angle,
"bb_bb_sc_equil_bond_angle": bb_bb_sc_equil_bond_angle,
}
# Torsion angle definitions
torsion_force_constant = 20.0 * unit.kilojoule_per_mole
torsion_force_constants = {
"bb_bb_bb_bb_torsion_force_constant": torsion_force_constant,
"bb_bb_bb_sc_torsion_force_constant": torsion_force_constant
}
bb_bb_bb_bb_torsion_phase_angle = 75.0 * unit.degrees
bb_bb_bb_sc_torsion_phase_angle = 75.0 * unit.degrees
torsion_phase_angles = {
"bb_bb_bb_bb_torsion_phase_angle": bb_bb_bb_bb_torsion_phase_angle,
"bb_bb_bb_sc_torsion_phase_angle": bb_bb_bb_sc_torsion_phase_angle
}
torsion_periodicities = {
"bb_bb_bb_bb_torsion_periodicity": 3,
"bb_bb_bb_sc_torsion_periodicity": 3
}
# Monomer definitions
A = {
"monomer_name": "A",
"particle_sequence": [bb, sc],
"bond_list": [[0, 1]],
"start": 0,
"end": 0,
}
sequence = 24 * [A]
pdb_path = os.path.join(structures_path,
"24mer_1b1s_initial_structure.pdb")
positions = PDBFile(pdb_path).getPositions()
# Build a coarse grained model
cgmodel = CGModel(
particle_type_list=[bb, sc],
bond_lengths=bond_lengths,
bond_force_constants=bond_force_constants,
bond_angle_force_constants=bond_angle_force_constants,
torsion_force_constants=torsion_force_constants,
equil_bond_angles=equil_bond_angles,
torsion_phase_angles=torsion_phase_angles,
torsion_periodicities=torsion_periodicities,
include_nonbonded_forces=include_nonbonded_forces,
include_bond_forces=include_bond_forces,
include_bond_angle_forces=include_bond_angle_forces,
include_torsion_forces=include_torsion_forces,
constrain_bonds=constrain_bonds,
positions=positions,
sequence=sequence,
monomer_types=[A],
)
run_replica_exchange(
cgmodel.topology,
cgmodel.system,
cgmodel.positions,
temperature_list=temperature_list,
simulation_time_step=simulation_time_step,
total_simulation_time=total_simulation_time,
exchange_frequency=exchange_frequency,
output_data=output_data,
)
assert os.path.isfile(f"{output_directory}/output.nc")
# Process replica exchange output
# 1) With plot production only and print_timing:
replica_energies, replica_states, production_start, sample_spacing, n_transit, mixing_stats = process_replica_exchange_data(
output_data=output_data,
output_directory=output_directory,
plot_production_only=True,
print_timing=True,
)
# 2) With non-default equil_nskip
replica_energies, replica_states, production_start, sample_spacing, n_transit, mixing_stats = process_replica_exchange_data(
output_data=output_data,
output_directory=output_directory,
plot_production_only=True,
equil_nskip=2,
)
# 3) With frame_begin used to circumvent detectEquilibration
replica_energies, replica_states, production_start, sample_spacing, n_transit, mixing_stats = process_replica_exchange_data(
output_data=output_data,
output_directory=output_directory,
frame_begin=5,
)
# 4) With frame end specified to analyze only the beginning of a trajectory
replica_energies, replica_states, production_start, sample_spacing, n_transit, mixing_stats = process_replica_exchange_data(
output_data=output_data,
output_directory=output_directory,
frame_end=25,
)
# 5) Without writing .dat file:
replica_energies, replica_states, production_start, sample_spacing, n_transit, mixing_stats = process_replica_exchange_data(
output_data=output_data,
output_directory=output_directory,
write_data_file=False,
)
# Test pdb writer:
make_replica_pdb_files(
cgmodel.topology,
output_dir=output_directory,
)
make_state_pdb_files(cgmodel.topology, output_dir=output_directory)
assert os.path.isfile(f"{output_directory}/replica_4.pdb")
assert os.path.isfile(f"{output_directory}/state_4.pdb")
# With non-default frame_begin, stride, no centering:
make_replica_pdb_files(cgmodel.topology,
frame_begin=10,
frame_stride=2,
output_dir=output_directory)
make_state_pdb_files(cgmodel.topology,
frame_begin=10,
frame_stride=2,
output_dir=output_directory,
center=False)
# Test dcd writer:
make_replica_dcd_files(cgmodel.topology,
timestep=simulation_time_step,
time_interval=exchange_frequency,
output_dir=output_directory)
make_state_dcd_files(cgmodel.topology,
timestep=simulation_time_step,
time_interval=exchange_frequency,
output_dir=output_directory)
assert os.path.isfile(f"{output_directory}/replica_4.dcd")
assert os.path.isfile(f"{output_directory}/state_4.dcd")
# With non-default frame_begin, stride, no centering:
make_replica_dcd_files(cgmodel.topology,
timestep=simulation_time_step,
time_interval=exchange_frequency,
frame_begin=10,
frame_stride=2,
output_dir=output_directory)
make_state_dcd_files(cgmodel.topology,
timestep=simulation_time_step,
time_interval=exchange_frequency,
frame_begin=10,
frame_stride=2,
output_dir=output_directory,
center=False)