def test_NeuronCalibration(self):
with TemporaryDirectory() as tmp_dir:
backend = loadXMLBackend(tmp_dir)
nc0 = cal.NeuronCollection()
nc0.setSpeedup(int(1e4))
nc0.setStartingCycle(42)
tmp = cal.NeuronCalibration()
tmp.setDefaults()
nc0.insert(0, tmp)
self.assertLess(0, tmp.at(pyhalbe.HICANN.neuron_parameter.E_l).apply(0.5))
backend.store("fisch", cal.MetaData(), nc0)
nc1 = cal.NeuronCollection()
md = cal.MetaData()
backend.load("fisch", md, nc1)
self.assertEqual(int(1e4), nc1.getSpeedup())
self.assertEqual(42, nc0.getStartingCycle())
bio = cell.EIF_cond_exp_isfa_ista()
hwparam0 = nc0.applyNeuronCalibration(
bio, 0, cal.NeuronCalibrationParameters())
hwparam1 = nc1.applyNeuronCalibration(
bio, 0, cal.NeuronCalibrationParameters())
for idx in range(cal.HWNeuronParameter.size()):
self.assertEqual(hwparam0.getParam(idx), hwparam1.getParam(idx),
"HWNeuronParameter[{}]: {} != {}".format(
idx, hwparam0.getParam(idx), hwparam1.getParam(idx)))
def test_RegressionUpcast(self):
with TemporaryDirectory() as tmp_dir:
backend = loadXMLBackend(tmp_dir)
nc0 = cal.NeuronCollection()
tmp = cal.NeuronCalibration()
tmp.setDefaults()
nc0.insert(0, tmp)
backend.store("fisch", cal.MetaData(), nc0)
nc1 = cal.NeuronCollection()
md = cal.MetaData()
backend.load("fisch", md, nc1)
self.assertEqual(nc0.at(0).size(), nc1.at(0).size())
def test_ADCCalibration(self):
"""Tests ADCCalibration functionality."""
# generate fake calibration measurement
vm = cal.VoltageMeasurement()
for i in range(1, 9):
dp = cal.DataPoint(0.2 + 0.01*i, i, 0.0001)
vm.push_back(dp)
# generate fake raw data to be converted to voltage
data = pywrapstdvector.Vector_UInt16(np.array([1, 5, 3], dtype='uint16'))
# create fresh calibration object
adc = cal.ADCCalibration()
# applying calibration on empty object should fail
channel = pyhalco_hicann_v2.ChannelOnADC(0)
self.assertRaises(RuntimeError, adc.apply, channel, data)
# generate polynomials for each channel
c_gnd = pyhalco_hicann_v2.ChannelOnADC(-1)
for cc in pyhalco_hicann_v2.iter_all(pyhalco_hicann_v2.ChannelOnADC):
if cc == c_gnd:
# skip GND "channel"
continue
adc.makePolynomialTrafo(cc.value(), vm)
# convert raw data to voltages
res = adc.apply(channel, data)
# check result
self.assertAlmostEqual(res[0], 0.21, places=2)
self.assertGreater(res[1], res[2])
with TemporaryDirectory() as tmp_dir:
backend = loadXMLBackend(tmp_dir)
md = cal.MetaData()
id = pyhalbe.ADC.USBSerial("0")
adc.store(backend, md, id)
adc2 = cal.ADCCalibration()
md2 = adc2.load(backend, id)
del md2
res = adc2.apply(channel, data)
self.assertAlmostEqual(res[0], 0.21, places=2)
self.assertGreater(res[1], res[2])
data = np.array([1, 5, 3], dtype=np.ushort)
res = adc.apply(channel, data)
self.assertAlmostEqual(res[0], 0.21, places=2)
self.assertGreater(res[1], res[2])
def test_HICANNCollection(self):
"""Write HICANNCollection to backend and read it back, compare"""
with TemporaryDirectory() as tmp_dir:
backend = loadXMLBackend(tmp_dir)
# create HICANNCollection, fill in defaults
hc0 = cal.HICANNCollection()
hc0.setDefaults()
nc0 = hc0.atNeuronCollection()
bc0 = hc0.atBlockCollection()
sc0 = hc0.atSynapseRowCollection()
# store collection
backend.store("frosch", cal.MetaData(), hc0)
# create objects filled by backend
hc1 = cal.HICANNCollection()
md = cal.MetaData()
# load back collection
backend.load("frosch", md, hc1)
nc1 = hc1.atNeuronCollection()
bc1 = hc1.atBlockCollection()
sc1 = hc1.atSynapseRowCollection()
# check that all collections exist
self.assertIsInstance(nc0.at(0).size(), int)
self.assertIsInstance(nc1.at(0).size(), int)
self.assertIsInstance(bc0.at(0).size(), int)
self.assertIsInstance(bc1.at(0).size(), int)
self.assertIsInstance(sc0.at(0).size(), int)
self.assertIsInstance(sc1.at(0).size(), int)
# check that collections are of equal size after loading from backend
self.assertEqual(nc0.at(0).size(), nc1.at(0).size(), "NeuronCollection was not restored from backend")
self.assertEqual(bc0.at(0).size(), bc1.at(0).size(), "BlockCollection was not restored from backend")
self.assertEqual(sc0.at(0).size(), sc1.at(0).size(), "SynapseRowCollection was not restored from backend")
def test_BackendRestoreFactors(self):
"""Are factors written to backend and can be loaded again?"""
backend = loadXMLBackend(self.backend_dir)
speedup = 1234
pll = 500
startingcycle = 890
nc0 = cal.NeuronCollection()
nc0.setSpeedup(speedup)
self.assertEqual(speedup, nc0.getSpeedup())
nc0.setPLLFrequency(pll)
nc0.setStartingCycle(startingcycle)
backend.store("issue1166", cal.MetaData(), nc0)
nc1 = cal.NeuronCollection()
md = cal.MetaData()
backend.load("issue1166", md, nc1)
self.assertEqual(nc1.getSpeedup(), speedup)
self.assertEqual(nc1.getPLLFrequency(), pll)
self.assertEqual(nc1.getClock(), pll / 4.)
self.assertEqual(nc1.getStartingCycle(), startingcycle)
def main(inpath, inext, outpath, outext, wafer, hicann):
"""
converts inname to outname based on filename extensions
If no outpath is received, only load the input backend,
which can be used as a file integrity check.
"""
in_backend = load_backend(inpath, inext)
if outpath: out_backend = load_backend(outpath, outext)
in_hc = pycalibtic.HICANNCollection()
in_md = pycalibtic.MetaData()
in_backend.load(get_calibtic_name(wafer, hicann), in_md, in_hc)
if outpath: out_backend.store(get_calibtic_name(wafer, hicann), in_md, in_hc)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('backend_path', type=str)
args = parser.parse_args()
lib = pycalibtic.loadLibrary('libcalibtic_xml.so')
backend = pycalibtic.loadBackend(lib)
backend.config('path', args.backend_path)
backend.init()
for calib in glob.glob('adc-*.xml'):
print("*" * 80)
adc = ADC(re.match(r'adc-([\w\d]+)\.xml', calib).group(1))
print(adc)
calib = pycalibtic.ADCCalibration()
meta = calib.load(backend, adc)
qcalib = pycalibtic.ADCCalibration.convertToQuadraticADCCalibration(calib)
print(meta)
print(qcalib)
pycalibtic.storeADCCalibration(backend, qcalib, meta, adc)
meta = pycalibtic.MetaData()
pycalibtic.loadADCCalibration(backend, meta, adc)
print(meta)
print(qcalib)