def get_matrix_products(gauss, data, MODREP, APR, NTOT, SIGMA2, file_IO4):
#
# GET MATRIX PRODUCTS
#
NSHP = APR.NSHP
NR = APR.NR
NRS = NR + NSHP
KA = data.KA
N = data.num_datapoints_used
for I in fort_range(1, NRS): # .lbl90
NI = KA[I, 1]
if NI == 0:
continue
for J in fort_range(I, NRS): # .lbl83
NJ = KA[J, 1]
if NJ == 0:
continue
IJ = J * (J - 1) // 2 + I
for MI in fort_range(1, NI): # .lbl85
MIX = KA[I, MI + 1]
for MJ in fort_range(1, NJ): # .lbl85
MJX = KA[J, MJ + 1]
gauss.B[IJ] = gauss.B[IJ] + gauss.AA[I, MI] * gauss.AA[
J, MJ] * data.ECOR[MIX, MJX]
for I in fort_range(1, NRS): # .lbl91
NI = KA[I, 1]
if NI == 0:
continue
for MI in fort_range(1, NI): # .lbl86
MIX = KA[I, MI + 1]
for MJ in fort_range(1, N): #.lbl86
gauss.BM[I] = gauss.BM[I] + gauss.AA[I, MI] * data.ECOR[
MIX, MJ] * gauss.AM[MJ]
for I in fort_range(1, N): # .lbl26
SUX = 0.
for J in fort_range(1, N): # .lbl52
SUX = SUX + data.ECOR[I, J] * gauss.AM[J]
SIGMA2 = SIGMA2 + gauss.AM[I] * SUX
SIGL = SIGMA2 / NTOT
format476 = "(/' ADDED ',I5,' TO GIVE ',I5,' TOTAL',2I5,F10.2/)"
fort_write(None, format476, [N, NTOT, NSHP, NRS, SIGL])
if N > LDA:
exit()
if NRS > LDB:
exit()
if MODREP == 0:
fort_write(file_IO4, format476, [N, NTOT, NSHP, NRS, SIGL])
return SIGMA2
def output_Ecor_matrix(data, file_IO4):
#
# output of correlation matrix of data block
#
N = data.num_datapoints_used
format101 = "(1H*//,' CORRELATION MATRIX OF DATA BLOCK'/)"
fort_write(file_IO4, format101, [])
format151 = "(1X,24F7.4)"
for K in fort_range(1, N):
fort_write(file_IO4, format151, [data.ECOR[K, 1:(K + 1)]])
def write_KAS_check(data, IPP, file_IO4):
if data.IDEN[data.num_datasets, 7] != 6:
#
# output of KAS for checking
#
if IPP[7] != 0:
format702 = "(20I5)"
NCT = data.NCT[data.num_datasets]
for K in fort_range(1, NCT):
NADD = data.num_datapoints + 1
NALT = NADD - ID[IDEN, 1]
fort_write(file_IO4, format702, [data.KAS[NALT:NADD], K])
def write_overflow_message(data, APR, file_IO4):
ID = data.num_datasets
IDEN = data.IDEN
MTTP = IDEN[ID, 8]
NSHP = APR.NSHP
NR = APR.NR
if data.IDEN[data.num_datasets, 7] != 6:
if MTTP == 2:
NSHP = NSHP + 1
L = NR + NSHP
if L > SIZE_LIMITS.MAX_NUM_UNKNOWNS:
format701 = "( ' OVERFLOW OF UNKNOWN-VECTOR SPACE WITH SET ',I3)"
fort_write(file_IO4, format701, [NS])
def complete_symmetric_Ecor(data, file_IO4):
#
# FILL IN SYMMETRIC TERM
#
MODC = data.MODC
N = data.num_datapoints_used
N1 = N - 1
format2830 = "(80X,4HN = ,I5)"
fort_write(file_IO4, format2830, [N])
for K in fort_range(1, N1): # .lbl25
K1 = K + 1
for L in fort_range(K1, N): # .lbl25
if MODC == 2:
data.ECOR[L, K] = 0.
data.ECOR[K, L] = data.ECOR[L, K]
# label .lbl25
L = L + 1 # to match L value of fortran after loop
def write_dataset_table(L, data, APR, LABL, MPPP, IPP, file_IO4):
IDEN = data.IDEN
ID = data.num_datasets
NS = IDEN[ID, 6]
NADD = data.num_datapoints + 1
NALT = NADD - IDEN[ID, 1]
NADD1 = NADD - 1
#VP PRIOR/EXP column is added
format5173 = "(/' ENERGY/MEV VALUE ABS. UNCERT. " + \
" PRIOR/EXP UNCERT./% DIFF./%" + \
" VAL.*SQRT(E)'/)"
fort_write(file_IO4, format5173, [])
AP = 0.
WWT = 0.
for K in fort_range(NALT, NADD1):
CSSK = data.CSS[K]
DCSK = data.DCS[K]
AX = get_AX(ID, K, data, APR)
AZ = AX / CSSK
if MPPP == 1:
DCSK /= AZ
WXX = 1. / (DCSK * DCSK)
WWT = WWT + WXX
#VPEND
#
# DATA OUTPUT
#
if IPP[2] != 0:
SECS = np.sqrt(data.E[K]) * CSSK
FDQ = DCSK * CSSK / 100.
DIFF = (CSSK - AX) * 100. / AX
#VP AZ print out was added
format133 = "(2X,E10.4,2X,E10.4,2X,E10.4,3X,F6.4,3X,F6.2," + \
" 3X,F10.2,3X,F10.4)"
fort_write(file_IO4, format133,
[data.E[K], CSSK, FDQ, AZ, DCSK, DIFF, SECS])
#VP Print out for Ratio of pior/exp value is added
AP = AP + AZ * WXX
AP = AP / WWT
# VP if(modrep .ne. 0) go to 2627
format111 = "(/' APRIORI NORM ',I4,F10.4,I5,2X,4A8)"
fort_write(file_IO4, format111, [L, AP, NS, LABL.CLABL[1:5]])
def write_invalid_datapoints_info(NS, data, file_IO4):
if NS in data.invalid_datapoints:
for KS in data.invalid_datapoints[NS]:
format704 = "( ' DATA POINT BUT NOT AN AP FOR SET ',I5,' NO ',I4)"
fort_write(file_IO4, format704, [NS, KS])
def write_missing_dataset_info(NS, data, file_IO4):
if NS in data.missing_datasets:
for NSET in data.missing_datasets[NS]:
format274 = "('CORRELATED DATA SET ',I5,' NOT FOUND FOR SET ',I5)"
fort_write(file_IO4, format274, [NSET, NS])
def write_dataset_exclusion_info(NS, data, file_IO4):
if NS in data.excluded_datasets:
# label .lbl517
format168 = "(' SET ',I5,' W/O VALID POINTS OR ELIMINATED'/)"
fort_write(file_IO4, format168, [NS])
def fill_AA_AM_COV(data, fisdata, APR, gauss, file_IO4):
#
# FILL AA,AM,AND COV
#
IDEN = data.IDEN
ID = data.num_datasets
NADD = data.num_datapoints + 1
NALT = NADD - IDEN[ID, 1]
MT = IDEN[ID, 7]
NADD1 = NADD - 1
KAS = data.KAS
KA = data.KA
NT = data.NT[ID, :]
NCT = data.NCT[ID]
N = data.num_datapoints_used
NS = IDEN[ID, 6]
EAVR = 0.
data.invalid_datapoints[NS] = []
for KS in fort_range(NALT, NADD1): # .lbl18
DQQQ = data.DCS[KS] * data.CSS[KS] * 0.01
J = KAS[KS, 1]
I = KAS[KS, 2]
I8 = KAS[KS, 3]
if (J == 0 and MT != 6) or \
(I == 0 and MT in (3,4,5,7,8,9)) or \
(I8 == 0 and MT in (7,9)):
data.invalid_datapoints[NS].append(KS)
continue
N = N + 1
if MT == 6:
#
# FISSION AVERAGE
#
K = 0
if NT[1] == 9:
K = 1
JA = APR.MCS[NT[1], 2]
JE = APR.MCS[NT[1], 3]
NW1 = 1
if NT[1] == 9:
NW1 = 2
NW = NW1
FL = 0.
SFL = 0.
J1 = JA + 1
J2 = JE - 1
for LI in fort_range(J1, J2): # .lbl53
NW = NW + 1
FL = FL + fisdata.FIS[NW]
EL1 = (APR.EN[LI] + APR.EN[LI - 1]) * 0.5
EL2 = (APR.EN[LI] + APR.EN[LI + 1]) * 0.5
DE1 = (APR.EN[LI] - EL1) * 0.5
DE2 = (EL2 - APR.EN[LI]) * 0.5
SS1 = .5 * (APR.CS[LI] + 0.5 * (APR.CS[LI] + APR.CS[LI - 1]))
SS2 = .5 * (APR.CS[LI] + 0.5 * (APR.CS[LI] + APR.CS[LI + 1]))
CSSLI = (SS1 * DE1 + SS2 * DE2) / (DE1 + DE2)
SFL = SFL + CSSLI * fisdata.FIS[NW]
FL = FL + fisdata.FIS[1] + fisdata.FIS[NW + 1]
SFL = SFL + fisdata.FIS[1] * APR.CS[JA] + fisdata.FIS[
NW + 1] * APR.CS[JE]
SFIS = SFL / FL
format156 = "( 'AP FISSION AVERAGE ',3F10.4,' EXP. VAL. ',2F10.4)"
fort_write(file_IO4, format156,
[EAVR, SFIS, FL, data.CSS[KS], data.DCS[KS]])
CX = SFIS
for J in fort_range(JA, JE): # .lbl39
K = K + 1
KA[J, 1] = KA[J, 1] + 1
KR = KA[J, 1]
KA[J, KR + 1] = N
if J == JA or J == JE:
CSSJ = APR.CS[J]
else:
EL1 = (APR.EN[J] + APR.EN[J - 1]) * 0.5
EL2 = (APR.EN[J] + APR.EN[J + 1]) * 0.5
DE1 = (APR.EN[J] - EL1) * 0.5
DE2 = (EL2 - APR.EN[J]) * 0.5
SS1 = .5 * (APR.CS[J] + 0.5 * (APR.CS[J] + APR.CS[J - 1]))
SS2 = .5 * (APR.CS[J] + 0.5 * (APR.CS[J] + APR.CS[J + 1]))
CSSJ = (SS1 * DE1 + SS2 * DE2) / (DE1 + DE2)
gauss.AA[J, KR] = CSSJ * fisdata.FIS[K] / DQQQ
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
elif MT == 5:
#
# TOTAL CROSS SECTION
#
CX = 0.
for I in fort_range(1, NCT): # .lbl49
II = KAS[KS, I]
CX = CX + APR.CS[II]
for I in fort_range(1, NCT): # .lbl60
J = KAS[KS, I]
KA[J, 1] = KA[J, 1] + 1
KR = KA[J, 1]
KA[J, KR + 1] = N
gauss.AA[J, KR] = APR.CS[J] / DQQQ
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
elif MT == 8:
#
# SHAPE OF SUM
#
L = APR.NR + APR.NSHP
AP = APR.CS[L]
CX = 0.
for I in fort_range(1, NCT): # .lbl253
II = KAS[KS, I]
CX = CX + APR.CS[II] * AP
APDQ = AP / DQQQ
for I in fort_range(1, NCT): # .lbl254
J = KAS[KS, I]
KA[J, 1] = KA[J, 1] + 1
KR = KA[J, 1]
KA[J, KR + 1] = N
gauss.AA[J, KR] = APR.CS[J] * APDQ
KA[L, 1] = KA[L, 1] + 1
KR = KA[L, 1]
KA[L, KR + 1] = N
gauss.AA[L, KR] = CX / DQQQ
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
KA[J, 1] = KA[J, 1] + 1
KR = KA[J, 1]
KA[J, KR + 1] = N
if MT == 1:
#
# CROSS SECTION
#
CX = APR.CS[J]
gauss.AA[J, KR] = CX / DQQQ
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
elif MT == 2:
#
# CROSS SECTION SHAPE L is shape data norm. const. index
#
L = APR.NR + APR.NSHP
AP = APR.CS[L]
CX = APR.CS[J] * AP
CXX = CX / DQQQ
gauss.AA[J, KR] = CXX
KA[L, 1] = KA[L, 1] + 1
KR = KA[L, 1]
KA[L, KR + 1] = N
gauss.AA[L, KR] = CXX
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
elif MT == 3:
#
# RATIO
#
CX = APR.CS[J] / APR.CS[I]
CCX = CX / DQQQ
gauss.AA[J, KR] = CCX
KA[I, 1] = KA[I, 1] + 1
KR = KA[I, 1]
KA[I, KR + 1] = N
gauss.AA[I, KR] = -CCX
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
elif MT == 4:
#
# RATIO SHAPE
#
L = APR.NR + APR.NSHP
AP = APR.CS[L]
CX = APR.CS[J] * AP / APR.CS[I]
CXX = CX / DQQQ
gauss.AA[J, KR] = CXX
KA[I, 1] = KA[I, 1] + 1
KR = KA[I, 1]
KA[I, KR + 1] = N
gauss.AA[I, KR] = -CXX
KA[L, 1] = KA[L, 1] + 1
KR = KA[L, 1]
KA[L, KR + 1] = N
gauss.AA[L, KR] = CXX
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
elif MT == 5 or MT == 6 or MT == 8:
format447 = "(10H ERROR 446)"
fort_write(file_IO4, format447, [])
exit()
elif MT == 7:
#
# ABSOLUTE RATIO S1/(S2+S3)
#
CX = APR.CS[J] / (APR.CS[I] + APR.CS[I8])
if I == J:
CBX = CX * CX * APR.CS[I8] / (APR.CS[J] * DQQQ)
gauss.AA[J, KR] = CBX
KA[I8, 1] = KA[I8, 1] + 1
KR = KA[I8, 1]
KA[I8, KR + 1] = N
gauss.AA[I8, KR] = -CBX
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
else:
CBX = CX / DQQQ
gauss.AA[J, KR] = CBX
KA[I, 1] = KA[I, 1] + 1
KR = KA[I, 1]
KA[I, KR + 1] = N
CBX2 = CBX * CBX * DQQQ / APR.CS[J]
CCX = CBX2 * APR.CS[I]
gauss.AA[I, KR] = -CCX
KA[I8, 1] = KA[I8, 1] + 1
KR = KA[I8, 1]
KA[I8, KR + 1] = N
CCX = CBX2 * APR.CS[I8]
gauss.AA[I8, KR] = -CCX
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
elif MT == 9:
#
# SHAPE OF RATIO S1/(S2+S3)
#
L = APR.NR + APR.NSHP
AP = APR.CS[L]
CII8 = APR.CS[I] + APR.CS[I8]
CX = AP * APR.CS[J] / CII8
CBX = CX / DQQQ
if I == J:
CCX = CBX * APR.CS[I8] / CII8
gauss.AA[J, KR] = CCX
KA[I8, 1] = KA[I8, 1] + 1
KR = KA[I8, 1]
KA[I8, KR + 1] = N
gauss.AA[I8, KR] = -CCX
KA[L, 1] = KA[L, 1] + 1
KR = KA[L, 1]
KA[L, KR + 1] = N
gauss.AA[L, KR] = CBX
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
else:
gauss.AA[J, KR] = CBX
KA[I, 1] = KA[I, 1] + 1
KR = KA[I, 1]
KA[I, KR + 1] = N
CDX = CBX * APR.CS[I] / CII8
gauss.AA[I, KR] = -CDX
KA[I8, 1] = KA[I8, 1] + 1
KR = KA[I8, 1]
KA[I8, KR + 1] = N
CDX = CBX * APR.CS[I8] / CII8
gauss.AA[I8, KR] = -CDX
KA[L, 1] = KA[L, 1] + 1
KR = KA[L, 1]
KA[L, KR + 1] = N
gauss.AA[L, KR] = CBX
gauss.AM[N] = (data.CSS[KS] - CX) / DQQQ
continue
data.num_datapoints_used = N
return
def force_stop(file_IO4):
format107 = "( ' REQUESTED STOP ' )"
fort_write(file_IO4, format107)
exit()
def input_fission_spectrum(MC1, file_IO3, file_IO4):
#
# INPUT OF FISSION SPECTRUM
#
#
# Fission Data block / data set
#
# ENFIS ENERGIES OF FISSION SPECTRUM
# FIS FISSION SPECTRUM*BINWIDTH
#
data = Bunch({
'FIS': np.zeros(250 + 1, dtype=float),
'ENFIS': np.zeros(250 + 1, dtype=float),
'NFIS': 0
})
if MC1 == 0:
#
# MAXWELLIAN SPECTRUM
#
EAVR = MC2 / 1000.
NFIS = APR.MCS[MC3, 1]
JA = APR.MCS[MC3, 2]
JE = APR.MCS[MC3, 3]
LL = 0
for K in fort_range(JA, JE): # .lbl693
LL = LL + 1
data.ENFIS[LL] = APR.EN[K]
NFIS1 = NFIS - 1
FISUM = 0.
for K in fort_range(1, NFIS1): # .lbl695
E1 = (data.ENFIS[K - 1] + data.ENFIS[K]) / 2.
E2 = (data.ENFIS[K + 1] + data.ENFIS[K]) / 2.
DE12 = E2 - E1
F1 = np.sqrt(E1) * np.exp(-1.5 * E1 / EAVR)
F2 = np.sqrt(E2) * np.exp(-1.5 * E2 / EAVR)
E12 = (E1 + E2) / 2.
F3 = np.sqrt(E12) * np.exp(-1.5 * E12 / EAVR)
data.FIS[K] = ((F1 + F2) * .5 + F3) * .5
FISUM = FISUM + DE12 * data.FIS[K]
data.FIS[1] = np.sqrt(APR.EN[JA]) * np.exp(-1.5 * APR.EN[JA] / EAVR)
data.FIS[NFIS] = np.sqrt(APR.EN[JE]) * np.exp(-1.5 * APR.EN[JE] / EAVR)
DE12 = (data.ENFIS[2] - data.ENFIS[1]) / 2.
DE13 = data.ENFIS[1] + DE12
FISUM = FISUM + data.FIS[1] * DE13
DE14 = (data.ENFIS(NFIS) - data.ENFIS[NFIS1]) / 2.
FISUM = FISUM + data.FIS[NFIS] * 2. * DE14
else:
format119 = "(2E13.5)"
for K in fort_range(1, LDF): # .lbl690
data.ENFIS[K], data.FIS[K] = fort_read(file_IO3, format119)
if data.ENFIS[K] == 0:
break
NFIS = K - 1
format800 = "(/' FISSION SPECTRUM * BIN WIDTH'/)"
fort_write(file_IO4, format800, [])
if MC1 == 0:
for K in fort_range(2, NFIS1): # .lbl696
E1 = (data.ENFIS[K - 1] + data.ENFIS[K]) / 2.
E2 = (data.ENFIS[K + 1] + data.ENFIS[K]) / 2.
DE12 = E2 - E1
data.FIS[K] = data.FIS[K] * DE12 / FISUM
data.FIS[NFIS] = data.FIS[NFIS] * DE14 / FISUM
data.FIS[1] = data.FIS[1] * DE13 / FISUM
format157 = "(2F10.6)"
for KQ in fort_range(1, NFIS): # .lbl694
fort_write(file_IO4, format157, [data.ENFIS[KQ], data.FIS[KQ]])
data.NFIS = NFIS
return data
def output_result_correlation_matrix(gauss, data, APR, IPP, LABL, file_IO4):
#
# OUTPUT OF CORRELATION MATRIX OF THE RESULT
#
NC = APR.NC
JA = APR.MCS[NC, 2]
if IPP[6] != 0:
format151 = "(1X,24F7.4)"
for K in fort_range(1, NC): # .lbl78
J1 = APR.MCS[K, 2]
J2 = APR.MCS[K, 3]
# CVP 3 lines below are added by VP, 26 July, 2004
NROW = J2 - J1 + 2
for III in fort_range(1, NROW):
gauss.EGR[III] = 1.0 * III
# CVP
for L in fort_range(1, K): # .lbl80
format122 = "(1H1, ' CORRELATION MATRIX OF THE RESULT ',2A8,2A8///)"
fort_write(file_IO4, format122,
[LABL.CLAB[K, 1:3], LABL.CLAB[L, 1:3]])
J3 = APR.MCS[L, 2]
J4 = APR.MCS[L, 3]
# CVP 3 lines below are added by VP, 26 July 2004
NCOL = J4 - J3 + 2
for III in fort_range(1, NROW + NCOL):
gauss.EEGR[III] = 1.0 * III
# CVP
if K == L:
for I in fort_range(J1, J2): # .lbl55
II = I * (I - 1) // 2 + I
for J in fort_range(J1, I): # .lbl27
IJ = I * (I - 1) // 2 + J
JJ = J * (J - 1) // 2 + J
gauss.BM[J] = gauss.B[IJ] / np.sqrt(
gauss.B[II] * gauss.B[JJ])
# CVP lines below are added by VP, 26 July, 2004
gauss.RELTRG[I - J1 + 1, J - J1 + 1] = gauss.B[IJ]
data.AAA[I - J1 + 1, J - J1 + 1] = gauss.BM[J]
data.AAA[J - J1 + 1, I - J1 + 1] = gauss.BM[J]
# CVP end
fort_write(file_IO4, format151, [gauss.BM[J1:(I + 1)]])
format389 = '(2x,f7.3,1x,200(E10.4,1x))'
IMAX = J2 - J1 + 1
for I in fort_range(1, IMAX):
fort_write(
file_IO4, format389,
[APR.EN[JA + I - 1], data.AAA[I, 1:(J2 - J1 + 2)]])
# CVP Lines below are added by VP, 26 July, 2004
format388 = '(6E11.4)'
tmp = [[
gauss.RELTRG[III, JJJ]
for III in fort_range(JJJ, NROW - 1)
] for JJJ in fort_range(1, NROW - 1)]
fort_write(file_IO4, format388,
[gauss.EGR[1:(NROW + 1)], tmp])
# CVP
else:
for I in fort_range(J1, J2): # .lbl88
II = I * (I - 1) // 2 + I
for J in fort_range(J3, J4): # .lbl16
IJ = I * (I - 1) // 2 + J
JJ = J * (J - 1) // 2 + J
gauss.BM[J] = gauss.B[IJ] / np.sqrt(
gauss.B[II] * gauss.B[JJ])
# CVP three lines below are inserted by VP
gauss.RELCOV[I - J1 + 1, J - J3 + 1] = gauss.B[IJ]
data.AAA[I - J1 + 1, J - J3 + 1] = gauss.BM[J]
data.AAA[J - J3 + 1, I - J1 + 1] = gauss.BM[J]
# CVP
fort_write(file_IO4, format151,
[gauss.BM[J3:(J4 + 1)]])
# CVP Lines below are added by VP, 26 July, 2004
format388 = '(6E11.4)'
fort_write(file_IO4, format388, [
gauss.EEGR[1:(NROW + NCOL + 1)],
gauss.RELCOV[1:NROW, 1:NCOL].flatten()
])
fort_write(file_IO4, format388, [
gauss.EEGR[1:(NROW + NCOL + 1)],
gauss.RELCOV[1:NROW, 1:NCOL].flatten(order='F')
])
# CVP print below is inserted by VP Aug2013
IMAX = J2 - J1 + 1
format389 = '(2x,f7.3,1x,200(E10.4,1x))'
for I in fort_range(1, IMAX):
fort_write(
file_IO4, format389,
[APR.EN[JA + I - 1], data.AAA[I, 1:(J4 - J3 + 2)]])
def output_result(gauss, fisdata, APR, MODAP, LABL, file_IO4, file_IO5):
#
# output of the result
#
NR = APR.NR
NC = APR.NC
NSHP = APR.NSHP
NRS = NR + NSHP
NFIS = fisdata.NFIS
NSETN = APR.NSETN
for L in fort_range(1, NC): # .lbl14
format117 = "(1H1,' RESULT',5X,2A8//)"
fort_write(file_IO4, format117, [LABL.CLAB[L, 1:3]])
fort_write(file_IO5, format117, [LABL.CLAB[L, 1:3]])
format112 = "( ' E/MEV CS/B DCS/B DCS/%" + \
" DIF/% CS*SQRT(E)'/)"
fort_write(file_IO4, format112, [])
JA = APR.MCS[L, 2]
JI = APR.MCS[L, 3]
FLX = 0.
for K in fort_range(JA, JI): # .lbl77
KBK = K * (K - 1) // 2 + K
DDX = APR.CS[K] * np.sqrt(gauss.B[KBK])
CXX = APR.CS[K] * (1. + gauss.DE[K])
CXXD = 100. * (CXX - APR.CS[K]) / CXX
found = False
for KK in fort_range(1, NFIS): # .lbl705
if fisdata.ENFIS[KK] > .999 * APR.EN[K] and fisdata.ENFIS[
KK] < 1.001 * APR.EN[K]:
found = True
break
if found:
if K == JA or K == JI:
CSSK = CXX
else:
EL1 = (APR.EN[K] + APR.EN[K - 1]) * 0.5
EL2 = (APR.EN[K] + APR.EN[K + 1]) * 0.5
DE1 = (APR.EN[K] - EL1) * 0.5
DE2 = (EL2 - APR.EN[K]) * 0.5
SS1 = .5 * (CXX + 0.5 *
(CXX + (1. + gauss.DE[K - 1]) * APR.CS[K - 1]))
SS2 = .5 * (CXX + 0.5 *
(CXX + (1. + gauss.DE[K + 1]) * APR.CS[K + 1]))
CSSK = (SS1 * DE1 + SS2 * DE2) / (DE1 + DE2)
FLX = FLX + fisdata.FIS[KK] * CSSK
FQW = DDX * 100. / CXX
SECS = np.sqrt(APR.EN[K]) * CXX
format153 = "(1X,E10.4,2F15.8,2X,F6.1,3X,F7.2,3X,F10.5)"
fort_write(file_IO4, format153,
[APR.EN[K], CXX, DDX, FQW, CXXD, SECS])
fort_write(file_IO5, format153,
[APR.EN[K], CXX, DDX, FQW, CXXD, SECS])
if not (MODAP == 0) and \
not (MODAP == 2 and K <= APR.MCS[5,3]):
APR.CS[K] = CXX
# VP: 13 lines below are added by VP, 26 July, 2004
format588 = "(6(1X,E10.5))"
fort_write(file_IO4, format588,
[(APR.EN[JA] * 500000.),
(APR.EN[JA:JI] + APR.EN[(JA + 1):(JI + 1)]) * 500000.,
(-APR.EN[JI - 1] + 3 * APR.EN[JI]) * 500000.])
tmp = np.vstack([APR.EN[JA:(JI + 1)] * 1000000., APR.CS[JA:(JI + 1)]])
tmp = tmp.T.flatten()
fort_write(file_IO4, format588, tmp)
for K in fort_range(JA + 1, JI - 1):
DSMOOA = (APR.CS[K+1] * (APR.EN[K] - APR.EN[K-1]) \
+APR.CS[K-1] * (APR.EN[K+1] - APR.EN[K]) \
-APR.CS[K] * (APR.EN[K+1] - APR.EN[K-1])) \
/2./(APR.EN[K+1] - APR.EN[K-1])
DSMOOR = DSMOOA / APR.CS[K] * 100.
SSMOO = APR.CS[K] + DSMOOA
fort_write(file_IO4, format153,
[APR.EN[K], APR.CS[K], SSMOO, DSMOOR])
# VP above is writing CS in B-6 format and smoothing with CS conserving
format158 = "(1H*//,' FISSION AVERAGE ' ,F8.4//)"
fort_write(file_IO4, format158, [FLX])
#
# OUTPUT OF NORM. FACTORS FOR SHAPE DATA
#
format114 = "(1H*///, ' NORMALIZATION OF SHAPE DATA '///)"
fort_write(file_IO4, format114, [])
NR1 = NR + 1
LLX = 0
if NSHP != 0:
for K in fort_range(NR1, NRS): # .lbl82
LLX = LLX + 1
KK = K * (K - 1) // 2 + K
ZCS = APR.CS[K]
DDX = APR.CS[K] * np.sqrt(gauss.B[KK])
CXX = APR.CS[K] * (1. + gauss.DE[K])
DDXD = DDX * 100. / CXX
format115 = "(2I6,4F10.4)"
fort_write(file_IO4, format115,
[K, NSETN[LLX], CXX, DDX, DDXD, ZCS])
APR.CS[K] = CXX
return APR
def get_result(gauss, APR, SIGMA2, NTOT, IPP, file_IO4):
#
# GETTING THE RESULT
#
NRS = APR.NR + APR.NSHP
format6919 = "(' start getting the result ')"
fort_write(None, format6919, [])
SIGMAA = SIGMA2 / float(NTOT - NRS)
format9679 = "(/' UNCERTENTY SCALING ',E12.4/)"
fort_write(file_IO4, format9679, [SIGMAA])
NRST = NRS * (NRS + 1) / 2
if IPP[8] == 0:
force_stop(file_IO4)
if IPP[4] != 0:
format116 = "(1H*//,' MATRIX PRODUCT'//)"
fort_write(file_IO4, format116, [])
format152 = "(2X,10E10.4)"
fort_write(file_IO4, format152, gauss.B[1:(NRST + 1)])
format2840 = "(80X,9HLDB,NRS= ,2I6,6H NTOT,I8)"
fort_write(file_IO4, format2840, [LDB, NRS, NTOT])
format7103 = "(2E16.8)"
format6918 = "(' start on matrix inversion ')"
fort_write(None, format6918, [])
# CALL DPPFA(B,NRS,INFO)
NUMEL = NRS * (NRS + 1) // 2
INFO = 0.
tmp = np.array(gauss.B[1:(NUMEL + 1)], dtype='float64', order='F')
linpack_slim.dppfa(ap=tmp, n=NRS, info=INFO)
gauss.B[1:(NUMEL + 1)] = tmp
# ALTERNATIVE: numpy does not know about the packed storaged format
# of symmetric matrices used by DPPFA, so we need to
# unpack the matrix first
# INFO = 0
# try:
# tmp[1:NRS+1,1:NRS+1] = cholesky(tmp[1:NRS+1,1:NRS+1]).T
# except np.linalg.LinAlgError:
# INFO = 1
if INFO != 0:
format105 = "(/' EXP BLOCK CORREL. MATRIX NOT PD',20X,'***** WARNING *')"
format106 = "( ' SOLUTION CORREL. MATRIX NOT PD ' )"
fort_write(file_IO4, format106)
exit()
format9171 = "(' INVERT SOLUTION MATRIX')"
fort_write(file_IO4, format9171, [])
fort_write(None, format9171, [])
JOB = 1
# CALL DPPDI(gauss.B,NRS,DET,JOB)
NUMEL = NRS * (NRS + 1) // 2
tmp_det = np.array([0., 0.], dtype='float64', order='F')
tmp = np.array(gauss.B[1:(NUMEL + 1)], dtype='float64', order='F')
linpack_slim.dppdi(ap=tmp, n=NRS, det=tmp_det, job=JOB)
gauss.B[1:(NUMEL + 1)] = tmp
# ALTERNATIVE: using numpy/scipy functions instead of LINPACK functions
# invert the matrix, we do it a bit complicated to use the cholesky factor
# we invert the cholesky factor and then mutliply its inverse by its transposed inverse
# tmp = unpack_utriang_matrix(tmp)
# tmp = inv(tmp)
# tmp = np.matmul(tmp, tmp.T)
# # pack the result again
# gauss.B[1:(NUMEL+1)] = pack_symmetric_matrix(tmp)
format6917 = "(' completed inversion of matrix')"
fort_write(None, format6917, [])
for I in fort_range(1, NRS): # .lbl13
gauss.DE[I] = 0.
for K in fort_range(1, NRS): # .lbl13
IK = K * (K - 1) // 2 + I
if K < I:
IK = I * (I - 1) // 2 + K
gauss.DE[I] = gauss.DE[I] + gauss.B[IK] * gauss.BM[K]
def write_datablock_header(file_IO4):
format108 = "(/' DATABLOCK************************DATABLOCK**************" + \
"******************************************DATABLOCK '/)"
fort_write(file_IO4, format108, [])
def write_dataset_info(ID, data, LABL, file_IO4):
IDEN = data.IDEN
NCT = data.NCT[ID]
NT = data.NT[ID, :]
NS = IDEN[ID, 6]
MT = IDEN[ID, 7]
format142 = "(//, ' ***********DATASET**************************** '/)"
fort_write(file_IO4, format142, [])
NU = NCT
if NCT > 4:
NU = 4
NCT2 = NCT - NU
NU1 = NU + 1
format139 = "(2X,8HDATA SET,I5,2X,A16,4(2X,2A8))"
tmp = [[LABL.CLAB[NT[K], L] for L in fort_range(1, 2)]
for K in fort_range(1, NU)]
fort_write(file_IO4, format139, [NS, LABL.TYPE[MT], tmp])
if NCT2 > 0:
format149 = "(2X,6(2X,2A8))"
tmp = [[LABL.CLAB[NT[K], L] for L in fort_range(1, 2)]
for K in fort_range(NU1, NCT2)]
fort_write(file_IO4, format149, tmp)
#
# NAME ID AND REFERENCE I/O
#
format132 = "(/' YEAR',I5,' TAG',I3,' AUTHOR: ',4A8,4A8/)"
fort_write(None, format132,
[IDEN[ID, 3:5], LABL.CLABL[1:5], LABL.BREF[1:5]])
# VP if(modrep .ne. 0) go to 183
fort_write(file_IO4, format132,
[IDEN[ID, 3:5], LABL.CLABL[1:5], LABL.BREF[1:5]])
if not should_downweight(ID, data) and (data.MOD2 > 1 and data.MOD2 < 10):
format339 = "(' WEIGHTING OPTION NOT IMPLEMENTED, DATA SET ',I5/)"
fort_write(file_IO4, format339, NS)
def invert_Ecor(data, IPP, file_IO4):
#
# INVERT ECOR
#
MODC = data.MODC
N = data.num_datapoints_used
IREP = 0
while True:
# cholesky decomposition
#CALL DPOFA(ECOR,LDA,N,INFO)
INFO = np.array(0)
tmp = np.array(data.ECOR[1:(N + 1), 1:(N + 1)],
dtype='float64',
order='F')
linpack_slim.dpofa(a=tmp, info=INFO)
data.ECOR[1:(N + 1), 1:(N + 1)] = tmp
# ALTERNATIVE USING NUMPY FUNCTION cholesky
# INFO = 0
# try:
# data.ECOR[1:(N+1),1:(N+1)] = cholesky(data.ECOR[1:(N+1), 1:(N+1)]).T
# except np.linalg.LinAlgError:
# INFO = 1
if INFO == 0:
break
else:
#
# ATTEMPT TO MAKE CORR. MATRIX POSITIVE DEFINITE
#
format105 = "(/' EXP BLOCK CORREL. MATRIX NOT PD',20X,'***** WARNING *')"
fort_write(file_IO4, format105, [])
IREP = IREP + 1
N1 = N - 1
for K in fort_range(1, N1): # .lbl2211
K1 = K + 1
for L in fort_range(K1, N): # .lbl2211
if MODC == 2:
data.ECOR[L, K] = 0.
data.ECOR[K, L] = data.ECOR[L, K]
for K in fort_range(1, N): # .lbl2212
data.ECOR[K, K] = 1.
CXZ = 0.10
for K in fort_range(1, N): # .lbl37
for L in fort_range(1, N):
data.ECOR[K, L] = data.ECOR[K, L] / (1. + CXZ)
if K == L:
data.ECOR[K, L] = 1.
if IREP >= 15:
return False
JOB = 1
# CALL DPODI(ECOR,LDA,N,DET,JOB)
tmp = np.array(data.ECOR[1:(N + 1), 1:(N + 1)], dtype='float64', order='F')
tmp_det = np.array([0., 0.], dtype='float64', order='F')
linpack_slim.dpodi(tmp, det=tmp_det, job=JOB)
data.ECOR[1:(N + 1), 1:(N + 1)] = tmp
# ALTERNATIVE USING NUMPY inv function
# tmp = inv(data.ECOR[1:(N+1),1:(N+1)])
# data.ECOR[1:(N+1),1:(N+1)] = np.matmul(tmp.T, tmp)
for K in fort_range(2, N): # .lbl17
L1 = K - 1
for L in fort_range(1, L1):
data.ECOR[K, L] = data.ECOR[L, K]
L = L + 1 # to match L value of fortran after loop
#
# output of inverted correlation matrix of data block
#
if IPP[5] != 0:
format151 = "(1X,24F7.4)"
for K in fort_range(1, N):
fort_write(file_IO4, format151, [data.ECOR[K, 1:(K + 1)]])
return True
def write_prior_info(APR, IPP, LABL, file_IO4):
# from here onwards only output
NC = APR.NC
NR = APR.NR
# label .lbl30
format134 = r"(//2X,36HCROSS SECTIONS OF PRESENT EVALUATION//)"
fort_write(file_IO4, format134, [])
format135 = "(10X,I3,5X,2A8)"
for K in fort_range(1, NC):
fort_write(file_IO4, format135, [K, LABL.CLAB[K, 1:3]])
# label .lbl22
if IPP[1] != 0:
format136 = "(1H1//,2X,35HENERGIES AND APRIORI CROSS SECTIONS//)"
fort_write(file_IO4, format136, [])
format137 = "(/ ' INDEX E/MEV ',7X,2A8 /)"
for K in fort_range(1, NC): # .lbl24
fort_write(file_IO4, format137, LABL.CLAB[K, 1:3])
JC1 = APR.MCS[K, 2]
JC2 = APR.MCS[K, 3]
LQ = 0
format138 = "(2X,2I4,3X,E10.4,3X,F15.8)"
for L in fort_range(JC1, JC2):
LQ += 1
fort_write(file_IO4, format138, [LQ, L, APR.EN[L], APR.CS[L]])
format113 = "(/,' TOTAL NO OF PARAMETERS ',I4/)"
fort_write(file_IO4, format113, [NR])
#
# for checking
#
if IPP[7] != 0:
format4390 = "(' No of Parameters per Cross Section '/)"
fort_write(file_IO4, format4390, [])
format154 = "(3X,3HAPR.MCS,10I5)"
fort_write(file_IO4, format154, [APR.MCS[1:(NC + 1), 1]])
format4391 = "(/' Start Address '/)"
fort_write(file_IO4, format4391, [])
fort_write(file_IO4, format154, [APR.MCS[1:(NC + 1), 2]])
format4392 = "(/' End Address '/)"
fort_write(file_IO4, format4392, [])
fort_write(file_IO4, format154, [APR.MCS[1:(NC + 1), 3]])
def main():
# IMPLICIT definitions in original version
# IMPLICIT REAL*8 (A-H,O-Z)
# NOTE: This is part of a hack to reproduce a
# bug in the Fortran version of GMAP
# with values in ENFF leaking into
# the next datablock
data = None
#
# IPP i/o choices
# NRED data set Nr.s for downweighting
# NELIM data set Nr.s to exclude from evaluation
#
# INTEGER*2 KAS(250,5),NT(5),IDEN(30,8),NSETN(200),IPP(8),
# 1 NENF(40,10),NETG(11,40),NCSST(10),NEC(2,10,10),NRED(160)
# 2 ,KA(1200,250),NELIM(40)
IPP = np.zeros(8 + 1, dtype=int)
NRED = np.zeros(160 + 1, dtype=int)
NELIM = np.zeros(40 + 1, dtype=int)
basedir = '.'
file_IO3 = open('data.gma', 'r')
file_IO4 = open('gma.res', 'w')
file_IO5 = open('plot.dta', 'w')
APR = init_prior()
gauss = init_gauss()
LABL = init_labels()
#
# INITIALIZE PARAMETERS
#
# NTOT TOTAL NO OF DATA POINTS
#
# DATA DE/1200*0.D0/,BM/1200*0.D0/,B/720600*0.D0/,NRED/160*0/
#
MODREP = 0
NTOT = 0
SIGMA2 = 0.
MODC = 3
IELIM = 0
LLL = 0
#
# CONTROL
#
# AKON CONTROL WORD A4
# MC1-8 PARAMETERS 8I5
#
format110 = (
r"1H1,' PROGRAM GMA'//," +
r"' GAUSS-MARKOV-AITKEN LEAST SQUARES NUCLEAR DATA EVALUATION'//," +
r"' W.P.POENITZ,ANL'///")
fort_write(file_IO4, format110, [])
while True:
#
# Control parameter input
#
format100 = "(A4,1X,8I5)"
ACON, MC1, MC2, MC3, MC4, MC5, MC6, MC7, MC8 = fort_read(
file_IO3, format100)
# LABL.AKON[9] == 'MODE'
if ACON == LABL.AKON[9]:
#
# MODE DEFINITION
#
MODC = MC1
MOD2 = MC2
#VPBEG MPPP=1 allows to use anti-PPP option, when errors of exp data
#VP are taken as % uncertainties from true (posterior) evaluation
MPPP = MC5
#VPEND
AMO3 = MC3 / 10.
MODAP = MC4
if MC2 == 10:
#
# test option: input of data set numbers which are to be downweighted
#
K1 = 1
K2 = 16
format677 = "(16I5)"
for K in fort_range(1, 10): # .lbl678
fort_write(file_IO3, format677, [NRED[K1:(K2 + 1)]])
if NRED[K2] == 0:
break
K1 = K1 + 16
K2 = K2 + 16
for K in fort_range(K1, K2): # .lbl680
if NRED[K] == 0:
break
NELI = K - 1
# LABL.AKON[5] == 'I/OC'
elif ACON == LABL.AKON[5]:
#
# I/O CONTROL
#
IPP = [None for i in range(9)]
IPP[1] = MC1
IPP[2] = MC2
IPP[3] = MC3
IPP[4] = MC4
IPP[5] = MC5
IPP[6] = MC6
IPP[7] = MC7
IPP[8] = MC8
# LABL.AKON[1] == 'APRI'
elif ACON == LABL.AKON[1]:
# INPUT OF CROSS SECTIONS TO BE EVALUATED,ENERGY GRID AND APRIORI CS
read_prior(MC1, MC2, APR, LABL, IPP, file_IO3, file_IO4)
# LABL.AKON[8] == 'FIS*'
elif ACON == LABL.AKON[8]:
fisdata = input_fission_spectrum(MC1, file_IO3, file_IO4)
# LABL.AKON[4] == 'BLCK'
elif ACON == LABL.AKON[4]:
# NOTE: data is provided as argument to reproduce a bug
# in the Fortran version that causes values of ENFF
# leaking into the next datablock
data = prepare_for_datablock_input(data, gauss, MODC, MOD2, AMO3,
MODREP, file_IO4)
# LABL.AKON[2] == 'DATA'
elif ACON == LABL.AKON[2]:
deal_with_dataset(MC1, MC2, MC3, MC4, MC5, MC6, MC7, MC8, data,
fisdata, gauss, LABL, APR, IELIM, NELIM, MPPP,
MODREP, IPP, file_IO3, file_IO4)
# LABL.AKON[7] == 'EDBL'
elif ACON == LABL.AKON[7]:
#
# Data BLOCK complete
#
if data.num_datasets == 0:
continue
complete_symmetric_Ecor(data, file_IO4)
N = data.num_datapoints_used
MODC = data.MODC
if not (IPP[3] == 0 or N == 1 or MODC == 2):
output_Ecor_matrix(data, file_IO4)
if not (MODC == 2 or N == 1):
invertible = invert_Ecor(data, IPP, file_IO4)
if not invertible:
continue
NTOT += data.num_datapoints_used
SIGMA2 = get_matrix_products(gauss, data, MODREP, APR, NTOT,
SIGMA2, file_IO4)
# LABL.AKON[3] == 'END*'
elif ACON == LABL.AKON[3]:
get_result(gauss, APR, SIGMA2, NTOT, IPP, file_IO4)
APR = output_result(gauss, fisdata, APR, MODAP, LABL, file_IO4,
file_IO5)
#
# reset for repeat of fit with replaced apriori from first fit
#
if not (MODAP == 0 or MODREP == MODAP):
MODREP = MODREP + 1
NTOT = 0
SIGMA2 = 0.
APR.NSHP = 0
gauss = init_gauss()
file_IO3.seek(0, 0)
format130 = "(A4)"
for L in fort_range(1, 2000): # .lbl69
DUM = fort_read(file_IO3, format130)[0]
if DUM == LABL.AKON[4]:
break
if DUM == LABL.AKON[4]:
data = prepare_for_datablock_input(data, gauss, MODC, MOD2,
AMO3, MODREP, file_IO4)
continue
output_result_correlation_matrix(gauss, data, APR, IPP, LABL,
file_IO4)
exit()
# LABL.AKON[11] == 'ELIM'
elif ACON == LABL.AKON[11]:
# input: data set numbers which are to be excluded from the evaluation
IELIM = MC1
format171 = r"(16I5)"
NELIM = fort_read(file_IO3, format171)
# LABL.AKON[10] == 'STOP'
elif ACON == LABL.AKON[10]:
force_stop(file_IO4)
elif ACON == LABL.AKON[6]:
format104 = "(A4,2X,' CONTROL CODE UNKNOWN')"
fort_write(file_IO4, format104, [ACON])
exit()
