def reformatOutputPDB(log,WorkingDir,NumberOfModes):
currentDir=os.getcwd()
changeDir(log,WorkingDir)
createDir(log,"modes")
Natoms=countAtoms("atoms.pdb")
fhIn=open('diagrtb.eigenfacs')
fhAni=open('vec_ani.txt','w')
for n in range(NumberOfModes):
# Skip two lines
fhIn.readline()
fhIn.readline()
fhOut=open('modes/vec.%d'%(n+1),'w')
for i in range(Natoms):
line=fhIn.readline()
fhOut.write(line)
fhAni.write(line.rstrip().lstrip()+" ")
fhOut.close()
if n!=(NumberOfModes-1):
fhAni.write("\n")
fhIn.close()
fhAni.close()
runJob(log,"nma_prepare_for_animate.py","")
runJob(log,"rm","vec_ani.txt")
moveFile(log,'vec_ani.pkl','extra/vec_ani.pkl')
changeDir(log,currentDir)
def runCLTomo(log, WorkingDir, params, nproc):
runJob(log,'xmipp_mpi_classify_CLTomo','%d %s'%(nproc,params))
levelFiles=glob.glob(WorkingDir+"/extra/results_classes_level*.xmd")
if levelFiles:
levelFiles.sort()
lastLevelFile=levelFiles[-1]
createLink(log,lastLevelFile,os.path.join(WorkingDir,'results.xmd'))
def integrateVolumes(log,WorkingDir,NumVolumes,NumIter):
fnOut = 'volumesProposed.xmd'
for n in range(NumVolumes-1):
fnRoot=os.path.join(WorkingDir,'volumeProposed%05d'%n)
fnRoot2=os.path.join(WorkingDir,'volumeProposed%05d'%n+1)
runJob(log,"xmipp_metadata_utilities","-i %s --set union_all %s -o %s"%(fnRoot,fnRoot2,fnOut))
def coarseSearch(log,WorkingDir,InputVolume,CylinderRadius,Rot0, RotF, RotStep, Z0, ZF, ZStep, NumberOfThreads,fnCoarse):
args="-i %s --sym helical -z %f %f %f --rotHelical %f %f %f --thr %d -o %s"%(InputVolume,float(Z0),float(ZF),float(ZStep),
float(Rot0),float(RotF),float(RotStep),NumberOfThreads,fnCoarse)
if CylinderRadius>0:
[xdim,ydim,zdim,ndim]=getImageSize(InputVolume)
args+=" --mask cylinder %d %d"%(int(-CylinderRadius),int(-xdim))
runJob(log,'xmipp_volume_find_symmetry',args)
def getBestVolumes(log,WorkingDir,NRansac,NumVolumes,UseAll):
volumes = []
inliers = []
for n in range(NRansac):
fnAngles = os.path.join(WorkingDir,"tmp/angles_ransac%05d"%n+".xmd")
md=MetaData("inliers@"+fnAngles)
numInliers=md.getValue(MDL_WEIGHT,md.firstObject())
volumes.append(fnAngles)
inliers.append(numInliers)
index = sorted(range(inliers.__len__()), key=lambda k: inliers[k])
fnBestAngles = ''
threshold=getCCThreshold(WorkingDir)
i=NRansac-1
indx = 0
while i>=0 and indx<NumVolumes:
fnBestAngles = volumes[index[i]]
fnBestAnglesOut=os.path.join(WorkingDir,"volumeProposed%05d"%indx+".xmd")
copyFile(log,fnBestAngles,fnBestAnglesOut)
print("Best volume "+str(indx)+" = "+fnBestAngles)
if not UseAll:
runJob(log,"xmipp_metadata_utilities","-i %s -o %s --query select \"maxCC>%f \" --mode append" %(fnBestAnglesOut,fnBestAnglesOut,threshold))
if getMdSize(fnBestAnglesOut) > 0:
indx += 1
else:
indx += 1
i -= 1
# Remove unnecessary files
for n in range(NRansac):
fnAngles = os.path.join(WorkingDir,"tmp/angles_ransac%05d"%n+".xmd")
deleteFile(log, fnAngles)
def scoreFinalVolumes(log,WorkingDir,NumVolumes):
threshold=getCCThreshold(WorkingDir)
mdOut=MetaData()
for n in range(NumVolumes):
fnRoot=os.path.join(WorkingDir,'volumeProposed%05d'%n)
fnAssignment=fnRoot+".xmd"
if exists(fnAssignment):
runJob(log,"xmipp_metadata_utilities","-i %s --fill weight constant 1"%fnAssignment)
MDassignment=MetaData(fnAssignment)
sum=0
thresholdedSum=0
N=0
minCC=2
for id in MDassignment:
cc=MDassignment.getValue(MDL_MAXCC,id)
sum+=cc
thresholdedSum+=cc-threshold
if cc<minCC:
minCC=cc
N+=1
avg=sum/N
id=mdOut.addObject()
mdOut.setValue(MDL_IMAGE,fnRoot+".vol",id)
mdOut.setValue(MDL_VOLUME_SCORE_SUM,float(sum),id)
mdOut.setValue(MDL_VOLUME_SCORE_SUM_TH,float(thresholdedSum),id)
mdOut.setValue(MDL_VOLUME_SCORE_MEAN,float(avg),id)
mdOut.setValue(MDL_VOLUME_SCORE_MIN,float(minCC),id)
mdOut.write(os.path.join(WorkingDir,"volumesProposed.xmd"))
def animateModes(log,WorkingDir,LastMode,Amplitude,NFrames,Downsample,PseudoAtomThreshold,PseudoAtomRadius,Sampling,StructureType):
createDir(log,os.path.join(WorkingDir,"extra/animations"))
currentDir=os.getcwd()
changeDir(log,WorkingDir)
if StructureType=="EM":
fn="pseudoatoms.pdb"
runJob(log,"nma_animate_pseudoatoms.py","%s extra/vec_ani.pkl 7 %d %f extra/animations/animated_mode %d %d %f"%\
(fn,LastMode,Amplitude,NFrames,Downsample,PseudoAtomThreshold))
else:
fn="atoms.pdb"
runJob(log,"nma_animate_atoms.py","%s extra/vec_ani.pkl 7 %d %f extra/animations/animated_mode %d"%\
(fn,LastMode,Amplitude,NFrames))
for mode in range(7,LastMode+1):
fnAnimation="extra/animations/animated_mode_%03d"%mode
fhCmd=open(fnAnimation+".vmd",'w')
fhCmd.write("mol new "+os.path.join(WorkingDir,fnAnimation)+".pdb\n")
fhCmd.write("animate style Loop\n")
fhCmd.write("display projection Orthographic\n")
if StructureType=="EM":
fhCmd.write("mol modcolor 0 0 Beta\n")
fhCmd.write("mol modstyle 0 0 Beads %f 8.000000\n"%(PseudoAtomRadius*Sampling))
else:
fhCmd.write("mol modcolor 0 0 Index\n")
fhCmd.write("mol modstyle 0 0 Beads 1.000000 8.000000\n")
fhCmd.write("animate speed 0.5\n")
fhCmd.write("animate forward\n")
fhCmd.close();
changeDir(log,currentDir)
def createProjections(_log
,AngSamplingRateDeg
,DocFileExp
,maskReconstructedVolume
,MaxChangeInAngles
, MpiJobSize
,NumberOfMpi
,NumberOfThreads
,referenceStack
,SymmetryGroup
):
parameters = ' -i ' + maskReconstructedVolume
parameters += ' --experimental_images ' + DocFileExp
parameters += ' -o ' + referenceStack
parameters += ' --sampling_rate ' + AngSamplingRateDeg
parameters += ' --sym ' + SymmetryGroup +'h'
parameters += ' --compute_neighbors --near_exp_data '
parameters += ' --angular_distance ' + str(MaxChangeInAngles)
if ((NumberOfMpi *NumberOfThreads)>1):
parameters += ' --mpi_job_size ' + MpiJobSize
runJob(_log,'xmipp_angular_project_library',
parameters,
NumberOfMpi *NumberOfThreads)
def vector2img(log, Mask, ExtraDir):
args=' -i ' + os.path.join(ExtraDir,"kerdensom_vectors.xmd")+\
' -o ' + os.path.join(ExtraDir,"classes.stk")
if Mask != '':
args += ' --mask binary_file ' + Mask
runJob(log,"xmipp_image_vectorize", args)
deleteFiles(log, [os.path.join(ExtraDir,"kerdensom_vectors.xmd"),os.path.join(ExtraDir,"kerdensom_vectors.vec")], True)
def setOption(log,OperationSetType, md, md2, Label, Label2, fnOut,ModeType):
if OperationSetType=="inner_join":
runJob(log,'xmipp_metadata_utilities',"-i %s --set %s %s %s %s -o %s --mode %s"
%(md,OperationSetType,md2,Label,Label2,fnOut,ModeType))
else:
runJob(log,'xmipp_metadata_utilities',"-i %s --set %s %s %s %s -o %s --mode %s"
%(md,OperationSetType,md2,Label,Label2,fnOut,ModeType))
def filter_volume(_log
, FourierMaxFrequencyOfInterest
, ReconstructedVolume
, ReconstructedFilteredVolume
, DoComputeResolution
, OuterRadius
, DoLowPassFilter
, UseFscForFilter
, ConstantToAddToFiltration
, ResolutionXmdPrevIterMax
, ResolSam
):
if (not DoLowPassFilter):
copyFile(_log, ReconstructedVolume, ReconstructedFilteredVolume)
else:
if (UseFscForFilter):
if (FourierMaxFrequencyOfInterest == -1):
md = MetaData(ResolutionXmdPrevIterMax)
id = md.firstObject()
FourierMaxFrequencyOfInterest = md.getValue(MDL_RESOLUTION_FREQREAL, id)
FourierMaxFrequencyOfInterest = ResolSam / FourierMaxFrequencyOfInterest
filter_in_pixels_at = float(FourierMaxFrequencyOfInterest) + float(ConstantToAddToFiltration)
else:
filter_in_pixels_at = float(ConstantToAddToFiltration)
if (filter_in_pixels_at > 0.5):
copyFile(_log, ReconstructedVolume, ReconstructedFilteredVolume)
else:
command = " -i " + ReconstructedVolume + \
" -o " + ReconstructedFilteredVolume + ' --fourier low_pass ' + \
str (filter_in_pixels_at)
runJob(_log, "xmipp_transform_filter", command)
def runResize(log,stack,new_size,Nproc):
size = MetaDataInfo(stack)[0]
args="-i %(stack)s" % locals()
if new_size<size:
args+=" --fourier %(new_size)d" % locals()
else:
args+=" --dim %(new_size)d" % locals()
runJob(log,"xmipp_image_resize",args,Nproc)
def window(log,input,OutModel,SingleVolume,Size):
if Size>0:
args="-i %s --size %d"%(input,int(Size))
if not SingleVolume:
args+=" --save_metadata_stack"
if input!=OutModel:
args+=" -o %s"%OutModel
runJob(log,"xmipp_transform_window",args)
def kerdensom(log,ExtraDir,SomXdim,SomYdim,SomReg0,SomReg1,SomSteps,KerdensomExtraCommand):
args='-i '+join(ExtraDir,"rotSpectra.xmd")+\
' --oroot '+join(ExtraDir,"kerdensom")+\
' --xdim ' + str(SomXdim) + \
' --ydim ' + str(SomYdim) + \
' --deterministic_annealing %f %f %f'%(SomSteps,SomReg0,SomReg1) + \
' '+ str(KerdensomExtraCommand)
runJob(log,"xmipp_classify_kerdensom",args)
deleteFiles(log, [os.path.join(ExtraDir,"rotSpectra.xmd"),os.path.join(ExtraDir,"rotSpectra.vec")], True)
def convertFromPDB(log,InModel,WorkingDir,Ts,Size,CenterPDB):
args="-i %s -o %s/volume --sampling %f"%(InModel,WorkingDir,Ts)
if CenterPDB:
args+=" --centerPDB"
if Size>0:
args+=" --size %d"%(int(Size))
if Ts>4:
args+=" --poor_Gaussian"
runJob(log,"xmipp_volume_from_pdb",args)
def runFourierFilter(log,stack,freq_low,freq_high,freq_decay,Nproc):
program = "xmipp_transform_filter"
args = "-i %(stack)s --fourier "
if freq_low == 0:
args += "low_pass %(freq_high)f %(freq_decay)f"
elif freq_high == 0.5:
args += "high_pass %(freq_low)f %(freq_decay)f"
else:
args += "band_pass %(freq_low)f %(freq_high)f %(freq_decay)f"
runJob(log, program, args % locals())
def symmetrize(log,WorkingDir,InputVolume,OutputVolume,CylinderRadius,fnFine):
md=MetaData(fnFine)
id=md.firstObject()
rot0=md.getValue(MDL_ANGLE_ROT,id)
z0=md.getValue(MDL_SHIFT_Z,id)
args="-i %s --sym helical --helixParams %f %f -o %s"%(InputVolume,z0,rot0,OutputVolume)
runJob(log,'xmipp_transform_symmetrize',args)
if CylinderRadius>0:
[xdim,ydim,zdim,ndim]=getImageSize(InputVolume)
args="-i %s --mask cylinder %d %d"%(OutputVolume,int(-CylinderRadius),int(-xdim))
runJob(log,'xmipp_transform_mask',args)
def fineSearch(log,WorkingDir,InputVolume,CylinderRadius,fnCoarse,Rot0, RotF, Z0, ZF,fnFine):
md=MetaData(fnCoarse)
id=md.firstObject()
rot0=md.getValue(MDL_ANGLE_ROT,id)
z0=md.getValue(MDL_SHIFT_Z,id)
args="-i %s --sym helical -z %f %f --rotHelical %f %f --localHelical %f %f -o %s"%(InputVolume,float(Z0),float(ZF),
float(Rot0),float(RotF),z0,rot0,fnFine)
if CylinderRadius>0:
[xdim,ydim,zdim,ndim]=getImageSize(InputVolume)
args+=" --mask cylinder %d %d"%(int(-CylinderRadius),int(-xdim))
runJob(log,'xmipp_volume_find_symmetry',args)
def segment(log,WorkingDir,InModel,SegmentationType,SegmentationMass,Ts):
fnMask="%s/mask.vol"%WorkingDir
args="-i %s -o %s --method "%(InModel,fnMask)
if SegmentationType=="Number of voxels":
args+="voxel_mass %d"%(int(SegmentationMass))
elif SegmentationType=="Number of aminoacids":
args+="aa_mass %d %f"%(int(SegmentationMass),float(Ts))
elif SegmentationType=="Dalton mass":
args+="dalton_mass %d %f"%(int(SegmentationMass),float(Ts))
else:
args+="otsu"
runJob(log,"xmipp_volume_segment",args)
def splitMetadata(log,InMetadata,WorkingDir,Nparts,SortBy,RemoveDisabled,RandomSplit):
fnRoot=os.path.join(WorkingDir,'images')
args="-i %s --oroot %s -n %d"%(InMetadata,fnRoot,Nparts)
if SortBy=="Do not sort":
args+=" --dont_sort"
elif SortBy=="image name":
args+=" --l image"
elif SortBy=="micrograph name":
args+=" --l micrograph"
if not RandomSplit:
args+=" --dont_randomize"
runJob(log,"xmipp_metadata_split",args)
def launchParticlePickingGUI(log, InputMicrographs, ExtraDir, PickingMode=PM_MANUAL,
TiltPairs=False, Memory=2):
''' Utility function to launch the Particle Picking application '''
if TiltPairs:
program = "xmipp_micrograph_tiltpair_picking "
args="-i micrographPairs@%(InputMicrographs)s"%locals()
else:
program = "xmipp_micrograph_particle_picking"
args="-i %(InputMicrographs)s"%locals()
args += " -o %(ExtraDir)s --mode %(PickingMode)s --memory %(Memory)dg"%locals()
runJob(log, program, args, RunInBackground=False)
def sortImages(log, ImagesFn, rejectionMethod='None', maxZscore=3, percentage=5):
md = MetaData(ImagesFn)
if not md.isEmpty():
args=""
if rejectionMethod=='MaxZscore':
args+=" --zcut "+str(maxZscore)
elif rejectionMethod=='Percentage':
args+=" --percent "+str(percentage)
runJob(log, "xmipp_image_sort_by_statistics","-i %(ImagesFn)s --addToInput" % locals()+args)
md.read(ImagesFn) # Should have ZScore label after runJob
md.sort(MDL_ZSCORE)
md.write(ImagesFn)
def sortClasses(log,ExtraDir,Nproc,suffix):
if Nproc==1:
Nproc=2
if Nproc>8:
Nproc=8
for filename in glob.glob(os.path.join(ExtraDir,"level_??/level_classes%s.xmd"%suffix)):
level=int(re.search('level_(\d\d)',filename).group(1))
fnRoot=os.path.join(ExtraDir,"level_%02d/level_classes%s_sorted"%(level,suffix))
params= "-i classes@"+filename+" --oroot "+fnRoot
runJob(log,"xmipp_image_sort",params,Nproc)
mD=MetaData(fnRoot+".xmd")
mD.write("classes_sorted@"+filename,MD_APPEND)
deleteFile(log,fnRoot+".xmd")
def sortImages(log, inputFile, outputFile, addToSelf, rejectionMethod, maxZscore, percentage):
from xmipp import MetaDataInfo
(Xdim, Ydim, Zdim, Ndim, _) = MetaDataInfo(inputFile)
args=""
if rejectionMethod=='MaxZscore':
args+=" --zcut "+str(maxZscore)
elif rejectionMethod=='Percentage':
args+=" --percent "+str(percentage)
if Ndim > 0:
if addToSelf:
runJob(log,"xmipp_image_sort_by_statistics","-i "+outputFile+" --addToInput"+args)
else:
runJob(log,"xmipp_image_sort_by_statistics","-i "+inputFile+" -o "+outputFile+args)
def automaticRejection(log,WorkingDir,condition,MDL_TYPE):
fnMic=os.path.join(WorkingDir,"micrographs.xmd")
fnRejected=os.path.join(WorkingDir,"tmp/rejectedMicrographs.xmd")
runJob(log,"xmipp_metadata_utilities",'-i %s --query select "%s" -o %s'%(fnMic,condition,fnRejected))
md = xmipp.MetaData(fnRejected)
fnRejectedMicrographs=md.getColumnValues(MDL_TYPE)
md.read(fnMic)
for id in md:
fnCurrentMicrograph=md.getValue(MDL_TYPE,id)
if fnCurrentMicrograph in fnRejectedMicrographs:
md.setValue(xmipp.MDL_ENABLED,-1,id)
md.write(fnMic)
deleteFile(log,fnRejected)
def projMatch(log, WorkingDir,WorkingDirStructure, fnClasses, fnBase, AngularSampling, SymmetryGroup, Xdim):
fnRoot=os.path.join(WorkingDirStructure,fnBase)
fnGallery=os.path.join(WorkingDir,'tmp/gallery_'+fnBase+'.stk')
AngularSampling=int(max(floor(AngularSampling/2.0),2));
runJob(log,"xmipp_angular_project_library", "-i %s.vol -o %s --sampling_rate %f --sym %s --method fourier 1 0.25 bspline --compute_neighbors --angular_distance -1 --experimental_images %s -v 0"\
%(fnRoot,fnGallery,float(AngularSampling),SymmetryGroup,fnClasses))
runJob(log,"xmipp_angular_projection_matching", "-i %s.xmd -o %s.xmd --ref %s --Ri 0 --Ro %s --max_shift %s --append -v 0"\
%(fnRoot,fnRoot,fnGallery,str(Xdim/2),str(Xdim/20)))
deleteFile(log,os.path.join(WorkingDir,'tmp/gallery_'+fnBase+'_sampling.xmd'))
deleteFile(log,os.path.join(WorkingDir,'tmp/gallery_'+fnBase+'.doc'))
deleteFile(log,os.path.join(WorkingDir,'tmp/gallery_'+fnBase+'.stk'))
def evaluateClasses(log,WorkingDir,ExtraDir,subset):
levelFiles=glob.glob(os.path.join(ExtraDir,"level_??/level_classes%s.xmd"%subset))
levelFiles.sort()
for filename in levelFiles:
runJob(log,"xmipp_classify_evaluate_classes","-i "+filename)
level=int(re.search('level_(\d\d)',filename).group(1))
if level>0:
previousFile=os.path.join(ExtraDir,"level_%02d/level_classes%s.xmd"%(level-1,subset))
if os.path.exists(previousFile):
fnOut="%s/classes%s_hierarchy.txt"%(ExtraDir,subset)
args="--i1 %s --i2 %s -o %s"%(previousFile,filename,fnOut)
if os.path.exists(fnOut):
args+=" --append"
runJob(log,"xmipp_classify_compare_classes",args)
def qualifyModes(log,WorkingDir,NumberOfModes,StructureType,CollectivityThreshold):
currentDir=os.getcwd()
changeDir(log,WorkingDir)
fnVec=glob.glob("modes/vec.*")
if len(fnVec)<NumberOfModes:
fhWarning=open("warnings.xmd",'w')
fhWarning.write(redStr("There are only "+str(len(fnVec))+" modes instead of "+str(NumberOfModes)+". Check the number of modes you asked to compute and/or consider increasing cut-off distance. The maximum number of modes allowed by the method for atomic normal mode analysis is 6 times the number of RTB blocks and for pseudoatomic normal mode analysis 3 times the number of pseudoatoms. However, the protocol allows only up to 200 modes as 20-100 modes are usually enough. If the number of modes is below the minimum between these two numbers, consider increasing cut-off distance.")+"\n")
fhWarning.close()
fnDiag="diagrtb.eigenfacs"
if StructureType=="EM":
runJob(log,"nma_reformatForElNemo.sh","%d"%NumberOfModes)
fnDiag="diag_arpack.eigenfacs"
runJob(log,"echo","%s | nma_check_modes"%fnDiag)
deleteFile(log,fnDiag)
fh=open("Chkmod.res")
MDout=MetaData()
collectivityList=[]
for n in range(NumberOfModes):
line=fh.readline()
collectivity=float(line.split()[1])
collectivityList.append(collectivity)
id=MDout.addObject()
MDout.setValue(MDL_NMA_MODEFILE,os.path.join(WorkingDir,"modes/vec.%d"%(n+1)),id)
MDout.setValue(MDL_ORDER,long(n+1),id)
if n>=6:
MDout.setValue(MDL_ENABLED,1,id)
else:
MDout.setValue(MDL_ENABLED,-1,id)
MDout.setValue(MDL_NMA_COLLECTIVITY,collectivity,id)
if collectivity<CollectivityThreshold:
MDout.setValue(MDL_ENABLED,-1,id)
fh.close()
idxSorted=[i[0] for i in sorted(enumerate(collectivityList), key=lambda x:x[1])]
score=[0]*NumberOfModes
for i in range(NumberOfModes):
score[i]+=i+1
score[idxSorted[i]]+=NumberOfModes-i
i=0
for id in MDout:
score_i=float(score[i])/(2.0*NumberOfModes)
MDout.setValue(MDL_NMA_SCORE,score_i,id)
i+=1
MDout.write("modes.xmd")
deleteFile(log,"Chkmod.res")
changeDir(log,currentDir)
def runNormalize(log,stack,normType,bgRadius,Nproc):
program = "xmipp_transform_normalize"
args = "-i %(stack)s "
if bgRadius <= 0:
particleSize = MetaDataInfo(stack)[0]
bgRadius = int(particleSize/2)
if normType=="OldXmipp":
args += "--method OldXmipp"
elif normType=="NewXmipp":
args += "--method NewXmipp --background circle %(bgRadius)d"
else:
args += "--method Ramp --background circle %(bgRadius)d"
runJob(log, program, args % locals(), Nproc)
def maskVolume(_log
,dRradiusMax
,dRradiusMin
,maskReconstructedVolume
,reconstructedVolume
,NumberOfMpi
,NumberOfThreads
):
parameters = ' -i ' + reconstructedVolume
parameters += ' -o ' + maskReconstructedVolume
parameters += ' --mask raised_crown -%d -%d 2' %(dRradiusMin, dRradiusMax)
runJob( _log,"xmipp_transform_mask",
parameters,
NumberOfMpi *NumberOfThreads)
