def __init__(self, datadir="data", outlabel="gainMeasurement"): self.outpathlabel = os.path.join(datadir, outlabel) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 self.cppfr = CPP_FILE_RUNNER() #misc variables self.gain = 0 self.shape = 0 self.base = 0 #json output, note module version number defined here self.jsondict = {'type':'quadFeAsic_gain_fpgadac'} self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date)
def __init__(self, datadir="data", outlabel="simpleMeasurement", wib=0, fembNum=0): #set internal variables self.datadir = datadir self.outlabel = outlabel + str("_femb_") + str(fembNum + 4 * wib) self.outpathlabel = os.path.join(self.datadir, self.outlabel) self.fembNum = int(fembNum) print("Test type\t" + str(self.outlabel)) print("Data path\t" + str(datadir)) print("FEMB #\t" + str(self.fembNum)) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 9014 self.cppfr = CPP_FILE_RUNNER() #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 #json output, note module version number defined here self.jsondict = {'type': 'fembTest_simple'} self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date)
def __init__(self, datadir="data", outlabel="simpleMeasurement", asicnum=0, isCold=False): #set internal variables self.datadir = datadir self.outlabel = outlabel + str("_asic_") + str(asicnum) self.outpathlabel = os.path.join(self.datadir, self.outlabel) self.asicnum = int(asicnum) print("Test type\t" + str(self.outlabel)) print("Data path\t" + str(datadir)) print("ASIC socket #\t" + str(self.asicnum)) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) self.cppfr = CPP_FILE_RUNNER() #set appropriate UDP packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #should be larger than largest expected packet size #set test module status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 self.isCold = isCold #define json output self.jsondict = {'type': 'quadAdcTest_simple'} #self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date) self.jsondict['asicnum'] = str(self.asicnum)
def __init__(self, datadir="data", outlabel="funcgenMeasurement", asicnum=0, doReconfig=True, doLongRamp=False, isExternalClock=True, is1MHzSAMPLERATE=True, isCold=False): #set internal variables self.datadir = datadir self.outlabel = outlabel + str("_asic_") + str(asicnum) self.outpathlabel = os.path.join(self.datadir, self.outlabel) self.asicnum = int(asicnum) print("Test type\t" + str(self.outlabel)) print("Data path\t" + str(datadir)) print("ASIC socket #\t" + str(self.asicnum)) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) self.cppfr = CPP_FILE_RUNNER() self.funcgen = Keysight_33600A("/dev/usbtmc0", 1) #hardcoded to usbtmc0 #set appropriate UDP packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #should be larger than largest expected packet size #set test module status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 #assign input to test and config module internal variables self.doReconfig = doReconfig self.doLongRamp = doLongRamp self.isExternalClock = isExternalClock self.is1MHzSAMPLERATE = is1MHzSAMPLERATE self.isCold = isCold self.femb_config.isExternalClock = self.isExternalClock #False = internal monostable, True = external self.femb_config.is1MHzSAMPLERATE = self.is1MHzSAMPLERATE #False = 1MHz, True = 2MHz self.femb_config.COLD = self.isCold self.femb_config.enableTest = 1 # 0 = no test input, 1 = enabled #define json output self.jsondict = {'type': 'quadAdcTest_funcgen'} #self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date) self.jsondict['asicnum'] = str(self.asicnum) self.jsondict['doreconfig'] = str(self.doReconfig) self.jsondict['extclock'] = str(self.isExternalClock) self.jsondict['is1MHz'] = str(self.is1MHzSAMPLERATE) self.jsondict['iscold'] = str(self.isCold)
def __init__(self, datadir="data"): #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 self.cppfr = CPP_FILE_RUNNER()
def __init__(self, datadir="data", outlabel="xtalk", fembNum=0): #set internal variables self.datadir = datadir self.outlabel = outlabel + str("_femb_") + str(fembNum) self.outpathlabel = os.path.join(self.datadir, self.outlabel) self.fembNum = int(fembNum) print("FEMB # " + str(self.fembNum)) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(self.datadir) #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 self.cppfr = CPP_FILE_RUNNER() #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 #misc variables self.gain = 0 self.shape = 0 self.base = 0 self.leakage = 0 self.leakagex10 = 0 self.buffer = 1 self.acdc = 0 self.useInternalPulser = False self.useExtAdcClock = False self.isRoomTemp = False self.isAPA = False self.useDefaultGainFactor = False #json output, note module version number defined here self.jsondict = {'type': 'fembTest_xtalk'} self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date)
def __init__(self, datadir="data", outlabel="syncData"): self.outpathlabel = os.path.join(datadir, outlabel) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) #set appropriate packet size self.plotting = plot_functions() self.write_data.femb.MAX_PACKET_SIZE = 8000 self.cppfr = CPP_FILE_RUNNER() #json output, note module version number defined here self.jsondict = {'type': 'sync_adcs'} self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date)
def __init__(self, datadir="data", outlabel="baselineTest"): #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) #import data analysis and plotting objects self.plotting = plot_functions() self.analyze = Data_Analysis() #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 self.cppfr = CPP_FILE_RUNNER() #json output, note module version number defined here self.jsondict = {'type':'baseline_test'} self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date)
def __init__(self): #declare basic system parameters self.NFEMBS = 4 self.NASICS = 8 self.NASICCH = 16 #declare board specific registers self.FEMB_VER = "WIB_SBND" self.REG_RESET = 0 self.REG_ASIC_RESET = 1 self.REG_ASIC_SPIPROG = 2 self.REG_SOFT_ADC_RESET = 1 self.REG_LATCHLOC_3_TO_0 = 4 self.REG_LATCHLOC_7_TO_4 = 14 self.REG_FPGA_TP_EN = 16 self.REG_ASIC_TP_EN = 16 self.REG_DAC_SELECT = 16 self.REG_TP = 5 self.CLK_SELECT = 6 self.CLK_SELECT2 = 15 self.REG_SEL_ASIC = 7 self.REG_SEL_ASIC_LSB = 8 self.REG_WIB_MODE = 8 self.REG_ADC_DISABLE = 8 self.REG_HS_DATA = 9 self.REG_HS = 17 self.INT_TP_EN = 18 self.EXT_TP_EN = 18 self.REG_SPI_BASE = 0x200 self.REG_SPI_RDBACK_BASE = 0x250 self.REG_TEST_PAT = 3 self.REG_TEST_PAT_DATA = 0x01230000 #internal variables self.fembNum = 0 self.wibNum = 0 self.useExtAdcClock = True self.isRoomTemp = False self.doReSync = True self.spiStatus = 0x0 self.syncStatus = 0x0 self.CLKSELECT_val_RT = 0xFF self.CLKSELECT2_val_RT = 0xFF self.CLKSELECT_val_CT = 0xEF self.CLKSELECT2_val_CT = 0xEF self.REG_LATCHLOC_3_TO_0_val = 0x04040404 self.REG_LATCHLOC_7_TO_4_val = 0x04040404 self.fe_regs = [0x00000000]*(16+2)*8*8 self.fe_REGS = [0x00000000]*(8+1)*4 self.useLArIATmap = False #True #COTS shifts self.fe1_sft_RT = 0x00000000 self.fe2_sft_RT = 0x00000000 self.fe3_sft_RT = 0x00000000 self.fe4_sft_RT = 0x00000000 self.fe5_sft_RT = 0x00000000 self.fe6_sft_RT = 0x00000000 self.fe7_sft_RT = 0x00000000 self.fe8_sft_RT = 0x00000000 self.fe1_sft_CT = 0x00000000 self.fe2_sft_CT = 0x00000000 self.fe3_sft_CT = 0x00000000 self.fe4_sft_CT = 0x00000000 self.fe5_sft_CT = 0x00000000 self.fe6_sft_CT = 0x00000000 self.fe7_sft_CT = 0x00000000 self.fe8_sft_CT = 0x00000000 #COTS phases self.fe1_pha_RT = 0x00000000 self.fe2_pha_RT = 0x00000000 self.fe3_pha_RT = 0x00000000 self.fe4_pha_RT = 0x00000000 self.fe5_pha_RT = 0x00000000 self.fe6_pha_RT = 0x00000000 self.fe7_pha_RT = 0x00000000 self.fe8_pha_RT = 0x00000000 self.fe1_pha_CT = 0x00000000 self.fe2_pha_CT = 0x00000000 self.fe3_pha_CT = 0x00000000 self.fe4_pha_CT = 0x00000000 self.fe5_pha_CT = 0x00000000 self.fe6_pha_CT = 0x00000000 self.fe7_pha_CT = 0x00000000 self.fe8_pha_CT = 0x00000000 #initialize FEMB UDP object self.femb = FEMB_UDP() self.femb.UDP_PORT_WREG = 32000 #WIB PORTS self.femb.UDP_PORT_RREG = 32001 self.femb.UDP_PORT_RREGRESP = 32002 self.femb.doReadBack = False #WIB register interface is unreliable #ASIC config variables self.feasicLeakage = 0 #0 = 500pA, 1 = 100pA self.feasicLeakagex10 = 0 #0 = pA, 1 = pA*10 self.feasicAcdc = 0 #AC = 0, DC = 1 self.feasicBaseline = 0 #0 = 900mV, 1 = 200mV self.feasicEnableTestInput = 0 #0 = disabled, 1 = enabled self.feasicGain = 2 #4.7,7.8,14,25 self.feasicShape = 1 #0.5,1,2,3 self.feasicBuf = 1 #0 = OFF, 1 = ON #Read in LArIAT mapping if desired if self.useLArIATmap: self.cppfr = CPP_FILE_RUNNER() with open(self.cppfr.filename('configuration/configs/LArIAT_pin_mapping.map'), "rb") as fp: self.lariatMap = pickle.load(fp) #APA Mapping va = self.lariatMap va_femb = [] for vb in va: if int(vb[9]) in (0,1,2,3,4) : va_femb.append(vb) apa_femb_loc = [] for chn in range(128): for vb in va_femb: if int(vb[8]) == chn: if (vb[1].find("Co")) >= 0 :#collection wire chninfo = [ "X" + vb[0], vb[8], int(vb[6]), int(vb[7]), int(vb[9]), int(vb[10])] elif (vb[1].find("In")) >= 0 : #induction wire chninfo = [ "U" + vb[0], vb[8], int(vb[6]), int(vb[7]), int(vb[9]), int(vb[10])] apa_femb_loc.append(chninfo) for chn in range(128): fl_w = True fl_i = 0 for tmp in apa_femb_loc: if int(tmp[1]) == chn: fl_w = False break if (fl_w): chninfo = [ "V" + format(fl_i, "03d"), format(chn, "03d"), chn//16 , format(chn%15, "02d"), apa_femb_loc[0][4], apa_femb_loc[0][5]] apa_femb_loc.append(chninfo) fl_i = fl_i + 1 self.All_sort = [] self.X_sort = [] self.V_sort = [] self.U_sort = [] for i in range(128): for chn in apa_femb_loc: if int(chn[1][0:3]) == i : self.All_sort.append(chn) for chn in apa_femb_loc: if chn[0][0] == "X" and int(chn[0][1:3]) == i : self.X_sort.append(chn) for chn in apa_femb_loc: if chn[0][0] == "V" and int(chn[0][1:3]) == i : self.V_sort.append(chn) for chn in apa_femb_loc: if chn[0][0] == "U" and int(chn[0][1:3]) == i : self.U_sort.append(chn) self.WireDict = {} for line in self.All_sort: key = "wib{:d}_femb{:d}_chip{:d}_chan{:02d}".format(line[5],line[4],line[2],line[3]) self.WireDict[key] = line[0]
class QUADADC_TEST_SIMPLE(object): def __init__(self, datadir="data", outlabel="simpleMeasurement", asicnum=0, isCold=False): #set internal variables self.datadir = datadir self.outlabel = outlabel + str("_asic_") + str(asicnum) self.outpathlabel = os.path.join(self.datadir, self.outlabel) self.asicnum = int(asicnum) print("Test type\t" + str(self.outlabel)) print("Data path\t" + str(datadir)) print("ASIC socket #\t" + str(self.asicnum)) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) self.cppfr = CPP_FILE_RUNNER() #set appropriate UDP packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #should be larger than largest expected packet size #set test module status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 self.isCold = isCold #define json output self.jsondict = {'type': 'quadAdcTest_simple'} #self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date) self.jsondict['asicnum'] = str(self.asicnum) def check_setup(self): #CHECK STATUS AND INITIALIZATION print("SIMPLE MEASUREMENT - CHECKING READOUT STATUS") self.status_check_setup = 0 #make sure output directory exists (should catch permissions issues etc) isDir = self.write_data.assure_filedir() if isDir == None: print("Error running test - Output data directory note created.") return #check if register interface is working print("Checking register interface") regVal = self.femb_config.femb.read_reg( self.femb_config.REG_FIRMWARE_VERSION) if (regVal == None): print("Error running test - register interface is not working.") print(" Turn on or debug UDP readout.") return if (regVal < 0): print("Error running test - register interface is not working.") print(" Turn on or debug UDP readout.") return print("Read register 6, value = " + str(hex(regVal))) #check for any problems in input variables #check that input ASIC # is correct if self.asicnum == None: print( "Error running test - Invalid ASIC socket # specified, ending test" ) return if (self.asicnum < 0) or (self.asicnum > self.femb_config.NASICS): print( "Error running test - Invalid ASIC socket # specified, ending test" ) return #initialize readout to known working state #initialization may identify problem that cancels test print("Initializing board") initStatus = self.femb_config.initBoard() if initStatus == False: print( "Error running test - Could not initialize board, ending test") return initStatus = self.femb_config.initAsic(self.asicnum) if initStatus == False: print( "Error running test - Could not initialize ASIC, ending test") return #firmware version check should be done in initialize, otherwise do here #if self.femb_config.checkFirmwareVersion() == False: # print('Error running doFembTest - Invalid firmware and/or register read error') # return #check if data streaming is working, assume it's ON after board + ASIC initialize print("Checking data streaming") testData = self.write_data.femb.get_data_packets(1) if testData == None: print("Error running test - board is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") return if len(testData) == 0: print("Error running test - board is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") return print("Received data packet " + str(len(testData[0])) + " bytes long") #check for analysis executables if not self.cppfr.exists( 'test_measurements/quadAdcTester/code/parseBinaryFile'): print( 'Error running test - parseBinaryFile executable not found, run setup.sh' ) return if not self.cppfr.exists( 'test_measurements/quadAdcTester/code/processNtuple_simpleMeasurement' ): print( 'Error running test - processNtuple_simpleMeasurement executable not found, run setup.sh' ) return #Setup is ok print("SIMPLE MEASUREMENT - READOUT STATUS OK" + "\n") self.status_check_setup = 1 def record_data(self): if self.status_check_setup == 0: print( "Error running test - Please run check_setup method before trying to take data" ) return if self.status_record_data == 1: print( "Error running test - Data already recorded. Reset/restat GUI to begin a new measurement" ) return #MEASUREMENT SECTION print("SIMPLE MEASUREMENT - RECORDING DATA") #wait to make sure HS link is back on after check_setup function sleep(1.) #setup output file and record data self.write_data.filename = self.outlabel + ".bin" print("Recording " + self.write_data.filename) isOpen = self.write_data.open_file() if isOpen == 0: print( "Error running test - Could not open output data file for writing, ending test" ) #record data self.write_data.numpacketsrecord = 10 self.write_data.run = 0 self.write_data.runtype = 0 self.write_data.runversion = 0 #loop over each ASIC, record some data subrun = 0 asic = self.asicnum asicCh = 0 self.femb_config.selectAsic(asic) self.write_data.record_data(subrun, asic, asicCh) self.write_data.close_file() #Power off ASIC #self.femb_config.turnOffAsics() print("SIMPLE MEASUREMENT - DONE RECORDING DATA" + "\n") self.status_record_data = 1 def do_analysis(self): if self.status_record_data == 0: print("Error running test - Please record data before analysis") return if self.status_do_analysis == 1: print("Error running test - Analysis already complete") return #ANALYSIS SECTION print("SIMPLE MEASUREMENT - ANALYZING AND SUMMARIZING DATA") #parse binary self.cppfr.run("test_measurements/quadAdcTester/code/parseBinaryFile", [self.write_data.data_file_path]) #check for parsed file here if os.path.isfile("output_parseBinaryFile.root") == False: print("Error running test - parsed data file not found.") return #run analysis program parseBinaryFile = "output_parseBinaryFile.root" self.cppfr.run( "test_measurements/quadAdcTester/code/processNtuple_simpleMeasurement", [parseBinaryFile]) #check for online analysis result files here if os.path.isfile( "output_processNtuple_simpleMeasurement.root") == False: print("Error running test - parsed data file not found.") return #update output file names parseBinaryFile = self.outpathlabel + "-parseBinaryFile.root" call(["mv", "output_parseBinaryFile.root", parseBinaryFile]) processNtupleFile = self.outpathlabel + "-processNtupleFile.root" call([ "mv", "output_processNtuple_simpleMeasurement.root", processNtupleFile ]) summaryPlot = self.outpathlabel + "-summaryPlot.png" call(["mv", "summaryPlot_simpleMeasurement.png", summaryPlot]) print("SIMPLE MEASUREMENT - DONE ANALYZING AND SUMMARIZING DATA" + "\n") self.status_do_analysis = 1 def archive_results(self): #NOTE: GENERALLY ALLOW ARCHIVE PROCESS TO RUN EVEN IF OTHER STEPS FAIL #if self.status_check_setup == 0 : # print("Check setup status is 0, not archiving data") # return #if self.status_do_analysis == 0: # print("Please analyze data before archiving results") # return if self.status_archive_results == 1: print("Error running test - Results already archived") return #ARCHIVE SECTION print("SIMPLE MEASUREMENT - ARCHIVE") #add summary variables to output self.jsondict['filedir'] = str(self.write_data.filedir) self.jsondict['status_check_setup'] = str(self.status_check_setup) self.jsondict['status_record_data'] = str(self.status_record_data) self.jsondict['status_do_analysis'] = str(self.status_do_analysis) self.jsondict['status_archive_results'] = str(1) #dump results into json jsonFile = self.outpathlabel + "-results.json" with open(jsonFile, 'w') as outfile: json.dump(self.jsondict, outfile, indent=4) print("SIMPLE MEASUREMENT - DONE ARCHIVING" + "\n") self.status_archive_results = 1
class FEMB_TEST_SIMPLE(object): def __init__(self, datadir="data", outlabel="simpleMeasurement", wib=0, fembNum=0): #set internal variables self.datadir = datadir self.outlabel = outlabel + str("_femb_") + str(fembNum + 4 * wib) self.outpathlabel = os.path.join(self.datadir, self.outlabel) self.fembNum = int(fembNum) print("Test type\t" + str(self.outlabel)) print("Data path\t" + str(datadir)) print("FEMB #\t" + str(self.fembNum)) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 9014 self.cppfr = CPP_FILE_RUNNER() #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 #json output, note module version number defined here self.jsondict = {'type': 'fembTest_simple'} self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date) def check_setup(self): #CHECK STATUS AND INITIALIZATION print("SIMPLE MEASUREMENT - CHECKING READOUT STATUS") self.status_check_setup = 0 #make sure output directory exists self.write_data.assure_filedir() #check if register interface is working print("Checking register interface") regVal = self.femb_config.femb.read_reg(6) if (regVal == None): print( "Error running test - FEMB register interface is not working.") print(" Turn on or debug FEMB UDP readout.") return if (regVal < 0): print( "Error running test - FEMB register interface is not working.") print(" Turn on or debug FEMB UDP readout.") return print("Read register 6, value = " + str(hex(regVal))) #check that femb number is valid if (int(self.fembNum) < 0) or (int(self.fembNum) >= self.femb_config.NFEMBS): print("Error running doFembTest - Invalid FEMB # specified.") return #DO NOT CONFIGURE, except to enable streaming self.femb_config.wib_reg_enable() self.femb_config.femb.write_reg(20, 3) self.femb_config.femb.write_reg(20, 3) time.sleep(0.001) self.femb_config.femb.write_reg(20, 0) self.femb_config.femb.write_reg(20, 0) time.sleep(0.001) # start streaming data from ASIC 0 in initialization self.femb_config.femb.write_reg(7, 0x80000000) self.femb_config.femb.write_reg(7, 0x80000000) femb_asic = 0 & 0x0F wib_asic = (((self.fembNum << 16) & 0x000F0000) + ((femb_asic << 8) & 0xFF00)) self.femb_config.femb.write_reg(7, wib_asic | 0x80000000) self.femb_config.femb.write_reg(7, wib_asic | 0x80000000) self.femb_config.femb.write_reg(7, wib_asic) self.femb_config.femb.write_reg(7, wib_asic) self.femb_config.selectFemb(self.fembNum) #Enable Streaming self.femb_config.femb.write_reg(9, 9) self.femb_config.femb.write_reg(9, 9) time.sleep(0.1) #test firmware versions if self.femb_config.checkFirmwareVersion() == False: print( 'Error running doFembTest - Invalid firmware and/or register read error' ) return if self.femb_config.syncStatus != 0: print('Error running doFembTest - ADC SYNC failed') return if self.femb_config.spiStatus != 0: print('Error running doFembTest - ADC SPI failed') return #check if data streaming is working print("Checking data streaming") testData = self.write_data.femb.get_data_packets(1) if testData == None: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") return if len(testData) == 0: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") return print("Received data packet " + str(len(testData[0])) + " bytes long") #check for analysis executables if not self.cppfr.exists( 'test_measurements/fembTest/code/parseBinaryFile'): print('parseBinaryFile not found, run setup.sh') return print("SIMPLE MEASUREMENT - READOUT STATUS OK" + "\n") self.status_check_setup = 1 def record_data(self): if self.status_check_setup == 0: print("Please run check_setup method before trying to take data") return if self.status_record_data == 1: print( "Data already recorded. Reset/restat GUI to begin a new measurement" ) return #MEASUREMENT SECTION print("SIMPLE MEASUREMENT - RECORDING DATA") #wait to make sure HS link is back on after check_setup sleep(5) self.femb_config.printParameters() #setup output file and record data self.write_data.filename = self.outlabel + ".bin" print("Recording " + self.write_data.filename) isOpen = self.write_data.open_file() if isOpen == 0: print( "Error running doFembTest - Could not open output data file for writing, ending test" ) subrun = 0 #record data self.write_data.numpacketsrecord = 100 self.write_data.run = 0 self.write_data.runtype = 0 self.write_data.runversion = 0 asicCh = 0 for asic in range(0, 8, 1): self.femb_config.selectChannel(asic, asicCh) self.write_data.record_data(subrun, asic, asicCh) self.write_data.close_file() print("SIMPLE MEASUREMENT - DONE RECORDING DATA" + "\n") self.status_record_data = 1 def do_analysis(self): if self.status_record_data == 0: print("Please record data before analysis") return if self.status_do_analysis == 1: print("Analysis already complete") return #ANALYSIS SECTION print("SIMPLE MEASUREMENT - ANALYZING AND SUMMARIZING DATA") #parse binary self.cppfr.run("test_measurements/fembTest/code/parseBinaryFile", [self.write_data.data_file_path]) #run analysis program parseBinaryFile = self.outpathlabel + "-parseBinaryFile.root" call(["mv", "output_parseBinaryFile.root", parseBinaryFile]) self.cppfr.run( "test_measurements/fembTest/code/processNtuple_simpleMeasurement", [parseBinaryFile]) processNtupleFile = self.outpathlabel + "-processNtupleFile.root" call([ "mv", "output_processNtuple_simpleMeasurement.root", processNtupleFile ]) summaryPlot = self.outpathlabel + "-summaryPlot.png" call(["mv", "summaryPlot_simpleMeasurement.png", summaryPlot]) print("SIMPLE MEASUREMENT - DONE ANALYZING AND SUMMARIZING DATA" + "\n") self.status_do_analysis = 1 def archive_results(self): #if self.status_check_setup == 0 : # print("Check setup status is 0, not archiving data") # return #if self.status_do_analysis == 0: # print("Please analyze data before archiving results") # return if self.status_archive_results == 1: print("Results already archived") return #ARCHIVE SECTION print("SIMPLE MEASUREMENT - ARCHIVE") #add summary variables to output self.jsondict['femb'] = self.fembNum self.jsondict['filedir'] = str(self.write_data.filedir) self.jsondict['status_check_setup'] = str(self.status_check_setup) self.jsondict['status_record_data'] = str(self.status_record_data) self.jsondict['status_do_analysis'] = str(self.status_do_analysis) self.jsondict['status_archive_results'] = str(1) self.jsondict['syncStatus'] = str(self.femb_config.syncStatus) #dump results into json jsonFile = self.outpathlabel + "-results.json" with open(jsonFile, 'w') as outfile: json.dump(self.jsondict, outfile, indent=4) print("SIMPLE MEASUREMENT - DONE ARCHIVING" + "\n") self.status_archive_results = 1
class FEMB_TEST_SIMPLE(object): def __init__(self, datadir="data"): #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 self.cppfr = CPP_FILE_RUNNER() def check_setup(self): #CHECK STATUS AND INITIALIZATION print("SIMPLE MEASUREMENT - CHECKING READOUT STATUS") self.status_check_setup = 0 self.write_data.assure_filedir() #create data-taking directory #print("doFembTest - creating data-taking directory : " + str( self.write_data.filedir ) ) #os.makedirs( str( self.write_data.filedir ) ) #if os.path.isdir( str( self.write_data.filedir ) ) == False: # print("Error creating data-taking directory.") # return #check if register interface is working print("Checking register interface") regVal = self.femb_config.femb.read_reg(6) if (regVal == None) or (regVal == -1): print("Error running doFembTest - FEMB register interface is not working.") print(" Turn on or debug FEMB UDP readout.") return print("Read register 6, value = " + str( hex( regVal ) ) ) #initialize FEMB to known state print("Initializing board") self.femb_config.initBoard() #check if data streaming is working print("Checking data streaming") testData = self.write_data.femb.get_data_packets(1) if testData == None: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") #print(" This script will exit now") #sys.exit(0) return if len(testData) == 0: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") #print(" This script will exit now") #sys.exit(0) return print("Received data packet " + str(len(testData[0])) + " bytes long") #check for analysis executables if not self.cppfr.exists('test_measurements/example_femb_test/parseBinaryFile'): print('parseBinaryFile not found, run setup.sh') #sys.exit(0) return print("SIMPLE MEASUREMENT - READOUT STATUS OK" + "\n") self.status_check_setup = 1 def record_data(self): if self.status_check_setup == 0: print("Please run check_setup method before trying to take data") return if self.status_record_data == 1: print("Data already recorded. Reset/restat GUI to begin a new measurement") return #MEASUREMENT SECTION print("SIMPLE MEASUREMENT - RECORDING DATA") #initialize FEMB configuration to known state self.femb_config.feasicGain = 1 #4.7,7.8,14,25 self.femb_config.feasicShape = 2 #0.5,1,2,3 self.femb_config.feasicBaseline = 1 #0 = 200mV, 1 = 900mV self.femb_config.feasicLeakage = 0 #0 = 500pA, 1 = 100pA self.femb_config.feasicLeakagex10 = 1 #0 = x1, 1 = x10 self.femb_config.feasicBuf = 1 #0 = OFF, 1 = ON self.femb_config.feasicAcdc = 0 #AC = 0, DC = 1 self.femb_config.feasicEnableTestInput = 1 #OFF = 0, ON = 1 self.femb_config.configFeAsic() #disable pulser self.femb_config.setDacPulser(0,0x0) self.femb_config.setFpgaPulser(0,0x0) self.femb_config.setExternalFpgaPulser(0,0x0) self.femb_config.setInternalPulser(1,0x5) #wait to make sure HS link is back on #sleep(0.5) #set output file self.write_data.filename = "rawdata_simpleMeasurement_" + str(self.write_data.date) + ".bin" print("Recording " + self.write_data.filename ) self.write_data.numpacketsrecord = 10 self.write_data.run = 0 self.write_data.runtype = 0 self.write_data.runversion = 0 #setup output file and record data isOpen = self.write_data.open_file() if isOpen == 0 : print( "Error running doFembTest - Could not open output data file for writing, ending test" ) subrun = 0 asicCh = 0 for asic in range(0,4,1): for asicCh in range(0,16,1): self.femb_config.selectChannel(asic,asicCh) self.write_data.record_data(subrun, asic, asicCh) self.write_data.close_file() #turn off ASICs self.femb_config.turnOffAsics() print("SIMPLE MEASUREMENT - DONE RECORDING DATA" + "\n") self.status_record_data = 1 def do_analysis(self): if self.status_record_data == 0: print("Please record data before analysis") return if self.status_do_analysis == 1: print("Analysis already complete") return #ANALYSIS SECTION print("SIMPLE MEASUREMENT - ANALYZING AND SUMMARIZING DATA") #parse binary self.cppfr.run("test_measurements/feAsicTest/parseBinaryFile", [self.write_data.data_file_path]) #run analysis program newName = "output_parseBinaryFile_" + self.write_data.filename + ".root" newPath = os.path.join(self.write_data.filedir, newName) call(["mv", "output_parseBinaryFile.root" , newPath]) self.cppfr.run("test_measurements/feAsicTest/processNtuple_simpleMeasurement", [newPath]) #move result to data directory newName = "output_processNtuple_simpleMeasurement_" + self.write_data.filename + ".root" newPath = os.path.join(self.write_data.filedir, newName) call(["mv", "output_processNtuple_simpleMeasurement.root" , newPath ]) newName = "summaryPlot_" + self.write_data.filename + ".png" newPath = os.path.join(self.write_data.filedir, newName) call(["mv", "summaryPlot_simpleMeasurement.png" , newPath]) #summary plot #print("SIMPLE MEASUREMENT - DISPLAYING SUMMARY PLOT, CLOSE PLOT TO CONTINUE") call(["display",str( newPath ) ]) print("SIMPLE MEASUREMENT - DONE ANALYZING AND SUMMARIZING DATA" + "\n") self.status_do_analysis = 1 def archive_results(self): if self.status_do_analysis == 0: print("Please analyze data before archiving results") return if self.status_archive_results == 1: print("Results already archived") return #ARCHIVE SECTION print("SIMPLE MEASUREMENT - STORE RESULTS IN DATABASE") #placeholder print("SIMPLE MEASUREMENT - DONE STORING RESULTS IN DATABASE" + "\n") self.status_archive_results = 1
class FEMB_TEST_GAIN_FPGADAC(object): def __init__(self, datadir="data", outlabel="gainMeasurement"): self.outpathlabel = os.path.join(datadir, outlabel) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 self.cppfr = CPP_FILE_RUNNER() #misc variables self.gain = 0 self.shape = 0 self.base = 0 #json output, note module version number defined here self.jsondict = {'type':'quadFeAsic_gain_fpgadac'} self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date) def reset(self): self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 def check_setup(self): #CHECK STATUS AND INITIALIZATION print("GAIN MEASUREMENT FPGA DAC - CHECKING READOUT STATUS") self.status_check_setup = 0 self.write_data.assure_filedir() #check if register interface is working print("Checking register interface") regVal = self.write_data.femb.read_reg(5) if (regVal == None) or (regVal == -1): print("Error running doFembTest - FEMB register interface is not working.") print(" Turn on or debug FEMB UDP readout.") return print("Read register 5, value = " + str( hex( regVal ) ) ) #initialize FEMB to known state print("Initializing board") self.femb_config.initBoard() #check if data streaming is working print("Checking data streaming") testData = self.write_data.femb.get_data_packets(1) if testData == None: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") #print(" This script will exit now") #sys.exit(0) return if len(testData) == 0: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") #print(" This script will exit now") #sys.exit(0) return print("Received data packet " + str(len(testData[0])) + " bytes long") #check for analysis executables if not self.cppfr.exists('test_measurements/example_femb_test/parseBinaryFile'): print('parseBinaryFile not found, run setup.sh') #sys.exit(0) return print("GAIN MEASUREMENT FPGA DAC - READOUT STATUS OK" + "\n") self.status_check_setup = 1 def record_data(self): if self.status_check_setup == 0: print("Please run check_setup method before trying to take data") return if self.status_record_data == 1: print("Data already recorded. Reset/restat GUI to begin a new measurement") return #MEASUREMENT SECTION print("GAIN MEASUREMENT FPGA DAC - RECORDING DATA") #initialize FEMB configuration to known state print("FE ASIC Settings: Gain " + str(self.gain) + ", Shaping Time " + str(self.shape) + ", Baseline " + str(self.base) ) self.femb_config.feasicGain = self.gain self.femb_config.feasicShape = self.shape self.femb_config.feasicBaseline = self.base self.femb_config.configFeAsic() #disable pulser self.femb_config.setInternalPulser(0,0x0) self.femb_config.setDacPulser(0,0x0) self.femb_config.setFpgaPulser(0,0x0) #setup output file and record data self.write_data.filename = self.outpathlabel+".bin" print("Recording " + self.write_data.filename ) self.write_data.numpacketsrecord = 50 self.write_data.run = 0 self.write_data.runtype = 0 self.write_data.runversion = 0 self.write_data.open_file() #take initial noise data run subrun = 0 for asic in range(0,4,1): self.femb_config.turnOffAsics() self.femb_config.turnOnAsic(asic) time.sleep(5) # wait extra for power to settle for asicCh in range(0,16,1): self.femb_config.selectChannel(asic,asicCh) self.write_data.record_data(subrun, asic, asicCh) #turn ASICs back on, start pulser section self.femb_config.feasicEnableTestInput = 1 self.femb_config.turnOnAsics() subrun = 1 #loop over pulser configurations, each configuration is it's own subrun #for p in range(1,2,1): for p in range(1,0x3F,1): pVal = int(p) self.femb_config.setFpgaPulser(1,pVal) print("Pulse amplitude " + str(pVal) ) #loop over channels for asic in range(0,4,1): for asicCh in range(0,16,1): self.femb_config.selectChannel(asic,asicCh) self.write_data.record_data(subrun, asic, asicCh) #increment subrun, important subrun = subrun + 1 #close file self.write_data.close_file() #turn off pulser self.femb_config.setFpgaPulser(0,0) #turn off ASICs self.femb_config.turnOffAsics() print("GAIN MEASUREMENT FPGA DAC - DONE RECORDING DATA" + "\n") self.status_record_data = 1 def do_analysis(self): if self.status_record_data == 0: print("Please record data before analysis") return if self.status_do_analysis == 1: print("Analysis already complete") return #ANALYSIS SECTION print("GAIN MEASUREMENT FPGA DAC - ANALYZING AND SUMMARIZING DATA") #parse binary self.cppfr.run("test_measurements/feAsicTest/parseBinaryFile", [self.write_data.data_file_path]) #run analysis program parseBinaryFile = self.outpathlabel + "-parseBinaryFile.root" call(["mv", "output_parseBinaryFile.root" , parseBinaryFile]) self.cppfr.run("test_measurements/feAsicTest/processNtuple_gainMeasurement_fpgadac", [parseBinaryFile]) processNtupleFile = self.outpathlabel + "-processNtupleFile.root" call(["mv", "output_processNtuple_gainMeasurement_fpgadac.root" , processNtupleFile]) summaryPlot = self.outpathlabel + "-summaryPlot.png" call(["mv", "summaryPlot_gainMeasurement_fpgadac.png" , summaryPlot]) resultsFile = self.outpathlabel + "-results.list" call(["mv", "output_processNtuple_gainMeasurement_fpgadac.list" , resultsFile]) #summary plot #print("GAIN MEASUREMENT - DISPLAYING SUMMARY PLOT, CLOSE PLOT TO CONTINUE") #call(["display", newPath]) print("GAIN MEASUREMENT FPGA DAC - DONE ANALYZING AND SUMMARIZING DATA" + "\n") self.status_do_analysis = 1 def archive_results(self): #if self.status_do_analysis == 0: # print("Please analyze data before archiving results") # return #if self.status_archive_results == 1: # print("Results already archived") # return #ARCHIVE SECTION print("GAIN MEASUREMENT FPGA DAC - ARCHIVE") #add summary variables to output self.jsondict['status_check_setup'] = str( self.status_check_setup ) self.jsondict['status_record_data'] = str( self.status_record_data ) self.jsondict['status_do_analysis'] = str( self.status_do_analysis ) self.jsondict['filedir'] = str( self.write_data.filedir ) self.jsondict['config_gain'] = str( self.gain ) self.jsondict['config_shape'] = str( self.shape ) self.jsondict['config_base'] = str( self.base ) if self.status_do_analysis == 1: #parse the output results, kind of messy listFile = self.outpathlabel + "-results.list" lines = [] with open( listFile ) as infile: for line in infile: line = line.strip('\n') line = line.split(',') #measurements separated by commas parseline = {} for n in range(0,len(line),1): word = line[n].split(' ') if( len(word) != 2 ): continue parseline[ str(word[0]) ] = str(word[1]) lines.append(parseline) self.jsondict['results'] = lines #dump results into json jsonFile = self.outpathlabel + "-results.json" with open( jsonFile , 'w') as outfile: json.dump( self.jsondict, outfile, indent=4) #get required results from dict to propagate to GUI """ asicStatus = [] if "results" in self.jsondict: results = self.jsondict["results"] for d in results: if "asic" in d: asicNum = d["asic"] fail = d["fail"] asicStatus.append( [asicNum,fail] ) """ print("GAIN MEASUREMENT - DONE ARCHIVING" + "\n") self.status_archive_results = 1
class QUADADC_TEST_FUNCGEN(object): def __init__(self, datadir="data", outlabel="funcgenMeasurement", asicnum=0, doReconfig=True, isExternalClock=True, is1MHzSAMPLERATE=True, isCold=False): #set internal variables self.datadir = datadir self.outlabel = outlabel + str("_asic_") + str(asicnum) self.outpathlabel = os.path.join(self.datadir, self.outlabel) self.asicnum = int(asicnum) print("Test type\t" + str(self.outlabel)) print("Data path\t" + str(datadir)) print("ASIC socket #\t" + str(self.asicnum)) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(datadir) self.cppfr = CPP_FILE_RUNNER() self.funcgen = Keysight_33600A("/dev/usbtmc0", 1) #hardcoded to usbtmc0 #set appropriate UDP packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #should be larger than largest expected packet size #set test module status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 #assign input to test and config module internal variables self.doReconfig = doReconfig self.isExternalClock = isExternalClock self.is1MHzSAMPLERATE = is1MHzSAMPLERATE self.isCold = isCold self.femb_config.isExternalClock = self.isExternalClock #False = internal monostable, True = external self.femb_config.is1MHzSAMPLERATE = self.is1MHzSAMPLERATE #False = 1MHz, True = 2MHz self.femb_config.COLD = self.isCold #define json output self.jsondict = {'type': 'quadAdcTest_funcgen'} #self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date) self.jsondict['asicnum'] = str(self.asicnum) self.jsondict['doreconfig'] = str(self.doReconfig) self.jsondict['extclock'] = str(self.isExternalClock) self.jsondict['is1MHz'] = str(self.is1MHzSAMPLERATE) self.jsondict['iscold'] = str(self.isCold) def check_setup(self): #CHECK STATUS AND INITIALIZATION print("FUNCTION GENERATOR MEASUREMENT - CHECKING READOUT STATUS") self.status_check_setup = 0 #make sure output directory exists (should catch permissions issues etc) isDir = self.write_data.assure_filedir() if isDir == None: print("Error running test - Output data directory note created.") return #check if register interface is working print("Checking register interface") regVal = self.femb_config.femb.read_reg( self.femb_config.REG_FIRMWARE_VERSION) if (regVal == None): print("Error running test - register interface is not working.") print(" Turn on or debug UDP readout.") return if (regVal < 0): print("Error running test - register interface is not working.") print(" Turn on or debug UDP readout.") return print("Read register 6, value = " + str(hex(regVal))) #check for any problems in input variables #check that input ASIC # is correct if self.asicnum == None: print( "Error running test - Invalid ASIC socket # specified, ending test" ) return if (self.asicnum < 0) or (self.asicnum > self.femb_config.NASICS): print( "Error running test - Invalid ASIC socket # specified, ending test" ) return #initialize readout to known working state #initialization may identify problem that cancels test if self.doReconfig == True: print("Initializing board") initStatus = self.femb_config.initBoard() if initStatus == False: print( "Error running test - Could not initialize board, ending test" ) return initStatus = self.femb_config.initAsic(self.asicnum) if initStatus == False: print( "Error running test - Could not initialize ASIC, ending test" ) return #firmware version check should be done in initialize, otherwise do here #if self.femb_config.checkFirmwareVersion() == False: # print('Error running doFembTest - Invalid firmware and/or register read error') # return #check if data streaming is working, assume it's ON after board + ASIC initialize print("Checking data streaming") testData = self.write_data.femb.get_data_packets(1) if testData == None: print("Error running test - board is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") return if len(testData) == 0: print("Error running test - board is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") return print("Received data packet " + str(len(testData[0])) + " bytes long") #check for analysis executables if not self.cppfr.exists( 'test_measurements/quadAdcTester/code/parseBinaryFile'): print( 'Error running test - parseBinaryFile executable not found, run setup.sh' ) return #if not self.cppfr.exists('test_measurements/quadAdcTester/code/processNtuple_funcgenMeasurement'): # print('Error running test - processNtuple_funcgenMeasurement executable not found, run setup.sh') # return #Setup is ok print("FUNCTION GENERATOR MEASUREMENT - READOUT STATUS OK" + "\n") self.status_check_setup = 1 def record_data(self): if self.status_check_setup == 0: print( "Error running test - Please run check_setup method before trying to take data" ) return if self.status_record_data == 1: print( "Error running test - Data already recorded. Reset/restat GUI to begin a new measurement" ) return #MEASUREMENT SECTION print("FUNCTION GENERATOR MEASUREMENT - RECORDING DATA") #wait to make sure HS link is back on after check_setup function sleep(1.) #enable external signal input self.femb_config.setFPGADac(0, 1, 0, 0) # write regs 4 and 5 #print config parameters just before data taking self.femb_config.printParameters() #data recording parameters self.write_data.run = 0 self.write_data.runtype = 0 self.write_data.runversion = 0 #setup output file and record data self.write_data.filename = self.outlabel + ".bin" print("Recording " + self.write_data.filename) isOpen = self.write_data.open_file() if isOpen == 0: print( "Error running test - Could not open output data file for writing, ending test" ) #speicify ASIC asic = self.asicnum asicCh = 0 self.femb_config.selectAsic(asic) #initialize function generator parameters xLow = -0.3 xHigh = 1.7 offsetV = (xLow + xHigh) * 0.5 amplitudeV = (xHigh - xLow) * 0.5 settlingTime = 0.1 #take a bunch of function generator data in sequence and stick it all in the same output file #long ramp subrun = 0 freq = 4 self.funcgen.startRamp(freq, xLow, xHigh) sleep(settlingTime) self.write_data.numpacketsrecord = 20000 #long self.write_data.record_data(subrun, asic, asicCh) #short ramp subrun = subrun + 1 freq = 734 self.funcgen.startRamp(freq, xLow, xHigh) sleep(settlingTime) self.write_data.numpacketsrecord = 1600 self.write_data.record_data(subrun, asic, asicCh) #DC [0.2,0.5,1.,1.6] for dc in [0.2, 0.5, 1., 1.6]: subrun = subrun + 1 self.funcgen.startDC(dc) sleep(settlingTime) self.write_data.numpacketsrecord = 160 self.write_data.record_data(subrun, asic, asicCh) #SINE [6.2365e4,4.83587e5,9.515125e5] for freq in [6.2365e4, 4.83587e5, 9.515125e5]: subrun = subrun + 1 self.funcgen.startSin(freq, amplitudeV, offsetV) sleep(settlingTime) self.write_data.numpacketsrecord = 1600 self.write_data.record_data(subrun, asic, asicCh) #done taking data self.write_data.close_file() #Power off ASIC #self.femb_config.turnOffAsics() #disable external signal input self.femb_config.setFPGADac(0, 0, 0, 0) # write regs 4 and 5 #turn off function generator sleep(1) self.funcgen.stop() sleep(1) print("FUNCTION GENERATOR MEASUREMENT - DONE RECORDING DATA" + "\n") self.status_record_data = 1 def do_analysis(self): if self.status_record_data == 0: print("Error running test - Please record data before analysis") return if self.status_do_analysis == 1: print("Error running test - Analysis already complete") return #ANALYSIS SECTION print( "FUNCTION GENERATOR MEASUREMENT - ANALYZING AND SUMMARIZING DATA") #parse binary self.cppfr.run("test_measurements/quadAdcTester/code/parseBinaryFile", [self.write_data.data_file_path]) #check for parsed file here if os.path.isfile("output_parseBinaryFile.root") == False: print("Error running test - parsed data file not found.") return #run analysis program parseBinaryFile = "output_parseBinaryFile.root" #self.cppfr.run("test_measurements/quadAdcTester/code/processNtuple_funcgenMeasurement", [parseBinaryFile]) #check for online analysis result files here #if os.path.isfile( "output_processNtuple_funcgenMeasurement.root" ) == False: # print("Error running test - parsed data file not found.") # return #update output file names parseBinaryFile = self.outpathlabel + "-parseBinaryFile.root" call(["mv", "output_parseBinaryFile.root", parseBinaryFile]) #processNtupleFile = self.outpathlabel + "-processNtupleFile.root" #call(["mv", "output_processNtuple_funcgenMeasurement.root" , processNtupleFile]) #summaryPlot = self.outpathlabel + "-summaryPlot.png" #call(["mv", "summaryPlot_funcgenMeasurement.png" , summaryPlot]) print( "FUNCTION GENERATOR MEASUREMENT - DONE ANALYZING AND SUMMARIZING DATA" + "\n") self.status_do_analysis = 1 def archive_results(self): #NOTE: GENERALLY ALLOW ARCHIVE PROCESS TO RUN EVEN IF OTHER STEPS FAIL #if self.status_check_setup == 0 : # print("Check setup status is 0, not archiving data") # return #if self.status_do_analysis == 0: # print("Please analyze data before archiving results") # return if self.status_archive_results == 1: print("Error running test - Results already archived") return #ARCHIVE SECTION print("FUNCTION GENERATOR MEASUREMENT - ARCHIVE") #add summary variables to output self.jsondict['filedir'] = str(self.write_data.filedir) self.jsondict['status_check_setup'] = str(self.status_check_setup) self.jsondict['status_record_data'] = str(self.status_record_data) self.jsondict['status_do_analysis'] = str(self.status_do_analysis) self.jsondict['status_archive_results'] = str(1) #dump results into json jsonFile = self.outpathlabel + "-results.json" with open(jsonFile, 'w') as outfile: json.dump(self.jsondict, outfile, indent=4) print("FUNCTION GENERATOR MEASUREMENT - DONE ARCHIVING" + "\n") self.status_archive_results = 1
class FEMB_CONFIG(FEMB_CONFIG_BASE): #__INIT__# def __init__(self): #declare basic system parameters self.NFEMBS = 4 self.NASICS = 8 self.NASICCH = 16 #declare board specific registers self.FEMB_VER = "WIB_SBND" self.REG_RESET = 0 self.REG_ASIC_RESET = 1 self.REG_ASIC_SPIPROG = 2 self.REG_SOFT_ADC_RESET = 1 self.REG_LATCHLOC_3_TO_0 = 4 self.REG_LATCHLOC_7_TO_4 = 14 self.REG_FPGA_TP_EN = 16 self.REG_ASIC_TP_EN = 16 self.REG_DAC_SELECT = 16 self.REG_TP = 5 self.CLK_SELECT = 6 self.CLK_SELECT2 = 15 self.REG_SEL_ASIC = 7 self.REG_SEL_ASIC_LSB = 8 self.REG_WIB_MODE = 8 self.REG_ADC_DISABLE = 8 self.REG_HS_DATA = 9 self.REG_HS = 17 self.INT_TP_EN = 18 self.EXT_TP_EN = 18 self.REG_SPI_BASE = 0x200 self.REG_SPI_RDBACK_BASE = 0x250 self.REG_TEST_PAT = 3 self.REG_TEST_PAT_DATA = 0x01230000 #internal variables self.fembNum = 0 self.wibNum = 0 self.useExtAdcClock = True self.isRoomTemp = False self.doReSync = True self.spiStatus = 0x0 self.syncStatus = 0x0 self.CLKSELECT_val_RT = 0xFF self.CLKSELECT2_val_RT = 0xFF self.CLKSELECT_val_CT = 0xEF self.CLKSELECT2_val_CT = 0xEF self.REG_LATCHLOC_3_TO_0_val = 0x04040404 self.REG_LATCHLOC_7_TO_4_val = 0x04040404 self.fe_regs = [0x00000000]*(16+2)*8*8 self.fe_REGS = [0x00000000]*(8+1)*4 self.useLArIATmap = False #True #COTS shifts self.fe1_sft_RT = 0x00000000 self.fe2_sft_RT = 0x00000000 self.fe3_sft_RT = 0x00000000 self.fe4_sft_RT = 0x00000000 self.fe5_sft_RT = 0x00000000 self.fe6_sft_RT = 0x00000000 self.fe7_sft_RT = 0x00000000 self.fe8_sft_RT = 0x00000000 self.fe1_sft_CT = 0x00000000 self.fe2_sft_CT = 0x00000000 self.fe3_sft_CT = 0x00000000 self.fe4_sft_CT = 0x00000000 self.fe5_sft_CT = 0x00000000 self.fe6_sft_CT = 0x00000000 self.fe7_sft_CT = 0x00000000 self.fe8_sft_CT = 0x00000000 #COTS phases self.fe1_pha_RT = 0x00000000 self.fe2_pha_RT = 0x00000000 self.fe3_pha_RT = 0x00000000 self.fe4_pha_RT = 0x00000000 self.fe5_pha_RT = 0x00000000 self.fe6_pha_RT = 0x00000000 self.fe7_pha_RT = 0x00000000 self.fe8_pha_RT = 0x00000000 self.fe1_pha_CT = 0x00000000 self.fe2_pha_CT = 0x00000000 self.fe3_pha_CT = 0x00000000 self.fe4_pha_CT = 0x00000000 self.fe5_pha_CT = 0x00000000 self.fe6_pha_CT = 0x00000000 self.fe7_pha_CT = 0x00000000 self.fe8_pha_CT = 0x00000000 #initialize FEMB UDP object self.femb = FEMB_UDP() self.femb.UDP_PORT_WREG = 32000 #WIB PORTS self.femb.UDP_PORT_RREG = 32001 self.femb.UDP_PORT_RREGRESP = 32002 self.femb.doReadBack = False #WIB register interface is unreliable #ASIC config variables self.feasicLeakage = 0 #0 = 500pA, 1 = 100pA self.feasicLeakagex10 = 0 #0 = pA, 1 = pA*10 self.feasicAcdc = 0 #AC = 0, DC = 1 self.feasicBaseline = 0 #0 = 900mV, 1 = 200mV self.feasicEnableTestInput = 0 #0 = disabled, 1 = enabled self.feasicGain = 2 #4.7,7.8,14,25 self.feasicShape = 1 #0.5,1,2,3 self.feasicBuf = 1 #0 = OFF, 1 = ON #Read in LArIAT mapping if desired if self.useLArIATmap: self.cppfr = CPP_FILE_RUNNER() with open(self.cppfr.filename('configuration/configs/LArIAT_pin_mapping.map'), "rb") as fp: self.lariatMap = pickle.load(fp) #APA Mapping va = self.lariatMap va_femb = [] for vb in va: if int(vb[9]) in (0,1,2,3,4) : va_femb.append(vb) apa_femb_loc = [] for chn in range(128): for vb in va_femb: if int(vb[8]) == chn: if (vb[1].find("Co")) >= 0 :#collection wire chninfo = [ "X" + vb[0], vb[8], int(vb[6]), int(vb[7]), int(vb[9]), int(vb[10])] elif (vb[1].find("In")) >= 0 : #induction wire chninfo = [ "U" + vb[0], vb[8], int(vb[6]), int(vb[7]), int(vb[9]), int(vb[10])] apa_femb_loc.append(chninfo) for chn in range(128): fl_w = True fl_i = 0 for tmp in apa_femb_loc: if int(tmp[1]) == chn: fl_w = False break if (fl_w): chninfo = [ "V" + format(fl_i, "03d"), format(chn, "03d"), chn//16 , format(chn%15, "02d"), apa_femb_loc[0][4], apa_femb_loc[0][5]] apa_femb_loc.append(chninfo) fl_i = fl_i + 1 self.All_sort = [] self.X_sort = [] self.V_sort = [] self.U_sort = [] for i in range(128): for chn in apa_femb_loc: if int(chn[1][0:3]) == i : self.All_sort.append(chn) for chn in apa_femb_loc: if chn[0][0] == "X" and int(chn[0][1:3]) == i : self.X_sort.append(chn) for chn in apa_femb_loc: if chn[0][0] == "V" and int(chn[0][1:3]) == i : self.V_sort.append(chn) for chn in apa_femb_loc: if chn[0][0] == "U" and int(chn[0][1:3]) == i : self.U_sort.append(chn) self.WireDict = {} for line in self.All_sort: key = "wib{:d}_femb{:d}_chip{:d}_chan{:02d}".format(line[5],line[4],line[2],line[3]) self.WireDict[key] = line[0] def printParameters(self): print("FEMB # \t",self.fembNum) print("Room temperature \t",self.isRoomTemp) print("Do resync \t",self.doReSync) print("FE-ASIC leakage \t",self.feasicLeakage) print("FE-ASIC leakage x10\t",self.feasicLeakagex10) print("FE-ASIC AD/DC \t",self.feasicAcdc) print("FE-ASIC test input \t",self.feasicEnableTestInput) print("FE-ASIC baseline \t",self.feasicBaseline) print("FE-ASIC gain \t",self.feasicGain) print("FE-ASIC shape \t",self.feasicShape) print("FE-ASIC buffer \t",self.feasicBuf) print("FE-ASIC config") for regNum in range(self.REG_SPI_BASE,self.REG_SPI_BASE+72,1): regVal = self.femb.read_reg( regNum) if regVal == None: continue print( str(regNum) + "\t" + str(hex(regVal)) ) def resetBoard(self): print("Reset") def initBoard(self): self.initWib() for femb in range(0,4,1): self.selectFemb(femb) self.initFemb() def initWib(self): #WIB initialization self.wib_switch() #set UDP ports to WIB registers self.wib_reg_enable() #register 2, LED #self.femb.write_reg_bits(2 , 0, 0xFF, 0 ) #set jumbo size #self.femb.write_reg(0x1F,0xEFB) #set external clock self.femb.write_reg(0x4, 8) self.femb.write_reg(16,0x7F00) self.femb.write_reg(15,0) #sync timestamp /WIB self.femb.write_reg(1,0) self.femb.write_reg(1,0) self.femb.write_reg(1,2) self.femb.write_reg(1,2) self.femb.write_reg(1,0) self.femb.write_reg(1,0) #Reset error /WIB self.femb.write_reg(18, 0x8000) self.femb.write_reg(18, 0x8000) #return register interface to FEMB self.selectFemb(self.fembNum) def initFemb(self): fembVal = self.fembNum - 4*(self.wibNum) if (fembVal < 0) or (fembVal >= self.NFEMBS ): return print("Initialize FEMB",fembVal) #FEMB power enable on WIB self.powerOnFemb(fembVal) #Make sure register interface is for correct FEMB self.selectFemb(fembVal) #check if FEMB register interface is working print("Checking register interface") regVal = self.femb.read_reg(6) if (regVal == None) or (regVal == -1): # try again self.powerOffFemb(fembVal) time.sleep(10) self.powerOnFemb(fembVal) newregVal = self.femb.read_reg(6) if (newregVal == None) or (newregVal == -1): print("Error - FEMB register interface is not working.") print(" Will not initialize FEMB.") return checkFirmware = self.checkFirmwareVersion() if checkFirmware == False: # try again self.powerOffFemb(fembVal) time.sleep(10) self.powerOnFemb(fembVal) newcheckFirmware = self.checkFirmwareVersion() if newcheckFirmware == False: print("Error - invalid firmware, will not attempt to initialize board") return #turn off pulser self.femb.write_reg_bits( self.REG_FPGA_TP_EN, 0,0x1,0) #test pulse enable self.femb.write_reg_bits( self.REG_ASIC_TP_EN, 1,0x1,0) #test pulse enable self.femb.write_reg_bits( self.REG_DAC_SELECT, 8,0x1,0) #test pulse enable self.femb.write_reg_bits( self.REG_TP, 0,0x1F,0x00) #test pulse amplitude self.femb.write_reg_bits( self.REG_TP, 16,0xFFFF,0x100) #test pulse frequency self.femb.write_reg_bits( self.REG_TP, 8,0xFF,0x00) #test pulse delay #Timestamp reset self.femb.write_reg(0, 4) self.femb.write_reg(0, 4) #Reset SPI self.femb.write_reg(self.REG_ASIC_RESET,1) self.femb.write_reg(self.REG_ASIC_RESET,1) self.femb.write_reg(self.REG_ASIC_RESET,2) self.femb.write_reg(self.REG_ASIC_RESET,2) self.femb.write_reg(self.REG_TEST_PAT, self.REG_TEST_PAT_DATA) #Turn off readback checking for ASIC config self.femb.doReadBack = False #ADC Setup self.set_cots_shift() #Set ASIC SPI configuration registers self.configFeAsic() #check ASIC SPI self.checkFembSpi() print("SPI STATUS","\t",self.spiStatus) #Enable Streaming self.femb.write_reg(9,9) self.femb.write_reg(9,9) time.sleep(0.1) # write to WIB self.wib_reg_enable() # check link status retry_links = False link_status = self.femb.read_reg(0x21) if (fembVal == 0): femb_link = link_status & 0xFF elif (fembVal == 1): femb_link = (link_status & 0xFF00)>>8 elif (fembVal == 2): femb_link = (link_status & 0xFF0000)>>16 elif (fembVal == 3): femb_link = (link_status & 0xFF000000)>>24 if (not femb_link): retry_links = True else: print("HS links enabled") if (retry_links): #Enable Streaming self.selectFemb(fembVal) self.femb.write_reg(9,9) self.femb.write_reg(9,9) time.sleep(2) self.wib_reg_enable() print("linkstatus",hex(link_status)) if (fembVal == 0): femb_link = link_status & 0xFF elif (fembVal == 1): femb_link = (link_status & 0xFF00)>>8 elif (fembVal == 2): femb_link = (link_status & 0xFF0000)>>16 elif (fembVal == 3): femb_link = (link_status & 0xFF000000)>>24 if (not femb_link): print("HS link error, LINK STATUS:",hex(femb_link)) return else: print("HS links enabled on retry") #reset the error counters self.femb.write_reg(20,3) self.femb.write_reg(20,3) time.sleep(0.001) self.femb.write_reg(20,0) self.femb.write_reg(20,0) time.sleep(0.001) # start streaming data from ASIC 0 in initialization self.femb.write_reg(7, 0x80000000) self.femb.write_reg(7, 0x80000000) femb_asic = 0 & 0x0F wib_asic = (((fembVal << 16)&0x000F0000) + ((femb_asic << 8) &0xFF00)) self.femb.write_reg(7, wib_asic | 0x80000000) self.femb.write_reg(7, wib_asic | 0x80000000) self.femb.write_reg(7, wib_asic) self.femb.write_reg(7, wib_asic) # return to FEMB control self.selectFemb(fembVal) #Print some happy messages for shifters print("Finished initializing ASICs for WIB{:d} FEMB{:d}".format(self.wibNum,fembVal)) #Test FEMB SPI working def checkFembSpi(self): print("Check ASIC SPI") self.spiStatus = 0 for k in range(2): #Disable streaming self.femb.write_reg(9, 0x0) time.sleep(0.01) i = 0 for regNum in range(self.REG_SPI_BASE,self.REG_SPI_BASE+len(self.fe_REGS),1): self.femb.write_reg( regNum, self.fe_REGS[i]) i += 1 time.sleep(0.01) self.femb.write_reg( self.REG_ASIC_SPIPROG, 1) if (k==1): for j in range(3): self.spiStatus = 0 time.sleep(0.01) readvals = [] for regNum in range(self.REG_SPI_RDBACK_BASE,self.REG_SPI_RDBACK_BASE+len(self.fe_REGS),1): rdbckVal = self.femb.read_reg( regNum) if rdbckVal == None : print("Error - FEMB register interface is not working.") return else: readvals.append(rdbckVal) time.sleep(0.001) for i in range(len(self.fe_REGS)): if self.fe_REGS[i] != readvals[i] : print(hex(self.fe_REGS[i]),"\t",hex(readvals[i])) print("SPI readback failed.") self.spiStatus = 1 if self.spiStatus == 1: return self.femb.write_reg(9, 9) self.femb.write_reg(9, 9) time.sleep(0.1) def checkSync(self): print("Check ASIC SYNC") regVal = self.femb.read_reg(6) if regVal == None: print("doAsicConfigcheckFembSpi: Could not check SYNC status, bad") return syncVal = ((regVal >> 16) & 0xFFFF) self.syncStatus = syncVal #Setup talking to WIB def wib_switch(self): #Set IP addresses based in wib number: #For SBND-LArIAT #iplist = ["131.225.150.203","131.225.150.206"] #For BNL testing iplist = ["192.168.121.1"] self.femb.UDP_IP = iplist[self.wibNum] def wib_reg_enable(self): self.femb.UDP_PORT_WREG = 32000 self.femb.UDP_PORT_RREG = 32001 self.femb.UDP_PORT_RREGRESP = 32002 self.femb.REG_SLEEP = 0.001 #COTS Shift and Phase Settings def set_cots_shift(self): if self.isRoomTemp: print("Setting COTS Shifts for RT") self.femb.write_reg(21,self.fe1_sft_RT) self.femb.write_reg(29,self.fe1_pha_RT) self.femb.write_reg(22,self.fe2_sft_RT) self.femb.write_reg(30,self.fe2_pha_RT) self.femb.write_reg(23,self.fe3_sft_RT) self.femb.write_reg(31,self.fe3_pha_RT) self.femb.write_reg(24,self.fe4_sft_RT) self.femb.write_reg(32,self.fe4_pha_RT) self.femb.write_reg(25,self.fe5_sft_RT) self.femb.write_reg(33,self.fe5_pha_RT) self.femb.write_reg(26,self.fe6_sft_RT) self.femb.write_reg(34,self.fe6_pha_RT) self.femb.write_reg(27,self.fe7_sft_RT) self.femb.write_reg(35,self.fe7_pha_RT) self.femb.write_reg(28,self.fe8_sft_RT) self.femb.write_reg(36,self.fe8_pha_RT) else: print("Setting COTS Shifts for CT") self.femb.write_reg(21,self.fe1_sft_CT) self.femb.write_reg(29,self.fe1_pha_CT) self.femb.write_reg(22,self.fe2_sft_CT) self.femb.write_reg(30,self.fe2_pha_CT) self.femb.write_reg(23,self.fe3_sft_CT) self.femb.write_reg(31,self.fe3_pha_CT) self.femb.write_reg(24,self.fe4_sft_CT) self.femb.write_reg(32,self.fe4_pha_CT) self.femb.write_reg(25,self.fe5_sft_CT) self.femb.write_reg(33,self.fe5_pha_CT) self.femb.write_reg(26,self.fe6_sft_CT) self.femb.write_reg(34,self.fe6_pha_CT) self.femb.write_reg(27,self.fe7_sft_CT) self.femb.write_reg(35,self.fe7_pha_CT) self.femb.write_reg(28,self.fe8_sft_CT) self.femb.write_reg(36,self.fe8_pha_CT) self.femb.write_reg(8,0) self.femb.write_reg(8,0) time.sleep(0.02) self.femb.write_reg(8,0x10) self.femb.write_reg(8,0x10) #FEMB power enable on WIB def powerOnFemb(self,femb): fembVal = int(femb) if (fembVal < 0) or (fembVal > 3 ): return #set UDP ports to WIB registers self.wib_reg_enable() # read back existing power setting oldVal = self.femb.read_reg(8) #print("oldVal",oldVal) #FEMB power enable if(fembVal == 0): regVal = 0x31000F if(fembVal == 1): regVal = 0x5200F0 if(fembVal == 2): regVal = 0x940F00 if(fembVal == 3): regVal = 0x118F000 pwrVal = regVal | oldVal self.femb.write_reg(8,0) time.sleep(1) self.femb.write_reg(8, pwrVal) time.sleep(2) regVal = self.femb.read_reg(8) if regVal == None: return print("FEMB Power on: ", hex(regVal)) #set UDP ports back to normal self.selectFemb(self.fembNum) def powerOffFemb(self,femb): fembVal = int(femb) if (fembVal < 0) or (fembVal > 3 ): return #set UDP ports to WIB registers self.wib_reg_enable() # read back existing power setting oldVal = self.femb.read_reg(8) regVal = 0 #FEMB power disable if(fembVal == 0 and (oldVal & 0xF) != 0): regVal = 0x31000F if(fembVal == 1 and (oldVal & 0xF0)>>4 != 0): regVal = 0x5200F0 if(fembVal == 2 and (oldVal & 0xF00)>>8 != 0): regVal = 0x940F00 if(fembVal == 3 and (oldVal & 0xF000)>>16 != 0): regVal = 0x118F000 pwrVal = 0x100000 | (regVal ^ oldVal) self.femb.write_reg(8, pwrVal) regVal = self.femb.read_reg(8) if regVal == None: return print("FEMB Power off: ", hex(regVal)) #set UDP ports back to normal self.selectFemb(self.fembNum) def selectChannel(self,asic,chan): #print("Select channel") asicVal = int(asic) if (asicVal < 0 ) or (asicVal > self.NASICS): return #print("asicVal",asicVal) fembVal = self.fembNum #print("fembVal",fembVal) #set UDP ports to WIB self.wib_reg_enable() # start streaming data from ASIC 0 in initialization self.femb.write_reg(7, 0x80000000) self.femb.write_reg(7, 0x80000000) femb_asic = asicVal & 0x0F wib_asic = (((fembVal << 16)&0x000F0000) + ((femb_asic << 8) &0xFF00)) self.femb.write_reg(7, wib_asic | 0x80000000) self.femb.write_reg(7, wib_asic | 0x80000000) self.femb.write_reg(7, wib_asic) self.femb.write_reg(7, wib_asic) #select ASIC #print("Selecting ASIC " + str(asicVal) ) self.femb.write_reg_bits(self.REG_SEL_ASIC , self.REG_SEL_ASIC_LSB, 0xF, asicVal ) #Note: WIB data format streams all 16 channels, don't need to select specific channel # return to FEMB control self.selectFemb(fembVal) #Enable Streaming self.femb.write_reg(9,9) self.femb.write_reg(9,9) time.sleep(0.1) def configFeAsic(self): print("CONFIG ASICs") # #global config varibles feasicLeakageVal = int( self.feasicLeakage ) #0 = 500pA, 1 = 100pA feasicLeakagex10Val = int( self.feasicLeakagex10 ) #0 = x1, 1 = x10 acdcVal = int( self.feasicAcdc ) #DC = 0, AC = 1 #channel specific variables testVal = int( self.feasicEnableTestInput ) baseVal = int( self.feasicBaseline ) #0 = 900mV, 1 = 200mV gainVal = int( self.feasicGain ) shapeVal = int( self.feasicShape ) bufVal = int( self.feasicBuf ) #0 = OFF, 1 = ON if (testVal < 0 ) or (testVal > 1): return if (baseVal < 0 ) or (baseVal > 1): return if (gainVal < 0 ) or (gainVal > 3): return if (shapeVal < 0 ) or (shapeVal > 3): return if (acdcVal < 0 ) or (acdcVal > 1): return if (bufVal < 0 ) or (bufVal > 1): return if (feasicLeakageVal < 0 ) or (feasicLeakageVal > 1 ): return if (feasicLeakagex10Val < 0) or (feasicLeakagex10Val > 1): return #gain gainArray = [0,2,1,3] #00=4.7, 10=7.8, 01=14, 11=25 gainValCorrect = gainArray[gainVal] #shape shapeArray = [2,0,3,1] #00=1.0, 10=0.5, 01=3.0, 11=2.0 shapeValCorrect = shapeArray[shapeVal] #datashift if self.isRoomTemp == True: self.femb.write_reg_bits(self.CLK_SELECT , 0, 0xFF, self.CLKSELECT_val_RT ) #clock select self.femb.write_reg_bits(self.CLK_SELECT2 , 0, 0xFF, self.CLKSELECT2_val_RT ) #clock select 2 else: self.femb.write_reg_bits(self.CLK_SELECT , 0, 0xFF, self.CLKSELECT_val_CT ) #clock select self.femb.write_reg_bits(self.CLK_SELECT2 , 0, 0xFF, self.CLKSELECT2_val_CT ) #clock select 2 self.femb.write_reg_bits(self.REG_LATCHLOC_3_TO_0 , 0, 0xFFFFFFFF, self.REG_LATCHLOC_3_TO_0_val ) self.femb.write_reg_bits(self.REG_LATCHLOC_7_TO_4 , 0, 0xFFFFFFFF, self.REG_LATCHLOC_7_TO_4_val ) #COTS Register Settings sts = testVal snc = baseVal sg = gainValCorrect st = shapeValCorrect smn = 0 #Output monitor enabled: not currently an option in femb_python so keep at 0 for now sdf = bufVal chn_reg = ((sts&0x01)<<7) + ((snc&0x01)<<6) + ((sg&0x03)<<4) + ((st&0x03)<<2) + ((smn&0x01)<<1) + ((sdf&0x01)<<0) #COTS Global Register Settings slk0 = feasicLeakageVal stb1 = 0 #Monitors not currently used in femb_python stb = 0 #Monitors not currently used in femb_python s16 = 0 #High filter in channel 16 disabled slk1 = feasicLeakagex10Val sdc = acdcVal swdac = 0 #For pulser, set elsewhere dac = 0 #For pulser, set elsewhere global_reg = ((slk0&0x01)<<0) + ((stb1&0x01)<<1) + ((stb&0x01)<<2)+ ((s16&0x01)<<3) + ((slk1&0x01)<<4) + ((sdc&0x01)<<5) +((00&0x03)<<6) dac_reg = (((dac&0x01)//0x01)<<7)+(((dac&0x02)//0x02)<<6)+\ (((dac&0x04)//0x04)<<5)+(((dac&0x08)//0x08)<<4)+\ (((dac&0x10)//0x10)<<3)+(((dac&0x20)//0x20)<<2)+\ (((swdac&0x03))<<0) for chip in range(self.NASICS): for chn in range(self.NASICCH): if self.useLArIATmap: key = "wib{:d}_femb{:d}_chip{:d}_chan{:02d}".format(self.wibNum,self.fembNum,chip+1,chn) #Note map has chips 1-8, not 0-7 if self.WireDict[key][0] == "X": snc = 0 #set baseline for collection elif self.WireDict[key][0] == "U": snc = 1 #set baseline for induction chn_reg = ((sts&0x01)<<7) + ((snc&0x01)<<6) + ((sg&0x03)<<4) + ((st&0x03)<<2) + ((smn&0x01)<<1) + ((sdf&0x01)<<0) #print("chip",chip,"channel",chn,"chn_reg",hex(chn_reg)) chn_reg_bool = [] for j in range(8): chn_reg_bool.append ( bool( (chn_reg>>j)%2 )) start_pos = (8*16+16)*chip + (16-chn)*8 self.fe_regs[start_pos-8 : start_pos] = chn_reg_bool global_reg_bool = [] for j in range(8): global_reg_bool.append ( bool( (global_reg>>j)%2 ) ) for j in range(8): global_reg_bool.append ( bool( (dac_reg>>j)%2 ) ) start_pos = (8*16+16)*chip + 16*8 self.fe_regs[start_pos : start_pos+16] = global_reg_bool #Convert bits to 36 32-bit register words for chip in [0,2,4,6]: chip_bits_len = 8*(16+2) chip_fe_regs0 = self.fe_regs[ chip*chip_bits_len: (chip+1)* chip_bits_len] chip_fe_regs1 = self.fe_regs[ (chip+1)*chip_bits_len: (chip+2)* chip_bits_len] chip_regs = [] for onebit in chip_fe_regs0: chip_regs.append(onebit) for onebit in chip_fe_regs1: chip_regs.append(onebit) len32 = len(chip_regs)//32 if (len32 != 9): print("ERROR FE register mapping") else: for i in range(len32): if ( i*32 <= len(chip_regs) ): bits32 = chip_regs[i*32: (i+1)*32] self.fe_REGS[int(chip/2*len32 + i) ] = (sum(v<<j for j, v in enumerate(bits32))) #turn off HS data before register writes self.femb.write_reg_bits(9 , 0, 0x1, 0 ) print("HS link turned off") time.sleep(1) #run the SPI programming self.doAsicConfig() #turn HS link back on print("HS link turned back on") self.femb.write_reg_bits(9 , 0, 0x1, 1 ) time.sleep(1) def doAsicConfig(self): print("Program ASIC SPI") for k in range(2): #Disable streaming self.femb.write_reg(9, 0x0) time.sleep(0.01) i = 0 for regNum in range(self.REG_SPI_BASE,self.REG_SPI_BASE+len(self.fe_REGS),1): self.femb.write_reg( regNum, self.fe_REGS[i]) self.femb.write_reg( regNum+36, self.fe_REGS[i]) i += 1 time.sleep(0.01) self.femb.write_reg( self.REG_ASIC_SPIPROG, 1) #self.printParameters() #Enable streaming self.femb.write_reg(9, 9) self.femb.write_reg(9, 9) time.sleep(0.1) def selectFemb(self, fembIn): fembVal = int( fembIn) if (fembVal < 0) or (fembVal > self.NFEMBS ): print("Invalid FEMB # requested") return self.fembNum = fembVal #print("selecting FEMB",fembVal) #set read/write ports if fembVal == 0: self.femb.UDP_PORT_WREG = 32016 self.femb.UDP_PORT_RREG = 32017 self.femb.UDP_PORT_RREGRESP = 32018 if fembVal == 1: self.femb.UDP_PORT_WREG = 32032 self.femb.UDP_PORT_RREG = 32033 self.femb.UDP_PORT_RREGRESP = 32034 if fembVal == 2: self.femb.UDP_PORT_WREG = 32048 self.femb.UDP_PORT_RREG = 32049 self.femb.UDP_PORT_RREGRESP = 32050 if fembVal == 3: self.femb.UDP_PORT_WREG = 32064 self.femb.UDP_PORT_RREG = 32065 self.femb.UDP_PORT_RREGRESP = 32066 #self.femb.write_reg(0, femb_asic) self.femb.write_reg(self.REG_HS,1) #slow down register interface for FEMBs self.femb.REG_SLEEP = 0.05 time.sleep(0.1) def setFpgaPulser(self,enable,dac): enableVal = int(enable) print("set FPGA pulser",enableVal) if (enableVal < 0 ) or (enableVal > 1 ) : print( "femb_config_femb : setFpgaPulser - invalid enable value") return dacVal = int(dac) if ( dacVal < 0 ) or ( dacVal > 0x3F ) : print( "femb_config_femb : setFpgaPulser - invalid dac value") return self.femb.write_reg_bits( self.REG_FPGA_TP_EN, 0,0x3,enableVal) #test pulse enable self.femb.write_reg_bits( self.REG_FPGA_TP_EN, 8,0x1,enableVal) #test pulse enable self.femb.write_reg_bits( self.REG_TP , 0, 0x3F, dacVal ) #TP Amplitude self.femb.write_reg_bits( self.REG_TP , 8, 0xFF, 219 ) #DLY self.femb.write_reg_bits( self.REG_TP , 16, 0xFFFF, 497 ) #FREQ #set pulser enable bit if enableVal == 1 : self.femb.write_reg( self.EXT_TP_EN, 0x2) #this register is confusing, check else : self.femb.write_reg( self.EXT_TP_EN, 0x3) #pulser disabled #connect channel test input to external pin firstfourasics = int(self.NASICS/2) for asic in range(0,firstfourasics,1): baseReg = int(asic)*9 self.fe_REGS[baseReg+4] = self.fe_REGS[baseReg+4] & 0xFFFF0000 self.fe_REGS[baseReg+8] = self.fe_REGS[baseReg+8] & 0x0000FFFF if enableVal == 1: self.fe_REGS[baseReg+4] = self.fe_REGS[baseReg+4] | 0x2<<8 self.fe_REGS[baseReg+8] = self.fe_REGS[baseReg+8] | 0x2<<24 self.doAsicConfig() def setInternalPulser(self,enable,dac): enableVal = int(enable) print("set ASIC pulser",enableVal) if (enableVal < 0 ) or (enableVal > 1 ) : print( "femb_config_femb : setInternalPulser - invalid enable value") return dacVal = int(dac) if ( dacVal < 0 ) or ( dacVal > 0x3F ) : print( "femb_config_femb : setInternalPulser - invalid dac value") return self.femb.write_reg_bits( self.REG_DAC_SELECT, 8, 0x1, 0) #test pulse enable self.femb.write_reg_bits( self.REG_TP , 0, 0x3F, 0 ) #TP Amplitude self.femb.write_reg_bits( self.REG_TP , 8, 0xFF, 219 ) #DLY self.femb.write_reg_bits( self.REG_TP , 16, 0xFFFF, 497 ) #FREQ #set pulser enable bit if enableVal == 1 : self.femb.write_reg( self.INT_TP_EN, 0x2) #this register is confusing, check else : self.femb.write_reg( self.INT_TP_EN, 0x3) #pulser disabled dacVal = (dacVal & 0x3F) newDacVal = int('{:08b}'.format(dacVal)[::-1], 2) asicWord = ((newDacVal << 8 ) & 0xFFFF) if enableVal == 1 : asicWord = asicWord + (0x1 << 8) #print(hex(asicWord)) #connect channel test input to external pin firstfourasics = int(self.NASICS/2) for asic in range(0,firstfourasics,1): baseReg = int(asic)*9 self.fe_REGS[baseReg+4] = self.fe_REGS[baseReg+4] & 0xFFFF0000 self.fe_REGS[baseReg+8] = self.fe_REGS[baseReg+8] & 0x0000FFFF if enableVal == 1: self.fe_REGS[baseReg+4] = self.fe_REGS[baseReg+4] | asicWord self.fe_REGS[baseReg+8] = self.fe_REGS[baseReg+8] | asicWord<<16 self.doAsicConfig() if enableVal == 1: self.femb.write_reg_bits( self.REG_ASIC_TP_EN , 0, 0x3, 0x2 ) #NOTE, also disabling FPGA pulser here else: self.femb.write_reg_bits( self.REG_ASIC_TP_EN , 0, 0x3, 0x0 ) def checkFirmwareVersion(self): #set UDP ports to WIB self.wib_reg_enable() #check WIB fw version reg wibVerReg = self.femb.read_reg(255) if wibVerReg == None : return False wibVerReg = (wibVerReg & 0xFFF) #set UDP ports back to normal self.selectFemb(self.fembNum) fembVerReg = self.femb.read_reg(257) if fembVerReg == None : return False fembVerReg = (fembVerReg & 0xFFF) if wibVerReg != 0x122 and wibVerReg != 0x111: print("Invalid WIB firmware version detected",hex(wibVerReg),"this configuration requires version 0x108 or 0x111") return False if fembVerReg != 0x501 : print("Invalid FEMB firmware version detected",hex(fembVerReg),"this configuration requires version 0x501") return False print( "WIB Firmware Version: " + str(hex(wibVerReg)) ) print( "FEMB Firmware Version: " + str(hex(fembVerReg)) ) #good firmware id return True def readCurrent(self): self.femb.UDP_PORT_WREG = 32000 #WIB PORTS self.femb.UDP_PORT_RREG = 32001 self.femb.UDP_PORT_RREGRESP = 32002 for j in range(0,100): self.femb.write_reg(5,0) self.femb.write_reg(5,0x10000) self.femb.write_reg(5,0) time.sleep(0.01) results = [] for pwrSel in range(1,25): self.femb.write_reg(5,pwrSel) time.sleep(0.1) regVal = self.femb.read_reg(6) if regVal == None: results.append(0) continue #return None val = regVal & 0xFFFFFFFF results.append(val) self.selectFemb(0) return results
class FEMB_TEST(object): def __init__(self): #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA() #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 self.fembNum = 0 self.cppfr = CPP_FILE_RUNNER() def check_setup(self): #CHECK STATUS AND INITIALIZATION print("SIMPLE MEASUREMENT - CHECKING READOUT STATUS") self.status_check_setup = 0 #check local directory structure, available space if os.path.isdir("./data") == False: print("Error running doFembTest - data directory not found.") print( " Please check that femb_python package directory structure is intact." ) return #select femb self.femb_config.selectFemb(self.fembNum) #check if register interface is working print("Checking register interface") regVal = self.femb_config.femb.read_reg(5) if (regVal == None) or (regVal == -1): print( "Error running doFembTest - FEMB register interface is not working." ) print(" Turn on or debug FEMB UDP readout.") return print("Read register 5, value = " + str(hex(regVal))) #for regNum in range (0,1024,1): # regVal = self.femb_config.femb.read_reg(regNum) # print(str(regNum) + "\t" + str( hex( regVal ) ) ) #initialize FEMB to known state print("Initializing board") self.femb_config.initFemb(self.fembNum) #check if data streaming is working print("Checking data streaming") testData = self.write_data.femb.get_data_packets(1) if testData == None: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") #print(" This script will exit now") #sys.exit(0) return if len(testData) == 0: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") #print(" This script will exit now") #sys.exit(0) return print("Received data packet " + str(len(testData[0])) + " bytes long") #check for analysis executables if not self.cppfr.exists( 'test_measurements/wibTestStand/parseBinaryFile'): print('parseBinaryFile not found, run setup.sh') #sys.exit(0) return print("SIMPLE MEASUREMENT - READOUT STATUS OK" + "\n") self.status_check_setup = 1 def record_data(self): if self.status_check_setup == 0: print("Please run check_setup method before trying to take data") return if self.status_record_data == 1: print( "Data already recorded. Reset/restat GUI to begin a new measurement" ) return #MEASUREMENT SECTION print("SIMPLE MEASUREMENT - RECORDING DATA") #initialize FEMB configuration to known state #self.femb_config.configFeAsic(0,0,0) #wait to make sure HS link is back on sleep(0.5) #set output file self.write_data.filedir = "data/" self.write_data.filename = "rawdata_simpleMeasurement_" + str( self.write_data.date) + ".bin" print("Recording " + self.write_data.filename) self.write_data.numpacketsrecord = 100 self.write_data.run = 0 self.write_data.runtype = 0 self.write_data.runversion = 0 #setup output file and record data self.write_data.open_file() subrun = 0 asicCh = 0 for asic in range(0, 8, 1): self.femb_config.selectChannel(asic, asicCh) self.write_data.record_data(subrun, asic, asicCh) self.write_data.close_file() #reset configuration to known state #self.femb_config.configFeAsic(0,0,0) print("SIMPLE MEASUREMENT - DONE RECORDING DATA" + "\n") self.status_record_data = 1 def do_analysis(self): if self.status_record_data == 0: print("Please record data before analysis") return if self.status_do_analysis == 1: print("Analysis already complete") return #ANALYSIS SECTION print("SIMPLE MEASUREMENT - ANALYZING AND SUMMARIZING DATA") #parse binary self.cppfr.run( 'test_measurements/wibTestStand/parseBinaryFile', [str(self.write_data.filedir) + str(self.write_data.filename)]) #run analysis program newName = "output_parseBinaryFile_" + self.write_data.filename + ".root" call([ "mv", "output_parseBinaryFile.root", str(self.write_data.filedir) + str(newName) ]) self.cppfr.run( "test_measurements/wibTestStand/processNtuple_simpleMeasurement", [str(self.write_data.filedir) + str(newName)]) #move result to data directory newName = "output_processNtuple_simpleMeasurement_" + self.write_data.filename + ".root" call([ "mv", "output_processNtuple_simpleMeasurement.root", str(self.write_data.filedir) + str(newName) ]) newName = "summaryPlot_" + self.write_data.filename + ".png" call([ "mv", "summaryPlot_simpleMeasurement.png", str(self.write_data.filedir) + str(newName) ]) #summary plot print( "SIMPLE MEASUREMENT - DISPLAYING SUMMARY PLOT, CLOSE PLOT TO CONTINUE" ) call(["display", str(self.write_data.filedir) + str(newName)]) print("SIMPLE MEASUREMENT - DONE ANALYZING AND SUMMARIZING DATA" + "\n") self.status_do_analysis = 1 def archive_results(self): if self.status_do_analysis == 0: print("Please analyze data before archiving results") return if self.status_archive_results == 1: print("Results already archived") return #ARCHIVE SECTION print("SIMPLE MEASUREMENT - STORE RESULTS IN DATABASE") #placeholder print("SIMPLE MEASUREMENT - DONE STORING RESULTS IN DATABASE" + "\n") self.status_archive_results = 1
class FEMB_TEST_GAIN(object): def __init__(self, datadir="data", outlabel="gainMeasurement",fembNum=0): #set internal variables self.datadir = datadir self.outlabel = outlabel + str("_femb_") + str(fembNum) self.outpathlabel = os.path.join(self.datadir, self.outlabel) self.fembNum = int(fembNum) print( "FEMB # " + str(fembNum) ) #import femb_udp modules from femb_udp package self.femb_config = CONFIG() self.write_data = WRITE_DATA(self.datadir) #set appropriate packet size self.write_data.femb.MAX_PACKET_SIZE = 8000 self.cppfr = CPP_FILE_RUNNER() #set status variables self.status_check_setup = 0 self.status_record_data = 0 self.status_do_analysis = 0 self.status_archive_results = 0 #misc variables self.gain = 0 self.shape = 0 self.base = 0 self.leakage = 0 self.leakagex10 = 0 self.buffer = 0 self.acdc = 0 self.useInternalPulser = False self.useExtAdcClock = False self.isRoomTemp = False #json output, note module version number defined here self.jsondict = {'type':'fembTest_gain'} self.jsondict['version'] = '1.0' self.jsondict['timestamp'] = str(self.write_data.date) def check_setup(self): #CHECK STATUS AND INITIALIZATION print("GAIN MEASUREMENT - CHECKING READOUT STATUS") self.status_check_setup = 0 #make sure output directory exists self.write_data.assure_filedir() #check if register interface is working print("Checking register interface") regVal = self.femb_config.femb.read_reg(6) if (regVal == None): print("Error running doFembTest - FEMB register interface is not working.") print(" Turn on or debug FEMB UDP readout.") return if ( regVal < 0 ): print("Error running doFembTest - FEMB register interface is not working.") print(" Turn on or debug FEMB UDP readout.") return print("Read register 6, value = " + str( hex( regVal ) ) ) #check that femb number is valid if ( int(self.fembNum) < 0 ) or ( int( self.fembNum) >= self.femb_config.NFEMBS ): print("Error running doFembTest - Invalid FEMB # specified.") return #assign FEMB # to test self.femb_config.selectFemb(self.fembNum) #initialize FEMB to known state print("Initializing board") self.femb_config.feasicGain = self.gain self.femb_config.feasicShape = self.shape self.femb_config.feasicBaseline = self.base self.femb_config.feasicLeakageVal = self.leakage self.femb_config.feasicLeakagex10Val = self.leakagex10 self.femb_config.bufVal = self.buffer self.femb_config.acdcVal = self.acdc self.femb_config.feasicEnableTestInput = 0 #important self.femb_config.useExtAdcClock = self.useExtAdcClock self.femb_config.isRoomTemp = self.isRoomTemp #self.femb_config.printParameters() self.femb_config.initFemb() #test firmware versions if self.femb_config.checkFirmwareVersion() == False: print('Error running doFembTest - Invalid firmware and/or register read error') return #check if data streaming is working print("Checking data streaming") testData = self.write_data.femb.get_data_packets(1) if testData == None: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") return if len(testData) == 0: print("Error running doFembTest - FEMB is not streaming data.") print(" Turn on and initialize FEMB UDP readout.") return print("Received data packet " + str(len(testData[0])) + " bytes long") #check for analysis executables if not self.cppfr.exists('test_measurements/fembTest/code/parseBinaryFile'): print('parseBinaryFile not found, run setup.sh') return print("GAIN MEASUREMENT - READOUT STATUS OK" + "\n") self.status_check_setup = 1 def record_data(self): if self.status_check_setup == 0: print("Please run check_setup method before trying to take data") return if self.status_record_data == 1: print("Data already recorded. Reset/restat GUI to begin a new measurement") return #MEASUREMENT SECTION print("GAIN MEASUREMENT - RECORDING DATA") #wait to make sure HS link is back on after check_setup sleep(5) #setup output file self.write_data.filename = self.outlabel+".bin" print("Recording " + self.write_data.filename ) isOpen = self.write_data.open_file() if isOpen == 0 : print( "Error running doFembTest - Could not open output data file for writing, ending test" ) subrun = 0 #config FE ASICs print("FE ASIC Settings: Gain " + str(self.gain) + ", Shaping Time " + str(self.shape) + ", Baseline " + str(self.base) ) print("FE ASIC Settings: Leakage Current " + str(self.leakage) + ", Leakage x10 " + str(self.leakagex10) ) print("FE ASIC Settings: Output Buffer " + str(self.buffer) + ", AC/DC " + str(self.acdc) ) self.femb_config.feasicGain = self.gain self.femb_config.feasicShape = self.shape self.femb_config.feasicBaseline = self.base self.femb_config.feasicLeakageVal = self.leakage self.femb_config.feasicLeakagex10Val = self.leakagex10 self.femb_config.bufVal = self.buffer self.femb_config.acdcVal = self.acdc self.femb_config.feasicEnableTestInput = 0 #important self.femb_config.useExtAdcClock = self.useExtAdcClock self.femb_config.isRoomTemp = self.isRoomTemp self.femb_config.configFeAsic() #disable pulsers self.femb_config.setInternalPulser(0,0x0) self.femb_config.setFpgaPulser(0,0x0) self.femb_config.printParameters() #record data self.write_data.numpacketsrecord = 500 self.write_data.run = 0 self.write_data.runtype = 0 self.write_data.runversion = 0 #take initial noise data run subrun = 0 asicCh = 0 for asic in range(0,self.femb_config.NASICS,1): self.femb_config.selectChannel(asic,asicCh) self.write_data.record_data(subrun, asic, asicCh) #turn ASIC test input on, start pulser section self.femb_config.feasicEnableTestInput = 1 self.femb_config.configFeAsic() if self.useInternalPulser == False : self.femb_config.setFpgaPulser(1,0) else: self.femb_config.setInternalPulser(1,0) subrun = 1 #loop over pulser configurations, each configuration is it's own subrun for p in range(0,10,1): pVal = int(p) if self.useInternalPulser == False : self.femb_config.setFpgaPulser(1,pVal) else: self.femb_config.setInternalPulser(1,pVal) print("Pulse amplitude " + str(pVal) ) #loop over channels for asic in range(0,8,1): self.femb_config.selectChannel(asic,asicCh) self.write_data.record_data(subrun, asic, asicCh) #increment subrun, important subrun = subrun + 1 #close file self.write_data.close_file() #turn off FEMB self.femb_config.powerOffFemb(self.fembNum) print("GAIN MEASUREMENT - DONE RECORDING DATA" + "\n") self.status_record_data = 1 def do_analysis(self): if self.status_record_data == 0: print("Please record data before analysis") return if self.status_do_analysis == 1: print("Analysis already complete") return #ANALYSIS SECTION print("GAIN MEASUREMENT - ANALYZING AND SUMMARIZING DATA") #parse binary self.cppfr.run("test_measurements/fembTest/code/parseBinaryFile", [self.write_data.data_file_path]) #run analysis program parseBinaryFile = self.outpathlabel + "-parseBinaryFile.root" call(["mv", "output_parseBinaryFile.root" , parseBinaryFile]) if self.useInternalPulser == False : self.cppfr.run("test_measurements/fembTest/code/processNtuple_gainMeasurement", [parseBinaryFile]) else : self.cppfr.run("test_measurements/fembTest/code/processNtuple_gainMeasurement", [parseBinaryFile,"1"]) processNtupleFile = self.outpathlabel + "-processNtupleFile.root" call(["mv", "output_processNtuple_gainMeasurement.root" , processNtupleFile]) summaryPlot = self.outpathlabel + "-summaryPlot.png" call(["mv", "summaryPlot_gainMeasurement.png" , summaryPlot]) resultsFile = self.outpathlabel + "-results.list" call(["mv", "output_processNtuple_gainMeasurement.list" , resultsFile]) print("GAIN MEASUREMENT - DONE ANALYZING AND SUMMARIZING DATA" + "\n") self.status_do_analysis = 1 def archive_results(self): #if self.status_check_setup == 0 : # print("Check setup status is 0, not archiving data") # return #if self.status_do_analysis == 0: # print("Please analyze data before archiving results") # return if self.status_archive_results == 1: print("Results already archived") return #ARCHIVE SECTION print("GAIN MEASUREMENT - ARCHIVE") #add summary variables to output self.jsondict['status_check_setup'] = str(self.status_check_setup) self.jsondict['status_record_data'] = str(self.status_record_data) self.jsondict['status_do_analysis'] = str(self.status_do_analysis) self.jsondict['status_archive_results'] = str(1) self.jsondict['filedir'] = str(self.write_data.filedir ) self.jsondict['config_gain'] = str(self.gain) self.jsondict['config_shape'] = str(self.shape) self.jsondict['config_base'] = str(self.base) self.jsondict['useInternalPulser'] = str(self.useInternalPulser) self.jsondict['syncStatus'] = str(self.femb_config.syncStatus) if self.status_do_analysis == 1: #parse the output results, kind of messy listFile = self.outpathlabel + "-results.list" lines = [] with open( listFile ) as infile: for line in infile: line = line.strip('\n') line = line.split(',') #measurements separated by commas parseline = {} for n in range(0,len(line),1): word = line[n].split(' ') if( len(word) != 2 ): continue parseline[ str(word[0]) ] = str(word[1]) lines.append(parseline) self.jsondict['results'] = lines #dump results into json jsonFile = self.outpathlabel + "-results.json" with open( jsonFile , 'w') as outfile: json.dump( self.jsondict, outfile, indent=4) print("GAIN MEASUREMENT - DONE STORING RESULTS IN DATABASE" + "\n") self.status_archive_results = 1