Esempio n. 1
0
 def __init__(self, atoms=None, label=None, top=None, crd=None,
              mm_options=None, qm_options=None, permutation=None, **kwargs):
     if not have_sander:
         raise RuntimeError("sander Python module could not be imported!")
     Calculator.__init__(self, label, atoms)
     self.permutation = permutation
     if qm_options is not None:
         sander.setup(top, crd.coordinates, crd.box, mm_options, qm_options)
     else:
         sander.setup(top, crd.coordinates, crd.box, mm_options)
Esempio n. 2
0
 def __init__(self, atoms=None, label=None, top=None, crd=None,
              mm_options=None, qm_options=None, permutation=None, **kwargs):
     if not have_sander:
         raise RuntimeError("sander Python module could not be imported!")
     Calculator.__init__(self, label, atoms)
     self.permutation = permutation
     if qm_options is not None:
         sander.setup(top, crd.coordinates, crd.box, mm_options, qm_options)
     else:
         sander.setup(top, crd.coordinates, crd.box, mm_options)
Esempio n. 3
0
def minimize(parm, igb, saltcon, cutoff, tol, maxcyc):
    """ Minimizes a snapshot. Use the existing System if it exists """
    if not HAS_SANDER:
        raise SimulationError('Could not import sander')
    if not HAS_SCIPY:
        raise SimulationError('Could not import scipy')

    if parm.box is None:
        if not igb in (0, 1, 2, 5, 6, 7, 8):
            raise SimulationError('Bad igb value. Must be 0, 1, 2, 5, '
                                  '6, 7, or 8')
        if cutoff is None: cutoff = 999.0
        inp = sander.gas_input(igb)
        inp.saltcon = saltcon
        inp.cut = cutoff
    else:
        if cutoff is None: cutoff = 8.0
        inp = sander.pme_input()
        inp.cut = cutoff

    # Define the objective function to minimize
    def energy_function(xyz):
        sander.set_positions(xyz)
        e, f = sander.energy_forces()
        return e.tot, -np.array(f)
    with sander.setup(parm, parm.coordinates, parm.box, inp):
        options = dict(maxiter=maxcyc, disp=True, gtol=tol)
        results = optimize.minimize(energy_function, parm.coordinates,
                                    method='L-BFGS-B', jac=True,
                                    options=options)
        parm.coordinates = results.x
    if not results.success:
        print('Problem minimizing structure with scipy and sander:',
              file=sys.stderr)
        print('\t' + results.message)
Esempio n. 4
0
def get_total_energy(agls):
    # get the coor from pyrosetta
    inp_coor=generate_coord(agls)
    # initialize the object topology with coordinates
    parm=AmberParm("tpp-1.prmtop",inp_coor)
    # set up the input options
    inp=sander.gas_input() 
    sander.setup (parm, parm.coordinates, None, inp)

    # compute the energy and force
    eney, frc=sander.energy_forces()
    # print('sander',eney.tot,eney.gb,eney.vdw, eney.elec, eney.dihedral,eney.angle, eney.bond)

    # clean and finish
    sander.cleanup()
    return eney.tot
Esempio n. 5
0
def minimize(parm, igb, saltcon, cutoff, tol, maxcyc, disp=True, callback=None):
    """ Minimizes a snapshot. Use the existing System if it exists """
    if not HAS_SANDER:
        raise SimulationError('Could not import sander')
    if not HAS_SCIPY:
        raise SimulationError('Could not import scipy')

    if parm.box is None:
        if not igb in {0, 1, 2, 5, 6, 7, 8}:
            raise SimulationError('Bad igb value. Must be 0, 1, 2, 5, 6, 7, or 8')
        if cutoff is None: cutoff = 999.0
        inp = sander.gas_input(igb)
        inp.saltcon = saltcon
        inp.cut = cutoff
    else:
        if cutoff is None: cutoff = 8.0
        inp = sander.pme_input()
        inp.cut = cutoff

    # Define the objective function to minimize
    def energy_function(xyz):
        sander.set_positions(xyz)
        e, f = sander.energy_forces()
        return e.tot, -np.array(f)
    with sander.setup(parm, parm.coordinates, parm.box, inp):
        options = dict(maxiter=maxcyc, disp=disp, gtol=tol)
        more_options = dict()
        if callable(callback):
            more_options['callback'] = callback
        results = optimize.minimize(energy_function, parm.coordinates, method='L-BFGS-B', jac=True,
                                    options=options, **more_options)
        parm.coordinates = results.x
    if not results.success:
        LOGGER.error(f'Problem minimizing structure with scipy and sander: {results.message}')
    def test_update_dihedral_parm(self):
        traj = pt.iterload("./data/Tc5b.crd", fn('Tc5b.top'))
        p = pmd.load_file(traj.top.filename)
        inp = sander.gas_input(8)
        coords = traj[0].xyz

        with pt.utils.context.tempfolder():
            for k in range(20, 100):
                p.bonds[3].type.k = k
                p.remake_parm()
                with sander.setup(p, coords, None, inp):
                    ene, frc = sander.energy_forces()
Esempio n. 7
0
    def test_update_dihedral_parm(self):
        traj = pt.iterload("./data/Tc5b.crd", "./data/Tc5b.top")
        p = pmd.load_file(traj.top.filename)
        inp = sander.gas_input(8)
        coords = traj[0].xyz

        fname = "tmp.parm7"

        with pt.utils.context.tempfolder():
            for k in range(20, 100):
                p.bonds[3].type.k = k
                p.remake_parm()
                with sander.setup(p, coords, None, inp):
                    ene, frc = sander.energy_forces()
Esempio n. 8
0
   def sanderforce(self,parmstr,atmlst,boxflag=False,pmeflag=False):
      """Calculates energy and forces for a provided
         Amber parm string and set of coordinates using the Sander
         API. Also takes box dimensions and a flag for use of PME.
         Currently uses standard simulation options for gas phase or pme
         based on pmeflag.
         Only returns forces on first 2 atoms in atmlst
         Returns a sander energy object and a 3 x 2 x traj length array
         of forces with units"""

      self.forces=[]
      self.energies=[]
#      sander.APPLY_UNITS = True # More bugs/inconsistencies in pysander in amber15, may be fixed later
      indices = [a.idx for a in atmlst[:2]]
      if pmeflag is True:
#        These default options will be suitable in most cases
#        PME,cut=8.0,ntb=1,ntf=1,ntc=1
#        Should be adapted if shake is required (not important here for ele)
         inp = sander.pme_input()
      else:
         inp = sander.gas_input()
      for i in range(0,self.traj.frame):
         coord = self.traj.coordinates[i]
         if boxflag is True:
            box = self.traj.box[i]
#           print box
         else:
            box = None
         with sander.setup(parmstr,coord,box=box,mm_options=inp): #Pass a string, else a temp parmfile is created that fills up tmp directory!
            ene,frc = sander.energy_forces(as_numpy=False) # pysander __init__ bug/inconsistency, can't use as_numpy!
         frc = np.asarray(frc)
         frc = np.reshape(frc,((len(frc)/3.),3))
         frcslice = frc[indices]
         # Add units for forces: kcal mol-1 A-1
         frcslice = frcslice * u.kilocalorie / (u.mole * u.angstroms)
         self.forces.append(frcslice)
         self.energies.append(ene)
Esempio n. 9
0
def test_eneregy_and_force():
    path = os.path.dirname(__file__) 
    
    prmtop = path + '/vAla3.prmtop'
    rst7 = path + '/vAla3.rst7'
    
    with mdgx.setup(prmtop, rst7) as context:
        mdgx_energies, mdgx_forces = context.energy_forces()
        
    pme_input = sander.pme_input()
    parm = pmd.load_file(prmtop, rst7)

    with sander.setup(prmtop, rst7, box=parm.box, mm_options=pme_input):
        
        ene, sander_forces = sander.energy_forces()
        sander_enegies = dict((att, getattr(ene, att)) for att in dir(ene) if not
            att.startswith('_'))
        
    print("")
    print("potential energy")
    print("sander_enegies")
    print(sander_enegies['tot'])
    print("mdgx_energies")
    print(mdgx_energies['eptot'])
    
    print("")
    print('forces')
    print('sander_forces, first 5 atoms')
    print(sander_forces[:15])
    print("")
    print('mdgx_forces, first 5 atoms')
    print(mdgx_forces.tolist()[:15])

    aa_eq([sander_enegies['tot'],],
          [mdgx_energies['eptot'],],
          decimal=4)
Esempio n. 10
0
def energy(parm, args, output=sys.stdout):
    """
    Compute a single-point energy using sander and print the result to the
    desired output
    """
    global HAS_SANDER
    if not HAS_SANDER:
        raise SimulationError('Could not import sander')

    cutoff = args.get_key_float('cutoff', None)
    igb = args.get_key_int('igb', 5)
    saltcon = args.get_key_float('saltcon', 0.0)
    do_ewald = args.has_key('Ewald')
    vdw_longrange = not args.has_key('nodisper')
    has_1264 = 'LENNARD_JONES_CCOEF' in parm.parm_data

    # Get any unmarked arguments
    unmarked_cmds = args.unmarked()
    if len(unmarked_cmds) > 0:
        warnings.warn("Un-handled arguments: " + ' '.join(unmarked_cmds),
                      UnhandledArgumentWarning)

    if parm.ptr('ifbox') == 0:
        if not igb in (0, 1, 2, 5, 6, 7, 8):
            raise SimulationError('Bad igb value. Must be 0, 1, 2, 5, '
                                  '6, 7, or 8')
        # Force vacuum electrostatics down the GB code path
        if igb == 0:
            igb = 6
        inp = sander.gas_input(igb)
        if cutoff is None:
            cutoff = 1000.0
        if cutoff <= 0:
            raise SimulationError('cutoff must be > 0')
        inp.cut = cutoff
        if saltcon < 0:
            raise SimulationError('salt concentration must be >= 0')
        inp.saltcon = saltcon
    elif parm.ptr('ifbox') > 0:
        inp = sander.pme_input()
        if cutoff is None:
            cutoff = 8.0
        elif cutoff <= 0:
            raise SimulationError('cutoff must be > 0')
        inp.cut = cutoff
        inp.ew_type = int(do_ewald)
        inp.vdwmeth = int(vdw_longrange)
        inp.lj1264 = int(has_1264)

    if parm.coordinates is None:
        raise SimulationError('No coordinates are loaded')
    # Time to set up sander
    with sander.setup(parm, parm.coordinates, parm.box, inp):
        e, f = sander.energy_forces()

    if parm.chamber:
        output.write('Bond          = %20.7f     Angle         = %20.7f\n'
                     'Dihedral      = %20.7f     Urey-Bradley  = %20.7f\n'
                     'Improper      = %20.7f     ' % (e.bond, e.angle,
                     e.dihedral, e.angle_ub, e.imp))
        if parm.has_cmap:
            output.write('CMAP         = %20.7f\n' % e.cmap)
        output.write('1-4 vdW       = %20.7f     1-4 Elec.     = %20.7f\n'
                     'Lennard-Jones = %20.7f     Electrostatic = %20.7f\n'
                     'TOTAL         = %20.7f\n' % (e.vdw_14, e.elec_14,
                     e.vdw, e.elec, e.tot))
    else:
        output.write('Bond     = %20.7f     Angle    = %20.7f\n'
                     'Dihedral = %20.7f     1-4 vdW  = %20.7f\n'
                     '1-4 Elec = %20.7f     vdWaals  = %20.7f\n'
                     'Elec.    = %20.7f' % (e.bond, e.angle, e.dihedral,
                      e.vdw_14, e.elec_14, e.vdw, e.elec))
        if igb != 0 and inp.ntb == 0:
            output.write('     Egb      = %20.7f' % e.gb)
        elif e.hbond != 0:
            output.write('     EHbond   = %20.7f' % e.hbond)
        output.write('\nTOTAL    = %20.7f\n' % e.tot)
Esempio n. 11
0
import sander
from parmed.amber.readparm import AmberParm, Rst7
import numpy as np
import os, sys
import pickle


base = '1nie'
# parm = AmberParm('4amber_%s.prmtop' %base)  #topo
rst = Rst7.open('4amber_%s.rst7' %base)     #box
coords1 = rst.coordinates
coords2 = np.around( np.array(pickle.load(open('tmp2','rb') ) ), 3) #2nd coordinate set
print coords1, coords1.shape
print coords2, coords2.shape

sander.setup('4amber_%s.prmtop' %base, rst.coordinates, rst.box, sander.pme_input())
ene, frc = sander.energy_forces()
print frc[0]

sander.set_positions(coords1)
ene, frc = sander.energy_forces()
print frc[0]

sander.set_positions(coords2)
ene, frc = sander.energy_forces()
print frc[0]
print max(frc)
print ene.tot, ene.elec, ene.vdw
# import code; code.interact(local=dict(globals(), **locals()))
import boost.python
Esempio n. 12
0
import sander
from parmed.amber.readparm import AmberParm, Rst7
import numpy as np
import os, sys
import pickle

base = '1nie'
# parm = AmberParm('4amber_%s.prmtop' %base)  #topo
rst = Rst7.open('4amber_%s.rst7' % base)  #box
coords1 = rst.coordinates
coords2 = np.around(np.array(pickle.load(open('tmp2', 'rb'))),
                    3)  #2nd coordinate set
print coords1, coords1.shape
print coords2, coords2.shape

sander.setup('4amber_%s.prmtop' % base, rst.coordinates, rst.box,
             sander.pme_input())
ene, frc = sander.energy_forces()
print frc[0]

sander.set_positions(coords1)
ene, frc = sander.energy_forces()
print frc[0]

sander.set_positions(coords2)
ene, frc = sander.energy_forces()
print frc[0]
print max(frc)
print ene.tot, ene.elec, ene.vdw
# import code; code.interact(local=dict(globals(), **locals()))
import boost.python
Esempio n. 13
0
#! /usr/bin/env python

import sander
from chemistry.amber.readparm import AmberParm, Rst7
import numpy as np

pdb = '3stl'
parm = AmberParm('4amber_%s.prmtop' % pdb)  #topo
rst = Rst7.open('4amber_%s.rst7' % pdb)  #box
sander.setup(parm, rst.coordinates, rst.box, sander.pme_input())
ene, frc = sander.energy_forces()
print ene.tot
print max(frc)

import code
code.interact(local=dict(globals(), **locals()))
sander.cleanup()
Esempio n. 14
0
def energy(parm, args, output=sys.stdout):
    """
    Compute a single-point energy using sander and print the result to the
    desired output

    Parameters
    ----------
    parm : Structure
    args : ArgumentList
    output : file handler, default sys.stdout
    """
    global HAS_SANDER
    if not HAS_SANDER:
        raise SimulationError('Could not import sander')

    cutoff = args.get_key_float('cutoff', None)
    igb = args.get_key_int('igb', 5)
    saltcon = args.get_key_float('saltcon', 0.0)
    do_ewald = args.has_key('Ewald')
    vdw_longrange = not args.has_key('nodisper')
    has_1264 = 'LENNARD_JONES_CCOEF' in parm.parm_data

    # Get any unmarked arguments
    unmarked_cmds = args.unmarked()
    if len(unmarked_cmds) > 0:
        warnings.warn("Un-handled arguments: " + ' '.join(unmarked_cmds),
                      UnhandledArgumentWarning)

    if parm.ptr('ifbox') == 0:
        if not igb in (0, 1, 2, 5, 6, 7, 8):
            raise SimulationError('Bad igb value. Must be 0, 1, 2, 5, '
                                  '6, 7, or 8')
        # Force vacuum electrostatics down the GB code path
        if igb == 0:
            igb = 6
        inp = sander.gas_input(igb)
        if cutoff is None:
            cutoff = 1000.0
        if cutoff <= 0:
            raise SimulationError('cutoff must be > 0')
        inp.cut = cutoff
        if saltcon < 0:
            raise SimulationError('salt concentration must be >= 0')
        inp.saltcon = saltcon
    elif parm.ptr('ifbox') > 0:
        inp = sander.pme_input()
        if cutoff is None:
            cutoff = 8.0
        elif cutoff <= 0:
            raise SimulationError('cutoff must be > 0')
        inp.cut = cutoff
        inp.ew_type = int(do_ewald)
        inp.vdwmeth = int(vdw_longrange)
        inp.lj1264 = int(has_1264)

    if parm.coordinates is None:
        raise SimulationError('No coordinates are loaded')
    # Time to set up sander
    with sander.setup(parm, parm.coordinates, parm.box, inp):
        e, f = sander.energy_forces()

    if parm.chamber:
        output.write('Bond          = %20.7f     Angle         = %20.7f\n'
                     'Dihedral      = %20.7f     Urey-Bradley  = %20.7f\n'
                     'Improper      = %20.7f     ' %
                     (e.bond, e.angle, e.dihedral, e.angle_ub, e.imp))
        if parm.has_cmap:
            output.write('CMAP         = %20.7f\n' % e.cmap)
        output.write('1-4 vdW       = %20.7f     1-4 Elec.     = %20.7f\n'
                     'Lennard-Jones = %20.7f     Electrostatic = %20.7f\n'
                     'TOTAL         = %20.7f\n' %
                     (e.vdw_14, e.elec_14, e.vdw, e.elec, e.tot))
    else:
        output.write(
            'Bond     = %20.7f     Angle    = %20.7f\n'
            'Dihedral = %20.7f     1-4 vdW  = %20.7f\n'
            '1-4 Elec = %20.7f     vdWaals  = %20.7f\n'
            'Elec.    = %20.7f' %
            (e.bond, e.angle, e.dihedral, e.vdw_14, e.elec_14, e.vdw, e.elec))
        if igb != 0 and inp.ntb == 0:
            output.write('     Egb      = %20.7f' % e.gb)
        elif e.hbond != 0:
            output.write('     EHbond   = %20.7f' % e.hbond)
        output.write('\nTOTAL    = %20.7f\n' % e.tot)
Esempio n. 15
0
                   help='''Cutoff for nonbonded forces in Angstroms. Cutoff is
                   always infinite for non-periodic systems''')
group.add_argument('--platform', dest='platform', default='Reference',
                   help='OpenMM platform to use. Default is %(default)s')

args = parser.parse_args()

# Get the Amber forces and energies
if args.pbc:
    inp = sander.pme_input()
    inp.cut = args.cutoff
else:
    inp = sander.gas_input(args.igb)
    inp.cut = 1000

with sander.setup(args.prmtop, args.inpcrd, None, inp) as context:
    e, f = sander.energy_forces()
    f = np.array(f).reshape((context.natom, 3))

# Get the OpenMM forces and energies
parm = app.AmberPrmtopFile(args.prmtop)
inpcrd = app.AmberInpcrdFile(args.inpcrd)

gbmap = collections.defaultdict(lambda: None)
gbmap[1] = app.HCT
gbmap[2] = app.OBC1
gbmap[5] = app.OBC2
gbmap[7] = app.GBn
gbmap[8] = app.GBn2

if args.pbc:
Esempio n. 16
0
# require, parmed, pysander, pytraj

# Aim: change "k" for bond and re-evaluate new energy

import pytraj as pt
import parmed as pmd
import sander

traj = pt.iterload("./data/Tc5b.crd", "./data/Tc5b.top")
p = pmd.load_file(traj.top.filename)
inp = sander.gas_input(8)
coords = traj[0].coords

fname = "tmp.parm7"

with pt.utils.context.goto_temp_folder():
    for k in range(20, 100):
        p.bonds[3].type.k = k
        p.remake_parm()
        with sander.setup(p, coords, None, inp):
            ene, frc = sander.energy_forces()
            print (ene.bond, ene.dihedral)
Esempio n. 17
0
    if v:
        gmx_out[v] = gmx_out[k]

for ii in vv:
    print(f"{ii:<10}: {error(gmx_out[ii],amb_out[ii]):-2.5f}%")

# DIHED = PROPER_DIH + IMPROPER_DIH + RYCKAERT-BELL.
# VDW14 : LJ-14, 1-4_NB
# VDW   : LJ_SR, VDWAALS
# QQ14  : COULOMB-14, 1-4_EEL
# QQ    : COULOMB_SR, EELEC

# Using gas-phase calculations
inp = sander.gas_input()
f_amb = e_amb.split(".")[0]
sander.setup(f"{f_amb}.prmtop", f"{f_amb}.inpcrd", box=None, mm_options=inp)
e, f = sander.energy_forces()

ll = [
    ("angle", "ANGLE"),
    ("bond", "BOND"),
    ("dihedral", "DIHED"),
    ("vdw_14", "VDW14"),
    ("vdw", "VDW"),
    ("elec_14", "QQ14"),
    ("elec", "QQ"),
    ("tot", "EPTOT"),
]

for pp in ll:
    v1, v2 = e.__getattribute__(pp[0]), amb_out[pp[1]] / ff
#! /usr/bin/env python

import sander
from chemistry.amber.readparm import AmberParm, Rst7
import numpy as np

pdb ='3stl'
parm = AmberParm('4amber_%s.prmtop' %pdb)  #topo
rst = Rst7.open('4amber_%s.rst7' %pdb)     #box
sander.setup(parm, rst.coordinates, rst.box, sander.pme_input())
ene, frc = sander.energy_forces()
print ene.tot
print max(frc)

import code; code.interact(local=dict(globals(), **locals()))
sander.cleanup()

def exercise(args, mean_positive_scale=1):
  processed_args = mmtbx.utils.process_command_line_args(
    args=args, log=null_out())
  use_amber=False
  for arg in args:
    if arg.split('=')[0] == 'use_amber':
      use_amber=arg.split('=')[1]
    if arg.split('=')[0] == 'prmtop':
      prmtop = arg.split('=')[1]
    if arg.split('=')[0] == 'rst7':
      rst7 = arg.split('=')[1]
  mon_lib_srv = monomer_library.server.server()
  ener_lib = monomer_library.server.ener_lib()
  processed_pdb_file = monomer_library.pdb_interpretation.process(
    mon_lib_srv    = mon_lib_srv,
    ener_lib       = ener_lib,
    file_name      = processed_args.pdb_file_names[0],
    raw_records    = None,
    force_symmetry = True)
  geometry = processed_pdb_file.geometry_restraints_manager(
    show_energies = False, plain_pairs_radius = 5.0)
  if use_amber != 'True':
    print "USING EH"
    restraints_manager = mmtbx.restraints.manager(
      geometry = geometry, normalization = True)
  else:
    print "USING AMBER"
    import amber_adaptbx
    import sander
    amber_structs = amber_adaptbx.sander_structs(
              parm_file_name=prmtop,
              rst_file_name=rst7)
    sander.setup(amber_structs.parm,
                   amber_structs.rst.coords,
                   amber_structs.rst.box,
                   amber_structs.inp)
    restraints_manager = mmtbx.restraints.manager(
        geometry      = geometry,
        normalization = True,
        use_amber     = use_amber,
        amber_structs = amber_structs)
  xray_structure = processed_pdb_file.xray_structure()
  xray_structure.scattering_type_registry(table = "wk1995") # is it is X-ray!
  refinement_flags = mmtbx.refinement.refinement_flags.manager(
    individual_sites = True,
    sites_individual = flex.bool(xray_structure.scatterers().size(), True))
  model = mmtbx.model.manager(
    restraints_manager = restraints_manager,
    xray_structure     = xray_structure,
    refinement_flags   = refinement_flags,
    pdb_hierarchy      = processed_pdb_file.all_chain_proxies.pdb_hierarchy)
  fmodel = get_fmodel(hkl_file=processed_args.reflection_files, 
    xrs=xray_structure)
  fmodels = mmtbx.fmodels(fmodel_xray = fmodel)
  result = weight_xray_chem.weight(
    fmodels               = fmodels,
    model                 = model,
    target_weights_params = weight_xray_chem.master_params.extract(),
    macro_cycle           = 0)
  print dir(result)
  w = result.xyz_weights_result
  print dir(w)
  print w.wx, w.w
Esempio n. 20
0
import numpy as np
import pytraj as pt
import sander

traj = pt.datafiles.load_tz2()

inp = sander.gas_input(8)

frcs = []

with sander.setup(traj.top.filename, traj[0].xyz, traj.top.box, inp):
    for frame in traj:
        sander.set_box(*frame.box.tolist())
        sander.set_positions(frame.xyz)
        ene, frc = sander.energy_forces()
        frcs.append(np.array(frc).reshape(traj.n_atoms, 3))


def get_frame_with_force(traj, forces=frcs):
    frame0 = pt.Frame()
    crdinfo = dict(has_force=True)

    frame0._allocate_force_and_velocity(traj.top, crdinfo)

    for frame, frc in zip(traj, frcs):
        frame0.xyz[:] = frame.xyz
        frame0.force[:] = frc
        yield frame0


pt.write_traj('traj.nc',
Esempio n. 21
0
def energy_decomposition(traj=None,
                         prmtop=None,
                         igb=8,
                         mm_options=None,
                         qm_options=None,
                         mode=None,
                         dtype='dict',
                         frame_indices=None,
                         top=None):
    """energy decomposition by calling `libsander`

    Parameters
    ----------
    traj : Trajectory-like or iterables that produce Frame
        if `traj` does not hold Topology information, `top` must be provided
    prmtop : str or Structure from ParmEd, default=None, optional
        To avoid any unexpected error, you should always provide original topology
        filename. If prmtop is None, pytraj will load Topology from traj.top.filename.

        - why do you need to load additional topology filename? Because cpptraj and sander
          use different Topology object, can not convert from one to another.
    igb : GB model, default=8 (GB-Neck2)
        If specify `mm_options`, this `igb` input will be ignored
    mm_options : InputOptions from `sander`, default=None, optional
        if `mm_options` is None, use `gas_input` with given igb.
        If `mm_options` is not None, use this
    qm_options : InputOptions from `sander` for QMMM, optional
    mode : str, default=None, optional
        if mode='minimal', get only 'bond', 'angle', 'dihedral' and 'total' energies
    top : pytraj.Topology or str, default=None, optional
        only need to specify this ``top`` if ``traj`` does not hold Topology
    dtype : str, {'dict', 'dataset', 'ndarray', 'dataframe'}, default='dict'
        return data type
    frame_indices : None or 1D array-like, default None
        if not None, only perform calculation for given frames

    Returns
    -------
    Dict of energies (to be used with DataFrame) or DatasetList

    Examples
    --------
    Examples are adapted from $AMBERHOME/test/sanderapi

    >>> import pytraj as pt
    >>> # GB energy
    >>> traj = pt.datafiles.load_ala3()
    >>> traj.n_frames
    1
    >>> data = pt.energy_decomposition(traj, igb=8)
    >>> data['gb']
    array([-92.88577683])
    >>> data['bond']
    array([ 5.59350521])

    >>> # PME
    >>> import os
    >>> from pytraj.testing import amberhome
    >>> import sander
    >>> topfile = os.path.join(amberhome, "test/4096wat/prmtop")
    >>> rstfile = os.path.join(amberhome, "test/4096wat/eq1.x")
    >>> traj = pt.iterload(rstfile, topfile)
    >>> options = sander.pme_input()
    >>> options.cut = 8.0
    >>> edict = pt.energy_decomposition(traj=traj, mm_options=options)
    >>> edict['vdw']
    array([ 6028.95167558])

    >>> # GB + QMMM
    >>> topfile = os.path.join(amberhome, "test/qmmm2/lysine_PM3_qmgb2/prmtop")
    >>> rstfile = os.path.join(amberhome, "test/qmmm2/lysine_PM3_qmgb2/lysine.crd")
    >>> traj = pt.iterload(rstfile, topfile)

    >>> options = sander.gas_input(8)
    >>> options.cut = 99.0
    >>> options.ifqnt = 1
    >>> qm_options = sander.qm_input()
    >>> qm_options.iqmatoms[:3] = [8, 9, 10]
    >>> qm_options.qm_theory = "PM3"
    >>> qm_options.qmcharge = 0
    >>> qm_options.qmgb = 2
    >>> qm_options.adjust_q = 0

    >>> edict = pt.energy_decomposition(traj=traj, mm_options=options, qm_options=qm_options)
    >>> edict['bond']
    array([ 0.00160733])
    >>> edict['scf']
    array([-11.92177575])

    Notes
    -----
    This method does not work with `pytraj.pmap` when you specify mm_options and
    qm_options. Use `pytraj.pmap_mpi` with MPI instead.

    Work with ``pytraj.pmap``::

        pt.pmap(pt.energy_decomposition, traj, igb=8, dtype='dict')

    Will NOT work with ``pytraj.pmap``::

        import sander
        inp = sander.gas_input(8)
        pt.pmap(pt.energy_decomposition, traj, mm_options=inp, dtype='dict')

    Why? Because Python need to pickle each object to send to different cores and Python
    does not know how to pickle mm_options from sander.gas_input(8).

    This works with ``pytraj.pmap_mpi`` because pytraj explicitly create ``mm_options``
    in each core without pickling.
    """
    from collections import defaultdict, OrderedDict
    from pytraj.misc import get_atts
    import numpy as np

    try:
        import sander
    except ImportError:
        raise ImportError("need both `pysander` installed. Check Ambertools15")

    ddict = defaultdict(_default_func)

    if mm_options is None:
        inp = sander.gas_input(igb)
    elif igb is not None:
        inp = mm_options

    if isinstance(inp, string_types):
        # dangerous
        local_dict = {'sander': sander}
        exec(inp.lstrip(), local_dict)
        inp = local_dict['mm_options']

    if isinstance(qm_options, string_types):
        # dangerous
        local_dict = {'sander': sander}
        exec(qm_options.lstrip(), local_dict)
        qm_options = local_dict['qm_options']

    if prmtop is None:
        try:
            # try to load from file by taking top.filename
            prmtop_ = top.filename
        except AttributeError:
            raise ValueError("prmtop must be AmberParm object in ParmEd")
    else:
        # Structure, string
        prmtop_ = prmtop

    if not hasattr(prmtop_, 'coordinates') or prmtop_.coordinates is None:
        try:
            # if `traj` is Trajectory-like (not frame_iter), try to take 1st
            # coords
            coords = traj[0].xyz
        except (TypeError, AttributeError):
            # create fake list
            coords = [0. for _ in range(top.n_atoms * 3)]
    else:
        # use default coords in `AmberParm`
        coords = prmtop_.coordinates

    if top.has_box():
        box = top.box.tolist()
        has_box = True
    else:
        box = None
        has_box = False

    with sander.setup(prmtop_, coords, box, inp, qm_options):
        for frame in iterframe_master(traj):
            if has_box:
                sander.set_box(*frame.box.tolist())
            sander.set_positions(frame.xyz)
            ene, frc = sander.energy_forces()

            # potentially slow
            ene_atts = get_atts(ene)
            for att in ene_atts:
                ddict[att].append(getattr(ene, att))

    new_dict = None
    if mode == 'minimal':
        new_dict = {}
        for key in ['bond', 'angle', 'dihedral', 'tot']:
            new_dict[key] = ddict[key]
    else:
        new_dict = ddict

    for key in new_dict.keys():
        new_dict[key] = np.asarray(new_dict[key])

    if dtype == 'dict':
        return OrderedDict(new_dict)
    else:
        from pytraj.datasets.c_datasetlist import DatasetList

        dslist = DatasetList()
        size = new_dict['tot'].__len__()
        for key in new_dict.keys():
            dslist.add('double')
            dslist[-1].key = key
            dslist[-1].resize(size)
            dslist[-1].data[:] = new_dict[key]
        return get_data_from_dtype(dslist, dtype)
Esempio n. 22
0
                   default='Reference',
                   help='OpenMM platform to use. Default is %(default)s')

args = parser.parse_args()

# Get the Amber forces and energies
if args.pbc:
    inp = sander.pme_input()
    inp.cut = args.cutoff
    inp.ntc = inp.ntf = 1
else:
    inp = sander.gas_input(args.igb)
    inp.cut = 1000
    inp.rgbmax = 1000

with sander.setup(args.prmtop, args.inpcrd, None, inp) as context:
    e, f = sander.energy_forces()
    f = np.array(f).reshape((context.natom, 3))

# Get the OpenMM forces and energies
parm = app.AmberPrmtopFile(args.prmtop)
inpcrd = app.AmberInpcrdFile(args.inpcrd)

gbmap = collections.defaultdict(lambda: None)
gbmap[1] = app.HCT
gbmap[2] = app.OBC1
gbmap[5] = app.OBC2
gbmap[7] = app.GBn
gbmap[8] = app.GBn2

if args.pbc:
Esempio n. 23
0
#! /usr/bin/env python

import sander
from chemistry.amber.readparm import AmberParm, Rst7
from chemistry.structure import Structure, read_PDB, write_PDB
import numpy as np


parm = AmberParm('4amber_1cby.prmtop')
pdb = read_PDB('new.pdb')
rst = Rst7.open('4amber_1cby.rst7')
xyz = pdb.pdbxyz[0]
sander.setup(parm,xyz, rst.box, sander.pme_input())

sander.set_positions(xyz)
ene, frc = sander.energy_forces()

#~ import code; code.interact(local=dict(globals(), **locals()))
sander.cleanup()