def postProcess(self, _edObject=None):
"""
"""
EDPluginControl.postProcess(self, _edObject)
EDVerbose.DEBUG("EDPluginControlKappaStrategyv2_0.postProcess...")
xsDataResultBest = self.edPluginBest.getDataOutput()
xsDataResultStrategy = None
if(xsDataResultBest is not None):
xsDataResultStrategy = self.edHandlerXSDataBest.getXSDataResultStrategy(xsDataResultBest, self.getDataInput("mxv1InputStrategy")[0].getExperimentalCondition(), self.xsDataSampleCopy)
self.setDataOutput(xsDataResultStrategy)
#possibleAlignments
try:
self.setDataOutput(self.edPluginAlignment.getDataOutput(), "possibleOrientations")
except:
EDVerbose.WARNING("Could not get the list of Possible orientations.")
def generateAbsCalcScript(self):
EDVerbose.DEBUG("*** EDPluginExecGnomv0_1.generateGnomScript")
self.setScriptCommandline("")
commandList = ['1', '1', str(self.__iNumCompounds), '1']
map(commandList.extend,
[[tmp['formula'],
str(tmp['fraction']),
str(tmp['density'])] for tmp in self.__lCompounds])
commandList.extend(
[self.__tBuffer['formula'],
str(self.__tBuffer['density'])])
commandList.extend([
self.__strEdge,
str(self.__fTransAfterEdge),
str(self.__fDiameterDisk), '1'
])
self.addListCommandExecution('\n'.join(commandList))
def preProcess(self, _edPlugin=None):
"""
Prepares the execution plugin
"""
EDPluginControl.preProcess(self, _edPlugin)
EDVerbose.DEBUG("EDPluginControlImageQualityIndicatorsv1_1.preProcess...")
# List containing instances of all the exeuction plugins
self.listPluginExecImageQualityIndicator = []
# Loop through all the incoming reference images
self.edPluginWaitMultiFile = self.loadPlugin(self.strPluginExecWaitMultiFileName)
listXSDataImage = self.getDataInput().getImage()
xsDataInputWaitMultiFile = XSDataInputWaitMultiFile()
for xsDataImage in listXSDataImage:
xsDataInputWaitMultiFile.addExpectedFile(XSDataFile(xsDataImage.getPath()))
xsDataInputWaitMultiFile.setExpectedSize(XSDataInteger(100000))
xsDataInputWaitMultiFile.setTimeOut(XSDataTime(self.fWaitFileTimeOut))
self.DEBUG("Wait file timeOut set to %f" % self.fWaitFileTimeOut)
self.edPluginWaitMultiFile.setDataInput(xsDataInputWaitMultiFile)
self.xsDataResultControlImageQualityIndicators = XSDataResultControlImageQualityIndicators()
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResult.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same",
_strExcluded="bioSaxs")
def doSuccess_MTZDUMP(self, _edPlugin=None):
"""
This method is called after the MTZDUMPUnitCellSpaceGroup execution plugin has successfully processed,
it retrieves the results out of the execution plugin MTZDUMPUnitCellSpaceGroupv10
and sets the input for the second execution plugin EDPluginExecPDBSETUnitCellv10
before running it. The two methods doSuccess_PDBSET and doFailure_PDBSET are also connected here.
"""
EDVerbose.DEBUG("*** doSuccess_MTZDUMP")
self.xsDataInput_inputUnitCell = self.edPluginMTZDUMP.getDataOutput(
).getUnitCell()
self.xsDataInput_PDBSET = XSDataInputPDBSETUnitCell()
self.xsDataInput_PDBSET.setUnitCell(self.xsDataInput_inputUnitCell)
self.xsDataInput_PDBSET.setInputPDBFile(self.xsDataInput_inputPDBFile)
self.edPluginPDBSET = self.loadPlugin('EDPluginExecPDBSETUnitCellv10')
self.edPluginPDBSET.setDataInput(self.xsDataInput_PDBSET)
self.edPluginPDBSET.connectSUCCESS(self.doSuccess_PDBSET)
self.edPluginPDBSET.connectFAILURE(self.doFailure_PDBSET)
self.edPluginPDBSET.executeSynchronous()
def configure(self):
EDPluginControl.configure(self)
EDVerbose.DEBUG("EDPluginControlKappaStrategyv2_0.configure")
strSymopHome = self.config.get(self.strCONF_SYMOP_HOME)
if strSymopHome is None:
strWarningMessage = EDMessage.WARNING_NO_PARAM_CONFIGURATION_ITEM_FOUND_03 % ('EDPluginControlKappaStrategyv2_0.configure', self.strCONF_SYMOP_HOME, self.getPluginName())
EDVerbose.warning(strWarningMessage)
self.addWarningMessage(strWarningMessage)
else:
strSymopHomeNorm = os.path.normpath(strSymopHome)
self.setSymopHome(strSymopHomeNorm)
bKappaOn = self.config.get("KAPPA")
if bKappaOn:
#self.strPluginStrategyName = "EDPluginControlStrategyv10"
#self.strPluginStrategyName = "EDPluginControlStrategyv2_0"
self.KappaStrategy = 1
else:
self.KappaStrategy = 0
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultSaxsAddMetadatav1_0.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same")
outputData = str(open(self.testOutput, "rb").read()[:8196])
referenceData = str(open(self.refOutput, "rb").read()[:8196])
EDAssert.strAlmostEqual(outputData, referenceData, "Same headers")
def testExecute(self):
"""
"""
self.run()
# Checks that there are no error messages
plugin = self.getPlugin()
# Checks the expected result
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = plugin.getDataOutput().marshal() # EDUtilsTest.readAndParseFile ( self.m_edObtainedOutputDataFile )
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultDiffractionCT.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()# XSDataResultDiffractionCT.parseString(strObtainedOutput)
EDAssert.equal(xsDataResultReference.marshal(), xsDataResultObtained.marshal())
def preProcess(self):
"""
PreProcess of the execution test: download an EDF file from http://www.edna-site.org
and remove any existing output file, i.e. /tmp/edna-$USER/stack.h5
"""
EDTestCasePluginExecute.preProcess(self)
self.loadTestImage(["test_region1_dark_1_0040.edf"])
strExpectedOutput = self.readAndParseFile(self.getDataInputFile())
xsDataResultReference = XSDataInputHDF5StackImages.parseString(
strExpectedOutput)
self.outputFileName = xsDataResultReference.getHDF5File().getPath(
).getValue()
EDVerbose.DEBUG(" Output file is %s" % self.outputFileName)
if not os.path.isdir(os.path.dirname(self.outputFileName)):
os.makedirs(os.path.dirname(self.outputFileName))
if self.getClassName() in [
"EDTestCasePluginExecuteHDF5StackImagesv10"
]: #, "EDTestCasePluginExecuteHDF5StackImagesv10_array"]:
self.removeDestination()
def preProcess(self, _edObject=None):
EDPluginExecProcessScript.preProcess(self)
EDVerbose.DEBUG("EDPluginExecSaxsAnglev1_0.preProcess")
xsdIn = self.getDataInput()
if xsdIn.getInputDataFile() is not None:
self.inputDataFile = xsdIn.getInputDataFile().getPath().getValue()
if not os.path.isfile(self.inputDataFile):
EDVerbose.WARNING(
"Input file %s does not exist ... try to go on anyway" %
self.inputDataFile)
self.inputDataFile = None
if xsdIn.getRegroupedDataFile() is not None:
self.regroupedDataFile = xsdIn.getRegroupedDataFile().getPath(
).getValue()
if xsdIn.getBeamCenterX() is not None:
self.beamCenterX = xsdIn.getBeamCenterX().getValue()
if xsdIn.getBeamCenterY() is not None:
self.beamCenterY = xsdIn.getBeamCenterY().getValue()
if xsdIn.getInnerRadius() is not None:
self.innerRadius = xsdIn.getInnerRadius().getValue()
if xsdIn.getStepRadius() is not None:
self.stepRadius = xsdIn.getStepRadius().getValue()
if xsdIn.getSizeRadial() is not None:
self.sizeRadial = xsdIn.getSizeRadial().getValue()
if xsdIn.getStartAzimuth() is not None:
self.startAzimuth = xsdIn.getStartAzimuth().getValue()
if xsdIn.getStepAzimuth() is not None:
self.stepAzimuth = xsdIn.getStepAzimuth().getValue()
if xsdIn.getSizeAzimuth() is not None:
self.sizeAzimuth = xsdIn.getSizeAzimuth().getValue()
if xsdIn.getFirstImage() is not None:
self.firstImage = xsdIn.getFirstImage().getValue()
if xsdIn.getLastImage() is not None:
self.lastImage = xsdIn.getLastImage().getValue()
if xsdIn.getOptions() is not None:
self.options = xsdIn.getOptions().getValue()
if xsdIn.getDummy() is not None:
self.dummy = xsdIn.getDummy().getValue()
if xsdIn.getIncrement() is not None:
self.increment = xsdIn.getIncrement().getValue()
#Create the command line to run the program
self.generateSaxsAngleCommand()
def doSuccessIntegration(self, _edPlugin=None):
EDVerbose.DEBUG(
"EDPluginControlCharacterisationv1_2.doSuccessIntegration")
self.retrieveSuccessMessages(
_edPlugin,
"EDPluginControlCharacterisationv1_2.doSuccessIntegration")
self.addStatusMessage("Integration successful.")
xsDataIntegrationOutput = self.__edPluginControlIntegration.getDataOutput(
)
self.__xsDataResultCharacterisation.setIntegrationResult(
xsDataIntegrationOutput)
# Integration short summary
if self.__edPluginControlIntegration.hasDataOutput(
"integrationShortSummary"):
self.__strCharacterisationShortSummary += self.__edPluginControlIntegration.getDataOutput(
"integrationShortSummary")[0].getValue()
#EDVerbose.DEBUG( self.__xsDataExperimentCharacterisation.marshal() )
if self.__bDoStrategyCalculation:
xsDataInputStrategy = XSDataInputStrategy()
xsDataSolutionSelected = self.__xsDataResultCharacterisation.getIndexingResult(
).getSelectedSolution()
xsDataInputStrategy.setCrystalRefined(
xsDataSolutionSelected.getCrystal())
xsDataInputStrategy.setSample(self.__xsDataResultCharacterisation.
getDataCollection().getSample())
xsDataIntegrationSubWedgeResultList = xsDataIntegrationOutput.getIntegrationSubWedgeResult(
)
xsDataInputStrategy.setBestFileContentDat(
xsDataIntegrationSubWedgeResultList[0].getBestfileDat())
xsDataInputStrategy.setBestFileContentPar(
xsDataIntegrationSubWedgeResultList[0].getBestfilePar())
xsDataInputStrategy.setExperimentalCondition(
xsDataIntegrationSubWedgeResultList[0].
getExperimentalConditionRefined())
for xsDataIntegrationSubWedgeResult in xsDataIntegrationSubWedgeResultList:
xsDataInputStrategy.addBestFileContentHKL(
xsDataIntegrationSubWedgeResult.getBestfileHKL())
xsDataInputStrategy.setDiffractionPlan(
self.__xsDataResultCharacterisation.getDataCollection(
).getDiffractionPlan())
self.__edPluginControlStrategy.setDataInput(xsDataInputStrategy)
self.__edPluginControlStrategy.executeSynchronous()
def preProcess(self, _edObject=None):
EDPluginExecProcessScript.preProcess(self)
EDVerbose.DEBUG("EDPluginExecDcrawv1_0.preProcess")
self.__strRawFile = self.getDataInput().getRawImagePath().getPath(
).getValue()
if self.getDataInput().getOutputPath() is not None:
self.__strOutputFile = self.getDataInput().getOutputPath().getPath(
).getValue()
if self.getDataInput().getExtractThumbnail() is not None:
self.__bExtracThumbnail = (
self.getDataInput().getExtractThumbnail().getValue()
in [1, "true", "True", "TRUE", True])
########################################################################
# This option is incompatible with all others
########################################################################
if self.__bExtracThumbnail is True:
self.__bWBCamera = False
self.__strOutputType = None #we cannot know what find of thumbnail is saved, can be jpeg, tiff or nothing !
else:
if self.getDataInput().getExportTiff() is not None:
self.__bExportTiff = (
self.getDataInput().getExportTiff().getValue()
in [1, "true", "True", "TRUE", True])
if self.__bExportTiff:
self.__strOutputType = "tiff"
if self.getDataInput().getWhiteBalanceAuto() is not None:
self.__bWBAuto = (
self.getDataInput().getWhiteBalanceAuto().getValue()
in [1, "true", "True", "TRUE", True])
if self.__bWBAuto is True: self.__bWBCamera = False
if self.getDataInput().getWhiteBalanceFromCamera() is not None:
self.__bWBCamera = (
self.getDataInput().getWhiteBalanceFromCamera().getValue()
in [1, "true", "True", "TRUE", True])
if self.getDataInput().getLevelsFromCamera() is not None:
self.__bLevelCamera = (
self.getDataInput().getLevelsFromCamera().getValue()
in [1, "true", "True", "TRUE", True])
if self.getDataInput().getInterpolationQuality() is not None:
self.__iInterpolate = self.getDataInput(
).getInterpolationQuality().getValue()
self.generateDcrawCommand()
def _check_xyzin_monomers(self):
'''Check that all of the monomers listed in the input PDB file
occur in the CCP4 monomer dictionary.'''
# first build up the database
known_monomers = []
monomer = os.path.join(os.environ['CCP4'], 'lib', 'data', 'monomers')
for dirpath, dirnames, filenames in os.walk(monomer):
for filename in filenames:
known_monomers.append(filename.replace('.cif', ''))
assert (known_monomers)
# then check the pdb file
unknown = []
known = []
for record in open(self._xyzin):
if 'ATOM ' in record[:6] or 'HETATM' in record[:6]:
residue = record[17:20]
if not residue in known_monomers:
if not residue in unknown:
unknown.append(residue)
else:
if not residue in known:
known.append(residue)
EDVerbose.DEBUG("Known residue: %s" % residue)
if unknown:
unknown_residues = unknown[0]
for m in unknown_residues[1:]:
unknown_residues += ' %s' % m
raise RuntimeError, 'Unknown residues: %s' % unknown_residues
return
def preProcess(self, _edObject=None):
EDPluginControl.preProcess(self)
EDVerbose.DEBUG("EDPluginControlDevelopRawv1_0.preProcess")
self.strRawFile = self.getDataInput().getInputRaw().getPath().getValue(
)
if self.getDataInput().getOutputJpeg() is None:
self.strJpegFile = os.path.splitext(
self.strRawFile)[0] + "-raw.jpg"
else:
self.strJpegFile = self.getDataInput().getOutputJpeg().getPath(
).getValue()
if self.getDataInput().getCopyExifTag() is None:
self.bCopyExif = True
else:
self.bCopyExif = (self.getDataInput().getCopyExifTag().getValue()
in [1, "true", "True", True])
if self.getDataInput().getCompressRaw() is None:
self.bCompressRaw = True
else:
self.bCompressRaw = (
self.getDataInput().getCompressRaw().getValue()
in [1, "true", "True", True])
if self.getDataInput().getCleanUp() is None:
self.bCleanUp = True
else:
self.bCleanUp = (self.getDataInput().getCleanUp().getValue()
in [1, "true", "True", True])
# Load the execution plugin
self.__edPluginExecDcraw = self.loadPlugin(
self.__strControlledPluginDcraw)
self.__edPluginExecThumbnail = self.loadPlugin(
self.__strControlledPluginThumbnail)
if self.bCompressRaw is True:
self.__edPluginExecBzip2 = self.loadPlugin(
self.__strControlledPluginBzip2)
if self.bCopyExif is True:
self.__edPluginExecMetadata = self.loadPlugin(
self.__strControlledPluginMetadata)
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsMetadatav1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare dictionary
################################################################################
edfRef = fabio.open(xsDataResultObtained.getOutputImage().getPath().value)
edfObt = fabio.open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsMetadata.edf"))
keysRef = edfRef.header_keys
keysObt = edfObt.header_keys
keysRef.sort()
keysObt.sort()
for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation" ]:
if key in keysObt: keysObt.remove(key)
if key in keysRef: keysRef.remove(key)
# print edfObt.header
EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary")
for key in keysRef:
EDAssert.strAlmostEqual(edfRef.header[key], edfObt.header[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfObt.data
referenceData = edfRef.data
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
def preProcess(self):
"""
PreProcess of the execution test: download an EDF file from http://www.edna-site.org
and remove any existing output file, i.e. /tmp/edna-$USER/stack.h5
"""
EDTestCasePluginExecute.preProcess(self)
self.loadTestImage([
"projections5077.edf", "projections5078.edf",
"projections5204.edf", "projections5203.edf"
])
strExpectedOutput = self.readAndParseFile(self.getDataInputFile())
xsDataResultReference = XSDataInputHDF5MapSpectra.parseString(
strExpectedOutput)
self.outputFileName = xsDataResultReference.getHDF5File().getPath(
).getValue()
EDVerbose.DEBUG(" Output file is %s" % self.outputFileName)
if not os.path.isdir(os.path.dirname(self.outputFileName)):
os.makedirs(os.path.dirname(self.outputFileName))
if self.getClassName() == "EDTestCasePluginExecuteHDF5MapSpectrav10":
self.removeDestination()
def preProcess(self):
"""
PreProcess of the execution test: download a set of images from http://www.edna-site.org
and delete any output file
"""
EDTestCasePluginExecute.preProcess(self)
xsDataInput = XSDataInputMatrixInvertFile.parseString(self.readAndParseFile(self.getDataInputFile()))
self.inputFile = xsDataInput.getInputMatrixFile().getPath().getValue()
self.xsDataResultReference = XSDataResultMatrixInvertFile.parseString(self.readAndParseFile(self.getReferenceDataOutputFile()))
self.outputFile = self.xsDataResultReference.getOutputMatrixFile().getPath().getValue()
self.loadTestImage([os.path.basename(self.inputFile), os.path.basename(self.outputFile) ])
if not os.path.isdir(os.path.dirname(self.outputFile)):
os.makedirs(os.path.dirname(self.outputFile))
if os.path.isfile(self.outputFile):
EDVerbose.DEBUG(" Output file exists %s, I will remove it" % self.outputFile)
os.remove(self.outputFile)
def executeOrientation(self, _edPlugin):
"""
"""
EDVerbose.DEBUG(
"EDPluginControlKappaReorientationStrategyv2_0.executeOrientation")
xsDataBestInput = self.edHandlerXSDataBest.getXSDataInputBest(
self.getDataInput("mxv1InputStrategy")[0])
self.edPluginOrientation.setDataInput(xsDataBestInput, "inputBest")
self.edPluginOrientation.setDataInput(
self.getDataInput("mxv2DataCollection")[0], "dataCollection")
self.edPluginOrientation.setDataInput(
self.getDataInput("mxv1IndexingResult")[0], "indexingResult")
listOpt = self.getDataInput("mxv1InputStrategy")[0].getDiffractionPlan(
).getKappaStrategyOption()
for strOpt in listOpt:
self.edPluginOrientation.setDataInput(strOpt,
"KappaStrategyOption")
self.edPluginOrientation.executeSynchronous()
def process(self, _edObject=None):
"""
"""
EDPluginControl.process(self, _edObject)
EDVerbose.DEBUG(
"EDPluginControlKappaReorientationStrategyv2_0.process...")
#call KAPPA orientation
if self.edPluginOrientation is not None:
self.connectProcess(self.executeOrientation)
self.edPluginOrientation.connectFAILURE(
self.doFailureActionOrientation)
if self.edPluginAlignment is not None:
self.connectProcess(self.doOrientationToAlignmentTransition)
self.edPluginAlignment.connectFAILURE(
self.doFailureActionAlignment)
if self.edPluginSimpleStrategy is not None:
self.connectProcess(self.doAlignmentToStrategyTransition)
def configure(self):
EDPluginControl.configure(self)
EDVerbose.DEBUG("EDPluginControlCharacterisationv2_0.configure")
pluginConfiguration = self.getConfiguration()
self.strPluginStrategyName = "EDPluginControlKappaStrategyv2_0"
if(pluginConfiguration != None):
strSymopHome = EDConfiguration.getStringParamValue(pluginConfiguration, "KAPPA")
# if(strSymopHome == None or strSymopHome != "ON"):
# #self.strPluginStrategyName = "EDPluginControlStrategyv10"
# #self.strPluginStrategyName = "EDPluginControlStrategyv2_0"
# self.strPluginStrategyName = "EDPluginControlKappaStrategyv2_0"
# else:
# self.strPluginStrategyName = "EDPluginControlKappaStrategyv2_0"
strSymopHome = EDConfiguration.getStringParamValue(pluginConfiguration, "POINTLESS")
if(strSymopHome == None or strSymopHome != "ON"):
self.strPluginIntegrationName = "EDPluginControlIntegrationv10"
else:
self.strPluginIntegrationName = "EDPluginControlIntegrationPointlessv10"
def postProcess(self, _edObject=None):
EDPluginControl.postProcess(self, _edObject)
EDVerbose.DEBUG("EDPluginControlStrategyv1_2.postProcess...")
#
# Create the BEST graphs from the plot mtv file
#
# Check if we have GLE files from BEST:
xsDataResultBest = self._edPluginBest.getDataOutput()
xsDataInputPlotGle = XSDataInputPlotGle()
if xsDataResultBest.glePlot != []:
for xsDataBestGlePlot in xsDataResultBest.glePlot:
xsDataGlePlot = XSDataGlePlot()
xsDataGlePlot.script = xsDataBestGlePlot.script
xsDataGlePlot.data = xsDataBestGlePlot.data
xsDataInputPlotGle.addGlePlot(xsDataGlePlot)
else:
xsDataInputPlotGle.filePlotMtv = xsDataResultBest.pathToPlotMtvFile
self._edPluginPlotGle.dataInput = xsDataInputPlotGle
self._edPluginPlotGle.executeSynchronous()
def postProcess(self, _edObject=None):
EDPluginExecProcessScript.postProcess(self)
EDVerbose.DEBUG("*** EDPluginFIT2DCakev1_1.postProcess")
#Remove the temporary data file
os.remove(os.path.join(self.getWorkingDirectory(), "CleanedImage.edf"))
os.remove(os.path.join(self.getWorkingDirectory(), "spline"))
# Create the output data
xsDataResultFIT2DCake = XSDataResultFIT2DCake()
if (self.m_strOutputFilePath is not None):
if os.path.splitext(self.m_strOutputFilePath)[1].lower() == ".cif" :
############read CHI plot file and convert it in cif cile if needed
cif = CIFfile.CIF()
cif.loadCHIPLOT(os.path.splitext(self.m_strOutputFilePath)[0] + ".chi")
cif["_diffrn_radiation_wavelength"] = str(self.getDataInput().getWavelength().getValue())
cif["_pd_instr_dist_spec/detc"] = str(self.getDataInput().getSampleToDetectorDistance().getValue())
cif.saveCIF(self.m_strOutputFilePath)
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(self.m_strOutputFilePath))
xsDataResultFIT2DCake.setResultFile(xsDataFile)
self.setDataOutput(xsDataResultFIT2DCake)
def doSuccessIndexingLabelit(self, _edPlugin=None):
EDVerbose.DEBUG(
"EDPluginControlCharacterisationv1_2.doSuccessIndexingLabelit")
self.retrieveSuccessMessages(
_edPlugin,
"EDPluginControlCharacterisationv1_2.doSuccessIndexingLabelit")
if self.__edPluginControlIndexingLabelit.hasDataOutput(
"indexingShortSummary"):
self.__strCharacterisationShortSummary += self.__edPluginControlIndexingLabelit.getDataOutput(
"indexingShortSummary")[0].getValue()
# Check the indexing results
xsDataIndexingResult = self.__edPluginControlIndexingLabelit.getDataOutput(
)
self.__edPluginExecEvaluationIndexingLABELIT.setDataInput(
xsDataIndexingResult, "indexingResult")
xsDataImageQualityIndicators = self.__xsDataResultCharacterisation.getImageQualityIndicators(
)[0]
self.__edPluginExecEvaluationIndexingLABELIT.setDataInput(
xsDataImageQualityIndicators, "imageQualityIndicators")
self.__edPluginExecEvaluationIndexingLABELIT.executeSynchronous()
def doRaddoseToBestTransition(self, _edPlugin):
"""
"""
EDVerbose.DEBUG("EDPluginControlKappaStrategyv2_0.doRaddoseToBestTransition")
self.retrieveSuccessMessages(_edPlugin, "EDPluginControlKappaStrategyv2_0.doRaddoseToBestTransition")
xsDataRaddoseOutput = self.edPluginRaddose.getDataOutput()
# update the strategy data with the data coming from Raddose
self.xsDataSampleCopy.setAbsorbedDoseRate(xsDataRaddoseOutput.getAbsorbedDoseRate())
# Call the Best Translator layer
xsDataInputStrategyCopy = XSDataInputStrategy.parseString(self.getDataInput("mxv1InputStrategy")[0].marshal())
xsDataInputStrategyCopy.setSample(self.xsDataSampleCopy)
xsDataInputBest = self.edHandlerXSDataBest.getXSDataInputBest(xsDataInputStrategyCopy)
self.edPluginBest.setDataInput(xsDataInputBest)
self.edPluginBest.executeSynchronous()
def preProcess(self):
"""
Processes the command line, creates the plugins
"""
EDApplication.preProcess(self)
EDVerbose.DEBUG("EDApplicationMXv1Characterisation.preProcess")
if self.__xsDataInputCharacterisation == None:
# Read command line parameters and check if they are ok
self.__bProcess = self.readAndProcessCommandLine()
if (self.__bProcess) and not (self.__strDatasetFileName is None):
# Check if XML data is given as input :
if (self.__strDatasetFileName is not None):
try:
self.__xsDataInputCharacterisation = XSDataInputCharacterisation.parseFile(self.__strDatasetFileName)
except:
errorMessage = EDMessage.ERROR_CANNOT_READ_FILE_02 % ("EDApplicationMXv1Characterisation.process", self.__strDatasetFileName)
EDVerbose.error(errorMessage)
raise RuntimeError, errorMessage
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultSiftDescriptor.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(
xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
_strExcluded="EDTestCasePluginExecuteExecSiftDescriptorv1_0",
_fRelError=0.0,
_fAbsError=0.3,
_strComment="XML out are the same")
def loadPlugin(self, _strPluginToBeControlledName=None, _strBaseName=None):
"""
This method loads and returns a reference to the plugin to be controlled.
The name of the plugin to be controlled can either be passed as an
argument, or bet set before calling this method using the
"setPluginToBeControlledName".
The base name of the plugin to be controlled is used as the working
directory name of the plugin in question. If no argument is supplied
the name of the plugin is used as base name. In the case of creation of
several plugins to be launched simultaneously, the base name should be
different for each plugin and hence must be provided explicitly.
"""
EDVerbose.DEBUG("EDPluginControl.loadPlugin")
if (_strPluginToBeControlledName is None):
strPluginName = self.__strPluginToBeControlledName
else:
strPluginName = _strPluginToBeControlledName
edPlugin = EDFactoryPluginStatic.loadPlugin(strPluginName)
if (edPlugin is None):
strErrorMessage = "EDPluginControl.loadPlugin : Cannot load plugin %s" % strPluginName
EDVerbose.error(strErrorMessage)
self.addErrorMessage(strErrorMessage)
raise RuntimeError, strErrorMessage
else:
self.__listOfLoadedPlugins.append(edPlugin)
edPlugin.setBaseDirectory(self.getWorkingDirectory())
if (_strBaseName is None):
# Check if base name exists. OBS! Not thread safe so please set explicitly
# _strBaseName for multi-threaded code
strRenamedPlugin = self.compactPluginName(strPluginName)
strNewWorkingDirectory = os.path.join(self.getWorkingDirectory(),
strRenamedPlugin)
if (os.path.exists(strNewWorkingDirectory)):
edPlugin.setBaseName(edPlugin.createBaseName())
else:
edPlugin.setBaseName(strRenamedPlugin)
else:
edPlugin.setBaseName(_strBaseName)
return edPlugin
def doAlignmentToStrategyTransition(self, _edPlugin):
"""
"""
EDVerbose.DEBUG(
"EDPluginControlKappaStrategyv2_0.doAlignmentToStrategy")
#self.retrieveSuccessMessages( _edPlugin, "EDPluginControlStrategyv01.doRaddoseToBestTransition" )
# Call the Best Translator layer
#from XSDataSTACv01 import kappa_alignment_response
#from XSDataSTACv01 import kappa_strategy_request
#from XSDataSTACv01 import strategy_request
self.xsKappaStrategyRequest = kappa_strategy_request()
#self.xsKappaStrategyRequest.build(???)
KappaAlignmentResponse = self.edPluginAlignment.getDataOutput()
xsDataKappaAlignmentList = KappaAlignmentResponse.getPossible_orientation(
)
self.xsKappaStrategyRequest.setDesired_datum(xsDataKappaAlignmentList)
self.xsksreq = strategy_request()
self.xsKappaStrategyRequest.setStandard_request(self.xsksreq)
#xsDataKappaStrategyInput=EDList()
#xsDataKappaStrategyInput.add(self.xsKappaStrategyRequest)
##data collection descriptor
#xsDataKappaStrategyInput.add(self.getDataInput("mxv2DataCollection")[0])
##indexing result
#xsDataKappaStrategyInput.add(self.getDataInput("mxv1IndexingResult")[0])
##bestfile
#xsDataKappaStrategyInput.add(self.getDataInput("mxv1InputStrategy")[0])
#self.edPluginKappaStrategy.setDataInput( xsDataKappaStrategyInput )
self.edPluginKappaStrategy.setDataInput(self.xsKappaStrategyRequest,
"kappa_strategy_request")
self.edPluginKappaStrategy.setDataInput(
self.getDataInput("mxv2DataCollection")[0], "dataCollection")
self.edPluginKappaStrategy.setDataInput(
self.getDataInput("mxv1InputStrategy")[0], "inputBest")
#self.edPluginKappaStrategy.m_xsDataBestFileContentPar=self.getDataInput()[0].getBestFileContentPar()
self.edPluginKappaStrategy.executeSynchronous()
def preProcess(self, _edObject=None):
"""
Loads the ISPyB execution plugin and prepares the input data
"""
EDPluginControl.preProcess(self, _edObject)
EDVerbose.DEBUG("EDPluginControlISPyBv1_1.preProcess...")
if (self.hasDataInput("shortComments")):
self.__strShortComments = self.getDataInput(
"shortComments")[0].getValue()
if (self.hasDataInput("comments")):
self.__strComments = self.getDataInput("comments")[0].getValue()
if (self.hasDataInput("statusMessage")):
self.__strStatusMessage = self.getDataInput(
"statusMessage")[0].getValue()
self.m_edPluginExecISPyB = self.loadPlugin(
self.m_edStringPluginExecISPyBName)
from EDHandlerXSDataISPyBv1_2 import EDHandlerXSDataISPyBv1_2
xsDataInputISPyB = None
xsDataISPyBImage = None
try:
xsDataISPyBScreening = EDHandlerXSDataISPyBv1_2.generateXSDataISPyBScreening(
self.getDataInput(), self.__strShortComments,
self.__strComments)
xsDataISPyBScreeningInput = EDHandlerXSDataISPyBv1_2.generateXSDataISPyBScreeningInput(
self.getDataInput())
xsDataISPyBScreeningOutputContainer = EDHandlerXSDataISPyBv1_2.generateXSDataISPyBScreeningOutputContainer(
self.getDataInput(), self.__strStatusMessage)
if (xsDataISPyBScreening.getDataCollectionId() is None):
xsDataISPyBImage = EDHandlerXSDataISPyBv1_2.generateXSDataISPyBImage(
self.getDataInput())
except Exception, error:
# This exception handling needs to be rethought, see bug #43.
errorMessage = EDMessage.ERROR_DATA_HANDLER_02 % (
"EDPluginControlISPyBv1_1.preProcess: Unexpected error in ISPyB handler: ",
error)
EDVerbose.error(errorMessage)
self.addErrorMessage(errorMessage)
raise RuntimeError, errorMessage
def preProcess(self):
"""
PreProcess of the execution test: download a set of images from http://www.edna-site.org
and remove any existing output file
"""
EDTestCasePluginExecute.preProcess(self)
self.loadTestImage(
["bioSaxsMask.edf"] +
["bioSaxs_bsa_013_%02i.edf" % i for i in range(1, 11)])
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
EDVerbose.DEBUG("strExpectedOutput:" + strExpectedOutput)
workdir = os.path.join(tempfile.gettempdir(),
"edna-%s" % os.environ["USER"], "serie1")
if os.path.exists(workdir):
for dirpath, dirnames, filenames in os.walk(workdir,
topdown=False):
for oneFile in filenames:
os.remove(os.path.join(workdir, dirpath, oneFile))
for oneDir in dirnames:
os.rmdir(os.path.join(workdir, dirpath, oneDir))
