Cycle Time Calculator

def cycle_time(available_time, required_output, uptime_pct=100):
    """
    Calculate cycle time for a production system.
    available_time: Total available production time (minutes)
    required_output: Number of units to produce (units)
    uptime_pct: Equipment uptime percentage (0-100)
    Returns:
        Cycle time (minutes/unit)
    """
    if available_time <= 0 or required_output <= 0:
        raise ValueError("Time and output must be positive.")
    if not (0 < uptime_pct <= 100):
        raise ValueError("Uptime must be between 0 and 100.")

    effective_time = available_time * (uptime_pct / 100)
    return effective_time / required_output

def takt_time(available_time, customer_demand):
    """
    Calculate takt time - the rate at which you must produce
    to meet customer demand.
    """
    if available_time <= 0 or customer_demand <= 0:
        raise ValueError("Time and demand must be positive.")
    return available_time / customer_demand

def throughput(cycle_time):
    """Calculate throughput (units per minute)."""
    if cycle_time <= 0:
        raise ValueError("Cycle time must be positive.")
    return 1 / cycle_time

def efficiency(takt_time, cycle_time):
    """Calculate line efficiency (takt/cycle ratio)."""
    if takt_time <= 0:
        raise ValueError("Takt time must be positive.")
    return (takt_time / cycle_time) * 100

def identify_bottleneck(stations):
    """
    Identify the bottleneck station (longest cycle time).
    stations: list of (name, time) tuples
    """
    return max(stations, key=lambda x: x[1])

# Example
available_time = 450  # minutes
required_output = 300  # units
demand = 280  # units
uptime = 90  # %

CT = cycle_time(available_time, required_output, uptime)
TT = takt_time(available_time, demand)
TP = throughput(CT)
EFF = efficiency(TT, CT)

stations = [
    ("Station 1", 1.2),
    ("Station 2", 1.8),
    ("Station 3", 1.5),
    ("Station 4", 2.1),
    ("Station 5", 1.4),
]
BN = identify_bottleneck(stations)

print(f"Cycle Time: {CT:.3f} min/unit")
print(f"Takt Time: {TT:.3f} min/unit")
print(f"Throughput: {TP:.3f} units/min")
print(f"Efficiency: {EFF:.1f}%")
print(f"Bottleneck: {BN[0]} ({BN[1]:.2f} min)")

function [CT, TT, TP, EFF] = cycle_time_analysis(T, N, D, U)
% Cycle Time Analysis
% T = Available production time (minutes)
% N = Required output (units)
% D = Customer demand (units)
% U = Uptime percentage (0-100)

    if T <= 0 || N <= 0 || D <= 0
        error('Time and quantities must be positive.');
    end
    if U <= 0 || U > 100
        error('Uptime must be between 0 and 100.');
    end

    effective_time = T * (U / 100);
    CT = effective_time / N;
    TT = T / D;
    TP = 1 / CT;
    EFF = (TT / CT) * 100;
end

% Example
T = 450;
N = 300;
D = 280;
U = 90;

[CT, TT, TP, EFF] = cycle_time_analysis(T, N, D, U);

fprintf('Cycle Time: %.3f min/unit\n', CT);
fprintf('Takt Time: %.3f min/unit\n', TT);
fprintf('Throughput: %.3f units/min\n', TP);
fprintf('Efficiency: %.1f%%\n', EFF);

% Bottleneck analysis
stations = [1.2, 1.8, 1.5, 2.1, 1.4];
[max_time, bn_idx] = max(stations);
fprintf('Bottleneck: Station %d (%.2f min)\n', bn_idx, max_time);