def setUp(self):
self.directory = tempfile.mkdtemp()
self.path_context = data.PathContext.cwd()
meta = gen.StageMeta(3.5, 3)
ideal = gen.PipeParameters([meta.generate_ideal()], gen.compute_thres(5, *meta.fsr))
real_stage = meta.generate_gaussian(s_eff=0.1, s_cap=0.1, s_refs=0.1, s_thres=0, s_cm=0.1)
real = gen.PipeParameters([real_stage], gen.compute_thres(5, *meta.fsr))
self.meta = meta
self.ideal = ideal
self.real = real
def create_single(args, metas, modify):
stages = [
meta.generate_gaussian(args.seff, args.scap, args.srefs, args.sthres,
args.scm) for meta in metas
]
tail = np.random.normal(
gen.compute_thres(args.tailbits, *stages[-1].meta.fsr), args.sthres)
adc = gen.PipeParameters(stages, tail)
adc = adc.create_modified(modify)
return adc
def test_stage_thres_code_consistency(self):
for n_bits in range(1, 12):
meta = gen.StageMeta(n_bits, n_refs=2)
meta_h = gen.StageMeta(n_bits, n_refs=3, half_bit=True)
for m in (
meta,
meta_h,
):
thres = gen.compute_thres(m.n_bits,
*m.fsr,
half_bit=m.half_bit)
self.assertEqual(m.n_codes - 1, len(thres))
def run(args):
path_context = data.PathContext.relative()
stages_location = [
data.DataLocation(path_context, args.location, source, "json")
for source in getattr(args, "stages-sources")
]
NestedStages = data.nested_lists_of(gen.StageParameters)
all_stages = []
for stage_loc in stages_location:
print(" loading {}...".format(stage_loc.computed_path))
stage = data.load(NestedStages, stage_loc)
all_stages.append(stage)
assert len(all_stages) > 0
shape = np.shape(all_stages[0].data)
assert all(shape == np.shape(stages.data) for stages in all_stages[1:])
adcs = np.full(shape, None)
for idx in all_stages[0].iter_idx():
stages = tuple(stages[idx] for stages in all_stages)
thresholds = [stage.thres for stage in stages]
meta0 = stages[0].meta
thresholds = [
gen.compute_thres(
meta0.n_bits, *meta0.fsr, half_bit=meta0.half_bit)
] + thresholds
thresholds, tail = thresholds[:-1], thresholds[-1]
assert all(stage.meta.n_codes == np.size(thres) + 1
for stage, thres in zip(stages, thresholds))
stages = [
gen.StageParameters(s.meta, s.eff, s.caps, s.refs, thres,
s.common_mode)
for s, thres in zip(stages, thresholds)
]
adcs[idx] = gen.PipeParameters(stages, tail)
adcs = data.nested_lists_of(gen.PipeParameters)(adcs.tolist(),
len(np.shape(adcs)))
adcs_location = data.DataLocation(path_context, args.location, args.dest,
"json")
print(" saving {}...".format(adcs_location.computed_path))
data.save(adcs, adcs_location)
def save_stages(tb, path_context, location, dest):
shape = tb.conf_shape + tb.shape
array = len(shape) > 0
stages = np.full(shape, None)
stages_ideal = np.full(shape, None)
for idx in tb.iter_idx():
conf_idx, stage_idx = idx
idx = conf_idx + stage_idx
real = tb.stages[stage_idx]
stages[idx] = real
ideal = real.meta.generate_ideal()
tail_bits, tail_half = gen.infer_thres_bits(real.thres)
thres_ideal = gen.compute_thres(tail_bits,
*real.meta.fsr,
half_bit=tail_half)
ideal._thres = thres_ideal
stages_ideal[idx] = ideal
NestedStages = data.nested_lists_of(gen.StageParameters)
dims = len(shape)
stages = NestedStages(stages.tolist() if array else stages[tuple()], dims)
stages_ideal = NestedStages(
stages_ideal.tolist() if array else stages_ideal[tuple()], dims)
stages_location = data.DataLocation(path_context, location,
dest + ".stages", "json")
print(" saving {}...".format(stages_location.computed_path))
data.save(stages if array else stages[tuple()], stages_location)
ideal_location = data.DataLocation(path_context, location,
dest + ".stages.ideal", "json")
print(" saving {}...".format(ideal_location.computed_path))
data.save(stages_ideal if array else stages_ideal[tuple()], ideal_location)
def test_snr(self):
TOLERANCE = 0.03
for bits in range(2, 10):
for half_bit in (
False,
True,
):
n_refs = 3 if half_bit else 2
meta = gen.StageMeta(bits,
n_refs,
eff=1,
fsr=(
-1,
1,
),
half_bit=half_bit)
stage = meta.generate_ideal()
adc = gen.PipeParameters([stage],
gen.compute_thres(1, *meta.fsr))
snr = an.snr(adc, sampling_factor=40)
enob = an.snr_to_enob(snr)
self.assertTrue(
np.abs((bits + 1) - (enob + 0.293)) - TOLERANCE <= 0)
def test_convert_rebuild_cycle(self):
N_TEST = 3
SAMPLES_FACT = 50
for n_bits_0, n_bits_1, n_bits_tail in \
zip(range(3, 3 + N_TEST), range(2, 2 + N_TEST), range(1, 1 + N_TEST)):
tot_bits = n_bits_0 + n_bits_1 + n_bits_tail
samples = int((2**tot_bits + 1) * SAMPLES_FACT)
for half_bit in (
False,
True,
):
n_refs = 3 if half_bit else 2
meta_0 = gen.StageMeta(n_bits_0,
n_refs=n_refs,
half_bit=half_bit,
eff=1)
meta_1 = gen.StageMeta(n_bits_1,
n_refs=n_refs,
half_bit=half_bit,
eff=1)
stages = [meta_0.generate_ideal(), meta_1.generate_ideal()]
thres_tail = gen.compute_thres(n_bits_tail,
*meta_1.fsr,
half_bit=half_bit)
adc = gen.PipeParameters(stages, thres_tail)
data = np.linspace(*meta_0.fsr, samples) # TODO:randomize
conversion, tail_code = adc.convert(data[..., np.newaxis])
re_data = adc.rebuild(conversion, tail_code)
lsb = (meta_0.fsr[1] - meta_0.fsr[0]) / 2**tot_bits
self.assertTrue((np.abs(data - re_data) <= lsb / 2).all())