def __init__(self, particleList=None, centerVector=None, symmetry=None):
"""
@param particleList: The particle List
@param centerVector: Center of viron (sphere) in origin of particles
@param symmetry: We might already know some symmetry properties of the particles
"""
from pytom.basic.structures import PointSymmetry
self._particleList = particleList or []
self._centerVector = centerVector or []
self._symmetry = symmetry or PointSymmetry(1)
from pytom.cluster.mcoEXMXStructures import MCOEXMXJob
from pytom.basic.structures import ParticleList, Reference, Mask, Wedge, SampleInformation, PointSymmetry
from pytom.score.score import FLCFScore
from pytom.frontend.serverpages.createMCOEXMXJob import createRunscripts
from pytom.alignment.preprocessing import Preprocessing
p = ParticleList()
p.fromXMLFile(particleList)
m = Mask(mask)
w = Wedge([float(wedge1), float(wedge2)])
pre = Preprocessing(lowestFrequency=float(lowestFrequency),
highestFrequency=float(highestFrequency))
sample = SampleInformation(pixelSize=float(pixelSize),
particleDiameter=float(diameter))
if symmetryN is None or symmetryAxisZ is None or symmetryAxisX is None:
sym = None
else:
sym = PointSymmetry(nfold=int(symmetryN),
z2=float(symmetryAxisZ),
x=float(symmetryAxisX))
job = MCOEXMXJob(particleList=p,numberIterations=numberIterations,\
destinationDirectory=destination,mask=mask,score=FLCFScore(),preprocessing=pre,\
wedgeInfo=w,binning=int(binning),sampleInformation=sample,numberClasses=int(numberClasses),\
endThreshold=float(endThreshold),symmetry = sym,doAlignment = False,frmBandwidth = None)
job.toXMLFile(jobName)
createRunscripts(jobName[:-3] + 'sh', jobName)
def interpretRequestParameters(parameters):
"""
interpretRequestParameters
"""
from pytom.basic.structures import ParticleList, SampleInformation, Reference, Mask, Wedge, PointSymmetry
from pytom.alignment.preprocessing import Preprocessing
from pytom.frontend.serverpages.serverMessages import FileMessage
particleList = ParticleList('.')
if 'plXML' in parameters:
particleList.fromXMLFile(parameters['plXML'])
elif 'plDIR' in parameters:
particleList = ParticleList(parameters['plDIR'])
particleList.loadDirectory()
else:
raise RuntimeError('ParticleList parameter missing in request!')
sampleInfo = SampleInformation()
if 'pixSize' in parameters:
sampleInfo.setPixelSize(parameters['pixSize'])
else:
raise RuntimeError('Pixelsize parameter missing in request!')
if 'partDia' in parameters:
sampleInfo.setParticleDiameter(parameters['partDia'])
else:
raise RuntimeError('Particle diameter missing in request!')
reference = ''
if 'ref' in parameters:
reference = Reference(parameters['ref'])
else:
raise RuntimeError('Reference parameter missing in request!')
if 'mask' in parameters:
mask = Mask(parameters['mask'])
else:
raise RuntimeError('Mask parameter missing in request!')
angles = None
if 'sampling' in parameters:
if parameters['sampling'] == 'GLOBAL':
from pytom.angles.globalSampling import GlobalSampling
if 'angFile' in parameters:
angles = GlobalSampling(parameters['angFile'])
else:
raise RuntimeError('Angle file missing in request!')
else:
from pytom.angles.localSampling import LocalSampling
if 'angStart' in parameters:
startIncrement = int(parameters['angStart'])
else:
raise RuntimeError('Angle start missing in request!')
if 'angShells' in parameters:
shells = int(parameters['angShells'])
else:
raise RuntimeError('Angle shells missing in request!')
if 'angInc' in parameters:
shellIncrement = int(parameters['angInc'])
else:
raise RuntimeError('Angle increment missing in request!')
angles = LocalSampling(shells=shells, increment=startIncrement)
else:
raise RuntimeError('Sampling completely missing in request!')
if not 'lowestF' in parameters:
raise RuntimeError('Lowest frequency parameter missing in request!')
if not 'highestF' in parameters:
raise RuntimeError('Highest frequency parameter missing in request!')
if not 'filtSm' in parameters:
raise RuntimeError('Filter smooth parameter missing in request!')
preprocessing = Preprocessing(float(parameters['lowestF']),
float(parameters['highestF']),
float(parameters['filtSm']))
adaptive = True
if 'adapt' in parameters:
fscCriterion = 0.5
resOffset = 0.1
angleFactor = 0.5
adaptive = parameters['adapt'] == 'ON'
if parameters['adapt'] == 'ON':
if 'adResC' in parameters:
fscCriterion = float(parameters['adResC'])
else:
raise RuntimeError('Resolution criterion missing in request!')
if 'adResOf' in parameters:
resOffset = parameters['adResOf']
else:
raise RuntimeError(
'Resolution offset parameter missing in request!')
if 'angFac' in parameters:
angleFactor = float(parameters['angFac'])
else:
raise RuntimeError(
'Angular factor parameter missing in request!')
else:
raise RuntimeError('Adaptive parameter missing in request!')
score = None
if 'score' in parameters:
if parameters['score'] == 'xcf':
from pytom.score.score import xcfScore as scoreClass
elif parameters['score'] == 'nxcf':
from pytom.score.score import nxcfScore as scoreClass
elif parameters['score'] == 'flcf':
from pytom.score.score import FLCFScore as scoreClass
score = scoreClass()
else:
raise RuntimeError('Score parameter missing in request!')
if 'pkPriRad' in parameters:
radius = float(parameters['pkPriRad'])
else:
raise RuntimeError('Peak distance parameter missing in request!')
if 'pkSmooth' in parameters:
smooth = float(parameters['pkSmooth'])
else:
raise RuntimeError('Peak distance smooth missing in request!')
score.setPeakPrior(radius=radius, smooth=smooth)
if 'iter' in parameters:
iterations = int(parameters['iter'])
else:
raise RuntimeError('Number of iterations missing in request!')
if 'binning' in parameters:
binning = int(parameters['binning'])
else:
raise RuntimeError('Scaling parameter missing in request!')
if 'dest' in parameters:
destination = parameters['dest']
else:
raise RuntimeError('Destination parameter missing in request!')
from pytom.alignment.ExMaxAlignment import ExMaxJob
job = ExMaxJob(particleList, destination, reference, score, angles, mask,
PointSymmetry(1), 1, iterations, preprocessing, -1, binning,
sampleInfo, fscCriterion, adaptive, resOffset, angleFactor)
#print job
jobXMLFile = ''
if 'jobFile' in parameters:
jobXMLFile = parameters['jobFile']
job.toXMLFile(jobXMLFile)
if jobXMLFile[-4:] == '.xml':
jobRunFile = jobXMLFile[0:-4]
else:
jobRunFile = jobXMLFile
createRunscripts(jobRunFile + '.sh', jobXMLFile)
return FileMessage('AlignmentJob', jobXMLFile, 'created')
try:
particleListName, volumeName, result, numberSymmetries, z1, x, z2, help = parse_script_options(
sys.argv[1:], helper)
except Exception as e:
print(e)
sys.exit()
if particleListName:
pl = ParticleList('.')
pl.fromXMLFile(particleListName)
elif volumeName:
volume = read(volumeName)
else:
raise RuntimeError(
'You must specify either a particle list or a volume file for symmetrization.'
)
if not z2:
z2 = 0
if not x:
x = 0
symmetry = PointSymmetry(numberSymmetries, z2, x)
if particleListName:
newParticleList = symmetry.apply(pl)
newParticleList.average(resul)
elif volumeName:
newVolume = symmetry.applyToParticle(volume, Rotation(0, z2, x))
newVolume.write(result)
def __init__(self,
particleList=None,
numberIterations=None,
destinationDirectory=None,
mask=None,
score=None,
preprocessing=None,
wedgeInfo=None,
binning=None,
sampleInformation=None,
numberClasses=None,
endThreshold=None,
symmetry=None,
doAlignment=False,
frmBandwidth=None):
"""
__init__:
@param particleList: The particles
@type particleList: L{pytom.basic.structures.ParticleList}
@param numberIterations: Number of kmeans rounds
@type numberIterations: int
@param destinationDirectory: Where will results be stored?
@type destinationDirectory: str
@param mask: Score mask
@type mask: L{pytom.basic.structures.Mask}
@param score: The score
@type score: Any child of L{pytom.alignment.score.Score}
@param preprocessing: Bandpass and other things here
@type preprocessing: L{pytom.alignment.preprocessing.Preprocessing}
@param wedgeInfo:
@type wedgeInfo: L{pytom.basic.structures.WedgeInfo}
@param binning: Binning factor.
@type binning:
@param sampleInformation:
@type sampleInformation:
@param numberClasses: Optional number classes. Particle List will be radomised if no predifined class membership is provided.
@type numberClasses: int
@param endThreshold: End threshold of how many particles at least should jump to continue (value as fraction between 0 and 1)
@type endThreshold: float
@param symmetry: Set symmetry for particles, default is none
@type symmetry: Any child of L{pytom.basic.structures.Symmetry}
@param doAlignment: Include FRM alignment in classification. Default is False.
@type doAlignment: boolean
@param frmBandwidth: The bandwidth of the spherical harmonics - lowestBand used, highestBand used
@type frmBandwidth: [lowestBand,highestBand]
"""
from pytom.basic.structures import PointSymmetry, HelicalSymmetry, Reference
from pytom.angles.angleList import OneAngleList
from pytom.alignment.ExMaxAlignment import ExMaxJob
#self._particleList = particleList
if numberIterations:
self._numberIterations = int(numberIterations)
else:
self._numberIterations = 0
if destinationDirectory:
self._destinationDirectory = str(destinationDirectory)
else:
self._destinationDirectory = None
self._numberClasses = numberClasses
self._endThreshold = endThreshold
rotations = OneAngleList()
rotations.append(0, 0, 0)
if not symmetry.__class__ in [PointSymmetry, HelicalSymmetry]:
symmetry = PointSymmetry(1)
self._exMaxJob = ExMaxJob(particleList,
self._destinationDirectory,
Reference(''),
score,
rotations,
mask,
symmetry,
0,
1,
preprocessing,
-1.0,
binning,
sampleInformation,
0.5,
adaptiveResolution=False)
self._doAlignment = doAlignment
self._frmBandwidth = frmBandwidth