diff --git a/IEX_Dictionaries/Dict_Slit.txt b/IEX_Dictionaries/Dict_Slit.txt index 12ba84e10e0a5536d0f46c66aabe0d9649c9084a..80a1e8473453e0b2b8021b9b980eeccce3582bc6 100644 --- a/IEX_Dictionaries/Dict_Slit.txt +++ b/IEX_Dictionaries/Dict_Slit.txt @@ -133,3 +133,9 @@ ======= 20220329: {'HEG': {'S2V': -0.244, 'S2H': -0.125, 'S1V': 0.0, 'S1H': 0.09}, 'MEG': {'S2V': 0.05, 'S2H': -0.02, 'S1V': -0.05, 'S1H': 0.1}} + +======= 20220405: +{'HEG': {'S2V': -0.015, 'S2H': -0.028, 'S1V': -0.041, 'S1H': 0.107}, 'MEG': {'S2V': 0.05, 'S2H': -0.02, 'S1V': -0.05, 'S1H': 0.1}} + +======= 20220405: +{'HEG': {'S2V': -0.015, 'S2H': -0.028, 'S1V': -0.041, 'S1H': 0.107}, 'MEG': {'S2V': -0.0725, 'S2H': 0.1813, 'S1V': -0.0789, 'S1H': 0.1735}} diff --git a/ScanFunctions_IEX.py b/ScanFunctions_IEX.py index 2116a2ed9dcb0ab5f24dd148c6302a9b4c93a9e8..662f8e20676cb5a68082593ca461e6b7388b4601 100755 --- a/ScanFunctions_IEX.py +++ b/ScanFunctions_IEX.py @@ -45,15 +45,13 @@ import matplotlib.pyplot as plt # required for optimize functions from Macros_29id.mda.mda import readMDA -#from Macros_29id.ScanFunctions_plot import plot_mda,fit_mda +from Macros_29id.ScanFunctions_plot import plot_mda,fit_mda,fit_d4,fit_d3,fit_z from Macros_29id.ScanFunctions_EA import * #from Macros_29id.ScanFunctions_ARPES import ARPES_PVmotor from Macros_29id.ScanFunctions_LakeShore import * #MPA_ROI_SetUp calls: from ScanFunctions_AD import AD_ROI_SetUp - - #import matplotlib.pyplot as plt #from matplotlib.pyplot import plot, show, legend, xlabel, ylabel @@ -4244,6 +4242,7 @@ def Get_Mirror(n): print(" => In D branch") elif branch == "c": print(" => In C branch") + return [round(Tx,3),round(Ty,3),round(Tx,3),round(Rx,3),round(Ry,3),round(Rz,3)] #def Sync_m4r(): #caput('29idHXP:hxp2:m1.SYNC',1) @@ -4738,12 +4737,12 @@ def beamsteering_2B(v_position): vroll=round(v_position*0.05/0.04,3) if v_position<0: v_direction=' +' else: v_direction=' -' - v_steering=v_direction+str(vroll)+' urad' + v_steering=v_direction+str(abs(vroll))+' urad' return v_steering def beamsteering_1A(h_position,v_position): - hrad=round(h_position*10/0.25,0) - vrad=round(v_position*10/0.25,0) + hrad=round(abs(h_position)*10/0.25,0) + vrad=round(abs(v_position)*10/0.25,0) if h_position<0: h_direction=' urad outboard' else: h_direction=' urad inboard' if v_position<0: v_direction=' urad up' @@ -4897,10 +4896,11 @@ def StartOfTheWeek(GRT,branch,wait=False,**kwargs): print(' - vertical: '+v_steering) print('\n') except: - print('Unable to fit position; try to tweak xrange or FWHM:') - print('fit_mda('+str(m)+','+str(detCA4)+',1,"gauss",xrange=[-1,1])') - print('fit_mda('+str(m+1)+','+str(detCA4)+',1,"gauss",xrange=[-1,1])') - print('\n') + print('\nUnable to fit position; try to tweak xrange or FWHM:\n') + print('h_position=fit_mda('+str(m-1)+','+str(detCA4)+',1,"gauss",xrange=[-1,1])') + print('v_position=fit_mda('+str(m)+','+str(detCA4)+',1,"gauss",xrange=[-1,1])') + print('\nThen use:') + print('\tbeamsteering_1A(h_position,v_position)') if kwargs['sound']:playsound() if kwargs['interactive']: flag=interactive_fct() else: break @@ -4915,19 +4915,16 @@ def StartOfTheWeek(GRT,branch,wait=False,**kwargs): try: plot_mda(m-1,detH,m,detV,title='wire-H (blue) & wire-V (orange)');plt.show() except: - print('Unable to plot.') + print('Unable to plot. Try:') + print("plot_mda("+str(m-1)+","+str(detH)+","+str(m)+","+str(detV)+",title='wire-H (blue) & wire-V (orange)');plt.show()") if kwargs['sound']:playsound() ###### Mono/slit scans: - list_position=[] - if 'monoVslit' in kwargs['scanType']: - if GRT=="HEG": - slit(300) - c=2 - else: - slit(200) - c=1 + if 'monoVslit' in kwargs['scanType']: + c=Mono_Optics()[1][3]/1200 + if c==2: slit(300) + else: slit(200) print("\n\n================== Mono/slit scans:") if 'quick' in kwargs: energy(500) @@ -4935,6 +4932,7 @@ def StartOfTheWeek(GRT,branch,wait=False,**kwargs): print('\n---------- Scanning slit 2B:\n') flag=True while flag: + list_position=[] Scan_NarrowSlit_Go(which='2V',slit_parameters=[0.25*c, -8, 8, 0.25]);sleep(1) Scan_NarrowSlit_Go(which='2H',slit_parameters=[0.25, -6, 6, 0.25]);sleep(1) m=MDA_GetLastFileNum() @@ -4947,12 +4945,15 @@ def StartOfTheWeek(GRT,branch,wait=False,**kwargs): #print(f"H2 = {round(H2,3)}") print('\nBeam position:') - print(f" - vertical: V1 = {round(V2,3)}") - print(f" - horizontal: H1 = {round(H2,3)}") + print(f" - vertical: V2 = {round(V2,3)}") + print(f" - horizontal: H2 = {round(H2,3)}") v_steering=beamsteering_2B(V2) print('\nM1 roll (RZ) steering:') print(' - vertical: ~ '+v_steering) print(' - horizontal: reset slit 2BH center to ',str(H2)) + print('\nThen use:') + current_roll=Get_Mirror(1)[5] + print("\tGet_Mirror(1);Move_M1('RZ',"+str(current_roll)+v_steering[:-5]+")") print('\n') print('\n\nWARNING: 2V slit should always be centered at zero') @@ -4961,7 +4962,13 @@ def StartOfTheWeek(GRT,branch,wait=False,**kwargs): print('To steer M1, use:') print("\tGet_Mirror(1);Move_M1('RZ',x)") except: - print('Unable to fit position.') + print('Unable to fit position. Try:') + print('c='+str(c)) + print('V2=fit_mda('+str(m-1)+','+str(detDiode)+',1*c+,"gauss")') + print('H2=fit_mda('+str(m)+','+str(detDiode)+',1,"gauss")') + print('\nThen use:') + print('\tbeamsteering_2B(V2)') + if kwargs['sound']:playsound() if kwargs['interactive']: flag=interactive_fct('slit 2B') else: break @@ -4981,7 +4988,9 @@ def StartOfTheWeek(GRT,branch,wait=False,**kwargs): print(f" - vertical: V1 = {round(V1,3)}") print(f" - horizontal: H1 = {round(H1,3)}") except: - print('Unable to fit position.') + print('\nUnable to fit position. Try:') + print('V1=fit_mda('+str(m-1)+','+str(detDiode)+',1,"gauss")') + print('H1=fit_mda('+str(m)+','+str(detDiode)+',1,"gauss")') if kwargs['sound']:playsound() if kwargs['interactive']: flag=interactive_fct('slit 1A') else: break @@ -5016,7 +5025,8 @@ def StartOfTheWeek(GRT,branch,wait=False,**kwargs): m=MDA_GetLastFileNum() plot_mda(m,detDiode,flux=3);plt.show() except: - print('Unable to fit position.') + print('Unable to plot. Try:') + print("plot_mda("+str(m)+","+str(detDiode)+",flux=3);plt.show()") ### interactive if kwargs['interactive']: flag=interactive_fct() else: break @@ -5030,7 +5040,7 @@ def StartOfTheWeek(GRT,branch,wait=False,**kwargs): if FirstScan is not None: logprint(comment="\nFirstScan = "+str(FirstScan)) print('StartOfTheWeek_plot("'+branch+'",'+str(FirstScan)+')' ) - print('Beam center fit @ [2V,2H,1V,1H]:',list_position) + print('\nBeam center fit @ [2V,2H,1V,1H]:',list_position) print('\nREMEMBER to update slit center using: update_slit_dict()') if kwargs['sound']: @@ -8544,7 +8554,148 @@ def LastMDA(): n=caget('29id'+scanIOC+':saveData_scanNumber')-1 return n -##### Kappa Optimization scans ##### + +def plot_latest(): + plot_mda(LastMDA(),16,NormDet=31,marker='+',save=True,title='mda_'+str(LastMDA())) + +##### Kappa Optimization scans - 2022 versions ##### + +def Find_kth_zero(th_0,th_180): + """ + th_0 is the motor position for specular near zero + th_180 is motor position for spectular near 180 + """ + + Offset =0.5*(180 - th_180 - th_0) + + print("with motor at 0, the actual value is ",Offset) + + +def align_d4(z0,th): + ''' th = 0 or 180 + ''' + setdet('d4') + sleep(1) + uan(0,th) + mvz(z0-1500) + setgain('d4',10,'uA') + dscantth(-0.25,0.25,0.01) + sleep(1) + setgain('d4',1,'nA') + mvz(z0) + n=LastMDA() + fit_mda(n,25,0,'poly',graph=False) + tth0=fit_d4(n) + print('tth0 = '+str(round(tth0,3))) + playsound() + return tth0 + + +def align_z0_chi0(question=True): + if question: + foo=input_d('Are you at th=90/270, chi=0, phi=90 (Y or N)? >') + if foo == 'Y'.lower() or foo == 'yes'.lower(): + setdet('d3') + sleep(1) + mvtth(0) + dscanz(-750,750,50) + sleep(1) + n=LastMDA() + fit_mda(n,25,0,'poly',graph=False) + z0=fit_z(n) + print('z0 = '+str(round(z0,0))) + playsound() + return z0 + else: + print('Canceling') + return + else: + setdet('d3') + sleep(1) + mvtth(0) + dscanz(-750,750,50) + sleep(1) + n=LastMDA() + fit_mda(n,25,0,'poly',graph=False) + z0=fit_z(n) + print('z0 = '+str(round(z0,0))) + playsound() + return z0 + + + +def align_z0(omega): + setdet('d3') + sleep(1) + uan(0,omega) + dscanz(-750,750,50) + sleep(1) + n=LastMDA() + fit_mda(n,25,0,'poly',graph=False) + z0=fit_z(n) + print('z0 = '+str(round(z0,0))) + playsound() + return z0 + + +def align_z180(omega): + setdet('d3') + sleep(1) + uan(0,180+omega) + dscanz(-750,750,50) + sleep(1) + n=LastMDA() + fit_mda(n,25,0,'poly',graph=False) + z180=fit_z(n) + print('z180 = '+str(round(z180,0))) + playsound() + return z180 + +def align_th0(omega,z): + setdet('d4') + sleep(1) + #uan(20,10+omega) + uan(30,15+omega) + mvz(z) + sleep(30) + setgain('d4',1,'nA') + dscanth(-0.25,0.25,0.01) + n=LastMDA() + fit_mda(n,25,0,'poly',graph=False) + th_spec=fit_d4(n) + print('th specular = '+str(round(th_spec,3))) + tth=round(caget('29idKappa:m9.RBV'),3) + omega=th_spec-tth/2 + print('omega = th-tth/2 = '+str(round(omega,3))) + playsound() + return omega + + +def align_th180(omega,z): + setdet('d4') + sleep(1) + uan(-30,180+omega-15) + #uan(-20,180+omega-10) + mvz(z) + setgain('d4',1,'nA') + dscanth(-0.25,0.25,0.01) + n=LastMDA() + fit_mda(n,25,0,'poly',graph=False) + th_spec=fit_d4(n) + print('th specular = '+str(round(th_spec,3))) + tth=round(caget('29idKappa:m9.RBV'),3) + omega180=th_spec-tth/2-180 + print('omega180 = th-tth/2-180 = '+str(round(omega180,3))) + playsound() + return omega180 + + + + +##### Kappa Optimization scans - old versions ##### + + + def Opt_d4(iteration,moveZ,graph='y',srs=None,start=-0.5,stop=0.5,step=0.04): tth_w=0.1 if srs==None: det=21 @@ -8794,6 +8945,9 @@ def scankphi(start,stop,step,mode="absolute",scanIOC=None,scanDIM=1,**kwargs): else: print("kphi motor does not exit") + + + def scanFocus(start,stop,step,mode="relative",**kwargs): """ scans the ARPES focus relative to the current x value, y=xtan55 diff --git a/ScanFunctions_plot.py b/ScanFunctions_plot.py index bd3f5fd9b2557104869fc054c78abede060325ce..1633217096f934fdf32a2a9e1075c7ff97ffec62 100755 --- a/ScanFunctions_plot.py +++ b/ScanFunctions_plot.py @@ -16,6 +16,7 @@ from math import * #from netCDF4 import Dataset #### Other utilities: import csv +import datetime from os import listdir from os.path import join, isfile, dirname from scipy.optimize import curve_fit @@ -27,16 +28,22 @@ import ast ##### APS / 29ID-IEX: from epics import * from Macros_29id.mda.mda import readMDA,scanDim -from Macros_29id.ScanFunctions_IEX import BL_ioc -from Macros_29id.ScanFunctions_IEX import ca2flux -from Macros_29id.ScanFunctions_IEX import MDA_CurrentDirectory -from Macros_29id.ScanFunctions_IEX import MDA_CurrentPrefix -from Macros_29id.ScanFunctions_IEX import MDA_CurrentUser -from Macros_29id.ScanFunctions_IEX import MDA_CurrentRun -from Macros_29id.ScanFunctions_IEX import today -from Macros_29id.ScanFunctions_IEX import read_dict -from Macros_29id.ScanFunctions_IEX import LastMDA -from Macros_29id.ScanFunctions_IEX import SetSlit_BL +from Macros_29id.mda.file import * + + + + + +#from Macros_29id.ScanFunctions_IEX import BL_ioc => plotIOC() +#from Macros_29id.ScanFunctions_IEX import ca2flux => _ca2flux defined localy in functions +#from Macros_29id.ScanFunctions_IEX import MDA_CurrentDirectory => mda.file.mda_CurrentDirectory +#from Macros_29id.ScanFunctions_IEX import MDA_CurrentPrefix => mda.file.mda_CurrentPrefix +#from Macros_29id.ScanFunctions_IEX import MDA_CurrentUser => mda.file.mda_CurrentUser +#from Macros_29id.ScanFunctions_IEX import MDA_CurrentRun => mda.file.mda_CurrentRun +#from Macros_29id.ScanFunctions_IEX import today => def today_plot() +#from Macros_29id.ScanFunctions_IEX import read_dict => _read_dict defined localy in functions +#from Macros_29id.ScanFunctions_IEX import LastMDA => replace tiwth mda.file.mda_GetLastFileNum +#from Macros_29id.ScanFunctions_IEX import SetSlit_BL => removed (plot should not move BL) try: from Macros_29id.IEX_nData import * @@ -50,6 +57,20 @@ if __name__=='__main__': +def today_plot(which='default'): + dt=datetime.date.today() + today_year = dt.year + today_month = dt.month + today_day = dt.day + if which == 'slash': + today_str=("{:02d}/{:02d}/{:04d}".format(today_month,today_day,today_year)) + elif which == 'int': + today_str=int(("{:04d}{:02d}{:02d}".format(today_year,today_month,today_day))) + else: # 'default': + today_str=("{:04d}{:02d}{:02d}".format(today_year,today_month,today_day)) + return today_str + + ############################################################################################################## ############################## JM Curves and Curve Fitting ############################## @@ -149,14 +170,14 @@ def plot_image2(Filepath1,Filepath2,h=20,v=10): def mda_unpack(ScanNum,filepath=None,prefix=None,scanIOC=None): """ Return data file + dictionary D##:("pv",index##) - filepath: by default plot scans for the current data folder (as defined in BL_ioc() ScanRecord SaveData) + filepath: by default plot scans for the current data folder (as defined in plotIOC() ScanRecord SaveData) or specified folder path: e.g. filepath='/net/s29data/export/data_29idb/2018_1/mda_b/' prefix: by default, uses prefix as defined in ScanRecord "mda_" for users, "Kappa_" or "ARPES_" for staff (sometimes) """ if scanIOC is None: - scanIOC = BL_ioc() + scanIOC = plotIOC() if filepath is None: filepath =caget("29id"+scanIOC+":saveData_fileSystem",as_string=True)+caget("29id"+scanIOC+":saveData_subDir",as_string=True) if filepath[1]=='/': @@ -298,6 +319,22 @@ def mda_Flux(ScanNum,DetectorNum,EnergyNum,filepath=None,prefix=None,scanIOC=Non EnergyNum is the detector number for the mono RBV. """ + def _ca2flux(ca,hv=None,p=1): + curve=LoadResponsivityCurve() + responsivity=curve[:,0] + energy=curve[:,1] + charge = 1.602e-19 + if hv is None: + hv=caget('29idmono:ENERGY_SP') + print("\nCalculating flux for:") + print(" hv = %.1f eV" % hv) + print(" ca = %.3e Amp" % ca) + eff=np.interp(hv,energy,responsivity) + flux = ca/(eff*hv*charge) + if p is not None: + print("Flux = %.3e ph/s\n" % flux) + return flux + try: (data_file,det)=mda_unpack(ScanNum,filepath,prefix,scanIOC) index=det[DetectorNum][1] @@ -316,7 +353,7 @@ def mda_Flux(ScanNum,DetectorNum,EnergyNum,filepath=None,prefix=None,scanIOC=Non if len(d)\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# to change mode: ['bissector', 'constant_omega', 'constant_chi', 'constant_phi', 'double_diffraction', 'psi_constant']\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mchangeMode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"constant_phi\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mNameError\u001b[0m: name 'changeMode' is not defined" - ] - } - ], - "source": [ - "# to change mode: ['bissector', 'constant_omega', 'constant_chi', 'constant_phi', 'double_diffraction', 'psi_constant']\n", - "changeMode(\"constant_phi\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HklSample(name='PrYBCO', lattice=LatticeTuple(a=3.86, b=3.86, c=11.5, alpha=90.0, beta=90.0, gamma=90.0), ux=Parameter(name='None (internally: ux)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), uy=Parameter(name='None (internally: uy)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), uz=Parameter(name='None (internally: uz)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), U=array([[1., 0., 0.],\n", - " [0., 1., 0.],\n", - " [0., 0., 1.]]), UB=array([[ 1.62776821e+00, -9.96720567e-17, -3.34551425e-17],\n", - " [ 0.00000000e+00, 1.62776821e+00, -3.34551425e-17],\n", - " [ 0.00000000e+00, 0.00000000e+00, 5.46363940e-01]]), reflections=[], reflection_measured_angles=array([], shape=(0, 0), dtype=float64), reflection_theoretical_angles=array([], shape=(0, 0), dtype=float64))\n" - ] - } - ], - "source": [ - "sampleNew('STO',3.905,3.905,3.905,90,90,90) # unique name, a,b,c,alpha,beta,gamma" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "ERROR: This sample already exist. Sample name is unique (dictionnary key). To change sample parameters, use sampleUpdate(...)\n" - ] - } - ], - "source": [ - "sampleNew('PrYBCO',3.86,3.86,11.5,90,90,90) # unique name, a,b,c,alpha,beta,gamma" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "======= PrYBCO :\n", - "LatticeTuple(a=3.86, b=3.86, c=11.5, alpha=90.0, beta=90.0, gamma=90.0)\n", - "[[1. 0. 0.]\n", - " [0. 1. 0.]\n", - " [0. 0. 1.]]\n", - "\n", - "Current sample: PrYBCO\n" - ] - } - ], - "source": [ - "sampleRBV()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "PrYBCO: LatticeTuple(a=3.9, b=3.9, c=11.5, alpha=90.0, beta=90.0, gamma=90.0)\n" - ] - } - ], - "source": [ - "sampleUpdate(3.9,3.9,11.5,90,90,90)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "UB Matrix forPrYBCO:\n", - "[[ 0.23300442 -1.59401948 0.0065016 ]\n", - " [ 0.03057933 0.02384078 0.54620568]\n", - " [-1.59384145 -0.23257304 0.01142993]]\n", - "\n", - "LAMBDA = 14.528 \thv = 853.402\n", - "Sync to motor:\n", - "omega = 89.99964 \tchi = 88.00004 \tphi = -0.00279\n", - "tth = 119.99994 \tkth = 144.12583 \tkap = 130.13700 \tkphi = 54.12340\n" - ] - } - ], - "source": [ - "r1=setor(0, 0,1) # with no motor specified, use current values\n", - "r2=setor(-1,0,1,tth=150.9, omega=3.760, chi=80.656, phi=78.9)\n", - "UB=UBcalc(r1,r2,sync=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 0.23300442, -1.59401948, 0.0065016 ],\n", - " [ 0.03057933, 0.02384078, 0.54620568],\n", - " [-1.59384145, -0.23257304, 0.01142993]])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "UBrbv()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Current energy: 2800.0\n" - ] - } - ], - "source": [ - "UBenergy(2800)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2800.0" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Lambda2eV(fourc.calc.wavelength)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sample = PrYBCO \n", - "Lattice = 3.900,3.900,11.500 \n", - "LAMBDA = 4.428 \thv = 2800.000\n", - "Mode = constant_phi\n", - "========== ======== ======== ======== ======== ========\n", - "(hkl) solution omega chi phi tth \n", - "========== ======== ======== ======== ======== ========\n", - "(0, 0, 2) 0 23.32836 88.80123 -0.00279 45.29295\n", - "(-1, 0, 1) 0 29.18191 17.80733 -0.00279 73.66103\n", - "========== ======== ======== ======== ======== ========\n", - "\n" - ] - } - ], - "source": [ - "reflections = ((0,0,2),(-1,0,1)) \n", - "\n", - "cahkl_table(reflections) " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calculating Kappa angles using kth0 = 57.045\n", - "Sample = PrYBCO \n", - "Lattice = 3.900,3.900,11.500 \n", - "LAMBDA = 4.428 \thv = 2800.000\n", - "Mode = constant_phi\n" - ] - }, - { - "data": { - "text/plain": [ - "(23.32836, 88.80123, -0.00279, 45.29295, 78.586, 131.947, 55.255)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cahkl(0,0,2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "mvhkl(0,0,2) # moves to hkl position" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "LAMBDA = 14.528 \thv = 853.395\n", - "Sync to motor:\n", - "omega = 89.99964 \tchi = 88.00004 \tphi = -0.00280\n", - "tth = 119.99994 \tkth = 144.12583 \tkap = 130.13700 \tkphi = 54.12339\n", - "Calculating Kappa angles using kth0 = 57.045\n", - "===================== ======================\n", - "term value \n", - "===================== ======================\n", - "diffractometer fourc \n", - "Sample PrYBCO \n", - "a 3.9 \n", - "b 3.9 \n", - "c 11.5 \n", - "wavelength (angstrom) 14.528343419538704 \n", - "energy (eV) 853.3953006180844 \n", - "h 0.027346681505743188 \n", - "k -0.22608789019568812 \n", - "l 1.19529570948112 \n", - "omega 89.99963649940887 \n", - "chi 88.0000366463628 \n", - "phi -0.0027977159442747032\n", - "tth 119.99993807032001 \n", - "kth 144.126 \n", - "kap 130.137 \n", - "kphi 54.123 \n", - "===================== ======================\n", - "\n" - ] - } - ], - "source": [ - "wh()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "HklSample(name='STO', lattice=LatticeTuple(a=3.905, b=3.905, c=3.905, alpha=90.0, beta=90.0, gamma=90.0), ux=Parameter(name='None (internally: ux)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), uy=Parameter(name='None (internally: uy)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), uz=Parameter(name='None (internally: uz)', limits=(min=-180.0, max=180.0), value=0.0, fit=True, inverted=False, units='Degree'), U=array([[1., 0., 0.],\n", - " [0., 1., 0.],\n", - " [0., 0., 1.]]), UB=array([[ 1.60901032e+00, -9.85234670e-17, -9.85234670e-17],\n", - " [ 0.00000000e+00, 1.60901032e+00, -9.85234670e-17],\n", - " [ 0.00000000e+00, 0.00000000e+00, 1.60901032e+00]]), reflections=[], reflection_measured_angles=array([], shape=(0, 0), dtype=float64), reflection_theoretical_angles=array([], shape=(0, 0), dtype=float64))\n" - ] - } - ], - "source": [ - "sampleNew('STO',3.905,3.905,3.905,90,90,90)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "======= PrYBCO :\n", - "LatticeTuple(a=3.9, b=3.9, c=11.5, alpha=90.0, beta=90.0, gamma=90.0)\n", - "[[ 0.14462684 -0.98941471 0.01189976]\n", - " [ 0.01898072 0.01479807 0.99971033]\n", - " [-0.9893042 -0.14435908 0.02092 ]]\n", - "\n", - "======= STO :\n", - "LatticeTuple(a=3.905, b=3.905, c=3.905, alpha=90.0, beta=90.0, gamma=90.0)\n", - "[[1. 0. 0.]\n", - " [0. 1. 0.]\n", - " [0. 0. 1.]]\n", - "\n", - "Current sample: STO\n" - ] - } - ], - "source": [ - "sampleList()" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Current sample: PrYBCO\n" - ] - } - ], - "source": [ - "sampleChange('PrYBCO')" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "PrYBCO: LatticeTuple(a=3.8, b=3.8, c=11.5, alpha=90.0, beta=90.0, gamma=90.0)\n" - ] - } - ], - "source": [ - "sampleUpdate(3.8,3.8,11.5,90,90,90) \n", - "#is there a way to not print LatticeTuple (besides explicitely enumerate it)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Current energy: 499.99\n" - ] - } - ], - "source": [ - "UBenergy_rbv()" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Current energy: 2800.0\n" - ] - } - ], - "source": [ - "UBenergy(2800)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Scan1: 29idKappa:m4.VAL= -2110.177 / -510.177 / 25.0\n", - "Kappa_192 started at Fri 30 Jul 2021 12:09:21\n", - "Kappa_192 finished at Fri 30 Jul 2021 12:11:04\n", - "\n", - "\n" - ] - } - ], - "source": [ - "dscanz(-800,800,25)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Calculating Kappa angles using kth0 = 57.045\n", - "Sample = PrYBCO \n", - "Lattice = 3.800,3.800,11.500 \n", - "LAMBDA = 4.428 \thv = 2800.000\n", - "Mode = constant_phi\n" - ] - }, - { - "data": { - "text/plain": [ - "(23.32831, 88.80121, -0.00082, 45.29295, 78.586, 131.947, 55.257)" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cahkl(0,0,2) # th, chi, phi, tth ,kth,kap,kphi\n", - "\n", - "#mvhkl(0,0,1)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Current energy: 2800.0\n", - "Number of accessible reflections: 7\n", - "Sample = PrYBCO \n", - "Lattice = 3.900,3.900,11.500 \n", - "LAMBDA = 4.428 \thv = 2800.000\n", - "Mode = constant_phi\n", - "================ ======== ======== ======== ======== ========\n", - "(hkl) solution omega chi phi tth \n", - "================ ======== ======== ======== ======== ========\n", - "[0. 0. 0.94] 0 11.10819 88.80123 -0.00280 20.85261\n", - "[0. 0. 0.96] 0 11.33259 88.80123 -0.00280 21.30141\n", - "[0. 0. 0.98] 0 11.55716 88.80123 -0.00280 21.75054\n", - "[0. 0. 1.] 0 11.78189 88.80123 -0.00280 22.20001\n", - "[0. 0. 1.02] 0 12.00679 88.80123 -0.00280 22.64982\n", - "[0. 0. 1.04] 0 12.23188 88.80123 -0.00280 23.09999\n", - "[0. 0. 1.06] 0 12.45714 88.80123 -0.00280 23.55052\n", - "================ ======== ======== ======== ======== ========\n", - "\n" - ] - } - ], - "source": [ - "# to get a preview of a given hkl scan \n", - "# (and make sure all reflections are reachable)\n", - "\n", - "#scanhkl_test((0,0,0.9),(0,0,1.1),10,ct=1,E=2800) #=> replaced by run=False in scanhkl()\n", - "\n", - "scanhkl((0,0,0.9),(0,0,1.1),10,ct=1,E=2800,run=False) " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Current energy: 2800.0\n", - "Integration time set to: 1.2\n", - " = [D46]\n", - " = [D47]\n", - " = [D48]\n", - "tth = [D54]\n", - "th = [D55]\n", - "chi = [D56]\n", - "phi = [D57]\n", - "Scan1: 29idKappa:m9.VAL= 0.0 / 0.0 / 0.0\n", - "Kappa_78 started at Wed 24 Mar 2021 23:06:17\n", - "Kappa_78 finished at Wed 24 Mar 2021 23:07:25\n", - "\n", - "\n", - "\n", - "All extra positionners cleared\n" - ] - } - ], - "source": [ - "hkl1=(0,0,0.9)\n", - "hkl2=(0,0,1.1)\n", - "scanhkl(hkl1,hkl2,5,1,E=2800)\n", - "#scanhkl(hkl1,hkl2,5,1,E=2831.75) # start_hkl, stop_hkl, npts, cts, energy" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "plot_mda(78,33,vs_det=46) # plot scan 78 big diode (33) vs H (46)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# fixed Q scan at hkl=(0,0,1):\n", - "\n", - "energy_list=[[620,640,1],[640,650,0.1],[650,660,0.5]] # energy trajectory \n", - "\n", - "scanhkl_E(energy_list,(0,0,1),mono_offset=1,cts=1) \n", - "\n", - "# mono_offset to tweak the energy calibration\n", - "# cts time is 1\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "img = '/home/beams/29IDUSER/Documents/User_Folders/Staff/Screenshots/900eV.png'" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plot_image(img)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0204.mda as mydata.scan[204]:\n", - "\t\t...1D data, 61/61 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0203.mda as mydata.scan[203]:\n", - "\t\t...1D data, 4/41 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0207.mda as mydata.scan[207]:\n", - "\t\t...1D data, 51/51 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0205.mda as mydata.scan[205]:\n", - "\t\t...1D data, 61/61 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0206.mda as mydata.scan[206]:\n", - "\t\t...1D data, 460/601 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0208.mda as mydata.scan[208]:\n", - "\t\t...1D data, 21/21 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0209.mda as mydata.scan[209]:\n", - "\t\t...1D data, 0/140 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0210.mda as mydata.scan[210]:\n", - "\t\t...1D data, 141/141 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0211.mda as mydata.scan[211]:\n", - "\t\t...1D data, 41/41 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0212.mda as mydata.scan[212]:\n", - "\t\t...1D data, 31/31 pts; 4 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0213.mda as mydata.scan[213]:\n", - "\t\t...1D data, 31/31 pts; 4 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0191.mda as mydata.scan[191]:\n", - "\t\t...1D data, 201/201 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0192.mda as mydata.scan[192]:\n", - "\t\t...1D data, 201/201 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0193.mda as mydata.scan[193]:\n", - "\t\t...1D data, 201/201 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0194.mda as mydata.scan[194]:\n", - "\t\t...1D data, 101/101 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0195.mda as mydata.scan[195]:\n", - "\t\t...1D data, 51/51 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0196.mda as mydata.scan[196]:\n", - "\t\t...1D data, 51/51 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0197.mda as mydata.scan[197]:\n", - "\t\t...1D data, 51/51 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0198.mda as mydata.scan[198]:\n", - "\t\t...1D data, 51/51 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0199.mda as mydata.scan[199]:\n", - "\t\t...1D data, 51/51 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0200.mda as mydata.scan[200]:\n", - "\t\t...1D data, 51/51 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0201.mda as mydata.scan[201]:\n", - "\t\t...1D data, 26/26 pts; 4 positioners, 50 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0202.mda as mydata.scan[202]:\n", - "\t\t...1D data, 26/26 pts; 4 positioners, 50 detectors\n" - ] - } - ], - "source": [ - "mydata=mdaFile(1,60) # load data" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0204.mda as mydata.scan[204]:\n", - "\t\t...1D data, 61/61 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0203.mda as mydata.scan[203]:\n", - "\t\t...1D data, 4/41 pts; 1 positioners, 47 detectors\n", - "Loading /net/s29data/export/data_29idb/2020_3/mda/Kappa_0202.mda as mydata.scan[202]:\n", - "\t\t...1D data, 26/26 pts; 4 positioners, 50 detectors\n", - "140600655559704\n", - "140600655559704\n" - ] - }, - { - "data": { - "text/plain": [ - "<__main__.mdaFile at 0x7fe00e984e10>" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mydata.updateFiles(70) # load more data\n", - "#mydata.updateFiles(mydata.scanNum[-1]) # load more data" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_hkl(mydata,216,218,det=34)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot_hkl(mydata,229,det=34)" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Amplitude: 154936.30828829386\n", - "Center: 1.0063548147400712\n", - "FWHM: 0.001136933153667314\n" - ] - }, - { - "data": { - "text/plain": [ - "1.0063548147400712" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fit_hkl_gauss(202,34,0.001) # scan, det, FWHM_guess" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'/home/beams22/29IDUSER/Documents/User_Macros'" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pwd" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "hkl", - "language": "python", - "name": "hkl" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.7" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/hklpy/ScanFunctions_hkl.py b/hklpy/ScanFunctions_hkl.py index d2da343440db70d9ecfbc51a2e0f44cf810029ae..9cdd0749f071a7bd048a712783a2818058a74ee0 100644 --- a/hklpy/ScanFunctions_hkl.py +++ b/hklpy/ScanFunctions_hkl.py @@ -20,7 +20,7 @@ from ScanFunctions_IEX import Lambda2eV from ScanFunctions_IEX import eV2Lambda from ScanFunctions_IEX import EtoK from ScanFunctions_IEX import getE -from ScanFunctions_IEX import ScalerInt +from ScanFunctions_IEX import cts from ScanFunctions_IEX import Scan_FillIn_Table from ScanFunctions_IEX import Scan_Go from ScanFunctions_IEX import Clear_Scan_Positioners @@ -280,7 +280,7 @@ def get_UB_pvs(q=False): return UBlattice,UBsample,UBenergy,UBlambda,UBor1,UBor2,UBmatrix -def get_UB_scan(n,**kwargs): +def get_UB_from_scan(n,**kwargs): """ kwargs: filepath = None, uses current mda filepath unless specified e.g. user : filepath='/net/s29data/export/data_29idc/2018_2/UserName/mda/' @@ -508,7 +508,7 @@ def sampleReload(n=None,**kwargs): if n == None: UBlattice,UBsample,UBenergy,UBlambda,UBor1,UBor2,UBmatrix=get_UB_pvs() else: - UBlattice,UBsample,UBenergy,UBlambda,UBor1,UBor2,UBmatrix=get_UB_scan(n) + UBlattice,UBsample,UBenergy,UBlambda,UBor1,UBor2,UBmatrix=get_UB_from_scan(n) A,B,C,Alpha,Beta,Gamma=[UBlattice[i] for i in range(0,len(UBlattice))] print('\n') sampleNew(UBsample,A,B,C,Alpha,Beta,Gamma) @@ -609,7 +609,7 @@ def UBenergy_rbv(): -def _scan_hkl_array(mytable,settling_time=0.2,cts=1,scanIOC='Kappa',scanDIM=1,**kwargs): +def _scan_hkl_array(mytable,settling_time=0.2,acq_time=1,scanIOC='Kappa',scanDIM=1,**kwargs): """ Uses bluesky pyhkl to calculate the motor positions for an hkl scan: @@ -646,7 +646,7 @@ def _scan_hkl_array(mytable,settling_time=0.2,cts=1,scanIOC='Kappa',scanDIM=1,** print(caget(ArrayCalc+".DESC")+" = [D"+str(Det_h+i)+"]") # Set counting time: - ScalerInt(cts) + cts(acq_time) # Extract individual arrays: table_omega = mytable[0] @@ -706,8 +706,8 @@ def scanhkl(hkl1,hkl2,npts,ct,E=None,run=True,mycomment=''): myarray=_hkl_array(hkl1,hkl2,npts,E) print("Number of accessible reflections: ",str(len(myarray[4]))) if run == True: - #scanHKL(myarray,settling_time=0.2,cts=ct,mypath=path,comment=mycomment) - _scan_hkl_array(myarray,settling_time=0.2,cts=ct,comment=mycomment) + #scanHKL(myarray,settling_time=0.2,acq_time=ct,mypath=path,comment=mycomment) + _scan_hkl_array(myarray,settling_time=0.2,acq_time=ct,comment=mycomment) elif run == False: cahkl_table(myarray[4]) @@ -772,7 +772,7 @@ def table2csv(hkl_table,filePath=None,separator=','): -def scanhkl_E(StartStopStepLists,hkl,mono_offset,settling_time=0.2,cts=1,scanIOC='Kappa',scanDIM=1,**kwargs): +def scanhkl_E(StartStopStepLists,hkl,mono_offset,settling_time=0.2,acq_time=1,scanIOC='Kappa',scanDIM=1,**kwargs): """ Uses bluesky pyhkl to calculate the motor positions for an energy scan at constant Q: @@ -787,7 +787,7 @@ def scanhkl_E(StartStopStepLists,hkl,mono_offset,settling_time=0.2,cts=1,scanIOC """ # Set counting time: - ScalerInt(cts) + cts(acq_time) # caget beamline parameters: if scanIOC is None: @@ -871,7 +871,7 @@ def scanhkl_E(StartStopStepLists,hkl,mono_offset,settling_time=0.2,cts=1,scanIOC -def scanhkl_mono(StartStopStepLists,hkl,mono_offset=0,settling_time=0.2,cts=1,scanIOC='Kappa',scanDIM=1,**kwargs): +def scanhkl_mono(StartStopStepLists,hkl,mono_offset=0,settling_time=0.2,acq_time=1,scanIOC='Kappa',scanDIM=1,**kwargs): """ Uses bluesky pyhkl to calculate the motor positions for an energy scan at constant Q: mono_offset => if you want to artificially shift the energy for the reciprocal space calulation (to match integer hkl indexes) @@ -886,7 +886,7 @@ def scanhkl_mono(StartStopStepLists,hkl,mono_offset=0,settling_time=0.2,cts=1,sc """ # Set counting time: - ScalerInt(cts) + cts(acq_time) # caget beamline parameters: if scanIOC is None: diff --git a/hklpy/ScanFunctions_hkl_v2.py b/hklpy/ScanFunctions_hkl_v2.py index a0b3b5f6eb8206e966c13edb93422cfec2a51f8d..5de46408d84f46f06284d4f4bdc6590560c119e2 100644 --- a/hklpy/ScanFunctions_hkl_v2.py +++ b/hklpy/ScanFunctions_hkl_v2.py @@ -1,3 +1,9 @@ + +############################ +### old version of hklpy ### +############################ + + ####### load the hklpy package import gi gi.require_version('Hkl', '5.0') diff --git a/hklpy/Test_Bluesky_20210616.ipynb b/hklpy/TestBluesky_20210616.ipynb similarity index 100% rename from hklpy/Test_Bluesky_20210616.ipynb rename to hklpy/TestBluesky_20210616.ipynb diff --git a/hklpy/TestDet.py b/hklpy/TestDet_20210621.py similarity index 100% rename from hklpy/TestDet.py rename to hklpy/TestDet_20210621.py diff --git a/hklpy/KappaSim_hklpy.ipynb b/hklpy/TestSimhklpy_20210604.ipynb similarity index 100% rename from hklpy/KappaSim_hklpy.ipynb rename to hklpy/TestSimhklpy_20210604.ipynb diff --git a/mda/file.py b/mda/file.py new file mode 100644 index 0000000000000000000000000000000000000000..42b3d8821f730c595d65cab7a74f352befeea41e --- /dev/null +++ b/mda/file.py @@ -0,0 +1,62 @@ + +__all__ = """ + plotIOC + mda_GetLastFileNum + mda_CurrentDirectory + mda_CurrentPrefix + mda_CurrentRun + mda_CurrentUser +""".split() + +from epics import caget + + + +def plotIOC(): + BranchPV=caget("29id:CurrentBranch.VAL") + if (BranchPV == 0): + branch = "ARPES" # PV = 0 => ARPES + else: + branch = "Kappa" # PV = 1 => RSXS + return branch + +def mda_GetLastFileNum(scanIOC=None): + if scanIOC is None: + scanIOC=branchIOC() + FileNum = caget("29id"+scanIOC+":saveData_scanNumber")-1 + return FileNum + +def mda_CurrentDirectory(scanIOC=None): + if scanIOC is None: + scanIOC=branchIOC() + Dir=caget("29id"+scanIOC+":saveData_fileSystem",as_string=True) + subDir=caget("29id"+scanIOC+":saveData_subDir",as_string=True) + FilePath = Dir +'/'+subDir+"/" + if FilePath[1]=='/': + FilePath="/net"+FilePath[1:] + FilePath=FilePath.replace('//','/') + return FilePath + +def mda_CurrentPrefix(scanIOC=None): + if scanIOC is None: + scanIOC=branchIOC() + Prefix=caget("29id"+scanIOC+":saveData_baseName",as_string=True) + return Prefix + +def mda_CurrentRun(scanIOC=None): + if scanIOC is None: + scanIOC=branchIOC() + directory = MDA_CurrentDirectory(scanIOC) + m=directory.find('data_29id')+len('data_29id')+2 + current_run=directory[m:m+6] + return current_run + +def mda_CurrentUser(scanIOC=None): + if scanIOC is None: + scanIOC=branchIOC() + subdir=caget("29id"+scanIOC+":saveData_subDir",as_string=True) + m=subdir.find('/mda') + if m == 0 : current_user='Staff' + elif m > 0: current_user=subdir[1:m] + else: current_user="";print("WARNING: MDA_CurrentUser is empty string") + return current_user \ No newline at end of file