def testDeSerialize(self):
""" Test deserialization (i.e. construction from a file/string). """
# Setup geometry.
geometry = DetectorGeometry(panels=[self.__panel0, self.__panel1])
# Serialize
stream = io.StringIO()
geometry.serialize(stream=stream)
serialized_panel = stream.getvalue()
stream.close()
# Deserialize
deserialized_geometry = _detectorGeometryFromString(serialized_panel)
# Compare.
for i, panel in enumerate(geometry.panels):
self.assertAlmostEqual(panel.ranges,
deserialized_geometry.panels[i].ranges)
self.assertAlmostEqual(panel.corners,
deserialized_geometry.panels[i].corners)
self.assertEqual(panel.fast_scan_xyz,
deserialized_geometry.panels[i].fast_scan_xyz)
self.assertEqual(panel.slow_scan_xyz,
deserialized_geometry.panels[i].slow_scan_xyz)
self.assertAlmostEqual(
panel.pixel_size.magnitude,
deserialized_geometry.panels[i].pixel_size.magnitude)
self.assertAlmostEqual(
panel.distance_from_interaction_plane.magnitude,
deserialized_geometry.panels[i].
distance_from_interaction_plane.magnitude)
def testDeSerializeOnlyCommonBlock(self):
""" Test deserialization when only a common block is present in the file. """
# Read in the file.
with open(TestUtilities.generateTestFilePath(
"one_panel.geom")) as geom_file_handle:
geom_string = "".join(geom_file_handle.readlines())
# Setup geometry.
geometry = _detectorGeometryFromString(geom_string)
# Check parameters from common block
self.assertEqual(len(geometry.panels), 1)
self.assertEqual(geometry.panels[0].energy_response,
1.25e-4 / electronvolt)
def testDeSerializeCommonBlockWithOverwrite(self):
""" Test deserialization when a common block is present but one panel overwrites a parameter."""
# Read in the file.
with open(TestUtilities.generateTestFilePath(
"common_overwrite.geom")) as geom_file_handle:
geom_string = "".join(geom_file_handle.readlines())
# Setup geometry.
geometry = _detectorGeometryFromString(geom_string)
# Check parameters from common block
self.assertEqual(len(geometry.panels), 2)
self.assertEqual(geometry.panels[0].energy_response,
1.0 / electronvolt)
self.assertEqual(geometry.panels[1].energy_response,
2.0 / electronvolt)
def testDeSerializeWithCommonBlock(self):
""" Test deserialization when a common block is present in the file. """
# Read in the file.
with open(TestUtilities.generateTestFilePath(
"simple.geom")) as geom_file_handle:
geom_string = "".join(geom_file_handle.readlines())
# Setup geometry.
geometry = _detectorGeometryFromString(geom_string)
# Check parameters from common block
self.assertEqual(geometry.panels[0].energy_response,
1.0 / electronvolt)
self.assertEqual(geometry.panels[1].energy_response,
1.0 / electronvolt)
# Check parameters from individual blocks
self.assertNotEqual(geometry.panels[0].ranges,
geometry.panels[1].ranges)
def testDeSerializeFromFile(self):
geom_file_path = TestUtilities.generateTestFilePath("simple.geom")
with open(geom_file_path, 'r') as geom_file_handle:
geom_string = ''.join(geom_file_handle.readlines())
geom_instance = _detectorGeometryFromString(geom_string)
def _run(self):
""" Perform the actual calls to pattern_sim. """
# Setup directory structure as needed.
if not os.path.isdir(self.output_path):
os.makedirs(self.output_path)
output_file_base = os.path.join(self.output_path, "diffr_out")
if self.parameters.number_of_diffraction_patterns == 1:
output_file_base += "_0000001.h5"
# Serialize geometry if necessary.
if isinstance(self.parameters.detector_geometry,
str) and os.path.isfile(
self.parameters.detector_geometry):
with open(self.parameters.detector_geometry) as tmp_geom_file:
geom_string = "\n".join(tmp_geom_file.readlines())
self.parameters.detector_geometry = _detectorGeometryFromString(
geom_string)
geom_file = tempfile.NamedTemporaryFile(suffix=".geom", delete=True)
geom_filename = geom_file.name
self.parameters.detector_geometry.serialize(stream=geom_filename,
caller=self.parameters)
# Setup command, minimum set first.
# Distribute patterns over available processes in round-robin.
command_sequence = [
'pattern_sim',
'-p%s' % self.parameters.sample,
'--geometry=%s' % geom_filename,
'--output=%s' % (output_file_base),
'--number=%d' % (self.parameters.number_of_diffraction_patterns)
]
# Handle random rotation as requested.
if self.parameters.uniform_rotation is True:
command_sequence.append('--random-orientation')
command_sequence.append('--really-random')
if self.parameters.beam_parameters is not None:
command_sequence.append(
'--photon-energy=%f' %
(self.parameters.beam_parameters.photon_energy.m_as(
electronvolt)))
command_sequence.append('--beam-bandwidth=%f' %
(self.parameters.beam_parameters.
photon_energy_relative_bandwidth))
nphotons = self.parameters.beam_parameters.pulse_energy / self.parameters.beam_parameters.photon_energy
command_sequence.append('--nphotons=%e' % (nphotons))
command_sequence.append(
'--beam-radius=%e' %
(self.parameters.beam_parameters.beam_diameter_fwhm.m_as(meter)
/ 2.))
command_sequence.append('--spectrum=%s' %
(self.parameters.beam_parameters.
photon_energy_spectrum_type.lower()))
if self.parameters.beam_parameters.photon_energy_spectrum_type.lower(
) == "sase":
command_sequence.append('--sample-spectrum=512')
# Handle intensities list if present.
if self.parameters.intensities_file is not None:
command_sequence.append('--intensities=%s' %
(self.parameters.intensities_file))
# Handle powder if present.
if self.parameters.powder is True:
command_sequence.append(
'--powder=%s' % (os.path.join(self.output_path, "powder.h5")))
# Handle size range if present.
if self.parameters.crystal_size_min is not None:
command_sequence.append(
'--min-size=%f' %
(self.parameters.crystal_size_min.m_as(1e-9 * meter)))
if self.parameters.crystal_size_max is not None:
command_sequence.append(
'--max-size=%f' %
(self.parameters.crystal_size_max.m_as(1e-9 * meter)))
# Handle gpu acceleration.
if self.parameters.gpus_per_task > 0:
# Check if crystfel was built with opencv support.
# Get pattern_sim's path.
pattern_sim_path = subprocess.check_output(
shlex.split("which pattern_sim"))[:-1].decode('utf-8')
# Get list of dynamic dependencies.
ldd = subprocess.check_output(
shlex.split("ldd " + pattern_sim_path)).decode('utf-8')
if "libOpenCL.so.1" in ldd:
command_sequence.append('--gpu')
if 'SIMEX_VERBOSE' in os.environ:
print("Pattern_sim call: " + " ".join(command_sequence))
# Run the backengine command.
proc = subprocess.Popen(command_sequence)
proc.wait()
return proc.returncode
