def test_evaluate():
Ts = 1e-3
M = 4
digitalControl = DigitalControl(Ts, M)
x = np.random.randn(4)
t = 0.1
res = digitalControl.control_contribution(t, x)
for value in res:
assert value == 1 or value == -1
def test_initialization(chain_of_integrators):
digitalControl = DigitalControl(Ts, M)
eta2 = 1.0
K1 = 100
K2 = 0
DigitalEstimator(chain_of_integrators['system'], digitalControl, eta2, K1,
K2)
def test_iterator(chain_of_integrators):
analogSignals = [ConstantSignal(0.1)]
digitalControl = DigitalControl(Ts, M)
statespacesimulator = StateSpaceSimulator(chain_of_integrators["system"],
digitalControl,
analogSignals,
t_stop=Ts * 1000)
for control_signal in statespacesimulator:
pass
def test_batch_iterations():
digitalControl = DigitalControl(Ts, M)
eta2 = 100.0
K1 = 25
K2 = 1000
analogSystem = AnalogSystem(A, B, CT, Gamma, Gamma_tildeT)
estimator = DigitalEstimator(analogSystem,
digitalControl,
eta2,
K1,
K2=K2,
stop_after_number_of_iterations=200)
estimator(controlSequence())
for est in estimator:
print(np.array(est))
def test_estimation_with_circuit_simulator():
eta2 = 1e12
K1 = 1000
K2 = 0
analogSystem = AnalogSystem(A, B, CT, Gamma, Gamma_tildeT)
# analogSignals = [Sinusoidal(0.5, 10)]
analogSignals = [ConstantSignal(0.25)]
digitalControl = DigitalControl(Ts, M)
circuitSimulator = StateSpaceSimulator(analogSystem,
digitalControl,
analogSignals,
t_stop=Ts * 1000)
estimator = DigitalEstimator(analogSystem, digitalControl, eta2, K1, K2)
estimator(circuitSimulator)
for est in estimator:
print(est)
def test_large_integrator():
N = 20
M = N
A = np.eye(N) * rho + np.eye(N, k=-1) * beta
B = np.zeros((N, 1))
B[0] = beta
CT = np.zeros((N, 1)).transpose()
CT[-1] = 1.0
Gamma_tildeT = np.eye(N)
Gamma = Gamma_tildeT * (-beta)
analogSystem = AnalogSystem(A, B, CT, Gamma, Gamma_tildeT)
analogSignals = [ConstantSignal(0.1)]
digitalControl = DigitalControl(Ts, M)
statespacesimulator = StateSpaceSimulator(analogSystem,
digitalControl,
analogSignals,
t_stop=Ts * 1000)
for control_signal in statespacesimulator:
pass
def main():
# Analog system
analog_system = ChainOfIntegrators(betaVec, rhoVec, kappaVec)
# Initialize the digital control.
digital_control = DigitalControl(T, M)
# Instantiate the analog signal
analog_signal = Sinusodial(amplitude, frequency, phase, offset)
# Instantiate the simulator.
simulator = StateSpaceSimulator(analog_system,
digital_control, [analog_signal],
t_stop=end_time)
# Depending on your analog system the step above might take some time to
# compute as it involves precomputing solutions to initial value problems.
# Construct byte stream.
byte_stream = control_signal_2_byte_stream(simulator, M)
write_byte_stream_to_file("./temp.adc", byte_stream)
os.remove("./temp.adc")
###############################################################################
# Simulating
# ----------
#
# Each estimator will require an independent stream of control signals.
# Therefore, we will next instantiate several digital controls and simulators.
from cbadc.simulator import StateSpaceSimulator
# Set simulation precision parameters
atol = 1e-6
rtol = 1e-12
max_step = T / 10.
# Instantiate digital controls
digital_control1 = DigitalControl(T, M)
digital_control2 = DigitalControl(T, M)
print(digital_control1)
# Instantiate simulators.
simulator1 = StateSpaceSimulator(analog_system,
digital_control1, [analog_signal],
atol=atol,
rtol=rtol,
max_step=max_step)
simulator2 = StateSpaceSimulator(analog_system,
digital_control2, [analog_signal],
atol=atol,
rtol=rtol,
max_step=max_step)
def test_initialization(chain_of_integrators):
analogSignals = [ConstantSignal(0.1)]
digitalControl = DigitalControl(Ts, M)
StateSpaceSimulator(chain_of_integrators["system"], digitalControl,
analogSignals)
M = N
beta = 6250.
rho = -beta * 1e-2
A = [[rho, 0, 0, 0, 0, 0], [beta, rho, 0, 0, 0, 0], [0, beta, rho, 0, 0, 0],
[0, 0, beta, rho, 0, 0], [0, 0, 0, beta, rho, 0], [0, 0, 0, 0, beta, rho]]
B = [[beta], [0], [0], [0], [0], [0]]
CT = np.eye(N)
Gamma = [[-beta, 0, 0, 0, 0, 0], [0, -beta, 0, 0, 0,
0], [0, 0, -beta, 0, 0, 0],
[0, 0, 0, -beta, 0, 0], [0, 0, 0, 0, -beta, 0],
[0, 0, 0, 0, 0, -beta]]
Gamma_tildeT = np.eye(N)
T = 1.0 / (2 * beta)
analog_system = AnalogSystem(A, B, CT, Gamma, Gamma_tildeT)
digital_control = DigitalControl(T, M)
# Summarize the analog system, digital control, and digital estimator.
print(analog_system, "\n")
print(digital_control)
###############################################################################
# Loading Control Signal from File
# --------------------------------
#
# Next, we will load an actual control signal to demonstrate the digital
# estimator's capabilities. To this end, we will use the
# `sinusodial_simulation.adc` file that was produced in
# :doc:`./plot_b_simulate_a_control_bounded_adc`.
#
# The control signal file is encoded as raw binary data so to unpack it
# B[0, 1] = -beta
C = np.eye(N)
Gamma_tilde = np.eye(N)
Gamma = Gamma_tilde * (-beta)
Ts = 1 / (2 * beta)
amplitude = 1.0
frequency = 10.
phase = 0.
eta2 = 1e6
K1 = 1 << 12
K2 = 1 << 12
size = K2 << 4
analogSystem = AnalogSystem(A, B, C, Gamma, Gamma_tilde)
digitalControl = DigitalControl(Ts, N)
analogSignals = [Sinusodial(amplitude, frequency, phase)]
def iterate_through(iterator):
count = 0
for _ in range(size):
next(iterator)
count = count + 1
return count
def test_benchmark_state_space_simulation_algorithm(benchmark):
est = StateSpaceSimulator(analogSystem, digitalControl, analogSignals)
result = benchmark(iterate_through, est)
assert (result == size)
def test_initialization():
Ts = 1e-3
M = 4
digitalControl = DigitalControl(Ts, M)
def test_control_signal():
Ts = 1e-3
epsilon = 1e-9
M = 4
digitalControl = DigitalControl(Ts, M)
x = np.ones(M)
t = Ts
np.testing.assert_allclose(np.ones(M), digitalControl.control_signal())
print("Inital control signal: ",
np.asarray(digitalControl.control_signal()))
digitalControl.control_update(t + epsilon, x)
res = digitalControl.control_contribution(t + epsilon)
print(
"Control signal after first control contribution call: ",
np.asarray(digitalControl.control_signal()),
)
print("control contribution response: ", np.asarray(res))
np.testing.assert_allclose(np.ones(M), digitalControl.control_signal())
np.testing.assert_allclose(np.ones(M), res)
digitalControl.control_update(t + Ts + epsilon, -x)
res = digitalControl.control_contribution(t + Ts + epsilon)
print(
"control signal after second control contribution update: ",
np.asarray(digitalControl.control_signal()),
)
print("control contribution response: ", np.asarray(res))
np.testing.assert_allclose(np.zeros(M), digitalControl.control_signal())
np.testing.assert_allclose(-np.ones(M), res)
digitalControl.control_update(t + 2 * Ts + epsilon, -x)
res = digitalControl.control_contribution(t + 2 * Ts + epsilon)
print(
"control signal after third control contribution update: ",
np.asarray(digitalControl.control_signal()),
)
print("control contribution response: ", np.asarray(res))
np.testing.assert_allclose(np.zeros(M), digitalControl.control_signal())
np.testing.assert_allclose(-np.ones(M), res)
def test_estimation_with_circuit_simulator():
eta2 = 1e12
K1 = 1 << 10
K2 = 1 << 10
size = K2 << 2
window = 1000
size_2 = size // 2
window_2 = window // 2
left_w = size_2 - window_2
right_w = size_2 + window_2
analogSystem = AnalogSystem(A, B, CT, Gamma, Gamma_tildeT)
analogSignals = [Sinusodial(amplitude, frequency, phase)]
digitalControl1 = DigitalControl(Ts, M)
digitalControl2 = DigitalControl(Ts, M)
digitalControl3 = DigitalControl(Ts, M)
digitalControl4 = DigitalControl(Ts, M)
tf_abs = np.abs(
analogSystem.transfer_function_matrix(np.array([2 * np.pi * frequency
])))
print(tf_abs, tf_abs.shape)
simulator1 = StateSpaceSimulator(analogSystem, digitalControl1,
analogSignals)
simulator2 = StateSpaceSimulator(analogSystem, digitalControl2,
analogSignals)
simulator3 = StateSpaceSimulator(analogSystem, digitalControl3,
analogSignals)
simulator4 = StateSpaceSimulator(analogSystem, digitalControl4,
analogSignals)
estimator1 = DigitalEstimator(analogSystem, digitalControl1, eta2, K1, K2)
estimator2 = ParallelEstimator(analogSystem, digitalControl2, eta2, K1, K2)
estimator3 = FIRFilter(analogSystem, digitalControl3, eta2, K1, K2)
estimator4 = IIRFilter(analogSystem, digitalControl4, eta2, K2)
estimator1(simulator1)
estimator2(simulator2)
estimator3(simulator3)
estimator4(simulator4)
tf_1 = estimator1.signal_transfer_function(
np.array([2 * np.pi * frequency]))[0]
e1_array = np.zeros(size)
e2_array = np.zeros(size)
e3_array = np.zeros(size)
e4_array = np.zeros(size)
e1_error = 0
e2_error = 0
e3_error = 0
e4_error = 0
for index in range(size):
e1 = estimator1.__next__()
e2 = estimator2.__next__()
e3 = estimator3.__next__()
e4 = estimator4.__next__()
e1_array[index] = e1
e2_array[index] = e2
e3_array[index] = e3
e4_array[index] = e4
t = index * Ts
u = analogSignals[0].evaluate(t)
u_lag = analogSignals[0].evaluate(t - estimator4.filter_lag() * Ts)
if (index > left_w and index < right_w):
print(
f"Time: {t: 0.2f}, Input Signal: {u * tf_1}, e1: {e1}, e2: {e2}, e3: {e3}, e4: {e4}"
)
e1_error += np.abs(e1 - u * tf_1)**2
e2_error += np.abs(e2 - u * tf_1)**2
e3_error += np.abs(e3 - u_lag * tf_1)**2
e4_error += np.abs(e4 - u_lag * tf_1)**2
e1_error /= window
e2_error /= window
e3_error /= window
e4_error /= window
print(f"""Digital estimator error: {e1_error}, {10 *
np.log10(e1_error)} dB""")
print(f"""Parallel estimator error: {e2_error}, {10 *
np.log10(e2_error)} dB""")
print(f"""FIR filter estimator error: {e3_error}, {10 *
np.log10(e3_error)} dB""")
print(f"""IIR filter estimator error: {e4_error}, {10 *
np.log10(e4_error)} dB""")
assert (np.allclose(e1_error, 0, rtol=1e-6, atol=1e-6))
assert (np.allclose(e2_error, 0, rtol=1e-6, atol=1e-6))
assert (np.allclose(e3_error, 0, rtol=1e-6, atol=1e-6))
assert (np.allclose(e4_error, 0, rtol=1e-6, atol=1e-6))
def test_control_signal():
Ts = 1e-3
M = 4
digitalControl = DigitalControl(Ts, M)
x = np.ones(M)
t = Ts
np.testing.assert_allclose(np.zeros(M), digitalControl.control_signal())
print(np.asarray(digitalControl.control_signal()))
res = digitalControl.control_contribution(t, x)
print(np.asarray(digitalControl.control_signal()))
print(np.asarray(res))
np.testing.assert_allclose(np.ones(M), digitalControl.control_signal())
np.testing.assert_allclose(np.ones(M), res)
res = digitalControl.control_contribution(t+Ts, -x)
print(np.asarray(digitalControl.control_signal()))
print(np.asarray(res))
np.testing.assert_allclose(np.zeros(M), digitalControl.control_signal())
np.testing.assert_allclose(-np.ones(M), res)
res = digitalControl.control_contribution(t, x)
print(np.asarray(digitalControl.control_signal()))
print(np.asarray(res))
np.testing.assert_allclose(np.zeros(M), digitalControl.control_signal())
np.testing.assert_allclose(-np.ones(M), res)