def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('numsteps', 'int', 'Number of steps to run the simulations in units of 4fs', 0, TYPE_INT, RANGE_0POS)
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0, TYPE_FLOAT, RANGE_ANY)
self._cmdString('reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.', 'none')
self._cmdString('selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('box', 'list', 'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]', [0,0,0,0,0,0])
self._cmdBoolean('useconstantratio', 'bool', 'For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.', False)
self._cmdDict('constraints', 'dict', 'A dictionary containing as keys the atomselections of the constraints '
'and as values the constraint scaling factor. 0 factor means no constraint'
', 1 full constraints and in between values are used for scaling.'
' The order with which the constraints are applied is random, so make '
'atomselects mutually exclusive to be sure you get the correct constraints.'
, {'protein and noh and not name CA': 0.1, 'protein and name CA': 1})
self.acemd = Acemd()
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '1000'
self.acemd.constraints = 'on'
self.acemd.consref = None
self.acemd.constraintscaling = '1.0'
self.acemd.berendsenpressure = 'on'
self.acemd.berendsenpressuretarget = '1.01325'
self.acemd.berendsenpressurerelaxationtime = '800'
self.acemd.tclforces = 'on'
self.acemd.minimize = '500'
self.acemd.run = '$numsteps'
self.acemd.TCL='''
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('numsteps', 'int', 'Number of steps to run the simulations in units of 4fs', 0, TYPE_INT, RANGE_0POS)
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0, TYPE_FLOAT, RANGE_ANY)
self._cmdString('reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.', 'none')
self._cmdString('selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('box', 'list', 'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]', [0,0,0,0,0,0])
self.acemd = Acemd()
#self.acemd.binindex='input.idx'
self.acemd.extendedsystem='input.xsc'
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '300'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '300'
self.acemd.langevindamping = '0.1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '5000'
self.acemd.run = '$numsteps'
self._TCL='''
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.', 25000, TYPE_FLOAT, RANGE_0POS)
self._cmdString('timeunits', 'str', 'Units for time arguments. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('fb_k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0,
TYPE_FLOAT, RANGE_ANY)
self._cmdString('fb_reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.',
'none')
self._cmdString('fb_selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('fb_box', 'list', 'Position of the flatbottom box in term of the reference center given as '
'[xmin, xmax, ymin, ymax, zmin, zmax]', [0, 0, 0, 0, 0, 0])
self._cmdBoolean('useconstantratio', 'bool', 'For membrane protein simulations set it to true so that the '
'barostat does not modify the xy aspect ratio.', False)
self._cmdDict('constraints', 'dict', 'A dictionary of atomselections and values of the constraint to be '
'applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.'
, {'protein and noh and not name CA': 0.1, 'protein and name CA': 1})
self._cmdValue('nvtsteps', 'int', 'Number of initial steps to apply NVT in units of 4fs.', 500, TYPE_INT,
RANGE_ANY)
self._cmdValue('constraintsteps', 'int', 'Number of initial steps to apply constraints in units of 4fs. '
'Defaults to half the simulation time.', None, TYPE_INT, RANGE_ANY)
self.acemd = Acemd()
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '1000'
self.acemd.constraints = 'on'
self.acemd.consref = None
self.acemd.constraintscaling = '1.0'
self.acemd.berendsenpressure = 'on'
self.acemd.berendsenpressuretarget = '1.01325'
self.acemd.berendsenpressurerelaxationtime = '800'
self.acemd.tclforces = 'on'
self.acemd.minimize = '500'
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set temperature {TEMPERATURE}
set nvtsteps {NVTSTEPS}
set constraintsteps {CONSTRAINTSTEPS}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''',
'''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel numsteps fb_K fb_box nvtsteps constraintsteps
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
##EQUIL
set step [ getstep ]
if { $step > $nvtsteps } {
berendsenpressure on
} else {
berendsenpressure off
}
if { $step > $constraintsteps } {
constraintscaling 0
} else {
constraintscaling [expr 1 - 0.95*$step/$constraintsteps]
}
}
proc calcforces_endstep { } { }
''')
class Equilibration(OldProtocolInterface):
""" Equilibration protocol v2
Equilibration protocol for globular and membrane proteins
It includes a flatbottom potential box to retrain a ligand
for example within this box.
Parameters
----------
runtime : float, default=0
Running time of the simulation.
timeunits : str, default='steps'
Units for time arguments. Can be 'steps', 'ns' etc.
temperature : float, default=300
Temperature of the thermostat in Kelvin
fb_k : float, default=0
Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5
fb_reference : str, default='none'
Reference selection to use as dynamic center of the flatbottom box.
fb_selection : str, default='none'
Selection of atoms to apply the flatbottom potential
fb_box : list, default=[0, 0, 0, 0, 0, 0]
Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]
useconstantratio : bool, default=False
For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.
constraints : dict, default={'protein and name CA': 1, 'protein and noh and not name CA': 0.1}
A dictionary of atomselections and values of the constraint to be applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.
nvtsteps : int, default=500
Number of initial steps to apply NVT in units of 4fs.
constraintsteps : int, default=None
Number of initial steps to apply constraints in units of 4fs. Defaults to half the simulation time.
Example
-------
>>> from htmd.protocols.equilibration_v2 import Equilibration
>>> md = Equilibration()
>>> md.runtime = 4
>>> md.timeunits = 'ns'
>>> md.temperature = 300
>>> md.useconstantratio = True # only for membrane sims
>>> # this is only needed for setting the flatbottom potential, otherwise remove it
>>> md.fb_reference = 'protein and resid 293'
>>> md.fb_selection = 'segname L and noh'
>>> md.fb_box = [-25, 25, -25, 25, 43, 45]
>>> md.fb_k = 5
>>> md.write('./build','./equil')
"""
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.', 25000, TYPE_FLOAT, RANGE_0POS)
self._cmdString('timeunits', 'str', 'Units for time arguments. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('fb_k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0,
TYPE_FLOAT, RANGE_ANY)
self._cmdString('fb_reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.',
'none')
self._cmdString('fb_selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('fb_box', 'list', 'Position of the flatbottom box in term of the reference center given as '
'[xmin, xmax, ymin, ymax, zmin, zmax]', [0, 0, 0, 0, 0, 0])
self._cmdBoolean('useconstantratio', 'bool', 'For membrane protein simulations set it to true so that the '
'barostat does not modify the xy aspect ratio.', False)
self._cmdDict('constraints', 'dict', 'A dictionary of atomselections and values of the constraint to be '
'applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.'
, {'protein and noh and not name CA': 0.1, 'protein and name CA': 1})
self._cmdValue('nvtsteps', 'int', 'Number of initial steps to apply NVT in units of 4fs.', 500, TYPE_INT,
RANGE_ANY)
self._cmdValue('constraintsteps', 'int', 'Number of initial steps to apply constraints in units of 4fs. '
'Defaults to half the simulation time.', None, TYPE_INT, RANGE_ANY)
self.acemd = Acemd()
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '1000'
self.acemd.constraints = 'on'
self.acemd.consref = None
self.acemd.constraintscaling = '1.0'
self.acemd.berendsenpressure = 'on'
self.acemd.berendsenpressuretarget = '1.01325'
self.acemd.berendsenpressurerelaxationtime = '800'
self.acemd.tclforces = 'on'
self.acemd.minimize = '500'
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set temperature {TEMPERATURE}
set nvtsteps {NVTSTEPS}
set constraintsteps {CONSTRAINTSTEPS}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''',
'''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel numsteps fb_K fb_box nvtsteps constraintsteps
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
##EQUIL
set step [ getstep ]
if { $step > $nvtsteps } {
berendsenpressure on
} else {
berendsenpressure off
}
if { $step > $constraintsteps } {
constraintscaling 0
} else {
constraintscaling [expr 1 - 0.95*$step/$constraintsteps]
}
}
proc calcforces_endstep { } { }
''')
def _findFiles(self, inputdir):
# Tries to find default files if the given don't exist
defaults = {'coordinates': ('structure.pdb', ),
'structure': ('structure.psf', 'structure.prmtop'),
'parameters': ('parameters', 'structure.prmtop')}
for field in defaults:
userval = self.acemd.__dict__[field]
if userval is not None and not os.path.exists(os.path.join(inputdir, userval)):
self.acemd.__dict__[field] = None
if self.acemd.__dict__[field] is None:
for val in defaults[field]:
if os.path.exists(os.path.join(inputdir, val)):
self.acemd.__dict__[field] = val
break
if userval is not None and self.acemd.__dict__[field] is not None and self.acemd.__dict__[field] != userval:
logger.warning('Could not locate structure file {}. Using {} instead.'.format(
os.path.join(inputdir, userval), os.path.join(inputdir, self.acemd.__dict__[field])
))
elif self.acemd.__dict__[field] is None:
raise RuntimeError('Could not locate any {f:} file in {i:}. '
'Please set the Equilibration.acemd.{f:} property to '
'point to the {f:} file'.format(f=field, i=inputdir))
if self.acemd.consref is None:
self.acemd.consref = self.acemd.coordinates
def _amberFixes(self):
# AMBER specific fixes
if self.acemd.parameters.endswith('structure.prmtop'):
self.acemd.parmfile = self.acemd.parameters
self.acemd.parameters = None
self.acemd.scaling14 = '0.8333333'
self.acemd.amber = 'on'
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning('Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
if isinstance(self.acemd.TCL, tuple):
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)),
NVTSTEPS=self.nvtsteps, CONSTRAINTSTEPS=constrsteps, TEMPERATURE=self.temperature)
self.acemd.TCL = tcl[0] + tcl[1]
else:
logger.warning('{} default TCL was already formatted.'.format(self.__class__.__name__))
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints by writing them to the consref file
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have not defined any constraints for the Equilibration (constraints={}).')
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def addConstraint(self, atomselect, factor=1):
""" Convenience function for adding a new constraint to existing constraints.
Parameters
----------
atomselect : str
Atom selection of atoms we want to constrain
factor : float
The scaling factor of the constraints applied to the atoms
Example
-------
>>> eq.addConstraint('chain X', 0.3)
"""
self.constraints[atomselect] = factor
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.', 0, TYPE_FLOAT, RANGE_0POS)
self._cmdString('timeunits', 'str', 'Units for runtime. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('fb_k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0, TYPE_FLOAT, RANGE_ANY)
self._cmdString('fb_reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.', 'none')
self._cmdString('fb_selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('fb_box', 'list', 'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]', [0,0,0,0,0,0])
self._cmdList('useconstraints', 'bool', 'Apply constraints to the production simulation, defined by the constraints parameter', False)
self._cmdDict('constraints', 'dict', 'A dictionary of atomselections and values of the constraint to be applied '
'(in kcal/mol/A^2). Atomselects must be mutually exclusive.'
, {})
self.acemd = Acemd()
#self.acemd.binindex='input.idx'
self.acemd.extendedsystem='input.xsc'
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '300'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '300'
self.acemd.langevindamping = '0.1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '5000'
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''',
'''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel fb_K fb_box
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
}
proc calcforces_endstep { } { }
''')
class Production(ProtocolInterface):
''' Production protocol v3
Production protocol for globular and membrane proteins
It also includes a possible flatbottom potential box
It is also possible to define constraints for the production run
Parameters
----------
runtime : float, default=0
Running time of the simulation.
timeunits : str, default='steps'
Units for runtime. Can be 'steps', 'ns' etc.
temperature : float, default=300
Temperature of the thermostat in Kelvin
fb_k : float, default=0
Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5
fb_reference : str, default='none'
Reference selection to use as dynamic center of the flatbottom box.
fb_selection : str, default='none'
Selection of atoms to apply the flatbottom potential
fb_box : list, default=[0, 0, 0, 0, 0, 0]
Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]
useconstraints: bool, default=False
Apply constraints to the production simulation, defined by the constraints parameter
constraints : dict, default={}
A dictionary of atomselections and values of the constraint to be applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.
'''
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.', 0, TYPE_FLOAT, RANGE_0POS)
self._cmdString('timeunits', 'str', 'Units for runtime. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('fb_k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0, TYPE_FLOAT, RANGE_ANY)
self._cmdString('fb_reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.', 'none')
self._cmdString('fb_selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('fb_box', 'list', 'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]', [0,0,0,0,0,0])
self._cmdList('useconstraints', 'bool', 'Apply constraints to the production simulation, defined by the constraints parameter', False)
self._cmdDict('constraints', 'dict', 'A dictionary of atomselections and values of the constraint to be applied '
'(in kcal/mol/A^2). Atomselects must be mutually exclusive.'
, {})
self.acemd = Acemd()
#self.acemd.binindex='input.idx'
self.acemd.extendedsystem='input.xsc'
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '300'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '300'
self.acemd.langevindamping = '0.1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '5000'
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''',
'''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel fb_K fb_box
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
}
proc calcforces_endstep { } { }
''')
def _findFiles(self, inputdir):
# Tries to find default files if the given don't exist
defaults = {'coordinates': ('structure.pdb',),
'structure': ('structure.psf', 'structure.prmtop'),
'parameters': ('parameters', 'structure.prmtop')}
for field in defaults:
userval = self.acemd.__dict__[field]
if userval is not None and not os.path.exists(os.path.join(inputdir, userval)):
self.acemd.__dict__[field] = None
if self.acemd.__dict__[field] is None:
for val in defaults[field]:
if os.path.exists(os.path.join(inputdir, val)):
self.acemd.__dict__[field] = val
break
if userval is not None and self.acemd.__dict__[field] is not None and self.acemd.__dict__[field] != userval:
logger.warning('Could not locate structure file {}. Using {} instead.'.format(
os.path.join(inputdir, userval), os.path.join(inputdir, self.acemd.__dict__[field])
))
elif self.acemd.__dict__[field] is None:
raise RuntimeError('Could not locate any {f:} file in {i:}. '
'Please set the Equilibration.acemd.{f:} property to '
'point to the {f:} file'.format(f=field, i=inputdir))
def _amberFixes(self):
# AMBER specific fixes
if self.acemd.parameters.endswith('structure.prmtop'):
self.acemd.parmfile = self.acemd.parameters
self.acemd.parameters = None
self.acemd.scaling14 = '0.8333333'
self.acemd.amber = 'on'
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
if self.fb_k > 0: #use TCL only for flatbottom
mol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, mol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, mol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {}\n'.format(numsteps)
if self.useconstraints:
# Turn on constraints
self.acemd.constraints = 'on'
self.acemd.constraintscaling = '1.0'
else:
if len(self.constraints) != 0:
logger.warning('You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define useconstraints=True'.format(self.constraints))
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints
if self.useconstraints:
inmol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
inmol.set('occupancy', 0)
inmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have set the production to use constraints (useconstraints=True), but have not '
'defined any constraints (constraints={}).')
else:
for sel in self.constraints:
inmol.set('beta', self.constraints[sel], sel)
outfile = os.path.join(outputdir, self.acemd.coordinates)
inmol.write(outfile)
self.acemd.consref = self.acemd.coordinates
def __init__(self):
super().__init__()
self._cmdObject('acemd',
':class:`MDEngine <htmd.apps.app.App>` object',
'MD engine', None, Acemd)
self._cmdValue(
'numsteps', 'int',
'Number of steps to run the simulations in units of 4fs', 0,
TYPE_INT, RANGE_0POS)
self._cmdValue('temperature', 'float',
'Temperature of the thermostat in Kelvin', 300,
TYPE_FLOAT, RANGE_ANY)
self._cmdValue(
'k', 'float',
'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5',
0, TYPE_FLOAT, RANGE_ANY)
self._cmdString(
'reference', 'str',
'Reference selection to use as dynamic center of the flatbottom box.',
'none')
self._cmdString(
'selection', 'str',
'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList(
'box', 'list',
'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]',
[0, 0, 0, 0, 0, 0])
self._cmdBoolean(
'useconstantratio', 'bool',
'For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.',
False)
self._cmdDict(
'constraints', 'dict',
'A dictionary containing as keys the atomselections of the constraints '
'and as values the constraint scaling factor. 0 factor means no constraint'
', 1 full constraints and in between values are used for scaling.'
' The order with which the constraints are applied is random, so make '
'atomselects mutually exclusive to be sure you get the correct constraints.',
{
'protein and noh and not name CA': 0.1,
'protein and name CA': 1
})
self.acemd = Acemd()
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '1000'
self.acemd.constraints = 'on'
self.acemd.consref = None
self.acemd.constraintscaling = '1.0'
self.acemd.berendsenpressure = 'on'
self.acemd.berendsenpressuretarget = '1.01325'
self.acemd.berendsenpressurerelaxationtime = '800'
self.acemd.tclforces = 'on'
self.acemd.minimize = '500'
self.acemd.run = '$numsteps'
self.acemd.TCL = '''
class Equilibration(ProtocolInterface):
""" Equilibration protocol
Equilibration protocol for globular and membrane proteins
It includes a flatbottom potential box to retrain a ligand
for example within this box.
Parameters
----------
numsteps : int, default=0
Number of steps to run the simulations in units of 4fs
temperature : float, default=300
Temperature of the thermostat in Kelvin
k : float, default=0
Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5
reference : str, default='none'
Reference selection to use as dynamic center of the flatbottom box.
selection : str, default='none'
Selection of atoms to apply the flatbottom potential
box : list, default=[0, 0, 0, 0, 0, 0]
Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]
useconstantratio : bool, default=False
For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.
constraints : dict, default={'protein and noh and not name CA': 0.1, 'protein and name CA': 1}
A dictionary containing as keys the atomselections of the constraints and as values the constraint scaling factor. 0 factor means no constraint, 1 full constraints and in between values are used for scaling. The order with which the constraints are applied is random, so make atomselects mutually exclusive to be sure you get the correct constraints.
Example
-------
>>> from htmd.protocols.equilibration_v1 import Equilibration
>>> md = Equilibration()
>>> md.numsteps = 10000000
>>> md.temperature = 300
>>> md.useconstantratio = True # only for membrane sims
>>> # this is only needed for setting the flatbottom potential, otherwise remove it
>>> md.reference = 'protein and resid 293'
>>> md.selection = 'segname L and noh'
>>> md.box = [-25, 25, -25, 25, 43, 45]
>>> md.k = 5
>>> md.write('./build','./equil')
"""
def __init__(self):
super().__init__()
self._cmdObject('acemd',
':class:`MDEngine <htmd.apps.app.App>` object',
'MD engine', None, Acemd)
self._cmdValue(
'numsteps', 'int',
'Number of steps to run the simulations in units of 4fs', 0,
TYPE_INT, RANGE_0POS)
self._cmdValue('temperature', 'float',
'Temperature of the thermostat in Kelvin', 300,
TYPE_FLOAT, RANGE_ANY)
self._cmdValue(
'k', 'float',
'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5',
0, TYPE_FLOAT, RANGE_ANY)
self._cmdString(
'reference', 'str',
'Reference selection to use as dynamic center of the flatbottom box.',
'none')
self._cmdString(
'selection', 'str',
'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList(
'box', 'list',
'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]',
[0, 0, 0, 0, 0, 0])
self._cmdBoolean(
'useconstantratio', 'bool',
'For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.',
False)
self._cmdDict(
'constraints', 'dict',
'A dictionary containing as keys the atomselections of the constraints '
'and as values the constraint scaling factor. 0 factor means no constraint'
', 1 full constraints and in between values are used for scaling.'
' The order with which the constraints are applied is random, so make '
'atomselects mutually exclusive to be sure you get the correct constraints.',
{
'protein and noh and not name CA': 0.1,
'protein and name CA': 1
})
self.acemd = Acemd()
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '1000'
self.acemd.constraints = 'on'
self.acemd.consref = None
self.acemd.constraintscaling = '1.0'
self.acemd.berendsenpressure = 'on'
self.acemd.berendsenpressuretarget = '1.01325'
self.acemd.berendsenpressurerelaxationtime = '800'
self.acemd.tclforces = 'on'
self.acemd.minimize = '500'
self.acemd.run = '$numsteps'
self.acemd.TCL = '''
set numsteps NUMSTEPS
set temperature TEMPERATURE
set refindex { REFINDEX }
set selindex { SELINDEX }
set box { BOX }
set K KCONST
#
proc flatbot1d {x xm xM K} {
set f 0
if {$x < $xm} {
set f [expr $K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel refindex selindex
berendsenpressure off
set ref [addgroup $refindex]
set sel [addgroup $selindex]
}
proc calcforces {} {
global ref sel numsteps K box
loadcoords coords
##FLATBOTTOM
if {$K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $box 0] [lindex $box 1] $K]
set fy [flatbot1d [lindex $dr 1] [lindex $box 2] [lindex $box 3] $K]
set fz [flatbot1d [lindex $dr 2] [lindex $box 4] [lindex $box 5] $K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
##EQUIL
set step [ getstep ]
if { $step > 500 } {
berendsenpressure on
} else {
berendsenpressure off}
if { $step > [expr $numsteps/2] } {
constraintscaling 0
} else {
constraintscaling [expr 1 + $step*(0.05-1)*2/$numsteps]}
}
proc calcforces_endstep { } { }
proc calcforces_terminate { } { }
'''
def _findFiles(self, inputdir):
# Tries to find default files if the given don't exist
defaults = {
'coordinates': ('structure.pdb', ),
'structure': ('structure.psf', 'structure.prmtop'),
'parameters': ('parameters', 'structure.prmtop')
}
for field in defaults:
userval = self.acemd.__dict__[field]
if userval is not None and not os.path.exists(
os.path.join(inputdir, userval)):
self.acemd.__dict__[field] = None
if self.acemd.__dict__[field] is None:
for val in defaults[field]:
if os.path.exists(os.path.join(inputdir, val)):
self.acemd.__dict__[field] = val
break
if userval is not None and self.acemd.__dict__[
field] is not None and self.acemd.__dict__[
field] != userval:
logger.warning(
'Could not locate structure file {}. Using {} instead.'.
format(os.path.join(inputdir, userval),
os.path.join(inputdir, self.acemd.__dict__[field])))
elif self.acemd.__dict__[field] is None:
raise RuntimeError(
'Could not locate any {f:} file in {i:}. '
'Please set the Equilibration.acemd.{f:} property to '
'point to the {f:} file'.format(f=field, i=inputdir))
if self.acemd.consref is None:
self.acemd.consref = self.acemd.coordinates
def _amberFixes(self):
# AMBER specific fixes
if self.acemd.parameters.endswith('structure.prmtop'):
self.acemd.parmfile = self.acemd.parameters
self.acemd.parameters = None
self.acemd.scaling14 = '0.8333333'
self.acemd.amber = 'on'
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
self.acemd.TCL = self.acemd.TCL.replace('NUMSTEPS', str(self.numsteps))
self.acemd.TCL = self.acemd.TCL.replace('TEMPERATURE',
str(self.temperature))
self.acemd.TCL = self.acemd.TCL.replace('KCONST', str(self.k))
self.acemd.TCL = self.acemd.TCL.replace(
'REFINDEX', ' '.join(map(str, inmol.get('index', self.reference))))
self.acemd.TCL = self.acemd.TCL.replace(
'SELINDEX', ' '.join(map(str, inmol.get('index', self.selection))))
self.acemd.TCL = self.acemd.TCL.replace('BOX',
' '.join(map(str, self.box)))
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(
dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints
inmol.set('occupancy', 0)
inmol.set('beta', 0)
for sel in self.constraints:
inmol.set('beta', self.constraints[sel], sel)
outfile = os.path.join(outputdir, self.acemd.coordinates)
inmol.write(outfile)
def addConstraint(self, atomselect, factor=1):
""" Convenience function for adding a new constraint to existing constraints.
Parameters
----------
atomselect : str
Atom selection of atoms we want to constrain
factor : float
The scaling factor of the constraints applied to the atoms
Example
-------
>>> eq.addConstraint('chain X', 0.3)
"""
self.constraints[atomselect] = factor
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.', 0, TYPE_FLOAT, RANGE_0POS)
self._cmdString('timeunits', 'str', 'Units for runtime. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('fb_k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0, TYPE_FLOAT, RANGE_ANY)
self._cmdString('fb_reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.', 'none')
self._cmdString('fb_selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('fb_box', 'list', 'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]', [0,0,0,0,0,0])
self.acemd = Acemd()
#self.acemd.binindex='input.idx'
self.acemd.extendedsystem='input.xsc'
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '300'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '300'
self.acemd.langevindamping = '0.1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '5000'
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''',
'''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel fb_K fb_box
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
}
proc calcforces_endstep { } { }
''')
class Production(ProtocolInterface):
''' Production protocol for globular and membrane proteins
It also includes a possible flatbottom potential box
Parameters
----------
runtime : float, default=0
Running time of the simulation.
timeunits : str, default='steps'
Units for runtime. Can be 'steps', 'ns' etc.
temperature : float, default=300
Temperature of the thermostat in Kelvin
fb_k : float, default=0
Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5
fb_reference : str, default='none'
Reference selection to use as dynamic center of the flatbottom box.
fb_selection : str, default='none'
Selection of atoms to apply the flatbottom potential
fb_box : list, default=[0, 0, 0, 0, 0, 0]
Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]
'''
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.', 0, TYPE_FLOAT, RANGE_0POS)
self._cmdString('timeunits', 'str', 'Units for runtime. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('fb_k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0, TYPE_FLOAT, RANGE_ANY)
self._cmdString('fb_reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.', 'none')
self._cmdString('fb_selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('fb_box', 'list', 'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]', [0,0,0,0,0,0])
self.acemd = Acemd()
#self.acemd.binindex='input.idx'
self.acemd.extendedsystem='input.xsc'
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '300'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '300'
self.acemd.langevindamping = '0.1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '5000'
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''',
'''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel fb_K fb_box
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
}
proc calcforces_endstep { } { }
''')
def _findFiles(self, inputdir):
# Tries to find default files if the given don't exist
defaults = {'coordinates': ('structure.pdb',),
'structure': ('structure.psf', 'structure.prmtop'),
'parameters': ('parameters', 'structure.prmtop')}
for field in defaults:
userval = self.acemd.__dict__[field]
if userval is not None and not os.path.exists(os.path.join(inputdir, userval)):
self.acemd.__dict__[field] = None
if self.acemd.__dict__[field] is None:
for val in defaults[field]:
if os.path.exists(os.path.join(inputdir, val)):
self.acemd.__dict__[field] = val
break
if userval is not None and self.acemd.__dict__[field] is not None and self.acemd.__dict__[field] != userval:
logger.warning('Could not locate structure file {}. Using {} instead.'.format(
os.path.join(inputdir, userval), os.path.join(inputdir, self.acemd.__dict__[field])
))
elif self.acemd.__dict__[field] is None:
raise RuntimeError('Could not locate any {f:} file in {i:}. '
'Please set the Equilibration.acemd.{f:} property to '
'point to the {f:} file'.format(f=field, i=inputdir))
def _amberFixes(self):
# AMBER specific fixes
if self.acemd.parameters.endswith('structure.prmtop'):
self.acemd.parmfile = self.acemd.parameters
self.acemd.parameters = None
self.acemd.scaling14 = '0.8333333'
self.acemd.amber = 'on'
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
if self.fb_k > 0: #use TCL only for flatbottom
mol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, mol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, mol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {}\n'.format(numsteps)
self.acemd.setup(inputdir, outputdir, overwrite=True)
class Equilibration(ProtocolInterface):
""" Equilibration protocol
Equilibration protocol for globular and membrane proteins
It includes a flatbottom potential box to retrain a ligand
for example within this box.
Parameters
----------
numsteps : int, default=0
Number of steps to run the simulations in units of 4fs
temperature : float, default=300
Temperature of the thermostat in Kelvin
k : float, default=0
Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5
reference : str, default='none'
Reference selection to use as dynamic center of the flatbottom box.
selection : str, default='none'
Selection of atoms to apply the flatbottom potential
box : list, default=[0, 0, 0, 0, 0, 0]
Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]
useconstantratio : bool, default=False
For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.
constraints : dict, default={'protein and noh and not name CA': 0.1, 'protein and name CA': 1}
A dictionary containing as keys the atomselections of the constraints and as values the constraint scaling factor. 0 factor means no constraint, 1 full constraints and in between values are used for scaling. The order with which the constraints are applied is random, so make atomselects mutually exclusive to be sure you get the correct constraints.
Example
-------
>>> from htmd.protocols.equilibration_v1 import Equilibration
>>> md = Equilibration()
>>> md.numsteps = 10000000
>>> md.temperature = 300
>>> md.useconstantratio = True # only for membrane sims
>>> # this is only needed for setting the flatbottom potential, otherwise remove it
>>> md.reference = 'protein and resid 293'
>>> md.selection = 'segname L and noh'
>>> md.box = [-25, 25, -25, 25, 43, 45]
>>> md.k = 5
>>> md.write('./build','./equil')
"""
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('numsteps', 'int', 'Number of steps to run the simulations in units of 4fs', 0, TYPE_INT, RANGE_0POS)
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0, TYPE_FLOAT, RANGE_ANY)
self._cmdString('reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.', 'none')
self._cmdString('selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('box', 'list', 'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]', [0,0,0,0,0,0])
self._cmdBoolean('useconstantratio', 'bool', 'For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.', False)
self._cmdDict('constraints', 'dict', 'A dictionary containing as keys the atomselections of the constraints '
'and as values the constraint scaling factor. 0 factor means no constraint'
', 1 full constraints and in between values are used for scaling.'
' The order with which the constraints are applied is random, so make '
'atomselects mutually exclusive to be sure you get the correct constraints.'
, {'protein and noh and not name CA': 0.1, 'protein and name CA': 1})
self.acemd = Acemd()
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '1000'
self.acemd.constraints = 'on'
self.acemd.consref = None
self.acemd.constraintscaling = '1.0'
self.acemd.berendsenpressure = 'on'
self.acemd.berendsenpressuretarget = '1.01325'
self.acemd.berendsenpressurerelaxationtime = '800'
self.acemd.tclforces = 'on'
self.acemd.minimize = '500'
self.acemd.run = '$numsteps'
self.acemd.TCL='''
set numsteps NUMSTEPS
set temperature TEMPERATURE
set refindex { REFINDEX }
set selindex { SELINDEX }
set box { BOX }
set K KCONST
#
proc flatbot1d {x xm xM K} {
set f 0
if {$x < $xm} {
set f [expr $K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel refindex selindex
berendsenpressure off
set ref [addgroup $refindex]
set sel [addgroup $selindex]
}
proc calcforces {} {
global ref sel numsteps K box
loadcoords coords
##FLATBOTTOM
if {$K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $box 0] [lindex $box 1] $K]
set fy [flatbot1d [lindex $dr 1] [lindex $box 2] [lindex $box 3] $K]
set fz [flatbot1d [lindex $dr 2] [lindex $box 4] [lindex $box 5] $K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
##EQUIL
set step [ getstep ]
if { $step > 500 } {
berendsenpressure on
} else {
berendsenpressure off}
if { $step > [expr $numsteps/2] } {
constraintscaling 0
} else {
constraintscaling [expr 1 + $step*(0.05-1)*2/$numsteps]}
}
proc calcforces_endstep { } { }
proc calcforces_terminate { } { }
'''
def _findFiles(self, inputdir):
# Tries to find default files if the given don't exist
defaults = {'coordinates': ('structure.pdb', ),
'structure': ('structure.psf', 'structure.prmtop'),
'parameters': ('parameters', 'structure.prmtop')}
for field in defaults:
userval = self.acemd.__dict__[field]
if userval is not None and not os.path.exists(os.path.join(inputdir, userval)):
self.acemd.__dict__[field] = None
if self.acemd.__dict__[field] is None:
for val in defaults[field]:
if os.path.exists(os.path.join(inputdir, val)):
self.acemd.__dict__[field] = val
break
if userval is not None and self.acemd.__dict__[field] is not None and self.acemd.__dict__[field] != userval:
logger.warning('Could not locate structure file {}. Using {} instead.'.format(
os.path.join(inputdir, userval), os.path.join(inputdir, self.acemd.__dict__[field])
))
elif self.acemd.__dict__[field] is None:
raise RuntimeError('Could not locate any {f:} file in {i:}. '
'Please set the Equilibration.acemd.{f:} property to '
'point to the {f:} file'.format(f=field, i=inputdir))
if self.acemd.consref is None:
self.acemd.consref = self.acemd.coordinates
def _amberFixes(self):
# AMBER specific fixes
if self.acemd.parameters.endswith('structure.prmtop'):
self.acemd.parmfile = self.acemd.parameters
self.acemd.parameters = None
self.acemd.scaling14 = '0.8333333'
self.acemd.amber = 'on'
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
self.acemd.TCL = self.acemd.TCL.replace('NUMSTEPS', str(self.numsteps))
self.acemd.TCL = self.acemd.TCL.replace('TEMPERATURE', str(self.temperature))
self.acemd.TCL = self.acemd.TCL.replace('KCONST', str(self.k))
self.acemd.TCL = self.acemd.TCL.replace('REFINDEX', ' '.join(map(str, inmol.get('index', self.reference))))
self.acemd.TCL = self.acemd.TCL.replace('SELINDEX', ' '.join(map(str, inmol.get('index', self.selection))))
self.acemd.TCL = self.acemd.TCL.replace('BOX', ' '.join(map(str, self.box)))
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints
inmol.set('occupancy', 0)
inmol.set('beta', 0)
for sel in self.constraints:
inmol.set('beta', self.constraints[sel], sel)
outfile = os.path.join(outputdir, self.acemd.coordinates)
inmol.write(outfile)
def addConstraint(self, atomselect, factor=1):
""" Convenience function for adding a new constraint to existing constraints.
Parameters
----------
atomselect : str
Atom selection of atoms we want to constrain
factor : float
The scaling factor of the constraints applied to the atoms
Example
-------
>>> eq.addConstraint('chain X', 0.3)
"""
self.constraints[atomselect] = factor
def __init__(self):
super().__init__()
self._cmdObject('acemd',
':class:`MDEngine <htmd.apps.app.App>` object',
'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.',
25000, TYPE_FLOAT, RANGE_0POS)
self._cmdString(
'timeunits', 'str',
'Units for time arguments. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float',
'Temperature of the thermostat in Kelvin', 300,
TYPE_FLOAT, RANGE_ANY)
self._cmdValue(
'fb_k', 'float',
'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5',
0, TYPE_FLOAT, RANGE_ANY)
self._cmdString(
'fb_reference', 'str',
'Reference selection to use as dynamic center of the flatbottom box.',
'none')
self._cmdString(
'fb_selection', 'str',
'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList(
'fb_box', 'list',
'Position of the flatbottom box in term of the reference center given as '
'[xmin, xmax, ymin, ymax, zmin, zmax]', [0, 0, 0, 0, 0, 0])
self._cmdBoolean(
'useconstantratio', 'bool',
'For membrane protein simulations set it to true so that the '
'barostat does not modify the xy aspect ratio.', False)
self._cmdDict(
'constraints', 'dict',
'A dictionary of atomselections and values of the constraint to be '
'applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.',
{
'protein and noh and not name CA': 0.1,
'protein and name CA': 1
})
self._cmdValue(
'nvtsteps', 'int',
'Number of initial steps to apply NVT in units of 4fs.', 500,
TYPE_INT, RANGE_ANY)
self._cmdValue(
'constraintsteps', 'int',
'Number of initial steps to apply constraints in units of 4fs. '
'Defaults to half the simulation time.', None, TYPE_INT, RANGE_ANY)
self.acemd = Acemd()
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '1000'
self.acemd.constraints = 'on'
self.acemd.consref = None
self.acemd.constraintscaling = '1.0'
self.acemd.berendsenpressure = 'on'
self.acemd.berendsenpressuretarget = '1.01325'
self.acemd.berendsenpressurerelaxationtime = '800'
self.acemd.tclforces = 'on'
self.acemd.minimize = '500'
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set temperature {TEMPERATURE}
set nvtsteps {NVTSTEPS}
set constraintsteps {CONSTRAINTSTEPS}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''', '''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel numsteps fb_K fb_box nvtsteps constraintsteps
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
##EQUIL
set step [ getstep ]
if { $step > $nvtsteps } {
berendsenpressure on
} else {
berendsenpressure off
}
if { $step > $constraintsteps } {
constraintscaling 0
} else {
constraintscaling [expr 1 - 0.95*$step/$constraintsteps]
}
}
proc calcforces_endstep { } { }
''')
class Equilibration(OldProtocolInterface):
""" Equilibration protocol v2
Equilibration protocol for globular and membrane proteins
It includes a flatbottom potential box to retrain a ligand
for example within this box.
Parameters
----------
runtime : float, default=0
Running time of the simulation.
timeunits : str, default='steps'
Units for time arguments. Can be 'steps', 'ns' etc.
temperature : float, default=300
Temperature of the thermostat in Kelvin
fb_k : float, default=0
Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5
fb_reference : str, default='none'
Reference selection to use as dynamic center of the flatbottom box.
fb_selection : str, default='none'
Selection of atoms to apply the flatbottom potential
fb_box : list, default=[0, 0, 0, 0, 0, 0]
Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]
useconstantratio : bool, default=False
For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.
constraints : dict, default={'protein and name CA': 1, 'protein and noh and not name CA': 0.1}
A dictionary of atomselections and values of the constraint to be applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.
nvtsteps : int, default=500
Number of initial steps to apply NVT in units of 4fs.
constraintsteps : int, default=None
Number of initial steps to apply constraints in units of 4fs. Defaults to half the simulation time.
Example
-------
>>> from htmd.protocols.equilibration_v2 import Equilibration
>>> md = Equilibration()
>>> md.runtime = 4
>>> md.timeunits = 'ns'
>>> md.temperature = 300
>>> md.useconstantratio = True # only for membrane sims
>>> # this is only needed for setting the flatbottom potential, otherwise remove it
>>> md.fb_reference = 'protein and resid 293'
>>> md.fb_selection = 'segname L and noh'
>>> md.fb_box = [-25, 25, -25, 25, 43, 45]
>>> md.fb_k = 5
>>> md.write('./build','./equil')
"""
def __init__(self):
super().__init__()
self._cmdObject('acemd',
':class:`MDEngine <htmd.apps.app.App>` object',
'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.',
25000, TYPE_FLOAT, RANGE_0POS)
self._cmdString(
'timeunits', 'str',
'Units for time arguments. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float',
'Temperature of the thermostat in Kelvin', 300,
TYPE_FLOAT, RANGE_ANY)
self._cmdValue(
'fb_k', 'float',
'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5',
0, TYPE_FLOAT, RANGE_ANY)
self._cmdString(
'fb_reference', 'str',
'Reference selection to use as dynamic center of the flatbottom box.',
'none')
self._cmdString(
'fb_selection', 'str',
'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList(
'fb_box', 'list',
'Position of the flatbottom box in term of the reference center given as '
'[xmin, xmax, ymin, ymax, zmin, zmax]', [0, 0, 0, 0, 0, 0])
self._cmdBoolean(
'useconstantratio', 'bool',
'For membrane protein simulations set it to true so that the '
'barostat does not modify the xy aspect ratio.', False)
self._cmdDict(
'constraints', 'dict',
'A dictionary of atomselections and values of the constraint to be '
'applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.',
{
'protein and noh and not name CA': 0.1,
'protein and name CA': 1
})
self._cmdValue(
'nvtsteps', 'int',
'Number of initial steps to apply NVT in units of 4fs.', 500,
TYPE_INT, RANGE_ANY)
self._cmdValue(
'constraintsteps', 'int',
'Number of initial steps to apply constraints in units of 4fs. '
'Defaults to half the simulation time.', None, TYPE_INT, RANGE_ANY)
self.acemd = Acemd()
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '1000'
self.acemd.constraints = 'on'
self.acemd.consref = None
self.acemd.constraintscaling = '1.0'
self.acemd.berendsenpressure = 'on'
self.acemd.berendsenpressuretarget = '1.01325'
self.acemd.berendsenpressurerelaxationtime = '800'
self.acemd.tclforces = 'on'
self.acemd.minimize = '500'
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set temperature {TEMPERATURE}
set nvtsteps {NVTSTEPS}
set constraintsteps {CONSTRAINTSTEPS}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''', '''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel numsteps fb_K fb_box nvtsteps constraintsteps
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
##EQUIL
set step [ getstep ]
if { $step > $nvtsteps } {
berendsenpressure on
} else {
berendsenpressure off
}
if { $step > $constraintsteps } {
constraintscaling 0
} else {
constraintscaling [expr 1 - 0.95*$step/$constraintsteps]
}
}
proc calcforces_endstep { } { }
''')
def _findFiles(self, inputdir):
# Tries to find default files if the given don't exist
defaults = {
'coordinates': ('structure.pdb', ),
'structure': ('structure.psf', 'structure.prmtop'),
'parameters': ('parameters', 'structure.prmtop')
}
for field in defaults:
userval = self.acemd.__dict__[field]
if userval is not None and not os.path.exists(
os.path.join(inputdir, userval)):
self.acemd.__dict__[field] = None
if self.acemd.__dict__[field] is None:
for val in defaults[field]:
if os.path.exists(os.path.join(inputdir, val)):
self.acemd.__dict__[field] = val
break
if userval is not None and self.acemd.__dict__[
field] is not None and self.acemd.__dict__[
field] != userval:
logger.warning(
'Could not locate structure file {}. Using {} instead.'.
format(os.path.join(inputdir, userval),
os.path.join(inputdir, self.acemd.__dict__[field])))
elif self.acemd.__dict__[field] is None:
raise RuntimeError(
'Could not locate any {f:} file in {i:}. '
'Please set the Equilibration.acemd.{f:} property to '
'point to the {f:} file'.format(f=field, i=inputdir))
if self.acemd.consref is None:
self.acemd.consref = self.acemd.coordinates
def _amberFixes(self):
# AMBER specific fixes
if self.acemd.parameters.endswith('structure.prmtop'):
self.acemd.parmfile = self.acemd.parameters
self.acemd.parameters = None
self.acemd.scaling14 = '0.8333333'
self.acemd.amber = 'on'
def write(self, inputdir, outputdir):
""" Write the equilibration protocol
Writes the equilibration protocol and files into a folder for execution
using files inside the inputdir directory
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a build process.
outputdir : str
Directory where to write the equilibration setup files.
Examples
--------
>>> md = Equilibration()
>>> md.write('./build','./equil')
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits,
'timesteps',
self.runtime,
timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning(
'Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.constraintsteps is None:
constrsteps = int(numsteps / 2)
else:
constrsteps = int(self.constraintsteps)
if isinstance(self.acemd.TCL, tuple):
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(
NUMSTEPS=numsteps,
KCONST=self.fb_k,
REFINDEX=' '.join(
map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(
map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)),
NVTSTEPS=self.nvtsteps,
CONSTRAINTSTEPS=constrsteps,
TEMPERATURE=self.temperature)
self.acemd.TCL = tcl[0] + tcl[1]
else:
logger.warning('{} default TCL was already formatted.'.format(
self.__class__.__name__))
if self.acemd.celldimension is None and self.acemd.extendedsystem is None:
coords = inmol.get('coords', sel='water')
if coords.size == 0: # It's a vacuum simulation
coords = inmol.get('coords', sel='all')
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
dim = dim + 12.
else:
dim = np.max(coords, axis=0) - np.min(coords, axis=0)
self.acemd.celldimension = '{} {} {}'.format(
dim[0], dim[1], dim[2])
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints by writing them to the consref file
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError(
'You have not defined any constraints for the Equilibration (constraints={}).'
)
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def addConstraint(self, atomselect, factor=1):
""" Convenience function for adding a new constraint to existing constraints.
Parameters
----------
atomselect : str
Atom selection of atoms we want to constrain
factor : float
The scaling factor of the constraints applied to the atoms
Example
-------
>>> eq.addConstraint('chain X', 0.3)
"""
self.constraints[atomselect] = factor
class Production(OldProtocolInterface):
''' Production protocol v5
Production protocol for globular and membrane proteins. You can optionally define a flatbottom potential box and
atom constraints for the production run.
Parameters
----------
runtime : float, default=0
Running time of the simulation.
timeunits : str, default='steps'
Units for runtime. Can be 'steps', 'ns' etc.
temperature : float, default=300
Temperature of the thermostat in Kelvin
fb_k : float, default=0
Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5
fb_reference : str, default='none'
Reference selection to use as dynamic center of the flatbottom box.
fb_selection : str, default='none'
Selection of atoms to apply the flatbottom potential
fb_box : list, default=[0, 0, 0, 0, 0, 0]
Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]
useconstantratio : bool, default=False
For membrane protein simulations set it to true so that the barostat does not modify the xy aspect ratio.
useconstraints : bool, default=False
Apply constraints to the production simulation, defined by the constraints parameter
constraints : dict, default={}
A dictionary of atomselections and values of the constraint to be applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.
adaptive : bool, default=False
Set to True if making production runs for adaptive sampling.
'''
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('runtime', 'float', 'Running time of the simulation.', 0, TYPE_FLOAT, RANGE_0POS)
self._cmdString('timeunits', 'str', 'Units for runtime. Can be \'steps\', \'ns\' etc.', 'steps')
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('fb_k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0,
TYPE_FLOAT, RANGE_ANY)
self._cmdString('fb_reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.',
'none')
self._cmdString('fb_selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('fb_box', 'list', 'Position of the flatbottom box in term of the reference center given as '
'[xmin, xmax, ymin, ymax, zmin, zmax]', [0, 0, 0, 0, 0, 0])
self._cmdBoolean('useconstantratio', 'bool', 'For membrane protein simulations set it to true so that the '
'barostat does not modify the xy aspect ratio.', False)
self._cmdList('useconstraints', 'bool', 'Apply constraints to the production simulation, defined by the '
'constraints parameter', False)
self._cmdDict('constraints', 'dict', 'A dictionary of atomselections and values of the constraint to be '
'applied (in kcal/mol/A^2). Atomselects must be mutually exclusive.', {})
self._cmdBoolean('adaptive', 'bool', 'Set to True if making production runs for adaptive sampling.', False)
self.acemd = Acemd()
#self.acemd.binindex='input.idx'
self.acemd.binindex = None
self.acemd.binvelocities = None
self.acemd.bincoordinates = 'output.coor'
self.acemd.extendedsystem='output.xsc'
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '$temperature'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '$temperature'
self.acemd.langevindamping = '0.1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '5000'
self.acemd.consref = None
self.acemd.run = '$numsteps'
self.acemd.TCL = ('''
set numsteps {NUMSTEPS}
set temperature {TEMPERATURE}
set fb_refindex {{ {REFINDEX} }}
set fb_selindex {{ {SELINDEX} }}
set fb_box {{ {BOX} }}
set fb_K {KCONST}
#
''',
'''
proc flatbot1d {x xm xM fb_K} {
set f 0
if {$x < $xm} {
set f [expr $fb_K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $fb_K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel fb_refindex fb_selindex
berendsenpressure off
set ref [addgroup $fb_refindex]
set sel [addgroup $fb_selindex]
}
proc calcforces {} {
global ref sel fb_K fb_box
loadcoords coords
##FLATBOTTOM
if {$fb_K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $fb_box 0] [lindex $fb_box 1] $fb_K]
set fy [flatbot1d [lindex $dr 1] [lindex $fb_box 2] [lindex $fb_box 3] $fb_K]
set fz [flatbot1d [lindex $dr 2] [lindex $fb_box 4] [lindex $fb_box 5] $fb_K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
}
proc calcforces_endstep { } { }
''')
def _findFiles(self, inputdir):
# Tries to find default files if the given don't exist
defaults = {'coordinates': ('structure.pdb',),
'structure': ('structure.psf', 'structure.prmtop'),
'parameters': ('parameters', 'structure.prmtop')}
for field in defaults:
userval = self.acemd.__dict__[field]
if userval is not None and not os.path.exists(os.path.join(inputdir, userval)):
raise RuntimeError('Could not locate file {} set by the user for argument '
'Production.acemd.{}'.format(os.path.join(inputdir, userval), field))
if self.acemd.__dict__[field] is None:
for val in defaults[field]:
if os.path.exists(os.path.join(inputdir, val)):
self.acemd.__dict__[field] = val
break
if userval is not None and self.acemd.__dict__[field] is not None and self.acemd.__dict__[field] != userval:
logger.warning('Could not locate structure file {}. Using {} instead.'.format(
os.path.join(inputdir, userval), os.path.join(inputdir, self.acemd.__dict__[field])
))
elif self.acemd.__dict__[field] is None:
raise RuntimeError('Could not locate any {f:} file in {i:}. '
'Please set the Production.acemd.{f:} property to '
'point to the {f:} file'.format(f=field, i=inputdir))
if self.useconstraints and self.acemd.consref is None:
self.acemd.consref = self.acemd.coordinates
def _amberFixes(self):
# AMBER specific fixes
if self.acemd.structure.endswith('.prmtop'):
self.acemd.parmfile = self.acemd.parameters
self.acemd.parameters = None
self.acemd.scaling14 = '0.8333333'
self.acemd.amber = 'on'
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
from htmd.units import convert
numsteps = convert(self.timeunits, 'timesteps', self.runtime, timestep=self.acemd.timestep)
pdbfile = os.path.join(inputdir, self.acemd.coordinates)
inmol = Molecule(pdbfile)
if np.any(inmol.atomselect('lipids')) and not self.useconstantratio:
logger.warning('Lipids detected in input structure. We highly recommend setting useconstantratio=True '
'for membrane simulations.')
if self.fb_k > 0: # use TCL only for flatbottom
self.acemd.tclforces = 'on'
tcl = list(self.acemd.TCL)
tcl[0] = tcl[0].format(NUMSTEPS=numsteps, TEMPERATURE=self.temperature, KCONST=self.fb_k,
REFINDEX=' '.join(map(str, inmol.get('index', self.fb_reference))),
SELINDEX=' '.join(map(str, inmol.get('index', self.fb_selection))),
BOX=' '.join(map(str, self.fb_box)))
self.acemd.TCL = tcl[0] + tcl[1]
else:
self.acemd.TCL = 'set numsteps {NUMSTEPS}\n' \
'set temperature {TEMPERATURE}\n'.format(NUMSTEPS=numsteps, TEMPERATURE=self.temperature)
if self.useconstraints:
# Turn on constraints
self.acemd.constraints = 'on'
self.acemd.constraintscaling = '1.0'
else:
if len(self.constraints) != 0:
logger.warning('You have setup constraints to {} but constraints are turned off. '
'If you want to use constraints, define useconstraints=True'.format(self.constraints))
if self.useconstantratio:
self.acemd.useconstantratio = 'on'
if self.adaptive:
self.acemd.binvelocities = None
self.acemd.setup(inputdir, outputdir, overwrite=True)
# Adding constraints by writing them to the consref file
if self.useconstraints:
inconsreffile = os.path.join(inputdir, self.acemd.consref)
consrefmol = Molecule(inconsreffile)
consrefmol.set('occupancy', 0)
consrefmol.set('beta', 0)
if len(self.constraints) == 0:
raise RuntimeError('You have set the production to use constraints (useconstraints=True), but have not '
'defined any constraints (constraints={}).')
else:
for sel in self.constraints:
consrefmol.set('beta', self.constraints[sel], sel)
outconsreffile = os.path.join(outputdir, self.acemd.consref)
consrefmol.write(outconsreffile)
def addConstraint(self, atomselect, factor=1):
""" Convenience function for adding a new constraint to existing constraints.
Parameters
----------
atomselect : str
Atom selection of atoms we want to constrain
factor : float
The scaling factor of the constraints applied to the atoms
Example
-------
>>> eq.addConstraint('chain X', 0.3)
"""
self.constraints[atomselect] = factor
class Production(ProtocolInterface):
''' Production protocol for globular and membrane proteins
It also includes a possible flatbottom potential box
Parameters
----------
numsteps : int, default=0
Number of steps to run the simulations in units of 4fs
temperature : float, default=300
Temperature of the thermostat in Kelvin
k : float, default=0
Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5
reference : str, default='none'
Reference selection to use as dynamic center of the flatbottom box.
selection : str, default='none'
Selection of atoms to apply the flatbottom potential
box : list, default=[0, 0, 0, 0, 0, 0]
Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]
'''
def __init__(self):
super().__init__()
self._cmdObject('acemd', ':class:`MDEngine <htmd.apps.app.App>` object', 'MD engine', None, Acemd)
self._cmdValue('numsteps', 'int', 'Number of steps to run the simulations in units of 4fs', 0, TYPE_INT, RANGE_0POS)
self._cmdValue('temperature', 'float', 'Temperature of the thermostat in Kelvin', 300, TYPE_FLOAT, RANGE_ANY)
self._cmdValue('k', 'float', 'Force constant of the flatbottom potential in kcal/mol/A^2. E.g. 5', 0, TYPE_FLOAT, RANGE_ANY)
self._cmdString('reference', 'str', 'Reference selection to use as dynamic center of the flatbottom box.', 'none')
self._cmdString('selection', 'str', 'Selection of atoms to apply the flatbottom potential', 'none')
self._cmdList('box', 'list', 'Position of the flatbottom box in term of the reference center given as [xmin, xmax, ymin, ymax, zmin, zmax]', [0,0,0,0,0,0])
self.acemd = Acemd()
#self.acemd.binindex='input.idx'
self.acemd.extendedsystem='input.xsc'
self.acemd.coordinates = None
self.acemd.structure = None
self.acemd.parameters = None
self.acemd.temperature = '300'
self.acemd.restart = 'on'
self.acemd.restartfreq = '5000'
self.acemd.outputname = 'output'
self.acemd.xtcfile = 'output.xtc'
self.acemd.xtcfreq = '25000'
self.acemd.timestep = '4'
self.acemd.rigidbonds = 'all'
self.acemd.hydrogenscale = '4'
self.acemd.switching = 'on'
self.acemd.switchdist = '7.5'
self.acemd.cutoff = '9'
self.acemd.exclude = 'scaled1-4'
self.acemd.scaling14 = '1.0'
self.acemd.langevin = 'on'
self.acemd.langevintemp = '300'
self.acemd.langevindamping = '0.1'
self.acemd.pme = 'on'
self.acemd.pmegridspacing = '1.0'
self.acemd.fullelectfrequency = '2'
self.acemd.energyfreq = '5000'
self.acemd.run = '$numsteps'
self._TCL='''
set numsteps NUMSTEPS
set refindex { REFINDEX }
set selindex { SELINDEX }
set box { BOX }
set K KCONST
#
proc flatbot1d {x xm xM K} {
set f 0
if {$x < $xm} {
set f [expr $K*[expr $xm-$x]]
}
if {$x > $xM} {
set f [expr $K*[expr $xM-$x]]
}
return $f
}
proc calcforces_init {} {
global ref sel refindex selindex
berendsenpressure off
set ref [addgroup $refindex]
set sel [addgroup $selindex]
}
proc calcforces {} {
global ref sel K box
loadcoords coords
##FLATBOTTOM
if {$K>0} {
set r0 $coords($ref)
set r1 $coords($sel)
set dr [vecsub $r1 $r0]
set fx [flatbot1d [lindex $dr 0] [lindex $box 0] [lindex $box 1] $K]
set fy [flatbot1d [lindex $dr 1] [lindex $box 2] [lindex $box 3] $K]
set fz [flatbot1d [lindex $dr 2] [lindex $box 4] [lindex $box 5] $K]
#print "dr: $dr fx: $fx fy: $fy fz: $fz"
addforce $sel [list $fx $fy $fz]
}
}
proc calcforces_endstep { } { }
proc calcforces_terminate { } { }
'''
def _findFiles(self, inputdir):
# Tries to find default files if the given don't exist
defaults = {'coordinates': ('structure.pdb',),
'structure': ('structure.psf', 'structure.prmtop'),
'parameters': ('parameters', 'structure.prmtop')}
for field in defaults:
userval = self.acemd.__dict__[field]
if userval is not None and not os.path.exists(os.path.join(inputdir, userval)):
self.acemd.__dict__[field] = None
if self.acemd.__dict__[field] is None:
for val in defaults[field]:
if os.path.exists(os.path.join(inputdir, val)):
self.acemd.__dict__[field] = val
break
if userval is not None and self.acemd.__dict__[field] is not None and self.acemd.__dict__[field] != userval:
logger.warning('Could not locate structure file {}. Using {} instead.'.format(
os.path.join(inputdir, userval), os.path.join(inputdir, self.acemd.__dict__[field])
))
elif self.acemd.__dict__[field] is None:
raise RuntimeError('Could not locate any {f:} file in {i:}. '
'Please set the Equilibration.acemd.{f:} property to '
'point to the {f:} file'.format(f=field, i=inputdir))
def _amberFixes(self):
# AMBER specific fixes
if self.acemd.parameters.endswith('structure.prmtop'):
self.acemd.parmfile = self.acemd.parameters
self.acemd.parameters = None
self.acemd.scaling14 = '0.8333333'
self.acemd.amber = 'on'
def write(self, inputdir, outputdir):
""" Writes the production protocol and files into a folder.
Parameters
----------
inputdir : str
Path to a directory containing the files produced by a equilibration process.
outputdir : str
Directory where to write the production setup files.
"""
self._findFiles(inputdir)
self._amberFixes()
self.acemd.temperature = str(self.temperature)
self.acemd.langevintemp = str(self.temperature)
if self.k > 0: #use TCL only for flatbottom
mol = Molecule(os.path.join(inputdir, self.acemd.coordinates))
self.acemd.tclforces = 'on'
TCL = self._TCL
TCL = TCL.replace('NUMSTEPS', str(self.numsteps))
TCL = TCL.replace('KCONST', str(self.k))
TCL = TCL.replace('REFINDEX', ' '.join(map(str, mol.get('index', self.reference))))
TCL = TCL.replace('SELINDEX', ' '.join(map(str, mol.get('index', self.selection))))
TCL = TCL.replace('BOX', ' '.join(map(str, self.box)))
self.acemd.TCL = TCL
else:
self.acemd.TCL = 'set numsteps {}\n'.format(self.numsteps)
self.acemd.setup(inputdir, outputdir, overwrite=True)
