def process_residue_set(residueSet, routines, output, clean = False,
neutraln = False,
neutralc = False,
ligand = None,
assign_only = False,
chain = False,
debump = True,
opt = True):
routines.write(str(residueSet)+'\n')
routines.removeHydrogens()
for newResidueName, oldResidue, index in izip(residueSet, routines.protein.getResidues(), count()):
if newResidueName is None:
continue
chain = routines.protein.chainmap[oldResidue.chainID]
chainIndex = chain.residues.index(oldResidue)
residueAtoms = oldResidue.atoms
#Create the replacement residue
newResidue = routines.protein.createResidue(residueAtoms, newResidueName)
#Make sure our names are cleaned up for output.
newResidue.renameResidue(newResidueName)
#Drop it in
routines.protein.residues[index] = newResidue
chain.residues[chainIndex] = newResidue
#Run the meaty bits of PDB2PQR
routines.setTermini(neutraln, neutralc)
routines.updateBonds()
if not clean and not assign_only:
routines.updateSSbridges()
if debump:
routines.debumpProtein()
routines.addHydrogens()
hydRoutines = hydrogenRoutines(routines)
if debump:
routines.debumpProtein()
if opt:
hydRoutines.setOptimizeableHydrogens()
hydRoutines.initializeFullOptimization()
hydRoutines.optimizeHydrogens()
else:
hydRoutines.initializeWaterOptimization()
hydRoutines.optimizeHydrogens()
# Special for GLH/ASH, since both conformations were added
hydRoutines.cleanup()
save_residue_interaction_energies(routines.protein.getResidues(), output)
def pre_init(pdbfilename=None,
output_dir=None,
ff=None,
verbose=1,
pdie=8.0,
maps=None,
xdiel=None,
ydiel=None,
zdiel=None,
kappa=None,
sd=None,
options=None):
"""This function cleans the PDB and prepares the APBS input file"""
#
# remove hydrogen atoms
#
import pka_help
pka_help.remove_hydrogens(pdbfilename)
#
# Get the PDBfile
#
global pdbfile_name
pdbfile_name = pdbfilename
pdbfile = getPDBFile(pdbfilename)
pdblist, errlist = readPDB(pdbfile)
#
# if len(pdblist) == 0 and len(errlist) == 0:
# print "Unable to find file %s!\n" % path
# os.remove(path)
# sys.exit(2)
if len(errlist) != 0 and verbose:
print "Warning: %s is a non-standard PDB file.\n" % pdbfilename
print errlist
if verbose:
print "Beginning PDB2PQR...\n"
#
# Read the definition file
#
myDefinition = Definition()
ligand_titratable_groups = None
#
#
# Choose whether to include the ligand or not
#
# Add the ligand to the pdb2pqr arrays
#
Lig = None
MOL2FLAG = False
if not options.ligand:
dummydef = Definition()
myProtein = Protein(pdblist, dummydef)
else:
#
# Mol2 ligands and PDB ligands are treated differently
#
if options.ligand != []:
for ligand in options.ligand:
#
# Open ligand mol2 file
#
if os.path.isfile(ligand):
ligfd = open(ligand, 'rU')
else:
print 'skipping ligand', ligand
continue
#
# Read the ligand into Paul's code
#
from ligandclean import ligff
myProtein, myDefinition, Lig = ligff.initialize(
myDefinition, ligfd, pdblist, verbose)
#
# Create the ligand definition from the mol2 data
#
#import NEWligand_topology
#MOL2FLAG = True # somethign is rotten here
##
#X=NEWligand_topology.get_ligand_topology(Lig.lAtoms,MOL2FLAG)
#
# Add it to the 'official' definition
#
#ligresidue=myDefinition.parseDefinition(X.lines, 'LIG', 2)
#myDefinition.AAdef.addResidue(ligresidue)
#
# Look for titratable groups in the ligand
#
#print '==============================\n================================\n======================='
#ligand_titratable_groups=X.find_titratable_groups()
#print '==============================\n================================\n======================='
#print "ligand_titratable_groups", ligand_titratable_groups
#
# ------------------------------------------------------
# Creation of ligand definition and identification of ligand titgrps done
# Start loading everything into PDB2PQR
#
# Append the ligand data to the end of the PDB data
#
#newpdblist=[]
# First the protein
#for line in pdblist:
# if isinstance(line, END) or isinstance(line,MASTER):
# continue
# newpdblist.append(line)
## Now the ligand
#for e in Lig.lAtoms:
# newpdblist.append(e)
#
# Add a TER and an END record for good measure
#
#newpdblist.append(TER)
#newpdblist.append(END)
#
# Let PDB2PQR parse the entire file
#
#myProtein = Protein(newpdblist)
#
# Post-Processing for adding sybylTypes to lig-atoms in myProtein
# Jens: that's the quick and easy solution
#
#for rrres in myProtein.chainmap['L'].residues:
# for aaat in rrres.atoms:
# for ligatoms in Lig.lAtoms:
# if ligatoms.name == aaat.name:
# aaat.sybylType = ligatoms.sybylType
# #
# # setting the formal charges
# if ligatoms.sybylType == "O.co2":
# aaat.formalcharge = -0.5
# else: aaat.formalcharge = 0.0
# xxxlll = []
# for xxx in ligatoms.lBondedAtoms:
# xxxlll.append(xxx.name)
# aaat.intrabonds = xxxlll
# #
# # charge initialisation must happen somewhere else
# # but i don't know where...
# aaat.charge = 0.0#
#
#
# =======================================================================
#
# We have identified the structural elements, now contiue with the setup
#
# Print something for some reason?
#
if verbose:
print "Created protein object -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Set up all other routines
#
myRoutines = Routines(myProtein, verbose) #myDefinition)
myRoutines.updateResidueTypes()
myRoutines.updateSSbridges()
myRoutines.updateBonds()
myRoutines.setTermini()
myRoutines.updateInternalBonds()
myRoutines.applyNameScheme(Forcefield(ff, myDefinition, None))
myRoutines.findMissingHeavy()
myRoutines.addHydrogens()
myRoutines.debumpProtein()
#myRoutines.randomizeWaters()
myProtein.reSerialize()
#
# Inject the information on hydrogen conformations in the HYDROGENS.DAT arrays
# We get this information from ligand_titratable_groups
#
from src.hydrogens import hydrogenRoutines
myRoutines.updateInternalBonds()
myRoutines.calculateDihedralAngles()
myhydRoutines = hydrogenRoutines(myRoutines)
#
# Here we should inject the info!!
#
myhydRoutines.setOptimizeableHydrogens()
myhydRoutines.initializeFullOptimization()
myhydRoutines.optimizeHydrogens()
myhydRoutines.cleanup()
myRoutines.setStates()
#
# Choose the correct forcefield
#
myForcefield = Forcefield(ff, myDefinition, None)
if Lig:
hitlist, misslist = myRoutines.applyForcefield(myForcefield)
#
# Can we get charges for the ligand?
#
templist = []
ligsuccess = False
for residue in myProtein.getResidues():
if isinstance(residue, LIG):
templist = []
Lig.make_up2date(residue)
net_charge = 0.0
print 'Ligand', residue
print 'Atom\tCharge\tRadius'
for atom in residue.getAtoms():
if atom.mol2charge:
atom.ffcharge = atom.mol2charge
else:
atom.ffcharge = Lig.ligand_props[atom.name]["charge"]
#
# Find the net charge
#
net_charge = net_charge + atom.ffcharge
#
# Assign radius
#
atom.radius = Lig.ligand_props[atom.name]["radius"]
print '%s\t%6.4f\t%6.4f' % (atom.name, atom.ffcharge,
atom.radius)
if atom in misslist:
misslist.pop(misslist.index(atom))
templist.append(atom)
#
# Store the charge and radius in the atom instance for later use
# This really should be done in a nicer way, but this will do for now
#
atom.secret_radius = atom.radius
atom.secret_charge = atom.ffcharge
#
#
charge = residue.getCharge()
if abs(charge - round(charge)) > 0.01:
# Ligand parameterization failed
myProtein.residues.remove(residue)
raise Exception('Non-integer charge on ligand: %8.5f' %
charge)
else:
ligsuccess = 1
# Mark these atoms as hits
hitlist = hitlist + templist
#
# Print the net charge
#
print 'Net charge for ligand %s is: %5.3f' % (residue.name,
net_charge)
#
# Temporary fix; if ligand was successful, pull all ligands from misslist
# Not sure if this is needed at all here ...? (Jens wrote this)
#
if ligsuccess:
templist = misslist[:]
for atom in templist:
if isinstance(atom.residue, Amino) or isinstance(
atom.residue, Nucleic):
continue
misslist.remove(atom)
if verbose:
print "Created protein object (after processing myRoutines) -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Create the APBS input file
#
import src.psize
size = src.psize.Psize()
method = ""
asynch = 0
split = 0
import inputgen_pKa
igen = inputgen_pKa.inputGen(pdbfilename)
#
# For convenience
#
igen.pdie = pdie
print 'Setting protein dielectric constant to ', igen.pdie
igen.sdie = options.sdie
igen.maps = maps
if maps == 1:
print "Using dielectric and mobile ion-accessibility function maps in PBE"
if xdiel:
igen.xdiel = xdiel
else:
sys.stderr.write("X dielectric map is missing\n")
usage(2)
sys.exit(0)
if ydiel:
igen.ydiel = ydiel
else:
sys.stderr.write("Y dielectric map is missing\n")
usage(2)
sys.exit(0)
if zdiel:
igen.zdiel = zdiel
else:
sys.stderr.write("Z dielectric map is missing\n")
usage(2)
sys.exit(0)
print 'Setting dielectric function maps: %s, %s, %s' % (
igen.xdiel, igen.ydiel, igen.zdiel)
if kappa:
igen.kappa = kappa
else:
sys.stderr.write("Mobile ion-accessibility map is missing\n")
usage(2)
sys.exit(0)
print 'Setting mobile ion-accessibility function map to: ', igen.kappa
if sd:
xdiel_smooth, ydiel_smooth, zdiel_smooth = smooth(
xdiel, ydiel, zdiel)
igen.xdiel = xdiel_smooth
igen.ydiel = ydiel_smooth
igen.zdiel = zdiel_smooth
#
# Return all we need
#
return myProtein, myRoutines, myForcefield, igen, ligand_titratable_groups, maps, sd
def process_residue_set(residueSet,
routines,
output,
clean=False,
neutraln=False,
neutralc=False,
ligand=None,
assign_only=False,
chain=False,
debump=True,
opt=True):
routines.write(str(residueSet) + '\n')
routines.removeHydrogens()
for newResidueName, oldResidue, index in zip(
residueSet, routines.protein.getResidues(), count()):
if newResidueName is None:
continue
chain = routines.protein.chainmap[oldResidue.chainID]
chainIndex = chain.residues.index(oldResidue)
residueAtoms = oldResidue.atoms
#Create the replacement residue
newResidue = routines.protein.createResidue(residueAtoms,
newResidueName)
#Make sure our names are cleaned up for output.
newResidue.renameResidue(newResidueName)
#Drop it in
routines.protein.residues[index] = newResidue
chain.residues[chainIndex] = newResidue
#Run the meaty bits of PDB2PQR
routines.setTermini(neutraln, neutralc)
routines.updateBonds()
if not clean and not assign_only:
routines.updateSSbridges()
if debump:
routines.debumpProtein()
routines.addHydrogens()
hydRoutines = hydrogenRoutines(routines)
if debump:
routines.debumpProtein()
if opt:
hydRoutines.setOptimizeableHydrogens()
hydRoutines.initializeFullOptimization()
hydRoutines.optimizeHydrogens()
else:
hydRoutines.initializeWaterOptimization()
hydRoutines.optimizeHydrogens()
# Special for GLH/ASH, since both conformations were added
hydRoutines.cleanup()
save_residue_interaction_energies(routines.protein.getResidues(), output)
def run_pdb2pqr(self, currentPDB):
"""Run pdb2pqr, prepare input for apbs"""
pdbfile = getPDBFile(currentPDB)
pdblist, errlist = readPDB(pdbfile)
#
# Instantiate pdb2pqr
#
myDefinition = Definition()
myProtein = Protein(pdblist, myDefinition)
#
# Setup everything
#
myRoutines = Routines(myProtein, verbose)
myRoutines.updateResidueTypes()
myRoutines.updateSSbridges()
myRoutines.updateBonds()
myRoutines.setTermini()
myRoutines.updateInternalBonds()
myforcefield = Forcefield(ff, myDefinition, None)
myRoutines.applyNameScheme(myforcefield)
myRoutines.findMissingHeavy()
myRoutines.addHydrogens()
myRoutines.debumpProtein()
myProtein.reSerialize()
#
# Add and optimze hydrogens:
#
from src.hydrogens import hydrogenRoutines
myRoutines.updateInternalBonds()
myRoutines.calculateDihedralAngles()
myhydRoutines = hydrogenRoutines(myRoutines)
#
# Now optimize hydrogens
#
myhydRoutines.setOptimizeableHydrogens()
myhydRoutines.initializeFullOptimization()
myhydRoutines.optimizeHydrogens()
myhydRoutines.cleanup()
myRoutines.setStates()
print "Created protein object (after processing myRoutines) -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Assign charges
#
for chain in myProtein.getChains():
for residue in chain.get("residues"):
for atom in residue.get("atoms"):
atomname = atom.get("name")
charge, radius = myforcefield.getParams1(residue, atomname)
atom.set("radius", radius)
atom.set("ffcharge", charge)
#
#
method = ""
async = 0
split = 0
import pdb2pka.inputgen_pKa as IP
igen = IP.inputGen(currentPDB)
igen.maps = None
igen.set_type('background')
igen.pdie = 8.0
igen.sdie = 80.0
all_center, extent = igen.getCenter()
igen.setfineCenter(all_center)
print 'Center: %5.1fA %5.1fA %5.1fA' % (
all_center[0], all_center[1], all_center[2])
print 'Extent: %5.1fA %5.1fA %5.1fA' % (extent[0], extent[1],
extent[2])
apbs_inputfile = igen.printInput()
return myProtein, apbs_inputfile
def pre_init(original_pdb_list=None,
output_dir=None,
ff=None,
verbose=False,
pdie=8.0,
sdie=80,
maps=None,
xdiel=None,
ydiel=None,
zdiel=None,
kappa=None,
sd=None,
ligand=None):
"""This function cleans the PDB and prepares the APBS input file
Prepares the output folder."""
#prepare the output directory
output_dir = os.path.abspath(output_dir)
try:
os.makedirs(output_dir)
except OSError:
if not os.path.isdir(output_dir):
raise ValueError('Target directory is a file! Aborting.')
workspace_dir = os.path.join(output_dir,'workspace')
try:
os.makedirs(workspace_dir)
except OSError:
if not os.path.isdir(output_dir):
raise ValueError('Target directory is a file! Aborting.')
#
# remove hydrogen atoms
#
working_pdb_filename = os.path.join(workspace_dir,'working.pdb')
pka_help.dump_protein_no_hydrogens(original_pdb_list, working_pdb_filename)
#
# Get the PDBfile
#
pdbfile = getPDBFile(working_pdb_filename)
pdblist, errlist = readPDB(pdbfile)
if verbose:
print "Beginning PDB2PKA...\n"
#
# Read the definition file
#
myDefinition = Definition()
ligand_titratable_groups=None
#
#
# Choose whether to include the ligand or not
#
# Add the ligand to the pdb2pqr arrays
#
Lig=None
if ligand is None:
myProtein = Protein(pdblist, myDefinition)
else:
from pdb2pka.ligandclean import ligff
myProtein, myDefinition, Lig = ligff.initialize(myDefinition, ligand, pdblist, verbose)
#
# =======================================================================
#
# We have identified the structural elements, now contiue with the setup
#
# Print something for some reason?
#
if verbose:
print "Created protein object -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Set up all other routines
#
myRoutines = Routines(myProtein, verbose) #myDefinition)
myRoutines.updateResidueTypes()
myRoutines.updateSSbridges()
myRoutines.updateBonds()
myRoutines.setTermini()
myRoutines.updateInternalBonds()
myRoutines.applyNameScheme(Forcefield(ff, myDefinition, None))
myRoutines.findMissingHeavy()
myRoutines.addHydrogens()
myRoutines.debumpProtein()
#myRoutines.randomizeWaters()
myProtein.reSerialize()
#
# Inject the information on hydrogen conformations in the HYDROGENS.DAT arrays
# We get this information from ligand_titratable_groups
#
from src.hydrogens import hydrogenRoutines
myRoutines.updateInternalBonds()
myRoutines.calculateDihedralAngles()
myhydRoutines = hydrogenRoutines(myRoutines)
#
# Here we should inject the info!!
#
myhydRoutines.setOptimizeableHydrogens()
myhydRoutines.initializeFullOptimization()
myhydRoutines.optimizeHydrogens()
myhydRoutines.cleanup()
myRoutines.setStates()
#
# Choose the correct forcefield
#
myForcefield = Forcefield(ff, myDefinition, None)
if Lig:
hitlist, misslist = myRoutines.applyForcefield(myForcefield)
#
# Can we get charges for the ligand?
#
templist=[]
ligsuccess=False
for residue in myProtein.getResidues():
if isinstance(residue, LIG):
templist = []
Lig.make_up2date(residue)
net_charge=0.0
print 'Ligand',residue
print 'Atom\tCharge\tRadius'
for atom in residue.getAtoms():
if atom.mol2charge:
atom.ffcharge=atom.mol2charge
else:
atom.ffcharge = Lig.ligand_props[atom.name]["charge"]
#
# Find the net charge
#
net_charge=net_charge+atom.ffcharge
#
# Assign radius
#
atom.radius = Lig.ligand_props[atom.name]["radius"]
print '%s\t%6.4f\t%6.4f' %(atom.name,atom.ffcharge,atom.radius)
if atom in misslist:
misslist.pop(misslist.index(atom))
templist.append(atom)
#
# Store the charge and radius in the atom instance for later use
# This really should be done in a nicer way, but this will do for now
#
atom.secret_radius=atom.radius
atom.secret_charge=atom.ffcharge
#
#
charge = residue.getCharge()
if abs(charge - round(charge)) > 0.01:
# Ligand parameterization failed
myProtein.residues.remove(residue)
raise Exception('Non-integer charge on ligand: %8.5f' %charge)
else:
ligsuccess = 1
# Mark these atoms as hits
hitlist = hitlist + templist
#
# Print the net charge
#
print 'Net charge for ligand %s is: %5.3f' %(residue.name,net_charge)
#
# Temporary fix; if ligand was successful, pull all ligands from misslist
# Not sure if this is needed at all here ...? (Jens wrote this)
#
if ligsuccess:
templist = misslist[:]
for atom in templist:
if isinstance(atom.residue, Amino) or isinstance(atom.residue, Nucleic):
continue
misslist.remove(atom)
if verbose:
print "Created protein object (after processing myRoutines) -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Create the APBS input file
#
import src.psize
size=src.psize.Psize()
method=""
async=0
split=0
igen = inputgen_pKa.inputGen(working_pdb_filename)
#
# For convenience
#
igen.pdie = pdie
print 'Setting protein dielectric constant to ',igen.pdie
igen.sdie=sdie
igen.maps=maps
if maps==1:
print "Using dielectric and mobile ion-accessibility function maps in PBE"
if xdiel:
igen.xdiel = xdiel
else:
raise PDB2PKAError('X dielectric map is missing')
if ydiel:
igen.ydiel = ydiel
else:
raise PDB2PKAError("Y dielectric map is missing\n")
if zdiel:
igen.zdiel = zdiel
else:
raise PDB2PKAError("Z dielectric map is missing\n")
print 'Setting dielectric function maps: %s, %s, %s'%(igen.xdiel,igen.ydiel,igen.zdiel)
if kappa:
igen.kappa = kappa
else:
raise PDB2PKAError("Mobile ion-accessibility map is missing\n")
print 'Setting mobile ion-accessibility function map to: ',igen.kappa
if sd:
xdiel_smooth, ydiel_smooth, zdiel_smooth = smooth(xdiel,ydiel,zdiel)
igen.xdiel = xdiel_smooth
igen.ydiel = ydiel_smooth
igen.zdiel = zdiel_smooth
#
# Return all we need
#
return output_dir, myProtein, myRoutines, myForcefield,igen, ligand_titratable_groups, maps, sd
def run_pdb2pqr(self,currentPDB):
"""Run pdb2pqr, prepare input for apbs"""
pdbfile = getPDBFile(currentPDB)
pdblist, errlist = readPDB(pdbfile)
#
# Instantiate pdb2pqr
#
myDefinition = Definition()
myProtein = Protein(pdblist, myDefinition)
#
# Setup everything
#
myRoutines = Routines(myProtein, verbose)
myRoutines.updateResidueTypes()
myRoutines.updateSSbridges()
myRoutines.updateBonds()
myRoutines.setTermini()
myRoutines.updateInternalBonds()
myforcefield=Forcefield(ff, myDefinition, None)
myRoutines.applyNameScheme(myforcefield)
myRoutines.findMissingHeavy()
myRoutines.addHydrogens()
myRoutines.debumpProtein()
myProtein.reSerialize()
#
# Add and optimze hydrogens:
#
from src.hydrogens import hydrogenRoutines
myRoutines.updateInternalBonds()
myRoutines.calculateDihedralAngles()
myhydRoutines = hydrogenRoutines(myRoutines)
#
# Now optimize hydrogens
#
myhydRoutines.setOptimizeableHydrogens()
myhydRoutines.initializeFullOptimization()
myhydRoutines.optimizeHydrogens()
myhydRoutines.cleanup()
myRoutines.setStates()
print "Created protein object (after processing myRoutines) -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Assign charges
#
for chain in myProtein.getChains():
for residue in chain.get("residues"):
for atom in residue.get("atoms"):
atomname = atom.get("name")
charge, radius = myforcefield.getParams1(residue, atomname)
atom.set("radius", radius)
atom.set("ffcharge", charge)
#
#
method=""
async=0
split=0
import pdb2pka.inputgen_pKa as IP
igen = IP.inputGen(currentPDB)
igen.maps=None
igen.set_type('background')
igen.pdie=8.0
igen.sdie=80.0
all_center,extent=igen.getCenter()
igen.setfineCenter(all_center)
print 'Center: %5.1fA %5.1fA %5.1fA' %(all_center[0],all_center[1],all_center[2])
print 'Extent: %5.1fA %5.1fA %5.1fA' %(extent[0],extent[1],extent[2])
apbs_inputfile=igen.printInput()
return myProtein, apbs_inputfile
def pre_init(original_pdb_list=None,
output_dir=None,
ff=None,
verbose=False,
pdie=8.0,
sdie=80,
maps=None,
xdiel=None,
ydiel=None,
zdiel=None,
kappa=None,
sd=None,
ligand=None):
"""This function cleans the PDB and prepares the APBS input file
Prepares the output folder."""
#prepare the output directory
output_dir = os.path.abspath(output_dir)
try:
os.makedirs(output_dir)
except OSError:
if not os.path.isdir(output_dir):
raise ValueError('Target directory is a file! Aborting.')
workspace_dir = os.path.join(output_dir, 'workspace')
try:
os.makedirs(workspace_dir)
except OSError:
if not os.path.isdir(output_dir):
raise ValueError('Target directory is a file! Aborting.')
#
# remove hydrogen atoms
#
working_pdb_filename = os.path.join(workspace_dir, 'working.pdb')
pka_help.dump_protein_no_hydrogens(original_pdb_list, working_pdb_filename)
#
# Get the PDBfile
#
pdbfile = getPDBFile(working_pdb_filename)
pdblist, errlist = readPDB(pdbfile)
if verbose:
print "Beginning PDB2PKA...\n"
#
# Read the definition file
#
myDefinition = Definition()
ligand_titratable_groups = None
#
#
# Choose whether to include the ligand or not
#
# Add the ligand to the pdb2pqr arrays
#
Lig = None
if ligand is None:
myProtein = Protein(pdblist, myDefinition)
else:
from pdb2pka.ligandclean import ligff
myProtein, myDefinition, Lig = ligff.initialize(
myDefinition, ligand, pdblist, verbose)
#
# =======================================================================
#
# We have identified the structural elements, now contiue with the setup
#
# Print something for some reason?
#
if verbose:
print "Created protein object -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Set up all other routines
#
myRoutines = Routines(myProtein, verbose) #myDefinition)
myRoutines.updateResidueTypes()
myRoutines.updateSSbridges()
myRoutines.updateBonds()
myRoutines.setTermini()
myRoutines.updateInternalBonds()
myRoutines.applyNameScheme(Forcefield(ff, myDefinition, None))
myRoutines.findMissingHeavy()
myRoutines.addHydrogens()
myRoutines.debumpProtein()
#myRoutines.randomizeWaters()
myProtein.reSerialize()
#
# Inject the information on hydrogen conformations in the HYDROGENS.DAT arrays
# We get this information from ligand_titratable_groups
#
from src.hydrogens import hydrogenRoutines
myRoutines.updateInternalBonds()
myRoutines.calculateDihedralAngles()
myhydRoutines = hydrogenRoutines(myRoutines)
#
# Here we should inject the info!!
#
myhydRoutines.setOptimizeableHydrogens()
myhydRoutines.initializeFullOptimization()
myhydRoutines.optimizeHydrogens()
myhydRoutines.cleanup()
myRoutines.setStates()
#
# Choose the correct forcefield
#
myForcefield = Forcefield(ff, myDefinition, None)
if Lig:
hitlist, misslist = myRoutines.applyForcefield(myForcefield)
#
# Can we get charges for the ligand?
#
templist = []
ligsuccess = False
for residue in myProtein.getResidues():
if isinstance(residue, LIG):
templist = []
Lig.make_up2date(residue)
net_charge = 0.0
print 'Ligand', residue
print 'Atom\tCharge\tRadius'
for atom in residue.getAtoms():
if atom.mol2charge:
atom.ffcharge = atom.mol2charge
else:
atom.ffcharge = Lig.ligand_props[atom.name]["charge"]
#
# Find the net charge
#
net_charge = net_charge + atom.ffcharge
#
# Assign radius
#
atom.radius = Lig.ligand_props[atom.name]["radius"]
print '%s\t%6.4f\t%6.4f' % (atom.name, atom.ffcharge,
atom.radius)
if atom in misslist:
misslist.pop(misslist.index(atom))
templist.append(atom)
#
# Store the charge and radius in the atom instance for later use
# This really should be done in a nicer way, but this will do for now
#
atom.secret_radius = atom.radius
atom.secret_charge = atom.ffcharge
#
#
charge = residue.getCharge()
if abs(charge - round(charge)) > 0.01:
# Ligand parameterization failed
myProtein.residues.remove(residue)
raise Exception('Non-integer charge on ligand: %8.5f' %
charge)
else:
ligsuccess = 1
# Mark these atoms as hits
hitlist = hitlist + templist
#
# Print the net charge
#
print 'Net charge for ligand %s is: %5.3f' % (residue.name,
net_charge)
#
# Temporary fix; if ligand was successful, pull all ligands from misslist
# Not sure if this is needed at all here ...? (Jens wrote this)
#
if ligsuccess:
templist = misslist[:]
for atom in templist:
if isinstance(atom.residue, Amino) or isinstance(
atom.residue, Nucleic):
continue
misslist.remove(atom)
if verbose:
print "Created protein object (after processing myRoutines) -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Create the APBS input file
#
import src.psize
size = src.psize.Psize()
method = ""
split = 0
igen = inputgen_pKa.inputGen(working_pdb_filename)
#
# For convenience
#
igen.pdie = pdie
print 'Setting protein dielectric constant to ', igen.pdie
igen.sdie = sdie
igen.maps = maps
if maps == 1:
print "Using dielectric and mobile ion-accessibility function maps in PBE"
if xdiel:
igen.xdiel = xdiel
else:
raise PDB2PKAError('X dielectric map is missing')
if ydiel:
igen.ydiel = ydiel
else:
raise PDB2PKAError("Y dielectric map is missing\n")
if zdiel:
igen.zdiel = zdiel
else:
raise PDB2PKAError("Z dielectric map is missing\n")
print 'Setting dielectric function maps: %s, %s, %s' % (
igen.xdiel, igen.ydiel, igen.zdiel)
if kappa:
igen.kappa = kappa
else:
raise PDB2PKAError("Mobile ion-accessibility map is missing\n")
print 'Setting mobile ion-accessibility function map to: ', igen.kappa
if sd:
xdiel_smooth, ydiel_smooth, zdiel_smooth = smooth(
xdiel, ydiel, zdiel)
igen.xdiel = xdiel_smooth
igen.ydiel = ydiel_smooth
igen.zdiel = zdiel_smooth
#
# Return all we need
#
return output_dir, myProtein, myRoutines, myForcefield, igen, ligand_titratable_groups, maps, sd
def pre_init(pdbfilename=None,
output_dir=None,
ff=None,
verbose=1,
pdie=8.0,
maps=None,
xdiel=None,
ydiel=None,
zdiel=None,
kappa=None,
sd=None,
options=None):
"""This function cleans the PDB and prepares the APBS input file"""
#
# remove hydrogen atoms
#
import pka_help
pka_help.remove_hydrogens(pdbfilename)
#
# Get the PDBfile
#
global pdbfile_name
pdbfile_name=pdbfilename
pdbfile = getPDBFile(pdbfilename)
pdblist, errlist = readPDB(pdbfile)
#
# if len(pdblist) == 0 and len(errlist) == 0:
# print "Unable to find file %s!\n" % path
# os.remove(path)
# sys.exit(2)
if len(errlist) != 0 and verbose:
print "Warning: %s is a non-standard PDB file.\n" %pdbfilename
print errlist
if verbose:
print "Beginning PDB2PQR...\n"
#
# Read the definition file
#
myDefinition = Definition()
ligand_titratable_groups=None
#
#
# Choose whether to include the ligand or not
#
# Add the ligand to the pdb2pqr arrays
#
Lig=None
MOL2FLAG = False
if not options.ligand:
dummydef = Definition()
myProtein = Protein(pdblist, dummydef)
else:
#
# Mol2 ligands and PDB ligands are treated differently
#
if options.ligand!=[]:
for ligand in options.ligand:
#
# Open ligand mol2 file
#
if os.path.isfile(ligand):
ligfd=open(ligand, 'rU')
else:
print 'skipping ligand',ligand
continue
#
# Read the ligand into Paul's code
#
from ligandclean import ligff
myProtein, myDefinition, Lig = ligff.initialize(myDefinition, ligfd, pdblist, verbose)
#
# Create the ligand definition from the mol2 data
#
#import NEWligand_topology
#MOL2FLAG = True # somethign is rotten here
##
#X=NEWligand_topology.get_ligand_topology(Lig.lAtoms,MOL2FLAG)
#
# Add it to the 'official' definition
#
#ligresidue=myDefinition.parseDefinition(X.lines, 'LIG', 2)
#myDefinition.AAdef.addResidue(ligresidue)
#
# Look for titratable groups in the ligand
#
#print '==============================\n================================\n======================='
#ligand_titratable_groups=X.find_titratable_groups()
#print '==============================\n================================\n======================='
#print "ligand_titratable_groups", ligand_titratable_groups
#
# ------------------------------------------------------
# Creation of ligand definition and identification of ligand titgrps done
# Start loading everything into PDB2PQR
#
# Append the ligand data to the end of the PDB data
#
#newpdblist=[]
# First the protein
#for line in pdblist:
# if isinstance(line, END) or isinstance(line,MASTER):
# continue
# newpdblist.append(line)
## Now the ligand
#for e in Lig.lAtoms:
# newpdblist.append(e)
#
# Add a TER and an END record for good measure
#
#newpdblist.append(TER)
#newpdblist.append(END)
#
# Let PDB2PQR parse the entire file
#
#myProtein = Protein(newpdblist)
#
# Post-Processing for adding sybylTypes to lig-atoms in myProtein
# Jens: that's the quick and easy solution
#
#for rrres in myProtein.chainmap['L'].residues:
# for aaat in rrres.atoms:
# for ligatoms in Lig.lAtoms:
# if ligatoms.name == aaat.name:
# aaat.sybylType = ligatoms.sybylType
# #
# # setting the formal charges
# if ligatoms.sybylType == "O.co2":
# aaat.formalcharge = -0.5
# else: aaat.formalcharge = 0.0
# xxxlll = []
# for xxx in ligatoms.lBondedAtoms:
# xxxlll.append(xxx.name)
# aaat.intrabonds = xxxlll
# #
# # charge initialisation must happen somewhere else
# # but i don't know where...
# aaat.charge = 0.0#
#
#
# =======================================================================
#
# We have identified the structural elements, now contiue with the setup
#
# Print something for some reason?
#
if verbose:
print "Created protein object -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Set up all other routines
#
myRoutines = Routines(myProtein, verbose) #myDefinition)
myRoutines.updateResidueTypes()
myRoutines.updateSSbridges()
myRoutines.updateBonds()
myRoutines.setTermini()
myRoutines.updateInternalBonds()
myRoutines.applyNameScheme(Forcefield(ff, myDefinition, None))
myRoutines.findMissingHeavy()
myRoutines.addHydrogens()
myRoutines.debumpProtein()
#myRoutines.randomizeWaters()
myProtein.reSerialize()
#
# Inject the information on hydrogen conformations in the HYDROGENS.DAT arrays
# We get this information from ligand_titratable_groups
#
from src.hydrogens import hydrogenRoutines
myRoutines.updateInternalBonds()
myRoutines.calculateDihedralAngles()
myhydRoutines = hydrogenRoutines(myRoutines)
#
# Here we should inject the info!!
#
myhydRoutines.setOptimizeableHydrogens()
myhydRoutines.initializeFullOptimization()
myhydRoutines.optimizeHydrogens()
myhydRoutines.cleanup()
myRoutines.setStates()
#
# Choose the correct forcefield
#
myForcefield = Forcefield(ff, myDefinition, None)
if Lig:
hitlist, misslist = myRoutines.applyForcefield(myForcefield)
#
# Can we get charges for the ligand?
#
templist=[]
ligsuccess=False
for residue in myProtein.getResidues():
if isinstance(residue, LIG):
templist = []
Lig.make_up2date(residue)
net_charge=0.0
print 'Ligand',residue
print 'Atom\tCharge\tRadius'
for atom in residue.getAtoms():
if atom.mol2charge:
atom.ffcharge=atom.mol2charge
else:
atom.ffcharge = Lig.ligand_props[atom.name]["charge"]
#
# Find the net charge
#
net_charge=net_charge+atom.ffcharge
#
# Assign radius
#
atom.radius = Lig.ligand_props[atom.name]["radius"]
print '%s\t%6.4f\t%6.4f' %(atom.name,atom.ffcharge,atom.radius)
if atom in misslist:
misslist.pop(misslist.index(atom))
templist.append(atom)
#
# Store the charge and radius in the atom instance for later use
# This really should be done in a nicer way, but this will do for now
#
atom.secret_radius=atom.radius
atom.secret_charge=atom.ffcharge
#
#
charge = residue.getCharge()
if abs(charge - round(charge)) > 0.01:
# Ligand parameterization failed
myProtein.residues.remove(residue)
raise Exception('Non-integer charge on ligand: %8.5f' %charge)
else:
ligsuccess = 1
# Mark these atoms as hits
hitlist = hitlist + templist
#
# Print the net charge
#
print 'Net charge for ligand %s is: %5.3f' %(residue.name,net_charge)
#
# Temporary fix; if ligand was successful, pull all ligands from misslist
# Not sure if this is needed at all here ...? (Jens wrote this)
#
if ligsuccess:
templist = misslist[:]
for atom in templist:
if isinstance(atom.residue, Amino) or isinstance(atom.residue, Nucleic): continue
misslist.remove(atom)
if verbose:
print "Created protein object (after processing myRoutines) -"
print "\tNumber of residues in protein: %s" % myProtein.numResidues()
print "\tNumber of atoms in protein : %s" % myProtein.numAtoms()
#
# Create the APBS input file
#
import src.psize
size=src.psize.Psize()
method=""
async=0
split=0
import inputgen_pKa
igen = inputgen_pKa.inputGen(pdbfilename)
#
# For convenience
#
igen.pdie = pdie
print 'Setting protein dielectric constant to ',igen.pdie
igen.sdie=options.sdie
igen.maps=maps
if maps==1:
print "Using dielectric and mobile ion-accessibility function maps in PBE"
if xdiel:
igen.xdiel = xdiel
else:
sys.stderr.write ("X dielectric map is missing\n")
usage(2)
sys.exit(0)
if ydiel:
igen.ydiel = ydiel
else:
sys.stderr.write ("Y dielectric map is missing\n")
usage(2)
sys.exit(0)
if zdiel:
igen.zdiel = zdiel
else:
sys.stderr.write ("Z dielectric map is missing\n")
usage(2)
sys.exit(0)
print 'Setting dielectric function maps: %s, %s, %s'%(igen.xdiel,igen.ydiel,igen.zdiel)
if kappa:
igen.kappa = kappa
else:
sys.stderr.write ("Mobile ion-accessibility map is missing\n")
usage(2)
sys.exit(0)
print 'Setting mobile ion-accessibility function map to: ',igen.kappa
if sd:
xdiel_smooth, ydiel_smooth, zdiel_smooth = smooth(xdiel,ydiel,zdiel)
igen.xdiel = xdiel_smooth
igen.ydiel = ydiel_smooth
igen.zdiel = zdiel_smooth
#
# Return all we need
#
return myProtein, myRoutines, myForcefield,igen, ligand_titratable_groups, maps, sd
