def setUp(self): self.universe = mda.Universe(PRMncdf, NCDF) self.tmpdir = tempdir.TempDir() self.outfile = self.tmpdir.name + '/xdr-writer-issue117' + self.ext self.Writer = mda.Writer(self.outfile, n_atoms=self.universe.atoms.n_atoms)
def u(self): return mda.Universe(two_water_gro)
def create_cc_orderfiles(): ''' ''' u = mda.Universe(GRO, TRJ) ## Gather all input data for _calc_scd_output function len_traj = len(u.trajectory) with open(OUTPUTFILENAME, "w") as scdfile, open("ztilt_randaxis.csv", "w") as axf: #### Print header files #### print("{: <12}{: <10}{: <15}{: <15}{: <15}{: <20}{: <20}{: <20}"\ .format("time", "axndx", "S", "proj_ch1", "proj_ch2", "ax_x", "ax_y", "ax_z"), file=scdfile) print("time,tilt", file=axf) tailatms = SCD_TAIL_ATOMS_OF[LIPID[:2]] s_atoms = [] for sn in tailatms: atms = u.atoms.select_atoms( "name {}"\ .format(' '.join(sn) ) ) idmap = {id: pos for pos, id in enumerate(sn)} atms = sorted(atms, key=lambda atom: idmap[atom.name]) s_atoms.append(atms) ### from get randaxis from PC vector ### #glycatms_ref = mda.AtomGroup([u.atoms.select_atoms("name P"), u.atoms.select_atoms("name C1")]) #glycatms_plane = mda.AtomGroup([u.atoms.select_atoms("name C1"), u.atoms.select_atoms("name C3")]) ######################################## chainvec_atms1 = mda.AtomGroup([ u.atoms.select_atoms("name P"), u.atoms.select_atoms("name C216") ]) chainvec_atms2 = mda.AtomGroup([ u.atoms.select_atoms("name P"), u.atoms.select_atoms("name C316") ]) for t in range(len_traj): time = u.trajectory[t].time LOGGER.info("At time %s", time) tailatms = SCD_TAIL_ATOMS_OF[LIPID[:2]] positions = [] for atms in s_atoms: positions.append([atm.position for atm in atms]) ### from get randaxis from PC vector ### #glycvecref = (glycatms_ref.positions[0] - glycatms_ref.positions[1])[0] #glycvecref = glycvecref / np.linalg.norm(glycvecref) #glycvecplane = (glycatms_plane.positions[0] - glycatms_plane.positions[1])[0] #glycvecplane = glycvecplane / np.linalg.norm(glycvecplane) ######################################## chainatmvec1 = (chainvec_atms1.positions[0] - chainvec_atms1.positions[1])[0] #chainatmvec1 = chainatmvec1 / np.linalg.norm(chainatmvec1) chainatmvec2 = (chainvec_atms2.positions[0] - chainvec_atms2.positions[1])[0] #chainatmvec2 = chainatmvec2 / np.linalg.norm(chainatmvec2) for i in range(1000): #### from get randaxis from PC vector ### #refaxis = get_rand_axis(glycvecref, glycvecplane) #tiltref = np.arccos(np.dot(refaxis, glycvecref)) * 180/np.pi #print("{},{}".format(time, tiltref), file=axf) ######################################### refaxis = np.random.random_sample((3, )) refaxis = refaxis / np.linalg.norm(refaxis) # projection of chainvec to new axis projection_mag1 = np.dot(chainatmvec1, refaxis) projection_mag2 = np.dot(chainatmvec2, refaxis) order_val, s_prof = get_cc_order(positions, ref_axis=refaxis) LOGGER.debug("printing to files ...") ### Print everything to files ### line_scd = "{: <12.2f}{: <10}{: <15.8}{: <15.5}{: <15.5}{: <20}{: <20}{: <20}".format( time, i, order_val, projection_mag1, projection_mag2, *refaxis) print(line_scd, file=scdfile)
def test_None_removal(self): with pytest.warns(UserWarning): u = mda.Universe(PDB_rama) rama = Ramachandran(u.select_atoms("protein").residues[1:-1])
def atomgroup(self): u = mda.Universe(GRO, XTC) ag = u.select_atoms( "(resid 4 and name N CA C) or (resid 5 and name N)") return ag
def transformed(ref): return mda.Universe(PSF, [DCD, CRD, DCD, CRD, DCD, CRD, CRD], transformations=[translate([10, 10, 10])])
import sys import numpy as np import MDAnalysis as mda input = sys.argv[1] output = sys.argv[2] u = mda.Universe(input) cog = u.atoms.center_of_geometry() u.atoms.positions = cog u.atoms.write(output, reindex=False)
import MDAnalysis import os MDAnalysis.core.flags['use_periodic_selections'] = True input_dir = "classification/" output_dir = "Diffusion/" if not os.path.exists(output_dir): os.makedirs(output_dir) top = 'membrane.pdb' traj = 'traj-dt-1ns-mol.xtc' #read the vectors u = MDAnalysis.Universe(top, traj) # ============================================================================= # ##Check and adapt # def fit_anomalous_diffusion_data(time_data_array,MSD_data_array,degrees_of_freedom=2): # # def function_to_fit(time,fractional_diffusion_coefficient,scaling_exponent): # coefficient_dictionary = {1:2,2:4,3:6} #dictionary for mapping degrees_of_freedom to coefficient in fitting equation # coefficient = coefficient_dictionary[degrees_of_freedom] # return coefficient * fractional_diffusion_coefficient * (time ** scaling_exponent) #equation 1 in the Kneller 2011 paper with appropriate coefficient based on degrees of freedom # # #fit the above function to the data and pull out the resulting parameters # optimized_parameter_value_array, estimated_covariance_params_array = scipy.optimize.curve_fit(function_to_fit,time_data_array,MSD_data_array) # #generate sample fitting data over the range of time window values # sample_fitting_data_X_values_nanoseconds = np.linspace(time_data_array[0],time_data_array[-1],100)
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)
#!/usr/bin/env python import MDAnalysis, argparse, math, tempfile, shutil, os, sys import numpy as np from PIL import Image parser = argparse.ArgumentParser(description='Compress a MD trajectory') parser.add_argument('topo', metavar='topology_file') parser.add_argument('traj', metavar='trajectory_file') parser.add_argument('--out', metavar='output_file', default="output.m4v") parser.add_argument("--selection", default="protein", required=False) args = parser.parse_args() model = MDAnalysis.Universe(args.topo, args.traj) selection = model.select_atoms(args.selection) n = selection.n_atoms #make square-ish images -- this can be optimized to reduce dead pixels #these also have to be even.. h = int(math.ceil(math.sqrt(n))) w = h #figure out overall range for x,y,z maxvals = np.array([float("-inf")] * 3) minvals = np.array([float("inf")] * 3) for ts in model.trajectory: for c in selection.coordinates(): for i in xrange(3): maxvals[i] = max(maxvals[i], c[i]) minvals[i] = min(minvals[i], c[i])
def setUp(self): self.universe = mda.Universe(DMS) self.ts = self.universe.trajectory.ts
simulation.reporters.append( md.reporters.XTCReporter( file=str(output_directory / "trajectory.xtc"), reportInterval=production_trajectory_frequency, ) ) print("Running production simulation ...") simulation.step(production_steps) if production_steps / production_trajectory_frequency >= 1: print("Transforming trajectory ...") u = mda.Universe( str(output_directory / "equilibration/out_state.pdb"), str(output_directory / "trajectory.xtc"), ) backbone = u.select_atoms("backbone") not_protein = u.select_atoms("not protein") workflow = ( transformations.unwrap(backbone), transformations.center_in_box(backbone), transformations.wrap(not_protein, compound="fragments"), transformations.fit_rot_trans(backbone, backbone), ) u.trajectory.add_transformations(*workflow) print("Saving transformed topology and trajectory ...") u.atoms.write(str(output_directory / "topology_wrapped.pdb")) with mda.Writer( str(output_directory / "trajectory_wrapped.xtc"), u.atoms.n_atoms
def benchmark(topology, trajectory): """Benchmarks rmsd calculation for a given universe""" with timeit() as init: with timeit() as init_top: u = mda.Universe(topology) with timeit() as init_traj: u.load_new(trajectory, driver="mpio", comm=comm) CA = u.select_atoms("protein and name CA") x_ref = CA.positions.copy() n_frames = len(u.trajectory) slices = make_balanced_slices(n_frames, size, start=0, stop=n_frames, step=1) # give each rank unique start and stop points start = slices[rank].start stop = slices[rank].stop bsize = stop - start # sendcounts is used for Gatherv() to know how many elements are sent # from each rank sendcounts = np.array([slices[i].stop - slices[i].start for i in range(size)]) t_init = init.elapsed t_init_top = init_top.elapsed t_init_traj = init_traj.elapsed # intialize time counters total_io = 0 total_rmsd = 0 rmsd_array = np.empty(bsize, dtype=float) for i, frame in enumerate(range(start, stop)): # input/output time with timeit() as io: ts = u.trajectory[frame] total_io += io.elapsed # rmsd calculation time with timeit() as rms: rmsd_array[i] = rmsd(CA.positions, x_ref, superposition=True) total_rmsd += rms.elapsed # checking for straggling processes with timeit() as wait_time: comm.Barrier() t_wait = wait_time.elapsed # time how long it takes for proceses to gather the data with timeit() as comm_gather: rmsd_buffer = None if rank == 0: rmsd_buffer = np.empty(n_frames, dtype=float) comm.Gatherv(sendbuf=rmsd_array, recvbuf=(rmsd_buffer, sendcounts), root=0) t_comm_gather = comm_gather.elapsed # total benchmark time per rank total_time = t_init + total_io + total_rmsd + t_wait + t_comm_gather # close trajectory now to avoid MPI errors when MPI finalizes with timeit() as close_traj: u.trajectory.close() t_close_traj = close_traj.elapsed # collect all timings into this array block_times = np.array((rank, t_init, t_init_top, t_init_traj, total_io, total_io/bsize, total_rmsd, total_rmsd/bsize, t_wait, t_comm_gather, t_close_traj, total_time), dtype=float) n_columns = len(block_times) # gather times from each block into times_array times_buffer = None if rank == 0: times_buffer = np.empty(n_columns*size, dtype=float) comm.Gather(sendbuf=block_times, recvbuf=times_buffer, root=0) if rank == 0: # turn 1 dimensional vector into size x n_columns matrix where the # columns are t_loop, t_rmsd, etc and rows are each rank times_buffer = times_buffer.reshape(size, n_columns) return times_buffer, rmsd_buffer return None, None
z_hi -- higher z boundary of protein """ if z_mol < z_lo: return -1 elif z_mol > z_hi: return 1 else: return 0 ################################################################################ # TRAJECTORY ANALYSIS ################################################################################ # creates a universe from given structure and trajectory files u = mda.Universe(args.s, args.t) # select specified solvent subset and sets default to O positions in water if args.monatomic_selection == None and args.polyatomic_selection == None: sel = u.select_atoms("resname SOL and type O") elif args.monatomic_selection != None and args.polyatomic_selection == None: sel = u.select_atoms(args.monatomic_selection) elif args.monatomic_selection == None and args.polyatomic_selection != None: sel = u.select_atoms("{} and {}".format(args.polyatomic_selection, args.polyatomic_position)) else: sel = u.select_atoms("{} or {} and {}".format(args.monatomic_selection, args.polyatomic_selection, args.polyatomic_position)) # check that resulting list of atoms only contains one from each molecule
def test_unsupported_filetypes(self): with pytest.raises(NotImplementedError): mda.Universe(PSF, [DCD, DCD], continuous=True)
def __init__(self, filename): self.universe = mda.Universe('protein.pdb')
def universe(self): return mda.Universe(PSF, [DCD, CRD, DCD, CRD, DCD, CRD, CRD])
output += '\n' export_file = open(sys.argv[1][:-3] + 'table.txt', 'w') export_file.write(output) export_file.close() sys.exit() pdb_file = sys.argv[1] dcd_file = sys.argv[2] res = sys.argv[3] step = float(sys.argv[4]) skip = int(sys.argv[5]) print "Loading trajectory" mol = MD.Universe(pdb_file, dcd_file) N_atoms = mol.selectAtoms("resid " + res + " and (name N or name HN)") print "Done... Calculating N-H bond" bond_vec = [] for ts1 in mol.trajectory[0:-1:skip]: coords = N_atoms.coordinates() coords = numpy.subtract(coords[1], coords[0]) bond_vec.append(coords / numpy.linalg.norm(coords)) x = [] c_func = [] x_chen = []
## Do vdw calculation from md trajectory## from __future__ import division, print_function import MDAnalysis import numpy as np import itertools import argparse try: u_for_prev = u_for except: pass univ = MDAnalysis.Universe('run.tpr', 'traj.trr') from mdtools import dr from math import erf, erfc from scipy.special import erfinv for_lmbdas = [1.0] n_for_lmbdas = len(for_lmbdas) this_lmbda = 0.0 atm_indices = np.arange(univ.atoms.n_atoms) alc_indices = np.arange(872, 888) #alc_indices = [877] excls = {i: None for i in alc_indices} excls[872] = [ 853, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 884, 888, 889, 890, 891, 892
def trajectory(self): universe = mda.Universe(PSF, [DCD, CRD, DCD, CRD, DCD, CRD, CRD], dt=self.common_dt) return universe.trajectory
DIM = 3 maxR = 2 #boundaryFacets = np.array([[-1,-1,-1]], dtype = np.int32) #boundaryEdges = np.array([[-1,-1]] , dtype = np.int32) #boundaryVertices = [] #boundaryFacets = [] #boundaryEdges = [] #boundaryCell = [] #points = np.array([[0,0,0],[1,0,0],[0,1,0],[-1,0,0],[0,-1,0],[0,0,1]]) #points = np.array([[0,0,0],[1,0,0],[1,1,0],[0,1,0],[0,0,1],[1,0,1],[1,1,1],[0,1,1]], dtype = np.float32) #points = np.array([[0,0,0],[1,0,0],[0,1,0],[0,0,1],[0,1,1],[-1,1,1]]) # Triangulate parameter space to determine the triangles #tri = mtri.Triangulation(u, v) u = MDAnalysis.Universe("md0.gro", "trj.trr") particle = u.select_atoms("name Ti or name O") solution = u.select_atoms("resname SOL") N_part = len(particle) N_sol = len(solution) N_oxy = N_sol / 3 outPoints = [] points = particle.positions init = particle.positions iteration = 0 while iteration < 3: iteration += 1 boundaryVertices = []
def test_set_all_format_tuples(self): universe = mda.Universe(GRO, [(PDB, 'pdb'), (XTC, 'xtc'), (TRR, 'trr')]) assert universe.trajectory.n_frames == 21 assert_equal(universe.trajectory.filenames, [PDB, XTC, TRR])
def test_atom_selection(self): with pytest.raises(ValueError): u = mda.Universe(PDB_janin) janin = Janin( u.select_atoms("protein and not resname ALA CYS GLY " "PRO SER THR VAL"))
def test_set_one_format_tuple(self): universe = mda.Universe(PSF, [(PDB_small, 'pdb'), DCD]) assert universe.trajectory.n_frames == 99
def universe(self): return mda.Universe(GRO, XTC)
def test_set_all_formats(self): universe = mda.Universe(PSF, [PDB_small, PDB_closed], format='pdb') assert universe.trajectory.n_frames == 2
def universe(self): return mda.Universe(TRZ_psf, TRZ)
def test_mixed_filetypes(self): with pytest.raises(ValueError): mda.Universe(PDB, [XTC, TRR], continuous=True)
def main(): top = '/oasis/projects/nsf/azs119/edisj/Comet/datafiles/adk4AKE.psf' traj = '/oasis/projects/nsf/azs119/edisj/Comet/datafiles/xtc600x.xtc' u = mda.Universe(top, traj) create_test_trj(u, '/oasis/projects/nsf/azs119/edisj/Comet/datafiles/xtc600x.h5md')
def setUp(self): self.universe = mda.Universe(GRO, self.infilename) ext = os.path.splitext(self.infilename)[1] self.tmpdir = tempdir.TempDir() self.outfile = self.tmpdir.name + '/xdr-writer-test' + ext self.Writer = self.Writers[ext]