Continuous vs. Discrete Systems: Models, Examples & Simulation

TAKEAWAYS:

• Continuous systems model real-valued, time-dependent variables (e.g., temperature, fluid flow) using differential equations, while discrete systems model countable, event-driven states (e.g., customer arrivals, machine cycles) using difference equations or state transitions.
• Hybrid systems combine both (e.g., a chemical reactor with discrete control valves and continuous temperature changes).
• Simulation tools like Simulink (continuous), AnyLogic (discrete), or Python (custom scripts) bridge theory and practice.
• Key metrics for validation: steady-state error, transient response (continuous); queue lengths, cycle times (discrete).
• Real-world applications span manufacturing (assembly lines), logistics (warehouse robots), and finance (portfolio optimization).

1. Definitions and Core Concepts

Continuous Systems

• Definition: Systems where state variables change smoothly over time (e.g., temperature, velocity, pressure).
• Mathematical Model: Governed by ordinary differential equations (ODEs) or partial differential equations (PDEs).
  • Example: A heating system’s temperature $T(t)$ follows: $$\frac{dT}{dt}=k(T_{\text{set}}-T(t))$$ where $k$ is a cooling constant.
• Key Features:
  • Infinite possible states between any two values.
  • Time is continuous (e.g., seconds, milliseconds).
  • Example Systems: Pendulums, electrical circuits, fluid dynamics.

Discrete Systems

• Definition: Systems where state changes occur at distinct points (e.g., customer arrivals, machine states).
• Mathematical Model: Described by difference equations or state transition diagrams.
  • Example: A bank teller’s queue:
    • State $S_n$: Number of customers at time step $n$.
    • Transition: $S_{n+1}=S_n+\text{arrivals}-\text{services}$.
• Key Features:
  • Countable, often integer-valued states.
  • Time progresses in discrete steps (e.g., per second, per hour).
  • Example Systems: Traffic lights, inventory management, digital circuits.

2. Visualizing the Systems

Continuous System: Pendulum Motion

• Real Picture:

Discrete System: Traffic Light Cycle

stateDiagram-v2
    [*] --> Green
    Green --> Yellow: after 30s
    Yellow --> Red: after 5s
    Red --> Green: after 45s

• Real Picture:

3. Modeling Techniques

Continuous Systems

Discrete Systems

4. Worked Examples

Example 1: Continuous – Drug Concentration in Blood

Scenario: A drug is injected into a patient. Its concentration $C(t)$ (mg/L) decays exponentially: $$\frac{dC}{dt}=-kC,C(0)=C_0$$ Solution:

1. Separate variables: $\frac{dC}{C}=-kdt$.
2. Integrate: $\ln C=-kt+\ln C_0$.
3. Solve: $C(t)=C_0{e}^{-kt}$. Simulation (Python):

import numpy as np
import matplotlib.pyplot as plt

k, C0 = 0.2, 100  # decay rate, initial concentration
t = np.linspace(0, 20, 100)
C = C0 * np.exp(-k * t)

plt.plot(t, C, 'r-', label='C(t) = 100e^(-0.2t)')
plt.xlabel('Time (hours)')
plt.ylabel('Concentration (mg/L)')
plt.legend()
plt.grid()

Graph:

Example 2: Discrete – Inventory Management

Scenario: A shop orders 50 units every 2 weeks. Demand is 10 units/week with 5% variability. State Transition:

• States: $S_n$ = inventory at week $n$.
• Transitions:
  • $S_{n+1}=S_n-\text{demand}+\text{order}$ (if $S_n<\text{reorder}$).
• Simulation Steps:
  1. Start with $S_0=50$.
  2. Week 1: Demand = 10 → $S_1=40$.
  3. Week 2: Demand = 10.5 → $S_2=30$ (order 50) → $S_2=80$.

Mermaid Diagram:

flowchart LR
    A["Start: S₀=50"] --> B["Week 1: Demand=10 → S₁=40"]
    B --> C["Week 2: Demand=10.5 → S₂=30 → Order 50 → S₂=80"]
    C --> D["Week 3: Demand=9.5 → S₃=70.5"]

5. Hybrid Systems: Real-World Bridge

Example: Nepal’s NTC Electricity Grid

• Continuous: Voltage $V(t)$ in transmission lines (PDEs).
• Discrete: Switching stations (event-driven). Model:

1. Continuous: $L\frac{dI}{dt}+RI=V(t)$ (inductive load).
2. Discrete: At $t=t_{\text{peak}}$, open switch to reroute power.

Real Picture:

6. Advantages and Limitations

7. In the Real World

1. eSewa (Nepal):

   • Discrete System: Transaction processing as a queue.
     • States: Pending → Verified → Completed.
     • Simulation Use: Model peak-hour delays (e.g., Dashain sales) to optimize server capacity.
   • Worked Example: If 10,000 transactions arrive/hour and servers process 5,000/hour, the queue grows linearly until more servers are added.

2. Pathao (Ride-Hailing):

   • Hybrid System:
     • Continuous: Driver’s speed $v(t)$ (ODE: $\frac{dv}{dt}=a$).
     • Discrete: Ride requests (event-driven).
   • Simulation: Optimize driver dispatch to minimize wait times (e.g., during Kathmandu traffic jams).

3. Nepal’s NEPSE Stock Market:

   • Discrete Events: Buy/sell orders at specific prices.
   • Continuous: Stock price $P(t)$ modeled as a stochastic differential equation (SDE): $$dP(t)=\mu P(t)dt+\sigma P(t)dW(t)$$ where $W(t)$ is Wiener process (random walk).

8. Exam Tip

1. Differentiate Clearly:

   • Continuous: Use ODEs/PDEs, terms like "derivative," "smooth."
   • Discrete: Use difference equations, "state transitions," "events."
   • Example Question: "Model a thermostat’s temperature control as continuous or discrete. Justify." Answer: Continuous (temperature $T(t)$ changes smoothly; ODE: $\frac{dT}{dt}=k(T_{\text{set}}-T)$).

2. Hybrid Systems:

   • Look for mixed keywords: "digital control of a continuous process" (e.g., cruise control).
   • Example: "A chemical reactor has continuous flow but discrete valve openings. Model it."
     • Solution: ODE for temperature + event triggers for valve states.

3. Numerical Methods:

   • For ODEs, expect Euler’s method or Runge-Kutta in exams.
   • Example: Given $\frac{dy}{dt}=-0.1y$, $y(0)=100$, compute $y(10)$ using Euler with $\Delta t=2$.
     • Steps:
       1. $y_1=y_0+\Delta t\cdot f(t_0,y_0)=100+2\cdot (-0.1\cdot 100)=80$.
       2. Repeat for $t=2,4,\dots ,10$.

4. Validation:

   • Always check:
     • Steady-state: Does the system stabilize? (e.g., ${\lim }_{t\to \infty }T(t)=T_{\text{set}}$).
     • Transient response: How fast does it reach equilibrium?
   • Example: For a queue, validate by comparing simulated vs. real average wait times.

5. Tools:

   • Mention in answers: "Simulated in Python using scipy.integrate.odeint" or "Modeled in Simulink with S-function blocks."
   • Avoid: Writing code unless asked; focus on mathematical setup.

Final Note: Master the visual distinction between smooth curves (continuous) and step changes (discrete). Examiners test this with sketching questions—always draw the system’s behavior!