def ELIMITC(Magboltz):
ISAMP = 10
I = 0
SMALL = 1.0e-20
RTHETA = Magboltz.BTHETA * math.acos(-1) / 180
EFZ100 = Magboltz.EFIELD * 100 * math.sin(RTHETA)
EFX100 = Magboltz.EFIELD * 100 * math.cos(RTHETA)
F1 = Magboltz.EFIELD * Magboltz.CONST2 * math.cos(Magboltz.RTHETA)
EOVBR = Magboltz.EOVB * math.sin(RTHETA)
E1 = Magboltz.ESTART
INTEM = 8
TDASH = 0.0
CONST9 = Magboltz.CONST3 * 0.01
TEMP = np.zeros(4000)
for J in range(4000):
TEMP[J] = Magboltz.TCFN[J] + Magboltz.TCF[J]
DCZ1 = math.cos(Magboltz.THETA)
DCX1 = math.sin(Magboltz.THETA) * math.cos(Magboltz.PHI)
DCY1 = math.sin(Magboltz.THETA) * math.sin(Magboltz.PHI)
VTOT = CONST9 * math.sqrt(E1)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
F4 = 2 * math.acos(-1)
DELTAE = Magboltz.EFINAL / float(INTEM)
J2M = Magboltz.NMAX / ISAMP
for J1 in range(int(J2M)):
R5 = 1
TEST1 = 0
while R5 > TEST1:
R1 = Magboltz.RAND48.drand()
I = int(E1 / DELTAE) + 1
I = min(I, INTEM) - 1
TLIM = Magboltz.TCFMAX[I]
T = -1 * np.log(R1) / TLIM + TDASH
TDASH = T
WBT = Magboltz.WB * T
COSWT = math.cos(WBT)
SINWT = math.sin(WBT)
DZ = (CZ1 * SINWT + (EOVBR - CY1) * (1 - COSWT)) / Magboltz.WB
DX = CX1 * T + F1 * T * T
E = E1 + DZ * EFZ100 + DX * EFX100
IE = int(E / Magboltz.ESTEP)
IE = min(IE, 3999)
if TEMP[IE] > TLIM:
TDASH += np.log(R1) / TLIM
Magboltz.TCFMAX[I] *= 1.05
continue
R5 = Magboltz.RAND48.drand()
TEST1 = Magboltz.TCF[IE] / TLIM
if IE == 3999:
Magboltz.IELOW = 1
TDASH = 0.0
CX2 = CX1 + 2 * F1 * T
CY2 = (CY1 - EOVBR) * COSWT + CZ1 * SINWT + EOVBR
CZ2 = CZ1 * COSWT - (CY1 - EOVBR) * SINWT
VTOT = math.sqrt(CX2**2 + CY2**2 + CZ2**2)
DCX2 = CX2 / VTOT
DCY2 = CY2 / VTOT
DCZ2 = CZ2 / VTOT
R2 = Magboltz.RAND48.drand()
I = 0
I = SORT(I, R2, IE, Magboltz)
while Magboltz.CF[IE][I] < R2:
I = I + 1
S1 = Magboltz.RGAS[I]
EI = Magboltz.EIN[I]
if Magboltz.IPN[I] > 0:
R9 = Magboltz.RAND48.drand()
EXTRA = R9 * (E - EI)
EI = EXTRA + EI
IPT = Magboltz.IARRY[I]
if E < EI:
EI = E - 0.0001
S2 = (S1 * S1) / (S1 - 1.0)
R3 = Magboltz.RAND48.drand()
if Magboltz.INDEX[I] == 1:
R31 = Magboltz.RAND48.drand()
F3 = 1.0 - R3 * Magboltz.ANGCT[IE][I]
if R31 > Magboltz.PSCT[IE][I]:
F3 = -1 * F3
elif Magboltz.INDEX[I] == 2:
EPSI = Magboltz.PSCT[IE][I]
F3 = 1 - (2 * R3 * (1 - EPSI)) / (1 + EPSI * (1 - 2 * R3))
else:
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
ARG1 = 1 - S1 * EI / E
ARG1 = max(ARG1, SMALL)
D = 1 - F3 * math.sqrt(ARG1)
E1 = E * (1 - EI / (S1 * E) - 2 * D / S2)
E1 = max(E1, SMALL)
Q = math.sqrt((E / E1) * ARG1) / S1
Q = min(Q, 1)
Magboltz.THETA = math.asin(Q * math.sin(THETA0))
F6 = math.cos(Magboltz.THETA)
U = (S1 - 1) * (S1 - 1) / ARG1
CSQD = F3**2
if F3 < 0 and CSQD > U:
F6 = -1 * F6
F5 = math.sin(Magboltz.THETA)
DCZ2 = min(DCZ2, 1)
VTOT = CONST9 * math.sqrt(E1)
ARGZ = math.sqrt(DCX2 * DCX2 + DCY2 * DCY2)
if ARGZ == 0:
DCZ1 = F6
DCX1 = F9 * F5
DCY1 = F8 * F5
else:
DCZ1 = DCZ2 * F6 + ARGZ * F5 * F8
DCY1 = DCY2 * F6 + (F5 / ARGZ) * (DCX2 * F9 - DCY2 * DCZ2 * F8)
DCX1 = DCX2 * F6 - (F5 / ARGZ) * (DCY2 * F9 + DCX2 * DCZ2 * F8)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
Magboltz.IELOW = 0
def ELIMIT(Magboltz):
ISAMP = 10
SMALL = 1.0e-20
I = 0
RDUM = Magboltz.RSTART
E1 = Magboltz.ESTART
N4000 = 4000
TDASH = 0.0
INTEM = 8
TEMP = np.zeros(4000)
for J in range(N4000):
TEMP[J] = Magboltz.TCFN[J] + Magboltz.TCF[J]
DCZ1 = math.cos(Magboltz.THETA)
DCX1 = math.sin(Magboltz.THETA) * math.cos(Magboltz.PHI)
DCY1 = math.sin(Magboltz.THETA) * math.sin(Magboltz.PHI)
BP = (Magboltz.EFIELD**2) * Magboltz.CONST1
F1 = Magboltz.EFIELD * Magboltz.CONST2
F2 = Magboltz.EFIELD * Magboltz.CONST3
F4 = 2 * math.acos(-1)
J2M = Magboltz.NMAX / ISAMP
DELTAE = Magboltz.EFINAL / float(INTEM)
for J1 in range(int(J2M)):
R5 = 1
TEST1 = 0
while R5 > TEST1:
R1 = Magboltz.RAND48.drand()
I = int(E1 / DELTAE) + 1
I = min(I, INTEM) - 1
TLIM = Magboltz.TCFMAX[I]
T = -1 * np.log(R1) / TLIM + TDASH
TDASH = T
AP = DCZ1 * F2 * math.sqrt(E1)
E = E1 + (AP + BP * T) * T
IE = int(E / Magboltz.ESTEP)
IE = min(IE, 3999)
if TEMP[IE] > TLIM:
TDASH += np.log(R1) / TLIM
Magboltz.TCFMAX[I] *= 1.05
continue
R5 = Magboltz.RAND48.drand()
TEST1 = Magboltz.TCF[IE] / TLIM
if IE == 3999:
Magboltz.IELOW = 1
TDASH = 0.0
CONST6 = math.sqrt(E1 / E)
DCX2 = DCX1 * CONST6
DCY2 = DCY1 * CONST6
DCZ2 = DCZ1 * CONST6 + Magboltz.EFIELD * T * Magboltz.CONST5 / math.sqrt(
E)
R2 = Magboltz.RAND48.drand()
I = 0
I = SORT(I, R2, IE, Magboltz)
while Magboltz.CF[IE][I] < R2:
I = I + 1
S1 = Magboltz.RGAS[I]
EI = Magboltz.EIN[I]
if Magboltz.IPN[I] > 0:
R9 = Magboltz.RAND48.drand()
EXTRA = R9 * (E - EI)
EI = EXTRA + EI
IPT = Magboltz.IARRY[I]
if E < EI:
EI = E - 0.0001
S2 = (S1 * S1) / (S1 - 1.0)
R3 = Magboltz.RAND48.drand()
if Magboltz.INDEX[I] == 1:
R31 = Magboltz.RAND48.drand()
F3 = 1.0 - R3 * Magboltz.ANGCT[IE][I]
if R31 > Magboltz.PSCT[IE][I]:
F3 = -1 * F3
elif Magboltz.INDEX[I] == 2:
EPSI = Magboltz.PSCT[IE][I]
F3 = 1 - (2 * R3 * (1 - EPSI)) / (1 + EPSI * (1 - 2 * R3))
else:
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
ARG1 = 1 - S1 * EI / E
ARG1 = max(ARG1, SMALL)
D = 1 - F3 * math.sqrt(ARG1)
E1 = E * (1 - EI / (S1 * E) - 2 * D / S2)
E1 = max(E1, SMALL)
Q = math.sqrt((E / E1) * ARG1) / S1
Q = min(Q, 1)
Magboltz.THETA = math.asin(Q * math.sin(THETA0))
F6 = math.cos(Magboltz.THETA)
U = (S1 - 1) * (S1 - 1) / ARG1
CSQD = F3**2
if F3 < 0 and CSQD > U:
F6 = -1 * F6
F5 = math.sin(Magboltz.THETA)
DCZ2 = min(DCZ2, 1)
ARGZ = math.sqrt(DCX2 * DCX2 + DCY2 * DCY2)
if ARGZ == 0:
DCZ1 = F6
DCX1 = F9 * F5
DCY1 = F8 * F5
else:
DCZ1 = DCZ2 * F6 + ARGZ * F5 * F8
DCY1 = DCY2 * F6 + (F5 / ARGZ) * (DCX2 * F9 - DCY2 * DCZ2 * F8)
DCX1 = DCX2 * F6 - (F5 / ARGZ) * (DCY2 * F9 + DCX2 * DCZ2 * F8)
Magboltz.IELOW = 0
def MONTEFTH(Magboltz, JPRT):
EPRM = np.zeros(10000000)
IESPECP = np.zeros(100)
TEMP = np.zeros(4000)
IMBPT = 0
I = 0
if JPRT == 0:
Magboltz.NMAX = Magboltz.NMAXOLD
if Magboltz.NMAXOLD > 80000000:
Magboltz.NMAX = 80000000
else:
Magboltz.NMAX = Magboltz.NMAXOLD
S = 0.0
Magboltz.ST = 0.0
Magboltz.X = 0.0
Magboltz.Y = 0.0
Magboltz.Z = 0.0
I100 = 0
Magboltz.ZTOT = 0.0
Magboltz.ZTOTS = 0.0
Magboltz.TTOT = 0.0
Magboltz.TTOTS = 0.0
Magboltz.SMALL = 1e-20
Magboltz.TMAX1 = 0.0
YTOT = 0.0
YTOTS = 0.0
RDUM = Magboltz.RSTART
E1 = Magboltz.ESTART
XTOT = 0.0
XTOTS = 0.0
Magboltz.API = math.acos(-1)
CONST9 = Magboltz.CONST3 * 0.01
F4 = 2 * Magboltz.API
for I in range(300):
Magboltz.TIME[I] = 0.0
for I in range(30):
Magboltz.ICOLL[I] = 0
for I in range(60):
Magboltz.ICOLNN[I] = 0
for I in range(4000):
Magboltz.SPEC[I] = 0
for I in range(8):
Magboltz.ETPL[I] = 0.0
Magboltz.XTPL[I] = 0.0
Magboltz.YTPL[I] = 0.0
Magboltz.ZTPL[I] = 0.0
Magboltz.TTPL[I] = 0.0
Magboltz.XXTPL[I] = 0.0
Magboltz.YYTPL[I] = 0.0
Magboltz.ZZTPL[I] = 0.0
Magboltz.YZTPL[I] = 0.0
Magboltz.XZTPL[I] = 0.0
Magboltz.XYTPL[I] = 0.0
Magboltz.VZTPL[I] = 0.0
Magboltz.VYTPL[I] = 0.0
Magboltz.VXTPL[I] = 0.0
Magboltz.NETPL[I] = 0.0
ID = 0
NCOL = 0
Magboltz.NNULL = 0
NELEC = 0
INTEM = 8
I100 = 0
NEION = 0
NMXADD = 0
NTMPFLG = 0
NPONT = 0
NCLUS = 0
J1 = 1
ZSTRT = 0.0
TSSTRT = 0.0
YSTRT = 0.0
XSTRT = 0.0
Magboltz.API = math.acos(-1)
for J in range(4000):
TEMP[J] = Magboltz.TCF[J] + Magboltz.TCFN[J]
ABSFAKEI = abs(Magboltz.FAKEI)
Magboltz.IFAKE = 0
for J in range(8):
Magboltz.IFAKET[J] = 0
RCS = math.cos((Magboltz.BTHETA - 90) * Magboltz.API / 180)
RSN = math.sin((Magboltz.BTHETA - 90) * Magboltz.API / 180)
RTHETA = Magboltz.BTHETA * Magboltz.API / 180
EFZ100 = Magboltz.EFIELD * 100 * math.sin(RTHETA)
EFX100 = Magboltz.EFIELD * 100 * math.cos(RTHETA)
F1 = Magboltz.EFIELD * Magboltz.CONST2 * math.cos(RTHETA)
EOVBR = Magboltz.EOVB * math.sin(RTHETA)
Magboltz.RNMX = GERJAN(Magboltz.RSTART, Magboltz.API)
IMBPT = 0
DCZ1 = math.cos(Magboltz.THETA)
DCX1 = math.sin(Magboltz.THETA) * math.cos(Magboltz.PHI)
DCY1 = math.sin(Magboltz.THETA) * math.sin(Magboltz.PHI)
JPRINT = Magboltz.NMAX / 10
VTOT = CONST9 * math.sqrt(E1)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
E100 = E1
DCZ100 = DCZ1
DCX100 = DCX1
DCY100 = DCY1
TLIM = Magboltz.TCFMAX[0]
for I in range(1, INTEM):
if TLIM < Magboltz.TCFMAX[I]:
TLIM = Magboltz.TCFMAX[I]
IPRINT = 0
ITER = 0
IPLANE = 0
Magboltz.IPRIM = 0
label.L544
Magboltz.IPRIM += 1
if Magboltz.IPRIM > 1:
if ITER > Magboltz.NMAX:
Magboltz.IPRIM -= 1
goto.L700
Magboltz.X = 0.0
Magboltz.Y = 0.0
Magboltz.Z = 0.0
DCZ1 = DCZ100
DCX1 = DCX100
DCY1 = DCY100
E1 = E100
VTOT = CONST9 * math.sqrt(E1)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
NCLUS += 1
Magboltz.ST = 0.0
TSSTRT = 0.0
ZSTRT = 0.0
IPLANE = 0
YSTRT = 0.0
XSTRT = 0.0
if Magboltz.IPRIM > 10000000:
goto.L700
EPRM[Magboltz.IPRIM - 1] = E1
IDUM = int(E1)
IDUM = min(IDUM, 99)
IESPECP[IDUM] += 1
label.L555
TDASH = 0.0
NELEC += 1
TSTOP = Magboltz.TSTEP + IPLANE * Magboltz.TSTEP
label.L1
R1 = Magboltz.RAND48.drand()
T = -1 * np.log(R1) / Magboltz.TCFMX + TDASH
TDASH = T
WBT = Magboltz.WB * T
COSWT = math.cos(WBT)
SINWT = math.sin(WBT)
label.L15
if T + Magboltz.ST >= TSTOP:
IPLANE += 1
TSTOP += Magboltz.TSTEP
TPLANEH(Magboltz, T, E1, CX1, CY1, CZ1, IPLANE - 1, EOVBR, F1, RCS,
RSN)
if T + Magboltz.ST >= TSTOP and TSTOP <= Magboltz.TFINAL:
goto.L15
if T + Magboltz.ST >= Magboltz.TFINAL:
Magboltz.ZTOT += Magboltz.Z
Magboltz.TTOT += Magboltz.ST
YTOT += Magboltz.Y
XTOT += Magboltz.X
Magboltz.ZTOTS += Magboltz.Z - ZSTRT
YTOTS += Magboltz.Y - YSTRT
XTOTS += Magboltz.X - XSTRT
Magboltz.TTOTS += Magboltz.ST - TSSTRT
TSTOP = Magboltz.TSTEP
if NELEC == NCLUS + 1:
goto.L544
label.L20
Magboltz.X = Magboltz.XS[NPONT]
Magboltz.Y = Magboltz.YS[NPONT]
Magboltz.Z = Magboltz.ZS[NPONT]
Magboltz.ST = Magboltz.TS[NPONT]
E1 = Magboltz.ES[NPONT]
DCX1 = Magboltz.DCX[NPONT]
DCY1 = Magboltz.DCY[NPONT]
DCZ1 = Magboltz.DCZ[NPONT]
VTOT = CONST9 * math.sqrt(E1)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
IPLANE = Magboltz.IPL[NPONT]
NPONT -= 1
ZSTRT = Magboltz.Z
YSTRT = Magboltz.Y
XSTRT = Magboltz.X
TSSTRT = Magboltz.ST
goto.L555
DZ = (CZ1 * SINWT + (EOVBR - CY1) * (1 - COSWT)) / Magboltz.WB
DX = CX1 * T + F1 * T * T
E = E1 + DZ * EFZ100 + DX * EFX100
if E < 0:
E = 0.001
IE = int(E / Magboltz.ESTEP) + 1
IE = min(IE, 3999)
R5 = Magboltz.RAND48.drand()
TEST1 = Magboltz.TCF[IE] / TLIM
if R5 > TEST1:
Magboltz.NNULL += 1
TEST2 = TEMP[IE] / TLIM
if R5 < TEST2:
if Magboltz.NPLAST == 0:
goto.L1
R2 = Magboltz.RAND48.drand()
I = 0
while Magboltz.CFN[IE][I] < R2:
I += 1
Magboltz.ICOLNN[I] += 1
goto.L1
else:
TEST3 = (TEMP[IE] + ABSFAKEI) / TLIM
if R5 < TEST3:
# FAKE IONISATION INCREMENT COUNTER
Magboltz.IFAKE += 1
Magboltz.IFAKET[IPLANE] += 1
if Magboltz.FAKEI < 0.0:
NEION += 1
if NELEC == NCLUS + 1:
goto.L544
goto.L20
NCLUS += 1
NPONT += 1
NMXADD = max(NPONT, NMXADD)
if NPONT >= 2000:
raise ValueError("NPONT>2000")
Magboltz.XS[NPONT] = Magboltz.X + DX
Magboltz.YS[NPONT] = Magboltz.Y + EOVBR * T + (
(CY1 - EOVBR) * SINWT + CZ1 * (1 - COSWT)) / Magboltz.WB
Magboltz.ZS[NPONT] = Magboltz.Z + DZ
Magboltz.TS[NPONT] = Magboltz.ST + T
Magboltz.ES[NPONT] = E
Magboltz.IPL[NPONT] = IPLANE
CXT = CX1 + 2 * T * F1
CYT = (CY1 - EOVBR) * COSWT + CZ1 * SINWT + EOVBR
CZT = CZ1 * COSWT - (CY1 - EOVBR) * SINWT
BOT = 1 / math.sqrt((CXT * CXT + CYT * CYT + CZT * CZT))
Magboltz.DCX[NPONT] = CXT * BOT
Magboltz.DCY[NPONT] = CYT * BOT
Magboltz.DCZ[NPONT] = CZT * BOT
goto.L1
NCOL += 1
T2 = T**2
if (T >= Magboltz.TMAX1):
Magboltz.TMAX1 = T
TDASH = 0.0
CX2 = CX1 + 2 * T * F1
CY2 = (CY1 - EOVBR) * COSWT + CZ1 * SINWT + EOVBR
CZ2 = CZ1 * COSWT - (CY1 - EOVBR) * SINWT
VTOT = math.sqrt(CX2**2 + CY2**2 + CZ2**2)
DCX2 = CX2 / VTOT
DCY2 = CY2 / VTOT
DCZ2 = CZ2 / VTOT
Magboltz.X += DX
Magboltz.Y += EOVBR * T + ((CY1 - EOVBR) * SINWT + CZ1 *
(1 - COSWT)) / Magboltz.WB
Magboltz.Z += DZ
Magboltz.ST += T
IT = int(T)
IT = min(IT, 299)
Magboltz.TIME[IT] += 1
Magboltz.SPEC[IE] += 1
R2 = Magboltz.RAND48.drand()
I = SORT(I, R2, IE, Magboltz)
while Magboltz.CF[IE][I] < R2:
I += 1
S1 = Magboltz.RGAS[I]
EI = Magboltz.EIN[I]
if E < EI:
EI = E - 0.0001
if Magboltz.IPN[I] != 0:
if Magboltz.IPN[I] == -1:
NEION += 1
IPT = Magboltz.IARRY[I]
ID += 1
ITER += 1
IPRINT += 1
Magboltz.ICOLL[int(IPT)] += 1
Magboltz.ICOLN[I] += 1
IT = int(T)
IT = min(IT, 299)
Magboltz.TIME[IT] += 1
Magboltz.ZTOT += Magboltz.Z
Magboltz.TTOT += Magboltz.ST
YTOT += Magboltz.Y
XTOT += Magboltz.X
Magboltz.ZTOTS += Magboltz.Z - ZSTRT
YTOTS += Magboltz.Y - YSTRT
XTOTS += Magboltz.X - XSTRT
Magboltz.TTOTS += Magboltz.ST - TSSTRT
if NELEC == NCLUS + 1:
goto.L544
goto.L20
EISTR = EI
R9 = Magboltz.RAND48.drand()
ESEC = Magboltz.WPL[I] * math.tan(R9 * math.atan(
(E - EI) / (2 * Magboltz.WPL[I])))
ESEC = Magboltz.WPL[I] * (ESEC / Magboltz.WPL[I])**0.9524
EI = ESEC + EI
NCLUS += 1
NPONT += 1
NMXADD = max(NPONT, NMXADD)
if NPONT >= 2000:
raise ValueError("NPONT>2000")
Magboltz.XS[NPONT] = Magboltz.X
Magboltz.YS[NPONT] = Magboltz.Y
Magboltz.ZS[NPONT] = Magboltz.Z
Magboltz.TS[NPONT] = Magboltz.ST
Magboltz.ES[NPONT] = ESEC
NTMPFLG = 1
NCLTMP = NPONT
Magboltz.IPL[NPONT] = IPLANE
if EISTR > 30:
NAUG = Magboltz.NC0[I]
EAVAUG = Magboltz.EC0[I] / float(NAUG)
for JFL in range(int(NAUG)):
NCLUS += 1
NPONT += 1
Magboltz.XS[NPONT] = Magboltz.X
Magboltz.YS[NPONT] = Magboltz.Y
Magboltz.ZS[NPONT] = Magboltz.Z
Magboltz.TS[NPONT] = Magboltz.ST
Magboltz.ES[NPONT] = EAVAUG
R3 = Magboltz.RAND48.drand()
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
F6 = math.cos(THETA0)
F5 = math.sin(THETA0)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
Magboltz.DCX[NPONT] = F9 * F5
Magboltz.DCY[NPONT] = F8 * F5
Magboltz.DCZ[NPONT] = F6
Magboltz.IPL[NPONT] = IPLANE
IPT = Magboltz.IARRY[I]
ID += 1
ITER += 1
IPRINT += 1
Magboltz.ICOLL[int(IPT)] += 1
Magboltz.ICOLN[I] += 1
if Magboltz.IPEN != 0:
if Magboltz.PENFRA[0][I] != 0.0:
RAN = Magboltz.RAND48.drand()
if RAN > Magboltz.PENFRA[0][I]:
goto.L5
NCLUS += 1
NPONT += 1
if NPONT >= 2000:
raise ValueError("NPONT>2000")
if Magboltz.PENFRA[1][I] == 0.0:
Magboltz.XS[NPONT] = Magboltz.X
Magboltz.YS[NPONT] = Magboltz.Y
Magboltz.ZS[NPONT] = Magboltz.Z
goto.L667
ASIGN = 1.0
RAN = Magboltz.RAND48.drand()
RAN1 = Magboltz.RAND48.drand()
if RAN1 < 0.5:
ASIGN = -1 * ASIGN
Magboltz.XS[NPONT] = Magboltz.X - np.log(
RAN) * Magboltz.PENFRA[1][I] * ASIGN
RAN = Magboltz.RAND48.drand()
RAN1 = Magboltz.RAND48.drand()
if RAN1 < 0.5:
ASIGN = -1 * ASIGN
Magboltz.YS[NPONT] = Magboltz.Y - np.log(
RAN) * Magboltz.PENFRA[1][I] * ASIGN
RAN = Magboltz.RAND48.drand()
RAN1 = Magboltz.RAND48.drand()
if RAN1 < 0.5:
ASIGN = -1 * ASIGN
Magboltz.ZS[NPONT] = Magboltz.Z - np.log(
RAN) * Magboltz.PENFRA[1][I] * ASIGN
label.L667
TPEN = Magboltz.ST
if Magboltz.PENFRA[2][I] == 0:
goto.L668
RAN = Magboltz.RAND48.drand()
TPEN = Magboltz.ST - np.log(RAN) * Magboltz.PENFRA[2][I]
label.L668
Magboltz.TS[NPONT] = TPEN
Magboltz.ES[NPONT] = 1.0
Magboltz.DCX[NPONT] = DCX1
Magboltz.DCY[NPONT] = DCY1
Magboltz.DCZ[NPONT] = DCZ1
TSTOP1 = 0.0
IPLANE1 = 0
for KDUM in range(int(Magboltz.ITFINAL)):
TSTOP1 += Magboltz.TSTEP
if TPEN < TSTOP1:
Magboltz.IPL[NPONT] = IPLANE1
break
IPLANE1 += 1
if TPEN >= TSTOP1:
NPONT -= 1
NCLUS -= 1
label.L5
S2 = (S1**2) / (S1 - 1)
R3 = Magboltz.RAND48.drand()
if Magboltz.INDEX[I] == 1:
R31 = Magboltz.RAND48.drand()
F3 = 1.0 - R3 * Magboltz.ANGCT[IE][I]
if R31 > Magboltz.PSCT[IE][I]:
F3 = -1 * F3
elif Magboltz.INDEX[I] == 2:
EPSI = Magboltz.PSCT[IE][I]
F3 = 1 - (2 * R3 * (1 - EPSI) / (1 + EPSI * (1 - 2 * R3)))
else:
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
if E < EI:
EI = 0.0
ARG1 = 1 - S1 * EI / E
ARG1 = max(ARG1, Magboltz.SMALL)
D = 1 - F3 * math.sqrt(ARG1)
E1 = E * (1 - EI / (S1 * E) - 2 * D / S2)
E1 = max(E1, Magboltz.SMALL)
Q = math.sqrt((E / E1) * ARG1) / S1
Q = min(Q, 1)
Magboltz.THETA = math.asin(Q * math.sin(THETA0))
F6 = math.cos(Magboltz.THETA)
U = (S1 - 1) * (S1 - 1) / ARG1
CSQD = F3 * F3
if F3 < 0 and CSQD > U:
F6 = -1 * F6
F5 = math.sin(Magboltz.THETA)
DCZ2 = min(DCZ2, 1)
ARGZ = math.sqrt(DCX2 * DCX2 + DCY2 * DCY2)
if ARGZ == 0:
DCZ1 = F6
DCX1 = F9 * F5
DCY1 = F8 * F5
if NTMPFLG == 1:
F5S = F5 * math.sqrt(E1 / Magboltz.ES[NCLTMP])
if F5S > 1.0:
F5S = 1.0
THSEC = math.asin(F5S)
F5S = math.sin(THSEC)
F6S = math.sin(THSEC)
if F6S < 0:
F6S *= -1
PHIS = PHI0 + Magboltz.API
if PHIS > F4:
PHIS = PHI0 - F4
F8S = math.sin(PHIS)
F9S = math.cos(PHIS)
Magboltz.DCZ[NCLTMP] = F6S
Magboltz.DCX[NCLTMP] = F9S * F5S
Magboltz.DCY[NCLTMP] = F8S * F5S
NTMPFLG = 0
else:
DCZ1 = DCZ2 * F6 + ARGZ * F5 * F8
DCY1 = DCY2 * F6 + (F5 / ARGZ) * (DCX2 * F9 - DCY2 * DCZ2 * F8)
DCX1 = DCX2 * F6 - (F5 / ARGZ) * (DCY2 * F9 + DCX2 * DCZ2 * F8)
if NTMPFLG == 1:
F5S = F5 * math.sqrt(E1 / Magboltz.ES[NCLTMP])
if F5S > 1.0:
F5S = 1.0
THSEC = math.asin(F5S)
F5S = math.sin(THSEC)
F6S = math.sin(THSEC)
if F6 < 0:
F6S *= -1
PHIS = PHI0 + Magboltz.API
if PHIS > F4:
PHIS = PHI0 - F4
F8S = math.sin(PHIS)
F9S = math.cos(PHIS)
Magboltz.DCZS[NCLTMP] = DCZ2 * F6S + ARGZ * F5S * F8S
Magboltz.DCYS[NCLTMP] = DCY2 * F6S + (F5S / ARGZ) * (
DCX2 * F9S - DCY2 * DCZ2 * F8S)
Magboltz.DCXS[NCLTMP] = DCX2 * F6S - (F5S / ARGZ) * (
DCY2 * F9S + DCX2 * DCZ2 * F8S)
NTMPFLG = 0
VTOT = CONST9 * math.sqrt(E1)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
I100 += 1
if I100 == 200:
DCZ100 = DCZ1
DCX100 = DCX1
DCY100 = DCY1
E100 = E1
I100 = 0
if IPRINT <= JPRINT:
goto.L1
IPRINT = 0
Magboltz.WZ = Magboltz.ZTOTS / Magboltz.TTOTS
Magboltz.WZ *= 1e9
Magboltz.WY = YTOTS / Magboltz.TTOTS
Magboltz.WY *= 1e9
Magboltz.WX = XTOTS / Magboltz.TTOTS
Magboltz.WX *= 1e9
WZR = Magboltz.WZ * RCS - Magboltz.WX * RSN
WYR = Magboltz.WY
WXR = Magboltz.WZ * RSN + Magboltz.WX * RCS
JCT = ID / 100000
J1 += 1
goto.L1
label.L700
XID = float(ID)
if NELEC > Magboltz.IPRIM:
ANEION = float(NEION)
ANBT = float(NELEC - Magboltz.IPRIM)
ATTOINT = ANEION / ANBT
Magboltz.ATTERT = math.sqrt(ANEION) / ANEION
Magboltz.AIOERT = math.sqrt(ANBT) / ANBT
else:
ANEION = float(NEION)
ATTOINT = -1
Magboltz.ATTERT = math.sqrt(ANEION) / ANEION
JCT = ID / 100000
EPRMBAR = 0.0
E2PRM = 0.0
if Magboltz.IPRIM == 1:
return
for I in range(int(Magboltz.IPRIM)):
E2PRM = E2PRM + EPRM[I] * EPRM[I]
EPRMBAR += EPRM
EBAR = EPRMBAR / (Magboltz.IPRIM)
EERR = math.sqrt(E2PRM / (Magboltz.IPRIM) - EBAR**2)
def MONTEA(Magboltz):
STO = np.zeros(2000000)
XST = np.zeros(2000000)
YST = np.zeros(2000000)
ZST = np.zeros(2000000)
WZST = np.zeros(10)
AVEST = np.zeros(10)
DFZZST = np.zeros(10)
DFYYST = np.zeros(10)
DFXXST = np.zeros(10)
Magboltz.WX = 0.0
I=0
Magboltz.WY = 0.0
Magboltz.DWX = 0.0
Magboltz.DWY = 0.0
TEMP = np.zeros(4000)
for J in range(4000):
TEMP[J] = Magboltz.TCF[J] + Magboltz.TCFN[J]
Magboltz.X = 0.0
Magboltz.Y = 0.0
Magboltz.Z = 0.0
Magboltz.ST = 0.0
ST1 = 0.0
ST2 = 0.0
SUME2 = 0.0
SUMXX = 0.0
SUMYY = 0.0
SUMZZ = 0.0
SUMVX = 0.0
SUMVY = 0.0
ZOLD = 0.0
STOLD = 0.0
ST1OLD = 0.0
ST2OLD = 0.0
SZZOLD = 0.0
SXXOLD = 0.0
SYYOLD = 0.0
SVXOLD = 0.0
SVYOLD = 0.0
SME2OLD = 0.0
Magboltz.SMALL = 1.0e-20
Magboltz.TMAX1 = 0.0
RDUM = Magboltz.RSTART
E1 = Magboltz.ESTART
CONST9 = Magboltz.CONST3 * 0.01
INTEM = 8
Magboltz.ITMAX = 10
ID = 0
Magboltz.XID = 0
NCOL = 0
IEXTRA = 0
Magboltz.NNULL = 0
# TODO: LIST
ABSFAKEI = Magboltz.FAKEI
Magboltz.IFAKE = 0
DCZ1 = math.cos(Magboltz.THETA)
DCX1 = math.sin(Magboltz.THETA) * math.cos(Magboltz.PHI)
DCY1 = math.sin(Magboltz.THETA) * math.sin(Magboltz.PHI)
VTOT = CONST9 * math.sqrt(E1)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
BP = Magboltz.EFIELD ** 2 * Magboltz.CONST1
F1 = Magboltz.EFIELD * Magboltz.CONST2
F2 = Magboltz.EFIELD * Magboltz.CONST3
F4 = 2 * math.acos(-1)
J2M = Magboltz.NMAX / Magboltz.ITMAX
DELTAE = Magboltz.EFINAL / float(INTEM)
for J1 in range(int(Magboltz.ITMAX)):
for J2 in range(int(J2M)):
while True:
R1 = Magboltz.RAND48.drand()
I = int(E1 / DELTAE) + 1
I = min(I, INTEM) - 1
TLIM = Magboltz.TCFMAX[I]
T = -1 * np.log(R1) / TLIM + TDASH
TDASH = T
AP = DCZ1 * F2 * math.sqrt(E1)
E = E1 + (AP + BP * T) * T
IE = int(E / Magboltz.ESTEP)
IE = min(IE, 3999)
if TEMP[IE] > TLIM:
TDASH += np.log(R1) / TLIM
Magboltz.TCFMAX[I] *= 1.05
continue
R5 = Magboltz.RAND48.drand()
TEST1 = Magboltz.TCF[IE] / TLIM
if R5 > TEST1:
Magboltz.NNULL += 1
TEST2 = TEMP[IE] / TLIM
if R5 < TEST2:
if Magboltz.NPLAST == 0:
continue
R2 = Magboltz.RAND48.drand()
I = 0
while Magboltz.CFN[IE][I] < R2:
I += 1
Magboltz.ICOLNN[I] += 1
continue
else:
TEST3 = (TEMP[IE] + ABSFAKEI) / TLIM
if R5 < TEST3:
# FAKE IONISATION INCREMENT COUNTER
Magboltz.IFAKE += 1
continue
continue
else:
break
T2 = T ** 2
if (T >= Magboltz.TMAX1):
Magboltz.TMAX1 = T
TDASH = 0.0
WBT = Magboltz.WB * T
COSWT = math.cos(WBT)
SINWT = math.sin(WBT)
CONST6 = math.sqrt(E1 / E)
CX2 = CX1 * COSWT - CY1 * SINWT
CY2 = CY1 * COSWT + CX1 * SINWT
VTOT = CONST9 * math.sqrt(E)
DCX2 = CX2 / VTOT
DCY2 = CY2 / VTOT
DCZ2 = DCZ1 * CONST6 + Magboltz.EFIELD * T * Magboltz.CONST5 / math.sqrt(E)
A = AP * T
B = BP * T2
SUME2 = SUME2 + T * (E1 + A / 2.0 + B / 3.0)
CONST7 = CONST9 * math.sqrt(E1)
A = T * CONST7
NCOL += 1
DX = (CX1 * SINWT - CY1 * (1 - COSWT)) / Magboltz.WB
Magboltz.X += DX
DY = (CY1 * SINWT + CX1 * (1 - COSWT)) / Magboltz.WB
Magboltz.Y += DY
Magboltz.Z += DCZ1 * A + T2 * F1
Magboltz.ST += T
IT = int(T)
IT = min(IT, 299)
Magboltz.TIME[IT] += 1
Magboltz.SPEC[IE] += 1
Magboltz.WZ = Magboltz.Z / Magboltz.ST
SUMVX = SUMVX + DX ** 2
SUMVY = SUMVY + DY ** 2
if ID != 0:
KDUM = 0
for JDUM in range(int(Magboltz.NCORST)):
ST2 = ST2 + T
NCOLDM = NCOL + KDUM
if NCOLDM > Magboltz.NCOLM:
NCOLDM = NCOLDM - Magboltz.NCOLM
SDIF = Magboltz.ST - STO[NCOLDM]
SUMXX += ((Magboltz.X - XST[NCOLDM]) ** 2) * T / SDIF
SUMYY += ((Magboltz.Y - YST[NCOLDM]) ** 2) * T / SDIF
KDUM += Magboltz.NCORLN
if J1 >= 2:
ST1 += T
SUMZZ += ((Magboltz.Z - ZST[NCOLDM] - Magboltz.WZ * SDIF) ** 2) * T / SDIF
XST[NCOL] = Magboltz.X
YST[NCOL] = Magboltz.Y
ZST[NCOL] = Magboltz.Z
STO[NCOL] = Magboltz.ST
if NCOL >= Magboltz.NCOLM:
ID += 1
Magboltz.XID = float(ID)
NCOL = 0
R2 = Magboltz.RAND48.drand()
I = SORT(I, R2, IE, Magboltz)
while Magboltz.CF[IE][I] < R2:
I += 1
S1 = Magboltz.RGAS[I]
EI = Magboltz.EIN[I]
if Magboltz.IPN[I] > 0:
R9 = Magboltz.RAND48.drand()
EXTRA = R9 * (E - EI)
EI = EXTRA + EI
IEXTRA += Magboltz.NC0[I]
IPT = Magboltz.IARRY[I]
Magboltz.ICOLL[int(IPT)] += 1
Magboltz.ICOLN[I] += 1
if E < EI:
EI = E - 0.0001
if Magboltz.IPEN != 0:
if Magboltz.PENFRA[0][I] != 0:
RAN = Magboltz.RAND48.drand()
if RAN <= Magboltz.PENFRA[0][I]:
IEXTRA += 1
S2 = (S1 ** 2) / (S1 - 1.0)
R3 = Magboltz.RAND48.drand()
if Magboltz.INDEX[I] == 1:
R31 = Magboltz.RAND48.drand()
F3 = 1.0 - R3 * Magboltz.ANGCT[IE][I]
if R31 > Magboltz.PSCT[IE][I]:
F3 = -1 * F3
elif Magboltz.INDEX[I] == 2:
EPSI = Magboltz.PSCT[IE][I]
F3 = 1 - (2 * R3 * (1 - EPSI) / (1 + EPSI * (1 - 2 * R3)))
else:
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
ARG1 = 1 - S1 * EI / E
ARG1 = max(ARG1, Magboltz.SMALL)
D = 1 - F3 * math.sqrt(ARG1)
E1 = E * (1 - EI / (S1 * E) - 2 * D / S2)
E1 = max(E1, Magboltz.SMALL)
Q = math.sqrt((E / E1) * ARG1) / S1
Q = min(Q, 1)
Magboltz.THETA = math.asin(Q * math.sin(THETA0))
F6 = math.cos(Magboltz.THETA)
U = (S1 - 1) * (S1 - 1) / ARG1
CSQD = F3 * F3
if F3 < 0 and CSQD > U:
F6 = -1 * F6
F5 = math.sin(Magboltz.THETA)
DCZ2 = min(DCZ2, 1)
VTOT = CONST9 * math.sqrt(E1)
ARGZ = math.sqrt(DCX2 * DCX2 + DCY2 * DCY2)
if ARGZ == 0:
DCZ1 = F6
DCX1 = F9 * F5
DCY1 = F8 * F5
else:
DCZ1 = DCZ2 * F6 + ARGZ * F5 * F8
DCY1 = DCY2 * F6 + (F5 / ARGZ) * (DCX2 * F9 - DCY2 * DCZ2 * F8)
DCX1 = DCX2 * F6 - (F5 / ARGZ) * (DCY2 * F9 + DCX2 * DCZ2 * F8)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
Magboltz.WZ *= 1e9
Magboltz.AVE = SUME2 / Magboltz.ST
if Magboltz.NISO == 0:
Magboltz.DIFXX = 5e15 * SUMVX / Magboltz.ST
Magboltz.DIFYY = 5e15 * SUMVY / Magboltz.ST
DFXXST[J1] = 5e15 * (SUMVX - SVXOLD) / (Magboltz.ST - STOLD)
DFYYST[J1] = 5e15 * (SUMVY - SVYOLD) / (Magboltz.ST - STOLD)
else:
if ST2 != 0.0:
Magboltz.DIFYY = 5e15 * SUMYY / ST2
Magboltz.DIFXX = 5e15 * SUMXX / ST2
DFXXST[J1] = 5e15 * (SUMXX - SXXOLD) / (ST2 - ST2OLD)
DFYYST[J1] = 5e15 * (SUMYY - SYYOLD) / (ST2 - ST2OLD)
else:
DFXXST[J1] = 0.0
DFYYST[J1] = 0.0
if ST1 != 0.0:
Magboltz.DIFZZ = 5e15 * SUMZZ / ST1
DFZZST[J1] = 5e15 * (SUMZZ - SZZOLD) / (ST1 - ST1OLD)
else:
DFZZST[J1] = 0.0
WZST[J1] = (Magboltz.Z - ZOLD) / (Magboltz.ST - STOLD) * 1e9
AVEST[J1] = (SUME2 - SME2OLD) / (Magboltz.ST - STOLD)
ZOLD = Magboltz.Z
STOLD = Magboltz.ST
ST1OLD = ST1
ST2OLD = ST2
SVXOLD = SUMVX
SVYOLD = SUMVY
SZZOLD = SUMZZ
SYYOLD = SUMYY
SXXOLD = SUMXX
SME2OLD = SUME2
TWZST = 0.0
TAVE = 0.0
T2WZST = 0.0
T2AVE = 0.0
TYYST = 0.0
TXXST = 0.0
TZZST = 0.0
T2ZZST = 0.0
T2YYST = 0.0
T2XXST = 0.0
for K in range(10):
TWZST = TWZST + WZST[K]
TAVE = TAVE + AVEST[K]
T2WZST = T2WZST + WZST[K] * WZST[K]
T2AVE = T2AVE + AVEST[K] * AVEST[K]
TXXST += DFXXST[K]
TYYST += DFYYST[K]
T2XXST += DFXXST ** 2
T2YYST += DFYYST ** 2
if K >= 2:
TZZST = TZZST + DFZZST[K]
T2ZZST += DFZZST[K] ** 2
Magboltz.DWZ = 100 * math.sqrt((T2WZST - TWZST * TWZST / 10.0) / 9.0) / Magboltz.WZ
Magboltz.DEN = 100 * math.sqrt((T2AVE - TAVE * TAVE / 10.0) / 9.0) / Magboltz.AVE
Magboltz.DXXER = 100 * math.sqrt((T2XXST - TXXST * TXXST / 10.0) / 9.0) / Magboltz.DIFXX
Magboltz.DYYER = 100 * math.sqrt((T2YYST - TYYST * TYYST / 10.0) / 9.0) / Magboltz.DIFYY
Magboltz.DZZER = 100 * math.sqrt((T2ZZST - TZZST * TZZST / 8.0) / 7.0) / Magboltz.DIFZZ
Magboltz.DWZ = Magboltz.DWZ / math.sqrt(10)
Magboltz.DEN = Magboltz.DEN / math.sqrt(10)
Magboltz.DXXER = Magboltz.DXXER / math.sqrt(10)
Magboltz.DYYER = Magboltz.DYYER / math.sqrt(10)
Magboltz.DZZER = Magboltz.DZZER / math.sqrt(8)
DIFLN = Magboltz.DIFZZ
Magboltz.DIFTR = (Magboltz.DIFXX + Magboltz.DYYER) / 2
# CONVERT CM/SEC
Magboltz.WZ *= 1e5
Magboltz.DFLER = Magboltz.DZZER
Magboltz.DFTER = (Magboltz.DXXER + Magboltz.DYYER) / 2.0
ANCATT = 0.0
ANCION = 0.0
for I in range(Magboltz.NGAS):
ANCATT += Magboltz.ICOLL[5 * I + 2]
ANCION += Magboltz.ICOLL[5 * I + 1]
ANCION += IEXTRA
Magboltz.ATTER = 0.0
if ANCATT != 0:
Magboltz.ATTER = 100 * math.sqrt(ANCATT) / ANCATT
Magboltz.ATT = ANCATT / (Magboltz.ST * Magboltz.WZ) * 1e12
Magboltz.ALPER = 0.0
if ANCION != 0:
Magboltz.ALPER = 100 * math.sqrt(ANCION) / ANCION
Magboltz.ALPHA = ANCION / (Magboltz.ST * Magboltz.WZ) * 1e12
def MONTEFT(Magboltz, JPRT):
EPRM = np.zeros(10000000)
IESPECP = np.zeros(100)
E = Magboltz.E
TEMP = np.zeros(4000)
I = 0
if JPRT == 0:
Magboltz.NMAX = Magboltz.NMAXOLD
if Magboltz.NMAXOLD > 80000000:
Magboltz.NMAX = 80000000
else:
Magboltz.NMAX = Magboltz.NMAXOLD
S = 0.0
Magboltz.ST = 0.0
Magboltz.X = 0.0
Magboltz.Y = 0.0
Magboltz.Z = 0.0
I100 = 0
Magboltz.ZTOT = 0.0
Magboltz.ZTOTS = 0.0
Magboltz.TTOT = 0.0
Magboltz.TTOTS = 0.0
Magboltz.SMALL = 1e-20
Magboltz.TMAX1 = 0.0
RDUM = Magboltz.RSTART
E1 = Magboltz.ESTART
CONST9 = Magboltz.CONST3 * 0.01
Magboltz.API = math.acos(-1)
for I in range(300):
Magboltz.TIME[I] = 0.0
for I in range(30):
Magboltz.ICOLL[I] = 0
for I in range(60):
Magboltz.ICOLNN[I] = 0
for I in range(4000):
Magboltz.SPEC[I] = 0
for I in range(8):
Magboltz.ETPL[I] = 0.0
Magboltz.XTPL[I] = 0.0
Magboltz.YTPL[I] = 0.0
Magboltz.ZTPL[I] = 0.0
Magboltz.TTPL[I] = 0.0
Magboltz.XXTPL[I] = 0.0
Magboltz.YYTPL[I] = 0.0
Magboltz.ZZTPL[I] = 0.0
Magboltz.VZTPL[I] = 0.0
Magboltz.NETPL[I] = 0.0
ID = 0
NCOL = 0
Magboltz.NNULL = 0
NELEC = 0
NEION = 0
NMXADD = 0
NTMPFLG = 0
INTEM = 8
NPONT = 0
NCLUS = 0
J1 = 1
ZSTRT = 0.0
TSSTRT = 0.0
for J in range(4000):
TEMP[J] = Magboltz.TCF[J] + Magboltz.TCFN[J]
ABSFAKEI = abs(Magboltz.FAKEI)
Magboltz.IFAKE = 0
DCZ1 = math.cos(Magboltz.THETA)
DCX1 = math.sin(Magboltz.THETA) * math.cos(Magboltz.PHI)
DCY1 = math.sin(Magboltz.THETA) * math.sin(Magboltz.PHI)
E100 = E1
DCZ100 = DCZ1
DCX100 = DCX1
DCY100 = DCY1
BP = Magboltz.EFIELD**2 * Magboltz.CONST1
F1 = Magboltz.EFIELD * Magboltz.CONST2
F2 = Magboltz.EFIELD * Magboltz.CONST3
F4 = 2 * Magboltz.API
TLIM = Magboltz.TCFMAX[0]
for I in range(1, INTEM):
if TLIM < Magboltz.TCFMAX[I]:
TLIM = Magboltz.TCFMAX[I]
JPRINT = Magboltz.NMAX / 10
IPRINT = 0
ITER = 0
IPLANE = 0
Magboltz.IPRIM = 0
CONST6 = math.sqrt(E1 / E)
label.L544
Magboltz.IPRIM += 1
if Magboltz.IPRIM > 1:
if ITER > Magboltz.NMAX:
Magboltz.IPRIM -= 1
goto.L700
Magboltz.X = 0.0
Magboltz.Y = 0.0
Magboltz.Z = 0.0
DCZ1 = DCZ100
DCX1 = DCX100
DCY1 = DCY100
E1 = E100
NCLUS += 1
Magboltz.ST = 0.0
TSSTRT = 0.0
ZSTRT = 0.0
IPLANE = 0
if Magboltz.IPRIM > 10000000:
goto.L700
EPRM[Magboltz.IPRIM - 1] = E1
IDUM = int(E1)
IDUM = min(IDUM, 99)
IESPECP[IDUM] += 1
label.L555
TDASH = 0.0
NELEC += 1
TSTOP = Magboltz.TSTEP + IPLANE * Magboltz.TSTEP
label.L1
R1 = Magboltz.RAND48.drand()
T = -1 * np.log(R1) / Magboltz.TCFMX + TDASH
TDASH = T
AP = DCZ1 * F2 * math.sqrt(E1)
label.L15
if T + Magboltz.ST >= TSTOP:
IPLANE += 1
TSTOP += Magboltz.TSTEP
TPLANE(Magboltz, T, E1, DCX1, DCY1, DCZ1, AP, BP, IPLANE - 1)
if T + Magboltz.ST >= TSTOP and TSTOP <= Magboltz.TFINAL:
goto.L15
if T + Magboltz.ST >= Magboltz.TFINAL:
Magboltz.ZTOT += Magboltz.Z
Magboltz.TTOT += Magboltz.ST
Magboltz.ZTOTS += Magboltz.Z - ZSTRT
Magboltz.TTOTS += Magboltz.ST - TSSTRT
TSTOP = Magboltz.TSTEP
if NELEC == NCLUS + 1:
goto.L544
label.L20
Magboltz.X = Magboltz.XS[NPONT]
Magboltz.Y = Magboltz.YS[NPONT]
Magboltz.Z = Magboltz.ZS[NPONT]
Magboltz.ST = Magboltz.TS[NPONT]
E1 = Magboltz.ES[NPONT]
DCX1 = Magboltz.DCX[NPONT]
DCY1 = Magboltz.DCY[NPONT]
DCZ1 = Magboltz.DCZ[NPONT]
IPLANE = Magboltz.IPL[NPONT]
NPONT -= 1
ZSTRT = Magboltz.Z
TSSTRT = Magboltz.ST
goto.L555
E = E1 + (AP + BP * T) * T
if E < 0:
E = 0.001
IE = np.int(E / Magboltz.ESTEP)
IE = min(IE, 3999)
R5 = Magboltz.RAND48.drand()
TEST1 = Magboltz.TCF[IE] / TLIM
if R5 > TEST1:
Magboltz.NNULL += 1
TEST2 = TEMP[IE] / TLIM
if R5 < TEST2:
if Magboltz.NPLAST == 0:
goto.L1
R2 = Magboltz.RAND48.drand()
I = 0
while Magboltz.CFN[IE][I] < R2:
I += 1
Magboltz.ICOLNN[I] += 1
goto.L1
else:
TEST3 = (TEMP[IE] + ABSFAKEI) / TLIM
if R5 < TEST3:
# FAKE IONISATION INCREMENT COUNTER
Magboltz.IFAKE += 1
Magboltz.IFAKET[IPLANE] += 1
if Magboltz.FAKEI < 0.0:
NEION += 1
if NELEC == NCLUS + 1:
goto.L544
goto.L20
NCLUS += 1
NPONT += 1
NMXADD = max(NPONT, NMXADD)
if NPONT >= 2000:
raise ValueError("NPONT>2000")
A = T * CONST9 * math.sqrt(E1)
Magboltz.XS[NPONT] = Magboltz.X + DCX1 * A
Magboltz.YS[NPONT] = Magboltz.Y + DCY1 * A
Magboltz.ZS[NPONT] = Magboltz.Z + DCZ1 * A + T * T * F1
Magboltz.TS[NPONT] = Magboltz.ST + T
Magboltz.ES[NPONT] = E
Magboltz.IPL[NPONT] = IPLANE
Magboltz.DCX[NPONT] = DCX1 * CONST6
Magboltz.DCY[NPONT] = DCY1 * CONST6
Magboltz.DCZ[
NPONT] = DCZ1 * CONST6 + Magboltz.EFIELD * T * Magboltz.CONST5 / math.sqrt(
E)
goto.L1
T2 = T**2
if (T >= Magboltz.TMAX1):
Magboltz.TMAX1 = T
TDASH = 0.0
CONST6 = math.sqrt(E1 / E)
DCX2 = DCX1 * CONST6
DCY2 = DCY1 * CONST6
DCZ2 = DCZ1 * CONST6
CONST7 = CONST9 * math.sqrt(E1)
A = T * CONST7
Magboltz.X += DCX1 * A
Magboltz.Y += DCY1 * A
Magboltz.Z += DCZ1 * A + T2 * F1
Magboltz.ST += T
NCOL += 1
IT = int(T)
IT = min(IT, 299)
Magboltz.TIME[IT] += 1
Magboltz.SPEC[IE] += 1
R2 = Magboltz.RAND48.drand()
I = SORT(I, R2, IE, Magboltz)
while Magboltz.CF[IE][I] < R2:
I += 1
S1 = Magboltz.RGAS[I]
EI = Magboltz.EIN[I]
if E < EI:
EI = E - 0.0001
if Magboltz.IPN[I] != 0:
if Magboltz.IPN[I] == -1:
NEION += 1
IPT = Magboltz.IARRY[I]
ID += 1
ITER += 1
IPRINT += 1
Magboltz.ICOLL[int(IPT)] += 1
Magboltz.ICOLN[I] += 1
IT = int(T)
IT = min(IT, 299)
Magboltz.TIME[IT] += 1
Magboltz.ZTOT += Magboltz.Z
Magboltz.TTOT += Magboltz.ST
Magboltz.ZTOTS += Magboltz.Z - ZSTRT
Magboltz.TTOTS += Magboltz.ST - TSSTRT
if NELEC == NCLUS + 1:
goto.L544
goto.L20
EISTR = EI
R9 = Magboltz.RAND48.drand()
ESEC = Magboltz.WPL[I] * math.tan(R9 * math.atan(
(E - EI) / (2 * Magboltz.WPL[I])))
ESEC = Magboltz.WPL[I] * (ESEC / Magboltz.WPL[I])**0.9524
EI = ESEC + EI
NCLUS += 1
NPONT += 1
NMXADD = max(NPONT, NMXADD)
if NPONT >= 2000:
raise ValueError("NPONT>2000")
Magboltz.XS[NPONT] = Magboltz.X
Magboltz.YS[NPONT] = Magboltz.Y
Magboltz.ZS[NPONT] = Magboltz.Z
Magboltz.TS[NPONT] = Magboltz.ST
Magboltz.ES[NPONT] = ESEC
NTMPFLG = 1
NCLTMP = NPONT
Magboltz.IPL[NPONT] = IPLANE
if EISTR > 30:
NAUG = Magboltz.NC0[I]
EAVAUG = Magboltz.EC0[I] / float(NAUG)
for JFL in range(int(NAUG)):
NCLUS += 1
NPONT += 1
Magboltz.XS[NPONT] = Magboltz.X
Magboltz.YS[NPONT] = Magboltz.Y
Magboltz.ZS[NPONT] = Magboltz.Z
Magboltz.TS[NPONT] = Magboltz.ST
Magboltz.ES[NPONT] = EAVAUG
R3 = Magboltz.RAND48.drand()
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
F6 = math.cos(THETA0)
F5 = math.sin(THETA0)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
Magboltz.DCX[NPONT] = F9 * F5
Magboltz.DCY[NPONT] = F8 * F5
Magboltz.DCZ[NPONT] = F6
Magboltz.IPL[NPONT] = IPLANE
IPT = Magboltz.IARRY[I]
ID += 1
ITER += 1
IPRINT += 1
Magboltz.ICOLL[int(IPT)] += 1
Magboltz.ICOLN[I] += 1
TPEN = 0
if Magboltz.IPEN != 0:
if Magboltz.PENFRA[0][I] != 0.0:
RAN = Magboltz.RAND48.drand()
if RAN <= Magboltz.PENFRA[0][I]:
NCLUS += 1
NPONT += 1
if NPONT >= 2000:
raise ValueError("NPONT>2000")
if Magboltz.PENFRA[1][I] == 0.0:
Magboltz.XS[NPONT] = Magboltz.X
Magboltz.YS[NPONT] = Magboltz.Y
Magboltz.ZS[NPONT] = Magboltz.Z
else:
ASIGN = 1.0
RAN = Magboltz.RAND48.drand()
RAN1 = Magboltz.RAND48.drand()
if RAN1 < 0.5:
ASIGN = -1 * ASIGN
Magboltz.XS[NPONT] = Magboltz.X - np.log(
RAN) * Magboltz.PENFRA[1][I] * ASIGN
RAN = Magboltz.RAND48.drand()
RAN1 = Magboltz.RAND48.drand()
if RAN1 < 0.5:
ASIGN = -1 * ASIGN
Magboltz.YS[NPONT] = Magboltz.Y - np.log(
RAN) * Magboltz.PENFRA[1][I] * ASIGN
RAN = Magboltz.RAND48.drand()
RAN1 = Magboltz.RAND48.drand()
if RAN1 < 0.5:
ASIGN = -1 * ASIGN
Magboltz.ZS[NPONT] = Magboltz.Z - np.log(
RAN) * Magboltz.PENFRA[1][I] * ASIGN
TPEN = Magboltz.ST
if Magboltz.PENFRA[2][I] == 0:
goto.L668
RAN = Magboltz.RAND48.drand()
TPEN = Magboltz.ST - np.log(RAN) * Magboltz.PENFRA[2][I]
label.L668
Magboltz.TS[NPONT] = TPEN
Magboltz.ES[NPONT] = 1.0
Magboltz.DCX[NPONT] = DCX1
Magboltz.DCY[NPONT] = DCY1
Magboltz.DCZ[NPONT] = DCZ1
TSTOP1 = 0.0
IPLANE1 = 0
for KDUM in range(int(Magboltz.ITFINAL)):
TSTOP1 += Magboltz.TSTEP
if TPEN < TSTOP1:
Magboltz.IPL[NPONT] = IPLANE1
break
IPLANE1 += 1
if TPEN >= TSTOP1:
NPONT -= 1
NCLUS -= 1
S2 = (S1**2) / (S1 - 1)
R3 = Magboltz.RAND48.drand()
if Magboltz.INDEX[I] == 1:
R31 = Magboltz.RAND48.drand()
F3 = 1.0 - R3 * Magboltz.ANGCT[IE][I]
if R31 > Magboltz.PSCT[IE][I]:
F3 = -1 * F3
elif Magboltz.INDEX[I] == 2:
EPSI = Magboltz.PSCT[IE][I]
F3 = 1 - (2 * R3 * (1 - EPSI) / (1 + EPSI * (1 - 2 * R3)))
else:
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
if E < EI:
EI = 0.0
ARG1 = 1 - S1 * EI / E
ARG1 = max(ARG1, Magboltz.SMALL)
D = 1 - F3 * math.sqrt(ARG1)
E1 = E * (1 - EI / (S1 * E) - 2 * D / S2)
E1 = max(E1, Magboltz.SMALL)
Q = math.sqrt((E / E1) * ARG1) / S1
Q = min(Q, 1)
Magboltz.THETA = math.asin(Q * math.sin(THETA0))
F6 = math.cos(Magboltz.THETA)
U = (S1 - 1) * (S1 - 1) / ARG1
CSQD = F3 * F3
if F3 < 0 and CSQD > U:
F6 = -1 * F6
F5 = math.sin(Magboltz.THETA)
DCZ2 = min(DCZ2, 1)
ARGZ = math.sqrt(DCX2 * DCX2 + DCY2 * DCY2)
if ARGZ == 0:
DCZ1 = F6
DCX1 = F9 * F5
DCY1 = F8 * F5
if NTMPFLG == 1:
F5S = F5 * math.sqrt(E1 / Magboltz.ES[NCLTMP])
if F5S > 1.0:
F5S = 1.0
THSEC = math.asin(F5S)
F5S = math.sin(THSEC)
F6S = math.sin(THSEC)
if F6S < 0:
F6S *= -1
PHIS = PHI0 + Magboltz.API
if PHIS > F4:
PHIS = PHI0 - F4
F8S = math.sin(PHIS)
F9S = math.cos(PHIS)
Magboltz.DCZ[NCLTMP] = F6S
Magboltz.DCX[NCLTMP] = F9S * F5S
Magboltz.DCY[NCLTMP] = F8S * F5S
NTMPFLG = 0
else:
DCZ1 = DCZ2 * F6 + ARGZ * F5 * F8
DCY1 = DCY2 * F6 + (F5 / ARGZ) * (DCX2 * F9 - DCY2 * DCZ2 * F8)
DCX1 = DCX2 * F6 - (F5 / ARGZ) * (DCY2 * F9 + DCX2 * DCZ2 * F8)
if NTMPFLG == 1:
F5S = F5 * math.sqrt(E1 / Magboltz.ES[NCLTMP])
if F5S > 1.0:
F5S = 1.0
THSEC = math.asin(F5S)
F5S = math.sin(THSEC)
F6S = math.sin(THSEC)
if F6S < 0:
F6S *= -1
PHIS = PHI0 + Magboltz.API
if PHIS > F4:
PHIS = PHI0 - F4
F8S = math.sin(PHIS)
F9S = math.cos(PHIS)
Magboltz.DCZ[NCLTMP] = DCZ2 * F6S + ARGZ * F5S * F8S
Magboltz.DCY[NCLTMP] = DCY2 * F6S + (F5S / ARGZ) * (
DCX2 * F9S - DCY2 * DCZ2 * F8S)
Magboltz.DCX[NCLTMP] = DCX2 * F6S - (F5S / ARGZ) * (
DCY2 * F9S + DCX2 * DCZ2 * F8S)
NTMPFLG = 0
I100 += 1
if I100 == 200:
DCZ100 = DCZ1
DCX100 = DCX1
DCY100 = DCY1
E100 = E1
I100 = 0
if IPRINT > JPRINT:
goto.L200
goto.L1
label.L200
IPRINT = 0
W = Magboltz.ZTOTS / Magboltz.TTOTS
W *= 1e9
JCT = ID / 100000
J1 += 1
goto.L1
label.L700
XID = float(ID)
if NELEC > Magboltz.IPRIM:
ANEION = float(NEION)
ANBT = float(NELEC - Magboltz.IPRIM)
ATTOINT = ANEION / ANBT
Magboltz.ATTERT = math.sqrt(ANEION) / ANEION
Magboltz.AIOERT = math.sqrt(ANBT) / ANBT
else:
ANEION = float(NEION)
ATTOINT = -1
Magboltz.ATTERT = math.sqrt(ANEION) / ANEION
JCT = ID / 100000
if J1 == 1:
raise ValueError("TOO FEW COLLISIONS")
EPRMBAR = 0.0
E2PRM = 0.0
if Magboltz.IPRIM == 1:
return
for I in range(int(Magboltz.IPRIM)):
E2PRM = E2PRM + EPRM[I] * EPRM[I]
EPRMBAR += EPRM
EBAR = EPRMBAR / (Magboltz.IPRIM)
EERR = math.sqrt(E2PRM / (Magboltz.IPRIM) - EBAR**2)
def MONTEB(Magboltz):
STO = np.zeros(2000000)
XST = np.zeros(2000000)
YST = np.zeros(2000000)
ZST = np.zeros(2000000)
DFZZST = np.zeros(10)
DFXXST = np.zeros(10)
DFYYST = np.zeros(10)
DFYZST = np.zeros(10)
DFLNST = np.zeros(10)
DFTRST = np.zeros(10)
WZST = np.zeros(10)
WYST = np.zeros(10)
AVEST = np.zeros(10)
TEMP = np.zeros(4000)
for J in range(4000):
TEMP[J] = Magboltz.TCF[J] + Magboltz.TCFN[J]
Magboltz.WX = 0.0
Magboltz.DWX = 0.0
Magboltz.X = 0.0
Magboltz.Y = 0.0
Magboltz.Z = 0.0
Magboltz.DIFXZ = 0.0
Magboltz.DIFXY = 0.0
Magboltz.DXZER = 0.0
Magboltz.DXYER = 0.0
Magboltz.ST = 0.0
ST1 = 0.0
ST2 = 0.0
SUMXX = 0.0
SUMYY = 0.0
SUMZZ = 0.0
SUMYZ = 0.0
SUMLS = 0.0
I=0
SUMTS = 0.0
SUMVX = 0.0
ZOLD = 0.0
YOLD = 0.0
STOLD = 0.0
ST1OLD = 0.0
ST2OLD = 0.0
SZZOLD = 0.0
SXXOLD = 0.0
SYYOLD = 0.0
SYZOLD = 0.0
SVXOLD = 0.0
SLNOLD = 0.0
STROLD = 0.0
EBAROLD = 0.0
Magboltz.SMALL = 1e-20
Magboltz.TMAX1 = 0.0
EF100 = Magboltz.EFIELD * 100
E1 = Magboltz.ESTART
INTEM = 8
Magboltz.ITMAX = 10
ID = 0
NCOL = 0
Magboltz.NNULL = 0
IEXTRA = 0
TDASH = 0.0
CONST9 = Magboltz.CONST3 * 0.01
ABSFAKEI = Magboltz.FAKEI
Magboltz.IFAKE = 0
F4 = 2 * math.acos(-1)
DCZ1 = math.cos(Magboltz.THETA)
DCX1 = math.sin(Magboltz.THETA) * math.cos(Magboltz.PHI)
DCY1 = math.sin(Magboltz.THETA) * math.sin(Magboltz.PHI)
VTOT = CONST9 * math.sqrt(E1)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
J2M = Magboltz.NMAX / Magboltz.ITMAX
DELTAE = Magboltz.EFINAL / float(INTEM)
for J1 in range(int(Magboltz.ITMAX)):
for J2 in range(int(J2M)):
while True:
R1 = Magboltz.RAND48.drand()
I = int(E1 / DELTAE) + 1
I = min(I, INTEM) - 1
TLIM = Magboltz.TCFMAX[I]
T = -1 * np.log(R1) / TLIM + TDASH
TDASH = T
WBT = Magboltz.WB * T
COSWT = math.cos(WBT)
SINWT = math.sin(WBT)
DZ = (CZ1 * SINWT + (Magboltz.EOVB - CY1) * (1 - COSWT)) / Magboltz.WB
E = E1 + DZ * EF100
IE = int(E / Magboltz.ESTEP)
IE = min(IE, 3999)
if TEMP[IE] > TLIM:
TDASH += np.log(R1) / TLIM
Magboltz.TCFMAX[I] *= 1.05
continue
R5 = Magboltz.RAND48.drand()
TEST1 = Magboltz.TCF[IE] / TLIM
if R5 > TEST1:
Magboltz.NNULL += 1
TEST2 = TEMP[IE] / TLIM
if R5 < TEST2:
if Magboltz.NPLAST == 0:
continue
R2 = Magboltz.RAND48.drand()
I = 0
while Magboltz.CFN[IE][I] < R2:
I += 1
Magboltz.ICOLNN[I] += 1
continue
else:
TEST3 = (TEMP[IE] + ABSFAKEI) / TLIM
if R5 < TEST3:
# FAKE IONISATION INCREMENT COUNTER
Magboltz.IFAKE += 1
continue
continue
else:
break
T2 = T ** 2
if (T >= Magboltz.TMAX1):
Magboltz.TMAX1 = T
TDASH = 0.0
CX2 = CX1
CY2 = (CY1 - Magboltz.EOVB) * COSWT + CZ1 * SINWT + Magboltz.EOVB
CZ2 = CZ1 * COSWT - (CY1 - Magboltz.EOVB) * SINWT
VTOT = math.sqrt(CX2 ** 2 + CY2 ** 2 + CZ2 ** 2)
DCX2 = CX2 / VTOT
DCY2 = CY2 / VTOT
DCZ2 = CZ2 / VTOT
NCOL += 1
Magboltz.X += CX1 * T
Magboltz.Y += Magboltz.EOVB * T + ((CY1 - Magboltz.EOVB) * SINWT + CZ1 * (1 - COSWT)) / Magboltz.WB
Magboltz.Z += DZ
Magboltz.ST += T
IT = int(T)
IT = min(IT, 299)
Magboltz.TIME[IT] += 1
Magboltz.SPEC[IE] += 1
Magboltz.WZ = Magboltz.Z / Magboltz.ST
Magboltz.WY = Magboltz.Y / Magboltz.ST
SUMVX += (CX1 ** 2) * T2
if ID != 0:
KDUM = 0
for J in range(int(Magboltz.NCORST)):
ST2 = ST2 + T
NCOLDM = NCOL + KDUM
if NCOLDM > Magboltz.NCOLM:
NCOLDM = NCOLDM - Magboltz.NCOLM
SDIF = Magboltz.ST - STO[NCOLDM]
SUMXX += ((Magboltz.X - XST[NCOLDM]) ** 2) * T / SDIF
KDUM += Magboltz.NCORLN
if J1 >= 2:
ST1 += T
SUMZZ += ((Magboltz.Z - ZST[NCOLDM] - Magboltz.WZ * SDIF) ** 2) * T / SDIF
SUMYY += ((Magboltz.Y - YST[NCOLDM] - Magboltz.WY * SDIF) ** 2) * T / SDIF
SUMYZ += (Magboltz.Z - ZST[NCOLDM] - Magboltz.WZ * SDIF) * (
Magboltz.Y - YST[NCOLDM] - Magboltz.WY * SDIF) * T / SDIF
A2 = (Magboltz.WZ * SDIF) ** 2 + (Magboltz.WY * SDIF) ** 2
B2 = (Magboltz.Z - Magboltz.WZ * SDIF - ZST[NCOLDM]) ** 2 + (
Magboltz.Y - Magboltz.WY * SDIF - YST[NCOLDM]) ** 2
C2 = (Magboltz.Z - ZST[NCOLDM]) ** 2 + (Magboltz.Y - YST[NCOLDM]) ** 2
DL2 = (A2 + B2 - C2) ** 2 / (4 * A2)
DT2 = B2 - DL2
SUMLS += DL2 * T / SDIF
SUMTS += DT2 * T / SDIF
XST[NCOL] = Magboltz.X
YST[NCOL] = Magboltz.Y
ZST[NCOL] = Magboltz.Z
STO[NCOL] = Magboltz.ST
if NCOL >= Magboltz.NCOLM:
ID += 1
Magboltz.XID = float(ID)
NCOL = 0
R2 = Magboltz.RAND48.drand()
I = SORT(I, R2, IE, Magboltz)
while Magboltz.CF[IE][I] < R2:
I += 1
S1 = Magboltz.RGAS[I]
EI = Magboltz.EIN[I]
if Magboltz.IPN[I] > 0:
R9 = Magboltz.RAND48.drand()
EXTRA = R9 * (E - EI)
EI = EXTRA + EI
IEXTRA += Magboltz.NC0[I]
IPT = Magboltz.IARRY[I]
Magboltz.ICOLL[int(IPT)] += 1
Magboltz.ICOLN[I] += 1
if E < EI:
EI = E - 0.0001
if Magboltz.IPEN != 0:
if Magboltz.PENFRA[0][I] != 0:
RAN = Magboltz.RAND48.drand()
if RAN <= Magboltz.PENFRA[0][I]:
IEXTRA += 1
S2 = (S1 ** 2) / (S1 - 1.0)
R3 = Magboltz.RAND48.drand()
if Magboltz.INDEX[I] == 1:
R31 = Magboltz.RAND48.drand()
F3 = 1.0 - R3 * Magboltz.ANGCT[IE][I]
if R31 > Magboltz.PSCT[IE][I]:
F3 = -1 * F3
elif Magboltz.INDEX[I] == 2:
EPSI = Magboltz.PSCT[IE][I]
F3 = 1 - (2 * R3 * (1 - EPSI) / (1 + EPSI * (1 - 2 * R3)))
else:
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
ARG1 = 1 - S1 * EI / E
ARG1 = max(ARG1, Magboltz.SMALL)
D = 1 - F3 * math.sqrt(ARG1)
E1 = E * (1 - EI / (S1 * E) - 2 * D / S2)
E1 = max(E1, Magboltz.SMALL)
Q = math.sqrt((E / E1) * ARG1) / S1
Q = min(Q, 1)
Magboltz.THETA = math.asin(Q * math.sin(THETA0))
F6 = math.cos(Magboltz.THETA)
U = (S1 - 1) * (S1 - 1) / ARG1
CSQD = F3 * F3
if F3 < 0 and CSQD > U:
F6 = -1 * F6
F5 = math.sin(Magboltz.THETA)
DCZ2 = min(DCZ2, 1)
ARGZ = math.sqrt(DCX2 * DCX2 + DCY2 * DCY2)
if ARGZ == 0:
DCZ1 = F6
DCX1 = F9 * F5
DCY1 = F8 * F5
else:
DCZ1 = DCZ2 * F6 + ARGZ * F5 * F8
DCY1 = DCY2 * F6 + (F5 / ARGZ) * (DCX2 * F9 - DCY2 * DCZ2 * F8)
DCX1 = DCX2 * F6 - (F5 / ARGZ) * (DCY2 * F9 + DCX2 * DCZ2 * F8)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
Magboltz.WZ *= 1e9
Magboltz.WY *= 1e9
if ST2 != 0.0:
Magboltz.DIFXX = 5e15 * SUMXX / ST2
if ST1 != 0.0:
Magboltz.DIFZZ = 5e15 * SUMZZ / ST1
Magboltz.DIFYY = 5e15 * SUMYY / ST1
Magboltz.DIFYZ = -5e15 * SUMYZ / ST1
Magboltz.DIFLN = 5e15 * SUMLS / ST1
Magboltz.DIFTR = 5e15 * SUMTS / ST1
if Magboltz.NISO == 0:
Magboltz.DIFXX = 5e15 * SUMVX / Magboltz.ST
EBAR = 0.0
for IK in range(4000):
EBAR += Magboltz.ES[IK] * Magboltz.SPEC[IK] / Magboltz.TCF[IK]
Magboltz.AVE = EBAR / Magboltz.ST
WZST[J1] = (Magboltz.Z - ZOLD) / (Magboltz.ST - STOLD) * 1e9
WYST[J1] = (Magboltz.Y - YOLD) / (Magboltz.ST - STOLD) * 1e9
AVEST[J1] = (EBAR - EBAROLD) / (Magboltz.ST - STOLD)
EBAROLD = EBAR
DFZZST[J1] = 0.0
DFYYST[J1] = 0.0
DFYZST[J1] = 0.0
DFLNST[J1] = 0.0
DFTRST[J1] = 0.0
if J1 > 1:
DFZZST[J1] = 5e15 * (SUMZZ - SZZOLD) / (ST1 - ST1OLD)
DFYYST[J1] = 5e15 * (SUMYY - SYYOLD) / (ST1 - ST1OLD)
DFYZST[J1] = 5e15 * (SUMYZ - SYZOLD) / (ST1 - ST1OLD)
DFLNST[J1] = 5e15 * (SUMLS - SLNOLD) / (ST1 - ST1OLD)
DFTRST[J1] = 5e15 * (SUMTS - STROLD) / (ST1 - ST1OLD)
DFXXST[J1] = 5e15 * (SUMXX - SXXOLD) / (ST2 - ST2OLD)
if Magboltz.NISO == 0:
DFXXST[J1] = 5e15 * (SUMVX - SVXOLD) / (Magboltz.ST - STOLD)
ZOLD = Magboltz.Z
YOLD = Magboltz.Y
STOLD = Magboltz.ST
ST1OLD = ST1
ST2OLD = ST2
SVXOLD = SUMVX
SZZOLD = SUMZZ
SXXOLD = SUMXX
SYYOLD = SUMYY
SYZOLD = SUMYZ
SLNOLD = SUMLS
STROLD = SUMTS
TWZST = 0.0
TWYST = 0.0
TAVE = 0.0
T2WZST = 0.0
T2WYST = 0.0
T2AVE = 0.0
TZZST = 0.0
TYYST = 0.0
TXXST = 0.0
TYZST = 0.0
TLNST = 0.0
TTRST = 0.0
T2ZZST = 0.0
T2YYST = 0.0
T2XXST = 0.0
T2YZST = 0.0
T2LNST = 0.0
T2TRST = 0.0
for K in range(10):
TWZST = TWZST + WZST[K]
TWYST = TWYST + WYST[K]
TAVE = TAVE + AVEST[K]
T2WZST = T2WZST + WZST[K] * WZST[K]
T2WYST = T2WYST + WYST[K] * WYST[K]
T2AVE = T2AVE + AVEST[K] * AVEST[K]
TXXST += DFXXST[K]
T2XXST += DFXXST ** 2
if K >= 2:
TZZST = TZZST + DFZZST[K]
TYYST = TYYST + DFYYST[K]
TYZST = TYZST + DFYZST[K]
TLNST = TLNST + DFLNST[K]
TTRST = TTRST + DFTRST[K]
T2ZZST += DFZZST[K] ** 2
T2YYST += DFYYST[K] ** 2
T2YZST += DFYZST[K] ** 2
T2LNST += DFLNST[K] ** 2
T2TRST += DFTRST[K] ** 2
Magboltz.DWZ = 100 * math.sqrt((T2WZST - TWZST * TWZST / 10.0) / 9.0) / Magboltz.WZ
Magboltz.DWY = 100 * math.sqrt((T2WYST - TWYST * TWYST / 10.0) / 9.0) / abs(Magboltz.WY)
Magboltz.DEN = 100 * math.sqrt((T2AVE - TAVE * TAVE / 10.0) / 9.0) / Magboltz.AVE
Magboltz.DXXER = 100 * math.sqrt((T2XXST - TXXST * TXXST / 10.0) / 9.0) / Magboltz.DIFXX
Magboltz.DYYER = 100 * math.sqrt((T2YYST - TYYST * TYYST / 10.0) / 9.0) / Magboltz.DIFYY
Magboltz.DZZER = 100 * math.sqrt((T2ZZST - TZZST * TZZST / 8.0) / 7.0) / Magboltz.DIFZZ
Magboltz.DYZER = 100 * math.sqrt((T2YZST - TYZST * TYZST / 8.0) / 7.0) / abs(Magboltz.DIFYZ)
Magboltz.DFLER = 100 * math.sqrt((T2LNST - TLNST * TLNST / 8.0) / 7.0) / Magboltz.DIFLN
Magboltz.DFTER = 100 * math.sqrt((T2TRST - TTRST * TTRST / 8.0) / 7.0) / Magboltz.DIFTR
Magboltz.DWZ = Magboltz.DWZ / math.sqrt(10)
Magboltz.DWY = Magboltz.DWY / math.sqrt(10)
Magboltz.DEN = Magboltz.DEN / math.sqrt(10)
Magboltz.DXXER = Magboltz.DXXER / math.sqrt(10)
Magboltz.DYYER = Magboltz.DYYER / math.sqrt(8)
Magboltz.DZZER = Magboltz.DZZER / math.sqrt(8)
Magboltz.DYZER = Magboltz.DYZER / math.sqrt(8)
Magboltz.DFLER = Magboltz.DFLER / math.sqrt(8)
Magboltz.DFTER = Magboltz.DFTER / math.sqrt(8)
# CONVERT CM/SEC
Magboltz.WZ *= 1e5
Magboltz.WY *= 1e5
ANCATT = 0.0
ANCION = 0.0
for I in range(Magboltz.NGAS):
ANCATT += Magboltz.ICOLL[5 * I + 2]
ANCION += Magboltz.ICOLL[5 * I + 1]
ANCION += IEXTRA
Magboltz.ATTER = 0.0
if ANCATT != 0:
Magboltz.ATTER = 100 * math.sqrt(ANCATT) / ANCATT
Magboltz.ATT = ANCATT / (Magboltz.ST * Magboltz.WZ) * 1e12
Magboltz.ALPER = 0.0
if ANCION != 0:
Magboltz.ALPER = 100 * math.sqrt(ANCION) / ANCION
Magboltz.ALPHA = ANCION / (Magboltz.ST * Magboltz.WZ) * 1e12
def MONTEC(Magboltz):
STO = np.zeros(2000000)
XST = np.zeros(2000000)
YST = np.zeros(2000000)
ZST = np.zeros(2000000)
WZST = np.zeros(10)
WYST = np.zeros(10)
WXST = np.zeros(10)
AVEST = np.zeros(10)
DFZZST = np.zeros(10)
DFXXST = np.zeros(10)
I = 0
DFYYST = np.zeros(10)
DFYZST = np.zeros(10)
DFXZST = np.zeros(10)
DFXYST = np.zeros(10)
TEMP = np.zeros(4000)
for J in range(4000):
TEMP[J] = Magboltz.TCF[J] + Magboltz.TCFN[J]
Magboltz.WX = 0.0
Magboltz.DWX = 0.0
Magboltz.X = 0.0
Magboltz.Y = 0.0
Magboltz.Z = 0.0
DIFXXR = 0.0
DIFYYR = 0.0
DIFZZR = 0.0
DIFYZR = 0.0
DIFTR = 0.0
DIFLN = 0.0
DFLER = 0.0
DFTER = 0.0
DIFXZR = 0.0
DIFXYR = 0.0
Magboltz.ST = 0.0
ST1 = 0.0
SUMXX = 0.0
SUMYY = 0.0
SUMZZ = 0.0
SUMYZ = 0.0
SUMXY = 0.0
SUMXZ = 0.0
ZROLD = 0.0
YROLD = 0.0
XROLD = 0.0
SZZR = 0.0
SYYR = 0.0
SXXR = 0.0
SXYR = 0.0
SYZR = 0.0
SXZR = 0.0
STOLD = 0.0
ST1OLD = 0.0
ST2OLD = 0.0
SZZOLD = 0.0
SYYOLD = 0.0
SXXOLD = 0.0
SYZOLD = 0.0
SXYOLD = 0.0
SXZOLD = 0.0
EBAROLD = 0.0
Magboltz.SMALL = 1e-20
Magboltz.TMAX1 = 0.0
Magboltz.API = math.acos(-1)
RCS = math.cos((Magboltz.BTHETA - 90) * Magboltz.API / 180)
RSN = math.sin((Magboltz.BTHETA - 90) * Magboltz.API / 180)
RTHETA = Magboltz.BTHETA * Magboltz.API / 180
EFZ100 = Magboltz.EFIELD * 100 * math.sin(RTHETA)
EFX100 = Magboltz.EFIELD * 100 * math.cos(RTHETA)
F1 = Magboltz.EFIELD * Magboltz.CONST2 * math.sin(RTHETA)
F4 = 2 * Magboltz.API
CONST9 = Magboltz.CONST3 * 0.01
EOVBR = Magboltz.EOVB * math.sin(RTHETA)
E1 = Magboltz.ESTART
ITMAX = 10
ID = 0
NCOL = 0
INTEM = 8
Magboltz.NNULL = 0
IEXTRA = 0
ABSFAKEI = Magboltz.FAKEI
Magboltz.IFAKE = 0
DCZ1 = math.cos(Magboltz.THETA)
DCX1 = math.sin(Magboltz.THETA) * math.cos(Magboltz.PHI)
DCY1 = math.sin(Magboltz.THETA) * math.sin(Magboltz.PHI)
VTOT = CONST9 * math.sqrt(E1)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
DELTAE = Magboltz.EFINAL / float(INTEM)
J2M = Magboltz.NMAX / Magboltz.ITMAX
for J1 in range(int(Magboltz.ITMAX)):
for J2 in range(int(J2M)):
while True:
R1 = Magboltz.RAND48.drand()
I = int(E1 / DELTAE) + 1
I = min(I, INTEM) - 1
TLIM = Magboltz.TCFMAX[I]
T = -1 * np.log(R1) / TLIM + TDASH
TDASH = T
WBT = Magboltz.WB * T
COSWT = math.cos(WBT)
SINWT = math.sin(WBT)
DZ = (CZ1 * SINWT + (EOVBR - CY1) * (1 - COSWT)) / Magboltz.WB
DX = CX1 * T + F1 * T * T
E = E1 + DZ * EFZ100 + DX * EFX100
IE = int(E / Magboltz.ESTEP)
IE = min(IE, 3999)
if TEMP[IE] > TLIM:
TDASH += np.log(R1) / TLIM
Magboltz.TCFMAX[I] *= 1.05
continue
R5 = Magboltz.RAND48.drand()
TEST1 = Magboltz.TCF[IE] / TLIM
if R5 > TEST1:
Magboltz.NNULL += 1
TEST2 = TEMP[IE] / TLIM
if R5 < TEST2:
if Magboltz.NPLAST == 0:
continue
R2 = Magboltz.RAND48.drand()
I = 0
while Magboltz.CFN[IE][I] < R2:
I += 1
Magboltz.ICOLNN[I] += 1
continue
else:
TEST3 = (TEMP[IE] + ABSFAKEI) / TLIM
if R5 < TEST3:
# FAKE IONISATION INCREMENT COUNTER
Magboltz.IFAKE += 1
continue
continue
else:
break
T2 = T**2
if (T >= Magboltz.TMAX1):
Magboltz.TMAX1 = T
TDASH = 0.0
CX2 = CX1 + 2 * F1 * T
CY2 = (CY1 - EOVBR) * COSWT + CZ1 * SINWT + EOVBR
CZ2 = CZ1 * COSWT - (CY1 - EOVBR) * SINWT
VTOT = math.sqrt(CX2**2 + CY2**2 + CZ2**2)
DCX2 = CX2 / VTOT
DCY2 = CY2 / VTOT
DCZ2 = CZ2 / VTOT
NCOL += 1
Magboltz.X += DX
Magboltz.Y += EOVBR * T + ((CY1 - EOVBR) * SINWT + CZ1 *
(1 - COSWT)) / Magboltz.WB
Magboltz.Z += DZ
Magboltz.ST += T
IT = int(T)
IT = min(IT, 299)
Magboltz.TIME[IT] += 1
Magboltz.SPEC[IE] += 1
Magboltz.WZ = Magboltz.Z / Magboltz.ST
Magboltz.WY = Magboltz.Y / Magboltz.ST
Magboltz.WX = Magboltz.X / Magboltz.ST
if J1 >= 2:
KDUM = 0
for J in range(int(Magboltz.NCORST)):
NCOLDM = NCOL + KDUM
if NCOLDM > Magboltz.NCOLM:
NCOLDM = NCOLDM - Magboltz.NCOLM
ST1 += T
SDIF = Magboltz.ST - STO[NCOLDM]
KDUM += Magboltz.NCORLN
SUMZZ += ((Magboltz.Z - ZST[NCOLDM] - Magboltz.WZ * SDIF)**
2) * T / SDIF
SUMYY += ((Magboltz.Y - YST[NCOLDM] - Magboltz.WY * SDIF)**
2) * T / SDIF
SUMXX += ((Magboltz.X - XST[NCOLDM] - Magboltz.WX * SDIF)**
2) * T / SDIF
SUMYZ += (Magboltz.Z - ZST[NCOLDM] - Magboltz.WZ *
SDIF) * (Magboltz.Y - YST[NCOLDM] -
Magboltz.WY * SDIF) * T / SDIF
SUMXY += (Magboltz.X - XST[NCOLDM] - Magboltz.WX *
SDIF) * (Magboltz.Y - YST[NCOLDM] -
Magboltz.WY * SDIF) * T / SDIF
SUMXZ += (Magboltz.X - XST[NCOLDM] - Magboltz.WX *
SDIF) * (Magboltz.Z - ZST[NCOLDM] -
Magboltz.WZ * SDIF) * T / SDIF
XST[NCOL] = Magboltz.X
YST[NCOL] = Magboltz.Y
ZST[NCOL] = Magboltz.Z
STO[NCOL] = Magboltz.ST
if NCOL >= Magboltz.NCOLM:
ID += 1
Magboltz.XID = float(ID)
NCOL = 0
R2 = Magboltz.RAND48.drand()
I = SORT(I, R2, IE, Magboltz)
while Magboltz.CF[IE][I] < R2:
I += 1
S1 = Magboltz.RGAS[I]
EI = Magboltz.EIN[I]
if Magboltz.IPN[I] > 0:
R9 = Magboltz.RAND48.drand()
EXTRA = R9 * (E - EI)
EI = EXTRA + EI
IEXTRA += Magboltz.NC0[I]
IPT = Magboltz.IARRY[I]
Magboltz.ICOLL[int(IPT)] += 1
Magboltz.ICOLN[I] += 1
if E < EI:
EI = E - 0.0001
if Magboltz.IPEN != 0:
if Magboltz.PENFRA[0][I] != 0:
RAN = Magboltz.RAND48.drand()
if RAN <= Magboltz.PENFRA[0][I]:
IEXTRA += 1
S2 = (S1**2) / (S1 - 1.0)
R3 = Magboltz.RAND48.drand()
if Magboltz.INDEX[I] == 1:
R31 = Magboltz.RAND48.drand()
F3 = 1.0 - R3 * Magboltz.ANGCT[IE][I]
if R31 > Magboltz.PSCT[IE][I]:
F3 = -1 * F3
elif Magboltz.INDEX[I] == 2:
EPSI = Magboltz.PSCT[IE][I]
F3 = 1 - (2 * R3 * (1 - EPSI) / (1 + EPSI * (1 - 2 * R3)))
else:
F3 = 1 - 2 * R3
THETA0 = math.acos(F3)
R4 = Magboltz.RAND48.drand()
PHI0 = F4 * R4
F8 = math.sin(PHI0)
F9 = math.cos(PHI0)
ARG1 = 1 - S1 * EI / E
ARG1 = max(ARG1, Magboltz.SMALL)
D = 1 - F3 * math.sqrt(ARG1)
E1 = E * (1 - EI / (S1 * E) - 2 * D / S2)
E1 = max(E1, Magboltz.SMALL)
Q = math.sqrt((E / E1) * ARG1) / S1
Q = min(Q, 1)
Magboltz.THETA = math.asin(Q * math.sin(THETA0))
F6 = math.cos(Magboltz.THETA)
U = (S1 - 1) * (S1 - 1) / ARG1
CSQD = F3 * F3
if F3 < 0 and CSQD > U:
F6 = -1 * F6
F5 = math.sin(Magboltz.THETA)
DCZ2 = min(DCZ2, 1)
VTOT = CONST9 * math.sqrt(E1)
ARGZ = math.sqrt(DCX2 * DCX2 + DCY2 * DCY2)
if ARGZ == 0:
DCZ1 = F6
DCX1 = F9 * F5
DCY1 = F8 * F5
else:
DCZ1 = DCZ2 * F6 + ARGZ * F5 * F8
DCY1 = DCY2 * F6 + (F5 / ARGZ) * (DCX2 * F9 - DCY2 * DCZ2 * F8)
DCX1 = DCX2 * F6 - (F5 / ARGZ) * (DCY2 * F9 + DCX2 * DCZ2 * F8)
CX1 = DCX1 * VTOT
CY1 = DCY1 * VTOT
CZ1 = DCZ1 * VTOT
Magboltz.WZ *= 1e9
Magboltz.WY *= 1e9
Magboltz.WX *= 1e9
WZR = Magboltz.WZ * RCS - Magboltz.WX * RSN
WYR = Magboltz.WY
WXR = Magboltz.WZ * RSN + Magboltz.WX * RCS
ZR = Magboltz.Z * RCS - Magboltz.X * RSN
YR = Magboltz.Y
XR = Magboltz.Z * RSN + Magboltz.X * RCS
EBAR = 0.0
for IK in range(4000):
EBAR += Magboltz.ES[IK] * Magboltz.SPEC[IK] / Magboltz.TCF[IK]
Magboltz.AVE = EBAR / Magboltz.ST
WZST[J1] = (ZR - ZROLD) / (Magboltz.ST - STOLD) * 1e9
WYST[J1] = (YR - YROLD) / (Magboltz.ST - STOLD) * 1e9
WXST[J1] = (XR - XROLD) / (Magboltz.ST - STOLD) * 1e9
AVEST[J1] = (EBAR - EBAROLD) / (Magboltz.ST - STOLD)
EBAROLD = EBAR
if J1 >= 2:
Magboltz.DIFXX = 5e15 * SUMXX / ST1
Magboltz.DIFYY = 5e15 * SUMYY / ST1
Magboltz.DIFZZ = 5e15 * SUMZZ / ST1
Magboltz.DIFXY = 5e15 * SUMXY / ST1
Magboltz.DIFYZ = 5e15 * SUMYZ / ST1
Magboltz.DIFXZ = 5e15 * SUMXZ / ST1
DIFXXR = Magboltz.DIFXX * RCS * RCS + Magboltz.DIFZZ * RSN * RSN + 2 * RCS * RSN * Magboltz.DIFXZ
DIFYYR = Magboltz.DIFYY
DIFZZR = Magboltz.DIFXX * RSN * RSN + Magboltz.DIFZZ * RCS * RCS - 2 * RCS * RSN * Magboltz.DIFXZ
DIFXYR = RCS * Magboltz.DIFXY + RSN * Magboltz.DIFYZ
DIFYZR = RCS * Magboltz.DIFXY - RCS * Magboltz.DIFYZ
DIFXZR = (RCS * RCS - RSN * RSN) * Magboltz.DIFXZ - RSN * RCS * (
Magboltz.DIFXX - Magboltz.DIFZZ)
SXXR = SUMXX * RCS * RCS + SUMZZ * RSN * RSN + 2 * RCS * RSN * SUMXZ
SYYR = SUMYY
SZZR = SUMXX * RSN * RSN + SUMZZ * RCS * RCS - 2 * RCS * RSN * SUMXZ
SXYR = RCS * SUMXY + RSN * SUMYZ
SYZR = RSN * SUMXY - RCS * SUMYZ
SXZR = (RCS * RCS - RSN * RSN) * SUMXZ - RSN * RCS * (SUMXX -
SUMZZ)
DFZZST[J1] = 0.0
DFXXST[J1] = 0.0
DFYYST[J1] = 0.0
DFYZST[J1] = 0.0
DFXZST[J1] = 0.0
DFXYST[J1] = 0.0
if J1 > 1:
DFZZST[J1] = 5e15 * (SUMZZ - SZZOLD) / (ST1 - ST1OLD)
DFXXST[J1] = 5e15 * (SUMXX - SXXOLD) / (ST1 - ST1OLD)
DFYYST[J1] = 5e15 * (SUMYY - SYYOLD) / (ST1 - ST1OLD)
DFYZST[J1] = 5e15 * (SUMYZ - SYZOLD) / (ST1 - ST1OLD)
DFXZST[J1] = 5e15 * (SUMXZ - SXZOLD) / (ST1 - ST1OLD)
DFXYST[J1] = 5e15 * (SUMXY - SXYOLD) / (ST1 - ST1OLD)
ZROLD = ZR
YROLD = YR
XROLD = XR
STOLD = Magboltz.ST
ST1OLD = ST1
SZZOLD = SZZR
SYYOLD = SYYR
SXXOLD = SXXR
SXYOLD = SXYR
SYZOLD = SYZR
SXZOLD = SXZR
TWZST = 0.0
TWYST = 0.0
TWXST = 0.0
TAVE = 0.0
T2WZST = 0.0
T2WYST = 0.0
T2WXST = 0.0
T2AVE = 0.0
TZZST = 0.0
TYYST = 0.0
TXXST = 0.0
TXYST = 0.0
TXZST = 0.0
TYZST = 0.0
T2ZZST = 0.0
T2YYST = 0.0
T2XXST = 0.0
T2XYST = 0.0
T2XZST = 0.0
T2YZST = 0.0
for K in range(10):
TWZST = TWZST + WZST[K]
TWYST = TWYST + WYST[K]
TWXST = TWXST + WXST[K]
TAVE = TAVE + AVEST[K]
T2WZST = T2WZST + WZST[K] * WZST[K]
T2WYST = T2WYST + WYST[K] * WYST[K]
T2WXST = T2WXST + WXST[K] * WXST[K]
T2AVE = T2AVE + AVEST[K] * AVEST[K]
if K >= 2:
TZZST = TZZST + DFZZST[K]
TYYST = TYYST + DFYYST[K]
TXXST = TXXST + DFXXST[K]
TYZST = TYZST + DFYZST[K]
TXYST = TXYST + DFXYST[K]
TXZST = TXZST + DFXZST[K]
T2ZZST += DFZZST[K]**2
T2XXST += DFXXST[K]**2
T2YYST += DFYYST[K]**2
T2YZST += DFYZST[K]**2
T2XYST += DFXYST[K]**2
T2XZST += DFXZST[K]**2
Magboltz.DWZ = 100 * math.sqrt((T2WZST - TWZST * TWZST / 10.0) / 9.0) / WZR
Magboltz.DWY = 100 * math.sqrt(
(T2WYST - TWYST * TWYST / 10.0) / 9.0) / abs(WYR)
Magboltz.DWX = 100 * math.sqrt(
(T2WXST - TWXST * TWXST / 10.0) / 9.0) / abs(WXR)
Magboltz.DEN = 100 * math.sqrt(
(T2AVE - TAVE * TAVE / 10.0) / 9.0) / Magboltz.AVE
Magboltz.DZZER = 100 * math.sqrt(
(T2ZZST - TZZST * TZZST / 8.0) / 7.0) / DIFZZR
Magboltz.DYYER = 100 * math.sqrt(
(T2YYST - TYYST * TYYST / 8.0) / 7.0) / DIFYYR
Magboltz.DXXER = 100 * math.sqrt(
(T2XXST - TXXST * TXXST / 8.0) / 7.0) / DIFXXR
Magboltz.DXYER = 100 * math.sqrt(
(T2XYST - TXYST * TXYST / 8.0) / 7.0) / abs(DIFXYR)
Magboltz.DXZER = 100 * math.sqrt(
(T2XZST - TXZST * TXZST / 8.0) / 7.0) / abs(DIFXZR)
Magboltz.DYZER = 100 * math.sqrt(
(T2YZST - TYZST * TYZST / 8.0) / 7.0) / abs(DIFYZR)
Magboltz.DWZ = Magboltz.DWZ / math.sqrt(10)
Magboltz.DWX = Magboltz.DWX / math.sqrt(10)
Magboltz.DWY = Magboltz.DWY / math.sqrt(10)
Magboltz.DEN = Magboltz.DEN / math.sqrt(10)
Magboltz.DXXER = Magboltz.DXXER / math.sqrt(8)
Magboltz.DYYER = Magboltz.DYYER / math.sqrt(8)
Magboltz.DZZER = Magboltz.DZZER / math.sqrt(8)
Magboltz.DYZER = Magboltz.DYZER / math.sqrt(8)
Magboltz.DXYER = Magboltz.DXYER / math.sqrt(8)
Magboltz.DXZER = Magboltz.DXZER / math.sqrt(8)
Magboltz.WZ = WZR
Magboltz.WX = WXR
Magboltz.WY = WYR
Magboltz.DIFXX = DIFXXR
Magboltz.DIFYY = DIFYYR
Magboltz.DIFZZ = DIFZZR
Magboltz.DIFYZ = DIFYZR
Magboltz.DIFXY = DIFXYR
Magboltz.DIFXZ = DIFXZR
Magboltz.WZ *= 1e5
Magboltz.WY *= 1e5
Magboltz.WX *= 1e5
ANCATT = 0.0
ANCION = 0.0
for I in range(Magboltz.NGAS):
ANCATT += Magboltz.ICOLL[5 * I + 2]
ANCION += Magboltz.ICOLL[5 * I + 1]
ANCION += IEXTRA
Magboltz.ATTER = 0.0
if ANCATT != 0:
Magboltz.ATTER = 100 * math.sqrt(ANCATT) / ANCATT
Magboltz.ATT = ANCATT / (Magboltz.ST * Magboltz.WZ) * 1e12
Magboltz.ALPER = 0.0
if ANCION != 0:
Magboltz.ALPER = 100 * math.sqrt(ANCION) / ANCION
Magboltz.ALPHA = ANCION / (Magboltz.ST * Magboltz.WZ) * 1e12