def getMOSFLMIntegrationStatistics(self, _xsDataList):
"""
This method creates a new XSDataMOSFLMIntegrationStatistics object and populates it with
values (averaged intensity, sigma, average I over sigma and number of reflections)
from the _xsDataList object.
"""
xsDataMOSFLMIntegrationStatistics = XSDataMOSFLMIntegrationStatistics()
strAverageIntensity = EDUtilsTable.getItemFromList(_xsDataList,
"i").getValueOf_()
xsDataMOSFLMIntegrationStatistics.setAverageIntensity(
XSDataFloat(float(strAverageIntensity)))
strAverageSigma = EDUtilsTable.getItemFromList(_xsDataList,
"sig").getValueOf_()
xsDataMOSFLMIntegrationStatistics.setAverageSigma(
XSDataFloat(float(strAverageSigma)))
strAverageIOverSigma = EDUtilsTable.getItemFromList(
_xsDataList, "i_sig").getValueOf_()
xsDataMOSFLMIntegrationStatistics.setAverageIOverSigma(
XSDataFloat(float(strAverageIOverSigma)))
strNumberOfReflections = EDUtilsTable.getItemFromList(
_xsDataList, "count").getValueOf_()
xsDataMOSFLMIntegrationStatistics.setNumberOfReflections(
XSDataInteger(int(strNumberOfReflections)))
return xsDataMOSFLMIntegrationStatistics
def testUpdateChemicalCompositionWithNativeSulfurAtom(self):
from XSDataCommon import XSDataAngle
from XSDataCommon import XSDataString
from XSDataCommon import XSDataInteger
from XSDataCommon import XSDataString
from XSDataCommon import XSDataFloat
from XSDataMXv1 import XSDataStructure
from XSDataMXv1 import XSDataChain
from XSDataMXv1 import XSDataAtom
from XSDataMXv1 import XSDataLigand
from XSDataMXv1 import XSDataSampleCrystalMM
from XSDataMXv1 import XSDataChemicalCompositionMM
from XSDataMXv1 import XSDataAtomicComposition
from XSDataMXv1 import XSDataSolvent
from XSDataMXv1 import XSDataCell
from XSDataMXv1 import XSDataSpaceGroup
edPluginStrategy = self.createPlugin()
xsPluginItemGood01 = self.getPluginConfiguration(os.path.join(self.strDataPath, "XSConfiguration_ESRF.xml"))
edPluginStrategy.setConfiguration(xsPluginItemGood01)
edPluginStrategy.configure()
xsDataStructure = XSDataStructure()
xsDataComposition = XSDataChemicalCompositionMM()
xsDataChain = XSDataChain()
xsDataChain.setType(XSDataString("protein"))
xsDataChain.setNumberOfCopies(XSDataFloat(2))
xsDataChain.setNumberOfMonomers(XSDataFloat(60))
xsDataStructure.addChain(xsDataChain)
xsDataComposition.setStructure(xsDataStructure)
updatedChemicalComposition = edPluginStrategy.updateChemicalComposition(xsDataComposition)
EDAssert.equal(3, updatedChemicalComposition.getStructure().getChain()[0].getHeavyAtoms().getAtom()[0].getNumberOf().getValue())
EDAssert.equal("S", updatedChemicalComposition.getStructure().getChain()[0].getHeavyAtoms().getAtom()[0].getSymbol().getValue())
xsDataStructure = XSDataStructure()
xsDataComposition = XSDataChemicalCompositionMM()
xsDataChain = XSDataChain()
xsDataChain.setType(XSDataString("protein"))
xsDataChain.setNumberOfCopies(XSDataFloat(2))
xsDataChain.setNumberOfMonomers(XSDataFloat(60))
xsDataAtom1 = XSDataAtom()
xsDataAtom1.setSymbol(XSDataString("Se"))
xsDataAtom1.setNumberOf(XSDataFloat(4))
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtomicComposition.addAtom(xsDataAtom1)
xsDataChain.setHeavyAtoms(xsDataAtomicComposition)
xsDataStructure.addChain(xsDataChain)
xsDataComposition.setStructure(xsDataStructure)
updatedChemicalComposition = edPluginStrategy.updateChemicalComposition(xsDataComposition)
heavyAtoms = updatedChemicalComposition.getStructure().getChain()[0].getHeavyAtoms().getAtom()
for heavyAtom in heavyAtoms:
EDVerbose.unitTest(heavyAtom.getSymbol().getValue() + " : " + str(heavyAtom.getNumberOf().getValue()))
if(heavyAtom.getSymbol().getValue() == "S"):
EDAssert.equal(3, heavyAtom.getNumberOf().getValue())
def _extract_completeness_entries(lines, output):
for line in lines:
if line.find('total') != -1:
# special case for the last table line which contains the
# totals
infos = [
float(x.replace('%', '').replace('*', ''))
for x in line.split()[1:]
]
output.total_completeness = XSDataXdsCompletenessEntry()
output.total_completeness.outer_complete = XSDataFloat(infos[3])
output.total_completeness.outer_rfactor = XSDataFloat(infos[4])
output.total_completeness.outer_isig = XSDataFloat(infos[7])
output.total_completeness.half_dataset_correlation = XSDataFloat(
infos[10])
else:
# regular line, do not strip the first elem and bump the
# indices by 1
infos = [
float(x.replace('%', '').replace('*', ''))
for x in line.split()
]
res = XSDataXdsCompletenessEntry()
res.outer_res = XSDataFloat(infos[0])
res.outer_complete = XSDataFloat(infos[4])
res.outer_rfactor = XSDataFloat(infos[5])
res.outer_isig = XSDataFloat(infos[8])
res.half_dataset_correlation = XSDataFloat(infos[10])
output.completeness_entries.append(res)
def getDefaultChemicalComposition(self, _xsDataSample, _inumOperators):
"""
"""
xsDataCell = _xsDataSample.getCrystal().getCell()
a = xsDataCell.getLength_a().getValue()
b = xsDataCell.getLength_b().getValue()
c = xsDataCell.getLength_c().getValue()
alpha = math.radians(xsDataCell.getAngle_alpha().getValue())
beta = math.radians(xsDataCell.getAngle_beta().getValue())
gamma = math.radians(xsDataCell.getAngle_gamma().getValue())
fUnitCellVolume = a * b * c * (
math.sqrt(1 - math.cos(alpha) * math.cos(alpha) - math.cos(beta) *
math.cos(beta) - math.cos(gamma) * math.cos(gamma) +
2 * math.cos(alpha) * math.cos(beta) * math.cos(gamma)))
fPolymerVolume = fUnitCellVolume * (
1 - self.__fAverageCrystalSolventContent)
fNumberOfMonomersPerUnitCell = fPolymerVolume / self.__fAverageAminoAcidVolume
fNumberOfMonomersPerAsymmetricUnit = fNumberOfMonomersPerUnitCell / _inumOperators
iNumberOfSulfurAtom = int(
round(fNumberOfMonomersPerAsymmetricUnit *
self.__fAverageSulfurContentPerAminoacid))
xsDataAtom = XSDataAtom()
xsDataAtom.setSymbol(XSDataString("S"))
xsDataAtom.setNumberOf(XSDataFloat(iNumberOfSulfurAtom))
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtomicComposition.addAtom(xsDataAtom)
xsDataChain = XSDataChain()
xsDataChain.setType(XSDataString("protein"))
xsDataChain.setNumberOfMonomers(
XSDataFloat(round(fNumberOfMonomersPerAsymmetricUnit)))
xsDataChain.setNumberOfCopies(XSDataFloat(1))
xsDataChain.setHeavyAtoms(xsDataAtomicComposition)
xsDataStructure = XSDataStructure()
xsDataStructure.addChain(xsDataChain)
xsDataStructure.setNumberOfCopiesInAsymmetricUnit(XSDataFloat(1))
xsDataAtomSolvent = XSDataAtom()
xsDataAtomSolvent.setSymbol(XSDataString("S"))
xsDataAtomSolvent.setConcentration(
XSDataFloat(self.__fAverageSulfurConcentration))
xsDataAtomicCompositionSolvent = XSDataAtomicComposition()
xsDataAtomicCompositionSolvent.addAtom(xsDataAtomSolvent)
xsDataSolvent = XSDataSolvent()
xsDataSolvent.setAtoms(xsDataAtomicCompositionSolvent)
xsDataChemicalCompositionMM = XSDataChemicalCompositionMM()
xsDataChemicalCompositionMM.setSolvent(xsDataSolvent)
xsDataChemicalCompositionMM.setStructure(xsDataStructure)
return xsDataChemicalCompositionMM
def readIdxrefLp(self, _pathToIdxrefLp, _xsDataResultXDSIndexing=None):
self.DEBUG("EDPluginXDSIndexingv1_0.readIdxrefLp")
if _xsDataResultXDSIndexing is None:
xsDataResultXDSIndexing = XSDataResultXDSIndexing()
else:
xsDataResultXDSIndexing = _xsDataResultXDSIndexing
if os.path.exists(_pathToIdxrefLp):
xsDataResultXDSIndexing.pathToLogFile = XSDataFile(XSDataString(_pathToIdxrefLp))
with open(_pathToIdxrefLp) as f:
listLines = f.readlines()
indexLine = 0
doParseParameters = False
doParseLattice = False
while (indexLine < len(listLines)):
if "DIFFRACTION PARAMETERS USED AT START OF INTEGRATION" in listLines[indexLine]:
doParseParameters = True
doParseLattice = False
elif "DETERMINATION OF LATTICE CHARACTER AND BRAVAIS LATTICE" in listLines[indexLine]:
doParseParameters = False
doParseLattice = True
if doParseParameters:
if "MOSAICITY" in listLines[indexLine]:
mosaicity = float(listLines[indexLine].split()[-1])
xsDataResultXDSIndexing.mosaicity = XSDataAngle(mosaicity)
elif "DETECTOR COORDINATES (PIXELS) OF DIRECT BEAM" in listLines[indexLine]:
xBeam = float(listLines[indexLine].split()[-2])
yBeam = float(listLines[indexLine].split()[-1])
xsDataResultXDSIndexing.beamCentreX = XSDataFloat(xBeam)
xsDataResultXDSIndexing.beamCentreY = XSDataFloat(yBeam)
elif "CRYSTAL TO DETECTOR DISTANCE" in listLines[indexLine]:
distance = float(listLines[indexLine].split()[-1])
xsDataResultXDSIndexing.distance = XSDataLength(distance)
elif doParseLattice:
if listLines[indexLine].startswith(" * ") and not listLines[indexLine + 1].startswith(" * "):
listLine = listLines[indexLine].split()
xsDataResultXDSIndexing.latticeCharacter = XSDataInteger(int(listLine[1]))
bravaisLattice = listLine[2]
xsDataResultXDSIndexing.bravaisLattice = XSDataString(bravaisLattice)
spaceGroup = EDUtilsSymmetry.getMinimumSymmetrySpaceGroupFromBravaisLattice(bravaisLattice)
xsDataResultXDSIndexing.spaceGroup = XSDataString(spaceGroup)
spaceGroupNumber = EDUtilsSymmetry.getITNumberFromSpaceGroupName(spaceGroup)
xsDataResultXDSIndexing.spaceGroupNumber = XSDataInteger(spaceGroupNumber)
xsDataResultXDSIndexing.qualityOfFit = XSDataFloat(float(listLine[3]))
xsDataXDSCell = XSDataXDSCell()
xsDataXDSCell.length_a = XSDataLength(float(listLine[4]))
xsDataXDSCell.length_b = XSDataLength(float(listLine[5]))
xsDataXDSCell.length_c = XSDataLength(float(listLine[6]))
xsDataXDSCell.angle_alpha = XSDataAngle(float(listLine[7]))
xsDataXDSCell.angle_beta = XSDataAngle(float(listLine[8]))
xsDataXDSCell.angle_gamma = XSDataAngle(float(listLine[9]))
xsDataResultXDSIndexing.unitCell = xsDataXDSCell
indexLine += 1
return xsDataResultXDSIndexing
def createInputCharacterisationFromSubWedges(self):
EDVerbose.DEBUG(
"EDPluginControlInterfacev2_0.createInputCharacterisationFromSubWedges"
)
xsDataResultSubWedgeAssemble = self.edPluginControlSubWedgeAssemble.getDataOutput(
)
self.xsDataInputCharacterisation = XSDataInputCharacterisation()
xsDataCollection = XSDataCollection()
# Default exposure time (for the moment, this value should be
# possible to read from the command line)
xsDataDiffractionPlan = XSDataDiffractionPlan()
if (not xsDataResultSubWedgeAssemble is None):
pyListSubWedge = xsDataResultSubWedgeAssemble.getSubWedge()
xsDataCollection.setSubWedge(pyListSubWedge)
for xsDataSubWedge in pyListSubWedge:
if (self.strComplexity is not None):
xsDataDiffractionPlan.setComplexity(
XSDataString(self.strComplexity))
if (self.fFlux is not None):
xsDataSubWedge.getExperimentalCondition().getBeam(
).setFlux(XSDataFloat(self.fFlux))
if (self.fBeamSize is not None):
xsDataSize = XSDataSize()
xsDataSize.setX(XSDataLength(self.fBeamSize))
xsDataSize.setY(XSDataLength(self.fBeamSize))
xsDataSubWedge.getExperimentalCondition().getBeam(
).setSize(xsDataSize)
if (self.fBeamPosX is not None):
xsDataSubWedge.getExperimentalCondition().getDetector(
).setBeamPositionX(XSDataLength(self.fBeamPosX))
if (self.fBeamPosY is not None):
xsDataSubWedge.getExperimentalCondition().getDetector(
).setBeamPositionY(XSDataLength(self.fBeamPosY))
if (self.fMinExposureTimePerImage is not None):
xsDataSubWedge.getExperimentalCondition().getBeam(
).setMinExposureTimePerImage(
XSDataFloat(self.fMinExposureTimePerImage))
if (self.fTransmission is not None):
xsDataSubWedge.getExperimentalCondition().getBeam(
).setTransmission(XSDataDouble(self.fTransmission))
if (self.strForcedSpaceGroup is not None):
xsDataDiffractionPlan.setForcedSpaceGroup(
XSDataString(self.strForcedSpaceGroup))
xsDataDiffractionPlan.setAnomalousData(
XSDataBoolean(self.bAnomalousData))
xsDataDiffractionPlan.setMaxExposureTimePerDataCollection(
XSDataTime(self.fMaxExposureTimePerDataCollection))
if (self.strStrategyOption is not None):
xsDataDiffractionPlan.setStrategyOption(
XSDataString(self.strStrategyOption))
xsDataCollection.setDiffractionPlan(xsDataDiffractionPlan)
self.xsDataInputCharacterisation.setDataCollection(xsDataCollection)
def strategySummaryItemListToStrategySummary(self,
_xsStrategySummaryItemList):
xsDataStrategySummary = XSDataBestStrategySummary()
pyStrItemAttenuation = EDUtilsTable.getItemFromList(
_xsStrategySummaryItemList, "attenuation")
fAttenuation = float(pyStrItemAttenuation.getValueOf_())
xsDataStrategySummary.setAttenuation(XSDataFloat(fAttenuation))
pyStrItemCompleteness = EDUtilsTable.getItemFromList(
_xsStrategySummaryItemList, "completeness")
# For homegeneity concerns, EDNA data model should store all the completeness value in fraction
# ( DNA table xml file stores the summary strategy completeness in percentage whereas
# the resolution bin completeness are in fraction )
fCompleteness = float(pyStrItemCompleteness.getValueOf_()) / 100
xsDataStrategySummary.setCompleteness(XSDataFloat(fCompleteness))
pyStrItemISigma = EDUtilsTable.getItemFromList(
_xsStrategySummaryItemList, "i_sigma")
fISigma = float(pyStrItemISigma.getValueOf_())
xsDataStrategySummary.setISigma(XSDataFloat(fISigma))
pyStrItemRedundancy = EDUtilsTable.getItemFromList(
_xsStrategySummaryItemList, "redundancy")
fRedundancy = float(pyStrItemRedundancy.getValueOf_())
xsDataStrategySummary.setRedundancy(XSDataFloat(fRedundancy))
pyStrItemResolution = EDUtilsTable.getItemFromList(
_xsStrategySummaryItemList, "resolution")
fResolution = float(pyStrItemResolution.getValueOf_())
xsDataStrategySummary.setResolution(XSDataFloat(fResolution))
pyStrItemResolutionReasoning = EDUtilsTable.getItemFromList(
_xsStrategySummaryItemList, "resolution_reasoning")
strResolutionReasoning = pyStrItemResolutionReasoning.getValueOf_()
xsDataStrategySummary.setResolutionReasoning(
XSDataString(strResolutionReasoning))
pyStrItemTotalDataCollectionTime = EDUtilsTable.getItemFromList(
_xsStrategySummaryItemList, "total_data_collection_time")
fTotalDataCollectionTime = float(
pyStrItemTotalDataCollectionTime.getValueOf_())
xsDataStrategySummary.setTotalDataCollectionTime(
XSDataTime(fTotalDataCollectionTime))
pyStrItemTotalExposureTime = EDUtilsTable.getItemFromList(
_xsStrategySummaryItemList, "total_exposure_time")
fTotalExposureTime = float(pyStrItemTotalExposureTime.getValueOf_())
xsDataStrategySummary.setTotalExposureTime(
XSDataTime(fTotalExposureTime))
return xsDataStrategySummary
def preProcess(self, _edObject=None):
EDPluginControl.preProcess(self)
self.DEBUG("EDPluginControlAutoproc.preProcess")
self.xds_anom = self.loadPlugin('EDPluginExecMinimalXds')
self.xds_noanom = self.loadPlugin('EDPluginExecMinimalXds')
path = os.path.abspath(self.dataInput.previous_run_dir.value)
# create the data inputs now we know the files are here
input_anom = XSDataMinimalXdsIn()
input_anom.input_file = XSDataString(os.path.join(path, 'XDS.INP'))
input_anom.friedels_law = XSDataBoolean(True)
input_anom.job = XSDataString('CORRECT')
input_anom.resolution = self.dataInput.resolution
input_anom.resolution_range = [
XSDataFloat(60), self.dataInput.resolution
]
self.xds_anom.dataInput = input_anom
input_noanom = XSDataMinimalXdsIn()
input_noanom.input_file = XSDataString(os.path.join(path, 'XDS.INP'))
input_noanom.fridels_law = XSDataBoolean(False)
input_noanom.job = XSDataString('CORRECT')
input_noanom.resolution_range = [
XSDataFloat(60), self.dataInput.resolution
]
self.xds_noanom.dataInput = input_noanom
xds_anom_dir = os.path.abspath(self.xds_anom.getWorkingDirectory())
xds_noanom_dir = os.path.abspath(self.xds_noanom.getWorkingDirectory())
# let's make some links!
for f in self._to_link:
os.symlink(f, os.path.join(xds_anom_dir, os.path.basename(f)))
os.symlink(f, os.path.join(xds_noanom_dir, os.path.basename(f)))
# now this is the horrible part, we need to make symlinks to
# the images also. for now we rely on the fact that the links
# in the previous run are most likely the links to the
# images. So we will make the same links and rely on the fact
# that in the input file the path to the images is already
# relative to the CWD
path = os.path.abspath(self.dataInput.previous_run_dir.value)
for f in os.listdir(path):
fullpath = os.path.join(path, f)
if os.path.islink(fullpath):
# symlink the symlink...
os.symlink(fullpath, os.path.join(xds_anom_dir, f))
os.symlink(fullpath, os.path.join(xds_noanom_dir, f))
def preProcess(self, _edObject = None):
EDPluginControl.preProcess(self)
self.DEBUG("EDPluginControlAutoproc.preProcess")
self.xds_anom = self.loadPlugin('EDPluginExecMinimalXds')
self.xds_noanom = self.loadPlugin('EDPluginExecMinimalXds')
path = os.path.abspath(self.dataInput.previous_run_dir.value)
# The MinimalXds plugin takes care of creating determining the
# real images directory and creating a symlink to it so we
# only need to update the NAMED_TEMPLATE_OF_DATA_FILES keyword
# to not be relative anymore. We'll copy it to our own dir
# beforehand to avoid clobbering it
xdsinp = os.path.join(path, 'XDS.INP')
new_xdsinp = os.path.join(self.getWorkingDirectory(), 'XDS.INP')
copyfile(xdsinp, new_xdsinp)
parsed_config = parse_xds_file(new_xdsinp)
file_template = parsed_config['NAME_TEMPLATE_OF_DATA_FRAMES='][0]
parsed_config['NAME_TEMPLATE_OF_DATA_FRAMES='] = os.path.abspath(os.path.join(path, file_template))
dump_xds_file(new_xdsinp, parsed_config)
# create the data inputs now we know the files are here
input_anom = XSDataMinimalXdsIn()
input_anom.input_file = XSDataString(new_xdsinp)
input_anom.friedels_law = XSDataBoolean(True)
input_anom.job = XSDataString('CORRECT')
input_anom.resolution = self.dataInput.resolution
input_anom.resolution_range = [XSDataFloat(60), self.dataInput.resolution]
self.xds_anom.dataInput = input_anom
input_noanom = XSDataMinimalXdsIn()
input_noanom.input_file = XSDataString(new_xdsinp)
input_noanom.friedels_law = XSDataBoolean(False)
input_noanom.job = XSDataString('CORRECT')
input_noanom.resolution_range = [XSDataFloat(60), self.dataInput.resolution]
self.xds_noanom.dataInput = input_noanom
xds_anom_dir = os.path.abspath(self.xds_anom.getWorkingDirectory())
xds_noanom_dir = os.path.abspath(self.xds_noanom.getWorkingDirectory())
# let's make some links!
for f in self._to_link:
os.symlink(f, os.path.join(xds_anom_dir, os.path.basename(f)))
os.symlink(f, os.path.join(xds_noanom_dir, os.path.basename(f)))
def postProcess(self):
# parse the output, the code's not very good looking
# maybe rewrite the parsing without using regexpes
outfile = self.getScriptLogFileName()
best_p = 0
best_sol = None
with open(outfile, 'r') as out:
# have we seen the start of the table we seek yet?
started = False
for line in out:
if not started:
# see if our table is beginning yet
if self.start_re.match(line): started = True
continue
else:
# try parsing the line as a table line
m = self.good_re.match(line)
bad = self.bad_re.match(line)
if m is not None and bad is None:
p = float(m.group(1))
if p > best_p:
best_p = p
best_sol = m.group(2)
# we found what we were looking for
if best_sol is not None:
self.dataOutput = XSDataMatthewsCoeffOut(best_p=XSDataFloat(best_p),
best_sol=XSDataString(best_sol))
def updateChemicalComposition(self, _xsDataChemicalComposition):
"""
"""
xsDataChemicalComposition = _xsDataChemicalComposition
for chain in xsDataChemicalComposition.getStructure().getChain():
if (chain.getType().getValue() == "protein"):
bSulfurExists = False
xsDataAtomicCompositionHeavyAtoms = chain.getHeavyAtoms()
if (xsDataAtomicCompositionHeavyAtoms is None):
xsDataAtomicCompositionHeavyAtoms = XSDataAtomicComposition(
)
else:
for heavyAtom in xsDataAtomicCompositionHeavyAtoms.getAtom(
):
if (heavyAtom.getSymbol().getValue() == "S"
or heavyAtom.getSymbol().getValue() == "s"):
bSulfurExists = True
# all protein chains should contain sulfur atom as a percentage of the number
# of amino acids. Add them if the user did not input them.
if (bSulfurExists == False):
iNumberOfSulfurAtom = int(
round(chain.getNumberOfMonomers().getValue() * 0.05))
xsDataSulfurAtom = XSDataAtom()
xsDataSulfurAtom.setSymbol(XSDataString("S"))
xsDataSulfurAtom.setNumberOf(
XSDataFloat(iNumberOfSulfurAtom))
xsDataAtomicCompositionHeavyAtoms.addAtom(xsDataSulfurAtom)
chain.setHeavyAtoms(xsDataAtomicCompositionHeavyAtoms)
return xsDataChemicalComposition
def fileName2xml(filename):
"""Here we create the XML string to be passed to the EDNA plugin from the input filename
This can / should be modified by the final user
@param filename: full path of the input file
@type filename: python string representing the path
@rtype: XML string
@return: python string
"""
if filename.endswith(".jpg"):
xm = None
else:
upperDir = os.path.dirname(os.path.dirname(filename))
if not os.path.isdir(os.path.join(upperDir, "Thumbnail")):
os.makedirs(os.path.join(upperDir, "Thumbnail"), int("775", 8))
destinationPath = os.path.join(upperDir, "Thumbnail")
xsd = XSDataInputExecThumbnail()
xsdFile = XSDataFile()
xsdFile.setPath(XSDataString(filename))
xsd.setInputImagePath(xsdFile)
xsdPath = XSDataFile()
xsdPath.setPath(XSDataString(destinationPath))
xsd.setOutputPath(xsdPath)
xsd.setLevelsColorize(XSDataBoolean(True))
xsd.setLevelsNormalize(XSDataBoolean(True))
xsd.setLevelsGamma(XSDataFloat(gamma))
xml = xsd.marshal()
return xml
def setPluginInput(self, _edPlugin):
xsDataDiffractionPlan = XSDataDiffractionPlan()
if (not self.__fMaxExposureTimePerDataCollection is None):
xsDataDiffractionPlan.setMaxExposureTimePerDataCollection(XSDataTime(self.__fMaxExposureTimePerDataCollection))
if (not self.__strForcedSpaceGroup is None):
xsDataDiffractionPlan.setForcedSpaceGroup(XSDataString(self.__strForcedSpaceGroup))
if (not self.__bAnomalousData is None):
xsDataDiffractionPlan.setAnomalousData(XSDataBoolean(self.__bAnomalousData))
if (not self.__strStrategyOption is None):
xsDataDiffractionPlan.setStrategyOption(XSDataString(self.__strStrategyOption))
if (not self.__strComplexity is None):
xsDataDiffractionPlan.setComplexity(XSDataString(self.__strComplexity))
_edPlugin.setDataInput(xsDataDiffractionPlan, "diffractionPlan")
if (not self.__listImagePaths is None):
for strImagePath in self.__listImagePaths:
_edPlugin.setDataInput(XSDataString(strImagePath), "imagePaths")
if (not self.__xsDataInputCharacterisation is None):
_edPlugin.setDataInput(self.__xsDataInputCharacterisation, "inputCharacterisation")
if (not self.__fFlux is None):
_edPlugin.setDataInput(XSDataFloat(self.__fFlux), "flux")
if (not self.__fMinExposureTimePerImage is None):
_edPlugin.setDataInput(XSDataFloat(self.__fMinExposureTimePerImage), "minExposureTimePerImage")
if (not self.__fBeamSize is None):
_edPlugin.setDataInput(XSDataFloat(self.__fBeamSize), "beamSize")
if (not self.__bTemplateMode is None):
_edPlugin.setDataInput(XSDataBoolean(self.__bTemplateMode), "templateMode")
if (not self.__strGeneratedTemplateFile is None):
_edPlugin.setDataInput(XSDataString(self.__strGeneratedTemplateFile), "generatedTemplateFile")
if (not self.__strResultsFilePath is None):
_edPlugin.setDataInput(XSDataString(self.__strResultsFilePath), "resultsFilePath")
if (not self.__fBeamPosX is None):
_edPlugin.setDataInput(XSDataFloat(self.__fBeamPosX), "beamPosX")
if (not self.__fBeamPosY is None):
_edPlugin.setDataInput(XSDataFloat(self.__fBeamPosY), "beamPosY")
if (not self.__iDataCollectionId is None):
_edPlugin.setDataInput(XSDataInteger(self.__iDataCollectionId), "dataCollectionId")
if (not self.__strShortComments is None):
_edPlugin.setDataInput(XSDataString(self.__strShortComments), "shortComments")
if (not self.__strComments is None):
_edPlugin.setDataInput(XSDataString(self.__strComments), "comments")
if (not self.__fTransmission is None):
_edPlugin.setDataInput(XSDataDouble(self.__fTransmission), "transmission")
def getMOSFLMIntegrationStatisticsPerResolutionBin(self, _xsDataDnaTables, _strListName, _fMinResolution=None):
"""
This method creates an XSDataMOSFLMIntegrationStatisticsPerResolutionBin object given an XSDataDnaTables object
and a list name, e.g. "bin_1". If _fMinResolution is provided it is used for setting the minimum resolution,
otherwise the min and max resolution are set to the same value provided by the xsDataList object.
"""
xsDataTableProfileFittedFull = EDUtilsTable.getTableFromTables(_xsDataDnaTables, "profile_fitted_full")
xsDataTableProfileFittedPartial = EDUtilsTable.getTableFromTables(_xsDataDnaTables, "profile_fitted_partial")
xsDataTableSummationFull = EDUtilsTable.getTableFromTables(_xsDataDnaTables, "summation_full")
xsDataTableSummationPartial = EDUtilsTable.getTableFromTables(_xsDataDnaTables, "summation_partial")
xsListProfileFittedFull = EDUtilsTable.getListsFromTable(xsDataTableProfileFittedFull, _strListName)[0]
xsListProfileFittedPartial = EDUtilsTable.getListsFromTable(xsDataTableProfileFittedPartial, _strListName)[0]
xsListSummationFull = EDUtilsTable.getListsFromTable(xsDataTableSummationFull, _strListName)[0]
xsListSummationPartial = EDUtilsTable.getListsFromTable(xsDataTableSummationPartial, _strListName)[0]
xsDataMOSFLMIntegrationDataProfileFittedFull = self.getMOSFLMIntegrationStatistics(xsListProfileFittedFull)
xsDataMOSFLMIntegrationDataProfileFittedPartials = self.getMOSFLMIntegrationStatistics(xsListProfileFittedPartial)
xsDataMOSFLMIntegrationSummationFull = self.getMOSFLMIntegrationStatistics(xsListSummationFull)
xsDataMOSFLMIntegrationSummationPartial = self.getMOSFLMIntegrationStatistics(xsListSummationPartial)
xsDataMOSFLMIntegrationStatisticsPerReflectionTypeProfileFitted = XSDataMOSFLMIntegrationStatisticsPerReflectionType()
xsDataMOSFLMIntegrationStatisticsPerReflectionTypeProfileFitted.setFullyRecorded(xsDataMOSFLMIntegrationDataProfileFittedFull)
xsDataMOSFLMIntegrationStatisticsPerReflectionTypeProfileFitted.setPartials(xsDataMOSFLMIntegrationDataProfileFittedPartials)
xsDataMOSFLMIntegrationStatisticsPerReflectionTypeSummation = XSDataMOSFLMIntegrationStatisticsPerReflectionType()
xsDataMOSFLMIntegrationStatisticsPerReflectionTypeSummation.setFullyRecorded(xsDataMOSFLMIntegrationSummationFull)
xsDataMOSFLMIntegrationStatisticsPerReflectionTypeSummation.setPartials(xsDataMOSFLMIntegrationSummationPartial)
xsDataMOSFLMIntegrationStatisticsPerResolutionBin = XSDataMOSFLMIntegrationStatisticsPerResolutionBin()
xsDataMOSFLMIntegrationStatisticsPerResolutionBin.setProfileFitted(xsDataMOSFLMIntegrationStatisticsPerReflectionTypeProfileFitted)
xsDataMOSFLMIntegrationStatisticsPerResolutionBin.setSummation(xsDataMOSFLMIntegrationStatisticsPerReflectionTypeSummation)
strMaxResolution = EDUtilsTable.getItemFromList(xsListProfileFittedFull, "resolution").getValueOf_()
if strMaxResolution != "overall":
xsDataMOSFLMIntegrationStatisticsPerResolutionBin.setMaxResolution(XSDataFloat(float(strMaxResolution)))
if (_fMinResolution is not None):
xsDataMOSFLMIntegrationStatisticsPerResolutionBin.setMinResolution(XSDataFloat(_fMinResolution))
else:
xsDataMOSFLMIntegrationStatisticsPerResolutionBin.setMinResolution(XSDataFloat(float(strMaxResolution)))
return xsDataMOSFLMIntegrationStatisticsPerResolutionBin
def getXSDataBestInput(self, _xsDataBeam, _xsDataSample, _xsDataDetector, _xsDataGoniostat, _xsDataDiffractionPlan,
_oedStrBestFileContentDat, _oedStrBestFileContentPar, _oedListBestFileContentHKL):
xsDataBestInput = XSDataBestInput()
# Sample
xdDataAbsorbedDose = None
xsDataSusceptibility = None
# Could be None if sample has not been set
# It could be not None in case Raddose has calculated an absorbed dose with default sample values
if(_xsDataSample is not None):
xdDataAbsorbedDose = _xsDataSample.getAbsorbedDoseRate()
xsDataSusceptibility = _xsDataSample.getSusceptibility()
# Could be None if Raddose failed to calculate the absorbed dose
if(xdDataAbsorbedDose is not None):
xsDataBestInput.setCrystalAbsorbedDoseRate(_xsDataSample.getAbsorbedDoseRate())
xsDataBestInput.setCrystalSusceptibility(xsDataSusceptibility)
# crystalShape
# Default value is 1 (We assume that Xtal is smaller than beam)
xsDataFloatCrystalShape = _xsDataSample.getShape()
if(xsDataFloatCrystalShape is None):
xsDataBestInput.setCrystalShape(XSDataFloat(1))
else:
xsDataBestInput.setCrystalShape(xsDataFloatCrystalShape)
# Detector
xsDataBestInput.setDetectorType(_xsDataDetector.getType())
# Beam
xsDataBestInput.setBeamExposureTime(_xsDataBeam.getExposureTime())
xsDataBestInput.setBeamMinExposureTime(_xsDataBeam.getMinExposureTimePerImage())
# Goniostat
xsDataBestInput.setGoniostatMaxRotationSpeed(_xsDataGoniostat.getMaxOscillationSpeed())
xsDataBestInput.setGoniostatMinRotationWidth(_xsDataGoniostat.getMinOscillationWidth())
# Diffraction plan
xsDataBestInput.setAimedResolution(_xsDataDiffractionPlan.getAimedResolution())
xsDataBestInput.setAimedRedundancy(_xsDataDiffractionPlan.getAimedMultiplicity())
xsDataBestInput.setAimedCompleteness(_xsDataDiffractionPlan.getAimedCompleteness())
xsDataBestInput.setAimedIOverSigma(_xsDataDiffractionPlan.getAimedIOverSigmaAtHighestResolution())
xsDataBestInput.setBeamMaxExposureTime(_xsDataDiffractionPlan.getMaxExposureTimePerDataCollection())
xsDataBestInput.setComplexity(_xsDataDiffractionPlan.getComplexity())
# Best Files
xsDataBestInput.setBestFileContentDat(_oedStrBestFileContentDat)
xsDataBestInput.setBestFileContentPar(_oedStrBestFileContentPar)
xsDataBestInput.setBestFileContentHKL(_oedListBestFileContentHKL)
return xsDataBestInput
def testSetDataModelInput(self):
# Crystal
from XSDataRaddosev10 import XSDataRaddoseInput
xsDataRaddoseInput = XSDataRaddoseInput()
from XSDataCommon import XSDataString
from XSDataCommon import XSDataFloat
from XSDataCommon import XSDataAngle
from XSDataCommon import XSDataLength
from XSDataCommon import XSDataSize
from XSDataCommon import XSDataInteger
from XSDataRaddosev10 import XSDataCell
from XSDataRaddosev10 import XSDataAtom
from XSDataRaddosev10 import XSDataAtomicComposition
xsDataAtomSulfur = XSDataAtom()
xsDataAtomSulfur.setNumberOf(XSDataFloat(4))
xsDataAtomSulfur.setSymbol(XSDataString("S"))
xsDataAtomSelenium = XSDataAtom()
xsDataAtomSelenium.setNumberOf(XSDataFloat(4))
xsDataAtomSelenium.setSymbol(XSDataString("Se"))
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtomicComposition.addAtom(xsDataAtomSulfur)
xsDataAtomicComposition.addAtom(xsDataAtomSelenium)
xsDataRaddoseInput.setCrystalPATM(xsDataAtomicComposition)
xsDataRaddoseInput.setCrystalNRES(XSDataInteger(295))
xsDataRaddoseInput.setCrystalNMON(XSDataInteger(8))
xsDataCell = XSDataCell(angle_alpha=XSDataAngle(90.0),
angle_beta=XSDataAngle(90.0),
angle_gamma=XSDataAngle(90.0),
length_a=XSDataLength(78.9),
length_b=XSDataLength(95.162),
length_c=XSDataLength(104.087))
xsDataSizeCrystal = XSDataSize(XSDataLength(0.1), XSDataLength(0.1),
XSDataLength(0.1))
xsDataRaddoseInput.setCrystalCell(xsDataCell)
xsDataRaddoseInput.setCrystalSize(xsDataSizeCrystal)
# Beam
from XSDataCommon import XSDataFlux
from XSDataCommon import XSDataWavelength
from XSDataCommon import XSDataTime
xsDataSize = XSDataSize(x=XSDataLength(0.1), y=XSDataLength(0.1))
xsDataRaddoseInput.setBeamSize(xsDataSize)
xsDataRaddoseInput.setBeamFlux(XSDataFlux(1e+12))
xsDataRaddoseInput.setBeamWavelength(XSDataWavelength(2.41))
xsDataRaddoseInput.setBeamExposureTime(XSDataTime(1))
xsDataRaddoseInput.setNumberOfImages(XSDataInteger(1))
xsDataRaddoseInput.exportToFile(self.strObtainedInputFile)
strExpectedInput = self.readAndParseFile(self.strReferenceInputFile)
strObtainedInput = self.readAndParseFile(self.strObtainedInputFile)
xsDataRaddoseInputExpected = XSDataRaddoseInput.parseString(
strExpectedInput)
xsDataRaddoseInputObtained = XSDataRaddoseInput.parseString(
strObtainedInput)
EDAssert.equal(xsDataRaddoseInputExpected.marshal(),
xsDataRaddoseInputObtained.marshal())
def _extract_infos(lines, output):
# extract values into the output obj modified in place
# stuff we want:
tmp_params = [
'CRYSTAL MOSAICITY (DEGREES)',
'DIRECT BEAM COORDINATES (REC. ANGSTROEM)',
'DETECTOR COORDINATES (PIXELS) OF DIRECT BEAM',
'DETECTOR ORIGIN (PIXELS) AT',
'CRYSTAL TO DETECTOR DISTANCE (mm)',
'COORDINATES OF UNIT CELL A-AXIS',
'COORDINATES OF UNIT CELL B-AXIS',
'COORDINATES OF UNIT CELL C-AXIS',
'UNIT_CELL_CONSTANTS=',
]
params = [(item, len(item.split())) for item in tmp_params]
parsed = dict()
for line in lines:
for param, param_len in params:
if line.find(param) != -1:
values = [float(x) for x in line.split()[param_len:]]
parsed[param] = values
# now fill in the data model with the values we got (and stop if
# any of them is missing)
try:
output.crystal_mosaicity = XSDataFloat(
parsed['CRYSTAL MOSAICITY (DEGREES)'][0])
output.direct_beam_coordinates = XSDataVectorDouble()
output.direct_beam_coordinates.v1 = parsed[
'DIRECT BEAM COORDINATES (REC. ANGSTROEM)'][0]
output.direct_beam_coordinates.v2 = parsed[
'DIRECT BEAM COORDINATES (REC. ANGSTROEM)'][1]
output.direct_beam_coordinates.v3 = parsed[
'DIRECT BEAM COORDINATES (REC. ANGSTROEM)'][2]
output.direct_beam_detector_coordinates = XSData2DCoordinates()
output.direct_beam_detector_coordinates.x = XSDataFloat(
parsed['DETECTOR COORDINATES (PIXELS) OF DIRECT BEAM'][0])
output.direct_beam_detector_coordinates.y = XSDataFloat(
parsed['DETECTOR COORDINATES (PIXELS) OF DIRECT BEAM'][1])
output.detector_origin = XSData2DCoordinates()
output.detector_origin.x = XSDataFloat(
parsed['DETECTOR ORIGIN (PIXELS) AT'][0])
output.detector_origin.y = XSDataFloat(
parsed['DETECTOR ORIGIN (PIXELS) AT'][1])
output.crystal_to_detector_distance = XSDataFloat(
parsed['CRYSTAL TO DETECTOR DISTANCE (mm)'][0])
output.coordinates_of_unit_cell_a_axis = XSDataVectorDouble()
output.coordinates_of_unit_cell_a_axis.v1 = parsed[
'COORDINATES OF UNIT CELL A-AXIS'][0]
output.coordinates_of_unit_cell_a_axis.v2 = parsed[
'COORDINATES OF UNIT CELL A-AXIS'][1]
output.coordinates_of_unit_cell_a_axis.v3 = parsed[
'COORDINATES OF UNIT CELL A-AXIS'][2]
output.coordinates_of_unit_cell_b_axis = XSDataVectorDouble()
output.coordinates_of_unit_cell_b_axis.v1 = parsed[
'COORDINATES OF UNIT CELL B-AXIS'][0]
output.coordinates_of_unit_cell_b_axis.v2 = parsed[
'COORDINATES OF UNIT CELL B-AXIS'][1]
output.coordinates_of_unit_cell_b_axis.v3 = parsed[
'COORDINATES OF UNIT CELL B-AXIS'][2]
output.coordinates_of_unit_cell_c_axis = XSDataVectorDouble()
output.coordinates_of_unit_cell_c_axis.v1 = parsed[
'COORDINATES OF UNIT CELL C-AXIS'][0]
output.coordinates_of_unit_cell_c_axis.v2 = parsed[
'COORDINATES OF UNIT CELL C-AXIS'][1]
output.coordinates_of_unit_cell_c_axis.v3 = parsed[
'COORDINATES OF UNIT CELL C-AXIS'][2]
parsed['UNIT_CELL_CONSTANTS='] = [
XSDataFloat(x) for x in parsed['UNIT_CELL_CONSTANTS=']
]
# there may be trailing information after the 6 floats (the
# string "as used by INTEGRATE")
unit_cells = parsed['UNIT_CELL_CONSTANTS='][:6]
output.cell_a, output.cell_b, output.cell_c, \
output.cell_alpha, output.cell_beta, output.cell_gamma = unit_cells
except KeyError, ke:
EDVerbose.ERROR('Some parameters could not be found!')
EDVerbose.DEBUG('Those found were: %s' % parsed)
raise ValueError('Some parameters missing')
def process(self, _edObject=None):
EDPlugin.process(self)
output = XSDataXdsOutput()
# get all the file's contents, find where the info is and then
# use helper functions to retrieve stuff and put it in the
# data model
try:
f = open(self.dataInput.correct_lp.path.value, 'r')
lines = f.readlines()
except IOError:
EDVerbose.ERROR(
'Could not open the specified XDS output file for reading')
self.setFailure()
return
# look for the "big piece of information"
info_begin = None
info_end = None
for lineno, line in enumerate(lines):
if info_begin is None:
if line.find(
'REFINEMENT OF DIFFRACTION PARAMETERS USING ALL IMAGES'
) != -1:
info_begin = lineno
else:
if line.find(
'MEAN INTENSITY AS FUNCTION OF SPINDLE POSITION WITHIN DATA IMAGE'
) != -1:
info_end = lineno
break
if info_begin is None or info_end is None:
EDVerbose.ERROR('could not find the refined parameters')
self.setFailure()
return
_extract_infos(lines[info_begin:info_end], output)
# second pass, look for the interesting table
info_begin = None
info_end = None
started = False
for line_no, line in enumerate(lines):
if line.find(
'REFLECTIONS OF TYPE H,0,0 0,K,0 0,0,L OR EXPECTED TO BE ABSENT (*)'
) != -1:
# the table will start shortly after
started = True
continue
if started:
# look if we are at the table yet
if line.find(
'LIMIT OBSERVED UNIQUE POSSIBLE OF DATA observed expected'
) != -1:
# there's an empty line after the header
info_begin = line_no + 2
if info_begin is not None and line.find('total') != -1:
# we're at the last table line
info_end = line_no
if info_begin is None or info_end is None:
EDVerbose.ERROR('could not find the completeness table')
self.setFailure()
return
_extract_completeness_entries(lines[info_begin:info_end + 1], output)
# now for the last bit: check if we were given a path to the
# gxparm file and if it exists get the space group and unit
# cell constants from it
if self.dataInput.gxparm is not None:
gxparm_path = self.dataInput.gxparm.path.value
if os.path.exists(gxparm_path):
with open(gxparm_path, 'r') as f:
lines = f.readlines()
for line in lines:
# the one we want has 7 floats
chunks = line.split()
if len(chunks) == 7:
output.sg_number = XSDataInteger(int(chunks[0]))
output.unit_cell_constants = [
XSDataFloat(float(x)) for x in chunks[1:]
]
input_file = self.dataInput.correct_lp.path.value
output.xds_run_directory = XSDataString(os.path.dirname(input_file))
self.dataOutput = output
def process(self, _edObject=None):
EDPlugin.process(self)
detector_max_res = self.dataInput.detector_max_res
if detector_max_res is not None:
detector_max_res = detector_max_res.value
completeness_cutoff_param = self.dataInput.completeness_cutoff
if completeness_cutoff_param is None:
completeness_cutoff = 80
else:
completeness_cutoff = completeness_cutoff_param.value
isig_cutoff_param = self.dataInput.isig_cutoff
if isig_cutoff_param is None:
isig_cutoff = 3
else:
isig_cutoff = isig_cutoff_param.value
res_override = self.dataInput.res_override
bins = list()
# for the first iteration
# comment from max's code: "less stringent at low res"
local_completeness_cutoff = 70
# declared but not initialized in the perl code
prev_isig = prev_res = 0
# XXX: if res is still not defined at the end it is set to
# detector_max_res, which we should somehow defined (in the
# data model?) and used as the default value before we start
# the processing
res = detector_max_res
for entry in self.dataInput.completeness_entries:
outer_res = entry.outer_res.value
outer_complete = entry.outer_complete.value
outer_rfactor = entry.outer_rfactor.value
outer_isig = entry.outer_isig.value
if outer_complete < local_completeness_cutoff or outer_isig < isig_cutoff or \
(res_override is not None and outer_res < res_override.value):
if outer_complete < completeness_cutoff:
EDVerbose.DEBUG('incomplete data (%s) in this shell' %
outer_complete)
res = prev_res
else:
res = _calculate_res_from_bins(prev_isig, prev_res,
outer_isig, outer_res,
isig_cutoff)
bins.append(outer_res)
#NOTE: get out of the loop, see the value of `skip` in
#max's code
break
else:
bins.append(outer_res)
prev_res, prev_isig = outer_res, outer_isig
# Now the implementation of what max does when he encouters
# the total values, which are conveniently already parsed in
# our case
if len(bins) < 2:
EDVerbose.DEBUG("No bins with I/sigma greater than %s" %
isig_cutoff)
EDVerbose.DEBUG(
"""something could be wrong, or the completeness could be too low!
bravais lattice/SG could be incorrect or something more insidious like
incorrect parameters in XDS.INP like distance, X beam, Y beam, etc.
Stopping""")
self.setFailure()
return
if res is None:
res = sorted(bins)[0]
if res_override is not None:
res = res_override.value
# remove last bin (see why w/ max)
retbins = [XSDataFloat(x) for x in bins[:-1]]
data_output = XSDataResCutoffResult()
data_output.res = XSDataFloat(res)
data_output.bins = retbins
totals = self.dataInput.total_completeness
data_output.total_complete = totals.outer_complete
data_output.total_rfactor = totals.outer_rfactor
data_output.total_isig = totals.outer_isig
self.dataOutput = data_output
def resolutionBinItemListToResolutionBin(self, _xsResolutionBinItemList):
xsDataResolutionBin = XSDataBestResolutionBin()
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"min_resolution")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setMinResolution(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"max_resolution")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setMaxResolution(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"completeness")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setCompleteness(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"redundancy")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setRedundancy(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"average_intensity")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setAverageIntensity(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"average_error")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setAverageSigma(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"average_i_over_sigma")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setIOverSigma(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"R_factor")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setRFactor(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"Chi**2")
if (pyStrItem is not None):
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setChi2(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(
_xsResolutionBinItemList, "average_i_over_sigma_Chi**2")
if (pyStrItem is not None):
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setIOverSigmaChi(XSDataFloat(fItem))
pyStrItem = EDUtilsTable.getItemFromList(_xsResolutionBinItemList,
"fract_overload")
fItem = float(pyStrItem.getValueOf_())
xsDataResolutionBin.setPercentageOverload(XSDataFloat(fItem))
return xsDataResolutionBin
def buildChildren(self, child_, nodeName_):
if child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'experimentalCondition':
obj_ = XSDataExperimentalCondition()
obj_.build(child_)
self.setExperimentalCondition(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'diffractionPlan':
obj_ = XSDataDiffractionPlan()
obj_.build(child_)
self.setDiffractionPlan(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'sample':
obj_ = XSDataSampleCrystalMM()
obj_.build(child_)
self.setSample(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'imagePath':
obj_ = XSDataFile()
obj_.build(child_)
self.imagePath.append(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'flux':
obj_ = XSDataFloat()
obj_.build(child_)
self.setFlux(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'minExposureTimePerImage':
obj_ = XSDataTime()
obj_.build(child_)
self.setMinExposureTimePerImage(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'beamSize':
obj_ = XSDataLength()
obj_.build(child_)
self.setBeamSize(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'beamSizeX':
obj_ = XSDataLength()
obj_.build(child_)
self.setBeamSizeX(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'beamSizeY':
obj_ = XSDataLength()
obj_.build(child_)
self.setBeamSizeY(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'apertureSize':
obj_ = XSDataLength()
obj_.build(child_)
self.setApertureSize(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'templateMode':
obj_ = XSDataBoolean()
obj_.build(child_)
self.setTemplateMode(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'generatedTemplateFile':
obj_ = XSDataFile()
obj_.build(child_)
self.setGeneratedTemplateFile(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'resultsFilePath':
obj_ = XSDataFile()
obj_.build(child_)
self.setResultsFilePath(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'beamPosX':
obj_ = XSDataFloat()
obj_.build(child_)
self.setBeamPosX(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'beamPosY':
obj_ = XSDataFloat()
obj_.build(child_)
self.setBeamPosY(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'wavelength':
obj_ = XSDataWavelength()
obj_.build(child_)
self.setWavelength(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'transmission':
obj_ = XSDataDouble()
obj_.build(child_)
self.setTransmission(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'dataCollectionId':
obj_ = XSDataInteger()
obj_.build(child_)
self.setDataCollectionId(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'shortComments':
obj_ = XSDataString()
obj_.build(child_)
self.setShortComments(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'comments':
obj_ = XSDataString()
obj_.build(child_)
self.setComments(obj_)
elif child_.nodeType == Node.ELEMENT_NODE and \
nodeName_ == 'inputCharacterisation':
obj_ = XSDataInputCharacterisation()
obj_.build(child_)
self.setInputCharacterisation(obj_)
def testSetDataModelInput(self):
"""
"""
edPluginStrategy = self.createPlugin()
xsPluginItemGood01 = self.getPluginConfiguration(os.path.join(self.strDataPath, "XSConfiguration_ESRF.xml"))
edPluginStrategy.setConfiguration(xsPluginItemGood01)
edPluginStrategy.configure()
from XSDataMXv1 import XSDataStrategyInput
xSDataStrategy = XSDataStrategyInput()
# Beam
from XSDataCommon import XSDataFlux
from XSDataCommon import XSDataWavelength
from XSDataCommon import XSDataSize
from XSDataCommon import XSDataLength
from XSDataCommon import XSDataTime
from XSDataMXv1 import XSDataBeam
from XSDataMXv1 import XSDataExperimentalCondition
xsExperimentalCondition = XSDataExperimentalCondition()
xsBeam = XSDataBeam()
xsBeam.setFlux(XSDataFlux(1e+12))
xsBeam.setWavelength(XSDataWavelength(2.41))
xsBeam.setSize(XSDataSize(x=XSDataLength(0.1), y=XSDataLength(0.1)))
xsBeam.setExposureTime(XSDataTime(1))
xsExperimentalCondition.setBeam(xsBeam)
# Detector and Exposure Time
from XSDataMXv1 import XSDataDetector
from XSDataCommon import XSDataString
from XSDataMXv1 import XSDataGoniostat
xsDataDetector = XSDataDetector()
xsDataDetector.setType(XSDataString("q210-2x"))
xsExperimentalCondition.setDetector(xsDataDetector)
xsDataGoniostat = XSDataGoniostat()
xsDataGoniostat.setRotationAxis(XSDataString("phi"))
xsExperimentalCondition.setGoniostat(xsDataGoniostat)
xSDataStrategy.setExperimentalCondition(xsExperimentalCondition)
# Best Files
bestFileContentDat = EDUtilsFile.readFile(os.path.join(self.strDataPath, "bestfile.dat"))
xSDataStrategy.setBestFileContentDat(XSDataString(bestFileContentDat))
bestFileContentPar = EDUtilsFile.readFile(os.path.join(self.strDataPath, "bestfile.par"))
xSDataStrategy.setBestFileContentPar(XSDataString(bestFileContentPar))
bestFileContentHKL = EDUtilsFile.readFile(os.path.join(self.strDataPath, "bestfile1.hkl"))
listBestFileContentHKL = []
listBestFileContentHKL.append(XSDataString(bestFileContentHKL))
xSDataStrategy.setBestFileContentHKL(listBestFileContentHKL)
# Crystal
from XSDataCommon import XSDataFloat
from XSDataCommon import XSDataAngle
from XSDataCommon import XSDataInteger
from XSDataMXv1 import XSDataCrystal
from XSDataMXv1 import XSDataStructure
from XSDataMXv1 import XSDataChain
from XSDataMXv1 import XSDataAtom
from XSDataMXv1 import XSDataLigand
from XSDataMXv1 import XSDataSampleCrystalMM
from XSDataMXv1 import XSDataChemicalCompositionMM
from XSDataMXv1 import XSDataAtomicComposition
from XSDataMXv1 import XSDataSolvent
from XSDataMXv1 import XSDataCell
from XSDataMXv1 import XSDataSpaceGroup
xsDataSampleCrystalMM = XSDataSampleCrystalMM()
xsDataStructure = XSDataStructure()
xsDataComposition = XSDataChemicalCompositionMM()
xsDataChain = XSDataChain()
xsDataChain.setType(XSDataString("protein"))
xsDataChain.setNumberOfCopies(XSDataFloat(2))
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtom1 = XSDataAtom()
xsDataAtom1.setSymbol(XSDataString("Se"))
xsDataAtom1.setNumberOf(XSDataFloat(4))
xsDataAtomicComposition.addAtom(xsDataAtom1)
xsDataChain.setHeavyAtoms(xsDataAtomicComposition)
xsDataChain.setNumberOfMonomers(XSDataFloat(100))
xsDataStructure.addChain(xsDataChain)
xsDataChain2 = XSDataChain()
xsDataChain2.setType(XSDataString("rna"))
xsDataChain2.setNumberOfCopies(XSDataFloat(1))
xsDataChain2.setNumberOfMonomers(XSDataFloat(60))
xsDataStructure.addChain(xsDataChain2)
xsDataLigand = XSDataLigand()
xsDataLigand.setNumberOfCopies(XSDataFloat(2))
xsDataLigand.setNumberOfLightAtoms(XSDataFloat(42))
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtom2 = XSDataAtom()
xsDataAtom2.setSymbol(XSDataString("Fe"))
xsDataAtom2.setNumberOf(XSDataFloat(1))
xsDataAtomicComposition.addAtom(xsDataAtom2)
xsDataLigand.setHeavyAtoms(xsDataAtomicComposition)
xsDataStructure.addLigand(xsDataLigand)
xsDataStructure.setNumberOfCopiesInAsymmetricUnit(XSDataFloat(0.25))
xsDataSolvent = XSDataSolvent()
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtom3 = XSDataAtom()
xsDataAtom3.setSymbol(XSDataString("Na"))
xsDataAtom3.setConcentration(XSDataFloat(1000))
xsDataAtom4 = XSDataAtom()
xsDataAtom4.setSymbol(XSDataString("Cl"))
xsDataAtom4.setConcentration(XSDataFloat(1000))
xsDataAtomicComposition.addAtom(xsDataAtom3)
xsDataAtomicComposition.addAtom(xsDataAtom4)
xsDataSolvent.setAtoms(xsDataAtomicComposition)
xsDataComposition.setStructure(xsDataStructure)
xsDataComposition.setSolvent(xsDataSolvent)
xsDataSampleCrystalMM.setChemicalComposition(xsDataComposition)
xsDataSampleCrystalMM.setSize(XSDataSize(XSDataLength(0.1), XSDataLength(0.1), XSDataLength(0.1)))
xsDataCrystal = XSDataCrystal()
xsDataCell = XSDataCell(angle_alpha=XSDataAngle(90.0),
angle_beta=XSDataAngle(90.0),
angle_gamma=XSDataAngle(90.0),
length_a=XSDataLength(78.9),
length_b=XSDataLength(95.162),
length_c=XSDataLength(104.087))
xsDataCrystal.setCell(xsDataCell)
xsDataSpaceGroup = XSDataSpaceGroup()
xsDataSpaceGroup.setITNumber(XSDataInteger(16))
xsDataCrystal.setSpaceGroup(xsDataSpaceGroup)
xsDataSampleCrystalMM.setSusceptibility(XSDataFloat(1.5))
xSDataStrategy.setCrystalRefined(xsDataCrystal)
xSDataStrategy.setSample(xsDataSampleCrystalMM)
xSDataStrategy.outputFile(self.strObtainedInputFile)
strExpectedInput = self.readAndParseFile (self.strReferenceInputFile)
strObtainedInput = self.readAndParseFile (self.strObtainedInputFile)
xsDataInputExpected = XSDataStrategyInput.parseString(strExpectedInput)
xsDataInputObtained = XSDataStrategyInput.parseString(strObtainedInput)
EDAssert.equal(xsDataInputExpected.marshal(), xsDataInputObtained.marshal())
from XSDataCommon import XSDataString
from XSDataCommon import XSDataInteger
from XSDataCommon import XSDataFloat
x = XSDataBoolean(True)
print x.value
print x.marshal()
x = XSDataBoolean(False)
print x.value
print x.marshal()
x = XSDataBoolean('true')
print x.value
print x.marshal()
x = XSDataBoolean('False')
print x.value
print x.marshal()
x = XSDataBoolean(0)
print x.value
print x.marshal()
x = XSDataBoolean(1)
print x.value
print x.marshal()
x = XSDataBoolean(2)
print x.value
print x.marshal()
y = XSDataFloat('this is not a float')
print y.value
print y.marshal()
z = XSDataInteger('this is not an integer')
print z.value
print z.marshal()
def testSetDataModelInput(self):
from XSDataCCP4iv1_1 import XSDataInputCCP4i
xsDataInputCCP4i = XSDataInputCCP4i()
# Beam
from XSDataCommon import XSDataFlux
from XSDataCommon import XSDataSize
from XSDataCommon import XSDataLength
from XSDataCommon import XSDataFloat
from XSDataMXv1 import XSDataBeam
from XSDataMXv1 import XSDataExperimentalCondition
xsExperimentalCondition = XSDataExperimentalCondition()
xsBeam = XSDataBeam()
xsBeam.setFlux(XSDataFlux(1e+12))
xsBeam.setSize(XSDataSize(XSDataLength(0.1), XSDataLength(0.1)))
xsBeam.setMinExposureTimePerImage(XSDataFloat(0.1))
xsExperimentalCondition.setBeam(xsBeam)
# Goniostat
from XSDataCommon import XSDataSpeed
from XSDataCommon import XSDataAngle
from XSDataMXv1 import XSDataGoniostat
xsDataGoniostat = XSDataGoniostat()
xsDataGoniostat.setMaxOscillationSpeed(XSDataSpeed(0.2))
xsDataGoniostat.setMinOscillationWidth(XSDataAngle(0.1))
xsExperimentalCondition.setGoniostat(xsDataGoniostat)
xsDataInputCCP4i.setExperimentalCondition(xsExperimentalCondition)
# Sample
from XSDataCommon import XSDataString
from XSDataCommon import XSDataFloat
from XSDataCommon import XSDataString
from XSDataMXv1 import XSDataStructure
from XSDataMXv1 import XSDataChain
from XSDataMXv1 import XSDataAtom
from XSDataMXv1 import XSDataLigand
from XSDataMXv1 import XSDataSampleCrystalMM
from XSDataMXv1 import XSDataChemicalCompositionMM
from XSDataMXv1 import XSDataAtomicComposition
from XSDataMXv1 import XSDataSolvent
xsDataSampleCrystalMM = XSDataSampleCrystalMM()
xsDataStructure = XSDataStructure()
xsDataComposition = XSDataChemicalCompositionMM()
xsDataChain = XSDataChain()
xsDataChain.setType(XSDataString("protein"))
xsDataChain.setNumberOfCopies(XSDataFloat(2))
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtom1 = XSDataAtom()
xsDataAtom1.setSymbol(XSDataString("Se"))
xsDataAtom1.setNumberOf(XSDataFloat(4))
xsDataAtomicComposition.addAtom(xsDataAtom1)
xsDataChain.setHeavyAtoms(xsDataAtomicComposition)
xsDataChain.setNumberOfMonomers(XSDataFloat(100))
xsDataStructure.addChain(xsDataChain)
xsDataChain2 = XSDataChain()
xsDataChain2.setType(XSDataString("rna"))
xsDataChain2.setNumberOfCopies(XSDataFloat(1))
xsDataChain2.setNumberOfMonomers(XSDataFloat(60))
xsDataStructure.addChain(xsDataChain2)
xsDataLigand = XSDataLigand()
xsDataLigand.setNumberOfCopies(XSDataFloat(2))
xsDataLigand.setNumberOfLightAtoms(XSDataFloat(42))
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtom2 = XSDataAtom()
xsDataAtom2.setSymbol(XSDataString("Fe"))
xsDataAtom2.setNumberOf(XSDataFloat(1))
xsDataAtomicComposition.addAtom(xsDataAtom2)
xsDataLigand.setHeavyAtoms(xsDataAtomicComposition)
xsDataStructure.addLigand(xsDataLigand)
xsDataStructure.setNumberOfCopiesInAsymmetricUnit(XSDataFloat(0.25))
xsDataSolvent = XSDataSolvent()
xsDataAtomicComposition = XSDataAtomicComposition()
xsDataAtom3 = XSDataAtom()
xsDataAtom3.setSymbol(XSDataString("Na"))
xsDataAtom3.setConcentration(XSDataFloat(1000))
xsDataAtom4 = XSDataAtom()
xsDataAtom4.setSymbol(XSDataString("Cl"))
xsDataAtom4.setConcentration(XSDataFloat(1000))
xsDataAtomicComposition.addAtom(xsDataAtom3)
xsDataAtomicComposition.addAtom(xsDataAtom4)
xsDataSolvent.setAtoms(xsDataAtomicComposition)
xsDataComposition.setStructure(xsDataStructure)
xsDataComposition.setSolvent(xsDataSolvent)
xsDataSampleCrystalMM.setChemicalComposition(xsDataComposition)
xsDataSampleCrystalMM.setSize(XSDataSize(XSDataLength(0.2), XSDataLength(0.2), XSDataLength(0.2)))
xsDataSampleCrystalMM.setSusceptibility(XSDataFloat(1.5))
xsDataSampleCrystalMM.setShape(XSDataFloat(2))
xsDataInputCCP4i.setSample(xsDataSampleCrystalMM)
from XSDataMXv1 import XSDataDiffractionPlan
xsDataDiffractionPlan = XSDataDiffractionPlan()
xsDataDiffractionPlan.setAimedCompleteness(XSDataFloat(95.5))
xsDataDiffractionPlan.setAimedIOverSigmaAtHighestResolution(XSDataFloat(2.5))
xsDataDiffractionPlan.setAimedMultiplicity(XSDataFloat(95.5))
xsDataDiffractionPlan.setAimedResolution(XSDataFloat(3))
xsDataDiffractionPlan.setComplexity(XSDataString("full"))
xsDataDiffractionPlan.setForcedSpaceGroup(XSDataString("P222"))
xsDataDiffractionPlan.setMaxExposureTimePerDataCollection(XSDataFloat(10000))
xsDataInputCCP4i.setDiffractionPlan(xsDataDiffractionPlan)
from XSDataCommon import XSDataFile
listInputDataFile = []
xsDataFile = XSDataFile(XSDataString(self.strXSDataGenerateTemplateFile))
listInputDataFile.append(xsDataFile)
xsDataInputCCP4i.setDataFile(listInputDataFile)
0].outer_rfactor.value
self.custom_stats[
'outer_i_over_sigma'] = xdsresult.completeness_entries[
-1].outer_isig.value
self.custom_stats['outer_r_value'] = xdsresult.completeness_entries[
-1].outer_rfactor.value
res_cutoff_in = XSDataResCutoff()
res_cutoff_in.xds_res = xdsresult
res_cutoff_in.completeness_entries = xdsresult.completeness_entries
res_cutoff_in.detector_max_res = self.dataInput.detector_max_res
#XXX: remove from the data model as it is just pass-through?
res_cutoff_in.total_completeness = xdsresult.total_completeness
res_cutoff_in.completeness_cutoff = self.dataInput.completeness_cutoff
res_cutoff_in.isig_cutoff = XSDataFloat(1.0)
#res_cutoff_in.isig_cutoff = self.dataInput.isig_cutoff
res_cutoff_in.r_value_cutoff = self.dataInput.r_value_cutoff
res_cutoff_in.cc_half_cutoff = self.dataInput.cc_half_cutoff
self.first_res_cutoff.dataInput = res_cutoff_in
self.first_res_cutoff.executeSynchronous()
self.stats['first_res_cutoff'] = time.time() - t0
if self.first_res_cutoff.isFailure():
EDVerbose.ERROR("res cutoff failed")
log_to_ispyb(
[self.integration_id_noanom, self.integration_id_anom],
'Indexing', 'Failed', 'res cutoff failed in {0}s'.format(
self.stats['first_res_cutoff']))
self.setFailure()
def createDataMOSFLMOutputIndexing(self):
self.DEBUG("EDPluginMOSFLMIndexingv10.createDataMOSFLMOutputIndexing")
xsDataMOSFLMOutputIndexing = XSDataMOSFLMOutputIndexing()
# Read Newmat file
xsDataMOSFLMNewmat = self.getDataMOSFLMNewmat()
if (xsDataMOSFLMNewmat is None):
strError = "MOSFLM indexing error : No solution was obtained!"
self.ERROR(strError)
self.setFailure()
else:
xsDataMOSFLMOutputIndexing.setRefinedNewmat(xsDataMOSFLMNewmat)
# Then read the XML file
strDnaTablesXML = self.readProcessFile(self.getScriptBaseName() +
"_dnaTables.xml")
xsDataDnaTables = dna_tables.parseString(strDnaTablesXML)
listXSTableMosaicityEstimation = EDUtilsTable.getTableListFromTables(
xsDataDnaTables, "mosaicity_estimation")
dMosaicityValueSum = 0.0
nValues = 0
for xsTableMosaicityEstimation in listXSTableMosaicityEstimation:
for xsListMosaicity in EDUtilsTable.getListsFromTable(
xsTableMosaicityEstimation, "mosaicity"):
dMosaicityValue = float(
EDUtilsTable.getItemFromList(xsListMosaicity,
"value").getValueOf_())
dMosaicityValueSum += dMosaicityValue
nValues += 1
xsDataFloatMosaicityEstimation = XSDataFloat()
xsDataFloatMosaicityEstimation.setValue(dMosaicityValueSum /
nValues)
xsDataMOSFLMOutputIndexing.setMosaicityEstimation(
xsDataFloatMosaicityEstimation)
xsTableRefinement = EDUtilsTable.getTableFromTables(
xsDataDnaTables, "refinement")
if (xsTableRefinement is None):
strError = "MOSFLM indexing error : No solution was refined!"
self.ERROR(strError)
self.setFailure()
else:
xsListDeviations = EDUtilsTable.getListsFromTable(
xsTableRefinement, "deviations")[0]
dDeviationAngular = float(
EDUtilsTable.getItemFromList(xsListDeviations,
"angular").getValueOf_())
dDeviationPositional = float(
EDUtilsTable.getItemFromList(xsListDeviations,
"positional").getValueOf_())
xsDataMOSFLMOutputIndexing.setDeviationAngular(
XSDataAngle(dDeviationAngular))
xsDataMOSFLMOutputIndexing.setDeviationPositional(
XSDataLength(dDeviationPositional))
xsListResults = EDUtilsTable.getListsFromTable(
xsTableRefinement, "results")[0]
dDetectorDistance = float(
EDUtilsTable.getItemFromList(
xsListResults, "detector_distance").getValueOf_())
xsDataMOSFLMOutputIndexing.setRefinedDistance(
XSDataLength(dDetectorDistance))
xsListParameters = EDUtilsTable.getListsFromTable(
xsTableRefinement, "parameters")[0]
iSpotsUsed = int(
EDUtilsTable.getItemFromList(xsListParameters,
"used").getValueOf_())
iSpotsTotal = int(
EDUtilsTable.getItemFromList(xsListParameters,
"out_of").getValueOf_())
xsDataMOSFLMOutputIndexing.setSpotsUsed(
XSDataInteger(iSpotsUsed))
xsDataMOSFLMOutputIndexing.setSpotsTotal(
XSDataInteger(iSpotsTotal))
xsTableSolutionRefinement = EDUtilsTable.getTableFromTables(
xsDataDnaTables, "solution_refinement")
xsListParameters = EDUtilsTable.getListsFromTable(
xsTableSolutionRefinement, "selection")[0]
iSelectedSolutionNumber = int(
EDUtilsTable.getItemFromList(xsListParameters,
"number").getValueOf_())
xsDataMOSFLMOutputIndexing.setSelectedSolutionNumber(
XSDataInteger(iSelectedSolutionNumber))
strSelectedSolutionSpaceGroup = (EDUtilsTable.getItemFromList(
xsListParameters, "spacegroup").getValueOf_())
xsDataMOSFLMOutputIndexing.setSelectedSolutionSpaceGroup(
XSDataString(strSelectedSolutionSpaceGroup))
iSelectedSolutionSpaceGroupNumber = int(
EDUtilsTable.getItemFromList(
xsListParameters, "spacegroup_number").getValueOf_())
xsDataMOSFLMOutputIndexing.setSelectedSolutionSpaceGroupNumber(
XSDataInteger(iSelectedSolutionSpaceGroupNumber))
xsTableAutoIndexSolutions = EDUtilsTable.getTableFromTables(
xsDataDnaTables, "autoindex_solutions")
xsListsSolution = xsTableAutoIndexSolutions.getList()
for xsListSolution in xsListsSolution:
xsDataMOSFLMIndexingSolution = XSDataMOSFLMIndexingSolution(
)
xsDataCell = XSDataCell()
iSolutionNumber = int(
EDUtilsTable.getItemFromList(xsListSolution,
"index").getValueOf_())
xsDataMOSFLMIndexingSolution.setIndex(
XSDataInteger(iSolutionNumber))
iPenalty = int(
EDUtilsTable.getItemFromList(xsListSolution,
"penalty").getValueOf_())
xsDataMOSFLMIndexingSolution.setPenalty(
XSDataInteger(iPenalty))
strLattice = (EDUtilsTable.getItemFromList(
xsListSolution, "lattice").getValueOf_())
xsDataMOSFLMIndexingSolution.setLattice(
XSDataString(strLattice))
dA = float(
EDUtilsTable.getItemFromList(xsListSolution,
"a").getValueOf_())
xsDataCell.setLength_a(XSDataLength(dA))
dB = float(
EDUtilsTable.getItemFromList(xsListSolution,
"b").getValueOf_())
xsDataCell.setLength_b(XSDataLength(dB))
dC = float(
EDUtilsTable.getItemFromList(xsListSolution,
"c").getValueOf_())
xsDataCell.setLength_c(XSDataLength(dC))
dAlpha = float(
EDUtilsTable.getItemFromList(xsListSolution,
"alpha").getValueOf_())
xsDataCell.setAngle_alpha(XSDataAngle(dAlpha))
dBeta = float(
EDUtilsTable.getItemFromList(xsListSolution,
"beta").getValueOf_())
xsDataCell.setAngle_beta(XSDataAngle(dBeta))
dGamma = float(
EDUtilsTable.getItemFromList(xsListSolution,
"gamma").getValueOf_())
xsDataCell.setAngle_gamma(XSDataAngle(dGamma))
xsDataMOSFLMIndexingSolution.setCell(xsDataCell)
xsDataMOSFLMOutputIndexing.addPossibleSolutions(
xsDataMOSFLMIndexingSolution)
xsTableBeamRefinement = EDUtilsTable.getTableFromTables(
xsDataDnaTables, "beam_refinement")
xsDataMOSFLMBeamPositionRefined = XSDataMOSFLMBeamPosition()
xsDataMOSFLMBeamPositionShift = XSDataMOSFLMBeamPosition()
dInitialBeamX = 0.0
dInitialBeamY = 0.0
dRefinedBeamX = 0.0
dRefinedBeamY = 0.0
xsListInitialBeam = EDUtilsTable.getListsFromTable(
xsTableBeamRefinement, "initial_beam")[0]
fInitialBeamPositionX = float(
EDUtilsTable.getItemFromList(xsListInitialBeam,
"x").getValueOf_())
fInitialBeamPositionY = float(
EDUtilsTable.getItemFromList(xsListInitialBeam,
"y").getValueOf_())
xsListRefinedBeam = EDUtilsTable.getListsFromTable(
xsTableBeamRefinement, "refined_beam")[0]
fRefinedBeamPositionX = float(
EDUtilsTable.getItemFromList(xsListRefinedBeam,
"x").getValueOf_())
fRefinedBeamPositionY = float(
EDUtilsTable.getItemFromList(xsListRefinedBeam,
"y").getValueOf_())
xsDataMOSFLMBeamPositionRefined.setX(
XSDataLength(fRefinedBeamPositionX))
xsDataMOSFLMBeamPositionRefined.setY(
XSDataLength(fRefinedBeamPositionY))
xsDataMOSFLMBeamPositionShift.setX(
XSDataLength(fInitialBeamPositionX -
fRefinedBeamPositionX))
xsDataMOSFLMBeamPositionShift.setY(
XSDataLength(fInitialBeamPositionY -
fRefinedBeamPositionY))
xsDataMOSFLMOutputIndexing.setRefinedBeam(
xsDataMOSFLMBeamPositionRefined)
xsDataMOSFLMOutputIndexing.setBeamShift(
xsDataMOSFLMBeamPositionShift)
# Path to log file
xsDataMOSFLMOutputIndexing.setPathToLogFile(
XSDataFile(
XSDataString(
os.path.join(self.getWorkingDirectory(),
self.getScriptLogFileName()))))
return xsDataMOSFLMOutputIndexing
def createDataMOSFLMOutputIntegration(self):
self.DEBUG("EDPluginMOSFLMIntegrationv10.createDataMOSFLMOutputIntegration")
xsDataMOSFLMOutputIntegration = XSDataMOSFLMOutputIntegration()
# Read bestfile.par, bestfile.hkl and bestfile.dat
strBestfilePar = self.readBestFile("bestfile.par")
bContinue = True
if (strBestfilePar is not None):
xsDataMOSFLMOutputIntegration.setBestfilePar(XSDataString(strBestfilePar))
else:
bContinue = False
if bContinue:
strBestfileHKL = self.readBestFile("bestfile.hkl")
if (strBestfileHKL is not None):
xsDataMOSFLMOutputIntegration.setBestfileHKL(XSDataString(strBestfileHKL))
else:
bContinue = False
if bContinue:
strBestfileDat = self.readBestFile("bestfile.dat")
if (strBestfileDat is not None):
xsDataMOSFLMOutputIntegration.setBestfileDat(XSDataString(strBestfileDat))
else:
bContinue = False
if bContinue:
strDnaTablesXML = self.readProcessFile(self.getBaseName() + "_dnaTables.xml")
xsDataDnaTables = dna_tables.parseString(strDnaTablesXML)
xsTableIntegrationResults = EDUtilsTable.getTableFromTables(xsDataDnaTables, "integration_results")
xsListFinalResiduals = EDUtilsTable.getListsFromTable(xsTableIntegrationResults, "final_residuals")[0]
strRMSSpotDeviation = EDUtilsTable.getItemFromList(xsListFinalResiduals, "rms").getValueOf_()
xsDataMOSFLMOutputIntegration.setRMSSpotDeviation(XSDataLength(float(strRMSSpotDeviation)))
strBeamPositionX = EDUtilsTable.getItemFromList(xsListFinalResiduals, "xcen").getValueOf_()
strBeamPositionY = EDUtilsTable.getItemFromList(xsListFinalResiduals, "ycen").getValueOf_()
xsDataMOSFLMBeamPosition = XSDataMOSFLMBeamPosition()
xsDataMOSFLMBeamPosition.setX(XSDataLength(float(strBeamPositionX)))
xsDataMOSFLMBeamPosition.setY(XSDataLength(float(strBeamPositionY)))
xsDataMOSFLMOutputIntegration.setRefinedBeam(xsDataMOSFLMBeamPosition)
xsDataMOSFLMNewmatMatrix = self.getDataMOSFLMMatrix()
xsDataMOSFLMOutputIntegration.setRefinedNewmat(xsDataMOSFLMNewmatMatrix)
# New results (described in bug #63)
xsTableIntegrationOutput = EDUtilsTable.getTableFromTables(xsDataDnaTables, "integration_output")
xsListOutputFiles = EDUtilsTable.getListsFromTable(xsTableIntegrationOutput, "output_files")[0]
strMTZFilename = EDUtilsTable.getItemFromList(xsListOutputFiles, "hklout").getValueOf_()
strMTZPath = os.path.join(self.getWorkingDirectory(), strMTZFilename)
xsDataFile = XSDataFile()
xsDataFile.setPath(XSDataString(strMTZPath))
xsDataMOSFLMOutputIntegration.setGeneratedMTZFile(xsDataFile)
xsTableSummaryInformation = EDUtilsTable.getTableFromTables(xsDataDnaTables, "summary_information")
xsListSummary = EDUtilsTable.getListsFromTable(xsTableSummaryInformation, "summary")[0]
xsListSpots = EDUtilsTable.getListsFromTable(xsTableSummaryInformation, "spots")[0]
strDistance = EDUtilsTable.getItemFromList(xsListSummary, "distance").getValueOf_()
xsDataMOSFLMOutputIntegration.setRefinedDistance(XSDataLength(float(strDistance)))
strYScale = EDUtilsTable.getItemFromList(xsListSummary, "yscale").getValueOf_()
xsDataMOSFLMOutputIntegration.setRefinedYScale(XSDataFloat(float(strYScale)))
strOverallIOverSigma = EDUtilsTable.getItemFromList(xsListSummary, "isigall").getValueOf_()
xsDataMOSFLMOutputIntegration.setOverallIOverSigma(XSDataFloat(float(strOverallIOverSigma)))
strHighestResolutionIOverSigma = EDUtilsTable.getItemFromList(xsListSummary, "isigout").getValueOf_()
xsDataMOSFLMOutputIntegration.setHighestResolutionIOverSigma(XSDataFloat(float(strHighestResolutionIOverSigma)))
strNumberOfBadReflections = EDUtilsTable.getItemFromList(xsListSpots, "bad_spots").getValueOf_()
xsDataMOSFLMOutputIntegration.setNumberOfBadReflections(XSDataInteger(int(strNumberOfBadReflections)))
strNumberOfFullyRecordedReflections = EDUtilsTable.getItemFromList(xsListSpots, "full").getValueOf_()
xsDataMOSFLMOutputIntegration.setNumberOfFullyRecordedReflections(XSDataInteger(int(strNumberOfFullyRecordedReflections)))
strNumberOfNegativeReflections = EDUtilsTable.getItemFromList(xsListSpots, "negative").getValueOf_()
xsDataMOSFLMOutputIntegration.setNumberOfNegativeReflections(XSDataInteger(int(strNumberOfNegativeReflections)))
strNumberOfOverlappedReflections = EDUtilsTable.getItemFromList(xsListSpots, "overlap").getValueOf_()
xsDataMOSFLMOutputIntegration.setNumberOfOverlappedReflections(XSDataInteger(int(strNumberOfOverlappedReflections)))
strNumberOfPartialReflections = EDUtilsTable.getItemFromList(xsListSpots, "partial").getValueOf_()
xsDataMOSFLMOutputIntegration.setNumberOfPartialReflections(XSDataInteger(int(strNumberOfPartialReflections)))
# Fill in the statistics
xsDataMOSFLMOutputIntegration.setOverallStatistics(self.getMOSFLMIntegrationStatisticsPerResolutionBin(xsDataDnaTables, "bin_0"))
iIndex = 1
bContinue = True
fMinResolution = None
while (bContinue == True):
strBin = "bin_%d" % iIndex
# I don't know how many intensity bins there are. Since the EDUtilsTable.getListsFromTable
# method crashes if the list is not present, I had to wrap the calls to this method in
# try - except:
try:
xsDataMOSFLMIntegrationStatisticsPerResolutionBin = self.getMOSFLMIntegrationStatisticsPerResolutionBin(xsDataDnaTables, strBin, fMinResolution)
fMinResolution = xsDataMOSFLMIntegrationStatisticsPerResolutionBin.getMaxResolution().getValue()
xsDataMOSFLMOutputIntegration.addStatisticsPerResolutionBin(xsDataMOSFLMIntegrationStatisticsPerResolutionBin)
iIndex += 1
except:
bContinue = False
# Path to log file
xsDataMOSFLMOutputIntegration.setPathToLogFile(XSDataFile(XSDataString(os.path.join(self.getWorkingDirectory(), self.getScriptLogFileName()))))
return xsDataMOSFLMOutputIntegration
def createDataMOSFLMOutputIndexing(self):
EDVerbose.DEBUG("EDPluginMOSFLMIndexingv10.createDataMOSFLMOutputIndexing")
xsDataMOSFLMOutputIndexing = XSDataMOSFLMOutputIndexing()
# Read Newmat file
xsDataMOSFLMNewmat = self.getDataMOSFLMNewmat()
if (xsDataMOSFLMNewmat is None):
strError = "MOSFLM indexing error : No solution was obtained!"
EDVerbose.ERROR(strError)
self.setFailure()
else:
xsDataMOSFLMOutputIndexing.setRefinedNewmat(xsDataMOSFLMNewmat)
# Then read the XML file
strDnaTablesXML = self.readProcessFile(self.getScriptBaseName() + "_dnaTables.xml")
xsDataDnaTables = dna_tables.parseString(strDnaTablesXML)
listXSTableMosaicityEstimation = EDUtilsTable.getTableListFromTables(xsDataDnaTables, "mosaicity_estimation")
dMosaicityValueSum = 0.0
nValues = 0
for xsTableMosaicityEstimation in listXSTableMosaicityEstimation:
for xsListMosaicity in EDUtilsTable.getListsFromTable(xsTableMosaicityEstimation, "mosaicity"):
dMosaicityValue = float(EDUtilsTable.getItemFromList(xsListMosaicity, "value").getValueOf_())
dMosaicityValueSum += dMosaicityValue
nValues += 1
xsDataFloatMosaicityEstimation = XSDataFloat()
xsDataFloatMosaicityEstimation.setValue(dMosaicityValueSum / nValues)
xsDataMOSFLMOutputIndexing.setMosaicityEstimation(xsDataFloatMosaicityEstimation)
xsTableRefinement = EDUtilsTable.getTableFromTables(xsDataDnaTables, "refinement")
if (xsTableRefinement is None):
strError = "MOSFLM indexing error : No solution was refined!"
EDVerbose.ERROR(strError)
self.setFailure()
else:
xsListDeviations = EDUtilsTable.getListsFromTable(xsTableRefinement, "deviations")[0]
dDeviationAngular = float(EDUtilsTable.getItemFromList(xsListDeviations, "angular").getValueOf_())
dDeviationPositional = float(EDUtilsTable.getItemFromList(xsListDeviations, "positional").getValueOf_())
xsDataMOSFLMOutputIndexing.setDeviationAngular(XSDataAngle(dDeviationAngular))
xsDataMOSFLMOutputIndexing.setDeviationPositional(XSDataLength(dDeviationPositional))
xsListResults = EDUtilsTable.getListsFromTable(xsTableRefinement, "results")[0]
dDetectorDistance = float(EDUtilsTable.getItemFromList(xsListResults, "detector_distance").getValueOf_())
xsDataMOSFLMOutputIndexing.setRefinedDistance(XSDataLength(dDetectorDistance))
xsListParameters = EDUtilsTable.getListsFromTable(xsTableRefinement, "parameters")[0]
iSpotsUsed = int(EDUtilsTable.getItemFromList(xsListParameters, "used").getValueOf_())
iSpotsTotal = int(EDUtilsTable.getItemFromList(xsListParameters, "out_of").getValueOf_())
xsDataMOSFLMOutputIndexing.setSpotsUsed(XSDataInteger(iSpotsUsed))
xsDataMOSFLMOutputIndexing.setSpotsTotal(XSDataInteger(iSpotsTotal))
xsTableSolutionRefinement = EDUtilsTable.getTableFromTables(xsDataDnaTables, "solution_refinement")
xsListParameters = EDUtilsTable.getListsFromTable(xsTableSolutionRefinement, "selection")[0]
iSelectedSolutionNumber = int(EDUtilsTable.getItemFromList(xsListParameters, "number").getValueOf_())
xsDataMOSFLMOutputIndexing.setSelectedSolutionNumber(XSDataInteger(iSelectedSolutionNumber))
strSelectedSolutionSpaceGroup = (EDUtilsTable.getItemFromList(xsListParameters, "spacegroup").getValueOf_())
xsDataMOSFLMOutputIndexing.setSelectedSolutionSpaceGroup(XSDataString(strSelectedSolutionSpaceGroup))
iSelectedSolutionSpaceGroupNumber = int(EDUtilsTable.getItemFromList(xsListParameters, "spacegroup_number").getValueOf_())
xsDataMOSFLMOutputIndexing.setSelectedSolutionSpaceGroupNumber(XSDataInteger(iSelectedSolutionSpaceGroupNumber))
xsTableAutoIndexSolutions = EDUtilsTable.getTableFromTables(xsDataDnaTables, "autoindex_solutions")
xsListsSolution = xsTableAutoIndexSolutions.getList()
for xsListSolution in xsListsSolution:
xsDataMOSFLMIndexingSolution = XSDataMOSFLMIndexingSolution()
xsDataCell = XSDataCell()
iSolutionNumber = int(EDUtilsTable.getItemFromList(xsListSolution, "index").getValueOf_())
xsDataMOSFLMIndexingSolution.setIndex(XSDataInteger(iSolutionNumber))
iPenalty = int(EDUtilsTable.getItemFromList(xsListSolution, "penalty").getValueOf_())
xsDataMOSFLMIndexingSolution.setPenalty(XSDataInteger(iPenalty))
strLattice = (EDUtilsTable.getItemFromList(xsListSolution, "lattice").getValueOf_())
xsDataMOSFLMIndexingSolution.setLattice(XSDataString(strLattice))
dA = float(EDUtilsTable.getItemFromList(xsListSolution, "a").getValueOf_())
xsDataCell.setLength_a(XSDataLength(dA))
dB = float(EDUtilsTable.getItemFromList(xsListSolution, "b").getValueOf_())
xsDataCell.setLength_b(XSDataLength(dB))
dC = float(EDUtilsTable.getItemFromList(xsListSolution, "c").getValueOf_())
xsDataCell.setLength_c(XSDataLength(dC))
dAlpha = float(EDUtilsTable.getItemFromList(xsListSolution, "alpha").getValueOf_())
xsDataCell.setAngle_alpha(XSDataAngle(dAlpha))
dBeta = float(EDUtilsTable.getItemFromList(xsListSolution, "beta").getValueOf_())
xsDataCell.setAngle_beta(XSDataAngle(dBeta))
dGamma = float(EDUtilsTable.getItemFromList(xsListSolution, "gamma").getValueOf_())
xsDataCell.setAngle_gamma(XSDataAngle(dGamma))
xsDataMOSFLMIndexingSolution.setCell(xsDataCell)
xsDataMOSFLMOutputIndexing.addPossibleSolutions(xsDataMOSFLMIndexingSolution)
xsTableBeamRefinement = EDUtilsTable.getTableFromTables(xsDataDnaTables, "beam_refinement")
xsDataMOSFLMBeamPositionRefined = XSDataMOSFLMBeamPosition()
xsDataMOSFLMBeamPositionShift = XSDataMOSFLMBeamPosition()
dInitialBeamX = 0.0
dInitialBeamY = 0.0
dRefinedBeamX = 0.0
dRefinedBeamY = 0.0
xsListInitialBeam = EDUtilsTable.getListsFromTable(xsTableBeamRefinement, "initial_beam")[0]
fInitialBeamPositionX = float(EDUtilsTable.getItemFromList(xsListInitialBeam, "x").getValueOf_())
fInitialBeamPositionY = float(EDUtilsTable.getItemFromList(xsListInitialBeam, "y").getValueOf_())
xsListRefinedBeam = EDUtilsTable.getListsFromTable(xsTableBeamRefinement, "refined_beam")[0]
fRefinedBeamPositionX = float(EDUtilsTable.getItemFromList(xsListRefinedBeam, "x").getValueOf_())
fRefinedBeamPositionY = float(EDUtilsTable.getItemFromList(xsListRefinedBeam, "y").getValueOf_())
xsDataMOSFLMBeamPositionRefined.setX(XSDataLength(fRefinedBeamPositionX))
xsDataMOSFLMBeamPositionRefined.setY(XSDataLength(fRefinedBeamPositionY))
xsDataMOSFLMBeamPositionShift.setX(XSDataLength(fInitialBeamPositionX - fRefinedBeamPositionX))
xsDataMOSFLMBeamPositionShift.setY(XSDataLength(fInitialBeamPositionY - fRefinedBeamPositionY))
xsDataMOSFLMOutputIndexing.setRefinedBeam(xsDataMOSFLMBeamPositionRefined)
xsDataMOSFLMOutputIndexing.setBeamShift(xsDataMOSFLMBeamPositionShift)
return xsDataMOSFLMOutputIndexing
def generateXSDataIndexingResult(_xsDataMOSFLMIndexingOutput,
_xsDataExperimentalCondition=None):
"""
Translation from XSDataMOSFLMIndexingOutput to XSDataIndexingResult.
"""
EDVerbose.DEBUG(
"EDHandlerXSDataMOSFLMv10.generateXSDataIndexingOutput")
xsDataMOSFLMBeamPositionRefined = _xsDataMOSFLMIndexingOutput.getRefinedBeam(
)
xsDataMOSFLMBeamPositionShift = _xsDataMOSFLMIndexingOutput.getBeamShift(
)
dDeviationAngular = _xsDataMOSFLMIndexingOutput.getDeviationAngular(
).getValue()
dDeviationPositional = _xsDataMOSFLMIndexingOutput.getDeviationPositional(
).getValue()
dMosaicityEstimation = _xsDataMOSFLMIndexingOutput.getMosaicityEstimation(
).getValue()
dDistanceRefined = _xsDataMOSFLMIndexingOutput.getRefinedDistance(
).getValue()
iSelectedSolution = _xsDataMOSFLMIndexingOutput.getSelectedSolutionNumber(
).getValue()
iSpotsTotal = _xsDataMOSFLMIndexingOutput.getSpotsTotal().getValue()
iSpotsUsed = _xsDataMOSFLMIndexingOutput.getSpotsUsed().getValue()
xsDataCellRefined = _xsDataMOSFLMIndexingOutput.getRefinedNewmat(
).getRefinedCell()
xsDataMatrixA = _xsDataMOSFLMIndexingOutput.getRefinedNewmat(
).getAMatrix()
xsDataMatrixU = _xsDataMOSFLMIndexingOutput.getRefinedNewmat(
).getUMatrix()
strSelectedSpaceGroupName = _xsDataMOSFLMIndexingOutput.getSelectedSolutionSpaceGroup(
).getValue()
iSelectedSpaceGroupNumber = _xsDataMOSFLMIndexingOutput.getSelectedSolutionSpaceGroupNumber(
).getValue()
xsDataIndexingResult = XSDataIndexingResult()
xsDataIndexingSolutionSelected = None
for possibleSolutions in _xsDataMOSFLMIndexingOutput.getPossibleSolutions(
):
xsDataCrystal = XSDataCrystal()
xsDataSpaceGroup = XSDataSpaceGroup()
xsDataSpaceGroup.setName(
XSDataString(possibleSolutions.getLattice().getValue()))
xsDataCrystal.setSpaceGroup(xsDataSpaceGroup)
xsDataCrystal.setCell(possibleSolutions.getCell())
xsDataIndexingSolution = XSDataIndexingSolution()
xsDataIndexingSolution.setCrystal(xsDataCrystal)
iIndex = possibleSolutions.getIndex().getValue()
xsDataIndexingSolution.setNumber(XSDataInteger(iIndex))
xsDataIndexingSolution.setPenalty(
XSDataFloat(possibleSolutions.getPenalty().getValue()))
xsDataIndexingResult.addSolution(xsDataIndexingSolution)
if (iIndex == iSelectedSolution):
xsDataIndexingSolutionSelected = XSDataIndexingSolutionSelected(
)
xsDataIndexingSolutionSelected.setNumber(XSDataInteger(iIndex))
xsDataIndexingSolutionSelected.setPenalty(
XSDataFloat(possibleSolutions.getPenalty().getValue()))
xsDataCrystalSelected = XSDataCrystal()
xsDataSpaceGroupSelected = XSDataSpaceGroup()
xsDataSpaceGroupSelected.setName(
XSDataString(strSelectedSpaceGroupName))
xsDataSpaceGroupSelected.setITNumber(
XSDataInteger(iSelectedSpaceGroupNumber))
xsDataCrystalSelected.setSpaceGroup(xsDataSpaceGroupSelected)
xsDataCrystalSelected.setCell(xsDataCellRefined)
xsDataCrystalSelected.setMosaicity(XSDataDouble(dMosaicityEstimation))
xsDataIndexingSolutionSelected.setCrystal(xsDataCrystalSelected)
xsDataOrientation = XSDataOrientation()
xsDataOrientation.setMatrixA(xsDataMatrixA)
xsDataOrientation.setMatrixU(xsDataMatrixU)
xsDataIndexingSolutionSelected.setOrientation(xsDataOrientation)
xsDataStatisticsIndexing = XSDataStatisticsIndexing()
xsDataStatisticsIndexing.setBeamPositionShiftX(
XSDataLength(xsDataMOSFLMBeamPositionShift.getX().getValue()))
xsDataStatisticsIndexing.setBeamPositionShiftY(
XSDataLength(xsDataMOSFLMBeamPositionShift.getY().getValue()))
xsDataStatisticsIndexing.setSpotDeviationAngular(
XSDataAngle(dDeviationAngular))
xsDataStatisticsIndexing.setSpotDeviationPositional(
XSDataLength(dDeviationPositional))
xsDataStatisticsIndexing.setSpotsUsed(XSDataInteger(iSpotsUsed))
xsDataStatisticsIndexing.setSpotsTotal(XSDataInteger(iSpotsTotal))
xsDataIndexingSolutionSelected.setStatistics(xsDataStatisticsIndexing)
xsDataExperimentalConditionRefined = None
if (_xsDataExperimentalCondition is None):
xsDataExperimentalConditionRefined = XSDataExperimentalCondition()
else:
# Copy the incoming experimental condition
xmlExperimentalCondition = _xsDataExperimentalCondition.marshal()
xsDataExperimentalConditionRefined = XSDataExperimentalCondition.parseString(
xmlExperimentalCondition)
xsDataDetector = xsDataExperimentalConditionRefined.getDetector()
if (xsDataDetector is None):
xsDataDetector = XSDataDetector()
xsDataDetector.setBeamPositionX(
XSDataLength(xsDataMOSFLMBeamPositionRefined.getX().getValue()))
xsDataDetector.setBeamPositionY(
XSDataLength(xsDataMOSFLMBeamPositionRefined.getY().getValue()))
xsDataDetector.setDistance(XSDataLength(dDistanceRefined))
xsDataExperimentalConditionRefined.setDetector(xsDataDetector)
xsDataIndexingSolutionSelected.setExperimentalConditionRefined(
xsDataExperimentalConditionRefined)
xsDataIndexingResult.setSelectedSolution(
xsDataIndexingSolutionSelected)
xsDataIndexingResult.setIndexingLogFile(
_xsDataMOSFLMIndexingOutput.getPathToLogFile())
return xsDataIndexingResult
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 XSDataBestv10 import XSDataBestInput
xsDataBestInput = XSDataBestInput()
from XSDataCommon import XSDataAbsorbedDoseRate
from XSDataCommon import XSDataFloat
from XSDataCommon import XSDataString
from XSDataCommon import XSDataTime
from XSDataCommon import XSDataFile
from XSDataCommon import XSDataSpeed
from XSDataCommon import XSDataString
from XSDataCommon import XSDataAngle
xsDataBestInput.setCrystalAbsorbedDoseRate(
XSDataAbsorbedDoseRate(0.22E+06))
xsDataBestInput.setCrystalShape(XSDataFloat(1))
xsDataBestInput.setCrystalSusceptibility(XSDataFloat(1.5))
xsDataBestInput.setDetectorType(XSDataString("q210-2x"))
xsDataBestInput.setBeamExposureTime(XSDataTime(1))
xsDataBestInput.setBeamMaxExposureTime(XSDataTime(10000))
xsDataBestInput.setBeamMinExposureTime(XSDataTime(0.1))
xsDataBestInput.setGoniostatMinRotationWidth(XSDataAngle(0.1))
xsDataBestInput.setGoniostatMaxRotationSpeed(XSDataSpeed(10))
xsDataBestInput.setAimedResolution(XSDataFloat(2))
xsDataBestInput.setAimedRedundancy(XSDataFloat(6.5))
xsDataBestInput.setAimedCompleteness(XSDataFloat(0.9))
xsDataBestInput.setAimedIOverSigma(XSDataFloat(3))
xsDataBestInput.setComplexity(XSDataString("min"))
fileDirectory = edPluginBest.getWorkingDirectory()
bestFileContentDat = EDUtilsFile.readFile(
os.path.join(self.strDataPath, "bestfile.dat"))
xsDataBestInput.setBestFileContentDat(XSDataString(bestFileContentDat))
bestFileContentPar = EDUtilsFile.readFile(
os.path.join(self.strDataPath, "bestfile.par"))
xsDataBestInput.setBestFileContentPar(XSDataString(bestFileContentPar))
bestFileContentHKL = EDUtilsFile.readFile(
os.path.join(self.strDataPath, "bestfile1.hkl"))
listBestFileContentHKL = []
listBestFileContentHKL.append(XSDataString(bestFileContentHKL))
xsDataBestInput.setBestFileContentHKL(listBestFileContentHKL)
xsDataBestInput.outputFile(self.strObtainedInputFile)
strExpectedInput = self.readAndParseFile(self.strReferenceInputFile)
strObtainedInput = self.readAndParseFile(self.strObtainedInputFile)
xsDataInputExpected = XSDataBestInput.parseString(strExpectedInput)
xsDataInputObtained = XSDataBestInput.parseString(strObtainedInput)
EDAssert.equal(xsDataInputExpected.marshal(),
xsDataInputObtained.marshal())
self.cleanUp(edPluginBest)
def getOutputDataFromDNATableFile(self, _strFileName):
"""
"""
xsDataBestOutput = XSDataBestOutput()
strDnaTablesXML = self.readProcessFile(_strFileName)
xsDataDnaTables = dna_tables.parseString(strDnaTablesXML)
# Loop through all the tables and fill in the relevant parts of xsDataBestOutput
# SubWedges
xsTablesCollectionStrategy = EDUtilsTable.getTableListFromTables(
xsDataDnaTables, "data_collection_strategy")
for xsTableCollectionStrategy in xsTablesCollectionStrategy:
xsDataBestCollectionPlan = XSDataBestCollectionPlan()
xsCollectionRunList = EDUtilsTable.getListsFromTable(
xsTableCollectionStrategy, "collection_run")
for xsCollectionRunItemList in xsCollectionRunList:
xsDataCollectionRun = self.collectionRunItemListToCollectionRun(
xsCollectionRunItemList)
xsDataBestCollectionPlan.addCollectionRun(xsDataCollectionRun)
# Strategy Summary
xsStrategySummaryItemList = EDUtilsTable.getListsFromTable(
xsTableCollectionStrategy, "summary")
xsDataStrategySummary = self.strategySummaryItemListToStrategySummary(
xsStrategySummaryItemList[0])
# Ranking Resolution
# Not part of strategySummaryItemListToStrategySummary method since it is in the general_form part
xsTableGeneralInform = EDUtilsTable.getTableFromTables(
xsDataDnaTables, "general_inform")
xsRankingResolutionItemList = EDUtilsTable.getListsFromTable(
xsTableGeneralInform, "ranking_resolution")
xsItemRankingResolution = EDUtilsTable.getItemFromList(
xsRankingResolutionItemList[0], "dmin")
fRankingResolution = float(xsItemRankingResolution.getValueOf_())
xsDataStrategySummary.setRankingResolution(
XSDataFloat(fRankingResolution))
xsDataBestCollectionPlan.setStrategySummary(xsDataStrategySummary)
# Satistics
xsTablesStatisticalPrediction = EDUtilsTable.getTableListFromTables(
xsDataDnaTables, "statistical_prediction")
for xsTableStatisticalPrediction in xsTablesStatisticalPrediction:
if (xsTableStatisticalPrediction.getIndex() ==
xsTableCollectionStrategy.getIndex()):
xsResolutionBinList = EDUtilsTable.getListsFromTable(
xsTableStatisticalPrediction, "resolution_bin")
xsDataStatisticalPrediction = XSDataBestStatisticalPrediction(
)
for xsResolutionBinItemList in xsResolutionBinList:
xsDataResolutionBin = self.resolutionBinItemListToResolutionBin(
xsResolutionBinItemList)
xsDataStatisticalPrediction.addResolutionBin(
xsDataResolutionBin)
xsDataBestCollectionPlan.setStatisticalPrediction(
xsDataStatisticalPrediction)
xsDataBestOutput.addCollectionPlan(xsDataBestCollectionPlan)
return xsDataBestOutput
def testSetDataModelInput(self):
"""
A test for whether we can obtain the expected XML by setting a certain input for the plugin.
"""
edPluginISPyB = self.createPlugin()
xsPluginItemISPyB = self.getPluginConfiguration(
os.path.join(self.getPluginTestsDataHome(), "XSConfiguration.xml"))
edPluginISPyB.setConfiguration(xsPluginItemISPyB)
edPluginISPyB.configure()
xsDataInputISPyB = XSDataInputISPyB()
xsDataISPyBImage = XSDataISPyBImage()
xsDataISPyBImage.setFileName(XSDataString("test.img"))
xsDataISPyBImage.setFileLocation(XSDataString("/tmp"))
xsDataISPyBScreening = XSDataISPyBScreening()
# xsDataISPyBScreening.setDataCollectionId( XSDataInteger ( 1 ) )
xsDataISPyBScreening.setProgramVersion(XSDataString("EDNA Prototype"))
xsDataISPyBScreeningInput = XSDataISPyBScreeningInput()
xsDataISPyBScreeningInput.setBeamX(XSDataFloat(10.4))
xsDataISPyBScreeningInput.setBeamY(XSDataFloat(2.31))
xsDataISPyBScreeningInput.setRmsErrorLimits(XSDataFloat(0.8))
xsDataISPyBScreeningInput.setMinimumFractionIndexed(XSDataFloat(0.4))
xsDataISPyBScreeningInput.setMaximumFractionRejected(XSDataFloat(0.45))
xsDataISPyBScreeningInput.setMinimumSignalToNoise(XSDataFloat(0.56))
xsDataISPyBScreeningOutput = XSDataISPyBScreeningOutput()
xsDataISPyBScreeningOutput.setStatusDescription(
XSDataString("It's just fine."))
xsDataISPyBScreeningOutput.setMosaicity(XSDataFloat(0.25))
xsDataISPyBScreeningOutput.setBeamShiftX(XSDataFloat(0.141))
xsDataISPyBScreeningOutput.setBeamShiftY(XSDataFloat(0.156))
xsDataISPyBScreeningOutputLattice = XSDataISPyBScreeningOutputLattice()
xsDataISPyBScreeningOutputLattice.setSpaceGroup(XSDataString("P222"))
xsDataISPyBScreeningStrategy = XSDataISPyBScreeningStrategy()
xsDataISPyBScreeningStrategy.setPhiStart(XSDataFloat(0))
xsDataISPyBScreeningStrategy.setPhiEnd(XSDataFloat(20))
xsDataISPyBScreeningStrategy.setRotation(XSDataFloat(1))
xsDataISPyBScreeningStrategy.setProgram(XSDataString("EDNA"))
xsDataISPyBScreeningStrategy.setAnomalous(XSDataBoolean(1))
xsDataInputISPyB.setImage(xsDataISPyBImage)
xsDataInputISPyB.setScreening(xsDataISPyBScreening)
xsDataInputISPyB.setScreeningInput(xsDataISPyBScreeningInput)
xsDataInputISPyB.setScreeningOutput(xsDataISPyBScreeningOutput)
xsDataInputISPyB.setScreeningOutputLattice(
xsDataISPyBScreeningOutputLattice)
xsDataInputISPyB.setScreeningStrategy(xsDataISPyBScreeningStrategy)
xsDataInputISPyB.outputFile(self.m_edObtainedInputFile)
strExpectedInput = self.readAndParseFile(self.m_edReferenceInputFile)
strObtainedInput = self.readAndParseFile(self.m_edObtainedInputFile)
xsDataScreeningExpected = XSDataInputISPyB.parseString(
strExpectedInput)
xsDataScreeningObtained = XSDataInputISPyB.parseString(
strObtainedInput)
pyStrExpectedXML = xsDataScreeningExpected.marshal()
pyStrObtainedXML = xsDataScreeningObtained.marshal()
EDAssert.equal(pyStrExpectedXML, pyStrObtainedXML)
self.cleanUp(edPluginISPyB)