A PRACTICAL FILE

ON
OPERATION AND SIMULATION LAB
(IEA-551)

Submitted By:
Name: Udit Narain Gupta

Roll Number : 24205309

Submitted to: Prof Narendra Kumar

Industrial and Production Engineering Department

Dr. B R Ambedkar National Institute of Technology, Jalandhar

 Experiment 1
Objective
To estimate the value of pi (π) using the Monte Carlo method by generating random numbers and
analyzing the ratio of points inside a unit circle to the total number of points.

Theory
The value of pi can be estimated using a Monte Carlo simulation, a statistical technique that relies
on repeated random sampling. The key idea is to generate random points inside a square that
contains a quarter circle and determine how many of those points fall inside the quarter circle.

Consider a unit square (side length = 1) with a quarter circle of radius 1 inscribed within it. The
area of the square is 1 x 1 = 1, and the area of the quarter circle is π/4. The ratio of points that
land inside the quarter circle to the total points in the square will approximate π/4.

By multiplying this ratio by 4, we can estimate the value of pi:

π ≈ 4 * (Number of points inside the circle / Total number of points).

This method becomes more accurate as the number of random points increases.

Apparatus/Software Used
- Computer with Python/Java/C++ (any programming language that supports random number
generation)
- Random number generator function
- Visualization software (optional)

Procedure
1. Initialize a counter for points inside the quarter circle.
2. Generate random points within the unit square by producing random x and y coordinates
between 0 and 1.
3. For each point, calculate the distance from the origin (0,0) using the formula: Distance =
sqrt(x^2 + y^2).
4. If the distance is less than or equal to 1, the point lies inside the quarter circle, and the counter
is incremented.
5. Repeat the process for a large number of points (e.g., 10,000 or 100,000).
6. Estimate the value of pi using the formula: π ≈ 4 * (Number of points inside the circle / Total
number of points).
7. Compare the estimated value with the actual value of pi.

Observations
 Using Excel:-
  Using Code:-

1. For 2000 simulations: Value is 3.146

Error is 0.1403%
 2. For 100,000 simulations Value is 3.14528

Error is 0.1174%

Results
The estimated value of pi after running the simulation is :-

1. Calculated Value of Pi Using Excel : 3.168

2. Calculated Value of Pi Using Python : 3.146 for 2000

3.14528 for 100,000

Conclusion
The Monte Carlo method provides a simple yet effective way to estimate the value of pi. As the
number of random points increases, the estimated value converges towards the actual value of pi.
This experiment demonstrates the power of random sampling techniques in numerical
computation.
 Experiment 2

Objective
To estimate the area under the curve y = x^3 over a given interval [x1, x2] using the Monte Carlo
method by generating random numbers.

Theory
The Monte Carlo method is a statistical technique that estimates the area under a curve by
randomly generating points within a bounding rectangle that encapsulates the region under the
curve. The method works by calculating the ratio of points under the curve to the total points
within the rectangular region and scaling it according to the area of the rectangle.

The idea is as follows:

1. Define the region under the curve y = x^3 over the interval [x1, x2].
2. Draw a bounding rectangle around this region, where the width of the rectangle is x2 - x1, and
the height is max(x1^3, x2^3).
3. Generate random points within the bounding rectangle.
4. Count how many points fall below the curve y = x^3.
5. The ratio of the points below the curve to the total points inside the rectangle will estimate the
fraction of the rectangle's area that lies under the curve.

The area under the curve can be estimated using the formula:
Estimated Area ≈ (Number of points below the curve / Total number of points) * Area of the
rectangle.

Apparatus/Software Used
- Computer with Python
- Random number generator function
- Function for y = x^3

Procedure
1. Input: Obtain the interval [x1, x2] from the user.
2. Bounding Rectangle: The width of the rectangle is x2 - x1, and the height is max(x1^3, x2^3).
3. Generate a large number of random points within the bounding rectangle. For each point:
a. Generate a random x-coordinate between x1 and x2.
b. Generate a random y-coordinate between 0 and max(x1^3, x2^3).
4. For each random point, evaluate whether the point lies below the curve by checking if y ≤ x^3.
5. Count the number of points that lie below the curve.
6. Estimate the area under the curve using the formula: Estimated Area ≈ (Number of points
below the curve / Total number of points) * Area of the rectangle.
7. Compare the estimated area to the analytical value (if known).
Observations
Using Python:-

1. For 2000 Simulations

2. For 100,000 Simulations

Results
The estimated area under the curve y = x^3 over the interval [5,7] is approximately the calculated
to 453.446 while actual value is 444 so this is somehow accurate when taken for 2000 simulations
while when taken 100,000 simulations for the same range value comes out to be 442.847 which is
more accurate.

Conclusion
The Monte Carlo method effectively estimates the area under a curve through random sampling.
As the number of points increases, the estimated area becomes more accurate. This experiment
demonstrates how randomness and statistical methods can be applied to solve numerical
integration problems.
 Experiment 3

Objective
To compare two methods of bearing replacement on a machine with three bearings, and
determine which method is more efficient in terms of minimizing downtime and maximizing
bearing lifespan:

 Current Method: Replace only the bearing that fails.

 Proposed Method: Replace all three bearings when any one bearing fails.

Theory
Machines with multiple bearings experience wear and tear over time. When a bearing fails, it can
cause downtime and may lead to further machine damage. The current maintenance practice is to
replace only the failed bearing. The proposed method suggests replacing all three bearings
whenever one fails, assuming that if one fails, the others are likely to fail soon. The goal of this
experiment is to determine which method is more efficient in terms of total machine uptime and
bearing replacement frequency over a given period.

The total cost in terms of both downtime and bearing replacement can be modeled and compared
over multiple iterations. The proposed method should theoretically reduce long-term maintenance
costs and downtime by preemptively replacing all bearings.

Procedure
1. Set Parameters:

 Assume a machine with 3 bearings (Bearing 1, Bearing 2, and Bearing 3).

 Each bearing has a different lifespan, modeled by a random variable or a known
distribution (e.g., normally distributed or exponentially distributed with a mean failure
time).
 Track the machine uptime and downtime for both methods over a fixed period (e.g., 1000
machine cycles or hours).

2. Current Method (Replace One Bearing):

 Start with all bearings in good condition.

 As each bearing fails, replace only the failed bearing.
 Record the number of bearing replacements and the total downtime after each
replacement.
 Repeat this process over multiple cycles.

3. Proposed Method (Replace All Bearings):

 Start with all bearings in good condition.

  When any one bearing fails, replace all three bearings, even if the other two are still
operational.
 Record the number of bearing replacements and the total downtime after each full set
replacement.
 Repeat this process over the same number of cycles as in the current method.

4. Simulations:

 Run the simulation multiple times (e.g., 1000 iterations) for both methods to gather
sufficient data on replacement frequency, total downtime, and maintenance cost.
 Use random lifespans for the bearings to introduce variability in the simulations.

5. Evaluation Metrics:

 Number of Bearing Replacements: Track how many individual bearings or sets of

bearings are replaced over the simulation period.
 Total Downtime: Measure the total machine downtime caused by bearing failures and
subsequent replacements.
 Maintenance Cost: Consider both the direct cost of replacing bearings and the indirect
cost associated with machine downtime.

Observations
 Current Method:
- Individual bearings are replaced when they fail, leading to less immediate cost
but potentially more frequent machine downtime.
- Record how often the machine needs to be stopped and restarted after each
failure.

 Proposed Method:
- Replacing all three bearings at once results in a higher immediate cost for each
failure, but it reduces the overall frequency of failures.
- Track the longer periods between machine stoppages due to bearing failure.

Results
The results will be illustrated through simulation screenshots for both methods, showing key data
such as:

Through Python:
Screenshots of these simulations will visually compare the effectiveness of each method in
reducing downtime and improving overall machine performance.
Conclusion
From the simulated data, the screenshots will indicate the trends for the proposed method, which
is expected to show:

 Reduced overall downtime.

 Lower long-term maintenance cost.

 Increased machine uptime.

This will visually confirm that the proposed method is more efficient in maintaining machine
performance over the long term.
 Experiment 4

Objective
To determine the optimal number of newspapers to order each day in order to maximize profits
while minimizing losses due to unsold copies using the Monte Carlo simulation.

Theory
The Newspaper Inventory Problem is a classic example of inventory management under
uncertainty. The newspaper vendor must decide how many newspapers to order daily, given that
unsold newspapers will result in losses and unmet demand leads to lost sales opportunities.

Key factors involved:

1. Demand: Varies daily and follows a certain probability distribution.

2. Cost per newspaper (C): The cost incurred for each newspaper ordered.
3. Selling price per newspaper (S): The price at which each newspaper is sold.
4. Salvage value per unsold newspaper (V): The value of unsold newspapers (e.g., returned or
recycled).

The goal is to find the optimal order quantity that maximizes the vendor’s expected profit while
accounting for uncertain demand.

Using Monte Carlo simulation, we can model this scenario by:

1. Generating random demand for newspapers based on historical or assumed probability
distributions.
2. Calculating the daily profit based on the number of newspapers ordered, sold, and unsold.
3. Repeating this process for several iterations to estimate the optimal order quantity.

Apparatus/Software Used
• Computer with Python/Excel/Java/C++ (or any programming language supporting random
number generation).
• Random number generator function to simulate demand.
• Spreadsheet or visualization software for recording and analyzing results.

Procedure
1. Define Parameters: Set the cost per newspaper (C), selling price (S), and salvage value (V).
Define a demand probability distribution (e.g., uniform, normal, or based on historical data).
2. Simulate Random Demand: Generate random demand values for each day using the defined
probability distribution.
3. Calculate Profit for Each Order Quantity: For each order quantity Q, calculate:
• Revenue = min(Q, Demand) × S
• Cost = Q × C
• Salvage = max(0, Q - Demand) × V
 • Profit = Revenue - Cost + Salvage
4. Repeat Simulation: Repeat the process for several days (e.g., 1,000 or 10,000 iterations) for
various order quantities Q.
5. Determine Optimal Order Quantity: Identify the order quantity that yields the highest average
profit.

Observations
• For order quantity = 50 newspapers, simulated average profit is $X with X% of demand met.

• For order quantity = 75 newspapers, simulated average profit is $Y with Y% of demand met.
• For order quantity = 100 newspapers, simulated average profit is $Z with Z% of demand met.

Code:

Results
1. Optimal order quantity: Based on simulations, the optimal number of newspapers to order each
day is 70.
2. Profit and demand match: The best order quantity resulted in an average profit of $X with Y%
of demand satisfied.
Conclusion
The Monte Carlo method allows for effective simulation of uncertain demand in inventory
management problems. By running simulations over different order quantities, we can determine
the optimal order size that maximizes profits while accounting for demand variability. This
experiment highlights the power of Monte Carlo simulations in solving real-world inventory
management problems under uncertainty.
 Experiment 5

Objective
Analysis of Transportation problems using excel solver

Theory
The transportation problem is a type of linear programming model that aims to determine the
most cost-efficient way to distribute goods from multiple suppliers to multiple consumers while
minimizing transportation costs. It ensures that supply and demand constraints are met at each
source and destination.

Key Factors Involved in Solving the Transportation Problem:

1. Using Excel Solver:

 Objective Function: Define the total transportation cost to minimize.

 Constraints: Set up supply constraints for each source and demand constraints for each
destination.
 Decision Variables: Input cells representing the number of units shipped from each
source to each destination.
 Solver Setup: Use Excel’s Solver tool to specify the objective function, constraints, and
decision variables, and choose the Simplex LP method to find the optimal solution.

2. Using Python:

 Objective Function: Formulate the minimization of transportation costs using libraries

like PuLP or SciPy.
 Constraints: Implement supply and demand constraints using linear programming
formulations.
 Decision Variables: Define variables for the quantities shipped between each source and
destination.
 Optimization: Use Python optimization libraries (e.g., PuLP, Gurobi, SciPy) to solve the
linear program for optimal transport allocation.

Apparatus/Software Used
• MS Excel and Python interpreter

Procedure
Using Excel

 Open Excel and take a new blank sheet.

 Check if solver is available in Excel or not. If not available, go to File > option > add-in,
then select the solver add-in.
  Create a cost matrix, where respective cells represent unit cost or distance from each
source to destinations.
 The decisions to be made are the number of shipments from each plant to each
distribution centre.
 Now create another table to determine the shipment quantity with empty cell in place of
shipment.
 Add a new column for total shipped where we sum all the shipment from each Source to
different destinations. Also add a row for Total received where we sum the shipment each
destination received from different sources.
 Total cost should be sum-product of cost matrix with shipment matrix.
 Now open solver and set the total cost cell as objective functions and optimize (maximize
or minimize as per requirements of the problem).
 Select the shipment matrix as variable cells.
 Now add constraints where total shipped value should be less than or equal to supply and
total received cells must be equal to respective demand cells.
 Add non-negativity constraint as all shipment cell has to be greater than or equals to zero.
 Choose simplex method for solving, then solve.

Balanced Problem:

Cost Table
Solver
 Optimal Solution

Results
 From Factory 1 100 Units will be shipped to Customer 2.
 From Factory 2 100 Units will be shipped to Customer 2 and 100 units to Customer 3
 From Factory 3 200 Units will be shipped to Customer 1 and 100 units to Cystomer 3
 Total Cost is 26000Rs.

Unbalanced Problem:

Cost Table
Cost table with Dummy

Shipment Table

Solving Parameters
Results
 From O 1 15 Units will be shipped to D 2.
 From O 2 13 Units will be shipped to D 1 and 12 units to D 3
 From O 3 17 Units will be shipped to D 1, 5 units to D 2 and 20 units to D 5
 From O 4 3 Units will be shipped to D 3 and 10 units to D 4 and also 22 Units to Dummy
 Total Cost is $374

Using Python:

Open Jupyter Notebook and create a new python file.

• Import numpy.
• Define the cost matrix using np.array.
• Formulate the supply and demand, also ensure total supply equals total demand for a
balanced problem.
• Create constraints matrix, now using for loop, for each supplier i, the loop creates a
row in that matrix that ensures the total amount shipped from that source equals the
source’s supply value.
• In second loop for each destination j, it creates a row in constraint matrix that ensures
total amount received at destination must fulfil destinations demand.
• We define non negativity constraints.
• Using numpy and giving cost and all constraints within the function we solve the
transportation problem.
• We resize the solution as shipment matrix and print the output.

Transportation Problem Example:

 Suppliers: A, B

 Destinations: X, Y, Z

 Supply: A can supply 20 units, B can supply 30 units.

 Demand: X needs 10 units, Y needs 25 units, Z needs 15 units.

 Costs: Shipping cost from each supplier to each destination.

Python Code:
# Install PuLP if you haven't already

# !pip install pulp

import pulp

# Define data
suppliers = ['A', 'B']

destinations = ['X', 'Y', 'Z']

# Supply at each supplier

supply = {

'A': 20,

'B': 30

# Demand at each destination

demand = {

'X': 10,

'Y': 25,

'Z': 15

# Costs from each supplier to each destination

costs = {

('A', 'X'): 8,

('A', 'Y'): 6,

('A', 'Z'): 10,

('B', 'X'): 9,

('B', 'Y'): 12,

('B', 'Z'): 5

# Create the linear programming problem

problem = pulp.LpProblem("Transportation_Problem", pulp.LpMinimize)

# Decision variables: how much to transport from each supplier to each destination

variables = pulp.LpVariable.dicts("Route", (suppliers, destinations), lowBound=0,

cat='Continuous')
 # Objective function: Minimize the total transportation cost

problem += pulp.lpSum([variables[s][d] * costs[(s, d)] for s in suppliers for d in

destinations])

# Supply constraints: Total shipped from each supplier should not exceed their supply

for s in suppliers:

problem += pulp.lpSum([variables[s][d] for d in destinations]) <= supply[s],

f"Supply_{s}"

# Demand constraints: Total received by each destination should meet its demand

for d in destinations:

problem += pulp.lpSum([variables[s][d] for s in suppliers]) == demand[d],

f"Demand_{d}"

# Solve the problem

problem.solve()

# Print the results

print(f"Status: {pulp.LpStatus[problem.status]}")

print("Optimal transportation plan:")

for s in suppliers:

for d in destinations:

print(f"Transport {variables[s][d].varValue} units from {s} to {d}")

# Total transportation cost

print(f"Total transportation cost = {pulp.value(problem.objective)}")

Output:
Initial allocation:

[[ 0. 0. 10. 2.]

[ 0. 10. 0. 7.]

[10. 0. 0. 1.]]

Total Cost: 33,300

Conclusion
Using solver and python interpreter we successfully generate the shipment allocations and
optimizes the cost for both balanced and unbalanced problem. In balanced problem constraints
are satisfied and in unbalanced problem some allocations are made into the dummy destination.
 Experiment 6

Objective
To analyze a selected plant layout by modeling and simulating bottleneck and line balancing over
a 48-hour (2 days) period using FlexSim software, and to evaluate performance metrics such as
total parts processed, average time for dispatch, and work in progress (WIP). Bottleneck analysis
will be performed, and solutions will be suggested if bottlenecks are identified.

Theory
 Simulation: Simulation is a powerful tool for analyzing and optimizing complex
production systems. It enables users to model real-world processes and predict the
performance of different configurations. In this experiment, we simulate a manufacturing
plant layout in FlexSim to identify bottlenecks and improve line balancing.

Key factors involved in this simulation are machine capacities, processing times, and
queue lengths. These factors determine the efficiency of the production line and directly
affect the overall system performance. When a machine in the production line has a
significantly longer processing time than others, it can cause a bottleneck, slowing down
the entire system and reducing throughput.

 Line Balancing: Line balancing aims to distribute tasks evenly across all workstations to
minimize idle times and ensure smooth workflow. Each workstation should have similar
workloads to avoid overburdening any particular station. Proper line balancing helps
prevent bottlenecks and ensures maximum utilization of resources.
 Bottleneck Analysis: A bottleneck is a point in the production process where the
workflow slows down due to limited capacity or longer task duration. Identifying and
addressing bottlenecks is critical for increasing the efficiency of the entire production
line. In FlexSim, bottleneck analysis is performed by running simulations that track each
workstation's performance. By adjusting parameters such as machine processing times
and capacities, we can reduce idle times and eliminate bottlenecks.

The aim of this experiment is to simulate the production system for 48 hours and determine
which workstations are causing delays, and how to optimize the line for better performance.

Apparatus/Software Used
 FlexSim Simulation Software

 Computer with FlexSim installed

Task Executors/Resources and Parameters

1. Source: Input is unlimited.

2. Lathe: 1 unit, process time 7 minutes.

 3. Queue: 1 unit, capacity 1000.

4. Drill: 1 unit, process time 5 minutes.

5. Queue: 1 unit, capacity 1000.

6. CNC Machine: 1 unit, process time 5 minutes.

7. Queue: 1 unit, capacity 1000.

8. Mill: 1 unit, process time 10 minutes.

9. Transporter: 1 unit, at a time.

10. Sink: Output.

Procedure
1. Assign Operators: Each machine (lathe, drill, CNC machine, mill) is assigned an operator
for efficient processing.

2. Define the Plant Layout: Using FlexSim, model the production system as per the task
executors and parameters listed above.

3. Run the Simulation: Simulate the model for 48 hours (2880 minutes) and gather data on:

o Total parts arrived and dispatched.

o Average time required for part dispatch.

o Average work in progress (WIP).

o Machine utilization rates to check for bottlenecks.

4. Check for Bottlenecks: Analyze the data to identify if any station is causing a delay in the
workflow.

5. Suggest Solutions for Bottlenecks: If a bottleneck is detected, modify processing times,

add resources, or make other adjustments to resolve the issue. Re-run the simulation to
test the effectiveness of the changes.

Observations
By setting up and connecting the components properly and following the bottleneck identification
steps, you can effectively manage and optimize the system in FlexSim.
Bottleneck identification at Mill Machine.

After Proposed Solution:

 Results

Parameter Before After

Total Parts Arrived 242 242
Total Parts Dispatched 200 238
Average time to dispatch 2880/200 = 14.4 min 2880/238 = 12.1 min
a part
Average WIP 42 4
Bottleneck Occurred at Mill Machine -

Conclusion
Through simulation in FlexSim, key performance metrics were successfully measured, and
bottlenecks in the production process were identified and addressed. The mill was identified as
the main bottleneck due to its longer processing time. By reducing the processing time of the
mill, the system achieved better throughput and reduced queue lengths, demonstrating the
importance of bottleneck analysis and optimization in manufacturing systems.
 Experiment 7

Objective
Analysis and simulation for routing and scheduling for a duration of 8hours(1 shift) of selected
plant layout in Flexsim software.

Apparatus/Software Used
 FlexSim Simulation Software

 Computer with FlexSim installed

Procedure
1. Drag and Drop Components:
 Open the Library panel on the left and drag the Source, Processor, and
Sink objects onto the workspace.

2. Arrange Components in Sequence:

 Arrange the objects in a logical flow:
o Start with the Source (input station).
o Place one or more Processors (machines or workstations) in the
middle.
o End with the Sink (final destination or output).

3. Connect Components:
 Link the Source to Processors and then the Processors to the Sink using
the Connector Tool (right-click on each component and select
“Connect”).

4. Configure Components:
o Double-click on each object to adjust its settings:
 Source: Set the arrival rate and input type.
 Processor: Configure the processing time and capacity.
 Sink: No configuration is needed unless specific outputs are
required.
Routing and scheduling procedure:

Problem statement

1. Routing is the process of path selection in any network. Scheduling is the process of
arranging, controlling and optimizing work and workloads in a production process or
manufacturing process.
2. We have to perform the simulation for routing and scheduling for the plant layout having
3 HMC machines and 2 VMC machines and having a source, queue and sink.
3. We drag and release all objects from panel to the workplace, then we connect them using
connect objects function make sure that there is 1 queue connected to all machines and
having source at first and sink at last.
4. Open the source and keep arrival time at 2.5 and all machines are having the process time
10 minutes.
5. We are calculating simulation for 8 hours which we take in 480 minutes and keep this as
stop time.
6. Now we go to source and select triggers in that we select on creation and there we select”
set label by percentage” and “ set colour by case” functions.
7. Then we select the machines and select the flow function and there we have HMC
machine as type 1 and VMC machine as type 2 in pull requirement.
8. Now reset the process and run the process then we get the below output and input from
source and sink.
9. Then have the total arrived and dispatched.

10. Now go to the dashboard function and open blank dashboard there double click and select
the average work content then select and all 5 machines and execute.
Results

By using Flexsim we have calculated the routing and scheduling of plant having 8 hours working
time. The results are productive and more efficient.
 Experiment 8

Objective
Analysis of Linear Programming Problem using Excel Solver

Apparatus/Software Used
 MS Excel

Procedure
Using MS EXCEL:

1. Define the Problem:

• Identify the decision variables (e.g., quantities to be produced).
• Define the objective function (e.g., maximize profit or minimize cost).
• Determine the constraints (e.g., resource limitations or budget).
2. Set Up the Spreadsheet:
• Enter each decision variable in a separate cell (e.g., B2 and C2 for two
variables).
• Enter the coefficients of each variable for the objective function and constraints
in their respective cells.
3. Formulate the Objective Function:
• In a designated cell, calculate the objective function by creating a formula that
multiplies each variable by its coefficient and sums the results.
4. Define Constraints:
• For each constraint, set up a formula that calculates the left side of the
inequality, using the decision variables and their respective coefficients.
• Place the right-hand values (constraints) in separate cells.
5. Open Excel Solver:
• Go to Data > Solver (If Solver isn’t available, enable it via File > Options >
Add-ins > Manage Excel Add-ins**).
6. Set Up Solver Parameters:
• Set Objective: Choose the cell that contains the objective function.
• To: Select either "Max" or "Min" depending on whether you want to maximize
or minimize the objective.
• By Changing Variable Cells: Select the cells where your decision variables are
located.
• Add Constraints: For each constraint:
• Click Add to open the constraint dialog box.
• Choose the cell with the left-hand side calculation, select the inequality sign,
and set it equal to the right-hand side constraint cell.
• Choose a Solving Method: For LP, select Simplex LP.
7. Run Solver:
 • Click Solve and review the solution provided by Solver.
8. Analyze Results:
• After Solver finishes, check whether a feasible solution was found and if the
objective was optimized as desired.
• Review the **Sensitivity Report** (optional) to understand the impact of each
constraint and variable on the solution.

This should give you the optimal solution within your defined constraints!

Maximization and Minimization problem result::

Maximization plot using Excel:

Conclusion:
We successfully solved both maximization and minimization type linear programming problems
and verified successfully using Excel solver.
 Experiment 9

Objective
Simulation of material handling using task executer and conveyor belt in flexsim.

Apparatus/Software Used
 Flexsim Software

Procedure

Material handling simulation using task executer

1. Define Objectives: Clearly outline the goals of the simulation, such as improving
efficiency, reducing costs, or enhancing safety.

2. Model Setup: Create a digital representation of the material handling system, including
all relevant objects like conveyors, storage units, and Task Executers.

3. Task Sequences: Develop task sequences for Task Executers, specifying actions like
loading, unloading, and transporting items.

4. Simulation Parameters: Set parameters such as maximum speed, acceleration, and

deceleration for Task Executers.

5. Run Simulation: Execute the simulation to observe the behavior of the system under
various conditions.

6. Data Collection: Gather data on key performance indicators like throughput, cycle
time, and resource utilization.

7. Analysis: Analyze the collected data to identify bottlenecks, inefficiencies, and areas
for improvement.

8.Taking a problem on plant layout for material handling having 8 hours of shift duration
with double shift for 3 days

9.we setup model using source, sink, queue and task executer as shown in figure.

10.we setup the AGV which is automatic guided vehicles for this operation and give the
specifications.

11.we then run the model and take average content from the dashboards
Material handling simulation using conveyor belt
1. Define Objectives:
Identify the goals of the simulation, such as improving throughput, reducing
bottlenecks, or enhancing safety.
2. Model Setup:
Create Environment: Build the digital layout of the facility, including all relevant
components like conveyors, sensors, and stations.
Add Conveyor Belts: Place conveyor belts in the model, specifying their length, width,
speed, and other parameters.
Configure Task Executers: If applicable, set up any task executers (e.g., robotic arms,
workers) that interact with the conveyor system.
Define Work Stations: Position workstations along the conveyor where tasks like
assembly, inspection, or packaging occur.
3. Define Flow Logic:
Product Flow: Determine the flow logic for products on the conveyor, including entry
points, routing, and exit points.
Task Sequences: Develop task sequences for task executers or operators interacting
with the conveyor.
Control Mechanisms: Set up sensors and control mechanisms to manage conveyor
operations (e.g., start/stop triggers, diverting mechanisms).
4. Set Parameters:
Speed and Timing: Define the speed of conveyor belts and timing for various
processes.
Capacity and Load: Set the capacity of each conveyor belt and the load it can handle.
5. Run Simulation:
Execute the simulation to observe the behavior of the conveyor system under different
scenarios.
6. Data Collection:
Collect data on key performance indicators like throughput, cycle time, and resource
utilization.
Track the movement and processing times of products on the conveyor.
7. Analysis:
Analyze the collected data to identify bottlenecks, inefficiencies, and areas for
improvement.
Use the analysis to adjust the model and re-run simulations as needed.
Using Task executer
Using conveyor belt

Result : material handling is simulated using flexsim and outputs are 957 for 959 input
in taskexecuter and 153 for 157 input which are optimal.

Conclusion:
Summary for task executer model: Summarize the outcomes of the simulation,
highlighting any improvements or issues identified.
Summary For conveyor belt model:
Present the outcomes of the simulation, highlighting any improvements in throughput,
cycle time, or resource utilization.
Bottlenecks and Issues:
Identify any bottlenecks or inefficiencies discovered during the simulation.
 Experiment 10

Objective
Optimizing Shipment Location Using GRG Nonlinear Solver in MS Excel

Apparatus/Software Used
 Flexsim software.

Procedure

1. Data Collection and Preparation:

a. Input the latitude and longitude values for each city in an Excel table.
b. Include shipment volumes and calculate the cost per city using a
predefined cost formula based on the distance and shipment size.
2. Defining Decision Variables:
a. Introduce cells for the latitude and longitude of the warehouse locations
(e.g., WAREHOUSE1, WAREHOUSE2) as decision variables.
3. Objective Function Setup:
a. Define the objective function in Excel to minimize the total shipment
cost: Total Cost=∑(Minimum Distance×Shipment Volume)\text{Total
Cost} = \sum (\text{Minimum Distance} \times \text{Shipment
Volume})Total Cost=∑(Minimum Distance×Shipment Volume)
b. Use the "MIN(DISTANCE1, DISTANCE2)" formula to select the
minimum distance for each city.
4. Setting Up Solver:
a. Open the Solver tool in Excel and configure the settings:
i. Set the objective to minimize the TOTAL COST cell.
ii. Define the warehouse latitude and longitude cells as "By Changing
Variable Cells."
iii. Select GRG Nonlinear as the solving method.
5. Adding Constraints:
a. Ensure that warehouse coordinates remain within realistic geographic
ranges based on the dataset.
6. Run the Solver:
a. Execute Solver to find the optimal warehouse locations that minimize total
cost.
b. Record the optimal coordinates of WAREHOUSE1 and
WAREHOUSE2.
7. Validation:
a. Cross-verify the total cost calculation using the optimized results.
b. Analyze whether further constraints or modifications are required for
better results.
EXCEL SHEET

OBSERVATIONS :

1.Location 1:
2. Location 2

Conclusion:
The optimum locations are in Rechhera, Madhya Pradesh and Gowdahalli, Karnataka
 Experiment 11

Objective
To generate various probability distributions using random variates and plot their histograms to
understand the behavior of these distributions.

Apparatus/Software Used
 MS Excel

Procedure

1. Setup in MS Excel:
a. Open a new Excel worksheet.
b. Generate a column of 500 random numbers using the Excel function
=RAND(). This column will serve as the base uniform distribution
(U(0,1)U(0, 1)U(0,1)).
2. Transforming Uniform Distribution into Desired Distributions:

Using the random variates generated, apply the following transformations to create
specific probability distributions:

a) Exponential Distribution:

a. Formula: X=−ln⁡(1−U)/λX = -\ln(1 - U) / \lambdaX=−ln(1−U)/λ, where

UUU is the uniform random variable, and λ\lambdaλ is the rate parameter
(e.g., λ=1\lambda = 1λ=1).

b. Add a column in Excel with the formula: =-LN(1-A1)/1, where A1

contains the uniform random number.

b) Weibull Distribution:

a. Formula: X=α×(−ln⁡(1−U))1/βX = \alpha \times (-\ln(1 - U))^{1/\

beta}X=α×(−ln(1−U))1/β, where α\alphaα is the scale parameter and β\
betaβ is the shape parameter.
b. In Excel, use the formula: =BETA*(-LN(1-A1))^(1/ALPHA).

c) Hyperexponential Distribution:

a. For a mixture of exponential distributions, decide on probabilities

p1,p2p_1, p_2p1 ,p2 (e.g., p1=0.5,p2=0.5p_1 = 0.5, p_2 = 0.5p1 =0.5,p2
=0.5) and corresponding rates λ1,λ2\lambda_1, \lambda_2λ1 ,λ2 .
 b. Use a nested IF function in Excel to assign random values based on
probabilities, e.g., =IF(A1 < 0.5, -LN(1-A1)/LAMBDA1,
-LN(1-A1)/LAMBDA2).
3. Generating Histograms:
a. After transforming the data into the desired distributions:
i. Select the data for the specific distribution.
ii. Use Insert > Charts > Histogram in Excel to plot the histogram
for each distribution.
iii. Adjust the bin size for clarity.
4. Customizing the Histograms:
a. Label the axes:
i. X-axis: Values of the random variable.
ii. Y-axis: Frequency.
b. Add a title indicating the distribution type (e.g., "Exponential
Distribution", "Weibull Distribution").
5. Repeat for All Distributions:
a. Generate, transform, and plot histograms for each distribution
(Exponential, Weibull, and Hyperexponential).

OBSERVATIONS PLOTS AND EXCEL SHEETS

1. Weibull distribution
2. Uniform Distribution

3.Normal Distribtuion
4. Exponential Distribution

Conclusion:
The experiment demonstrated how to generate and analyze different probability distributions
using random variates in MS Excel.

1. Uniform Distribution: Provided a base distribution using =RAND() to transform into

other types.

2. Exponential Distribution: Showed a rapid decline in values, illustrating the memoryless

property.

3. Weibull Distribution: Modeled various real-world scenarios like reliability and failure
times through adjustable parameters.

4. Hyperexponential Distribution: Successfully represented mixed processes with varying

rates.

This experiment highlights the versatility of Excel for simulating and visualizing probability
distributions, aiding in understanding their applications in real-world modeling.