Simulation Basics: Definitions, Types, Models & Applications

What is Simulation?

Simulation is the process of creating a virtual model of a real-world system to study its behavior under different conditions. Instead of building physical prototypes or running experiments on actual systems (which can be expensive, time-consuming, or dangerous), simulations allow engineers, scientists, and businesses to test hypotheses, optimize performance, and predict outcomes.

Why Use Simulation?

• Cost-effective: Avoids building physical prototypes (e.g., testing a new car design virtually).
• Safe: No risk of damage or injury (e.g., simulating a chemical reaction before running it in a lab).
• Time-saving: Run thousands of experiments in seconds (e.g., testing traffic flow in Kathmandu before building new roads).
• Flexibility: Easily change variables to see how they affect the system (e.g., adjusting loan interest rates in a bank’s financial model).

Types of Simulation

Simulations can be classified based on the nature of the system being modeled and the time representation. The two primary categories are:

Visual: Discrete vs. Continuous Systems

graph LR
    A["System Type"] --> B["Discrete"]
    A --> C["Continuous"]
    B --> D["Events occur at distinct times"]
    B --> E["Example: Customer arrivals in a bank"]
    C --> F["Changes occur continuously"]
    C --> G["Example: Temperature rise in a room"]

Key Components of a Simulation

A simulation consists of three main parts:

1. Model: A mathematical or logical representation of the real system (e.g., a queueing model for eSewa transactions).
2. Experiment: Running the model under specific conditions (e.g., simulating 1000 customers per hour in a bank).
3. Validation: Ensuring the model accurately represents reality (e.g., comparing simulated traffic times with real data from NTC).

How Simulations Work: A Step-by-Step Process

Simulations follow a structured pipeline. Here’s how it works in practice:

flowchart LR
    A["Define Problem"] --> B["Build Model"]
    B --> C["Collect Data"]
    C --> D["Run Simulation"]
    D --> E["Analyze Results"]
    E --> F["Validate Model"]
    F --> G["Refine & Repeat"]

Worked Example: Simulating a Bank Loan Approval System

Scenario: A bank wants to simulate how many loan applications it can process per day. Assume:

• Arrival rate of customers: 5 per hour (Poisson distribution).
• Service time per customer: 10 minutes (exponential distribution).
• Bank opens for 8 hours/day.

Steps:

1. Model the Queue:
   • Customers arrive randomly at a rate of 5/hour.
   • Each customer takes 10 minutes to be served.
2. Run the Simulation:
   • Simulate 8 hours of operation.
   • Track the number of customers in the queue and waiting time.
3. Analyze Results:
   • Average waiting time: ~20 minutes.
   • Maximum queue length: 8 customers.

Real-World Tie-In: This is exactly how Nabil Bank or Global IME Bank might test their loan processing efficiency before expanding branches. Simulations help them decide whether to hire more staff or optimize their workflow.

Applications of Simulation in Nepal and Globally

In the Real World

1. eSewa & Khalti (Digital Payments):

   • Idea Used: Queuing Simulation
   • How: These apps simulate millions of transactions per day to predict server load and prevent crashes during festivals (e.g., Dashain or Tihar). By modeling user behavior, they ensure smooth payment processing even during peak hours.

2. Pathao (Ride-Hailing):

   • Idea Used: Discrete-Event Simulation
   • How: Pathao uses simulations to optimize driver-customer matching. For example, if a simulation shows that 60% of rides in Kathmandu take less than 15 minutes, they can adjust surge pricing dynamically to balance supply and demand.

3. NTC (Traffic Management):

   • Idea Used: Continuous Simulation
   • How: NTC simulates traffic flow in Kathmandu to predict congestion hotspots. For instance, if a simulation shows that traffic on the Ring Road slows to 10 km/h during 7–9 AM, they can adjust signal timings or suggest alternative routes via their app.

Visual: Simulation in Traffic Management (Kathmandu Example)

graph TD
    A["Traffic Simulation Model"] --> B["Input: Road Network"]
    A --> C["Input: Vehicle Arrival Rates"]
    A --> D["Input: Signal Timings"]
    B --> E["Output: Congestion Map"]
    C --> E
    D --> E
    E --> F["Action: Adjust Signals or Add Lanes"]

Advantages and Disadvantages of Simulation

Common Simulation Techniques

1. Monte Carlo Simulation:

   • Uses random sampling to model uncertainty (e.g., predicting stock prices or insurance risks).
   • Example: Simulating how many Daraz orders might be canceled due to delayed deliveries.

2. Agent-Based Modeling (ABM):

   • Models interactions between autonomous agents (e.g., pedestrians in a mall or ants in a colony).
   • Example: Simulating how people move during a festival like Indra Jatra to design safer crowd control.

3. System Dynamics:

   • Models feedback loops in complex systems (e.g., economic growth or disease spread).
   • Example: Simulating how interest rate changes affect Nepal’s GDP.

Real Picture: A Simulation Output (Traffic Flow)

Verification vs. Validation

These are critical steps to ensure a simulation is useful:

• Verification: Are the equations and code implemented correctly? (e.g., checking if the queueing model’s math is correct).
• Validation: Does the model accurately represent the real system? (e.g., comparing simulated traffic times with real GPS data from Ncell).

Worked Example: Validating a Pendulum Simulation

1. Build the Model:
   • Equation: $\theta (t)={\theta }_0\cos (\sqrt{\frac{g}{L}}t)$, where ${\theta }_0$ is initial angle, $g$ is gravity, and $L$ is pendulum length.
2. Verify:
   • Check if the code correctly solves the differential equation.
3. Validate:
   • Compare simulated swing times with a real pendulum (IMAGE: "simple pendulum experiment setup" | A lab photo of a pendulum with a protractor and stopwatch).
   • If simulated period = 2.0 sec and real period = 2.1 sec, the model is 85% accurate and may need refinement.

Exam Tip

For exams like Pokhara University (PU) or Tribhuvan University (TU), focus on:

1. Definitions: Know the difference between discrete and continuous simulations.
2. Applications: Be ready to explain how simulations are used in banking (loan processing), logistics (Pathao/Daraz), or traffic (NTC).
3. Worked Examples: Practice calculating queue lengths, waiting times, or probabilities (e.g., "A call center receives 20 calls/hour; agents take 3 minutes per call. What’s the average wait time?").
4. Validation: Always justify why a model is valid or invalid (e.g., "This traffic model is invalid because it ignores pedestrian crossings").
5. Diagrams: Draw flowcharts for simulation pipelines or timelines for discrete events.

Common Pitfalls to Avoid

• Overcomplicating the Model: Start simple (e.g., model a bank queue as M/M/1 before adding priorities).
• Ignoring Randomness: Use random number generators for realistic simulations (e.g., customer arrival times).
• Skipping Validation: Always compare simulation results with real data.

Summary Table: Key Concepts