def doSuccessExecSaxsMac(self, _edPlugin=None):
self.DEBUG("EDPluginBioSaxsNormalizev1_0.doSuccessExecSaxsMac")
self.retrieveSuccessMessages(_edPlugin, "EDPluginBioSaxsNormalizev1_0.doSuccessExecSaxsMac")
strEdnaLogFile = os.path.join(
self.__edPluginExecSaxsMac.getWorkingDirectory(), self.__edPluginExecSaxsMac.getScriptLogFileName()
)
self.DEBUG("ExecPlugin log file is in: %s" % strEdnaLogFile)
if os.path.isfile(self.strNormalizedImage) and self.isVerboseDebug():
shutil.copy(self.strNormalizedImage, self.strNormalizedImage + ".bak")
if os.path.isfile(strEdnaLogFile):
shutil.copy(strEdnaLogFile, self.strLogFile)
xsLogFile = XSDataFile()
xsLogFile.setPath(XSDataString(self.strLogFile))
self.xsdResult.setLogFile(xsLogFile)
xsdiMetadata = XSDataInputBioSaxsMetadatav1_0()
xsdiMetadata.setInputImage(self.xsdInput.normalizedImage)
xsdiMetadata.setOutputImage(self.xsdInput.normalizedImage)
xsdiMetadata.setBeamStopDiode(self.xsdInput.experimentSetup.beamStopDiode)
xsdiMetadata.setNormalizationFactor(self.xsdInput.experimentSetup.normalizationFactor)
xsdiMetadata.setDetector(self.xsdInput.experimentSetup.getDetector())
xsdiMetadata.setMachineCurrent(self.xsdInput.experimentSetup.machineCurrent)
xsdiMetadata.setMaskFile(self.xsdInput.experimentSetup.maskFile)
xsdiMetadata.setDetectorDistance(self.xsdInput.experimentSetup.detectorDistance)
xsdiMetadata.setWavelength(self.xsdInput.experimentSetup.wavelength)
xsdiMetadata.setPixelSize_1(self.xsdInput.experimentSetup.pixelSize_1)
xsdiMetadata.setPixelSize_2(self.xsdInput.experimentSetup.pixelSize_2)
xsdiMetadata.setBeamCenter_1(self.xsdInput.experimentSetup.beamCenter_1)
xsdiMetadata.setBeamCenter_2(self.xsdInput.experimentSetup.beamCenter_2)
xsdiMetadata.setConcentration(self.xsdInput.sample.concentration)
xsdiMetadata.setComments(self.xsdInput.sample.comments)
xsdiMetadata.setCode(self.xsdInput.sample.code)
self.__edPluginExecMetadata.setDataInput(xsdiMetadata)
def functionXMLin(_strFilename):
"""Here we create the XML string to be passed to the EDNA plugin from the input strFilename
This can / should be modified by the final user
@param _strFilename: full path of the input file
@type _strFilename: python string representing the path
@return: string
"""
EDVerbose.screen("Starting processing of image %s" % (_strFilename))
# First check if the filename end with .img or .mccd:
strXML = None
if _strFilename.endswith(".img") or _strFilename.endswith(".mccd") or _strFilename.endswith(".cbf"):
xsDataInputGridScreening = XSDataInputGridScreening()
xsDataDiffractionPlan = XSDataDiffractionPlan()
xsDataDiffractionPlan.setMaxExposureTimePerDataCollection(
XSDataTime(EDParallelExecuteGridScreening.fMaxExposureTime)
)
xsDataInputGridScreening.setDiffractionPlan(xsDataDiffractionPlan)
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(_strFilename))
xsDataInputGridScreening.setImageFile(xsDataFile)
if EDParallelExecuteGridScreening.bOnlyImageQualityIndicators:
xsDataInputGridScreening.setDoOnlyImageQualityIndicators(XSDataBoolean(True))
if EDParallelExecuteGridScreening.bStoreInISPyB:
xsDataInputGridScreening.setStoreImageQualityIndicatorsInISPyB(XSDataBoolean(True))
if EDParallelExecuteGridScreening.bDoOnlyIntegrationWithXMLOutput:
xsDataInputGridScreening.setDoOnlyIntegrationWithXMLOutput(XSDataBoolean(True))
strXML = xsDataInputGridScreening.marshal()
else:
EDVerbose.screen("File name not ending with .img or .mccd - ignored : %s" % _strFilename)
return strXML
def buildChildren(self, child_, nodeName_): if child_.nodeType == Node.ELEMENT_NODE and \ nodeName_ == 'outputFilePath': obj_ = XSDataFile() obj_.build(child_) self.setOutputFilePath(obj_) XSDataResult.buildChildren(self, child_, nodeName_)
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'image':
obj_ = XSDataFile()
obj_.build(child_)
self.image.append(obj_)
XSDataInput.buildChildren(self, child_, nodeName_)
def postProcess(self, _edObject=None):
"""
postProcess of the plugin EDPluginSPDCorrectv10.py:
- convert to HDF if needed (to be implemented)
- move images (if needed)
- set result XML
"""
EDPluginExecProcess.postProcess(self)
self.DEBUG("EDPluginSPDCorrectv10.postProcess")
EDUtilsPath.createFolder(self.dictGeometry["OutputDir"])
if self.getClassName() == "EDPluginSPDCorrectv10":
strInputImagePathNoSfx = os.path.splitext(os.path.basename(self.pathToInputFile))[0]
destFileBaseName = strInputImagePathNoSfx + self.dictGeometry["OutputFileType"]
strOutputFilePath = os.path.join(self.dictGeometry["OutputDir"], destFileBaseName)
if not self._bFireAndForget:
if "corrected" in self.dictRes:
strTempFilePath = self.dictRes["corrected"]
else:
strTempFilePath = os.path.join(self.getWorkingDirectory(), destFileBaseName)
if self.dictGeometry["OutputFileType"].lower() in [".hdf5", ".nexus", ".h5", ".nx"]:
self.WARNING("HDF5/Nexus output is not yet implemented in the SPD plugin.")
if os.path.exists(strOutputFilePath):
self.WARNING("Destination file exists, I will leave result file in %s." % strTempFilePath)
strOutputFilePath = strTempFilePath
else:
shutil.move(strTempFilePath, strOutputFilePath)
# # Create the output data
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(strOutputFilePath))
xsDataResultSPD = XSDataResultSPD()
xsDataResultSPD.setCorrectedFile(xsDataFile)
self.setDataOutput(xsDataResultSPD)
def buildChildren(self, child_, nodeName_): if child_.nodeType == Node.ELEMENT_NODE and \ nodeName_ == 'inputMatrixFile': obj_ = XSDataFile() obj_.build(child_) self.setInputMatrixFile(obj_) XSDataInput.buildChildren(self, child_, nodeName_)
def doSuccessExecSPDCake(self, _edPlugin=None):
self.synchronizeOn()
self.DEBUG("EDPluginControlID11v1_0.doSuccessExecSPDCake")
self.retrieveSuccessMessages(_edPlugin, "EDPluginControlID11v1_0.doSuccessExecSPDCake")
xsdOut = _edPlugin.getDataOutput()
xsdAzimFile = xsdOut.getCakedFile()
xsdIn = XSDataInput1DPowderEDF()
xsdIn.setEdfFile(xsdAzimFile)
strInputFile = os.path.basename(_edPlugin.getDataInput().getInputFile().getPath().getValue())
xsdFile = XSDataFile()
xsdFile.setPath(XSDataString(
os.path.join(self.__dictID11["output_dir"], os.path.splitext(strInputFile)[0] + "." + self.__dictID11["output_extn"])
))
xsdIn.setOutputFile(xsdFile)
xsdIn.setEdfFile(xsdOut.getCakedFile())
xsdIn.setOutputFormat(XSDataString(self.__dictID11["output_extn"]))
xsdIn.setNumberOfBins(XSDataInteger(int(self.__dictID11["RADIAL BINS"])))
# EDF Launch
edPluginEDF = self.loadPlugin(self.__strControlledPluginEDF)
edPluginEDF.setDataInput(xsdIn)
edPluginEDF.connectSUCCESS(self.doSuccessExec1DPowderEDF)
edPluginEDF.connectFAILURE(self.doFailureExec1DPowderEDF)
edPluginEDF.execute()
self.synchronizeOff()
def characteriseWithXmlInput(self, data_collection_id, sampleCharacteriseIndex, beamsize):
if data_collection_id is not None:
self.ednaInput.setDataCollectionId(XSDataInteger(data_collection_id))
else:
self.ednaInput.setDataCollectionId(None)
logging.getLogger().warning("The data collection ID is not known for this characterisation. Therefore the EDNA results cannot be put into the database")
# build data set
imageSuffix = self.beamlinePars["BCM_PARS"].getProperty("FileSuffix")
dataSetObj = XSDataMXCuBEDataSet()
self.ednaInput.setDataSet([])
methodDCNo = len(self.current_method[1])
for methodIndex in range(methodDCNo):
number_of_images = self.current_method[1][methodIndex]['number_of_images']
imageNameIdx = self.current_method[0]
listIndex = sampleCharacteriseIndex * methodDCNo + methodIndex
for imageno in range(int(number_of_images)):
imageFileObj = XSDataFile()
pathStrObj = XSDataString()
pathStrObj.setValue(('%s/%s_%d_%04d.%s' % (self.collectSeqList[listIndex]['fileinfo']['directory'],\
self.collectSeqList[listIndex]['fileinfo']['prefix'],\
int(self.collectSeqList[listIndex]['fileinfo']['run_number']),\
imageno+1,imageSuffix)))
imageFileObj.setPath(pathStrObj)
dataSetObj.addImageFile(imageFileObj)
self.ednaInput.addDataSet(dataSetObj)
if TEST:
self.ednaInput.getDataSet()[0].getImageFile()[0].getPath().setValue("/opt/pxsoft/DNA/TestCase/ref-testscale_1_001.img")
self.ednaInput.getDataSet()[0].getImageFile()[1].getPath().setValue("/opt/pxsoft/DNA/TestCase/ref-testscale_1_002.img")
path = self.process_dir
suffix = '_%s.xml' % (self.ednaInput.getDataCollectionId().getValue() or id(self.ednaInput))
ednaResultsFile = os.path.join(path, 'EDNAOutput%s' % suffix)
ednaInputXMLFile = os.path.join(path, 'EDNAInput%s' % suffix)
if not os.path.isdir(path):
os.makedirs(path)
beamObj = self.ednaInput.getExperimentalCondition().getBeam()
beamObj.setSize(XSDataSize(x=XSDataLength(float(beamsize[0])),y=XSDataLength(float(beamsize[1]))))
""" create an edna input file using the ednainput model """
ednaInputXML = self.ednaInput.exportToFile(ednaInputXMLFile)
logging.getLogger().info("Starting Edna using xml file, %s" % ednaInputXMLFile)
# use an intermediate script to run edna with its command line options
edna_args = "%s %s %s" % (ednaInputXMLFile,ednaResultsFile,path)
edna_cmd=self.StartEdnaCommand+" "+edna_args
if self.ednaPollTimer is None:
self.ednaPollTimer = qt.QTimer()
qt.QObject.connect(self.ednaPollTimer,qt.SIGNAL("timeout()"), self.pollEDNA)
logging.getLogger().debug(edna_cmd)
EDNA_PROCESSES.append(EnhancedPopen.Popen(edna_cmd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True,universal_newlines=True))
self.EDNAResultsFiles[id(EDNA_PROCESSES[-1])]=ednaResultsFile
# save image prefix,etc. for next step
# only take first image, since we just want to have image prefix, run number, etc. :
# it is the same within the whole collectSeqList (hopefully)
imagePrefix = self.collectSeqList[0]['fileinfo']['prefix'][4:] #remove ref-
self.imagePathProperties[id(EDNA_PROCESSES[-1])]={"imagePrefix":imagePrefix, "imageDir": self.collectSeqList[0]['fileinfo']['directory'], "lRunN": int(self.collectSeqList[0]['fileinfo']['run_number'])}
self.ednaPollTimer.start(100)
def doSuccessSaxsMac(self, _edPlugin=None):
EDVerbose.DEBUG("EDPluginBioSaxsAveragev1_0.doSuccessSaxsMac")
self.retrieveSuccessMessages(_edPlugin, "EDPluginBioSaxsAveragev1_0.doSuccessSaxsMac")
strEdnaLogFile = os.path.join(_edPlugin.getWorkingDirectory(), _edPlugin.getScriptLogFileName())
EDVerbose.DEBUG("ExecPlugin log file is in: %s" % strEdnaLogFile)
if os.path.isfile(strEdnaLogFile):
shutil.copy(strEdnaLogFile, self.strLogFile)
xsLogFile = XSDataFile()
xsLogFile.setPath(XSDataString(self.strLogFile))
self.xsdResult.setLogFile(xsLogFile)
xsdiMetadata = XSDataInputBioSaxsMetadatav1_0()
xsdiMetadata.setInputImage(self.dataInput.getAveragedImage())
xsdiMetadata.setOutputImage(self.dataInput.getAveragedImage())
xsdiMetadata.setConcentration(self.xsdMetadata.concentration)
xsdiMetadata.setComments(self.xsdMetadata.comments)
xsdiMetadata.setCode(self.xsdMetadata.code)
xsdiMetadata.setDetector(self.xsdMetadata.getDetector())
xsdiMetadata.setDetectorDistance(self.xsdMetadata.detectorDistance)
xsdiMetadata.setPixelSize_1(self.xsdMetadata.pixelSize_1)
xsdiMetadata.setPixelSize_2(self.xsdMetadata.pixelSize_2)
xsdiMetadata.setBeamCenter_1(self.xsdMetadata.beamCenter_1)
xsdiMetadata.setBeamCenter_2(self.xsdMetadata.beamCenter_2)
xsdiMetadata.setWavelength(self.xsdMetadata.wavelength)
xsdiMetadata.setMachineCurrent(self.xsdMetadata.machineCurrent)
xsdiMetadata.setMaskFile(self.xsdMetadata.maskFile)
xsdiMetadata.setNormalizationFactor(self.xsdMetadata.normalizationFactor)
self.__edPluginSaxsSetMetadata.setDataInput(xsdiMetadata)
self.__edPluginSaxsSetMetadata.connectSUCCESS(self.doSuccessSetMetadata)
self.__edPluginSaxsSetMetadata.connectFAILURE(self.doFailureSetMetadata)
self.__edPluginSaxsSetMetadata.executeSynchronous()
def buildChildren(self, child_, nodeName_): if child_.nodeType == Node.ELEMENT_NODE and \ nodeName_ == 'fileGraph': obj_ = XSDataFile() obj_.build(child_) self.fileGraph.append(obj_) XSDataResult.buildChildren(self, child_, nodeName_)
def buildChildren(self, child_, nodeName_): if child_.nodeType == Node.ELEMENT_NODE and \ nodeName_ == 'hklfile': obj_ = XSDataFile() obj_.build(child_) self.setHklfile(obj_) XSDataResult.buildChildren(self, child_, nodeName_)
def createInputCharacterisationFromImageHeaders(self, _edPlugin):
self.DEBUG("EDPluginControlInterfacev1_3.createInputCharacterisationFromImageHeaders")
xsDataInputSubWedgeAssemble = XSDataInputSubWedgeAssemble()
for xsDataStringImagePath in self.listImagePaths:
xsDataFile = XSDataFile()
xsDataFile.setPath(xsDataStringImagePath)
xsDataInputSubWedgeAssemble.addFile(xsDataFile)
_edPlugin.setDataInput(xsDataInputSubWedgeAssemble)
_edPlugin.executeSynchronous()
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
self.DEBUG("EDPluginExecSiftDescriptorv1_0.postProcess")
# Create some output data
xsDataResult = XSDataResultSiftDescriptor()
if os.path.isfile(self.strKeys):
xsdFile = XSDataFile()
xsdFile.setPath(XSDataString(self.strKeys))
xsDataResult.setDescriptorFile(xsdFile)
self.setDataOutput(xsDataResult)
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
EDVerbose.DEBUG("*** EDPluginFIT2DCakev1_0.postProcess")
# Create the output data
xsDataResultFIT2DCake = XSDataResultFIT2DCake()
if (self.m_strOutputFilePath is not None):
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(self.m_strOutputFilePath))
xsDataResultFIT2DCake.setResultFile(xsDataFile)
self.setDataOutput(xsDataResultFIT2DCake)
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
EDVerbose.DEBUG("EDPluginExecVideov10.postProcess")
# Create some output data
xsDataResult = XSDataResultExecVideo()
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(self.videoFile))
xsDataResult.setVideoPath(xsDataFile)
xsDataResult.setVideoPath(xsDataFile)
xsDataResult.setVideoCodec(XSDataString(self.codec))
self.setDataOutput(xsDataResult)
def postProcess(self, _edObject=None):
EDPlugin.postProcess(self)
self.DEBUG("EDPluginWaitFile.postProcess: Waited for %.3f s" % self.getRunTime())
xsDataResult = XSDataResultWaitFile()
if os.path.exists(self.__filename):
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(self.__filename))
xsDataResult.setActualFile(xsDataFile)
xsDataResult.setActualSize(XSDataInteger(os.path.getsize(self.__filename)))
xsDataResult.setTimedOut(XSDataBoolean(self.getRunTime() >= self.__timeout))
# Create some output data
self.setDataOutput(xsDataResult)
def compressRaw(self):
xsdin = XSDataInputExecCommandLine()
xsdin.setFireAndForget(XSDataBoolean(1))
xsdin.setInputFileName(self.getDataInput().getInputRaw())
xsdin.setCommandLineOptions(XSDataString("-9"))
xsdf = XSDataFile()
xsdf.setPath(XSDataString("/bin/bzip2"))
xsdin.setCommandLineProgram(xsdf)
self.__edPluginExecBzip2.setDataInput(xsdin)
self.__edPluginExecBzip2.connectSUCCESS(self.doSuccessExecBzip2)
self.__edPluginExecBzip2.connectFAILURE(self.doFailureExecBzip2)
self.__edPluginExecBzip2.executeSynchronous()
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
EDVerbose.DEBUG("EDPluginExecGnomv0_1.postProcess")
# Create some output data
xsDataResult = self.parseGnomOutputFile()
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(os.path.join(self.getWorkingDirectory(), "gnom.out")))
xsDataResult.setOutput(xsDataFile)
self.setDataOutput(xsDataResult)
def doFailureExecSaxsMac(self, _edPlugin=None):
self.DEBUG("EDPluginBioSaxsNormalizev1_0.doFailureExecSaxsMac")
self.retrieveFailureMessages(_edPlugin, "EDPluginBioSaxsNormalizev1_0.doFailureExecSaxsMac")
strEdnaLogFile = self.__edPluginExecSaxsMac.getScriptLogFileName()
if os.path.isfile(strEdnaLogFile):
shutil.copy(strEdnaLogFile, self.strLogFile)
xsLogFile = XSDataFile()
xsLogFile.setPath(XSDataString(self.strLogFile))
self.xsdResult.setLogFile(xsLogFile)
self.lstProcessLog.append("Normalization failure during execution of saxs_mac.")
self.setFailure()
def postProcess(self, _edObject=None):
"""
"""
EDPluginExec.postProcess(self)
EDVerbose.DEBUG("*** EDPluginDCTWriteSinogramv1_0.postProcess")
xsDataResultWriteSinogram = XSDataResultWriteSinogram()
for pystrPathToOneSinogram in self.pydProcessSinograms:
oneSinogram = XSDataFile()
oneSinogram.setPath(XSDataString(pystrPathToOneSinogram + "Size%ix%i.edf" % (self.yMax, self.xMax)))
xsDataResultWriteSinogram.addSinogramFile(oneSinogram)
EDVerbose.DEBUG("Adding sinogram: %s" % pystrPathToOneSinogram)
self.setDataOutput(xsDataResultWriteSinogram)
def process(self, _edObject=None):
"""
"""
for i in range(2):
execPlugin = self.loadPlugin(self.__strControlledPluginThumbnail)
xsdin = XSDataInputExecThumbnail()
xsdin.setInputArray(self.xsdImages[i])
xsdFile = XSDataFile()
xsdFile.setPath(XSDataString(os.path.join(self.getWorkingDirectory(), "image%i.jpg" % self.xsdIdx[i].getValue())))
xsdin.setOutputPath(xsdFile)
xsdin.setLevelsColorize(XSDataBoolean(1))
xsdin.setLevelsEqualize(XSDataBoolean(1))
execPlugin.setDataInput(xsdin)
execPlugin.connectSUCCESS(self.doSuccessThumb)
execPlugin.connectFAILURE(self.doFailureThumb)
self.ACThumbnail.addAction(execPlugin)
self.ACThumbnail.execute()
while len(self.xsdThumb) < 2:
time.sleep(1)
for oneImage in self.xsdThumb:
execPlugin = self.loadPlugin(self.__strControlledPluginSift)
xsdin = XSDataInputSiftDescriptor()
xsdin.setImage(oneImage)
execPlugin.setDataInput(xsdin)
execPlugin.connectSUCCESS(self.doSuccessSift)
execPlugin.connectFAILURE(self.doFailureSift)
self.ACSift.addAction(execPlugin)
self.ACSift.execute()
#
# else:
# strError = "There are only %s images in self.xsdThumb" % len(self.xsdThumb)
# EDVerbose.ERROR(strError)
# self.setFailure()
# raise RuntimeError(strError)
################################################################################
# This should be executed only after the Sift actions cluster finishes
################################################################################
while len(self.xsdKeys) < 2:
time.sleep(1)
execPlugin = self.loadPlugin(self.__strControlledPluginAutopano)
xsdin = XSDataInputMeasureOffsetSift()
xsdin.setDescriptorFile(self.xsdKeys)
execPlugin.setDataInput(xsdin)
execPlugin.connectSUCCESS(self.doSuccessAutopano)
execPlugin.connectFAILURE(self.doFailureAutopano)
execPlugin.executeSynchronous()
def postProcess(self, _edObject=None):
EDPluginExec.postProcess(self)
self.DEBUG("EDPluginExecSaxsCurvesv1_1.postProcess")
# Create some output data
xsDataResult = XSDataResultSaxsCurvesv1_0()
if self.outputDataFile is None:
self.outputDataFile = "output.edf"
if os.path.isfile(self.outputDataFile):
xsdFile = XSDataFile()
xsdFile.setPath(XSDataString(os.path.abspath(self.outputDataFile)))
xsDataResult.setOutputDataFile(xsdFile)
self.setDataOutput(xsDataResult)
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
strError = self.readProcessErrorLogFile()
if((strError is not None) and (strError != "")):
strErrorMessage = EDMessage.ERROR_EXECUTION_03 % ('EDPluginMxv1ParamsToXMLv1_0.postProcess', 'EDPluginMxv1ParamsToXMLv1_0', strError)
EDVerbose.error(strErrorMessage)
self.addErrorMessage(strErrorMessage)
raise RuntimeError, strErrorMessage
# This should work as long as there is a single output, i.e. not a list:
strFilePath = os.path.join(self.getWorkingDirectory(), self.getScriptLogFileName())
xsDataFileResult = XSDataFile()
xsDataFileResult.setPath(XSDataString(strFilePath))
# Do not specify name of output here:
self.setDataOutput(xsDataFileResult)
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
EDVerbose.DEBUG("EDPluginExecDcrawv1_0.postProcess")
# Create some output data
xsDataResult = XSDataResultExecDcrawv1()
xsdFile = XSDataFile()
if self.__strOutputFile is not None:
shutil.copyfile(os.path.join(self.getWorkingDirectory(), self.getScriptLogFileName()), self.__strOutputFile)
xsdFile.setPath(XSDataString(self.__strOutputFile))
else:
xsdFile.setPath(XSDataString(os.path.join(self.getWorkingDirectory(), self.getScriptLogFileName())))
xsDataResult.setOutputPath(xsdFile)
if self.__strOutputType is not None:
xsDataResult.setOutputFileType(XSDataString(self.__strOutputType))
self.setDataOutput(xsDataResult)
def postProcess(self, _edObject=None):
EDPluginExec.postProcess(self)
EDVerbose.DEBUG("EDPluginExportAsciiPowderv1_0.postProcess")
# Create some output data
xsDataResult = XSDataResult1DPowderEDF()
if self.outputFilename is None:
xsDataResult.setTwoTheta(EDUtilsArray.arrayToXSData(self.npaTwoTheta))
xsDataResult.setIntensity(EDUtilsArray.arrayToXSData(self.npaIntensities))
else:
xsdFile = XSDataFile()
xsdFile.setPath(XSDataString(self.outputFilename))
xsDataResult.setOutputFile(xsdFile)
self.setDataOutput(xsDataResult)
self.npaTwoTheta = None
self.npaIntensities = None
self.inputArray = None
def postProcess(self, _edObject=None):
"""
Postprocess of the plugin:
* set output of the plugin
* free some memory from large arrays
"""
EDPluginExec.postProcess(self)
EDVerbose.DEBUG("EDPluginPyarchThumbnailv10.postProcess")
# Create some output data
if self.strOutputPath:
xsDataResult = XSDataResultPyarchThumbnail()
if os.path.isfile(self.strOutputPath):
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(self.strOutputPath))
xsDataResult.setThumbnailPath(xsDataFile)
self.setDataOutput(xsDataResult)
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
self.DEBUG("EDPluginExecSiftOffsetv1_0.postProcess")
xsDataResult = XSDataResultMeasureOffsetSift()
if os.path.isfile(self.outFile):
xsdStr = XSDataString(self.outFile)
xsdFile = XSDataFile()
xsdFile.setPath(xsdStr)
xsDataResult.setPanoFile(xsdFile)
dx = []
dy = []
for oneLine in open(self.outFile).readlines():
if oneLine.startswith("c"):
x = 0
X = 0
y = 0
Y = 0
for oneWord in oneLine.strip().split(" "):
if oneWord.startswith("x"):
x = float(oneWord[1:])
elif oneWord.startswith("X"):
X = float(oneWord[1:])
elif oneWord.startswith("y"):
y = float(oneWord[1:])
elif oneWord.startswith("Y"):
Y = float(oneWord[1:])
if x != 0 and y != 0 and X != 0 and Y != 0 and abs(X - x) < 100 and abs(Y - y) < 100:
dx.append(X - x)
dy.append(Y - y)
else:
self.DEBUG("%s %s %s %s %s %s %s" % (oneLine, x, y, X, Y, X - x, Y - y))
dx.sort()
dy.sort()
subDx = dx[int(round(0.1 * len(dx))):int(round(0.9 * len(dx)))]
subDy = dy[int(round(0.1 * len(dy))):int(round(0.9 * len(dy)))]
sum1 = 0.0
sum2 = 0.0
for i in subDx:
sum1 += i
for i in subDy:
sum2 += i
xsDataResult.setOffset([XSDataDouble(-sum2 / max(1, len(subDy))), XSDataDouble(-sum1 / max(1, len(subDx))) ])
# Create some output data
self.setDataOutput(xsDataResult)
def postProcess(self, _edObject=None):
"""
Post-Process: set the output of the plugin
"""
EDPluginExecProcessScript.postProcess(self)
self.DEBUG("EDPluginExecCommandLinev10.postProcess")
# Create some output data
xsDataResult = XSDataResultExecCommandLine()
if self.dataInput.getFireAndForget() is not None:
if self.dataInput.getFireAndForget().value is True:
self.setDataOutput(xsDataResult)
return
if self.dataInput.getOutfileFromStdout() is not None:
#self.DEBUG("*** getOutfileFromStdout = %s" % self.dataInput.getOutfileFromStdout().value)
if self.dataInput.getOutfileFromStdout().value : # this is not clean ... should be 1 or True ... or whatever
if self.dataInput.getOutputPath() is not None:
outputPath = self.dataInput.getOutputPath().path.value
stdout = os.path.join(self.getWorkingDirectory() , self.getScriptLogFileName())
self.synchronizeOn()
if os.path.isdir(outputPath):
outfile = os.path.join(outputPath, os.path.split(self.dataInput.inputFileName.path.value)[1])
else:
outfile = outputPath
if os.path.isfile(outfile):
takenNames = []
[mydir, myname] = os.path.split(outfile)
for onefile in os.listdir(mydir):
if onefile.find(myname) == 0:
takenNames.append(onefile)
for ext in string.digits + string.ascii_lowercase:
if not (outfile + ext) in takenNames:
outfile += ext
break
shutil.move(stdout , outfile)
self.synchronizeOff()
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(outfile))
xsDataResult.setOutputFilename(xsDataFile)
else:
xsDataResult.setOutputFilename(self.getScriptLogFileName())
self.setDataOutput(xsDataResult)
def testCreateDataMOSFLMOutputIntegration(self):
pluginIntegration = self.createPlugin()
pluginIntegration.setScriptExecutable("cat")
pluginIntegration.configure()
strBaseName = pluginIntegration.getBaseName()
shutil.copyfile(os.path.join(self.strUnitTestDataHome, "EDPluginMOSFLMIntegrationv10_bestfileDat_ok.txt"), os.path.join (pluginIntegration.getWorkingDirectory(), "bestfile.dat"))
shutil.copyfile(os.path.join(self.strUnitTestDataHome, "EDPluginMOSFLMIntegrationv10_bestfilePar_ok.txt"), os.path.join (pluginIntegration.getWorkingDirectory(), "bestfile.par"))
shutil.copyfile(os.path.join(self.strUnitTestDataHome, "EDPluginMOSFLMIntegrationv10_bestfileHKL_ok.txt"), os.path.join (pluginIntegration.getWorkingDirectory(), "bestfile.hkl"))
shutil.copyfile(os.path.join(self.strUnitTestDataHome, "EDPluginMOSFLMIntegrationv10_outputDnaTables_ok.xml"), os.path.join(pluginIntegration.getWorkingDirectory(), strBaseName + "_dnaTables.xml"))
strMatrixFile = os.path.join(self.strUnitTestDataHome, "EDPluginMOSFLMv10_autoindexMat_ok.txt")
pluginIntegration.setMatrixFileName(strMatrixFile)
xsDataMOSFLMIntegrationOutput = pluginIntegration.createDataMOSFLMOutputIntegration()
# Fix problem with absolute path by replacing it with a fixed one
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString("/tmp/EDPluginMOSFLMIntegrationv10_process_1_1.mtz"))
xsDataMOSFLMIntegrationOutput.setGeneratedMTZFile(xsDataFile)
strReferenceXML = self.readAndParseFile(self.strReferenceDataOutputFile)
xsDataMOSFLMIntegrationOutputReference = XSDataMOSFLMOutputIntegration.parseString(strReferenceXML)
EDAssert.equal(xsDataMOSFLMIntegrationOutputReference.marshal(), xsDataMOSFLMIntegrationOutput.marshal())
def postProcess(self, _edObject=None):
EDPluginHDF5.postProcess(self)
self.DEBUG("EDPluginHDF5MapOfSpectrav10.postProcess")
xsDataResult = XSDataResultHDF5MapSpectra()
if os.path.isfile(self.strHDF5Filename):
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(self.strHDF5Filename))
xsDataResult.setHDF5File(xsDataFile)
xsDataResult.setInternalHDF5Path(XSDataString(self.strHDF5Path))
self.setDataOutput(xsDataResult)
# Delete input images if requested
if self.bDeleteSpectrum:
for oneImage in self.listSpectrumFilenames:
os.remove(oneImage)
# De-Allocate memory
self.listSpectrumFilenames = []
self.listForcedPositions = []
self.listSpectrumFileType = []
self.listArray = []
def readIdxrefLp(self, _pathToIdxrefLp, _xsDataResultXDSIndexing=None):
self.DEBUG("EDPluginXDSIndexingv1_0.readIdxrefLp")
if _xsDataResultXDSIndexing is None:
xsDataResultXDSIndexing = XSDataResultXDSIndexing()
else:
xsDataResultXDSIndexing = _xsDataResultXDSIndexing
if os.path.exists(_pathToIdxrefLp):
xsDataResultXDSIndexing.pathToLogFile = XSDataFile(XSDataString(_pathToIdxrefLp))
with open(_pathToIdxrefLp) as f:
listLines = f.readlines()
indexLine = 0
doParseParameters = False
doParseLattice = False
while (indexLine < len(listLines)):
if "DIFFRACTION PARAMETERS USED AT START OF INTEGRATION" in listLines[indexLine]:
doParseParameters = True
doParseLattice = False
elif "DETERMINATION OF LATTICE CHARACTER AND BRAVAIS LATTICE" in listLines[indexLine]:
doParseParameters = False
doParseLattice = True
if doParseParameters:
if "MOSAICITY" in listLines[indexLine]:
mosaicity = float(listLines[indexLine].split()[-1])
xsDataResultXDSIndexing.mosaicity = XSDataAngle(mosaicity)
elif "DETECTOR COORDINATES (PIXELS) OF DIRECT BEAM" in listLines[indexLine]:
xBeam = float(listLines[indexLine].split()[-2])
yBeam = float(listLines[indexLine].split()[-1])
xsDataResultXDSIndexing.beamCentreX = XSDataFloat(xBeam)
xsDataResultXDSIndexing.beamCentreY = XSDataFloat(yBeam)
elif "CRYSTAL TO DETECTOR DISTANCE" in listLines[indexLine]:
distance = float(listLines[indexLine].split()[-1])
xsDataResultXDSIndexing.distance = XSDataLength(distance)
elif doParseLattice:
if listLines[indexLine].startswith(" * ") and not listLines[indexLine + 1].startswith(" * "):
listLine = listLines[indexLine].split()
xsDataResultXDSIndexing.latticeCharacter = XSDataInteger(int(listLine[1]))
bravaisLattice = listLine[2]
xsDataResultXDSIndexing.bravaisLattice = XSDataString(bravaisLattice)
spaceGroup = EDUtilsSymmetry.getMinimumSymmetrySpaceGroupFromBravaisLattice(bravaisLattice)
xsDataResultXDSIndexing.spaceGroup = XSDataString(spaceGroup)
spaceGroupNumber = EDUtilsSymmetry.getITNumberFromSpaceGroupName(spaceGroup)
xsDataResultXDSIndexing.spaceGroupNumber = XSDataInteger(spaceGroupNumber)
xsDataResultXDSIndexing.qualityOfFit = XSDataFloat(float(listLine[3]))
xsDataXDSCell = XSDataXDSCell()
xsDataXDSCell.length_a = XSDataLength(float(listLine[4]))
xsDataXDSCell.length_b = XSDataLength(float(listLine[5]))
xsDataXDSCell.length_c = XSDataLength(float(listLine[6]))
xsDataXDSCell.angle_alpha = XSDataAngle(float(listLine[7]))
xsDataXDSCell.angle_beta = XSDataAngle(float(listLine[8]))
xsDataXDSCell.angle_gamma = XSDataAngle(float(listLine[9]))
xsDataResultXDSIndexing.unitCell = xsDataXDSCell
indexLine += 1
return xsDataResultXDSIndexing
def postProcess(self, _edObject=None):
"""
Postprocess of the plugin:
* set output of the plugin
* free some memory from large arrays
"""
EDPluginExec.postProcess(self)
EDVerbose.DEBUG("EDPluginExecThumbnailv10.postProcess")
# Create some output data
xsDataResult = XSDataResultExecThumbnail()
if os.path.isfile(self.output):
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(self.output))
xsDataResult.setThumbnailPath(xsDataFile)
xsDataString = XSDataString()
xsDataString.setValue(self.format)
xsDataResult.setThumbnailType(xsDataString)
self.setDataOutput(xsDataResult)
self.npaImage = None
def testCheckParameters(self):
xsDataInput = XSDataInputBioSaxsAzimutIntv1_0()
xsDataInput.setNormalizedImage(XSDataImage())
xsDataInput.setNormalizedImageSize(XSDataInteger())
xsDataInput.setIntegratedImage(XSDataImage())
xsDataInput.setIntegratedCurve(XSDataFile())
xsDataInput.correctedImage = XSDataImage()
xsDataInput.sample = XSDataBioSaxsSample()
xsDataInput.experimentSetup = XSDataBioSaxsExperimentSetup()
edPluginExec = self.createPlugin()
edPluginExec.setDataInput(xsDataInput)
edPluginExec.checkParameters()
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'characterisationResult':
obj_ = XSDataResultCharacterisation()
obj_.build(child_)
self.setCharacterisationResult(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'fileGraph':
obj_ = XSDataFile()
obj_.build(child_)
self.fileGraph.append(obj_)
XSDataInput.buildChildren(self, child_, nodeName_)
def processRun(self, run):
run.dump_json()
hdf5 = run.save_hdf5()
self.json = os.path.splitext(hdf5)[0] + ".json"
self.xsDataResult.hplcFile = XSDataFile(XSDataString(hdf5))
self.xsDataResult.hplcImage = XSDataFile(XSDataString(run.make_plot()))
for group in run.analyse():
self.lstExecutiveSummary.append("Merging frames from %s to %s" % (group[0], group[-1]))
xsdFrames = [XSDataFile(XSDataString(run.frames[i].subtracted)) for i in group]
outname = os.path.splitext(run.frames[group[0]].subtracted)[0] + "_aver_%s.dat" % group[-1]
edpugin = self.loadPlugin(self.strControlledPluginDatAver)
edpugin.dataInput = XSDataInputDataver(outputCurve=XSDataFile(XSDataString(outname)), inputCurve=xsdFrames)
edpugin.connectSUCCESS(self.doSuccessDatAver)
edpugin.connectFAILURE(self.doFailureDatAver)
edpugin.execute()
run.merge_curves.append(outname)
run.merge_analysis[outname] = None
run.merge_Rg[outname] = None
run.merge_framesDIC[outname] = [group[0], group[-1]]
# Append to hdf5
run.append_hdf5()
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'inputMatrix':
obj_ = XSDataArray()
obj_.build(child_)
self.setInputMatrix(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'outputMatrixFile':
obj_ = XSDataFile()
obj_.build(child_)
self.setOutputMatrixFile(obj_)
XSDataInput.buildChildren(self, child_, nodeName_)
def postProcess(self, _edObject=None):
EDPluginControl.postProcess(self)
self.DEBUG("EDPluginBioSaxsSmartMergev1_7.postProcess")
# Create some output data
self.xsDataResult.mergedCurve = self.dataInput.mergedCurve
if self.strSubFile is not None and os.path.isfile(self.strSubFile):
self.xsDataResult.subtractedCurve = XSDataFile(
XSDataString(self.strSubFile))
self.xsDataResult.autoRg = self.autoRg
self.xsDataResult.gnom = self.gnom
self.xsDataResult.volume = self.volume
self.xsDataResult.rti = self.rti
def doSuccessAccumulator(self, _edPlugin=None):
with self.locked():
self.DEBUG("EDPluginWaitMultiFile.doSuccessAccumulator")
self.retrieveSuccessMessages(
_edPlugin, "EDPluginWaitMultiFile.doSuccessAccumulator")
xsdQueries = _edPlugin.dataOutput.getQuery()
if xsdQueries is not None and len(xsdQueries) == 1:
xsdQuery = xsdQueries[0]
if (xsdQuery is not None) and (len(xsdQuery.getItem()) == len(
self.listXsdFiles)):
self.xsdDataOut.setActualFile(
[XSDataFile(xsd) for xsd in xsdQuery.getItem()])
def postProcess(self, _edObject=None):
EDPluginControl.postProcess(self)
self.DEBUG("EDPluginBioSaxsProcessOneFilev1_3.postProcess")
# Create some output data
xsDataResult = XSDataResultBioSaxsProcessOneFilev1_0()
if os.path.exists(self.integratedCurve):
xsDataResult.integratedCurve = XSDataFile(XSDataString(self.integratedCurve))
xsDataResult.sample = self.sample
xsDataResult.experimentSetup = self.experimentSetup
xsDataResult.status = XSDataStatus(executiveSummary=XSDataString(os.linesep.join(self.lstExecutiveSummary)))
self.setDataOutput(xsDataResult)
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
EDVerbose.DEBUG("EDPluginExecDamfiltv0_1.postProcess")
xsDataResult = XSDataResultDamfilt()
pathOutputFile = XSDataString(
os.path.join(self.getWorkingDirectory(),
self.__strOutputPdbFileName))
xsDataResult.setOutputPdbFile(XSDataFile(pathOutputFile))
self.setDataOutput(xsDataResult)
def average_buffers(self):
"""
Average out all buffers
"""
self.lstExecutiveSummary.append("Averaging out buffer files: " +
", ".join(self.hplc_run.for_buffer))
xsdIn = XSDataInputDataver(inputCurve=[
XSDataFile(XSDataString(i)) for i in self.hplc_run.for_buffer
])
if self.dataInput.bufferCurve:
xsdIn.outputCurve = self.dataInput.bufferCurve
else:
xsdIn.outputCurve = XSDataFile(
XSDataString(
self.hplc_run.first_curve[::-1].split("_", 1)[1][::-1] +
"_buffer_aver%02i.dat" % len(self.hplc_run.for_buffer)))
self.edPluginDatAver = self.loadPlugin(self.strControlledPluginDatAver)
self.edPluginDatAver.dataInput = xsdIn
self.edPluginDatAver.connectSUCCESS(self.doSuccessDatAver)
self.edPluginDatAver.connectFAILURE(self.doFailureDatAver)
self.edPluginDatAver.executeSynchronous()
def buildChildren(self, child_, nodeName_): if child_.nodeType == Node.ELEMENT_NODE and \ nodeName_ == 'plotSet': obj_ = XSDataPlotSet() obj_.build(child_) self.setPlotSet(obj_) elif child_.nodeType == Node.ELEMENT_NODE and \ nodeName_ == 'filePlotMtv': obj_ = XSDataFile() obj_.build(child_) self.setFilePlotMtv(obj_) XSDataInput.buildChildren(self, child_, nodeName_)
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'elementName':
obj_ = XSDataString()
obj_.build(child_)
self.setElementName(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'inputFile':
obj_ = XSDataFile()
obj_.build(child_)
self.setInputFile(obj_)
XSDataInput.buildChildren(self, child_, nodeName_)
def postProcess(self, _oedObject=None):
EDPluginExecProcessScript.postProcess(self, _oedObject)
# Fill in file paths
xsDataXDSFilePaths = XSDataXDSFilePaths()
xparmXds = os.path.join(self.getWorkingDirectory(), "XPARM.XDS")
if os.path.exists(xparmXds):
xsDataXDSFilePaths.xparmXds = XSDataFile(XSDataString(xparmXds))
xCorrectionsCbf = os.path.join(self.getWorkingDirectory(),
"X-CORRECTIONS.cbf")
if os.path.exists(xCorrectionsCbf):
xsDataXDSFilePaths.xCorrectionsCbf = XSDataFile(
XSDataString(xCorrectionsCbf))
yCorrectionsCbf = os.path.join(self.getWorkingDirectory(),
"Y-CORRECTIONS.cbf")
if os.path.exists(yCorrectionsCbf):
xsDataXDSFilePaths.yCorrectionsCbf = XSDataFile(
XSDataString(yCorrectionsCbf))
bkginitCbf = os.path.join(self.getWorkingDirectory(), "BKGINIT.cbf")
if os.path.exists(bkginitCbf):
xsDataXDSFilePaths.bkginitCbf = XSDataFile(
XSDataString(bkginitCbf))
gainCbf = os.path.join(self.getWorkingDirectory(), "GAIN.cbf")
if os.path.exists(gainCbf):
xsDataXDSFilePaths.gainCbf = XSDataFile(XSDataString(gainCbf))
blankCbf = os.path.join(self.getWorkingDirectory(), "BLANK.cbf")
if os.path.exists(blankCbf):
xsDataXDSFilePaths.blankCbf = XSDataFile(XSDataString(blankCbf))
self.dataOutput.filePaths = xsDataXDSFilePaths
def parseOutputDirectory(self, _workingDirectory):
xsDataResultXia2DIALS = XSDataResultXia2DIALS()
# Log file
xia2txtPath = os.path.join(_workingDirectory, "xia2.txt")
if os.path.exists(xia2txtPath):
xsDataResultXia2DIALS.logFile = XSDataFile(
XSDataString(xia2txtPath))
# Html file
xia2htmlPath = os.path.join(_workingDirectory, "xia2.html")
if os.path.exists(xia2htmlPath):
xsDataResultXia2DIALS.htmlFile = XSDataFile(
XSDataString(xia2htmlPath))
# Summary file
summaryPath = os.path.join(_workingDirectory, "xia2-summary.dat")
if os.path.exists(summaryPath):
xsDataResultXia2DIALS.summary = XSDataFile(
XSDataString(summaryPath))
# ISPyB XML file
ispybXmlPath = os.path.join(_workingDirectory, "ispyb.xml")
if os.path.exists(ispybXmlPath):
xsDataResultXia2DIALS.ispybXML = XSDataFile(
XSDataString(ispybXmlPath))
# Datafiles
dataFiles = glob.glob(os.path.join(_workingDirectory, "DataFiles",
"*"))
for dataFile in dataFiles:
xsDataResultXia2DIALS.addDataFiles(
XSDataFile(XSDataString(dataFile)))
# Log files
logFiles = glob.glob(os.path.join(_workingDirectory, "LogFiles", "*"))
for logFile in logFiles:
xsDataResultXia2DIALS.addLogFiles(XSDataFile(
XSDataString(logFile)))
return xsDataResultXia2DIALS
def processRun(self, run):
run.dump_json()
hdf5 = run.save_hdf5()
self.json = os.path.splitext(hdf5)[0] + ".json"
self.xsDataResult.hplcFile = XSDataFile(XSDataString(hdf5))
self.xsDataResult.hplcImage = XSDataFile(XSDataString(run.make_plot()))
try:
peaks = run.analyse()
for group in peaks:
self.lstExecutiveSummary.append(
"Merging frames from %s to %s" % (group[0], group[-1]))
xsdFrames = [
XSDataFile(XSDataString(run.frames[i].subtracted))
for i in group
]
outname = os.path.splitext(run.frames[
group[0]].subtracted)[0] + "_aver_%s.dat" % group[-1]
edpugin = self.loadPlugin(self.strControlledPluginDatAver)
edpugin.dataInput = XSDataInputDataver(outputCurve=XSDataFile(
XSDataString(outname)),
inputCurve=xsdFrames)
edpugin.connectSUCCESS(self.doSuccessDatAver)
edpugin.connectFAILURE(self.doFailureDatAver)
edpugin.execute()
run.merge_curves.append(outname)
run.merge_analysis[outname] = None
run.merge_Rg[outname] = None
run.merge_framesDIC[outname] = [group[0], group[-1]]
except ValueError:
traceback.print_stack()
self.ERROR(
"EDPluginBioSaxsFlushHPLCv1_3: ValueError Error in analysing run"
)
except Exception as error:
traceback.print_stack()
self.ERROR(
"EDPluginBioSaxsFlushHPLCv1_3: Error in analysing run" %
error)
# Append to hdf5
run.append_hdf5()
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginBioSaxsNormalizev1_1.process")
xsdiWaitFile = XSDataInputWaitFile(
expectedFile=XSDataFile(self.xsdInput.rawImage.path),
expectedSize=self.xsdInput.rawImageSize,
timeOut=XSDataTime(value=30))
self.__edPluginExecWaitFile.setDataInput(xsdiWaitFile)
self.__edPluginExecWaitFile.connectSUCCESS(self.doSuccessExecWaitFile)
self.__edPluginExecWaitFile.connectFAILURE(self.doFailureExecWaitFile)
self.__edPluginExecWaitFile.executeSynchronous()
if self.isFailure():
return
# Small Numpy processing:
fabIn = fabio.open(self.strRawImage)
if "time_of_day" in fabIn.header:
self.dictOutputHeader["time_of_day"] = fabIn.header["time_of_day"]
if "Mask" in self.dictOutputHeader:
mask = self.getMask(self.dictOutputHeader["Mask"])
npaMaskedData = numpy.ma.masked_array(
fabIn.data.astype("float32"),
((fabIn.data < 0) + (mask[:fabIn.dim2, :fabIn.dim1] < 0)))
else:
npaMaskedData = numpy.ma.masked_array(fabIn.data.astype("float32"),
(fabIn.data < 0))
if self.dictOutputHeader["DiodeCurr"] == 0:
warn = "DiodeCurr is Null --> I Guess we are testing and take it as one"
self.lstProcessLog.append(warn)
self.warning(warn)
scale = self.dictOutputHeader["Normalization"]
else:
scale = self.dictOutputHeader[
"Normalization"] / self.dictOutputHeader["DiodeCurr"]
self.dictOutputHeader["Dummy"] = str(self.dummy)
self.dictOutputHeader["DDummy"] = "0.1"
self.dictOutputHeader["EDF_DataBlockID"] = "1.Image.Psd"
header_keys = self.dictOutputHeader.keys()
header_keys.sort()
fabioOut = fabio.edfimage.edfimage(header=self.dictOutputHeader,
header_keys=header_keys,
data=numpy.ma.filled(
npaMaskedData * scale,
float(self.dummy)))
fabioOut.appendFrame(header={
"Dummy": str(self.dummy),
"DDummy": "0.1",
"EDF_DataBlockID": "1.Image.Error"
},
data=(numpy.ma.filled(npaMaskedData * (scale**2),
float(self.dummy))))
fabioOut.write(self.strNormalizedImage)
self.lstProcessLog.append("Normalized image by factor %.3f " % (scale))
def postProcess(self, _edObject=None):
EDPluginControl.postProcess(self)
self.DEBUG("EDPluginBioSaxsSmartMergev1_3.postProcess")
# Create some output data
xsDataResult = XSDataResultBioSaxsSmartMergev1_0()
xsDataResult.mergedCurve = self.dataInput.mergedCurve
executiveSummary = os.linesep.join(self.lstSummary)
xsDataResult.status = XSDataStatus(executiveSummary=XSDataString(executiveSummary))
if self.autoRg is not None:
xsDataResult.autoRg = self.autoRg
if self.strSubFile is not None and os.path.isfile(self.strSubFile):
xsDataResult.subtractedCurve = XSDataFile(XSDataString(self.strSubFile))
self.setDataOutput(xsDataResult)
def postProcess(self, _edObject=None):
"""
"""
if (self.edXMLFileSize > 0):
EDVerbose.DEBUG(
strftime("%Y-%m-%d %H:%M:%S") +
" *** EDPluginExecSRBRegisterv10.postProcess...")
# This is to make the tests pass, and it is during the postprocess step where the data is returned from the plugin.
xsDataResultPluginExecSRBRegister = XSDataResultPluginExecSRBRegister(
)
edOutput = XSDataFile(XSDataString(self.edXMLFileName))
xsDataResultPluginExecSRBRegister.setXmlIngestFileName(edOutput)
self.setDataOutput(xsDataResultPluginExecSRBRegister)
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'dataCollectionId':
obj_ = XSDataInteger()
obj_.build(child_)
self.setDataCollectionId(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'dozorProcessDirectory':
obj_ = XSDataFile()
obj_.build(child_)
self.setDozorProcessDirectory(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'xdsappProcessDirectory':
obj_ = XSDataFile()
obj_.build(child_)
self.setXdsappProcessDirectory(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'doAnomAndNonanom':
obj_ = XSDataBoolean()
obj_.build(child_)
self.setDoAnomAndNonanom(obj_)
XSDataInput.buildChildren(self, child_, nodeName_)
def finallyProcess(self, _edPlugin=None):
EDPluginExec.finallyProcess(self, _edPlugin)
self.DEBUG("EDPluginExecSimpleHTMLPagev1_1.finallyProcess...")
xsDataResultSimpleHTMLPage = XSDataResultSimpleHTMLPage()
xsDataResultSimpleHTMLPage.setPathToHTMLFile(
XSDataFile(
XSDataString(
os.path.join(self.getWorkingDirectory(),
self.strHtmlFileName))))
xsDataResultSimpleHTMLPage.setPathToHTMLDirectory(
XSDataFile(XSDataString(self.getWorkingDirectory())))
# Write workflowStepReport HTML page
pathToIndexFile = self.workflowStepReport.renderHtml(
self.getWorkingDirectory(), nameOfIndexFile=self.strHtmlFileName)
pathToJsonFile = self.workflowStepReport.renderJson(
self.getWorkingDirectory())
# Store in Pyarch
if EDUtilsPath.isESRF() or EDUtilsPath.isEMBL() or EDUtilsPath.isALBA:
strPyarchPath = None
if self.xsDataResultCharacterisation is not None:
strPyarchPath = EDHandlerESRFPyarchv1_0.createPyarchHtmlDirectoryPath(
self.xsDataResultCharacterisation.getDataCollection())
if strPyarchPath is None:
# For debugging purposes
strPyarchPath = EDUtilsPath.getEdnaUserTempFolder()
EDHandlerESRFPyarchv1_0.copyHTMLDir(
_strPathToHTMLDir=os.path.dirname(self.strPath),
_strPathToPyarchDirectory=strPyarchPath)
xsDataResultSimpleHTMLPage.setPathToHTMLDirectory(
XSDataFile(XSDataString(strPyarchPath)))
if not os.path.exists(strPyarchPath):
os.makedirs(strPyarchPath, 0o755)
shutil.copy(pathToJsonFile, strPyarchPath)
pathToJsonFile = os.path.join(strPyarchPath,
os.path.basename(pathToJsonFile))
# Write json file
xsDataResultSimpleHTMLPage.pathToJsonFile = XSDataFile(
XSDataString(pathToJsonFile))
self.setDataOutput(xsDataResultSimpleHTMLPage)
def process(self, _edObject=None):
EDPluginControl.process(self)
self.DEBUG("EDPluginControlGridScreeningv1_0.process")
xsDataInputReadImageHeader = XSDataInputReadImageHeader()
xsDataInputReadImageHeader.setImage(image=XSDataFile(
path=XSDataString(self.strImageFile)))
self.edPluginControlReadImageHeader.setDataInput(
xsDataInputReadImageHeader)
self.edPluginControlReadImageHeader.connectSUCCESS(
self.doSuccessReadImageHeader)
self.edPluginControlReadImageHeader.connectFAILURE(
self.doFailureReadImageHeader)
self.executePluginSynchronous(self.edPluginControlReadImageHeader)
def createDataMOSFLMOutputGeneratePrediction(self):
self.DEBUG("EDPluginMOSFLMGeneratePredictionv10.createDataMOSFLMOutputIntegration")
xsDataMOSFLMInputGeneratePrediction = self.getDataInput()
xsDataMOSFLMImage = xsDataMOSFLMInputGeneratePrediction.getImage()
iImageNumber = xsDataMOSFLMImage.getNumber().getValue()
xsDataMOSFLMOutputGeneratePrediction = XSDataMOSFLMOutputGeneratePrediction()
xsDataImage = XSDataImage()
xsDataImage.setNumber(XSDataInteger(iImageNumber))
xsDataImage.setPath(XSDataString(os.path.join(self.getWorkingDirectory(), self.getPredictionImageFileName())))
xsDataMOSFLMOutputGeneratePrediction.setPredictionImage(xsDataImage)
# Path to log file
xsDataMOSFLMOutputGeneratePrediction.setPathToLogFile(XSDataFile(XSDataString(os.path.join(self.getWorkingDirectory(), self.getScriptLogFileName()))))
return xsDataMOSFLMOutputGeneratePrediction
def populateXSDataInputSPDCake(dictID11):
xsDataInputSPDCake = XSDataInputSPDCake()
# Angle of tilt
xsDataInputSPDCake.setAngleOfTilt(
XSDataAngle(float(dictID11["ANGLE OF TILT"])))
# Dark current
if dictID11["DARK CURRENT"] == "YES":
xsDataInputSPDCake.setDarkCurrentImageFile(
XSDataFile(XSDataString(dictID11["DC FILE"])))
#xsDataFile = XSDataFile()
#xsDataFile.setPath(XSDataString(dictID11["DC FILE "]))
#xsDataInputSPDCake.setDarkCurrentImageFile(xsDataFile)
if dictID11["FLAT-FIELD"] == "YES":
xsDataInputSPDCake.setFlatFieldImageFile(
XSDataFile(XSDataString(dictID11["FF FILE"])))
if dictID11["FF SCALE"] == "NO":
xsDataInputSPDCake.setFlatFieldImageFile(
XSDataFile(XSDataString(dictID11["FF MULTIPLIER"])))
if dictID11["SPATIAL DIS."] == "YES":
xsDataInputSPDCake.setSpatialDistortionFile(
XSDataFile(XSDataString(dictID11["SD FILE"])))
xsDataInputSPDCake.setStartAzimuth(
XSDataAngle(float(dictID11["START AZIMUTH"])))
xsDataInputSPDCake.setStopAzimuth(
XSDataAngle(float(dictID11["END AZIMUTH"])))
xsDataInputSPDCake.setInnerRadius(
XSDataDouble(float(dictID11["INNER RADIUS"])))
xsDataInputSPDCake.setOuterRadius(
XSDataDouble(float(dictID11["OUTER RADIUS"])))
xsDataInputSPDCake.setBufferSizeX(
XSDataInteger(int(dictID11["X-PIXEL SIZE"])))
xsDataInputSPDCake.setBufferSizeY(
XSDataInteger(int(dictID11["Y-PIXEL SIZE"])))
xsDataInputSPDCake.setSampleToDetectorDistance(
XSDataLength(float(dictID11["DISTANCE"])))
xsDataInputSPDCake.setWavelength(
XSDataLength(float(dictID11["WAVELENGTH"])))
xsDataInputSPDCake.setBeamCentreInPixelsX(
XSDataDouble(float(dictID11["X-BEAM CENTRE"])))
xsDataInputSPDCake.setBeamCentreInPixelsY(
XSDataDouble(float(dictID11["Y-BEAM CENTRE"])))
xsDataInputSPDCake.setTiltRotation(
XSDataAngle(float(dictID11["TILT ROTATION"])))
xsDataInputSPDCake.setOutputFileType(
XSDataFile(XSDataString(dictID11["saving_format"])))
xsDataInputSPDCake.setOutputFileType(
XSDataFile(XSDataString(dictID11["output_dir"])))
# TODO : some parameters remain not inserted in this file because not in the datamodel
print xsDataInputSPDCake.marshal()
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'inputFile':
obj_ = XSDataFile()
obj_.build(child_)
self.inputFile.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'energyCalibration':
obj_ = XSDataEnergyCalibration()
obj_.build(child_)
self.setEnergyCalibration(obj_)
XSDataInput.buildChildren(self, child_, nodeName_)
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'logFile':
obj_ = XSDataFile()
obj_.build(child_)
self.setLogFile(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'solution':
obj_ = XSDataXOalignSolution()
obj_.build(child_)
self.solution.append(obj_)
XSDataResult.buildChildren(self, child_, nodeName_)
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'inputFile':
obj_ = XSDataFile()
obj_.build(child_)
self.setInputFile(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'nSkipHeader':
obj_ = XSDataInteger()
obj_.build(child_)
self.setNSkipHeader(obj_)
XSDataInput.buildChildren(self, child_, nodeName_)
def functionXMLin(_strFilename):
"""Here we create the XML string to be passed to the EDNA plugin from the input strFilename
This can / should be modified by the final user
@param _strFilename: full path of the input file
@type _strFilename: python string representing the path
@return: string
"""
EDVerbose.screen("Starting processing of image %s" % (_strFilename))
# First check if the filename end with .img or .mccd:
strXML = None
if (_strFilename.endswith(".img") or _strFilename.endswith(".mccd") or _strFilename.endswith(".cbf")):
xsDataInputInterface = XSDataInputInterface()
xsDataDiffractionPlan = XSDataDiffractionPlan()
xsDataDiffractionPlan.setMaxExposureTimePerDataCollection(XSDataTime(EDParallelExecuteMXv1Characterisation.m_fMaxExposureTime))
xsDataInputInterface.setDiffractionPlan(xsDataDiffractionPlan)
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(_strFilename))
xsDataInputInterface.addImagePath(xsDataFile)
strXML = xsDataInputInterface.marshal()
else:
EDVerbose.screen("File name not ending with .img or .mccd - ignored : %s" % _strFilename)
return strXML
def finallyProcess(self, _edPlugin=None):
EDPluginExec.finallyProcess(self, _edPlugin)
self.DEBUG("EDPluginExecSimpleHTMLPagev1_0.finallyProcess...")
# Render the page
strHTML = str(self.page)
EDUtilsFile.writeFile(self.strPath, strHTML)
xsDataResultSimpleHTMLPage = XSDataResultSimpleHTMLPage()
xsDataResultSimpleHTMLPage.setPathToHTMLFile(
XSDataFile(XSDataString(self.strPath)))
xsDataResultSimpleHTMLPage.setPathToHTMLDirectory(
XSDataFile(XSDataString(os.path.dirname(self.strPath))))
self.setDataOutput(xsDataResultSimpleHTMLPage)
# Store in Pyarch
strPyarchPath = None
if self.xsDataResultCharacterisation is not None:
strPyarchPath = EDHandlerESRFPyarchv1_0.createPyarchHtmlDirectoryPath(
self.xsDataResultCharacterisation.getDataCollection())
if strPyarchPath is None:
# For debugging purposes
strPyarchPath = EDUtilsPath.getEdnaUserTempFolder()
EDHandlerESRFPyarchv1_0.copyHTMLDir(
_strPathToHTMLDir=os.path.dirname(self.strPath),
_strPathToPyarchDirectory=strPyarchPath)
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'imageNumber':
obj_ = XSDataInteger()
obj_.build(child_)
self.setImageNumber(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'hdf5ImageNumber':
obj_ = XSDataInteger()
obj_.build(child_)
self.setHdf5ImageNumber(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'hdf5File':
obj_ = XSDataFile()
obj_.build(child_)
self.setHdf5File(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'forcedOutputDirectory':
obj_ = XSDataFile()
obj_.build(child_)
self.setForcedOutputDirectory(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'forcedOutputImageNumber':
obj_ = XSDataInteger()
obj_.build(child_)
self.setForcedOutputImageNumber(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'startImageNumber':
obj_ = XSDataInteger()
obj_.build(child_)
self.setStartImageNumber(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'endImageNumber':
obj_ = XSDataInteger()
obj_.build(child_)
self.setEndImageNumber(obj_)
XSDataInput.buildChildren(self, child_, nodeName_)