def candidate_basis_vectors_fft1d(reciprocal_lattice_vectors, params, max_cell=None): # Spot_positions: Centroid positions for spotfinder spots, in pixels # Return value: Corrected for parallax, converted to mm # derive a max_cell from mm spots # derive a grid sampling from spots from rstbx.indexing_api.lattice import DPS_primitive_lattice # max_cell: max possible cell in Angstroms; set to None, determine from data # recommended_grid_sampling_rad: grid sampling in radians; guess for now DPS = DPS_primitive_lattice(max_cell=max_cell, recommended_grid_sampling_rad = None, horizon_phil = params) from scitbx import matrix #DPS.S0_vector = matrix.col(beam.get_s0()) #DPS.inv_wave = 1./beam.get_wavelength() # transform input into what Nick needs # i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees DPS.index(reciprocal_space_vectors=reciprocal_lattice_vectors) solutions = DPS.getSolutions() return [matrix.col(s.bvec()) for s in solutions],DPS.getXyzData()
def find_basis_vectors(self, reciprocal_lattice_vectors): """Find a list of likely basis vectors. Args: reciprocal_lattice_vectors (scitbx.array_family.flex.vec3_double): The list of reciprocal lattice vectors to search for periodicity. Returns: A tuple containing the list of basis vectors and a flex.bool array identifying which reflections were used in indexing. """ from rstbx.phil.phil_preferences import indexing_api_defs import iotbx.phil used_in_indexing = flex.bool(reciprocal_lattice_vectors.size(), True) hardcoded_phil = iotbx.phil.parse( input_string=indexing_api_defs).extract() # Spot_positions: Centroid positions for spotfinder spots, in pixels # Return value: Corrected for parallax, converted to mm # derive a max_cell from mm spots # derive a grid sampling from spots from rstbx.indexing_api.lattice import DPS_primitive_lattice # max_cell: max possible cell in Angstroms; set to None, determine from data # recommended_grid_sampling_rad: grid sampling in radians; guess for now DPS = DPS_primitive_lattice( max_cell=self._max_cell, recommended_grid_sampling_rad=self._params.characteristic_grid, horizon_phil=hardcoded_phil, ) # transform input into what Nick needs # i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees DPS.index(reciprocal_space_vectors=reciprocal_lattice_vectors) solutions = DPS.getSolutions() candidate_basis_vectors = [matrix.col(s.bvec()) for s in solutions] return candidate_basis_vectors, used_in_indexing
def candidate_basis_vectors_fft1d(reciprocal_lattice_vectors, params, max_cell=None): # Spot_positions: Centroid positions for spotfinder spots, in pixels # Return value: Corrected for parallax, converted to mm # derive a max_cell from mm spots # derive a grid sampling from spots from rstbx.indexing_api.lattice import DPS_primitive_lattice # max_cell: max possible cell in Angstroms; set to None, determine from data # recommended_grid_sampling_rad: grid sampling in radians; guess for now DPS = DPS_primitive_lattice(max_cell=max_cell, recommended_grid_sampling_rad=None, horizon_phil=params) from scitbx import matrix #DPS.S0_vector = matrix.col(beam.get_s0()) #DPS.inv_wave = 1./beam.get_wavelength() # transform input into what Nick needs # i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees DPS.index(reciprocal_space_vectors=reciprocal_lattice_vectors) solutions = DPS.getSolutions() return [matrix.col(s.bvec()) for s in solutions], DPS.getXyzData()
def run_dps(args): imageset, spots_mm, max_cell, params = args detector = imageset.get_detector() beam = imageset.get_beam() goniometer = imageset.get_goniometer() scan = imageset.get_scan() from rstbx.indexing_api.lattice import DPS_primitive_lattice # max_cell: max possible cell in Angstroms; set to None, determine from data # recommended_grid_sampling_rad: grid sampling in radians; guess for now DPS = DPS_primitive_lattice(max_cell=max_cell, recommended_grid_sampling_rad=None, horizon_phil=params) from scitbx import matrix DPS.S0_vector = matrix.col(beam.get_s0()) DPS.inv_wave = 1. / beam.get_wavelength() if goniometer is None: DPS.axis = matrix.col((1, 0, 0)) else: DPS.axis = matrix.col(goniometer.get_rotation_axis()) DPS.set_detector(detector) # transform input into what Nick needs # i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees data = flex.vec3_double() for spot in spots_mm: data.append((spot['xyzobs.mm.value'][0], spot['xyzobs.mm.value'][1], spot['xyzobs.mm.value'][2] * 180. / math.pi)) #from matplotlib import pyplot as plt #plt.plot([spot.centroid_position[0] for spot in spots_mm] , [spot.centroid_position[1] for spot in spots_mm], 'ro') #plt.show() logger.info("Running DPS using %i reflections" % len(data)) DPS.index(raw_spot_input=data, panel_addresses=flex.int([s['panel'] for s in spots_mm])) solutions = DPS.getSolutions() from libtbx.utils import plural_s logger.info("Found %i solution%s with max unit cell %.2f Angstroms." % (len(solutions), plural_s(len(solutions))[1], DPS.amax)) if len(solutions) < 3: from libtbx.utils import Sorry raise Sorry("Not enough solutions: found %i, need at least 3" % (len(solutions))) return dict(solutions=flex.vec3_double([s.dvec for s in solutions]), amax=DPS.amax)
def run_dps(experiment, spots_mm, max_cell): # max_cell: max possible cell in Angstroms; set to None, determine from data # recommended_grid_sampling_rad: grid sampling in radians; guess for now horizon_phil = iotbx.phil.parse(input_string=indexing_api_defs).extract() DPS = DPS_primitive_lattice(max_cell=max_cell, recommended_grid_sampling_rad=None, horizon_phil=horizon_phil) DPS.S0_vector = matrix.col(experiment.beam.get_s0()) DPS.inv_wave = 1.0 / experiment.beam.get_wavelength() if experiment.goniometer is None: DPS.axis = matrix.col((1, 0, 0)) else: DPS.axis = matrix.col(experiment.goniometer.get_rotation_axis()) DPS.set_detector(experiment.detector) # transform input into what DPS needs # i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees data = flex.vec3_double() for spot in spots_mm.rows(): data.append(( spot["xyzobs.mm.value"][0], spot["xyzobs.mm.value"][1], spot["xyzobs.mm.value"][2] * 180.0 / math.pi, )) logger.info("Running DPS using %i reflections" % len(data)) DPS.index( raw_spot_input=data, panel_addresses=flex.int(s["panel"] for s in spots_mm.rows()), ) solutions = DPS.getSolutions() logger.info("Found %i solution%s with max unit cell %.2f Angstroms." % (len(solutions), plural_s(len(solutions))[1], DPS.amax)) # There must be at least 3 solutions to make a set, otherwise return empty result if len(solutions) < 3: return {} return dict(solutions=flex.vec3_double(s.dvec for s in solutions), amax=DPS.amax)
def test_out(process_dictionary,data,phil_set): from rstbx.indexing_api.lattice import DPS_primitive_lattice from scitbx.matrix import col sample_to_beamspot = col((0.,0.,float(process_dictionary['distance']))) detector_d1 = col((1., 0., 0.)) detector_d2 = col((0., 1., 0.)) detector_origin = sample_to_beamspot - \ detector_d1 * float(process_dictionary['xbeam']) - \ detector_d2 * float(process_dictionary['ybeam']) assert detector_d1.length() == 1.0 assert detector_d2.length() == 1.0 assert detector_d1.dot(detector_d2) == 0.0 beam_vector = sample_to_beamspot.normalize() * ( 1./float(process_dictionary['wavelength'])) rot_axis = col(process_dictionary["endstation"].rot_axi) - col((0.0,0.0,0.0)) # coerce to float type DPS = DPS_primitive_lattice(max_cell = float(process_dictionary['ref_maxcel']), recommended_grid_sampling_rad = process_dictionary['recommended_grid_sampling'], horizon_phil = phil_set) DPS.set_beam_vector(beam = -beam_vector) DPS.set_rotation_axis(axis = rot_axis) DPS.set_detector_position(origin = detector_origin, d1 = detector_d1, d2 = detector_d2) DPS.index(raw_spot_input = data) L = DPS.get_basis_general() new_detector = DPS.optimize_origin_offset_local_scope() DPS2= DPS_primitive_lattice(max_cell = float(process_dictionary['ref_maxcel']), recommended_grid_sampling_rad = process_dictionary['recommended_grid_sampling'], horizon_phil = phil_set) DPS2.set_beam_vector(beam = -beam_vector) DPS2.set_rotation_axis(axis = rot_axis) DPS2.set_detector(new_detector) DPS2.index(raw_spot_input = data) L = DPS2.get_basis_general() from rstbx.indexing_api.outlier_procedure import main_go main_go(index_engine=DPS2, phil_set=phil_set) print "Finishing" exit()
def test_dps_single_panel_labelit_input_optimal_origin(process_dictionary,data,phil_set): from rstbx.indexing_api.lattice import DPS_primitive_lattice from scitbx.matrix import col sample_to_beamspot = col((0.,0.,float(process_dictionary['distance']))) detector_d1 = col((1., 0., 0.)) detector_d2 = col((0., 1., 0.)) detector_origin = sample_to_beamspot - \ detector_d1 * float(process_dictionary['xbeam']) - \ detector_d2 * float(process_dictionary['ybeam']) assert detector_d1.length() == 1.0 assert detector_d2.length() == 1.0 assert detector_d1.dot(detector_d2) == 0.0 from dxtbx.model.detector import detector_factory detector = detector_factory.make_detector( stype = "indexing", fast_axis = detector_d1, slow_axis = detector_d2, origin = detector_origin, pixel_size = (float(process_dictionary['pixel_size']), float(process_dictionary['pixel_size'])), image_size = (int(process_dictionary['size1']), int(process_dictionary['size2'])) ) beam_vector = sample_to_beamspot.normalize() * ( 1./float(process_dictionary['wavelength'])) rot_axis = col(process_dictionary["endstation"].rot_axi) - col((0.0,0.0,0.0)) # coerce to float type DPS = DPS_primitive_lattice(max_cell = float(process_dictionary['ref_maxcel']), recommended_grid_sampling_rad = process_dictionary['recommended_grid_sampling'], horizon_phil = phil_set) DPS.set_beam_vector(beam = -beam_vector) DPS.set_rotation_axis(axis = rot_axis) DPS.set_detector(detector) DPS.index(raw_spot_input = data) #L = DPS.get_basis_general() # can skip this first time around new_detector = DPS.optimize_origin_offset_local_scope() DPS2= DPS_primitive_lattice(max_cell = float(process_dictionary['ref_maxcel']), recommended_grid_sampling_rad = process_dictionary['recommended_grid_sampling'], horizon_phil = phil_set) DPS2.set_beam_vector(beam = -beam_vector) DPS2.set_rotation_axis(axis = rot_axis) DPS2.set_detector(new_detector) DPS2.index(raw_spot_input = data) L = DPS2.get_basis_general()
def test_dps_single_panel_labelit_input_optimal_origin(process_dictionary,data,phil_set): from rstbx.indexing_api.lattice import DPS_primitive_lattice from scitbx.matrix import col sample_to_beamspot = col((0.,0.,float(process_dictionary['distance']))) detector_d1 = col((1., 0., 0.)) detector_d2 = col((0., 1., 0.)) detector_origin = sample_to_beamspot - \ detector_d1 * float(process_dictionary['xbeam']) - \ detector_d2 * float(process_dictionary['ybeam']) assert detector_d1.length() == 1.0 assert detector_d2.length() == 1.0 assert detector_d1.dot(detector_d2) == 0.0 from dxtbx.model import DetectorFactory detector = DetectorFactory.make_detector( stype = "indexing", fast_axis = detector_d1, slow_axis = detector_d2, origin = detector_origin, pixel_size = (float(process_dictionary['pixel_size']), float(process_dictionary['pixel_size'])), image_size = (int(process_dictionary['size1']), int(process_dictionary['size2'])) ) beam_vector = sample_to_beamspot.normalize() * ( 1./float(process_dictionary['wavelength'])) rot_axis = col(process_dictionary["endstation"].rot_axi) - col((0.0,0.0,0.0)) # coerce to float type DPS = DPS_primitive_lattice(max_cell = float(process_dictionary['ref_maxcel']), recommended_grid_sampling_rad = process_dictionary['recommended_grid_sampling'], horizon_phil = phil_set) DPS.set_beam_vector(beam = -beam_vector) DPS.set_rotation_axis(axis = rot_axis) DPS.set_detector(detector) DPS.index(raw_spot_input = data) #L = DPS.get_basis_general() # can skip this first time around new_detector = DPS.optimize_origin_offset_local_scope() DPS2= DPS_primitive_lattice(max_cell = float(process_dictionary['ref_maxcel']), recommended_grid_sampling_rad = process_dictionary['recommended_grid_sampling'], horizon_phil = phil_set) DPS2.set_beam_vector(beam = -beam_vector) DPS2.set_rotation_axis(axis = rot_axis) DPS2.set_detector(new_detector) DPS2.index(raw_spot_input = data) L = DPS2.get_basis_general()
def run_dps(args): imageset, spots_mm, max_cell, params = args detector = imageset.get_detector() beam = imageset.get_beam() goniometer = imageset.get_goniometer() # max_cell: max possible cell in Angstroms; set to None, determine from data # recommended_grid_sampling_rad: grid sampling in radians; guess for now DPS = DPS_primitive_lattice(max_cell=max_cell, recommended_grid_sampling_rad=None, horizon_phil=params) DPS.S0_vector = matrix.col(beam.get_s0()) DPS.inv_wave = 1.0 / beam.get_wavelength() if goniometer is None: DPS.axis = matrix.col((1, 0, 0)) else: DPS.axis = matrix.col(goniometer.get_rotation_axis()) DPS.set_detector(detector) # transform input into what Nick needs # i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees data = flex.vec3_double() for spot in spots_mm.rows(): data.append(( spot["xyzobs.mm.value"][0], spot["xyzobs.mm.value"][1], spot["xyzobs.mm.value"][2] * 180.0 / math.pi, )) logger.info("Running DPS using %i reflections" % len(data)) DPS.index( raw_spot_input=data, panel_addresses=flex.int(s["panel"] for s in spots_mm.rows()), ) solutions = DPS.getSolutions() logger.info("Found %i solution%s with max unit cell %.2f Angstroms." % (len(solutions), plural_s(len(solutions))[1], DPS.amax)) if len(solutions) < 3: raise Sorry("Not enough solutions: found %i, need at least 3" % (len(solutions))) return dict(solutions=flex.vec3_double([s.dvec for s in solutions]), amax=DPS.amax)
def run_dps(args): imageset, spots_mm, max_cell, params = args detector = imageset.get_detector() beam = imageset.get_beam() goniometer = imageset.get_goniometer() scan = imageset.get_scan() from rstbx.indexing_api.lattice import DPS_primitive_lattice # max_cell: max possible cell in Angstroms; set to None, determine from data # recommended_grid_sampling_rad: grid sampling in radians; guess for now DPS = DPS_primitive_lattice(max_cell=max_cell, recommended_grid_sampling_rad=None, horizon_phil=params) from scitbx import matrix DPS.S0_vector = matrix.col(beam.get_s0()) DPS.inv_wave = 1./beam.get_wavelength() if goniometer is None: DPS.axis = matrix.col((1,0,0)) else: DPS.axis = matrix.col(goniometer.get_rotation_axis()) DPS.set_detector(detector) # transform input into what Nick needs # i.e., construct a flex.vec3 double consisting of mm spots, phi in degrees data = flex.vec3_double() for spot in spots_mm: data.append((spot['xyzobs.mm.value'][0], spot['xyzobs.mm.value'][1], spot['xyzobs.mm.value'][2]*180./math.pi)) #from matplotlib import pyplot as plt #plt.plot([spot.centroid_position[0] for spot in spots_mm] , [spot.centroid_position[1] for spot in spots_mm], 'ro') #plt.show() logger.info("Running DPS using %i reflections" %len(data)) DPS.index(raw_spot_input=data, panel_addresses=flex.int([s['panel'] for s in spots_mm])) logger.info("Found %i solutions with max unit cell %.2f Angstroms." %( len(DPS.getSolutions()), DPS.amax)) return dict(solutions=flex.vec3_double( [s.dvec for s in DPS.getSolutions()]), amax=DPS.amax)