def logs_extraction(ctx, stgn):
for record in ctx.obj['records']:
mdrecord = MDDataRecord(record)
info = mdrecord.get_stage_info(stg_name=stgn)
print(info)
def _test_success(self):
print('Testing cube:', self.cube.name)
# File name
ifs = oechem.oeifstream(
os.path.join(FILE_DIR, "pP38_lig38a_2n_npt_5ns.oedb"))
for record in read_records(ifs):
pass
# Process the molecules
self.cube.process(record, self.cube.intake.name)
# Assert that one molecule was emitted on the success port
self.assertEqual(self.runner.outputs['success'].qsize(), 1)
# Assert that zero molecules were emitted on the failure port
self.assertEqual(self.runner.outputs['failure'].qsize(), 0)
# Check out the output record
record = self.runner.outputs["success"].get()
mdrecord = MDDataRecord(record)
stages = mdrecord.get_stages
self.assertEqual(len(stages), 3)
mdstate = mdrecord.get_stage_state()
parmed_structure = mdrecord.get_parmed(sync_stage_name='last')
# Calculate final volume and temperature
vol_f, temp_f = calculate_VT(mdstate, parmed_structure)
# Check 3*std volume
# Average volume and its standard deviation (in nm^3) measured along
# one 5ns run for the selected system
avg_volume = 632.4198167 * (unit.nanometers**3)
std_volume = 1.201609662
self.assertAlmostEqual(avg_volume / (unit.nanometers**3),
vol_f.in_units_of(unit.nanometers**3) /
(unit.nanometers**3),
delta=3 * std_volume)
# Check temperature
# Average temperature and its standard deviation (in K) measured along
# one 5ns run for the selected system
avg_temperature = 299.9852145 * unit.kelvin
std_temperature = 2.021052471
self.assertAlmostEqual(avg_temperature / unit.kelvin,
temp_f.in_units_of(unit.kelvin) / unit.kelvin,
delta=3 * std_temperature)
def test_set_protein_traj(self):
oetraj_record = self.record.get_value(OEField('OETraj', Types.Record))
prot_mol = oetraj_record.get_value(Fields.protein_traj_confs)
mdrecord = MDDataRecord(oetraj_record)
oetraj_record.delete_field(Fields.protein_traj_confs)
with self.assertRaises(ValueError):
mdrecord.get_protein_traj
self.assertTrue(mdrecord.set_protein_traj(prot_mol))
def setUp(self):
fname = os.path.join(FILE_DIR, "mdrecord.oedb")
ifs = oechem.oeifstream(fname)
records = []
for record in read_records(ifs):
records.append(record)
self.assertEqual(len(records), 1)
self.record = OERecord(records[0])
self.mdrecord = MDDataRecord(records[0])
self.cwd = os.getcwd()
os.chdir(FILE_DIR)
def test_protein_traj(self):
oetraj_record = self.record.get_value(OEField('OETraj', Types.Record))
prot_mol = oetraj_record.get_value(Fields.protein_traj_confs)
mdrecord = MDDataRecord(oetraj_record)
mdprot = mdrecord.get_protein_traj
self.assertEqual(prot_mol.NumAtoms(), mdprot.NumAtoms())
def test_add_new_stage(self):
new_record = OERecord(self.record)
new_mdrecord = MDDataRecord(new_record)
topology = self.mdrecord.get_stage_topology()
md_state = self.mdrecord.get_stage_state()
self.assertTrue(
new_mdrecord.add_new_stage("Testing",
MDStageTypes.FEC,
topology,
md_state,
"test.tar.gz",
log='TestingLogs'))
self.assertEqual(len(new_mdrecord.get_value(Fields.md_stages)), 4)
new_last_stage = new_mdrecord.get_stage_by_name(stg_name='Testing')
self.assertEqual(new_last_stage.get_value(Fields.stage_name),
'Testing')
self.assertEqual(new_last_stage.get_value(Fields.stage_type),
MDStageTypes.FEC)
def test_set_parmed(self):
new_record = OERecord(self.record)
new_mdrecord = MDDataRecord(new_record)
pmd = new_mdrecord.get_parmed()
new_mdrecord.delete_field(Fields.pmd_structure)
self.assertFalse(new_mdrecord.has_parmed)
new_mdrecord.set_parmed(pmd, sync_stage_name='last')
self.assertTrue(new_mdrecord.has_parmed)
def protein_extraction(ctx):
for record in ctx.obj['records']:
mdrecord = MDDataRecord(record)
if not record.has_value(Fields.protein):
print("No protein have been found in the selected record")
return
else:
title = mdrecord.get_title
fn = title.split('_')[0] + ".oeb"
with oechem.oemolostream(fn) as ofs:
oechem.OEWriteConstMolecule(ofs,
record.get_value(Fields.protein))
print("Protein file generated: {}".format(fn))
def _test_success(self):
print('Testing cube:', self.cube.name)
# Complex file name
# File name
ifs = oechem.oeifstream(os.path.join(FILE_DIR, "pbace_lcat13a.oedb"))
for record in read_records(ifs):
mdrecord = MDDataRecord(record)
stages = mdrecord.get_stages
self.assertEqual(len(stages), 1)
mdstate = mdrecord.get_stage_state()
parmed_structure = mdrecord.get_parmed(sync_stage_name='last')
# Calculate the initial potential energy
eng_i = calculate_eng(mdstate, parmed_structure)
# Process the molecules
self.cube.process(record, self.cube.intake.name)
# Assert that one molecule was emitted on the success port
self.assertEqual(self.runner.outputs['success'].qsize(), 1)
# Assert that zero molecules were emitted on the failure port
self.assertEqual(self.runner.outputs['failure'].qsize(), 0)
# Check out the output record
record = self.runner.outputs["success"].get()
mdrecord = MDDataRecord(record)
stages = mdrecord.get_stages
self.assertEqual(len(stages), 2)
mdstate = mdrecord.get_stage_state()
parmed_structure = mdrecord.get_parmed(sync_stage_name='last')
# Calculate the final potential energy
eng_f = calculate_eng(mdstate, parmed_structure)
self.assertLess(eng_f, eng_i)
def ligand_extraction(ctx):
for record in ctx.obj['records']:
mdrecord = MDDataRecord(record)
if not record.has_value(Fields.ligand):
print("No ligand have been found in the selected record")
return
else:
title = mdrecord.get_title.split("_")[1:]
title = "_".join(title)
id = mdrecord.get_flask_id
fn = title + "_" + str(id) + ".oeb"
with oechem.oemolostream(fn) as ofs:
oechem.OEWriteConstMolecule(ofs,
record.get_value(Fields.ligand))
print("Ligand file generated: {}".format(fn))
def process(self, record, port):
try:
mdrecord = MDDataRecord(record)
sys_id = mdrecord.get_lig_id
if sys_id not in self.lig_sys_ids.keys():
self.lig_sys_ids[sys_id] = [record]
else:
self.lig_sys_ids[sys_id].append(record)
except Exception as e:
print("Failed to complete", str(e), flush=True)
self.opt['Logger'].info('Exception {} {}'.format(
str(e), self.title))
self.log.error(traceback.format_exc())
self.failure.emit(record)
return
def process(self, record, port):
try:
mdrecord = MDDataRecord(record)
protein = mdrecord.get_protein
protein, ligand, water, exc = oeutils.split(protein,
ligand_res_name='LIG')
if protein.NumAtoms() == 0:
raise ValueError("The Protein Atom number is zero")
ligand = mdrecord.get_ligand
if self.opt['explicit_water']:
if self.opt['water_number'] != 0:
self.opt['Logger'].info(
"User selected number of waters: {}".format(
self.opt['water_number']))
nmax = self.opt['water_number']
else:
nmax = nmax_waters(protein, ligand, self.opt['cutoff'])
else:
self.opt['Logger'].info("MMPBSA Explicit Water set off")
nmax = 0
self.nwaters.append(nmax)
self.records.append(record)
except Exception as e:
print("Failed to complete", str(e), flush=True)
self.opt['Logger'].info('Exception {} {}'.format(
str(e), self.title))
self.log.error(traceback.format_exc())
self.failure.emit(record)
return
def process(self, record, port):
try:
opt = self.opt
opt['CubeTitle'] = self.title
if not record.has_value(Fields.md_components):
raise ValueError("MD Components Field is missing")
md_components = record.get_value(Fields.md_components)
flask, map_comp = md_components.create_flask
opt['Logger'].info(md_components.get_info)
if not record.has_value(Fields.title):
self.log.warn("Missing record Title field")
flask_title = flask.GetTitle()[0:12]
else:
flask_title = record.get_value(Fields.title)
# Parametrize the whole flask
flask_pmd_structure = md_components.parametrize_components(protein_ff=opt['protein_forcefield'],
ligand_ff=opt['ligand_forcefield'])
# Set Parmed structure box_vectors
is_periodic = True
if md_components.get_box_vectors is not None:
flask_pmd_structure.box_vectors = md_components.get_box_vectors
else:
is_periodic = False
self.log.warn("Flask {} has been parametrize without periodic box vectors ".format(flask_title))
if flask.NumAtoms() != flask_pmd_structure.topology.getNumAtoms():
raise ValueError("The flask {} and the generated Parmed structure "
"have mismatch atom numbers: {} vs {}".
format(flask_title,
flask.NumAtoms(),
flask_pmd_structure.topology.getNumAtoms()))
# Check Formal vs Partial charges
flask_formal_charge = 0
for at in flask.GetAtoms():
flask_formal_charge += at.GetFormalCharge()
flask_partial_charge = 0.0
for at in flask_pmd_structure.atoms:
flask_partial_charge += at.charge
if abs(flask_formal_charge - flask_partial_charge) > 0.01:
raise ValueError("Flask Formal charge and flask Partial charge mismatch: {} vs {}".format(
flask_formal_charge, flask_partial_charge))
# Copying the charges between the parmed structure and the oemol
for parm_at, oe_at in zip(flask_pmd_structure.atoms, flask.GetAtoms()):
if parm_at.atomic_number != oe_at.GetAtomicNum():
raise ValueError(
"Atomic number mismatch between the Parmed and the OpenEye topologies: {} - {}".
format(parm_at.atomic_number, oe_at.GetAtomicNum()))
oe_at.SetPartialCharge(parm_at.charge)
# Set the component charges
for comp_name, comp in md_components.get_components.items():
for at_comp in comp.GetAtoms():
pred = oechem.OEHasAtomIdx(map_comp[comp_name][at_comp.GetIdx()])
at_flask = flask.GetAtom(pred)
if at_flask.GetAtomicNum() != at_comp.GetAtomicNum():
"Atomic number mismatch between the component {} atom {} and the flask atom {}".\
format(comp_name, at_comp, at_flask)
at_comp.SetPartialCharge(at_flask.GetPartialCharge())
md_components.set_component_by_name(comp_name, comp)
# Update the components after setting the charges
record.set_value(Fields.md_components, md_components)
# Check if it is possible to create the OpenMM System
if is_periodic:
omm_flask = flask_pmd_structure.createSystem(nonbondedMethod=app.CutoffPeriodic,
nonbondedCutoff=10.0 * unit.angstroms,
constraints=None,
removeCMMotion=False,
rigidWater=False)
else:
omm_flask = flask_pmd_structure.createSystem(nonbondedMethod=app.NoCutoff,
constraints=None,
removeCMMotion=False,
rigidWater=False)
mdrecord = MDDataRecord(record)
sys_id = mdrecord.get_flask_id
mdrecord.set_flask(flask)
mdrecord.set_parmed(flask_pmd_structure, shard_name="Parmed_" + flask_title + '_' + str(sys_id))
data_fn = os.path.basename(mdrecord.cwd) + '_' + flask_title+'_' + str(sys_id) + '-' + opt['suffix']+'.tar.gz'
if not mdrecord.add_new_stage(MDStageNames.ForceField,
MDStageTypes.SETUP,
flask,
MDState(flask_pmd_structure),
data_fn):
raise ValueError("Problems adding the new Parametrization Stage")
self.success.emit(mdrecord.get_record)
del mdrecord
except Exception as e:
print("Failed to complete", str(e), flush=True)
self.opt['Logger'].info('Exception {} {}'.format(str(e), self.title))
self.log.error(traceback.format_exc())
self.failure.emit(record)
return
def test_compex_prep_split_floe(self):
workfloe = WorkFloeWrapper.get_workfloe(os.path.join(
FLOES_DEV_DIR, "Complex_prep.py"),
run_timeout=43200,
queue_timeout=2000)
ligand_file = DatasetWrapper.get_dataset(
os.path.join(FILE_DIR, "MCL1_lig26.oeb"))
protein_file = DatasetWrapper.get_dataset(
os.path.join(FILE_DIR, "MCL1_protein_ACE_NMA_caps.pdb"))
output_file = OutputDatasetWrapper(extension=".oedb")
fail_output_file = OutputDatasetWrapper(extension=".oedb")
workfloe.start({
"promoted": {
"ligands": ligand_file.identifier,
"protein": protein_file.identifier,
"out": output_file.identifier,
"fail": fail_output_file.identifier
}
})
self.assertWorkFloeComplete(workfloe)
fail_ifs = oechem.oeifstream()
records_fail = []
for rec_fail in read_records(fail_ifs):
records_fail.append(rec_fail)
fail_ifs.close()
count = len(records_fail)
# The fail record must be empty
self.assertEqual(count, 0)
ifs = oeifstream(output_file.path)
records = []
for rec in read_records(ifs):
records.append(rec)
ifs.close()
count = len(records)
# Check the out record list
self.assertEqual(count, 1)
# Each record should have the MD record interface
for record in records:
mdrecord = MDDataRecord(record)
self.assertTrue(record.has_value(Fields.flaskid))
self.assertTrue(record.has_value(Fields.title))
self.assertTrue(record.has_value(Fields.ligand))
self.assertTrue(record.has_value(Fields.protein))
self.assertTrue(record.has_value(Fields.primary_molecule))
self.assertTrue(record.has_value(Fields.flask))
self.assertTrue(record.has_value(Fields.md_stages))
self.assertTrue(record.has_value(Fields.pmd_structure))
self.assertEqual(mdrecord.get_flask_id, 0)
self.assertEqual(mdrecord.get_title, "pMCL1_l26")
self.assertEqual(record.get_value(Fields.ligand).NumAtoms(), 43)
self.assertEqual(record.get_value(Fields.protein).NumAtoms(), 2432)
complx = mdrecord.get_flask
protein_split, ligand_split, water, excipients = oeommutils.split(
complx)
self.assertEqual(protein_split.NumAtoms(), 2432)
self.assertEqual(ligand_split.NumAtoms(), 43)
self.assertEqual(water.NumAtoms(), 20022)
self.assertEqual(excipients.NumAtoms(), 17)
stages = mdrecord.get_stages
self.assertEqual(len(stages), 1)
stage = stages[0]
self.assertTrue(stage.has_value(Fields.stage_name))
self.assertTrue(stage.has_value(Fields.mddata))
self.assertEqual(stage.get_value(Fields.stage_type), "SETUP")
top_mol = mdrecord.get_stage_topology()
self.assertEqual(top_mol.NumAtoms(), complx.NumAtoms())
def test_omm_minimization_floe(self):
workfloe = WorkFloeWrapper.get_workfloe(os.path.join(
FLOES_DEV_DIR, "MDminimize.py"),
run_timeout=43200,
queue_timeout=2000)
system = DatasetWrapper.get_dataset(
os.path.join(FILE_DIR, "pbace_lcat13a.oedb"))
# Read input record
ifs = oeifstream(system.dataset_path)
records = []
for rec in read_records(ifs):
records.append(rec)
ifs.close()
count = len(records)
# Check the out record list
self.assertEqual(count, 1)
# Calculate the initial potential energy
for record in records:
mdrecord = MDDataRecord(record)
stages = mdrecord.get_stages
self.assertEqual(len(stages), 1)
mdstate = mdrecord.get_stage_state()
parmed_structure = mdrecord.get_parmed(sync_stage_name='last')
# Calculate the initial potential energy
eng_i = calculate_eng(mdstate, parmed_structure)
output_file = OutputDatasetWrapper(extension=".oedb")
fail_output_file = OutputDatasetWrapper(extension=".oedb")
workfloe.start({
"promoted": {
"system": system.identifier,
"out": output_file.identifier,
"fail": fail_output_file.identifier
},
"cube": {
"Minimize": {
"save_md_stage": True
}
}
})
self.assertWorkFloeComplete(workfloe)
fail_ifs = oechem.oeifstream()
records_fail = []
for rec_fail in read_records(fail_ifs):
records_fail.append(rec_fail)
fail_ifs.close()
count = len(records_fail)
# The fail record must be empty
self.assertEqual(count, 0)
# Read output record
ifs = oeifstream(output_file.path)
records = []
for rec in read_records(ifs):
records.append(rec)
ifs.close()
count = len(records)
# The records list must have just one record
self.assertEqual(count, 1)
# Calculate the final potential energy
for record in records:
mdrecord = MDDataRecord(record)
stages = mdrecord.get_stages
self.assertEqual(len(stages), 2)
mdstate = mdrecord.get_stage_state()
parmed_structure = mdrecord.get_parmed(sync_stage_name='last')
# Calculate the final potential energy
eng_f = calculate_eng(mdstate, parmed_structure)
self.assertLess(
eng_f.in_units_of(unit.kilojoule_per_mole) /
unit.kilojoule_per_mole,
eng_i.in_units_of(unit.kilojoule_per_mole) /
unit.kilojoule_per_mole)
def process(self, record, port):
try:
# The copy of the dictionary option as local variable
# is necessary to avoid filename collisions due to
# the parallel cube processes
opt = dict(self.opt)
opt['CubeTitle'] = self.title
# Logger string
str_logger = '-' * 32 + ' MIN CUBE PARAMETERS ' + '-' * 32
str_logger += "\n{:<25} = {:<10}".format("Cube Title",
opt['CubeTitle'])
for k, v in sorted(self.parameters().items()):
tmp_default = copy.deepcopy(v)
if v.default is None:
tmp_default.default = 'None'
elif isinstance(v, parameters.BooleanParameter):
if v.default:
tmp_default.default = 'True'
else:
tmp_default.default = 'False'
else:
tmp_description = textwrap.fill(" ".join(
v.description.split()),
subsequent_indent=' ' * 39,
width=80)
str_logger += "\n{:<25} = {:<10} {}".format(
k, getattr(self.args, tmp_default.name),
tmp_description)
str_logger += "\n{:<25} = {:<10}".format("Simulation Type",
opt['SimType'])
# Create the MD record to use the MD Record API
mdrecord = MDDataRecord(record)
system_title = mdrecord.get_title
opt['system_title'] = system_title
opt['system_id'] = mdrecord.get_flask_id
flask = mdrecord.get_stage_topology()
mdstate = mdrecord.get_stage_state()
if opt['restraint_to_reference']:
opt['reference_state'] = mdrecord.get_stage_state(
stg_name=MDStageNames.ForceField)
opt['out_directory'] = mdrecord.cwd
opt['molecule'] = flask
opt['str_logger'] = str_logger
opt['Logger'].info('[{}] MINIMIZING System: {}'.format(
opt['CubeTitle'], system_title))
# Extract the Parmed structure and synchronize it with the last MD stage state
parmed_structure = mdrecord.get_parmed(sync_stage_name='last')
# Run the MD simulation
new_mdstate = md_simulation(mdstate, parmed_structure, opt)
# Update the flask coordinates
flask.SetCoords(new_mdstate.get_oe_positions())
mdrecord.set_flask(flask)
data_fn = os.path.basename(
mdrecord.cwd) + '_' + opt['system_title'] + '_' + str(
opt['system_id']) + '-' + opt['suffix'] + '.tar.gz'
if not mdrecord.add_new_stage(self.title,
MDStageTypes.MINIMIZATION,
flask,
new_mdstate,
data_fn,
append=opt['save_md_stage'],
log=opt['str_logger']):
raise ValueError("Problems adding the new Minimization Stage")
self.success.emit(mdrecord.get_record)
del mdrecord
except Exception as e:
print("Failed to complete", str(e), flush=True)
self.opt['Logger'].info('Exception {} {}'.format(
str(e), self.title))
self.log.error(traceback.format_exc())
self.failure.emit(record)
return
def test_delete_parmed(self):
new_record = OERecord(self.record)
new_mdrecord = MDDataRecord(new_record)
new_mdrecord.delete_parmed
self.assertFalse(new_mdrecord.has_parmed)
def process(self, record, port):
try:
# The copy of the dictionary option as local variable
# is necessary to avoid filename collisions due to
# the parallel cube processes
opt = dict(self.opt)
opt['CubeTitle'] = self.title
# Logger string
str_logger = '-' * 32 + ' NPT CUBE PARAMETERS ' + '-' * 32
str_logger += "\n{:<25} = {:<10}".format("Cube Title",
opt['CubeTitle'])
for k, v in sorted(self.parameters().items()):
tmp_default = copy.deepcopy(v)
if v.default is None:
tmp_default.default = 'None'
elif isinstance(v, parameters.BooleanParameter):
if v.default:
tmp_default.default = 'True'
else:
tmp_default.default = 'False'
else:
tmp_description = textwrap.fill(" ".join(
v.description.split()),
subsequent_indent=' ' * 39,
width=80)
str_logger += "\n{:<25} = {:<10} {}".format(
k, getattr(self.args, tmp_default.name),
tmp_description)
str_logger += "\n{:<25} = {:<10}".format("Simulation Type",
opt['SimType'])
# Create the MD record to use the MD Record API
mdrecord = MDDataRecord(record)
system_title = mdrecord.get_title
opt['system_title'] = system_title
opt['system_id'] = mdrecord.get_flask_id
flask = mdrecord.get_stage_topology()
mdstate = mdrecord.get_stage_state()
# Update cube simulation parameters
for field in record.get_fields(include_meta=True):
field_name = field.get_name()
if field_name in ['temperature', 'pressure']:
rec_value = record.get_value(field)
opt[field_name] = rec_value
opt['Logger'].info(
"{} Updating parameters for molecule: {} {} = {}".
format(self.title, system_title, field_name,
rec_value))
if opt['restraint_to_reference']:
opt['reference_state'] = mdrecord.get_stage_state(
stg_name=MDStageNames.ForceField)
opt['out_directory'] = mdrecord.cwd
opt['molecule'] = flask
opt['str_logger'] = str_logger
opt['Logger'].info('[{}] START NPT SIMULATION: {}'.format(
opt['CubeTitle'], system_title))
opt['out_fn'] = os.path.basename(opt['out_directory']) + '_' + \
opt['system_title'] + '_' + \
str(opt['system_id']) + '-' + \
opt['suffix']
# Trajectory file name if any generated
opt['trj_fn'] = opt['out_fn'] + '_' + 'traj.tar.gz'
# Extract the Parmed structure and synchronize it with the last MD stage state
parmed_structure = mdrecord.get_parmed(sync_stage_name='last')
# Run the MD simulation
new_mdstate = md_simulation(mdstate, parmed_structure, opt)
# Update the system coordinates
flask.SetCoords(new_mdstate.get_oe_positions())
mdrecord.set_flask(flask)
# Trajectory
if opt['trajectory_interval'] or opt['trajectory_frames']:
trajectory_fn = opt['trj_fn']
if opt['md_engine'] == MDEngines.OpenMM:
trajectory_engine = MDEngines.OpenMM
else:
trajectory_engine = MDEngines.Gromacs
else: # Empty Trajectory
trajectory_fn = None
trajectory_engine = None
data_fn = opt['out_fn'] + '.tar.gz'
if not mdrecord.add_new_stage(
self.title,
MDStageTypes.NPT,
flask,
new_mdstate,
data_fn,
append=opt['save_md_stage'],
log=opt['str_logger'],
trajectory_fn=trajectory_fn,
trajectory_engine=trajectory_engine,
trajectory_orion_ui=opt['system_title'] + '_' +
str(opt['system_id']) + '-' + opt['suffix'] + '.tar.gz'):
raise ValueError("Problems adding in the new NPT Stage")
self.success.emit(mdrecord.get_record)
del mdrecord
except Exception as e:
print("Failed to complete", str(e), flush=True)
self.opt['Logger'].info('Exception {} {}'.format(
str(e), self.title))
self.log.error(traceback.format_exc())
self.failure.emit(record)
return
def process(self, record, port):
try:
opt = self.opt
# Logger string
opt['Logger'].info(' Beginning TrajPBSACube')
system_title = utl.RequestOEFieldType(record, Fields.title)
opt['Logger'].info(
'{} Attempting to compute MD Traj PBSA energies'.format(
system_title))
# Check that the OETraj analysis has been done
analysesDone = utl.RequestOEFieldType(record,
Fields.Analysis.analysesDone)
if 'OETraj' not in analysesDone:
raise ValueError(
'{} does not have OETraj analyses done'.format(
system_title))
else:
opt['Logger'].info(
'{} found OETraj analyses'.format(system_title))
# Extract the relevant traj OEMols from the OETraj record
oetrajRecord = utl.RequestOEFieldType(record,
Fields.Analysis.oetraj_rec)
opt['Logger'].info('{} found OETraj record'.format(system_title))
ligTraj = utl.RequestOEField(oetrajRecord, 'LigTraj',
Types.Chem.Mol)
opt['Logger'].info(
'{} #atoms, #confs in ligand traj OEMol: {}, {}'.format(
system_title, ligTraj.NumAtoms(), ligTraj.NumConfs()))
mdtrajrecord = MDDataRecord(oetrajRecord)
if self.opt['explicit_water']:
water_traj = oetrajRecord.get_value(
OEField('WatTraj', Types.Chem.Mol))
opt['Logger'].info(
'{} #atoms, #confs in water traj OEMol: {}, {}'.format(
system_title, water_traj.NumAtoms(),
water_traj.NumConfs()))
protTraj = mdtrajrecord.get_protein_traj
prot_wat = oechem.OEMol(protTraj.GetActive())
oechem.OEAddMols(prot_wat, water_traj.GetActive())
prot_wat.DeleteConfs()
for pr_conf, wat_conf in zip(protTraj.GetConfs(),
water_traj.GetConfs()):
pr_wat_conf = oechem.OEMol(pr_conf)
oechem.OEAddMols(pr_wat_conf, wat_conf)
pr_wat_conf_xyz = oechem.OEFloatArray(prot_wat.NumAtoms() *
3)
pr_wat_conf.GetCoords(pr_wat_conf_xyz)
prot_wat.NewConf(pr_wat_conf_xyz)
protTraj = prot_wat
else:
protTraj = mdtrajrecord.get_protein_traj
opt['Logger'].info(
'{} #atoms, #confs in protein traj OEMol: {}, {}'.format(
system_title, protTraj.NumAtoms(), protTraj.NumConfs()))
# Compute PBSA energies for the protein-ligand complex
PBSAdata = mmpbsa.TrajPBSA(ligTraj, protTraj)
if PBSAdata is None:
raise ValueError(
'{} Calculation of PBSA energies failed'.format(
system_title))
# generate Surface Areas energy for buried SA based on 0.006 kcal/mol/A^2
PBSAdata['OEZap_SA6_Bind'] = [
sa * -0.006 for sa in PBSAdata['OEZap_BuriedArea']
]
# If the OETraj Interaction Energies has been done calculate MMPBSA values
if 'TrajIntE' in analysesDone:
opt['Logger'].info(
'{} found TrajIntE analyses'.format(system_title))
# Extract the relevant P-L Interaction Energies from the record
intEdata = record.get_value(Fields.Analysis.oeintE_dict)
opt['Logger'].info(
'{} found Traj intEdata data'.format(system_title))
if self.opt['explicit_water']:
PLIntE = intEdata['protein_and_water_ligand_interE']
opt['Logger'].info(
'{} found Protein-Water and Ligand force field interaction energies'
.format(system_title))
else:
PLIntE = intEdata['protein_ligand_interE']
opt['Logger'].info(
'{} found Protein-Ligand force field interaction energies'
.format(system_title))
# Calculate and store MMPB and MMPBSA energies on the trajPBSA record
PBSAdata['OEZap_MMPB_Bind'] = [
eInt + eDesol for eInt, eDesol in zip(
PLIntE, PBSAdata['OEZap_PB_Desolvation'])
]
PBSAdata['OEZap_MMPBSA6_Bind'] = [
eMMPB + eSA6
for eMMPB, eSA6 in zip(PBSAdata['OEZap_MMPB_Bind'],
PBSAdata['OEZap_SA6_Bind'])
]
# list field and change any NaNs to a really big float
for key in PBSAdata.keys():
opt['Logger'].info(
'{} TrajPBSACube PBSAdata[{}] of length {}'.format(
system_title, key, len(PBSAdata[key])))
# change any NaNs to a really big float or else Orion WriterCube fails on JSON dict
for i, x in enumerate(PBSAdata[key]):
if math.isnan(x):
opt['Logger'].info(
'{} found a NaN at PBSAdata[{}][{}]'.format(
system_title, key, i))
PBSAdata[key][i] = magic_big_float_to_replace_NaN
# Add the PBSAdata dict to the record
record.set_value(Fields.Analysis.oepbsa_dict, PBSAdata)
analysesDone.append('TrajPBSA')
record.set_value(Fields.Analysis.analysesDone, analysesDone)
opt['Logger'].info(
'{} finished writing TrajPBSA OERecord'.format(system_title))
self.success.emit(record)
del mdtrajrecord
except Exception as e:
print("Failed to complete", str(e), flush=True)
self.opt['Logger'].info('Exception {} in TrajPBSACube'.format(
str(e)))
self.log.error(traceback.format_exc())
# Return failed mol
self.failure.emit(record)
return
class MDRecordTests(unittest.TestCase):
"""
Testing MD Record API
"""
def setUp(self):
fname = os.path.join(FILE_DIR, "mdrecord.oedb")
ifs = oechem.oeifstream(fname)
records = []
for record in read_records(ifs):
records.append(record)
self.assertEqual(len(records), 1)
self.record = OERecord(records[0])
self.mdrecord = MDDataRecord(records[0])
self.cwd = os.getcwd()
os.chdir(FILE_DIR)
@pytest.mark.travis
@pytest.mark.local
def test_get_primary(self):
mol = self.mdrecord.get_value(Fields.primary_molecule)
self.assertEqual(mol.NumAtoms(), self.mdrecord.get_primary.NumAtoms())
@pytest.mark.travis
@pytest.mark.local
def test_set_primary(self):
mol = self.mdrecord.get_value(Fields.primary_molecule)
self.assertTrue(self.mdrecord.set_primary(mol))
@pytest.mark.travis
@pytest.mark.local
def test_get_flask(self):
mol = self.mdrecord.get_value(Fields.flask)
self.assertEqual(mol.NumAtoms(), self.mdrecord.get_flask.NumAtoms())
@pytest.mark.travis
@pytest.mark.local
def test_set_flask(self):
mol = self.mdrecord.get_value(Fields.flask)
self.assertTrue(self.mdrecord.set_flask(mol))
@pytest.mark.travis
@pytest.mark.local
def test_get_flaskid(self):
id = self.mdrecord.get_value(Fields.flaskid)
self.assertEqual(id, 0)
@pytest.mark.travis
@pytest.mark.local
def test_has_flaskid(self):
self.assertTrue(self.mdrecord.has_flask_id)
@pytest.mark.travis
@pytest.mark.local
def test_set_flaskid(self):
self.mdrecord.set_flask_id(5)
self.assertEqual(self.mdrecord.get_flask_id, 5)
@pytest.mark.travis
@pytest.mark.local
def test_get_lig_id(self):
id = self.mdrecord.get_value(Fields.ligid)
self.assertEqual(id, 0)
@pytest.mark.travis
@pytest.mark.local
def test_has_lig_id(self):
self.assertTrue(self.mdrecord.has_lig_id)
@pytest.mark.travis
@pytest.mark.local
def test_set_lig_id(self):
self.mdrecord.set_lig_id(5)
self.assertEqual(self.mdrecord.get_lig_id, 5)
@pytest.mark.travis
@pytest.mark.local
def test_get_conf_id(self):
id = self.mdrecord.get_value(Fields.confid)
self.assertEqual(id, 0)
@pytest.mark.travis
@pytest.mark.local
def test_has_conf_id(self):
self.assertTrue(self.mdrecord.has_conf_id)
@pytest.mark.travis
@pytest.mark.local
def test_set_conf_id(self):
self.mdrecord.set_conf_id(5)
self.assertEqual(self.mdrecord.get_conf_id, 5)
@pytest.mark.travis
@pytest.mark.local
def test_get_title(self):
title = self.mdrecord.get_value(Fields.title)
self.assertEqual(title, 'pPRT_ltoluene')
@pytest.mark.travis
@pytest.mark.local
def test_has_tile(self):
self.assertTrue(self.mdrecord.has_title)
@pytest.mark.travis
@pytest.mark.local
def test_set_title(self):
self.mdrecord.set_title("Pippo")
self.assertEqual(self.mdrecord.get_title, 'Pippo')
@pytest.mark.travis
@pytest.mark.local
def test_get_last_stage(self):
last_stage = self.mdrecord.get_last_stage
self.assertEqual(last_stage.get_value(Fields.stage_name), 'Production')
self.assertEqual(last_stage.get_value(Fields.stage_type), 'NPT')
@pytest.mark.travis
@pytest.mark.local
def test_get_stage_by_name(self):
last_stage = self.mdrecord.get_stage_by_name()
self.assertEqual(last_stage.get_value(Fields.stage_name), 'Production')
self.assertEqual(last_stage.get_value(Fields.stage_type), 'NPT')
param_stage = self.mdrecord.get_stage_by_name(
stg_name='System Parametrization')
self.assertEqual(param_stage.get_value(Fields.stage_name),
'System Parametrization')
self.assertEqual(param_stage.get_value(Fields.stage_type), 'SETUP')
param_stage = self.mdrecord.get_stage_by_name(
stg_name='System Minimization')
self.assertEqual(param_stage.get_value(Fields.stage_name),
'System Minimization')
self.assertEqual(param_stage.get_value(Fields.stage_type),
'MINIMIZATION')
with self.assertRaises(ValueError):
self.mdrecord.get_stage_by_name('Error')
# @pytest.mark.local
# def test_delete_stage_by_name(self):
# new_record = OERecord(self.record)
# new_mdrecord = MDDataRecord(new_record)
#
# new_mdrecord.delete_stage_by_name(stg_name='System Minimization')
# self.assertFalse(new_mdrecord.has_stage_name('System Minimization'))
# self.assertEqual(len(new_mdrecord.get_stages), 2)
# TODO THIS IS GOING TO DELETE FILES LOCALLY KEEP DISABLED
@pytest.mark.travis
@pytest.mark.local
def test_has_stage_name(self):
self.assertTrue(self.mdrecord.has_stage_name('Production'))
self.assertFalse(self.mdrecord.has_stage_name('Error'))
@pytest.mark.travis
@pytest.mark.local
def test_get_stage_by_idx(self):
with self.assertRaises(ValueError):
self.mdrecord.get_stage_by_idx(5)
self.assertEqual(
self.mdrecord.get_stage_by_idx(0).get_value(Fields.stage_name),
'System Parametrization')
@pytest.mark.travis
@pytest.mark.local
def test_get_stage_state(self):
last_stage = self.mdrecord.get_last_stage
mddata_fn = os.path.join(FILE_DIR, last_stage.get_value(Fields.mddata))
with TemporaryDirectory() as out_directory:
with tarfile.open(mddata_fn) as tar:
tar.extractall(path=out_directory)
state_fn = os.path.join(out_directory, MDFileNames.state)
with open(state_fn, 'rb') as f:
md_state = pickle.load(f)
self.assertEqual(md_state.get_positions(),
self.mdrecord.get_stage_state().get_positions())
self.assertEqual(md_state.get_velocities(),
self.mdrecord.get_stage_state().get_velocities())
self.assertEqual(md_state.get_box_vectors(),
self.mdrecord.get_stage_state().get_box_vectors())
@pytest.mark.travis
@pytest.mark.local
def test_get_stage_topology(self):
par_stage = self.mdrecord.get_stage_by_idx(0)
mddata_fn = os.path.join(FILE_DIR, par_stage.get_value(Fields.mddata))
with TemporaryDirectory() as out_directory:
with tarfile.open(mddata_fn) as tar:
tar.extractall(path=out_directory)
topology_fn = os.path.join(out_directory, MDFileNames.topology)
topology_mol = oechem.OEMol()
with oechem.oemolistream(topology_fn) as ifs:
oechem.OEReadMolecule(ifs, topology_mol)
topology = self.mdrecord.get_stage_topology(
stg_name='System Parametrization')
for mol_at, top_at in zip(topology_mol.GetAtoms(),
topology.GetAtoms()):
self.assertEqual(mol_at.GetAtomicNum(), top_at.GetAtomicNum())
@pytest.mark.travis
@pytest.mark.local
def test_get_stage_info(self):
last_stage = self.mdrecord.get_last_stage
info = last_stage.get_value(Fields.log_data)
self.assertEqual(info, self.mdrecord.get_stage_info())
min_stage = self.mdrecord.get_stage_by_name(
stg_name='System Minimization')
info = min_stage.get_value(Fields.log_data)
self.assertEqual(
info, self.mdrecord.get_stage_info(stg_name='System Minimization'))
@pytest.mark.travis
@pytest.mark.local
def test_get_stage_trajectory(self):
self.assertTrue(os.path.isfile(self.mdrecord.get_stage_trajectory()))
@pytest.mark.travis
@pytest.mark.local
def test_add_new_stage(self):
new_record = OERecord(self.record)
new_mdrecord = MDDataRecord(new_record)
topology = self.mdrecord.get_stage_topology()
md_state = self.mdrecord.get_stage_state()
self.assertTrue(
new_mdrecord.add_new_stage("Testing",
MDStageTypes.FEC,
topology,
md_state,
"test.tar.gz",
log='TestingLogs'))
self.assertEqual(len(new_mdrecord.get_value(Fields.md_stages)), 4)
new_last_stage = new_mdrecord.get_stage_by_name(stg_name='Testing')
self.assertEqual(new_last_stage.get_value(Fields.stage_name),
'Testing')
self.assertEqual(new_last_stage.get_value(Fields.stage_type),
MDStageTypes.FEC)
@pytest.mark.travis
@pytest.mark.local
def test_get_stages(self):
stages = self.mdrecord.get_stages
self.assertEqual(len(stages), 3)
@pytest.mark.travis
@pytest.mark.local
def test_get_stages_names(self):
ls_names = [
'System Parametrization', 'System Minimization', 'Production'
]
stg_names = self.mdrecord.get_stages_names
self.assertEqual(stg_names, ls_names)
@pytest.mark.travis
@pytest.mark.local
def test_has_stages(self):
self.assertTrue(self.mdrecord.has_stages)
@pytest.mark.travis
@pytest.mark.local
def test_get_parmed(self):
pmd = self.mdrecord.get_parmed(sync_stage_name='last')
self.assertEqual(len(pmd.atoms), 30439)
self.assertEqual((len(pmd.residues)), 9446)
self.assertEqual((len(pmd.bonds)), 21178)
self.assertEqual((len(pmd.angles)), 14069)
self.assertEqual((len(pmd.dihedrals)), 8028)
@pytest.mark.travis
@pytest.mark.local
def test_set_parmed(self):
new_record = OERecord(self.record)
new_mdrecord = MDDataRecord(new_record)
pmd = new_mdrecord.get_parmed()
new_mdrecord.delete_field(Fields.pmd_structure)
self.assertFalse(new_mdrecord.has_parmed)
new_mdrecord.set_parmed(pmd, sync_stage_name='last')
self.assertTrue(new_mdrecord.has_parmed)
@pytest.mark.travis
@pytest.mark.local
def test_has_parmed(self):
self.assertTrue(self.mdrecord.has_parmed)
@pytest.mark.travis
@pytest.mark.local
def test_delete_parmed(self):
new_record = OERecord(self.record)
new_mdrecord = MDDataRecord(new_record)
new_mdrecord.delete_parmed
self.assertFalse(new_mdrecord.has_parmed)
@pytest.mark.travis
@pytest.mark.local
def test_protein_traj(self):
oetraj_record = self.record.get_value(OEField('OETraj', Types.Record))
prot_mol = oetraj_record.get_value(Fields.protein_traj_confs)
mdrecord = MDDataRecord(oetraj_record)
mdprot = mdrecord.get_protein_traj
self.assertEqual(prot_mol.NumAtoms(), mdprot.NumAtoms())
@pytest.mark.travis
@pytest.mark.local
def test_set_protein_traj(self):
oetraj_record = self.record.get_value(OEField('OETraj', Types.Record))
prot_mol = oetraj_record.get_value(Fields.protein_traj_confs)
mdrecord = MDDataRecord(oetraj_record)
oetraj_record.delete_field(Fields.protein_traj_confs)
with self.assertRaises(ValueError):
mdrecord.get_protein_traj
self.assertTrue(mdrecord.set_protein_traj(prot_mol))
def process(self, record, port):
try:
opt = self.opt
# Logger string
opt['Logger'].info(' Beginning TrajInteractionEnergyCube')
mdrecord = MDDataRecord(record)
system_title = mdrecord.get_title
opt['Logger'].info(
'{} Attempting to compute MD Traj protein-ligand Interaction energies'
.format(system_title))
# Check that the OETraj analysis has been done
analysesDone = utl.RequestOEFieldType(record,
Fields.Analysis.analysesDone)
if 'OETraj' not in analysesDone:
raise ValueError(
'{} does not have OETraj analyses done'.format(
system_title))
else:
opt['Logger'].info(
'{} found OETraj analyses'.format(system_title))
# Extract the relevant traj OEMols from the OETraj record
oetrajRecord = utl.RequestOEFieldType(record,
Fields.Analysis.oetraj_rec)
opt['Logger'].info('{} found OETraj record'.format(system_title))
ligTraj = utl.RequestOEField(oetrajRecord, 'LigTraj',
Types.Chem.Mol)
opt['Logger'].info(
'{} #atoms, #confs in ligand traj OEMol: {}, {}'.format(
system_title, ligTraj.NumAtoms(), ligTraj.NumConfs()))
mdtrajrecord = MDDataRecord(oetrajRecord)
protTraj = mdtrajrecord.get_protein_traj
opt['Logger'].info(
'{} #atoms, #confs in protein traj OEMol: {}, {}'.format(
system_title, protTraj.NumAtoms(), protTraj.NumConfs()))
water_traj = oetrajRecord.get_value(
OEField('WatTraj', Types.Chem.Mol))
opt['Logger'].info(
'{} #atoms, #confs in water traj OEMol: {}, {}'.format(
system_title, water_traj.NumAtoms(),
water_traj.NumConfs()))
prmed = mdrecord.get_parmed(sync_stage_name='last')
# Compute interaction energies for the protein, ligand, complex and water subsystems
intEdata = mmpbsa.ProtLigWatInteractionEFromParmedOETraj(
prmed, ligTraj, protTraj, water_traj, opt)
if intEdata is None:
raise ValueError(
'{} Calculation of Interaction Energies failed'.format(
system_title))
# protein and ligand traj OEMols now have parmed charges on them; save these
oetrajRecord.set_value(OEField('LigTraj', Types.Chem.Mol), ligTraj)
record.set_value(Fields.Analysis.oetraj_rec, oetrajRecord)
# list the energy terms in the intEdata dict to be stored on the record
for key in intEdata.keys():
opt['Logger'].info('{} traj intEdata[{}] of length {}'.format(
system_title, key, len(intEdata[key])))
# change any NaNs to a really big float or else Orion WriterCube fails on JSON dict
for i, x in enumerate(intEdata[key]):
if math.isnan(x):
opt['Logger'].info(
'{} found a NaN at intEdata[{}][{}]'.format(
system_title, key, i))
intEdata[key][i] = magic_big_float_to_replace_NaN
# Add the intEdata dict to the record
record.set_value(Fields.Analysis.oeintE_dict, intEdata)
# Add the trajIntE record to the parent record
#record.set_value(Fields.Analysis.oeintE_rec, trajIntE)
analysesDone.append('TrajIntE')
record.set_value(Fields.Analysis.analysesDone, analysesDone)
opt['Logger'].info(
'{} finished writing trajIntE OERecord'.format(system_title))
self.success.emit(record)
del mdrecord
del mdtrajrecord
except Exception as e:
print("Failed to complete", str(e), flush=True)
opt['Logger'].info(
'Exception {} in TrajInteractionEnergyCube on {}'.format(
str(e), system_title))
self.log.error(traceback.format_exc())
# Return failed mol
self.failure.emit(record)
return
def process(self, record, port):
try:
# The copy of the dictionary option as local variable
# is necessary to avoid filename collisions due to
# the parallel cube processes
opt = dict(self.opt)
# Logger string
opt['Logger'].info(' Beginning ConfTrajsToLigTraj')
system_title = utl.RequestOEFieldType(record, Fields.title)
opt['Logger'].info(
'{} Attempting to combine conf traj OEMols into ligand traj OEMol'
.format(system_title))
# Go find the ligand and LigTraj fields in each of the conformer records
if not record.has_field(Fields.Analysis.oetrajconf_rec):
raise ValueError(
'{} could not find the conformer record'.format(
system_title))
else:
opt['Logger'].info(
'{} found the conformer record'.format(system_title))
# set up ligand and LigTraj lists then loop over conformer records
poseIdVec = []
ligTrajConfs = []
protTrajConfs = []
watTrajConfs = []
list_conf_rec = record.get_value(Fields.Analysis.oetrajconf_rec)
for confrec in list_conf_rec:
confid = utl.RequestOEFieldType(confrec, Fields.confid)
if not confrec.has_field(Fields.Analysis.oetraj_rec):
raise ValueError(
'{} confID {}: could not find traj record'.format(
system_title, confid))
oetrajRecord = confrec.get_value(Fields.Analysis.oetraj_rec)
# Extract the ligand traj OEMol from the OETraj record
ligTraj = utl.RequestOEField(oetrajRecord, 'LigTraj',
Types.Chem.Mol)
poseIdVec += [confid] * ligTraj.NumConfs()
ligTrajConfs.append(ligTraj)
opt['Logger'].info(
'{} confID {}: adding ligTraj with {} atoms, {} confs'.
format(system_title, confid, ligTraj.NumAtoms(),
ligTraj.NumConfs()))
# Extract the activeSite water traj OEMol from the OETraj record
watTraj = utl.RequestOEField(oetrajRecord, 'WatTraj',
Types.Chem.Mol)
watTrajConfs.append(watTraj)
opt['Logger'].info(
'{} confID {}: adding watTraj with {} atoms, {} confs'.
format(system_title, confid, watTraj.NumAtoms(),
watTraj.NumConfs()))
# Extract the protTraj OEMol from the OETraj record
mdtrajrecord = MDDataRecord(oetrajRecord)
protTraj = mdtrajrecord.get_protein_traj
protTrajConfs.append(protTraj)
opt['Logger'].info(
'{} confID {}: adding protTraj with {} atoms, {} confs'.
format(system_title, confid, protTraj.NumAtoms(),
protTraj.NumConfs()))
del mdtrajrecord
if len(ligTrajConfs) < 1 or len(protTrajConfs) < 1:
raise ValueError(
'{} empty list of lig or protein trajectory OEMols'.format(
system_title))
ligTraj = oechem.OEMol(ligTrajConfs[0])
xyz = oechem.OEFloatArray(3 * ligTraj.GetMaxAtomIdx())
for trajMol in ligTrajConfs[1:]:
for conf in trajMol.GetConfs():
conf.GetCoords(xyz)
ligTraj.NewConf(xyz)
opt['Logger'].info(
'{} composite ligTraj has {} atoms, {} confs'.format(
system_title, ligTraj.NumAtoms(), ligTraj.NumConfs()))
watTraj = oechem.OEMol(watTrajConfs[0])
xyz = oechem.OEFloatArray(3 * watTraj.GetMaxAtomIdx())
for trajMol in watTrajConfs[1:]:
for conf in trajMol.GetConfs():
conf.GetCoords(xyz)
watTraj.NewConf(xyz)
opt['Logger'].info(
'{} composite watTraj has {} atoms, {} confs'.format(
system_title, watTraj.NumAtoms(), watTraj.NumConfs()))
protTraj = protTrajConfs[0]
xyz = oechem.OEFloatArray(3 * protTraj.GetMaxAtomIdx())
for trajMol in protTrajConfs[1:]:
for conf in trajMol.GetConfs():
conf.GetCoords(xyz)
protTraj.NewConf(xyz)
opt['Logger'].info(
'{} composite protTraj has {} atoms, {} confs'.format(
system_title, protTraj.NumAtoms(), protTraj.NumConfs()))
record.set_value(Fields.Analysis.poseIdVec, poseIdVec)
# Create new record with OETraj results
oetrajRecord = OERecord()
oetrajRecord.set_value(OEField('LigTraj', Types.Chem.Mol), ligTraj)
if watTraj:
oetrajRecord.set_value(OEField('WatTraj', Types.Chem.Mol),
watTraj)
if in_orion():
collection_id = utl.RequestOEFieldType(record,
Fields.collection)
oetrajRecord.set_value(Fields.collection, collection_id)
mdrecord_traj = MDDataRecord(oetrajRecord)
mdrecord_traj.set_protein_traj(protTraj,
shard_name="ProteinTrajConfs_")
record.set_value(Fields.Analysis.oetraj_rec, oetrajRecord)
self.success.emit(record)
except Exception as e:
print("Failed to complete", str(e), flush=True)
opt['Logger'].info(
'Exception {} in ConfTrajsToLigTraj on {}'.format(
str(e), system_title))
self.log.error(traceback.format_exc())
# Return failed mol
self.failure.emit(record)
return
def test_gmx_npt_floe(self):
workfloe = WorkFloeWrapper.get_workfloe(os.path.join(
FLOES_DEV_DIR, "MDnpt.py"),
run_timeout=43200,
queue_timeout=2000)
system = DatasetWrapper.get_dataset(
os.path.join(FILE_DIR, "pP38_lig38a_2n_npt_5ns.oedb"))
output_file = OutputDatasetWrapper(extension=".oedb")
fail_output_file = OutputDatasetWrapper(extension=".oedb")
workfloe.start({
"promoted": {
"system": system.identifier,
"md_engine": "Gromacs",
"nanoseconds": 0.01,
"temperature": 300.0,
"pressure": 1.0,
"trajectory_interval": 0.0,
"reporter_interval": 0.0,
"out": output_file.identifier,
"fail": fail_output_file.identifier
},
"cube": {
"npt": {
"save_md_stage": True,
"constraints": "H-Bonds",
"restraints": "",
"nonbondedCutoff": 10.0
}
}
})
self.assertWorkFloeComplete(workfloe)
fail_ifs = oechem.oeifstream()
records_fail = []
for rec_fail in read_records(fail_ifs):
records_fail.append(rec_fail)
fail_ifs.close()
count = len(records_fail)
# The fail record must be empty
self.assertEqual(count, 0)
ifs = oeifstream(output_file.path)
records = []
for rec in read_records(ifs):
records.append(rec)
ifs.close()
count = len(records)
# Check the out record list
self.assertEqual(count, 1)
for record in records:
mdrecord = MDDataRecord(record)
stages = mdrecord.get_stages
self.assertEqual(len(stages), 3)
def process(self, record, port):
try:
# The copy of the dictionary option as local variable
# is necessary to avoid filename collisions due to
# the parallel cube processes
opt = dict(self.opt)
# Create the MD record to use the MD Record API
mdrecord = MDDataRecord(record)
# Logger string
opt['Logger'].info(' ')
system_title = mdrecord.get_title
#sys_id = mdrecord.get_flask_id
opt['Logger'].info(
'{}: Attempting MD Traj conversion into OEMols'.format(
system_title))
traj_fn = mdrecord.get_stage_trajectory()
opt['Logger'].info('{} Temp Directory: {}'.format(
system_title, os.path.dirname(traj_fn)))
opt['Logger'].info('{} Trajectory filename: {}'.format(
system_title, traj_fn))
# Generate multi-conformer protein and ligand OEMols from the trajectory
opt['Logger'].info(
'{} Generating protein and ligand trajectory OEMols'.format(
system_title))
flask = mdrecord.get_flask
md_components = record.get_value(Fields.md_components)
# opt['Logger'].info(md_components.get_info)
# Check Ligand Isomeric Smiles
lig_comp = md_components.get_ligand
lig_ref = record.get_value(Fields.ligand)
smi_lig_comp = oechem.OECreateSmiString(lig_comp)
smi_lig_ref = oechem.OECreateSmiString(lig_ref)
if smi_lig_ref != smi_lig_comp:
raise ValueError(
"Ligand Isomeric Smiles String check failure: {} vs {}".
format(smi_lig_comp, smi_lig_ref))
ptraj, ltraj, wtraj = utl.extract_aligned_prot_lig_wat_traj(
md_components,
flask,
traj_fn,
opt,
water_cutoff=opt['water_cutoff'])
ltraj.SetTitle(record.get_value(Fields.ligand_name))
ptraj.SetTitle(record.get_value(Fields.protein_name))
opt['Logger'].info(
'{} #atoms, #confs in protein traj OEMol: {}, {}'.format(
system_title, ptraj.NumAtoms(), ptraj.NumConfs()))
opt['Logger'].info(
'{} #atoms, #confs in ligand traj OEMol: {}, {}'.format(
system_title, ltraj.NumAtoms(), ltraj.NumConfs()))
opt['Logger'].info(
'{} #atoms, #confs in water traj OEMol: {}, {}'.format(
system_title, wtraj.NumAtoms(), wtraj.NumConfs()))
# Create new record with OETraj results
oetrajRecord = OERecord()
oetrajRecord.set_value(OEField('LigTraj', Types.Chem.Mol), ltraj)
if wtraj:
oetrajRecord.set_value(OEField('WatTraj', Types.Chem.Mol),
wtraj)
if in_orion():
oetrajRecord.set_value(Fields.collection,
mdrecord.collection_id)
mdrecord_traj = MDDataRecord(oetrajRecord)
mdrecord_traj.set_protein_traj(ptraj,
shard_name="ProteinTrajConfs_")
record.set_value(Fields.Analysis.oetraj_rec, oetrajRecord)
# update or initiate the list of analyses that have been done
if record.has_value(Fields.Analysis.analysesDone):
analysesDone = utl.RequestOEFieldType(
record, Fields.Analysis.analysesDone)
analysesDone.append('OETraj')
else:
analysesDone = ['OETraj']
record.set_value(Fields.Analysis.analysesDone, analysesDone)
opt['Logger'].info(
'{}: saved protein, ligand and water traj OEMols'.format(
system_title))
self.success.emit(record)
del mdrecord
del mdrecord_traj
except Exception as e:
print("Failed to complete", str(e), flush=True)
self.log.error(traceback.format_exc())
# Return failed mol
self.failure.emit(record)
return
def data_trajectory_extraction(ctx, name, only):
check_only = ['a', 'stages', 'parmed', 'protein_confs']
for v in only:
if v not in check_only:
raise ValueError(
"The only keyword value is not recognized {}. Option available: {}"
.format(only, check_only[1:]))
session = ctx.obj['session']
ofs = oechem.oeofstream(name)
for record in tqdm(ctx.obj['records']):
new_record = OERecord(record)
if not record.has_field(Fields.collection):
raise ValueError(
"No Collection field has been found in the record")
collection_id = record.get_value(Fields.collection)
collection = session.get_resource(ShardCollection, collection_id)
new_stages = []
if 'a' in only or 'stages' in only:
mdrecord = MDDataRecord(record)
stages = mdrecord.get_stages
system_title = mdrecord.get_title
sys_id = mdrecord.get_flask_id
for stage in stages:
stg_type = stage.get_value(Fields.stage_type)
new_stage = OERecord(stage)
with TemporaryDirectory() as output_directory:
data_fn = os.path.basename(
output_directory) + '_' + system_title + '_' + str(
sys_id) + '-' + stg_type + '.tar.gz'
shard_id = stage.get_value(
OEField("MDData_OPLMD", Types.Int))
shard = session.get_resource(Shard(collection=collection),
shard_id)
shard.download_to_file(data_fn)
new_stage.delete_field(OEField("MDData_OPLMD", Types.Int))
new_stage.set_value(Fields.mddata, data_fn)
if stage.has_field(OEField("Trajectory_OPLMD", Types.Int)):
trj_field = stage.get_field("Trajectory_OPLMD")
trj_meta = trj_field.get_meta()
md_engine = trj_meta.get_attribute(
Meta.Annotation.Description)
trj_id = stage.get_value(trj_field)
trj_fn = os.path.basename(
output_directory) + '_' + system_title + '_' + str(
sys_id) + '-' + stg_type + '_traj' + '.tar.gz'
resource = session.get_resource(File, trj_id)
resource.download_to_file(trj_fn)
trj_meta = OEFieldMeta()
trj_meta.set_attribute(Meta.Annotation.Description,
md_engine)
new_trj_field = OEField(Fields.trajectory.get_name(),
Fields.trajectory.get_type(),
meta=trj_meta)
new_stage.delete_field(
OEField("Trajectory_OPLMD", Types.Int))
new_stage.set_value(new_trj_field, trj_fn)
new_stages.append(new_stage)
new_record.set_value(Fields.md_stages, new_stages)
if 'a' in only or 'parmed' in only:
if record.has_field(OEField('Structure_Parmed_OPLMD', Types.Int)):
pmd_id = record.get_value(
OEField('Structure_Parmed_OPLMD', Types.Int))
shard = session.get_resource(Shard(collection=collection),
pmd_id)
with TemporaryDirectory() as output_directory:
parmed_fn = os.path.join(output_directory, "parmed.pickle")
shard.download_to_file(parmed_fn)
with open(parmed_fn, 'rb') as f:
parm_dic = pickle.load(f)
pmd_structure = parmed.structure.Structure()
pmd_structure.__setstate__(parm_dic)
new_record.delete_field(
OEField('Structure_Parmed_OPLMD', Types.Int))
new_record.set_value(Fields.pmd_structure, pmd_structure)
if 'a' in only or 'protein_confs' in only:
if record.has_field(OEField('OETraj', Types.Record)):
oetrajrec = record.get_value(OEField('OETraj', Types.Record))
prot_conf_id = oetrajrec.get_value(
OEField("ProtTraj_OPLMD", Types.Int))
shard = session.get_resource(Shard(collection=collection),
prot_conf_id)
with TemporaryDirectory() as output_directory:
protein_fn = os.path.join(output_directory,
"prot_traj_confs.oeb")
shard.download_to_file(protein_fn)
protein_conf = oechem.OEMol()
with oechem.oemolistream(protein_fn) as ifs:
oechem.OEReadMolecule(ifs, protein_conf)
oetrajrec.delete_field(OEField('ProtTraj_OPLMD', Types.Int))
oetrajrec.set_value(Fields.protein_traj_confs, protein_conf)
new_record.set_value(OEField('OETraj', Types.Record),
oetrajrec)
new_record.delete_field(Fields.collection)
OEWriteRecord(ofs, new_record, fmt='binary')
ofs.close()
def test_omm_npt_floe(self):
workfloe = WorkFloeWrapper.get_workfloe(os.path.join(
FLOES_DEV_DIR, "MDnpt.py"),
run_timeout=43200,
queue_timeout=2000)
system = DatasetWrapper.get_dataset(
os.path.join(FILE_DIR, "pP38_lig38a_2n_npt_5ns.oedb"))
output_file = OutputDatasetWrapper(extension=".oedb")
fail_output_file = OutputDatasetWrapper(extension=".oedb")
workfloe.start({
"promoted": {
"system": system.identifier,
"nanoseconds": 0.01,
"temperature": 300.0,
"pressure": 1.0,
"trajectory_interval": 0.0,
"reporter_interval": 0.0,
"out": output_file.identifier,
"fail": fail_output_file.identifier
},
"cube": {
"npt": {
"save_md_stage": True,
"constraints": "H-Bonds",
"restraints": "",
"nonbondedCutoff": 10.0
}
}
})
self.assertWorkFloeComplete(workfloe)
fail_ifs = oechem.oeifstream()
records_fail = []
for rec_fail in read_records(fail_ifs):
records_fail.append(rec_fail)
fail_ifs.close()
count = len(records_fail)
# The fail record must be empty
self.assertEqual(count, 0)
ifs = oeifstream(output_file.path)
records = []
for rec in read_records(ifs):
records.append(rec)
ifs.close()
count = len(records)
# Check the out record list
self.assertEqual(count, 1)
for record in records:
mdrecord = MDDataRecord(record)
stages = mdrecord.get_stages
self.assertEqual(len(stages), 3)
mdstate = mdrecord.get_stage_state()
parmed_structure = mdrecord.get_parmed(sync_stage_name='last')
# Calculate final volume and temperature
vol_f, temp_f = calculate_VT(mdstate, parmed_structure)
# Check 3*std volume
# Average volume and its standard deviation (in nm^3) measured along
# one 5ns run for the selected system
avg_volume = 632.4198167 * (unit.nanometers**3)
std_volume = 1.201609662
self.assertAlmostEqual(avg_volume / (unit.nanometers**3),
vol_f.in_units_of(unit.nanometers**3) /
(unit.nanometers**3),
delta=3 * std_volume)
# Check temperature
# Average temperature and its standard deviation (in K) measured along
# one 5ns run for the selected system
avg_temperature = 299.9852145 * unit.kelvin
std_temperature = 2.021052471
self.assertAlmostEqual(avg_temperature / unit.kelvin,
temp_f.in_units_of(unit.kelvin) /
unit.kelvin,
delta=3 * std_temperature)
