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)