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)