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]
