def characteriseWithXmlInput(self, data_collection_id, sampleCharacteriseIndex, beamsize):
if data_collection_id is not None:
self.ednaInput.setDataCollectionId(XSDataInteger(data_collection_id))
else:
self.ednaInput.setDataCollectionId(None)
logging.getLogger().warning("The data collection ID is not known for this characterisation. Therefore the EDNA results cannot be put into the database")
# build data set
imageSuffix = self.beamlinePars["BCM_PARS"].getProperty("FileSuffix")
dataSetObj = XSDataMXCuBEDataSet()
self.ednaInput.setDataSet([])
methodDCNo = len(self.current_method[1])
for methodIndex in range(methodDCNo):
number_of_images = self.current_method[1][methodIndex]['number_of_images']
imageNameIdx = self.current_method[0]
listIndex = sampleCharacteriseIndex * methodDCNo + methodIndex
for imageno in range(int(number_of_images)):
imageFileObj = XSDataFile()
pathStrObj = XSDataString()
pathStrObj.setValue(('%s/%s_%d_%04d.%s' % (self.collectSeqList[listIndex]['fileinfo']['directory'],\
self.collectSeqList[listIndex]['fileinfo']['prefix'],\
int(self.collectSeqList[listIndex]['fileinfo']['run_number']),\
imageno+1,imageSuffix)))
imageFileObj.setPath(pathStrObj)
dataSetObj.addImageFile(imageFileObj)
self.ednaInput.addDataSet(dataSetObj)
if TEST:
self.ednaInput.getDataSet()[0].getImageFile()[0].getPath().setValue("/opt/pxsoft/DNA/TestCase/ref-testscale_1_001.img")
self.ednaInput.getDataSet()[0].getImageFile()[1].getPath().setValue("/opt/pxsoft/DNA/TestCase/ref-testscale_1_002.img")
path = self.process_dir
suffix = '_%s.xml' % (self.ednaInput.getDataCollectionId().getValue() or id(self.ednaInput))
ednaResultsFile = os.path.join(path, 'EDNAOutput%s' % suffix)
ednaInputXMLFile = os.path.join(path, 'EDNAInput%s' % suffix)
if not os.path.isdir(path):
os.makedirs(path)
beamObj = self.ednaInput.getExperimentalCondition().getBeam()
beamObj.setSize(XSDataSize(x=XSDataLength(float(beamsize[0])),y=XSDataLength(float(beamsize[1]))))
""" create an edna input file using the ednainput model """
ednaInputXML = self.ednaInput.exportToFile(ednaInputXMLFile)
logging.getLogger().info("Starting Edna using xml file, %s" % ednaInputXMLFile)
# use an intermediate script to run edna with its command line options
edna_args = "%s %s %s" % (ednaInputXMLFile,ednaResultsFile,path)
edna_cmd=self.StartEdnaCommand+" "+edna_args
if self.ednaPollTimer is None:
self.ednaPollTimer = qt.QTimer()
qt.QObject.connect(self.ednaPollTimer,qt.SIGNAL("timeout()"), self.pollEDNA)
logging.getLogger().debug(edna_cmd)
EDNA_PROCESSES.append(EnhancedPopen.Popen(edna_cmd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True,universal_newlines=True))
self.EDNAResultsFiles[id(EDNA_PROCESSES[-1])]=ednaResultsFile
# save image prefix,etc. for next step
# only take first image, since we just want to have image prefix, run number, etc. :
# it is the same within the whole collectSeqList (hopefully)
imagePrefix = self.collectSeqList[0]['fileinfo']['prefix'][4:] #remove ref-
self.imagePathProperties[id(EDNA_PROCESSES[-1])]={"imagePrefix":imagePrefix, "imageDir": self.collectSeqList[0]['fileinfo']['directory'], "lRunN": int(self.collectSeqList[0]['fileinfo']['run_number'])}
self.ednaPollTimer.start(100)
def from_params(self, data_collection, char_params):
edna_input = XSDataInputMXCuBE.parseString(self.edna_default_input)
if data_collection.id:
edna_input.setDataCollectionId(XSDataInteger(data_collection.id))
#Beam object
beam = edna_input.getExperimentalCondition().getBeam()
try:
transmission = self.collect_obj.get_transmission()
beam.setTransmission(XSDataDouble(transmission))
except AttributeError:
pass
try:
wavelength = self.collect_obj.get_wavelength()
beam.setWavelength(XSDataWavelength(wavelength))
except AttributeError:
pass
try:
beam.setFlux(XSDataFlux(self.collect_obj.get_measured_intensity()))
except AttributeError:
pass
try:
beamsize = self.get_beam_size()
if not None in beamsize:
beam.setSize(
XSDataSize(x=XSDataLength(float(beamsize[0])),
y=XSDataLength(float(beamsize[1]))))
except AttributeError:
pass
#Optimization parameters
diff_plan = edna_input.getDiffractionPlan()
aimed_i_sigma = XSDataDouble(char_params.aimed_i_sigma)
aimed_completness = XSDataDouble(char_params.aimed_completness)
aimed_multiplicity = XSDataDouble(char_params.aimed_multiplicity)
aimed_resolution = XSDataDouble(char_params.aimed_resolution)
complexity = char_params.strategy_complexity
complexity = XSDataString(qme.STRATEGY_COMPLEXITY[complexity])
permitted_phi_start = XSDataAngle(char_params.permitted_phi_start)
_range = char_params.permitted_phi_end - char_params.permitted_phi_start
rotation_range = XSDataAngle(_range)
diff_plan.setAimedIOverSigmaAtHighestResolution(aimed_i_sigma)
diff_plan.setAimedCompleteness(aimed_completness)
if char_params.use_aimed_multiplicity:
diff_plan.setAimedMultiplicity(aimed_multiplicity)
if char_params.use_aimed_resolution:
diff_plan.setAimedResolution(aimed_resolution)
diff_plan.setComplexity(complexity)
if char_params.use_permitted_rotation:
diff_plan.setUserDefinedRotationStart(permitted_phi_start)
diff_plan.setUserDefinedRotationRange(rotation_range)
#Vertical crystal dimension
sample = edna_input.getSample()
sample.getSize().setY(XSDataLength(char_params.max_crystal_vdim))
sample.getSize().setZ(XSDataLength(char_params.min_crystal_vdim))
#Radiation damage model
sample.setSusceptibility(XSDataDouble(char_params.rad_suscept))
sample.setChemicalComposition(None)
sample.setRadiationDamageModelBeta(XSDataDouble(char_params.beta /
1e6))
sample.setRadiationDamageModelGamma(
XSDataDouble(char_params.gamma / 1e6))
diff_plan.setForcedSpaceGroup(XSDataString(char_params.space_group))
# Characterisation type - Routine DC
if char_params.use_min_dose:
pass
if char_params.use_min_time:
time = XSDataTime(char_params.min_time)
diff_plan.setMaxExposureTimePerDataCollection(time)
# Account for radiation damage
if char_params.induce_burn:
diff_plan.setStrategyOption(XSDataString("-DamPar"))
else:
diff_plan.setStrategyOption(None)
# Characterisation type - SAD
if char_params.opt_sad:
diff_plan.setAnomalousData(XSDataBoolean(True))
else:
diff_plan.setAnomalousData(XSDataBoolean(False))
#Data set
data_set = XSDataMXCuBEDataSet()
acquisition_parameters = data_collection.acquisitions[
0].acquisition_parameters
path_template = data_collection.acquisitions[0].path_template
path_str = os.path.join(path_template.directory,
path_template.get_image_file_name())
for img_num in range(int(acquisition_parameters.num_images)):
image_file = XSDataFile()
path = XSDataString()
path.setValue(path_str % (img_num + 1))
image_file.setPath(path)
data_set.addImageFile(image_file)
edna_input.addDataSet(data_set)
edna_input.process_directory = path_template.process_directory
return edna_input
def from_params(self, data_collection, char_params):
edna_input = XSDataInputMXCuBE.parseString(EDNA_DEFAULT_INPUT)
if data_collection.id:
edna_input.setDataCollectionId(XSDataInteger(data_collection.id))
#Beam object
beam = edna_input.getExperimentalCondition().getBeam()
try:
beam.setTransmission(XSDataDouble(self.collect_obj.get_transmission()))
except AttributeError:
pass
try:
beam.setWavelength(XSDataWavelength(self.collect_obj.get_wavelength()))
except AttributeError:
pass
try:
beam.setFlux(XSDataFlux(self.collect_obj.get_measured_intensity()))
except AttributeError:
pass
try:
beamsize = self.get_beam_size()
if not None in beamsize:
beam.setSize(XSDataSize(x=XSDataLength(float(beamsize[0])),
y=XSDataLength(float(beamsize[1]))))
except AttributeError:
pass
#Optimization parameters
diff_plan = edna_input.getDiffractionPlan()
diff_plan.setAimedIOverSigmaAtHighestResolution(\
XSDataDouble(char_params.aimed_i_sigma))
diff_plan.setAimedCompleteness(XSDataDouble(char_params.\
aimed_completness))
if char_params.use_aimed_multiplicity:
diff_plan.setAimedMultiplicity(XSDataDouble(char_params.\
aimed_multiplicity))
if char_params.use_aimed_resolution:
diff_plan.setAimedResolution(XSDataDouble(char_params.aimed_resolution))
diff_plan.setComplexity(XSDataString(\
queue_model_enumerables.STRATEGY_COMPLEXITY[char_params.strategy_complexity]))
if char_params.use_permitted_rotation:
diff_plan.setUserDefinedRotationStart(XSDataAngle(char_params.\
permitted_phi_start))
diff_plan.setUserDefinedRotationRange(XSDataAngle(char_params.permitted_phi_end -\
char_params.permitted_phi_start))
#Vertical crystal dimension
sample = edna_input.getSample()
sample.getSize().setY(XSDataLength(char_params.max_crystal_vdim))
sample.getSize().setZ(XSDataLength(char_params.min_crystal_vdim))
#Radiation damage model
sample.setSusceptibility(XSDataDouble(char_params.rad_suscept))
sample.setChemicalComposition(None)
sample.setRadiationDamageModelBeta(XSDataDouble(char_params.beta/1e6))
sample.setRadiationDamageModelGamma(XSDataDouble(char_params.gamma/1e6))
diff_plan.setForcedSpaceGroup(XSDataString(char_params.\
space_group))
# Characterisation type - Routine DC
if char_params.use_min_dose:
pass
if char_params.use_min_time:
diff_plan.setMaxExposureTimePerDataCollection(XSDataTime(char_params.\
min_time))
# Account for radiation damage
if char_params.induce_burn:
diff_plan.setStrategyOption(XSDataString("-DamPar")) # What is -DamPar ?
else:
diff_plan.setStrategyOption(None)
# Characterisation type - SAD
if queue_model_enumerables.EXPERIMENT_TYPE[char_params.experiment_type] is \
queue_model_enumerables.EXPERIMENT_TYPE.SAD:
diff_plan.setAnomalousData(XSDataBoolean(True))
else:
diff_plan.setAnomalousData(XSDataBoolean(False))
#Data set
data_set = XSDataMXCuBEDataSet()
acquisition_parameters = data_collection.acquisitions[0].acquisition_parameters
path_str = os.path.join(data_collection.acquisitions[0].path_template.directory,
data_collection.acquisitions[0].path_template.get_image_file_name())
for img_num in range(int(acquisition_parameters.num_images)):
image_file = XSDataFile()
path = XSDataString()
path.setValue(path_str % (img_num + 1))
image_file.setPath(path)
data_set.addImageFile(image_file)
edna_input.addDataSet(data_set)
edna_input.process_directory = data_collection.acquisitions[0].path_template.process_directory
return edna_input
def from_params(self, data_collection, char_params):
edna_input = XSDataInputMXCuBE.parseString(self.edna_default_input)
if data_collection.id:
edna_input.setDataCollectionId(XSDataInteger(data_collection.id))
# Beam object
beam = edna_input.getExperimentalCondition().getBeam()
try:
transmission = self.collect_obj.get_transmission()
beam.setTransmission(XSDataDouble(transmission))
except AttributeError:
import traceback
logging.getLogger("HWR").debug("DataAnalysis. transmission not saved ")
logging.getLogger("HWR").debug(traceback.format_exc())
try:
wavelength = self.collect_obj.get_wavelength()
beam.setWavelength(XSDataWavelength(wavelength))
except AttributeError:
pass
try:
beam.setFlux(XSDataFlux(self.collect_obj.get_measured_intensity()))
except AttributeError:
pass
try:
min_exp_time = self.collect_obj.detector_hwobj.get_exposure_time_limits()[0]
beam.setMinExposureTimePerImage(XSDataTime(min_exp_time))
except AttributeError:
pass
try:
beamsize = self.get_beam_size()
if None not in beamsize:
beam.setSize(
XSDataSize(
x=XSDataLength(float(beamsize[0])),
y=XSDataLength(float(beamsize[1])),
)
)
except AttributeError:
pass
# Optimization parameters
diff_plan = edna_input.getDiffractionPlan()
aimed_i_sigma = XSDataDouble(char_params.aimed_i_sigma)
aimed_completness = XSDataDouble(char_params.aimed_completness)
aimed_multiplicity = XSDataDouble(char_params.aimed_multiplicity)
aimed_resolution = XSDataDouble(char_params.aimed_resolution)
complexity = char_params.strategy_complexity
complexity = XSDataString(qme.STRATEGY_COMPLEXITY[complexity])
permitted_phi_start = XSDataAngle(char_params.permitted_phi_start)
_range = char_params.permitted_phi_end - char_params.permitted_phi_start
rotation_range = XSDataAngle(_range)
if char_params.aimed_i_sigma:
diff_plan.setAimedIOverSigmaAtHighestResolution(aimed_i_sigma)
if char_params.aimed_completness:
diff_plan.setAimedCompleteness(aimed_completness)
if char_params.use_aimed_multiplicity:
diff_plan.setAimedMultiplicity(aimed_multiplicity)
if char_params.use_aimed_resolution:
diff_plan.setAimedResolution(aimed_resolution)
diff_plan.setComplexity(complexity)
if char_params.use_permitted_rotation:
diff_plan.setUserDefinedRotationStart(permitted_phi_start)
diff_plan.setUserDefinedRotationRange(rotation_range)
# Vertical crystal dimension
sample = edna_input.getSample()
sample.getSize().setY(XSDataLength(char_params.max_crystal_vdim))
sample.getSize().setZ(XSDataLength(char_params.min_crystal_vdim))
# Radiation damage model
sample.setSusceptibility(XSDataDouble(char_params.rad_suscept))
sample.setChemicalComposition(None)
sample.setRadiationDamageModelBeta(XSDataDouble(char_params.beta / 1e6))
sample.setRadiationDamageModelGamma(XSDataDouble(char_params.gamma / 1e6))
diff_plan.setForcedSpaceGroup(XSDataString(char_params.space_group))
# Characterisation type - Routine DC
if char_params.use_min_dose:
pass
if char_params.use_min_time:
time = XSDataTime(char_params.min_time)
diff_plan.setMaxExposureTimePerDataCollection(time)
# Account for radiation damage
if char_params.induce_burn:
self.modify_strategy_option(diff_plan, "-DamPar")
# Characterisation type - SAD
if char_params.opt_sad:
if char_params.auto_res:
diff_plan.setAnomalousData(XSDataBoolean(True))
else:
diff_plan.setAnomalousData(XSDataBoolean(False))
self.modify_strategy_option(diff_plan, "-SAD yes")
diff_plan.setAimedResolution(XSDataDouble(char_params.sad_res))
else:
diff_plan.setAnomalousData(XSDataBoolean(False))
# Data set
data_set = XSDataMXCuBEDataSet()
acquisition_parameters = data_collection.acquisitions[0].acquisition_parameters
path_template = data_collection.acquisitions[0].path_template
path_str = os.path.join(
path_template.directory, path_template.get_image_file_name()
)
for img_num in range(int(acquisition_parameters.num_images)):
image_file = XSDataFile()
path = XSDataString()
path.setValue(path_str % (img_num + 1))
image_file.setPath(path)
data_set.addImageFile(image_file)
edna_input.addDataSet(data_set)
edna_input.process_directory = path_template.process_directory
return edna_input