def channel_pixels(ROI,wavelength_A,flux,N,UMAT_nm,Amatrix_rot,fmodel_generator,output): energy_dependent_fmodel=False if energy_dependent_fmodel: fmodel_generator.reset_wavelength(wavelength_A) fmodel_generator.reset_specific_at_wavelength( label_has="FE1",tables=Fe_oxidized_model,newvalue=wavelength_A) fmodel_generator.reset_specific_at_wavelength( label_has="FE2",tables=Fe_reduced_model,newvalue=wavelength_A) print("USING scatterer-specific energy-dependent scattering factors") sfall_channel = fmodel_generator.get_amplitudes() elif use_g_sfall: global g_sfall if g_sfall is None: g_sfall = fmodel_generator.get_amplitudes() sfall_channel = g_sfall else: sfall_channel = sfall_7122 SIM = nanoBragg(detpixels_slowfast=(3000,3000),pixel_size_mm=0.11,Ncells_abc=(N,N,N), wavelength_A=wavelength_A,verbose=0) SIM.adc_offset_adu = 10 # Do not offset by 40 SIM.region_of_interest = ROI SIM.mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = 50 # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image SIM.distance_mm=141.7 SIM.set_mosaic_blocks(UMAT_nm) #SIM.detector_thick_mm = 0.5 # = 0 for Rayonix #SIM.detector_thicksteps = 1 # should default to 1 for Rayonix, but set to 5 for CSPAD #SIM.detector_attenuation_length_mm = default is silicon # get same noise each time this test is run SIM.seed = 1 SIM.oversample=1 SIM.wavelength_A = wavelength_A SIM.polarization=1 SIM.default_F=0 SIM.Fhkl=sfall_channel SIM.Amatrix_RUB = Amatrix_rot SIM.xtal_shape=shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter=False # flux is always in photons/s SIM.flux=flux SIM.exposure_s=1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm=0.003 #cannot make this 3 microns; spots are too intense temp=SIM.Ncells_abc print("Ncells_abc=",SIM.Ncells_abc) SIM.Ncells_abc=temp from libtbx.development.timers import Profiler P = Profiler("nanoBragg") SIM.printout=True fast = ROI[1][0] + (ROI[1][1]-ROI[1][0])//2 slow = ROI[0][0] + (ROI[0][1]-ROI[0][0])//2 SIM.printout_pixel_fastslow=(slow,fast) from boost_adaptbx.boost.python import streambuf # will deposit printout into output as side effect SIM.add_nanoBragg_spots_nks(streambuf(output)) del P print(("SIM count > 0",(SIM.raw_pixels>0).count(True))) return SIM
def simple_monochromatic_case_GPU(BEAM, DETECTOR, CRYSTAL, SF_model, argchk=False): Famp = SF_model.get_amplitudes(at_angstrom=BEAM.get_wavelength()) # do the simulation SIM = nanoBragg(DETECTOR, BEAM, panel_id=0) SIM.Ncells_abc = (20, 20, 20) SIM.Fhkl = Famp SIM.Amatrix = sqr(CRYSTAL.get_A()).transpose() SIM.oversample = 2 if argchk: print("\nmonochromatic case, GPU argchk") SIM.xtal_shape = shapetype.Gauss_argchk else: print("\nmonochromatic case, GPU no argchk") SIM.xtal_shape = shapetype.Gauss SIM.add_nanoBragg_spots_cuda() SIM.Fbg_vs_stol = water SIM.amorphous_sample_thick_mm = 0.02 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.flux = 1e12 SIM.beamsize_mm = 0.003 # square (not user specified) SIM.exposure_s = 1.0 # multiplies flux x exposure SIM.progress_meter = False SIM.add_background() return SIM
def instantiate_diffBragg(self, verbose=0, oversample=0, device_Id=0, adc_offset=0, default_F=1e3, interpolate=0, use_diffBragg=True, auto_set_spotscale=False): if not use_diffBragg: self.D = nanoBragg(self.detector, self.beam.nanoBragg_constructor_beam, verbose=verbose, panel_id=int(self.panel_id)) else: self.D = diffBragg(self.detector, self.beam.nanoBragg_constructor_beam, verbose) self.using_diffBragg_spots = use_diffBragg self._seedlings() self.D.interpolate = interpolate self._crystal_properties() self._beam_properties() if auto_set_spotscale: self.D.spot_scale = self.determine_spot_scale() self.D.adc_offset_adu = adc_offset self.D.default_F = default_F if oversample > 0: self.D.oversample = int(oversample) self.D.device_Id = device_Id if not self.using_diffBragg_spots: self._full_roi = self.D.region_of_interest else: self.D.vectorize_umats()
def channel_pixels(wavelength_A, flux, N, UMAT_nm, Amatrix_rot, fmodel_generator, local_data): fmodel_generator.reset_wavelength(wavelength_A) fmodel_generator.reset_specific_at_wavelength( label_has="FE1", tables=local_data.get("Fe_oxidized_model"), newvalue=wavelength_A) fmodel_generator.reset_specific_at_wavelength( label_has="FE2", tables=local_data.get("Fe_reduced_model"), newvalue=wavelength_A) print("USING scatterer-specific energy-dependent scattering factors") sfall_channel = fmodel_generator.get_amplitudes() SIM = nanoBragg(detpixels_slowfast=(3000, 3000), pixel_size_mm=0.11, Ncells_abc=(N, N, N), wavelength_A=wavelength_A, verbose=0) SIM.adc_offset_adu = 10 # Do not offset by 40 SIM.mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = 25 # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image SIM.distance_mm = 141.7 SIM.set_mosaic_blocks(UMAT_nm) #SIM.detector_thick_mm = 0.5 # = 0 for Rayonix #SIM.detector_thicksteps = 1 # should default to 1 for Rayonix, but set to 5 for CSPAD #SIM.detector_attenuation_length_mm = default is silicon # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = wavelength_A SIM.polarization = 1 SIM.default_F = 0 SIM.Fhkl = sfall_channel SIM.Amatrix_RUB = Amatrix_rot SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter = False # flux is always in photons/s SIM.flux = flux SIM.exposure_s = 1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm = 0.003 #cannot make this 3 microns; spots are too intense temp = SIM.Ncells_abc print("Ncells_abc=", SIM.Ncells_abc) SIM.Ncells_abc = temp from libtbx.development.timers import Profiler P = Profiler("nanoBragg") if add_spots_algorithm == "NKS": from boost_adaptbx.boost.python import streambuf # will deposit printout into dummy StringIO as side effect SIM.add_nanoBragg_spots_nks(streambuf(StringIO())) elif add_spots_algorithm == "JH": SIM.add_nanoBragg_spots() elif add_spots_algorithm == "cuda": SIM.add_nanoBragg_spots_cuda() else: raise Exception("unknown spots algorithm") del P return SIM
def several_wavelength_case_for_CPU(self): SIM = nanoBragg(self.DETECTOR, self.BEAM, panel_id=0) for x in range(len(self.wavlen)): SIM.flux = self.flux[x] SIM.wavelength_A = self.wavlen[x] print( "CPUnanoBragg_API+++++++++++++ Wavelength %d=%.6f, Flux %.6e, Fluence %.6e" % (x, SIM.wavelength_A, SIM.flux, SIM.fluence)) SIM.Fhkl = self.sfall_channels[x] SIM.Ncells_abc = (20, 20, 20) SIM.Amatrix = sqr(self.CRYSTAL.get_A()).transpose() SIM.oversample = 2 SIM.xtal_shape = shapetype.Gauss SIM.interpolate = 0 SIM.add_nanoBragg_spots() SIM.wavelength_A = self.BEAM.get_wavelength() SIM.Fbg_vs_stol = water SIM.amorphous_sample_thick_mm = 0.02 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.flux = 1e12 SIM.beamsize_mm = 0.003 # square (not user specified) SIM.exposure_s = 1.0 # multiplies flux x exposure SIM.progress_meter = False SIM.add_background() return SIM
def __init__(self): self.SIM = nanoBragg() self.SIM.progress_meter = False self.SIM.Fbg_vs_stol = water self.SIM.amorphous_sample_thick_mm = 0.1 self.SIM.amorphous_density_gcm3 = 1 self.SIM.amorphous_molecular_weight_Da = 18 self.total_flux = self.SIM.flux = 1e12 self.verbose_beams = False
def __call__(self, N, UMAT_nm, Amatrix_rot, sfall_channel): SIM = nanoBragg(detpixels_slowfast=(3000, 3000), pixel_size_mm=0.11, Ncells_abc=(N, N, N), wavelength_A=self.wavlen[0], verbose=0) SIM.adc_offset_adu = 10 # Do not offset by 40 SIM.mosaic_domains = n_mosaic_domains # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image SIM.mosaic_spread_deg = mosaic_spread_deg # interpreted by UMAT_nm as a half-width stddev SIM.distance_mm = distance_mm SIM.set_mosaic_blocks(UMAT_nm) #SIM.detector_thick_mm = 0.5 # = 0 for Rayonix #SIM.detector_thicksteps = 1 # should default to 1 for Rayonix, but set to 5 for CSPAD #SIM.detector_attenuation_length_mm = default is silicon # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.polarization = 1 SIM.default_F = 0 SIM.Fhkl = sfall_channel SIM.Amatrix_RUB = Amatrix_rot SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter = False # flux is always in photons/s #SIM.flux=0.8E10 # number of photons per 100 ps integrated pulse, 24-bunch APS SIM.flux = 0.8E12 # number of photons per 100 ps integrated pulse, 24-bunch APS SIM.xray_source_wavelengths_A = self.wavlen SIM.xray_source_intensity_fraction = self.norm_intensity SIM.xray_source_XYZ = self.source_XYZ SIM.exposure_s = 1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm = 0.003 #cannot make this 3 microns; spots are too intense temp = SIM.Ncells_abc print("Ncells_abc=", SIM.Ncells_abc) SIM.Ncells_abc = temp from libtbx.development.timers import Profiler P = Profiler("nanoBragg") if add_spots_algorithm is "NKS": print("USING NKS") from boost.python import streambuf # will deposit printout into dummy StringIO as side effect SIM.add_nanoBragg_spots_nks(streambuf(StringIO())) elif add_spots_algorithm is "JH": print("USING JH") SIM.add_nanoBragg_spots() elif add_spots_algorithm is "cuda": print("USING cuda") SIM.add_nanoBragg_spots_cuda() else: raise Exception("unknown spots algorithm") del P return SIM
def channel_pixels(simparams=None,single_wavelength_A=None,single_flux=None,N=None,UMAT_nm=None, \ Amatrix_rot=None,sfall_channel=None,rank=None): # print("## inside channel wavlength/flux = ", single_wavelength_A, single_flux/simparams.flux) SIM = nanoBragg(detpixels_slowfast=(simparams.detector_size_ny,simparams.detector_size_nx),pixel_size_mm=simparams.pixel_size_mm,\ Ncells_abc=(N,N,N),wavelength_A=single_wavelength_A,verbose=0) SIM.adc_offset_adu = 10 # Do not offset by 40 SIM.seed = 0 SIM.mosaic_spread_deg = simparams.mosaic_spread_deg # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = simparams.mosaic_domains # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image SIM.distance_mm = simparams.distance_mm SIM.set_mosaic_blocks(UMAT_nm) ###################### SIM.beamcenter_convention = convention.ADXV SIM.beam_center_mm = (simparams.beam_center_x_mm, simparams.beam_center_y_mm) # 95.975 96.855 ###################### # get same noise each time this test is run SIM.seed = 0 SIM.oversample = simparams.oversample SIM.wavelength_A = single_wavelength_A SIM.polarization = simparams.polarization SIM.default_F = simparams.default_F SIM.Fhkl = sfall_channel SIM.Amatrix_RUB = Amatrix_rot SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter = False # flux is always in photons/s SIM.flux = single_flux SIM.exposure_s = simparams.exposure_s # so total fluence is e12 # assumes round beam SIM.beamsize_mm = simparams.beamsize_mm #cannot make this 3 microns; spots are too intense temp = SIM.Ncells_abc SIM.Ncells_abc = temp # SIM.show_params() add_spots_algorithm = simparams.add_spots_algorithm if add_spots_algorithm == "NKS": from boost.python import streambuf # will deposit printout into dummy StringIO as side effect SIM.add_nanoBragg_spots_nks(streambuf(StringIO())) elif add_spots_algorithm == "JH": SIM.add_nanoBragg_spots() elif add_spots_algorithm == "cuda": devices_per_node = int(os.environ["DEVICES_PER_NODE"]) SIM.device_Id = rank % devices_per_node #if rank==7: # os.system("nvidia-smi") SIM.add_nanoBragg_spots_cuda() else: raise Exception("!!! unknown spots algorithm") return SIM
def channel_pixels(wavelength_A, flux, N, UMAT_nm, Amatrix_rot, rank, sfall_channel): if rank in [0, 7]: print("USING scatterer-specific energy-dependent scattering factors") SIM = nanoBragg(detpixels_slowfast=(3000, 3000), pixel_size_mm=0.11, Ncells_abc=(N, N, N), wavelength_A=wavelength_A, verbose=0) SIM.adc_offset_adu = 10 # Do not offset by 40 SIM.mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = 25 # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image SIM.distance_mm = 141.7 SIM.set_mosaic_blocks(UMAT_nm) #SIM.detector_thick_mm = 0.5 # = 0 for Rayonix #SIM.detector_thicksteps = 1 # should default to 1 for Rayonix, but set to 5 for CSPAD #SIM.detector_attenuation_length_mm = default is silicon # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = wavelength_A SIM.polarization = 1 SIM.default_F = 0 SIM.Fhkl = sfall_channel SIM.Amatrix_RUB = Amatrix_rot SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter = False # flux is always in photons/s SIM.flux = flux SIM.exposure_s = 1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm = 0.003 #cannot make this 3 microns; spots are too intense temp = SIM.Ncells_abc if rank in [0, 7]: print("Ncells_abc=", SIM.Ncells_abc) SIM.Ncells_abc = temp if rank in [0, 7]: P = Profiler("nanoBragg C++ rank %d" % (rank)) if add_spots_algorithm == "NKS": from boost_adaptbx.boost.python import streambuf # will deposit printout into dummy StringIO as side effect SIM.add_nanoBragg_spots_nks(streambuf(StringIO())) elif add_spots_algorithm == "JH": SIM.add_nanoBragg_spots() elif add_spots_algorithm == "cuda": SIM.xtal_shape = shapetype.Gauss_argchk devices_per_node = int(os.environ["DEVICES_PER_NODE"]) SIM.device_Id = rank % devices_per_node #if rank==7: # os.system("nvidia-smi") SIM.add_nanoBragg_spots_cuda() else: raise Exception("unknown spots algorithm") if rank in [0, 7]: del P return SIM
def run_sim2smv(fileout): SIM = nanoBragg(detpixels_slowfast=(1000, 1000), pixel_size_mm=0.1, Ncells_abc=(5, 5, 5), verbose=0) SIM.mosaic_spread_deg = MOSAIC_SPREAD # apparently this is half width SIM.mosaic_domains = SAMPLE_SIZE SIM.distance_mm = 100 # this triggers the generation of mosaic distribution UMAT_th = SIM.get_mosaic_blocks() # extract top-hat distributed U-mats #sanity checks on the top hat distribution th_angles = check_distributions.get_angular_rotation(UMAT_th) max_angle = flex.max(th_angles) assert max_angle <= MOSAIC_SPREAD + 0.0000001 # need to allow a small epsilon assert max_angle > 0.99 * MOSAIC_SPREAD # insist that max angle is near the limit we gave it rms_angle = math.sqrt(flex.mean(th_angles * th_angles)) print(rms_angle) assert rms_angle < MOSAIC_SPREAD import scitbx # compute an array of normally-distributed U-mats into the simulator UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister( seed=0) # set seed, get reproducible results scitbx.random.set_random_seed(4321) # set seed, get reproducibe results rand_norm = scitbx.random.normal_distribution(mean=0, sigma=rms_angle * math.pi / 180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(SAMPLE_SIZE) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append(site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) # set the normally-distributed U-mats into the simulator: SIM.set_mosaic_blocks(UMAT_nm) # get them back new_UMAT_nm = SIM.get_mosaic_blocks() #double check that simulator does not alter the UMATs for iumat in range(0, SAMPLE_SIZE, 100): assert UMAT_nm[iumat] == new_UMAT_nm[iumat] #sanity check on the gaussian distribution nm_angles = check_distributions.get_angular_rotation(new_UMAT_nm) nm_rms_angle = math.sqrt(flex.mean(nm_angles * nm_angles)) print(nm_rms_angle) assert approx_equal(rms_angle,nm_rms_angle,eps=1e-03), \ "The top hat and gaussian models should have similar standard deviations" return UMAT_th, new_UMAT_nm
def sim_background(DETECTOR, BEAM, wavelengths, wavelength_weights, total_flux, pidx=0, beam_size_mm=0.001, Fbg_vs_stol=None, sample_thick_mm=100, density_gcm3=1, molecular_weight=18): """ :param DETECTOR: :param BEAM: see sim_spots :param wavelengths: see sim_spots :param wavelength_weights: see sim_spots :param total_flux: see sim_spots :param pidx: see sim_spots :param beam_size_mm: see sim_spots :param Fbg_vs_stol: list of tuples where each tuple is (Fbg, sin theta over lambda) :param sample_thick_mm: path length of background that is exposed by the beam :param density_gcm3: density of background (defaults to water) :param molecular_weight: molecular weight of background (defaults to water) :return: raw_pixels as flex array, these can be passed to sim_spots function below """ wavelength_weights = np.array(wavelength_weights) weights = wavelength_weights / wavelength_weights.sum() * total_flux spectrum = list(zip(wavelengths, weights)) xray_beams = get_xray_beams(spectrum, BEAM) SIM = nanoBragg(DETECTOR, BEAM, panel_id=(int(pidx))) SIM.beamsize_mm = beam_size_mm SIM.xray_beams = xray_beams if Fbg_vs_stol is None: Fbg_vs_stol = flex.vec2_double([(0, 2.57), (0.0365, 2.58), (0.07, 2.8), (0.12, 5), (0.162, 8), (0.18, 7.32), (0.2, 6.75), (0.216, 6.75), (0.236, 6.5), (0.28, 4.5), (0.3, 4.3), (0.345, 4.36), (0.436, 3.77), (0.5, 3.17)]) SIM.flux = sum(weights) SIM.Fbg_vs_stol = Fbg_vs_stol SIM.amorphous_sample_thick_mm = sample_thick_mm SIM.amorphous_density_gcm3 = density_gcm3 SIM.amorphous_molecular_weight_Da = molecular_weight SIM.progress_meter = False SIM.add_background() background_raw_pixels = SIM.raw_pixels.deep_copy() SIM.free_all() del SIM return background_raw_pixels
def instantiate_nanoBragg(self, verbose=0, oversample=0, device_Id=0, adc_offset=0, default_F=1000.0, interpolate=0, pid=0): self.D = nanoBragg(self.detector, self.beam.nanoBragg_constructor_beam, verbose=verbose, panel_id=int(pid)) self._seedlings() self.D.interpolate = interpolate self._crystal_properties() self._beam_properties() self.D.spot_scale = self.determine_spot_scale() self.D.adc_offset_adu = adc_offset self.D.default_F = default_F if oversample > 0: self.D.oversample = oversample if self.using_cuda: self.D.device_Id = device_Id self._full_roi = self.D.region_of_interest
def __init__(self, parent, params, add_background=True, add_noise=True, randomize=True, pixel_scale=None, preview=True): Thread.__init__(self) self.SIM = nanoBragg(detpixels_slowfast=(1231, 1263), pixel_size_mm=0.344, Ncells_abc=(5, 5, 5)) self.parent = parent self.params = params self.add_background = add_background self.add_noise = add_noise self.randomize = randomize self.crystal_size = pixel_scale self.preview = preview
def __init__(self, BEAM, DETECTOR, CRYSTAL, SF_model): SIM = nanoBragg(DETECTOR, BEAM, panel_id=0) print("\nassume three energy channels") self.wavlen = flex.double([ BEAM.get_wavelength() - 0.002, BEAM.get_wavelength(), BEAM.get_wavelength() + 0.002 ]) self.flux = flex.double([(1. / 6.) * SIM.flux, (3. / 6.) * SIM.flux, (2. / 6.) * SIM.flux]) self.sfall_channels = {} for x in range(len(self.wavlen)): self.sfall_channels[x] = SF_model.get_amplitudes( at_angstrom=self.wavlen[x]) self.DETECTOR = DETECTOR self.BEAM = BEAM self.CRYSTAL = CRYSTAL
def channel_pixels(wavelength_A, flux, UMAT_nm, Amatrix_rot, rank, sfall_channel): SIM = nanoBragg(detpixels_slowfast=detpixels_slowfast, pixel_size_mm=pixsize_mm, Ncells_abc=Ncells_abc, wavelength_A=wavelength_A, verbose=verbose) SIM.adc_offset_adu = offset_adu SIM.mosaic_spread_deg = mos_spread_deg # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = mos_doms # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image SIM.distance_mm = distance_mm SIM.set_mosaic_blocks(UMAT_nm) # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = wavelength_A SIM.polarization = 1 SIM.default_F = 0 SIM.Fhkl = sfall_channel.amplitudes() SIM.Amatrix_RUB = Amatrix_rot SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter = True # False # flux is always in photons/s SIM.flux = flux SIM.exposure_s = exposure_s # assumes round beam SIM.beamsize_mm = beam_size_mm temp = SIM.Ncells_abc SIM.Ncells_abc = temp #P = Profiler("nanoBragg C++ rank %d"%(rank)) if add_spots_algorithm is "NKS": from boost.python import streambuf # will deposit printout into dummy StringIO as side effect SIM.add_nanoBragg_spots_nks(streambuf(StringIO())) elif add_spots_algorithm is "JH": SIM.add_nanoBragg_spots() elif add_spots_algorithm is "cuda": SIM.timelog = timelog SIM.device_Id = device_Id SIM.add_nanoBragg_spots_cuda() else: raise Exception("unknown spots algorithm") #del P return SIM
def run_sim2smv(fileout): SIM = nanoBragg(detpixels_slowfast=(1000,1000),pixel_size_mm=0.1,Ncells_abc=(5,5,5),verbose=0) SIM.mosaic_domains = 10000 SIM.mosaic_spread_deg = 2.0 SIM.distance_mm=100 # this triggers the generation of mosaic distribution UMAT_th = SIM.get_mosaic_blocks() import scitbx UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=math.pi/180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(10000) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(m,deg=False) ) return UMAT_th, UMAT_nm
def run_sim2smv(fileout): SIM = nanoBragg(detpixels_slowfast=(1000, 1000), pixel_size_mm=0.1, Ncells_abc=(5, 5, 5), verbose=0) SIM.mosaic_domains = 10000 SIM.mosaic_spread_deg = MOSAIC_SPREAD SIM.distance_mm = 100 # this triggers the generation of mosaic distribution UMAT_th = SIM.get_mosaic_blocks() # extract top-hat distributed U-mats #sanity checks on the top hat distribution th_angles = check_distributions.get_angular_rotation(UMAT_th) max_angle = flex.max(th_angles) assert max_angle <= MOSAIC_SPREAD + 0.0000001 # need to allow a small epsilon assert max_angle > 0.99 * MOSAIC_SPREAD # insist that max angle is near the limit we gave it rms_angle = math.sqrt(flex.mean(th_angles * th_angles)) print rms_angle import scitbx # computer an array of normally-distributed U-mats into the simulator UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=rms_angle * math.pi / 180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(10000) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append(site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) # set the normally-distributed U-mats into the simulator: SIM.set_mosaic_blocks(UMAT_nm) # get them back new_UMAT_nm = SIM.get_mosaic_blocks() #sanity check on the gaussian distribution nm_angles = check_distributions.get_angular_rotation(new_UMAT_nm) nm_rms_angle = math.sqrt(flex.mean(nm_angles * nm_angles)) print nm_rms_angle return UMAT_th, new_UMAT_nm
def memory_leak_1(fileout): SIM = nanoBragg(detpixels_slowfast=(1000,1000),pixel_size_mm=0.1,Ncells_abc=(5,5,5),verbose=0) import sys if len(sys.argv)>2: SIM.seed = -int(sys.argv[2]) print(("GOTHERE seed=",SIM.seed)) if len(sys.argv)>1: if sys.argv[1]=="random" : SIM.randomize_orientation() SIM.distance_mm=100 SIM.seed = 1 SIM.oversample=1 SIM.wavelength_A=1 SIM.polarization=1 print(("unit_cell_Adeg=",SIM.unit_cell_Adeg)) print(("unit_cell_tuple=",SIM.unit_cell_tuple)) SIM.default_F=100 print(("mosaic_seed=",SIM.mosaic_seed)) print(("seed=",SIM.seed)) print(("calib_seed=",SIM.calib_seed)) print(("missets_deg =", SIM.missets_deg)) SIM.free_all()
def channel_pixels(wavelength_A, flux, N, UMAT_nm, Amatrix_rot, sfall): SIM = nanoBragg(detpixels_slowfast=(3000, 3000), pixel_size_mm=0.11, Ncells_abc=(N, N, N), wavelength_A=wavelength_A, verbose=0) SIM.adc_offset_adu = 10 # Do not offset by 40 SIM.mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = 25 # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image SIM.distance_mm = 141.7 SIM.set_mosaic_blocks(UMAT_nm) #SIM.detector_thick_mm = 0.5 # = 0 for Rayonix #SIM.detector_thicksteps = 1 # should default to 1 for Rayonix, but set to 5 for CSPAD #SIM.detector_attenuation_length_mm = default is silicon # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = wavelength_A SIM.polarization = 1 SIM.default_F = 0 SIM.Fhkl = sfall SIM.Amatrix_RUB = Amatrix_rot SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter = False # flux is always in photons/s SIM.flux = flux SIM.exposure_s = 1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm = 0.003 #cannot make this 3 microns; spots are too intense temp = SIM.Ncells_abc print("Ncells_abc=", SIM.Ncells_abc) SIM.Ncells_abc = temp from libtbx.development.timers import Profiler P = Profiler("nanoBragg") SIM.add_nanoBragg_spots_nks() del P return SIM
def __init__(self, mosaic_domains=25, mosaic_spread_deg=0.05): local_data = data() direct_algo_res_limit = 1.7 wavelength_A = 1.3 # Angstroms, dummy value GF = gen_fmodel(resolution=direct_algo_res_limit, pdb_text=local_data.get("pdb_lines"), algorithm="fft", wavelength=wavelength_A) GF.set_k_sol(0.435) GF.make_P1_primitive() self.sfall_main = GF.get_amplitudes() SIM = nanoBragg( detpixels_slowfast=(3000, 3000), pixel_size_mm=0.11, Ncells_abc=(10, 10, 10), # workaround for problem with wavelength array, specify it separately in constructor. wavelength_A=wavelength_A, verbose=0) SIM.mosaic_spread_deg = mosaic_spread_deg # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = mosaic_domains # mosaic_domains setter must come after mosaic_spread_deg setter UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) scitbx.random.set_random_seed(1234) rand_norm = scitbx.random.normal_distribution( mean=0, sigma=SIM.mosaic_spread_deg * math.pi / 180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(SIM.mosaic_domains) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) SIM.set_mosaic_blocks(UMAT_nm) self.SIM = SIM
def run_sim2smv(ROI,prefix,crystal,spectra,rotation,rank,quick=False): smv_fileout = prefix + ".img" direct_algo_res_limit = 1.7 wavlen, flux, wavelength_A = next(spectra) # list of lambdas, list of fluxes, average wavelength tophat_spectrum = True if tophat_spectrum: sum_flux = flex.sum(flux) #from IPython import embed; embed() ave_flux = sum_flux/60. # 60 energy channels for ix in range(len(wavlen)): energy = 12398.425 / wavlen[ix] if energy>=7090 and energy <=7150: flux[ix]=ave_flux else: flux[ix]=0. if quick: wavlen = flex.double([wavelength_A]); flux = flex.double([flex.sum(flux)]) print("Quick sim, lambda=%f, flux=%f"%(wavelength_A,flux[0])) GF = gen_fmodel(resolution=direct_algo_res_limit,pdb_text=pdb_lines,algorithm="fft",wavelength=wavelength_A) GF.set_k_sol(0.435) GF.make_P1_primitive() sfall_main = GF.get_amplitudes() # use crystal structure to initialize Fhkl array sfall_main.show_summary(prefix = "Amplitudes used ") N = crystal.number_of_cells(sfall_main.unit_cell()) #SIM = nanoBragg(detpixels_slowfast=(2000,2000),pixel_size_mm=0.11,Ncells_abc=(5,5,5),verbose=0) SIM = nanoBragg(detpixels_slowfast=(3000,3000),pixel_size_mm=0.11,Ncells_abc=(N,N,N), # workaround for problem with wavelength array, specify it separately in constructor. wavelength_A=wavelength_A,verbose=0) SIM.adc_offset_adu = 0 # Do not offset by 40 SIM.adc_offset_adu = 10 # Do not offset by 40 import sys if len(sys.argv)>2: SIM.seed = -int(sys.argv[2]) print("GOTHERE seed=",SIM.seed) if len(sys.argv)>1: if sys.argv[1]=="random" : SIM.randomize_orientation() SIM.mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = 50 # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image # 3000000 images would be 100000 hours on a 60-core machine (dials), or 11.4 years # using 2 nodes, 5.7 years. Do this at SLAC? NERSC? combination of all? # SLAC downtimes: Tues Dec 5 (24 hrs), Mon Dec 11 (72 hrs), Mon Dec 18 light use, 24 days # mosaic_domains setter must come after mosaic_spread_deg setter SIM.distance_mm=141.7 UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) scitbx.random.set_random_seed(1234) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=SIM.mosaic_spread_deg * math.pi/180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(SIM.mosaic_domains) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(m,deg=False) ) SIM.set_mosaic_blocks(UMAT_nm) #SIM.detector_thick_mm = 0.5 # = 0 for Rayonix #SIM.detector_thicksteps = 1 # should default to 1 for Rayonix, but set to 5 for CSPAD #SIM.detector_attenuation_length_mm = default is silicon # get same noise each time this test is run SIM.seed = 1 SIM.oversample=1 SIM.wavelength_A = wavelength_A SIM.polarization=1 # this will become F000, marking the beam center SIM.default_F=0 #SIM.missets_deg= (10,20,30) print("mosaic_seed=",SIM.mosaic_seed) print("seed=",SIM.seed) print("calib_seed=",SIM.calib_seed) print("missets_deg =", SIM.missets_deg) SIM.Fhkl=sfall_main print("Determinant",rotation.determinant()) Amatrix_rot = (rotation * sqr(sfall_main.unit_cell().orthogonalization_matrix())).transpose() print("RAND_ORI", prefix, end=' ') for i in Amatrix_rot: print(i, end=' ') print() SIM.Amatrix_RUB = Amatrix_rot #workaround for failing init_cell, use custom written Amatrix setter print("unit_cell_Adeg=",SIM.unit_cell_Adeg) print("unit_cell_tuple=",SIM.unit_cell_tuple) Amat = sqr(SIM.Amatrix).transpose() # recovered Amatrix from SIM from cctbx import crystal_orientation Ori = crystal_orientation.crystal_orientation(Amat, crystal_orientation.basis_type.reciprocal) print("Python unit cell from SIM state",Ori.unit_cell()) # fastest option, least realistic #SIM.xtal_shape=shapetype.Tophat # RLP = hard sphere #SIM.xtal_shape=shapetype.Square # gives fringes SIM.xtal_shape=shapetype.Gauss # both crystal & RLP are Gaussian #SIM.xtal_shape=shapetype.Round # Crystal is a hard sphere # only really useful for long runs SIM.progress_meter=False # prints out value of one pixel only. will not render full image! #SIM.printout_pixel_fastslow=(500,500) #SIM.printout=True SIM.show_params() # flux is always in photons/s SIM.flux=1e12 SIM.exposure_s=1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm=0.003 #cannot make this 3 microns; spots are too intense temp=SIM.Ncells_abc print("Ncells_abc=",SIM.Ncells_abc) SIM.Ncells_abc=temp print("Ncells_abc=",SIM.Ncells_abc) print("xtal_size_mm=",SIM.xtal_size_mm) print("unit_cell_Adeg=",SIM.unit_cell_Adeg) print("unit_cell_tuple=",SIM.unit_cell_tuple) print("missets_deg=",SIM.missets_deg) print("Amatrix=",SIM.Amatrix) print("beam_center_mm=",SIM.beam_center_mm) print("XDS_ORGXY=",SIM.XDS_ORGXY) print("detector_pivot=",SIM.detector_pivot) print("xtal_shape=",SIM.xtal_shape) print("beamcenter_convention=",SIM.beamcenter_convention) print("fdet_vector=",SIM.fdet_vector) print("sdet_vector=",SIM.sdet_vector) print("odet_vector=",SIM.odet_vector) print("beam_vector=",SIM.beam_vector) print("polar_vector=",SIM.polar_vector) print("spindle_axis=",SIM.spindle_axis) print("twotheta_axis=",SIM.twotheta_axis) print("distance_meters=",SIM.distance_meters) print("distance_mm=",SIM.distance_mm) print("close_distance_mm=",SIM.close_distance_mm) print("detector_twotheta_deg=",SIM.detector_twotheta_deg) print("detsize_fastslow_mm=",SIM.detsize_fastslow_mm) print("detpixels_fastslow=",SIM.detpixels_fastslow) print("detector_rot_deg=",SIM.detector_rot_deg) print("curved_detector=",SIM.curved_detector) print("pixel_size_mm=",SIM.pixel_size_mm) print("point_pixel=",SIM.point_pixel) print("polarization=",SIM.polarization) print("nopolar=",SIM.nopolar) print("oversample=",SIM.oversample) print("region_of_interest=",SIM.region_of_interest) print("wavelength_A=",SIM.wavelength_A) print("energy_eV=",SIM.energy_eV) print("fluence=",SIM.fluence) print("flux=",SIM.flux) print("exposure_s=",SIM.exposure_s) print("beamsize_mm=",SIM.beamsize_mm) print("dispersion_pct=",SIM.dispersion_pct) print("dispsteps=",SIM.dispsteps) print("divergence_hv_mrad=",SIM.divergence_hv_mrad) print("divsteps_hv=",SIM.divsteps_hv) print("divstep_hv_mrad=",SIM.divstep_hv_mrad) print("round_div=",SIM.round_div) print("phi_deg=",SIM.phi_deg) print("osc_deg=",SIM.osc_deg) print("phisteps=",SIM.phisteps) print("phistep_deg=",SIM.phistep_deg) print("detector_thick_mm=",SIM.detector_thick_mm) print("detector_thicksteps=",SIM.detector_thicksteps) print("detector_thickstep_mm=",SIM.detector_thickstep_mm) print("***mosaic_spread_deg=",SIM.mosaic_spread_deg) print("***mosaic_domains=",SIM.mosaic_domains) print("indices=",SIM.indices) print("amplitudes=",SIM.amplitudes) print("Fhkl_tuple=",SIM.Fhkl_tuple) print("default_F=",SIM.default_F) print("interpolate=",SIM.interpolate) print("integral_form=",SIM.integral_form) from libtbx.development.timers import Profiler P = Profiler("nanoBragg") # now actually burn up some CPU #SIM.add_nanoBragg_spots() del P # simulated crystal is only 125 unit cells (25 nm wide) # amplify spot signal to simulate physical crystal of 4000x larger: 100 um (64e9 x the volume) print(crystal.domains_per_crystal) SIM.raw_pixels *= crystal.domains_per_crystal; # must calculate the correct scale! output = StringIO() # open("myfile","w") for x in range(0,100,2): #len(flux)): if flux[x]==0.0:continue print("+++++++++++++++++++++++++++++++++++++++ Wavelength",x) CH = channel_pixels(ROI,wavlen[x],flux[x],N,UMAT_nm,Amatrix_rot,GF,output) SIM.raw_pixels += CH.raw_pixels * crystal.domains_per_crystal; print(SIM.raw_pixels) CH.free_all() message = output.getvalue().split() miller = (int(message[4]),int(message[5]),int(message[6])) intensity = float(message[9]); #SIM.to_smv_format(fileout=prefix + "_intimage_001.img") pixels = SIM.raw_pixels roi_pixels = pixels[ROI[1][0]:ROI[1][1], ROI[0][0]:ROI[0][1]] print("Reducing full shape of",pixels.focus(),"to ROI of",roi_pixels.focus()) SIM.free_all() return dict(roi_pixels=roi_pixels,miller=miller,intensity=intensity)
def run_sim2smv(prefix, crystal, spectra, rotation, rank, quick=False): local_data = data() smv_fileout = prefix + ".img" if quick is not True: if not write_safe(smv_fileout): print("File %s already exists, skipping in rank %d" % (smv_fileout, rank)) return direct_algo_res_limit = 1.7 wavlen, flux, wavelength_A = next( spectra) # list of lambdas, list of fluxes, average wavelength if quick: wavlen = flex.double([wavelength_A]) flux = flex.double([flex.sum(flux)]) print("Quick sim, lambda=%f, flux=%f" % (wavelength_A, flux[0])) GF = gen_fmodel(resolution=direct_algo_res_limit, pdb_text=local_data.get("pdb_lines"), algorithm="fft", wavelength=wavelength_A) GF.set_k_sol(0.435) GF.make_P1_primitive() sfall_main = GF.get_amplitudes() # use crystal structure to initialize Fhkl array sfall_main.show_summary(prefix="Amplitudes used ") N = crystal.number_of_cells(sfall_main.unit_cell()) #SIM = nanoBragg(detpixels_slowfast=(2000,2000),pixel_size_mm=0.11,Ncells_abc=(5,5,5),verbose=0) SIM = nanoBragg( detpixels_slowfast=(3000, 3000), pixel_size_mm=0.11, Ncells_abc=(N, N, N), # workaround for problem with wavelength array, specify it separately in constructor. wavelength_A=wavelength_A, verbose=0) SIM.adc_offset_adu = 0 # Do not offset by 40 SIM.adc_offset_adu = 10 # Do not offset by 40 import sys if len(sys.argv) > 2: SIM.seed = -int(sys.argv[2]) print("GOTHERE seed=", SIM.seed) if len(sys.argv) > 1: if sys.argv[1] == "random": SIM.randomize_orientation() SIM.mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = n_mosaic_domains # 77 seconds. With 100 energy points, 7700 seconds (2 hours) per image # 3000000 images would be 100000 hours on a 60-core machine (dials), or 11.4 years # using 2 nodes, 5.7 years. Do this at SLAC? NERSC? combination of all? # SLAC downtimes: Tues Dec 5 (24 hrs), Mon Dec 11 (72 hrs), Mon Dec 18 light use, 24 days # mosaic_domains setter must come after mosaic_spread_deg setter SIM.distance_mm = 141.7 UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) scitbx.random.set_random_seed(1234) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=SIM.mosaic_spread_deg * math.pi / 180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(SIM.mosaic_domains) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append(site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) SIM.set_mosaic_blocks(UMAT_nm) #SIM.detector_thick_mm = 0.5 # = 0 for Rayonix #SIM.detector_thicksteps = 1 # should default to 1 for Rayonix, but set to 5 for CSPAD #SIM.detector_attenuation_length_mm = default is silicon # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = wavelength_A SIM.polarization = 1 # this will become F000, marking the beam center SIM.default_F = 0 #SIM.missets_deg= (10,20,30) print("mosaic_seed=", SIM.mosaic_seed) print("seed=", SIM.seed) print("calib_seed=", SIM.calib_seed) print("missets_deg =", SIM.missets_deg) SIM.Fhkl = sfall_main print("Determinant", rotation.determinant()) Amatrix_rot = ( rotation * sqr(sfall_main.unit_cell().orthogonalization_matrix())).transpose() print("RAND_ORI", prefix, end=' ') for i in Amatrix_rot: print(i, end=' ') print() SIM.Amatrix_RUB = Amatrix_rot #workaround for failing init_cell, use custom written Amatrix setter print("unit_cell_Adeg=", SIM.unit_cell_Adeg) print("unit_cell_tuple=", SIM.unit_cell_tuple) Amat = sqr(SIM.Amatrix).transpose() # recovered Amatrix from SIM from cctbx import crystal_orientation Ori = crystal_orientation.crystal_orientation( Amat, crystal_orientation.basis_type.reciprocal) print("Python unit cell from SIM state", Ori.unit_cell()) # fastest option, least realistic #SIM.xtal_shape=shapetype.Tophat # RLP = hard sphere #SIM.xtal_shape=shapetype.Square # gives fringes SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian #SIM.xtal_shape=shapetype.Round # Crystal is a hard sphere # only really useful for long runs SIM.progress_meter = False # prints out value of one pixel only. will not render full image! #SIM.printout_pixel_fastslow=(500,500) #SIM.printout=True SIM.show_params() # flux is always in photons/s SIM.flux = 1e12 SIM.exposure_s = 1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm = 0.003 #cannot make this 3 microns; spots are too intense temp = SIM.Ncells_abc print("Ncells_abc=", SIM.Ncells_abc) SIM.Ncells_abc = temp print("Ncells_abc=", SIM.Ncells_abc) print("xtal_size_mm=", SIM.xtal_size_mm) print("unit_cell_Adeg=", SIM.unit_cell_Adeg) print("unit_cell_tuple=", SIM.unit_cell_tuple) print("missets_deg=", SIM.missets_deg) print("Amatrix=", SIM.Amatrix) print("beam_center_mm=", SIM.beam_center_mm) print("XDS_ORGXY=", SIM.XDS_ORGXY) print("detector_pivot=", SIM.detector_pivot) print("xtal_shape=", SIM.xtal_shape) print("beamcenter_convention=", SIM.beamcenter_convention) print("fdet_vector=", SIM.fdet_vector) print("sdet_vector=", SIM.sdet_vector) print("odet_vector=", SIM.odet_vector) print("beam_vector=", SIM.beam_vector) print("polar_vector=", SIM.polar_vector) print("spindle_axis=", SIM.spindle_axis) print("twotheta_axis=", SIM.twotheta_axis) print("distance_meters=", SIM.distance_meters) print("distance_mm=", SIM.distance_mm) print("close_distance_mm=", SIM.close_distance_mm) print("detector_twotheta_deg=", SIM.detector_twotheta_deg) print("detsize_fastslow_mm=", SIM.detsize_fastslow_mm) print("detpixels_fastslow=", SIM.detpixels_fastslow) print("detector_rot_deg=", SIM.detector_rot_deg) print("curved_detector=", SIM.curved_detector) print("pixel_size_mm=", SIM.pixel_size_mm) print("point_pixel=", SIM.point_pixel) print("polarization=", SIM.polarization) print("nopolar=", SIM.nopolar) print("oversample=", SIM.oversample) print("region_of_interest=", SIM.region_of_interest) print("wavelength_A=", SIM.wavelength_A) print("energy_eV=", SIM.energy_eV) print("fluence=", SIM.fluence) print("flux=", SIM.flux) print("exposure_s=", SIM.exposure_s) print("beamsize_mm=", SIM.beamsize_mm) print("dispersion_pct=", SIM.dispersion_pct) print("dispsteps=", SIM.dispsteps) print("divergence_hv_mrad=", SIM.divergence_hv_mrad) print("divsteps_hv=", SIM.divsteps_hv) print("divstep_hv_mrad=", SIM.divstep_hv_mrad) print("round_div=", SIM.round_div) print("phi_deg=", SIM.phi_deg) print("osc_deg=", SIM.osc_deg) print("phisteps=", SIM.phisteps) print("phistep_deg=", SIM.phistep_deg) print("detector_thick_mm=", SIM.detector_thick_mm) print("detector_thicksteps=", SIM.detector_thicksteps) print("detector_thickstep_mm=", SIM.detector_thickstep_mm) print("***mosaic_spread_deg=", SIM.mosaic_spread_deg) print("***mosaic_domains=", SIM.mosaic_domains) print("indices=", SIM.indices) print("amplitudes=", SIM.amplitudes) print("Fhkl_tuple=", SIM.Fhkl_tuple) print("default_F=", SIM.default_F) print("interpolate=", SIM.interpolate) print("integral_form=", SIM.integral_form) from libtbx.development.timers import Profiler P = Profiler("nanoBragg") # now actually burn up some CPU #SIM.add_nanoBragg_spots() del P # simulated crystal is only 125 unit cells (25 nm wide) # amplify spot signal to simulate physical crystal of 4000x larger: 100 um (64e9 x the volume) print(crystal.domains_per_crystal) SIM.raw_pixels *= crystal.domains_per_crystal # must calculate the correct scale! # Use single wavelength for all energy channels for the purpose of Fcalc wavelength_hi_remote = wavlen[-1] GF.reset_wavelength(wavelength_hi_remote) GF.reset_specific_at_wavelength(label_has="FE1", tables=local_data.get("Fe_oxidized_model"), newvalue=wavelength_hi_remote) GF.reset_specific_at_wavelength(label_has="FE2", tables=local_data.get("Fe_reduced_model"), newvalue=wavelength_hi_remote) sfall_channel = GF.get_amplitudes() # sources channel_source_XYZ = flex.vec3_double(len(flux), SIM.xray_source_XYZ[0]) CP = channel_pixels( wavlen, flux, channel_source_XYZ) # class interface for multi-wavelength print("+++++++++++++++++++++++++++++++++++++++ Multiwavelength call") CH = CP(N=N, UMAT_nm=UMAT_nm, Amatrix_rot=Amatrix_rot, sfall_channel=sfall_channel) SIM.raw_pixels += CH.raw_pixels * crystal.domains_per_crystal CH.free_all() if quick: SIM.to_smv_format(fileout=prefix + "_intimage_001.img") # rough approximation to water: interpolation points for sin(theta/lambda) vs structure factor bg = flex.vec2_double([(0, 2.57), (0.0365, 2.58), (0.07, 2.8), (0.12, 5), (0.162, 8), (0.2, 6.75), (0.18, 7.32), (0.216, 6.75), (0.236, 6.5), (0.28, 4.5), (0.3, 4.3), (0.345, 4.36), (0.436, 3.77), (0.5, 3.17)]) SIM.Fbg_vs_stol = bg SIM.amorphous_sample_thick_mm = 0.1 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.flux = 1e12 SIM.beamsize_mm = 0.003 # square (not user specified) SIM.exposure_s = 1.0 # multiplies flux x exposure SIM.add_background() if quick: SIM.to_smv_format(fileout=prefix + "_intimage_002.img") # rough approximation to air bg = flex.vec2_double([(0, 14.1), (0.045, 13.5), (0.174, 8.35), (0.35, 4.78), (0.5, 4.22)]) SIM.Fbg_vs_stol = bg #SIM.amorphous_sample_thick_mm = 35 # between beamstop and collimator SIM.amorphous_sample_thick_mm = 10 # between beamstop and collimator SIM.amorphous_density_gcm3 = 1.2e-3 SIM.amorphous_sample_molecular_weight_Da = 28 # nitrogen = N2 print("amorphous_sample_size_mm=", SIM.amorphous_sample_size_mm) print("amorphous_sample_thick_mm=", SIM.amorphous_sample_thick_mm) print("amorphous_density_gcm3=", SIM.amorphous_density_gcm3) print("amorphous_molecular_weight_Da=", SIM.amorphous_molecular_weight_Da) SIM.add_background() #apply beamstop mask here # set this to 0 or -1 to trigger automatic radius. could be very slow with bright images # settings for CCD SIM.detector_psf_kernel_radius_pixels = 5 #SIM.detector_psf_fwhm_mm=0.08; #SIM.detector_psf_type=shapetype.Fiber # rayonix=Fiber, CSPAD=None (or small Gaussian) SIM.detector_psf_type = shapetype.Unknown # for CSPAD SIM.detector_psf_fwhm_mm = 0 #SIM.apply_psf() print("One pixel-->", SIM.raw_pixels[500000]) # at this point we scale the raw pixels so that the output array is on an scale from 0 to 50000. # that is the default behavior (intfile_scale<=0), otherwise it applies intfile_scale as a multiplier on an abs scale. if quick: SIM.to_smv_format(fileout=prefix + "_intimage_003.img") print("quantum_gain=", SIM.quantum_gain) #defaults to 1. converts photons to ADU print("adc_offset_adu=", SIM.adc_offset_adu) print("detector_calibration_noise_pct=", SIM.detector_calibration_noise_pct) print("flicker_noise_pct=", SIM.flicker_noise_pct) print("readout_noise_adu=", SIM.readout_noise_adu ) # gaussian random number to add to every pixel (0 for PAD) # apply Poissonion correction, then scale to ADU, then adc_offset. # should be 10 for most Rayonix, Pilatus should be 0, CSPAD should be 0. print("detector_psf_type=", SIM.detector_psf_type) print("detector_psf_fwhm_mm=", SIM.detector_psf_fwhm_mm) print("detector_psf_kernel_radius_pixels=", SIM.detector_psf_kernel_radius_pixels) SIM.add_noise() #converts phtons to ADU. print("raw_pixels=", SIM.raw_pixels) extra = "PREFIX=%s;\nRANK=%d;\n" % (prefix, rank) SIM.to_smv_format_py(fileout=smv_fileout, intfile_scale=1, rotmat=True, extra=extra, gz=True) # try to write as CBF if False: import dxtbx from dxtbx.format.FormatCBFMiniPilatus import FormatCBFMiniPilatus img = dxtbx.load(prefix + ".img") print(img) FormatCBFMiniPilatus.as_file(detector=img.get_detector(), beam=img.get_beam(), gonio=img.get_goniometer(), scan=img.get_scan(), data=img.get_raw_data(), path=prefix + ".cbf") SIM.free_all()
def run_sim2smv(fileout): SIM = nanoBragg(detpixels_slowfast=(1000, 1000), pixel_size_mm=0.1, Ncells_abc=(5, 5, 5), verbose=9) import sys if len(sys.argv) > 2: SIM.seed = -int(sys.argv[2]) print "GOTHERE seed=", SIM.seed if len(sys.argv) > 1: if sys.argv[1] == "random": SIM.randomize_orientation() SIM.distance_mm = 100 #SIM = nanoBragg(detpixels_slowfast=(2527,2463),pixel_size_mm=0.172,Ncells_abc=(5,5,5),verbose=9) #SIM.distance_mm=200 # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = 1 SIM.polarization = 1 #SIM.unit_cell_tuple=(50,50,50,90,90,90) print "unit_cell_Adeg=", SIM.unit_cell_Adeg print "unit_cell_tuple=", SIM.unit_cell_tuple # this will become F000, marking the beam center SIM.default_F = 100 #SIM.missets_deg= (10,20,30) print "mosaic_seed=", SIM.mosaic_seed print "seed=", SIM.seed print "calib_seed=", SIM.calib_seed print "missets_deg =", SIM.missets_deg sfall = fcalc_from_pdb(resolution=1.6, algorithm="direct", wavelength=SIM.wavelength_A) # use crystal structure to initialize Fhkl array SIM.Fhkl = sfall # fastest option, least realistic SIM.xtal_shape = shapetype.Tophat # only really useful for long runs SIM.progress_meter = False # prints out value of one pixel only. will not render full image! #SIM.printout_pixel_fastslow=(500,500) #SIM.printout=True SIM.show_params() # flux is always in photons/s SIM.flux = 1e12 # assumes round beam SIM.beamsize_mm = 0.1 SIM.exposure_s = 0.1 temp = SIM.Ncells_abc print "Ncells_abc=", SIM.Ncells_abc SIM.Ncells_abc = temp print "Ncells_abc=", SIM.Ncells_abc print "xtal_size_mm=", SIM.xtal_size_mm print "unit_cell_Adeg=", SIM.unit_cell_Adeg print "unit_cell_tuple=", SIM.unit_cell_tuple print "missets_deg=", SIM.missets_deg print "Amatrix=", SIM.Amatrix print "beam_center_mm=", SIM.beam_center_mm print "XDS_ORGXY=", SIM.XDS_ORGXY print "detector_pivot=", SIM.detector_pivot print "xtal_shape=", SIM.xtal_shape print "beamcenter_convention=", SIM.beamcenter_convention print "fdet_vector=", SIM.fdet_vector print "sdet_vector=", SIM.sdet_vector print "odet_vector=", SIM.odet_vector print "beam_vector=", SIM.beam_vector print "polar_vector=", SIM.polar_vector print "spindle_axis=", SIM.spindle_axis print "twotheta_axis=", SIM.twotheta_axis print "distance_meters=", SIM.distance_meters print "distance_mm=", SIM.distance_mm print "close_distance_mm=", SIM.close_distance_mm print "detector_twotheta_deg=", SIM.detector_twotheta_deg print "detsize_fastslow_mm=", SIM.detsize_fastslow_mm print "detpixels_fastslow=", SIM.detpixels_fastslow print "detector_rot_deg=", SIM.detector_rot_deg print "curved_detector=", SIM.curved_detector print "pixel_size_mm=", SIM.pixel_size_mm print "point_pixel=", SIM.point_pixel print "polarization=", SIM.polarization print "nopolar=", SIM.nopolar print "oversample=", SIM.oversample print "region_of_interest=", SIM.region_of_interest print "wavelength_A=", SIM.wavelength_A print "energy_eV=", SIM.energy_eV print "fluence=", SIM.fluence print "flux=", SIM.flux print "exposure_s=", SIM.exposure_s print "beamsize_mm=", SIM.beamsize_mm print "dispersion_pct=", SIM.dispersion_pct print "dispsteps=", SIM.dispsteps print "divergence_hv_mrad=", SIM.divergence_hv_mrad print "divsteps_hv=", SIM.divsteps_hv print "divstep_hv_mrad=", SIM.divstep_hv_mrad print "round_div=", SIM.round_div print "phi_deg=", SIM.phi_deg print "osc_deg=", SIM.osc_deg print "phisteps=", SIM.phisteps print "phistep_deg=", SIM.phistep_deg print "detector_thick_mm=", SIM.detector_thick_mm print "detector_thicksteps=", SIM.detector_thicksteps print "detector_thickstep_mm=", SIM.detector_thickstep_mm print "mosaic_spread_deg=", SIM.mosaic_spread_deg print "mosaic_domains=", SIM.mosaic_domains print "indices=", SIM.indices print "amplitudes=", SIM.amplitudes print "Fhkl_tuple=", SIM.Fhkl_tuple print "default_F=", SIM.default_F print "interpolate=", SIM.interpolate print "integral_form=", SIM.integral_form # now actually burn up some CPU SIM.add_nanoBragg_spots() # simulated crystal is only 125 unit cells (25 nm wide) # amplify spot signal to simulate physical crystal of 4000x larger: 100 um (64e9 x the volume) SIM.raw_pixels *= 64e9 SIM.to_smv_format(fileout="intimage_001.img") # rough approximation to water: interpolation points for sin(theta/lambda) vs structure factor bg = flex.vec2_double([(0, 2.57), (0.0365, 2.58), (0.07, 2.8), (0.12, 5), (0.162, 8), (0.2, 6.75), (0.18, 7.32), (0.216, 6.75), (0.236, 6.5), (0.28, 4.5), (0.3, 4.3), (0.345, 4.36), (0.436, 3.77), (0.5, 3.17)]) SIM.Fbg_vs_stol = bg SIM.amorphous_sample_thick_mm = 0.1 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.flux = 1e12 SIM.beamsize_mm = 0.1 SIM.exposure_s = 0.1 SIM.add_background() SIM.to_smv_format(fileout="intimage_002.img") # rough approximation to air bg = flex.vec2_double([(0, 14.1), (0.045, 13.5), (0.174, 8.35), (0.35, 4.78), (0.5, 4.22)]) SIM.Fbg_vs_stol = bg SIM.amorphous_sample_thick_mm = 35 # between beamstop and collimator SIM.amorphous_density_gcm3 = 1.2e-3 SIM.amorphous_sample_molecular_weight_Da = 28 # nitrogen = N2 print "amorphous_sample_size_mm=", SIM.amorphous_sample_size_mm print "amorphous_sample_thick_mm=", SIM.amorphous_sample_thick_mm print "amorphous_density_gcm3=", SIM.amorphous_density_gcm3 print "amorphous_molecular_weight_Da=", SIM.amorphous_molecular_weight_Da SIM.add_background() # set this to 0 or -1 to trigger automatic radius. could be very slow with bright images SIM.detector_psf_kernel_radius_pixels = 5 SIM.detector_psf_fwhm_mm = 0.08 SIM.detector_psf_type = shapetype.Fiber #SIM.apply_psf() print SIM.raw_pixels[500000] SIM.to_smv_format(fileout="intimage_003.img") #SIM.detector_psf_fwhm_mm=0 print "quantum_gain=", SIM.quantum_gain print "adc_offset_adu=", SIM.adc_offset_adu print "detector_calibration_noise_pct=", SIM.detector_calibration_noise_pct print "flicker_noise_pct=", SIM.flicker_noise_pct print "readout_noise_adu=", SIM.readout_noise_adu print "detector_psf_type=", SIM.detector_psf_type print "detector_psf_fwhm_mm=", SIM.detector_psf_fwhm_mm print "detector_psf_kernel_radius_pixels=", SIM.detector_psf_kernel_radius_pixels SIM.add_noise() #fileout = "intimage_001.img" print "raw_pixels=", SIM.raw_pixels SIM.to_smv_format(fileout="noiseimage_001.img", intfile_scale=1) # try to write as CBF import dxtbx from dxtbx.format.FormatCBFMini import FormatCBFMini img = dxtbx.load("noiseimage_001.img") print img FormatCBFMini.as_file(detector=img.get_detector(), beam=img.get_beam(), gonio=img.get_goniometer(), scan=img.get_scan(), data=img.get_raw_data(), path=fileout) SIM.free_all()
def run_sim2smv(Nshot_max, odir, prefix, rank, n_jobs, save_bragg=False, save_smv=True, save_h5 =False, return_pixels=False): from six.moves import range, StringIO from six.moves import cPickle as pickle from cxid9114.sim import sim_utils import os import h5py import math import sys import numpy as np from IPython import embed from cxid9114.bigsim.bigsim_geom import DET,BEAM import scitbx from scitbx.array_family import flex from scitbx.matrix import sqr,col from simtbx.nanoBragg import shapetype from simtbx.nanoBragg import nanoBragg import libtbx.load_env # possibly implicit from libtbx.development.timers import Profiler from cctbx import crystal,crystal_orientation from LS49.sim.step4_pad import microcrystal from cxid9114 import utils from cxid9114.parameters import ENERGY_CONV, ENERGY_HIGH, ENERGY_LOW from cxid9114.bigsim import sim_spectra odir_j = os.path.join( odir, "job%d" % rank) if not os.path.exists(odir_j): os.makedirs(odir_j) add_noise = False add_background = False overwrite = True #$False sample_thick_mm = 0.005 # 50 micron GDVN nozzle makes a ~5ish micron jet air_thick_mm =0 # mostly vacuum, maybe helium layer of 1 micron flux_ave=2e11 add_spots_algorithm="cuda" big_data = "." # directory location for reference files detpixels_slowfast = (1800,1800) pixsize_mm=0.11 distance_mm = 125 offset_adu=30 mos_spread_deg=0.015 mos_doms=1000 beam_size_mm=0.001 exposure_s=1 use_microcrystal=True #False Ncells_abc=(120,120,120) Deff_A = 2200 length_um = 2.2 timelog = False background = utils.open_flex("background") crystal = microcrystal(Deff_A = Deff_A, length_um = length_um, beam_diameter_um = beam_size_mm*1000, verbose=False) spec_file = h5py.File("simMe_data_run62.h5", "r") spec_data = spec_file["hist_spec"] Umat_data = spec_file["Umats"] en_chans = spec_file["energy_bins"][()] ilow = np.abs(en_chans - ENERGY_LOW).argmin() ihigh = np.abs(en_chans - ENERGY_HIGH).argmin() wave_chans = ENERGY_CONV/en_chans sfall_main = sim_spectra.load_spectra("test_sfall.h5") Nshot = spec_data.shape[0] idx_range = np.array_split(np.arange(Nshot), n_jobs) Nshot_per_job = len(idx_range[rank]) if Nshot_max > 0 : Nshot_per_job = min( Nshot_max, Nshot_per_job) print ("Job %d: Simulating %d shots" % (rank, Nshot_per_job)) istart = idx_range[rank][0] istop = istart + Nshot_per_job smi_stride = 10 for idx in range( istart, istop): print ("<><><><><><><><><><><><><><>") print ("Job %d; Image %d (%d - %d)" % (rank, idx+1, istart, istop)) print ("<><><><><><><><><><><><><><>") smv_fileout = os.path.join( odir_j, prefix % idx + ".img") h5_fileout = smv_fileout + ".h5" if os.path.exists(smv_fileout) and not overwrite and save_smv: print("Shot %s exists: moving on" % smv_fileout) continue if os.path.exists(h5_fileout) and not overwrite and save_h5: print("Shot %s exists: moving on" % h5_fileout) continue if (rank==0 and idx % smi_stride==0): print("GPU status") os.system("nvidia-smi") print("\n\n") print("CPU memory usage") mem_usg= """ps -U dermen --no-headers -o rss | awk '{ sum+=$1} END {print int(sum/1024) "MB consumed by CPU user"}'""" os.system(mem_usg) spec = spec_data[2] rotation = sqr(Umat_data[2]) wavelength_A = np.mean(wave_chans) spectra = iter([(wave_chans, spec, wavelength_A)]) direct_algo_res_limit = 1.7 wavlen, flux, wavelength_A = next(spectra) # list of lambdas, list of fluxes, average wavelength assert wavelength_A > 0 assert (len(wavlen)==len(flux)==len(sfall_main)) N = crystal.number_of_cells(sfall_main[0].unit_cell()) if use_mcrocrystal: Ncells_abc = (N,N,N) flux *= 0 flux[ilow] = 1e12 flux[ihigh]=1e12 UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) scitbx.random.set_random_seed(1234) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=mos_spread_deg * math.pi/180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(mos_doms) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(m,deg=False) ) Amatrix_rot = (rotation * sqr(sfall_main[0].unit_cell().orthogonalization_matrix())).transpose() #SIM = nanoBragg(detpixels_slowfast=detpixels_slowfast, # pixel_size_mm=pixsize_mm,Ncells_abc=Ncells_abc, # wavelength_A=wavelength_A,verbose=verbose) SIM = nanoBragg(detector=DET, beam=BEAM, panel_id=0,verbose=verbose) SIM.adc_offset_adu = offset_adu # Do not offset by 40 SIM.mosaic_spread_deg = mos_spread_deg # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = mos_doms SIM.distance_mm=distance_mm SIM.set_mosaic_blocks(UMAT_nm) SIM.seed = 1 SIM.oversample=1 SIM.wavelength_A = wavelength_A SIM.polarization=1 SIM.default_F=0 SIM.Fhkl=sfall_main[0].amplitudes() SIM.progress_meter=False SIM.flux=flux_ave SIM.exposure_s=exposure_s SIM.beamsize_mm=beam_size_mm SIM.Ncells_abc=Ncells_abc SIM.xtal_shape=shapetype.Gauss idxpath = "try3_idx2/job0/dump_0_data.pkl" Amat = sim_utils.Amatrix_dials2nanoBragg(utils.open_flex(idxpath)["crystalAB"]) #SIM.Umatrix = rotation.elems #SIM.unit_cell_Adeg = sfall_main[0].unit_cell() #SIM2 = nanoBragg(detector=DET, beam=BEAM, panel_id=0,verbose=verbose) #SIM2.adc_offset_adu = offset_adu # Do not offset by 40 #SIM2.mosaic_spread_deg = mos_spread_deg # interpreted by UMAT_nm as a half-width stddev #SIM2.mosaic_domains = mos_doms #SIM2.distance_mm=distance_mm #SIM2.set_mosaic_blocks(UMAT_nm) #SIM2.seed = 1 #SIM2.oversample=1 #SIM2.wavelength_A = wavelength_A #SIM2.polarization=1 #SIM2.default_F=0 #SIM2.Fhkl=sfall_main[0].amplitudes() #SIM2.progress_meter=False #SIM2.flux=flux_ave #SIM2.exposure_s=exposure_s #SIM2.beamsize_mm=beam_size_mm #SIM2.Ncells_abc=Ncells_abc #SIM2.xtal_shape=shapetype.Gauss #SIM2.Umatrix = rotation.elems #SIM2.unit_cell_Adeg = sfall_main[0].unit_cell() #SIM.Amatrix_RUB = Amatrix_rot #SIM.Amatrix = Amatrix_rot.inverse() raw_pixel_sum = flex.double(len(SIM.raw_pixels)) Nflux = len(flux) print("Beginning the loop") for x in range(Nflux): if x % 10==0: print("+++++++++++++++++++++++++++++++++++++++ Wavelength %d / %d" % (x+1, Nflux) , end="\r") if flux[x] ==0: continue #SIM.Amatrix = Amatrix_rot.inverse() print (SIM.Ncells_abc) SIM.wavelength_A=wavlen[x] SIM.flux=flux[x] SIM.Fhkl=sfall_main[x].amplitudes() SIM.Amatrix = Amat#Amatrix_rot.inverse() #sim_utils.compare_sims(SIM, SIM2) #SIM.Ncells_abc=Ncells_abc #SIM.adc_offset_adu = offset_adu #SIM.mosaic_spread_deg = mos_spread_deg # interpreted by UMAT_nm as a half-width stddev #SIM.mosaic_domains = mos_doms # #SIM.distance_mm=distance_mm #SIM.set_mosaic_blocks(UMAT_nm) #SIM.seed = 1 #SIM.polarization=1 #SIM.default_F=0 #SIM.xtal_shape=shapetype.Gauss #SIM.progress_meter=False #SIM.exposure_s = exposure_s #SIM.beamsize_mm=beam_size_mm SIM.timelog=timelog SIM.device_Id=rank SIM.raw_pixels *= 0 # just in case! SIM.add_nanoBragg_spots_cuda() if use_microcrystal: raw_pixel_sum += SIM.raw_pixels * crystal.domains_per_crystal print() SIM.raw_pixels = raw_pixel_sum if add_background: SIM.raw_pixels = SIM.raw_pixels + background SIM.detector_psf_kernel_radius_pixels=5; #SIM.detector_psf_fwhm_mm=0.08; #SIM.detector_psf_type=shapetype.Fiber # rayonix=Fiber, CSPAD=None (or small Gaussian) SIM.detector_psf_type=shapetype.Unknown # for CSPAD SIM.detector_psf_fwhm_mm=0 SIM.quantum_gain = 28. #SIM.apply_psf() if add_noise: SIM.add_noise() #converts phtons to ADU. extra = "PREFIX=%s;\nRANK=%d;\n"%(prefix,rank) out = SIM.raw_pixels.as_numpy_array() if save_smv: SIM.to_smv_format_py(fileout=smv_fileout,intfile_scale=1,rotmat=True,extra=extra,gz=True) elif save_h5: f = h5py.File(h5_fileout, "w") f.create_dataset("bigsim_d9114", data=SIM.raw_pixels.as_numpy_array().astype(np.uint16).reshape(detpixels_slowfast), compression="lzf") f.close() if npout is not None: np.save(npout, SIM.raw_pixels.as_numpy_array()) SIM.free_all()
def run_sim(seed=1, wavelength=0.9, distance=500, random_orientation=False, phi=0, osc=0): SIM = nanoBragg(detpixels_slowfast=(2527, 2463), pixel_size_mm=0.172, Ncells_abc=(15, 15, 15), verbose=0) # get same noise each time this test is run SIM.seed = seed # user may select random orientation if random_orientation: SIM.randomize_orientation() else: # fixed orientation, for doing rotation data sets SIM.missets_deg = (10, 20, 30) SIM.distance_mm = distance SIM.wavelength_A = wavelength # option to render a phi swell SIM.phi_deg = phi SIM.osc_deg = osc if osc >= 0: # need quite a few steps/deg for decent Rmeas SIM.phistep_deg = 0.001 SIM.oversample = 1 SIM.polarization = 1 # this will become F000, marking the beam center SIM.F000 = 100 print "mosaic_seed=", SIM.mosaic_seed print "seed=", SIM.seed print "calib_seed=", SIM.calib_seed print "missets_deg =", SIM.missets_deg # re-set the detector to be in SIM.beamcenter_convention = convention.DIALS SIM.beam_center_mm = (211, 214) sfall = fcalc_from_pdb(resolution=1.6, algorithm="direct", wavelength=SIM.wavelength_A) # use crystal structure to initialize Fhkl array SIM.Fhkl = sfall # fastest option, least realistic SIM.xtal_shape = shapetype.Tophat # only really useful for long runs SIM.progress_meter = False # prints out value of one pixel only. will not render full image! #SIM.printout_pixel_fastslow=(500,500) #SIM.printout=True # flux is always in photons/s SIM.flux = 1e12 # assumes round beam SIM.beamsize_mm = 0.1 SIM.exposure_s = 0.1 # Pilatus detector is thick SIM.detector_thick_mm = 0.450 # get attenuation depth in mm from cctbx.eltbx import attenuation_coefficient table = attenuation_coefficient.get_table("Si") SIM.detector_attenuation_length_mm = 10.0 / (table.mu_at_angstrom( SIM.wavelength_A)) print "detector_attenuation_length =", SIM.detector_attenuation_length_mm #SIM.detector_thick_mm=0 SIM.detector_thicksteps = 3 # # will simulate module mis-alignment by adjusting beam center of each module beam_center0 = SIM.beam_center_mm # simulated crystal is only 3375 unit cells (42 nm wide) # amplify spot signal to simulate physical crystal of 100 um # this is equivalent to adding up 28e9 mosaic domains in exactly the same orientation, but a lot faster aggregate_xtal_volume_mm3 = 0.1 * 0.1 * 0.1 mosaic_domain_volume_mm3 = SIM.xtal_size_mm[0] * SIM.xtal_size_mm[ 1] * SIM.xtal_size_mm[2] SIM.spot_scale = aggregate_xtal_volume_mm3 / mosaic_domain_volume_mm3 # # option for detector rotations to be about beam center or sample position #SIM.detector_pivot=pivot.Sample SIM.detector_pivot = pivot.Beam print "pivoting detector about", SIM.detector_pivot # make the module roi list # and also make up per-module mis-alignments shifts and rotations import random # make sure shifts are the same from image to image random.seed(12345) module_size = (487, 195) gap_size = (7, 17) modules = [] for mx in range(0, 5): for my in range(0, 12): # define region of interest for this module fmin = mx * (module_size[0] + gap_size[0]) fmax = fmin + module_size[0] smin = my * (module_size[1] + gap_size[1]) smax = smin + module_size[1] # assume misalignments are uniform # up to ~0.5 pixel and 0.0 deg in each direction dx = 0.07 * (random.random() - 0.5) * 2 dy = 0.07 * (random.random() - 0.5) * 2 rotx = 0.0 * (random.random() - 0.5) * 2 roty = 0.0 * (random.random() - 0.5) * 2 rotz = 0.0 * (random.random() - 0.5) * 2 modules.append( (((fmin, fmax), (smin, smax)), (dx, dy), (rotx, roty, rotz))) # # defeat module-by-module rendering by uncommenting next 3 lines #dim=SIM.detpixels_fastslow #modules = [(( ((0,dim[0]),(0,dim[1])) ),(0,0),(0,0,0))] #print modules i = -1 for roi, (dx, dy), drot in modules: i = i + 1 print "rendering module:", i, "roi=", roi SIM.region_of_interest = roi # shift the beam center x = beam_center0[0] + dx y = beam_center0[1] + dy SIM.beam_center_mm = (x, y) # also tilt the module by up to 0.05 deg in all directions SIM.detector_rotation_deg = drot print "beam center: ", SIM.beam_center_mm, "rotations:", drot # now actually burn up some CPU SIM.add_nanoBragg_spots() # add water contribution SIM.Fbg_vs_stol = Fbg_water SIM.amorphous_sample_thick_mm = 0.1 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.add_background() # add air contribution SIM.Fbg_vs_stol = Fbg_air SIM.amorphous_sample_thick_mm = 35 # between beamstop and collimator SIM.amorphous_density_gcm3 = 1.2e-3 SIM.amorphous_sample_molecular_weight_Da = 28 # nitrogen = N2 SIM.add_background() # add nanocrystalline cubic ice contribution (unscaled) SIM.Fbg_vs_stol = Fbg_nanoice SIM.amorphous_sample_thick_mm = 0.05 # between beamstop and collimator SIM.amorphous_density_gcm3 = 0.95 SIM.amorphous_sample_molecular_weight_Da = 18 # H2O SIM.add_background() # # set this to 0 or -1 to trigger automatic radius. could be very slow with bright images SIM.detector_psf_kernel_radius_pixels = 5 # turn off the point spread function for Pilatus SIM.detector_psf_fwhm_mm = 0.0 SIM.detector_psf_type = shapetype.Gauss SIM.adc_offset_adu = 0 SIM.readout_noise_adu = 0 dim = SIM.detpixels_fastslow SIM.region_of_interest = ((0, dim[0]), (0, dim[1])) SIM.add_noise() return SIM
def generate_simtbx_phil(): ''' Generates a PHIL object from simTBX params @return: sim_phil: a PHIL object ''' ui_phil_string = """ description = None .type = str .help = Run description (optional). .optional = True output = None .type = path .help = Base output directory, current directory in command-line, can be set in GUI .optional = False image_prefix = synthetic_image .type = str .help = Prefix for synthetic image filenames (numbers will be added) image_format = *img cbf mccd pickle .type = choice .help = Will be format in the future, just extension for now reference_coordinates = None .type = path .help = Coordinates (PDB) to generate FCalc reference_FCalc = None .type = path .help = FCalc (MTZ) that can be used to generate the diffraction pattern reference_image = None .type = path .help = Diffraction image that can be used to match orientation radial_average_background = None .type = path .help = Radial average background (sin(theta) / lambda, STOL) dataset .help = Synthetic dataset options { start_phi = 0 .type = float .help = phi angle for the first image in the dataset finish_phi = 90 .type = float .help = phi angle for the last image in the dataset oscillation = 1 .type = float .help = phi oscillation per dataset image } """ sim = nanoBragg() params = [name for (name, value) in inspect.getmembers(nanoBragg, isprop)] param_lines = ['simtbx', '{'] for i in params: # The below properties result in boost errors (Fbg_vs_stol), TypeError # exceptions (xray_beams), or yield objects rather than values (the rest) if i in ('Fbg_vs_stol', 'Fhkl_tuple', 'amplitudes', 'indices', 'raw_pixels', 'xray_source_XYZ', 'xray_source_intensity_fraction', 'xray_beams', 'xray_source_wavelengths_A', 'unit_cell_tuple', 'progress_pixel'): continue try: param_value = getattr(sim, i) if type(param_value).__name__ == 'tuple': element_type = type(list(flatten(param_value))[0]).__name__ param_type = "{}s".format(element_type) param_value = ' '.join( str(i) for i in list(flatten(param_value))) param_doc = getattr(nanoBragg, i).__doc__ else: param_type = type(param_value).__name__ param_doc = getattr(nanoBragg, i).__doc__ if param_type == 'unit_cell': param_value = ' '.join( str(i) for i in param_value.parameters()) # Correct a number of weird vartypes if param_type in ('convention', 'pivot', 'shapetype'): param_type = 'str' # PHIL interprets ';' as a line break param_doc = param_doc.replace(';', '.') param_line = ' {} = {} \n .type = {}\n .help = {}' \ ''.format(i, param_value, param_type, param_doc) param_lines.append(param_line) except TypeError, e: print i, e pass
def modularized_exafel_api_for_GPU(self, argchk=False, cuda_background=True): from simtbx.gpu import gpu_energy_channels gpu_channels_singleton = gpu_energy_channels(deviceId=0) SIM = nanoBragg(self.DETECTOR, self.BEAM, panel_id=0) SIM.device_Id = 0 assert gpu_channels_singleton.get_deviceID() == SIM.device_Id assert gpu_channels_singleton.get_nchannels() == 0 # uninitialized for x in range(len(self.flux)): gpu_channels_singleton.structure_factors_to_GPU_direct_cuda( x, self.sfall_channels[x].indices(), self.sfall_channels[x].data()) assert gpu_channels_singleton.get_nchannels() == len(self.flux) SIM.Ncells_abc = (20, 20, 20) SIM.Amatrix = sqr(self.CRYSTAL.get_A()).transpose() SIM.oversample = 2 if argchk: print("\npolychromatic GPU argchk") SIM.xtal_shape = shapetype.Gauss_argchk else: print("\npolychromatic GPU no argchk") SIM.xtal_shape = shapetype.Gauss SIM.interpolate = 0 # allocate GPU arrays from simtbx.gpu import exascale_api gpu_simulation = exascale_api(nanoBragg=SIM) gpu_simulation.allocate_cuda() from simtbx.gpu import gpu_detector as gpud gpu_detector = gpud(deviceId=SIM.device_Id, detector=self.DETECTOR, beam=self.BEAM) gpu_detector.each_image_allocate_cuda() # loop over energies for x in range(len(self.flux)): SIM.flux = self.flux[x] SIM.wavelength_A = self.wavlen[x] print( "USE_EXASCALE_API+++++++++++++ Wavelength %d=%.6f, Flux %.6e, Fluence %.6e" % (x, SIM.wavelength_A, SIM.flux, SIM.fluence)) gpu_simulation.add_energy_channel_from_gpu_amplitudes_cuda( x, gpu_channels_singleton, gpu_detector) per_image_scale_factor = 1.0 gpu_detector.scale_in_place_cuda( per_image_scale_factor) # apply scale directly on GPU SIM.wavelength_A = self.BEAM.get_wavelength( ) # return to canonical energy for subsequent background if cuda_background: SIM.Fbg_vs_stol = water SIM.amorphous_sample_thick_mm = 0.02 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.flux = 1e12 SIM.beamsize_mm = 0.003 # square (not user specified) SIM.exposure_s = 1.0 # multiplies flux x exposure gpu_simulation.add_background_cuda(gpu_detector) # deallocate GPU arrays afterward gpu_detector.write_raw_pixels_cuda( SIM) # updates SIM.raw_pixels from GPU gpu_detector.each_image_free_cuda() else: # deallocate GPU arrays up front gpu_detector.write_raw_pixels_cuda( SIM) # updates SIM.raw_pixels from GPU gpu_detector.each_image_free_cuda() SIM.Fbg_vs_stol = water SIM.amorphous_sample_thick_mm = 0.02 SIM.amorphous_density_gcm3 = 1 SIM.amorphous_molecular_weight_Da = 18 SIM.flux = 1e12 SIM.beamsize_mm = 0.003 # square (not user specified) SIM.exposure_s = 1.0 # multiplies flux x exposure SIM.progress_meter = False SIM.add_background() return SIM
from __future__ import division # test that mosaic spread is working #from scitbx.array_family import flex from simtbx.nanoBragg import shapetype #from simtbx.nanoBragg import convention from simtbx.nanoBragg import nanoBragg # create the simulation object, all parameters have sensible defaults SIM = nanoBragg(detpixels_slowfast=(150,150),pixel_size_mm=0.1,verbose=0) # fairly big cell SIM.unit_cell_tuple = (100,100,100,90,90,90) # nice, sharp spots SIM.Ncells_abc = (50,50,50) SIM.xtal_shape=shapetype.Tophat # dont bother with importing a structure, we just want spots SIM.default_F = 1 SIM.F000 = 0.03 # the usual wavelength SIM.wavelength_A = 1.0 # detector far away SIM.distance_mm = 1000 # beam center near one edge SIM.beam_center_mm = (1,7) #print SIM.XDS_ORGXY #print SIM.dials_origin_mm
def run_sim2smv(img_prefix=None, simparams=None,pdb_lines=None,crystal=None,spectra=None,rotation=None,rank=None,fsave=None,sfall_cluster=None,quick=False): smv_fileout = fsave direct_algo_res_limit = simparams.direct_algo_res_limit wavlen, flux, real_wavelength_A = next(spectra) # list of lambdas, list of fluxes, average wavelength real_flux = flex.sum(flux) assert real_wavelength_A > 0 # print(rank, " ## real_wavelength_A/real_flux = ", real_wavelength_A, real_flux*1.0/simparams.flux) if quick: wavlen = flex.double([real_wavelength_A]) flux = flex.double([real_flux]) # GF = gen_fmodel(resolution=simparams.direct_algo_res_limit,pdb_text=pdb_lines,algorithm=simparams.fmodel_algorithm,wavelength=real_wavelength_A) # GF.set_k_sol(simparams.k_sol) # GF.make_P1_primitive() sfall_main = sfall_cluster["main"] #GF.get_amplitudes() # use crystal structure to initialize Fhkl array # sfall_main.show_summary(prefix = "Amplitudes used ") N = crystal.number_of_cells(sfall_main.unit_cell()) #print("## number of N = ", N) SIM = nanoBragg(detpixels_slowfast=(simparams.detector_size_ny,simparams.detector_size_nx),pixel_size_mm=simparams.pixel_size_mm,\ Ncells_abc=(N,N,N),wavelength_A=real_wavelength_A,verbose=0) # workaround for problem with wavelength array, specify it separately in constructor. # SIM.adc_offset_adu = 0 # Do not offset by 40 SIM.adc_offset_adu = 10 # Do not offset by 40 SIM.seed = 0 # SIM.randomize_orientation() SIM.mosaic_spread_deg = simparams.mosaic_spread_deg # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = simparams.mosaic_domains # 77 seconds. SIM.distance_mm = simparams.distance_mm ## setup the mosaicity UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) scitbx.random.set_random_seed(1234) rand_norm = scitbx.random.normal_distribution(mean=0, sigma=SIM.mosaic_spread_deg * math.pi/180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(SIM.mosaic_domains) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(m,deg=False) ) SIM.set_mosaic_blocks(UMAT_nm) ###################### SIM.beamcenter_convention=convention.ADXV SIM.beam_center_mm=(simparams.beam_center_x_mm, simparams.beam_center_y_mm) # 95.975 96.855 ###################### # get same noise each time this test is run SIM.seed = 0 SIM.oversample=simparams.oversample SIM.wavelength_A = real_wavelength_A SIM.polarization=simparams.polarization # this will become F000, marking the beam center SIM.default_F=simparams.default_F #SIM.missets_deg= (10,20,30) SIM.Fhkl=sfall_main Amatrix_rot = (rotation * sqr(sfall_main.unit_cell().orthogonalization_matrix())).transpose() SIM.Amatrix_RUB = Amatrix_rot #workaround for failing init_cell, use custom written Amatrix setter # print("## inside run_sim2smv, Amat_rot = ", Amatrix_rot) Amat = sqr(SIM.Amatrix).transpose() # recovered Amatrix from SIM Ori = crystal_orientation.crystal_orientation(Amat, crystal_orientation.basis_type.reciprocal) SIM.xtal_shape=shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter=False # SIM.show_params() # flux is always in photons/s SIM.flux=real_flux SIM.exposure_s=simparams.exposure_s # assumes round beam SIM.beamsize_mm=simparams.beamsize_mm #cannot make this 3 microns; spots are too intense temp=SIM.Ncells_abc SIM.Ncells_abc=temp # print("## domains_per_crystal = ", crystal.domains_per_crystal) SIM.raw_pixels *= crystal.domains_per_crystal # must calculate the correct scale! # print("## Initial raw_pixels = ", flex.sum(SIM.raw_pixels)) for x in range(len(flux)): # CH = channel_pixels(wavlen[x],flux[x],N,UMAT_nm,Amatrix_rot,sfall_cluster[x],rank) # print("## in loop wavlen/flux/real_wavelength_A = ", wavlen[x], flux[x]/real_flux, real_wavelength_A) CH = channel_pixels(simparams=simparams,single_wavelength_A=wavlen[x],single_flux=flux[x],N=N,UMAT_nm=UMAT_nm, \ Amatrix_rot=Amatrix_rot,sfall_channel=sfall_cluster[x],rank=rank) SIM.raw_pixels += CH.raw_pixels * crystal.domains_per_crystal CHDBG_singleton.extract(channel_no=x, data=CH.raw_pixels) CH.free_all() # print("## sum raw_pixels after ", x, "is", flex.sum(SIM.raw_pixels)) # rough approximation to water: interpolation points for sin(theta/lambda) vs structure factor bg = flex.vec2_double([(0,2.57),(0.0365,2.58),(0.07,2.8),(0.12,5),(0.162,8),(0.2,6.75),(0.18,7.32),(0.216,6.75),(0.236,6.5),(0.28,4.5),(0.3,4.3),(0.345,4.36),(0.436,3.77),(0.5,3.17)]) SIM.Fbg_vs_stol = bg SIM.amorphous_sample_thick_mm = simparams.water_sample_thick_mm SIM.amorphous_density_gcm3 = simparams.water_density_gcm3 SIM.amorphous_molecular_weight_Da = simparams.water_molecular_weight_Da SIM.flux=real_flux SIM.beamsize_mm=simparams.beamsize_mm # square (not user specified) SIM.exposure_s=simparams.exposure_s # multiplies flux x exposure SIM.add_background() # rough approximation to air bg = flex.vec2_double([(0,14.1),(0.045,13.5),(0.174,8.35),(0.35,4.78),(0.5,4.22)]) SIM.Fbg_vs_stol = bg SIM.amorphous_sample_thick_mm = simparams.air_sample_thick_mm # between beamstop and collimator SIM.amorphous_density_gcm3 = simparams.air_density_gcm3 SIM.amorphous_sample_molecular_weight_Da = simparams.air_molecular_weight_Da # nitrogen = N2 SIM.add_background() #apply beamstop mask here # settings for CCD SIM.detector_psf_kernel_radius_pixels=simparams.detector_psf_kernel_radius_pixels SIM.detector_psf_type=shapetype.Unknown # for CSPAD SIM.detector_psf_fwhm_mm=simparams.detector_psf_fwhm_mm SIM.apply_psf() SIM.add_noise() extra = "PREFIX=%s;\nRANK=%d;\n"%(img_prefix,rank) SIM.to_smv_format_py(fileout=smv_fileout,intfile_scale=1,rotmat=True,extra=extra,gz=True) SIM.free_all()
def perform_simulations(self, spectrum, crystal, tophat_spectrum=True): #borrow code from util_partiality. #def run_sim2smv(ROI,prefix,crystal,spectra,rotation,rank,tophat_spectrum=True,quick=False): direct_algo_res_limit = 1.7 self.wavlen, self.flux, self.wavelength_A = next( spectrum) # list of lambdas, list of fluxes, average wavelength if tophat_spectrum: sum_flux = flex.sum(self.flux) ave_flux = sum_flux / 60. # 60 energy channels for ix in range(len(self.wavlen)): energy = 12398.425 / self.wavlen[ix] if energy >= 7090 and energy <= 7150: self.flux[ix] = ave_flux else: self.flux[ix] = 0. # use crystal structure to initialize Fhkl array self.sfall_main.show_summary(prefix="Amplitudes used ") N = crystal.number_of_cells(self.sfall_main.unit_cell()) self.crystal = crystal # delete later self.N = N # delete later SIM = nanoBragg( detpixels_slowfast=(3000, 3000), pixel_size_mm=0.11, Ncells_abc=(N, N, N), # workaround for problem with wavelength array, specify it separately in constructor. wavelength_A=self.wavelength_A, verbose=0) self.SIM = SIM SIM.adc_offset_adu = 10 # Do not offset by 40 SIM.mosaic_spread_deg = 0.05 # interpreted by UMAT_nm as a half-width stddev SIM.mosaic_domains = 50 # mosaic_domains setter must come after mosaic_spread_deg setter #manuscript says 200, June 15 abc_cov was done with 50 SIM.distance_mm = 141.7 UMAT_nm = flex.mat3_double() mersenne_twister = flex.mersenne_twister(seed=0) scitbx.random.set_random_seed(1234) rand_norm = scitbx.random.normal_distribution( mean=0, sigma=SIM.mosaic_spread_deg * math.pi / 180.) g = scitbx.random.variate(rand_norm) mosaic_rotation = g(SIM.mosaic_domains) for m in mosaic_rotation: site = col(mersenne_twister.random_double_point_on_sphere()) UMAT_nm.append( site.axis_and_angle_as_r3_rotation_matrix(m, deg=False)) SIM.set_mosaic_blocks(UMAT_nm) self.UMAT_nm = UMAT_nm # delete later # get same noise each time this test is run SIM.seed = 1 SIM.oversample = 1 SIM.wavelength_A = self.wavelength_A SIM.polarization = 1 # this will become F000, marking the beam center SIM.default_F = 0 #SIM.Fhkl=self.sfall_main # no it turns out we don't use these calculations for abc_coverage # use local file with (open(something,"wb")) as F: with (open("confirm_sfall_P1_7122_amplitudes.pickle", "rb")) as F: sfall_P1_7122_amplitudes = pickle.load(F) SIM.Fhkl = sfall_P1_7122_amplitudes SIM.xtal_shape = shapetype.Gauss # both crystal & RLP are Gaussian SIM.progress_meter = False SIM.show_params() # flux is always in photons/s SIM.flux = 1e12 SIM.exposure_s = 1.0 # so total fluence is e12 # assumes round beam SIM.beamsize_mm = 0.003 #cannot make this 3 microns; spots are too intense temp = SIM.Ncells_abc print("Ncells_abc=", SIM.Ncells_abc) SIM.Ncells_abc = temp