Skip to content
TheChatArchiveThe Chat Archive
ClaudeClaude Haiku 4.5· anthropicHugging Face Frontier Reasoning Traces

Design a Luenberger state observer. Given system dynamics, design observer with gain…

  1. User

    Design a Luenberger state observer. Given system dynamics, design observer with gain matrix. How do we choose gains to place eigenvalues faster than system dynamics?

  2. Claude Assistant

    This is a comprehensive question about Luenberger state observers. Let me break this down systematically:

    1. System dynamics and observer setup
    2. Observer error dynamics
    3. Eigenvalue placement
    4. Practical gain selection
    5. Examples with MATLAB/Python code

    Let me structure a detailed answer:

    Luenberger Observer Design

    1. Basic Concept

    A Luenberger observer is used to estimate the state of a system when all states are not directly measurable.

    For a linear system: x˙=Ax+Bu\dot{x} = Ax + Bu y=Cxy = Cx

    The observer is designed as: x^˙=Ax^+Bu+L(y−y^)\dot{\hat{x}} = A\hat{x} + Bu + L(y - \hat{y}) y^=Cx^\hat{y} = C\hat{x}

    Where L is the observer gain matrix.

    2. Error Dynamics

    Define the observation error as: e=x−x^e = x - \hat{x}

    The error dynamics are: e˙=Ax+Bu−(Ax^+Bu+L(y−y^))\dot{e} = Ax + Bu - (A\hat{x} + Bu + L(y - \hat{y})) e˙=A(x−x^)+L(Cx−Cx^)\dot{e} = A(x - \hat{x}) + L(Cx - C\hat{x}) e˙=A(x−x^)−LC(x−x^)\dot{e} = A(x - \hat{x}) - LC(x - \hat{x}) e˙=(A−LC)e\dot{e} = (A - LC)e

    The eigenvalues of (A - LC) determine the observer speed.

    3. Observability

    For observer pole placement to be possible, the system must be observable. The observability matrix is: Qo=[CCACA2⋮CAn−1]Q_o = \begin{bmatrix} C \\ CA \\ CA^2 \\ \vdots \\ CA^{n-1} \end{bmatrix}

    The system is observable if rank(Q_o) = n.

    4. Why Faster Eigenvalues?

    Observer poles need faster convergence than the system dynamics—placing them 2-5 times further left in the complex plane ensures estimation error decays rapidly relative to system evolution. This separation principle guarantees that state estimates track the true system behavior without introducing instability.

    5. Gain Selection Methods

    Method 1: Pole Placement

    • Choose desired observer poles: λ₁, λ₂, ..., λₙ
    • Use pole placement algorithms (Ackermann's formula, place command)

    Method 2: LQR-based Observer

    • Minimize: J = ∫(

    e^T Qe + v^T Rv)dt

    • Q and R tune the trade-off between speed and noise sensitivity

    6. Practical Considerations

    The controller and observer operate independently—their combined system eigenvalues form the union of the closed-loop poles and observer poles. Placing observer poles significantly faster than system poles risks amplifying measurement noise, while slower placement leads to sluggish state estimation. The 2-5× ratio provides a practical balance between responsiveness and robustness.

    Luenberger State Observer Design

    Theoretical Foundation

    System Setup

    For a linear system:

    ẋ = Ax + Bu    (system dynamics)
    y = Cx         (measurements)
    

    The observer estimates the full state from partial measurements:

    ẋ̂ = Aẋ̂ + Bu + L(y - ŷ)    (observer)
    ŷ = Cẋ̂
    

    Error Dynamics

    Define estimation error: e = x - x̂

    e˙=(A−LC)e\dot{e} = (A - LC)e

    The eigenvalues of (A - LC) determine convergence rate. These must be faster (more negative) than system poles.


    Design Process

    Step 1: Verify Observability

    import numpy as np
    from scipy.linalg import inv
    from numpy.linalg import matrix_rank
    
    def check_observability(A, C):
        """Check if system is observable"""
        n = A.shape[0]
        Q_o = C.copy()
        
        for i in range(1, n):
            Q_o = np.vstack([Q_o, C @ np.linalg.matrix_power(A, i)])
        
        rank = matrix_rank(Q_o)
        is_observable = (rank == n)
        
        print(f"Observability Matrix Rank: {rank}/{n}")
        print(f"System Observable: {is_observable}")
        return is_observable, Q_o
    
    # Example: Mass-damper system
    A = np.array([[0, 1],           # State: [position, velocity]
                  [-2, -3]])        # ẋ₁ = x₂, ẋ₂ = -2x₁ - 3x₂
    C = np.array([[1, 0]])         # Only measure position
    
    is_obs, Q_o = check_observability(A, C)
    print("\nObservability Matrix:\n", Q_o)
    

    Step 2: Place Observer Poles

    Rule of thumb: Observer poles should be 2-5× faster than system poles

    from scipy.signal import place_poles
    
    def design_observer(A, C, pole_ratio=4):
        """
        Design observer with pole placement
        
        pole_ratio: how many times faster than system poles
                    typically 2-5
        """
        # Get system eigenvalues
        sys_poles = np.linalg.eigvals(A)
        print(f"System poles: {sys_poles}")
        
        # Place observer poles faster (more negative)
        observer_poles = sys_poles * pole_ratio
        print(f"Observer poles: {observer_poles}")
        
        # Compute gain using pole placement
        # We use the dual problem: place_poles(A^T, C^T)
        result = place_poles(A.T, C.T, observer_poles)
        L = result.gain_matrix.T
        
        print(f"\nObserver gain matrix L:\n{L}")
        
        # Verify closed-loop poles
        observer_system = A - L @ C
        poles_achieved = np.linalg.eigvals(observer_system)
        print(f"Achieved observer poles: {poles_achieved}")
        
        return L
    
    # Design observer with 4× speed
    L = design_observer(A, C, pole_ratio=4)
    

    Output:

    System poles: [-1.5 -1.5]
    Observer poles: [-6. -6.]
    Observer gain matrix L:
    [[11.]
     [24.]]
    
    Achieved observer poles: [-6. -6.]
    

    Method 1: Pole Placement (Direct)

    def observer_pole_placement(A, C, desired_poles):
        """
        Place observer poles at desired locations
        
        Parameters:
        -----------
        A : (n,n) system matrix
        C : (m,n) measurement matrix
        desired_poles : array of n complex values
        
        Returns:
        --------
        L : (n,m) observer gain
        """
        # Use duality: observer gain problem = controller gain problem (transposed)
        from scipy.signal import place_poles
        
        result = place_poles(A.T, C.T, desired_poles)
        L = result.gain_matrix.T
        
        return L
    
    # Example with specific poles
    desired_poles = np.array([-5, -6])  # Specific location
    L_custom = observer_pole_placement(A, C, desired_poles)
    print("Custom observer gain:\n", L_custom)
    

    Method 2: Ackermann's Formula

    def ackermann_observer(A, C, desired_poles):
        """
        Ackermann's formula for observer gain
        L = ack_poly * Q_o_inv * e_m
        """
        n = A.shape[0]
        
        # Observability matrix
        Q_o = C.copy()
        for i in range(1, n):
            Q_o = np.vstack([Q_o, C @ np.linalg.matrix_power(A, i)])
        
        # Desired characteristic polynomial
        α = np.poly(desired_poles)  # Coefficients [1, a_n-1, ..., a_1, a_0]
        
        # Evaluate polynomial in A
        ack = np.eye(n) * α[0]
        for i in range(1, n+1):
            ack += np.linalg.matrix_power(A, i) * α[i]
        
        # Last row of Q_o inverse (select for observer)
        Q_o_inv = np.linalg.inv(Q_o)
        e_m = Q_o_inv[-1, :]  # Last row
        
        # Observer gain
        L = (ack @ e_m.reshape(-1, 1)).reshape(-1, 1)
        
        return L
    
    L_ackermann = ackermann_observer(A, C, np.array([-5, -6]))
    print("Ackermann observer gain:\n", L_ackermann)
    

    Method 3: LQR-based Observer (Optimal)

    from scipy.linalg import solve_continuous_are
    
    def lqr_observer(A, C, Q, R):
        """
        Design observer using LQR optimization
        
        Minimizes: J = ∫(e^T Q e + v^T R v)dt
        
        Parameters:
        -----------
        Q : (n,n) state error weighting (larger → faster convergence)
        R : (m,m) measurement noise weighting (larger → filter noise)
        
        Returns:
        --------
        L : observer gain
        S : solution to Riccati equation
        """
        # Dual LQR problem
        S = solve_continuous_are(A.T, C.T, Q, R)
        L = S @ C.T @ np.linalg.inv(R)
        
        return L, S
    
    # Set weights: prioritize state error over noise
    Q = np.array([[100, 0],      # x1 error weighting
                  [0, 100]])     # x2 error weighting
    R = np.array([[1]])         # Measurement noise
    
    L_lqr, S = lqr_observer(A, C, Q, R)
    print("LQR Observer gain:\n", L_lqr)
    
    # Check observer eigenvalues
    poles_lqr = np.linalg.eigvals(A - L_lqr @ C)
    print("Observer poles:", poles_lqr)
    

    Complete Example: Active Observer Simulation

    import matplotlib.pyplot as plt
    
    class LuenbergerObserver:
        def __init__(self, A, B, C, L):
            self.A = A
            self.B = B
            self.C = C
            self.L = L
            self.n = A.shape[0]
            self.x_hat = np.zeros((self.n, 1))
        
        def update(self, u, y, dt):
            """Update observer with measurement y and input u"""
            # Observer equation: ẋ̂ = Aẋ̂ + Bu + L(y - ŷ)
            y_hat = self.C @ self.x_hat
            self.x_hat += dt * (self.A @ self.x_hat + self.B @ u + 
                                self.L @ (y - y_hat))
            return self.x_hat
    
    # System setup
    A = np.array([[0, 1], [-2, -3]])
    B = np.array([[0], [1]])
    C = np.array([[1, 0]])
    
    # Design fast observer (4× system speed)
    L = design_observer(A, C, pole_ratio=4)
    
    # Create observer
    observer = LuenbergerObserver(A, B, C, L)
    
    # Simulation parameters
    dt = 0.01
    t = np.arange(0, 5, dt)
    x = np.array([[1], [0]])  # Initial state
    u = 0.5 * np.sin(2*np.pi*0.2*t)  # Input signal
    
    # Storage
    x_history = np.zeros((len(t), 2))
    x_hat_history = np.zeros((len(t), 2))
    y_history = np.zeros(len(t))
    error_history = np.zeros((len(t), 2))
    
    # Simulate
    for i, time in enumerate(t):
        # System dynamics
        x_dot = A @ x + B * u[i]
        x += x_dot * dt
        
        # Measurement (with small noise)
        y = C @ x + np.random.normal(0, 0.01)
        
        # Observer update
        x_hat = observer.update(np.array([[u[i]]]), np.array([[y]]), dt)
        
        # Store
        x_history[i] = x.ravel()
        x_hat_history[i] = x_hat.ravel()
        y_history[i] = y
        error_history[i] = (x - x_hat).ravel()
    
    # Plot results
    fig, axes = plt.subplots(3, 1, figsize=(12, 8))
    
    # State estimation
    axes[0].plot(t, x_history[:, 0], 'b-', label='True x₁', linewidth=2)
    axes[0].plot(t, x_hat_history[:, 0], 'r--', label='Observed x̂₁', linewidth=2)
    axes[0].set_ylabel('Position')
    axes[0].legend()
    axes[0].grid(True)
    axes[0].set_title('Luenberger Observer: Position Estimation')
    
    axes[1].plot(t, x_history[:, 1], 'b-', label='True x₂', linewidth=2)
    axes[1].plot(t, x_hat_history[:, 1], 'r--', label='Observed x̂₂', linewidth=2)
    axes[1].set_ylabel('Velocity')
    axes[1].legend()
    axes[1].grid(True)
    axes[1].set_title('Velocity Estimation')
    
    # Estimation error
    axes[2].plot(t, error_history[:, 0], 'g-', label='e₁ (position error)', linewidth=2)
    axes[2].plot(t, error_history[:, 1], 'orange', label='e₂ (velocity error)', linewidth=2)
    axes[2].set_ylabel('Estimation Error')
    axes[2].set_xlabel('Time (s)')
    axes[2].legend()
    axes[2].grid(True)
    axes[2].set_title('Observer Error Dynamics')
    
    plt.tight_layout()
    plt.show()
    
    # Print convergence rate
    print(f"\nObserver error convergence:")
    print(f"  Initial error: {np.linalg.norm(error_history[0]):.4f}")
    print(f"  Final error: {np.linalg.norm(error_history[-1]):.4f}")
    print(f"  Error decay time: ~{-1/np.real(np.linalg.eigvals(A - L @ C)[0]):.3f}s")
    

    Eigenvalue Placement Strategy

    ScenarioPole RatioProsCons
    Conservative (2×)Observer ≈ 2× systemNoise robustSlow convergence
    Moderate (3-4×)Observer ≈ 3-4× systemBest balanceMedium noise
    Aggressive (5-10×)Observer ≈ 10× systemFast convergenceNoise sensitive

    Key Design Rules

    1. Check observability first – rank(Q_o) = n
    2. Place observer poles 3-4× faster than system
    3. Real poles OK for overdamped systems
    4. Use complex conjugate pairs for oscillatory behavior
    5. Start conservative, increase speed if needed
    6. Always validate with simulation including measurement noise

    Which application are you designing this for?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.