def readIdxrefLp(pathToIdxrefLp, resultXDSIndexing=None):
if resultXDSIndexing is None:
resultXDSIndexing = {}
if pathToIdxrefLp.exists():
with open(str(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]:
resultXDSIndexing['mosaicity'] = float(
listLines[indexLine].split()[-1])
elif "DETECTOR COORDINATES (PIXELS) OF DIRECT BEAM" in listLines[
indexLine]:
resultXDSIndexing['xBeam'] = float(
listLines[indexLine].split()[-1])
resultXDSIndexing['yBeam'] = float(
listLines[indexLine].split()[-2])
elif "CRYSTAL TO DETECTOR DISTANCE" in listLines[
indexLine]:
resultXDSIndexing['distance'] = float(
listLines[indexLine].split()[-1])
elif doParseLattice:
if listLines[indexLine].startswith(
" * ") and not listLines[indexLine +
1].startswith(" * "):
listLine = listLines[indexLine].split()
latticeCharacter = int(listLine[1])
bravaisLattice = listLine[2]
spaceGroup = UtilsSymmetry.getMinimumSymmetrySpaceGroupFromBravaisLattice(
bravaisLattice)
spaceGroupNumber = UtilsSymmetry.getITNumberFromSpaceGroupName(
spaceGroup)
qualityOfFit = float(listLine[3])
resultXDSIndexing.update({
'latticeCharacter': latticeCharacter,
'spaceGroupNumber': spaceGroupNumber,
'qualityOfFit': qualityOfFit,
'a': float(listLine[4]),
'b': float(listLine[5]),
'c': float(listLine[6]),
'alpha': float(listLine[7]),
'beta': float(listLine[8]),
'gamma': float(listLine[9])
})
indexLine += 1
return resultXDSIndexing
def test_getMinimumSymmetrySpaceGroupFromBravaisLattice(self):
"""
Testing retrieving the lowest symmetry space group from all Bravais Lattices
"""
listBravaisLattice = [
"aP",
"mP",
"mC",
"mI",
"oP",
"oA",
"oB",
"oC",
"oS",
"oF",
"oI",
"tP",
"tC",
"tI",
"tF",
"hP",
"hR",
"cP",
"cF",
"cI",
]
listSpaceGroup = [
"P1",
"P2",
"C2",
"C2",
"P222",
"C222",
"C222",
"C222",
"C222",
"F222",
"I222",
"P4",
"P4",
"I4",
"I4",
"P3",
"H3",
"P23",
"F23",
"I23",
]
for index in range(len(listBravaisLattice)):
self.assertEqual(
listSpaceGroup[index],
UtilsSymmetry.getMinimumSymmetrySpaceGroupFromBravaisLattice(
listBravaisLattice[index]),
)
def parseLattice(indexLine, listLines, resultXDSIndexing):
if listLines[indexLine].startswith(
" * ") and not listLines[indexLine + 1].startswith(" * "):
listLine = listLines[indexLine].split()
latticeCharacter = int(listLine[1])
bravaisLattice = listLine[2]
spaceGroup = UtilsSymmetry.getMinimumSymmetrySpaceGroupFromBravaisLattice(
bravaisLattice)
spaceGroupNumber = UtilsSymmetry.getITNumberFromSpaceGroupName(
spaceGroup)
qualityOfFit = float(listLine[3])
resultXDSIndexing.update({
"latticeCharacter": latticeCharacter,
"spaceGroupNumber": spaceGroupNumber,
"qualityOfFit": qualityOfFit,
"a": float(listLine[4]),
"b": float(listLine[5]),
"c": float(listLine[6]),
"alpha": float(listLine[7]),
"beta": float(listLine[8]),
"gamma": float(listLine[9]),
})
def testGetSpaceGroupNameFromITNumber(self):
self.assertEqual("P1", UtilsSymmetry.getSpaceGroupNameFromITNumber(1),
"Space group from from it number 1")
self.assertEqual("P2", UtilsSymmetry.getSpaceGroupNameFromITNumber(3),
"Space group from from it number 3")
self.assertEqual("C2", UtilsSymmetry.getSpaceGroupNameFromITNumber(5),
"Space group from from it number 5")
self.assertEqual("P222",
UtilsSymmetry.getSpaceGroupNameFromITNumber(16),
"Space group from from it number 16")
self.assertEqual("C222",
UtilsSymmetry.getSpaceGroupNameFromITNumber(21),
"Space group from from it number 21")
self.assertEqual("F222",
UtilsSymmetry.getSpaceGroupNameFromITNumber(22),
"Space group from from it number 22")
self.assertEqual("P4", UtilsSymmetry.getSpaceGroupNameFromITNumber(75),
"Space group from from it number 75")
self.assertEqual("I4", UtilsSymmetry.getSpaceGroupNameFromITNumber(79),
"Space group from from it number 79")
self.assertEqual("P3",
UtilsSymmetry.getSpaceGroupNameFromITNumber(143),
"Space group from from it number 143")
self.assertEqual("H3",
UtilsSymmetry.getSpaceGroupNameFromITNumber(146),
"Space group from from it number 146")
self.assertEqual("P23",
UtilsSymmetry.getSpaceGroupNameFromITNumber(195),
"Space group from from it number 195")
self.assertEqual("F23",
UtilsSymmetry.getSpaceGroupNameFromITNumber(196),
"Space group from from it number 196")
def test_getITNumberFromSpaceGroupName(self):
self.assertEqual(1, UtilsSymmetry.getITNumberFromSpaceGroupName("P1"),
"ITNumber from space group P1")
self.assertEqual(3, UtilsSymmetry.getITNumberFromSpaceGroupName("P2"),
"ITNumber from space group P2")
self.assertEqual(5, UtilsSymmetry.getITNumberFromSpaceGroupName("C2"),
"ITNumber from space group C2")
self.assertEqual(16,
UtilsSymmetry.getITNumberFromSpaceGroupName("P222"),
"ITNumber from space group P222")
self.assertEqual(21,
UtilsSymmetry.getITNumberFromSpaceGroupName("C222"),
"ITNumber from space group C222")
self.assertEqual(22,
UtilsSymmetry.getITNumberFromSpaceGroupName("F222"),
"ITNumber from space group F222")
self.assertEqual(75, UtilsSymmetry.getITNumberFromSpaceGroupName("P4"),
"ITNumber from space group P4")
self.assertEqual(79, UtilsSymmetry.getITNumberFromSpaceGroupName("I4"),
"ITNumber from space group I4")
self.assertEqual(143,
UtilsSymmetry.getITNumberFromSpaceGroupName("P3"),
"ITNumber from space group P3")
self.assertEqual(146,
UtilsSymmetry.getITNumberFromSpaceGroupName("H3"),
"ITNumber from space group H3")
self.assertEqual(195,
UtilsSymmetry.getITNumberFromSpaceGroupName("P23"),
"ITNumber from space group P23")
self.assertEqual(196,
UtilsSymmetry.getITNumberFromSpaceGroupName("F23"),
"ITNumber from space group F23")
def run(self, inData):
listImagePath = inData["imagePath"]
prefix = UtilsImage.getPrefix(listImagePath[0])
listSubWedge = self.getListSubWedge(inData)
diffractionPlan = inData.get("diffractionPlan", {})
sample = inData.get("sample", {})
# Check if flux is present
flux = None
absorbedDoseRate = None
experimentalCondition = inData.get("experimentalCondition", None)
if experimentalCondition is not None:
beam = experimentalCondition.get("beam", None)
if beam is not None:
flux = beam.get("flux", None)
# if not "size" in beam:
# beam["size"] = listSubWedge[0]["experimentalCondition"]["beam"]["size"]
beam["exposureTime"] = listSubWedge[0][
"experimentalCondition"]["beam"]["exposureTime"]
beam["wavelength"] = listSubWedge[0]["experimentalCondition"][
"beam"]["wavelength"]
# Convert images to CBF
firstImage = listSubWedge[0]["image"][0]["path"]
import os
import pprint
listH5ToCBF = []
suffix = os.path.splitext(firstImage)[1]
if suffix == ".h5":
for subWedge in listSubWedge:
imageList = subWedge["image"]
for image in imageList:
imagePath = image["path"]
hdf5ImageNumber = UtilsImage.getImageNumber(imagePath)
inDataH5ToCBF = {
"hdf5File": imagePath,
"hdf5ImageNumber": hdf5ImageNumber,
"imageNumber": 1,
"forcedOutputDirectory":
str(self.getWorkingDirectory()),
"forcedOutputImageNumber": hdf5ImageNumber,
}
h5ToCBF = H5ToCBFTask(inData=inDataH5ToCBF)
h5ToCBF.start()
listH5ToCBF.append((image, h5ToCBF))
# Join CBF creation
for image, h5ToCBF in listH5ToCBF:
h5ToCBF.join()
image["path"] = h5ToCBF.outData["outputCBFFile"]
pprint.pprint(listSubWedge)
# Start indexing
outDataIndexing, outDataGB, listSubWedge = self.indexing(
prefix, listSubWedge, self.getWorkingDirectory())
if outDataIndexing is not None and outDataGB is not None:
listXdsAsciiHkl, correctLp, bkgpixCbf = self.integration(
prefix, listSubWedge, outDataIndexing, outDataGB)
if listXdsAsciiHkl is not None:
# Check if Raddose should be run
estimateRadiationDamage = self.checkEstimateRadiationDamage(
inData, flux)
if estimateRadiationDamage:
# Check if forced space group
forcedSpaceGroup = None
numOperators = None
cell = None
if ("diffractionPlan" in inData and "forcedSpaceGroup"
in inData["diffractionPlan"]):
forcedSpaceGroup = inData["diffractionPlan"][
"forcedSpaceGroup"]
if forcedSpaceGroup is not None:
if forcedSpaceGroup != "":
forcedSpaceGroup = forcedSpaceGroup.replace(
" ", "")
numOperators = UtilsSymmetry.getNumberOfSymmetryOperatorsFromSpaceGroupName(
forcedSpaceGroup)
else:
forcedSpaceGroup = None
if forcedSpaceGroup is None:
# Get indexing space group IT number
if "resultIndexing" in outDataIndexing:
resultIndexing = outDataIndexing["resultIndexing"]
cell = resultIndexing["cell"]
if "spaceGroupNumber" in resultIndexing:
spaceGroupNumber = resultIndexing[
"spaceGroupNumber"]
numOperators = UtilsSymmetry.getNumberOfSymmetryOperatorsFromSpaceGroupITNumber(
spaceGroupNumber)
if numOperators is None:
raise RuntimeError(
"Error when trying to determine number of symmetry operators!"
)
chemicalComposition = self.getDefaultChemicalComposition(
cell, numOperators)
numberOfImages = self.getNumberOfImages(listSubWedge)
sample = inData["sample"]
inDataRaddose = {
"experimentalCondition": experimentalCondition,
"chemicalComposition": chemicalComposition,
"sample": sample,
"cell": cell,
"numberOfImages": numberOfImages,
"numOperators": numOperators,
}
# import pprint
# pprint.pprint(inDataRaddose)
raddose = Raddose(inData=inDataRaddose,
workingDirectorySuffix=prefix)
raddose.execute()
if raddose.isSuccess():
absorbedDoseRate = raddose.outData["absorbedDoseRate"]
inDataBest = {
"diffractionPlan": diffractionPlan,
"sample": sample,
"subWedge": listSubWedge,
"xdsAsciiHkl": listXdsAsciiHkl,
"bkgpixCbf": bkgpixCbf,
"correctLp": correctLp,
"crystalAbsorbedDoseRate": absorbedDoseRate,
}
bestTask = Best(inData=inDataBest,
workingDirectorySuffix=prefix)
bestTask.execute()
def run(self, inData):
outData = {}
listImagePath = inData["imagePath"]
prefix = UtilsImage.getPrefix(listImagePath[0])
listSubWedge = self.getListSubWedge(inData)
diffractionPlan = inData.get("diffractionPlan", {})
sample = inData.get("sample", {})
# Check if flux is present
flux = None
absorbedDoseRate = None
experimentalCondition = inData.get("experimentalCondition", None)
if experimentalCondition is not None:
beam = experimentalCondition.get("beam", None)
if beam is not None:
flux = beam.get("flux", None)
# if not "size" in beam:
# beam["size"] = listSubWedge[0]["experimentalCondition"]["beam"]["size"]
beam["exposureTime"] = listSubWedge[0]["experimentalCondition"]["beam"]["exposureTime"]
beam["wavelength"] = listSubWedge[0]["experimentalCondition"]["beam"]["wavelength"]
# Start indexing
outDataIndexing, outDataGB = self.indexing(prefix, listSubWedge)
if outDataIndexing is not None and outDataGB is not None:
listXdsAsciiHkl, correctLp, bkgpixCbf = self.integration(
prefix, listSubWedge, outDataIndexing, outDataGB)
if listXdsAsciiHkl is not None:
# Check if Raddose should be run
estimateRadiationDamage = self.checkEstimateRadiationDamage(inData, flux)
if estimateRadiationDamage:
# Check if forced space group
forcedSpaceGroup = None
numOperators = None
cell = None
if "diffractionPlan" in inData and "forcedSpaceGroup" in inData["diffractionPlan"]:
forcedSpaceGroup = inData["diffractionPlan"]["forcedSpaceGroup"]
if forcedSpaceGroup is not None:
if forcedSpaceGroup != "":
forcedSpaceGroup = forcedSpaceGroup.replace(" ", "")
numOperators = UtilsSymmetry.getNumberOfSymmetryOperatorsFromSpaceGroupName(forcedSpaceGroup)
else:
forcedSpaceGroup = None
if forcedSpaceGroup is None:
# Get indexing space group IT number
if "resultIndexing" in outDataIndexing:
resultIndexing = outDataIndexing["resultIndexing"]
cell = resultIndexing["cell"]
if "spaceGroupNumber" in resultIndexing:
spaceGroupNumber = resultIndexing["spaceGroupNumber"]
numOperators = UtilsSymmetry.getNumberOfSymmetryOperatorsFromSpaceGroupITNumber(spaceGroupNumber)
if numOperators is None:
raise RuntimeError("Error when trying to determine number of symmetry operators!")
chemicalComposition = self.getDefaultChemicalComposition(cell, numOperators)
numberOfImages = self.getNumberOfImages(listSubWedge)
sample = inData["sample"]
inDataRaddose = {
"experimentalCondition": experimentalCondition,
"chemicalComposition": chemicalComposition,
"sample": sample,
"cell": cell,
"numberOfImages": numberOfImages,
"numOperators": numOperators
}
# import pprint
# pprint.pprint(inDataRaddose)
raddose = Raddose(
inData=inDataRaddose,
workingDirectorySuffix=prefix)
raddose.execute()
if raddose.isSuccess():
absorbedDoseRate = raddose.outData["absorbedDoseRate"]
inDataBest = {
"diffractionPlan": diffractionPlan,
"sample": sample,
"subWedge": listSubWedge,
"xdsAsciiHkl": listXdsAsciiHkl,
"bkgpixCbf": bkgpixCbf,
"correctLp": correctLp,
"crystalAbsorbedDoseRate": absorbedDoseRate
}
bestTask = Best(
inData=inDataBest,
workingDirectorySuffix=prefix
)
bestTask.execute()