LCRControllerCode/Dasha_LCRCode.py

# -*- 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)

# Maximum output voltage
V_MAX = 25  # corresponds to the max RMS voltage of 25 V of KLC101 device
# NOTE: AC output of KLC101 is a square wave, RMS = Amplitude

############################################

# import AMC  # TODO: removed, this package only relevant for the positioner in the 1000 cryostat
import csv
import time
import clr
import sys
import os, glob, string
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 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])

################################################################# RYAN'S FUNCTIONS HERE ##########################################################################################

# NOTE: leave this function here, could be useful for future uses
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 ##############################################################################################

# NOTE: all voltage values are the RMS values, and have the unit V
def LCR_scan_func(handle:int, init_voltage:float, final_voltage:float, 
                res:float, base_file_name='', folder_name='',
                reversescan_bool=False, zerowhenfin_bool=True, loopscan_bool=False)->None:
    # TODO: docstring
    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/Dasha/LCR_temp_dump_folder"
    
    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

    # Check if the given start and/or end voltages are within the accepted limits
    if (init_voltage >= V_MAX):
        raise ValueError('Maximum device voltage exceeded! Please input a smaller initial voltage!')
    elif (end_voltage >= V_MAX):
        raise ValueError('Maximum device voltage exceeded! Please input a smaller final voltage!')
    elif (res >= V_MAX):
        raise ValueError('Entered step size exceeds 25 V! Please choose a smaller step size!')

    # creates list of voltage values to measure at, with given resolution, in V
    voltage_lst = np.arange(init_voltage, final_voltage + res, res)
    
    # if reverse scan, flips the direction of the scan
    if reversescan_bool:
        voltage_lst = voltage_lst[::-1]

    # creates the pyramid list of B vals if one were to perform a hysteresis measurement 
    if loopscan_bool:
        voltage_lst = pyramid_list(voltage_lst)

    total_points = len(voltage_lst)
    middle_index_voltage_lst = total_points // 2
    intensity_data = []  # To store data from each scan
    cwd = os.getcwd() # save original directory

    # helper function for the scanning loop
    def helper_scan_func(idx, voltage_val, instr=handle, sleep=0.5):  # TODO: idx argument possibly redundant for Dasha's code
        # TODO: docstring
        # => enable V1 preset => set voltage for V1 preset
        klcSetChannelEnable(instr, 1)
        # initialise actual_voltage_val variable
        actual_voltage_val = [0]
        klcGetVoltage1(instr, actual_voltage_val)
        print(f'Actual output voltage: {actual_voltage_val[0]} V,', f'Target output voltage: {voltage_val} V')
        klcSetVoltage1(instr, voltage_val)

        while abs(actual_voltage_val[0] - voltage_val) > 0.0005:  # check if target voltage is reached, if not, wait   
            time.sleep(sleep)  # little break
            klcGetVoltage1(instr, actual_voltage_val)  # update the actual voltage
            print(f'Actual output voltage: {actual_voltage_val[0]} V,', f'Target output voltage: {voltage_val} V')
    
    #scanning loop
    for i, bval in enumerate(voltage_lst):
        if not loopscan_bool:
            helper_scan_func(i, bval)
        else:
            if i <= middle_index_voltage_lst:
                helper_scan_func(i, bval)
            else:
                helper_scan_func(i, bval)
        
        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
        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')

    if zerowhenfin_bool:
        klcSetVoltage1(handle, 0)  # sets V1 channel voltage to 0 V
        klcSetChannelEnable(handle, 0)  # disables channel output
   
    #save intensity & WL data as .txt
    os.chdir('C:/Users/localadmin/Desktop/Users/Dasha')
    # creates new folder for MAP data
    if folder_name == '':
        folder_name = f"{datetime.datetime.now().strftime('%Y_%m_%d_%H.%M')}"
    else:
        folder_name = f"{datetime.datetime.now().strftime('%Y_%m_%d_%H.%M')}_" + folder_name
    
    os.mkdir(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/Dasha/'+ folder_name)
    
    intensity_data = np.array(intensity_data) 
    np.savetxt(base_file_name + '.txt', intensity_data)
            
    wl = np.array(loaded_files.wavelength)
    np.savetxt("Wavelength.txt", wl)

################################################################# END OF FUNCTION DEFS ###########################################################################################

# ENTER START AND END VOLTAGES, AS WELL AS VOLTAGE STEP SIZE HERE
start_voltage = 0
end_voltage = 0.5
voltage_stepsize = 0.25

# ENTER FILE NAME HERE (experiment settings + voltage range, stepsize, actual time)
#Here you can specify the filename of the map e.g. put experiment type, exposure time, used filters, etc....
experiment_settings = 'Test settings'
#The program adds the range of the scan as well as the resolution and the date and time of the measurement
experiment_name = experiment_settings + f"{start_voltage}V_to_{end_voltage}V_{voltage_stepsize}V_{datetime.datetime.now().strftime('%Y_%m_%d_%H%M')}"

# ENTER FOLDER NAME HERE, TO WHICH THE EXP. DATA IS TO BE STORED IN
# NOTE: This folder name is in the path 'C:/Users/localadmin/Desktop/Users/Dasha/'
# suited for Dasha's uses 
experiment_folder_name = 'Test_folder'

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]  # devs is a list of 2-element lists, in which the serial-nr. and device name are contained 
    serialnumber = klc[0]
    
    # Connect device
    KLC_handle = klcOpen(serialnumber, 115200, 3)  # baud rate and timeout(in s)
    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)

    # Enable global output
    # TODO: idk why disable output then only enable, maybe remove later on
    klcSetEnable(KLC_handle,1)  # 1 enable, 2 disable
    print("Enable output\n")
    if(klcSetEnable(KLC_handle, 1)<0):  # 1 enable, 2 disable
        print("klcSetEnable failed")
    en=[0]
    if(klcGetEnable(KLC_handle, en)<0):  # check if the set enable fucntion was called successfully
        print("klcGetEnable failed")

    auto = Automation(True, List[String]())
    experiment = auto.LightFieldApplication.Experiment
    acquireCompleted = AutoResetEvent(False)

    experiment.Load("Alison_08.07.24")  # NOTE: this should be the 
    experiment.ExperimentCompleted += experiment_completed  # we are hooking a listener.
    # experiment.SetValue(SpectrometerSettings.GratingSelected, '[750nm,1200][0][0]')
    # InitializerFilenameParams()
    # TODO: find out what these two lines of code do, leave commented as of (31.10.2024)

    LCR_scan_func(handle=KLC_handle, init_voltage=start_voltage, final_voltage=end_voltage, res=voltage_stepsize,
                  base_file_name=experiment_name, folder_name=experiment_folder_name)

except Exception() as e:
    print(e)
finally: 
    #close connection to device
    klcClose(KLC_handle)
    print("Connection closed")