def testStdDevQuery(self):
""" Test the standard deviation query function. """
# Setup a dummy object with data.
msd = OnTheFlyMSD.__new__(OnTheFlyMSD)
std_dev = "data"
msd._OnTheFlyMSD__std_dev = std_dev
# Check the adress.
self.assertTrue( msd.stdDev() == std_dev )
def testBinCountersQuery(self):
""" Test the bin counters query function. """
# Setup a dummy object with data.
msd = OnTheFlyMSD.__new__(OnTheFlyMSD)
bin_counters = "data"
msd._OnTheFlyMSD__bin_counters = bin_counters
# Check the adress.
self.assertTrue( msd.binCounters() == bin_counters )
def testTimeStepsQuery(self):
""" Test the time step query function. """
# Setup a dummy object with data.
msd = OnTheFlyMSD.__new__(OnTheFlyMSD)
time_steps = "data"
msd._OnTheFlyMSD__time_steps = time_steps
# Check the adress.
self.assertTrue( msd.timeSteps() == time_steps )
def testResultsQuery(self):
""" Test the result query function. """
# Setup a dummy object with data.
msd = OnTheFlyMSD.__new__(OnTheFlyMSD)
results = "data"
msd._OnTheFlyMSD__results = results
# Check the adress.
self.assertTrue( msd.results() == results )
def testSafeCutoffQuery(self):
""" Test the save cutoff query function. """
# Setup a dummy object with data.
msd = OnTheFlyMSD.__new__(OnTheFlyMSD)
history_bin_counters = numpy.array([[0,0,0,0,0],[0,0,0,6,5],[0,0,0,0,6]], dtype=int)
msd._OnTheFlyMSD__history_bin_counters = history_bin_counters
# Check the value.
self.assertEqual( msd.safeCutoff(), 4 )
history_bin_counters = numpy.array([[0,0,0,0,0],[0,0,0,6,5],[0,0,0,0,0]], dtype=int)
msd._OnTheFlyMSD__history_bin_counters = history_bin_counters
# Check the value.
self.assertEqual( msd.safeCutoff(), 5 )
history_bin_counters = numpy.array([[0]], dtype=int)
msd._OnTheFlyMSD__history_bin_counters = history_bin_counters
# Check the value.
self.assertEqual( msd.safeCutoff(), 1 )
def testFinalizeWithCoordinateTransform(self):
""" Test finalization. """
msd = OnTheFlyMSD.__new__(OnTheFlyMSD)
# Replace the getBackendResults function.
def dummy():
pass
msd._OnTheFlyMSD__getBackendResults = dummy
# Set a unitcell on the class.
unit_cell = KMCUnitCell(cell_vectors=numpy.array([[1.0,0.0,0.0],
[0.0,1.0,0.0],
[0.0,0.0,1.0]]),
basis_points=[[0.0,0.0,0.0]])
msd._OnTheFlyMSD__unit_cell = unit_cell
# Set the values.
msd._OnTheFlyMSD__raw_histogram = numpy.array([[ 171144., 173906., 188389.],
[ 516721., 497558., 536213.],
[ 851961., 810151., 836426.],
[ 1195930., 1046238., 1111184.],
[ 1507650., 1366678., 1434213.],
[ 1780731., 1743443., 1719186.],
[ 2155426., 2154562., 1980822.],
[ 2554205., 2604757., 2354967.],
[ 2954351., 3032799., 2698023.],
[ 3372070., 3443433., 3158002.]])
bin_counters = (60283, 60628, 60461, 59779, 59683, 59178, 58856, 58752, 58162, 57881)
msd._OnTheFlyMSD__bin_counters = bin_counters
msd._OnTheFlyMSD__n_bins = 10
msd._OnTheFlyMSD__binsize = 2.5
hstep_counts = [8919,8918,8917,8916,8915,8914,8913,8912,8911,8910,8099,8908,8907,8906,8905,8904,8903,8902,8901]
msd._OnTheFlyMSD__hstep_counts = hstep_counts
history_bin_counters = [(1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
(0, 0, 0, 0, 0, 1, 87, 58752, 58162, 57881)]
msd._OnTheFlyMSD__history_bin_counters = history_bin_counters
msd._OnTheFlyMSD__n_eff = [1.12, 2.24, 3.36, 4.48, 5.60, 6.72, 7.84, 8.96, 9.0, 10.12]
# Call the finalize function.
msd.finalize()
# Check a few results.
result_0_3 = 1195930. / 59779.0
self.assertAlmostEqual(result_0_3, msd._OnTheFlyMSD__results[0][3], 10)
result_1_7 = 2604757.0 / 58752.0
self.assertAlmostEqual(result_1_7, msd._OnTheFlyMSD__results[1][7], 10)
result_2_0 = 188389.0 / 60283.0
self.assertAlmostEqual(result_2_0, msd._OnTheFlyMSD__results[2][0], 10)
result_3_4 = ( 1507650.0 + 1366678.0) / 59683.0
self.assertAlmostEqual(result_3_4, msd._OnTheFlyMSD__results[3][4], 10)
result_4_4 = ( 1507650.0 + 1434213.0) / 59683.0
self.assertAlmostEqual(result_4_4, msd._OnTheFlyMSD__results[4][4], 10)
result_5_6 = ( 2154562.0 + 1980822.0) / 58856.0
self.assertAlmostEqual(result_5_6, msd._OnTheFlyMSD__results[5][6], 10)
result_6_5 = ( 1780731.0 + 1743443.0 + 1719186.0)/ 59178.0
self.assertAlmostEqual(result_6_5, msd._OnTheFlyMSD__results[6][5], 10)
# Check the corresponding standard deviation against hardcoded values.
std_0_3 = 42.291401180595834
std_1_7 = 0.813230156401512
std_2_0 = 6.634050132990601
std_3_4 = 71.931090096615776
std_4_4 = 73.621177716983027
std_5_6 = 7.877909031669120
std_6_5 = 62.119638306131414
self.assertAlmostEqual(std_0_3, msd._OnTheFlyMSD__std_dev[0][3], 10)
self.assertAlmostEqual(std_1_7, msd._OnTheFlyMSD__std_dev[1][7], 10)
self.assertAlmostEqual(std_2_0, msd._OnTheFlyMSD__std_dev[2][0], 10)
self.assertAlmostEqual(std_3_4, msd._OnTheFlyMSD__std_dev[3][4], 10)
self.assertAlmostEqual(std_4_4, msd._OnTheFlyMSD__std_dev[4][4], 10)
self.assertAlmostEqual(std_5_6, msd._OnTheFlyMSD__std_dev[5][6], 10)
self.assertAlmostEqual(std_6_5, msd._OnTheFlyMSD__std_dev[6][5], 10)
def testFinalizeNoCoordinateTransform(self):
""" Test finalization. """
msd = OnTheFlyMSD.__new__(OnTheFlyMSD)
# Replace the getBackendResults function.
def dummy():
pass
msd._OnTheFlyMSD__getBackendResults = dummy
# Set a unitcell on the class.
unit_cell = KMCUnitCell(cell_vectors=numpy.array([[1.0,0.0,0.0],
[0.0,1.0,0.0],
[0.0,0.0,1.0]]),
basis_points=[[0.0,0.0,0.0]])
msd._OnTheFlyMSD__unit_cell = unit_cell
# Set the values.
msd._OnTheFlyMSD__raw_histogram = numpy.array([[ 171144., 173906., 188389.],
[ 516721., 497558., 536213.],
[ 851961., 810151., 836426.],
[ 1195930., 1046238., 1111184.],
[ 1507650., 1366678., 1434213.],
[ 1780731., 1743443., 1719186.],
[ 2155426., 2154562., 1980822.],
[ 2554205., 2604757., 2354967.],
[ 2954351., 3032799., 2698023.],
[ 3372070., 3443433., 3158002.]])
bin_counters = (60283, 60628, 60461, 59779, 59683, 59178, 58856, 58752, 58162, 57881)
msd._OnTheFlyMSD__bin_counters = bin_counters
msd._OnTheFlyMSD__n_bins = 10
msd._OnTheFlyMSD__binsize = 2.5
hstep_counts = [8919,8918,8917,8916,8915,8914,8913,8912,8911,8910,8099,8908,8907,8906,8905,8904,8903,8902,8901]
msd._OnTheFlyMSD__hstep_counts = hstep_counts
history_bin_counters = [(1, 1, 1, 1, 1, 1, 1, 1, 1, 1),
(0, 0, 0, 0, 0, 1, 87, 58752, 58162, 57881)]
msd._OnTheFlyMSD__history_bin_counters = history_bin_counters
msd._OnTheFlyMSD__n_eff = [1.12, 2.24, 3.36, 4.48, 5.60, 6.72, 7.84, 8.96, 9.0, 10.12]
# Call the finalize function.
msd.finalize()
# Check a few results.
result_0_3 = 1195930. / 59779.0
self.assertAlmostEqual(result_0_3, msd._OnTheFlyMSD__results[0][3], 10)
result_1_7 = 2604757.0 / 58752.0
self.assertAlmostEqual(result_1_7, msd._OnTheFlyMSD__results[1][7], 10)
result_2_0 = 188389.0 / 60283.0
self.assertAlmostEqual(result_2_0, msd._OnTheFlyMSD__results[2][0], 10)
# Check the corresponding standard deviation.
n_eff = numpy.zeros(10)
for i in range(len(n_eff)):
for b in range(len(history_bin_counters)):
fraction = float(history_bin_counters[b][i]) / float(bin_counters[i])
n_eff[i] += fraction * (b+1.0)
K1 = hstep_counts[int(n_eff[3]+1)]
K2 = K1*K1
std_0_3 = result_0_3 * numpy.sqrt(2.0) * numpy.sqrt((4*n_eff[3]*n_eff[3]*K1 + 2*K1 + n_eff[3] - n_eff[3]*n_eff[3]*n_eff[3])/(n_eff[3]*6*K2))
self.assertAlmostEqual(std_0_3, msd._OnTheFlyMSD__std_dev[0][3], 10)
K1 = hstep_counts[int(n_eff[7]+1)]
K2 = K1*K1
std_1_7 = result_1_7 * numpy.sqrt(2.0) * numpy.sqrt((4*n_eff[7]*n_eff[7]*K1 + 2*K1 + n_eff[7] - n_eff[7]*n_eff[7]*n_eff[7])/(n_eff[7]*6*K2))
self.assertAlmostEqual(std_1_7, msd._OnTheFlyMSD__std_dev[1][7], 10)
K1 = hstep_counts[int(n_eff[0]+1)]
K2 = K1*K1
std_2_0 = result_2_0 * numpy.sqrt(2.0) * numpy.sqrt((4*n_eff[0]*n_eff[0]*K1 + 2*K1 + n_eff[0] - n_eff[0]*n_eff[0]*n_eff[0])/(n_eff[0]*6*K2))
self.assertAlmostEqual(std_2_0, msd._OnTheFlyMSD__std_dev[2][0], 10)
def testPrintResults(self):
""" Test that the results gets printed as expected. """
# Fill an object with data.
ref_results = numpy.array([[ 2.83900934, 8.52281124, 14.09108351, 20.00585490, 25.26096208,
30.09109804, 36.62202664, 43.47434981, 50.79520993, 58.25866865],
[ 2.88482657, 8.20673616, 13.39956335, 17.50176483, 22.89894945,
29.46099902, 36.60734674, 44.33478009, 52.14399436, 59.49159482],
[ 22.88482657, 48.20673616, 53.39956335, 67.50176483, 72.89894945,
39.46099902, 56.60734674, 54.33478009, 62.14399436, 79.49159482],
[ 3.12507672, 8.84431286, 13.83414102, 18.58819987, 24.03051120,
29.05110007, 77.65539622, 40.08318015, 46.38807125, 54.56025293],
[ 13.83900934, 66.52281124, 14.09108351, 20.00585490, 25.26096208,
24.09109804, 88.62202664, 43.47434981, 30.79520993, 78.25866865],
[ 35.88482657, 5.20673616, 13.39956335, 37.50176483, 82.89894945,
45.46099902, 34.60734674, 44.33478009, 42.14399436, 99.49159482],
[ 56.12507672, 1.84431286, 13.83414102, 58.58819987, 84.03051120,
29.05110007, 33.65539622, 40.08318015, 56.38807125, 74.56025293]])
ref_time_steps = numpy.array([ 1.25, 3.75, 6.25, 8.75, 11.25, 13.75, 16.25, 18.75, 21.25, 23.75])
ref_std_dev = numpy.array([[ 0.02008562, 0.05432052, 0.08833069, 0.11053417, 0.12584537, 0.14901027,
0.18265464, 0.20891115, 0.24045901, 0.27834904],
[ 0.01911933, 0.04761810, 0.07830592, 0.10414501, 0.14034533, 0.18069990,
0.23416218, 0.28725392, 0.34211121, 0.39464802],
[ 0.02198474, 0.05167655, 0.08130953, 0.10885342, 0.14397243, 0.16894787,
0.19585331, 0.22369909, 0.25162530, 0.29321875],
[ 3.02198474, 4.05167655, 5.08130953, 5.10885342, 0.14397243, 4.16894787,
3.19585331, 4.22369909, 50.25162530, 10.29321875],
[ 1.02008562, 3.05432052, 0.08833069, 0.11053417, 44.12584537, 3.14901027,
3.18265464, 4.20891115, 0.24045901, 0.27834904],
[ 4.01911933, 5.04761810, 4.07830592, 0.10414501, 0.14034533, 1.18069990,
5.23416218, 6.28725392, 4.34211121, 0.39464802],
[ 6.02198474, 7.05167655, 3.08130953, 2.10885342, 4.14397243, 1.16894787,
7.19585331, 8.22369909, 0.25162530, 0.29321875]])
ref_bin_counters = (60283, 60628, 60461, 59779, 59683, 59178, 58856, 58752, 58162, 57881)
ref_history_bin_counters = [(0, 0, 0, 0, 0, 1, 87, 58752, 58162, 57881)]
msd = OnTheFlyMSD.__new__(OnTheFlyMSD)
msd._OnTheFlyMSD__results = ref_results
msd._OnTheFlyMSD__time_steps = ref_time_steps
msd._OnTheFlyMSD__std_dev = ref_std_dev
msd._OnTheFlyMSD__bin_counters = ref_bin_counters
msd._OnTheFlyMSD__history_bin_counters = ref_history_bin_counters
msd._OnTheFlyMSD__n_eff = [0.1, 1.2, 3.4, 5.5, 6.6, 7.7, 0.8, 9.9, 4.3, 2.1]
# Print the results to a stream.
stream = StringIO.StringIO()
msd.printResults(stream)
# Check against reference.
ref_value = """ TIME MSD_x DSD_y MSD_z MSD_xy MSD_xz MSD_yz MSD_xyz STD_x STD_y STD_z STD_xy STD_xz STD_yz STD_xyz N_eff
1.25000e+00 2.83901e+00 2.88483e+00 2.28848e+01 3.12508e+00 1.38390e+01 3.58848e+01 5.61251e+01 2.00856e-02 1.91193e-02 2.19847e-02 3.02198e+00 1.02009e+00 4.01912e+00 6.02198e+00 1.00000e-01
3.75000e+00 8.52281e+00 8.20674e+00 4.82067e+01 8.84431e+00 6.65228e+01 5.20674e+00 1.84431e+00 5.43205e-02 4.76181e-02 5.16766e-02 4.05168e+00 3.05432e+00 5.04762e+00 7.05168e+00 1.20000e+00
6.25000e+00 1.40911e+01 1.33996e+01 5.33996e+01 1.38341e+01 1.40911e+01 1.33996e+01 1.38341e+01 8.83307e-02 7.83059e-02 8.13095e-02 5.08131e+00 8.83307e-02 4.07831e+00 3.08131e+00 3.40000e+00
8.75000e+00 2.00059e+01 1.75018e+01 6.75018e+01 1.85882e+01 2.00059e+01 3.75018e+01 5.85882e+01 1.10534e-01 1.04145e-01 1.08853e-01 5.10885e+00 1.10534e-01 1.04145e-01 2.10885e+00 5.50000e+00
1.12500e+01 2.52610e+01 2.28989e+01 7.28989e+01 2.40305e+01 2.52610e+01 8.28989e+01 8.40305e+01 1.25845e-01 1.40345e-01 1.43972e-01 1.43972e-01 4.41258e+01 1.40345e-01 4.14397e+00 6.60000e+00
1.37500e+01 3.00911e+01 2.94610e+01 3.94610e+01 2.90511e+01 2.40911e+01 4.54610e+01 2.90511e+01 1.49010e-01 1.80700e-01 1.68948e-01 4.16895e+00 3.14901e+00 1.18070e+00 1.16895e+00 7.70000e+00
1.62500e+01 3.66220e+01 3.66073e+01 5.66073e+01 7.76554e+01 8.86220e+01 3.46073e+01 3.36554e+01 1.82655e-01 2.34162e-01 1.95853e-01 3.19585e+00 3.18265e+00 5.23416e+00 7.19585e+00 8.00000e-01
"""
if MPICommons.isMaster():
self.assertEqual(stream.getvalue(), ref_value)
else:
self.assertEqual(stream.getvalue(), "")
