def PeakJob_Test(self):
from pytom.localization.peak_job import PeakJob
from pytom.basic.structures import Mask, Reference, WedgeInfo
from pytom.localization.structures import Volume
from pytom.score.score import FLCFScore
from pytom.angles.angleList import AngleList
v = Volume(self.testfilename)
ref = Reference(self.testfilename)
m = Mask(self.testfilename)
w = WedgeInfo(30)
s = FLCFScore()
rot = AngleList([[1, 1, 1], [2, 2, 2], [3, 3, 3]])
a = PeakJob(v, ref, m, w, rot, s, 1)
xmlObj = a.toXML()
b = PeakJob()
b.fromXML(xmlObj)
self.assertTrue(b.volume.getFilename() == a.volume.getFilename(),
msg='')
self.assertTrue(b.jobID == a.jobID, msg='')
self.assertTrue(b.reference.getReferenceFilename() ==
a.reference.getReferenceFilename(),
msg='')
self.assertTrue(b.mask.getFilename() == a.mask.getFilename(), msg='')
self.assertTrue(b.wedge.getWedgeAngle() == a.wedge.getWedgeAngle(),
msg='')
self.assertTrue(b.score.getScoreFunc() == a.score.getScoreFunc(),
msg='')
def fromXML(self,xmlObj):
"""
fromXML : Assigns values to job attributes from XML object
@param xmlObj: A xml object
@type xmlObj: L{lxml.etree._Element}
@author: Thomas Hrabe
"""
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
raise ParameterError('You must provide a valid XML-CorrelationMatrixJob object.')
from pytom.basic.structures import ParticleList,Mask
particleListObject = xmlObj.xpath('ParticleList')
self._particleList = ParticleList('/')
self._particleList.fromXML(particleListObject[0])
maskObject = xmlObj.xpath('Mask')[0]
self._mask = Mask()
self._mask.fromXML(maskObject)
self._resultMatrixName = xmlObj.get('ResultMatrixName')
self._applyWedge = xmlObj.get('ApplyWedge') == 'True'
self._binningFactor = float(xmlObj.get('Binning'))
self._lowestFrequency = float(xmlObj.get('LowestFrequency'))
self._highestFrequency = float(xmlObj.get('HighestFrequency'))
def PeakJobMsg_Test(self):
from pytom.localization.peak_job_msg import PeakJobMsg
from pytom.localization.peak_job import PeakJob
from pytom.basic.structures import Mask, Reference, WedgeInfo
from pytom.localization.structures import Volume
from pytom.score.score import FLCFScore
from pytom.angles.angleList import AngleList
v = Volume(self.testfilename)
ref = Reference(self.testfilename)
m = Mask(self.testfilename)
w = WedgeInfo(30)
s = FLCFScore()
rot = AngleList([[1, 1, 1], [2, 2, 2], [3, 3, 3]])
j = PeakJob(v, ref, m, w, rot, s)
a = PeakJobMsg(str(0), str(1))
a.setJob(j)
xmlObj = a.toXML()
b = PeakJobMsg()
b.fromXML(xmlObj)
self.assertTrue(b.getSender() == a.getSender(), msg='')
self.assertTrue(b.getRecipient() == a.getRecipient(), msg='')
def __init__(self,particleList=None,angleObject=None,maskFile=None,scoreObject=None,startClassNumber=0,destinationDirectory='.',preprocessing = None):
from pytom.tools.files import checkDirExists
from pytom.angles.angleList import AngleList
from pytom.basic.structures import ParticleList
self._particleList = particleList or ParticleList('/')
self._angleObject = angleObject or AngleList()
self._startClassNumber = startClassNumber
self._maskFile = maskFile or None
if preprocessing:
self._preprocessing = preprocessing
else:
from pytom.alignment.preprocessing import Preprocessing
self._preprocessing = Preprocessing()
if self._maskFile.__class__ == str:
from pytom.basic.structures import Mask
self._maskFile = Mask(self.maskFile)
self._score = scoreObject
if not checkDirExists(destinationDirectory):
raise Exception('Destination directory ' + destinationDirectory + ' does not exist.')
if not destinationDirectory[len(destinationDirectory)-1] == '/':
destinationDirectory = destinationDirectory + '/'
self._destinationDirectory = destinationDirectory
def __init__(self,particle=None,particleList=None,mask=None,particleIndex = None,applyWedge = True,binningFactor=0,lowestFrequency=-1,highestFrequency=-1):
"""
__init__:
@param particle: Particle
@type particle: pytom.alignment.structures.Particle
@param particleList: ParticleList of all particles will be correlated with self._particle
@type particleList: pytom.alignment.structures.ParticleList
@param mask: Mask used for correlation
@type mask: str
@param applyWedge: Apply wedge during correlation. True by default, disable for rotation classification.
@type applyWedge: Bool
@param binningFactor: Binning factor accroding to libtomc definition. 0 by default.
@type binningFactor: unsigned int
@param lowestFrequency: Lowest frequency for bandpass in nyquist
@type lowestFrequency: float
@param highestFrequency: Highest frequency for bandpass in nyquist
@type highestFrequency: float
"""
from pytom.basic.structures import Particle,ParticleList,Mask
if particle and particle.__class__ != Particle:
raise ParameterError('You must provide a Particle object.')
if particleList and particleList.__class__ != ParticleList:
raise ParameterError('You must provide a ParticleList object.')
self._particle = particle
self._particleList = particleList
if not mask:
mask = Mask()
elif mask.__class__ == str:
mask = Mask(mask)
elif mask.__class__ != Mask:
from pytom.basic.exceptions import ParameterError
raise ParameterError('Mask must be a string or Mask object!')
self._mask = mask
self._particleIndex = particleIndex
self._applyWedge = applyWedge
self._binningFactor = binningFactor
self._lowestFrequency = lowestFrequency
self._highestFrequency = highestFrequency
def fromXML(self, xmlObj):
"""
fromXML:
@param xmlObj: A xml object
@type xmlObj: L{lxml.etree._Element}
@author: Thomas Hrabe
"""
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
from pytom.basic.exceptions import ParameterError
raise ParameterError(
'Is not a lxml.etree._Element! You must provide a valid XMLobject.'
)
if xmlObj.tag == 'GrowingAverageJob':
job_element = xmlObj
else:
from pytom.basic.exceptions import ParameterError
raise ParameterError(
'Is not a GrowingAverageJobXML! You must provide a valid GrowingAverageJobXML object.'
)
from pytom.angles.angle import AngleObject
from pytom.score.score import fromXML as scoreFromXML
from pytom.basic.structures import ParticleList
from pytom.alignment.preprocessing import Preprocessing
self.startParticleNumber = int(job_element.get('StartParticleNumber'))
mask = job_element.xpath('Mask')[0]
from pytom.basic.structures import Mask
self.maskFile = Mask('')
self.maskFile.fromXML(mask)
self.destinationDirectory = job_element.get('DestinationDirectory')
particleXML = job_element.xpath('ParticleList')[0]
self.particleList = ParticleList('/', [])
self.particleList.fromXML(particleXML)
angleXML = job_element.xpath('Angles')[0]
ang = AngleObject()
self.angleObject = ang.fromXML(angleXML)
scoreXML = job_element.xpath('Score')[0]
self.score = scoreFromXML(scoreXML)
self.preprocessing = Preprocessing()
preprocessingXML = job_element.xpath('Preprocessing')[0]
self.preprocessing.fromXML(preprocessingXML)
def fromXML(self, xmlObj):
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
raise Exception('You must provide a valid XML object.')
if xmlObj.tag == "CTFCorrectionJob":
jobDescription = xmlObj
else:
jobDescription = xmlObj.xpath('CTFCorrectionJob')
if len(jobDescription) == 0:
raise Exception("This XML is not a CTFCorrectionJob.")
jobDescription = jobDescription[0]
from pytom.basic.structures import ParticleList, Reference, Mask, SampleInformation
particleList_element = jobDescription.xpath('ParticleList')[0]
pl = ParticleList('.')
pl.fromXML(particleList_element)
self.particleList = pl
self.reference = []
r = jobDescription.xpath('Reference')
for ref_obj in r:
ref = Reference('')
ref.fromXML(ref_obj)
self.reference.append(ref)
m = jobDescription.xpath('Mask')[0]
self.mask = Mask('')
self.mask.fromXML(m)
try:
si = jobDescription.xpath('SampleInformation')[0]
self.sampleInformation = SampleInformation()
self.sampleInformation.fromXML(si)
except:
self._sampleInformation = SampleInformation()
self.ctf_conv_pl = jobDescription.get('CTFConvolutedParticleList')
self.peak_offset = int(jobDescription.get('PeakOffset'))
self.bw_range = [
int(i)
for i in jobDescription.get('BandwidthRange')[1:-1].split(',')
]
self.freq = int(jobDescription.get('Frequency'))
self.destination = jobDescription.get('Destination')
self.max_iter = int(jobDescription.get('MaxIterations'))
self.r_score = jobDescription.get('RScore') == 'True'
self.weighting = jobDescription.get('WeightedAverage') == 'True'
self.bfactor = jobDescription.get('BFactor')
self.sum_ctf_sqr = jobDescription.get('CTFSquared')
def __init__(self,particleList=None,mask='',resultMatrixName='',applyWedge = True,binningFactor=0,lowestFrequency=-1,highestFrequency=-1):
"""
__init__:
@param particleList: ParticleList of all particles that will be correlated
@type particleList: L{pytom.basic.structures.ParticleList}
@param mask: Mask used for correlation
@type mask: str or L{pytom.basic.structures.Mask}
@param resultMatrixName: Result filename
@type resultMatrixName: str
@param applyWedge: Apply wedge weighting if available?
@type applyWedge: boolean, False by default
@param binningFactor: Binning factor accroding to libtomc definition. 0 by default.
@type binningFactor: unsigned int
@param lowestFrequency: Lowest frequency for bandpass in nyquist
@type lowestFrequency: float
@param highestFrequency: Highest frequency for bandpass in nyquist
@type highestFrequency: float
"""
from pytom.basic.structures import ParticleList,Mask
from pytom.tools.files import checkFileExists
if not particleList:
particleList = ParticleList('/')
elif particleList.__class__ != ParticleList:
raise ParameterError('You must provide a ParticleList object!')
self._particleList = particleList
if mask.__class__ == str:
mask = Mask(mask)
elif mask.__class__ != Mask:
raise ParameterError('Mask must be a string or Mask object!')
self._mask = mask
self._resultMatrixName = resultMatrixName
self._applyWedge = applyWedge
self._binningFactor = binningFactor
self._lowestFrequency = lowestFrequency
self._highestFrequency = highestFrequency
def fromXML(self, xmlObj):
"""
read from xml file
@param xmlObj: xml object
@type xmlObj: L{lxml.etree.Element}
"""
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
raise Exception('You must provide a valid XML object.')
if xmlObj.tag == "FRMJob":
jobDescription = xmlObj
else:
jobDescription = xmlObj.xpath('FRMJob')
if len(jobDescription) == 0:
raise Exception("This XML is not a FRMJob.")
jobDescription = jobDescription[0]
from pytom.basic.structures import ParticleList, Reference, Mask, SampleInformation, MultiSymmetries
pl = ParticleList('.')
particleList_element = jobDescription.xpath('ParticleList')
if len(particleList_element) > 0:
pl.fromXML(particleList_element[0])
else:
list_elements = jobDescription.xpath('ParticleListLocation')
for e in list_elements:
sub_pl = ParticleList()
sub_pl.fromXMLFile(e.get('Path'))
pl += sub_pl
self.particleList = pl
r = jobDescription.xpath('Reference')[0]
self.reference = Reference('')
self.reference.fromXML(r)
m = jobDescription.xpath('Mask')[0]
self.mask = Mask('')
self.mask.fromXML(m)
try:
si = jobDescription.xpath('SampleInformation')[0]
self.sampleInformation = SampleInformation()
self.sampleInformation.fromXML(si)
except:
self.sampleInformation = SampleInformation()
try:
syms = jobDescription.xpath('MultiSymmetries')[0]
self.symmetries = MultiSymmetries()
self.symmetries.fromXML(syms)
except:
self.symmetries = MultiSymmetries()
self.peak_offset = int(jobDescription.get('PeakOffset'))
self.bw_range = [
int(i)
for i in jobDescription.get('BandwidthRange')[1:-1].split(',')
]
self.freq = int(jobDescription.get('Frequency'))
self.destination = jobDescription.get('Destination')
self.max_iter = int(jobDescription.get('MaxIterations'))
self.r_score = jobDescription.get('RScore') == 'True'
self.weighting = jobDescription.get('WeightedAverage') == 'True'
self.bfactor = jobDescription.get('BFactor')
self.binning = int(jobDescription.get('binning'))
if jobDescription.get('AdaptiveResolution'):
adaptive_resolution = jobDescription.get('AdaptiveResolution')
if adaptive_resolution == '+1':
self.adaptive_res = False # always increase by 1
else:
self.adaptive_res = float(adaptive_resolution)
else:
self.adaptive_res = 0.0 # default, if not specified
if jobDescription.get('FSC'):
self.fsc_criterion = float(jobDescription.get('FSC'))
else:
self.fsc_criterion = 0.5 # default value
# for the constraint
try:
from sh_alignment.constrained_frm import AngularConstraint
con = jobDescription.xpath('AngularConstraint')
if len(con) != 0:
ac = AngularConstraint()
c = ac.fromXML(con[0])
self.constraint = c
else:
self.constraint = None
except:
self.constraint = None
pl.fromXMLFile(particleList)
if reference:
if not checkFileExists(reference):
raise RuntimeError('Reference file ' + reference + ' does not exist!')
ref = Reference(referenceFile=reference)
else:
ref = Reference()
if not checkFileExists(mask):
raise RuntimeError('Mask file ' + mask + ' does not exist!')
if isSphere:
isSphere = True
else:
isSphere = False
m = Mask(filename=mask, isSphere=isSphere)
if not checkDirExists(destination):
raise RuntimeError('Destination directory ' + destination + ' does not exist!')
if not angShells:
angShells = 3
if not angleInc:
angleInc = 3.
rot = LocalSampling(angShells,angleInc)
if not pixelSize:
pixelSize = 1.
if not diameter:
diameter = -1
sampleI = SampleInformation(pixelSize=float(pixelSize), particleDiameter=float(diameter))
def interpretRequestParameters(parameters):
from pytom.localization.peak_job import PeakJob
from pytom.localization.structures import Volume
from pytom.basic.structures import Mask, Reference, WedgeInfo
from pytom.angles.globalSampling import GlobalSampling
from pytom.basic.structures import BandPassFilter
from pytom.frontend.serverpages.serverMessages import FileMessage
if 'tomo' in parameters:
vol = Volume(parameters['tomo'])
else:
raise RuntimeError('Parameter missing in request!')
if 'ref' in parameters:
ref = Reference(parameters['ref'])
else:
raise RuntimeError('Parameter missing in request!')
if 'mask' in parameters:
mask = Mask(parameters['mask'])
else:
raise RuntimeError('Parameter missing in request!')
if 'angle' in parameters:
ang = GlobalSampling(parameters['angle'])
else:
raise RuntimeError('Parameter missing in request!')
if 'dest' in parameters:
dest = parameters['dest']
else:
dest = './'
if 'low' in parameters:
low = float(parameters['low'])
else:
raise RuntimeError('Parameter missing in request!')
if 'high' in parameters:
high = float(parameters['high'])
else:
raise RuntimeError('Parameter missing in request!')
if 'smooth' in parameters:
smooth = float(parameters['smooth'])
else:
raise RuntimeError('Parameter missing in request!')
if 'w1' in parameters:
w1 = float(parameters['w1'])
else:
raise RuntimeError('Parameter missing in request!')
if 'w2' in parameters:
w2 = float(parameters['w2'])
else:
raise RuntimeError('Parameter missing in request!')
if 'x' in parameters:
x = float(parameters['x'])
else:
x = 0
if 'y' in parameters:
y = float(parameters['y'])
else:
y = 0
if 'z' in parameters:
z = float(parameters['z'])
else:
z = 0
bp = BandPassFilter(low, high, smooth)
wedge = WedgeInfo([w1, w2])
from pytom.score.score import FLCFScore
sc = FLCFScore()
job = PeakJob(vol,
ref,
mask,
wedge,
ang,
dstDir=dest,
score=sc,
bandpass=bp)
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, x, y, z)
return FileMessage('LocalizationJob', jobXMLFile, 'created')
def interpretRequestParameters(parameters):
"""
interpretRequestParameters
"""
from pytom.basic.structures import ParticleList, SampleInformation, Reference, Mask, Wedge
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!')
if 'wa1' in parameters:
wedgeAngle1 = float(parameters['wa1'])
else:
raise RuntimeError('Wedge angle 1 parameter missing in request!')
if 'wa2' in parameters:
wedgeAngle2 = float(parameters['wa2'])
else:
raise RuntimeError('Wedge angle 2 parameter missing in request!')
wedgeInfo = Wedge([wedgeAngle1, wedgeAngle2])
if 'mask' in parameters:
mask = Mask(parameters['mask'])
else:
raise RuntimeError('Mask parameter 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']))
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 '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 'classes' in parameters:
numberClasses = float(parameters['classes'])
else:
raise RuntimeError('Number classes parameter missing in request!')
if 'conv' in parameters:
convergence = float(parameters['conv'])
else:
raise RuntimeError('Convergence parameter missing in request!')
if 'dest' in parameters:
destination = parameters['dest']
else:
raise RuntimeError('Destination parameter missing in request!')
sampleInfo = SampleInformation()
if 'pixSize' in parameters:
sampleInfo.setPixelSize(float(parameters['pixSize']))
else:
raise RuntimeError('Pixelsize parameter missing in request!')
if 'partDia' in parameters:
sampleInfo.setParticleDiameter(float(parameters['partDia']))
else:
raise RuntimeError('Particle diameter missing in request!')
from pytom.cluster.mcoEXMXStructures import MCOEXMXJob
job = MCOEXMXJob(particleList,
iterations,
destination,
mask,
score,
preprocessing,
wedgeInfo,
binning,
sampleInfo,
numberClasses,
convergence,
symmetry=None)
jobXMLFile = ''
if 'jobFile' in parameters:
jobXMLFile = parameters['jobFile']
job.toXMLFile(jobXMLFile)
jobRunFile = jobXMLFile[0:-3]
createRunscripts(jobRunFile + 'sh', jobXMLFile)
return FileMessage('MCOEXMXJob', jobXMLFile, 'created')
@param splitType: split type of the job
@type splitType: "Ang" or "Vol"
"""
def __init__(self, jobID=-1, originalJobID=-1, splitType=None):
self.jobID = jobID
self.originalJobID = originalJobID
self.splitType = splitType
if __name__ == '__main__':
from pytom.basic.structures import Mask, Reference, WedgeInfo
from pytom.localization.structures import Volume
from pytom.score.score import FLCFScore, xcfScore
from pytom.localization.peak_job import PeakJob
v = Volume('/fs/pool/pool-foerster/apps/src/molmatch/test/testvol.em')
ref = Reference('/fs/pool/pool-foerster/apps/src/molmatch/test/templ.em')
m = Mask('/fs/pool/pool-foerster/apps/src/molmatch/test/mask_15.em', True)
w = WedgeInfo(0)
s = FLCFScore()
from pytom.angles.globalSampling import GlobalSampling
r = GlobalSampling(
'/fs/home/ychen/develop/pytom/trunk/pytom/pytomc/libs/libtomc/data/common_data/angles_90_26.em'
)
job = PeakJob(v, ref, m, w, r, s)
job.toXMLFile('JobInfo.xml')
job.toHTMLFile('JobInfo.html')
def interpretRequestParameters(parameters):
"""
interpretRequestParameters
"""
from pytom.basic.structures import ParticleList, SampleInformation, Reference, Mask, Wedge
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!')
if 'wa1' in parameters:
wedgeAngle1 = float(parameters['wa1'])
else:
raise RuntimeError('Wedge angle 1 parameter missing in request!')
if 'wa2' in parameters:
wedgeAngle2 = float(parameters['wa2'])
else:
raise RuntimeError('Wedge angle 2 parameter missing in request!')
wedgeInfo = Wedge([wedgeAngle1, wedgeAngle2])
if 'mask' in parameters:
mask = Mask(parameters['mask'])
else:
raise RuntimeError('Mask parameter 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']))
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 'binning' in parameters:
binning = int(parameters['binning'])
else:
raise RuntimeError('Scaling parameter missing in request!')
if 'classes' in parameters:
numberClasses = float(parameters['classes'])
else:
raise RuntimeError('Number classes parameter missing in request!')
if 'conv' in parameters:
convergence = float(parameters['conv'])
else:
raise RuntimeError('Convergence parameter missing in request!')
if 'dest' in parameters:
destination = parameters['dest']
else:
raise RuntimeError('Destination parameter missing in request!')
sampleInfo = SampleInformation()
if 'pixSize' in parameters:
sampleInfo.setPixelSize(float(parameters['pixSize']))
else:
raise RuntimeError('Pixelsize parameter missing in request!')
if 'partDia' in parameters:
sampleInfo.setParticleDiameter(float(parameters['partDia']))
else:
raise RuntimeError('Particle diameter missing in request!')
temperature = None
if 'temp' in parameters:
temperature = parameters['temp']
if 'stemp' in parameters:
startTemperature = float(parameters['stemp'])
else:
raise RuntimeError(
'Start temperature parameter missing in request!')
if 'astep' in parameters:
annealingStep = float(parameters['astep'])
else:
raise RuntimeError('Annealing step parameter missing in request!')
from pytom.cluster.mcoACStructures import SigmaTemperature
if temperature == 'sigma':
temperature = SigmaTemperature(startTemperature, annealingStep)
else:
raise RuntimeError('Temperature missing in request!')
criterion = None
if 'crit' in parameters:
from pytom.cluster.mcoACStructures import MetropolisCriterion, ThresholdAcceptance
criterion = parameters['crit']
if criterion == 'metropolis':
criterion = MetropolisCriterion()
elif criterion == 'threshold':
criterion = ThresholdAcceptance()
else:
raise RuntimeError('Criterion missing in request!')
if 'refin' in parameters:
localSearchIncrement = float(parameters['refin'])
else:
raise RuntimeError('Number of refinement rounds missing in request!')
from pytom.cluster.mcoACStructures import MCOACJob
job = MCOACJob(particleList,
destination,
mask,
score,
preprocessing,
wedgeInfo,
binning,
sampleInfo,
numberClasses,
temperature,
criterion,
convergence,
localSearchIncrement,
symmetry=None)
jobXMLFile = ''
if 'jobFile' in parameters:
jobXMLFile = parameters['jobFile']
job.toXMLFile(jobXMLFile)
jobRunFile = jobXMLFile[0:-3]
createRunscripts(jobRunFile + 'sh', jobXMLFile)
return FileMessage('MCOACJob', jobXMLFile, 'created')
def fromXML(self, xmlObj): # only rewrite this function
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
raise Exception('You must provide a valid XML object.')
if xmlObj.tag == "FRMJob": # the name is not changed here!
jobDescription = xmlObj
else:
jobDescription = xmlObj.xpath('FRMJob')
if len(jobDescription) == 0:
raise Exception("This XML is not a FRMJob.")
jobDescription = jobDescription[0]
from pytom.basic.structures import Reference, Mask, SampleInformation, MultiSymmetries
particleList_element = jobDescription.xpath('ParticleListSet')[0]
pl = ParticleListSet()
pl.fromXML(particleList_element)
self.particleList = pl # here i still use the original name!
self.reference = []
r = jobDescription.xpath('Reference')
for ref_obj in r:
ref = Reference('')
ref.fromXML(ref_obj)
self.reference.append(ref)
m = jobDescription.xpath('Mask')[0]
self.mask = Mask('')
self.mask.fromXML(m)
try:
si = jobDescription.xpath('SampleInformation')[0]
self.sampleInformation = SampleInformation()
self.sampleInformation.fromXML(si)
except:
self.sampleInformation = SampleInformation()
try:
syms = jobDescription.xpath('MultiSymmetries')[0]
self.symmetries = MultiSymmetries()
self.symmetries.fromXML(syms)
except:
self.symmetries = MultiSymmetries()
self.peak_offset = int(jobDescription.get('PeakOffset'))
self.bw_range = [
int(i)
for i in jobDescription.get('BandwidthRange')[1:-1].split(',')
]
self.freq = int(jobDescription.get('Frequency'))
self.destination = jobDescription.get('Destination')
self.max_iter = int(jobDescription.get('MaxIterations'))
self.r_score = jobDescription.get('RScore') == 'True'
self.weighting = jobDescription.get('WeightedAverage') == 'True'
self.bfactor = jobDescription.get('BFactor')
if jobDescription.get('AdaptiveResolution'):
adaptive_resolution = jobDescription.get('AdaptiveResolution')
if adaptive_resolution == '+1':
self.adaptive_res = False # always increase by 1
else:
self.adaptive_res = float(adaptive_resolution)
else:
self.adaptive_res = 0.0 # default, if not specified
if jobDescription.get('FSC'):
self.fsc_criterion = float(jobDescription.get('FSC'))
else:
self.fsc_criterion = 0.5 # default value
def fromXML(self, xmlObj):
"""
fromXML : Assigns values to job attributes from XML object
@param xmlObj: A xml object
@author: Thomas Hrabe
"""
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
from pytom.basic.exceptions import ParameterError
raise ParameterError(
'You must provide a valid XML-MaximisationJob object.')
if xmlObj.tag == "JobDescription":
jobDescription = xmlObj
else:
jobDescription = xmlObj.xpath('JobDescription')
if len(jobDescription) == 0:
from pytom.basic.structures import PyTomClassError
raise PyTomClassError("This XML is not an JobDescription.")
jobDescription = jobDescription[0]
from pytom.angles.angle import AngleObject
from pytom.score.score import fromXML as fromXMLScore
from pytom.alignment.preprocessing import Preprocessing
from pytom.basic.structures import Mask, Particle, Reference, ReferenceList
self.binning = int(jobDescription.get('Binning'))
particle_element = jobDescription.xpath('Particle')[0]
p = Particle('')
p.fromXML(particle_element)
self.particle = p
r = jobDescription.xpath('Reference')
if len(r) > 0:
ref = Reference('')
ref.fromXML(r[0])
self.reference = ref
else:
r = jobDescription.xpath('ReferenceList')
ref = ReferenceList()
ref.fromXML(r[0])
self.reference = ref
mask = jobDescription.xpath('Mask')[0]
self.mask = Mask('')
self.mask.fromXML(mask)
self.numberRefinementRounds = jobDescription.get(
'NumberRefinementRounds')
self.numberRefinementRounds = int(self.numberRefinementRounds)
score = jobDescription.xpath('Score')
self.score = fromXMLScore(score[0])
angles = jobDescription.xpath('Angles')
ang = AngleObject()
self.rotations = ang.fromXML(angles[0])
preObj = xmlObj.xpath('Preprocessing')
if len(preObj) == 0:
self.preprocessing = Preprocessing()
else:
p = Preprocessing()
p.fromXML(preObj[0])
self.preprocessing = p
def fromXML(self, xmlObj):
"""
fromXML : Assigns values to job attributes from XML object
@param xmlObj: A xml object
@author: chen
"""
from lxml.etree import _Element
if xmlObj.__class__ != _Element:
raise Exception('You must provide a valid XML object.')
if xmlObj.tag == "JobDescription":
jobDescription = xmlObj
else:
jobDescription = xmlObj.xpath('JobDescription')
if len(jobDescription) == 0:
raise Exception("This XML is not an JobDescription.")
jobDescription = jobDescription[0]
id = jobDescription.get('ID')
if id != None and id != 'None':
self.jobID = int(id)
members = jobDescription.get('Members')
if members != None and members != 'None':
self.members = int(members)
dstDir = jobDescription.get('Destination')
if dstDir != None:
if dstDir[-1] == '/':
self.dstDir = dstDir
else:
self.dstDir = dstDir + '/'
from pytom.score.score import fromXML as fromXMLScore
from pytom.basic.structures import Mask, Reference, Wedge
# from pytom.angles.angleList import AngleList
from pytom.localization.structures import Volume
e = jobDescription.xpath('Volume')[0]
v = Volume()
v.fromXML(e)
self.volume = v
ref = jobDescription.xpath('Reference')[0]
self.reference = Reference('')
self.reference.fromXML(ref)
wedgeXML = jobDescription.xpath('Wedge')
if len(wedgeXML) == 0:
wedgeXML = jobDescription.xpath('SingleTiltWedge')
if len(wedgeXML) == 0:
wedgeXML = jobDescription.xpath('WedgeInfo')
if len(wedgeXML) == 0:
wedgeXML = jobDescription.xpath('DoubleTiltWedge')
assert len(wedgeXML) > 0
self.wedge = Wedge()
self.wedge.fromXML(wedgeXML[0])
mask = jobDescription.xpath('Mask')[0]
self.mask = Mask('')
self.mask.fromXML(mask)
score = jobDescription.xpath('Score')
self.score = fromXMLScore(score[0])
rot = jobDescription.xpath('Angles')[0]
from pytom.angles.angle import AngleObject
ang = AngleObject()
self.rotations = ang.fromXML(rot)
# self.rotations = AngleList()
# self.rotations.fromXML(rot)
bp = jobDescription.xpath('BandPassFilter')
if bp != []:
bp = bp[0]
from pytom.basic.structures import BandPassFilter
self.bandpass = BandPassFilter(0, 0, 0)
self.bandpass.fromXML(bp)
else:
self.bandpass = None
if not checkFileExists(mask):
raise RuntimeError('Mask file ' + mask + ' does not exist!')
if not checkDirExists(destination):
raise RuntimeError('Destination directory ' + destination +
' does not exist!')
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,\
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')