def ratioerror(self, shuntv, xv, yv, shunt, comr, nomexcitation, full_scale):
"""
Calculates the measured ratio error. All parameters are lists of data from
:param shuntv: shuntv: voltage measured across the shunt on the secondary monitoring the primary current
:param xv: xv: real part of voltage across the common resistor
:param yv: imaginary part of the voltage across the common resistor
:param shunt: value of the secondary shunt
:param comr: value of the common resistor
:param nomexcitation: nominal excitation list, e.g. 10%, 20% ... 120%
:return: a list of errors, a list of actual excitation levels and a list of the matching nominal excitations
"""
# TODO consider a 'swap' flag for where the nominal reference ratio was actually on the UUT side
e = [] # list of error e1 at each excitation level
excite = [] # matching list of fractional excitation level
nom_excite = [] # matched nominal excitation level
for i in range(len(xv)):
xvolt = xv[i] * gtc.ureal(1.0, self.sr830, self.df_sr830, label = 'sr830 '+ repr(xv[i])) #type B
xvolt = xvolt + gtc.ureal(0.0, self.cmnmode, self.df_cmnmode, label = 'common mode ' + repr(xvolt.x))
yvolt = yv[i] * gtc.ureal(1.0, self.sr830, self.df_sr830, label='sr830 '+ repr(yv[i])) # type B
yvolt = yvolt + gtc.ureal(0.0, self.cmnmode, self.df_cmnmode, label='common mode '+ repr(yvolt.x))
ecurrent = (xvolt + 1j * yvolt) / comr[i] # difference current measured by SR830
current = shuntv[i] / shunt[i] # primary = secondary current
e_answer = gtc.result((ecurrent/current), 'my label') # key intermiediate result? decide later
e.append(e_answer)
excite.append(current / full_scale * 100) # note this is a ureal
nom_excite.append(
min(nomexcitation, key=lambda x: abs(x - excite[i].x))) # finds closest nominal excitation level
return e, excite, nom_excite
def get_correction(self, meas):
"""
Read calibration parameters from 'Calibrations' table determined by the
measurement data in meas.
:param meas: (Measurement obj) - single measurement data.
:return: (Calibration obj) - Includes GTC.ureals of correction-factor
and offset, calibration date and report no.
"""
equip = self.equip_id
quant = meas.quantity
date = meas.timestamp
line = self.readrow_from_calibration_table(equip, quant, 'factor',
date)
val_fact = line['Value']
unc_fact = line['Uncert']
dof_fact = line['DoF']
cal_date = line['Date']
rep_no = line['Report No']
fact = GTC.ureal(val_fact, unc_fact, dof_fact)
line = self.readrow_from_calibration_table(equip, quant, 'offset',
date)
val_offs = line['Value']
unc_offs = line['Uncert']
dof_offs = line['DoF']
offs = GTC.ureal(val_offs, unc_offs, dof_offs)
cal = Calibration(date=cal_date,
rep_no=rep_no,
factor=fact,
offset=offs)
return cal
def newcapsp(self, ypg, z, r2, z2, uut_ratio):
"""
Calculates the parallel error minus the series error for a set of primary windings due to the change
in potential distribution across the distributed capacitance from the primary windings to the screen.
This version of the formula differs from the original published version. It also caclualtes the series/
parallel - series error when k=4. This error is set to 0 if k does not equal 4.
:param ypg: ypg is complex admittance from series primary to primary screen
:param z: is the leakage impedance of the primary when all the sections are connected in parallel
:param r2: the secondary burden impedance
:param z2: leakage impedance of the secondary winding
:param uut_ratio: [k, m, n] is the ratio windings of the uut
:return: (parallel-series) error, (series/parallel - series) erro
"""
k = uut_ratio[0]
m = uut_ratio[1]
n = uut_ratio[2]
s_p_error = ypg / 3 *(k**2 - 1) * ((r2 + z2) * (m/n) ** 2 + z)
s_p_error = s_p_error * gtc.ureal(1.0, self.sp_cap, self.df_sp_cap, label='sp_cap') # type B factor
if k == 4: # 4 sections in series/parallel possible, note relies on exact integer ... isclose() needed?
g = 2
sp_s_error = ypg / 3 * (k ** 2 - g**2) * ((r2 + z2) * (m / n) ** 2 + z)
sp_s_error = sp_s_error * gtc.ureal(1.0, self.sp_cap, self.df_sp_cap, label='sp_s_cap') # type B factor
else:
sp_s_error =0
return s_p_error, sp_s_error
def get_test_result(self, a):
"""
:param a: first row of test
:return: list of (ultimately ureals) [complex error 1, complex error 2, resistance]
"""
# first get relevant resistor
resistor = self.perturbr[str(
self.getblock([a + 1, a + 3, 12, 13])[0][0])]
multiplier = float(self.getblock([a, a + 1, 7, 8])[0][0])
errors = self.getblock([a, a + 2, 10, 12])
error1 = self.tuple_to_complex(errors[0])
u_resolutionR = gtc.ureal(
0, self.arnie.resolutionR(error1.real, multiplier), 12,
'resR' + repr(error1.real))
u_correctionR = gtc.ureal(0, self.arnie.corrnR(error1.real,
multiplier), 12,
'corrnR' + repr(error1.real))
u_resolutionM = gtc.ureal(
0, self.arnie.resolutionM(error1.imag, multiplier), 12,
'resM' + repr(error1.imag))
u_correctionM = gtc.ureal(0, self.arnie.corrnM(error1.imag,
multiplier), 12,
'corrnM' + repr(error1.imag))
error = error1.real + u_resolutionR + u_correctionR + 1j * (
error1.imag + u_resolutionM + u_correctionM)
error1 = error
error2 = self.tuple_to_complex(errors[1])
u_resolutionR = gtc.ureal(
0, self.arnie.resolutionR(error2.real, multiplier), 12,
'resR' + repr(error2.real))
u_correctionR = gtc.ureal(0, self.arnie.corrnR(error2.real,
multiplier), 12,
'corrnR' + repr(error2.real))
u_resolutionM = gtc.ureal(
0, self.arnie.resolutionM(error2.imag, multiplier), 12,
'resM' + repr(error2.imag))
u_correctionM = gtc.ureal(0, self.arnie.corrnM(error2.imag,
multiplier), 12,
'corrnM' + repr(error2.imag))
error = error2.real + u_resolutionR + u_correctionR + 1j * (
error2.imag + u_resolutionM + u_correctionM)
error2 = error
the_burden = self.burdenZ(error1, error2, resistor)
frequency_factor = gtc.ureal(0,
self.maxfreq / 3.0,
50,
label='frequency')
the_burden = the_burden + 1j * the_burden.imag * frequency_factor # the addition is nominally zero
return the_burden
def get_test_result(self, a):
"""
:param a: first row of test
:return: list of (ultimately ureals) [complex error 1, complex error 2, resistance]
"""
# first get relevant resistor
resistor = float(self.data_store.getdata_block(self.datasheet, [a +1, a + 3 , 12, 13])[0][0])
multiplier = float(self.data_store.getdata_block(self.datasheet, [a , a + 1 , 7, 8])[0][0])
errors = self.data_store.getdata_block(self.datasheet, [a , a + 2 , 10, 12])
error1 = self.tuple_to_complex(errors[0])
u_resolutionR = gtc.ureal(0,self.arnie.resolutionR(error1.real, multiplier), 12, 'resR' + repr(error1.real))
u_correctionR = gtc.ureal(0, self.arnie.corrnR(error1.real, multiplier), 12, 'corrnR' + repr(error1.real))
u_resolutionM = gtc.ureal(0,self.arnie.resolutionM(error1.imag, multiplier), 12, 'resM' + repr(error1.imag))
u_correctionM = gtc.ureal(0,self.arnie.corrnM(error1.imag, multiplier), 12, 'corrnM' + repr(error1.imag))
error = error1.real + u_resolutionR + u_correctionR + 1j*(error1.imag + u_resolutionM + u_correctionM )
error1 = error
error2 = self.tuple_to_complex(errors[1])
u_resolutionR = gtc.ureal(0, self.arnie.resolutionR(error2.real, multiplier), 12, 'resR' + repr(error2.real))
u_correctionR = gtc.ureal(0, self.arnie.corrnR(error2.real, multiplier), 12, 'corrnR' + repr(error2.real))
u_resolutionM = gtc.ureal(0, self.arnie.resolutionM(error2.imag, multiplier), 12, 'resM' + repr(error2.imag))
u_correctionM = gtc.ureal(0, self.arnie.corrnM(error2.imag, multiplier), 12, 'corrnM' + repr(error2.imag))
error = error2.real + u_resolutionR + u_correctionR + 1j * (error2.imag + u_resolutionM + u_correctionM)
error2 = error
the_burden = self.burdenZ(error1, error2, resistor)
return the_burden
def fit_ureals(self, coeffs, cov, dof, label):
"""
Takes the coefficients, *coeffs*, and covariances, *cov*, together with
degrees of freedom, *dof*, in the array output from *fit* and returns a
list of function coefficients as correlated GTC ureals. The ureal is
named with *label*. If one of the uncertainties is zero, a set of unlinked
ureals is created. This should only occur if a transformer has had all
errors set to zero (e.g. no VT) or the input data has been fabricated to
be a perfect fit.
"""
uncert = []
for i in range(len(coeffs)):
uncert.append(np.sqrt(cov[i, i]))
flag = 1 #assume no zero uncertainties
for x in uncert:
if x == 0.0:
flag = 0
if flag == 1:
a = gtc.multiple_ureal(coeffs, uncert, dof, label)
# and now set the correlations between all coefficients
for i in range(len(coeffs)):
for j in range(i):
gtc.set_correlation(cov[i, j]/np.sqrt(cov[i, i]*cov[j, j]), a[j], a[i])
else: #have a zero uncertainty so create separate ureals
print 'A fit has returned zero uncertainty for a function coefficient. This should only occur if input data has been purposely set to a perfect fit.'
a = []
for i in range(len(coeffs)):
a.append(gtc.ureal(coeffs[i], uncert[i], dof, label[i]))
return a
def magnetic_coupling(self, block1, block2, uut_ratio, Rs, rls, target_i2, individual):
"""
Calculates the series error - parallel error for a set of primary windings.
This method processes the data and calls on internal methods ishare, couple and magneticsp
:param block1: the data block for calculating current sharing
:param block2: the data block with coupling measurements
:param uut_ratio: [k, m, n] ratio windings of the uut
:param Rs: secondary burden resistance
:param rls: secondary leakage impedance
:param target_i2: the i2 value used to normalise the volt drops, usually 1, i.e. 5 A through 0.2 ohm
:param individual: boolean when set to True the vdrops are measured across each individual winding
:return: same as magneticsp, a complex error with no scaling
"""
N = uut_ratio[2]/(uut_ratio[0] * uut_ratio[1]) # the ratio in series connection
vdrop = [] # measured volt drop
i2 = [] # measured secondary current voltage
for x in block1:
vdrop.append(x[2])
i2.append(x[0])
proportions = self.ishare(uut_ratio, Rs, rls, vdrop, i2, 1, individual)
# data is label, shunt volts, X V, Y V, Sh V sd/100, X stdev V, Y stdev V, CT ratio, Shunt, Com R
# k = len(block2) + 1 # one fewer measurements than sections
# create lists of data
shuntv = [] # gtc values
xv = [] # gtc values
yv = [] # gtc values
ctratio = [] # duplicates of a constant?
shunt = [] # secondary shunt duplicates of a fixed value
comr = [] # common resistance duplicates of a fixed value
for x in block2:
shuntv.append(gtc.ureal(x[1], x[4], 100, label='shuntv ' + repr(x[0])))
xv.append(gtc.ureal(x[2], x[5], 100, label='X V ' + repr(x[0])))
yv.append(gtc.ureal(x[3], x[6], 100, label='Y V ' + repr(x[0])))
ctratio.append(x[7])
shunt.append(x[8])
comr.append(x[9])
# calculation of coupling
coupling = self.couple(shuntv, xv, yv, ctratio, shunt, comr, uut_ratio)
return self.magneticsp(coupling, proportions, uut_ratio)
def magneticsp(self, couple, share, uut_ratio):
"""
Calculates the series error minus the parallel error for a set of primary windings due to magnetic
coupling differences between the windings. Note that the way coupling was measured forces the first couple
element to be zero.
:param couple: list of k-1 mutual couplings for k primary windings
:param share: list of fractional share of current for k primary windings in parallel
:param uut_ratio: list [k, m, n] of windings for transformer
:return: two complex errors, no scaling to % or ppm
"""
assert len(share) - len(couple) == 1, "sharing list should be one longer than coupling list"
k = len(share)
N = uut_ratio[2]/(uut_ratio[0] * uut_ratio[1])
if k == 4: # series/parallel available on Ta primaries
x = (2-(share[0]+share[1]))/2 # x is offset required to make first two add to 2.0
y = (2-(share[2]+share[3]))/2 # y is offset required to make last two add to 2.0
sp_share = []
sp_share.append(share[0] + x)
sp_share.append(share[1] + x)
sp_share.append(share[2] + y)
sp_share.append(share[3] + y)
sp_merror = 0 # summation for the serie/parallel magnetic error
for i in range(1, k): # the first element of share would have been multiplied by zero, so not needed
sp_merror = couple[i - 1] * (sp_share[i]-1) + sp_merror
sp_merror = N * sp_merror # the sign of this is as derived in section A3 of E056.005, relies on aj defn
sp_merror = sp_merror * gtc.ureal(1.0, self.sp_mag, self.df_sp_mag, label='s_sp_mag') # type B factor
else:
sp_merror = 0 #i.e. there is no series/paralle connection
merror = 0
for i in range(1, k): # the first element of share would have been multiplied by zero, so not needed
merror = couple[i - 1] * (share[i] - 1) + merror
merror = N * merror #the sign of this is as derived in section A3 of E056.005 and depends on aj measurement
merror = merror * gtc.ureal(1.0, self.sp_mag, self.df_sp_mag, label='sp_mag') # type B factor
return merror, sp_merror
def oldcapsp(self, ypg, k, z4, r2, z2, uut_ratio):
"""
Calculates the series error minus the parallel error for a set of primary windings due to the change
in potential distribution on the capacitance from the windings to screen. INCORRECT old formula.
:param ypg: ypg is complex admittance from series primary to primary screen
:param k: the number of sections connected in series
:param z4: the leakage impedance of the primary winding
:param r2: the secondary burden impedance
:param z2: leakage impedance of the secondary winding
:param uut_ratio: [k, n, m] transformer ratio
:return: error; should be a GTC ucomplex if inputs are experimental values
"""
n = uut_ratio[2]/(uut_ratio[0] * uut_ratio[1])
s_p_error = ypg / 6 * 1 / (k ** 2 - 1) * (z4 + (r2 + z2) / n ** 2)
s_p_error = s_p_error * gtc.ureal(1.0, self.sp_cap, self.df_sp_cap, label = 'sp_cap') # type B factor
return s_p_error
def urealext(value_list, unc_list=0.0, k=2, array_label='X', df=GTC.inf):
# INPUT variables:
# for value_list are:
# <class 'list'>
# <class 'numpy.ndarray'>
# <class 'int'>
# <class 'float'>
# for unc_list are:
# <class 'list'>
# <class 'numpy.ndarray'>
# <class 'int'>
# <class 'float'>
# for k are:
# <class 'int'>
# <class 'float'>
# for value_name are:
# <class 'string'>
if isinstance(value_list, int) or isinstance(value_list, float): # check if list is single value
value_list = [[value_list]]
n_rows = 1
n_cols = 1
else:
# find size of value_list
n_rows = len(value_list)
n_cols = len(value_list[0])
if df == 'N':
df = n_rows * n_cols - 1
realnumber_list = [[0 for x in range(n_cols)] for x in range(n_rows)]
for i in range(n_rows):
for j in range(n_cols):
label = array_label + str(i) + '_' + str(j)
if isinstance(unc_list, int) or isinstance(unc_list, float):
unc_std = unc_list / k
else:
unc_std = unc_list[i][j] / k
realnumber_list[i][j] = GTC.ureal(x=value_list[i][j], u=unc_std, label=label, df=df)
unc_array = GTC.la.uarray(realnumber_list)
return unc_array
def ctcompare(self, datablock, fullscale, targetexcitation, settings):
"""
Takes a set of CT error measurements as a block and returns the calculated ratio errors. Older spread sheets
did not include gain and reserve settings for the SR830, hence the boolean settings
:param datablock: shunt Volts, X V, Y V, Sh V sd/100, X stdev V, Y stdev, blank, Shunt, Gain, Reserve, Com R.
:param fullscale: the value of current, A, that equates to 100% excitation
:param targetexcitation: the set of nominal % excitation levels at which measurements were made
:param settings: a boolean set to True if gain and reserve colunmns available
:return: a list of errors, a list of actual excitation levels and a list of the matching nominal excitations
"""
assert settings in [True, False], "settings must be True for range and gain information, otherwise False"
shuntv = [] # gtc values
xv = [] # gtc values
yv = [] # gtc values
shunt = [] # secondary shunt duplicates of a fixed value
gain = [] # SR830 range
reserve = [] # reserve, 1 for on?
comr = [] # common resistance, list will likely be duplicates of a fixed value
for x in datablock:
if settings == False:
shunt.append(x[7])
comr.append(x[8])
shuntv.append(
gtc.ureal(x[0], x[3], 100, label='shuntv ' + str(x[0] / x[7] / fullscale))) # use current as label
xv.append(gtc.ureal(x[1], x[4], 100, label='X V ' + str(x[0] / x[7] / fullscale)))
yv.append(gtc.ureal(x[2], x[5], 100, label='Y V ' + str(x[0] / x[7] / fullscale)))
elif settings == True:
gain.append(x[6])
reserve.append(x[7])
shunt.append(x[8])
comr.append(x[9])
shuntv.append(
gtc.ureal(x[0], x[3], 100, label='shuntv ' + str(x[0] / x[8] / fullscale))) # use current as label
xv.append(gtc.ureal(x[1], x[4], 100, label='X V ' + str(x[0] / x[8] / fullscale)))
yv.append(gtc.ureal(x[2], x[5], 100, label='Y V ' + str(x[0] / x[8] / fullscale)))
e, excite, nom_excite = self.ratioerror(shuntv, xv, yv, shunt, comr, targetexcitation, fullscale)
return e, excite, nom_excite
def isGTC(value):
typeGTC = type(GTC.ureal(0, 0))
if type(value) == typeGTC:
return True
else:
return False
def float2GTC(value):
if isGTC(value):
return value
else:
return GTC.ureal(value, 0)
import GTC as gtc x = gtc.ureal(0.0, 0.1, 5) y = gtc.ureal(0.0, 0.2, 10) a = x * y print(a.u) b = gtc.function.mul2(x, y) print(b) ab = gtc.result(a * b, label='result') print(ab.label, ab)
max_sd = 0.00007754
return sd * reading
def auxP(self, reading):
"""
uncertainty in the correction factor for auxiliary phase
"""
max_sd = 0.0003270
return sd * reading
if __name__ == "__main__":
print 'Testing that the module works as intended.'
arnie = ARNOLD('a', 'b')
#in GTC terms we add the corrections
res_corrn_e = GTC.ureal(0, arnie.resolutionR(-0.682, 1), 5,
'swire_resolution').u
scale_corrn_e = GTC.ureal(0, arnie.corrnR(-0.682, 1), 5,
'swire_correction').u
res_corrn_p = GTC.ureal(0, arnie.resolutionM(0.032, 0.1), 5,
'mutual_resolution').u
scale_corrn_p = GTC.ureal(0, arnie.corrnM(0.032, 0.1), 5,
'mutual_correction').u
print res_corrn_e, '%'
print scale_corrn_e, '%'
print res_corrn_p, 'crad'
print scale_corrn_p, 'crad'
"""
>pythonw -u "arnold.py"
Testing that the module works as intended.
0.001 %
coeff=GTC.la.matmul(invA,B)
print('\ncoeff=',coeff)
a=coeff[0][0]
b=coeff[1][0]
c=coeff[2][0]
print('\nCalculated coefficients:\n')
print('a coeff=',a.x,'u=',a.u)
print('b coeff=',b.x,'u=',b.u)
print('c coeff=',c.x,'u=',c.u)
#### STEP 3- TEMPERATURE CALCULATION FROM RESISTANCE MEASURED
#resistancec from measurement
R0=GTC.ureal(100,0.000002,label='R0') #Triple point of water resistance
Ri=[102,189,300] # measured resistances
R=GTCext.urealext(value_list=Ri, unc_list=0.0005, k=2, array_label='R', df=GTC.inf)
print('\nR0=',R0)
print('\nR=',R)
Wt=R/R0 # calculating reference function for measured resistances
print('\nW(t)=',Wt)
Wt1=GTCext.python_list_transposition(Wt-1)
pow2=lambda
#Wt2=GTC.pow(Wt1,2)
#Wt3=GTC.pow(Wt1,3)
total = sum1 + sum2 + sum3 + sum4 + sum5 + sum6 + sum7 + sum8 + sum9 + sum10
return total
result = minimize(fitfun,[0.05,0.001])#, method = 'Nelder-Mead')#need to start with good guess
hessian = result.hess_inv #inverse Hessian is estimate of variance/covariance matrix
sum_square = result.fun#final rss
#scaling the inverse hessian by multiplying by the residuals
sa0 = math.sqrt(hessian[0,0]*sum_square)
sa1 = math.sqrt(hessian[1,1]*sum_square)
a = result.x
## zs = GTC.ucomplex(a[0]+1j*a[1],(hessian[0,0]*sum_square,hessian[0,1]*sum_square,hessian[1,0]*sum_square,hessian[1,1]*sum_square),138)
zs = GTC.ucomplex(a[0]+1j*a[1],(hessian[0,0]*sum_square,hessian[1,1]*sum_square),df=138,label='zs')
#use fitted impedance coefficients to define behviour of core impedance
#should look at GTC output when model inputs have uncertainty from the fits
a1 = GTC.ureal(11.7204144319303,0.346683597109428,df=34,label ='a1',dependent = True)
a2 = GTC.ureal(-0.0273771774408702,0.0136282110753501,df=34,label ='a2',dependent = True)
a3 = GTC.ureal(29.7364068940134,0.695696459888704,df=34,label ='a3',dependent = True)
GTC.set_correlation(-0.826126693986887, a1, a2)
GTC.set_correlation(-0.881067593505553, a1, a3)
GTC.set_correlation(0.551078899199967, a2, a3)
a4 = GTC.ureal(3.90272331971033,0.0859519946028212,34,label ='a4',dependent = True)
a5 = GTC.ureal(0.000243735060998679,0.0000527749402101903,34,label ='a5',dependent = True)
a6 = GTC.ureal(5.8544055409592,0.501146466659668,34,label ='a6',dependent = True)
GTC.set_correlation(-0.679730943215757, a4, a5)
GTC.set_correlation(-0.562016044432279, a4, a6)
GTC.set_correlation(0.303221134084321, a5, a6)
this_core_gtc = [a1,a2,a3,a4,a5,a6]
this_CT_gtc = modelCT.CT(this_core_gtc)
this_error.append(complex_error.real*100)
this_phase.append(complex_error.imag*100)
print this_error
print this_phase
line1 = plt.plot(x_axis,this_error)
line2 = plt.plot(x_axis,this_phase)
plt.show()
if __name__ == "__main__":
#use fitted impedance coefficients to define behviour of core impedance
this_core = [11.7204144319303, -0.0273771774408702, 29.7364068940134, 3.90272331971033, 0.000243735060998679, 5.8544055409592]
this_CT = CT(this_core)
#should look at GTC output when model inputs have uncertainty from the fits
a1 = GTC.ureal(11.7204144319303,0.346683597109428,34,label ='a1',dependent = True)
a2 = GTC.ureal(-0.0273771774408702,0.0136282110753501,34,label ='a2',dependent = True)
a3 = GTC.ureal(29.7364068940134,0.695696459888704,34,label ='a3',dependent = True)
GTC.set_correlation(-0.826126693986887, a1, a2)
GTC.set_correlation(-0.881067593505553, a1, a3)
GTC.set_correlation(0.551078899199967, a2, a3)
a4 = GTC.ureal(3.90272331971033,0.0859519946028212,34,label ='a4',dependent = True)
a5 = GTC.ureal(0.000243735060998679,0.0000527749402101903,34,label ='a5',dependent = True)
a6 = GTC.ureal(5.8544055409592,0.501146466659668,34,label ='a6',dependent = True)
GTC.set_correlation(-0.679730943215757, a4, a5)
GTC.set_correlation(-0.562016044432279, a4, a6)
GTC.set_correlation(0.303221134084321, a5, a6)
this_core_gtc = [a1,a2,a3,a4,a5,a6]
this_CT_gtc = CT(this_core_gtc)
import ITS90 as ITS
import GTC
import GTCext
import numpy as np
#definition od SPRT object
term1 = ITS.PRT(model='5685', numer='1114')
#example values of T and W
T = GTC.ureal(29.764663066392302, 0.005, label='temp')
W = GTC.ureal(1.11813889, 1.982113655829038e-05, label='W')
print(ITS.Conv_kelvin2celsius(T))
ITS.Calculate_Wr(T, verbose=True)
ITS.Calculate_temp_from_W(W, verbose=True)
value_list = [[1, 2, 3, 4], [5, 6, 7, 8]]
#value_list=1
#unc_list=[[0.1,0.2,0.3,0.4],[0.01,0.02,0.03,0.04]] #osobna niepwenośc dla każdej wartości
unc_list = 0.1 # jedna niepewnośc dla wszystkich wartości
value_list = np.array(value_list)
unc_array = GTCext.urealext(value_list, unc_list, k=2, array_label='temp')
print('value_list=\n', value_list)
print('unc_list=\n', unc_list)
print('unc_array=\n',
unc_array) # tutaj jest wytworzona macierz liczb z niepewnoscią
print('sin(unc_array)=\n', GTC.sin(unc_array)) #tutaj można zrobic ich sinus
w = 2 * math.pi * 50 # angular mains frequency
# perturbing resistors values from S22008_burden_support.xlsx
ohm10 = gtc.ucomplex((10.0112386 + 1j * w * 1724.3e-9),
(0.0005995 / 2.0, 52e-9 / 2.0),
50,
label='10 ohm')
ohm50 = gtc.ucomplex((50.0046351 + 1j * w * 2590.5e-9),
(0.0050221 / 2.0, 426.2e-9 / 2.0),
50,
label='50 ohm')
ohm100 = gtc.ucomplex((100.0048255 + 1j * w * -4140.8e-9),
(0.0057092 / 2.0, 520.1e-9 / 2.0),
50,
label='100 ohm')
ohm1000 = gtc.ureal(1000, 0.01, 12, label='1000 ohm') #not measured on UB
check_r = {
'10': ohm10,
'50': 50.0,
'100': 100.0,
'1000': 1000.0
} # dictionary of values of perturbing resistors
# analyse data from Excel sheet
myburden = BURDEN('S22008_py_Burden_5AmpRatio Template V5.0_draft.xlsm',
'ForPython', [1, 128, 1, 17], check_r)
mydata = myburden.datalist
print('starting run')
test_sets = [
4, 6, 11, 13, 18, 25, 27, 32, 34, 39, 41, 46, 48, 53, 55, 60, 62, 67,
69, 74, 76, 81, 83, 88, 90, 95, 97, 102, 104, 109, 111, 116, 118, 123,
125
def analysis(self):
"""
Main analysis function. Reads averages and standard deviations to create GTC,ureal objects, by using the find_center function to determine starting and end points of a set.
These are first sent to the split_set function to be seperated out for the different instruments, then each segment is sent to a ratio computation function which
returns the gain ratio and lineariy ratio for that set.
"""
end_point = float(self.read_cell(3, 3))
continue_analysis = True #flag for continuing to read through the data table
start_row = int(float(self.read_cell(
3, 1))) - 1 #wx starts at zero, initial starting row
while continue_analysis == True:
center, last_row = self.find_center(start_row)
print(start_row, center, last_row)
if last_row > len(
self.data
): #last row is outside the table, last set is incomplete or not there at all
print("last set not found")
continue_analysis = False
else:
S_settings = [
float(self.read_cell(i, self.S_setting_col))
for i in range(start_row, last_row + 1)
]
X_settings = [
float(self.read_cell(i, self.X_setting_col))
for i in range(start_row, last_row + 1)
]
GTC_list = [
GTC.ureal(float(self.read_cell(row, self.mean_col)),
float(self.read_cell(row, self.std_col)),
float(self.read_cell(row, self.DoF_col)) - 1)
for row in range(start_row, last_row + 1)
]
#get split up segments, then compute ratios individually and print then repeat.
m_top, m_bottom, x_top, x_bottom, s0, s1 = self.split_set(
GTC_list, S_settings)
x_ratios = self.x_ratio(x_top, s0, s1) + self.x_ratio(
x_bottom[::-1], s0, s1)
m_ratios = self.m_ratio(m_top, s0, s1) + self.m_ratio(
m_bottom[::-1], s0, s1
) #join arrays of the three ratios, linearity, gain, fit ??
ratios = x_ratios + m_ratios
print("m ratios" + str([x.x for x in m_ratios]))
print("x ratios" + str([x.x for x in x_ratios]))
#print the ratios to the sheet
self.PrintCol([x.label for x in ratios], start_row + 1,
self.mean_col + 5, self.sh_results)
self.PrintCol(["Ratio"] + [x.x for x in ratios], start_row,
self.mean_col + 6, self.sh_results)
self.PrintCol(["STDEV"] + [x.u for x in ratios], start_row,
self.mean_col + 7, self.sh_results)
self.PrintCol(["Effct. DoF"] + [x.df for x in ratios],
start_row, self.mean_col + 8, self.sh_results)
#check if there is a next section:
if last_row >= float(self.read_cell(3, 3)) - 1:
continue_analysis = False
else:
start_row = last_row + 1
def buildup(self, excite, e1, e2, e3, e4, e5a, e5b, mag1a, mag2a, mag3a, mag1b, mag2b, capa, capb):
"""
Assembles all the measurement results so that final ratio errors can be calculated.
It is assumed that all input error values are signed as an error in Ta after using the signcheck method
:param excite: the list of % excitation levels at which the errors apply
:param e1: Ta 5:5 self cal of P1as
:param e2: 20:5 P1ap vs P1bs
:param e3: 100:5 P1bp vs P1ap
:param e4: 100:5 P2ap vs P2bs
:param e5: 100:5 P1bp vs P3as
:param mag1a: magnetic series parallel error for P1a
:param mag2a: magnetic series parallel error for P2a
:param mag3a: magnetic series parallel error for P3a
:param mag1b: magnetic series parallel error for P1b
:param mag2b: magnetic series parallel error for P2b
:param capa: capacitive series parallel erro for P1a
:param capb: capacitive series parallel error for P1b
:return: list of errors for p1as, p1ap, p2ap, p3as, p1bs, p1bp, p2bs
"""
# TODO should the measured errors already be fully corrected, or should some corrections occur in this method?
#P1as, 5:5 in series
polarity = 1 # SR830 readings normalised to be 'error' when Ta is the UUT
p1as = []
for x in e1:
ans = x * polarity
ans = ans + gtc.ucomplex(0 + 0j,(self.ct_x_stability, self.ct_y_stability),self.df_ct_x_stability,
label = 'ct_stability_p1as')
ans = ans * gtc.ureal(1.0, self.brdn1a, self.df_brdn1a, label="burden1a")
ans = ans * gtc.ureal(1.0, self.brdn2a, self.df_brdn2a, label="burden2a")
p1as.append(ans) # as measured, modified by polarity
p1ap = []
for x in p1as:
ans = x + mag1a + capa
ans = ans + gtc.ucomplex(0 + 0j,(self.ct_x_stability, self.ct_y_stability),self.df_ct_x_stability,
label = 'ct_stability_p1ap')
ans = ans * gtc.ureal(1.0, self.brdn1b, self.df_brdn1b, label = "burden1b")
ans = ans * gtc.ureal(1.0, self.brdn2b, self.df_brdn2b, label="burden2b")
p1ap.append(ans)
polarity = -1 # as Tb is being calibrated
p1bs = []
for i in range(len(p1ap)):
ans = p1ap[i] + e2[i] * polarity
ans = ans + gtc.ucomplex(0 + 0j,(self.ct_x_stability, self.ct_y_stability),self.df_ct_x_stability,
label = 'ct_stability_p1bs')
p1bs.append(ans)
p1bp = []
for i in range(len(p1bs)):
ans = p1bs[i] + capb + mag1b
ans = ans + gtc.ucomplex(0 + 0j,(self.ct_x_stability, self.ct_y_stability),self.df_ct_x_stability,
label = 'ct_stability_p1bp')
p1bp.append(ans)
polarity = 1 # as Ta is being calibrated
p2ap = []
for i in range(len(p1bp)):
ans = p1bp[i] + e3[i] * polarity
ans = ans + gtc.ucomplex(0 + 0j,(self.ct_x_stability, self.ct_y_stability),self.df_ct_x_stability,
label = 'ct_stability_p2ap')
p2ap.append(ans)
polarity = -1 # as Tb is being calibrated
p2bs = []
for i in range(len(p2ap)):
ans = p2ap[i] + e4[i] * polarity
ans = ans + gtc.ucomplex(0 + 0j,(self.ct_x_stability, self.ct_y_stability),self.df_ct_x_stability,
label = 'ct_stability_p2bs')
p2bs.append(ans)
polarity = 1 # as Ta is being calibrated
p3as_a = []
for i in range(len(p2bs)):
ans = p2bs[i] + e5a[i] * polarity
ans = ans + gtc.ucomplex(0 + 0j,(self.ct_x_stability, self.ct_y_stability),self.df_ct_x_stability,
label = 'ct_stability_p3as_a')
p3as_a.append(ans)
polarity = 1 # as Ta is being calibrated
p3as_b = []
for i in range(len(p1bp)):
ans = p1bp[i] + e5b[i] * polarity
ans = ans + gtc.ucomplex(0 + 0j,(self.ct_x_stability, self.ct_y_stability),self.df_ct_x_stability,
label = 'ct_stability_p3as_b')
p3as_b.append(ans)
return p1as, p1ap, p2ap, p3as_a, p3as_b, p1bs, p1bp, p2bs
def analysis(self):
"""
Main analysis function. Reads averages and standard deviations to create GTC,ureal objects, by using the find_center function to determine starting and end points of a set.
These are first sent to the split_set function to be seperated out for the different instruments, then each segment is sent to a ratio computation function which
returns the gain ratio and lineariy ratio for that set. Additionally the ratios are converted to parts per million and stored in a separate location.
"""
if self.wb == None:
return
end_point = float(self.read_cell(3,3))
continue_analysis = True #flag for continuing to read through the data table
start_row = int(float(self.read_cell(3,1)))-1 #wx starts at zero, initial starting row
printing_row = 1 #The first row to start printing columns to.
while continue_analysis ==True:
center,last_row = self.find_center(start_row)
print(start_row,center,last_row)
if last_row>len(self.data): #last row is outside the table, last set is incomplete or not there at all
print("last set not found")
continue_analysis = False
else:
cols = []
S_settings = [float(self.read_cell(i,self.S_setting_col)) for i in range(start_row,last_row+1)]
X_settings = [float(self.read_cell(i,self.X_setting_col)) for i in range(start_row,last_row+1)]
GTC_list = [GTC.ureal(float(self.read_cell(row,self.mean_col)),float(self.read_cell(row,self.std_col)),float(self.read_cell(row,self.DoF_col))-1) for row in range(start_row,last_row+1)]
#get split up segments, then compute ratios individually and print then repeat.
m_top,m_bottom,x_top,x_bottom,s0,s1 = self.split_set(GTC_list,S_settings)
x_ratios = self.x_ratio(x_top,s0,s1)+self.x_ratio(x_bottom[::-1],s0,s1)
m_ratios = self.m_ratio(m_top,s0,s1)+self.m_ratio(m_bottom[::-1],s0,s1)
#join arrays of the three ratios, linearity, gain, fit ??
x_ranges = self.x_range(center)+self.x_range(center)
m_ranges = self.m_range(center)+self.m_range(center)
x_readouts = [self.read_cell(center,2)] + [self.read_cell(center,2)]+ [self.read_cell(center,2)]+ [self.read_cell(center,2)]
m_readouts = [self.read_cell(center,2)] + [self.read_cell(center,2)]+ [self.read_cell(center,2)]+ [self.read_cell(center,2)]
step_size = [float(self.read_cell(center,4))+float(self.read_cell(center+1,4))]+[float(self.read_cell(center,4))+float(self.read_cell(center+1,4))]+[float(self.read_cell(center,4))+float(self.read_cell(center+1,4))]+[float(self.read_cell(center,4))+float(self.read_cell(center+1,4))]
ratios = x_ratios+m_ratios
ranges = x_ranges+m_ranges
readouts = x_readouts + m_readouts
step_sizes = step_size+step_size
#print the ratios to the sheet
cols.append(["Label"]+[x.label for x in ratios])
cols.append(["Ratio"]+[x.x for x in ratios])
cols.append(["STDEV"]+[x.u for x in ratios])
cols.append(["Effct. DoF"]+[x.df for x in ratios])
cols.append(["Range"]+[x for x in ranges])
cols.append(["Max/Min V Setting"] + [x for x in readouts])
cols.append(["Step Size"]+[x for x in step_sizes])
self.print_cols(cols,printing_row,self.sh_results)
printing_row += len(ratios) + 1
self.results.append(cols)
#check if there is a next section:
if last_row>=float(self.read_cell(3,3))-1:
continue_analysis = False
else:
start_row = last_row+1
continue_analysis_ratios = True
while continue_analysis_ratios == True:
sets = int(0.5*len(self.results))
rows = []
rows.append(["Source Gain Ratios"]+["Positive"]+['']+["Negative"])
rows.append(["Range"]+["Mean(ppm)"]+["Std Dev(ppm)"]+["Mean(ppm)"]+["Std Dev(ppm)"])
# Generate Gain Ratios in correct form using calculated ratios for the Source
for i in range(0, sets):
mean_posi = (abs(self.results[2*i][1][2]) - 1 + abs(self.results[2*i][1][4])-1)/2 * 1000000
std_dev_posi = (self.results[2*i][2][2] + self.results[2*i][2][4])/2 * 1000000
mean_neg = (abs(self.results[2*i+1][1][2]) - 1 + abs(self.results[2*i+1][1][4])-1)/2 * 1000000
std_dev_neg = (self.results[2*i+1][2][2] + self.results[2*i+1][2][4])/2 * 1000000
g_ratio = str(float(self.results[2*i][5][2]))+" : "+str(float(self.results[2*i][6][2]))
rows.append([g_ratio]+[mean_posi]+[std_dev_posi]+[mean_neg]+[std_dev_neg])
# x2 and x2+1
rows.append([" "])
rows.append(["Meter Gain Ratios"]+["Positive"]+['']+["Negative"])
rows.append(["Range"]+["Mean(ppm)"]+["Std Dev(ppm)"]+["Mean(ppm)"]+["Std Dev(ppm)"])
# Generate Gain Ratios in correct form using calculated ratios for the Meter
for i in range(0, sets):
mean_posi = (abs(self.results[2*i][1][6]) - 1 + abs(self.results[2*i][1][8])-1)/2 * 1000000
std_dev_posi = (self.results[2*i][2][6] + self.results[2*i][2][8])/2 * 1000000
mean_neg = (abs(self.results[2*i+1][1][6]) - 1 + abs(self.results[2*i+1][1][8])-1)/2 * 1000000
std_dev_neg = (self.results[2*i+1][2][6] + self.results[2*i+1][2][8])/2 * 1000000
g_ratio = str(float(self.results[2*i][5][6]))+" : "+str(float(self.results[2*i][6][6]))
rows.append([g_ratio]+[mean_posi]+[std_dev_posi]+[mean_neg]+[std_dev_neg])
lin_ratios = []
lin_ratios.append(["Source Linearity Ratios"]+["Positive"]+['']+["Negative"])
lin_ratios.append(["Range"]+["Mean(ppm)"]+["Std Dev(ppm)"]+["Mean(ppm)"]+["Std Dev(ppm)"])
for i in range(0, sets):
mean_posi = (abs(self.results[2*i][1][2]) - 1 + abs(self.results[2*i][1][4])-1)/2 * 1000000
std_dev_posi = (self.results[2*i][2][2] + self.results[2*i][2][4])/2 * 1000000
mean_neg = (abs(self.results[2*i+1][1][2]) - 1 + abs(self.results[2*i+1][1][4])-1)/2 * 1000000
std_dev_neg = (self.results[2*i+1][2][2] + self.results[2*i+1][2][4])/2 * 1000000
g_ratio = str(float(self.results[2*i][5][2]))+" : "+str(float(self.results[2*i][6][2]))
lin_ratios.append([g_ratio]+[mean_posi]+[std_dev_posi]+[mean_neg]+[std_dev_neg])
# x2 and x2+1
lin_ratios.append([" "])
lin_ratios.append(["Meter Linearity Ratios"]+["Positive"]+['']+["Negative"])
lin_ratios.append(["Range"]+["Mean(ppm)"]+["Std Dev(ppm)"]+["Mean(ppm)"]+["Std Dev(ppm)"])
# Generate Gain Ratios in correct form using calculated ratios for the Meter
for i in range(0, sets):
mean_posi = (abs(self.results[2*i][1][6]) - 1 + abs(self.results[2*i][1][8])-1)/2 * 1000000
std_dev_posi = (self.results[2*i][2][6] + self.results[2*i][2][8])/2 * 1000000
mean_neg = (abs(self.results[2*i+1][1][6]) - 1 + abs(self.results[2*i+1][1][8])-1)/2 * 1000000
std_dev_neg = (self.results[2*i+1][2][6] + self.results[2*i+1][2][8])/2 * 1000000
g_ratio = str(float(self.results[2*i][5][6]))+" : "+str(float(self.results[2*i][6][6]))
lin_ratios.append([g_ratio]+[mean_posi]+[std_dev_posi]+[mean_neg]+[std_dev_neg])
# x2 and x2+1
self.gain_ratios.append(rows)
self.print_rows(rows,1,self.sh_gain_ratios)
self.print_rows(lin_ratios,1,self.sh_lin_ratios)
continue_analysis_ratios = False
"""
A GTC calculated ureal *target* has its uncertainty reported against
lists of labels in *labels*. Labels identify uncertainty inputs to
target. This facilitates reporting of uncertainties due to separate
metering components. There is no error checking so the onus is entirely
on the programmer to choose relevant lists of labels for parameters. A
list of summed variance by label group is returned.
"""
n = len(labels)# expect a list of lists
total = []
for i in range(n):
total.append(0.0) # the uncertainty for each list will be summed
for l, u in gtc.reporting.budget(target, trim = 0.0):
for i in range(n):
if l in labels[i]:
total[i] = total[i] + u**2
return total
if __name__ == "__main__":
print 'Testing components'
model = MODEL('tran') # contains all fitting functions
print model.line([1, 2], [3, 4])
alpha = gtc.ureal(0.0e-6, 1.0e-6, 9)
t = gtc.ureal(20.0, 0.5, 9)
t0 = 20.0
print model.influence1(t, t0, alpha).u