def createBinaryLink(fn):
""" Just create a link named .mrcs to Relion understand
that it is a binary stack file and not a volume.
"""
newFn = getUniqueFileName(fn, extension)
createLink(fn, newFn)
return newFn
def createChimeraScript(self, volume, pdb):
""" Create a chimera script to visualize a pseudoatoms pdb
obteined from a given EM 3d volume.
A property will be set in the pdb object to
store the location of the script.
"""
pseudoatoms = pdb.getFileName()
scriptFile = pseudoatoms + '_chimera.cmd'
pdb._chimeraScript = String(scriptFile)
sampling = volume.getSamplingRate()
radius = sampling * self.pseudoAtomRadius.get()
fnIn = volume.getFileName()
localInputFn = self._getBasePath(fnIn)
createLink(fnIn, localInputFn)
fhCmd = open(scriptFile, 'w')
fhCmd.write("open %s\n" % basename(pseudoatoms))
fhCmd.write("rangecol bfactor,a 0 white 1 red\n")
fhCmd.write("setattr a radius %f\n" % radius)
fhCmd.write("represent sphere\n")
fhCmd.write("open %s\n" % basename(localInputFn))
threshold = 0.01
if self.maskMode == NMA_MASK_THRE:
self.maskThreshold.get()
xdim = volume.getDim()[0]
origin = xdim / 2
fhCmd.write("volume #1 level %f transparency 0.5 voxelSize %f originIndex %d\n" % (threshold, sampling, origin))
fhCmd.close()
def processMovieStep(self, movieId, movieFn, *args):
movieFolder = self._getMovieFolder(movieId)
movieName = basename(movieFn)
#export SCIPION_DEBUG=1 # passwd=a
#startDebugger()
if self._filterMovie(movieId, movieFn):
makePath(movieFolder)
createLink(movieFn, join(movieFolder, movieName))
toDelete = [movieName]
if movieName.endswith('bz2'):
movieMrc = movieName.replace('.bz2', '') # we assume that if compressed the name ends with .mrc.bz2
toDelete.append(movieMrc)
if not exists(movieMrc):
self.runJob('bzip2', '-d -f %s' % movieName, cwd=movieFolder)
else:
movieMrc = movieName
self.info("Processing movie: %s" % movieMrc)
if movieMrc.endswith('.em'):
movieMrc = movieMrc + ":ems"
self._processMovie(movieId, movieMrc, movieFolder, *args)
if self.cleanMovieData:
cleanPath(movieFolder)
else:
self.info('Clean movie data DISABLED. Movie folder will remain in disk!!!')
def createBinaryLink(fn):
""" Just create a link named .mrcs to Relion understand
that it is a binary stack file and not a volume.
"""
newFn = join(outputDir, replaceBaseExt(fn, extension))
createLink(fn, newFn)
return newFn
def processMovieStep(self, movieId, movieFn, *args):
movieFolder = self._getMovieFolder(movieId)
movieName = basename(movieFn)
if self._filterMovie(movieId, movieFn):
makePath(movieFolder)
createLink(movieFn, join(movieFolder, movieName))
toDelete = [movieName]
if movieName.endswith('bz2'):
# We assume that if compressed the name ends with .mrc.bz2
movieMrc = movieName.replace('.bz2', '')
toDelete.append(movieMrc)
if not exists(movieMrc):
self.runJob('bzip2', '-d -f %s' % movieName, cwd=movieFolder)
elif movieName.endswith('tbz'):
# We assume that if compressed the name ends with .tbz
movieMrc = movieName.replace('.tbz', '.mrc')
toDelete.append(movieMrc)
if not exists(movieMrc):
self.runJob('tar', 'jxf %s' % movieName, cwd=movieFolder)
else:
movieMrc = movieName
self.info("Processing movie: %s" % movieMrc)
self._processMovie(movieId, movieMrc, movieFolder, *args)
if self.cleanMovieData:
print "erasing.....movieFolder: ", movieFolder
os.system('rm -rf %s' % movieFolder)
# cleanPath(movieFolder)
else:
self.info('Clean movie data DISABLED. Movie folder will remain in disk!!!')
def createChimeraScript(self, volume, pdb):
""" Create a chimera script to visualize a pseudoatoms pdb
obteined from a given EM 3d volume.
A property will be set in the pdb object to
store the location of the script.
"""
pseudoatoms = pdb.getFileName()
scriptFile = pseudoatoms + '_chimera.cmd'
pdb._chimeraScript = String(scriptFile)
sampling = volume.getSamplingRate()
radius = sampling * self.pseudoAtomRadius.get()
fnIn = volume.getFileName()
localInputFn = self._getBasePath(fnIn)
createLink(fnIn, localInputFn)
fhCmd = open(scriptFile, 'w')
fhCmd.write("open %s\n" % basename(pseudoatoms))
fhCmd.write("rangecol bfactor,a 0 white 1 red\n")
fhCmd.write("setattr a radius %f\n" % radius)
fhCmd.write("represent sphere\n")
fhCmd.write("open %s\n" % basename(localInputFn))
threshold = 0.01
if self.maskMode == NMA_MASK_THRE:
self.maskThreshold.get()
xdim = volume.getDim()[0]
origin = xdim / 2
fhCmd.write(
"volume #1 level %f transparency 0.5 voxelSize %f originIndex %d\n"
% (threshold, sampling, origin))
fhCmd.close()
def convertToPseudoAtomsStep(self, inputStructure, fnIn, fnMask, prefix):
XmippProtConvertToPseudoAtomsBase.convertToPseudoAtomsStep(self, fnIn,
fnMask,
prefix)
self.createChimeraScriptStep(inputStructure, fnIn, prefix)
createLink(self._getPath("pseudoatoms%s.pdb" % prefix),
self._getPath("pseudoatoms.pdb"))
def linkMrcToMrcs(fn):
""" Just create a link named .mrc to Eman understand
that it is a mrc binary stack.
"""
newFn = join(outputDir, replaceBaseExt(fn, 'mrcs'))
createLink(fn, newFn)
return newFn
def linkMrcToMrcs(fn):
""" Just create a link named .mrc to Eman understand
that it is a mrc binary stack.
"""
newFn = join(outputDir, replaceBaseExt(fn, 'mrcs'))
createLink(fn, newFn)
return newFn
def _processMovie(self, movieId, movieName, movieFolder):
"""call program here"""
# if not mrc convert format to mrc
# special case is mrc but ends in mrcs
inMovieName = os.path.join(movieFolder, movieName)
if movieName.endswith(".mrc"):
movieNameAux = inMovieName
elif movieName.endswith(".mrcs"):
movieNameAux = pwutils.replaceExt(inMovieName, "mrc")
createLink(inMovieName, movieNameAux)
movieNameAux = pwutils.replaceExt(movieName, "mrc")
else:
micFnMrc = pwutils.replaceExt(inMovieName, "mrc")
ImageHandler().convert(inMovieName, micFnMrc, DT_FLOAT)
movieNameAux = pwutils.replaceExt(movieName, "mrc")
# get number of frames
if self.alignFrameRange == -1:
numberOfFramesPerMovie = self.inputMovies.get().getDimensions()[3]
else:
numberOfFramesPerMovie = self.alignFrameRange.get()
doApplyDoseFilter = self.doApplyDoseFilter.get()
exposurePerFrame = self.exposurePerFrame.get()
self._argsUnblur(
movieNameAux, movieFolder, movieId, numberOfFramesPerMovie, doApplyDoseFilter, exposurePerFrame
)
try:
self.runJob(self._program, self._args, cwd=movieFolder)
except:
print("ERROR: Movie %s failed\n" % movieName)
logFile = self._getLogFile(movieId)
def createBinaryLink(fn):
""" Just create a link named .mrcs to Relion understand
that it is a binary stack file and not a volume.
"""
newFn = getUniqueFileName(fn, extension)
createLink(fn, newFn)
return newFn
def copyPdbStep(self, inputFn, localFn, isEM):
""" Copy the input pdb file and also create a link 'atoms.pdb' """
copyFile(inputFn, localFn)
if isEM:
fnOut=self._getPath('pseudoatoms.pdb')
else:
fnOut=self._getPath('atoms.pdb')
if not os.path.exists(fnOut):
createLink(localFn, fnOut)
def copyPdbStep(self, inputFn, localFn, isEM):
""" Copy the input pdb file and also create a link 'atoms.pdb' """
copyFile(inputFn, localFn)
if isEM:
fnOut = self._getPath('pseudoatoms.pdb')
else:
fnOut = self._getPath('atoms.pdb')
if not os.path.exists(fnOut):
createLink(localFn, fnOut)
def importMicrographs(self, pattern, suffix, voltage, sphericalAberration,
amplitudeContrast):
""" Copy images matching the filename pattern
Register other parameters.
"""
filePaths = glob(expandPattern(pattern))
#imgSet = SetOfMicrographs(filename=self.micsPairsSqlite, prefix=suffix)
imgSet = self._createSetOfMicrographs(suffix=suffix)
acquisition = imgSet.getAcquisition()
# Setting Acquisition properties
acquisition.setVoltage(voltage)
acquisition.setSphericalAberration(sphericalAberration)
acquisition.setAmplitudeContrast(amplitudeContrast)
# Call a function that should be implemented by each subclass
self._setOtherPars(imgSet)
outFiles = [imgSet.getFileName()]
imgh = ImageHandler()
img = imgSet.ITEM_TYPE()
n = 1
size = len(filePaths)
filePaths.sort()
for i, fn in enumerate(filePaths):
# ext = os.path.splitext(basename(f))[1]
dst = self._getExtraPath(basename(fn))
if self.copyToProj:
copyFile(fn, dst)
else:
createLink(fn, dst)
if n > 1:
for index in range(1, n + 1):
img.cleanObjId()
img.setFileName(dst)
img.setIndex(index)
imgSet.append(img)
else:
img.cleanObjId()
img.setFileName(dst)
# Fill the micName if img is a Micrograph.
self._fillMicName(img, fn, pattern)
imgSet.append(img)
outFiles.append(dst)
sys.stdout.write("\rImported %d/%d" % (i + 1, size))
sys.stdout.flush()
print "\n"
imgSet.write()
return imgSet
def importMicrographs(self, pattern, suffix, voltage, sphericalAberration, amplitudeContrast):
""" Copy images matching the filename pattern
Register other parameters.
"""
filePaths = glob(expandPattern(pattern))
#imgSet = SetOfMicrographs(filename=self.micsPairsSqlite, prefix=suffix)
imgSet = self._createSetOfMicrographs(suffix=suffix)
acquisition = imgSet.getAcquisition()
# Setting Acquisition properties
acquisition.setVoltage(voltage)
acquisition.setSphericalAberration(sphericalAberration)
acquisition.setAmplitudeContrast(amplitudeContrast)
# Call a function that should be implemented by each subclass
self._setOtherPars(imgSet)
outFiles = [imgSet.getFileName()]
imgh = ImageHandler()
img = imgSet.ITEM_TYPE()
n = 1
size = len(filePaths)
filePaths.sort()
for i, fn in enumerate(filePaths):
# ext = os.path.splitext(basename(f))[1]
dst = self._getExtraPath(basename(fn))
if self.copyToProj:
copyFile(fn, dst)
else:
createLink(fn, dst)
if n > 1:
for index in range(1, n+1):
img.cleanObjId()
img.setFileName(dst)
img.setIndex(index)
imgSet.append(img)
else:
img.cleanObjId()
img.setFileName(dst)
# Fill the micName if img is a Micrograph.
self._fillMicName(img, fn, pattern)
imgSet.append(img)
outFiles.append(dst)
sys.stdout.write("\rImported %d/%d" % (i+1, size))
sys.stdout.flush()
print "\n"
imgSet.write()
return imgSet
def copyOrLinkFileName(imgRow, prefixDir, outputDir, copyFiles=False):
index, imgPath = relionToLocation(imgRow.getValue(md.RLN_IMAGE_NAME))
baseName = os.path.basename(imgPath)
newName = os.path.join(outputDir, baseName)
if not os.path.exists(newName):
if copyFiles:
copyFile(os.path.join(prefixDir, imgPath), newName)
else:
createLink(os.path.join(prefixDir, imgPath), newName)
imgRow.setValue(md.RLN_IMAGE_NAME, locationToRelion(index, newName))
def copyOrLinkFileName(imgRow, prefixDir, outputDir, copyFiles=False):
index, imgPath = relionToLocation(imgRow.getValue(md.RLN_IMAGE_NAME))
baseName = os.path.basename(imgPath)
newName = os.path.join(outputDir, baseName)
if not os.path.exists(newName):
if copyFiles:
copyFile(os.path.join(prefixDir, imgPath), newName)
else:
createLink(os.path.join(prefixDir, imgPath), newName)
imgRow.setValue(md.RLN_IMAGE_NAME, locationToRelion(index, newName))
def sitemapStep(self):
prog = Plugin.getHome('sitemap')
fnIn = self._getExtraPath(
"atomStructIn") + self.inputStructure.get().getExtension()
createLink(self.inputStructure.get().getFileName(), fnIn)
fnIn = os.path.join('extra', os.path.split(fnIn)[1])
args = '-WAIT -prot %s -j job -keeplogs -keepeval' % fnIn
args += " -maxsites %d" % self.maxsites.get()
self.runJob(prog, args, cwd=self._getPath())
def preparationStep(self):
if isinstance(self.inputStructure.get(),AtomStruct):
fnIn = self._getExtraPath("atomStructIn.pdb")
aStruct1 = AtomicStructHandler(self.inputStructure.get().getFileName())
aStruct1.write(fnIn)
fnIn='extra/atomStructIn.pdb'
else:
fnIn = self._getExtraPath("atomStructIn.mae")
createLink(self.inputStructure.get().getFileName(),fnIn)
fnIn='extra/atomStructIn.mae'
self.runJob(schrodinger_plugin.getHome('maestro'), "-b %s"%fnIn, cwd=self._getPath())
def copyFastaSequenceAndRead(protocol):
outFileName = protocol._getExtraPath("sequence.fasta")
if isinstance(protocol.inputSeq.get(), Sequence):
fh = open(outFileName, "w")
fh.write(">%s\n" % protocol.inputSeq.get().getSeqName())
fh.write("%s\n" % protocol.inputSeq.get().getSequence())
fh.close()
elif isinstance(protocol.inputSeq.get(), SetOfDatabaseID):
obj = protocol.inputSeq.get().getFirstItem()
createLink(obj._uniprotFile.get(), outFileName)
record = SeqIO.read(outFileName, "fasta")
return str(record.seq)
def dockStep(self, fnGridDir, fnSmall):
fnReceptor = os.path.join(fnGridDir, "atomStruct.pdbqt")
fnBase = os.path.splitext(os.path.split(fnSmall)[1])[0]
fnSmallDir = self._getExtraPath(fnBase)
makePath(fnSmallDir)
fnDPF = os.path.join(fnSmallDir, fnBase + ".dpf")
args = " -l %s -r %s -o %s" % (fnSmall, fnReceptor, fnDPF)
args += " -p ga_pop_size=%d" % self.gaPop.get()
args += " -p ga_num_evals=%d" % self.gaNumEvals.get()
args += " -p ga_num_generations=%d" % self.gaNumGens.get()
args += " -p ga_elitism=%d" % self.gaElitism.get()
args += " -p ga_mutation_rate=%f" % self.gaMutationRate.get()
args += " -p ga_crossover_rate=%f" % self.gaCrossOverRate.get()
args += " -p ga_window_size=%d" % self.gaWindowSize.get()
args += " -p sw_max_its=%d" % self.swMaxIts.get()
args += " -p sw_max_succ=%d" % self.swMaxSucc.get()
args += " -p sw_max_fail=%d" % self.swMaxFail.get()
args += " -p sw_rho=%f" % self.swRho.get()
args += " -p sw_lb_rho=%d" % self.swLbRho.get()
args += " -p ls_search_freq=%f" % self.lsFreq.get()
args += " -p ga_run=%d" % self.gaRun.get()
args += " -p rmstol=%f" % self.rmsTol.get()
self.runJob(
bioinformatics_plugin.getMGLPath('bin/pythonsh'),
bioinformatics_plugin.getADTPath('Utilities24/prepare_dpf42.py') +
args)
fnSmallLocal = os.path.split(fnSmall)[1]
createLink(fnSmall, os.path.join(fnSmallDir, fnSmallLocal))
createLink(fnReceptor, os.path.join(fnSmallDir, "atomStruct.pdbqt"))
args = " -r atomStruct.pdbqt -l %s -o library.gpf" % fnSmallLocal
self.runJob(
bioinformatics_plugin.getMGLPath('bin/pythonsh'),
bioinformatics_plugin.getADTPath('Utilities24/prepare_gpf4.py') +
args,
cwd=fnSmallDir)
args = "-p library.gpf -l library.glg"
self.runJob(bioinformatics_plugin.getAutodockPath("autogrid4"),
args,
cwd=fnSmallDir)
args = "-p %s.dpf -l %s.dlg" % (fnBase, fnBase)
self.runJob(bioinformatics_plugin.getAutodockPath("autodock4"),
args,
cwd=fnSmallDir)
# Clean a bit
cleanPattern(os.path.join(fnSmallDir, "atomStruct.*.map"))
def continueStep(self, iterN):
"""Create a symbolic link of a previous iteration from a previous run."""
iterN -= 1
continueRun = self.continueRun.get()
self._createWorkingDirs()
# link particles
prevStack = continueRun._getFileName('run_stack', run=0)
currStack = self._getFileName('run_stack', run=0)
createLink(continueRun._getExtraPath(prevStack),
self._getExtraPath(currStack))
# link params & cls
for fn in ['iter_par', 'iter_cls']:
prevParam = continueRun._getFileName(fn, iter=iterN)
currParam = self._getFileName(fn, iter=iterN)
createLink(continueRun._getExtraPath(prevParam),
self._getExtraPath(currParam))
def _insertAllSteps(self):
self._params = {}
# diameter must be passed in Armstrongs and therefore should be converted
self._params['diam'] = self.diameter.get() * self.getInputMicrographs().getSamplingRate()
# self._params['num-slices'] = self.numberSizes.get()
# self._params['size-range'] = self.sizeRange.get()
self._params['apix'] = self.inputMicrographs.get().getSamplingRate()
self._params['thresh'] = self.threshold.get()
# self._params['max-thresh'] = self.maxThreshold.get()
# self._params['max-area'] = self.maxArea.get()
# self._params['max-peaks'] = self.maxPeaks.get()
args = ""
for par, val in self._params.iteritems():
args += " --%s=%s" % (par, str(val))
if self.invert:
args += " --invert"
args += " " + self.extraParams.get('')
deps = [] # Store all steps ids, final step createOutput depends on all of them
ih = ImageHandler()
for mic in self.inputMicrographs.get():
# Create micrograph folder
micName = mic.getFileName()
micDir = self._getTmpPath(removeBaseExt(micName))
makePath(micDir)
# If needed convert micrograph to mrc format, otherwise link it
if getExt(micName) != ".mrc":
fnMicBase = replaceBaseExt(micName, 'mrc')
inputMic = join(micDir, fnMicBase)
ih.convert(mic.getLocation(), inputMic)
else:
inputMic = join(micDir, basename(micName))
createLink(micName, inputMic)
# Insert step to execute program
stepId = self._insertFunctionStep('executeDogpickerStep', inputMic, args)
deps.append(stepId)
self._insertFinalSteps(deps)
def _insertAllSteps(self):
self._params = {}
# diameter must be passed in Angstrongs and therefore should be converted
self._params['diam'] = self.diameter.get() * self.getInputMicrographs().getSamplingRate()
# self._params['num-slices'] = self.numberSizes.get()
# self._params['size-range'] = self.sizeRange.get()
self._params['apix'] = self.inputMicrographs.get().getSamplingRate()
self._params['thresh'] = self.threshold.get()
# self._params['max-thresh'] = self.maxThreshold.get()
# self._params['max-area'] = self.maxArea.get()
# self._params['max-peaks'] = self.maxPeaks.get()
args = ""
for par, val in self._params.iteritems():
args += " --%s=%s" % (par, str(val))
if self.invert:
args += " --invert"
args += " " + self.extraParams.get('')
deps = [] # Store all steps ids, final step createOutput depends on all of them
ih = ImageHandler()
for mic in self.inputMicrographs.get():
# Create micrograph folder
micName = mic.getFileName()
micDir = self._getTmpPath(removeBaseExt(micName))
makePath(micDir)
# If needed convert micrograph to mrc format, otherwise link it
if getExt(micName) != ".mrc":
fnMicBase = replaceBaseExt(micName, 'mrc')
inputMic = join(micDir, fnMicBase)
ih.convert(mic.getLocation(), inputMic)
else:
inputMic = join(micDir, basename(micName))
createLink(micName, inputMic)
# Insert step to execute program
stepId = self._insertFunctionStep('executeDogpickerStep', inputMic, args)
deps.append(stepId)
self._insertFinalSteps(deps)
def preparationStep(self):
if isinstance(self.inputStructure.get(), AtomStruct):
fnIn = self._getExtraPath("atomStructIn.pdb")
aStruct1 = AtomicStructHandler(
self.inputStructure.get().getFileName())
aStruct1.write(fnIn)
fnIn = 'extra/atomStructIn.pdb'
self.runJob(schrodinger_plugin.getHome('maestro'),
"-b %s" % fnIn,
cwd=self._getPath())
else:
fnIn = self._getExtraPath(
"atomStructIn") + self.inputStructure.get().getExtension()
createLink(self.inputStructure.get().getFileName(), fnIn)
fnIn = os.path.join('extra', os.path.split(fnIn)[1])
self.runJob(schrodinger_plugin.getHome('maestro'),
"-m %s" % fnIn,
cwd=self._getPath())
def crysolWrapper(self):
experimentalSAXS=""
if self.experimentalSAXS.get()!="":
experimentalSAXS=os.path.abspath(self.experimentalSAXS.get())
inputStructure=os.path.abspath(self.inputStructure.get().getFileName())
self._enterWorkingDir()
if experimentalSAXS!="":
createLink(experimentalSAXS,'experimental_SAXS_curve.dat')
experimentalSAXS='experimental_SAXS_curve.dat'
createLink(inputStructure,'pseudoatoms.pdb')
self.runJob("crysol",
"pseudoatoms.pdb %s /lm %d /sm %f /ns %d %s"%(experimentalSAXS,self.numberOfHarmonics.get(),
self.maximumFrequency.get(),self.numberOfSamples.get(),
self.otherCrysol.get()))
self.runJob("mv","*log *txt extra")
if experimentalSAXS=="":
self.runJob("mv","*alm extra")
self._leaveWorkingDir()
def _processMovie(self, movieId, movieName, movieFolder):
# if not mrc convert format to mrc
# special case is mrc but ends in mrcs
moviePath = os.path.join(movieFolder, movieName)
movieNameMrc = pwutils.replaceExt(movieName, "mrc")
moviePathMrc = pwutils.replaceExt(moviePath, "mrc")
ih = ImageHandler()
if movieName.endswith('.mrc'):
pass # Do nothing
elif movieName.endswith('.mrcs'):
# Create a link to the mrc or mrcs file but with .mrc extension
createLink(moviePath, moviePathMrc)
else:
# Convert to mrc if the movie is in other format
ih.convert(moviePath, moviePathMrc, DT_FLOAT)
_, _, z, n = ih.getDimensions(moviePathMrc)
numberOfFrames = max(z, n) # Deal with mrc ambiguity
# Write dummy auxiliary shift file.
# TODO: this should be done properly when we define
# how to transfer between movies
shiftFnName = os.path.join(movieFolder, self._getShiftFnName(movieId))
f = open(shiftFnName, 'w')
shift = ("0 " * numberOfFrames + "\n") * 2
f.write(shift)
f.close()
if self.alignFrameRange != -1:
if self.alignFrameRange > numberOfFrames:
raise Exception('Frame number (%d) is greater than '
'the total frames of the movie (%d)' %
(numberOfFrames, self.alignFrameRange))
numberOfFrames = self.alignFrameRange.get()
self._argsSummovie(movieNameMrc, movieFolder, movieId, numberOfFrames)
try:
self.runJob(self._program, self._args, cwd=movieFolder)
except:
print("ERROR: Movie %s failed\n" % movieName)
logFile = self._getLogFile(movieId)
def _processMovie(self, movieId, movieName, movieFolder):
# if not mrc convert format to mrc
# special case is mrc but ends in mrcs
moviePath = os.path.join(movieFolder, movieName)
movieNameMrc = pwutils.replaceExt(movieName, "mrc")
moviePathMrc = pwutils.replaceExt(moviePath, "mrc")
ih = ImageHandler()
if movieName.endswith('.mrc'):
pass # Do nothing
elif movieName.endswith('.mrcs'):
# Create a link to the mrc or mrcs file but with .mrc extension
createLink(moviePath, moviePathMrc)
else:
# Convert to mrc if the movie is in other format
ih.convert(moviePath, moviePathMrc, DT_FLOAT)
_, _, z, n = ih.getDimensions(moviePathMrc)
numberOfFrames = max(z, n) # Deal with mrc ambiguity
# Write dummy auxiliary shift file.
# TODO: this should be done properly when we define
# how to transfer between movies
shiftFnName = os.path.join(movieFolder, self._getShiftFnName(movieId))
f = open(shiftFnName,'w')
shift = ("0 " * numberOfFrames + "\n" ) * 2
f.write(shift)
f.close()
if self.alignFrameRange != -1:
if self.alignFrameRange > numberOfFrames:
raise Exception('Frame number (%d) is greater than '
'the total frames of the movie (%d)' %
(numberOfFrames, self.alignFrameRange))
numberOfFrames = self.alignFrameRange.get()
self._argsSummovie(movieNameMrc, movieFolder, movieId, numberOfFrames)
try:
self.runJob(self._program, self._args, cwd=movieFolder)
except:
print("ERROR: Movie %s failed\n"%movieName)
logFile = self._getLogFile(movieId)
def crysolWrapper(self):
experimentalSAXS = ""
if self.experimentalSAXS.get() != "":
experimentalSAXS = os.path.abspath(self.experimentalSAXS.get())
inputStructure = os.path.abspath(
self.inputStructure.get().getFileName())
self._enterWorkingDir()
if experimentalSAXS != "":
createLink(experimentalSAXS, 'experimental_SAXS_curve.dat')
experimentalSAXS = 'experimental_SAXS_curve.dat'
createLink(inputStructure, 'pseudoatoms.pdb')
self.runJob(
CRYSOL, "pseudoatoms.pdb %s /lm %d /sm %f /ns %d %s" %
(experimentalSAXS, self.numberOfHarmonics, self.maximumFrequency,
self.numberOfSamples, self.otherCrysol))
self.runJob("mv", "*log *txt extra")
if experimentalSAXS == "":
self.runJob("mv", "*alm extra")
self._leaveWorkingDir()
def _processMovie(self, movieId, movieName, movieFolder):
"""call program here"""
# if not mrc convert format to mrc
# special case is mrc but ends in mrcs
inMovieName = os.path.join(movieFolder, movieName)
if movieName.endswith(".mrc"):
movieNameAux = inMovieName
elif movieName.endswith(".mrcs"):
movieNameAux = pwutils.replaceExt(inMovieName, "mrc")
createLink(inMovieName, movieNameAux)
movieNameAux = pwutils.replaceExt(movieName, "mrc")
else:
micFnMrc = pwutils.replaceExt(inMovieName, "mrc")
ImageHandler().convert(inMovieName, micFnMrc, DT_FLOAT)
movieNameAux = pwutils.replaceExt(movieName, "mrc")
# get number of frames
if self.alignFrameRange == -1:
numberOfFramesPerMovie = self.inputMovies.get().getDimensions()[3]
else:
numberOfFramesPerMovie = self.alignFrameRange.get()
# write dummy auxiliary shift file.
# TODO: this should be done properly when we define how to transfer shift
# between movies
shiftFnName = os.path.join(movieFolder, self._getShiftFnName(movieId))
f = open(shiftFnName, "w")
shift = ("0 " * numberOfFramesPerMovie + "\n") * 2
f.write(shift)
f.close()
doApplyDoseFilter = self.doApplyDoseFilter.get()
exposurePerFrame = self.exposurePerFrame.get()
self._argsSummovie(
movieNameAux, movieFolder, movieId, numberOfFramesPerMovie, doApplyDoseFilter, exposurePerFrame
)
try:
self.runJob(self._program, self._args, cwd=movieFolder)
except:
print("ERROR: Movie %s failed\n" % movieName)
logFile = self._getLogFile(movieId)
def prepareGrid(self, fnSite, fnTarget):
n = fnSite.split('@')[0]
args = schrodinger_plugin.getPluginHome('utils/schrodingerUtils.py') + " centroid %s %s" % \
(fnSite, self._getTmpPath("centroid.txt"))
schrodinger_plugin.runSchrodinger(self, "python3", args)
fh = open(self._getTmpPath("centroid.txt"))
line = fh.readline()
fh.close()
x, y, z = line.split()
fnGridDir = "grid-%s" % n
makePath(self._getPath(fnGridDir))
fnTargetLocal = self._getPath("%s/%s.maegz" % (fnGridDir, fnGridDir))
createLink(fnTarget, fnTargetLocal)
fnJob = self._getPath('%s/%s.inp' % (fnGridDir, fnGridDir))
fh = open(fnJob, 'w')
fh.write("GRIDFILE %s.zip\n" % fnGridDir)
fh.write("OUTPUTDIR %s\n" % fnGridDir)
fh.write("RECEP_FILE %s.maegz\n" % fnGridDir)
fh.write("REC_MAECHARGES True\n")
fh.write("HBOND_DONOR_AROMH %s\n" % self.HbondDonorAromH.get())
if self.HbondDonorAromH.get():
fh.write("HBOND_DONOR_AROMH_CHARGE %f\n" %
self.HbondDonorAromHCharge.get())
fh.write("HBOND_ACCEP_HALO %s\n" % self.HbondAcceptHalo.get())
fh.write("HBOND_DONOR_HALO %s\n" % self.HbondDonorHalo.get())
fh.write("INNERBOX %d,%d,%d\n" %
(self.innerX.get(), self.innerY.get(), self.innerZ.get()))
fh.write("ACTXRANGE %d\n" % self.outerX.get())
fh.write("ACTYRANGE %d\n" % self.outerY.get())
fh.write("ACTZRANGE %d\n" % self.outerZ.get())
fh.write("OUTERBOX %d,%d,%d\n" %
(self.outerX.get(), self.outerY.get(), self.outerZ.get()))
fh.write("GRID_CENTER %s,%s,%s\n" % (x, y, z))
fh.close()
args = "-WAIT -LOCAL -NJOBS %d %s.inp" % (self.numberOfThreads.get(),
fnGridDir)
self.runJob(schrodinger_plugin.getHome('glide'),
args,
cwd=self._getPath(fnGridDir))
def primeStep(self):
prog=Plugin.getHome('prime')
fnInputStructure = self.inputStructure.get().getFileName()
fnIn=self._getPath("atomStructIn")+self.inputStructure.get().getExtension()
createLink(fnInputStructure,fnIn)
fnIn=os.path.split(fnIn)[1]
fhJob = open(self._getPath('job.inp'),'w')
fhJob.write("STRUCT_FILE %s\n" % fnIn)
if self.operation.get()==0:
# Side chain prediction
fhJob.write("PRIME_TYPE SIDE_PRED\n")
fhJob.write("SELECT pick\n")
i=0
for residue in self.residueList.get().split(','):
fhJob.write("RESIDUE_%d %s\n"%(i,residue.strip()))
i+=1
elif self.operation.get()==1:
# Minimization of all hydrogens
fhJob.write("PRIME_TYPE REAL_MIN\n")
fhJob.write("SELECT asl = (atom.ele H)\n")
elif self.operation.get()==2:
# Loop prediction
fhJob.write("PRIME_TYPE LOOP_BLD\n")
fhJob.write("LOOP_0_RES_0 %s\n"%self.residueFirst.get())
fhJob.write("LOOP_0_RES_1 %s\n"%self.residueLast.get())
fhJob.write("RES_SPHERE %f\n"%self.resSphere.get())
fhJob.write("MIN_OVERLAP %f\n"%self.minOverlap.get())
fhJob.write("USE_CRYSTAL_SYMMETRY no\n")
fhJob.write("USE_RANDOM_SEED no\n")
fhJob.write("SEED 0\n")
fhJob.write("EXT_DIEL 80.00\n")
fhJob.write("USE_MEMBRANE no\n")
fhJob.close()
args='-WAIT -LOCAL job.inp'
self.runJob(prog,args,cwd=self._getPath())
def _preprocessMicrographRow(self, img, imgRow):
if self._imgPath:
# Create a link or copy files to extraPath
# and update the Row properly
micFile = imgRow.getValue(md.MDL_MICROGRAPH)
micBase = basename(micFile)
micDst = self.protocol._getExtraPath(micBase)
self.copyOrLink(join(self._imgPath, micFile), micDst)
imgRow.setValue(md.MDL_MICROGRAPH, micDst)
self._fillMicName(img, micBase)
if self._ctfPath:
# Read Xmipp ctfModel parameters and add
# to the original micrograph row
ctfFile = imgRow.getValue(md.MDL_CTF_MODEL)
ctfPath = join(self._imgPath, ctfFile)
ctfRow = md.Row()
ctfRow.readFromFile(ctfPath)
imgRow.copyFromRow(ctfRow)
# Also copy or link to the result micrograph
# folder output by Xmipp containing the PSD and other images
ctfSrcDir = dirname(ctfPath)
ctfBaseDir = basename(ctfSrcDir)
ctfDstDir = self.protocol._getExtraPath(ctfBaseDir)
if self.copyOrLink == createLink:
createLink(ctfSrcDir, ctfDstDir)
else: # use copyTree instead of copyFile
copyTree(ctfSrcDir, ctfDstDir)
# Fix the path to psd files
for label in CTF_PSD_DICT.values():
filePath = imgRow.getValue(label)
# Take the last part of the path including
# the filename and the folder up to that
fileName = basename(filePath)
newFilePath = join(ctfDstDir, fileName)
imgRow.setValue(label, newFilePath)
def _preprocessMicrographRow(self, img, imgRow):
if self._imgPath:
# Create a link or copy files to extraPath
# and update the Row properly
micFile = imgRow.getValue(md.MDL_MICROGRAPH)
micBase = basename(micFile)
micDst = self.protocol._getExtraPath(micBase)
self.copyOrLink(join(self._imgPath, micFile), micDst)
imgRow.setValue(md.MDL_MICROGRAPH, micDst)
self._fillMicName(img, micBase)
if self._ctfPath:
# Read Xmipp ctfModel parameters and add
# to the original micrograph row
ctfFile = imgRow.getValue(md.MDL_CTF_MODEL)
ctfPath = join(self._imgPath, ctfFile)
ctfRow = md.Row()
ctfRow.readFromFile(ctfPath)
imgRow.copyFromRow(ctfRow)
# Also copy or link to the result micrograph
# folder output by Xmipp containing the PSD and other images
ctfSrcDir = dirname(ctfPath)
ctfBaseDir = basename(ctfSrcDir)
ctfDstDir = self.protocol._getExtraPath(ctfBaseDir)
if self.copyOrLink == createLink:
createLink(ctfSrcDir, ctfDstDir)
else: # use copyTree instead of copyFile
copyTree(ctfSrcDir, ctfDstDir)
# Fix the path to psd files
for label in CTF_PSD_DICT.values():
filePath = imgRow.getValue(label)
# Take the last part of the path including
# the filename and the folder up to that
fileName = basename(filePath)
newFilePath = join(ctfDstDir, fileName)
imgRow.setValue(label, newFilePath)
def _processMovie(self, movieId, movieName, movieFolder):
# if not mrc convert format to mrc
# special case is mrc but ends in mrcs
moviePath = os.path.join(movieFolder, movieName)
movieNameMrc = pwutils.replaceExt(movieName, "mrc")
moviePathMrc = pwutils.replaceExt(moviePath, "mrc")
ih = ImageHandler()
if movieName.endswith('.mrc'):
pass # Do nothing
elif movieName.endswith('.mrcs'):
# Create a link to the mrc or mrcs file but with .mrc extension
createLink(moviePath, moviePathMrc)
else:
# Convert to mrc if the movie is in other format
ih.convert(moviePath, moviePathMrc, DT_FLOAT)
_, _, z, n = ih.getDimensions(moviePathMrc)
numberOfFrames = max(z, n) # Deal with mrc ambiguity
if self.alignFrameRange != -1:
if self.alignFrameRange > numberOfFrames:
raise Exception('Frame number (%d) is greater than '
'the total frames of the movie (%d)' %
(numberOfFrames, self.alignFrameRange))
numberOfFrames = self.alignFrameRange.get()
self._argsUnblur(movieNameMrc, movieFolder, movieId, numberOfFrames)
try:
self.runJob(self._program, self._args, cwd=movieFolder)
except:
print("ERROR: Movie %s failed\n" % movieName)
logFile = self._getLogFile(movieId)
def _processMovie(self, movieId, movieName, movieFolder):
# if not mrc convert format to mrc
# special case is mrc but ends in mrcs
moviePath = os.path.join(movieFolder, movieName)
movieNameMrc = pwutils.replaceExt(movieName, "mrc")
moviePathMrc = pwutils.replaceExt(moviePath, "mrc")
ih = ImageHandler()
if movieName.endswith('.mrc'):
pass # Do nothing
elif movieName.endswith('.mrcs'):
# Create a link to the mrc or mrcs file but with .mrc extension
createLink(moviePath, moviePathMrc)
else:
# Convert to mrc if the movie is in other format
ih.convert(moviePath, moviePathMrc, DT_FLOAT)
_, _, z, n = ih.getDimensions(moviePathMrc)
numberOfFrames = max(z, n) # Deal with mrc ambiguity
if self.alignFrameRange != -1:
if self.alignFrameRange > numberOfFrames:
raise Exception('Frame number (%d) is greater than '
'the total frames of the movie (%d)' %
(numberOfFrames, self.alignFrameRange))
numberOfFrames = self.alignFrameRange.get()
self._argsUnblur(movieNameMrc, movieFolder, movieId, numberOfFrames)
try:
self.runJob(self._program, self._args, cwd=movieFolder)
except:
print("ERROR: Movie %s failed\n" % movieName)
logFile = self._getLogFile(movieId)
def createLinkSteps(self):
continueRun = self.continueRun.get()
prevPartDir = continueRun._getExtraPath("particles")
currPartDir = self._getExtraPath("particles")
runN = self._getRun() - 1 if not Plugin.isVersion('2.91') else self._getRun()
prevRefDir = continueRun._getExtraPath("refine_%02d" % runN)
currRefDir = self._getExtraPath("refine_%02d" % runN)
prevSetsDir = continueRun._getExtraPath("sets")
currSetsDir = self._getExtraPath("sets")
createLink(prevPartDir, currPartDir)
createLink(prevRefDir, currRefDir)
createLink(prevSetsDir, currSetsDir)
def createLinkSteps(self):
continueRun = self.continueRun.get()
prevPartDir = continueRun._getExtraPath("particles")
currPartDir = self._getExtraPath("particles")
runN = self._getRun()
prevRefDir = continueRun._getExtraPath("r2d_%02d" % (runN - 1))
currRefDir = self._getExtraPath("r2d_%02d" % (runN - 1))
prevSetsDir = continueRun._getExtraPath("sets")
currSetsDir = self._getExtraPath("sets")
createLink(prevPartDir, currPartDir)
createLink(prevRefDir, currRefDir)
createLink(prevSetsDir, currSetsDir)
def createLinkSteps(self):
continueRun = self.continueRun.get()
prevPartDir = continueRun._getExtraPath("particles")
currPartDir = self._getExtraPath("particles")
runN = self._getRun() - 1
prevRefDir = continueRun._getExtraPath("refine_%02d" % runN)
currRefDir = self._getExtraPath("refine_%02d" % runN)
prevSetsDir = continueRun._getExtraPath("sets")
currSetsDir = self._getExtraPath("sets")
# createLink(prevInfoDir, currInfoDir)
createLink(prevPartDir, currPartDir)
createLink(prevRefDir, currRefDir)
createLink(prevSetsDir, currSetsDir)
def createLinkSteps(self):
continueRun = self.continueRun.get()
prevPartDir = continueRun._getExtraPath("particles")
currPartDir = self._getExtraPath("particles")
runN = self._getRun() - 1
prevRefDir = continueRun._getExtraPath("refine_%02d" % runN)
currRefDir = self._getExtraPath("refine_%02d" % runN)
prevSetsDir = continueRun._getExtraPath("sets")
currSetsDir = self._getExtraPath("sets")
# createLink(prevInfoDir, currInfoDir)
createLink(prevPartDir, currPartDir)
createLink(prevRefDir, currRefDir)
createLink(prevSetsDir, currSetsDir)
def evaluateDeformationsStep(self):
N = self.inputStructures.get().getSize()
import numpy
distances = numpy.zeros([N, N])
for volCounter in range(1, N + 1):
pdb1 = open(
self._getPath('pseudoatoms_%02d.pdb' % volCounter)).readlines()
for volCounter2 in range(1, N + 1):
if volCounter != volCounter2:
davg = 0.
Navg = 0.
pdb2 = open(self._getExtraPath('alignment_%02d_%02d.pdb' % (
volCounter, volCounter2))).readlines()
for i in range(len(pdb1)):
line1 = pdb1[i]
if line1.startswith("ATOM"):
line2 = pdb2[i]
x1 = float(line1[30:37])
y1 = float(line1[38:45])
z1 = float(line1[46:53])
x2 = float(line2[30:37])
y2 = float(line2[38:45])
z2 = float(line2[46:53])
dx = x1 - x2
dy = y1 - y2
dz = z1 - z2
d = math.sqrt(dx * dx + dy * dy + dz * dz)
davg += d
Navg += 1
if Navg > 0:
davg /= Navg
distances[volCounter - 1, volCounter2 - 1] = davg
distances = 0.5 * (distances + numpy.transpose(distances))
numpy.savetxt(self._getPath('distances.txt'), distances)
distances1D = numpy.mean(distances, axis=0)
print("Average distance to rest of volumes=", distances1D)
imin = numpy.argmin(distances1D)
print("The volume in the middle is pseudoatoms_%02d.pdb" % (imin + 1))
createLink(self._getPath("pseudoatoms_%02d.pdb" % (imin + 1)),
self._getPath("pseudoatoms.pdb"))
createLink(self._getPath("modes_%02d.xmd" % (imin + 1)),
self._getPath("modes.xmd"))
createLink(
self._getExtraPath("pseudoatoms_%02d_distance.hist" % (imin + 1)),
self._getExtraPath("pseudoatoms_distance.hist"))
# Measure range
minDisplacement = 1e38 * numpy.ones([self.numberOfModes.get(), 1])
maxDisplacement = -1e38 * numpy.ones([self.numberOfModes.get(), 1])
mdNMA = MetaData(self._getPath("modes.xmd"))
for volCounter in range(1, N + 1):
if volCounter != imin + 1:
md = MetaData(self._getExtraPath(
"alignment_%02d_%02d.xmd" % (imin + 1, volCounter)))
displacements = md.getValue(MDL_NMA, md.firstObject())
idx1 = 0
idx2 = 0
for idRow in mdNMA:
if mdNMA.getValue(MDL_ENABLED, idRow) == 1:
minDisplacement[idx2] = min(minDisplacement[idx2],
displacements[idx1])
maxDisplacement[idx2] = max(maxDisplacement[idx2],
displacements[idx1])
idx1 += 1
else:
minDisplacement[idx2] = 0
maxDisplacement[idx2] = 0
idx2 += 1
idx2 = 0
for idRow in mdNMA:
mdNMA.setValue(MDL_NMA_MINRANGE, float(minDisplacement[idx2]),
idRow)
mdNMA.setValue(MDL_NMA_MAXRANGE, float(maxDisplacement[idx2]),
idRow)
idx2 += 1
mdNMA.write(self._getPath("modes.xmd"))
# Create output
volCounter = 0
for inputStructure in self.inputStructures.get():
if volCounter == imin:
print("The corresponding volume is %s" % (
getImageLocation(inputStructure)))
finalStructure = inputStructure
break
volCounter += 1
pdb = AtomStruct(self._getPath('pseudoatoms.pdb'), pseudoatoms=True)
self._defineOutputs(outputPdb=pdb)
modes = NormalModes(filename=self._getPath('modes.xmd'))
self._defineOutputs(outputModes=modes)
self._defineSourceRelation(self.inputStructures, self.outputPdb)
def _createLink(self, movie):
movieFn = movie.getFileName()
if movieFn.endswith("mrcs"):
pwutils.createLink(movieFn, self._getMovieFn(movie))
def dockingStep(self):
def makeLocal(fn):
return fn.replace(self._getPath()+'/','')
glideProg = schrodinger_plugin.getHome('glide')
structConvertProg = schrodinger_plugin.getHome('utilities/structconvert')
structCatProg = schrodinger_plugin.getHome('utilities/structcat')
propListerProg = schrodinger_plugin.getHome('utilities/proplister')
fnGrid = self._getExtraPath("grid.zip")
if not os.path.exists(fnGrid): # Prepared to resume
createLink(self.inputGrid.get().getFileName(),fnGrid)
fnLigands = self._getPath('ligands')
if not os.path.exists(fnLigands):
makePath(fnLigands)
fnIn = self._getPath('job.inp')
if not os.path.exists(fnIn): # Prepared to resume
fhIn = open(fnIn,'w')
fhIn.write("GRIDFILE %s\n"%makeLocal(fnGrid))
if self.dockingMethod.get()==0:
fhIn.write("DOCKING_METHOD confgen\n")
fhIn.write("FLEXTORS True\n")
elif self.dockingMethod.get()==1:
fhIn.write("DOCKING_METHOD rigid\n")
elif self.dockingMethod.get()==2:
fhIn.write("DOCKING_METHOD mininplace\n")
elif self.dockingMethod.get()==3:
fhIn.write("DOCKING_METHOD inplace\n")
if self.dockingPrecision.get()==0:
fhIn.write("PRECISION HTVS\n")
elif self.dockingPrecision.get()==1:
fhIn.write("PRECISION SP\n")
elif self.dockingPrecision.get()==2:
fhIn.write("PRECISION XP\n")
fhIn.write("WRITE_XP_DESC True\n")
fhIn.write("POSTDOCK_NPOSE 10\n")
fhIn.write("SAMPLE_N_INVERSIONS %s\n"%self.sampleNinversions.get())
fhIn.write("SAMPLE_RINGS %s\n"%self.sampleRings.get())
fhIn.write("EPIK_PENALTIES %s\n"%self.sampleNinversions.get())
fhIn.write("SKIP_EPIK_METAL_ONLY %s\n"%self.skipMetalEpik.get())
fhIn.write("EXPANDED_SAMPLING %s\n"%self.expandedSampling.get())
fhIn.write("REWARD_INTRA_HBONDS %s\n"%self.rewardIntraHBonds.get())
fhIn.write("HBOND_DONOR_AROMH %s\n"%self.HbondDonorAromH.get())
if self.HbondDonorAromH.get():
fhIn.write("HBOND_DONOR_AROMH_CHARGE %f\n" % self.HbondDonorAromHCharge.get())
fhIn.write("HBOND_ACCEP_HALO %s\n"%self.HbondAcceptHalo.get())
fhIn.write("HBOND_DONOR_HALO %s\n"%self.HbondDonorHalo.get())
fhIn.write("MAXKEEP %d\n"%self.maxkeep.get())
fhIn.write("SCORING_CUTOFF %f\n"%self.scoreCutoff.get())
if self.maxref.get()>0:
fhIn.write("MAXREF %d\n" % self.maxref.get())
else:
if self.dockingPrecision.get()==2:
fhIn.write("MAXREF %d\n" % 800)
else:
fhIn.write("MAXREF %d\n" % 400)
fhIn.write("POSES_PER_LIG %d\n"%self.posesPerLig.get())
fh=open(self._getTmpPath("allLigands.mol2"),'w')
for small in self.inputLibrary.get():
fnSmall = small.getFileName()
fnBase = os.path.splitext(os.path.split(fnSmall)[1])[0]
if not fnSmall.endswith('.mol2'):
args = inputArg(fnSmall)
fnSmall = self._getTmpPath('ligand.mol2')
args += " -omol2 %s"%fnSmall
self.runJob(structConvertProg, args)
putMol2Title(fnSmall,fnBase)
fhLigand = open(fnSmall)
for line in fhLigand:
fh.write(line)
fhLigand.close()
fh.close()
fhIn.write("LIGANDFILE tmp/allLigands.mol2\n")
fhIn.close()
args = "-WAIT -NJOBS %d -RESTART -LOCAL job.inp"%(self.numberOfThreads.get())
self.runJob(glideProg, args, cwd=self._getPath())
self.runJob(propListerProg,
'-p "title" -p "docking score" -p "glide ligand efficiency" -p "glide ligand efficiency sa" -p "glide ligand efficiency ln" -c -o %s %s'%\
(self._getPath("job_pv.csv"), self._getPath("job_pv.maegz")))
def _createLink(self, movie):
movieFn = movie.getFileName()
if movieFn.endswith("mrcs"):
pwutils.createLink(movieFn, self._getMovieFn(movie))
def evaluateDeformationsStep(self):
N = self.inputStructures.get().getSize()
import numpy
distances=numpy.zeros([N,N])
for volCounter in range(1,N+1):
pdb1=open(self._getPath('pseudoatoms_%02d.pdb'%volCounter)).readlines()
for volCounter2 in range(1,N+1):
if volCounter!=volCounter2:
davg=0.
Navg=0.
pdb2=open(self._getExtraPath('alignment_%02d_%02d.pdb'%(volCounter,volCounter2))).readlines()
for i in range(len(pdb1)):
line1=pdb1[i]
if line1.startswith("ATOM"):
line2=pdb2[i]
x1=float(line1[30:37])
y1=float(line1[38:45])
z1=float(line1[46:53])
x2=float(line2[30:37])
y2=float(line2[38:45])
z2=float(line2[46:53])
dx=x1-x2
dy=y1-y2
dz=z1-z2
d=math.sqrt(dx*dx+dy*dy+dz*dz)
davg+=d
Navg+=1
if Navg>0:
davg/=Navg
distances[volCounter-1,volCounter2-1]=davg
distances=0.5*(distances+numpy.transpose(distances))
numpy.savetxt(self._getPath('distances.txt'),distances)
distances1D=numpy.mean(distances,axis=0)
print("Average distance to rest of volumes=",distances1D)
imin=numpy.argmin(distances1D)
print("The volume in the middle is pseudoatoms_%02d.pdb"%(imin+1))
createLink(self._getPath("pseudoatoms_%02d.pdb"%(imin+1)),self._getPath("pseudoatoms.pdb"))
createLink(self._getPath("modes_%02d.xmd"%(imin+1)),self._getPath("modes.xmd"))
createLink(self._getExtraPath("pseudoatoms_%02d_distance.hist"%(imin+1)),self._getExtraPath("pseudoatoms_distance.hist"))
# Measure range
minDisplacement= 1e38*numpy.ones([self.numberOfModes.get(),1])
maxDisplacement=-1e38*numpy.ones([self.numberOfModes.get(),1])
mdNMA=MetaData(self._getPath("modes.xmd"))
for volCounter in range(1,N+1):
if volCounter!=imin+1:
md=MetaData(self._getExtraPath("alignment_%02d_%02d.xmd"%(imin+1,volCounter)))
displacements=md.getValue(MDL_NMA, md.firstObject())
idx1=0
idx2=0
for idRow in mdNMA:
if mdNMA.getValue(MDL_ENABLED,idRow)==1:
minDisplacement[idx2]=min(minDisplacement[idx2],displacements[idx1])
maxDisplacement[idx2]=max(maxDisplacement[idx2],displacements[idx1])
idx1+=1
else:
minDisplacement[idx2]=0
maxDisplacement[idx2]=0
idx2+=1
idx2=0
for idRow in mdNMA:
mdNMA.setValue(MDL_NMA_MINRANGE,float(minDisplacement[idx2]),idRow)
mdNMA.setValue(MDL_NMA_MAXRANGE,float(maxDisplacement[idx2]),idRow)
idx2+=1
mdNMA.write(self._getPath("modes.xmd"))
# Create output
volCounter=0
for inputStructure in self.inputStructures.get():
if volCounter==imin:
print("The corresponding volume is %s"%(getImageLocation(inputStructure)))
finalStructure=inputStructure
break
volCounter+=1
pdb = PdbFile(self._getPath('pseudoatoms.pdb'), pseudoatoms=True)
self._defineOutputs(outputPdb=pdb)
modes = NormalModes(filename=self._getPath('modes.xmd'))
self._defineOutputs(outputModes=modes)
self._defineSourceRelation(finalStructure, self.outputPdb)
self._defineSourceRelation(self.outputPdb, self.outputModes)
def convertToPseudoAtomsStep(self, inputStructure, fnIn, fnMask, prefix):
XmippProtConvertToPseudoAtomsBase.convertToPseudoAtomsStep(self, fnIn, fnMask, prefix)
self.createChimeraScriptStep(inputStructure, fnIn, prefix)
createLink(self._getPath("pseudoatoms%s.pdb"%prefix),self._getPath("pseudoatoms.pdb"))
def preparationStep(self):
prog = Plugin.getHome('utilities/prepwizard')
if isinstance(self.inputStructure.get(), AtomStruct):
fnIn = self._getExtraPath("atomStructIn.pdb")
aStruct1 = AtomicStructHandler(
self.inputStructure.get().getFileName())
aStruct1.write(fnIn)
fnIn = 'extra/atomStructIn.pdb'
else:
fnIn = self._getExtraPath("atomStructIn.mae")
createLink(self.inputStructure.get().getFileName(), fnIn)
fnIn = 'extra/atomStructIn.mae'
args = '-WAIT'
if self.stage1.get():
if self.fillSideChains.get():
args += ' -fillsidechains'
if self.fillLoops.get():
args += ' -fillloops'
if self.disulfides.get():
args += ' -disulfides'
if self.mse.get():
args += ' -mse'
if self.hydrogens.get() == 0:
args += " -nohtreat"
elif self.hydrogens.get() == 1:
args += " -rehtreat"
if self.glycosylation.get():
args += " -glycosylation"
if self.palmitoylation.get():
args += " -palmitoylation"
if self.captermini.get():
args += " -captermini"
if self.keepFarWat.get():
args += " -keepfarwat -watdist %f" % self.watdist.get()
if not self.treatMetals.get():
args += " -nometaltreat"
if self.stage2.get():
if self.sampleWaters.get():
args += " -samplewater"
if self.xtal.get():
args += " -xtal"
if self.propKa.get():
args += " -propka_pH %f" % self.propKapH.get()
else:
args += " -nopropka"
if self.minadjh.get():
args += " -minimize_adj_h"
else:
args += " -noprotassign"
if self.stage3.get():
args += " -rmsd %f" % self.rmsdD.get()
if self.fix.get():
args += " -fix"
if self.force.get() == 0:
args += " -f 2005"
else:
args += " -f 3"
else:
args += " -noimpref"
if self.stage4.get():
if self.ms.get():
args += " -ms %d" % self.msN.get()
args += " -epik_pH %f" % self.epikPh.get()
args += " -epik_pHt %f" % self.epikPht.get()
else:
args += " -noepik"
args += ' %s atomStructOut.maegz' % fnIn
self.runJob(prog, args, cwd=self._getPath())
