def CCF(self):
infile = str(self.pfile.get())
targetPath = airsIO.getPath(infile)
ccffile = str(self.tfile.get())
ccfPath = airsIO.getPath(ccffile)
cmd0 = "ccf2.py %s %s" % (targetPath, ccfPath)
os.system(cmd0)
def Generate(self):
target1 = str(self.infile1.get())
target1PATH = airsIO.getPath(target1)
target2 = str(self.infile2.get())
target2PATH = airsIO.getPath(target2)
cmd1 = "cmm-morph.py %s %s %d" % (target1PATH, target2PATH, int(self.steps.get()))
print cmd1
os.system(cmd1)
counter = 0
while counter < int(self.steps.get()):
openfile = "morph-%s-%s-%d.cmm" % (target1PATH, target2PATH, counter)
chimera.openModels.open(openfile)
counter = counter + 1
def Apply(self): target=airsIO.cleanFileName(str(self.target.get())) targetPath=airsIO.getPath(target) t=os.path.splitext(target) targetPRE=str(t[0]) pseudoatoms=str(self.atoms.get()) apix=float(self.apix.get()) thresh=float(self.thresh.get()) res=float(self.res.get()) sseFLAG=self.sse.get() skeFLAG=self.skeleton.get() print "Generating skeletons on %s where pseudoatoms are %s. apix: %f threshold: %f resolution: %f skeletons: %d sse: %d"%(targetPath,pseudoatoms,apix,thresh,res,skeFLAG,sseFLAG) if pseudoatoms=="None": pseudoatoms="%s-atoms.pdb"%(targetPRE) cmd0="pseudoatom.py %s %s %f %f %f"%(targetPath, pseudoatoms, apix, res, thresh) print cmd0 os.system(cmd0) else: pseudoatomsPath=airsIO.getPath(pseudoatoms) helixsize=float(self.helixsize.get()) sheetsize=float(self.sheetsize.get()) mode=6 if skeFLAG==1 and sseFLAG==0: mode=4 elif skeFLAG==0 and sseFLAG==1: mode=5 outfile="%s-score.pdb"%(targetPRE) cmd1="skeleton %d %s %s %f %f %f %f %s"%(mode,targetPath, pseudoatoms, apix, thresh, helixsize, sheetsize, outfile) print cmd1 os.system(cmd1) if mode==4 or mode==6: helixout="%s_helix.mrc"%(targetPRE) chimera.openModels.open(helixout) sheetout="%s_sheet.mrc"%(targetPRE) chimera.openModels.open(sheetout) skeletonout="%s_skeleton.mrc"%(targetPRE) chimera.openModels.open(skeletonout) if mode==5 or mode==6: chimera.openModels.open(outfile)
def Apply(self): target=str(self.target.get()) targetPath=airsIO.getPath(target) t=os.path.splitext(target) targetNAME=str(t[0]) hhint=str(self.intfile.get()) if hhint != "None": hhinfile=airsIO.getPath(hhint) auto=int(self.autoassign.get()) percen=int(self.percen.get()) apix=float(self.apix.get()) res=float(self.res.get()) Hvalue=float(self.Hvalue.get()) Bvalue=float(self.Bvalue.get()) thr=float(self.thr.get()) logfile="log_%s_%f_%f.txt"%(targetNAME,Hvalue,Bvalue) if hhint=="None": if percen==1: cmd0="ssehunter2.py %s %f %f thr=%f helixcutoff=%f sheetcutoff=%f percen > %s"%(targetPath,apix,res,thr,Hvalue,Bvalue,logfile) else: cmd0="ssehunter2.py %s %f %f thr=%f helixcutoff=%f sheetcutoff=%f > %s"%(targetPath,apix,res,thr,Hvalue,Bvalue,logfile) else: if percen==1: cmd0="ssehunter2.py %s %f %f thr=%f helixcutoff=%f sheetcutoff=%f hh=%s percen >%s"%(targetPath,apix,res,thr,Hvalue,Bvalue,hhinfile,logfile) else: cmd0="ssehunter2.py %s %f %f thr=%f helixcutoff=%f sheetcutoff=%f hh=%s >%s"%(targetPath,apix,res,thr,Hvalue,Bvalue,hhinfile,logfile) print cmd0 os.system(cmd0) hfile="helix.pdb" bfile="sheet.pdb" scorefile="score-%s.pdb"%(targetNAME) chimera.openModels.open(scorefile) if auto==1 or percen==1: chimera.openModels.open(hfile) chimera.openModels.open(bfile)
def median(self):
filename = airsIO.cleanFileName(str(self.infile.get()))
filepath = airsIO.getPath(filename)
width = str(self.Mwid.get())
outfile = "median-%s" % (filename.strip())
cmd0 = "proc3d %s %s rfilt=20,%s" % (filepath, outfile, width)
print cmd0
os.system(cmd0)
chimera.openModels.open(outfile)
def hp(self):
filename = airsIO.cleanFileName(str(self.infile.get()))
filepath = airsIO.getPath(filename)
apix = str(self.apix.get())
filterRadius = str(self.filterRadius.get())
outfile = "hp-%s" % (filename.strip())
cmd0 = "proc3d %s %s hp=%s,%s" % (filepath, outfile, apix, filterRadius)
print cmd0
os.system(cmd0)
chimera.openModels.open(outfile)
def bf(self):
filename = airsIO.cleanFileName(str(self.infile.get()))
filepath = airsIO.getPath(filename)
sigma1 = str(self.sigma1.get())
sigma2 = str(self.sigma2.get())
iteration = int(self.iteration.get())
width = str(self.wid.get())
outfile = "bf-%s" % (filename.strip())
cmd0 = "proc3d %s %s blfilt=%s,%s,%d,%s" % (filepath, outfile, sigma1, sigma2, iteration, width)
print cmd0
os.system(cmd0)
chimera.openModels.open(outfile)
def Generate(self): target=airsIO.cleanFileName(str(self.infile.get())) targetPath=airsIO.getPath(target) t=os.path.splitext(target) targetPRE=str(t[0]) self.selectionlist=[] atoms="" selected=chimera.selection.currentAtoms() for i in selected: atoms=atoms+str(i.serialNumber)+"," print atoms outfile="%s.cmm"%(targetPRE) cmd1="pdb2cmm.py %s %s cmm %s"%(targetPath,outfile,atoms[0:-1].strip()) print cmd1 os.system(cmd1) chimera.openModels.open(outfile)
def calculatemodes(self): # Construct system inputfile=str(self.infile.get()) inputPath=airsIO.getPath(inputfile) self.universe = InfiniteUniverse(DeformationForceField()) self.universe.protein = Protein(inputPath, model='calpha') self.modelist() nbasis = max(8, self.universe.numberOfAtoms()/30) cutoff, nbasis = estimateCutoff(self.universe, nbasis) print "Calculating %d low-frequency modes for %s." %(nbasis,self.infile.get()) if cutoff is None: #Do full normal mode calculation self.modes = NormalModes(self.universe) else: # Do subspace mode calculation with Fourier basis subspace = FourierBasis(self.universe, cutoff) self.modes = SubspaceNormalModes(self.universe, subspace) self.modeSelector()
def Apply(self):
infile = airsIO.cleanFileName(str(self.target.get()))
targetPath = airsIO.getPath(infile)
alt = float(self.alt.get())
az = float(self.az.get())
phi = float(self.phi.get())
dx = float(self.dx.get())
dy = float(self.dy.get())
dz = float(self.dz.get())
outfile = "rt-%s" % (infile.strip())
print outfile
if str(infile.split(".")[-1].strip()) == ("mrc" or "map" or "ccp4"):
cmd0 = "chimerart.py %s %s %f,%f,%f,%f,%f,%f" % (targetPath, outfile, alt, az, phi, dx, dy, dz)
elif str(infile.split(".")[-1]) == ("pdb" or "ent"):
cmd0 = "procpdb.py %s %s rot=%f,%f,%f trans=%f,%f,%f" % (targetPath, outfile, alt, az, phi, dx, dy, dz)
else:
print "bad file"
print cmd0
os.system(cmd0)
chimera.openModels.open(outfile)
def Apply(self):
target = airsIO.cleanFileName(str(self.target.get()))
targetPath = airsIO.getPath(target)
output = str(self.outfile.get())
apix = float(self.apix.get())
res = float(self.res.get())
mapsize = float(self.boxsize.get())
centerFLAG = self.centeratoms.get()
if centerFLAG == 1:
cmd0 = "pdb2mrc %s %s apix=%f res=%f box=%f centeratoms" % (targetPath, output, apix, res, mapsize)
else:
cmd0 = "pdb2mrc %s %s apix=%f res=%f box=%f" % (targetPath, output, apix, res, mapsize)
print cmd0
os.system(cmd0)
chimera.openModels.open(output)
def Dock (self):
apix=float(self.apix.get())
res=float(self.res.get())
angle=float(self.angle.get())
trans=float(self.trans.get())
target=airsIO.cleanFileName(str(self.target.get()))
targetPath=airsIO.getPath(target)
t=os.path.splitext(target)
targetName=str(t[0])
mapInfo=airsIO.getMapInfo(target)
mapSize=mapInfo[0][0]
probePDB=self.outfile
cmdCenter="procpdb.py %s probe.pdb centeratoms"%(probePDB)
os.system(cmdCenter)
cmdMRC="pdb2mrc probe.pdb probe.mrc apix=%f res=%f box=%f"%(apix, res, mapSize)
os.system(cmdMRC)
self.outFit="fh-mode-%s"%(targetName)
cmdDock="foldhunterP %s probe.mrc fh-mode.mrc log=log-mode-fit.txt da=1 startangle=0,0,0 range=%f sphere_region=0,0,0,%f"%(targetPath, angle, trans)
print cmdDock
os.system(cmdDock)
file=open("log-mode-fit.txt", "r")
lines=file.readlines()
file.close()
fh = {}
pattern=re.compile(r"Solution\s(?P<solnum>\d+)\:\trotation\s=\s\(\s(?P<rotx>-?\d+(\.\d+)?(e.\d+)?)\s,\s(?P<rotz1>-?\d+(\.\d+)?(e.\d+)?)\s,\s(?P<rotz2>-?\d+(\.\d+)?(e.\d+)?)\s\)\ttranslation\s=\s\(\s(?P<dx>-?\d+(\.\d+)?(e.\d+)?)\s,\s(?P<dy>-?\d+(\.\d+)?(e.\d+)?)\s,\s(?P<dz>-?\d+(\.\d+)?(e.\d+)?)\s\)")
for line in lines:
ps=pattern.search(line)
if ps:
fh[int(ps.group('solnum'))]=[float(ps.group('rotx')),float(ps.group('rotz1')),float(ps.group('rotz2')),float(ps.group('dx')),float(ps.group('dy')),float(ps.group('dz'))]
outRefinePDB="flex-fh-%s.pdb"%(targetName)
cmd1="procpdb.py %s r.pdb rot=%f,%f,%f"%(self.outfile,fh[0][0],fh[0][1],fh[0][2])
os.system(cmd1)
cmd2="procpdb.py r.pdb %s apix=%f trans=%f,%f,%f"%(outRefinePDB,apix,fh[0][3],fh[0][4],fh[0][5])
os.system(cmd2)
chimera.openModels.open(outRefinePDB)
def Apply(self): target=airsIO.cleanFileName(str(self.target.get())) targetPath=airsIO.getPath(target) t=os.path.splitext(target) targetPRE=str(t[0]) pseudoatoms=str(self.atoms.get()) coeff=airsIO.cleanFileName(str(self.coeff.get())) apix=float(self.apix.get()) thresh=float(self.thresh.get()) res=float(self.res.get()) mapinfo=airsIO.getMapInfo(target) mapSize=mapinfo[0][0] mapOrigin=mapinfo[1] logfile="log-%s.txt"%(targetPRE) if coeff!="None": if pseudoatoms!="None": cmd1="ssehunter3.py %s %f %f %f coeff=%s atoms=%s > %s"%(target, apix, res, thresh, coeff, pseudoatoms, logfile) else: cmd1="ssehunter3.py %s %f %f %f coeff=%s > %s"%(target, apix, res, thresh, coeff, logfile) else: if pseudoatoms!="None": cmd1="ssehunter3.py %s %f %f %f atoms=%s > %s"%(target, apix, res, thresh, pseudoatoms, logfile) else: cmd1="ssehunter3.py %s %f %f %f > %s"%(target, apix, res, thresh, logfile) print cmd1 os.system(cmd1) outfile="score-%s.pdb"%(targetPRE) if self.mapOri.get()==1: Ox=mapOrigin[0] Oy=mapOrigin[1] Oz=mapOrigin[2] cmdt="procpdb.py %s %s trans=%f,%f,%f"%(outfile,outfile,Ox,Oy,Oz) os.system(cmdt) chimera.openModels.open(outfile)
def Apply(self):
target=airsIO.cleanFileName(str(self.target.get()))
targetPath=airsIO.getPath(target).strip()
shutil.copy(targetPath, 'target.mrc')
t=target.split('.')
targetExt=str(t[-1])
refineFLAG=0
maskFLAG=0
if (self.rs.get()==1):
refineFLAG=1
if self.ms.get()==1:
maskFLAG=1
probe=airsIO.cleanFileName(str(self.probe.get()))
print str(self.probe.get())
print probe
probePath=airsIO.getPath(probe)
print probePath
probesplit=probe.split('.')
probeExt=str(probesplit[-1])
probeName=str(probesplit[0])
print probeExt
print probeName
#probesplit=os.path.split(probe)
#probeName=str(probesplit[0])
mapinfo=airsIO.getMapInfo(target)
mapSize=mapinfo[0][0]
mapOrigin=mapinfo[1]
if probeExt=="mrc" or probeExt=="map" or probeExt=="ccp4":
probeinfo=airsIO.getMapInfo(probe)
tempSizeX=probeinfo[0][0]
tempSizeY=probeinfo[0][1]
tempSizeZ=probeinfo[0][2]
#openfiles=chimera.openModels.list()
#mapSize=0
#from VolumeViewer import volume_list
#for v in volume_list():
# if v.data.name == volume_name.strip():
# mapSize = v.data.size[0]
# mapOrigin= v.data.origin
# if probeExt=="mrc":
# tempSizeX,tempSizeY,tempSizeZ = v.data.size
apix=float(self.apix.get())
res= float(self.res.get())
shrink = int(self.shrink.get())
keep=int(self.keep.get())
if ((self.filter.get()=='None') or (self.filter.get()=='Normalize')):
value=None
else:
value=float(self.filterValue.get())
hs=0
hs=int(self.hs.get())
if hs==1:
depth= int(self.depth.get())
pixel=int(self.pixel.get())
else:
depth=1
pixel=1
########create user selection
if (refineFLAG==1):
selectedLength=0
selected=chimera.selection.currentAtoms()
selectedLength=len(selected)
if (selectedLength!=0) and (probeExt=='pdb' or probeExt=='ent'):
print "ENTERED USER SELECTION"
i=0
selectedAtoms=[]
while (i < selectedLength):
selectedAtoms.append(chimera.selection.currentAtoms()[i].serialNumber)
i=i+1
selectedAtoms.sort()
print selectedAtoms
fileRefine=open(probe, "r")
linesRefine=fileRefine.readlines()
fileRefine.close()
refinePDB=open("refine.pdb", "w")
maskPDB=open("mask.pdb", "w")
for lineRefine in linesRefine:
isatom=str(lineRefine[0:6].strip())
serialNum=str(lineRefine[6:11].strip())
if (isatom=="ATOM"):
serialNum=int(lineRefine[6:11].strip())
if (serialNum in selectedAtoms):
refinePDB.write(lineRefine)
else :
maskPDB.write(lineRefine)
refinePDB.close()
maskPDB.close()
cmdRS0="pdb2mrc refine.pdb refine.mrc apix=%f res=%f box=%d"%(apix, res, mapSize)
os.system(cmdRS0)
cmdRS1="pdb2mrc mask.pdb mask.mrc apix=%f res=%f box=%d"%(apix, res, mapSize)
os.system(cmdRS1)
cmdRS2="proc3d refine.mrc refine.mrc norm"
os.system(cmdRS2)
if self.mask.get()!="Unselected":
maskfile=str(self.mask.get())
maskPath=airsIO.getPath(maskfile)
maskEXT=str(maskfile[-1])
if (maskExt=='pdb' or maskExt=='ent'):
cmdRS3="pdb2mrc %s mask.mrc apix=%f res=%f box=%d"%(maskPath, apix, res, mapSize)
os.system(cmdRS3)
else:
shutil.copy(targetpath, 'mask.mrc')
# for f in openfiles:
# if f.name==maskfile:
# mask=str(f.name)
# from VolumeViewer import Volume
# from chimera import Molecule
# if isinstance(p,Volume):
# maskpath=str(os.path.abspath(mask))
# elif isinstance(p,Molecule):
# mf=f.openedAs
# maskpath=mf[0]
#
#
# maskExt=str(probesplit2[-1])
# maskName=str(probesplit2[0])
#
# if (maskExt=='pdb' or maskExt=='ent'):
# cmdRS3="pdb2mrc %s mask.mrc apix=%f res=%f box=%d"%(msplit, apix, res, mapSize)
# else:
# if os.system("copy")==1:
# cmdRS3="copy %s mask.mrc"%(msplit)
# else:
# cmdRS3="cp %s mask.mrc"%(msplit)
# os.system(cmdRS3)
cmdRS9="proc3d mask.mrc mask.mrc norm"
os.system(cmdRS9)
if (maskFLAG!=0):
cmdRS4="proc3d mask.mrc mask-bin.mrc bin=0.5"
cmdRS5="proc3d mask-bin.mrc mask-inv.mrc mult=-1"
cmdRS6="proc3d mask-inv.mrc mask-add.mrc add=1"
cmdRS7="proc3d target.mrc target.mrc maskfile=mask-add.mrc"
cmdRS8="proc3d target.mrc target.mrc rfilt=0,0.5"
os.system(cmdRS4)
os.system(cmdRS5)
os.system(cmdRS6)
os.system(cmdRS7)
os.system(cmdRS8)
tempfiles=["mask.mrc","mask-bin.mrc","mask-inv.mrc","mask-add.mrc"]
airsIO.cleanTempFiles(tempfiles)
else:
shutil.copy(probePath, 'refine.mrc')
selected=chimera.selection.currentEmpty()
selectedLength=0
########Transform PDB file and generate MRC file
if (probeExt=='pdb' or probeExt=='ent') and (refineFLAG==0):
print probe
shutil.copy(probe, 'probe.pdb')
cmd1="procpdb.py probe.pdb probe.pdb centeratoms"
os.system(cmd1)
cmd2="pdb2mrc probe.pdb probe.mrc apix=%f res=%f box=%d"%(apix, res, mapSize)
os.system(cmd2)
cmd3="proc3d probe.mrc probe.mrc norm"
os.system(cmd3)
elif (refineFLAG!=0):
print "Selection transformed"
else:
shutil.copy(probePath, 'probe.mrc')
if (tempSizeX!=tempSizeY!=tempSizeZ!=mapSize):
cmd3a="proc3d probe.mrc probe.mrc clip=%d,%d,%d"%(mapSize,mapSize,mapSize)
os.system(cmd3a)
print "filter"
########Filter and Scale MRC files
if (self.filter.get()=='Threshold'):
print("Tresholding target map")
cmdF1="proc3d target.mrc target.mrc rfilt=0,%f"%(value)
os.system(cmdF1)
if (self.filter.get()=='Binary'):
print("Binerizing target map")
cmdF2="proc3d target.mrc target.mrc rfilt=2,%f"%(value)
os.system(cmdF2)
if (self.filter.get()=='Normalize'):
print("Normalizing target map")
cmdF3="proc3d target.mrc target.mrc norm"
os.system(cmdF3)
if (self.filter.get()=='Laplacian'):
print("Laplacian filter")
cmdF4="proc3d target.mrc target.mrc rfilt=80,%f"%(value)
os.system(cmdF4)
if (refineFLAG==0):
print("Shrinking maps")
cmdST="proc3d target.mrc target-shrink.mrc shrink=%f"%(shrink)
os.system(cmdST)
cmdSP="proc3d probe.mrc probe-shrink.mrc shrink=%f"%(shrink)
os.system(cmdSP)
pattern=re.compile(r"Solution\s(?P<solnum>\d+)\:\trotation\s=\s\(\s(?P<rotx>-?\d+(\.\d+)?(e.\d+)?)\s,\s(?P<rotz1>-?\d+(\.\d+)?(e.\d+)?)\s,\s(?P<rotz2>-?\d+(\.\d+)?(e.\d+)?)\s\)\ttranslation\s=\s\(\s(?P<dx>-?\d+(\.\d+)?(e.\d+)?)\s,\s(?P<dy>-?\d+(\.\d+)?(e.\d+)?)\s,\s(?P<dz>-?\d+(\.\d+)?(e.\d+)?)\s\)")
self.listResults=[]
###############################
####### Run foldhunterP #######
###############################
########SMART option
if (self.smart.get()==1 and refineFLAG==0):
print "RUNNING SMART FOLDHUNTER"
logSmart="log-fh-%s.txt"%(probeName)
outSmart="fh-smart-%s.mrc"%(probeName)
cmdS1="foldhunterP target.mrc probe.mrc %s log=%s da=1 keep=%d "%(outSmart, logSmart, keep)
print cmdS1
os.system(cmdS1)
if (probeExt=='pdb' or probeExt=='ent'):
file0=open(logSmart, "r")
lines0=file0.readlines()
file0.close()
fh0 = {}
for line in lines0:
ps=pattern.search(line)
if ps:
fh0[int(ps.group('solnum'))]=[float(ps.group('rotx')),float(ps.group('rotz1')),float(ps.group('rotz2')),float(ps.group('dx')),float(ps.group('dy')),float(ps.group('dz'))]
fhSmart="fh-smart-%s.pdb"%(probeName)
self.transformPDB('probe.pdb', fhSmart, apix, mapSize, mapOrigin,fh0[0][0],fh0[0][1],fh0[0][2],fh0[0][3],fh0[0][4],fh0[0][5])
else:
chimera.openModels.open(outSmart)
########Scale foldhunter
if (refineFLAG==0) and (self.smart.get()==0):
print "RUNNING FOLDHUNTER ON SMALL MAPS"
outShrink="fh-shrink-%s.mrc"%(probeName)
da=((180*res)/(math.pi*(mapSize/(2*shrink))))*1.5
if da>30:
da=30
cmdFHS="foldhunterP target-shrink.mrc probe-shrink.mrc %s log=log-fh-shrink.txt da=%f keep=%d"%(outShrink,da,keep)
print cmdFHS
os.system(cmdFHS)
########Parse output and repeat foldhunterP
file1=open('log-fh-shrink.txt', "r")
lines1=file1.readlines()
file1.close()
fh1 = {}
for line in lines1:
ps=pattern.search(line)
if ps:
fh1[int(ps.group('solnum'))]=[float(ps.group('rotx')),float(ps.group('rotz1')),float(ps.group('rotz2')),float(ps.group('dx')),float(ps.group('dy')),float(ps.group('dz'))]
print("RUNNING FOLDHUNTER")
count=0
children=0
while ((count < depth) and (children < keep)):
angle_range=da/2
da2=1
if ((angle_range >=10) and (mapSize>=80)):
da2=2
sphere_radius=mapSize/10
x1=shrink*fh1[children][3]
y1=shrink*fh1[children][4]
z1=shrink*fh1[children][5]
dist = []
solution=0
while (solution <= children):
x2=shrink*fh1[solution][3]
y2=shrink*fh1[solution][4]
z2=shrink*fh1[solution][5]
if (solution!=children):
distance=math.sqrt((x1-x2)**2+(y1-y2)**2+(z1-z2)**2)
else:
distance=10000
dist.append(distance)
print "%d verse %d: %f"%(children,solution,dist[solution])
solution=solution+1
pixel_distance=min(dist)
if ((pixel_distance >= pixel) or (count==0)):
logfile="log-%s-%d.txt"%(probeName,count)
cmdFH="foldhunterP target.mrc probe.mrc fh-%d.mrc log=%s da=%f startangle=%f,%f,%f range=%f sphere_region=%f,%f,%f,%f"%(children,logfile,da2,fh1[children][0],fh1[children][1],fh1[children][2],angle_range,x1,y1,z1,sphere_radius)
print cmdFH
os.system(cmdFH)
num=count
count=count+1
########Transform PDB
if (probeExt=='pdb' or probeExt=='ent'):
print("Transforming PDB")
file2=open(logfile, "r")
lines2=file2.readlines()
file2.close()
fh2 = {}
for line in lines2:
ps=pattern.search(line)
if ps:
fh2[int(ps.group('solnum'))]=[float(ps.group('rotx')),float(ps.group('rotz1')),float(ps.group('rotz2')),float(ps.group('dx')),float(ps.group('dy')),float(ps.group('dz'))]
addFile="fh-solution-%d-%s.pdb"%(num,probeName)
self.transformPDB('probe.pdb', addFile, apix, mapSize, mapOrigin,fh2[0][0],fh2[0][1],fh2[0][2],fh2[0][3],fh2[0][4],fh2[0][5])
else:
addFile="fh-%d.mrc"%(children)
children=children+1
self.listResults.append(addFile)
# bestResult=self.listResults[0]
# chimera.openModels.open(bestResult)
self.resultSelector()
########Refinement option
if (refineFLAG==1)and (self.smart.get()==0):
print "RUNNING REFINEMENT"
outRefine="fh-refine-%s.mrc"%(probeName)
angl=float(self.angle.get())
refdis=float(self.refdist.get())
cmdREF1="foldhunterP target.mrc refine.mrc %s log=log-fh-refine.txt keep=%d da=1 startangle=0,0,0 range=%f sphere_region=0,0,0,%f"%(outRefine, keep, angl, refdis)
os.system(cmdREF1)
if (probeExt=='pdb' or probeExt=='ent'):
fileR=open("log-fh-refine.txt", "r")
linesR=fileR.readlines()
fileR.close()
fhR = {}
for lineR in linesR:
ps=pattern.search(lineR)
if ps:
fhR[int(ps.group('solnum'))]=[float(ps.group('rotx')),float(ps.group('rotz1')),float(ps.group('rotz2')),float(ps.group('dx')),float(ps.group('dy')),float(ps.group('dz'))]
outRefinePDB="fh-refine-%s.pdb"%(probeName)
self.transformPDB('refine.pdb', outRefinePDB, apix, mapSize, mapOrigin,fhR[0][0],fhR[0][1],fhR[0][2],fhR[0][3],fhR[0][4],fhR[0][5])
else:
chimera.openModels.open(outRefine)
tempfiles=["target.mrc", "probe.mrc", "target-shrink.mrc", "probe-shrink.mrc", "r.pdb", "refine.mrc", "refine.pdb"]
airsIO.cleanTempFiles(tempfiles)
def Apply(self):
inputfile = airsIO.cleanFileName(str(self.infile.get()))
fullPath = airsIO.getPath(inputfile)
shutil.copy(fullPath, "hh.mrc")
a = os.path.splitext(inputfile)
name = str(a[0])
apix = float(self.apix.get())
da = float(self.da.get())
percen = float(self.percen.get())
if self.bf.get() == 1:
sigma1 = float(self.sigma1.get())
sigma2 = float(self.sigma2.get())
it = int(self.iter.get())
width = float(self.wid.get())
else:
sigma1 = 0
sigma2 = 0
it = 0
width = 0
if self.norm.get() == 1:
print "Normalizing map"
cmd2 = "proc3d hh.mrc hh.mrc norm"
os.system(cmd2)
if it >= 1:
print "Filtering Map"
cmd3 = "proc3d hh.mrc hh.mrc blfilt=%f,%f,%d,%f" % (sigma1, sigma2, iter, width)
os.system(cmd3)
print "Running helixhunter2"
file0 = "hh2-%s-%f" % (name, percen)
if self.coeff.get() == 1:
cmd4 = (
"helixhunter2 hh.mrc %s.iv %f percen=%f docylccffirst int=int-%s dejavu=%s.sse da=%d minlen=8 maxlen=50"
% (file0, apix, percen, name, file0, da)
)
os.system(cmd4)
else:
cmd4 = "helixhunter2 hh.mrc %s.iv %f percen=%f dejavu=%s.sse minlen=8 maxlen=50 da=%d" % (
file0,
apix,
percen,
file0,
da,
)
os.system(cmd4)
print "Saving results as a PDB file"
trash = ["hh.mrc"]
airsIO.cleanTempFiles(trash)
file1 = "%s.sse" % (file0)
file2 = "%s.pdb" % (file0)
check = os.path.exists(file1)
if check == 1:
cmd5 = "dejavu2pdb.py %s %s" % (file1, file2)
os.system(cmd5)
chimera.openModels.open(file2)
def Build(self):
inputfile=str(self.infile.get())
inputPre=str((inputfile.split('.'))[0])
infile='None'
helixColor="%s,%s,%s"%(self.helixRed.get(),self.helixGreen.get(),self.helixBlue.get())
index=0
filename=airsIO.getPath(inputfile)
# while index < len(self.names):
# if str(self.files[index].name) == inputfile:
# filename=self.pdbpath(self.files[index])
# index=index+1
outDejavu=open("helix.sse","w")
outDejavu.write("!\n")
outDejavu.write("! === 0dum\n")
outDejavu.write("!\n")
outDejavu.write("MOL 0dum\n")
outDejavu.write("NOTE from helixhunter3.py\n")
outDejavu.write("PDB 1SSE\n")
outDejavu.write("!\n")
file=open(filename, "r")
lines=file.readlines()
file.close
x=[]
y=[]
z=[]
atomNumber=[]
counter=0
atomLine=[]
for line in lines:
isatom=str(line[0:6].strip())
if (isatom=="ATOM"):
atomLine.append(line)
x.append(float(line[30:38].strip()))
y.append(float(line[38:46].strip()))
z.append(float(line[46:54].strip()))
atomNumber.append(int(line[6:11].strip()))
counter=counter+1
k=0
alphaAtoms=open("helix-atoms.pdb","w")
betaAtoms=open("sheet-atoms.pdb","w")
sheetFile="sheet-%s.wrl"%(inputPre)
coilFile="coil-%s.wrl"%(inputPre)
print sheetFile,coilFile
outsheet=open(sheetFile,"w")
outsheet.write("#VRML V2.0 utf8\n")
outcoil=open(coilFile,"w")
outcoil.write("#VRML V2.0 utf8\n")
while k < len(self.displayinfo):
buildlist=self.displayinfo[k]
print buildlist
if buildlist[0] == 'Helix':
helixpoints=[]
helixlength=0.0
q=0
while q < len(atomNumber):
if atomNumber[q] in buildlist[2]:
helixpoints.append(q)
alphaAtoms.write(atomLine[q])
q=q+1
for point1 in helixpoints:
for point2 in helixpoints:
distance=math.sqrt((x[point1]-x[point2])**2+(y[point1]-y[point2])**2+(z[point1]-z[point2])**2)
if distance >= helixlength:
helixlength=distance
hpoint1=[x[point1], y[point1], z[point1]]
hpoint2=[x[point2], y[point2], z[point2]]
intlength=int(math.ceil(helixlength/1.54))
dejavuline="ALPHA 'A%d' '%d' '%d' %d %f %f %f %f %f %f\n"%(k,k*100,k*100+(intlength-1),intlength,hpoint1[0],hpoint1[1],hpoint1[2],hpoint2[0],hpoint2[1],hpoint2[2])
outDejavu.write(dejavuline)
if buildlist[0] == 'Sheet':
sheetpoints=[]
templine=[0,0,0]
q=0
xsum=0.0
ysum=0.0
zsum=0.0
while q < len(atomNumber):
if atomNumber[q] in buildlist[2]:
betaAtoms.write(atomLine[q])
templine=[x[q], y[q], z[q]]
xsum=xsum+x[q]
ysum=ysum+y[q]
zsum=zsum+z[q]
sheetpoints.append(templine)
q=q+1
xOrigin=xsum/len(sheetpoints)
yOrigin=ysum/len(sheetpoints)
zOrigin=zsum/len(sheetpoints)
points=0
maxDistance=0.0
while points < len(sheetpoints):
point1=sheetpoints[points]
x1=point1[0]
y1=point1[1]
z1=point1[2]
distance=math.sqrt((x1-xOrigin)**2+(y1-yOrigin)**2+(z1-zOrigin)**2)
if distance > maxDistance:
maxDistance=distance
points=points+1
print maxDistance
sheetColor=" emissiveColor %s %s %s\n"%(self.sheetRed.get(), self.sheetGreen.get(), self.sheetBlue.get())
outsheet.write("Shape {\n")
outsheet.write(" appearance Appearance {\n")
outsheet.write(" material Material {\n")
#outsheet.write(" emissiveColor 0.0 1.0 1.0\n")
outsheet.write(sheetColor)
outsheet.write(" }\n")
outsheet.write(" }\n")
outsheet.write(" geometry IndexedFaceSet {\n")
outsheet.write(" coord Coordinate {\n")
outsheet.write(" point [\n")
counter=0
originLine=" %f %f %f,\n"%(xOrigin,yOrigin,zOrigin)
outsheet.write(originLine)
for item in sheetpoints:
lineA=" %f %f %f,\n"%(item[0],item[1],item[2])
outsheet.write(lineA)
outsheet.write(" ]\n")
outsheet.write(" }\n")
outsheet.write(" coordIndex [\n")
counter1=0
while counter1 < len(sheetpoints):
counter2=0
while counter2 < len(sheetpoints):
distanceCheck=math.sqrt((sheetpoints[counter1][0]-sheetpoints[counter2][0])**2+(sheetpoints[counter1][1]-sheetpoints[counter2][1])**2+(sheetpoints[counter1][2]-sheetpoints[counter2][2])**2)
print buildlist[2][counter1],counter1+1,buildlist[2][counter2],counter2+1, distanceCheck
if counter1!=counter2 and distanceCheck <=maxDistance:
print buildlist[2][counter1],counter1,buildlist[2][counter2],counter2, distanceCheck
lineB=" 0,%d,%d,0\n"%(counter1+1,counter2+1)
outsheet.write(lineB)
#counter3=0
#while counter3<len(sheetpoints):
# if counter1!=counter!=counter3:
# lineB=" %d,%d,%d,%d,-1\n"%(counter1,counter2,counter3,counter1)
# outsheet.write(lineB)
# counter3=counter3+1
counter2=counter2+1
counter1=counter1+1
outsheet.write(" ]\n")
outsheet.write(" }\n")
outsheet.write("}\n")
if buildlist[0] == 'Coil':
coilpoints=[]
templine=[0,0,0]
q=0
while q < len(atomNumber):
if atomNumber[q] in buildlist[2]:
templine=[x[q], y[q], z[q]]
coilpoints.append(templine)
q=q+1
outcoil.write("Shape {\n")
outcoil.write(" appearance Appearance {\n")
outcoil.write(" material Material {\n")
outcoil.write(" emissiveColor 1.0 0.5 0.0\n")
outcoil.write(" }\n")
outcoil.write(" }\n")
outcoil.write(" geometry IndexedLineSet {\n")
outcoil.write(" coord Coordinate {\n")
outcoil.write(" point [\n")
counter=0
for item in coilpoints:
lineA=" %f %f %f,\n"%(item[0],item[1],item[2])
outcoil.write(lineA)
counter1=0
maxdistance=0
endpoints=[]
while counter1 < len(coilpoints):
counter2=0
while counter2 < len (coilpoints):
distance=math.sqrt((coilpoints[counter1][0]-coilpoints[counter2][0])**2+(coilpoints[counter1][1]-coilpoints[counter2][1])**2+(coilpoints[counter1][2]-coilpoints[counter2][2])**2)
if distance>maxdistance:
maxdistance=distance
endpoints=[counter1,counter2]
counter2=counter2+1
counter1=counter1+1
print endpoints
counter3=0
start=endpoints[0]
listofdistances=[]
sortedlistofdistances=[]
while counter3<len(coilpoints):
neighbordistance=math.sqrt((coilpoints[start][0]-coilpoints[counter3][0])**2+(coilpoints[start][1]-coilpoints[counter3][1])**2+(coilpoints[start][2]-coilpoints[counter3][2])**2)
listofdistances.append(neighbordistance)
sortedlistofdistances.append(neighbordistance)
counter3=counter3+1
sortedlistofdistances.sort()
sortedlistofdistances.pop(0)
connection=[]
connection.append(start)
counter4=0
while counter4<len(sortedlistofdistances):
comparedistance=sortedlistofdistances[counter4]
print comparedistance
print "versus"
counter5=0
while counter5<len(listofdistances):
print counter5 , listofdistances[counter5]
if comparedistance==listofdistances[counter5]:
print counter5,
print " is the same"
connection.append(counter5)
counter5=counter5+1
counter4=counter4+1
print connection
outcoil.write(" ]\n")
outcoil.write(" }\n")
outcoil.write(" coordIndex [\n")
coiltext=str(connection)
coiltext2=coiltext[1:-1]
lineS=" %s\n"%(coiltext2)
outcoil.write(lineS)
outcoil.write(" ]\n")
outcoil.write(" }\n")
outcoil.write("}\n")
"""
while counter4<len(coilpoints):
counter3=0
mindistance=999999
while counter3<len(coilpoints):
print excludelist, mindistance
if counter3 not in excludelist:
neighbordistance=math.sqrt((coilpoints[start][0]-coilpoints[counter3][0])**2+(coilpoints[start][1]-coilpoints[counter3][1])**2+(coilpoints[start][2]-coilpoints[counter3][2])**2)
print neighbordistance
if neighbordistance < mindistance:
mindistance=neighbordistance
start=counter3
print start
#start=nextpoint
counter3=counter3+1
excludelist.append(start)
counter4=counter4+1
print excludelist
text=str(excludelist)
"""
k=k+1
outcoil.close()
outsheet.close()
alphaAtoms.close()
betaAtoms.close()
chimera.openModels.open(sheetFile)
chimera.openModels.open(coilFile)
outDejavu.close()
outfile="helix-%s"%(inputfile)
if str(self.style.get())=='VRML':
cmdHH="dejavu2pdb.py helix.sse %s vrml helixColor=%s"%(outfile,helixColor)
outfile="helix-%s.wrl"%(inputPre)
else:
cmdHH="dejavu2pdb.py helix.sse %s"%(outfile)
os.system(cmdHH)
chimera.openModels.open(outfile)
