def runXscale(self, _workingDirectory, merged=False, anom=False):
strPathXscaleLp = None
if os.path.exists(os.path.join(_workingDirectory, "XDS_ASCII.HKL")):
if merged:
strMerged = "merged"
else:
strMerged = "unmerged"
if anom:
strAnom = "anom"
else:
strAnom = "noanom"
strXscaleInp = "OUTPUT_FILE= {0}_{1}_XSCALE.hkl\n".format(strMerged, strAnom)
strXscaleInp += "INPUT_FILE= XDS_ASCII.HKL\n"
strXscaleInp += "MERGE= {0}\n".format(str(merged).upper())
strXscaleInp += "FRIEDEL'S_LAW= {0}\n".format(str(not anom).upper())
EDUtilsFile.writeFile(os.path.join(_workingDirectory, "XSCALE.INP"), strXscaleInp)
xscaleLog = os.path.join(_workingDirectory, "xscale.log")
pipe1 = subprocess.Popen("/opt/pxsoft/bin/xscale",
shell=True,
stdout=subprocess.PIPE,
close_fds=True,
cwd=_workingDirectory)
xdsInp = pipe1.communicate()[0]
with open(xscaleLog, "w") as f:
f.write(str(xdsInp))
# Find path to XSCALE.LP file
strPathXscaleLp = os.path.join(_workingDirectory, "XSCALE.LP")
return strPathXscaleLp
def testCopyHTMLFilesAndDir(self):
if not os.path.exists(EDUtilsPath.getEdnaUserTempFolder()):
os.mkdir(EDUtilsPath.getEdnaUserTempFolder())
strTestFromDir = os.path.join(EDUtilsPath.getEdnaUserTempFolder(), "TestFromDir")
shutil.rmtree(strTestFromDir, ignore_errors=True)
os.mkdir(strTestFromDir)
strTestHtmlFilePath = os.path.join(strTestFromDir, "index.html")
strTestHtmlDirPath = os.path.join(strTestFromDir, "index")
EDUtilsFile.writeFile(strTestHtmlFilePath, "Test content")
if not os.path.exists(strTestHtmlDirPath):
os.mkdir(strTestHtmlDirPath)
strTestHtmlDirFilePath = os.path.join(strTestHtmlDirPath, "test.txt")
EDUtilsFile.writeFile(strTestHtmlDirFilePath, "Test content")
#
strTestToDir = os.path.join(EDUtilsPath.getEdnaUserTempFolder(), "TestToDir")
shutil.rmtree(strTestToDir, ignore_errors=True)
os.mkdir(strTestToDir)
EDHandlerESRFPyarchv1_0.copyHTMLDir(strTestFromDir, strTestToDir)
#
# Check that files exist in strTestToDir:
EDAssert.isFile(os.path.join(strTestToDir, "index", "index.html"))
EDAssert.isFile(os.path.join(strTestToDir, "index", "index", "test.txt"))
#
shutil.rmtree(strTestFromDir, ignore_errors=True)
shutil.rmtree(strTestToDir, ignore_errors=True)
def testDetermineImageType(self):
edPluginControlReadImageHeaderv10 = self.createPlugin()
# Test 1 : ADSC
self.loadTestImage([ "testscale_1_001.img" ])
strImage1 = os.path.join(self.getTestsDataImagesHome(), "testscale_1_001.img")
strType1 = edPluginControlReadImageHeaderv10.determineImageType(strImage1)
EDAssert.equal(strType1, "ADSC", "ADSC")
# Test 2 : MAR CCD with .mccd suffix
self.loadTestImage([ "ref-screentest-crystal1_1_001.mccd" ])
strImage2 = os.path.join(self.getTestsDataImagesHome(), "ref-screentest-crystal1_1_001.mccd")
strType2 = edPluginControlReadImageHeaderv10.determineImageType(strImage2)
EDAssert.equal(strType2, "MARCCD", "MARCCD 1")
# Test 3 : MAR CCD with .marccd suffix - copied from ref-screentest-crystal1_1_001.mccd
strImage3 = tempfile.mktemp(suffix="_1_001.marccd", prefix="ref-screentest-crystal1_")
shutil.copyfile(strImage2, strImage3)
strType3 = edPluginControlReadImageHeaderv10.determineImageType(strImage3)
EDAssert.equal(strType3, "MARCCD", "MARCCD 2")
os.remove(strImage3)
# Test 4 : Pilatus 2M CBF image
self.loadTestImage([ "ref-2m_RNASE_1_0001.cbf" ])
strImage1 = os.path.join(self.getTestsDataImagesHome(), "ref-2m_RNASE_1_0001.cbf")
strType1 = edPluginControlReadImageHeaderv10.determineImageType(strImage1)
EDAssert.equal(strType1, "Pilatus2M", "Pilatus2M")
# Test 5 : Pilatus 6M CBF image
self.loadTestImage([ "FAE_1_1_00001.cbf" ])
strImage1 = os.path.join(self.getTestsDataImagesHome(), "FAE_1_1_00001.cbf")
strType1 = edPluginControlReadImageHeaderv10.determineImageType(strImage1)
EDAssert.equal(strType1, "Pilatus6M", "Pilatus6M")
# Test 6 : Unknown image - created by the test
strImage4 = tempfile.mktemp(suffix="_1_001.unknown", prefix="zeroes_")
EDUtilsFile.writeFile(strImage4, "Dummy text string for EDTestCasePluginUnitPluginControlReadImageHeaderv10.testDetermineImageType")
strType4 = edPluginControlReadImageHeaderv10.determineImageType(strImage4)
EDAssert.equal(True, edPluginControlReadImageHeaderv10.isFailure(), "Not recognized format")
os.remove(strImage4)
def writeBestfilePar(self, fname, content):
'''
Writing a bestfile.par for STAC to describe the xtal (orinetation,spacegroup,etc.)
'''
#version reusing a pregenerated bestfile.par
#EDUtilsFile.writeFile( EDDiskExplorer.mergePath( self.getWorkingDirectory(), "bestfile.par" ), self.m_xsDataInput.getBestFileContentPar().getValue())
EDUtilsFile.writeFile(fname, content)
def preProcess(self, _edObject=None):
EDPlugin.preProcess(self, _edObject)
EDVerbose.DEBUG("EDPluginWrapperForJobScheduler.preProcess")
# Construct python script for executing the plugin
strPythonWrapper = self.preparePythonWrapperScript()
self.__strPathToPythonWrapper = os.path.join(self.getWorkingDirectory(), self.__strPythonWrapperScriptName)
EDUtilsFile.writeFile(self.__strPathToPythonWrapper, strPythonWrapper)
def process(self, _edPlugin=None):
EDPluginExec.process(self, _edPlugin)
self.DEBUG("EDPluginExecSimpleHTMLPagev1_0.process...")
if self.xsDataResultCharacterisation is not None:
# Create the simple characterisation result page
self.page = markupv1_7.page(mode='loose_html')
self.page.init( title="Characterisation Results",
footer="Generated on %s" % time.asctime())
self.page.div( align_="CENTER")
self.page.h1()
if self.xsDataResultCharacterisation is not None:
self.page.strong( "Characterisation Results " )
else:
self.page.strong( "No Characterisation Results! " )
# Link to the EDNA log file
strPathToLogFile = self.findEDNALogFile()
if strPathToLogFile is not None:
self.page.strong("(")
self.strPageEDNALog = os.path.join(self.getWorkingDirectory(), "edna_log.html")
pageEDNALog = markupv1_7.page()
pageEDNALog.h1("EDNA Log")
pageEDNALog.a("Back to previous page", href_=self.strHtmlFileName)
pageEDNALog.pre(cgi.escape(EDUtilsFile.readFile(strPathToLogFile)))
pageEDNALog.a("Back to previous page", href_=self.strHtmlFileName)
EDUtilsFile.writeFile(self.strPageEDNALog, str(pageEDNALog))
self.page.a("EDNA log file", href_="edna_log.html")
self.page.strong(")")
self.page.h1.close()
self.page.div.close()
self.diffractionPlan()
self.strategyResults()
self.graphs()
self.indexingResults()
self.integrationResults()
self.imageQualityIndicatorResults()
def writeKappaSettings(self):
'''
# future version for getting motor positions related to images under processing
# checking in order:
# - value got as input
# - mosflm.descr file in process subdir (if BCM (like mxcube) registered it)
# - {imageTemplate}_kappa_settings.xml file (if BCM (like DNA) registered it)
# - read it now (and try to register as {imageTemplate}_kappa_settings.xml)
# - just use the datum (0,0,0)
'''
#code for using a predefined datum (0;0;0)
#EDUtilsFile.writeFile( EDDiskExplorer.mergePath( self.getWorkingDirectory(), "DNA_STAC_Kappa_Settings" ), "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><kappa_collect_settings><motorSettings><motorName>Omega</motorName><motorValue>0</motorValue></motorSettings><motorSettings><motorName>Kappa</motorName><motorValue>0.000000</motorValue></motorSettings><motorSettings><motorName>Phi</motorName><motorValue>0</motorValue></motorSettings><motorSettings><motorName>X</motorName><motorValue>0.261444</motorValue></motorSettings><motorSettings><motorName>Y</motorName><motorValue>-0.085559</motorValue></motorSettings><motorSettings><motorName>Z</motorName><motorValue>0.659333</motorValue></motorSettings><comment>BCM query performed by STAC</comment></kappa_collect_settings>")
# gonio settings from DC descriptor object
EDFactoryPluginStatic.loadModule("XSDataMXv2")
#import XSDataMXv2
#dc = XSDataMXv2.XSDataCollection()
from XSDataMXv2 import XSDataCollection
dc = XSDataCollection()
dc = self.getDataInput("dataCollection")[0]
omega = dc.getXSSubWedge()[0].getXSRotationalGoniostatSetting().getBaseaxissetting()
[kappa, phi] = dc.getXSSubWedge()[0].getXSRotationalGoniostatSetting().getAxissetting()
EDUtilsFile.writeFile(os.path.join(self.getWorkingDirectory(), "DNA_STAC_Kappa_Settings"), "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><kappa_collect_settings><motorSettings><motorName>Omega</motorName><motorValue>%e</motorValue></motorSettings><motorSettings><motorName>Kappa</motorName><motorValue>%e</motorValue></motorSettings><motorSettings><motorName>Phi</motorName><motorValue>%e</motorValue></motorSettings><motorSettings><motorName>X</motorName><motorValue>0.261444</motorValue></motorSettings><motorSettings><motorName>Y</motorName><motorValue>-0.085559</motorValue></motorSettings><motorSettings><motorName>Z</motorName><motorValue>0.659333</motorValue></motorSettings><comment>BCM query performed by STAC</comment></kappa_collect_settings>" % (omega.getValue(), kappa.getValue(), phi.getValue()))
'''
def postProcess(self, _edObject=None):
EDPluginExec.postProcess(self)
EDVerbose.DEBUG("EDPluginExecOutputHTMLv1_0.postProcess")
if self.__strWorkingDir != None:
xsDataFileHTMLFile = XSDataFile()
xsDataFileHTMLDir = XSDataFile()
if self.strBasename is None:
strHTMLFilePath = os.path.join(self.__strWorkingDir, "edna.html")
strHTMLDirPath = os.path.join(self.__strWorkingDir, "edna_html")
else:
strHTMLFilePath = os.path.join(self.strBasename, "edna.html")
strHTMLDirPath = os.path.join(self.strBasename, "edna_html")
if os.path.exists(strHTMLFilePath):
strFileContent = EDUtilsFile.readFile(strHTMLFilePath)
strFileContent = strFileContent.replace("table,td,th { border-style: none;", "div.edna table,td,th { border-style: none;")
strFileContent = strFileContent.replace("td,th { border-style: solid;", "div.edna td,th { border-style: solid;")
strFileContent = strFileContent.replace("th { background-color: gray;", "div.edna th { background-color: gray;")
strFileContent = strFileContent.replace("<body onload=\"initTable('strategyData',false,false);\">", "<body onload=\"initTable('strategyData',false,false);\"><div class = 'edna'> ")
strFileContent = strFileContent.replace("</body>", "</div></body>")
EDUtilsFile.writeFile(strHTMLFilePath, strFileContent)
xsDataFileHTMLFile.setPath(XSDataString(strHTMLFilePath))
xsDataFileHTMLDir.setPath(XSDataString(strHTMLDirPath))
self.setDataOutput(xsDataFileHTMLFile, "htmlFile")
self.setDataOutput(xsDataFileHTMLDir, "htmlDir")
else:
EDVerbose.ERROR("EDPluginExecOutputHTMLv1_0.postProcess: file doesn't exist: " + strHTMLFilePath)
def createHtmlPage(self, strImagePrefix, xsDataResultDimple, strResultsDirectory, strHtmlPath, strProposal, strSessionDate, strBeamline):
"""Create an HTML page with the results"""
if not os.path.exists(strHtmlPath):
os.makedirs(strHtmlPath, 0o755)
strSample = "_".join(strImagePrefix.split("_")[0:-1])
strHtmlFileName = "ep_%s_index.html" % strImagePrefix
strPath = os.path.join(strHtmlPath, strHtmlFileName)
page = markupv1_10.page(mode='loose_html')
# Title and footer
page.init(title="Dimple Results",
footer="Generated on %s" % time.asctime())
page.div(align_="LEFT")
page.h1()
page.strong("Dimple Results for sample {0} from proposal {1}".format(strSample, strProposal))
page.h1.close()
page.h3("Session date: {0}-{1}-{2}".format(strSessionDate[0:4], strSessionDate[4:6], strSessionDate[6:]))
page.h3("Beamline: {0}".format(strBeamline))
page.h3("Dimple output files can be found in :")
page.strong(strResultsDirectory)
page.div.close()
# Results of REFMAC 5
page.h3("Final results of Recmac 5:")
page.pre(self.extractFinalResultsFromRefmac5RestrLog(xsDataResultDimple.refmac5restrLog.path.value))
# Results of findblobs
page.h3("Findblobs log:")
page.pre(open(xsDataResultDimple.findBlobsLog.path.value).read())
# Blobs
page.br()
listImageHTML = []
for xsDataFileBlob in xsDataResultDimple.blob:
# Copy blob file to html directory
strBlobName = os.path.basename(xsDataFileBlob.path.value).split(".")[0]
strBlobImage = "ep_%s_%s_dimple.png" % (strImagePrefix, strBlobName)
strTargetPath = os.path.join(strHtmlPath, strBlobImage)
shutil.copyfile(xsDataFileBlob.path.value, strTargetPath)
strPageBlobPath = os.path.join(strHtmlPath, "ep_%s_%s_dimple.html" % (strImagePrefix, strBlobName))
pageBlob = markupv1_10.page()
pageBlob.init(title=strBlobName,
footer="Generated on %s" % time.asctime())
pageBlob.h1(strBlobName)
pageBlob.div(align_="LEFT")
pageBlob.img(src=strBlobImage, title=strBlobName)
pageBlob.div.close()
pageBlob.br()
pageBlob.div(align_="LEFT")
pageBlob.a("Back to previous page", href_=os.path.basename(strPath))
pageBlob.div.close()
EDUtilsFile.writeFile(strPageBlobPath, str(pageBlob))
listImageHTML.append(strPageBlobPath)
page.a(href=os.path.basename(strPageBlobPath))
page.img(src=strBlobImage, width=200, height=200, title=strBlobName)
page.a.close()
if strBlobName == "blob1v3":
page.br()
page.br()
# FInalise html page
strHTML = str(page)
EDUtilsFile.writeFile(strPath, strHTML)
listHTML = [strPath] + listImageHTML
return listHTML
def testSetDataModelInput(self):
"""
"""
edPluginBest = self.createPlugin()
xsPluginItemGood01 = self.getPluginConfiguration(os.path.join(self.strDataPath, "XSConfiguration.xml"))
edPluginBest.setConfiguration(xsPluginItemGood01)
edPluginBest.setScriptExecutable("cat")
edPluginBest.configure()
from XSDataBestv1_1 import XSDataInputBest
xsDataInputBest = XSDataInputBest()
from XSDataCommon import XSDataAbsorbedDoseRate
from XSDataCommon import XSDataDouble
from XSDataCommon import XSDataTime
from XSDataCommon import XSDataSpeed
from XSDataCommon import XSDataString
from XSDataCommon import XSDataAngle
from XSDataCommon import XSDataBoolean
xsDataInputBest.setCrystalAbsorbedDoseRate(XSDataAbsorbedDoseRate(0.22e06))
xsDataInputBest.setCrystalShape(XSDataDouble(1))
xsDataInputBest.setCrystalSusceptibility(XSDataDouble(1.5))
xsDataInputBest.setDetectorType(XSDataString("q210-2x"))
xsDataInputBest.setBeamExposureTime(XSDataTime(1))
xsDataInputBest.setBeamMaxExposureTime(XSDataTime(10000))
xsDataInputBest.setBeamMinExposureTime(XSDataTime(0.1))
xsDataInputBest.setGoniostatMinRotationWidth(XSDataAngle(0.1))
xsDataInputBest.setGoniostatMaxRotationSpeed(XSDataSpeed(10))
xsDataInputBest.setAimedResolution(XSDataDouble(2))
xsDataInputBest.setAimedRedundancy(XSDataDouble(6.5))
xsDataInputBest.setAimedCompleteness(XSDataDouble(0.9))
xsDataInputBest.setAimedIOverSigma(XSDataDouble(3))
xsDataInputBest.setComplexity(XSDataString("min"))
xsDataInputBest.setAnomalousData(XSDataBoolean(True))
bestFileContentDat = EDUtilsFile.readFile(os.path.join(self.strDataPath, "bestfile.dat"))
xsDataInputBest.setBestFileContentDat(XSDataString(bestFileContentDat))
bestFileContentPar = EDUtilsFile.readFile(os.path.join(self.strDataPath, "bestfile.par"))
xsDataInputBest.setBestFileContentPar(XSDataString(bestFileContentPar))
bestFileContentHKL = EDUtilsFile.readFile(os.path.join(self.strDataPath, "bestfile1.hkl"))
listBestFileContentHKL = []
listBestFileContentHKL.append(XSDataString(bestFileContentHKL))
xsDataInputBest.setBestFileContentHKL(listBestFileContentHKL)
xsDataInputBest.outputFile(self.strObtainedInputFile)
strExpectedInput = self.readAndParseFile(self.strReferenceInputFile)
strObtainedInput = self.readAndParseFile(self.strObtainedInputFile)
xsDataInputExpected = XSDataInputBest.parseString(strExpectedInput)
xsDataInputObtained = XSDataInputBest.parseString(strObtainedInput)
EDAssert.equal(xsDataInputExpected.marshal(), xsDataInputObtained.marshal())
os.remove(self.strObtainedInputFile)
self.cleanUp(edPluginBest)
def __init__(self,):
"""
"""
self.EPSILON_REL = 0.01 #1 percent error
self.EPSILON_ABS = 0.0001 #1 percent error
EDTestCasePluginExecute.__init__(self, "EDPluginFIT2DCakev1_1", "EDPluginControlFIT2D-v1.0")
self.setConfigurationFile(self.getRefConfigFile())
self.setDataInputFile(os.path.join(self.getPluginTestsDataHome(), \
"XSDataInputFIT2DCake_reference.xml"))
self.setReferenceDataOutputFile(os.path.join(self.getPluginTestsDataHome(), \
"XSDataResultFIT2DCake_reference.xml"))
self.m_edObtainedOutputDataFile = self.getPluginName() + "_output.xml"
strSplineFileName = "frelon_spline_file_to_correct_SPD.spline"
strPathToSplineFile = os.path.join(self.getTestsDataImagesHome(), strSplineFileName)
if (not os.path.exists(strPathToSplineFile)):
EDUtilsFile.copyFile(os.path.join(self.getPluginTestsDataHome(), strSplineFileName), \
strPathToSplineFile)
self.m_iNoErrorMessages = 0
self.m_iNoWarningMessages = 0
def preProcess(self, _oedObject=None):
EDPluginSTACv2_0.preProcess(self)
EDVerbose.DEBUG("EDPluginSTACAlignmentv2_0.preProcess")
#bestfile.par
#EDUtilsFile.writeFile( EDDiskExplorer.mergePath( self.getWorkingDirectory(), "bestfile.par" ), self.m_xsDataInput.getBestFileContentPar().getValue())
#self.writeBestfilePar( EDDiskExplorer.mergePath( self.getWorkingDirectory(), "bestfile.par" ), self.getDataInput()[0].getBestFileContentPar().getValue() )
self.writeBestfilePar(
os.path.join(self.getWorkingDirectory(), "bestfile.par"),
self.getDataInput("inputBest")[0].getBestFileContentPar().
getValue())
#self.writeAlignmentRequest() - for now use a predefined request
if (self.getDataInput("kappa_alignment_request") is not None):
EDUtilsFile.writeFile(
os.path.join(self.getWorkingDirectory(),
"DNA_kappa_alignment_request"),
self.getDataInput("kappa_alignment_request")[0].marshal())
else:
EDUtilsFile.writeFile(
os.path.join(self.getWorkingDirectory(),
"DNA_kappa_alignment_request"),
"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><kappa_alignment_request><desired_orientation><v1>a*</v1><v2>b*</v2><close>false</close><comment></comment></desired_orientation><desired_orientation><v1>a*</v1><v2>c*</v2><close>false</close><comment></comment></desired_orientation><desired_orientation><v1>b*</v1><v2>a*</v2><close>false</close><comment></comment></desired_orientation><desired_orientation><v1>b*</v1><v2>c*</v2><close>false</close><comment></comment></desired_orientation><desired_orientation><v1>c*</v1><v2>a*</v2><close>true</close><comment></comment></desired_orientation><desired_orientation><v1>c*</v1><v2>b*</v2><close>false</close><comment></comment></desired_orientation><comment>First test parameter passed</comment></kappa_alignment_request>"
)
#self.writeKappaSettings() - for now use a predefined datum (0;0;0)
#EDUtilsFile.writeFile( os.path.join( self.getWorkingDirectory(), "DNA_STAC_Kappa_Settings" ), "<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><kappa_collect_settings><motorSettings><motorName>Omega</motorName><motorValue>0</motorValue></motorSettings><motorSettings><motorName>Kappa</motorName><motorValue>0.000000</motorValue></motorSettings><motorSettings><motorName>Phi</motorName><motorValue>0</motorValue></motorSettings><motorSettings><motorName>X</motorName><motorValue>0.261444</motorValue></motorSettings><motorSettings><motorName>Y</motorName><motorValue>-0.085559</motorValue></motorSettings><motorSettings><motorName>Z</motorName><motorValue>0.659333</motorValue></motorSettings><comment>BCM query performed by STAC</comment></kappa_collect_settings>")
self.writeKappaSettings()
def testSetDataModelInput(self):
edPluginBest = self.createPlugin()
edConfigurationGood01 = EDConfiguration(os.path.join(self.m_pyStrDataPath, "XSConfiguration.xml"))
dictItemGood01 = edConfigurationGood01.get(self.getPluginName())
edPluginBest.setConfig(dictItemGood01, _bLocal = True)
edPluginBest.setScriptExecutable("cat")
edPluginBest.configure()
from XSDataBestv1_2 import XSDataInputBest
xsDataInputBest = XSDataInputBest()
from XSDataCommon import XSDataAbsorbedDoseRate
from XSDataCommon import XSDataDouble
from XSDataCommon import XSDataString
from XSDataCommon import XSDataTime
from XSDataCommon import XSDataFile
from XSDataCommon import XSDataAngularSpeed
from XSDataCommon import XSDataString
from XSDataCommon import XSDataAngle
from XSDataCommon import XSDataBoolean
xsDataInputBest.setCrystalAbsorbedDoseRate(XSDataAbsorbedDoseRate(0.22E+06))
xsDataInputBest.setCrystalShape(XSDataDouble(1))
xsDataInputBest.setCrystalSusceptibility(XSDataDouble(1.5))
xsDataInputBest.setDetectorType(XSDataString("q210-2x"))
xsDataInputBest.setBeamExposureTime(XSDataTime(1))
xsDataInputBest.setBeamMaxExposureTime(XSDataTime(10000))
xsDataInputBest.setBeamMinExposureTime(XSDataTime(0.1))
xsDataInputBest.setGoniostatMinRotationWidth(XSDataAngle(0.1))
xsDataInputBest.setGoniostatMaxRotationSpeed(XSDataAngularSpeed(10))
xsDataInputBest.setAimedResolution(XSDataDouble(2))
xsDataInputBest.setAimedRedundancy(XSDataDouble(6.5))
xsDataInputBest.setAimedCompleteness(XSDataDouble(0.9))
xsDataInputBest.setAimedIOverSigma(XSDataDouble(3))
xsDataInputBest.setComplexity(XSDataString("min"))
xsDataInputBest.setAnomalousData(XSDataBoolean(False))
fileDirectory = edPluginBest.getWorkingDirectory()
bestFileContentDat = EDUtilsFile.readFile(os.path.join(self.m_pyStrDataPath, "bestfile.dat"))
xsDataInputBest.setBestFileContentDat(XSDataString(bestFileContentDat))
bestFileContentPar = EDUtilsFile.readFile(os.path.join(self.m_pyStrDataPath, "bestfile.par"))
xsDataInputBest.setBestFileContentPar(XSDataString(bestFileContentPar))
bestFileContentHKL = EDUtilsFile.readFile(os.path.join(self.m_pyStrDataPath, "bestfile1.hkl"))
xsDataInputBest.addBestFileContentHKL(XSDataString(bestFileContentHKL))
xsDataInputBest.exportToFile(self.m_edObtainedInputFile)
pyStrExpectedInput = self.readAndParseFile (self.m_edReferenceInputFile)
pyStrObtainedInput = self.readAndParseFile (self.m_edObtainedInputFile)
xsDataInputExpected = XSDataInputBest.parseString(pyStrExpectedInput)
xsDataInputObtained = XSDataInputBest.parseString(pyStrObtainedInput)
EDAssert.equal(xsDataInputExpected.marshal(), xsDataInputObtained.marshal())
EDUtilsFile.deleteFile(self.m_edObtainedInputFile)
self.cleanUp(edPluginBest)
def writeExecutableScript(self, _strScript):
"""
Writes the script to the script file.
"""
self.DEBUG("EDPluginExecProcessScript.writeScriptToFile")
EDUtilsFile.writeFile(self.getScriptFilePath(), _strScript)
self.setExecutable(self.getScriptExecutor())
self.setCommandline(self.getScriptFilePath())
def preProcess(self, _edObject=None):
EDPluginExecProcessScript.preProcess(self)
self.DEBUG("EDPluginBackground3Dv1_0.preProcess")
xsDataInputBackground3D = self.getDataInput()
self.setScriptCommandline("background.dat")
strCommands = self.generateCommands(xsDataInputBackground3D)
self.createImageLinks(xsDataInputBackground3D)
EDUtilsFile.writeFile(os.path.join(self.getWorkingDirectory(), "background.dat"), strCommands)
def writeProcessFile(self, _strFileName, _strContent):
"""
Main method to write a file in the plugin working directory
Such a file is called process file
"""
EDVerbose.DEBUG("EDPluginExecProcessXIA2CORE.writeProcessFile")
strFilePath = os.path.join(self.getWorkingDirectory(), _strFileName)
EDUtilsFile.writeFile(strFilePath, _strContent)
def doSuccessActionInterface(self, _edPlugin=None):
self.DEBUG("EDPluginControlInterfaceToMXCuBEv1_3.doSuccessActionInterface...")
self.retrieveSuccessMessages(self.edPluginControlInterface, "EDPluginControlInterfaceToMXCuBEv1_3.doSuccessActionInterface")
xsDataResultCharacterisation = self.edPluginControlInterface.getDataOutput().getResultCharacterisation()
self.xsDataResultMXCuBE.setCharacterisationResult(xsDataResultCharacterisation)
xsDataResultControlISPyB = self.edPluginControlInterface.getDataOutput().getResultControlISPyB()
if xsDataResultControlISPyB != None:
self.xsDataResultMXCuBE.setScreeningId(xsDataResultControlISPyB.getScreeningId())
if xsDataResultCharacterisation != None:
strPathCharacterisationResult = os.path.join(self.getWorkingDirectory(), "CharacterisationResult.xml")
xsDataResultCharacterisation.exportToFile(strPathCharacterisationResult)
self.xsDataResultMXCuBE.setListOfOutputFiles(XSDataString(strPathCharacterisationResult))
# For the moment, create "DNA" style output directory
strPathToDNAFileDirectory = self.createDNAFileDirectoryPath(xsDataResultCharacterisation)
xsDataDictionaryLogFile = None
if (self.createDNAFileDirectory(strPathToDNAFileDirectory)):
xsDataDictionaryLogFile = self.createOutputFileDictionary(xsDataResultCharacterisation, strPathToDNAFileDirectory)
strPyArchPathToDNAFileDirectory = self.createPyArchDNAFilePath(strPathToDNAFileDirectory)
if (self.createDNAFileDirectory(strPyArchPathToDNAFileDirectory)):
xsDataDictionaryLogFile = self.createOutputFileDictionary(xsDataResultCharacterisation, strPyArchPathToDNAFileDirectory)
self.xsDataResultMXCuBE.setOutputFileDictionary(xsDataDictionaryLogFile)
# Send success email message (MXSUP-183):
self.tStop = time.time()
strSubject = "%s : SUCCESS! (%.1f s)" % (EDUtilsPath.getEdnaSite(), self.tStop-self.tStart)
strMessage = "Characterisation success!"
if xsDataResultCharacterisation.getStatusMessage():
strMessage += "\n\n"
strMessage += xsDataResultCharacterisation.getStatusMessage().getValue()
if xsDataResultCharacterisation.getShortSummary():
strMessage += "\n\n"
strMessage += xsDataResultCharacterisation.getShortSummary().getValue()
self.sendEmail(strSubject, strMessage)
# Fix for bug EDNA-55 : If burning strategy EDNA2html shouldn't be run
bRunExecOutputHTML = False
xsDataInputMXCuBE = self.getDataInput()
xsDataDiffractionPlan = xsDataInputMXCuBE.getDiffractionPlan()
if xsDataDiffractionPlan.getStrategyOption() is not None:
strStrategyOption = xsDataDiffractionPlan.getStrategyOption().getValue()
if strStrategyOption.find("-DamPar") != -1:
bRunExecOutputHTML = False
if (self.edPluginExecOutputHTML is not None) and bRunExecOutputHTML:
self.edPluginExecOutputHTML.setDataInput(XSDataFile(XSDataString(strPathToDNAFileDirectory)), "dnaFileDirectory")
self.edPluginExecOutputHTML.execute()
# Fix for bug MXSUP-251: Put the BEST .par file in the EDNA characterisation root directory
xsDataIntegrationResult = xsDataResultCharacterisation.getIntegrationResult()
if xsDataIntegrationResult:
listXSDataIntegrationSubWedgeResult = xsDataIntegrationResult.getIntegrationSubWedgeResult()
if listXSDataIntegrationSubWedgeResult:
if listXSDataIntegrationSubWedgeResult != []:
strBestfilePar = listXSDataIntegrationSubWedgeResult[0].getBestfilePar().getValue()
# Put the file one directory above the mxCuBE v1.3 plugin working directory:
strDir = os.path.dirname(self.getWorkingDirectory())
strPath = os.path.join(strDir, "bestfile.par")
EDUtilsFile.writeFile(strPath, strBestfilePar)
# Execute plugin which creates a simple HTML page
self.executeSimpleHTML(xsDataResultCharacterisation)
def __generateIfeffitInputFile(self):
xsExperimentalDataEnergy = self.getDataInput().getExperimentalDataEnergy()
xsExperimentalDataLnI0It = self.getDataInput().getExperimentalDataLnI0It()
strLines = "# energy ln(I0/It)\n"
for i, dataEnergy in enumerate(xsExperimentalDataEnergy):
strLines += " ".join([str(dataEnergy.getValue()), str(xsExperimentalDataLnI0It[i].getValue())]) + "\n"
tmpInputFileName = os.path.join(self.getWorkingDirectory(), self.__strIfeffitDataName)
EDUtilsFile.writeFile(tmpInputFileName, strLines)
return tmpInputFileName
def doSuccessActionCharacterisation(self, _edPlugin):
"""
retrieve the potential warning messages
"""
EDPluginControlInterfacev1_1.doSuccessActionCharacterisation(self, _edPlugin)
# Generate file with executive summary...
pyStrCharacterisationExecutiveSummary = ""
pyListExecutiveSummaryLines = self.getPluginCharacterisation().getListExecutiveSummaryLines()
for pyStrLine in pyListExecutiveSummaryLines:
pyStrCharacterisationExecutiveSummary += pyStrLine + "\n"
pyStrSummaryDirectory = self.getWorkingDirectory()
pyStrSummaryPath = os.path.join(pyStrSummaryDirectory, "CharacterisationExecutiveSummary.txt")
EDUtilsFile.writeFile(pyStrSummaryPath, pyStrCharacterisationExecutiveSummary)
xsDataResultCCP4i = XSDataResultCCP4i()
# Construct the listOfOutputFiles string...
pyStrListOfOutputFiles = '\n'
pyStrListOfOutputFiles = pyStrListOfOutputFiles + self.getBaseDirectory() + '\n'
xsDataOutput = self.getPluginCharacterisation().getDataOutput()
pyListPredictionImages = xsDataOutput.getIndexingResult().getPredictionResult().getPredictionImage()
for xsDataImagePrediction in pyListPredictionImages:
strImagePath = xsDataImagePrediction.getPath().getValue()
pyStrListOfOutputFiles = pyStrListOfOutputFiles + strImagePath + '\n'
pyStrCharacterisationDirectory = os.path.join(self.getWorkingDirectory(), "Characterisation")
# "Hack" for determining if we use version 1.1 or 1.2 of the BEST plugin...
pyStrBestWorkingDirectory = os.path.join(pyStrCharacterisationDirectory, "Strategy")
pyStrBestPlotFilePath = None
pyStrBestLogFilePath = None
if (os.path.exists(os.path.join(pyStrBestWorkingDirectory, "Bestv1_1"))):
pyStrBestWorkingDirectory = os.path.join(pyStrBestWorkingDirectory, "Bestv1_1")
pyStrBestPlotFilePath = os.path.join(pyStrBestWorkingDirectory, "Bestv1_1_plots.mtv")
pyStrBestLogFilePath = os.path.join(pyStrBestWorkingDirectory, "Bestv1_1.log")
elif (os.path.exists(os.path.join(pyStrBestWorkingDirectory, "Bestv1_2"))):
pyStrBestWorkingDirectory = os.path.join(pyStrBestWorkingDirectory, "Bestv1_2")
pyStrBestPlotFilePath = os.path.join(pyStrBestWorkingDirectory, "Bestv1_2_plots.mtv")
pyStrBestLogFilePath = os.path.join(pyStrBestWorkingDirectory, "best.log")
pyStrCharacterisationOutput = None
if self.getPluginCharacterisation().getClassName() == "EDPluginControlCharacterisationv1_1":
pyStrCharacterisationOutput = os.path.join(pyStrCharacterisationDirectory, "ControlCharacterisationv1_1_dataOutput.xml")
elif self.getPluginCharacterisation().getClassName() == "EDPluginControlCharacterisationv1_2":
pyStrCharacterisationOutput = os.path.join(pyStrCharacterisationDirectory, "ControlCharacterisationv1_2_dataOutput.xml")
pyStrListOfOutputFiles = pyStrListOfOutputFiles + pyStrCharacterisationOutput + '\n'
if (pyStrBestLogFilePath is not None):
pyStrListOfOutputFiles = pyStrListOfOutputFiles + pyStrBestLogFilePath + '\n'
pyStrListOfOutputFiles = pyStrListOfOutputFiles + pyStrBestPlotFilePath + '\n'
pyStrListOfOutputFiles = pyStrListOfOutputFiles + pyStrSummaryPath + '\n'
xsDataStringListOfOutputFiles = XSDataString(pyStrListOfOutputFiles)
xsDataResultCCP4i.setListOfOutputFiles(xsDataStringListOfOutputFiles)
self.setDataOutput(xsDataResultCCP4i)
def __generateIfeffitInputFile(self, dataset):
_xsExperimentalDataEnergy = dataset.getExperimentalDataEnergy()
_xsExperimentalDataLnI0It = dataset.getExperimentalDataLnI0It()
_label = self.__getDatasetLabel(dataset)
strLines = '# energy ln(I0/It)\n'
for i, dataEnergy in enumerate(_xsExperimentalDataEnergy):
strLines += ' '.join([str(dataEnergy.getValue()), str(_xsExperimentalDataLnI0It[i].getValue())]) + '\n'
tmpInputFileName = os.path.join(self.getWorkingDirectory(), _label + self.__strIfeffitDataName)
EDUtilsFile.writeFile(tmpInputFileName, strLines)
return tmpInputFileName
def testGetEdnaUserTempFolder(self):
# Test that we can access the user temp folder
strUserTempFolder = EDUtilsPath.getEdnaUserTempFolder()
EDAssert.equal(True, os.path.exists(strUserTempFolder), "Checking that user temp folder exists")
# Test if we can write to the temp folder
strTest = "This is a test string."
strPathTestFile = os.path.join(strUserTempFolder, "EDTestCaseEDUtilsPath_testFile.txt")
EDUtilsFile.writeFile(strPathTestFile, strTest)
EDAssert.equal(True, os.path.exists(strPathTestFile), "Checking that new temp file exists")
# Delete the test file
os.remove(strPathTestFile)
def createHtmlPage(self):
page = markupv1_7.page(mode='loose_html')
page.init( title="Burn Strategy Results",
footer="Generated on %s" % time.asctime())
page.div( align_="CENTER")
page.h1()
page.strong("Burn Strategy Results")
page.h1.close()
page.img(src=self.strScaleIntensityPlot, title=self.strScaleIntensityPlot)
page.div.close()
strHTML = str(page)
EDUtilsFile.writeFile(os.path.join(self.getWorkingDirectory(), self.strHtmlPath), strHTML)
def parseIfeffitFiles(self, f, strIfeffitResultName, dictDatasets, _groupLabel, _xLabel):
dataLabels = []
xResults = []
yResults = []
for (idx,label) in enumerate(sorted(self.__xsIfeffitPlugin.iterkeys())):
dataLabels.append(label)
yResults.append({})
logLines = EDUtilsFile.readFile(os.path.join(self.__xsIfeffitPlugin[label].getWorkingDirectory(), \
label + strIfeffitResultName)).split('\n')[4:]
xResults.append([float(dataLine.split()[0]) for dataLine in logLines if dataLine])
for (col, param) in dictDatasets.iteritems():
yResults[idx][param] = [float(dataLine.split()[col]) for dataLine in logLines if dataLine]
_lenData = min([len(tmp) for tmp in xResults])
dEntry = f['/entry1']
dProcessing = dEntry.create_group(_groupLabel)
dProcessing.attrs["NX_class"] = "NXdata"
dx = dProcessing.create_dataset(_xLabel, (_lenData,), '=f8')
dx.attrs["target"] = "/".join(['','entry1',_groupLabel,_xLabel])
dx.attrs["axis"] = 2
dx.attrs["primary"] = 1
dx[:] = xResults[0][:_lenData]
#str_type = h5py.new_vlen(str)
#dz = dProcessing.create_dataset('dataLabels', (len(dataLabels),), str_type)
dz = dProcessing.create_dataset('scanID', (len(dataLabels),), "i")
dz.attrs["target"] = "/".join(['','entry1',_groupLabel,'scanID'])
dz.attrs["axis"] = 1
dz.attrs["primary"] = 2
dz[:] = [int(tmpLabel.split('_')[-1]) for tmpLabel in dataLabels]
for tmpName in dictDatasets.itervalues():
tmpLines = [' '.join(['#',_xLabel,''] + dataLabels)]
for idx in range(_lenData):
tmpLines.append(str(xResults[0][idx]) + ' ' + ' '.join([str(yResults[idxDataLabel][tmpName][idx]) for idxDataLabel in range(len(dataLabels))]))
EDUtilsFile.writeFile(os.path.join(self.getWorkingDirectory(), ''.join(['results_',tmpName,'.dat'])), '\n'.join(tmpLines))
#dTmp = dProcessing.create_dataset(tmpName, (_lenData,len(dataLabels)), '=f8')
#dTmp.attrs["target"] = "/".join(['','entry1',_groupLabel,tmpName])
#for idxDataLabel in range(len(dataLabels)):
# dTmp[:,idxDataLabel] = yResults[idxDataLabel][tmpName][:_lenData]
dTmp = dProcessing.create_dataset(tmpName, (len(dataLabels),_lenData), '=f8')
dTmp.attrs["target"] = "/".join(['','entry1',_groupLabel,tmpName])
dTmp.attrs["signal"] = 1
dTmp.attrs["axes"] = ':'.join(["scanID", _xLabel])
for idxDataLabel in range(len(dataLabels)):
dTmp[idxDataLabel,:] = yResults[idxDataLabel][tmpName][:_lenData]
def run(self):
"""
Executes the plugin and checks that the data output is not None
"""
EDVerbose.DEBUG("EDTestCasePluginExecute: Executing " + self.getPluginName())
self._edPlugin.executeSynchronous()
# Check that the plugin didn't end in failure
EDAssert.equal(self._bAcceptPluginFailure , self._edPlugin.isFailure(), \
"Plugin failure assert: should be %r, was %r" % (self._bAcceptPluginFailure , self._edPlugin.isFailure()))
# Checks the number of error messages
EDAssert.equal(self._iNoExpectedErrorMessages, len(self._edPlugin.getListOfErrorMessages()), \
"Number of error messages: expected %d, got %d" % (self._iNoExpectedErrorMessages, len(self._edPlugin.getListOfErrorMessages())))
# Checks the number of warning messages
EDAssert.equal(self._iNoExpectedWarningMessages, len(self._edPlugin.getListOfWarningMessages()), \
"Number of warning messages: expected %d, got %d" % (self._iNoExpectedWarningMessages, len(self._edPlugin.getListOfWarningMessages())))
# Check the output data
listOfDataOutputKeys = self._edPlugin.getListOfDataOutputKeys()
for strReferenceOutputDataKey in self._dictStrReferenceDataOutputFiles.keys():
# Only check the reference data keys
if (strReferenceOutputDataKey in listOfDataOutputKeys):
EDVerbose.unitTest("Testing data output for %s" % strReferenceOutputDataKey)
listReferenceFile = self._dictStrReferenceDataOutputFiles[ strReferenceOutputDataKey ]
if (type(listReferenceFile) != types.ListType):
listReferenceFile = [ listReferenceFile ]
listReferenceOutput = []
for strReferenceFile in listReferenceFile:
listReferenceOutput.append(self.readAndParseFile(strReferenceFile))
# Obtained output
listObtainedOutputXML = []
pyObjectObtainedDataOutput = self._edPlugin.getDataOutput(strReferenceOutputDataKey)
listObtainedOutput = None
if (type(pyObjectObtainedDataOutput) == types.ListType):
listObtainedOutput = pyObjectObtainedDataOutput
else:
listObtainedOutput = [ pyObjectObtainedDataOutput ]
for xsDataOutput in listObtainedOutput:
listObtainedOutputXML.append(xsDataOutput.marshal())
# Compare the lists, sort them first
listReferenceOutput.sort()
listObtainedOutputXML.sort()
for iIndex in range(len(listReferenceOutput)):
# Check of deprecated tests - if default data key only warn
if (strReferenceOutputDataKey == self._strDefaultOutputDataKey):
if (listReferenceOutput[ iIndex ] != listObtainedOutputXML[ iIndex ]):
EDVerbose.unitTest("WARNING! Expected output is not corresponding to obtained output.")
else:
EDAssert.equal(listReferenceOutput[ iIndex ], listObtainedOutputXML[ iIndex ])
# Legacy - save output data
if (strReferenceOutputDataKey == self._strDefaultOutputDataKey):
if (self.m_edObtainedOutputDataFile is None):
self.m_edObtainedOutputDataFile = self.getPluginName() + "_output.xml"
EDUtilsFile.writeFile(self.m_edObtainedOutputDataFile, self._edPlugin.getDataOutput().marshal())
def testInitaliseLabelitCommandLine(self):
"""
This method tests the initaliseLabelitCommandLine method of the Labelit plugin.
"""
edPluginLabelitv1_1 = self.createPlugin()
xmlInput1 = EDUtilsFile.readFile(self.__strReferenceInputFile1)
edPluginLabelitv1_1.setDataInput(xmlInput1, "referenceImage")
xmlInput2 = EDUtilsFile.readFile(self.__strReferenceInputFile2)
edPluginLabelitv1_1.setDataInput(xmlInput2, "referenceImage")
edPluginLabelitv1_1.initaliseLabelitCommandLine()
strScriptCommandLine = edPluginLabelitv1_1.getScriptCommandline()
strCommandLineExpected = "--index_only ${EDNA_TESTIMAGES}/images/ref-testscale_1_001.img ${EDNA_TESTIMAGES}/images/ref-testscale_1_002.img"
EDAssert.equal(strCommandLineExpected, strScriptCommandLine)
def testGenerateXSDataInputISPyB(self):
"""
This method is testing the generation of the XSDataInputISPyB object given a XSDataIndexingInput object.
"""
strReferenceInputControlISPyBFile = EDUtilsPath.mergePath(self.strDataPath, "XSDataInputControlISPyB_reference.xml")
strPath = os.path.join(self.strDataPath, strReferenceInputControlISPyBFile)
strXMLIndexingInput = EDUtilsFile.readFileAndParseVariables(strPath, self.dictReplace)
xsDataInputControlISPyB = XSDataInputControlISPyB.parseString(strXMLIndexingInput)
xsDataInputISPyB = EDHandlerXSDataISPyBv1_4.generateXSDataInputISPyBStoreScreening(xsDataInputControlISPyB)
strReferenceInputISPyBFile = EDUtilsPath.mergePath(self.strDataPath, "XSDataInputISPyB_reference.xml")
strReferencePath = os.path.join(self.strDataPath, strReferenceInputISPyBFile)
strXMLInputISPyBReference = EDUtilsFile.readFileAndParseVariables(strReferencePath, self.dictReplace)
EDFactoryPluginStatic.loadModule("XSDataISPyBv1_4")
def finallyProcess(self, _edObject=None):
EDPluginExecProcessScript.finallyProcess(self)
self.DEBUG("EDPluginBestv1_2.finallyProcess")
xsDataResultBest = self.getOutputDataFromDNATableFile(
os.path.join(self.getWorkingDirectory(), self.getScriptBaseName() + "_dnaTables.xml")
)
xsDataFilePathToLog = XSDataFile(
XSDataString(os.path.join(self.getWorkingDirectory(), self.getScriptLogFileName()))
)
xsDataResultBest.setPathToLogFile(xsDataFilePathToLog)
strError = self.readProcessErrorLogFile()
if (strError is not None) and (strError != ""):
strErrorMessage = EDMessage.ERROR_EXECUTION_03 % (
"EDPluginBestv1_2.finallyProcess",
"EDPluginBestv1_2",
strError,
)
self.error(strErrorMessage)
self.addErrorMessage(strErrorMessage)
# Append error message to best log
strLog = self.readProcessLogFile()
strLog += "\n" + strError
EDUtilsFile.writeFile(os.path.join(self.getWorkingDirectory(), self.getScriptLogFileName()), strLog)
self.setDataOutput(xsDataResultBest)
self.setFailure()
else:
strPathToPlotMtv = os.path.join(self.getWorkingDirectory(), self.getScriptBaseName() + "_plots.mtv")
if os.path.exists(strPathToPlotMtv):
xsDataFilePathToPlotMtv = XSDataFile(XSDataString(strPathToPlotMtv))
xsDataResultBest.setPathToPlotMtvFile(xsDataFilePathToPlotMtv)
# Check for .gle files
for strPath in os.listdir(self.getWorkingDirectory()):
if strPath.endswith(".gle"):
xsDataBestGlePlot = XSDataBestGlePlot()
xsDataBestGlePlot.script = XSDataFile(
XSDataString(os.path.join(self.getWorkingDirectory(), strPath))
)
strDataPath = strPath[:-4] + ".dat"
if os.path.exists(os.path.join(self.getWorkingDirectory(), strDataPath)):
xsDataBestGlePlot.data = XSDataFile(
XSDataString(os.path.join(self.getWorkingDirectory(), strDataPath))
)
else:
strDataPath = strPath[:-4] + ".data"
if os.path.exists(os.path.join(self.getWorkingDirectory(), strDataPath)):
xsDataBestGlePlot.data = XSDataFile(
XSDataString(os.path.join(self.getWorkingDirectory(), strDataPath))
)
xsDataResultBest.addGlePlot(xsDataBestGlePlot)
self.setDataOutput(xsDataResultBest)
def preProcess(self, _edObject=None):
EDPluginExecProcessScript.preProcess(self)
self.DEBUG("EDPluginDozorv1_0.preProcess")
xsDataInputDozor = self.getDataInput()
# First image number and osc range for output angle calculations
self.firstImageNumber = xsDataInputDozor.firstImageNumber.value
self.oscillationRange = xsDataInputDozor.oscillationRange.value
if xsDataInputDozor.overlap is not None:
self.overlap = xsDataInputDozor.overlap.value
if xsDataInputDozor.radiationDamage is not None and xsDataInputDozor.radiationDamage.value:
self.setScriptCommandline("-rd dozor.dat")
else:
self.setScriptCommandline("-p dozor.dat")
strCommands = self.generateCommands(xsDataInputDozor)
EDUtilsFile.writeFile(os.path.join(self.getWorkingDirectory(), "dozor.dat"), strCommands)
def testExecute(self):
"""
"""
self.run()
# Checks that there are no error messages
plugin = self.getPlugin()
EDVerbose.DEBUG("Checking error messages...")
EDAssert.equal(self.m_iNoErrorMessages, self.getErrorMessages().getNumberObjects())
EDVerbose.DEBUG("Checking warning messages...")
EDAssert.equal(self.m_iNoWarningMessages, self.getWarningMessages().getNumberObjects())
# Checking obtained results
# For the moment, just check if the output file exists
xsDataResultsFIT2DCake = plugin.getDataOutput()
strPathToOutputFile = xsDataResultsFIT2DCake.getResultFile().getPath().getValue()
strDataObtained = EDUtilsFile.readFile(strPathToOutputFile)
strDataReference = EDUtilsFile.readFile(os.path.join(self.getPluginTestsDataHome(), \
"EDPluginFIT2DCakev1_1.chi"))
EDAssert.equal(strDataReference, strDataObtained)
EDAssert.equal(True, os.path.exists(strPathToOutputFile))
bEqual = (strDataReference == strDataObtained)
if not bEqual:
lstDataReference = strDataReference.split()
lstDataObtained = strDataObtained.split()
if len(lstDataReference) == len(lstDataObtained):
EDVerbose.DEBUG("Checking for small numerical error...Relative:%s Absolute: %s" % (self.EPSILON_REL, self.EPSILON_ABS))
bEqual = True
for i in xrange(len(lstDataReference)):
if lstDataReference[i] != lstDataObtained[i]:
try:
r = float(lstDataReference[i])
o = float(lstDataObtained[i])
except Exception:
bEqual = False
break
if (2 * abs(r - o) / (o + r) > self.EPSILON_REL) and abs(r - o) > self.EPSILON_ABS:
# EDVerbose.setVerboseDebugOn()
EDVerbose.DEBUG("MisMatch: %s,%s" % (r, o))
bEqual = False
break
EDAssert.equal(bEqual, True)
def preProcess(self, _edObject=None):
EDPluginExec.preProcess(self)
self.DEBUG("EDPluginExecPlotGlev1_1.preProcess")
FileGle = None
# Check if we have a plotmtv input file
xsDataInput = self.getDataInput()
for xsDataGlePlot in xsDataInput.glePlot:
dictPlot = {}
dictPlot["script"] = xsDataGlePlot.script.path.value
dictPlot["data"] = [xsDataGlePlot.data.path.value]
self.listPlot.append(dictPlot)
if xsDataInput.filePlotMtv is not None:
strPlotMtvPath = xsDataInput.filePlotMtv.path.value
if os.path.exists(strPlotMtvPath):
strPlotMtv = EDUtilsFile.readFile(strPlotMtvPath)
xsDataPlotSet = self.readPlotMtv(strPlotMtv)
else:
self.ERROR("Path to plt mtv file does not exist: %s" % strPlotMtvPath)
self.setFailure()
return
else:
xsDataPlotSet = xsDataInput.plotSet
# Prepare input script
iIndex = 1
if xsDataPlotSet is not None:
for xsDataPlot in xsDataPlotSet.plot:
if xsDataPlot.xsize is None:
xsDataPlot.xsize = 10
if xsDataPlot.ysize is None:
xsDataPlot.ysize = 10
if iIndex in [1, 5, 8]:
xsDataPlot.keypos = "tl"
elif iIndex in [2, 4, 6]:
xsDataPlot.keypos = "tr"
elif iIndex in [3]:
xsDataPlot.keypos = "br"
elif iIndex in [7]:
xsDataPlot.keypos = "bl"
if iIndex == 4:
xsDataPlot.xmax = 500
strPlotFile = os.path.join(self.getWorkingDirectory(), "plot%d" % iIndex)
(strGle, listDataFiles) = self.prepareGleGraph(xsDataPlot)
EDUtilsFile.writeFile(strPlotFile + ".gle", strGle)
dictPlot = {}
dictPlot["script"] = strPlotFile + ".gle"
dictPlot["data"] = listDataFiles
self.listPlot.append(dictPlot)
iIndex += 1
def preProcess(self, _edObject=None):
EDPluginExec.preProcess(self)
self.DEBUG("EDPluginExecPlotGlev1_0.preProcess")
# Check if we have a plotmtv input file
xsDataInput = self.getDataInput()
if xsDataInput.filePlotMtv is not None:
strPlotMtvPath = xsDataInput.filePlotMtv.path.value
if os.path.exists(strPlotMtvPath):
strPlotMtv = EDUtilsFile.readFile(strPlotMtvPath)
xsDataPlotSet = self.readPlotMtv(strPlotMtv)
else:
self.ERROR("Path to plt mtv file does not exist: %s" %
strPlotMtvPath)
self.setFailure()
return
else:
xsDataPlotSet = xsDataInput.plotSet
# Prepare input script
iIndex = 1
for xsDataPlot in xsDataPlotSet.plot:
if xsDataPlot.xsize is None:
xsDataPlot.xsize = 10
if xsDataPlot.ysize is None:
xsDataPlot.ysize = 10
if iIndex in [1, 5, 8]:
xsDataPlot.keypos = "tl"
elif iIndex in [2, 4, 6]:
xsDataPlot.keypos = "tr"
elif iIndex in [3]:
xsDataPlot.keypos = "br"
elif iIndex in [7]:
xsDataPlot.keypos = "bl"
if iIndex == 4:
xsDataPlot.xmax = 500
strPlotFile = os.path.join(self.getWorkingDirectory(),
"plot%d" % iIndex)
strGle = self.prepareGleGraph(xsDataPlot)
EDUtilsFile.writeFile(strPlotFile + ".gle", strGle)
self.listPlot.append(strPlotFile)
iIndex += 1
def postProcess(self, _edObject=None):
EDPluginExec.postProcess(self)
EDVerbose.DEBUG("EDPluginExecOutputHTMLv1_0.postProcess")
if self.strWorkingDir != None:
xsDataFileHTMLFile = XSDataFile()
xsDataFileHTMLDir = XSDataFile()
if self.strBasename is None:
strHTMLFilePath = os.path.join(self.strWorkingDir, "edna.html")
strHTMLDirPath = os.path.join(self.strWorkingDir, "edna_html")
else:
strHTMLFilePath = os.path.join(self.strBasename, "edna.html")
strHTMLDirPath = os.path.join(self.strBasename, "edna_html")
if os.path.exists(strHTMLFilePath):
strFileContent = EDUtilsFile.readFile(strHTMLFilePath)
strFileContent = strFileContent.replace(
"table,td,th { border-style: none;",
"div.edna table,td,th { border-style: none;")
strFileContent = strFileContent.replace(
"td,th { border-style: solid;",
"div.edna td,th { border-style: solid;")
strFileContent = strFileContent.replace(
"th { background-color: gray;",
"div.edna th { background-color: gray;")
strFileContent = strFileContent.replace(
"<body onload=\"initTable('strategyData',false,false);\">",
"<body onload=\"initTable('strategyData',false,false);\"><div class = 'edna'> "
)
strFileContent = strFileContent.replace(
"</body>", "</div></body>")
EDUtilsFile.writeFile(strHTMLFilePath, strFileContent)
xsDataFileHTMLFile.setPath(XSDataString(strHTMLFilePath))
xsDataFileHTMLDir.setPath(XSDataString(strHTMLDirPath))
self.setDataOutput(xsDataFileHTMLFile, "htmlFile")
self.setDataOutput(xsDataFileHTMLDir, "htmlDir")
else:
EDVerbose.ERROR(
"EDPluginExecOutputHTMLv1_0.postProcess: file doesn't exist: "
+ strHTMLFilePath)
def preProcess(self, _edObject=None):
"""
"""
EDPluginExecProcessScript.preProcess(self)
self.setFileBestDat(
os.path.join(self.getWorkingDirectory(), "bestfile.dat"))
self.setFileBestPar(
os.path.join(self.getWorkingDirectory(), "bestfile.par"))
EDUtilsFile.writeFile(
self.getFileBestDat(),
self.getDataInput().getBestFileContentDat().getValue())
EDUtilsFile.writeFile(
self.getFileBestPar(),
self.getDataInput().getBestFileContentPar().getValue())
listBestFileContentHKL = self.getDataInput().getBestFileContentHKL()
iterator = 0
for bestFileContentHKL in listBestFileContentHKL:
iterator = iterator + 1
bestFileHKL = os.path.join(self.getWorkingDirectory(),
"bestfile" + str(iterator) + ".hkl")
self.listFileBestHKL.append(bestFileHKL)
EDUtilsFile.writeFile(bestFileHKL, bestFileContentHKL.getValue())
if (self.getDataInput().getComplexity() is not None):
self.setComplexity(self.getDataInput().getComplexity().getValue())
self.initializeCommands()
def process(self, _edPlugin=None):
EDPluginExec.process(self, _edPlugin)
self.DEBUG("EDPluginExecSimpleHTMLPagev1_0.process...")
if self.xsDataResultCharacterisation is not None:
# Create the simple characterisation result page
self.page = markupv1_7.page(mode='loose_html')
self.page.init(title="Characterisation Results",
footer="Generated on %s" % time.asctime())
self.page.div(align_="CENTER")
self.page.h1()
if self.xsDataResultCharacterisation is not None:
self.page.strong("Characterisation Results ")
else:
self.page.strong("No Characterisation Results! ")
# Link to the EDNA log file
strPathToLogFile = self.findEDNALogFile()
if strPathToLogFile is not None:
self.page.strong("(")
self.strPageEDNALog = os.path.join(self.getWorkingDirectory(),
"edna_log.html")
pageEDNALog = markupv1_7.page()
pageEDNALog.h1("EDNA Log")
pageEDNALog.a("Back to previous page",
href_=self.strHtmlFileName)
pageEDNALog.pre(
cgi.escape(EDUtilsFile.readFile(strPathToLogFile)))
pageEDNALog.a("Back to previous page",
href_=self.strHtmlFileName)
EDUtilsFile.writeFile(self.strPageEDNALog, str(pageEDNALog))
self.page.a("EDNA log file", href_="edna_log.html")
self.page.strong(")")
self.page.h1.close()
self.page.div.close()
self.dataCollectionInfo()
self.diffractionPlan()
self.strategyResults()
self.graphs()
self.indexingResults()
self.integrationResults()
self.imageQualityIndicatorResults()
def preProcess(self, _edObject=None):
EDPluginExecProcessScript.preProcess(self)
self.DEBUG("EDPluginBestv1_3.preProcess")
self.setScriptLogFileName("best.log")
self.setFileBestDat(
os.path.join(self.getWorkingDirectory(), "bestfile.dat"))
self.setFileBestPar(
os.path.join(self.getWorkingDirectory(), "bestfile.par"))
EDUtilsFile.writeFile(self.getFileBestDat(),
self.dataInput.bestFileContentDat.value)
EDUtilsFile.writeFile(self.getFileBestPar(),
self.dataInput.bestFileContentPar.value)
listBestFileContentHKL = self.dataInput.getBestFileContentHKL()
iterator = 0
for bestFileContentHKL in listBestFileContentHKL:
iterator = iterator + 1
bestFileHKL = os.path.join(self.getWorkingDirectory(),
"bestfile" + str(iterator) + ".hkl")
self.listFileBestHKL.append(bestFileHKL)
EDUtilsFile.writeFile(bestFileHKL, bestFileContentHKL.value)
if self.dataInput.complexity is not None:
self.setComplexity(self.dataInput.complexity.value)
self.initializeCommands()
def writeDataInput(self, _edObject=None):
"""
Writes the input data object(s) into a working dir xml file
"""
self.DEBUG("EDPlugin.writeDataInput")
strBasename = os.path.join(
self.getWorkingDirectory(),
self.compactPluginName(self.getPluginName()))
for strKey in self.__dictXSDataInput.keys():
if (strKey == self.__strDefaultInputDataKey): # "Old" style
xsDataInput = self.__dictXSDataInput[
self.__strDefaultInputDataKey]
self.strPathDataInput = strBasename + "_dataInput.xml"
EDUtilsFile.writeFile(self.strPathDataInput,
xsDataInput.marshal())
else: # We have a list of objects
listXSDataInput = self.__dictXSDataInput[strKey]
for iIndex, xsDataInput in enumerate(listXSDataInput):
strPathDataInput = "%s_%s_%d_dataInput.xml" % (
strBasename, strKey, iIndex)
EDUtilsFile.writeFile(strPathDataInput,
xsDataInput.marshal())
def __init__(self, _edStringTestName=None):
"""
"""
self.refInput = "MokeImage-2th21-tilt3-rot30.edf"
self.refOutput = "MokeImage-2th21-tilt3-rot30.azim"
EDTestCasePluginExecute.__init__(self, "EDPluginSPDCakev1_5",
_edStringTestName)
self.setConfigurationFile(self.getRefConfigFile())
self.setDataInputFile(os.path.join(self.getPluginTestsDataHome(), \
"XSDataInputSPDCakev1_5_MokeImage.xml"))
self.setReferenceDataOutputFile(os.path.join(self.getPluginTestsDataHome(), \
"XSDataResultSPDCakev1_5_MokeImage.xml"))
self.m_edObtainedOutputDataFile = self.getPluginName() + "_output.xml"
strSplineFileName = "frelon_spline_file_to_correct_SPD.spline"
strPathToSplineFile = os.path.join(self.getTestsDataImagesHome(),
strSplineFileName)
if (not os.path.isfile(strPathToSplineFile)):
EDUtilsFile.copyFile(os.path.join(self.getPluginTestsDataHome(), strSplineFileName), \
strPathToSplineFile)
def __init__(self):
"""
"""
EDTestCasePluginExecute.__init__(self, "EDPluginSPDCakev1_1",
"EDPluginControlSPD-v1.1")
self.setConfigurationFile(self.getRefConfigFile())
self.setDataInputFile(os.path.join(self.getPluginTestsDataHome(), \
"XSDataInputSPDCake_reference.xml"))
self.setReferenceDataOutputFile(os.path.join(self.getPluginTestsDataHome(), \
"XSDataResultSPDCake_reference.xml"))
self.m_edObtainedOutputDataFile = self.getPluginName() + "_output.xml"
edStringSplineFileName = "frelon_spline_file_to_correct_SPD.spline"
edStringPathToSplineFile = os.path.join(self.getTestsDataImagesHome(),
edStringSplineFileName)
if (not os.path.exists(edStringPathToSplineFile)):
EDUtilsFile.copyFile(os.path.join(self.getPluginTestsDataHome(), edStringSplineFileName), \
edStringPathToSplineFile)
def readGnomDataFile(self, fileName):
tmpExperimentalDataQ = []
tmpExperimentalDataValues = []
dataLines = EDUtilsFile.readFile(fileName).splitlines()[1:]
for line in dataLines:
lineList = line.split()
if len(lineList) > 0:
tmpExperimentalDataQ.append(XSDataDouble(float(lineList[0])))
tmpExperimentalDataValues.append(XSDataDouble(float(lineList[1])))
dataInput = self.plugin.dataInput
dataInput.setExperimentalDataQ(tmpExperimentalDataQ)
dataInput.setExperimentalDataValues(tmpExperimentalDataValues)
dataInput.exportToFile("XSDataInputGnom_reference_list.xml")
def generateGnomInputFile(self):
xsExperimentalDataQ = self.getDataInput().getExperimentalDataQ()
xsExperimentalDataValues = self.getDataInput(
).getExperimentalDataValues()
xsExperimentalDataStdDev = None
if self.getDataInput().getExperimentalDataStdDev() is not None:
xsExperimentalDataStdDev = self.getDataInput(
).getExperimentalDataStdDev()
strLines = 'Gnom data file\n'
for i, dataQ in enumerate(xsExperimentalDataQ):
if xsExperimentalDataStdDev:
strStdDev = str(xsExperimentalDataStdDev[i].getValue())
else:
strStdDev = ''
strLines += ' '.join([
str(dataQ.getValue()),
str(xsExperimentalDataValues[i].getValue()), strStdDev
]) + '\n'
tmpInputFileName = os.path.join(self.getWorkingDirectory(),
"gnom_tmp.dat")
EDUtilsFile.writeFile(tmpInputFileName, strLines)
return tmpInputFileName
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 readAndParseFile(self, _strFileName):
"""
Reads a file and parses potential existing environment variables such as:
- EDNA_TESTS_DATA_HOME
- EDNA_PLUGIN_TESTS_DATA_HOME
- EDNA_HOME
- USER
- TMPDIR
All those key are defined in a class dictionary
Returns the content of this file as a string
"""
return str(EDUtilsFile.readFileAndParseVariables(_strFileName, self.dictReplace))
def readProcessFile(self, _strFileName):
"""
Returns the file content of a process file
"""
self.DEBUG("EDPluginExecProcessScript.readProcessFile")
if _strFileName.startswith("/"):
strFilePath = _strFileName
else:
strFilePath = os.path.join(self.getWorkingDirectory(),
_strFileName)
strFileContent = None
if os.path.exists(strFilePath):
strFileContent = EDUtilsFile.readFile(strFilePath)
return strFileContent
def testExecute(self):
"""
"""
self.run()
# Checks that there are no error messages
plugin = self.getPlugin()
EDVerbose.DEBUG("Checking error messages...")
EDAssert.equal(self.m_iNoErrorMessages,
self.getErrorMessages().getNumberObjects())
EDVerbose.DEBUG("Checking warning messages...")
EDAssert.equal(self.m_iNoWarningMessages,
self.getWarningMessages().getNumberObjects())
# Checking obtained results
xsDataResults = plugin.getDataOutput()
edStringPathToOutput = xsDataResults.getIntegratedIntensities(
).getPath().getValue()
edStringDataObtained = EDUtilsFile.readFile(edStringPathToOutput)
edStringDataReference = EDUtilsFile.readFile( os.path.join( self.getPluginTestsDataHome(), \
"Reference_powder_diffraction.cif" ) )
def preProcess(self):
"""
Creates the application working directory (log dir)
Initializes the configuration
retrieves the plugin xml data to be passed to the plugin
"""
EDVerbose.DEBUG("EDApplication.preProcess")
self.processCommandline()
if (not self._bIsFailure):
# Check that the plugin can be located
strPluginLocation = EDFactoryPluginStatic.getFactoryPlugin().getModuleLocation(self._strPluginName)
if (strPluginLocation is None):
EDVerbose.error("Plugin %s cannot be loaded!" % self._strPluginName)
self._bIsFailure = True
# Check that the input file can be read
if (self.getDataInputFilePath() is not None) and (not os.path.exists(self._strDataInputFilePath)):
EDVerbose.error("Input XML file not found : %s" % self._strDataInputFilePath)
self._bIsFailure = True
# Check that the output file can be created
if (self._strDataOutputFilePath is not None):
strOutputDirectory = os.path.dirname(self._strDataOutputFilePath)
if (strOutputDirectory is None or strOutputDirectory == ""):
strOutputDirectory = os.getcwd()
self._strDataOutputFilePath = os.path.join(strOutputDirectory, self._strDataOutputFilePath)
if (not os.access(strOutputDirectory, os.W_OK)):
EDVerbose.error("Output directory not writable: %s" % strOutputDirectory)
self._bIsFailure = True
elif (os.path.exists(self._strDataOutputFilePath)):
if (not os.access(self._strDataOutputFilePath, os.W_OK)):
EDVerbose.error("Output file not writable: %s" % self._strDataOutputFilePath)
self._bIsFailure = True
if (not self._bIsFailure):
EDVerbose.DEBUG("EDApplication.PLUGIN_PARAM_LABEL: " + EDApplication.PLUGIN_PARAM_LABEL)
if self._strConfigurationFileName is not None:
# Load the configuration file
if (os.path.exists(self._strConfigurationFileName)):
EDVerbose.screen("Loading Configuration file: %s" % self._strConfigurationFileName)
EDConfigurationStatic.addConfigurationFile(self._strConfigurationFileName, _bReplace=True)
else:
EDVerbose.warning("Cannot find configuration file: %s" % self._strConfigurationFileName)
pyDictionary = {}
pyDictionary[ "${EDNA_HOME}" ] = EDUtilsPath.getEdnaHome()
if self.getDataInputFilePath() is not None:
self._strXMLData = EDUtilsFile.readFileAndParseVariables(self.getDataInputFilePath(), pyDictionary)
# Create the application working directory
if(self._strWorkingDir is None):
self._strWorkingDir = self._strApplicationInstanceName
self.createApplicationWorkingDirectory()
def testGetBestWilsonPlotPath(self):
strReferenceInputControlISPyBFile = EDUtilsPath.mergePath(
self.strDataPath, "XSDataInputControlISPyB_reference.xml")
strPath = os.path.join(self.strDataPath,
strReferenceInputControlISPyBFile)
strXMLIndexingInput = EDUtilsFile.readFileAndParseVariables(
strPath, self.dictReplace)
xsDataInputControlISPyB = XSDataInputControlISPyB.parseString(
strXMLIndexingInput)
xsDataCharacterisationResult = xsDataInputControlISPyB.characterisationResult
strPath = EDHandlerXSDataISPyBv1_4.getBestWilsonPlotPath(
xsDataCharacterisationResult)
EDAssert.equal(
True, strPath.endswith("B.jpg"),
"Wilson plot path extracted from characterisation results")
def parsePointlessOutput(self, _outputFile):
sgre = re.compile(
""" \* Space group = '(?P<sgstr>.*)' \(number\s+(?P<sgnumber>\d+)\)"""
)
sgnumber = sgstr = None
res = XSDataPointlessOut()
status = XSDataStatus()
status.isSuccess = XSDataBoolean(False)
if os.path.exists(_outputFile):
res.status = status
strLog = EDUtilsFile.readFile(_outputFile)
if strLog is not None:
# we'll apply the regexp to the whole file contents which
# hopefully won't be that long.
m = sgre.search(strLog)
if m is not None:
d = m.groupdict()
sgnumber = d['sgnumber']
sgstr = d['sgstr']
res.sgnumber = XSDataInteger(sgnumber)
res.sgstr = XSDataString(sgstr)
status.isSuccess = XSDataBoolean(True)
# Search first for unit cell after the Laue group...
unitCellRe = re.compile(
""" Laue group confidence.+\\n\\n\s+Unit cell:(.+)""")
m2 = unitCellRe.search(strLog)
if m2 is None:
# Then search it from the end...
unitCellRe = re.compile(
""" \* Cell Dimensions : \(obsolete \- refer to dataset cell dimensions above\)\\n\\n(.+)"""
)
m2 = unitCellRe.search(strLog)
if m2 is not None:
listCell = m2.groups()[0].split()
xsDataCCP4Cell = XSDataCCP4Cell()
xsDataCCP4Cell.length_a = XSDataLength(listCell[0])
xsDataCCP4Cell.length_b = XSDataLength(listCell[1])
xsDataCCP4Cell.length_c = XSDataLength(listCell[2])
xsDataCCP4Cell.angle_alpha = XSDataAngle(listCell[3])
xsDataCCP4Cell.angle_beta = XSDataAngle(listCell[4])
xsDataCCP4Cell.angle_gamma = XSDataAngle(listCell[5])
res.cell = xsDataCCP4Cell
return res
def testSpatialDistortion(self):
strRefX = "spline-3-18x.edf"
strRefY = "spline-3-18y.edf"
self.loadTestImage([strRefX, strRefY])
edPluginSPD = self.createPlugin()
strXMLInput = EDUtilsFile.readFileAndParseVariables(
self.strReferenceInputFileName)
xsDataInputSPDCake = XSDataInputSPDCake.parseString(strXMLInput)
edPluginSPD.setDataInput(xsDataInputSPDCake)
edPluginSPD.configure()
edPluginSPD.getInputParameter()
########################################################################
# Enforce some values
########################################################################
edPluginSPD.dictGeometry["SpatialDistortionFile"] = os.path.join(
self.getTestsDataImagesHome(),
"frelon_spline_file_to_correct_SPD.spline")
edPluginSPD.dictGeometry["TiltRotation"] = 18
edPluginSPD.dictGeometry["AngleOfTilt"] = 3
spline = Spline()
spline.read(edPluginSPD.dictGeometry["SpatialDistortionFile"])
edPluginSPD.dictGeometry["PixelSizeX"], edPluginSPD.dictGeometry[
"PixelSizeY"] = spline.getPixelSize()
edPluginSPD.createDisplacementMatrix(spline)
edPluginSPD.cleanDispMat(edPluginSPD.getWorkingDirectory())
refX = fabio.openimage.openimage(
os.path.join(self.getTestsDataImagesHome(), strRefX)).data
obtX = fabio.openimage.openimage(
os.path.join(
edPluginSPD.getWorkingDirectory(),
"frelon_spline_file_to_correct_SPD-tilted-x.edf")).data
refY = fabio.openimage.openimage(
os.path.join(self.getTestsDataImagesHome(), strRefY)).data
obtY = fabio.openimage.openimage(
os.path.join(
edPluginSPD.getWorkingDirectory(),
"frelon_spline_file_to_correct_SPD-tilted-y.edf")).data
# print edPluginSPD.dictGeometry
EDAssert.arraySimilar(obtX,
refX,
_fAbsMaxDelta=0.1,
_strComment="X displacement Matrix is the same")
EDAssert.arraySimilar(obtY,
refY,
_fAbsMaxDelta=0.1,
_strComment="Y displacement Matrix is the same")
def getXSDataResultBest(self, _strPathToLogFile):
"""Parse the BEST log file"""
xsDataResultBest = None
if os.path.exists(_strPathToLogFile):
strBestLog = EDUtilsFile.readFile(_strPathToLogFile)
xsDataStringStrategyOption = self.dataInput.strategyOption
# Check if -DamPar or -Bonly strategy options have been used
if xsDataStringStrategyOption is not None:
strStrategyOption = xsDataStringStrategyOption.value
if strStrategyOption.find("-Bonly") != -1:
xsDataResultBest = self.getBonlyOutputFromLog(strBestLog)
if xsDataResultBest is None:
# Neither the -DamPar nor the -Bonly strategy option has been used
xsDataResultBest = self.getDataCollectionOutputDataFromLog(
strBestLog)
return xsDataResultBest
def testExecute(self):
"""
"""
plugin = self.getPlugin()
plugin.emptyItems()
plugin.emptyQueries()
self.run()
# Checking obtained results
xsDataResult = plugin.getDataOutput()
strXMLRef = XSDataResultAccumulator.parseString(
EDUtilsFile.readFile(self.getReferenceDataOutputFile())).marshal()
EDAssert.equal(xsDataResult.marshal(), strXMLRef,
"XML results are conform")
EDAssert.equal(plugin.getItems(),
[u'data1', u'data2', u'data3', u'data4', u'data5'],
"Remaining items are the same")
plugin.emptyItems()
def preProcess(self, _edObject=None):
EDPluginExecProcessScript.preProcess(self)
self.DEBUG("EDPluginBestv1_2.preProcess")
self.setScriptLogFileName("best.log")
if self.dataInput.bestFileContentPar is not None:
self.setFileBestDat(
os.path.join(self.getWorkingDirectory(), "bestfile.dat"))
self.setFileBestPar(
os.path.join(self.getWorkingDirectory(), "bestfile.par"))
EDUtilsFile.writeFile(self.getFileBestDat(),
self.dataInput.bestFileContentDat.value)
EDUtilsFile.writeFile(self.getFileBestPar(),
self.dataInput.bestFileContentPar.value)
listBestFileContentHKL = self.dataInput.bestFileContentHKL
iterator = 0
for bestFileContentHKL in listBestFileContentHKL:
iterator = iterator + 1
bestFileHKL = os.path.join(self.getWorkingDirectory(),
"bestfile" + str(iterator) + ".hkl")
self.listFileBestHKL.append(bestFileHKL)
EDUtilsFile.writeFile(bestFileHKL, bestFileContentHKL.value)
elif self.dataInput.xdsCorrectLp is not None:
self.strPathToCorrectLp = os.path.join(self.getWorkingDirectory(),
"CORRECT.LP")
shutil.copyFile(self.dataInput.xdsCorrectLp.path.value,
self.strPathToCorrectLp)
self.strPathToBkgpixCbf = os.path.join(self.getWorkingDirectory(),
"BKGPIX.cbf")
shutil.copyFile(self.dataInput.xdsBkgpixCbf.path.value,
self.strPathToBkgpixCbf)
self.strListFileXdsAsciiHkl = ""
index = 1
for xdsAsciiHkl in self.dataInput.xdsAsciiHkl:
strPathToXdsAsciiHkl = os.path.join(
self.getWorkingDirectory(),
"XDS_ASCII_{0}.HKL".format(index))
shutil.copyFile(xdsAsciiHkl.path.value, strPathToXdsAsciiHkl)
self.strListFileXdsAsciiHkl += " " + strPathToXdsAsciiHkl
index += 1
if self.dataInput.complexity is not None:
self.strComplexity = self.dataInput.complexity.value
self.initializeCommands()
def testGenerateSPDCommand(self):
edPluginSPD = self.createPlugin()
strXMLInput = EDUtilsFile.readFileAndParseVariables(
self.strReferenceInputFileName, EDUtilsPath.getDictOfPaths())
xsDataInputSPDCake = XSDataInputSPDCake.parseString(strXMLInput)
edPluginSPD.setDataInput(xsDataInputSPDCake)
edPluginSPD.configure()
edPluginSPD.getInputParameter()
#edPluginSPD.preProcess()
edPluginSPD.generateSPDCommand()
EDVerbose.screen("SPD configuration:\n%s" % edPluginSPD.getSPDConfig())
if EDVerbose.isVerboseDebug():
expected = """off_1=0 off_2=0 verbose=2 src_ext=.edf cor_ext=.cor wvl=1.000000e-10 cen_1=1.050000e+03 cen_2=1.000000e+03 dis=1.000000e-01 pix_1=4.722440e-05 pix_2=4.683150e-05 do_distortion=0 do_dark=0"""
#"do_distortion=2 off_1=0 off_2=0 verbose=2 src_ext=.edf cor_ext=.cor wvl=1.000000e-10 cen_1=1.050000e+03 cen_2=1.000000e+03 dis=1.000000e-01 pix_1=4.722440e-05 pix_2=4.683150e-05 do_dark=0"
else:
expected = """off_1=0 off_2=0 verbose=0 src_ext=.edf cor_ext=.cor wvl=1.000000e-10 cen_1=1.050000e+03 cen_2=1.000000e+03 dis=1.000000e-01 pix_1=4.722440e-05 pix_2=4.683150e-05 do_distortion=0 do_dark=0"""
#do_distortion=2 off_1=0 off_2=0 verbose=0 src_ext=.edf cor_ext=.cor wvl=1.000000e-10 cen_1=1.050000e+03 cen_2=1.000000e+03 dis=1.000000e-01 pix_1=4.722440e-05 pix_2=4.683150e-05 do_dark=0"
EDAssert.equal(edPluginSPD.getSPDConfig(), expected)
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 = XSDataResultBioSaxsAzimutIntv1_0.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same",
_strExcluded="bioSaxs")
################################################################################
# Compare spectrum ascii Files
################################################################################
outputData = open(
xsDataResultObtained.getIntegratedCurve().getPath().value,
"rb").read().split(os.linesep)
referenceData = EDUtilsFile.readFileAndParseVariables(
os.path.join(self.getTestsDataImagesHome(),
"bioSaxsIntegratedv1_3.dat"),
EDUtilsPath.getDictOfPaths()).split(os.linesep)
outputData = os.linesep.join(
[i for i in outputData if not i.startswith("# History")])
referenceData = os.linesep.join(
[i for i in referenceData if not i.startswith("# History")])
EDAssert.strAlmostEqual(
referenceData,
outputData,
_strComment="3column ascii spectra files are the same",
_fRelError=0.1,
_fAbsError=0.1,
_strExcluded="bioSaxs")
def doSuccessIntegration(self, _edPlugin=None):
self.DEBUG("EDPluginControlGridScreeningv1_0.doSuccessIntegration")
self.retrieveSuccessMessages(_edPlugin, "EDPluginControlGridScreeningv1_0.doSuccessIntegration")
self.addStatusMessage("Integration successful.")
self.xsDataIntegrationOutput = self.edPluginControlIntegration.getDataOutput()
# Integration short summary
if self.edPluginControlIntegration.hasDataOutput("integrationShortSummary"):
self.strCharacterisationShortSummary += self.edPluginControlIntegration.getDataOutput("integrationShortSummary")[0].getValue()
# self.DEBUG( self.xsDataExperimentCharacterisation.marshal() )
if self.bDoOnlyIntegrationWithXMLOutput:
# Run mtz2various
xsDataInputMtz2Various = XSDataInputMtz2Various()
xsDataInputMtz2Various.setMtzfile(self.edPluginControlIntegration.getDataOutput().getIntegrationSubWedgeResult()[0].getGeneratedMTZFile())
xsDataInputMtz2Various.addLabin(XSDataString("I=I"))
xsDataInputMtz2Various.addLabin(XSDataString("SIGI=SIGI"))
xsDataInputMtz2Various.setOutput(XSDataString("USER '(3I4,2F10.1)'"))
self.edPluginExecMtz2Various.setDataInput(xsDataInputMtz2Various)
self.edPluginExecMtz2Various.executeSynchronous()
strHklFilePath = self.edPluginExecMtz2Various.getDataOutput().getHklfile().getPath().getValue()
strIntegration = EDUtilsFile.readFile(strHklFilePath)
# Output the result in XML format
self.xsDataGridScreeningResultIntegration = XSDataGridScreeningResultIntegration()
self.xsDataGridScreeningResultIntegration.setFileName(os.path.basename(self.strImageFile))
self.xsDataGridScreeningResultIntegration.setFileDirectory(os.path.dirname(self.strImageFile))
self.xsDataGridScreeningResultIntegration.setIntegratedData(strIntegration)
else:
# We continue with the strategy calculation
xsDataInputStrategy = XSDataInputStrategy()
xsDataSolutionSelected = self.xsDataIndexingResult.getSelectedSolution()
xsDataInputStrategy.setCrystalRefined(xsDataSolutionSelected.getCrystal())
xsDataInputStrategy.setSample(self.xsDataCollection.getSample())
xsDataIntegrationSubWedgeResultList = self.xsDataIntegrationOutput.getIntegrationSubWedgeResult()
xsDataInputStrategy.setBestFileContentDat(xsDataIntegrationSubWedgeResultList[0].getBestfileDat())
xsDataInputStrategy.setBestFileContentPar(xsDataIntegrationSubWedgeResultList[0].getBestfilePar())
xsDataInputStrategy.setExperimentalCondition(xsDataIntegrationSubWedgeResultList[0].getExperimentalConditionRefined())
xsDataInputStrategy.setDataCollection(self.xsDataCollection)
for xsDataIntegrationSubWedgeResult in xsDataIntegrationSubWedgeResultList:
xsDataInputStrategy.addBestFileContentHKL(xsDataIntegrationSubWedgeResult.getBestfileHKL())
xsDataInputStrategy.setDiffractionPlan(self.xsDataDiffractionPlan)
self.edPluginControlStrategy.connectSUCCESS(self.doSuccessStrategy)
self.edPluginControlStrategy.connectFAILURE(self.doFailureStrategy)
self.edPluginControlStrategy.setDataInput(xsDataInputStrategy)
self.executePluginSynchronous(self.edPluginControlStrategy)
def parseParameterFiles(self, _strPath):
"""
parses Configuration file
"""
self.DEBUG("EDPluginControlID11v1_0.parseParameterFiles")
self.__dictID11 = {}
dictSub = {
"${TEST_DATA_IMAGES_HOME}": EDUtilsTest.getTestsDataImagesHome()
}
for linefile in EDUtilsFile.readFileAndParseVariables(
_strPath, dictSub).split("\n"):
strLineData = linefile.strip()
#discard comment lines
if not strLineData.startswith('#'):
# discard end line carriage return
splited = strLineData.split("=", 1)
if len(splited) == 2:
self.__dictID11[splited[0].strip()] = splited[1].strip()
return self.__dictID11
def parseGnomOutputFile(self):
logFile = EDUtilsFile.readFile(
os.path.join(self.getWorkingDirectory(), "gnom.out"))
logLines = logFile.splitlines()
xsRadiusOfGyration = self.parseRadiusOfGyration(logLines[-1])
#xsRadiusOfCrossSection = parseCrossSection(logFile)
for idx, line in enumerate(logLines):
if (line.find("Total estimate") != -1):
xsFitQuality = self.parseFitQuality(line)
if (line.find("I REG") != -1):
idx_start = idx + 2
if (line.find("Distance distribution") != -1):
idx_stop = idx - 1
if (line.find("P(R)") != -1):
idx_pr_start = idx + 2
if (line.find("Reciprocal space:") != -1):
idx_pr_stop = idx - 1
xsScatteringFitQ = []
xsScatteringFitValues = []
self.parseScatteringFitData(idx_start, idx_stop, logLines,
xsScatteringFitQ, xsScatteringFitValues)
xsDistributionR = []
xsDistributionPr = []
xsDistributionErr = []
self.parseDistributionData(idx_pr_start, idx_pr_stop, logLines, \
xsDistributionR, xsDistributionPr, xsDistributionErr)
xsDataResult = XSDataResultGnom()
xsDataResult.setFitQuality(xsFitQuality)
xsDataResult.setRadiusOfGyration(xsRadiusOfGyration)
#xsDataResult.setRadiusOfCrossSection(xsRadiusOfCrossSection)
xsDataResult.setScatteringFitQ(xsScatteringFitQ)
xsDataResult.setScatteringFitValues(xsScatteringFitValues)
xsDataResult.setDistributionR(xsDistributionR)
xsDataResult.setDistributionPr(xsDistributionPr)
xsDataResult.setDistributionErr(xsDistributionErr)
return xsDataResult
def parseOutput(self, _strFileName):
"""
This method parses the output of background3D
"""
xsDataResultBackground3D = XSDataResultBackground3D()
strOutput = EDUtilsFile.readFile(_strFileName)
# Skip the four first lines
listOutput = strOutput.split("\n")[4:]
for strLine in listOutput:
xsDataImageBackground3D = XSDataImageBackground3D()
# Remove empty strings ""
listLine = list(filter(None, strLine.split(" ")))
if listLine != []:
xsDataImageBackground3D.number = XSDataInteger(listLine[0])
if listLine[1].startswith("-"):
xsDataImageBackground3D.b_coef = self.parseDouble(
listLine[4])
xsDataImageBackground3D.b_cryst = self.parseDouble(
listLine[5])
xsDataImageBackground3D.estimate = self.parseDouble(
listLine[6])
else:
xsDataImageBackground3D.scale = self.parseDouble(
listLine[1])
xsDataImageBackground3D.bfactor = self.parseDouble(
listLine[2])
xsDataImageBackground3D.resolution = self.parseDouble(
listLine[3])
xsDataImageBackground3D.correlation = self.parseDouble(
listLine[4])
xsDataImageBackground3D.rfactor = self.parseDouble(
listLine[5])
xsDataImageBackground3D.b_coef = self.parseDouble(
listLine[6])
xsDataImageBackground3D.b_cryst = self.parseDouble(
listLine[7])
xsDataImageBackground3D.estimate = self.parseDouble(
listLine[8])
xsDataResultBackground3D.addImageBackground(
xsDataImageBackground3D)
return xsDataResultBackground3D
def determineImageType(self, _strImagePath):
"""
This method determines the type of an image, i.e. ADSC, MAR CCD etc.
"""
strImageType = None
bUnknownImageType = False
self.DEBUG("EDPluginControlReadImageHeaderv10.determineImageType")
# First look at the image extension, then try to distinguish between MARCCD and ADSC based on header information
strImageSuffix = EDUtilsFile.getFileExtension(_strImagePath)
if strImageSuffix in self.dictSuffixToImageType.keys():
# find out image type depending on the content of the respective image header
if self.isMarccdImageFormat(_strImagePath):
strImageType = self.strMARCCD
elif self.isAdscImageFormat(_strImagePath):
strImageType = self.strADSC
elif self.isPilatus2MImageFormat(_strImagePath):
strImageType = self.strPilatus2M
elif self.isPilatus6MImageFormat(_strImagePath):
strImageType = self.strPilatus6M
elif self.isEiger4MImageFormat(_strImagePath):
strImageType = self.strEiger4M
elif self.isEiger9MImageFormat(_strImagePath):
strImageType = self.strEiger9M
elif self.isEiger16MImageFormat(_strImagePath):
strImageType = self.strEiger16M
elif self.isEiger2_16MImageFormat(_strImagePath):
strImageType = self.strEiger2_16M
else:
bUnknownImageType = True
else:
bUnknownImageType = True
if bUnknownImageType:
strErrorMessage = "EDPluginControlReadImageHeaderv10.determineImageType: Unknown image type for image %s " % _strImagePath
self.error(strErrorMessage)
self.addErrorMessage(strErrorMessage)
self.setFailure()
else:
self.DEBUG("EDPluginControlReadImageHeaderv10.determineImageType: file: " + _strImagePath + \
", type: " + strImageType)
return strImageType
def testTableListItem(self):
xsItem = None
xsItem2 = None
strDnaTablesXML = EDUtilsFile.readFile(self.__strFilePath)
xsDataDnaTables = dna_tables.parseString(strDnaTablesXML)
xsTable = EDUtilsTable.getTableFromTables(xsDataDnaTables, "input")
xsLists = EDUtilsTable.getListsFromTable(xsTable, "select_task")
for xsList in xsLists:
xsItem = EDUtilsTable.getItemFromList(xsList, "task")
xsItem2 = EDUtilsTable.getItemFromList(xsList, "tata")
EDAssert.equal("optimize", xsItem.getValueOf_())
EDAssert.equal(None, xsItem2)
xsLists = EDUtilsTable.getListsFromTable(xsTable, "select_tata")
EDAssert.equal([], xsLists)
xsTable = EDUtilsTable.getTableFromTables(xsDataDnaTables, "toto")
EDAssert.equal(None, xsTable)
EDVerbose.DEBUG("Test done...")
def parseOutput(self, _strFileName):
"""
This method parses the output of dozor
"""
xsDataResultDozor = XSDataResultDozor()
strOutput = EDUtilsFile.readFile(_strFileName)
# Skip the four first lines
self.DEBUG('***** Dozor raw output ***** ')
self.DEBUG(strOutput)
listOutput = strOutput.split("\n")[14:]
for strLine in listOutput:
xsDataImageDozor = XSDataImageDozor()
# Remove "|"
listLine = shlex.split(strLine.replace("|", " "))
#print listLine
if listLine != [] and not listLine[0].startswith("-"):
xsDataImageDozor.number = XSDataInteger(listLine[0])
# Fix for xaloc-ALBA
#if listLine[5].startswith("-") or len(listLine) < 11:
if len(listLine) < 11:
xsDataImageDozor.spots_num_of = XSDataInteger(listLine[1])
xsDataImageDozor.spots_int_aver = self.parseDouble(listLine[2])
try:
xsDataImageDozor.spots_resolution = self.parseDouble(listLine[3])
except IndexError as e:
xsDataImageDozor.spots_resolution = XSDataDouble(0.0)
xsDataImageDozor.score = XSDataDouble(0.0) #self.parseDouble(listLine[4])
else:
xsDataImageDozor.spots_num_of = XSDataInteger(listLine[1])
xsDataImageDozor.spots_int_aver = self.parseDouble(listLine[2])
xsDataImageDozor.spots_resolution = self.parseDouble(listLine[3])
xsDataImageDozor.powder_wilson_scale = self.parseDouble(listLine[4])
xsDataImageDozor.powder_wilson_bfactor = self.parseDouble(listLine[5])
xsDataImageDozor.powder_wilson_resolution = self.parseDouble(listLine[6])
xsDataImageDozor.powder_wilson_correlation = self.parseDouble(listLine[7])
xsDataImageDozor.powder_wilson_rfactor = self.parseDouble(listLine[8])
xsDataImageDozor.score = self.parseDouble(listLine[9])
# print xsDataImageDozor.marshal()
xsDataResultDozor.addImageDozor(xsDataImageDozor)
return xsDataResultDozor
