def solve(self):
self._power = pkes.Solution(1)
# check object
self._validate()
# open output file
fh = open("power.dat", "w")
# calculate steady state
y0 = self._steady_state()
fh.write("{} {} {} {}\n".format(0, 0.0,
self.reactivity.interpolate(0.0),
y0[0]))
self.power.add_data_point(0, 0.0, y0[0])
# resolve function handles
create_f = lambda t, y: self._create_f(self, t, y)
create_jac = lambda t, y: self._create_jac(self, t, y)
set_solution = lambda t, y: self._set_solution(self, t, y)
# create ode solver
ode_solver = ode(create_f,
create_jac).set_integrator('vode',
method='adams',
rtol=1.e-5,
atol=1.e-6,
first_step=1.e-4,
min_step=1.e-5,
max_step=self._max_step)
# set ode parameters and initial value
ode_solver.set_initial_value(y0, 0.0)
# integrate to end time
i = 1
while ode_solver.successful() and ode_solver.t < self.end_time:
ode_solver.integrate(self.end_time, step=True)
self.power.add_data_point(i, ode_solver.t, ode_solver.y[0])
# print to screen and write to file
fh.write("{} {} {} {}\n".format(
i, ode_solver.t, self.reactivity.interpolate(ode_solver.t),
ode_solver.y[0]))
i += 1
fh.close()
# write hdf5 data file
fh = h5py.File("power.h5", "w")
fh["time"] = self.power.time
fh["power"] = self.power.data
fh.close()
def _allocate(self):
# allocate power vector
self._power = pkes.Solution(np.sum(self.num_time_steps) + 1)
# coefficient matrix
self._matrix = np.zeros(
(self.material.num_precs + 1, self.material.num_precs + 1))
# right hand side vector
self._b = np.zeros((self.material.num_precs + 1))
import pkes
import numpy as np
# set material information
mat = pkes.Material()
mat.beta = np.array([
0.000218, 0.001023, 0.000605, 0.00131, 0.00220, 0.000060, 0.000540,
0.000152
])
halflife = np.array([55.6, 24.5, 16.3, 5.21, 2.37, 1.04, 0.424, 0.195])
mat.decay = np.log(2.0) / halflife
mat.pnl = 0.0001866
print(mat)
# set up reactivity trace
reactivity = pkes.Solution(4)
reactivity.add_data_point(0, 0.0, 0.0)
reactivity.add_data_point(1, 10.0, 0.0)
reactivity.add_data_point(2, 10.01, 0.002)
reactivity.add_data_point(3, 100.0, 0.002)
print(reactivity)
# set up solver
solver = pkes.PKEODESolver()
solver.material = mat
solver.end_time = 100.0
solver.max_step = 1.0
solver.reactivity = reactivity
# solve problem
solver.solve()
from __future__ import print_function
import pkes
import numpy as np
# set material information
mat = pkes.Material()
mat.beta = np.array([
0.000218, 0.001023, 0.000605, 0.00131, 0.00220, 0.000060, 0.000540,
0.000152
])
halflife = np.array([55.6, 24.5, 16.3, 5.21, 2.37, 1.04, 0.424, 0.195])
mat.decay = np.log(2.0) / halflife
mat.pnl = 0.0001866
print(mat)
# set up power trace
power = pkes.Solution(2)
power.add_data_point(0, 0.0, 5.0)
power.add_data_point(1, 1.0, 5.0)
print(power)
# set up solver
solver = pkes.IPKESolver()
solver.material = mat
solver.end_times = [1.0]
solver.num_time_steps = [100]
solver.power = power
# solve problem
solver.solve()
#!/usr/bin/env python
# packages
from __future__ import print_function
import pkes
import numpy as np
import pkes.decay_solver_new
TO_SECONDS=86400.0
# get power
with open("power.dat") as handle:
lines = handle.read().splitlines()
n_lines = len(lines)
power = pkes.Solution(n_lines)
for i in range(len(lines)):
time = float(lines[i].split()[1])
power_pt = float(lines[i].split()[3])
power.add_data_point(i, time, power_pt)
# set up solver
solver = pkes.decay_solver_new.DecaySolverNew()
solver.end_times = np.asarray([1.0, 2.0, 23.0, 25.0, 72.0, 100.0, 720.0, 1000.0]) * TO_SECONDS
solver.num_time_steps = [1000, 1000, 3000, 3000, 10000, 10000, 10000, 10000]
solver.power = power
# solve problem
solver.solve()
mat = pkes.Material()
mat.beta = np.array([
0.000218, 0.001023, 0.000605, 0.00131, 0.00220, 0.000060, 0.000540,
0.000152
])
halflife = np.array([55.6, 24.5, 16.3, 5.21, 2.37, 1.04, 0.424, 0.195])
mat.decay = np.log(2.0) / halflife
mat.pnl = 0.0001866
print(mat)
# get reactivity
fh = h5py.File("reactivity.h5", "r")
time = fh["time"].value
rho = fh["rho"].value
n_points = len(time)
reactivity = pkes.Solution(n_points + 3)
for i in range(n_points):
reactivity.add_data_point(i, time[i], rho[i])
reactivity.add_data_point(n_points, 720.0 * TO_SECONDS, rho[-1])
reactivity.add_data_point(n_points + 1, 720.0 * TO_SECONDS + 5.0,
-0.0050 * np.sum(mat.beta))
reactivity.add_data_point(n_points + 2,
72.0 * TO_SECONDS + 100000.0 * TO_SECONDS,
-0.0050 * np.sum(mat.beta))
print(reactivity._time[-3])
print(reactivity._data[-3])
print(reactivity._time[-2])
print(reactivity._data[-2])
print(reactivity._time[-1])
print(reactivity._data[-1])
def _allocate(self):
# allocate reactivity vector
self._reactivity = pkes.Solution(np.sum(self.num_time_steps) + 1)
self._power = pkes.Solution(np.sum(self.num_time_steps) + 1)
self._time = pkes.Solution(np.sum(self.num_time_steps) + 1)
