def setUpClass(cls):
ds = DataSet.getDataSet('pyseg')
cls.ds = ds
cls.preSegStar = join(ds.getPath(), 'preseg.star')
setupTestProject(cls)
cls.ds = DataSet.getDataSet('pyseg')
cls.preSegStar = join(cls.ds.getPath(), 'preseg.star')
def setUpClass(cls):
cls.dataset = DataSet.getDataSet('xmipp_tutorial')
cls.moviewset = DataSet.getDataSet('jmbFalconMovies')
cls.mic1 = cls.dataset.getFile('mic1')
cls.particlesStk = os.path.join(cls.dataset.getPath(), 'particles',
'BPV_1386.stk')
cls.movieFn = cls.moviewset.getFile("movie1")
def setUpClass(cls):
setupTestProject(cls)
cls.dsXmipp = DataSet.getDataSet('xmipp_tutorial')
cls.dsGrigorieff = DataSet.getDataSet('grigorieff')
# First, import a set of micrographs that will be used
# from all ctf test cases
cls.protImport = cls.newProtocol(ProtImportMicrographs,
filesPath=cls.dsXmipp.getFile('allMics'),
samplingRate=1.237, voltage=300)
cls.launchProtocol(cls.protImport)
def setUpClass(cls):
setupTestProject(cls)
cls.dsXmipp = DataSet.getDataSet('xmipp_tutorial')
cls.dsGrigorieff = DataSet.getDataSet('grigorieff')
# First, import a set of micrographs that will be used
# from all ctf test cases
cls.protImport = cls.newProtocol(ProtImportMicrographs,
filesPath=cls.dsXmipp.getFile('allMics'),
samplingRate=1.237, voltage=300)
cls.launchProtocol(cls.protImport)
def setUpClass(cls):
"""Prepare the data that we will use later on."""
print "\n", greenStr(" Set Up - Collect data ".center(75, '-'))
setupTestProject(cls) # defined in BaseTest, creates cls.proj
cls.dataset_xmipp = DataSet.getDataSet('xmipp_tutorial')
cls.dataset_mda = DataSet.getDataSet('mda')
cls.dataset_ribo = DataSet.getDataSet('ribo_movies')
#
# Imports
#
new = cls.proj.newProtocol # short notation
launch = cls.proj.launchProtocol
# Micrographs
print magentaStr("\n==> Importing data - micrographs")
p_imp_micros = new(ProtImportMicrographs,
filesPath=cls.dataset_xmipp.getFile('allMics'),
samplingRate=1.237,
voltage=300)
launch(p_imp_micros, wait=True)
cls.micros = p_imp_micros.outputMicrographs
# Volumes
print magentaStr("\n==> Importing data - volumes")
p_imp_volumes = new(ProtImportVolumes,
filesPath=cls.dataset_xmipp.getFile('volumes'),
samplingRate=9.896)
launch(p_imp_volumes, wait=True)
cls.vols = p_imp_volumes.outputVolumes
# Movies
print magentaStr("\n==> Importing data - movies")
p_imp_movies = new(ProtImportMovies,
filesPath=cls.dataset_ribo.getFile('movies'),
samplingRate=2.37,
magnification=59000,
voltage=300,
sphericalAberration=2.0)
launch(p_imp_movies, wait=True)
cls.movies = p_imp_movies.outputMovies
# Particles
print magentaStr("\n==> Importing data - particles")
p_imp_particles = new(ProtImportParticles,
filesPath=cls.dataset_mda.getFile('particles'),
samplingRate=3.5)
launch(p_imp_particles, wait=True)
cls.particles = p_imp_particles.outputParticles
def setUpClass(cls):
"""Prepare the data that we will use later on."""
print "\n", greenStr(" Set Up - Collect data ".center(75, '-'))
setupTestProject(cls) # defined in BaseTest, creates cls.proj
cls.dataset_xmipp = DataSet.getDataSet('xmipp_tutorial')
cls.dataset_mda = DataSet.getDataSet('mda')
cls.dataset_ribo = DataSet.getDataSet('ribo_movies')
#
# Imports
#
new = cls.proj.newProtocol # short notation
launch = cls.proj.launchProtocol
# Micrographs
print magentaStr("\n==> Importing data - micrographs")
p_imp_micros = new(ProtImportMicrographs,
filesPath=cls.dataset_xmipp.getFile('allMics'),
samplingRate=1.237, voltage=300)
launch(p_imp_micros, wait=True)
cls.micros = p_imp_micros.outputMicrographs
# Volumes
print magentaStr("\n==> Importing data - volumes")
p_imp_volumes = new(ProtImportVolumes,
filesPath=cls.dataset_xmipp.getFile('volumes'),
samplingRate=9.896)
launch(p_imp_volumes, wait=True)
cls.vols = p_imp_volumes.outputVolumes
# Movies
print magentaStr("\n==> Importing data - movies")
p_imp_movies = new(ProtImportMovies,
filesPath=cls.dataset_ribo.getFile('movies'),
samplingRate=2.37, magnification=59000,
voltage=300, sphericalAberration=2.0)
launch(p_imp_movies, wait=True)
cls.movies = p_imp_movies.outputMovies
# Particles
print magentaStr("\n==> Importing data - particles")
p_imp_particles = new(ProtImportParticles,
filesPath=cls.dataset_mda.getFile('particles'),
samplingRate=3.5)
launch(p_imp_particles, wait=True)
cls.particles = p_imp_particles.outputParticles
def _runTomoSubtomogramInitialModelWithVolume(self):
protTomoExtraction = self._runPreviousProtocols()
particles = protTomoExtraction.outputSetOfSubtomogram
self.dataset = DataSet.getDataSet('eman')
self.vol = self.dataset.getFile('volume')
self.protImportVol = self.runImportVolumes(self.vol, 3.5)
self.assertIsNotNone(self.protImportVol.outputVolume,
"There was a problem with SetOfSubtomogram output")
protInitialModel = self.newProtocol(EmanProtTomoInitialModel,
particles=particles,
reference=self.protImportVol.outputVolume,
symmetry="c1",
gaussFilter=-1.5,
filterto=0.03,
fourier=False,
batchSize=20,
learningRate=1,
numberOfIterations=2,
numberOfBatches=1,
shrink=4,
applySim=False)
self.launchProtocol(protInitialModel)
self.assertIsNotNone(protInitialModel.averageSubTomogram,
"There was a problem with subTomograms output")
self.assertIsNotNone(protInitialModel.outputParticles,
"There was a problem with particles output")
return protInitialModel
def _runTomoSubtomogramRefinementWithVolume(self, niter=2, mass=500.0, threads=1, pkeep=1, goldstandard=-1,
goldcontinue=False, sym="c1", localfilter=False, maxtilt=90.0):
protTomoExtraction = self._runPreviousProtocols()
particles = protTomoExtraction.outputSetOfSubtomogram
self.dataset = DataSet.getDataSet('eman')
self.vol = self.dataset.getFile('volume')
self.protImportVol = self.runImportVolumes(self.vol, 3.5)
self.assertIsNotNone(self.protImportVol.outputVolume,
"There was a problem with SetOfSubtomogram output")
protTomoRefinement = self.newProtocol(EmanProtTomoRefinement,
inputSetOfSubTomogram=particles,
inputRef=self.protImportVol.outputVolume,
niter=niter,
mass=mass,
threads=threads,
pkeep=pkeep,
goldstandard=goldstandard,
goldcontinue=goldcontinue,
sym=sym,
localfilter=localfilter,
maxtilt=maxtilt)
self.launchProtocol(protTomoRefinement)
self.assertIsNotNone(protTomoRefinement.averageSubTomogram,
"There was a problem with subTomograms output")
self.assertIsNotNone(protTomoRefinement.outputParticles,
"There was a problem with particles output")
return protTomoRefinement
def setUpClass(cls):
setupTestProject(cls)
cls.ds = DataSet.getDataSet('movies')
cls.importThread = threading.Thread(target=cls._createInputLinks)
cls.importThread.start()
# Wait until the first link is created
time.sleep(5)
def setUpClass(cls):
setupTestProject(cls)
cls.dsRct = DataSet.getDataSet('rct')
cls.micsFn = cls.dsRct.getFile('positions/input_micrographs.xmd')
cls.patternU1 = cls.dsRct.getFile('positions/F_rct_u_*.pos')
cls.patternT1 = cls.dsRct.getFile('positions/F_rct_t_*.pos')
cls.micsUFn1 = cls.dsRct.getFile('untilted')
cls.micsTFn1 = cls.dsRct.getFile('tilted')
cls.dsEman = DataSet.getDataSet('eman')
cls.micsUFn2 = cls.dsEman.getFile('micU')
cls.micsTFn2 = cls.dsEman.getFile('micT')
cls.patternU2 = cls.dsEman.getFile(
"coords/ip3r10252011-0005_0-2_info.json")
cls.patternT2 = cls.dsEman.getFile(
"coords/ip3r10252011-0005_10_info.json")
def setUpClass(cls):
setupTestProject(cls)
cls.ds = DataSet.getDataSet('movies')
cls.importThread = threading.Thread(target=cls._createInputLinks)
cls.importThread.start()
# Wait until the first link is created
time.sleep(5)
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('relion_tutorial')
cls.partFn = cls.dataset.getFile(
'import/refine3d_case2/relion_data.star')
cls.protImport = cls.runImportParticlesStar(cls.partFn, 50000, 3.54)
cls.protPreprocess = cls.runPreprocess(cls.protImport.outputParticles)
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('relion_tutorial')
cls.particlesFn = cls.dataset.getFile('import/case2/particles.sqlite')
print(magentaStr("\n==> Importing data - particles:"))
cls.protImport = cls.runImportParticlesSqlite(cls.particlesFn,
sampling=3.5)
def setUpClass(cls):
"""Prepare the data that we will use later on."""
setupTestProject(cls) # defined in BaseTest, creates cls.proj
cls.jjsoftDataTest = DataSet.getDataSet('tomo-em')
cls.getFile = cls.jjsoftDataTest.getFile('etomo')
cls.setOfTs = cls._runImportTiltSeries()
cls.setOfXcorrTs = cls._runXcorrPrealignment()
cls.setOfFiducials, cls.setOfFiducialTs = cls._runFiducialModel()
def setData(cls, projectData='tomo-em'):
from tomo.tests import DataSet
cls.dataset = DataSet.getDataSet(projectData)
cls.tomogram = cls.dataset.getFile('tomo1')
cls.coords3D = cls.dataset.getFile('overview_wbp.txt')
cls.coords3D_Large = cls.dataset.getFile('overview_wbp_large.txt')
cls.inputSetOfSubTomogram = cls.dataset.getFile('subtomo')
cls.smallTomogram = cls.dataset.getFile('coremask_normcorona.mrc')
def setUpClass(cls):
setupTestProject(cls)
cls.ds = DataSet.getDataSet('relion_tutorial')
cls.importThread = threading.Thread(name="createInputLinksR",
target=cls._createInputLinks)
cls.importThread.start()
# Wait until the first link is created
time.sleep(5)
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('groel')
cls.averages = cls.dataset.getFile('averages')
cls.symmetry = 'd7'
cls.numberOfIterations = 20
cls.numberOfModels = 2
print(magentaStr("\n==> Importing data - class averages:"))
cls.protImportAvg = cls.runImportAverages(cls.averages, 2.1)
def setUpClass(cls):
setupTestProject(cls)
cls.ds = DataSet.getDataSet('relion_tutorial')
cls.ds2 = DataSet.getDataSet('mda')
cls.micsFn = cls.ds.getFile('micrographs/*mrc')
cls.avgsFn = cls.ds2.getFile('averages/averages.stk')
print(magentaStr("\n==> Importing data - micrographs:"))
cls.protImportMics = cls.newProtocol(ProtImportMicrographs,
filesPath=cls.micsFn,
samplingRate=7.08)
cls.launchProtocol(cls.protImportMics)
print(magentaStr("\n==> Importing data - averages:"))
cls.protImportAvgs = cls.newProtocol(ProtImportAverages,
filesPath=cls.avgsFn,
samplingRate=5.04,
checkStack=True)
cls.launchProtocol(cls.protImportAvgs)
def setUpClass(cls):
setupTestProject(cls)
# Data
cls.dataset = DataSet.getDataSet('10010')
cls.initialVolume = cls.dataset.getFile('initialVolume')
cls.particles = cls.dataset.getFile('particles')
cls.protImportVol = cls.runImportVolume(cls.initialVolume, 4.95)
cls.protImportParts = cls.runImportParticles()
def setData(cls):
cls.dataset = DataSet(name='test_zernike3d',
folder='test_zernike3d',
files={
'particles':
'particles/images_1720_norm.xmd',
'volumes': 'volumes/*.vol',
'1720': 'volumes/EMD-1720_norm.vol',
'1723': 'volumes/EMD-1723_norm.vol'
})
cls.dataset = DataSet.getDataSet('test_zernike3d')
cls.particles = cls.dataset.getFile('particles')
cls.volumes = cls.dataset.getFile('volumes')
cls.volume_1720 = cls.dataset.getFile('1720')
cls.volume_1723 = cls.dataset.getFile('1723')
cls.clnm_pd_cpu_gold = cls.dataset.getFile(
'gold_standard_pd/CPU/Volumes_clnm.txt')
cls.clnm_pd_gpu_gold = cls.dataset.getFile(
'gold_standard_pd/GPU/Volumes_clnm.txt')
def setUpClass(cls):
setupTestProject(cls)
cls.ds = DataSet.getDataSet('relion_tutorial')
pathFns = 'import/refine3d/extra'
cls.volFn = cls.ds.getFile(os.path.join(pathFns,
'relion_class001.mrc'))
cls.half1Fn = cls.ds.getFile(
os.path.join(pathFns, 'relion_it025_half1_class001.mrc'))
cls.half2Fn = cls.ds.getFile(
os.path.join(pathFns, 'relion_it025_half2_class001.mrc'))
def setUpClass(cls):
setupTestProject(cls)
cls.dsRelion = DataSet.getDataSet('relion_tutorial')
cls.protImport1 = cls.newProtocol(ProtImportVolumes,
filesPath=cls.dsRelion.getFile('volumes/reference_rotated_masked.vol'),
samplingRate=1.0)
cls.launchProtocol(cls.protImport1)
cls.protImport2 = cls.newProtocol(ProtImportVolumes,
filesPath=cls.dsRelion.getFile('volumes/reference_masked.vol'),
samplingRate=1.0)
cls.launchProtocol(cls.protImport2)
def setUpClass(cls):
setupTestProject(cls)
cls.dsRelion = DataSet.getDataSet('relion_tutorial')
cls.protImport1 = cls.newProtocol(ProtImportVolumes,
filesPath=cls.dsRelion.getFile('volumes/reference_rotated.vol'),
samplingRate=1.0)
cls.launchProtocol(cls.protImport1)
cls.protImport2 = cls.newProtocol(ProtImportVolumes,
filesPath=cls.dsRelion.getFile('volumes/reference.mrc'),
samplingRate=1.0)
cls.launchProtocol(cls.protImport2)
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('eman')
cls.vol = cls.dataset.getFile('volume')
cls.micsUFn = cls.dataset.getFile('micU')
cls.micsTFn = cls.dataset.getFile('micT')
cls.patternU = cls.dataset.getFile(
"coords/ip3r10252011-0005_0-2_info.json")
cls.patternT = cls.dataset.getFile(
"coords/ip3r10252011-0005_10_info.json")
cls.protImportVol = cls.runImportVolumes(cls.vol, 3.6)
def setUpClass(cls):
setupTestProject(cls)
cls.inputDataSet = DataSet.getDataSet('tutorialDataImodCTF')
cls.inputSoTS = cls.inputDataSet.getFile('tsCtf1')
print(magentaStr("\n==> Importing data - tilt series:"))
cls.protImportTS = cls.runImportTiltSeries(
filesPath=os.path.dirname(cls.inputSoTS),
filesPattern="WTI042413_1series4.mdoc",
voltage=300,
sphericalAberration=2.7,
amplitudeContrast=0.07,
anglesFrom=2)
def setUpClass(cls):
setupTestProject(cls)
cls.ds = DataSet.getDataSet('relion_tutorial')
inputStar = cls.ds.getFile('import/classify3d/extra/'
'relion_it015_data.star')
cls.protImport = cls.newProtocol(
ProtImportParticles,
objLabel='particles from relion (auto-refine 3d)',
importFrom=ProtImportParticles.IMPORT_FROM_RELION,
starFile=inputStar,
magnification=10000,
samplingRate=7.08,
haveDataBeenPhaseFlipped=True)
cls.launchProtocol(cls.protImport)
def setUpClass(cls):
setupTestProject(cls)
cls.dataSet = DataSet.getDataSet('xmipp_tutorial')
#
# Imports
#
print magentaStr("\n==> Importing data - Input data")
new = cls.proj.newProtocol # short notation
launch = cls.proj.launchProtocol
# Volumes
print magentaStr("\nImporting Volumes:")
pImpVolume = new(ProtImportVolumes,
samplingRate=1,
filesPath=cls.dataSet.getFile('vol2'))
launch(pImpVolume, wait=True)
# volume.vol
cls.inputVol = pImpVolume.outputVolume
pImpVolume2 = new(ProtImportVolumes,
samplingRate=1,
filesPath=cls.dataSet.getFile('vol1'))
launch(pImpVolume2, wait=True)
cls.inputVol2 = pImpVolume2.outputVolume
# References
print magentaStr("\nImporting References:")
pImpRef = new(ProtImportVolumes,
samplingRate=1,
filesPath=cls.dataSet.getFile('vol3'))
launch(pImpRef, wait=True)
# reference.vol
cls.inputRef = pImpRef.outputVolume
pImpRef2 = new(ProtImportVolumes,
samplingRate=1,
filesPath=cls.dataSet.getFile('vol1'))
launch(pImpRef2, wait=True)
cls.inputRef2 = pImpRef2.outputVolume
# Masks
print magentaStr("\nImporting Mask:")
pImpMask = new(ProtImportMask,
maskPath=cls.dataSet.getFile('mask3d'),
samplingRate=1)
launch(pImpMask, wait=True)
cls.mask = pImpMask.outputMask
def setUpClass(cls):
setupTestProject(cls)
cls.dataSet = DataSet.getDataSet('xmipp_tutorial')
#
# Imports
#
print magentaStr("\n==> Importing data - Input data")
new = cls.proj.newProtocol # short notation
launch = cls.proj.launchProtocol
# Volumes
print magentaStr("\nImporting Volumes:")
pImpVolume = new(ProtImportVolumes, samplingRate=1,
filesPath=cls.dataSet.getFile('vol2'))
launch(pImpVolume, wait=True)
# volume.vol
cls.inputVol = pImpVolume.outputVolume
pImpVolume2 = new(ProtImportVolumes, samplingRate=1,
filesPath=cls.dataSet.getFile('vol1'))
launch(pImpVolume2, wait=True)
cls.inputVol2 = pImpVolume2.outputVolume
# References
print magentaStr("\nImporting References:")
pImpRef = new(ProtImportVolumes, samplingRate=1,
filesPath=cls.dataSet.getFile('vol3'))
launch(pImpRef, wait=True)
# reference.vol
cls.inputRef = pImpRef.outputVolume
pImpRef2 = new(ProtImportVolumes, samplingRate=1,
filesPath=cls.dataSet.getFile('vol1'))
launch(pImpRef2, wait=True)
cls.inputRef2 = pImpRef2.outputVolume
# Masks
print magentaStr("\nImporting Mask:")
pImpMask = new(ProtImportMask,
maskPath=cls.dataSet.getFile('mask3d'),
samplingRate=1)
launch(pImpMask, wait=True)
cls.mask = pImpMask.outputMask
def _runTomoTempMatch(self):
protImportTomogramBig = self.newProtocol(tomo.protocols.ProtImportTomograms,
filesPath=self.tomogram,
samplingRate=5)
protImportTomogramSmall = self.newProtocol(tomo.protocols.ProtImportTomograms,
filesPath=self.smallTomogram,
samplingRate=5)
self.launchProtocol(protImportTomogramBig)
self.launchProtocol(protImportTomogramSmall)
self.assertSetSize(protImportTomogramBig.outputTomograms, size=1,
msg="There was a problem with tomogram output")
self.assertSetSize(protImportTomogramSmall.outputTomograms, size=1, msg="There was a problem with tomogram "
"output")
self.dataset = DataSet.getDataSet('eman')
self.vol = self.dataset.getFile('volume')
self.protImportVol = self.runImportVolumes(self.vol, 3.5)
self.assertIsNotNone(self.protImportVol.outputVolume,
"There was a problem with SetOfSubtomogram output")
protTomoTempMatchBig = self.newProtocol(EmanProtTomoTempMatch,
inputSet=protImportTomogramBig.outputTomograms,
ref=self.protImportVol.outputVolume,
boxSize=128,
sym="c1")
protTomoTempMatchSmall = self.newProtocol(EmanProtTomoTempMatch,
inputSet=protImportTomogramSmall.outputTomograms,
ref=self.protImportVol.outputVolume,
boxSize=128,
sym="d1")
self.launchProtocol(protTomoTempMatchBig)
self.launchProtocol(protTomoTempMatchSmall)
return protTomoTempMatchBig, protTomoTempMatchSmall
def setUpClass(cls):
setupTestOutput(cls)
cls.ds = DataSet.getDataSet('xmipp_tutorial')
cls.dsEmx = DataSet.getDataSet('emx')
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('ribo_movies')
cls.movies = cls.dataset.getFile('movies')
cls.crdsDir = cls.dataset.getFile('posAllDir')
def setData(cls, dataProject='resmap'):
cls.dataset = DataSet.getDataSet(dataProject)
cls.map3D = cls.dataset.getFile('betagal')
cls.setVols = cls.dataset.getFile('*.mrc')
cls.dsParticles = DataSet.getDataSet('xmipp_tutorial')
def setUpClass(cls):
setupTestProject(cls)
cls.dsXmipp = DataSet.getDataSet("xmipp_tutorial")
cls.dsEmx = DataSet.getDataSet("emx")
cls.dsMda = DataSet.getDataSet("mda")
cls.dsRelion = DataSet.getDataSet("relion_tutorial")
def setData(cls, dataProject='resmap'):
cls.dataset = DataSet.getDataSet(dataProject)
cls.map3D = cls.dataset.getFile('betagal')
cls.half1 = cls.dataset.getFile('betagal_half1')
cls.half2 = cls.dataset.getFile('betagal_half2')
cls.mask = cls.dataset.getFile('betagal_mask')
def setUpClass(cls):
setupTestOutput(cls)
cls.ds = DataSet.getDataSet('relion31_tutorial_precalculated')
def setUpClass(cls):
setupTestProject(cls)
cls.dsXmipp = DataSet.getDataSet('xmipp_tutorial')
#cls.dsRelion = DataSet.getDataSet('relion_tutorial')
cls.dsGroel = DataSet.getDataSet('groel')
def setUpClass(cls):
setupTestProject(cls)
cls.dsXmipp = DataSet.getDataSet('xmipp_tutorial')
cls.dsEmx = DataSet.getDataSet('emx')
cls.dsMda = DataSet.getDataSet('mda')
cls.dsRelion = DataSet.getDataSet('relion_tutorial')
def setUpClass(cls):
# Create a new project
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('mda')
cls.particlesFn = cls.dataset.getFile('particles/xmipp_particles.xmd')
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('xmipp_tutorial')
cls.crdsDir = cls.dataset.getFile('boxingDir')
cls.micsFn = cls.dataset.getFile('allMics')
cls.vol1 = cls.dataset.getFile('vol1')
def setUpClass(cls):
setupTestProject(cls)
cls.dsXmipp = DataSet.getDataSet('xmipp_tutorial')
cls.dsGrigorieff = DataSet.getDataSet('grigorieff')
def setUpClass(cls):
setupTestOutput(cls)
cls.dataset = DataSet.getDataSet('relion_tutorial')
cls.getFile = cls.dataset.getFile
cls.ds = DataSet.getDataSet('relion_tutorial')
def setUpClass(cls):
setupTestProject(cls)
cls.ds = DataSet.getDataSet('relion_tutorial')
def setUpClass(cls):
setupTestOutput(cls)
cls.dataset = DataSet.getDataSet('emx')
def setUpClass(cls):
# Create a new project
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('mda')
cls.particlesFn = cls.dataset.getFile('particles')
def setUpClass(cls):
setupTestOutput(cls)
cls.ds = DataSet.getDataSet('relion_tutorial')
def setUpClass(cls):
setupTestProject(cls)
cls.dsMovies = DataSet.getDataSet('movies')
def setUpClass(cls):
setupTestProject(cls)
cls.dsXmipp = DataSet.getDataSet('xmipp_tutorial')
cls.dsGrigorieff = DataSet.getDataSet('grigorieff')
def setUpClass(cls):
# Create a new project
setupTestProject(cls)
cls.ds = DataSet.getDataSet("nma")
def setData(cls, dataProject='resmap'):
cls.dataset = DataSet.getDataSet(dataProject)
cls.map3D = cls.dataset.getFile('betagal')
cls.half1 = cls.dataset.getFile('betagal_half1')
cls.half2 = cls.dataset.getFile('betagal_half2')
cls.mask = cls.dataset.getFile('betagal_mask')
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('groel')
cls.averages = cls.dataset.getFile('averages')
def setData(cls, dataProject='resmap'):
cls.dataset = DataSet.getDataSet(dataProject)
cls.map3D = cls.dataset.getFile('betagal')
cls.setVols = cls.dataset.getFile('*.mrc')
cls.dsParticles = DataSet.getDataSet('xmipp_tutorial')
def setUpClass(cls):
setupTestProject(cls)
cls.dsRelion = DataSet.getDataSet("relion_tutorial")
# Import only once for all tests
cls.protImport = cls.runImportFromScipion()