def test_state_functions(self):
mol = initialize_system()
d = initialize_dataset()
state = mol.get_state(0)
self.assertFalse(state.has_data())
state.add_dataset(d)
self.assertTrue(state.has_data())
# test calculating sectors
sectors = state.calculate_sectors()
self.assertEqual(len(sectors), 4)
self.assertEqual(state.sector_dictionary[0], set([3,4]))
self.assertEqual(len(state.sector_dictionary), 4)
pep = d.create_peptide("EGAM", start_residue=2)
sectors = state.calculate_sectors()
self.assertEqual(len(sectors), 5)
self.assertEqual(state.sector_dictionary[0], set([3]))
pep.add_timepoints([10,100])
state.set_output_model(model.ResidueGridModel(state, 10))
state.initialize()
def test_residue_grid_model(self):
state = initialize_system_and_dataset()
rgm = model.ResidueGridModel(state, grid_size=10)
pf_grids = rgm.calculate_protection_factor_grids(threshold = 0.01)
mod = rgm.generate_model(random=False, value=2, initialize=True)
self.assertEqual(len(state.get_sequence()), len(mod))
for i in mod:
self.assertEqual(i, 2)
mod2 = rgm.generate_model(random=True, initialize=True)
self.assertEqual(len(mod2), len(mod))
for i in range(len(mod2)):
self.assertEqual(mod2[i], rgm.model[i])
def test_change_residue(self):
state = initialize_system_and_dataset()
rgm = model.ResidueGridModel(state, grid_size=10)
mod = rgm.generate_model(False, value=1, initialize=True)
pfs = rgm.model_protection_factors
dc_model = deepcopy(rgm.model)
dc_model_pf = deepcopy(rgm.model_protection_factors)
self.assertEqual(mod[1], rgm.model[1])
self.assertEqual(pfs[1], rgm.model_protection_factors[1])
rgm.change_residue(5, 4)
print("MODEL", rgm.get_model_residue(5), rgm.model[4:6], rgm.model_protection_factors[4:6])
print("REG_COPY", mod[4:6], pfs[4:6])
print("DEEP_COPY", dc_model[4:6], dc_model_pf[4:6])
mol = sys.add_macromolecule(inseq, "VDR", initialize_apo=False)
# Import data
datasets = hxio.import_HDXWorkbench(
workbench_file, # Workbench input file
macromolecule=mol,
sequence=None, # FASTA sequence string
sigma0=sigma0
) # The initial estimate for experimental SD in % deuterium untis.
print(datasets)
# Add data to molecule states and initialize models
for s in range(len(mol.get_states())):
print(s)
state = mol.get_states()[s]
state.add_dataset(datasets[s])
output_model = state.set_output_model(
model.ResidueGridModel(state, grid_size=num_exp_bins))
sys.output.initialize_output_model_file(state, output_model.pf_grids)
sampler = sampling.MCSampler(sys, sigma_sample_level="timepoint")
# First, run a short minimization step
sampler.run(250, 0.0001)
sampler.run(annealing_steps, 1)
#sampler.residue_sampler.set_adjacency(True, 4)
sampler.run(annealing_steps, 0.5)
#sampler.residue_sampler.set_adjacency(True, 3)
sampler.run(annealing_steps, 0.3)
# This temperature tends to sit around 15% MC acceptance rate, which seems to be good.
sampler.run(nsteps, 0.3, write=True)
fwd_exchange_t = 293
back_exchange_est = 0.35 # Back exchange for the entire system
back_exchange_ph = 3.0 #
back_exchange_t = 277
###########################################
####
# System Setup
sys = system.System("test_system", noclobber=False)
mol = sys.add_macromolecule(inseq, name="Test")
state = mol.get_apo_state()
# HDX model setup
hmod = model.ResidueGridModel(state, 20, protection_factors=True)
##############
# Get rates for each residue
act_sat = numpy.random.normal(saturation_est, sat_pct_error * saturation_est)
act_timepoints = [
numpy.random.normal(tp, tp * time_error) for tp in timepoints
]
fwd_rates = [-1]
back_rates = [-1]
for i in range(1, len(inseq)):
ra2 = 'A'
la2 = 'A'
if i == 1:
percentD=
False, # Is the data in percent deuterium (True) or absolute deuterons (False)
conditions=
None, # A data.Conditions object specifying pH, Temp, etc... None uses a standard set of conditions
error_estimate=
5.0, # The initial estimate for experimental SD in % deuterium untis.
n_fastamides=2, # Number of fast exchanging N-terminal amides
offset=offset
) # Numbering offset between data and FASTA file. (positive or negative integer)
# Add data to molecule state
state.add_dataset(dataset)
state1.add_dataset(dataset)
state2.add_dataset(dataset)
output_model = model.ResidueGridModel(state, grid_size=num_exp_bins)
state.set_output_model(output_model)
output_model1 = model.ResidueGridModel(state1, grid_size=num_exp_bins)
state1.set_output_model(output_model1)
output_model2 = model.ResidueGridModel(state2, grid_size=num_exp_bins)
state2.set_output_model(output_model2)
sampler = sampling.MCSampler(sys,
pct_moves=20) #, sigma_sample_level="timepoint")
sys.output.initialize_output_model_file(state, output_model.pf_grids)
sys.output.initialize_output_model_file(state1, output_model1.pf_grids)
sys.output.initialize_output_model_file(state2, output_model2.pf_grids)
sampler.run(nsteps, 2.0, write=True)
