# -*- coding: utf-8 -*- """ Created on 29.10.2024, 09:00 hrs LC Controller measurement script @author: Serdar, adjusted by Lukas and Ryan """ ############################################ # Packages from Ryan import re import math import threading import pyvisa import time # from pyvisa import ResourceManager, constants # NOTE: KLCCommandLib64.py must be in the same folder as this script! try: from KLCCommandLib64 import * except OSError as ex: print("Warning:",ex) # TODO: add LC Controller limits as constants, as not to be exceeded ############################################ import AMC import csv import time import clr import sys import os import spe2py as spe import spe_loader as sl import pandas as pd import time from System.IO import * from System import String import numpy as np import matplotlib.pyplot as plt import datetime from typing import Union # NOTE: this is possibly not needed, remove later #First choose your controller IP_AMC300 = "192.168.1.1" IP_AMC100 = "192.168.71.100" # IP = "192.168.1.1" IP = IP_AMC100 # Import os module import os, glob, string # Import System.IO for saving and opening files from System.IO import * from System.Threading import AutoResetEvent # Import C compatible List and String from System import String from System.Collections.Generic import List # Add needed dll references sys.path.append(os.environ['LIGHTFIELD_ROOT']) sys.path.append(os.environ['LIGHTFIELD_ROOT']+"\\AddInViews") sys.path.append(r'C:\Program Files\Princeton Instruments\LightField\AddInViews') #I added them by hand -serdar sys.path.append(r'C:\Program Files\Princeton Instruments\LightField') #this one also clr.AddReference('PrincetonInstruments.LightFieldViewV5') clr.AddReference('PrincetonInstruments.LightField.AutomationV5') clr.AddReference('PrincetonInstruments.LightFieldAddInSupportServices') os.environ['LIGHTFIELD_ROOT'] = r'C:\Program Files\Princeton Instruments\LightField' # PI imports from PrincetonInstruments.LightField.Automation import Automation from PrincetonInstruments.LightField.AddIns import ExperimentSettings from PrincetonInstruments.LightField.AddIns import CameraSettings #from PrincetonInstruments.LightField.AddIns import DeviceType from PrincetonInstruments.LightField.AddIns import SpectrometerSettings from PrincetonInstruments.LightField.AddIns import RegionOfInterest ######################################################################################################### code begins from here ############################################# def set_custom_ROI(): # Get device full dimensions dimensions = experiment.FullSensorRegion() regions = [] # Add two ROI to regions regions.append( RegionOfInterest( int(dimensions.X), int(dimensions.Y), int(dimensions.Width), int(dimensions.Height//4), # Use // for integer division int(dimensions.XBinning), int(dimensions.Height//4))) # Set both ROI experiment.SetCustomRegions(regions) def experiment_completed(sender, event_args): #callback function which is hooked to event completed, this is the listener print("... Acquisition Complete!") acquireCompleted.Set() #set the event. This puts the autoresetevent false.(look at .NET library for furher info) def InitializerFilenameParams(): experiment.SetValue(ExperimentSettings.FileNameGenerationAttachIncrement, False) experiment.SetValue(ExperimentSettings.FileNameGenerationIncrementNumber, 1.0) experiment.SetValue(ExperimentSettings.FileNameGenerationIncrementMinimumDigits, 2.0) experiment.SetValue(ExperimentSettings.FileNameGenerationAttachDate, False) experiment.SetValue(ExperimentSettings.FileNameGenerationAttachTime, False) def AcquireAndLock(name): print("Acquiring...", end = "") # name += 'Exp{0:06.2f}ms.CWL{1:07.2f}nm'.format(\ # experiment.GetValue(CameraSettings.ShutterTimingExposureTime)\ # ,experiment.GetValue(SpectrometerSettings.GratingCenterWavelength)) experiment.SetValue(ExperimentSettings.FileNameGenerationBaseFileName, name) #this creates .spe file with the name experiment.Acquire() # this is an ashynrchronus func. acquireCompleted.WaitOne() def calculate_distance(x1, y1, x2, y2): return np.sqrt((x2 - x1)**2 + (y2 - y1)**2) def generate_scan_positions(center, range_val, resolution): positive_range = np.arange(center, center + range_val + resolution, resolution) return positive_range def save_as_csv(filename, position_x, position_y): file_existance = os.path.isfile(filename) with open(filename, 'a', newline = '') as csvfile: writer = csv.writer(csvfile) if not file_existance: writer.writerow(['x_coordinates','y_coordinates']) writer.writerow([position_x, position_y]) # def move_axis(axis, target): # """ # This function moves an axis to the specified target and stop moving after it is in the really closed # vicinity (+- 25nm) of the target (listener hooked to it). # """ # amc.move.setControlTargetPosition(axis, target) # amc.control.setControlMove(axis, True) # while not (target - 25) < amc.move.getPosition(axis) < (target + 25): # time.sleep(0.1) # time.sleep(0.15) # while not (target - 25) < amc.move.getPosition(axis) < (target + 25): # time.sleep(0.1) # amc.control.setControlMove(axis, False) # def move_xy(target_x, target_y): # moving in x and y direction closed to desired position # amc.move.setControlTargetPosition(0, target_x) # amc.control.setControlMove(0, True) # amc.move.setControlTargetPosition(1, target_y) # amc.control.setControlMove(1, True) # while not (target_x - 25) < amc.move.getPosition(0) < (target_x + 25) and (target_y - 25) < amc.move.getPosition(1) < (target_y + 25): # time.sleep(0.1) # time.sleep(0.15) # while not (target_x - 25) < amc.move.getPosition(0) < (target_x + 25) and (target_y - 25) < amc.move.getPosition(1) < (target_y + 25): # time.sleep(0.1) # amc.control.setControlOutput(0, False) # amc.control.setControlOutput(1, False) # intensity_data = [] # To store data from each scan # data_list = [] # def move_scan_xy(range_x, range_y, resolution, Settings, baseFileName): # """ # This function moves the positioners to scan the sample with desired ranges and resolution in 2 dimensions. # At the end it saves a csv file # Parameters # ---------- # range_x : integer in nm. max value is 5um # Scan range in x direction. # range_y : integer in nm. max value is 5um # Scan range in y direction. # resolution : integer in nm. # Room temprature max res is 50nm. In cyrostat (4K) it is 10nm (check the Attocube manual) # baseFileName: string. At the end the saved file will be: baseFileName_scan_data.csv and it will be saved to the current directory # Returns # ------- # None. # """ # start_time = time.time() # axis_x = 0 #first axis # axis_y = 1 #second axis # center_x = amc.move.getPosition(axis_x) # center_y = amc.move.getPosition(axis_y) # # #check if the intput range is reasonable # # if amc.move.getPosition(axis_x) + range_x >= 5000 or amc.move.getPosition(axis_x)- range_x <= 0 or amc.move.getPosition(axis_y) + range_y >=5000 or amc.move.getPosition(axis_y) - range_y <= 5000 : # # print("scan range is out of range!") # # return # # +- range from current positions for x and y directions # array_x = generate_scan_positions(center_x, range_x, resolution) # array_y = generate_scan_positions(center_y, range_y, resolution) # total_points = len(array_x)*len(array_y) # len_y = len(array_y) # intensity_data = [] # To store data from each scan # data_list = [] # cwd = os.getcwd() # save original directory # #This gives a directory, in which the script will save the spectrum of each spot as spe # #However, it will open the spectrum, convert it to txt, add it to the intensity_data and delete the spe file # temp_folder_path = "C:/Users/localadmin/Desktop/Users/Lukas/2024_02_08_Map_test" # #scanning loop # for i, x_positions in enumerate(array_x): # move_axis(axis_x, x_positions) # y = False # for j, y_positions in enumerate(array_y): # move_axis(axis_y, y_positions) # #each time when the positioner comes to the beggining of a new line # #this if will make the positioner wait a bit longer to really go to the target. # if y == False: # move_axis(axis_y, y_positions) # y = True # #we acquire with the LF # acquire_name_spe = f'{baseFileName}_X{x_positions}_Y{y_positions}' # AcquireAndLock(acquire_name_spe) #this creates a .spe file with the scan name. # #read the .spe file and get the data as loaded_files # cwd = os.getcwd() # save original directory # os.chdir(temp_folder_path) #change directory # loaded_files = sl.load_from_files([acquire_name_spe + '.spe']) # get the .spe file as a variable # os.chdir(cwd) # go back to original directory # # Delete the created .spe file from acquiring after getting necessary info # spe_file_path = os.path.join(temp_folder_path, acquire_name_spe + '.spe') # os.remove(spe_file_path) # distance = calculate_distance(x_positions, y_positions,amc.move.getPosition(axis_x), amc.move.getPosition(axis_y)) # points_left = total_points - (i * len_y + (j+1)) + 1 # print('Points left in the scan: ', points_left) # #append the intensity data as it is (so after every #of_wl_points, the spectrum of the next point begins) # intensity_data.append(loaded_files.data[0][0][0]) # data_list.append({ # 'position_x': x_positions, # 'position_y': y_positions, # 'actual_x': amc.move.getPosition(axis_x), # 'actual_y': amc.move.getPosition(axis_y), # 'distance': distance, # }) # #moves back to starting position # move_axis(axis_x, center_x) # move_axis(axis_y, center_y) # #prints total time the mapping lasted # end_time = time.time() # elapsed_time = (end_time - start_time) / 60 # print('Scan time: ', elapsed_time, 'minutes') # # df = pd.DataFrame(data_list) # #save intensity & WL data as .txt # os.chdir('C:/Users/localadmin/Desktop/Users/Lukas') # # creates new folder for MAP data # new_folder_name = "Test_Map_" + f"{datetime.datetime.now().strftime('%Y_%m_%d_%H.%M')}" # os.mkdir(new_folder_name) # # Here the things will be saved in a new folder under user Lukas ! # # IMPORTANT last / has to be there, otherwise data cannot be saved and will be lost!!!!!!!!!!!!!!!! # os.chdir('C:/Users/localadmin/Desktop/Users/Lukas/'+ new_folder_name) # intensity_data = np.array(intensity_data) # np.savetxt(Settings + str(center_x) + '_' + str(center_y) + experiment_name +'.txt', intensity_data) # wl = np.array(loaded_files.wavelength) # np.savetxt("Wavelength.txt", wl) ################################################################# RYAN'S FUNCTIONS HERE ########################################################################################## def polar_to_cartesian(radius, start_angle, end_angle, step_size, clockwise=True): # TODO: DOCS """Creates a list of discrete cartesian coordinates (x,y), given the radius, start- and end angles, the angle step size, and the direction of rotation. Function then returns a list of two lists: list of angles and list of cartesian coordinates (x,y coordinates in a tuple). Args: radius (_type_): _description_ start_angle (_type_): _description_ end_angle (_type_): _description_ step_size (_type_): _description_ clockwise (bool, optional): _description_. Defaults to True. Returns: _type_: _description_ """ """""" # Initialize lists to hold angles and (x, y) pairs angles = [] coordinates = [] # Normalize angles to the range [0, 360) start_angle = start_angle % 360 end_angle = end_angle % 360 if clockwise: # Clockwise rotation current_angle = start_angle while True: # Append the current angle to the angles list angles.append(current_angle % 360) # Convert the current angle to radians current_angle_rad = math.radians(current_angle % 360) # Convert polar to Cartesian coordinates x = radius * math.cos(current_angle_rad) y = radius * math.sin(current_angle_rad) # Append the (x, y) pair to the list coordinates.append((x, y)) # Check if we've reached the end_angle (handling wrap-around) (current_angle - step_size) % 360 == end_angle or if current_angle % 360 == end_angle: break # Decrement the current angle by the step size current_angle -= step_size if current_angle < 0: current_angle += 360 else: # Counterclockwise rotation current_angle = start_angle while True: # Append the current angle to the angles list angles.append(current_angle % 360) # Convert the current angle to radians current_angle_rad = math.radians(current_angle % 360) # Convert polar to Cartesian coordinates x = radius * math.cos(current_angle_rad) y = radius * math.sin(current_angle_rad) # Append the (x, y) pair to the list coordinates.append((x, y)) # Check if we've reached the end_angle (handling wrap-around) (current_angle + step_size) % 360 == end_angle or if current_angle % 360 == end_angle: break # Increment the current angle by the step size current_angle += step_size if current_angle >= 360: current_angle -= 360 return [angles, coordinates] ################################################################# DASHA'S CODE HERE ############################################################################################## # TODO: modify b field scan script for Dasha, to be used for the KLC controller def LCR_scan_func(instr:KLC, min_bval:float, max_bval:float, res:float, magnet_coil:str, Settings:str, base_file_name='', reversescan_bool=False, zerowhenfin_bool=False, loopscan_bool=False)->None: def pyramid_list(lst) -> Union[list, np.ndarray]: """reverses the list and removes the first element of reversed list. Then, this is appended to the end of the original list and returned as the 'pyramid' list. Args: lst (list or np.ndarray): Raises: TypeError: if the input object isn't a list or np.ndarray Returns: Union[list, np.ndarray]: the pyramid list """ '''''' if isinstance(lst, list): return lst + lst[-2::-1] elif isinstance(lst, np.ndarray): return np.append(lst, lst[-2::-1]) else: raise TypeError('Please input a list!') # defines the folder, in which the data from the spectrometer is temporarily stored in temp_folder_path = "C:/Users/localadmin/Desktop/Users/Lukas/2024_02_08_Map_test" # if path_save =='': # path_save = datetime.datetime.now().strftime("%Y_%m_%d_%H%M_hrs_") if base_file_name =='': base_file_name = datetime.datetime.now().strftime('%Y_%m_%d_%H.%M') start_time = time.time() # start of the scan function instr_info = query_no_echo(instr, '*IDN?') instr_bsettings = list(sep_num_from_units(el) for el in query_no_echo(instr, 'UNITS?;LLIM?;ULIM?').split(';')) # deliver a 3 element list of lists containing the set unit, llim and ulim if instr_bsettings[0][0] == 'T': instr_bsettings[1][0] = instr_bsettings[1][0]*0.1 # rescale kG to T, device accepts values only in kG or A, eventho we set it to T instr_bsettings[2][0] = instr_bsettings[2][0]*0.1 # if singlepowersupply_bool: # checks limits of Bx or By # if (min_bval< -BY_MAX) or (max_bval > BY_MAX): # raise ValueError('Input limits exceed that of the magnet By! Please input smaller limits.') # elif '1' in query_no_echo(instr, 'CHAN?'): # check if its the coils for Bz # if (min_bval < -BZ_MAX) or (max_bval > BZ_MAX): # raise ValueError('Input limits exceed that of the magnet (Bz)! Please input smaller limits.') # else: # checks limits of Bx # if (min_bval< -BX_MAX) or (max_bval > BX_MAX): # raise ValueError('Input limits exceed that of the magnet Bx! Please input smaller limits.') if '2101014' in instr_info and (magnet_coil=='y-axis'): # single power supply if (min_bval< -BY_MAX) or (max_bval > BY_MAX): raise ValueError('Input limits exceed that of the magnet By! Please input smaller limits.') elif '2301034' in instr_info: # dual power supply if magnet_coil=='z-axis': # check if its the coils for Bz if (min_bval < -BZ_MAX) or (max_bval > BZ_MAX): raise ValueError('Input limits exceed that of the magnet (Bz)! Please input smaller limits.') write_no_echo(instr, 'CHAN 1') elif magnet_coil=='x-axis': # checks limits of Bx if (min_bval< -BX_MAX) or (max_bval > BX_MAX): raise ValueError('Input limits exceed that of the magnet Bx! Please input smaller limits.') write_no_echo(instr, 'CHAN 2') else: raise ConnectionError('Device is not connected!') write_no_echo(instr, f'LLIM {min_bval*10};ULIM {max_bval*10}') # sets the given limits, must convert to kG for the device to read bval_lst = np.arange(min_bval, max_bval + res, res) # creates list of B values to measure at, with given resolution, in T # TODO: unused, see if can remove # init_bval = sep_num_from_units(query_no_echo(instr, 'IMAG?'))[0]*0.1 # queries the initial B value of the coil, rescale from kG to T init_lim, subsequent_lim = 'LLIM', 'ULIM' init_sweep, subsequent_sweep = 'DOWN', 'UP' #################################################### # TODO: decide whether to start at min b val or max b val, depending on which one is nearer, IMPLEMENT THIS LATER # nearest_bval = (abs(init_bval - min_bval), abs(init_bval - max_bval)) # if nearest_bval[0] <= nearest_bval[1]: # reversescan_bool = True #################################################### # if reverse scan, then flip the values in the b list, and swap the initial limit and sweep conditions if reversescan_bool: bval_lst = bval_lst[::-1] init_lim, subsequent_lim = subsequent_lim, init_lim init_sweep, subsequent_sweep = subsequent_sweep, init_sweep # creates the pyramid list of B vals if one were to perform a hysteresis measurement if loopscan_bool: bval_lst = pyramid_list(bval_lst) total_points = len(bval_lst) middle_index_bval_lst = total_points // 2 intensity_data = [] # To store data from each scan cwd = os.getcwd() # save original directory # NOTE: helper function for the scanning loop def helper_scan_func(idx, bval, instr=instr, init_lim=init_lim, init_sweep=init_sweep, subsequent_lim=subsequent_lim, subsequent_sweep=subsequent_sweep, sleep=5): if idx == 0: # for first iteration, sweep to one of the limits write_no_echo(instr, f'{init_lim} {bval*10}') # convert back to kG write_no_echo(instr, f'SWEEP {init_sweep}') else: write_no_echo(instr, f'{subsequent_lim} {bval*10}') # convert back to kG write_no_echo(instr, f'SWEEP {subsequent_sweep}') actual_bval = sep_num_from_units(query_no_echo(instr, 'IMAG?'))[0]*0.1 # convert kG to T print(f'Actual magnet strength: {actual_bval} T,', f'Target magnet strength: {bval} T') while abs(actual_bval - bval) > 0.0001: time.sleep(5) # little break actual_bval = sep_num_from_units(query_no_echo(instr, 'IMAG?'))[0]*0.1 # update the actual bval print(f'Actual magnet strength: {actual_bval} T,', f'Target magnet strength: {bval} T') #scanning loop for i, bval in enumerate(bval_lst): if not loopscan_bool: helper_scan_func(i, bval) else: if i <= middle_index_bval_lst: helper_scan_func(i, bval) else: helper_scan_func(i, bval, instr=instr, init_lim=subsequent_lim, init_sweep=subsequent_sweep, subsequent_lim=init_lim, subsequent_sweep=init_sweep, sleep=5) time.sleep(5) # we acquire with the LF acquire_name_spe = f'{base_file_name}_{bval}T' AcquireAndLock(acquire_name_spe) #this creates a .spe file with the scan name. # read the .spe file and get the data as loaded_files cwd = os.getcwd() # save original directory os.chdir(temp_folder_path) #change directory loaded_files = sl.load_from_files([acquire_name_spe + '.spe']) # get the .spe file as a variable os.chdir(cwd) # go back to original directory # Delete the created .spe file from acquiring after getting necessary info spe_file_path = os.path.join(temp_folder_path, acquire_name_spe + '.spe') os.remove(spe_file_path) points_left = total_points - i - 1 # TODO: SEE IF THIS IS CORRECT print('Points left in the scan: ', points_left) #append the intensity data as it is (so after every #of_wl_points, the spectrum of the next point begins) intensity_data.append(loaded_files.data[0][0][0]) #prints total time the mapping lasted end_time = time.time() elapsed_time = (end_time - start_time) / 60 print('Scan time: ', elapsed_time, 'minutes') write_no_echo(instr, f'LLIM {instr_bsettings[1][0]*10};ULIM {instr_bsettings[2][0]*10}') # reset the initial limits of the device after the scan if zerowhenfin_bool: write_no_echo(instr, 'SWEEP ZERO') # if switched on, discharges the magnet after performing the measurement loop above #save intensity & WL data as .txt os.chdir('C:/Users/localadmin/Desktop/Users/Lukas') # creates new folder for MAP data new_folder_name = "Test_Map_" + f"{datetime.datetime.now().strftime('%Y_%m_%d_%H.%M')}" os.mkdir(new_folder_name) # Here the things will be saved in a new folder under user Lukas ! # IMPORTANT last / has to be there, otherwise data cannot be saved and will be lost!!!!!!!!!!!!!!!! os.chdir('C:/Users/localadmin/Desktop/Users/Lukas/'+ new_folder_name) intensity_data = np.array(intensity_data) np.savetxt(Settings + str(min_bval) + 'T_to_' + str(max_bval) + 'T' + experiment_name +'.txt', intensity_data) wl = np.array(loaded_files.wavelength) np.savetxt("Wavelength.txt", wl) ################################################################# END OF FUNCTION DEFS ########################################################################################### # NOTE: RYAN INTRODUCED SOME FUNCTIONS HERE TO PERFORM THE SCAN try: # initialise KLC connection #Find devices devs = klcListDevices() print("Found devices:",devs,"\n") if(len(devs)<=0): print('There is no device connected') sys.exit() klc = devs[0] serialnumber = klc[0] #Connect device KLC_handle = klcOpen(serialnumber, 115200, 3) if(KLC_handle<0): print("open ", serialnumber, " failed") sys.exit() if(klcIsOpen(serialnumber) == 0): print("klcIsOpen failed") klcClose(KLC_handle) sys.exit() print("Connected to serial number ", serialnumber) # TODO: continue editing the code below this # Initialise PYVISA ResourceManager rm = pyvisa.ResourceManager() # print(rm.list_resources()) # 'ASRL8::INSTR' for dual power supply, 'ASRL9::INSTR' for single power supply (online PC) # 'ASRL10::INSTR' for dual power supply, 'ASRL12::INSTR' for single power supply (offline PC) auto = Automation(True, List[String]()) experiment = auto.LightFieldApplication.Experiment acquireCompleted = AutoResetEvent(False) experiment.Load("Lukas_experiment_2024_02_06") experiment.ExperimentCompleted += experiment_completed # we are hooking a listener. # experiment.SetValue(SpectrometerSettings.GratingSelected, '[750nm,1200][0][0]') # InitializerFilenameParams() #set scan range and resolution in nanometers range_x = 20000 range_y = 20000 resolution = 1000 # set B-field scan range and resolution (all in T) set_llim_bval = -0.01 set_ulim_bval = 0.01 set_res_bval = 0.01 # TODO: add the start-, end angles, as well as angle step size here (alternatively, add it above) #Here you can specify the filename of the map e.g. put experiment type, exposure time, used filters, etc.... experiment_settings = 'PL_SP_700_LP_700_HeNe_52muW_exp_2s_Start_' #The program adds the range of the scan as well as the resolution and the date and time of the measurement experiment_name = f"{set_llim_bval}T_to_{set_ulim_bval}T_{set_res_bval}T_{datetime.datetime.now().strftime('%Y_%m_%d_%H%M')}" # TODO: insert LCR rotation scan function here except Exception() as e: print(e) finally: #close connection to device klcClose(KLC_handle) print("Connection closed")