def norm_spray(test_path, flat_path, dark_path, mask_fld, save_fld): if 'TimeRes' in save_fld: test_fld = test_path.split('.tif')[0][:-5].split('/')[-1] save_fld = create_folder(f'{save_fld}/{test_fld}/') mask_fld = save_fld.replace('Norm', 'Mask') data = np.array(Image.open(test_path)) flat = np.array(Image.open(flat_path)) dark = np.array(Image.open(dark_path)) data_norm = (data - dark) / (flat - dark) # Mask the image lcsc_mask = np.array(Image.open(f'{prj_fld}/Images/Spray/LCSC_Mask.tif')) data_norm *= (lcsc_mask > 0) # Calculate offset data_mask = mask_image(test_path, data_norm, 0.7, mask_fld, lcsc_mask) data_bg = data_norm * ~(data_mask > 0) * (lcsc_mask > 0) data_bg[data_bg == 0] = np.nan ofst = np.nanmedian(data_bg) data_norm /= ofst # Apply median filter to remove spurious pixels data_norm = median_filter(data_norm, 3) # Scale image data_norm *= 5000 # Save Transmission images im = Image.fromarray(data_norm.astype(np.uint16)) im.save(save_fld + '/' + split(test_path)[1])
def saveProj(data, name, folder): folder = create_folder(folder) montage = np.reshape(data, (data.shape[0], -1)) im = Image.fromarray(montage) im.save('{0}/{1}.tif'.format(folder, name)) return
def main(): # Get 50% KI in H2O density in g/cm^3, convert to ug/mm^3 density = density_KIinH2O(50) * 1000 # Location of the 0.30 gpm AVERAGED input and outputs #ij_0p30avg_inp = glob.glob('{0}/TimeAvg_0p30/' # '0p30/FastMART_500iter_Smooth500iter/' # 'Data/S0*/'.format(inp_fld)) #ij_0p30avg_out = create_folder('{0}/SprayVol/IJ_0p30gpm_AVG/' # .format(out_fld)) # Location of the 0.30 gpm input and outputs ij_0p30_inp = glob.glob('{0}/EPL7_30/MakePermanentImgMask/' 'FastMART_500iter_Smooth500Iter/' 'Data/S0*/'.format(inp_fld)) ij_0p30_out = create_folder('{0}/SprayVol/IJ_0p30gpm/'.format(out_fld)) # Location of the 0.45 gpm input and outputs #ij_0p45_inp = glob.glob('{0}/Statistics_0p45/' # '0p45/FastMART_500iter_Smooth500/' # 'Data/S0*/'.format(inp_fld)) #ij_0p45_out = create_folder('{0}/SprayVol/IJ_0p45gpm/' # .format(out_fld)) # Rotations for the volumes (see Jupyter Notebook) rot = {'Angle': 13, 'Axes': (2, 0)} # Convert the individual volumes #convertVTK(ij_0p30avg_inp, rot, ij_0p30avg_out, density) convertVTK(ij_0p30_inp, rot, ij_0p30_out, density)
def save_plt(dataset, plt_folder, plt_name, zone=None): """ Function that saves the Tecplot dataset/zone into a .plt file. This function saves to an individual .plt file. If you want to save a series of volumes (such as for each zone), then call this function inside a for-loop. INPUT VARIABLES --------------- dataset: Tecplot dataset. plt_folder: Output folder path where the .plt file will be saved. plt_name: Desired name of the .plt file. zone: OPTIONAL. Specific zone to save (can call by name or index starting at 1). If not specified, will save the entire dataset. """ # Create folder if it doesn't exist plt_fld = create_folder(plt_fld) # Save the dataset to a PLT file tp.data.save_tecplot_plt('{0}/{1}.plt'.format(plt_fld, plt_name), dataset=dataset, zones=zone)
def averaged_plots(x, y, ylbl, xlbl, scale, name, scint): """ Creates plots of the averaged variables. ============= --VARIABLES-- x: X axis variable. y: Y axis variable. ylbl: Y axis label. xlbl: X axis label. scale: Y scale ('log' or 'linear'). name: Save name for the plot. scint: Scintillator being used. """ global prj_fld averaged_folder = create_folder( '{0}/Figures/Averaged_Figures'.format(prj_fld)) plt.figure() # Water plt.plot(x[0], y[0], color='k', linewidth=2.0, label='Water') # 1.6% KI plt.plot(x[1], y[1], marker='x', markevery=50, linewidth=2.0, label='1.6% KI') # 3.4% KI plt.plot(x[2], y[2], linestyle='--', linewidth=2.0, label='3.4% KI') # 5.3% KI plt.plot(x[3], y[3], linestyle='-.', linewidth=2.0, label='5.3% KI') # 8.1% KI plt.plot(x[4], y[4], linestyle=':', linewidth=2.0, label='8.1% KI') # 10.0% KI plt.plot(x[5], y[5], marker='^', markevery=50, linewidth=2.0, label='10.0% KI') # 11.1% KI plt.plot(x[6], y[6], linestyle='--', linewidth=2.0, label='11.1% KI') plt.legend() plt.ylabel(ylbl) plt.xlabel(xlbl) plt.yscale(scale) plt.savefig('{0}/{1}_{2}.png'.format(averaged_folder, scint, name))
def saveAnim(fld, renderView, viewType, timeSteps): # Save animation save_fld = create_folder('{0}/PV_{1}/'.format(fld, viewType)) SaveAnimation( '{}/vol.png'.format(save_fld), renderView, FrameWindow=[0, timeSteps-1], ImageResolution=[1116, 527], TransparentBackground=1, CompressionLevel='0', SuffixFormat='%04d' )
def main(): prj_fld = '/mnt/r/X-ray Radiography/APS 2019-1/' cor_fld = '{0}/Corrected/YAG/Summary/'.format(prj_fld) plt_fld = create_folder('{0}/Figures/Cal_Errors/'.format(prj_fld)) tests = glob.glob('{0}/*.pckl'.format(cor_fld)) # Container for what will be the summary DataFrame d = [] for test in tests: # Use 'Ellipse' as the method (worked best in 2018-1) method = 'Ellipse' # Retrieve test name test_name = test.rsplit('/')[-1].rsplit('.')[0] # Retrieve vertical locations vert_loc = np.array(get_ypos(test)) # Retrieve errors abEr = get_abs(test, method) rmse = get_rmse(test, method) mape = get_mape(test, method) zeta = get_zeta(test, method) mdlq = get_mdlq(test, method) # Remove outliers from data vert_loc, abEr = reject_outliers(vert_loc, abEr) # Build up summary dict d.append({ 'Name': test_name, 'RMSE': rmse, 'MAPE': mape, 'Zeta': zeta, 'MdLQ': mdlq }) # Create absolute error plot plt.figure() plt.plot(vert_loc, abEr, color='tab:blue', linewidth=2.0) plt.xlabel('Vertical Location (px)') plt.ylabel('Absolute Error ($\mu$m)') plt.title(test_name) plt.savefig('{0}/{1}.png'.format(plt_fld, test_name)) plt.close() # Save summary of errors summ = pd.DataFrame(d) summ.to_csv(prj_fld + '/Corrected/YAG/summary.txt', sep='\t')
def main(): # Get 50% KI in H2O density in g/cm^3, convert to ug/mm^3 density = density_KIinH2O(50) * 1000 # Location of the 0.30 gpm input and outputs sc_0p20_inp = glob.glob('{0}/New_SC_0p20/' 'SC_0p20/FastMART/' 'Data/S0*/'.format(inp_fld)) sc_0p20_out = create_folder('{0}/SprayVol/SC_0p20gpm/'.format(out_fld)) # Rotations for the volumes (see Jupyter Notebook) rot = {'Angle': 13, 'Axes': (2, 0)} # Convert the individual volumes convertVTK(sc_0p20_inp, rot, sc_0p20_out, density)
def conv_spray(test_path, save_fld): if 'TimeRes' in save_fld: test_fld = test_path.split('.tif')[0][:-5].split('/')[-1] save_fld = create_folder(f'{save_fld}/{test_fld}/') # Load models from the whitebeam_2019 script with open(prj_fld + '/Model/water_model_YAG.pckl', 'rb') as f: water_mdl = pickle.load(f) with open(prj_fld + '/Model/KI4p8_model_YAG.pckl', 'rb') as f: KI4p8_mdl = pickle.load(f) models = [water_mdl, KI4p8_mdl] # Load corresponding model if 'KI' in test_path: model = models[1] else: model = models[0] TtoEPL = model[0] # Load in normalized image data_norm = np.array(Image.open(test_path)).astype(float) / 5000 # Convert to EPL in cm data_epl = np.zeros(np.shape(data_norm), dtype=float) for k, _ in enumerate(data_norm): data_epl[k, :] = TtoEPL[k](data_norm[k, :]) # Mask the image lcsc_mask = np.array(Image.open(f'{prj_fld}/Images/Spray/LCSC_Mask.tif')) data_epl *= (lcsc_mask > 0) # Calculate offset data_mask = np.array(Image.open(test_path.replace('/Norm/', '/Mask/'))) data_bg = data_epl * ~(data_mask > 0) * (lcsc_mask > 0) data_bg[data_bg == 0] = np.nan ofst = np.nanmedian(data_bg) data_epl -= ofst # Scale image for saving as np.uint16 data_epl += 1 # for negative values data_epl *= 2500 # Save EPL image im = Image.fromarray(data_epl.astype(np.uint16)) im.save(save_fld + '/' + split(test_path)[1])
def saveVol(vol, W, name, folder): grid = W.vshape[::-1] winX = [W.vg['options']['WindowMinX'], W.vg['options']['WindowMaxX']] winY = [W.vg['options']['WindowMinY'], W.vg['options']['WindowMaxY']] winZ = [W.vg['options']['WindowMinZ'], W.vg['options']['WindowMaxZ']] win = [winX, winY, winZ] grid = [np.linspace(*w, g) for (w, g) in zip(win, grid)] limits = [[-999, 999]] * 3 center_x = -0.37 center_y = 0.9 center_z = 0.2 cropX = [np.argmin(np.abs(grid[0] - x)) for x in limits[0]] cropY = [np.argmin(np.abs(grid[1] - y)) for y in limits[1]] cropZ = [np.argmin(np.abs(grid[2] - z)) for z in limits[2]] vol2 = np.array(vol[cropZ[0]:cropZ[1], cropY[0]:cropY[1], cropX[0]:cropX[1]], order='F') gridX = grid[0][cropX[0]:cropX[1]] gridY = grid[1][cropY[0]:cropY[1]] gridZ = grid[2][cropZ[0]:cropZ[1]] voxelSize = [ np.mean(np.diff(gridX)), np.mean(np.diff(gridY)), np.mean(np.diff(gridZ)) ] originX = (gridX - center_x)[0] originY = (gridY - center_y)[0] originZ = (gridZ - center_z)[0] # Save volume folder = create_folder(folder) imageToVTK( '{0}/{1}'.format(folder, name), origin=[originZ, originY, originX], spacing=np.flip(voxelSize, axis=0).tolist(), pointData={'LVF': (vol2 / density_KIinH2O(50)).astype(np.int16)}) return
def main(): # Spray type sprays = ['SC', 'AeroECN 100psi 10%KI'] for spray in sprays: # Location of spray images spry_fld = '{0}/Images/{1}/'.format(prj_fld, spray) # Flat and dark image paths flat = glob.glob('{0}/Mean/*flat*'.format(spry_fld))[0] dark = glob.glob('{0}/Mean/*dark*'.format(spry_fld))[0] # Time-averaged images tavg_files = glob.glob('{0}/Mean/*.tif'.format(spry_fld)) # Time-resolved images tres_fld = glob.glob('{0}/Raw/*'.format(spry_fld)) # Remove flat/dark from the folder tres_fld = [x for x in tres_fld if 'dark' not in x] tres_fld = [x for x in tres_fld if 'flat' not in x] tres_files = [glob.glob('{0}/*.tif'.format(x))[500] for x in tres_fld] # Run time-averaged normalization norm_tavg_fld = create_folder('{0}/Norm/TimeAvg/'.format(spry_fld)) mask_tavg_fld = create_folder('{0}/Mask/TimeAvg/'.format(spry_fld)) [ norm_spray(x, flat, dark, norm_tavg_fld, mask_tavg_fld) for x in tavg_files ] # Run time-resolved normalization norm_tres_fld = create_folder('{0}/Norm/TimeRes/'.format(spry_fld)) mask_tres_fld = create_folder('{0}/Mask/TimeRes/'.format(spry_fld)) [ norm_spray(x, flat, dark, norm_tres_fld, mask_tres_fld) for x in tres_files ] # Run time-averaged EPL conversion epl_tavg_fld = create_folder('{0}/EPL/TimeAvg/'.format(spry_fld)) tavg_files = glob.glob('{0}/*.tif'.format(norm_tavg_fld)) [conv_spray(x, epl_tavg_fld) for x in tavg_files] # Run time-resolved EPL conversion epl_tres_fld = create_folder('{0}/EPL/TimeRes/'.format(spry_fld)) tres_files = glob.glob('{0}/*.tif'.format(norm_tres_fld)) [conv_spray(x, epl_tres_fld) for x in tres_files]
def plot_atten(atten1, atten2, name): """ Plots the attenuation coefficients before and after re-shaping. ============= --VARIABLES-- atten1: Original attenuation coefficient from nist.mass_atten. atten2: Updated attenuation coefficient from spectrum_modeling.xcom_reshape. name: Name of filter. """ atten_fld = create_folder('{0}/Figures/Atten_Coeff'.format(prj_fld)) plt.figure() plt.plot(atten1['Energy'], atten1['Attenuation'], label='Original', linestyle='solid', color='k', linewidth=2.0, zorder=1) plt.plot(atten2['Energy'], atten2['Attenuation'], label='Re-shaped', linestyle='dashed', color='b', linewidth=2.0, zorder=2) plt.yscale('log') plt.legend() plt.xlabel('Photon Energy (keV)') plt.ylabel('Attenuation Coefficient (cm$^2$/g') plt.title('{0}'.format(name)) plt.savefig('{0}/{1}.png'.format(atten_fld, name)) plt.close() return
def main(): # Location of spray images spry_fld = '{0}/Images/Spray/'.format(prj_fld) # Flat and dark image paths flat = '{0}/Images/Flat/Mean/AVG_Background_NewYAG.tif'.format(prj_fld) dark = '{0}/Images/Flat/AVG_dark_current.tif'.format(prj_fld) # Time-averaged images tavg_files = glob.glob('{0}/Mean/*.tif'.format(spry_fld)) # Time-resolved images tres_fld = glob.glob('{0}/Raw/*'.format(spry_fld)) tres_files = [ glob.glob('{0}/*.tif'.format(x))[:100] for x in tres_fld if 'NewYAG' in x ] # Run time-averaged normalization mask_fld = create_folder('{0}/Mask/TimeAvg/'.format(spry_fld)) norm_fld = create_folder('{0}/Norm/TimeAvg/'.format(spry_fld)) [norm_spray(x, flat, dark, mask_fld, norm_fld) for x in tavg_files] # Run time-averaged EPL conversion epl_tavg_fld = create_folder('{0}/EPL/TimeAvg/'.format(spry_fld)) tavg_files = glob.glob('{0}/*.tif'.format(norm_fld)) [conv_spray(x, epl_tavg_fld) for x in tavg_files] # Run time-resolved normalization mask_fld = create_folder('{0}/Mask/TimeRes/'.format(spry_fld)) norm_fld = create_folder('{0}/Norm/TimeRes/'.format(spry_fld)) [[norm_spray(x, flat, dark, mask_fld, norm_fld) for x in y] for y in tres_files] # Run time-resolved EPL conversion epl_tres_fld = create_folder('{0}/EPL/TimeRes/'.format(spry_fld)) tres_files = glob.glob('{0}/**/*.tif'.format(norm_fld), recursive=True) # Crop (if desired) tres_files = np.reshape(tres_files, (-1, 5001)) tres_files = tres_files[:, :100].flatten().tolist() [conv_spray(x, epl_tres_fld) for x in tres_files]
""" import pickle import glob import warnings import numpy as np import pandas as pd import matplotlib.pyplot as plt from general.calc_statistics import polyfit from general.misc import create_folder # Location of APS 2018-1 data prj_fld = '/mnt/r/X-ray Radiography/APS 2018-1/' # Save location for the plots plt_fld = create_folder('{0}/Figures/Jet_Errors/'.format(prj_fld)) # KI % KIconc = [0, 1.6, 3.4, 5.3, 8.1, 10, 11.1] def get_xpos(path): with open(path, 'rb') as f: processed_data = pickle.load(f) xpos = np.nanmean(processed_data['Lateral Position']) return xpos def get_per(path, method):
def proc_jet(cropped_view, cm_px, save_fld, scint, index, test_name, test_path, TtoEPL, EPLtoT, offset_sl_x, offset_sl_y, data_norm, iface): # Create folders epl_fld = create_folder(save_fld + '/EPL') summ_fld = create_folder(save_fld + '/Summary') ratio_elps_fld = create_folder(save_fld + '/RatioEllipse') ratio_peak_fld = create_folder(save_fld + '/RatioPeak') vert_elps_fld = create_folder(save_fld + '/EllipseVertical') vert_peak_fld = create_folder(save_fld + '/PeakVertical') vert_opt_fld = create_folder(save_fld + '/OpticalVertical') ratio_elpsT_fld = create_folder(save_fld + '/RatioEllipseT') ratio_peakT_fld = create_folder(save_fld + '/RatioPeakT') bnd_fld = create_folder(save_fld + '/Boundaries') graph_fld = create_folder(save_fld + '/Graphs/' + test_name) width_fld = create_folder(save_fld + '/Widths/' + test_name) scans_fld = create_folder(save_fld + '/Scans/') # Construct EPL mapping data_epl = np.zeros(np.shape(data_norm), dtype=float) ofst_epl = np.zeros(np.shape(data_norm)[0], dtype=float) for _, k in enumerate(cropped_view): data_epl[k, :] = TtoEPL[k](data_norm[k, :]) # Correct the EPL values ofst_epl = np.nanmedian(data_epl[offset_sl_x, offset_sl_y]) data_epl -= ofst_epl left_bound = len(cropped_view) * [np.nan] right_bound = len(cropped_view) * [np.nan] elps_epl = len(cropped_view) * [np.nan] optical_diameter = len(cropped_view) * [np.nan] peak_epl = len(cropped_view) * [np.nan] axial_position = len(cropped_view) * [np.nan] lateral_position = len(cropped_view) * [np.nan] fitted_graph = len(cropped_view) * [np.nan] epl_graph = len(cropped_view) * [np.nan] optical_T = len(cropped_view) * [np.nan] peak_T = len(cropped_view) * [np.nan] elps_T = len(cropped_view) * [np.nan] for z, k in enumerate(cropped_view): smoothed = savgol_filter(data_epl[k, :], 5, 3) warnings.filterwarnings('ignore') peaks, _ = find_peaks(smoothed, width=100) warnings.filterwarnings('default') if len(peaks) == 1: # Offset EPL calculation (row-wise) warnings.filterwarnings('ignore') [_, _, lpos, rpos] = peak_widths(smoothed, peaks, rel_height=0.85) warnings.filterwarnings('default') #left_side = data_epl[k, 0:int(round(lpos[0]))-10] #right_side = data_epl[k, int(round(rpos[0]))+10:-1] #ofst_epl[k] = np.mean([np.nanmedian(left_side), # np.nanmedian(right_side)]) #data_epl[k, :] -= ofst_epl[k] #if '005' in test_name: # breakpoint() #smoothed -= ofst_epl[k] # Ellipse fitting warnings.filterwarnings('ignore') [rel_width, rel_max, lpos, rpos] = peak_widths(smoothed, peaks, rel_height=0.85) warnings.filterwarnings('default') rel_width = rel_width[0] rel_max = rel_max[0] left_bound[z] = lpos[0] right_bound[z] = rpos[0] ydata = smoothed[int(round(lpos[0])):int(round(rpos[0]))] warnings.filterwarnings('ignore') ide_data = ideal_ellipse(ydata, rel_width, rel_max, cm_px) elps_epl[z] = ide_data[0] fitted_graph[z] = ide_data[1] epl_graph[z] = ide_data[2] warnings.filterwarnings('default') optical_diameter[z] = rel_width * cm_px axial_position[z] = k lateral_position[z] = int(np.mean([lpos[0], rpos[0]])) peak_epl[z] = smoothed[peaks[0]] # Convert diameters to transmissions optical_T[z] = EPLtoT[k](optical_diameter[z]) peak_T[z] = EPLtoT[k](peak_epl[z]) elps_T[z] = EPLtoT[k](elps_epl[z]) # Plot the fitted and EPL graphs if z % 15 == 0: # Ellipse plot_ellipse(epl_graph[z], fitted_graph[z], '{0}/{1}_{2:03d}.png'.format(graph_fld, scint, k)) plt.close() plot_widths(data_epl[k, :], peaks, rel_max, lpos[0], rpos[0], '{0}/{1}_{2:03d}.png'.format(width_fld, scint, k)) plt.close() # Save EPL images im = Image.fromarray(data_epl) im.save(epl_fld + '/' + test_path.rsplit('/')[-1].replace('Norm', 'EPL')) if len(peaks) == 1: lat_start = int(round(np.nanmean(lateral_position))) - 20 lat_end = int(round(np.nanmean(lateral_position))) + 20 signal = np.nanmean(data_epl[20:325, lat_start:lat_end]) else: signal = 0 noise = np.nanstd(data_epl[offset_sl_x, offset_sl_y]) SNR = signal / noise # Calculate ratios ratio_ellipseT = np.array(elps_T) / np.array(optical_T) ratio_peakT = np.array(peak_T) / np.array(optical_T) ratio_ellipse = np.array(elps_epl) / np.array(optical_diameter) ratio_peak = np.array(peak_epl) / np.array(optical_diameter) mean_ratio_ellipseT = np.nanmean(ratio_ellipseT) mean_ratio_peakT = np.nanmean(ratio_peakT) mean_ratio_ellipse = np.nanmean(ratio_ellipse) mean_ratio_peak = np.nanmean(ratio_peak) cv_ratio_ellipseT = np.nanstd(ratio_ellipseT) / np.nanmean(ratio_ellipseT) cv_ratio_peakT = np.nanstd(ratio_peakT) / np.nanmean(ratio_peakT) cv_ratio_ellipse = np.nanstd(ratio_ellipse) / np.nanmean(ratio_ellipse) cv_ratio_peak = np.nanstd(ratio_peak) / np.nanmean(ratio_peak) with np.errstate(all='ignore'): ellipse_errors = [ rmse(elps_epl, optical_diameter), mape(elps_epl, optical_diameter), zeta(elps_epl, optical_diameter), mdlq(elps_epl, optical_diameter) ] peak_errors = [ rmse(peak_epl, optical_diameter), mape(peak_epl, optical_diameter), zeta(peak_epl, optical_diameter), mdlq(peak_epl, optical_diameter) ] processed_data = { 'Diameters': [optical_diameter, elps_epl, peak_epl], 'Transmissions': [optical_T, elps_T, peak_T], 'Axial Position': axial_position, 'Lateral Position': lateral_position, 'Bounds': [left_bound, right_bound], 'Offset EPL': ofst_epl, 'SNR': SNR, 'Ellipse Errors': ellipse_errors, 'Peak Errors': peak_errors, 'Transmission Ratios': [ratio_ellipseT, ratio_peakT], 'EPL Ratios': [ratio_peak, ratio_ellipse], 'Injector Face': iface } with open(summ_fld + '/' + scint + '_' + test_name + '.pckl', 'wb') as f: pickle.dump(processed_data, f) with open('{0}/{1}_{2}_y170.pckl'.format(scans_fld, scint, test_name), 'wb') as f: pickle.dump( [data_epl[170, :], savgol_filter(data_epl[170, :], 105, 7)], f) with open('{0}/{1}_{2}_y60.pckl'.format(scans_fld, scint, test_name), 'wb') as f: pickle.dump([data_epl[60, :], savgol_filter(data_epl[60, :], 105, 7)], f) # Boundary plot plt.figure() plt.imshow(data_epl, vmin=0, vmax=0.50, zorder=1) plt.scatter(x=left_bound, y=axial_position, s=1, color='red', zorder=2) plt.scatter(x=right_bound, y=axial_position, s=1, color='red', zorder=2) plt.scatter(x=lateral_position, y=axial_position, s=1, color='white', zorder=2) plt.title(test_name) plt.savefig('{0}/{1}.png'.format(bnd_fld, test_name)) plt.close() # Vertical ellipse variation plt.figure() plt.plot(axial_position, np.array(elps_epl) * 10, ' o') plt.xlabel('Axial Position (px)') plt.ylabel('Ellipse Diameter (mm)') plt.xlim([0, 480]) plt.ylim([0.4, 5.0]) plt.title(test_name) plt.savefig('{0}/{1}_{2}.png'.format(vert_elps_fld, scint, test_name)) plt.close() # Vertical peak variation plt.figure() plt.plot(axial_position, np.array(peak_epl) * 10, ' o') plt.xlabel('Axial Position (px)') plt.ylabel('Peak Diameter (mm)') plt.xlim([0, 480]) plt.ylim([0.4, 5.0]) plt.title(test_name) plt.savefig('{0}/{1}_{2}.png'.format(vert_peak_fld, scint, test_name)) plt.close() # Vertical optical variation plt.figure() plt.plot(axial_position, np.array(optical_diameter) * 10, ' o') plt.xlabel('Axial Position (px)') plt.ylabel('Optical Diameter (mm)') plt.xlim([0, 480]) plt.ylim([0.4, 5.0]) plt.title(test_name) plt.savefig('{0}/{1}_{2}.png'.format(vert_opt_fld, scint, test_name)) plt.close() # Vertical EPL ratio (ellipse) plt.figure() plt.plot(axial_position, ratio_ellipse, ' o') plt.xlabel('Axial Position (px)') plt.ylabel('Ellipse/Optical EPL Ratio') plt.xlim([0, 480]) plt.ylim([0.4, 2.1]) plt.savefig('{0}/{1}_{2}.png'.format(ratio_elps_fld, scint, test_name)) plt.close() # Vertical EPL ratio (peak) plt.figure() plt.plot(axial_position, ratio_peak, ' o') plt.xlabel('Axial Position (px)') plt.ylabel('Peak/Optical EPL Ratio') plt.xlim([0, 480]) plt.ylim([0.4, 2.1]) plt.savefig('{0}/{1}_{2}.png'.format(ratio_peak_fld, scint, test_name)) plt.close() # Vertical transmission ratio (ellipse) plt.figure() plt.plot(axial_position, ratio_ellipseT, ' o') plt.xlabel('Axial Position (px)') plt.ylabel('Ellipse/Optical Transmission Ratio') plt.xlim([0, 480]) plt.ylim([0.8, 2.3]) plt.title(test_name) plt.savefig('{0}/{1}_{2}.png'.format(ratio_elpsT_fld, scint, test_name)) plt.close() # Vertical transmission ratio (peak) plt.figure() plt.plot(axial_position, ratio_peakT, ' o') plt.xlabel('Axial Position (px)') plt.ylabel('Peak/Optical Transmission Ratio') plt.xlim([0, 480]) plt.ylim([0.8, 2.3]) plt.title(test_name) plt.savefig('{0}/{1}_{2}.png'.format(ratio_peakT_fld, scint, test_name)) plt.close()
def main(): # Location of APS 2018-1 data prj_fld = '/mnt/r/X-ray Radiography/APS 2019-1/' # Imaging setup # See 'Pixel Size' in Excel workbook cm_px = np.loadtxt('{}/cm_px.txt'.format(prj_fld)) dark_path = prj_fld + '/Images/Flat/AVG_dark_current.tif' dark = np.array(Image.open(dark_path)) flat_path = prj_fld + '/Images/Flat/Mean/AVG_Background_NewYAG.tif' flatfield = np.array(Image.open(flat_path)) matrix_path = prj_fld + '/test_matrix.txt' test_matrix = pd.read_csv(matrix_path, sep='\t+', engine='python') # Create folder for the Normalized sets norm_fld = create_folder('{0}/Processed/Normalized/'.format(prj_fld)) # Normalize the all of the images and save them norm_jets(prj_fld, dark, flatfield, test_matrix, norm_fld) # Scintillator used scint = 'YAG' # Load models from the whitebeam_2019 script f = open(prj_fld + '/Model/water_model_' + scint + '.pckl', 'rb') water_mdl = pickle.load(f) f.close() f = open(prj_fld + '/Model/KI4p8_model_' + scint + '.pckl', 'rb') KI4p8_mdl = pickle.load(f) f.close() # Top-level save folder save_fld = '{0}/Processed/{1}/'.format(prj_fld, scint) KI_conc = [0, 4.8] models = [water_mdl, KI4p8_mdl] # Look at only the Calibration2 files (NewYAG) calib2_files = glob.glob('{0}/Images/Calibration/Mean/' '*Calibration2*'.format(prj_fld)) # Add KI to the glob ki_files = glob.glob('{0}/Images/Calibration/Mean/*KI*'.format(prj_fld)) calib2_files.append(ki_files[0]) # Get Calibration2 file names to look up in matrix table calib2_names = [ split(x)[1].rsplit('.')[0].rsplit('AVG_')[1] for x in calib2_files ] for index, test_name in enumerate(test_matrix['Test']): if test_name in calib2_names: test_path = norm_fld + '/Norm_' + test_name + '.tif' # Load relevant model if 'KI' in test_name: model = models[1] else: model = models[0] TtoEPL = model[0] EPLtoT = model[1] # Cropping window crop_start = test_matrix['Cropping Start'][index] crop_stop = 480 cropped_view = np.linspace(start=crop_start, stop=crop_stop, num=crop_stop - crop_start + 1, dtype=int) # ROI for offset calculations roi = test_matrix['ROI'][index] sl_x_start = int(roi.rsplit(',')[0].rsplit(':')[0][1:]) sl_x_end = int(roi.rsplit(',')[0].rsplit(':')[1]) offset_sl_x = slice(sl_x_start, sl_x_end) sl_y_start = int(roi.rsplit(",")[1].rsplit(":")[0]) sl_y_end = int(roi.rsplit(",")[1].rsplit(":")[1][:-1]) offset_sl_y = slice(sl_y_start, sl_y_end) # Injector face iface = test_matrix['Injector Face'][index] # Load in normalized images data_norm = np.array(Image.open(test_path)) # Process the jet file proc_jet(cropped_view, cm_px, save_fld, scint, index, test_name, test_path, TtoEPL, EPLtoT, offset_sl_x, offset_sl_y, data_norm, iface)
""" import glob import h5py import numpy as np import matplotlib.pyplot as plt from PIL import Image from scipy.interpolate import interp1d from general.calc_statistics import rmse from general.misc import create_folder prj_fld = '/mnt/r/X-ray Radiography/APS 2018-1/' hdf5_fld = '{0}/HDF5'.format(prj_fld) mb_fld = create_folder('{0}/Monobeam/SC'.format(prj_fld)) def horiz_scan(xx, image_h_x, yy, image_h_y, img, EPL, x, y): # Set min/max X locations minX = -3.5 maxX = 3.5 # Get horizontal scan indices h_y = yy[image_h_y] h_x1 = xx[image_h_x[0]] h_x2 = xx[image_h_x[1]] h_xslice = list(range(np.argmin(abs(-5 - x)), np.argmin(abs(5 - x)))) # APS data aps_ind = slice(np.argmin(abs(x - minX)), np.argmin(abs(x - maxX)))
def main(): # Location of APS 2018-1 data prj_fld = '/mnt/r/X-ray Radiography/APS 2018-1/' # Imaging setup # See 'APS White Beam.xlsx -> Pixel Size' cm_px = np.loadtxt('{0}/cm_px.txt'.format(prj_fld)) dark_path = prj_fld + '/Images/Uniform_Jets/Mean/AVG_Jet_dark2.tif' dark = np.array(Image.open(dark_path)) flat_path = prj_fld + '/Images/Uniform_Jets/Mean/AVG_Jet_flat2.tif' flatfield = np.array(Image.open(flat_path)) matrix_path = prj_fld + '/APS White Beam.txt' test_matrix = pd.read_csv(matrix_path, sep='\t+', engine='python') norm_fld = create_folder('{0}/Processed/Normalized/'.format(prj_fld)) # Normalize the images and save them norm_jets(prj_fld, dark, flatfield, test_matrix, norm_fld) # Scintillator scintillators = ['LuAG', 'YAG'] for scint in scintillators: # Load models from the whitebeam_2018-1 script f = open(prj_fld + '/Model/water_model_' + scint + '.pckl', 'rb') water_mdl = pickle.load(f) f.close() f = open(prj_fld + '/Model/KI1p6_model_' + scint + '.pckl', 'rb') KI1p6_mdl = pickle.load(f) f.close() f = open(prj_fld + '/Model/KI3p4_model_' + scint + '.pckl', 'rb') KI3p4_mdl = pickle.load(f) f.close() f = open(prj_fld + '/Model/KI5p3_model_' + scint + '.pckl', 'rb') KI5p3_mdl = pickle.load(f) f.close() f = open(prj_fld + '/Model/KI8p1_model_' + scint + '.pckl', 'rb') KI8p1_mdl = pickle.load(f) f.close() f = open(prj_fld + '/Model/KI10p0_model_' + scint + '.pckl', 'rb') KI10p0_mdl = pickle.load(f) f.close() f = open(prj_fld + '/Model/KI11p1_model_' + scint + '.pckl', 'rb') KI11p1_mdl = pickle.load(f) f.close() # Top-level save folder save_fld = '{0}/Processed/{1}/'.format(prj_fld, scint) KI_conc = [0, 1.6, 3.4, 5.3, 8.1, 10, 11.1] models = [ water_mdl, KI1p6_mdl, KI3p4_mdl, KI5p3_mdl, KI8p1_mdl, KI10p0_mdl, KI11p1_mdl ] for index, test_name in enumerate(test_matrix['Test']): test_path = norm_fld + '/Norm_' + test_name + '.tif' model = models[KI_conc.index(test_matrix['KI %'][index])] TtoEPL = model[0] EPLtoT = model[1] # Offset bounds found in ImageJ, X and Y are flipped! sl_x_start = test_matrix['BY'][index] sl_x_end = sl_x_start + test_matrix['Height'][index] offset_sl_x = slice(sl_x_start, sl_x_end) sl_y_start = test_matrix['BX'][index] sl_y_end = sl_y_start + test_matrix['Width'][index] offset_sl_y = slice(sl_y_start, sl_y_end) # Load in normalized images data_norm = np.array(Image.open(test_path)) # Process the jet file proc_jet(cm_px, save_fld, scint, index, test_name, test_path, TtoEPL, EPLtoT, offset_sl_x, offset_sl_y, data_norm)
def main(): prj_fld = '/mnt/r/X-ray Radiography/APS 2019-1/' test_conditions = pd.read_csv('{0}/test_conditions.txt'.format(prj_fld), sep='\t+', engine='python') grouped = test_conditions.groupby(by=['Imaging']) tests_keys = list(grouped.groups.keys())[3:] hdf5_fld = '{0}/HDF5'.format(prj_fld) # Imaging setup # See 'Pixel Size' in Excel workbook cm_px = np.loadtxt('{}/cm_px.txt'.format(prj_fld)) # Create offsets file open(prj_fld + '/offsets.txt', 'w').close() for z in tests_keys: indices = [ i for i, s in enumerate( list(grouped.get_group(z)['Y Positions (mm)'])) if 'to' not in s ] temp_list = list(grouped.get_group(z)['Scan']) EPL = len(indices) * [None] wbp = len(indices) * [None] yp = len(indices) * [None] scan = len(indices) * [None] x = len(indices) * [None] test = z.rsplit('_')[0] # Load in the relevant HDF5 scans for n, y in enumerate(indices): scan[n] = temp_list[y] f = h5py.File('{0}/Scan_{1}.hdf5'.format(hdf5_fld, scan[n]), 'r') x[n] = np.array(f['X']) BIM = np.array(f['BIM']) PIN = np.array(f['PINDiode']) extinction_length = np.log(BIM / PIN) offset = np.median(extinction_length[0:10]) extinction_length -= offset # Location of injector face in px inj_faceY = 19 wbp[n] = inj_faceY + round( float(list(grouped.get_group(z)['Y Positions (mm)'])[y]) / (cm_px * 10)) yp[n] = float(list(grouped.get_group(z)['Y Positions (mm)'])[y]) # Attenuation coefficient (total w/o coh. scattering - cm^2/g) # Convert to mm^2/g for mm, multiply by density in g/mm^3 if 'KI' not in z: # Pure water @ 8 keV # <https://physics.nist.gov/PhysRefData/Xcom/html/xcom1.html> atten_coeff = (1.006 * 10 * (10 * 10)) * (0.001) elif 'KI' in z: # 4.8% KI in water @ 8 keV # <https://physics.nist.gov/PhysRefData/Xcom/html/xcom1.html> atten_coeff = (2.182 * 10 * (10 * 10)) * (density_KIinH2O(4.8) / 1000) # Add in air attenuation coefficient #atten_coeff *= (9.227*(10*10))*(0.0012929/1000) # Calculate EPL and convert to um from mm EPL[n] = (extinction_length / atten_coeff) * 1000 # Append offset value to file with open(prj_fld + '/offsets.txt', 'a') as f: f.write('{0}\n'.format(offset)) # Load in corresponding EPL image and convert to um from cm img_path = '{0}/Images/Spray/EPL/TimeAvg/AVG_{1}_S001.tif'\ .format(prj_fld, z) img = np.array(Image.open(img_path)) img *= 10000 # Flip image to match MB scan img = np.fliplr(img) xx = np.linspace(1, 768, 768) xx = xx * cm_px * 10 # in mm xx = xx - np.mean(xx) mb_fld = create_folder('{0}/Monobeam/{1}'.format(prj_fld, z)) for n, _ in enumerate(indices): plt.figure() plt.plot(xx[0::5], img[wbp[n], :][0::5], color='b', marker='o', fillstyle='none', label='WB {0}'.format(test)) plt.plot(x[n], np.mean(EPL[n], axis=1), color='r', marker='s', fillstyle='none', label='MB {0}'.format(scan[n])) plt.xlim([-3, 3]) plt.ylim([-200, 3500]) plt.xlabel('Horizontal Location (mm)') plt.ylabel('EPL ($\mu$m)') plt.title('{0} mm Downstream - {1} & {2}'.format( yp[n], test, scan[n])) plt.legend() plt.savefig('{0}/comparison_{1}mm.png'.format(mb_fld, yp[n])) plt.close() plt.figure() plt.imshow(img, vmin=-200, vmax=3500) plt.colorbar() plt.title('EPL ($\mu$m) Mapping of Spray - {0}'.format(test)) for n, _ in enumerate(indices): plt.plot(np.linspace(1, 768, 768), np.linspace(wbp[n], wbp[n], 768), label='{0}'.format(scan[n])) plt.legend() plt.savefig('{0}/Spray Image.png'.format(mb_fld)) plt.close() with open('{0}/monobeam_data.pckl'.format(mb_fld), 'wb') as f: pickle.dump([EPL, x, scan, wbp, yp], f)
def main(): # Location of APS 2018-1 data prj_fld = '/mnt/r/X-ray Radiography/APS 2018-1/' # Load XOP spectra input_folder = prj_fld + '/Spectra_Inputs' input_spectra = xop(input_folder + '/xsurface1.dat') # Get energy values energy = input_spectra['Energy'] # Find the angles corresponding to the 2018-1 image vertical pixels angles_mrad, flatfield_avg = spectra_angles( '{0}/Images/Uniform_Jets/Mean/AVG_' 'Jet_flat2.tif'.format(prj_fld)) # Find the index that best approximates middle (angle = 0) middle_index = np.argmin(abs(angles_mrad)) # Create an interpolation object based on angle # Passing in an angle in mrad will output an interpolated spectra (w/ XOP as reference) spectra_linfit = interp1d(input_spectra['Angle'], input_spectra['Intensity'], axis=0) # Create an array containing spectra corresponding to each row of the 2018-1 images spectra2D = spectra_linfit(angles_mrad) # Middle spectra spectra_middle = spectra2D[middle_index, :] # Load NIST XCOM attenuation curves YAG_atten = mass_atten(['YAG'], xcom=1, col=3, keV=200) LuAG_atten = mass_atten(['LuAG'], xcom=1, col=3, keV=200) # Reshape XCOM x-axis to match XOP YAG_atten = xcom_reshape(YAG_atten, energy) LuAG_atten = xcom_reshape(LuAG_atten, energy) # Scintillator EPL YAG_epl = 0.05 # 500 um LuAG_epl = 0.01 # 100 um ## Density in g/cm^3 # Scintillator densities from Crytur <https://www.crytur.cz/materials/yagce/> YAG_den = 4.57 LuAG_den = 6.73 ## Apply Beer-Lambert Law # Find detected scintillator spectrum (along middle) and response curves (no filters) LuAG_resp = scint_respfn(spectra_linfit, LuAG_atten, LuAG_den, LuAG_epl) YAG_resp = scint_respfn(spectra_linfit, YAG_atten, YAG_den, YAG_epl) # Find detected spectra (no filters) LuAG_detected_nofilters = np.array([x * LuAG_resp for x in spectra2D]) YAG_detected_nofilters = np.array([x * YAG_resp for x in spectra2D]) # Use filters LuAG = map(lambda x: filtered_spectra(energy, x, LuAG_resp), spectra2D) LuAG = list(LuAG) spectra_filtered = np.swapaxes(LuAG, 0, 1)[0] LuAG_detected = np.swapaxes(LuAG, 0, 1)[1] YAG = map(lambda x: filtered_spectra(energy, x, YAG_resp), spectra2D) YAG = list(YAG) YAG_detected = np.swapaxes(YAG, 0, 1)[1] ## Plot figures plot_folder = create_folder(prj_fld + '/Figures/Energy_Spectra') # Create vertical integrated power curves integrated_xray = np.trapz(spectra2D, energy, axis=1) integrated_xray_filtered = np.trapz(spectra_filtered, energy, axis=1) integrated_LuAG = np.trapz(LuAG_detected_nofilters, energy, axis=1) integrated_YAG = np.trapz(YAG_detected_nofilters, energy, axis=1) integrated_LuAG_filtered = np.trapz(LuAG_detected, energy) integrated_YAG_filtered = np.trapz(YAG_detected, energy) # Integrated plots plt.figure() plt.plot(integrated_xray, color='black', linewidth=1.5, label='X-ray Beam') plt.plot(integrated_xray_filtered, color='black', linestyle='--', linewidth=1.5, label='X-ray Beam (filtered)') plt.plot(integrated_LuAG, color='cornflowerblue', linewidth=1.5, label='LuAG') plt.plot(integrated_LuAG_filtered, color='cornflowerblue', linestyle='--', linewidth=1.5, label='LuAG (filtered)') plt.plot(integrated_YAG, color='seagreen', linewidth=1.5, label='YAG') plt.plot(integrated_YAG_filtered, color='seagreen', linestyle='--', linewidth=1.5, label='YAG (filtered)') plt.legend() plt.savefig(plot_folder + '/integrated_intensity.png') plt.close() # Integrated and normalized (filtered) plots plt.figure() plt.plot(integrated_xray_filtered / max(integrated_xray_filtered), zorder=1, color='black', linewidth=1.5, label='X-ray Beam (filtered)') plt.plot(integrated_LuAG_filtered / max(integrated_LuAG_filtered), zorder=2, color='cornflowerblue', linewidth=1.5, label='LuAG (filtered)') plt.plot(integrated_YAG_filtered / max(integrated_YAG_filtered), zorder=3, color='seagreen', linewidth=1.5, label='YAG (filtered)') plt.plot(flatfield_avg / max(flatfield_avg), zorder=4, color='red', linewidth=1.5, label='Flat Field') plt.legend() plt.savefig(plot_folder + '/integrated_norm_intensity.png') plt.close() # Scintillator response plt.figure() plt.plot(energy / 1000, LuAG_resp, linewidth=1.5, color='cornflowerblue', label='LuAG') plt.plot(energy / 1000, YAG_resp, linewidth=1.5, color='seagreen', label='YAG') plt.legend() plt.xlabel('Energy (keV)') plt.ylabel('Scintillator Response') plt.savefig(plot_folder + '/scintillator_response.png') plt.close() # Spectra along middle plt.figure() plt.plot(energy / 1000, spectra_middle, linewidth=1.5, color='black', label='Incident') plt.plot(energy / 1000, spectra_filtered[middle_index, :], linewidth=1.5, color='black', linestyle='--', label='Incident (filtered)') plt.plot(energy / 1000, LuAG_detected_nofilters[middle_index, :], linewidth=1.5, color='cornflowerblue', label='LuAG') plt.plot(energy / 1000, LuAG_detected[middle_index, :], linewidth=1.5, color='cornflowerblue', linestyle='--', label='LuAG (filtered)') plt.plot(energy / 1000, YAG_detected_nofilters[middle_index, :], linewidth=1.5, color='seagreen', label='YAG') plt.plot(energy / 1000, YAG_detected[middle_index, :], linewidth=1.5, color='seagreen', linestyle='--', label='YAG (filtered)') plt.legend() plt.xlabel('Energy (keV)') plt.ylabel('Intensity') plt.savefig(plot_folder + '/middle_spectra.png') plt.close() # LuAG filtered spectra at various locations plt.figure() plt.plot(energy / 1000, LuAG_detected[middle_index, :], linewidth=1.5, color='black', label='{0}'.format(middle_index)) plt.plot(energy / 1000, LuAG_detected[middle_index + 50, :], linewidth=1.5, color='blue', label='{0}'.format(middle_index + 50)) plt.plot(energy / 1000, LuAG_detected[middle_index - 50, :], linewidth=1.5, color='blue', linestyle='--', label='{0}'.format(middle_index - 50)) plt.plot(energy / 1000, LuAG_detected[middle_index + 100, :], linewidth=1.5, color='red', label='{0}'.format(middle_index + 100)) plt.plot(energy / 1000, LuAG_detected[middle_index - 100, :], linewidth=1.5, color='red', linestyle='--', label='{0}'.format(middle_index - 100)) plt.legend() plt.title('Filtered') plt.xlabel('Energy (keV)') plt.ylabel('Intensity') plt.savefig(plot_folder + '/LuAG_filtered_spectra.png') plt.close() # YAG filtered spectra at various locations plt.figure() plt.plot(energy / 1000, YAG_detected[middle_index, :], linewidth=1.5, color='black', label='{0}'.format(middle_index)) plt.plot(energy / 1000, YAG_detected[middle_index + 50, :], linewidth=1.5, color='blue', label='{0}'.format(middle_index + 50)) plt.plot(energy / 1000, YAG_detected[middle_index - 50, :], linewidth=1.5, color='blue', linestyle='--', label='{0}'.format(middle_index - 50)) plt.plot(energy / 1000, YAG_detected[middle_index + 100, :], linewidth=1.5, color='red', label='{0}'.format(middle_index + 100)) plt.plot(energy / 1000, YAG_detected[middle_index - 100, :], linewidth=1.5, color='red', linestyle='--', label='{0}'.format(middle_index - 100)) plt.legend() plt.title('Filtered') plt.xlabel('Energy (keV)') plt.ylabel('Intensity') plt.savefig(plot_folder + '/YAG_filtered_spectra.png') plt.close() # X-ray spectra at various locations plt.figure() plt.plot(energy / 1000, spectra2D[middle_index, :], linewidth=1.5, color='black', label='{0}'.format(middle_index)) plt.plot(energy / 1000, spectra2D[middle_index + 50, :], linewidth=1.5, color='blue', label='{0}'.format(middle_index + 50)) plt.plot(energy / 1000, spectra2D[middle_index - 50, :], linewidth=1.5, color='blue', linestyle='--', label='{0}'.format(middle_index - 50)) plt.plot(energy / 1000, spectra2D[middle_index + 100, :], linewidth=1.5, color='red', label='{0}'.format(middle_index + 100)) plt.plot(energy / 1000, spectra2D[middle_index - 100, :], linewidth=1.5, color='red', linestyle='--', label='{0}'.format(middle_index - 100)) plt.legend() plt.title('Unfiltered') plt.xlabel('Energy (keV)') plt.ylabel('Intensity') plt.savefig(plot_folder + '/xray_spectra.png') plt.close()
def main(): # Coding logic: # X Read in all file names # O Read in KI parameters: # O Read ratio_peakT # O Read ratio_ellipseT # Location of APS 2019-1 data prj_fld = '/mnt/r/X-ray Radiography/APS 2019-1/' # Save location for the plots plt_fld = create_folder('{0}/Figures/Cal_Summary/'.format(prj_fld)) # Test matrix test_matrix = pd.read_csv('{0}/test_matrix.txt'.format(prj_fld), sep='\t+', engine='python') # Processed data sets location proc_fld = '{0}/Processed/YAG/Summary/'.format(prj_fld) # Read in all file names water_tests = glob.glob(proc_fld + '/*Calibration2*') ki_tests = glob.glob(proc_fld + '/*KI*') # Read in axial positions water_apos = [get_ypos(x) for x in water_tests] ki_apos = get_ypos(ki_tests[0]) # Read in water lateral positions posn = np.array([get_xpos(x) for x in water_tests]) posn[np.abs(250 - posn) <= 11] = int(0) posn[np.abs(390 - posn) <= 11] = int(1) posn[np.abs(510 - posn) <= 11] = int(2) posn = posn.astype(int) # Indices corresponding to each of the positions ind_left = np.where(posn == 0)[0] ind_midl = np.where(posn == 1)[0] ind_rght = np.where(posn == 2)[0] # Indices of only the top injector face (iface = 16) top_ind = np.concatenate((ind_left[-2:], ind_midl[-2:], ind_rght[-2:])) # Setup water tags for plots lbls = ['Left', 'Middle', 'Right'] colr = ['lightcoral', 'forestgreen', 'cornflowerblue'] mrkr = ['s', 'o', '^'] # Read in transmission ratios water_elpsT = np.array([get_ellipseT(x) for x in water_tests]) ki_elpsT = np.array(get_ellipseT(ki_tests[0])) water_peakT = np.array([get_peakT(x) for x in water_tests]) ki_peakT = np.array(get_peakT(ki_tests[0])) # Summarize the CF water_elpsCF = np.array([np.nanmedian(x) for x in water_elpsT]) water_peakCF = np.array([np.nanmedian(x) for x in water_peakT]) ki_elpsCF = np.nanmedian(ki_elpsT) ki_peakCF = np.nanmedian(ki_peakT) # Consolidate water CF into only the top injector face (iface = 16) water_elpsCF_top = np.median(water_elpsCF[top_ind]) water_peakCF_top = np.median(water_peakCF[top_ind]) # Read in Injector Face locations iface = np.array([get_iface(x) for x in water_tests]) # Save the CF np.savetxt('{0}/cf_water.txt'.format(proc_fld), np.c_[iface, water_elpsCF, water_peakCF], delimiter='\t', header='IFace\telpsCF\tpeakCF') np.savetxt('{0}/cf_summary.txt'.format(proc_fld), (water_elpsCF_top, water_peakCF_top, ki_elpsCF, ki_peakCF), delimiter='\t', header='Water elpsCF\tWater peakCF\tKI elpsCF\tKI peakCF') ########################################################################## ## PLOTS (O - Planned, X - Completed) ## X--> Vertical EllipseT (combined) ## X--> FIG1: Water ## X--> FIG2: KI ## X--> Vertical EllipseT (left/middle/right subplots) ## X--> FIG3: Water ## X--> Vertical PeakT (combined) ## X--> FIG4: Water ## X--> FIG5: KI ## X--> Vertical PeakT (left/middle/right subplots) ## X--> FIG6: Water ########################################################################## # FIG1: Water vertical EllipseT plt.figure() [ plt.plot( water_apos[i], water_elpsT[i], marker=mrkr[posn[i]], markerfacecolor=colr[posn[i]], markeredgecolor=colr[posn[i]], linestyle='', ) for i, _ in enumerate(water_tests) ] leg_el = [ Line2D([0], [0], color=colr[0], marker=mrkr[0], linestyle='', markeredgecolor=colr[0], label=lbls[0]), Line2D([0], [0], color=colr[1], marker=mrkr[1], linestyle='', markeredgecolor=colr[1], label=lbls[1]), Line2D([0], [0], color=colr[2], marker=mrkr[2], linestyle='', markeredgecolor=colr[2], label=lbls[2]) ] plt.legend(handles=leg_el) plt.xlabel('Axial Position (px)') plt.ylabel('Correction Factor (-)') plt.title('Water EllipseT') plt.savefig('{0}/water_vert_elpsT.png'.format(plt_fld)) # FIG2: KI vertical EllipseT plt.figure() plt.plot(ki_apos, ki_elpsT, marker='o', linestyle='') plt.xlabel('Axial Position (px)') plt.ylabel('Correction Factor (-)') plt.title('KI EllipseT') plt.savefig('{0}/ki_vert_elpsT.png'.format(plt_fld)) plt.close() # FIG3: Vertical EllipseT (left/middle/right) plt.subplots(3, 1, sharex=True, figsize=(15, 15)) # Water vertical EllipseT (left) plt.subplot(311) [ plt.plot(water_apos[i], water_elpsT[i], marker=mrkr[posn[i]], linestyle='', label='{0}'.format(iface[i])) for i in ind_left ] plt.legend() plt.ylabel('Correction Factor (-)') plt.title('Water EllipseT Left') # Water vertical EllipseT (middle) plt.subplot(312) [ plt.plot(water_apos[i], water_elpsT[i], marker=mrkr[posn[i]], linestyle='', label='{0}'.format(iface[i])) for i in ind_midl ] plt.legend() plt.ylabel('Correction Factor (-)') plt.title('Water EllipseT Middle') # Water vertical EllipseT (right) plt.subplot(313) [ plt.plot(water_apos[i], water_elpsT[i], marker=mrkr[posn[i]], linestyle='', label='{0}'.format(iface[i])) for i in ind_rght ] plt.legend() plt.xlabel('Axial Position (px)') plt.ylabel('Correction Factor (-)') plt.title('Water EllipseT Right') plt.savefig('{0}/water_vert_separate_elpsT.png'.format(plt_fld)) # FIG4: Water vertical PeakT plt.figure() [ plt.plot( water_apos[i], water_peakT[i], marker=mrkr[posn[i]], markerfacecolor=colr[posn[i]], markeredgecolor=colr[posn[i]], linestyle='', ) for i, _ in enumerate(water_tests) ] leg_el = [ Line2D([0], [0], color=colr[0], marker=mrkr[0], linestyle='', markeredgecolor=colr[0], label=lbls[0]), Line2D([0], [0], color=colr[1], marker=mrkr[1], linestyle='', markeredgecolor=colr[1], label=lbls[1]), Line2D([0], [0], color=colr[2], marker=mrkr[2], linestyle='', markeredgecolor=colr[2], label=lbls[2]) ] plt.legend(handles=leg_el) plt.xlabel('Axial Position (px)') plt.ylabel('Correction Factor (-)') plt.title('Water PeakT') plt.savefig('{0}/water_vert_peakT.png'.format(plt_fld)) # FIG5: KI vertical EllipseT plt.figure() plt.plot(ki_apos, ki_peakT, marker='o', linestyle='') plt.xlabel('Axial Position (px)') plt.ylabel('Correction Factor (-)') plt.title('KI PeakT') plt.savefig('{0}/ki_vert_peakT.png'.format(plt_fld)) plt.close() # FIG6: Vertical PeakT (left/middle/right) plt.subplots(3, 1, sharex=True, figsize=(15, 15)) # Water vertical PeakT (left) plt.subplot(311) [ plt.plot(water_apos[i], water_peakT[i], marker=mrkr[posn[i]], linestyle='', label='{0}'.format(iface[i])) for i in ind_left ] plt.legend() plt.ylabel('Correction Factor (-)') plt.title('Water PeakT Left') # Water vertical PeakT (middle) plt.subplot(312) [ plt.plot(water_apos[i], water_peakT[i], marker=mrkr[posn[i]], linestyle='', label='{0}'.format(iface[i])) for i in ind_midl ] plt.legend() plt.ylabel('Correction Factor (-)') plt.title('Water PeakT Middle') # Water vertical PeakT (right) plt.subplot(313) [ plt.plot(water_apos[i], water_peakT[i], marker=mrkr[posn[i]], linestyle='', label='{0}'.format(iface[i])) for i in ind_rght ] plt.legend() plt.xlabel('Axial Position (px)') plt.ylabel('Correction Factor (-)') plt.title('Water PeakT Right') plt.savefig('{0}/water_vert_separate_peakT.png'.format(plt_fld))
ij30video_fld = '{}/0p30gpm_Video/VTK'.format(prj_fld) ij45_fld = '{}/0p45gpm/VTK'.format(prj_fld) ij45avg_fld = '{}/0p45gpm_AVG/VTK'.format(prj_fld) ij45video_fld = '{}/0p45gpm_Video/VTK'.format(prj_fld) # VTK files ij30 = glob.glob('{}/*.vti'.format(ij30_fld)) ij30avg = glob.glob('{}/*.vti'.format(ij30avg_fld)) ij30video = glob.glob('{}/*.vti'.format(ij30video_fld)) ij45 = glob.glob('{}/*.vti'.format(ij45_fld)) ij45avg = glob.glob('{}/*.vti'.format(ij45avg_fld)) ij45video = glob.glob('{}/*.vti'.format(ij45video_fld)) # Output slice folders slice30_fld = create_folder('{}/0p30gpm/Slice/'.format(prj_fld)) slice30avg_fld = create_folder('{}/0p30gpm_AVG/Slice/'.format(prj_fld)) slice30vid_fld = create_folder('{}/0p30gpm_Video/Slice/'.format(prj_fld)) slice45_fld = create_folder('{}/0p45gpm/Slice/'.format(prj_fld)) slice45avg_fld = create_folder('{}/0p45gpm_AVG/Slice/'.format(prj_fld)) slice45vid_fld = create_folder('{}/0p45gpm_Video/Slice/'.format(prj_fld)) # Output surface folders surf30_fld = create_folder('{}/0p30gpm/Surface/'.format(prj_fld)) surf30avg_fld = create_folder('{}/0p30gpm_AVG/Surface/'.format(prj_fld)) surf30vid_fld = create_folder('{}/0p30gpm_Video/Surface/'.format(prj_fld)) surf45_fld = create_folder('{}/0p45gpm/Surface/'.format(prj_fld)) surf45avg_fld = create_folder('{}/0p45gpm_AVG/Surface/'.format(prj_fld)) surf45vid_fld = create_folder('{}/0p45gpm_Video/Surface/'.format(prj_fld))
def main(): # Location of APS 2018-1 data prj_fld = '/mnt/r/X-ray Radiography/APS 2018-1/' # Save location for the plots plots_folder = create_folder('{0}/Figures/Jet_HorizSumm/'.format(prj_fld)) # Scintillator scintillators = ['LuAG', 'YAG'] # KI % KI_conc = [0, 1.6, 3.4, 5.3, 8, 10, 11.1] # Test matrix test_matrix = pd.read_csv('{0}/APS White Beam.txt'.format(prj_fld), sep='\t+', engine='python') # Crop down the test matrix test_matrix = test_matrix[['Test', 'Nozzle Diameter (um)', 'KI %']].copy() for scint in scintillators: # Processed data sets location prc_fld = '{0}/Processed/{1}/Summary/'.format(prj_fld, scint) # Groups rpkT = 'Ratio Peak T' relT = 'Ratio Ellipse T' # Horizontal variation horiz_matrix = test_matrix[test_matrix['Test'].str.contains( 'mm')].copy() horiz_matrix['X Position'] = [ get_xpos('{0}/{1}_{2}.pckl'.format(prc_fld, scint, x)) for x in horiz_matrix['Test'] ] # Sort horiz_matrix by X position, re-index, and drop the outliers horiz_matrix.sort_values(by=['X Position'], inplace=True) horiz_matrix.reset_index(inplace=True) horiz_matrix.drop([0, len(horiz_matrix) - 1], inplace=True) # Get horizontal values horiz_matrix[relT] = [ get_mean_elpsT('{0}/{1}_{2}.pckl'.format(prc_fld, scint, x)) for x in horiz_matrix['Test'] ] horiz_matrix[rpkT] = [ get_mean_peakT('{0}/{1}_{2}.pckl'.format(prc_fld, scint, x)) for x in horiz_matrix['Test'] ] breakpoint() # Create a fit to the horizontal variation xData = horiz_matrix['X Position'] yData = horiz_matrix[relT] yData = savgol_filter(yData, 55, 3) XtoCF = CubicSpline(xData, yData) # Horizontal plot plt.figure() plt.plot(horiz_matrix['X Position'], horiz_matrix[rpkT], color='olivedrab', marker='s', label=rpkT) plt.plot(xData, XtoCF(xData), color='cornflowerblue', label='Fit') plt.plot(horiz_matrix['X Position'], horiz_matrix[relT], fillstyle='none', color='olivedrab', marker='s', label=relT) plt.legend() plt.title('{0} - Horizontal Variation - 700 um, 10% KI'.format(scint)) plt.savefig('{0}/{1}_horiz.png'.format(plots_folder, scint)) plt.close() # Save the linear fitted correction factors with open('{0}/Processed/{1}/{1}_peakT_cf.txt'.format(prj_fld, scint), 'wb') as f: np.savetxt(f, peakT_combi_fit['function'](KI_conc)) with open('{0}/Processed/{1}/{1}_elpsT_cf.txt'.format(prj_fld, scint), 'wb') as f: np.savetxt(f, elpsT_combi_fit['function'](KI_conc))
@author: rahmann """ import glob import h5py import pickle import numpy as np from PIL import Image from monobeam_aecn import horiz_scan from general.misc import create_folder prj_fld = '/mnt/r/X-ray Radiography/APS 2018-1/' hdf5_fld = '{0}/HDF5'.format(prj_fld) mb_fld = create_folder('{0}/Monobeam/AeroECN'.format(prj_fld)) def main(): # See 'Spray Imaging' in Excel workbook cm_px = np.loadtxt('{0}/cm_px.txt'.format(prj_fld)) fly_scan = 'Fly_Scans_208_340' # Injector center position on image (in pixels) image_inj_x = 390 image_inj_y = 18 # Load in fly scan data f = h5py.File('{0}/{1}.hdf5'.format(hdf5_fld, fly_scan), 'r') x = np.array(f['X'])
def saveConvergence(data, name, folder): folder = create_folder(folder) np.save('{0}/{1}.npy'.format(folder, name), data) return
""" import cv2 import glob import h5py import numpy as np import matplotlib.pyplot as plt from PIL import Image from skimage.filters import (threshold_otsu, threshold_local) from general.misc import create_folder inp_fld = '/mnt/f/X-ray Tomography/3DXray-Tomo/Processed/IJ/' out_fld = create_folder('/mnt/r/X-ray Tomography/2018_DataSets/' 'ImageCalibration/OpenCV/') def resizeData(path): data = np.array(Image.open(path)) input_size = data.shape[0] bin_size = 2 output_size = input_size // bin_size data_reshaped = data.reshape( (1, output_size, bin_size, output_size, bin_size)).max(4).max(2) return data_reshaped[0] def makeBlob(): # Setup SimpleBlobDetector parameters
def main(): # Location of APS 2018-1 data prj_fld = '/mnt/r/X-ray Radiography/APS 2018-1/' # Save location for the plots plots_folder = create_folder( '{0}/Figures/Jet_EPL_Summary/'.format(prj_fld)) # Scintillator scintillators = ['LuAG', 'YAG'] # KI % KI_conc = [0, 1.6, 3.4, 5.3, 8.1, 10, 11.1] # Test matrix test_matrix = pd.read_csv('{0}/APS White Beam.txt'.format(prj_fld), sep='\t+', engine='python') # Crop down the test matrix test_matrix = test_matrix[['Test', 'Nozzle Diameter (um)', 'KI %']].copy() for scint in scintillators: # Processed data sets location prc_fld = '{0}/Processed/{1}/Summary/'.format(prj_fld, scint) # Vertical variation vert_mat = test_matrix[~test_matrix['Test'].str.contains('mm')].copy() # Groups grp1 = 'Nozzle Diameter (um)' grp2 = 'KI %' rpk = 'Ratio Peak' rel = 'Ratio Ellipse' # Get vertical values vert_mat[rel] = [ get_elps('{0}/{1}_{2}.pckl'\ .format(prc_fld, scint, x)) for x in vert_mat['Test'] ] vert_mat[rpk] = [ get_peak('{0}/{1}_{2}.pckl'\ .format(prc_fld, scint, x)) for x in vert_mat['Test'] ] vert_peak_grp = vert_mat.groupby([grp1, grp2])\ .apply(lambda x: np.mean(x[rpk], axis=0)) vert_elps_grp = vert_mat.groupby([grp1, grp2])\ .apply(lambda x: np.mean(x[rel], axis=0)) axial_loc = np.linspace(start=20, stop=325, num=325 - 20 + 1, dtype=int) linecolors = [ 'dimgray', 'firebrick', 'goldenrod', 'mediumseagreen', 'steelblue', 'mediumpurple', 'hotpink' ] linelabels = ['0%', '1.6%', '3.4%', '4.8%', '8%', '10%', '11.1%'] warnings.filterwarnings('ignore') # Vertical peak plot fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True) fig.set_size_inches(12, 6) for i, x in enumerate(linecolors): ax1.plot(axial_loc[2:-1], vert_peak_grp[700, KI_conc[i]][2:-1], color=x, linewidth=2.0) ax2.plot(axial_loc[2:-1], vert_peak_grp[2000, KI_conc[i]][2:-1], color=x, linewidth=2.0) ax1.title.set_text(r'700 $\mu$m') ax2.title.set_text(r'2000 $\mu$m') ax1.set_xlabel('Axial Position (px)') ax2.set_xlabel('Axial Position (px)') ax1.set_ylabel('Correction Factor (-)') fig.suptitle('Vertical Variation - Ratio Peak') fig.legend(ax1, labels=linelabels, loc='center right', borderaxespad=0.1, title=grp2) plt.subplots_adjust(wspace=0.05, top=0.90) plt.savefig('{0}/{1}_vert_peak.png'.format(plots_folder, scint)) plt.close() # Vertical elps plot fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True) fig.set_size_inches(12, 6) for i, x in enumerate(linecolors): ax1.plot(axial_loc[2:-1], vert_elps_grp[700, KI_conc[i]][2:-1], linewidth=2.0) ax2.plot(axial_loc[2:-1], vert_elps_grp[2000, KI_conc[i]][2:-1], linewidth=2.0) ax1.title.set_text(r'700 $\mu$m') ax2.title.set_text(r'2000 $\mu$m') ax1.set_xlabel('Axial Position (px)') ax2.set_xlabel('Axial Position (px)') ax1.set_ylabel('Correction Factor (-)') fig.suptitle('Vertical Variation - Ratio Ellipse') fig.legend(ax1, labels=linelabels, loc='center right', borderaxespad=0.1, title=grp2) plt.subplots_adjust(wspace=0.05, top=0.90) plt.savefig('{0}/{1}_vert_elps.png'.format(plots_folder, scint)) warnings.filterwarnings('default') ###################################################################### # Horizontal variation horiz_matrix = test_matrix[test_matrix['Test'].str\ .contains('mm')]\ .copy() horiz_matrix['X Position'] = [ get_xpos('{0}/{1}_{2}.pckl'\ .format(prc_fld, scint, x)) for x in horiz_matrix['Test'] ] # Sort horiz_matrix by X position, re-index, and drop the outliers horiz_matrix.sort_values(by=['X Position'], inplace=True) horiz_matrix.reset_index(inplace=True) horiz_matrix.drop([0, len(horiz_matrix) - 1], inplace=True) # Get horizontal values horiz_matrix[rel] = [ get_mean_elps('{0}/{1}_{2}.pckl'\ .format(prc_fld, scint, x)) for x in horiz_matrix['Test'] ] horiz_matrix[rpk] = [ get_mean_peak('{0}/{1}_{2}.pckl'\ .format(prc_fld, scint, x)) for x in horiz_matrix['Test'] ] # Normalize the horiz values to remove KI% dependency horiz_matrix[rel] /= max(horiz_matrix[rel]) horiz_matrix[rpk] /= max(horiz_matrix[rpk]) # Fit a quadratic to the horizontal values rel_quad = np.poly1d( np.polyfit(x=horiz_matrix['X Position'], y=horiz_matrix[rel], deg=2)) rpk_quad = np.poly1d( np.polyfit(x=horiz_matrix['X Position'], y=horiz_matrix[rpk], deg=2)) # Horizontal plot plt.figure() plt.plot(horiz_matrix['X Position'], horiz_matrix[rpk], color='olivedrab', marker='s', label=rpk) plt.plot(horiz_matrix['X Position'], rpk_quad(horiz_matrix['X Position']), color='black', marker='s', linestyle='dashed', alpha=0.5, label='Peak Fit') plt.legend() plt.title('{0} - Horizontal Variation - 700 um, 10% KI'.format(scint)) plt.savefig('{0}/{1}_horiz_peak.png'.format(plots_folder, scint)) plt.close() plt.figure() plt.plot(horiz_matrix['X Position'], horiz_matrix[rel], fillstyle='none', color='olivedrab', marker='s', label=rel) plt.plot(horiz_matrix['X Position'], rel_quad(horiz_matrix['X Position']), fillstyle='none', color='black', marker='s', linestyle='dashed', alpha=0.5, label='Ellipse Fit') plt.legend() plt.title('{0} - Horizontal Variation - 700 um, 10% KI'.format(scint)) plt.savefig('{0}/{1}_horiz_elps.png'.format(plots_folder, scint)) plt.close() ###################################################################### # Mean vertical variation mean_matrix = test_matrix[~test_matrix['Test'].str\ .contains('mm')]\ .copy() # Get mean vertical values mean_matrix[rel] = [ get_mean_elps('{0}/{1}_{2}.pckl'\ .format(prc_fld, scint, x)) for x in mean_matrix['Test'] ] mean_matrix[rpk] = [ get_mean_peak('{0}/{1}_{2}.pckl'\ .format(prc_fld, scint, x)) for x in mean_matrix['Test'] ] # Calculate the mean values as needed pivot_mean_peak = mean_matrix.pivot_table(values=rpk, index=[grp2], columns=[grp1], aggfunc=np.nanmean) pivot_mean_elps = mean_matrix.pivot_table(values=rel, index=[grp2], columns=[grp1], aggfunc=np.nanmean) # Create arrays from the pivot tables # Could plot directly from the pivot table but I didn't want to delve # too deep into that mean_peak_700 = pivot_mean_peak[700] peak_700_fit = polyfit(KI_conc, mean_peak_700, 1) peak_700_fit_r2 = peak_700_fit['determination'] peak_700_fit_lbl = 'y$_{700}$ = ' + '{0:0.3f}x + {1:0.3f};'\ 'R$^2$ {2:0.0f}%'\ .format( peak_700_fit['polynomial'][0], peak_700_fit['polynomial'][1], 100*peak_700_fit_r2 ) mean_peak_2000 = pivot_mean_peak[2000] peak_2000_fit = polyfit(KI_conc, mean_peak_2000, 1) peak_2000_fit_r2 = peak_2000_fit['determination'] peak_2000_fit_lbl = 'y$_{2000}$ = ' + '{0:0.3f}x + {1:0.3f};'\ 'R$^2$ {2:0.0f}%'\ .format( peak_2000_fit['polynomial'][0], peak_2000_fit['polynomial'][1], 100*peak_2000_fit_r2 ) mean_elps_700 = pivot_mean_elps[700] elps_700_fit = polyfit(KI_conc, mean_elps_700, 1) elps_700_fit_r2 = elps_700_fit['determination'] elps_700_fit_lbl = 'y$_{700}$ = ' + '{0:0.3f}x + {1:0.3f};'\ 'R$^2$ {2:0.0f}%'\ .format( elps_700_fit['polynomial'][0], elps_700_fit['polynomial'][1], 100*elps_700_fit_r2 ) mean_elps_2000 = pivot_mean_elps[2000] elps_2000_fit = polyfit(KI_conc, mean_elps_2000, 1) elps_2000_fit_r2 = elps_2000_fit['determination'] elps_2000_fit_lbl = 'y$_{2000}$ = ' + '{0:0.3f}x + {1:0.3f};'\ 'R$^2$ {2:0.0f}%'\ .format( elps_2000_fit['polynomial'][0], elps_2000_fit['polynomial'][1], 100*elps_2000_fit_r2 ) # Peak plot (markers filled) plt.figure() plt.plot(KI_conc, mean_peak_700, color='olivedrab', marker='s', label='700 um') plt.plot(KI_conc, peak_700_fit['function'](KI_conc), color='teal', label=peak_700_fit_lbl) plt.plot(KI_conc, mean_peak_2000, color='indianred', marker='^', label='2000 um') plt.plot(KI_conc, peak_2000_fit['function'](KI_conc), color='darkorange', label=peak_2000_fit_lbl) plt.legend() plt.title('{0} - Ratio Peak'.format(scint)) plt.xlabel('KI (%)') plt.ylabel('Correction Factor (-)') plt.savefig('{0}/{1}_mean_peak.png'.format(plots_folder, scint)) plt.close() # Ellipse plot (markers not filled) plt.figure() plt.plot(KI_conc, mean_elps_700, fillstyle='none', color='olivedrab', marker='s', label='700 um') plt.plot(KI_conc, elps_700_fit['function'](KI_conc), color='teal', label=elps_700_fit_lbl) plt.plot(KI_conc, mean_elps_2000, fillstyle='none', color='indianred', marker='^', label='2000 um') plt.plot(KI_conc, elps_2000_fit['function'](KI_conc), color='darkorange', label=elps_2000_fit_lbl) plt.legend() plt.title('{0} - Ratio Ellipse'.format(scint)) plt.xlabel('KI (%)') plt.ylabel('Correction Factor (-)') plt.savefig('{0}/{1}_mean_elps.png'.format(plots_folder, scint)) plt.close() ###################################################################### mean_peak_combi = np.mean([mean_peak_700, mean_peak_2000], axis=0) peak_combi_fit = polyfit(KI_conc, mean_peak_combi, 1) peak_combi_fit_r2 = peak_combi_fit['determination'] peak_combi_fit_lbl = 'y = {0:0.3f}x + {1:0.3f};'\ 'R$^2$ {2:0.0f}%'\ .format(peak_combi_fit['polynomial'][0], peak_combi_fit['polynomial'][1], 100*peak_combi_fit_r2 ) mean_elps_combi = np.mean([mean_elps_700, mean_elps_2000], axis=0) elps_combi_fit = polyfit(KI_conc, mean_elps_combi, 1) elps_combi_fit_r2 = elps_combi_fit['determination'] elps_combi_fit_lbl = 'y = {0:0.3f}x + {1:0.3f}; R$^2$ {2:0.0f}%'\ .format( elps_combi_fit['polynomial'][0], elps_combi_fit['polynomial'][1], 100*elps_combi_fit_r2 ) # Save the linear fitted correction factors with open('{0}/Processed/{1}/{1}_peak_cf.txt'\ .format(prj_fld, scint), 'wb') as f: np.savetxt(f, peak_combi_fit['function'](KI_conc)) with open('{0}/Processed/{1}/{1}_elps_cf.txt'\ .format(prj_fld, scint), 'wb') as f: np.savetxt(f, elps_combi_fit['function'](KI_conc)) # Map out the correction factor horizontally over an image array cf_fld = create_folder('{0}/Processed/{1}/CF_Map/'.format( prj_fld, scint)) image_x = np.linspace(0, 767, 768) for KI in KI_conc: KIstr = str(KI).replace('.', 'p') # Create CF based on elps elps_mat = np.ones((352, 768)) * elps_combi_fit['function'](KI) elps_mat *= rel_quad(image_x) elps_im = Image.fromarray(elps_mat) elps_im.save('{0}/elps_{1}.tif'.format(cf_fld, KIstr)) # Create CF based on peak peak_mat = np.ones((352, 768)) * peak_combi_fit['function'](KI) peak_mat *= rpk_quad(image_x) peak_im = Image.fromarray(peak_mat) peak_im.save('{0}/peak_{1}.tif'.format(cf_fld, KIstr)) plt.figure() plt.plot(KI_conc, mean_peak_combi, color='lightcoral', marker='s', linestyle='', label=rpk, zorder=2) plt.plot(KI_conc, peak_combi_fit['function'](KI_conc), linestyle='-', color='maroon', label=peak_combi_fit_lbl, zorder=1) plt.plot(KI_conc, mean_elps_combi, color='cornflowerblue', marker='^', linestyle='', label=rel, zorder=2) plt.plot(KI_conc, elps_combi_fit['function'](KI_conc), linestyle='-', color='mediumblue', label=elps_combi_fit_lbl, zorder=1) plt.title('{0} - Combined'.format(scint)) plt.legend() plt.xlabel('KI (%)') plt.ylabel('Correction Factor (-)') plt.savefig('{0}/{1}_combi.png'.format(plots_folder, scint)) plt.close()
#for spray, spray_fld in zip([ij30], [ij30_fld]): n += 1 for i in range(201): #for i in range(1): # Import surface #bpy.ops.import_mesh.ply(filepath=spray[i]) filepath = '{0}/Surface/vol{1:04d}.ply'.format(spray_fld, i) bpy.ops.import_mesh.ply(filepath=filepath) # Surface name surf_name = spray[i].split('\\')[-1].split('.')[0] # Translate and rotate spray D.objects[surf_name].rotation_euler = Euler(sprayRot, 'XYZ') D.objects[surf_name].location = sprayLoc[n] # Set material D.objects[surf_name].active_material = D.materials.get('water') # Output path outFld = create_folder('{}/ISO Blender/'.format(spray_fld)) outPath = '{0}/{1}.png'.format(outFld, surf_name) C.scene.render.filepath = outPath # Render and save bpy.ops.render.render(write_still=True, use_viewport=True) # Clear object obj_del = bpy.data.objects[surf_name] D.objects.remove(obj_del, do_unlink=True)
def spray_model(spray_epl, energy, model, scint, I0, wfct): """ Applies the spray to the filtered X-ray spectra. ============= --VARIABLES-- spray_epl: Spray path lengths to iterate through. energy: Energy values from XOP. model: Model type (water/KI%). scint: Scintillator name (LuAG/YAG). I0: Detected flat field spectra. wfct: Weighting function for T calculation. """ global prj_fld global inp_fld # Spray densities if model == 'water': ki_perc = 0 spray_den = 1.0 elif model == 'KI1p6': ki_perc = 1.6 spray_den = density_KIinH2O(ki_perc) elif model == 'KI3p4': ki_perc = 3.4 spray_den = density_KIinH2O(ki_perc) elif model == 'KI5p3': ki_perc = 5.3 spray_den = density_KIinH2O(ki_perc) elif model == 'KI8p1': ki_perc = 8.1 spray_den = density_KIinH2O(ki_perc) elif model == 'KI10p0': ki_perc = 10.0 spray_den = density_KIinH2O(ki_perc) elif model == 'KI11p1': ki_perc = 11.1 spray_den = density_KIinH2O(ki_perc) # Spray composition molec = ['H2O', 'KI'] comp = [100 - ki_perc, ki_perc] # Spray attenuation liq_atten1 = mass_atten(molec=molec, comp=comp, xcom=xcom, keV=200) liq_atten2 = xcom_reshape(liq_atten1, energy) plot_atten(liq_atten1, liq_atten2, model) # Detected spray spectra I I = [ bl_unk(incident=incident, attenuation=liq_atten2['Attenuation'], density=spray_den, epl=spray_epl) for incident in I0 ] # Swap the axes of I so that it's EPL (len(spray_epl)) x Row (352) x # Intensity (1991) I = np.swapaxes(I, 0, 1) method = 1 # Method 1: Ratio of areas if method == 1: Transmission = np.trapz(y=I, x=energy) / np.trapz(y=I0, x=energy) # Method 2: Weighted sum elif method == 2: Transmission = [np.sum((x / I0) * wfct, axis=1) for x in I] # Method 3: Average value elif method == 3: Transmission = np.mean(I / I0, axis=2) # Swap axes so that it's Row x EPL Transmission = np.swapaxes(Transmission, 0, 1) # Cubic spline fitting of Transmission and spray_epl curves # Needs to be reversed b/c of monotonically increasing # restriction on 'x', however this doesn't change the interp call. # Function that takes in I/I0 and outputs expected EPL (cm) TtoEPL = [ CubicSpline(vertical_pix[::-1], spray_epl[::-1]) for vertical_pix in Transmission ] # Function that takes in EPL (cm) value and outputs expected I/I0 EPLtoT = [ CubicSpline(spray_epl, vertical_pix) for vertical_pix in Transmission ] # Save model mdl_fld = create_folder('{0}/Model/'.format(prj_fld)) with open('{0}/{1}_model_{2}.pckl'.format(mdl_fld, model, scint), 'wb') as f: pickle.dump([TtoEPL, EPLtoT, spray_epl, Transmission], f) # Calculate average attenuation and transmission atten_avg = np.nanmean([-np.log(x) / spray_epl for x in Transmission], axis=0) trans_avg = np.nanmean(Transmission, axis=0) return atten_avg, trans_avg
def convertVTK(ij_inp, rot, ij_out, density): """ Converts individual IJ volumes. VARIABLES --------- ij_inp: Input folder containing each of the LaVision DaVis volumes. rot: Rotation dict to correct the volumes (see Jupyter notebook). ij_out: Location to save the VTK files. density: Density of the liquid to use for conversion to LVF. Use density=1 for no correction for the mixing cases. """ # Create folders as needed create_folder('{0}/VTK'.format(ij_out)) create_folder('{0}/PIM'.format(ij_out)) create_folder('{0}/Slice-4'.format(ij_out)) create_folder('{0}/SliceIJ'.format(ij_out)) create_folder('{0}/Slice+4'.format(ij_out)) create_folder('{0}/Slice+8'.format(ij_out)) # Get total number of volumes and initialize the impingement point var ijPtn4_den = np.zeros((len(ij_inp), 1)) ijPt0_den = np.zeros((len(ij_inp), 1)) ijPt4_den = np.zeros((len(ij_inp), 1)) ijPt8_den = np.zeros((len(ij_inp), 1)) for i, inp in enumerate(ij_inp): # Load in the density volume # Only load in the X/Y/Z values on the first volume (always the same) if i == 0: volume, x_mm, y_mm, z_mm = load_davis(inp) # Flip the Y values y_mm = y_mm[::-1] # Get the location of the impingement point in mm space X, Y, Z = np.meshgrid(x_mm, y_mm, z_mm, indexing='ij') # Rotate the X, Y, Z meshgrids X = rotate(X, rot['Angle'], axes=rot['Axes'], reshape=False) Y = rotate(Y, rot['Angle'], axes=rot['Axes'], reshape=False) Z = rotate(Z, rot['Angle'], axes=rot['Axes'], reshape=False) # Center point in voxels center_X = 90 center_Y = 129 center_Z = 195 # Impingement point in voxel coordinates (found from the rotated # projection images) ij_X = X[center_X, center_Y, center_Z] ij_Y = Y[center_X, center_Y, center_Z] ij_Z = Z[center_X, center_Y, center_Z] # Center the x, y, z vectors x_mm -= ij_X y_mm -= ij_Y z_mm -= ij_Z # Crop down the volume (see Jupyter notebook) x1 = np.argmin(np.abs(x_mm - -4.7)) x2 = np.argmin(np.abs(x_mm - 4.7)) y1 = np.argmin(np.abs(y_mm - -5)) y2 = np.argmin(np.abs(y_mm - 14)) z1 = np.argmin(np.abs(z_mm - -10)) z2 = np.argmin(np.abs(z_mm - 10)) # Get the origin (defines corner of the grid) origin = [x_mm[x1], y_mm[y1], z_mm[z1]] # Cropping x_mm = x_mm[x1:x2] y_mm = y_mm[y1:y2] z_mm = z_mm[z1:z2] # Save the volume extents np.save('{0}/VTK/x_mm.npy'.format(ij_out), x_mm, allow_pickle=False) np.save('{0}/VTK/y_mm.npy'.format(ij_out), y_mm, allow_pickle=False) np.save('{0}/VTK/z_mm.npy'.format(ij_out), z_mm, allow_pickle=False) # Get the APS locations ind0X = np.argmin(np.abs(x_mm - 0)) ind0Z = np.argmin(np.abs(z_mm - 0)) indn4Y = np.argmin(np.abs(y_mm - -4)) ind0Y = np.argmin(np.abs(y_mm - 0)) ind4Y = np.argmin(np.abs(y_mm - 4)) ind8Y = np.argmin(np.abs(y_mm - 8)) else: volume, _, _, _ = load_davis(inp) # Rotate the volume volume = rotate(volume, rot['Angle'], axes=rot['Axes'], reshape=False) # Mask out invalid values volume[volume < 0] = 0 # Calculate optical depth for the mixing cases # Volumes were inverted (1 - buffer) in DaVis if density == 1: volume = -np.log(1 - volume) # Get voxel size dx = np.abs(x_mm[1] - x_mm[0]) dy = np.abs(y_mm[1] - y_mm[0]) dz = np.abs(z_mm[1] - z_mm[0]) voxelSize = (dx, dy, dz) # Cropping volume = volume[x1:x2, y1:y2, z1:z2].astype('float32') # Calculate the PIM as a function of y # Convert volume to density, then project onto all XZ planes PIM = np.sum(volume / dx, axis=(0, 2)) * dx**2 # Save the PIM trace np.save('{0}/PIM/{1:04d}'.format(ij_out, i), PIM, allow_pickle=False) # Get the intensity value at the impingement point (as density) ijPtn4_den[i] = volume[ind0X, indn4Y, ind0Z] / dx ijPt0_den[i] = volume[ind0X, ind0Y, ind0Z] / dx ijPt4_den[i] = volume[ind0X, ind4Y, ind0Z] / dx ijPt8_den[i] = volume[ind0X, ind8Y, ind0Z] / dx # Extract the slices as solution density slicen4 = volume[:, indn4Y, :].astype('float32') / dx slice0 = volume[:, ind0Y, :].astype('float32') / dx slice4 = volume[:, ind4Y, :].astype('float32') / dx slice8 = volume[:, ind8Y, :].astype('float32') / dx # Save slices as numpy files np.save('{0}/Slice-4/{1:04d}'.format(ij_out, i), slicen4, allow_pickle=False) np.save('{0}/SliceIJ/{1:04d}'.format(ij_out, i), slice0, allow_pickle=False) np.save('{0}/Slice+4/{1:04d}'.format(ij_out, i), slice4, allow_pickle=False) np.save('{0}/Slice+8/{1:04d}'.format(ij_out, i), slice8, allow_pickle=False) # Bin volumes down and smooth #volume = zoom(volume, (0.5, 0.5, 0.5)) volume = gaussian_filter(volume, 1) # Convert density to liquid volume fraction (LVF) LVF = volume / density breakpoint() # Convert files to VTK format (make sure to normalize by grid size!) imageToVTK( '{0}/VTK/{1:04d}'.format(ij_out, i), origin=origin, spacing=voxelSize, pointData={'LVF': LVF / dx}, ) # Create a time series file seriesVTK(ij_out) # Save the impingement point values as density and LVF np.save('{0}/ijPtn4_den'.format(ij_out), ijPtn4_den) np.save('{0}/ijPtn4_LVF'.format(ij_out), ijPtn4_den / density) np.save('{0}/ijPt0_den'.format(ij_out), ijPt0_den) np.save('{0}/ijPt0_LVF'.format(ij_out), ijPt0_den / density) np.save('{0}/ijPt4_den'.format(ij_out), ijPt4_den) np.save('{0}/ijPt4_LVF'.format(ij_out), ijPt4_den / density) np.save('{0}/ijPt8_den'.format(ij_out), ijPt8_den) np.save('{0}/ijPt8_LVF'.format(ij_out), ijPt8_den / density)