def _CDPLgenerateConformation(cdpl_mol): ''' PRIVAT METHOD configures a CDPL Molecule for conformation generation. \n Input: \n mol (CDPL BasicMolecule): a CDPL BasicMolecule \n Return: \n (CDPL BasicMolecule): the corresponding random conf. for the input BasicMolecule ''' _CDPLconfigForConformation( cdpl_mol ) #TODO What exactly should be in the config for the cmp generation? cg = ConfGen.RandomConformerGenerator() coords = Math.Vector3DArray() i = 0 cg.strictMMFF94AtomTyping = False ConfGen.prepareForConformerGeneration(cdpl_mol) coords.resize(cdpl_mol.numAtoms, Math.Vector3D()) cg.setup(cdpl_mol) if cg.generate(coords) != ConfGen.RandomConformerGenerator.SUCCESS: log.error('! Conformer generation failed !') return Chem.set3DCoordinates(cdpl_mol, coords) return cdpl_mol
def calcMSF(positions, mean_pos): msf = 0.0 tmp = Math.Vector3D() for pos in positions: tmp.assign(pos) tmp -= mean_pos msf += Math.innerProd(tmp, tmp) msf = msf / len(positions) return msf
def calcMaxFluct(positions, mean_pos): max_fluct = 0.0 tmp = Math.Vector3D() for pos in positions: tmp.assign(pos) tmp -= mean_pos dev = Math.norm2(tmp) if dev > max_fluct: max_fluct = dev return max_fluct
def calcMeanPos(positions): mean_pos = Math.Vector3D() for pos in positions: mean_pos += pos mean_pos /= len(positions) return mean_pos
def __init__(self, structure: Chem.BasicMolecule = None): self.shape: Shape.GaussianShape = Shape.GaussianShape() self.shapeFunc: Shape.GaussianShapeFunction = Shape.GaussianShapeFunction() self.coordinates: Math.Vector3DArray = Math.Vector3DArray() self.ligands: List[Chem.BasicMolecule] = [] super(Protein, self).__init__() if structure: self.assign(structure)
def translate_mol_to_coords(mol, coords): mol_coords = Math.Vector3DArray() Chem.get3DCoordinates(mol, mol_coords) for i, row in enumerate(mol_coords): for j, column in enumerate(row): row[j] = column - coords[j] # shift to desired coordinates Chem.set3DCoordinates(mol, mol_coords) return mol
def makeRandomRotation(self, inplace: bool = True) -> Math.Vector3DArray: # TODO: maybe add boundaries for randomness rotMatrix = Math.Matrix3D() rotMatrix.assign(Rotation.random().as_matrix()) rotatedCoords = rotate3DObject(self.getCoordinates(), rotMatrix) if inplace: Chem.set3DCoordinates(self, rotatedCoords) return rotatedCoords
def calcAtomSetCentroid(atoms, conf_idx): if len(atoms) == 1: return Chem.getConformer3DCoordinates(atoms[0], conf_idx) ctr = Math.Vector3D() for atom in atoms: ctr += Chem.getConformer3DCoordinates(atom, conf_idx) ctr /= len(atoms) return ctr
def __init__(self, structure: Chem.BasicMolecule = None): self.shape: Shape.GaussianShape = Shape.GaussianShape() self.shapeFunc: Shape.GaussianShapeFunction = Shape.GaussianShapeFunction( ) self.coordinates: Math.Vector3DArray = Math.Vector3DArray() self.ligands: List[Chem.BasicMolecule] = [] self.surfaceAtoms: Chem.BasicMolecule = Chem.BasicMolecule() super(Protein, self).__init__() if structure: from MoleculeTools import sanitize_mol self.assign(structure)
def calcLonePairPosition(atom, mol, coords): lp_pos = Math.Vector3D() atom_pos = coords[mol.getAtomIndex(atom)] for nbr_atom in atom.atoms: lp_pos -= coords[mol.getAtomIndex(nbr_atom)] lp_pos -= atom_pos lp_pos /= atom.getNumAtoms() lp_pos += atom_pos return lp_pos
def process(): if len(sys.argv) < 4: print >> sys.stderr, 'Usage:', sys.argv[ 0], '[input.cdf] [output directory] [frame index]' sys.exit(2) print >> sys.stderr, '> Processing grid CDF-file:', sys.argv[1], '...' index_frame = int(sys.argv[3]) grid_set = Grid.DRegularGridSet() cdf_grid_reader = Grid.FileCDFDRegularGridSetReader(sys.argv[1]) print >> sys.stderr, '> Writing grid data for frame', index_frame, '...\n' grid_set.clear() if not cdf_grid_reader.read(index_frame, grid_set): print '> No grid in file.' sys.exit(2) coord = Math.Vector3D() for grid in grid_set: int_descr = Grid.getName(grid) out_fname = path.splitext( path.basename(sys.argv[1]) )[0] + '_' + int_descr + '_frame_no_' + sys.argv[3] + '.kont' out_path = path.join(sys.argv[2], out_fname) kont_file = open(out_path, 'w') index_mol = 0 grid_values = [] print '>', int_descr, 'grid' for k in range(grid.getSize3()): for i in range(grid.getSize1()): for j in range(grid.getSize2()): index_mol += 1 grid_values.append(grid(i, j, k)) grid.getCoordinates(i, j, k, coord) kont_file.write( "{:>7} {:>7.3f} {:>7.3f} {:>7.3f}\n".format( index_mol, coord[0], coord[1], coord[2])) kont_file.write("{:>8}\n".format(int_descr)) for txt in grid_values: kont_file.write("{:>8.3f}\n".format(txt)) kont_file.close()
def center_mol(mol): coords = Math.Vector3DArray() Chem.get3DCoordinates(mol, coords) np_coords = np.array(coords) centroid = get_centroid(np_coords) centered = np_coords - centroid # set coordinates coordinate object for i, row in enumerate(coords): for j, column in enumerate(row): row[j] = centered[i, j] # set coordinates to molecule Chem.set3DCoordinates(mol, coords) return mol
def cdfMol_pdb(pdb, output, name): initial_time = time.time() cdf_mol = Chem.BasicMolecule() pdb_mol = Chem.BasicMolecule() pdb_str = open(pdb, 'r').read().replace('WAT', 'HOH').replace('HIE', 'HIS') pdb_reader = Biomol.PDBMoleculeReader(Base.StringIOStream(pdb_str)) Biomol.setPDBApplyDictAtomBondingToNonStdResiduesParameter( pdb_reader, True) if not pdb_reader.read(pdb_mol): return None Chem.calcImplicitHydrogenCounts(pdb_mol, False) Chem.perceiveHybridizationStates(pdb_mol, False) Chem.setAtomSymbolsFromTypes(pdb_mol, False) Chem.perceiveSSSR(pdb_mol, False) Chem.setRingFlags(pdb_mol, False) Chem.setAromaticityFlags(pdb_mol, False) cdf_mol.assign(pdb_mol) for atom in cdf_mol.atoms: Chem.set3DCoordinatesArray(atom, Math.Vector3DArray()) i = 0 while i < cdf_mol.numAtoms: Chem.get3DCoordinatesArray(cdf_mol.getAtom(i)).addElement( Chem.get3DCoordinates(pdb_mol.getAtom(i))) i += 1 tmp_output = output + name + ".cdf" try: Chem.FileCDFMolecularGraphWriter(tmp_output).write(cdf_mol) except: print('> Cdf_mol writing failure.') raise residues = Biomol.ResidueList(cdf_mol) tmp_output = output + name + "_residue_info.txt" with open(tmp_output, 'w') as txt_writer: txt_writer.write('residue name_resid_chain\n') for res in residues: res_id = getResidueID(res) txt_writer.write('{}: \n'.format(res_id)) calc_time = time.time() - initial_time print('> Cdf and amino acid residue number list files generated in {}s'. format(int(calc_time)))
def makeRandomTranslation(self, inplace: bool = True, scalingFactor: float = 10) -> Math.Vector3DArray: """ :param inplace: :param scalingFactor: Scales the randomly retrieved direction by this factor :return: """ direction = Math.Vector3D() direction.assign(np.random.rand(3) * scalingFactor) translatedCoords = translate3DObject(self.getCoordinates(), direction) if inplace: Chem.set3DCoordinates(self, translatedCoords) return translatedCoords
def generateSurfacePoints(self, scaleFactor: float = 1, density: float = 1) -> Math.Vector3DArray: """ Get an array of coordinates corresponding to surface exposed atoms in the protein. Points are placed on the vdw surface of the atoms. :param scaleFactor: Scales the VDW radius. Points are set at a distance proportional to this factor. :param density: Determines the density of points representing the atom surface per square angstrom. :return: """ from pyvdwsurface import vdwsurface atomTypes = [Chem.getSymbol(a) for a in self.atoms] points = vdwsurface(self.getCoordinates(), atomTypes, scale_factor=scaleFactor, double_density=density) surfacePointCoordinates = Math.Vector3DArray() surfacePointCoordinates.assign(points) return surfacePointCoordinates
import CDPL.Base as Base import CDPL.Chem as Chem import CDPL.Math as Math def process(): if len(sys.argv) < 4: print('Usage:', sys.argv[0], 'training-set.sdf logP-data regression-coeff-file', file=sys.stderr) sys.exit(2) struct_is = Base.FileIOStream(sys.argv[1], 'r') exp_logp_is = Base.FileIOStream(sys.argv[2], 'r') coeff_os = Base.FileIOStream(sys.argv[3], 'w') mlr_model = Math.DMLRModel() sdf_reader = Chem.SDFMoleculeReader(struct_is) mol = Chem.BasicMolecule() xlogp_calc = Chem.XLogPCalculator() histo = Math.DVector() histo.resize(Chem.XLogPCalculator.FEATURE_VECTOR_SIZE) Chem.setMultiConfImportParameter(sdf_reader, False) while sdf_reader.read(mol): exp_logp = float(exp_logp_is.readline()) Chem.perceiveComponents(mol, False) Chem.perceiveSSSR(mol, False) Chem.setRingFlags(mol, False)
def process(): if len(sys.argv) < 3: print >> sys.stderr, 'Usage:', sys.argv[ 0], '[input.cdf] [output directory]' sys.exit(2) in_fname = path.splitext(path.basename(sys.argv[1]))[0] mol = Chem.BasicMolecule() cdf_reader = Chem.FileCDFMoleculeReader(sys.argv[1]) pvd_file = open(path.join(sys.argv[2], in_fname + '.pvd'), 'w') Util.writePVDHeader(pvd_file) print >> sys.stderr, '- Processing CDF-file:', sys.argv[1], '...' if not cdf_reader.read(mol): print '!! Could not read file' sys.exit(2) backbone_atoms = [] for atom in mol.atoms: if Biomol.isPDBBackboneAtom(atom) and Biomol.getResidueAtomName( atom) == 'C': backbone_atoms.append(atom) bond_list = [] for bond in mol.bonds: if Biomol.getResidueCode( bond.getAtom(0)) == 'HOH' or Biomol.getResidueCode( bond.getAtom(1)) == 'HOH': continue if Chem.getType(bond.getAtom(0)) == Chem.AtomType.H or Chem.getType( bond.getAtom(1)) == Chem.AtomType.H: continue bond_list.append(bond) num_confs = Chem.getNumConformations(mol) num_coords = len(bond_list) * 4 + ( len(backbone_atoms) * SPLINE_POINTS_PER_BB_ATOM - 1) * 2 bond_ctr = Math.Vector3D() i = 0 while i < num_confs: line_x_coords = numpy.ndarray(num_coords, numpy.float32) line_y_coords = numpy.ndarray(num_coords, numpy.float32) line_z_coords = numpy.ndarray(num_coords, numpy.float32) atom_types = numpy.ndarray(num_coords, numpy.uint32) spline_ctrl_points = numpy.ndarray((len(backbone_atoms), 3), numpy.float32) j = 0 for atom in backbone_atoms: atom_pos = Chem.getConformer3DCoordinates(atom, i) spline_ctrl_points[j, 0] = atom_pos(0) spline_ctrl_points[j, 1] = atom_pos(1) spline_ctrl_points[j, 2] = atom_pos(2) j += 1 spline_pts = spline(spline_ctrl_points, len(backbone_atoms) * SPLINE_POINTS_PER_BB_ATOM) j = 0 k = 0 while k < (len(backbone_atoms) * SPLINE_POINTS_PER_BB_ATOM - 1): line_x_coords[j] = spline_pts[0][k] line_y_coords[j] = spline_pts[1][k] line_z_coords[j] = spline_pts[2][k] atom_types[j] = 0 j += 1 line_x_coords[j] = spline_pts[0][k + 1] line_y_coords[j] = spline_pts[1][k + 1] line_z_coords[j] = spline_pts[2][k + 1] atom_types[j] = 0 j += 1 k += 1 for bond in bond_list: atom1 = bond.getAtom(0) atom2 = bond.getAtom(1) atom1_pos = Chem.getConformer3DCoordinates(atom1, i) atom2_pos = Chem.getConformer3DCoordinates(atom2, i) atom1_type = Chem.getType(atom1) atom2_type = Chem.getType(atom2) bond_ctr.assign(atom1_pos) bond_ctr += atom2_pos bond_ctr *= 0.5 line_x_coords[j] = atom1_pos(0) line_y_coords[j] = atom1_pos(1) line_z_coords[j] = atom1_pos(2) atom_types[j] = atom1_type j += 1 line_x_coords[j] = bond_ctr(0) line_y_coords[j] = bond_ctr(1) line_z_coords[j] = bond_ctr(2) atom_types[j] = atom1_type j += 1 line_x_coords[j] = bond_ctr(0) line_y_coords[j] = bond_ctr(1) line_z_coords[j] = bond_ctr(2) atom_types[j] = atom2_type j += 1 line_x_coords[j] = atom2_pos(0) line_y_coords[j] = atom2_pos(1) line_z_coords[j] = atom2_pos(2) atom_types[j] = atom2_type j += 1 line_x_coords.resize(j) line_y_coords.resize(j) line_z_coords.resize(j) atom_types.resize(j) out_fname = in_fname + '_frame_no_' + str(i) out_path = path.join(sys.argv[2], out_fname) line_data = {'atom_type': atom_types} print >> sys.stderr, '- Writing structure data for frame', i, '...' if not pyevtk.hl.linesToVTK(out_path, line_x_coords, line_y_coords, line_z_coords, pointData=line_data): print '!! Could not write output file' sys.exit(2) Util.writePVDEntry(pvd_file, i, out_fname, 'vtu') i += 1 Util.writePVDFooter(pvd_file)
def process(): if len(sys.argv) < 3: print >> sys.stderr, 'Usage:', sys.argv[ 0], '[input CDF-file] [output CDF-file] [[residue subset]]' sys.exit(2) print '- Processing CDF-file:', sys.argv[1], '...' mol = Util.loadCDFMolecule(sys.argv[1]) if not mol: print '!! Could not read file' sys.exit(2) residues = Biomol.ResidueList(mol) print '- Num. residues:', residues.getSize() if len(sys.argv) > 3: res_subset_ids = Util.toIntegerList(Util.readLines(sys.argv[3])) print '- Residue subset:', res_subset_ids Util.filterResidues(residues, res_subset_ids) print '- num residues', len(residues) num_confs = Chem.getNumConformations(mol) print '- Num. frames:', num_confs print '- Aligning frames...' res_positions = [] for res in residues: atoms = Util.getBackboneAtoms(res) positions = [] i = 0 while i < num_confs: positions.append(Util.calcAtomSetCentroid(atoms, i)) i += 1 res_positions.append(positions) alignment = Math.DKabschAlgorithm() al_ref_positions = Math.DMatrix(3, residues.getSize()) al_positions = Math.DMatrix(3, residues.getSize()) i = 0 while i < residues.getSize(): pos = res_positions[i][0] al_ref_positions.setElement(0, i, pos[0]) al_ref_positions.setElement(1, i, pos[1]) al_ref_positions.setElement(2, i, pos[2]) i += 1 i = 1 xform = Math.Matrix4D() while i < num_confs: j = 0 while j < residues.getSize(): pos = res_positions[j][i] al_positions.setElement(0, j, pos[0]) al_positions.setElement(1, j, pos[1]) al_positions.setElement(2, j, pos[2]) j += 1 if not alignment.align(al_positions, al_ref_positions): print '!! Could not align frame', i else: xform.assign(alignment.getTransform()) Chem.transformConformation(mol, i, xform) i += 1 if not Util.saveCDFMolecule(sys.argv[2], mol): print '!! Could not write output file' sys.exit(2)
# calculate surface area for a single carbon atom protein.getGaussianShape() shapeFunc = protein.shapeFunc carbonProteinIndex = None for a in protein.atoms: if Chem.getType(a) == 6: carbonProteinIndex = protein.getAtomIndex(a) break surfAreaCarbonProtein = shapeFunc.calcSurfaceArea(carbonProteinIndex) # calculate the surface area contribution here? # create a simple carbon molecule with coordinates carbon = Chem.BasicMolecule() cAtom = carbon.addAtom() Chem.setType(cAtom, 6) coords = Math.Vector3D() coords.assign([1, 2, 3]) Chem.set3DCoordinates(cAtom, coords) # calculate shape and surface area of carbon molecule carbonShape, carbonShapeFunc = getGaussianShapeOfMolecule(carbon) surfAreaCarbon = carbonShapeFunc.surfaceArea # assert that contribution of carbon atom in protein is in fact the entire surface area of a single carbon assert surfAreaCarbon == surfAreaCarbonProtein # What am I missing here? # Summing the surface area of all atoms in the protein yields the surface area of the protein. I find it hard to # believe that all the atoms are surface atoms. Am I missing the VDW radius somehow and all atoms are in fact # just points right now? # for example:
def process(): if len(sys.argv) < 3: print >> sys.stderr, 'Usage:', sys.argv[ 0], '[input.cdf] [output directory]' sys.exit(2) in_fname = path.splitext(path.basename(sys.argv[1]))[0] grid_set = Grid.DRegularGridSet() cdf_reader = Grid.FileCDFDRegularGridSetReader(sys.argv[1]) pvd_file = open(path.join(sys.argv[2], in_fname + '.pvd'), 'w') Util.writePVDHeader(pvd_file) print >> sys.stderr, '- Processing grid CDF-file:', sys.argv[1], '...' frame_no = 0 while True: grid_set.clear() if not cdf_reader.read(grid_set): break output_data = {} grid_spacing = None grid_origin = None for grid in grid_set: int_descr = Grid.getName(grid) grid_values = numpy.ndarray( (grid.getSize1(), grid.getSize2(), grid.getSize3()), numpy.float32) output_data[int_descr] = grid_values for i in range(grid.getSize1()): for j in range(grid.getSize2()): for k in range(grid.getSize3()): grid_values[i, j, k] = grid(i, j, k) if not grid_spacing: grid_spacing = (grid.getXStepSize(), grid.getYStepSize(), grid.getZStepSize()) if not grid_origin: grid_origin = Math.Vector3D() grid.getCoordinates(0, 0, 0, grid_origin) out_fname = in_fname + '_frame_no_' + str(frame_no) out_path = path.join(sys.argv[2], out_fname) print >> sys.stderr, '- Writing grid data for frame', frame_no, '...' if not pyevtk.hl.imageToVTK(out_path, origin=grid_origin, spacing=grid_spacing, pointData=output_data): print '!! Could not write grid output file' sys.exit(2) Util.writePVDEntry(pvd_file, frame_no, out_fname, 'vti') frame_no += 1 Util.writePVDFooter(pvd_file)
def process(): if len(sys.argv) < 4: print >> sys.stderr, 'Usage:', sys.argv[ 0], '[input topology-file] [input coordinates-file] [output CDF-file]' sys.exit(2) print >> sys.stderr, '- Processing topology-file', sys.argv[ 1], 'and coordinates-file', sys.argv[2], '...' u = MDAnalysis.Universe(sys.argv[1], sys.argv[2]) cdf_mol = Chem.BasicMolecule() cdf_mol.reserveMemoryForAtoms(len(u.atoms)) cdf_mol.reserveMemoryForBonds(len(u.bonds)) print >> sys.stderr, '- Num. atoms:', len(u.atoms) print >> sys.stderr, '- Num. bonds:', len(u.bonds) num_frames = len(u.trajectory) print >> sys.stderr, '- Num. frames:', num_frames # construct atoms print >> sys.stderr, '- Building atoms ...' waters = {} i = 0 for md_atom in u.atoms: atom = cdf_mol.addAtom() sym = MDAnalysis.topology.guessers.guess_atom_element(md_atom.name) Chem.setSymbol(atom, sym.title()) Chem.setImplicitHydrogenCount(atom, 0) Biomol.setChainID(atom, md_atom.segid) if md_atom.resname == 'WAT': Biomol.setResidueCode(atom, 'HOH') else: Biomol.setResidueCode(atom, md_atom.resname) if Biomol.getResidueCode(atom) == 'HOH': if md_atom.resid in waters: waters[md_atom.resid].append(i) else: waters[md_atom.resid] = [i] Biomol.setResidueSequenceNumber(atom, int(md_atom.resid)) Biomol.setResidueAtomName(atom, md_atom.name) # fix positive charge on arginin nitrogen if md_atom.resname == 'ARG' and md_atom.name == 'NH2': Chem.setFormalCharge(atom, 1) coords = [] for coord in md_atom.position: coords.append(float(coord)) Chem.set3DCoordinates(atom, coords) coords_array = Math.Vector3DArray() coords_array.reserve(num_frames) Chem.set3DCoordinatesArray(atom, coords_array) Chem.setPEOECharge(atom, float(md_atom.charge)) i += 1 Chem.setAtomTypesFromSymbols(cdf_mol, True) # construct bonds print >> sys.stderr, '- Building bonds ...' for md_bond in u.bonds: cdf_mol.addBond(int(md_bond.atoms[0].index), int(md_bond.atoms[1].index)) print >> sys.stderr, '- Building water atom bonds ...' for water in waters.values(): if len(water) < 2: continue for atom_idx in water: if Chem.getType(cdf_mol.atoms[atom_idx]) == Chem.AtomType.O: if atom.numBonds > 1: break for atom_idx2 in water: if Chem.getType( cdf_mol.atoms[atom_idx2]) == Chem.AtomType.H: cdf_mol.addBond(atom_idx, atom_idx2) break # make sane biomolecule Chem.perceiveSSSR(cdf_mol, True) Chem.setRingFlags(cdf_mol, True) Chem.perceiveBondOrders(cdf_mol, True) Chem.perceiveHybridizationStates(cdf_mol, True) Chem.setAromaticityFlags(cdf_mol, True) Chem.calcFormalCharges(cdf_mol, True) # read timsteps and write cdf print >> sys.stderr, '- Importing coordinates ...' i = 0 traj_coords = [] atom_coords = Math.Vector3D() for ts in u.trajectory: print >> sys.stderr, '- Processing time step', i, '...' for md_atom in u.atoms: del traj_coords[:] for coord in md_atom.position: traj_coords.append(float(coord)) coords_array = Chem.get3DCoordinatesArray( cdf_mol.getAtom(int(md_atom.index))) atom_coords[0] = traj_coords[0] atom_coords[1] = traj_coords[1] atom_coords[2] = traj_coords[2] coords_array.addElement(atom_coords) i += 1 print >> sys.stderr, '- Writing output file:' if not Chem.FileCDFMolecularGraphWriter(sys.argv[3]).write(cdf_mol): print >> sys.stderr, '!! Could not write output file' sys.exit(2)
def process(): if len(sys.argv) < 4: print( 'Usage:', sys.argv[0], '[input torsion rules.xml] [structures.sdf] [output torsion histogram library.sdf]', file=sys.stderr) sys.exit(2) tor_lib = ConfGen.TorsionLibrary() try: tor_lib.load(Base.FileIOStream(sys.argv[1], 'r')) except: print('Error while loading input torsion rules:', sys.exc_info()[0], file=sys.stderr) sys.exit(2) tor_matcher = ConfGen.TorsionRuleMatcher(tor_lib) tor_matcher.findAllRuleMappings(True) tor_matcher.findUniqueMappingsOnly(True) tor_matcher.stopAtFirstMatchingRule(True) mol = Chem.BasicMolecule() mol_reader = Chem.FileSDFMoleculeReader(sys.argv[2]) Chem.setMultiConfImportParameter(mol_reader, False) print('- Analyzing input structures...', file=sys.stderr) i = 1 rule_to_angle_hists = {} coords = Math.Vector3DArray() while True: try: if not mol_reader.read(mol): break except IOError as e: print('Error while reading input molecule', i, ':', e, file=sys.stderr) i += 1 continue if i % 500 == 0: print(' ... At input molecule', i, '...', file=sys.stderr) Chem.initSubstructureSearchTarget(mol, False) try: Chem.get3DCoordinates(mol, coords) except Base.ItemNotFound: print('Could not get 3D-coordinates for molecule', i, file=sys.stderr) i += 1 continue for bond in mol.bonds: if Chem.getRingFlag(bond): continue if Chem.isHydrogenBond(bond): continue if Chem.getExplicitBondCount( bond.getBegin()) <= 1 or Chem.getExplicitBondCount( bond.getEnd()) <= 1: continue tor_matcher.findMatches(bond, mol, False) for match in tor_matcher: processMatch(i, match, mol, coords, rule_to_angle_hists) i += 1 print('- Processing torsion angle histograms...', file=sys.stderr) processHistograms(tor_lib, rule_to_angle_hists) print('- Writing output torsion library...', file=sys.stderr) try: tor_lib.save(Base.FileIOStream(sys.argv[3], 'w+')) except: print('Error while writing torsion library:', sys.exc_info()[0], file=sys.stderr) sys.exit(2) print('DONE!', file=sys.stderr)
def process(): if len(sys.argv) < 3: print >> sys.stderr, 'Usage:', sys.argv[0], '[input.cdf] [output directory]' sys.exit(2) print >> sys.stderr, '> Processing grid CDF-file:', sys.argv[1], '...' grid_set = Grid.DRegularGridSet() cdf_grid_reader = Grid.FileCDFDRegularGridSetReader(sys.argv[1]) if not cdf_grid_reader.read(grid_set): print '> CDF reader failure.' new_grids = Grid.DRegularGridSet() for grid in grid_set: g1 = grid.getSize1() g2 = grid.getSize2() g3 = grid.getSize3() g_type = Grid.getName(grid) new_grids.addElement(Grid.DRegularGrid(g1, g2, g3).assign(grid)) Grid.setName(new_grids.getLastElement(), "Avg_" + g_type) new_grids.addElement(Grid.DRegularGrid(g1, g2, g3).assign(grid)) Grid.setName(new_grids.getLastElement(), "Std_" + g_type) for k in range(g3): for i in range(g1): for j in range(g2): new_grids.getLastElement()[i, j, k] = 0 print >> sys.stderr, '> Calculating averaged grids...' index_frame = 0 while True: grid_set.clear() if not cdf_grid_reader.read(grid_set): break n = 0 for grid in grid_set: tmp_mean = Math.DGrid(grid.getSize1(), grid.getSize2(), grid.getSize3()) g_mean = new_grids[2 * n] g_v = new_grids[2 * n + 1] tmp_mean.assign(g_mean + (grid - g_mean) / (index_frame + 1)) g_v.assign(g_v + Math.elemProd((grid - g_mean), (grid - tmp_mean))) g_mean.assign(tmp_mean) n += 1 index_frame += 1 n = 0 for grid in grid_set: g1 = grid.getSize1() g2 = grid.getSize2() g3 = grid.getSize3() g_v = new_grids[2 * n + 1] for k in range(g3): for i in range(g1): for j in range(g2): variance = round(g_v(i, j, k) / (index_frame+1), 10) #### Due to calculations, negative values closer than e-10 from 0 are rounded to avoid warnings g_v[i, j, k] = np.sqrt(variance) n += 1 print >> sys.stderr, '> Writing averaged grids to', sys.argv[2] out_fname = path.splitext(path.basename(sys.argv[1]))[0] + '_average_grid.cdf' out_path = path.join(sys.argv[2], out_fname) grid_set_writer = Grid.FileCDFDRegularGridSetWriter(out_path) if not grid_set_writer.write(new_grids): print >> sys.stderr, '> Could not write output file'