def status(self,
step,
numberOfSteps,
stepIncrement=1,
mode=True,
logEvery=10):
"""
This method is used to log selection status.
:Parameters:
#. step (int): The current step number
#. numberOfSteps (int): The total number of steps
#. stepIncrement (int): The incrementation between one step and another
#. mode (bool): if False no status logging
#. logEvery (float): the frequency of status logging. its a percent number.
"""
if not mode:
return
if step - 1 == -1:
return
actualPercent = int(float(step) / float(numberOfSteps) * 100)
previousPercent = int(
float(step - stepIncrement) / float(numberOfSteps) * 100)
if actualPercent / logEvery != previousPercent / logEvery:
Logger.info("%s%% completed. %s left out of %s" %
(actualPercent, numberOfSteps - step, numberOfSteps))
def __init__(self,
trajectory,
configurationsIndexes,
cylinderAtomsIndexes,
targetAtomsIndexes,
axis=None,
weighting="equal",
histBin=1,
*args,
**kwargs):
# set trajectory
super(MeanSquareDisplacementInCylinder,
self).__init__(trajectory, *args, **kwargs)
# set configurations indexes
self.configurationsIndexes = self.get_trajectory_indexes(
configurationsIndexes)
# set atoms indexes
self.targetAtomsIndexes = self.get_atoms_indexes(targetAtomsIndexes)
self.cylinderAtomsIndexes = self.get_atoms_indexes(
cylinderAtomsIndexes)
# set steps indexes
self.numberOfSteps = len(self.targetAtomsIndexes)
# set weighting
assert is_element_property(weighting), Logger.error(
"weighting '%s' don't exist in database" % weighting)
self.weighting = weighting
# set residency time histogram bin
try:
self.histBin = float(histBin)
except:
raise Logger.error(
"histBin must be number convertible. %s is given." % histBin)
assert self.histBin % 1 == 0, logger.error(
"histBin must be integer. %s is given." % histBin)
assert self.histBin > 0, logger.error(
"histBin must be positive. %s is given." % histBin)
assert self.histBin < len(self.configurationsIndexes), logger.error(
"histBin must smaller than numberOfConfigurations")
# initialize variables
self.__initialize_variables__(axis)
# initialize results
self.__initialize_results__()
# get cylinder centers, matrices, radii, length
Logger.info(
"%s --> initializing cylinder parameters along all configurations"
% self.__class__.__name__)
self.cylCenters, self.cylMatrices, self.cylRadii, self.cylLengths = self.__get_cylinder_properties__(
)
def convert(self, types = None):
"""
Converts to pdbParser
"""
# read lines
lines = self.get_lines()
# get number of atoms
self.info["number_of_records"] = self.__get_number_of_records__(lines)
# get number of types
self.info["number_of_types"] = self.__get_number_of_types__(lines)
# get simulation box vectors
self.info["vectors"] = self.__get_box_vectors__(lines)
# set types names
if types is None:
Logger.info("types are not given. carbon element is considered for all types")
self.info["types"] = [{"name":"c%s"%idx,"element":"c"} for idx in range(self.info["number_of_types"])]
else:
assert len(types) == self.info["number_of_types"], "types must be a list of length equal to the number of types"
for idx in range(self.info["number_of_types"]):
if not isinstance(types[idx], dict):
assert is_element(types[idx]), "%s not found database elements"%types[idx]
types[idx] = {"name":types[idx], "element":types[idx]}
assert types[idx].has_key("name"), "every type dictionary must have 'name' and 'element' keys"
assert types[idx].has_key("element"), "every type dictionary must have 'name' and 'element' keys"
if types[idx]["element"].lower() not in __atoms_database__.keys():
Logger.warr("type %r is not defined in database"%types[idx]["element"])
else:
types[idx]["element"] = types[idx]["element"].lower()
self.info["types"] = types
# get types records number
self.info["records_per_type"] = []
for idx in range(self.info["number_of_types"]):
self.info["records_per_type"].append( self.__get_records_per_type__(lines, idx+1) )
assert sum(self.info["records_per_type"]) == self.info["number_of_records"], "the sum of number of molecules in all types must be equal to number of ' molecules of all types'"
# get coordinates
fracCoord = self.__get_coordinates__(lines)
assert fracCoord.shape ==(self.info["number_of_records"],3), "stored fractional coordinates must be equal to number of ' molecules of all types'"
# calculate real coordinates
realCoord = self.__calculate_real_coordinates__(fracCoord)
# create pdb
self.__create_pdb__(realCoord)
return self
def status(self, step, totalSteps, logFrequency=10):
"""
This method is used to log converting status.\n
:Parameters:
#. step (int): The current step number
#. logFrequency (float): the frequency of status logging. its a percent number.
"""
if not step:
Logger.info("%s --> converting started" %
(self.__class__.__name__))
elif step == totalSteps:
Logger.info("%s --> converting finished" %
(self.__class__.__name__))
else:
actualPercent = int(float(step) / float(totalSteps) * 100)
if self.__previousStep is not None:
previousPercent = int(
float(self.__previousStep) / float(totalSteps) * 100)
else:
previousPercent = -1
if actualPercent / logFrequency != previousPercent / logFrequency:
Logger.info("%s --> %s%% completed. %s left out of %s" %
(self.__class__.__name__, actualPercent,
totalSteps - step, totalSteps))
# update previous step
self.__previousStep = step
def __init__(self, pdb, dcd, indexes=None, format="charmm"):
"""
Read new simulation trajectory
:Parameters:
#. pdb (string): NAMD pdb file used as trajectory structure file
#. dcd (string): NAMD DCD output file
#. indexes (list): the configuration indexes to convert. None converts all configurations
#. format (string): the known formats. only charmm and dcd are supported.
"""
# initialize converter
super(DCDConverter, self).__init__()
# log some info
Logger.info("Converting NAMD trajectory")
Logger.info("pdb file path: %s" % pdb)
Logger.info("dcd file path: %s" % dcd)
# check format
assert isinstance(format, str), Logger.error("format must be a string")
self.format = str(format).lower()
assert self.format in (
"charmm",
"namd"), Logger.error("format must be either charmm or namd")
# check indexes
if indexes is not None:
assert isinstance(
indexes, (list, tuple, set, np.ndarray)), Logger.error(
"indexes must be a list of 3 integers [start, end, step]")
indexes = [int(idx) for idx in sorted(set(indexes))]
assert indexes[0] >= 0, Logger.error(
"indexes start must be positive")
self.indexes = indexes
# check pdb file
try:
fd = open(pdb, 'r')
except:
raise Logger.error("cannot open pdb file")
else:
fd.close()
self.pdb = pdb
# check dcd file
try:
fd = open(dcd, 'r')
except:
raise Logger.error("cannot open dcd file")
else:
fd.close()
self.dcd = dcd
# create trajectory
self.trajectory = None
def status(self, step, logFrequency=10):
"""
This method is used to log analysis status.\n
:Parameters:
#. step (int): The current step number
#. logFrequency (float): the frequency of status logging. its a percent number.
"""
if not step:
Logger.info("%s --> analysis started %s steps to go" %
(self.__class__.__name__, self.numberOfSteps))
elif step == self.numberOfSteps:
Logger.info("%s --> analysis steps finished" %
(self.__class__.__name__))
else:
actualPercent = int(float(step) / float(self.numberOfSteps) * 100)
previousPercent = int(
float(step - 1) / float(self.numberOfSteps) * 100)
if actualPercent / logFrequency != previousPercent / logFrequency:
Logger.info("%s --> %s%% completed. %s left out of %s" %
(self.__class__.__name__, actualPercent,
self.numberOfSteps - step, self.numberOfSteps))
from pdbParser import pdbParser
from pdbParser.Utilities.Simulate import Simulation
# import molecule
pdb = pdbParser(os.path.join(get_path("pdbparser"), "Data/WATER.pdb"))
# create simulation
sim = Simulation(pdb,
logStatus=False,
logExport=False,
numberOfSteps=100,
outputFrequency=1,
outputPath=tempfile.mktemp(".xyz"))
# initial parameters
Logger.info("minimizing 100 step with H-O-H angle %s and O-H bond %s" %
(sim.__ANGLE__['h o h']['theta0'], sim.__BOND__['h o']['b0']))
sim.minimize_steepest_descent()
# change parameters to 120
sim.__ANGLE__['h o h']['theta0'] = 120
sim.set_angles_parameters()
sim.set_bonds_parameters()
Logger.info("minimizing 100 step with H-O-H angle %s and O-H bond %s" %
(sim.__ANGLE__['h o h']['theta0'], sim.__BOND__['h o']['b0']))
sim.minimize_steepest_descent()
# change parameters to 120
sim.__BOND__['h o']['b0'] = 3
sim.set_angles_parameters()
sim.set_bonds_parameters()
Logger.info("minimizing 100 step with H-O-H angle %s and O-H bond %s" %
def finalize(self):
"""
called once all the steps has been run.\n
"""
# self.hbonds = [[[hIdx, shellIdx, shellTimeLimitsIdx, accIdx],[hIdx, shellIdx, shellTimeLimitsIdx,accIdx],...], ... ]
# ............first bond first shell..........,............first bond second shell2.......,....
# ........................................first bond..........................................., .... second bond ...
Logger.info("%s --> parsing and creating hydrogen bonds" %
(self.__class__.__name__))
self.hbonds = [[]]
def create_hbonds():
for bond in self.hbonds:
if not len(bond):
continue
# check all bond time threshold
if self.time[bond[-1][2][1]] - self.time[
bond[0][2][0]] < self.thresholdTime:
continue
if self.bondStartAtCore and bond[0][1]:
continue
self.results['hbonds_time'][bond[-1][2][1] -
bond[0][2][0]] += 1
self.results['number_of_hbonds'][
bond[0][2][0]:bond[-1][2][1]] += 1
for shell in bond:
hIdx = shell[0]
shellIdx = shell[1]
shellTimeIdx = shell[2]
shellKey = self.shellsResultKeys[shellIdx]
time = shellTimeIdx[1] - shellTimeIdx[0]
# append 1 to hbonds time
self.results['hbonds_%s_time' % shellKey][time] += 1
# update number of hbonds
self.results['number_of_hbonds_%s' %
shellKey][shellTimeIdx[0]:shellTimeIdx[1] +
1] += 1
# calculate bond lengths histogram
hist, _ = np.histogram(
self.bondsDistances[hIdx,
shellTimeIdx[0]:shellTimeIdx[1] +
1], self.bins)
self.results['hbonds_%s_distribution' % shellKey] += hist
def add_hbond(hIdx,
shellIdx,
shellTimeIdx,
thisAcceptor,
breakBond=False,
debugMessage=""):
if not (shellTimeIdx[0] is None) and not (shellTimeIdx[1] is None):
#if not (self.time[shellTimeIdx[1]]-self.time[shellTimeIdx[0]]<=self.hbondAllShellsTime[shellIdx]):
# print debugMessage
# print "last shell index: %s"%str(lastShellIdx)
# print "this shell index: %s"%str(thisShellIdx)
# print "saving shell index: %s"%str(shellIdx)
# print "stayed between %s"%str(shellTimeIdx)
# print "total time of %s while allowed time is %s"%(str(self.time[timeIdx]-self.time[shellTimeIdx[0]]), str(self.hbondAllShellsTime[shellIdx]))
# print '\n'
# first or new hbond added to the same hydrogen atom
if not len(self.hbonds[-1]):
self.hbonds[-1].append(
[hIdx, shellIdx, shellTimeIdx, thisAcceptor])
# new hydrogen index
elif self.hbonds[-1][-1][0] != hIdx:
self.hbonds.append(
[[hIdx, shellIdx, shellTimeIdx, thisAcceptor]])
# new acceptor
elif self.hbonds[-1][-1][3] != thisAcceptor:
self.hbonds.append(
[[hIdx, shellIdx, shellTimeIdx, thisAcceptor]])
# not continuous shellTimeIdx
elif self.hbonds[-1][-1][2][1] + 1 != shellTimeIdx[0]:
self.hbonds.append(
[[hIdx, shellIdx, shellTimeIdx, thisAcceptor]])
else:
self.hbonds[-1].append(
[hIdx, shellIdx, shellTimeIdx, thisAcceptor])
if breakBond:
self.hbonds.append([])
def reset_shellTimeIdx_lowerAngleTime(thisDistance, thisAngle,
thisTime):
if self.bondStartAtCore and thisDistance > self.bondLength:
shellTimeIdx = [None, None]
lowerAngleTime = [None, None]
elif self.bondStartWithinAngle and (
thisAngle < self.bondAngleLimits[0]
or thisAngle > self.bondAngleLimits[1]):
shellTimeIdx = [None, None]
lowerAngleTime = [None, None]
else:
shellTimeIdx = [timeIdx, timeIdx]
# update bond angle time
if thisAngle < self.bondAngleLimits[
0] or thisAngle > self.bondAngleLimits[1]:
if lowerAngleTime[0] is None:
lowerAngleTime = [thisTime, thisTime]
else:
lowerAngleTime[1] = thisTime
else:
lowerAngleTime = [None, None]
return shellTimeIdx, lowerAngleTime
# create hydrogen bonds
for hIdx in range(len(self.hydrogenAtomsIndexes)):
# create shellsIndexes list
shellsIndexes = []
for timeIdx in range(len(self.configurationsIndexes)):
thisDistance = self.bondsDistances[hIdx, timeIdx]
if thisDistance == -1:
shellsIndexes.append(-1)
else:
indexes = [
idx for idx in range(len(self.cumsumhbondAllShells))
if thisDistance <= self.cumsumhbondAllShells[idx]
]
shellIdx = indexes[0]
shellsIndexes.append(shellIdx)
# remove hfjumps
if self.smoothHfJumps and len(shellsIndexes) >= 3:
for timeIdx in range(1, len(shellsIndexes) - 1):
if self.bondsDistances[hIdx, timeIdx] == -1:
continue
if shellsIndexes[timeIdx - 1] == shellsIndexes[timeIdx +
1]:
shellsIndexes[timeIdx] = shellsIndexes[timeIdx - 1]
self.bondsDistances[hIdx, timeIdx] = (
self.bondsDistances[hIdx, timeIdx - 1] +
self.bondsDistances[hIdx, timeIdx + 1]) / 2.
if self.acceptorsIndex[hIdx, timeIdx -
1] == self.acceptorsIndex[hIdx,
timeIdx +
1]:
self.acceptorsIndex[
hIdx, timeIdx] = self.acceptorsIndex[hIdx,
timeIdx - 1]
# create hbonds
shellTimeIdx = [None, None]
lowerAngleTime = [None, None]
for timeIdx in range(len(self.configurationsIndexes)):
# get bond information
thisShellIdx = shellsIndexes[timeIdx]
thisAcceptor = self.acceptorsIndex[hIdx, timeIdx]
thisAngle = self.bondsAngles[hIdx, timeIdx]
thisTime = self.time[timeIdx]
if timeIdx == 0:
lastShellIdx = thisShellIdx
lastAcceptor = thisAcceptor
else:
lastAcceptor = self.acceptorsIndex[hIdx, timeIdx - 1]
lastShellIdx = shellsIndexes[timeIdx - 1]
#################################################################################################
########################################## checking bond ########################################
# check shell idx whether there is a bond or not
if thisShellIdx == -1:
# add all valid bonds
add_hbond(hIdx,
lastShellIdx,
shellTimeIdx,
thisAcceptor,
breakBond=True,
debugMessage="no bond found")
# reset parameters
shellTimeIdx = [None, None]
lowerAngleTime = [None, None]
continue
# new bond or after non-bond thisShellIdx = -1
if shellTimeIdx[0] is None:
shellTimeIdx, lowerAngleTime = reset_shellTimeIdx_lowerAngleTime(
thisDistance, thisAngle, thisTime)
continue
# check acceptors and break bond
if thisAcceptor != lastAcceptor:
# add all valid bonds
add_hbond(hIdx,
lastShellIdx,
shellTimeIdx,
thisAcceptor,
breakBond=True,
debugMessage="different acceptor")
# reset parameters
shellTimeIdx, lowerAngleTime = reset_shellTimeIdx_lowerAngleTime(
thisDistance, thisAngle, thisTime)
continue
# check bondAngle and break bond
if thisAngle < self.bondAngleLimits[
0] or thisAngle > self.bondAngleLimits[1]:
if (lowerAngleTime[0] is not None):
if (thisTime - lowerAngleTime[0]
) > self.belowAngleToleranceTime:
# add all valid bonds
add_hbond(hIdx,
lastShellIdx,
shellTimeIdx,
thisAcceptor,
breakBond=True,
debugMessage="angle time")
# reset parameters
shellTimeIdx = [None, None]
lowerAngleTime = [None, None]
continue
else:
lowerAngleTime[1] = thisTime
else:
lowerAngleTime = [thisTime, thisTime]
else:
lowerAngleTime = [None, None]
# Bond change shell
if thisShellIdx != lastShellIdx:
# add all valid bonds
add_hbond(hIdx,
lastShellIdx,
shellTimeIdx,
thisAcceptor,
breakBond=False,
debugMessage="jump to another shell")
# reset parameters
shellTimeIdx = [timeIdx, timeIdx]
continue
# bond stay in same shell, check tolerance time
elif thisTime - self.time[shellTimeIdx[
0]] <= self.hbondAllShellsTime[thisShellIdx]:
shellTimeIdx[1] = timeIdx
continue
# bond break because of tolerance time in outer shell
else:
# add all valid bonds
add_hbond(hIdx,
lastShellIdx,
shellTimeIdx,
thisAcceptor,
breakBond=True,
debugMessage="tolerance time violated")
# reset parameters
shellTimeIdx = [None, None]
lowerAngleTime = [None, None]
continue
# final hbonds in hIdx
add_hbond(hIdx,
lastShellIdx,
shellTimeIdx,
thisAcceptor,
breakBond=False)
# create all registered hbond
create_hbonds()
# normalize and create the total
for shellIdx in range(len(self.shellsResultKeys)):
shellKey = self.shellsResultKeys[shellIdx]
self.results['hbonds_%s_distribution' % shellKey] /= len(
self.configurationsIndexes)
self.results['hbonds_distribution'] += self.results[
'hbonds_%s_distribution' % shellKey]
# Hydrogen bonds mean life time
nonzero = list(np.where(self.results['hbonds_time'])[0])
nHbonds = [self.results['hbonds_time'][idx] for idx in nonzero]
times = [self.results['time'][idx] for idx in nonzero]
times = [times[idx] * nHbonds[idx] for idx in range(len(times))]
if len(times):
self.results['hBond_mean_life_time'] = np.array([np.sum(times)
]) / len(times)
else:
self.results['hBond_mean_life_time'] = np.array([0.0])
import numpy as np
from pdbParser.log import Logger
from pdbParser import pdbParser
from pdbParser.Utilities.Construct import AmorphousSystem
from pdbParser.Utilities.Database import __WATER__
# create pdbWATER
pdbWATER = pdbParser()
pdbWATER.records = __WATER__
pdbWATER.set_name("water")
Logger.info("Create water box")
pdbWATER = AmorphousSystem(pdbWATER,
density=0.25,
boxSize=np.array([10, 10,
10])).construct().get_pdb()
pdbWATER.visualize()
"""
Construct a graphene sheet in two orientations
"""
from pdbParser.log import Logger
from pdbParser import pdbParser
from pdbParser.Utilities.Geometry import translate
from pdbParser.Utilities.Construct import Sheet, Nanotube, MultipleWallNanotube
Logger.info("Constructing arm-chair sheet")
pdbGS_armchair = Sheet().construct().get_pdb()
Logger.info("Constructing zig-zag sheet")
pdbGS_zigzag = Sheet(orientation="zigzag").construct().pdb
translate(pdbGS_zigzag.indexes, pdbGS_zigzag, vector=[0, 0, 10])
Logger.info("Constructing carbon nanotube from scratch")
pdbCNT1 = Sheet(orientation="zigzag").construct().wrap().get_pdb()
translate(pdbCNT1.indexes, pdbCNT1, vector=[0, 40, 30])
Logger.info("constructing nanotube using appropriate class")
pdbCNT2 = Nanotube().construct().get_pdb()
translate(pdbCNT2.indexes, pdbCNT2, vector=[0, 10, 30])
Logger.info("constructing 5 walls multi-walled nanotube")
pdbMWNT = MultipleWallNanotube(
wallsNumber=5,
orientation=["armchair", "zig-zag", "zig-zag", "zig-zag",
"armchair"]).construct().get_pdb()
translate(pdbMWNT.indexes, pdbMWNT, vector=[0, 25, -40])
pdbALL = pdbGS_armchair
stepTime=0.2,
numberOfSteps=10,
outputFrequency=1,
exportInitialConfiguration=True,
outputPath=tempfile.mktemp(".xyz"))
# remove all bonded interactions
sim.bonds_indexes = []
sim.angles_indexes = []
sim.dihedrals_indexes = []
sim.nBondsThreshold = [[], []]
# setting charges to 0
sim.atomsCharge = [0, 0]
# initial parameters
Logger.info(
"minimizing %s steps at %s fm per step, with atoms charge %s, VDW forces push atoms to equilibrium distance %s"
% (sim.numberOfSteps, sim.timeStep, sim.atomsCharge,
2 * sim.__LJ__['h']['rmin/2']))
sim.minimize_steepest_descent()
# add charges and change stepTime
sim.atomsCharge = [0.15, 0.15]
sim.stepTime = 0.02
sim.exportInitialConfiguration = False
# re-minimize parameters
Logger.info(
"minimizing %s steps at %s fm per step, with atoms charge %s, VDW forces push atoms to equilibrium distance %s"
% (sim.numberOfSteps, sim.timeStep, sim.atomsCharge,
2 * sim.__LJ__['h']['rmin/2']))
sim.minimize_steepest_descent()
sim.bonds_indexes = []
sim.angles_indexes = []
sim.lennardJones_eps *= 0
sim.atomsCharge *= 0
# initial parameters
sim.__DIHEDRAL__["c c c c"] = {
1.0: {
'delta': 40.0,
'n': 1.0,
'kchi': 3.6375696
}
}
sim.set_dihedrals_parameters()
Logger.info(
"minimizing %s steps at %s fm per step, with all terms suppressed but dihedral %s"
% (sim.numberOfSteps, sim.timeStep, sim.__DIHEDRAL__["c c c c"]))
sim.minimize_steepest_descent()
sim.exportInitialConfiguration = False
# initial parameters
sim.__DIHEDRAL__["c c c c"] = {
1.0: {
'delta': 120.0,
'n': 1.0,
'kchi': 3.6375696
}
}
sim.set_dihedrals_parameters()
Logger.info(
"""
Construct a graphene sheet in two orientations
"""
import os
from pdbParser.Utilities.Collection import get_path
from pdbParser.log import Logger
from pdbParser import pdbParser
from pdbParser.Utilities.Connectivity import Connectivity
from pdbParser.Utilities.Modify import reset_atom_name
Logger.info("reading SDBS molecule")
pdb = pdbParser(
os.path.join(get_path("pdbparser"), "Data/connectivityTestMolecule.pdb"))
connectivity = Connectivity(pdb)
# bonds
Logger.info("calculating bonds")
connectivity.calculate_bonds()
bonds = connectivity.get_bonds(key="atom_name")
print "BONDS:"
print "======"
for idx in range(len(bonds[0])):
print "%6s" % bonds[0][idx], ' = ', bonds[1][idx]
#connectivity.export_bonds('lol.psf')
# angles
Logger.info("calculating angles")
connectivity.calculate_angles()
angles = connectivity.get_angles(key="atom_name")
import os
import numpy as np
from pdbParser.log import Logger
from pdbParser import pdbParser
from pdbParser.Utilities.Collection import get_path
from pdbParser.Utilities.Selection import NanotubeSelection
from pdbParser.Utilities.Information import get_models_records_indexes_by_records_indexes, get_records_indexes_in_attribute_values
from pdbParser.Utilities.Modify import *
from pdbParser.Utilities.Geometry import get_principal_axis, translate, orient
# read pdb
pdbCNT = pdbParser(
os.path.join(get_path("pdbparser"), "Data/nanotubeWaterNAGMA.pdb"))
Logger.info("Define models")
# define models
define_models_by_records_attribute_value(pdbCNT.indexes, pdbCNT)
Logger.info("Getting nanotube indexes")
# get CNT indexes
cntIndexes = get_records_indexes_in_attribute_values(pdbCNT.indexes, pdbCNT,
"residue_name", "CNT")
Logger.info("Create selection")
# create selection
sel = NanotubeSelection(pdbCNT, nanotubeIndexes=cntIndexes).select()
Logger.info("Get models inside nanotube")
# construct models out of residues
indexes = get_models_records_indexes_by_records_indexes(
sim.nBondsThreshold = [[] for ids in pdb.indexes]
sim.angles_indexes = []
sim.dihedrals_indexes = []
sim.atomsCharge *= 0
# minimize energy
#Logger.info("minimization at %s fm per step" % (sim.timeStep) )
#sim.outputFrequency = 1
#sim.minimize_steepest_descent(99)
# equilibration
sim.exportInitialConfiguration = True
sim.outputFrequency = 1
sim.logExport = True
sim.timeStep = 0.1
Logger.info("equilibration at %s fm per step" % (sim.timeStep) )
sim.simulate(100)
# production
sim.exportInitialConfiguration = False
sim.outputFrequency = 1
sim.logExport = True
sim.timeStep = 1
Logger.info("production at %s fm per step" % (sim.timeStep) )
sim.simulate(3000, initializeVelocities = False)
# visualize molecule
sim.visualize_trajectory(sim.outputPath)
"""
In this test, an SDS molecule is loaded
several records manipulations, translation, rotation, orientation, ... are tested
"""
# standard distribution imports
import os
# pdbParser imports
from pdbParser.Utilities.Collection import get_path
from pdbParser.log import Logger
from pdbParser.pdbParser import pdbParser
from pdbParser.Utilities.Geometry import *
pdbRESULT = pdbParser()
Logger.info("loading sds molecule ...")
pdbSDS = pdbParser(os.path.join(get_path("pdbparser"), "Data", "SDS.pdb"))
INDEXES = range(len(pdbSDS.records))
# get molecule axis
sdsAxis = get_axis(INDEXES, pdbSDS)
## translate to positive quadrant
atomToOriginIndex = get_closest_to_origin(INDEXES, pdbSDS)
atom = pdbSDS.records[atomToOriginIndex]
[minX, minY,
minZ] = [atom['coordinates_x'], atom['coordinates_y'], atom['coordinates_z']]
translate(INDEXES, pdbSDS, [-1.1 * minX, -1.1 * minY, -1.1 * minZ])
Logger.info("orient molecule along [1,0,0] ...")
orient(axis=[1, 0, 0], indexes=INDEXES, pdb=pdbSDS, records_axis=sdsAxis)
sdsAxis = [1, 0, 0]
pdbRESULT.concatenate(pdbSDS)
# pdbParser imports
from pdbParser.Utilities.Collection import get_path
from pdbParser import pdbParser
from pdbParser.log import Logger
from pdbParser.Utilities.Construct import AmorphousSystem, Micelle
from pdbParser.Utilities.Geometry import get_satisfactory_records_indexes, translate
from pdbParser.Utilities.Modify import delete_records_and_models_records
from pdbParser.Utilities.Database import __WATER__
# create pdbWATER
pdbWATER = pdbParser()
pdbWATER.records = __WATER__
pdbWATER.set_name("water")
Logger.info("Create water box")
pdbWATER = AmorphousSystem(pdbWATER, density = 0.5).construct().get_pdb()
pdbWATERhollow = pdbWATER.get_copy()
# make sphere
Logger.info("Create a water sphere of 15A radius")
sphereIndexes = get_satisfactory_records_indexes(pdbWATER.indexes, pdbWATER, "np.sqrt(x**2 + y**2 + z**2) >= 15")
delete_records_and_models_records(sphereIndexes, pdbWATER)
# make hollow
Logger.info("Remove a water sphere of 15A radius")
hollowIndexes = get_satisfactory_records_indexes(pdbWATERhollow.indexes, pdbWATERhollow, "np.sqrt(x**2 + y**2 + z**2) <= 15")
delete_records_and_models_records(hollowIndexes, pdbWATERhollow)
# translate hollow
translate(pdbWATERhollow.indexes, pdbWATERhollow, vector =[60,0,0])
