def test_checker(self):
self.assertTrue(self.res.closest('fn1_correct', 0))
self.assertTrue(self.res.closest('fn2_correct', 0))
self.assertTrue(
os.path.isfile(
self.sim.realpath('Resources/tests/weatherfile2.motab')))
cleantest.clean('TestWeatherFileChecker')
def test_sodium_props(self):
delta = 2 # error tolerated (percentage)
self.assertLessEqual(self.res.interpolate('err_avg_cp_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_cv_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_gamma_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_eta_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_eta_v_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_h_rho_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_h_fg_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_h_s_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_h_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_lamda_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_lamda_v_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_p_rho_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_p_v_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_rho_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_rho_v_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_s_rho_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_s_T_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_T_h_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_T_p_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_T_s_test', 1), delta)
self.assertLessEqual(self.res.interpolate('err_avg_vs_T_test', 1), delta)
cleantest.clean('TestSodiumMedium')
def test_sched(self):
# Note these are set to the values for what is thought to be a working
# version. They are not validated against anything or independently
# calculated.
self.assertTrue(abs(self.perf[0]- 399743.26)/399743.26<0.01) # epy
self.assertTrue(abs(self.perf[1]- 158.11)/ 158.11<0.01) # LCOE
self.assertTrue(abs(self.perf[2]- 45.63)/45.63<0.01) # Capacity factor
cleantest.clean('Reference_2')
def test_sched(self):
# Note these are set to the values for what is thought to be a working
# version. They are not validated against anything or independently
# calculated.
self.assertTrue(
abs(self.perf[0] - 9786027.07) / 9786027.07 < 0.01) # fpy
self.assertTrue(abs(self.perf[1] - 3.24) / 3.24 < 0.01) # LCOF
self.assertTrue(
abs(self.perf[2] - 72.18) / 72.18 < 0.01) # Capacity factor
cleantest.clean('SolarFuelSystem')
def test_sched(self):
# Note these are set to the values for what is thought to be a working
# version. They are not validated against anything or independently
# calculated.
self.assertTrue(
abs(self.perf[0] - 21077831.1) / 21077831.1 < 0.01) # fpy
self.assertTrue(abs(self.perf[1] - 1.52) / 1.52 < 0.01) # LCOF
self.assertTrue(
abs(self.perf[2] - 72.46) / 72.46 < 0.01) # Capacity factor
cleantest.clean('SolarMethanolSystem')
def test_sched(self):
def getval(n):
return self.res.interpolate(n, 1)
if 0:
self.assertAlmostEqual(self.perf[0], 540466.03, 2) # epy
self.assertAlmostEqual(self.perf[1], 75.06, 2) # LCOE
self.assertAlmostEqual(self.perf[2], 61.697, 2) # Capacity factor
self.assertAlmostEqual(getval('R_des') / 1e6, 619.77,
2) # Receiver thermal input
self.assertAlmostEqual(getval('Q_rec_out') / 1e6, 536.25,
2) # Receiver thermal output
self.assertAlmostEqual(getval('P_gross') / 1e6, 111.0,
2) # Power block gross rating
self.assertAlmostEqual(getval('SM'), 2.46, 2) # Solar multiple
self.assertAlmostEqual(getval('D_receiver'), 16.0,
2) # Receiver diameter
self.assertAlmostEqual(getval('H_receiver'), 24.0,
2) # Receiver height
self.assertAlmostEqual(getval('H_tower'), 175.0, 2) # Tower height
self.assertAlmostEqual(getval('n_heliostat'), 6764.0,
2) # Number of heliostats
else:
warnings.warn("Test evaluation has been disabled")
print(
"-----------------------------------------------------------------------"
)
print('Energy per year: %6.2f MWh' %
(self.perf[0]))
print('Capacity factor: %6.2f %%' %
(self.perf[2]))
print('LCOE: $%6.2f/MWh' %
(self.perf[1]))
print(
"-----------------------------------------------------------------------"
)
print('Receiver thermal input at design point: %6.2f MW' %
(getval('R_des') / 1e6))
print('Receiver thermal output at design point: %6.2f MW' %
(getval('Q_rec_out') / 1e6))
print('Power block gross rating at design point: %6.2f MW' %
(getval('P_gross') / 1e6))
print('Solar multiple: %4.2f ' %
(getval('SM')))
print('Receiver diameter: %4.2f m' %
(getval('D_receiver')))
print('Receiver height: %4.2f m' %
(getval('H_receiver')))
print('Tower height: %4.1f m' %
(getval('H_tower')))
print('Number of heliostats: %i' %
(getval('n_heliostat')))
cleantest.clean('NaSaltsCO2System')
def test_source(self):
self.assertAlmostEqual(self.res.closest('wea.lat', 0), -34.236)
self.assertAlmostEqual(self.res.closest('wea.lon', 0), 142.087)
tstart = 6600
solar_noon = 12*60*60 + 34*60 + 54 - tstart
self.assertAlmostEqual(self.res.interpolate('wea.wbus.alt', solar_noon),
78.8, delta=0.1)
self.assertAlmostEqual(self.res.interpolate('wea.wbus.azi', solar_noon),
360.0, delta=1.0) # very sensitive around noon
cleantest.clean('TestWeatherSource')
def test_simple_system(self):
# Note these are set to the values for what is thought to be a working
# version. They are not validated against anything or independently
# calculated.
print('index, epy (MWh/year),lcoe peaker ($/MWh),capf (%),srev ($')
print(self.perf)
self.assertTrue(abs(self.perf[0] - 352.558) / 352.558 < 0.0005) # epy
self.assertTrue(abs(self.perf[1] - 96.490) / 96.490 < 0.0005) # LCOE
self.assertTrue(
abs(self.perf[2] - 40.246) / 40.246 < 0.0005) # Capacity factor
cleantest.clean('SimpleSystem')
def test_sched(self):
def getval(n):
return self.res.interpolate(n,1)
warnings.warn("Test evaluation has been disabled")
# self.assertAlmostEqual(self.perf[0], 560675.35, 2) # epy
# self.assertAlmostEqual(self.perf[1], 78.32, 2) # LCOE
# self.assertAlmostEqual(self.perf[2], 64.00, 2) # Capacity factor
# self.assertAlmostEqual(getval('R_des')/1e6, 741.98, 2) # Receiver thermal input
# self.assertAlmostEqual(getval('Q_rec_out')/1e6, 587.65, 2) # Receiver thermal output
# self.assertAlmostEqual(getval('P_gross')/1e6, 111.0, 2) # Power block gross rating
# self.assertAlmostEqual(getval('SM'), 2.70, 2) # Solar multiple
# self.assertAlmostEqual(getval('D_receiver'), 35.0, 2) # Receiver diameter
# self.assertAlmostEqual(getval('H_receiver'), 20.0, 2) # Receiver height
# self.assertAlmostEqual(getval('H_tower'), 175.0, 2) # Tower height
# self.assertAlmostEqual(getval('n_heliostat'), 8134.0, 2) # Number of heliostas
print("-----------------------------------------------------------------------")
print('Energy per year: %6.2f MWh'%(self.perf[0]))
print('Capacity factor: %6.2f %%'%(self.perf[2]))
print('LCOE: $%6.2f/MWh'%(self.perf[1]))
print("-----------------------------------------------------------------------")
print('Receiver thermal input at design point: %6.2f MW'%(getval('R_des')/1e6))
print('Receiver thermal output at design point: %6.2f MW'%(getval('Q_rec_out')/1e6))
print('Power block gross rating at design point: %6.2f MW'%(getval('P_gross')/1e6))
print('Solar multiple: %4.2f '%(getval('SM')))
print('Receiver diameter: %4.2f m'%(getval('D_receiver')))
print('Receiver height: %4.2f m'%(getval('H_receiver')))
print('Tower height: %4.1f m'%(getval('H_tower')))
print('Number of heliostats: %i'%(getval('n_heliostat')))
print('Tank height: %4.1f m'%(getval('H_storage')))
print('Tank diameter: %4.1f m'%(getval('D_storage')))
print('Available HTF volume: %4.1f m3'%(getval('V_max')))
print("-----------------------------------------------------------------------")
print('Site improvement cost: $%6.2f'%(getval('C_site')/1e6))
print('Heliostat field cost: $%6.2f'%(getval('C_field')/1e6))
print('Tower cost: $%6.2f'%(getval('C_tower')/1e6))
print('Receiver cost: $%6.2f'%(getval('C_receiver')/1e6))
print('Piping (Riser/Downcomer) cost: $%6.2f'%(getval('C_piping')/1e6))
print('Cold pump cost: $%6.2f'%(getval('C_pumps')/1e6))
print('Thermal Storage cost: $%6.2f'%(getval('C_storage')/1e6))
print('Power Block cost: $%6.2f'%(getval('C_block')/1e6))
print("-----------------------------------------------------------------------")
print('Subtotal: $%6.2f'%(getval('C_cap_dir_sub')/1e6))
print('Contingency: $%6.2f'%(getval('C_contingency')/1e6))
print("-----------------------------------------------------------------------")
print('Total direct cost: $%6.2f'%(getval('C_cap_dir_tot')/1e6))
print('Total EPC cost: $%6.2f'%(getval('C_EPC')/1e6))
print('Total land cost: $%6.2f'%(getval('C_land')/1e6))
print("-----------------------------------------------------------------------")
print('Total capital cost: $%6.2f'%(getval('C_cap')/1e6))
cleantest.clean('SaltSCO2System')
def test_table(self):
self.assertAlmostEqual(self.res.interpolate('linear.y[1]', 0.5), 2.5)
self.assertAlmostEqual(self.res.interpolate('linear.y[1]', 0.5), 2.5)
self.assertAlmostEqual(self.res.interpolate('linear.y[1]', 1.5), 2)
self.assertAlmostEqual(self.res.interpolate('linear.y[1]', 2.5), 2.5)
self.assertAlmostEqual(self.res.interpolate('cderiv.y[1]', 0), 3)
self.assertAlmostEqual(self.res.interpolate('cderiv.y[1]', 1), 2)
self.assertAlmostEqual(self.res.interpolate('cderiv.y[1]', 2), 2)
self.assertAlmostEqual(self.res.interpolate('cderiv.y[1]', 3), 3)
self.assertAlmostEqual(self.res.interpolate('cseg.y[1]', 0.5), 3)
self.assertAlmostEqual(self.res.interpolate('cseg.y[1]', 1.5), 2)
self.assertAlmostEqual(self.res.interpolate('cseg.y[1]', 2.5), 2)
cleantest.clean('TestWeatherTable')
def test_modelica():
"""
Run the modelica test of STMotab.
"""
fn = './TestSTMotab.mo'
sim = simulation.Simulator(fn)
sim.compile_model()
sim.compile_sim(args=['-s'])
sim.simulate(start=0, stop='1y', step='5m', solver='dassl', nls='homotopy')
res = DyMat.DyMatFile('TestSTMotab_res.mat')
assert res.data("t1")[0] == 31500000.
assert res.data("dnival")[0] == 976.
assert res.data("dnicol")[0] == 2.
cleantest.clean('TestSTMotab')
def test_solarposition(self):
self.longMessage = True # allow assert msg to be added to std msg
delta = 0.6 # error tolerated (deg)
for i, (t, alt, azi) in enumerate(pnts_0):
self.assertAlmostEqual(self.res.interpolate('solp_0.alt', t),
alt,
delta=delta,
msg='Alt of 0: ' + str(i))
self.assertAlmostEqual(self.res.interpolate('solp_0.azi', t),
azi,
delta=delta,
msg='Azi of 0: ' + str(i))
for i, (t, alt, azi) in enumerate(pnts_can):
self.assertAlmostEqual(self.res.interpolate('solp_can.alt', t),
alt,
delta=delta,
msg='Alt of can: ' + str(i))
self.assertAlmostEqual(self.res.interpolate('solp_can.azi', t),
azi,
delta=delta,
msg='Azi of can: ' + str(i))
for i, (t, alt, azi) in enumerate(pnts_den):
self.assertAlmostEqual(self.res.interpolate('solp_den.alt', t),
alt,
delta=delta,
msg='Alt of den: ' + str(i))
self.assertAlmostEqual(self.res.interpolate('solp_den.azi', t),
azi,
delta=delta,
msg='Azi of den: ' + str(i))
for i, (t, alt, azi) in enumerate(pnts_dag):
self.assertAlmostEqual(self.res.interpolate('solp_dag.alt', t),
alt,
delta=delta,
msg='Alt of dag: ' + str(i))
self.assertAlmostEqual(self.res.interpolate('solp_dag.azi', t),
azi,
delta=delta,
msg='Azi of dag: ' + str(i))
cleantest.clean('TestSolarPosition')
def test_optimum():
from solartherm import simulation
from solartherm import postproc
import cleantest
fn = 'TestOptimisation.mo'
model = 'AO'
sim = simulation.Simulator(fn, model=model)
# For some reason won't compile with Modelica library
sim.compile_model(libs=[], args=['-g=Optimica'])
sim.compile_sim(args=['-s'])
sim.simulate(start=0, stop=1, step=0.02, solver='optimization')
res = postproc.SimResult(sim.model + '_res.mat')
assert abs(res.interpolate('x1', 0) - 1.0) / 1.0 < 0.01
assert abs(res.interpolate('x2', 0) - 0.0) < 0.01
assert abs(res.interpolate('u', 1) - 2.48) / 2.48 < 0.01
cleantest.clean('AO')
def test_system():
fn = '../examples/SimpleSystemOptimalDispatch.mo'
sim = simulation.Simulator(fn)
sim.compile_model()
sim.compile_sim(args=['-s'])
sim.simulate(start=0, stop='1y', step='5m', solver='dassl', nls='newton')
res = postproc.SimResultElec(sim.res_fn)
perf = res.calc_perf(peaker=True)
# Note these are set to the values for what is thought to be a working
# version. They are not validated against anything or independently
# calculated.
print('index, epy (MWh/year),lcoe peaker ($/MWh),capf (%),srev ($')
print(perf)
assert abs(perf[0] - 300.757) / 300.757 < 0.01 # epy
assert abs(perf[1] - 38.798) / 38.798 < 0.01 # LCOE peaker
assert abs(perf[2] - 100.09) / 100.09 < 0.01 # Capacity factor
cleantest.clean('SimpleSystemOptimalDispatch')
def test_steering(self):
self.assertAlmostEqual(float(self.res.interpolate('conc.R_foc[1]', 0)),
0)
self.assertAlmostEqual(float(self.res.interpolate('conc.actual', 1)),
0)
self.assertAlmostEqual(float(self.res.interpolate('conc.actual', 11)),
0.1)
self.assertAlmostEqual(float(self.res.interpolate('conc.actual', 51)),
0.499)
self.assertAlmostEqual(float(self.res.interpolate('conc.actual', 100)),
0.499)
self.assertAlmostEqual(float(self.res.interpolate('conc.actual', 120)),
0.299)
self.assertAlmostEqual(float(self.res.interpolate('conc.actual', 130)),
0.201)
self.assertAlmostEqual(float(self.res.interpolate('conc.actual', 200)),
0.201)
cleantest.clean('TestSteeredCL')
def test_ref2solstice():
fn = '../examples/Reference_2_solstice.mo'
sim = simulation.Simulator(fn)
sim.compile_model()
sim.compile_sim(args=['-s'])
sim.update_pars(['n_row_oelt', 'n_col_oelt'],
['3', '3']) # reduce oelt resolution
sim.simulate(start=0, stop='1y', step='5m', solver='dassl', nls='newton')
res = postproc.SimResultElec(sim.res_fn)
perf = res.calc_perf()
# Note these are set to the values for what is thought to be a working
# version. They are not validated against anything or independently
# calculated.
assert abs(perf[0] - 393933.791) / 393933.791 < 0.1 # epy
assert abs(perf[1] - 160.352) / 160.352 < 0.1 # LCOE
assert abs(perf[2] - 44.969) / 44.969 < 0.1 # Capacity factor
cleantest.clean('Reference_2_solstice')
def test_sched(self):
def getval(n):
return self.res.interpolate(n, 1)
warnings.warn("Test evaluation has been disabled")
# self.assertAlmostEqual(self.perf[0], 569076.05, 2) # epy
# self.assertAlmostEqual(self.perf[1], 75.17, 2) # LCOE
# self.assertAlmostEqual(self.perf[2], 64.96, 2) # Capacity factor
# self.assertAlmostEqual(getval('R_des')/1e6, 633.04, 2) # Receiver thermal input
# self.assertAlmostEqual(getval('Q_rec_out')/1e6, 581.38, 2) # Receiver thermal output
# self.assertAlmostEqual(getval('P_gross')/1e6, 111.0, 2) # Power block gross rating
# self.assertAlmostEqual(getval('SM'), 2.67, 2) # Solar multiple
# self.assertAlmostEqual(getval('H_tower'), 47.0, 2) # Tower height
# self.assertAlmostEqual(getval('n_heliostat'), 2822.0, 2) # Number of heliostas
# self.assertAlmostEqual(getval('n_modules'), 58.0, 2) # Number of modules
print(
"-----------------------------------------------------------------------"
)
print('Energy per year: %6.2f MWh' %
(self.perf[0]))
print('Capacity factor: %6.2f %%' %
(self.perf[2]))
print('LCOE: $%6.2f/MWh' %
(self.perf[1]))
print(
"-----------------------------------------------------------------------"
)
print('Receiver thermal input at design point: %6.2f MW' %
(getval('R_des') / 1e6))
print('Receiver thermal output at design point: %6.2f MW' %
(getval('Q_rec_out') / 1e6))
print('Power block gross rating at design point: %6.2f MW' %
(getval('P_gross') / 1e6))
print('Solar multiple: %4.2f ' %
(getval('SM')))
print('Tower height (per module): %4.1f m' %
(getval('H_tower')))
print('Number of heliostats (per module): %i' %
(getval('n_heliostat')))
print('Number of modules: %i' %
(getval('n_modules')))
cleantest.clean('NaSaltSCO2System_modular')
def test_pso():
outfile = 'TestStOptimise_pso_results.txt'
obj = 999
x = 999
y = 999
i = 0
args = 'st_optimise --outfile_f %s --start 0 --stop 1 --objective f_rosen --method pso --maxiter 100 --test %s x1=-2,2,1 y1=-2,2,-1.5' % (
outfile, MODELICAFILE)
while obj > 0.1 or abs(x - 1.) > 0.5 or abs(y - 1.) > 0.5:
subprocess.call(args, shell=True)
obj, x, y = get_res(outfile)
print('Attempt ', i + 1)
i += 1
print('Total attempts: ', i)
assert abs(obj) < 1e-1
assert abs(x - 1.) < 5e-1
assert abs(y - 1.) < 5e-1
map(os.unlink, glob.glob(outfile))
cleantest.clean('TestStOptimise')
def test_nsga2():
outfile = 'TestStOptimise_nsga2_results.txt'
front = 'TestStOptimise_nsga2_pareto_front.txt'
figfile = 'TestStOptimise_nsga2_pareto_front.png'
args = 'st_optimise --outfile_f %s --outfile_p %s --outfig %s --start 0 --stop 1 --objective f_schaffer1,f_schaffer2 --method nsga2 --test %s x2=-100,100,2' % (
outfile, front, figfile, MODELICAFILE)
subprocess.call(args, shell=True)
with open(front) as f:
content = f.read().splitlines()
f.close()
names = content[0].split(' ')
names = names[:-1]
summary = {}
for n in names:
summary[n] = np.array([])
t = len(content)
for i in range(1, t):
c = content[i]
l = c.split(" ")
for j in range(len(names)):
summary[names[j]] = np.append(summary[names[j]], float(l[j]))
f_schaffer1 = summary['f_schaffer1']
f_schaffer2 = summary['f_schaffer2']
idx = [10, 20, 50, 70]
for i in idx:
f1 = f_schaffer1[i]
f2 = f_schaffer2[i]
assert (abs((f2 - get_schaffer_front(f1)) / f2) < 0.1)
map(os.unlink, glob.glob(outfile))
map(os.unlink, glob.glob(figfile))
map(os.unlink, glob.glob(front))
cleantest.clean('TestStOptimise')
def test_tmy3_weather_file(self):
self.assertAlmostEqual(self.res.interpolate('l1[2]', 1), l_1[1])
self.assertAlmostEqual(self.res.interpolate('l1[3]', 1), l_1[2])
self.assertAlmostEqual(self.res.interpolate('l1[4]', 1), l_1[3])
self.assertAlmostEqual(self.res.interpolate('l1[5]', 1), l_1[4])
self.assertAlmostEqual(self.res.interpolate('l1[6]', 1), l_1[5])
self.assertAlmostEqual(self.res.interpolate('l1[7]', 1), l_1[6])
self.assertAlmostEqual(self.res.interpolate('l1[8]', 1), l_1[7])
self.assertAlmostEqual(self.res.interpolate('l1[9]', 1), l_1[8])
self.assertAlmostEqual(self.res.interpolate('l2[2]', 1), l_2[1])
self.assertAlmostEqual(self.res.interpolate('l2[3]', 1), l_2[2])
self.assertAlmostEqual(self.res.interpolate('l2[4]', 1), l_2[3])
self.assertAlmostEqual(self.res.interpolate('l2[5]', 1), l_2[4])
self.assertAlmostEqual(self.res.interpolate('l2[6]', 1), l_2[5])
self.assertAlmostEqual(self.res.interpolate('l2[7]', 1), l_2[6])
self.assertAlmostEqual(self.res.interpolate('l2[8]', 1), l_2[7])
self.assertAlmostEqual(self.res.interpolate('l2[9]', 1), l_2[8])
self.assertAlmostEqual(self.res.interpolate('l3[2]', 1), l_3[1])
self.assertAlmostEqual(self.res.interpolate('l3[3]', 1), l_3[2])
self.assertAlmostEqual(self.res.interpolate('l3[4]', 1), l_3[3])
self.assertAlmostEqual(self.res.interpolate('l3[5]', 1), l_3[4])
self.assertAlmostEqual(self.res.interpolate('l3[6]', 1), l_3[5])
self.assertAlmostEqual(self.res.interpolate('l3[7]', 1), l_3[6])
self.assertAlmostEqual(self.res.interpolate('l3[8]', 1), l_3[7])
self.assertAlmostEqual(self.res.interpolate('l3[9]', 1), l_3[8])
self.assertAlmostEqual(self.res.interpolate('l4[2]', 1), l_4[1])
self.assertAlmostEqual(self.res.interpolate('l4[3]', 1), l_4[2])
self.assertAlmostEqual(self.res.interpolate('l4[4]', 1), l_4[3])
self.assertAlmostEqual(self.res.interpolate('l4[5]', 1), l_4[4])
self.assertAlmostEqual(self.res.interpolate('l4[6]', 1), l_4[5])
self.assertAlmostEqual(self.res.interpolate('l4[7]', 1), l_4[6])
self.assertAlmostEqual(self.res.interpolate('l4[8]', 1), l_4[7])
self.assertAlmostEqual(self.res.interpolate('l4[9]', 1), l_4[8])
cleantest.clean('TestTMY3WeatherFileChecker')
def test_poly_calc(self):
self.assertAlmostEqual(self.res.interpolate('p1.y', 1), 1)
self.assertAlmostEqual(self.res.interpolate('p2.y', 1), 1)
self.assertAlmostEqual(self.res.interpolate('p3.y', 1), 6)
self.assertAlmostEqual(self.res.interpolate('p4.y', 1), 76)
cleantest.clean('TestPolynomial')
def test_squaring(self):
self.assertTrue(abs(self.res.interpolate('y', 1) - 1) / 1 < 0.01)
self.assertTrue(abs(self.res.interpolate('y', 2) - 4) / 4 < 0.01)
cleantest.clean('TestExternalPyFunc')
def test_squaring(self):
self.assertEqual(self.res.interpolate('y', 1), 1)
self.assertEqual(self.res.interpolate('y', 2), 4)
self.assertEqual(self.res.interpolate('y', 3), 9)
self.assertEqual(self.res.interpolate('y', 4), 16)
cleantest.clean('TestExternalC')
def test_interp(self):
self.assertEqual(self.res.interpolate('res', 0), 0)
self.assertEqual(self.res.interpolate('val', 0), 3.)
cleantest.clean('TestSTTable')
def test_touching(self):
self.assertTrue(abs(self.res.interpolate('nu', 0)-0.8834)/0.8834<0.01)
cleantest.clean('TestSolsticePyFunc')
