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):
setupTestProject(cls)
TestBase.setData()
print(magentaStr("\n==> Importing data - micrographs:"))
cls.protImport = cls.runImportMicrographBPV(cls.micFn)
print(magentaStr("\n==> Running cistem - ctffind:"))
cls.protCtfRun = cls.runCtffind(cls.protImport.outputMicrographs)
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('tomo-em')
cls.tomogram = cls.dataset.getFile('tomo1')
cls.coords3D = cls.dataset.getFile('overview_wbp.txt')
cls.table = cls.dataset.getFile('initial.tbl')
cls.path = cls.dataset.getPath()
def setUpClass(cls):
# Prepare test project
setupTestProject(cls)
# Prepare the test data
cls.setData()
# Run needed protocols
cls.runImportMicrograph()
def setUpClass(cls):
pwtests.setupTestProject(cls)
cls.dsXmipp = pwtests.DataSet.getDataSet('xmipp_tutorial')
cls.dsRelion = pwtests.DataSet.getDataSet('relion_tutorial')
cls.dsEmx = pwtests.DataSet.getDataSet('emx')
cls.dsMda = pwtests.DataSet.getDataSet('mda')
cls.dsModBuild = pwtests.DataSet.getDataSet('model_building_tutorial')
def setUpClass(cls):
pwtests.setupTestProject(cls, writeLocalConfig=True)
cls.dataPath = os.environ.get("SCIPION_ED_TESTDATA")
if not os.path.exists(cls.dataPath):
raise Exception("Can not run DIALS tests, missing file:\n %s" %
cls.dataPath)
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):
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):
setupTestProject(cls)
TestMonoResBase.setData()
cls.protImportVol = cls.runImportVolumes(cls.map3D, 3.54)
cls.protImportHalf1 = cls.runImportVolumes(cls.half1, 3.54)
cls.protImportHalf2 = cls.runImportVolumes(cls.half2, 3.54)
cls.protCreateMask = cls.runCreateMask(cls.protImportVol.outputVolume, 0.02)
def setUpClass(cls):
def generate(suffix="feat"):
(fd, filename) = mkstemp(suffix=suffix)
f = os.fdopen(fd, "w")
fileContent = """# XMIPP_STAR_1 *
# Type of feature (sph, blo, gau, Cyl, dcy, cub, ell, con)(Required)
# The operation after adding the feature to the phantom (+/=) (Required)
# The feature density (Required)
# The feature center (Required)
# The vector for special parameters of each vector (Required)
# Sphere: [radius] Blob : [radius alpha m] Gaussian : [sigma]
# Cylinder : [xradius yradius height rot tilt psi]
# DCylinder : [radius height separation rot tilt psi]
# Cube : [xdim ydim zdim rot tilt psi]
# Ellipsoid : [xradius yradius zradius rot tilt psi]
# Cone : [radius height rot tilt psi]
data_block1
_dimensions3D '100 100 100'
_phantomBGDensity 0.
_scale 1.
data_block2
loop_
_featureType
_featureOperation
_featureDensity
_featureCenter
_featureSpecificVector
blo = 1 '0 0 0' '50 10.4 2'
"""
f.write(fileContent)
f.close()
return filename
cls.inFileName = generate()
pwtests.setupTestProject(cls)
def setUpClass(cls):
pwtests.setupTestOutput(cls)
# Set the application domain
Config.setDomain("pyworkflowtests")
pwtests.setupTestProject(cls)
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)
TestResMapBase.setData()
cls.protImportVol = cls.runImportVolumes(cls.map3D, 3.54)
cls.protImportHalf1 = cls.runImportVolumes(cls.half1, 3.54)
cls.protImportHalf2 = cls.runImportVolumes(cls.half2, 3.54)
cls.protImportMask = cls.runImportMask(cls.mask, 3.54)
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):
pwtest.setupTestProject(cls)
cls.setData()
cls.protImportHalf1 = cls.runImportVolumes(cls.half1, 3.54,
'import half1')
cls.protImportHalf2 = cls.runImportVolumes(cls.half2, 3.54,
'import half2')
def setUpClass(cls):
setupTestProject(cls)
TestResMapBase.setData()
cls.protImportVol = cls.runImportVolumes(cls.map3D, 3.54)
cls.protImportHalf1 = cls.runImportVolumes(cls.half1, 3.54)
cls.protImportHalf2 = cls.runImportVolumes(cls.half2, 3.54)
cls.protImportMask = cls.runImportMask(cls.mask, 3.54)
def setUpClass(cls):
setupTestProject(cls)
TestEmanBase.setData('mda')
print(magentaStr("\n==> Importing data - particles:"))
cls.protImport = cls.runImportParticles(cls.particlesFn, 3.5)
print(magentaStr("\n==> Importing data - volume:"))
cls.protImportVol = cls.runImportVolumes(cls.vol, 3.5)
def setUpClass(cls):
pwtests.setupTestProject(cls)
cls.dataset = pwtests.DataSet.getDataSet('rct')
cls.allCrdsDir = cls.dataset.getFile('positions')
cls.micsUFn = cls.dataset.getFile('untilted')
cls.micsTFn = cls.dataset.getFile('tilted')
cls.classesSqlite = cls.dataset.getFile('classes')
def setUpClass(cls):
setupTestProject(cls)
TestMonoResBase.setData()
cls.protImportVol = cls.runImportVolumes(cls.map3D, 3.54)
cls.protImportHalf1 = cls.runImportVolumes(cls.half1, 3.54)
cls.protImportHalf2 = cls.runImportVolumes(cls.half2, 3.54)
cls.protCreateMask = cls.runCreateMask(cls.protImportVol.outputVolume, 0.02)
def setUpClass(cls):
setupTestProject(cls)
cls.setData()
print(magentaStr("\n==> Importing data - movies:"))
cls.protImport1 = cls.runImportMovies(
cls.ds.getFile('qbeta/qbeta.mrc'), magnification=50000)
cls.protImport2 = cls.runImportMovies(cls.ds.getFile('cct/cct_1.em'),
magnification=61000)
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 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):
pwtests.setupTestProject(cls, writeLocalConfig=True)
cls.dataPath = os.path.join(pwed.Config.SCIPION_ED_TESTDATA,
'190503')
if not os.path.exists(cls.dataPath):
raise Exception("Can not run XDS tests, missing file:\n %s"
% cls.dataPath)
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('tomo-em')
cls.parentDir = cls.dataset.getFile('tsMParentFolder')
cls.ts10Dir = cls.dataset.getFile('tsM10Dir')
cls.ts31Dir = cls.dataset.getFile('tsM31Dir')
cls.path = cls.dataset.getPath()
cls.pattern = '*/stack*.mdoc'
cls.sRate = 1.716
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):
if SKIP_BASE_TESTS:
cls.skipTest(cls, "Skipping base tests")
pwtests.setupTestProject(cls, writeLocalConfig=True)
cls.dataPath = pwed.Config.SCIPION_ED_TESTDATA
if not os.path.exists(cls.dataPath):
raise Exception(
f"Can not run ED tests, missing file:\n {cls.dataPath}")
def setUpClass(cls):
setupTestProject(cls)
TestLocalDeblurBase.setData()
cls.protImportVol = cls.runImportVolumes(cls.map3D, 3.54)
cls.protCreateMask = cls.runCreateMask(cls.protImportVol.outputVolume,
0.02)
cls.protImportVol2 = cls.runImportVolumes2('3488')
cls.protCreateMask2 = cls.runCreateMask2(
cls.protImportVol2.outputVolume, 0.167)
def setUpClass(cls):
setupTestProject(cls)
TestZernike3DBase.setData()
cls.protImportPart = cls.runImportParticles(cls.particles)
cls.protImportVols = cls.runImportVolumes(cls.volumes)
cls.protImportVol_1720 = cls.runImportVolume(cls.volume_1720, '1720')
cls.protImportVol_1723 = cls.runImportVolume(cls.volume_1723, '1723')
cls.CORR_FILE = 'CoordinateMatrixCorr3.txt'
cls.EXPECTED_CORR_MAP = 'Unexpected correlation structure mapping'
def setUpClass(cls):
setupTestProject(cls)
TestMultipleFSCsBase.setData()
cls.protImportVol = cls.runImportVolumes(cls.map3D, 3.54, 'import vol')
cls.protImportHalf1 = cls.runImportVolumes(cls.half1, 3.54,
'import half1')
cls.protImportHalf2 = cls.runImportVolumes(cls.half2, 3.54,
'import half2')
cls.protImportMask = cls.runImportMask(cls.mask, 3.54, 'import mask')
def setUpClass(cls):
# Prepare test project
setupTestProject(cls)
# Prepare the test data
cls.setData()
# Execute the protocols required to generate the inputs for the janni protocol, which will be the preprocessed
# images (downsampled) in the xmipp tutorial. Thus, the micrographs must be loaded and preprocessed before
# executing the test
cls.runImportMicrograph()
cls.runMicPreprocessing()
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 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):
pwtests.setupTestProject(cls)
ds = pwtests.DataSet.getDataSet('tomosegmemtv')
cls.ds = ds
cls.samplingRate = 1
# Because only one tomogram is provided in the tutorial, 2 links will be created pointing to the same file, so
# they can be interpreted as a set of two tomograms, making the test complexity closer to the real usage
cls.virtualTomos = ['vTomo1', 'vTomo2']
virtualTomos = [join(ds.getPath(), fpath + '.mrc') for fpath in cls.virtualTomos]
[symlink(ds.getFile('tomogram'), virtualTomo) for virtualTomo in virtualTomos if not exists(virtualTomo)]
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.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):
"""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):
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)
TestAddNoiseBase.setData()
cls.protImportVol = cls.runImportVolumes(cls.map3D, 3.54)
cls.protImportVols = cls.runImportVolumes(cls.setVols, 3.54)
cls.protImportParts = cls.runImportParticles()
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('groel')
cls.averages = cls.dataset.getFile('averages')
def setUpClass(cls):
tests.setupTestProject(cls)
cls.dataset = tests.DataSet.getDataSet('emx')
cls.dsRelion = tests.DataSet.getDataSet('relion_tutorial')
def setUpClass(cls):
# Create a new project
setupTestProject(cls)
cls.ds = DataSet.getDataSet("nma")
def setUpClass(cls):
setupTestProject(cls)
def setUpClass(cls):
tests.setupTestProject(cls)
cls.dataset = tests.DataSet.getDataSet('emx')
def setUpClass(cls):
# Create a new project
tests.setupTestProject(cls)
cls.ds = tests.DataSet.getDataSet('initial_volume')
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):
tests.setupTestProject(cls)
cls.baseUrl = "http://i2pc.cnb.csic.es/emx/resourcesEmx/Tests/"
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.dsXmipp = DataSet.getDataSet('xmipp_tutorial')
#cls.dsRelion = DataSet.getDataSet('relion_tutorial')
cls.dsGroel = DataSet.getDataSet('groel')
def setUpClass(cls):
setupTestProject(cls)
cls.dataset = DataSet.getDataSet('ribo_movies')
cls.movies = cls.dataset.getFile('movies')
cls.crdsDir = cls.dataset.getFile('posAllDir')
def setUpClass(cls):
setupTestProject(cls)
cls.dsXmipp = DataSet.getDataSet('xmipp_tutorial')
cls.dsGrigorieff = DataSet.getDataSet('grigorieff')
def setUpClass(cls):
tests.setupTestProject(cls)
cls.dataset = tests.DataSet.getDataSet('CTFDiscrepancy')
def setUpClass(cls):
setupTestProject(cls)
cls.dsMovies = DataSet.getDataSet('movies')
def setUpClass(cls):
setupTestProject(cls)
cls.dsRelion = DataSet.getDataSet("relion_tutorial")
# Import only once for all tests
cls.protImport = cls.runImportFromScipion()
def setUpClass(cls):
tests.setupTestProject(cls)
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.ds = DataSet.getDataSet('relion_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")
