class TestReadDouble3D(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Sequence')
seq = self.sim.get_nextSequence(0, 0.0)
n1 = random.randint(12, 50)
n2 = random.randint(10, 60)
n3 = random.randint(2, 40)
self.data = numpy.random.random_sample((n1, n2, n3))
self.data_name = 'Double Data'
seq.data_write(self.data_name, self.data)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
seq = self.sim.get_sequence('Series 1')
read_data = seq.data_read(self.data_name)
self.assertEqual(read_data.all(), self.data.all())
class TestUtils(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Simulation')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_data_count(self):
cnt = self.sim.data_count()
self.assertEqual(cnt, 0)
def test_data_exists(self):
data_name = 'Dataset'
self.assertEqual(self.sim.data_exists(data_name), 0)
def test_data_list(self):
list = self.sim.data_list()
self.assertEqual(len(list), 0)
class TestUtils(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Simulation')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_data_count(self):
cnt=self.sim.data_count()
self.assertEqual(cnt,0)
def test_data_exists(self):
data_name='Dataset'
self.assertEqual(self.sim.data_exists(data_name),0)
def test_data_list(self):
list=self.sim.data_list()
self.assertEqual(len(list),0)
class TestReadDouble3D(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Sequence')
seq=self.sim.get_nextSequence(0,0.0)
n1=random.randint(12,50)
n2=random.randint(10,60)
n3=random.randint(2,40)
self.data=numpy.random.random_sample((n1,n2,n3))
self.data_name='Double Data'
seq.data_write(self.data_name,self.data)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
seq=self.sim.get_sequence('Series 1')
read_data=seq.data_read(self.data_name)
self.assertEqual(read_data.all(), self.data.all())
class TestCreate(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Probe.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Probe')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_create_int(self):
import numpy
import random
len=random.randint(1,7)
num=random.randint(128,512)
idata=numpy.zeros((num,len))
i=0
while i < num:
l=0
while l < len:
idata[i][l]=random.randint(0,100000)
l=l+1
i=i+1
probe=Probe(self.sim,'Int Data',idata)
def test_create_float(self):
import numpy
import random
len=random.randint(1,7)
num=random.randint(128,512)
data=numpy.float32(numpy.random.random_sample((num,len)))
probe=Probe(self.sim,'Float data',data)
def test_create_double(self):
import numpy
import random
len=random.randint(1,7)
num=random.randint(128,512)
data=numpy.random.random_sample((num,len))
probe=Probe(self.sim,'Double data',data)
class TestBasic(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Probe.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Probe')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
import random
import numpy
print 'Begin basic test'
try:
probe=Probe()
except:
print 'Caught invalid number of arguments'
try:
probe=Probe(self.sim)
except:
print 'Caught invalid number of arguments'
try:
probe=Probe(self.sim,'Dummy Probe')
except:
print 'Caught invalid number of arguments'
try:
data=numpy.ones((10))
probe=Probe(self.sim,'Dummy Probe',data)
except:
print 'Caught incorrect argument type'
# Simple constructor and delete
len=2
num=20
data=numpy.ones((num,len))
probe= Probe(self.sim,'Dummy Probe',data)
del probe
probe=self.sim.probe_open('Dummy Probe')
self.assertEqual(probe.length(),len)
self.assertEqual(probe.number(),num)
class TestAttributes(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Probe.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Probe')
self.probe_name='Dummy Probe'
data=numpy.ones((3,10))
Probe(self.sim,self.probe_name,data)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
import random
probe=self.sim.probe_open(self.probe_name)
# integers
int_name='Integer Attribute'
try:
probe.get_attribute(int_name)
except:
print 'Caught DNE attribute'
else:
raise RuntimeError, 'Failed to catch DNE error'
int_attr=random.randint(1,102400)
probe.set_attribute(int_name,int_attr)
read_attr=probe.get_attribute(int_name)
self.assertEqual(int_attr,read_attr)
# double
dbl_name='Double Attribute'
dbl_attr=random.random()
probe.set_attribute(dbl_name,dbl_attr)
read_dbl=probe.get_attribute(dbl_name)
self.assertEqual(read_dbl,dbl_attr)
# string
str_name='Chacracter Name Attribute'
str_attr='ajksdweiouamnv 9iajemn oiwiwe'
probe.set_attribute(str_name,str_attr)
string=probe.get_attribute(str_name)
self.assertEqual(string,str_attr)
class TestAttributes(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Sequence')
self.seq=self.sim.get_nextSequence(0,0.0)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
import random
seq=self.seq
# integers
int_name='Integer Attribute'
try:
seq.get_attribute(int_name)
except:
print 'Caught DNE attribute'
else:
raise RuntimeError, 'Failed to catch DNE error'
int_attr=random.randint(1,102400)
seq.set_attribute(int_name,int_attr)
read_attr=seq.get_attribute(int_name)
self.assertEqual(int_attr,read_attr)
# double
dbl_name='Double Attribute'
dbl_attr=random.random()
seq.set_attribute(dbl_name,dbl_attr)
read_dbl=seq.get_attribute(dbl_name)
self.assertEqual(read_dbl,dbl_attr)
# string
str_name='Chacracter Name Attribute'
str_attr='ajksdweiouamnv 9iajemn oiwiwe'
seq.set_attribute(str_name,str_attr)
string=seq.get_attribute(str_name)
self.assertEqual(string,str_attr)
class TestAttributes(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Sequence')
self.seq = self.sim.get_nextSequence(0, 0.0)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
import random
seq = self.seq
# integers
int_name = 'Integer Attribute'
try:
seq.get_attribute(int_name)
except:
print 'Caught DNE attribute'
else:
raise RuntimeError, 'Failed to catch DNE error'
int_attr = random.randint(1, 102400)
seq.set_attribute(int_name, int_attr)
read_attr = seq.get_attribute(int_name)
self.assertEqual(int_attr, read_attr)
# double
dbl_name = 'Double Attribute'
dbl_attr = random.random()
seq.set_attribute(dbl_name, dbl_attr)
read_dbl = seq.get_attribute(dbl_name)
self.assertEqual(read_dbl, dbl_attr)
# string
str_name = 'Chacracter Name Attribute'
str_attr = 'ajksdweiouamnv 9iajemn oiwiwe'
seq.set_attribute(str_name, str_attr)
string = seq.get_attribute(str_name)
self.assertEqual(string, str_attr)
class TestBasic(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Sequence')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
import random
import numpy
print 'Begin basic test'
try:
seq=Sequence()
except:
print 'Caught invalid number of arguments'
try:
seq=Sequence(self.sim)
except:
print 'Caught invalid name or id'
try:
seq=Sequence(self.sim,'Series DNE')
except:
print 'Caught id group that does not exist'
try:
seq=Sequence(self.sim,seriesname='Series 10')
except:
print 'Caught group name that does not exist'
cycle=random.randint(0,10)
time=numpy.float64(random.randint(0,1000))
seq=self.sim.get_nextSequence(cycle,time)
id=seq.id
del seq
seq_name=self.sim.get_sequence_name(id)
new_seq=Sequence(self.sim,seq_name)
del new_seq
class TestBasic(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Sequence')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
import random
import numpy
print 'Begin basic test'
try:
seq = Sequence()
except:
print 'Caught invalid number of arguments'
try:
seq = Sequence(self.sim)
except:
print 'Caught invalid name or id'
try:
seq = Sequence(self.sim, 'Series DNE')
except:
print 'Caught id group that does not exist'
try:
seq = Sequence(self.sim, seriesname='Series 10')
except:
print 'Caught group name that does not exist'
cycle = random.randint(0, 10)
time = numpy.float64(random.randint(0, 1000))
seq = self.sim.get_nextSequence(cycle, time)
id = seq.id
del seq
seq_name = self.sim.get_sequence_name(id)
new_seq = Sequence(self.sim, seq_name)
del new_seq
class TestDataReadFloat(TestCase):
def setUp(self):
import os
import numpy
import random
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Simulation')
self.data_name_1d = 'Float Data 1D'
self.n = random.randint(1000, 10000)
self.data_1d = numpy.float32(numpy.random.random_sample((self.n)))
self.sim.data_write(self.data_name_1d, self.data_1d)
self.data_name_2d = 'Float Data 2D'
self.n1 = random.randint(100, 1000)
self.n2 = random.randint(100, 1000)
self.data_2d = numpy.float32(
numpy.random.random_sample((self.n1, self.n2)))
self.sim.data_write(self.data_name_2d, self.data_2d)
self.data_name_3d = 'Float Data 3D'
self.n1 = random.randint(10, 100)
self.n2 = random.randint(10, 100)
self.n3 = random.randint(10, 100)
self.data_3d = numpy.float32(
numpy.random.random_sample((self.n1, self.n2, self.n3)))
self.sim.data_write(self.data_name_3d, self.data_3d)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
def runTest(self):
data1 = self.sim.data_read(self.data_name_1d)
self.assertEqual(data1.all(), self.data_1d.all())
data2 = self.sim.data_read(self.data_name_2d)
self.assertEqual(data2.all(), self.data_2d.all())
data3 = self.sim.data_read(self.data_name_3d)
self.assertEqual(data3.all(), self.data_3d.all())
class TestDataReadDouble(TestCase):
def setUp(self):
import os
import numpy
import random
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Simulation')
self.data_name_1d='Double Data 1D'
self.n=random.randint(1000,10000)
self.data_1d=numpy.random.random_sample((self.n))
self.sim.data_write(self.data_name_1d,self.data_1d)
self.data_name_2d='Double Data 2D'
self.n1=random.randint(100,1000)
self.n2=random.randint(100,1000)
self.data_2d=numpy.random.random_sample((self.n1,self.n2))
self.sim.data_write(self.data_name_2d,self.data_2d)
self.data_name_3d='Double Data 3D'
self.n1=random.randint(10,100)
self.n2=random.randint(10,100)
self.n3=random.randint(10,100)
self.data_3d=numpy.random.random_sample((self.n1,self.n2,self.n3))
self.sim.data_write(self.data_name_3d,self.data_3d)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
def runTest(self):
data1=self.sim.data_read(self.data_name_1d)
self.assertEqual(data1.all(),self.data_1d.all())
data2=self.sim.data_read(self.data_name_2d)
self.assertEqual(data2.all(),self.data_2d.all())
data3=self.sim.data_read(self.data_name_3d)
self.assertEqual(data3.all(),self.data_3d.all())
class TestReadInteger3D(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Sequence')
seq=self.sim.get_nextSequence(0,0.0)
n1=random.randint(10,20)
n2=random.randint(10,20)
n3=random.randint(10,20)
self.data=numpy.zeros((n1,n2,n3))
i=0
while i < n1:
j=0
while j < n2:
k=0
while k < n3:
self.data[i][j]=random.randint(0,10000)
k=k+1
j=j+1
i=i+1
self.data_name='Integer Data'
seq.data_write(self.data_name,self.data)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
seq=self.sim.get_sequence('Series 1')
read_data=seq.data_read(self.data_name)
self.assertEqual(read_data.all(), self.data.all())
class TestReadInteger3D(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Sequence')
seq = self.sim.get_nextSequence(0, 0.0)
n1 = random.randint(10, 20)
n2 = random.randint(10, 20)
n3 = random.randint(10, 20)
self.data = numpy.zeros((n1, n2, n3))
i = 0
while i < n1:
j = 0
while j < n2:
k = 0
while k < n3:
self.data[i][j] = random.randint(0, 10000)
k = k + 1
j = j + 1
i = i + 1
self.data_name = 'Integer Data'
seq.data_write(self.data_name, self.data)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
seq = self.sim.get_sequence('Series 1')
read_data = seq.data_read(self.data_name)
self.assertEqual(read_data.all(), self.data.all())
class TestReadInteger1D(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Sequence')
seq=self.sim.get_nextSequence(0,0.0)
n=random.randint(128,512)
self.data=numpy.zeros((n))
i=0
while i < n:
self.data[i]=random.randint(0,10000)
i=i+1
self.data_name='Integer Data'
seq.data_write(self.data_name,self.data)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
seq=self.sim.get_sequence('Series 1')
try:
read_data=seq.data_read('Data DNE')
except:
print 'Caught Data set that did not exist'
read_data=seq.data_read(self.data_name)
self.assertEqual(read_data.all(), self.data.all())
class TestReadInteger1D(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Sequence')
seq = self.sim.get_nextSequence(0, 0.0)
n = random.randint(128, 512)
self.data = numpy.zeros((n))
i = 0
while i < n:
self.data[i] = random.randint(0, 10000)
i = i + 1
self.data_name = 'Integer Data'
seq.data_write(self.data_name, self.data)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def runTest(self):
seq = self.sim.get_sequence('Series 1')
try:
read_data = seq.data_read('Data DNE')
except:
print 'Caught Data set that did not exist'
read_data = seq.data_read(self.data_name)
self.assertEqual(read_data.all(), self.data.all())
class TestWriteData(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Simulation')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
def test_write_int(self):
import random
import numpy
data_name='Data Set 1D Integer'
nsize=random.randint(1000,100000)
data=numpy.zeros((nsize),numpy.int32)
i=0
while i < nsize:
data[i]=random.randint(0,100000)
i=i+1
self.sim.data_write(data_name,data)
del data
data_name='Data Set 2D Integer'
n1=random.randint(100,1000)
n2=random.randint(100,1000)
data=numpy.zeros((n1,n2),numpy.int32)
i=0
j=0
while i < n1:
while j < n2:
data[i][j]=random.randint(0,100000)
j=j+1
i=i+1
self.sim.data_write(data_name,data)
del data
data_name='Data Set 3D Integer'
n1=random.randint(100,1000)
n2=random.randint(100,1000)
n3=random.randint(100,1000)
data=numpy.zeros((n1,n2,n3),numpy.int32)
i=0
j=0
k=0
while i < n1:
while j < n2:
while k < n3:
data[i][j][k]=random.randint(0,100000)
k=k+1
j=j+1
i=i+1
self.sim.data_write(data_name,data)
del data
def test_write_double(self):
import random
import numpy
data_name='Data Set 1D Double'
nsize=random.randint(1000,100000)
data=numpy.random.random_sample((nsize))
self.sim.data_write(data_name,data)
del data
data_name='Data Set 2D Double'
n1=random.randint(100,1000)
n2=random.randint(100,1000)
data=numpy.random.random_sample((n1,n2))
self.sim.data_write(data_name,data)
del data
data_name='Data Set 3D Double'
n1=random.randint(100,1000)
n2=random.randint(100,1000)
n3=random.randint(100,1000)
data=numpy.random.random_sample((n1,n2,n3))
self.sim.data_write(data_name,data)
del data
def test_write_float(self):
import random
import numpy
data_name='Data Set 1D Float'
nsize=random.randint(1000,100000)
data=numpy.float32(numpy.random.random_sample((nsize)))
self.sim.data_write(data_name,data)
del data
data_name='Data Set 2D Float'
n1=random.randint(100,1000)
n2=random.randint(100,1000)
data=numpy.float32(numpy.random.random_sample((n1,n2)))
self.sim.data_write(data_name,data)
del data
data_name='Data Set 3D Float'
n1=random.randint(10,100)
n2=random.randint(10,100)
n3=random.randint(10,100)
data=numpy.float32(numpy.random.random_sample((n1,n2,n3)))
self.sim.data_write(data_name,data)
del data
class TestReadData(TestCase):
def setUp(self):
import os
from Danu import Output
import random
import numpy
self.filename='test-Probe.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Probe')
# Int data
self.idata_name='Int data'
len=random.randint(1,7)
num=random.randint(128,512)
self.idata=numpy.zeros((num,len))
i=0
while i < num:
l=0
while l < len:
self.idata[i][l]=random.randint(0,100000)
l=l+1
i=i+1
probe=Probe(self.sim,self.idata_name,self.idata)
# Float data
self.fdata_name='Float data'
len=random.randint(1,7)
num=random.randint(128,512)
self.fdata=numpy.float32(numpy.random.random_sample((num,len)))
probe=Probe(self.sim,self.fdata_name,self.fdata)
# Double data
self.rdata_name='Double data'
len=random.randint(1,7)
num=random.randint(128,512)
self.rdata=numpy.random.random_sample((num,len))
probe=Probe(self.sim,self.rdata_name,self.rdata)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_read_int(self):
probe=self.sim.probe_open(self.idata_name)
read_data=probe.read()
self.assertEqual(read_data.all(), self.idata.all())
def test_read_float(self):
probe=self.sim.probe_open(self.fdata_name)
read_data=probe.read()
self.assertEqual(read_data.all(), self.fdata.all())
def test_read_double(self):
probe=self.sim.probe_open(self.rdata_name)
read_data=probe.read()
self.assertEqual(read_data.all(), self.rdata.all())
class TestWrite(TestCase):
def setUp(self):
import os
import random
import numpy
from Danu import Output
self.filename = 'test-Probe.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Probe')
# Int data
self.idata_name='Int data'
len=random.randint(1,7)
num=random.randint(128,512)
self.idata=numpy.zeros((num,len))
self.idata_len=len
i=0
while i < num:
l=0
while l < len:
self.idata[i][l]=random.randint(0,100000)
l=l+1
i=i+1
probe=Probe(self.sim,self.idata_name,self.idata)
# Float data
self.fdata_name='Float data'
len=random.randint(1,7)
num=random.randint(128,512)
self.fdata=numpy.float32(numpy.random.random_sample((num,len)))
self.fdata_len=len
probe=Probe(self.sim,self.fdata_name,self.fdata)
# Double data
self.rdata_name='Double data'
len=random.randint(1,7)
num=random.randint(128,512)
self.rdata=numpy.random.random_sample((num,len))
self.rdata_len=len
probe=Probe(self.sim,self.rdata_name,self.rdata)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_write_int(self):
import numpy
import random
len=self.idata_len + 1
num=random.randint(128,512)
idata=numpy.zeros((num,len))
probe=self.sim.probe_open(self.idata_name)
try:
probe.write(idata)
except:
print 'Caught error when trying to write mis-sized data'
idata=numpy.zeros((num,self.idata_len))
probe.write(idata)
def test_write_float(self):
import numpy
import random
len=self.fdata_len+1
num=random.randint(128,512)
data=numpy.float32(numpy.random.random_sample((num,len)))
probe=self.sim.probe_open(self.fdata_name)
try:
probe.write(data)
except:
print 'Caught error when trying to write mis-sized data'
data=numpy.float32(numpy.random.random_sample((num,self.fdata_len)))
probe.write(data)
def test_write_double(self):
import numpy
import random
len=self.rdata_len+1
num=random.randint(128,512)
data=numpy.random.random_sample((num,len))
probe=self.sim.probe_open(self.rdata_name)
try:
probe.write(data)
except:
print 'Caught mis-sized data array'
len=self.rdata_len
data=numpy.random.random_sample((num,len))
probe.write(data)
class TestWriteData(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Simulation')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
def test_write_int(self):
import random
import numpy
data_name = 'Data Set 1D Integer'
nsize = random.randint(1000, 100000)
data = numpy.zeros((nsize), numpy.int32)
i = 0
while i < nsize:
data[i] = random.randint(0, 100000)
i = i + 1
self.sim.data_write(data_name, data)
del data
data_name = 'Data Set 2D Integer'
n1 = random.randint(100, 1000)
n2 = random.randint(100, 1000)
data = numpy.zeros((n1, n2), numpy.int32)
i = 0
j = 0
while i < n1:
while j < n2:
data[i][j] = random.randint(0, 100000)
j = j + 1
i = i + 1
self.sim.data_write(data_name, data)
del data
data_name = 'Data Set 3D Integer'
n1 = random.randint(100, 1000)
n2 = random.randint(100, 1000)
n3 = random.randint(100, 1000)
data = numpy.zeros((n1, n2, n3), numpy.int32)
i = 0
j = 0
k = 0
while i < n1:
while j < n2:
while k < n3:
data[i][j][k] = random.randint(0, 100000)
k = k + 1
j = j + 1
i = i + 1
self.sim.data_write(data_name, data)
del data
def test_write_double(self):
import random
import numpy
data_name = 'Data Set 1D Double'
nsize = random.randint(1000, 100000)
data = numpy.random.random_sample((nsize))
self.sim.data_write(data_name, data)
del data
data_name = 'Data Set 2D Double'
n1 = random.randint(100, 1000)
n2 = random.randint(100, 1000)
data = numpy.random.random_sample((n1, n2))
self.sim.data_write(data_name, data)
del data
data_name = 'Data Set 3D Double'
n1 = random.randint(100, 1000)
n2 = random.randint(100, 1000)
n3 = random.randint(100, 1000)
data = numpy.random.random_sample((n1, n2, n3))
self.sim.data_write(data_name, data)
del data
def test_write_float(self):
import random
import numpy
data_name = 'Data Set 1D Float'
nsize = random.randint(1000, 100000)
data = numpy.float32(numpy.random.random_sample((nsize)))
self.sim.data_write(data_name, data)
del data
data_name = 'Data Set 2D Float'
n1 = random.randint(100, 1000)
n2 = random.randint(100, 1000)
data = numpy.float32(numpy.random.random_sample((n1, n2)))
self.sim.data_write(data_name, data)
del data
data_name = 'Data Set 3D Float'
n1 = random.randint(10, 100)
n2 = random.randint(10, 100)
n3 = random.randint(10, 100)
data = numpy.float32(numpy.random.random_sample((n1, n2, n3)))
self.sim.data_write(data_name, data)
del data
class TestDataReadInteger(TestCase):
def setUp(self):
import os
import numpy
import random
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Simulation')
self.data_name_1d='Integer Data 1D'
self.n=random.randint(1000,10000)
self.data_1d=numpy.zeros((self.n),numpy.int32)
i=0
while i < self.n:
self.data_1d[i]=random.randint(1,100000)
i=i+1
self.sim.data_write(self.data_name_1d,self.data_1d)
self.data_name_2d='Integer Data 2D'
self.n1=random.randint(100,1000)
self.n2=random.randint(100,1000)
self.data_2d=numpy.zeros((self.n1,self.n2),numpy.int32)
i=0
while i < self.n1:
j=0
while j < self.n2:
self.data_2d[i][j]=random.randint(1,100000)
j=j+1
i=i+1
self.sim.data_write(self.data_name_2d,self.data_2d)
self.data_name_3d='Integer Data 3D'
self.n1=random.randint(10,100)
self.n2=random.randint(10,100)
self.n3=random.randint(10,100)
self.data_3d=numpy.zeros((self.n1,self.n2,self.n3),numpy.int32)
i=0
while i < self.n1:
j=0
while j < self.n2:
k=0
while k < self.n3:
self.data_3d[i][j][k]=random.randint(1,100000)
k=k+1
j=j+1
i=i+1
self.sim.data_write(self.data_name_3d,self.data_3d)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
def runTest(self):
try:
data=self.sim.data_read('Data DNE')
except:
print 'Caught bad non-series data name'
else:
raise RuntimeError, 'Failed to catch DNE dataset name'
data1=self.sim.data_read(self.data_name_1d)
self.assertEqual(data1.all(),self.data_1d.all())
data2=self.sim.data_read(self.data_name_2d)
self.assertEqual(data2.all(),self.data_2d.all())
data3=self.sim.data_read(self.data_name_3d)
self.assertEqual(data3.all(),self.data_3d.all())
class TestWriteData(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Sequence')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_write_1D(self):
import numpy
import random
seq=self.sim.get_nextSequence(0,0.0)
size=random.randint(128,512)
idata=numpy.zeros((size))
i=0
while i < size:
idata[i]=random.randint(0,100000)
i=i+1
seq.data_write('Integer Data',idata)
size=random.randint(128,512)
data=numpy.float32(numpy.random.random_sample((size)))
seq.data_write('Float Data',data)
size=random.randint(128,512)
data=numpy.random.random_sample((size))
seq.data_write('Double Data',data)
def test_write_2D(self):
import numpy
import random
seq=self.sim.get_nextSequence(0,0.0)
n1=random.randint(10,128)
n2=random.randint(10,128)
idata=numpy.zeros((n1,n2))
i=0
while i < n1:
j=0
while j < n2:
idata[i][j]=random.randint(1,1000)
j=j+1
i=i+1
seq.data_write('Integer Data',idata)
data=numpy.float32(numpy.random.random_sample((n1,n2)))
seq.data_write('Float Data',data)
data=numpy.random.random_sample((n1,n2))
seq.data_write('Double Data',data)
def test_write_3D(self):
import numpy
import random
seq=self.sim.get_nextSequence(0,0.0)
n1=random.randint(1,20)
n2=random.randint(1,20)
n3=random.randint(1,20)
idata=numpy.zeros((n1,n2,n3))
i=0
while i < n1:
j=0
while j < n2:
k=0
while k < n3:
idata[i][j][k]=random.randint(1,1000)
k=k+1
j=j+1
i=i+1
seq.data_write('Integer Data',idata)
data=numpy.float32(numpy.random.random_sample((n1,n2,n3)))
seq.data_write('Float Data',data)
data=numpy.random.random_sample((n1,n2,n3))
seq.data_write('Double Data',data)
class TestSequence(TestCase):
def setUp(self):
import os
import numpy
import random
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh=Output(self.filename,'w')
self.sim=self.fh.add_simulation('Test Simulation')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
def test_basic(self):
from Danu import Sequence
import numpy
import random
cycle=random.randint(10,100)
time=numpy.random.random_sample((1))[0]
seq=self.sim.get_nextSequence(cycle,time);
print seq.id
print seq.time
print seq.cycle
def test_sequence_count(self):
import random
import numpy
cnt=self.sim.sequence_count()
self.assertEqual(cnt,0,'Failed to return zero count')
gen_cnt=random.randint(1,100)
cycle=1
i=1
time=numpy.random.random_sample((1))[0]
while i <= gen_cnt:
time=time+numpy.random.random_sample((1))[0]
seq=self.sim.get_nextSequence(cycle,time)
del seq
i=i+1
cnt=self.sim.sequence_count()
self.assertEqual(cnt,gen_cnt)
def test_sequence_exists(self):
import random
import numpy
cycle=1
time=numpy.random.random_sample((1))[0]
flag=self.sim.sequence_exists('Series DNE')
self.assertEqual(flag,0,'Failed to return false status')
seq=self.sim.get_nextSequence(cycle,time)
id=seq.id
del seq
seq_name=self.sim.get_sequence_name(id)
flag=self.sim.sequence_exists(seq_name)
self.assertEqual(flag,1,'Failed to return true status')
def test_sequence_list(self):
import random
import numpy
list=self.sim.sequence_list()
self.assertEqual(len(list),0,'Failed to return empty list')
gen_cnt=random.randint(1,100)
cycle=1
i=1
time=numpy.random.random_sample((1))[0]
names=[]
while i <= gen_cnt:
time=time+numpy.random.random_sample((1))[0]
seq=self.sim.get_nextSequence(cycle,time)
seq_name=self.sim.get_sequence_name(seq.id)
names.append(seq_name)
del seq
i=i+1
list=self.sim.sequence_list()
self.assertEqual(len(list),gen_cnt,'Failed to return correct list size')
for name in names:
self.assertTrue(name in list)
class TestDataReadInteger(TestCase):
def setUp(self):
import os
import numpy
import random
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Simulation')
self.data_name_1d = 'Integer Data 1D'
self.n = random.randint(1000, 10000)
self.data_1d = numpy.zeros((self.n), numpy.int32)
i = 0
while i < self.n:
self.data_1d[i] = random.randint(1, 100000)
i = i + 1
self.sim.data_write(self.data_name_1d, self.data_1d)
self.data_name_2d = 'Integer Data 2D'
self.n1 = random.randint(100, 1000)
self.n2 = random.randint(100, 1000)
self.data_2d = numpy.zeros((self.n1, self.n2), numpy.int32)
i = 0
while i < self.n1:
j = 0
while j < self.n2:
self.data_2d[i][j] = random.randint(1, 100000)
j = j + 1
i = i + 1
self.sim.data_write(self.data_name_2d, self.data_2d)
self.data_name_3d = 'Integer Data 3D'
self.n1 = random.randint(10, 100)
self.n2 = random.randint(10, 100)
self.n3 = random.randint(10, 100)
self.data_3d = numpy.zeros((self.n1, self.n2, self.n3), numpy.int32)
i = 0
while i < self.n1:
j = 0
while j < self.n2:
k = 0
while k < self.n3:
self.data_3d[i][j][k] = random.randint(1, 100000)
k = k + 1
j = j + 1
i = i + 1
self.sim.data_write(self.data_name_3d, self.data_3d)
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
def runTest(self):
try:
data = self.sim.data_read('Data DNE')
except:
print 'Caught bad non-series data name'
else:
raise RuntimeError, 'Failed to catch DNE dataset name'
data1 = self.sim.data_read(self.data_name_1d)
self.assertEqual(data1.all(), self.data_1d.all())
data2 = self.sim.data_read(self.data_name_2d)
self.assertEqual(data2.all(), self.data_2d.all())
data3 = self.sim.data_read(self.data_name_3d)
self.assertEqual(data3.all(), self.data_3d.all())
class TestOutputSimulations(unittest.TestCase):
def setUp(self):
import random
self.filename = 'test-Output.h5'
self.fh = Output(self.filename, 'w')
def tearDown(self):
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_sim_list(self):
import random
list = self.fh.simulation_list()
self.assertEqual(len(list), 0)
n = random.randint(10, 20)
i = 0
save_names = []
while i < n:
sim_name = 'Simulation ' + str(i)
save_names.insert(i, sim_name)
self.fh.add_simulation(sim_name)
i = i + 1
list = self.fh.simulation_list()
self.assertEqual(len(list), n)
for name in save_names:
if not name in list:
raise RuntimeError, 'Name not found in list'
def test_add_simulation(self):
sim_name = 'New Simulation'
self.fh.add_simulation(sim_name)
def test_sim_count(self):
import random
sim_count = self.fh.simulation_count()
self.assertEqual(sim_count, 0)
n = random.randint(10, 20)
i = 0
while i < n:
sim_name = 'Simulation ' + str(i)
self.fh.add_simulation(sim_name)
i = i + 1
cnt = self.fh.simulation_count()
self.assertEqual(cnt, n)
def test_sim_exists(self):
sim_name = 'Sim DNE'
self.assertEqual(self.fh.simulation_exists(sim_name), 0)
sim_name = 'Smin Does Exist'
self.fh.add_simulation(sim_name)
self.assertEqual(self.fh.simulation_exists(sim_name), 1)
def test_get_simulation(self):
import Danu
sim_name = 'Fetchme'
try:
sim = self.get_simulation(sim_name)
except:
print 'Caught get_simulation DNE test'
else:
raise RuntimeError, 'Failed to raise an error'
self.fh.add_simulation(sim_name)
sim = self.fh.get_simulation(sim_name)
if not isinstance(sim, Danu.Simulation):
raise RuntimeError, 'Failed to return simulation object'
class TestSequence(TestCase):
def setUp(self):
import os
import numpy
import random
from Danu import Output
self.filename = 'test-Simulation.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Simulation')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
def test_basic(self):
from Danu import Sequence
import numpy
import random
cycle = random.randint(10, 100)
time = numpy.random.random_sample((1))[0]
seq = self.sim.get_nextSequence(cycle, time)
print seq.id
print seq.time
print seq.cycle
def test_sequence_count(self):
import random
import numpy
cnt = self.sim.sequence_count()
self.assertEqual(cnt, 0, 'Failed to return zero count')
gen_cnt = random.randint(1, 100)
cycle = 1
i = 1
time = numpy.random.random_sample((1))[0]
while i <= gen_cnt:
time = time + numpy.random.random_sample((1))[0]
seq = self.sim.get_nextSequence(cycle, time)
del seq
i = i + 1
cnt = self.sim.sequence_count()
self.assertEqual(cnt, gen_cnt)
def test_sequence_exists(self):
import random
import numpy
cycle = 1
time = numpy.random.random_sample((1))[0]
flag = self.sim.sequence_exists('Series DNE')
self.assertEqual(flag, 0, 'Failed to return false status')
seq = self.sim.get_nextSequence(cycle, time)
id = seq.id
del seq
seq_name = self.sim.get_sequence_name(id)
flag = self.sim.sequence_exists(seq_name)
self.assertEqual(flag, 1, 'Failed to return true status')
def test_sequence_list(self):
import random
import numpy
list = self.sim.sequence_list()
self.assertEqual(len(list), 0, 'Failed to return empty list')
gen_cnt = random.randint(1, 100)
cycle = 1
i = 1
time = numpy.random.random_sample((1))[0]
names = []
while i <= gen_cnt:
time = time + numpy.random.random_sample((1))[0]
seq = self.sim.get_nextSequence(cycle, time)
seq_name = self.sim.get_sequence_name(seq.id)
names.append(seq_name)
del seq
i = i + 1
list = self.sim.sequence_list()
self.assertEqual(len(list), gen_cnt,
'Failed to return correct list size')
for name in names:
self.assertTrue(name in list)
class TestOutputSimulations(unittest.TestCase):
def setUp(self):
import random
self.filename = 'test-Output.h5'
self.fh = Output(self.filename,'w')
def tearDown(self):
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_sim_list(self):
import random
list=self.fh.simulation_list()
self.assertEqual(len(list),0)
n=random.randint(10,20)
i=0
save_names=[]
while i < n:
sim_name='Simulation ' + str(i)
save_names.insert(i,sim_name)
self.fh.add_simulation(sim_name)
i=i+1
list=self.fh.simulation_list()
self.assertEqual(len(list),n)
for name in save_names:
if not name in list:
raise RuntimeError, 'Name not found in list'
def test_add_simulation(self):
sim_name='New Simulation'
self.fh.add_simulation(sim_name)
def test_sim_count(self):
import random
sim_count=self.fh.simulation_count()
self.assertEqual(sim_count,0)
n=random.randint(10,20)
i=0
while i < n:
sim_name='Simulation ' + str(i)
self.fh.add_simulation(sim_name)
i=i+1
cnt=self.fh.simulation_count()
self.assertEqual(cnt,n)
def test_sim_exists(self):
sim_name='Sim DNE'
self.assertEqual(self.fh.simulation_exists(sim_name),0)
sim_name='Smin Does Exist'
self.fh.add_simulation(sim_name)
self.assertEqual(self.fh.simulation_exists(sim_name),1)
def test_get_simulation(self):
import Danu
sim_name='Fetchme'
try:
sim=self.get_simulation(sim_name)
except:
print 'Caught get_simulation DNE test'
else:
raise RuntimeError, 'Failed to raise an error'
self.fh.add_simulation(sim_name)
sim=self.fh.get_simulation(sim_name)
if not isinstance(sim,Danu.Simulation):
raise RuntimeError, 'Failed to return simulation object'
class TestWriteData(TestCase):
def setUp(self):
import os
from Danu import Output
self.filename = 'test-Sequence.h5'
if os.path.exists(self.filename):
os.remove(self.filename)
self.fh = Output(self.filename, 'w')
self.sim = self.fh.add_simulation('Test Sequence')
def tearDown(self):
import os
if os.path.exists(self.filename):
self.fh.close()
os.remove(self.filename)
def test_write_1D(self):
import numpy
import random
seq = self.sim.get_nextSequence(0, 0.0)
size = random.randint(128, 512)
idata = numpy.zeros((size))
i = 0
while i < size:
idata[i] = random.randint(0, 100000)
i = i + 1
seq.data_write('Integer Data', idata)
size = random.randint(128, 512)
data = numpy.float32(numpy.random.random_sample((size)))
seq.data_write('Float Data', data)
size = random.randint(128, 512)
data = numpy.random.random_sample((size))
seq.data_write('Double Data', data)
def test_write_2D(self):
import numpy
import random
seq = self.sim.get_nextSequence(0, 0.0)
n1 = random.randint(10, 128)
n2 = random.randint(10, 128)
idata = numpy.zeros((n1, n2))
i = 0
while i < n1:
j = 0
while j < n2:
idata[i][j] = random.randint(1, 1000)
j = j + 1
i = i + 1
seq.data_write('Integer Data', idata)
data = numpy.float32(numpy.random.random_sample((n1, n2)))
seq.data_write('Float Data', data)
data = numpy.random.random_sample((n1, n2))
seq.data_write('Double Data', data)
def test_write_3D(self):
import numpy
import random
seq = self.sim.get_nextSequence(0, 0.0)
n1 = random.randint(1, 20)
n2 = random.randint(1, 20)
n3 = random.randint(1, 20)
idata = numpy.zeros((n1, n2, n3))
i = 0
while i < n1:
j = 0
while j < n2:
k = 0
while k < n3:
idata[i][j][k] = random.randint(1, 1000)
k = k + 1
j = j + 1
i = i + 1
seq.data_write('Integer Data', idata)
data = numpy.float32(numpy.random.random_sample((n1, n2, n3)))
seq.data_write('Float Data', data)
data = numpy.random.random_sample((n1, n2, n3))
seq.data_write('Double Data', data)
