bias harmonic field both on and off to help compensate for change in position of the cathode. This data is used to determine the strength of our accelerating fields and to help determine running parameters. Example of how to use it: - Run it ''' import Master as M import Tag_Database as Tags import numpy as np import matplotlib.pyplot as plt import time time_1 = time.time() Client = M.Make_Client("10.50.0.10") M.Read(Client, Tags.WF1H ) #Arbitrary read to establish trust (I think this part is weird to me) ################################################################ ### Initialize ################################################# ################################################################ V0_resolution = 50 #Resolution of steps taken in both cutoff measurements Num_sawtooths_1 = 1 #number of points taken in the first cutoff Num_sawtooths_2 = 1 #second cutoff ################################################################ ### Grab the operator input of V0 ranges ####################### ################################################################
import sys # insert at 1, 0 is the script path (or '' in REPL) sys.path.insert(1, '..\\') import Master as M import Tag_Database_West as Tags plot_type = 'png' Tunnel, PLC_IP, os_address, Runs, Step_Size, count, Oscope = M.config_reader( 'dp1_scan_config.txt', "Dipole Scan") # print(Tunnel, PLC_IP, os_address, Runs, Step_Size, count, Oscope) # print(type(Tunnel), type(PLC_IP), type(os_address), type(Runs), type(Step_Size), type(count), type(Oscope)) Client = M.Make_Client(PLC_IP) End_Value = float( input( "What is the ending amperage that you want to ramp the magnet to? (Amps) " )) now = datetime.today().strftime( '%y%m%d_%H%M%S' ) #Taking the current time in YYMMDD_HHmm format to save the plot and the txt file #Grabbing all of our data for the system snapshot ################################################# Pulsing_Status = bool(M.Read(Client, Tags.Pulsing_Output, Bool=True)) Emission_Setpoint = M.Read(Client, Tags.Emission_Set)
#Adjust T scan Parameters Horizontal_Delta = .1 Vertical_Delta = .1 Resolution = 40 #Adjust Grid Parameters Grid_Resolution_Horizontal = 4 Grid_Resolution_Vertical = 5 #For the client IP = '192.168.1.2' Client = M.Make_Client(IP) WFH_Start = M.Read(Client, WFH_Tag) WFV_Start = M.Read(Client, WFV_Tag) ###### #Walking us to our starting point ###### for i in range(1, Grid_Resolution + 1): WFH_Write_Value = WFH_Start - i/2 * (Horizontal_Delta/Grid_Resolution) WFV_Write_Value = WFV_Start + i/2 * (Vertical_Delta/Grid_Resolution) M.Write(Client, WFH_Tag, WFH_Write_Value) M.Write(Client, WFV_Tag, WFV_Write_Value)
- Read the Starting current of the Dump - At the beginning of each run, check to insure no human intervention has occurred with the write, if it has, kill the loop, continue to produce graphs and txt file - Add the appropriate step to each magnet - Read the current many times and then take the average of that current and store it alongside the written values for the magnets - Every step of the way check if the current has dropped below a specified threshold, if it has, then walk the magnets backs where they came from by the steps taken, plus the same amount of read steps going the other way. - Repeat the same safety checks, always check each step that the current hasn't reached a lowpoint beyond the threshold - When it has, or it reaches the end, turn the magnets back around to walk back to where they started. - Repeat for the other set of magnets (Vertical) - Plot and produce txt file with Magnet settings in the left column and current readbacks in the right ''' #Establish a connection to the PLC Client = M.Make_Client('10.50.0.10') #Dog Leg Target_Tag = Tags.Recirculator_Halfway #Importing the tag value from our Tag Database Target_Tag_2 = Tags.Recirculator_Bypass Threshold_Percent = 0 #Float. The percentage of beam that we want to collect in order to turn the Dog Leg around Zoom_In_Factor = 1 #This is how much we want to zoomn in if we are interested in an artifact at the center of the dog leg or want higher precision in the center #Starting the loop to read the current collected #Take the starting value of the Target Tag, use for the threshold read_steps = 40 #Integer. Number of steps to be taken in the Dog Leg. Must be an integer count = 10 #Integer. How many points will be recorded at each step and averaged over.
import GPIB_FUNCS as GPIB #Importing our GPIB communication functions for easier comprehension and use import pyvisa #import GPIB communication module import time #imports time to sleep program temporarily import Master as M import Tag_Database as Tags Client = M.Make_Client('10.50.0.10') #Connecting to PLC print(M.Read(Client, Tags.Oscope_Reset, Bool = True)) print(M.Read(Client, Tags.Regulation_Setpoint_Reset, Bool = True)) print(M.Read(Client, Tags.Error_Signal_Regulation, Bool = True)) print(M.Read(Client, Tags.Pulsing_Output, Bool = True)) #for i in range(100): # M.Write(Client,55555, i) # print(i) # time.sleep(0.1) #Pulsing_Tag = Tags.Pulsing_Output #Assign Modbus address here Running_Tag = Tags.Error_Signal_Regulation #Assign Modbus address here #Reset_Tag = Tags.Error_Signal_Reset #Assign Modbus address here #Regulation_Setpoint_Tag = Tags.Regulation_Setpoint_Reset #Assign Modbus address here RM = pyvisa.ResourceManager() #pyVISA device manager Resources = RM.list_resources() #Printing out all detected device IDs print(Resources) SG = RM.open_resource("GPIB0::10::INSTR") OS = RM.open_resource("GPIB0::16::INSTR") time.sleep(2)
- Repeat for the other set of magnets (Vertical) - Plot and produce txt file with Magnet settings in the left column and current readbacks in the right ''' import Master as M import time import matplotlib.pyplot as plt import numpy as np from datetime import datetime import Tag_Database as Tags #Establish a connection to the PLC Client = M.Make_Client('192.168.1.6') start_time = time.time() #Dog Leg Target_Tag = Tags.RF_Beam_Mon #Int or Str. Which Tag we are reading, we are interested in the RF Beam monitor currently Threshold_Percent = 0 #Float. The percentage of beam that we want to collect in order to turn the Dog Leg around Zoom_In_Factor = 1 #This is how much we want to zoom in if we are interested in an artifact at the center of the dog leg or want higher precision in the center Scale_Factor = 1 #This is how much we want to scale off of the excel documents used prior to Dog Legs mm_factor = 1 #Starting the loop to read the current collected #Take the starting value of the Target Tag, use for the threshold
import time #imports time to sleep program temporarily import Master as M import numpy as np import Tag_Database as Tags from datetime import datetime import os def flasher(times): for _ in range(times): os.system('color DF') time.sleep(0.2) os.system('color 0F') Client = M.Make_Client('10.60.0.11') Pulsing_Tag = Tags.Pulsing_Output #Assign Modbus address here Running_Tag = Tags.Error_Signal_Regulation #Assign Modbus address here Reset_Tag = Tags.Oscope_Reset #Assign Modbus address here Regulation_Setpoint_Tag = Tags.Regulation_Setpoint_Reset #Assign Modbus address here Regulation_Entry_Tag = Tags.Regulation_Float #The input tag for this guy RM = pyvisa.ResourceManager() #pyVISA device manager Resources = RM.list_resources() #Printing out all detected device IDs print(Resources) try: SG = RM.open_resource( Resources[0]) #Opening the Signal generator as an object OS = RM.open_resource(Resources[1]) #Opening the oscilloscope as an object
) #Modbus tag numbering convention for all of these, these are the starts and steps between likewise magnets if i < WFVnum: Vnums.append(20201 + 4 * i) if i < DPnum: Dpnums.append(22201 + 2 * i) if i < Solnum: Solnums.append(21201 + 2 * i) #Reading in the excel file as a dataframe for easier access (abbreviated as df) excel_as_df = pd.read_excel( '..\Magnet Saves\{}.xlsx'.format(Notebook) ) #Using windows command line controls to direct python to the directory Client = M.Make_Client( '192.168.1.2' ) #Establishing a connection with the PLC, see Master.Make_Client for i in range( len(Hnums)): #Iterate through the list of Horizontal window frames print("Window Frame {} H".format(i + 1), Hnums[i], excel_as_df['WF H'].iloc[i]) #Print which magnet it is ramping M.Ramp_One_Way(Client, Hnums[i], excel_as_df['WF H'].iloc[i], Max_Step=0.010) #Ramp that magnet, see Master.Ramp_One_Way #Repeat for all types of magnets for i in range(len(Vnums)): print("Window Frame {} V".format(i + 1), Vnums[i], excel_as_df['WF V'].iloc[i]) M.Ramp_One_Way(Client,
- Run it ******* Changes to Master File -- Gather() added inital_values for speed ******* Changes to Tag Database -- Added BH Pf slider bar params (bottom) ''' import Master as M import Tag_Database as Tags import numpy as np import matplotlib.pyplot as plt import time from datetime import datetime time_1 = time.time() Client = M.Make_Client("10.60.0.11") M.Read(Client, Tags.WF1H ) #Arbitrary read to establish trust (I think this part is weird to me) ################################################################ ### Initialize ################################################# ################################################################ number_of_points = 50 #Resolution of steps taken in both cutoff measurements Num_sawtooths_1 = 6 #number of points taken in the first cutoff Num_sawtooths_2 = 6 #second cutoff Ratio_From_Start = 0.8 #The amount to move the slider bar back up after running ################################################################ ### Grab the operator input of V0 ranges ####################### ################################################################
import time import os import numpy as np import Master as M #importing the PLC communications library ############################# ## Connect to PLC, define Modbus addresses ############################# PLC_IP = "10.1.2.100" Amp_IP = '10.1.2.125' Sleep_Check_Time = 10 #Seconds try: Client = M.Make_Client(PLC_IP) #Connecting to PLC except: print("Connection to PLC Failed") print("Waiting...") time.sleep(Sleep_Check_Time) try: Client = M.Make_Client(PLC_IP) except: print("Connection after {} seconds failed. Ending script...".format( Sleep_Check_Time)) time.sleep(10) exit() #Convert amp forward power from percent to Watts Conversion_Rate = 50
Points = 3000 Dipole_Amplitude = 5 #(Amps) The value we want Dipoles to reach in the peak #This can also be set to the start value if need be Frequency = 5 #Increase this value for more oscillations WF_Amplitude = 3 #(Amps) Sol_Amplitude = 4 #(Amps) ###################################### #PLC Parameters ###################################### Client = M.Make_Client("192.168.1.2") Dipole_Start_Tag = Tags.DP1 #First Dipole we are controlling Window_Frame_Start_Tag = Tags.WF1V #First Window Frame we are controlling Solenoid_Start_Tag = Tags.Sol1 #First Solenoid we are controlling Dipole_Count = 2 #Number of Dipoles Window_Frame_Count = 7 #Number of Window Frames Solenoid_Count = 3 #Number of Solenoids (Not used currently) Start_Time = time.time()
- Read the Starting current of the Dump - At the beginning of each write, check to insure no human intervention has occurred with the write, if it has, kill the loop, continue to produce graphs and txt file - Add the appropriate step to each magnet - Read the current many times and then take the average of that current and store it alongside the written values for the magnets - Every step of the way check if the current has dropped below a specified threshold, if it has, then walk the magnets backs where they came from by the steps taken, plus the same amount of read steps going the other way. - Repeat the same safety checks, always check each step that the current hasn't reached a lowpoint beyond the threshold - When it has, or it reaches the end, turn the magnets back around to walk back to where they started. - Repeat for the other set of magnets (Vertical) - Plot and produce txt file with Magnet settings in the left column and current readbacks in the right ''' #Establish a connection to the PLC Client = M.Make_Client('') start_time = time.time() #Dog Leg Target_Tag = Tags.Recirculator_Halfway #Int or Str. Which Tag we are reading, 11109 is Loop bypass dump as of 01/01/2020 Target_Tag_2 = Tags.Recirculator_Bypass Threshold_Percent = 20 #Float. The percentage of beam that we want to collect in order to turn the Dog Leg around Zoom_In_Factor = 1 #This is how much we want to zoomn in if we are interested in an artifact at the center of the dog leg or want higher precision in the center Scale_Factor = 0.91 #This is how much we want to scale off of the excel documents used prior to Dog Legs #Starting the loop to read the current collected #Take the starting value of the Target Tag, use for the threshold
import GPIB_FUNCS as GPIB #Importing our GPIB communication functions for easier comprehension and use import pyvisa #import GPIB communication module import time #imports time to sleep program temporarily import Master as M import Tag_Database as Tags Client = M.Make_Client('10.60.0.11') #Connecting to PLC print(M.Read(Client, Tags.Oscope_Reset, Bool=True)) print(M.Read(Client, Tags.Regulation_Setpoint_Reset, Bool=True)) print(M.Read(Client, Tags.Error_Signal_Regulation, Bool=True)) print(M.Read(Client, Tags.Pulsing_Output, Bool=True)) #for i in range(100): # M.Write(Client,55555, i) # print(i) # time.sleep(0.1) #Pulsing_Tag = Tags.Pulsing_Output #Assign Modbus address here Running_Tag = Tags.Error_Signal_Regulation #Assign Modbus address here #Reset_Tag = Tags.Error_Signal_Reset #Assign Modbus address here #Regulation_Setpoint_Tag = Tags.Regulation_Setpoint_Reset #Assign Modbus address here RM = pyvisa.ResourceManager() #pyVISA device manager Resources = RM.list_resources() #Printing out all detected device IDs print(Resources) SG = RM.open_resource(Resources[0]) time.sleep(2) print("SG \n", SG.query("*IDN?")) print("OS \n", OS.query("*IDN?"))