def test(self):
subset = self.newProtocol(ProtSubSet,
inputFullSet=self.protImportParts.outputParticles,
chooseAtRandom=True,
nElements=400)
self.launchProtocol(subset)
highres = self.newProtocol(XmippProtReconstructHighRes,
inputParticles=subset.outputParticles,
inputVolumes=self.protImportVol.outputVolume,
particleRadius=180,
symmetryGroup="i1",
nextResolutionCriterion=0.143,
alignmentMethod=XmippProtReconstructHighRes.AUTOMATIC_ALIGNMENT,
maximumTargetResolution="15 10 7",
numberOfMpi=8)
self.launchProtocol(highres)
self.assertIsNotNone(highres.outputParticles,
"There was a problem with Highres")
fnResolution = highres._getExtraPath("Iter005/iterInfo.xmd")
if not exists(fnResolution):
self.assertTrue(False, fnResolution + " does not exist")
else:
md = emlib.MetaData("resolution@" + fnResolution)
R = md.getValue(emlib.MDL_RESOLUTION_FREQREAL, md.firstObject())
self.assertTrue(R < 10, "Resolution is not below 10A")
def testfs2(self):
fso = self.newProtocol(XmippProtFSO,
halfVolumesFile=False,
half1=self.protImportHalf1.outputVolume,
half2=self.protImportHalf2.outputVolume,
estimate3DFSC=True)
self.launchProtocol(fso)
self.assertTrue(exists(fso._getExtraPath("fso.xmd")),
"fso without mask has failed")
def testAddNoise3(self):
addnoise = self.newProtocol(
XmippProtAddNoiseParticles,
input=self.protImportParts.outputParticles,
noiseType=XmippProtAddNoiseParticles.UNIFORM_NOISE,
uniformMax=1,
uniformMin=0)
self.launchProtocol(addnoise)
self.assertTrue(exists(addnoise._getExtraPath('Noisy.stk')),
"AddNoise with uniform noise has failed")
def testMonoDir(self):
MonoDir = self.newProtocol(XmippProtMonoDir,
objLabel='single volume monodir',
inputVolumes=self.protImportVol.outputVolume,
Mask=self.protCreateMask.outputMask,
resstep=0.5,
significance=0.95,
fast=True,
isPremasked=False
)
self.launchProtocol(MonoDir)
self.assertTrue(exists(MonoDir._getExtraPath('meanResdoa.vol')),
"MonoDir has failed")
def testMonoRes1(self):
MonoRes = self.newProtocol(XmippProtMonoRes,
objLabel='single volume monores',
useHalfVolumes=False,
hasHalfVolumesFile=False,
fullMap=self.protImportVol.outputVolume,
mask=self.protCreateMask.outputMask,
minRes=1,
maxRes=25,
)
self.launchProtocol(MonoRes)
self.assertTrue(exists(MonoRes._getExtraPath('monoresResolutionMap.mrc')),
"MonoRes (no split, no premasked) has failed")
def testAddNoise1(self):
addnoise = self.newProtocol(
XmippProtAddNoiseVolumes,
input=self.protImportVol.outputVolume,
noiseType=XmippProtAddNoiseVolumes.GAUSSIAN_NOISE,
gaussianStd=0.08,
gaussianMean=0)
self.launchProtocol(addnoise)
self.assertTrue(
exists(
addnoise._getNoisyOutputPath(
self.protImportVol.outputVolume.getFileName())),
"AddNoise with gaussian noise has failed")
def testDeepVolPostpro1(self):
deepPostProc = self.newProtocol(
XmippProtDeepVolPostProc,
inputVolume=self.protImportVol.outputVolume,
normalization=XmippProtDeepVolPostProc.NORMALIZATION_AUTO)
self.launchProtocol(deepPostProc)
self.assertTrue(
exists(deepPostProc._getExtraPath(POSTPROCESS_VOL_BASENAME)),
"Deep Volume Postprocessing has failed")
self._checkMeanVal(
deepPostProc._getExtraPath(POSTPROCESS_VOL_BASENAME),
0.1224,
r_delta=0.5)
def testAddNoise2(self):
addnoise = self.newProtocol(
XmippProtAddNoiseVolumes,
input=self.protImportVols.outputVolumes,
noiseType=XmippProtAddNoiseVolumes.STUDENT_NOISE,
studentDf=1,
studentStd=0.08,
studentMean=0)
self.launchProtocol(addnoise)
fnVols = self.protImportVols.outputVolumes.getFiles()
for fnvol in fnVols:
fn = addnoise._getNoisyOutputPath(fnvol)
self.assertTrue(exists(fn),
"AddNoise with student noise has failed %s" % (fn))
def testLocalDeblur2(self):
MonoRes = self.newProtocol(XmippProtMonoRes,
objLabel='single volume monores',
usehalfVolumes=False,
fullMap=self.protImportVol2.outputVolume,
Mask=self.protCreateMask2.outputMask,
minRes=1,
maxRes=6)
self.launchProtocol(MonoRes)
self.assertTrue(
exists(MonoRes._getExtraPath('monoresResolutionMap.mrc')),
"MonoRes (no split, no premasked) has failed")
LocalDeblur = self.newProtocol(
XmippProtLocSharp,
objLabel='sharpening localdeblur',
inputVolume=self.protImportVol2.outputVolume,
resolutionVolume=MonoRes.resolution_Volume,
const=1,
)
self.launchProtocol(LocalDeblur)
self.assertTrue(
exists(LocalDeblur._getExtraPath('sharpenedMap_last.mrc')),
"LocalDeblur has failed")
def testDeepVolPostpro3(self):
deepPostProc = self.newProtocol(
XmippProtDeepVolPostProc,
useHalfMapsInsteadVol=True,
halfMapsAttached=True,
inputVolume=self.protImportVolWithHalfs.outputVolume,
normalization=XmippProtDeepVolPostProc.NORMALIZATION_AUTO)
self.launchProtocol(deepPostProc)
self.assertTrue(
exists(deepPostProc._getExtraPath(POSTPROCESS_VOL_BASENAME)),
"Deep Volume Postprocessing has failed")
self._checkMeanVal(
deepPostProc._getExtraPath(POSTPROCESS_VOL_BASENAME),
0.1102,
r_delta=0.5)
def testMonoRes2(self):
MonoRes = self.newProtocol(XmippProtMonoRes,
objLabel='two halves monores',
useHalfVolumes=True,
hasHalfVolumesFile=False,
halfMap1=self.protImportHalf1.outputVolume,
halfMap2=self.protImportHalf2.outputVolume,
provideMaskInHalves=True,
mask=self.protCreateMask.outputMask,
minRes=1,
maxRes=25,
)
self.launchProtocol(MonoRes)
self.assertTrue(exists(MonoRes._getExtraPath('monoresResolutionMap.mrc')),
"MonoRes (split, pre-masked, no filter) has failed")
def test(self):
goldenHighres = self.newProtocol(
XmippMetaProtGoldenHighRes,
inputParticles=self.protImportParts.outputParticles,
inputVolumes=self.protImportVol.outputVolume,
particleRadius=180,
symmetryGroup="i1",
discardParticles=True,
numberOfMpi=8)
self.launchProtocol(goldenHighres)
self.assertIsNotNone(goldenHighres.outputParticlesLocal1,
"There was a problem with Golden Highres")
fnResolution = goldenHighres._getExtraPath('fnFSCs.txt')
if not exists(fnResolution):
self.assertTrue(False, fnResolution + " does not exist")
else:
count = len(open(fnResolution).readlines())
count = count - 10
result = 'outputParticlesLocal%d' % (count)
o = getattr(goldenHighres, result, None)
locals()[result] = o
self.assertIsNotNone(o, "Output: %s is None" % result)
