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)