Skip to content

W
White Rabbit Calibration
Commit eefa9a9c authored by Peter Jansweijer's avatar Peter Jansweijer
Browse files
Options

added calc_sfp_timing_cal_mod.py which calculates the SFP Timing Calibration… 

added calc_sfp_timing_cal_mod.py which calculates the SFP Timing Calibration parameters form the AnalyzeScopeData.py correlation stat_result.txt files
parent b9965a45
Hide whitespace changes
Inline Side-by-side
Showing with 751 additions and 0 deletions
sw/eooe/calc_sfp_timing_cal_mod.py 0 → 100644
View file @ eefa9a9c
#!/usr/bin/python
"""
calc_sfp_timing_cal_mod.py: Analyses the stat_result files that were output by AnalyzeScopeData.py
and takes the linear correlation results to calculate the final tloop, tx_to_out an rx_to_out
delay parameters for the SFP Timing Calibration Modules
-------------------------------------------------------------------------------
Copyright (C) 2017 Peter Jansweijer, Henk Peek
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
-------------------------------------------------------------------------------
Usage:
calc_sfp_timing_cal_mod.py <dir-name>
calc_sfp_timing_cal_mod.py -h | --help
<dir-name> directory name where all AnalyzeScopeData result files are stored
sub directories start with root names:
A open reflection reference measurement
B_TXP TxP short reflection reference measurement
B_TXN TxN short reflection reference measurement
B_RXP RxP short reflection reference measurement
B_RXN RxN short reflection reference measurement
C Reference delay chain + delta_F-F
D_TXP_RXP Loopback delay via SFP Timing Calibration Module
D_TXN_RXN Loopback delay via SFP Timing Calibration Module
E_TXP_P Input to Output delay via SFP Timing Calibration Module
E_TXP_N Input to Output delay via SFP Timing Calibration Module
E_RXP_P Input to Output delay via SFP Timing Calibration Module
E_RXP_N Input to Output delay via SFP Timing Calibration Module
and may be extended with a number A_1, A_2 etc. if multiple measurement
sets were taken in order to check reproducibility after SFP Timing
Calibration Module eject/insert cycles.
Note:
Parameters A , B_TXP, B_TXN ,B_RXP, B_RXN, C belong to the calibration
setup and may be hard coded after the calibration setup is calibarted once.
Parameters D_TXP_RXP , D_TXN_RXN, E_TXP_P, E_TXP_N, E_RXP_P, E_RXP_N belong
to the SFP Timing Calibration Module.
Options:
-h --help Show this screen.
-f --full full calibration (i.e. also take measurements A , B_TXP, B_TXN ,B_RXP, B_RXN, C into account)
"""
import os
import sys
import scipy
import numpy
import matplotlib.pyplot as plt
import pdb
# Add parent directory (containing 'lib') to the module search path
lib_path = (os.path.dirname(os.path.abspath(__file__)))
lib_path = os.path.join(lib_path,"..")
sys.path.insert(0,lib_path)
############################################################################
def read_stat_result(dirname,sign="neg"):
"""
read_stat_result
dirname -- pointer to the directory that contains the stat_result.txt file
sign -- default "neg" i.e. stat_result lineair-mean values are negative due
-- to the fact that channel 1 and 3 of the oscilloscope are swapped.
returns:
fail, lin_meas
-- <Bool> fail = True when an error occurred while reading the file
-- <Tuple> lin_meas [0] = lineair-mean,
-- [1] = se,
-- [2] = sem,
"""
print(os.path.join(name,meas_dir))
if not(os.path.isdir(dirname)):
print(dirname+": is not a directory.")
return (True,nan)
stat_result_filename = os.path.join(dirname,"stat_result.txt")
if not(os.path.isfile(stat_result_filename)):
print(stat_result_filename + ": No stat_result.txt file found.")
return (True,nan)
stat_result_file = open(stat_result_filename,"r")
while 1:
# Lines look like this:
# data/data_181106_1/181106_2 lineair-mean: -6.79100959999e-10 se: 2.16707944778e-14 sem: 4.33415889555e-15 topt: 1 if line == "":
line = stat_result_file.readline()
if line == "":
break #end of file
line_lst = line.strip().split(" ")
if "lineair" in line_lst[1]:
if sign == "neg":
lin_meas = -float(line_lst[2]), float(line_lst[4]), float(line_lst[6])
else:
lin_meas = +float(line_lst[2]), float(line_lst[4]), float(line_lst[6])
return (False,lin_meas)
return (True,nan)
###########################################################################
#
# If run from commandline, we can test the library
"""
Usage:
calc_sfp_timing_cal_mod.py <dir-name>
calc_sfp_timing_cal_mod.py -h | --help
<dir-name> directory name where all AnalyzeScopeData result files are stored
sub directories start with root names:
A open reflection reference measurement
B_TXP TxP short reflection reference measurement
B_TXN TxN short reflection reference measurement
B_RXP RxP short reflection reference measurement
B_RXN RxN short reflection reference measurement
C Reference delay chain + delta_F-F
D_TXP_RXP Loopback delay via SFP Timing Calibration Module
D_TXN_RXN Loopback delay via SFP Timing Calibration Module
E_TXP_P Input to Output delay via SFP Timing Calibration Module
E_TXP_N Input to Output delay via SFP Timing Calibration Module
E_RXP_P Input to Output delay via SFP Timing Calibration Module
E_RXP_N Input to Output delay via SFP Timing Calibration Module
and may be extended with a number A_1, A_2 etc. if multiple measurement
sets were taken in order to check reproducibility after SFP Timing
Calibration Module eject/insert cycles.
Note:
Parameters A , B_TXP, B_TXN ,B_RXP, B_RXN, C belong to the calibration
setup and may be hard coded after the calibration setup is calibarted once.
Parameters D_TXP_RXP , D_TXN_RXN, E_TXP_P, E_TXP_N, E_RXP_P, E_RXP_N belong
to the SFP Timing Calibration Module.
Options:
-h --help Show this screen.
-f --full full calibration (i.e. also take measurements A , B_TXP, B_TXN ,B_RXP, B_RXN, C into account)
"""
if __name__ == "__main__":
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("name", help="directory that contains the measurement files A, B_TXP, B_TXN, B_RXP, B_RXN, C, D_TXP_RXP, D_TXN_RXN, E_TXP_P, E_TXP_N, E_RXP_P, E_RXP_N")
parser.add_argument("-f", help="full calibration (i.e. including multi SFP crate measurements.", action='store_true')
args = parser.parse_args()
name = args.name
use_pre_calibrated_setup_parameters = not bool(args.f)
files = []
# Figure out if the input files exist. Extensions should be:
files_exist = True
if not(os.path.isdir(name)):
print(name+": is not a directory.")
print("Provide the root that contains measurement subdirectories A, B_TXP, B_TXN, B_RXP, B_RXN, C, D_TXP_RXP, D_TXN_RXN, E_TXP_P, E_TXP_N, E_RXP_P, E_RXP_N")
sys.exit()
meas_dirs = os.listdir(name)
# In case there are multiple measurement (A_1, A_2,... , B_TXP_1, B_TXP_2,... etc.) then
# these will be accumulated in lists for "meas", "se" and "sem"
A_meas_lst = []
A_se_lst = []
A_sem_lst = []
B_TXP_meas_lst = []
B_TXP_se_lst = []
B_TXP_sem_lst = []
B_TXN_meas_lst = []
B_TXN_se_lst = []
B_TXN_sem_lst = []
B_RXP_meas_lst = []
B_RXP_se_lst = []
B_RXP_sem_lst = []
B_RXN_meas_lst = []
B_RXN_se_lst = []
B_RXN_sem_lst = []
C_meas_lst = []
C_se_lst = []
C_sem_lst = []
D_TXP_RXP_meas_lst = []
D_TXP_RXP_se_lst = []
D_TXP_RXP_sem_lst = []
D_TXN_RXN_meas_lst = []
D_TXN_RXN_se_lst = []
D_TXN_RXN_sem_lst = []
E_TXP_P_meas_lst = []
E_TXP_P_se_lst = []
E_TXP_P_sem_lst = []
E_TXN_N_meas_lst = []
E_TXN_N_se_lst = []
E_TXN_N_sem_lst = []
E_RXP_P_meas_lst = []
E_RXP_P_se_lst = []
E_RXP_P_sem_lst = []
E_RXN_N_meas_lst = []
E_RXN_N_se_lst = []
E_RXN_N_sem_lst = []
print("use_pre_calibrated_setup_parameters", use_pre_calibrated_setup_parameters)
# Search the directory structure and catch the "stat_result.txt" files that
# were outputted by "AnalyzeScopeData.py". Append "meas", "se" and "sem"
for meas_dir in meas_dirs:
if meas_dir[:1] == "A" and not use_pre_calibrated_setup_parameters:
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
A_meas_lst.append(meas[0])
A_se_lst.append(meas[1])
A_sem_lst.append(meas[2])
elif meas_dir[:5] == "B_TXP" and not use_pre_calibrated_setup_parameters:
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
B_TXP_meas_lst.append(meas[0])
B_TXP_se_lst.append(meas[1])
B_TXP_sem_lst.append(meas[2])
elif meas_dir[:5] == "B_TXN" and not use_pre_calibrated_setup_parameters:
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
B_TXN_meas_lst.append(meas[0])
B_TXN_se_lst.append(meas[1])
B_TXN_sem_lst.append(meas[2])
elif meas_dir[:5] == "B_RXP" and not use_pre_calibrated_setup_parameters:
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
B_RXP_meas_lst.append(meas[0])
B_RXP_se_lst.append(meas[1])
B_RXP_sem_lst.append(meas[2])
elif meas_dir[:5] == "B_RXN" and not use_pre_calibrated_setup_parameters:
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
B_RXN_meas_lst.append(meas[0])
B_RXN_se_lst.append(meas[1])
B_RXN_sem_lst.append(meas[2])
elif meas_dir[:1] == "C" and not use_pre_calibrated_setup_parameters:
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
C_meas_lst.append(meas[0])
C_se_lst.append(meas[1])
C_sem_lst.append(meas[2])
elif meas_dir[:9] == "D_TXP_RXP":
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
D_TXP_RXP_meas_lst.append(meas[0])
D_TXP_RXP_se_lst.append(meas[1])
D_TXP_RXP_sem_lst.append(meas[2])
elif meas_dir[:9] == "D_TXN_RXN":
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
D_TXN_RXN_meas_lst.append(meas[0])
D_TXN_RXN_se_lst.append(meas[1])
D_TXN_RXN_sem_lst.append(meas[2])
elif meas_dir[:7] == "E_TXP_P":
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
E_TXP_P_meas_lst.append(meas[0])
E_TXP_P_se_lst.append(meas[1])
E_TXP_P_sem_lst.append(meas[2])
elif meas_dir[:7] == "E_TXN_N":
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
E_TXN_N_meas_lst.append(meas[0])
E_TXN_N_se_lst.append(meas[1])
E_TXN_N_sem_lst.append(meas[2])
elif meas_dir[:7] == "E_RXP_P":
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
E_RXP_P_meas_lst.append(meas[0])
E_RXP_P_se_lst.append(meas[1])
E_RXP_P_sem_lst.append(meas[2])
elif meas_dir[:7] == "E_RXN_N":
fail,meas = read_stat_result(os.path.join(name,meas_dir))
if not fail:
E_RXN_N_meas_lst.append(meas[0])
E_RXN_N_se_lst.append(meas[1])
E_RXN_N_sem_lst.append(meas[2])
if use_pre_calibrated_setup_parameters:
# Hard code the delay and error for the Multi SFP Crate (port SFP0)
# Parameters taken from p:\App\ASTERICS_Cleopatra_WP5_1\WR_Calibration\wr-calibration\sw\eooe\data\data_190604\
A_meas_mean = 1.20894077e-09
A_meas_se = 9.78516962061e-15
A_se_max = 2.57716757556e-14
A_sem_max = 5.15433515112e-15
B_TXP_meas_mean = 4.61207614597e-09
B_TXP_meas_se = 7.16805399026e-14
B_TXP_se_max = 3.95850875804e-14
B_TXP_sem_max = 7.91701751608e-15
B_TXN_meas_mean = 4.61545252796e-09
B_TXN_meas_se = 1.32508667248e-13
B_TXN_se_max = 4.31867720749e-14
B_TXN_sem_max = 8.63735441498e-15
B_RXP_meas_mean = 4.96503455946e-09
B_RXP_meas_se = 4.38301316766e-14
B_RXP_se_max = 3.96830035821e-14
B_RXP_sem_max = 7.93660071642e-15
B_RXN_meas_mean = 4.96602602596e-09
B_RXN_meas_se = 1.20212384153e-13
B_RXN_se_max = 4.65143105165e-14
B_RXN_sem_max = 9.30286210331e-15
C_meas_mean = 6.88770495004e-10
C_meas_se = 0
C_se_max = 2.16409647305e-14
C_sem_max = 4.32819294609e-15
else:
# Check if all mandatory measurements are present:
try:
A_meas_arr = numpy.array(A_meas_lst)
A_se_arr = numpy.array(A_se_lst)
A_sem_arr = numpy.array(A_sem_lst)
A_meas_mean = A_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(A_meas_arr) > 1:
A_meas_se = A_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
A_meas_se = 0
A_se_max = A_se_arr.max() # Take the worse case (i.e. the maximum value) from the
A_sem_max = A_sem_arr.max() # error values
except:
print("FAIL: no file found for measurements A")
sys.exit()
try:
B_TXP_meas_arr = numpy.array(B_TXP_meas_lst)
B_TXP_se_arr = numpy.array(B_TXP_se_lst)
B_TXP_sem_arr = numpy.array(B_TXP_sem_lst)
B_TXP_meas_mean = B_TXP_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(B_TXP_meas_arr) > 1:
B_TXP_meas_se = B_TXP_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
B_TXP_meas_se = 0
B_TXP_se_max = B_TXP_se_arr.max()
B_TXP_sem_max = B_TXP_sem_arr.max()
except:
print("FAIL: no file found for measurements B_TXP")
sys.exit()
try:
B_TXN_meas_arr = numpy.array(B_TXN_meas_lst)
B_TXN_se_arr = numpy.array(B_TXN_se_lst)
B_TXN_sem_arr = numpy.array(B_TXN_sem_lst)
B_TXN_meas_mean = B_TXN_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(B_TXN_meas_arr) > 1:
B_TXN_meas_se = B_TXN_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
B_TXN_meas_se = 0
B_TXN_se_max = B_TXN_se_arr.max()
B_TXN_sem_max = B_TXN_sem_arr.max()
except:
print("FAIL: no file found for measurements B_TXN")
sys.exit()
try:
B_RXP_meas_arr = numpy.array(B_RXP_meas_lst)
B_RXP_se_arr = numpy.array(B_RXP_se_lst)
B_RXP_sem_arr = numpy.array(B_RXP_sem_lst)
B_RXP_meas_mean = B_RXP_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(B_RXP_meas_arr) > 1:
B_RXP_meas_se = B_RXP_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
B_RXP_meas_se = 0
B_RXP_se_max = B_RXP_se_arr.max()
B_RXP_sem_max = B_RXP_sem_arr.max()
except:
print("FAIL: no file found for measurements B_RXP")
sys.exit()
try:
B_RXN_meas_arr = numpy.array(B_RXN_meas_lst)
B_RXN_se_arr = numpy.array(B_RXN_se_lst)
B_RXN_sem_arr = numpy.array(B_RXN_sem_lst)
B_RXN_meas_mean = B_RXN_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(B_RXN_meas_arr) > 1:
B_RXN_meas_se = B_RXN_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
B_RXN_meas_se = 0
B_RXN_se_max = B_RXN_se_arr.max()
B_RXN_sem_max = B_RXN_sem_arr.max()
except:
print("FAIL: no file found for measurements B_RXN")
sys.exit()
try:
C_meas_arr = numpy.array(C_meas_lst)
C_se_arr = numpy.array(C_se_lst)
C_sem_arr = numpy.array(C_sem_lst)
C_meas_mean = C_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(C_meas_arr) > 1:
C_meas_se = C_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
C_meas_se = 0
C_se_max = C_se_arr.max()
C_sem_max = C_sem_arr.max()
except:
print("FAIL: no file found for measurements C")
sys.exit()
# The SFP Timing Calibration Module measurements are mandatory an need
# to be present. Check their availability.
try:
D_TXP_RXP_meas_arr = numpy.array(D_TXP_RXP_meas_lst)
D_TXP_RXP_se_arr = numpy.array(D_TXP_RXP_se_lst)
D_TXP_RXP_sem_arr = numpy.array(D_TXP_RXP_sem_lst)
D_TXP_RXP_meas_mean = D_TXP_RXP_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(D_TXP_RXP_meas_arr) > 1:
D_TXP_RXP_meas_se = D_TXP_RXP_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
D_TXP_RXP_meas_se = 0
D_TXP_RXP_se_max = D_TXP_RXP_se_arr.max()
D_TXP_RXP_sem_max = D_TXP_RXP_sem_arr.max()
except:
print("FAIL: no file found for measurements D_TXP_RXP")
sys.exit()
try:
D_TXN_RXN_meas_arr = numpy.array(D_TXN_RXN_meas_lst)
D_TXN_RXN_se_arr = numpy.array(D_TXN_RXN_se_lst)
D_TXN_RXN_sem_arr = numpy.array(D_TXN_RXN_sem_lst)
D_TXN_RXN_meas_mean = D_TXN_RXN_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(D_TXN_RXN_meas_arr) > 1:
D_TXN_RXN_meas_se = D_TXN_RXN_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
D_TXN_RXN_meas_se = 0
D_TXN_RXN_se_max = D_TXN_RXN_se_arr.max()
D_TXN_RXN_sem_max = D_TXN_RXN_sem_arr.max()
except:
print("FAIL: no file found for measurements D_TXN_RXN")
sys.exit()
try:
E_TXP_P_meas_arr = numpy.array(E_TXP_P_meas_lst)
E_TXP_P_se_arr = numpy.array(E_TXP_P_se_lst)
E_TXP_P_sem_arr = numpy.array(E_TXP_P_sem_lst)
E_TXP_P_meas_mean = E_TXP_P_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(E_TXP_P_meas_arr) > 1:
E_TXP_P_meas_se = E_TXP_P_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
E_TXP_P_meas_se = 0
E_TXP_P_se_max = E_TXP_P_se_arr.max()
E_TXP_P_sem_max = E_TXP_P_sem_arr.max()
except:
print("FAIL: no file found for measurements E_TXP_P")
sys.exit()
try:
E_TXN_N_meas_arr = numpy.array(E_TXN_N_meas_lst)
E_TXN_N_se_arr = numpy.array(E_TXN_N_se_lst)
E_TXN_N_sem_arr = numpy.array(E_TXN_N_sem_lst)
E_TXN_N_meas_mean = E_TXN_N_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(E_TXN_N_meas_arr) > 1:
E_TXN_N_meas_se = E_TXN_N_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
E_TXN_N_meas_se = 0
E_TXN_N_se_max = E_TXN_N_se_arr.max()
E_TXN_N_sem_max = E_TXN_N_sem_arr.max()
except:
print("FAIL: no file found for measurements E_TXN_N")
sys.exit()
try:
E_RXP_P_meas_arr = numpy.array(E_RXP_P_meas_lst)
E_RXP_P_se_arr = numpy.array(E_RXP_P_se_lst)
E_RXP_P_sem_arr = numpy.array(E_RXP_P_sem_lst)
E_RXP_P_meas_mean = E_RXP_P_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(E_RXP_P_meas_arr) > 1:
E_RXP_P_meas_se = E_RXP_P_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
E_RXP_P_meas_se = 0
E_RXP_P_se_max = E_RXP_P_se_arr.max()
E_RXP_P_sem_max = E_RXP_P_sem_arr.max()
except:
print("FAIL: no file found for measurements E_RXP_P")
sys.exit()
try:
E_RXN_N_meas_arr = numpy.array(E_RXN_N_meas_lst)
E_RXN_N_se_arr = numpy.array(E_RXN_N_se_lst)
E_RXN_N_sem_arr = numpy.array(E_RXN_N_sem_lst)
E_RXN_N_meas_mean = E_RXN_N_meas_arr.mean() # reproducibility = mean value of sets of measured values
if len(E_RXN_N_meas_arr) > 1:
E_RXN_N_meas_se = E_RXN_N_meas_arr.std(ddof=1) # reproducibility standard deviation
else:
E_RXN_N_meas_se = 0
E_RXN_N_se_max = E_RXN_N_se_arr.max()
E_RXN_N_sem_max = E_RXN_N_sem_arr.max()
except:
print("FAIL: no file found for measurements E_RXN_N")
sys.exit()
detail_file = open(os.path.join(name,"calc_sfp_timing_cal_mod_result_detail.txt"),"w")
detail_file.write("# Calculated result for SFP Timing Calibration Module measurement\n")
detail_file.write("# file: " + os.path.join(name,"calc_sfp_timing_cal_mod_result_detail.txt") + "\n")
detail_file.write("A_meas_mean " + str(A_meas_mean ) + "\n" )
detail_file.write("A_meas_se " + str(A_meas_se ) + "\n" )
detail_file.write("A_se_max " + str(A_se_max ) + "\n" )
detail_file.write("A_sem_max " + str(A_sem_max ) + "\n" )
detail_file.write("B_TXP_meas_mean " + str(B_TXP_meas_mean ) + "\n" )
detail_file.write("B_TXP_meas_se " + str(B_TXP_meas_se ) + "\n" )
detail_file.write("B_TXP_se_max " + str(B_TXP_se_max ) + "\n" )
detail_file.write("B_TXP_sem_max " + str(B_TXP_sem_max ) + "\n" )
detail_file.write("B_TXN_meas_mean " + str(B_TXN_meas_mean ) + "\n" )
detail_file.write("B_TXN_meas_se " + str(B_TXN_meas_se ) + "\n" )
detail_file.write("B_TXN_se_max " + str(B_TXN_se_max ) + "\n" )
detail_file.write("B_TXN_sem_max " + str(B_TXN_sem_max ) + "\n" )
detail_file.write("B_RXP_meas_mean " + str(B_RXP_meas_mean ) + "\n" )
detail_file.write("B_RXP_meas_se " + str(B_RXP_meas_se ) + "\n" )
detail_file.write("B_RXP_se_max " + str(B_RXP_se_max ) + "\n" )
detail_file.write("B_RXP_sem_max " + str(B_RXP_sem_max ) + "\n" )
detail_file.write("B_RXN_meas_mean " + str(B_RXN_meas_mean ) + "\n" )
detail_file.write("B_RXN_meas_se " + str(B_RXN_meas_se ) + "\n" )
detail_file.write("B_RXN_se_max " + str(B_RXN_se_max ) + "\n" )
detail_file.write("B_RXN_sem_max " + str(B_RXN_sem_max ) + "\n" )
detail_file.write("C_meas_mean " + str(C_meas_mean ) + "\n" )
detail_file.write("C_meas_se " + str(C_meas_se ) + "\n" )
detail_file.write("C_se_max " + str(C_se_max ) + "\n" )
detail_file.write("C_sem_max " + str(C_sem_max ) + "\n" )
detail_file.write("D_TXP_RXP_meas_mean " + str(D_TXP_RXP_meas_mean) + "\n" )
detail_file.write("D_TXP_RXP_meas_se " + str(D_TXP_RXP_meas_se ) + "\n" )
detail_file.write("D_TXP_RXP_se_max " + str(D_TXP_RXP_se_max ) + "\n" )
detail_file.write("D_TXP_RXP_sem_max " + str(D_TXP_RXP_sem_max ) + "\n" )
detail_file.write("D_TXN_RXN_meas_mean " + str(D_TXN_RXN_meas_mean) + "\n" )
detail_file.write("D_TXN_RXN_meas_se " + str(D_TXN_RXN_meas_se ) + "\n" )
detail_file.write("D_TXN_RXN_se_max " + str(D_TXN_RXN_se_max ) + "\n" )
detail_file.write("D_TXN_RXN_sem_max " + str(D_TXN_RXN_sem_max ) + "\n" )
detail_file.write("E_TXP_P_meas_mean " + str(E_TXP_P_meas_mean ) + "\n" )
detail_file.write("E_TXP_P_meas_se " + str(E_TXP_P_meas_se ) + "\n" )
detail_file.write("E_TXP_P_se_max " + str(E_TXP_P_se_max ) + "\n" )
detail_file.write("E_TXP_P_sem_max " + str(E_TXP_P_sem_max ) + "\n" )
detail_file.write("E_TXN_N_meas_mean " + str(E_TXN_N_meas_mean ) + "\n" )
detail_file.write("E_TXN_N_meas_se " + str(E_TXN_N_meas_se ) + "\n" )
detail_file.write("E_TXN_N_se_max " + str(E_TXN_N_se_max ) + "\n" )
detail_file.write("E_TXN_N_sem_max " + str(E_TXN_N_sem_max ) + "\n" )
detail_file.write("E_RXP_P_meas_mean " + str(E_RXP_P_meas_mean ) + "\n" )
detail_file.write("E_RXP_P_meas_se " + str(E_RXP_P_meas_se ) + "\n" )
detail_file.write("E_RXP_P_se_max " + str(E_RXP_P_se_max ) + "\n" )
detail_file.write("E_RXP_P_sem_max " + str(E_RXP_P_sem_max ) + "\n" )
detail_file.write("E_RXN_N_meas_mean " + str(E_RXN_N_meas_mean ) + "\n" )
detail_file.write("E_RXN_N_meas_se " + str(E_RXN_N_meas_se ) + "\n" )
detail_file.write("E_RXN_N_se_max " + str(E_RXN_N_se_max ) + "\n" )
detail_file.write("E_RXN_N_sem_max " + str(E_RXN_N_sem_max ) + "\n" )
# Now do the calculations:
# Hard code the delay and error for the female-female_coupling device
#D_f = (85.36e-12,1.1e-13,1.1e-14)
D_f_meas_mean = 85.36e-12
D_f_se_max = 1.1e-13
D_f_sem_max = 1.1e-14
# Calculate Multi SFP crate delays and errors
Multi_SFP_TxP = (B_TXP_meas_mean - A_meas_mean )/2
Multi_SFP_TxP_se = numpy.sqrt(B_TXP_se_max **2 + A_se_max **2 )/2
Multi_SFP_TxP_rep = numpy.sqrt(B_TXP_meas_se**2 + A_meas_se**2 )/2
Multi_SFP_TxP_sem = numpy.sqrt(B_TXP_sem_max **2 + A_sem_max **2 )/2
Multi_SFP_TxN = (B_TXN_meas_mean - A_meas_mean )/2
Multi_SFP_TxN_se = numpy.sqrt(B_TXN_se_max **2 + A_se_max **2 )/2
Multi_SFP_TxN_rep = numpy.sqrt(B_TXN_meas_se**2 + A_meas_se**2 )/2
Multi_SFP_TxN_sem = numpy.sqrt(B_TXN_sem_max **2 + A_sem_max **2 )/2
Multi_SFP_RxP = (B_RXP_meas_mean - A_meas_mean )/2
Multi_SFP_RxP_se = numpy.sqrt(B_RXP_se_max **2 + A_se_max **2 )/2
Multi_SFP_RxP_rep = numpy.sqrt(B_RXP_meas_se**2 + A_meas_se**2 )/2
Multi_SFP_RxP_sem = numpy.sqrt(B_RXP_sem_max **2 + A_sem_max **2 )/2
Multi_SFP_RxN = (B_RXN_meas_mean - A_meas_mean )/2
Multi_SFP_RxN_se = numpy.sqrt(B_RXN_se_max **2 + A_se_max **2 )/2
Multi_SFP_RxN_rep = numpy.sqrt(B_RXN_meas_se**2 + A_meas_se**2 )/2
Multi_SFP_RxN_sem = numpy.sqrt(B_RXN_sem_max **2 + A_sem_max **2 )/2
Multi_SFP_Tx = (Multi_SFP_TxP + Multi_SFP_TxN )/2
Multi_SFP_Tx_se = numpy.sqrt(Multi_SFP_TxP_se**2 + Multi_SFP_TxN_se**2 )/2
Multi_SFP_Tx_rep = numpy.sqrt(Multi_SFP_TxP_rep**2 + Multi_SFP_TxN_rep**2)/2
Multi_SFP_Tx_sem = numpy.sqrt(Multi_SFP_TxP_sem**2 + Multi_SFP_TxN_sem**2)/2
Multi_SFP_Rx = (Multi_SFP_RxP + Multi_SFP_RxN )/2
Multi_SFP_Rx_se = numpy.sqrt(Multi_SFP_RxP_se**2 + Multi_SFP_RxN_se**2 )/2
Multi_SFP_Rx_rep = numpy.sqrt(Multi_SFP_RxP_rep**2 + Multi_SFP_RxN_rep**2)/2
Multi_SFP_Rx_sem = numpy.sqrt(Multi_SFP_RxP_sem**2 + Multi_SFP_RxN_sem**2)/2
# Calculate SFP Timing Calibration delays and errors
# "se" is the resulting standard deviation of the measurement sets
# "rep" is the resulting standard deviation of the multiple eject/insert measurement sets (reproducibility)
# "sem" is the resulting standard error of the measurement sets
tloop_P = D_TXP_RXP_meas_mean - (C_meas_mean - D_f_meas_mean) - Multi_SFP_TxP - Multi_SFP_RxP
tloop_P_se = numpy.sqrt(D_TXP_RXP_se_max **2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_TxP_se**2 + Multi_SFP_RxP_se**2)
tloop_P_rep = numpy.sqrt(D_TXP_RXP_meas_se**2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_TxP_se**2 + Multi_SFP_RxP_se**2)
tloop_P_sem = numpy.sqrt(D_TXP_RXP_sem_max **2 + C_sem_max **2 + D_f_sem_max **2 + Multi_SFP_TxP_sem**2 + Multi_SFP_RxP_sem**2)
tloop_N = D_TXN_RXN_meas_mean - (C_meas_mean - D_f_meas_mean) - Multi_SFP_TxN - Multi_SFP_RxN
tloop_N_se = numpy.sqrt(D_TXN_RXN_se_max **2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_TxN_se**2 + Multi_SFP_RxN_se**2)
tloop_N_rep = numpy.sqrt(D_TXN_RXN_meas_se**2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_TxN_se**2 + Multi_SFP_RxN_se**2)
tloop_N_sem = numpy.sqrt(D_TXN_RXN_sem_max **2 + C_sem_max **2 + D_f_sem_max **2 + Multi_SFP_TxN_sem**2 + Multi_SFP_RxN_sem**2)
tloop = (tloop_P + tloop_N )/2
tloop_se = numpy.sqrt(tloop_P_se**2 + tloop_N_se**2 )/2
tloop_rep = numpy.sqrt(tloop_P_rep**2 + tloop_N_rep**2)/2
tloop_sem = numpy.sqrt(tloop_P_sem**2 + tloop_N_sem**2)/2
TxP_to_Out = E_TXP_P_meas_mean - (C_meas_mean - D_f_meas_mean) - Multi_SFP_TxP
TxP_to_Out_se = numpy.sqrt(E_TXP_P_se_max **2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_TxP_se**2)/2
TxP_to_Out_rep = numpy.sqrt(E_TXP_P_meas_se**2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_TxP_rep**2)/2
TxP_to_Out_sem = numpy.sqrt(E_TXP_P_sem_max **2 + C_sem_max **2 + D_f_sem_max **2 + Multi_SFP_TxP_sem**2)/2
TxN_to_Out = E_TXN_N_meas_mean - (C_meas_mean - D_f_meas_mean) - Multi_SFP_TxN
TxN_to_Out_se = numpy.sqrt(E_TXN_N_se_max **2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_TxN_se**2)/2
TxN_to_Out_rep = numpy.sqrt(E_TXN_N_meas_se**2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_TxN_rep**2)/2
TxN_to_Out_sem = numpy.sqrt(E_TXN_N_sem_max **2 + C_sem_max **2 + D_f_sem_max **2 + Multi_SFP_TxN_sem**2)/2
RxP_to_Out = E_RXP_P_meas_mean - (C_meas_mean - D_f_meas_mean) - Multi_SFP_RxP
RxP_to_Out_se = numpy.sqrt(E_RXP_P_se_max **2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_RxP_se**2)/2
RxP_to_Out_rep = numpy.sqrt(E_RXP_P_meas_se**2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_RxP_rep**2)/2
RxP_to_Out_sem = numpy.sqrt(E_RXP_P_sem_max **2 + C_sem_max **2 + D_f_sem_max **2 + Multi_SFP_RxP_sem**2)/2
RxN_to_Out = E_RXN_N_meas_mean - (C_meas_mean - D_f_meas_mean) - Multi_SFP_RxN
RxN_to_Out_se = numpy.sqrt(E_RXN_N_se_max **2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_RxN_se**2)/2
RxN_to_Out_rep = numpy.sqrt(E_RXN_N_meas_se**2 + C_se_max **2 + D_f_se_max **2 + Multi_SFP_RxN_rep**2)/2
RxN_to_Out_sem = numpy.sqrt(E_RXN_N_sem_max **2 + C_sem_max **2 + D_f_sem_max **2 + Multi_SFP_RxN_sem**2)/2
Tx_to_Out = (TxP_to_Out + TxN_to_Out )/2
Tx_to_Out_se = numpy.sqrt(TxP_to_Out_se**2 + TxN_to_Out_se**2 )/2
Tx_to_Out_rep = numpy.sqrt(TxP_to_Out_rep**2 + TxN_to_Out_rep**2 )/2
Tx_to_Out_sem = numpy.sqrt(TxP_to_Out_sem**2 + TxN_to_Out_sem**2)/2
Rx_to_Out = (RxP_to_Out + RxN_to_Out )/2
Rx_to_Out_se = numpy.sqrt(RxP_to_Out_se**2 + RxN_to_Out_se**2 )/2
Rx_to_Out_rep = numpy.sqrt(RxP_to_Out_rep**2 + RxN_to_Out_rep**2 )/2
Rx_to_Out_sem = numpy.sqrt(RxP_to_Out_sem**2 + RxN_to_Out_sem**2)/2
# Write out the resuts in the details file
detail_file.write("\n")
detail_file.write("Multi_SFP_TxP " + str(Multi_SFP_TxP ) + "\n")
detail_file.write("Multi_SFP_TxP_se " + str(Multi_SFP_TxP_se ) + "\n")
detail_file.write("Multi_SFP_TxP_rep " + str(Multi_SFP_TxP_rep ) + "\n")
detail_file.write("Multi_SFP_TxP_sem " + str(Multi_SFP_TxP_sem ) + "\n")
detail_file.write("Multi_SFP_TxN " + str(Multi_SFP_TxN ) + "\n")
detail_file.write("Multi_SFP_TxN_se " + str(Multi_SFP_TxN_se ) + "\n")
detail_file.write("Multi_SFP_TxN_rep " + str(Multi_SFP_TxN_rep ) + "\n")
detail_file.write("Multi_SFP_TxN_sem " + str(Multi_SFP_TxN_sem ) + "\n")
detail_file.write("Multi_SFP_RxP " + str(Multi_SFP_RxP ) + "\n")
detail_file.write("Multi_SFP_RxP_se " + str(Multi_SFP_RxP_se ) + "\n")
detail_file.write("Multi_SFP_RxP_rep " + str(Multi_SFP_RxP_rep ) + "\n")
detail_file.write("Multi_SFP_RxP_sem " + str(Multi_SFP_RxP_sem ) + "\n")
detail_file.write("Multi_SFP_RxN " + str(Multi_SFP_RxN ) + "\n")
detail_file.write("Multi_SFP_RxN_se " + str(Multi_SFP_RxN_se ) + "\n")
detail_file.write("Multi_SFP_RxN_rep " + str(Multi_SFP_RxN_rep ) + "\n")
detail_file.write("Multi_SFP_RxN_sem " + str(Multi_SFP_RxN_sem ) + "\n")
detail_file.write("\n")
detail_file.write("tloop_P " + str(tloop_P ) + "\n")
detail_file.write("tloop_P_se " + str(tloop_P_se ) + "\n")
detail_file.write("tloop_P_rep " + str(tloop_P_rep ) + "\n")
detail_file.write("tloop_P_sem " + str(tloop_P_sem ) + "\n")
detail_file.write("tloop_N " + str(tloop_N ) + "\n")
detail_file.write("tloop_N_se " + str(tloop_N_se ) + "\n")
detail_file.write("tloop_N_rep " + str(tloop_N_rep ) + "\n")
detail_file.write("tloop_N_sem " + str(tloop_N_sem ) + "\n")
detail_file.write("\n")
detail_file.write("TxP_to_Out " + str(TxP_to_Out ) + "\n")
detail_file.write("TxP_to_Out_se " + str(TxP_to_Out_se ) + "\n")
detail_file.write("TxP_to_Out_rep " + str(TxP_to_Out_rep ) + "\n")
detail_file.write("TxP_to_Out_sem " + str(TxP_to_Out_sem ) + "\n")
detail_file.write("TxN_to_Out " + str(TxN_to_Out ) + "\n")
detail_file.write("TxN_to_Out_se " + str(TxN_to_Out_se ) + "\n")
detail_file.write("TxN_to_Out_rep " + str(TxN_to_Out_rep ) + "\n")
detail_file.write("TxN_to_Out_sem " + str(TxN_to_Out_sem ) + "\n")
detail_file.write("RxP_to_Out " + str(RxP_to_Out ) + "\n")
detail_file.write("RxP_to_Out_se " + str(RxP_to_Out_se ) + "\n")
detail_file.write("RxP_to_Out_rep " + str(RxP_to_Out_rep ) + "\n")
detail_file.write("RxP_to_Out_sem " + str(RxP_to_Out_sem ) + "\n")
detail_file.write("RxN_to_Out " + str(RxN_to_Out ) + "\n")
detail_file.write("RxN_to_Out_se " + str(RxN_to_Out_se ) + "\n")
detail_file.write("RxN_to_Out_rep " + str(RxN_to_Out_rep ) + "\n")
detail_file.write("RxN_to_Out_sem " + str(RxN_to_Out_sem ) + "\n")
detail_file.write("\n")
detail_file.write("tloop " + str(tloop ) + "\n")
detail_file.write("tloop_se " + str(tloop_se ) + "\n")
detail_file.write("tloop_rep " + str(tloop_rep ) + "\n")
detail_file.write("tloop_sem " + str(tloop_sem ) + "\n")
detail_file.write("Tx_to_Out " + str(Tx_to_Out ) + "\n")
detail_file.write("Tx_to_Out_se " + str(Tx_to_Out_se ) + "\n")
detail_file.write("Tx_to_Out_rep " + str(Tx_to_Out_rep ) + "\n")
detail_file.write("Tx_to_Out_sem " + str(Tx_to_Out_sem ) + "\n")
detail_file.write("Rx_to_Out " + str(Rx_to_Out ) + "\n")
detail_file.write("Rx_to_Out_se " + str(Rx_to_Out_se ) + "\n")
detail_file.write("Rx_to_Out_rep " + str(Rx_to_Out_rep ) + "\n")
detail_file.write("Rx_to_Out_sem " + str(Rx_to_Out_sem ) + "\n")
detail_file.close()
# Write out the SFP Timing Calibration Module parameters
result_file = open(os.path.join(name,"calc_sfp_timing_cal_mod_result.txt"),"w")
result_file.write("# Calculated result for SFP Timing Calibration Module measurement\n")
result_file.write("# file: " + os.path.join(name,"calc_sfp_timing_cal_mod_result.txt") + "\n")
result_file.write("# =============================================\n")
result_file.write("tloop {0:.4g}".format(tloop) + "\n")
result_file.write("Tx_to_Out {0:.4g}".format(Tx_to_Out) + "\n")
result_file.write("Rx_to_Out {0:.4g}".format(Rx_to_Out) + "\n")
result_file.write("# =============================================\n")
result_file.write("\n")
result_file.write("tloop_se {0:.4g}".format(tloop_se) + "\n")
result_file.write("tloop_rep {0:.4g}".format(tloop_rep) + "\n")
result_file.write("tloop_sem {0:.4g}".format(tloop_sem) + "\n")
result_file.write("\n")
result_file.write("Tx_to_Out_se {0:.4g}".format(Tx_to_Out_se) + "\n")
result_file.write("Tx_to_Out_rep {0:.4g}".format(Tx_to_Out_rep) + "\n")
result_file.write("Tx_to_Out_sem {0:.4g}".format(Tx_to_Out_sem) + "\n")
result_file.write("\n")
result_file.write("Rx_to_Out_se {0:.4g}".format(Rx_to_Out_se) + "\n")
result_file.write("Rx_to_Out_rep {0:.4g}".format(Rx_to_Out_rep) + "\n")
result_file.write("Rx_to_Out_sem {0:.4g}".format(Rx_to_Out_sem) + "\n")
result_file.close()
sys.exit()
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment