import numpy as np
import matplotlib.pyplot as plt
def failure_rate_curve(time, infant_mortality_rate, random_failure_rate, wear_out_start, wear_out_slope):
"""
Generate a failure rate curve with infant mortality, random failure, and wear-out periods.
:param time: Time array
:param infant_mortality_rate: Initial failure rate for the infant mortality period
:param random_failure_rate: Constant failure rate for the random failure period
:param wear_out_start: Time when the wear-out period starts
:param wear_out_slope: Slope of the failure rate increase in the wear-out period
:return: Failure rate array
"""
failure_rate = np.zeros_like(time)
# Infant mortality period
infant_mortality_end = 0.1 * max(time)
failure_rate[time < infant_mortality_end] = infant_mortality_rate / np.sqrt(time[time < infant_mortality_end])
# Random failure period
failure_rate[(time >= infant_mortality_end) & (time < wear_out_start)] = random_failure_rate
# Wear-out period
failure_rate[time >= wear_out_start] = random_failure_rate + wear_out_slope * (time[time >= wear_out_start] - wear_out_start)
return failure_rate
# Parameters
duration = 1000 # Total time in hours
sampling_rate = 100 # Number of points
time = np.linspace(1, duration, sampling_rate) # Time array
# Failure rate parameters
infant_mortality_rate = 0.02 # Initial failure rate
random_failure_rate = 0.005 # Constant failure rate during random failure period
wear_out_start = 700 # Start of the wear-out period
wear_out_slope = 0.0001 # Slope of the failure rate increase in the wear-out period
# Generate failure rate curve
failure_rate = failure_rate_curve(time, infant_mortality_rate, random_failure_rate, wear_out_start, wear_out_slope)
# Plot the failure rate curve
plt.figure(figsize=(10, 6))
plt.plot(time, failure_rate, label='Failure Rate')
plt.title('Bathtub Curve: Failure Rate over Time')
plt.xlabel('Time [hours]')
plt.ylabel('Failure Rate')
plt.ylim(0, max(failure_rate) * 1.1)
plt.grid()
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
def failure_rate_curve(time, infant_mortality_rate, random_failure_rate, wear_out_start, wear_out_slope):
"""
Generate a failure rate curve with infant mortality, random failure, and wear-out periods.
:param time: Time array
:param infant_mortality_rate: Initial failure rate for the infant mortality period
:param random_failure_rate: Constant failure rate for the random failure period
:param wear_out_start: Time when the wear-out period starts
:param wear_out_slope: Slope of the failure rate increase in the wear-out period
:return: Failure rate array
"""
failure_rate = np.zeros_like(time)
# Infant mortality period
infant_mortality_end = 0.1 * max(time)
failure_rate[time < infant_mortality_end] = infant_mortality_rate / np.sqrt(time[time < infant_mortality_end])
# Random failure period
failure_rate[(time >= infant_mortality_end) & (time < wear_out_start)] = random_failure_rate
# Wear-out period
failure_rate[time >= wear_out_start] = random_failure_rate + wear_out_slope * (time[time >= wear_out_start] - wear_out_start)
return failure_rate
def reliability_function(failure_rate, time):
"""
Calculate the reliability function R(t) from the failure rate.
:param failure_rate: Array of failure rates
:param time: Array of time values
:return: Reliability function R(t)
"""
cumulative_hazard = np.cumsum(failure_rate) * (time[1] - time[0])
return np.exp(-cumulative_hazard)
def unreliability_function(reliability):
"""
Calculate the unreliability function F(t) from the reliability function.
:param reliability: Array of reliability values
:return: Unreliability function F(t)
"""
return 1 - reliability
# Parameters
duration = 1000 # Total time in hours
sampling_rate = 1000 # Number of points
time = np.linspace(1, duration, sampling_rate) # Time array
# Failure rate parameters
infant_mortality_rate = 0.02 # Initial failure rate
random_failure_rate = 0.005 # Constant failure rate during random failure period
wear_out_start = 700 # Start of the wear-out period
wear_out_slope = 0.0001 # Slope of the failure rate increase in the wear-out period
# Generate failure rate curve
failure_rate = failure_rate_curve(time, infant_mortality_rate, random_failure_rate, wear_out_start, wear_out_slope)
# Calculate reliability and unreliability functions
reliability = reliability_function(failure_rate, time)
unreliability = unreliability_function(reliability)
# Plot the failure rate, reliability function, and unreliability function
plt.figure(figsize=(12, 8))
plt.subplot(3, 1, 1)
plt.plot(time, failure_rate, label='Failure Rate')
plt.title('Failure Rate Curve')
plt.xlabel('Time [hours]')
plt.ylabel('Failure Rate')
plt.grid()
plt.legend()
plt.subplot(3, 1, 2)
plt.plot(time, reliability, label='Reliability Function R(t)', color='green')
plt.title('Reliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Reliability')
plt.grid()
plt.legend()
plt.subplot(3, 1, 3)
plt.plot(time, unreliability, label='Unreliability Function F(t)', color='red')
plt.title('Unreliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Unreliability')
plt.grid()
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import cumtrapz
def failure_rate_curve(time, infant_mortality_rate, random_failure_rate, wear_out_start, wear_out_slope):
failure_rate = np.zeros_like(time)
infant_mortality_end = 0.1 * max(time)
failure_rate[time < infant_mortality_end] = infant_mortality_rate / np.sqrt(time[time < infant_mortality_end])
failure_rate[(time >= infant_mortality_end) & (time < wear_out_start)] = random_failure_rate
failure_rate[time >= wear_out_start] = random_failure_rate + wear_out_slope * (time[time >= wear_out_start] - wear_out_start)
return failure_rate
def reliability_function(failure_rate, time):
cumulative_hazard = cumtrapz(failure_rate, time, initial=0)
return np.exp(-cumulative_hazard)
def unreliability_function(reliability):
return 1 - reliability
def pdf_from_reliability(reliability, time):
return -np.gradient(reliability, time)
def cumulative_hazard_function(failure_rate, time):
return cumtrapz(failure_rate, time, initial=0)
# Parameters
duration = 1000 # Total time in hours
sampling_rate = 1000 # Number of points
time = np.linspace(1, duration, sampling_rate) # Time array
# Failure rate parameters
infant_mortality_rate = 0.02 # Initial failure rate
random_failure_rate = 0.005 # Constant failure rate during random failure period
wear_out_start = 700 # Start of the wear-out period
wear_out_slope = 0.0001 # Slope of the failure rate increase in the wear-out period
# Generate failure rate curve
failure_rate = failure_rate_curve(time, infant_mortality_rate, random_failure_rate, wear_out_start, wear_out_slope)
# Calculate reliability, unreliability, PDF, and cumulative hazard functions
reliability = reliability_function(failure_rate, time)
unreliability = unreliability_function(reliability)
pdf = pdf_from_reliability(reliability, time)
cumulative_hazard = cumulative_hazard_function(failure_rate, time)
# Plotting
plt.figure(figsize=(12, 12))
plt.subplot(3, 2, 1)
plt.plot(time, failure_rate, label='Failure Rate')
plt.title('Failure Rate Function')
plt.xlabel('Time [hours]')
plt.ylabel('Failure Rate')
plt.grid()
plt.legend()
plt.subplot(3, 2, 2)
plt.plot(time, reliability, label='Reliability Function R(t)', color='green')
plt.title('Reliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Reliability')
plt.grid()
plt.legend()
plt.subplot(3, 2, 3)
plt.plot(time, unreliability, label='Unreliability Function F(t)', color='red')
plt.title('Unreliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Unreliability')
plt.grid()
plt.legend()
plt.subplot(3, 2, 4)
plt.plot(time, pdf, label='PDF', color='purple')
plt.title('Probability Density Function (PDF)')
plt.xlabel('Time [hours]')
plt.ylabel('Probability Density')
plt.grid()
plt.legend()
plt.subplot(3, 2, 5)
plt.plot(time, cumulative_hazard, label='Cumulative Hazard Function', color='orange')
plt.title('Cumulative Hazard Function')
plt.xlabel('Time [hours]')
plt.ylabel('Cumulative Hazard')
plt.grid()
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import expon
def exponential_failure_rate(mean_lifetime, time):
return np.full_like(time, 1/mean_lifetime)
def reliability_function_exponential(failure_rate, time):
return np.exp(-failure_rate * time)
def unreliability_function_exponential(reliability):
return 1 - reliability
def pdf_exponential(failure_rate, time):
return failure_rate * np.exp(-failure_rate * time)
def cumulative_hazard_function_exponential(failure_rate, time):
return failure_rate * time
# Parameters
mean_lifetime = 200 # Mean time to failure (MTTF) in hours
duration = 1000 # Total time in hours
sampling_rate = 1000 # Number of points
time = np.linspace(0, duration, sampling_rate) # Time array
# Generate exponential failure rate
failure_rate = exponential_failure_rate(mean_lifetime, time)
# Calculate reliability, unreliability, PDF, and cumulative hazard functions for exponential distribution
reliability = reliability_function_exponential(1/mean_lifetime, time)
unreliability = unreliability_function_exponential(reliability)
pdf = pdf_exponential(1/mean_lifetime, time)
cumulative_hazard = cumulative_hazard_function_exponential(1/mean_lifetime, time)
# Plotting
plt.figure(figsize=(12, 12))
plt.subplot(3, 2, 1)
plt.plot(time, failure_rate, label='Failure Rate')
plt.title('Failure Rate Function')
plt.xlabel('Time [hours]')
plt.ylabel('Failure Rate')
plt.grid()
plt.legend()
plt.subplot(3, 2, 2)
plt.plot(time, reliability, label='Reliability Function R(t)', color='green')
plt.title('Reliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Reliability')
plt.grid()
plt.legend()
plt.subplot(3, 2, 3)
plt.plot(time, unreliability, label='Unreliability Function F(t)', color='red')
plt.title('Unreliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Unreliability')
plt.grid()
plt.legend()
plt.subplot(3, 2, 4)
plt.plot(time, pdf, label='PDF', color='purple')
plt.title('Probability Density Function (PDF)')
plt.xlabel('Time [hours]')
plt.ylabel('Probability Density')
plt.grid()
plt.legend()
plt.subplot(3, 2, 5)
plt.plot(time, cumulative_hazard, label='Cumulative Hazard Function', color='orange')
plt.title('Cumulative Hazard Function')
plt.xlabel('Time [hours]')
plt.ylabel('Cumulative Hazard')
plt.grid()
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm, lognorm, weibull_min
# Parameters for distributions
mean_lifetime = 200 # Mean lifetime for normal distribution
std_dev = 50 # Standard deviation for normal distribution
shape_param = 1.5 # Shape parameter for Weibull distribution
scale_param = 200 # Scale parameter for Weibull distribution
mu = np.log(mean_lifetime) # Mu for log-normal distribution (natural log of mean)
sigma = 0.3 # Sigma for log-normal distribution
duration = 500 # Total time in hours
sampling_rate = 1000 # Number of points
time = np.linspace(1, duration, sampling_rate) # Time array
# Normal Distribution
pdf_normal = norm.pdf(time, mean_lifetime, std_dev)
cdf_normal = norm.cdf(time, mean_lifetime, std_dev)
reliability_normal = 1 - cdf_normal
# Log-Normal Distribution
pdf_lognormal = lognorm.pdf(time, sigma, scale=np.exp(mu))
cdf_lognormal = lognorm.cdf(time, sigma, scale=np.exp(mu))
reliability_lognormal = 1 - cdf_lognormal
# Weibull Distribution
pdf_weibull = weibull_min.pdf(time, shape_param, scale=scale_param)
cdf_weibull = weibull_min.cdf(time, shape_param, scale=scale_param)
reliability_weibull = 1 - cdf_weibull
# Plotting
plt.figure(figsize=(18, 12))
# Normal Distribution
plt.subplot(3, 2, 1)
plt.plot(time, pdf_normal, label='Normal PDF', color='blue')
plt.title('Normal Distribution - PDF')
plt.xlabel('Time [hours]')
plt.ylabel('Probability Density')
plt.grid()
plt.legend()
plt.subplot(3, 2, 2)
plt.plot(time, reliability_normal, label='Normal Reliability Function R(t)', color='green')
plt.title('Normal Distribution - Reliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Reliability')
plt.grid()
plt.legend()
# Log-Normal Distribution
plt.subplot(3, 2, 3)
plt.plot(time, pdf_lognormal, label='Log-Normal PDF', color='blue')
plt.title('Log-Normal Distribution - PDF')
plt.xlabel('Time [hours]')
plt.ylabel('Probability Density')
plt.grid()
plt.legend()
plt.subplot(3, 2, 4)
plt.plot(time, reliability_lognormal, label='Log-Normal Reliability Function R(t)', color='green')
plt.title('Log-Normal Distribution - Reliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Reliability')
plt.grid()
plt.legend()
# Weibull Distribution
plt.subplot(3, 2, 5)
plt.plot(time, pdf_weibull, label='Weibull PDF', color='blue')
plt.title('Weibull Distribution - PDF')
plt.xlabel('Time [hours]')
plt.ylabel('Probability Density')
plt.grid()
plt.legend()
plt.subplot(3, 2, 6)
plt.plot(time, reliability_weibull, label='Weibull Reliability Function R(t)', color='green')
plt.title('Weibull Distribution - Reliability Function')
plt.xlabel('Time [hours]')
plt.ylabel('Reliability')
plt.grid()
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# Constants
k = 8.617333262145e-5 # Boltzmann constant in eV/K
Ea = 0.7 # Activation energy in eV (example value)
A = 1e6 # Pre-exponential factor (example value)
T_base = 298 # Base temperature in Kelvin (25°C)
# Temperature range for analysis
temperature = np.linspace(250, 400, 150) # Temperature range in Kelvin
# Arrhenius equation
def arrhenius_rate(T, A, Ea, k):
return A * np.exp(-Ea / (k * T))
# Eyring model (including stress)
def eyring_rate(T, S, A, Ea, k, n):
return A * np.exp(-Ea / (k * T)) * S**n
# Compute failure rates
failure_rate_arrhenius = arrhenius_rate(temperature, A, Ea, k)
# Parameters for the Eyring model
stress = 1.2 # Example stress value
n = 1 # Example constant for stress dependence
failure_rate_eyring = eyring_rate(temperature, stress, A, Ea, k, n)
# Plotting
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot(temperature, failure_rate_arrhenius, label='Arrhenius Model')
plt.title('Failure Rate vs. Temperature (Arrhenius Model)')
plt.xlabel('Temperature [K]')
plt.ylabel('Failure Rate')
plt.grid()
plt.legend()
plt.subplot(1, 2, 2)
plt.plot(temperature, failure_rate_eyring, label='Eyring Model')
plt.title('Failure Rate vs. Temperature (Eyring Model)')
plt.xlabel('Temperature [K]')
plt.ylabel('Failure Rate')
plt.grid()
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# Constants for Silicon
K = 0.306 # Thermal conductivity in W/cm·K
rho = 2.33 # Density in g/cm^3
Cp = 0.7566 # Specific heat in J/g·K
Tm = 1688 # Melting temperature in K
Ti = 298 # Initial temperature in K
# Pulse width range (t in seconds)
pulse_width = np.linspace(1e-9, 1e-3, 1000) # From 1 ns to 1 ms
# Calculate allowable power per unit area
P_per_A = np.pi * K * rho * Cp * (Tm - Ti) * pulse_width**(-0.5)
# Plotting
plt.figure(figsize=(10, 6))
plt.plot(pulse_width, P_per_A)
plt.xscale('log')
plt.yscale('log')
plt.title('Allowable Power per Unit Area vs Pulse Width (Wunsch & Bell Model)')
plt.xlabel('Pulse Width (s)')
plt.ylabel('Allowable Power per Unit Area (W/cm^2)')
plt.grid(True, which='both', linestyle='--', linewidth=0.5)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import poisson
# Parameters
n = 10 # Sample size
c = 2 # Acceptance number
p_values = np.linspace(0, 0.3, 100) # Fraction defective (p) values from 0 to 0.3
# Function to calculate probability of acceptance using Poisson distribution
def prob_acceptance_poisson(n, c, p):
pa = np.zeros_like(p)
for i in range(len(p)):
pa[i] = np.sum([poisson.pmf(k, n*p[i]) for k in range(c + 1)])
return pa
# Calculate probability of acceptance for different values of p
P_a = prob_acceptance_poisson(n, c, p_values)
# Plotting the OC curve
plt.figure(figsize=(10, 6))
plt.plot(p_values, P_a, label=f'n={n}, c={c}')
plt.xlabel('Fraction Defective (p)')
plt.ylabel('Probability of Acceptance (P_a)')
plt.title('OC Curve for Acceptance Sampling Plan')
plt.grid(True)
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import chi2
# Parameters
n = 10 # Number of units tested
beta = 0.1 # Producer's risk
lambda_failure = 0.001 # Failure rate
c = 0 # Acceptance number (no failures allowed)
# Chi-square value for given beta and degrees of freedom
chi_square_value = chi2.ppf(1 - beta, 2 * (c + 1))
# Calculate required test time T
T = chi_square_value / (2 * lambda_failure * n)
print(f"Required test time T: {T:.2f} hours")
# Total test time for range of λ values
lambda_values = np.linspace(0.0001, 0.002, 500)
test_times = chi_square_value / (2 * lambda_values * n)
# Plotting
plt.figure(figsize=(10, 6))
plt.plot(lambda_values, test_times, label=f'n={n}, β={beta}, c={c}')
plt.axvline(x=lambda_failure, color='r', linestyle='--', label=f'λ={lambda_failure}')
plt.xlabel('Failure Rate λ')
plt.ylabel('Required Test Time T (hours)')
plt.title('Required Test Time vs Failure Rate for Acceptance Sampling Plan')
plt.grid(True)
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# Parameters
n = 100 # Total number of samples
h = 1 # Time interval between observations
time_intervals = np.arange(0, 11, h) # Observation times from 0 to 10
failures = np.array([0, 3, 7, 12, 18, 25, 33, 42, 52, 63, 75]) # Number of failures observed in each interval
# Cumulative number of failures
cumulative_failures = np.cumsum(failures)
# Total observation time
t_total = time_intervals[-1]
# Failure rate (f(t))
failure_rate = failures / (n - np.concatenate(([0], cumulative_failures[:-1])))
# Reliability function (R(t))
reliability = np.exp(-np.cumsum(failure_rate) * h)
# Plotting the discrete failure distribution
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.bar(time_intervals, failures, width=0.5, align='center', alpha=0.7, color='blue', label='Failures')
plt.xlabel('Time')
plt.ylabel('Number of Failures')
plt.title('Discrete Failure Distribution')
plt.grid(True)
plt.legend()
# Plotting the reliability function
plt.subplot(1, 2, 2)
plt.step(time_intervals, reliability, where='mid', label='Reliability Function (R(t))', color='green')
plt.xlabel('Time')
plt.ylabel('Reliability')
plt.title('Reliability Function')
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# Parameters
lambda_rate = 0.1 # Failure rate parameter (constant for exponential distribution)
time = np.linspace(0, 20, 500) # Time range from 0 to 20
# Failure rate function λ(t) (constant for exponential distribution)
lambda_t = lambda_rate * np.ones_like(time)
# Reliability function R(t) for exponential distribution
R_t = np.exp(-lambda_rate * time)
# Failure distribution function F(t)
F_t = 1 - R_t
# Plotting
plt.figure(figsize=(12, 6))
# Plot Reliability Function R(t)
plt.subplot(1, 2, 1)
plt.plot(time, R_t, label='Reliability Function R(t)')
plt.xlabel('Time t')
plt.ylabel('Reliability R(t)')
plt.title('Reliability Function R(t)')
plt.grid(True)
plt.legend()
# Plot Failure Distribution Function F(t) and Failure Rate λ(t)
plt.subplot(1, 2, 2)
plt.plot(time, F_t, label='Failure Distribution Function F(t)', color='blue')
plt.xlabel('Time t')
plt.ylabel('Probability')
plt.title('Failure Distribution Function F(t)')
plt.grid(True)
plt.legend()
# Failure Rate λ(t) on the same plot
plt.twinx() # Create a second y-axis
plt.plot(time, lambda_t, label='Failure Rate λ(t)', color='red', linestyle='--')
plt.ylabel('Failure Rate λ(t)')
plt.legend(loc='upper right')
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.special import gamma
# Parameters
m = 1.5 # Shape parameter
t0 = 1.0 # Scale parameter
eta = t0 * gamma(1 + 1/m) # Characteristic life
time = np.linspace(0, 3 * eta, 500) # Time range
# Weibull Failure Distribution Function
F_t = 1 - np.exp(-(time / t0) ** m)
# Mean and Standard Deviation
mu = eta * gamma(1 + 1/m)
sigma = eta * np.sqrt(gamma(1 + 2/m) - gamma(1 + 1/m)**2)
F_mu = 1 - np.exp(-(mu / t0) ** m)
# Plotting the Weibull Failure Distribution Function
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot(time, F_t, label=f'Weibull Failure Distribution Function F(t)')
plt.xlabel('Time t')
plt.ylabel('Failure Probability F(t)')
plt.title('Weibull Failure Distribution Function')
plt.grid(True)
plt.legend()
# Plotting Mean and Standard Deviation
plt.subplot(1, 2, 2)
plt.axvline(x=mu, color='r', linestyle='--', label=f'Mean μ = {mu:.2f}')
plt.axvline(x=mu + sigma, color='g', linestyle='--', label=f'Standard Deviation σ = {sigma:.2f}')
plt.axvline(x=mu - sigma, color='g', linestyle='--')
plt.xlabel('Time t')
plt.ylabel('Failure Probability')
plt.title('Mean and Standard Deviation')
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()
# Print values
print(f"Mean μ: {mu:.2f}")
print(f"Standard Deviation σ: {sigma:.2f}")
print(f"Failure Probability at Mean F(μ): {F_mu:.2f}")
import numpy as np
import matplotlib.pyplot as plt
# Parameters
m = 1.5 # Shape parameter
t0 = 1.0 # Scale parameter
time = np.linspace(0, 3 * t0, 500) # Time range from 0 to 3*t0
# Cumulative Hazard Function H(t) for Weibull Distribution
H_t = (time / t0) ** m
# Weibull Failure Distribution Function F(t) for comparison
F_t = 1 - np.exp(-H_t)
# Plotting the Cumulative Hazard Function H(t)
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot(time, H_t, label='Cumulative Hazard Function H(t)', color='blue')
plt.xlabel('Time t')
plt.ylabel('Cumulative Hazard H(t)')
plt.title('Weibull Cumulative Hazard Function')
plt.grid(True)
plt.legend()
# Plotting Failure Distribution Function F(t) for comparison
plt.subplot(1, 2, 2)
plt.plot(time, F_t, label='Failure Distribution Function F(t)', color='green')
plt.xlabel('Time t')
plt.ylabel('Failure Probability F(t)')
plt.title('Weibull Failure Distribution Function')
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import binom
# Parameters
n = 20 # Number of trials
p = 0.3 # Probability of success
x = np.arange(0, n+1) # Range of number of successes
# Probability Mass Function for Binomial Distribution
pmf = binom.pmf(x, n, p)
# Mean and Standard Deviation
mean = n * p
std_dev = np.sqrt(n * p * (1 - p))
# Plotting the Binomial Distribution
plt.figure(figsize=(10, 6))
plt.bar(x, pmf, color='skyblue', edgecolor='black', alpha=0.7)
plt.xlabel('Number of Successes (x)')
plt.ylabel('Probability')
plt.title(f'Binomial Distribution PMF\nn={n}, p={p}\nMean = {mean:.2f}, Std Dev = {std_dev:.2f}')
plt.grid(True)
plt.show()
# Print values
print(f"Mean μ: {mean:.2f}")
print(f"Standard Deviation σ: {std_dev:.2f}")
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import nbinom
# Parameters
r = 5 # Number of failures
p = 0.3 # Probability of failure
x = np.arange(r, 30) # Range of number of trials
# Probability Mass Function for Negative Binomial Distribution
pmf = nbinom.pmf(x - r, r, p)
# Plotting the Negative Binomial Distribution
plt.figure(figsize=(10, 6))
plt.bar(x, pmf, color='skyblue', edgecolor='black', alpha=0.7)
plt.xlabel('Number of Trials (x)')
plt.ylabel('Probability')
plt.title(f'Negative Binomial Distribution PMF\nFailures = {r}, p = {p}')
plt.grid(True)
plt.show()
# Print values
print(f"Mean: {r / p}")
print(f"Variance: {r * (1 - p) / p**2}")
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import geom
# Parameters
p = 0.3 # Probability of success
n = np.arange(1, 21) # Range of trials (1 to 20)
# Probability Mass Function for Geometric Distribution
pmf = geom.pmf(n, p)
# Cumulative Distribution Function for Geometric Distribution
cdf = geom.cdf(n, p)
# Plotting the Geometric Distribution PMF
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.stem(n, pmf, use_line_collection=True, basefmt=" ", linefmt='b-', markerfmt='bo', label='PMF')
plt.xlabel('Number of Trials (n)')
plt.ylabel('Probability')
plt.title(f'Geometric Distribution PMF\np = {p}')
plt.grid(True)
plt.legend()
# Plotting the Geometric Distribution CDF
plt.subplot(1, 2, 2)
plt.step(n, cdf, where='post', label='CDF', color='green')
plt.xlabel('Number of Trials (n)')
plt.ylabel('Cumulative Probability')
plt.title(f'Geometric Distribution CDF\np = {p}')
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()
# Print values
mean = 1 / p
variance = (1 - p) / (p**2)
print(f"Mean μ: {mean:.2f}")
print(f"Variance σ^2: {variance:.2f}")
import numpy as np
import matplotlib.pyplot as plt
# 発熱密度の計算
def heat_density(power, area):
return power / area
# LSIチップのパラメータ
lsi_power = 50 # [W]
lsi_length = 1.5 # [cm]
lsi_area = lsi_length * lsi_length # [cm²]
lsi_heat_density = heat_density(lsi_power, lsi_area)
# ホットプレートのパラメータ
hot_plate_power = 1500 # [W]
hot_plate_diameter = 30 # [cm]
hot_plate_area = np.pi * (hot_plate_diameter / 2) ** 2 # [cm²]
hot_plate_heat_density = heat_density(hot_plate_power, hot_plate_area)
# 欠陥密度の範囲
D = np.linspace(0, 0.1, 100) # 欠陥密度の範囲 (例: 0から0.1)
# LSIチップの歩留まりの計算
lsi_yield = np.exp(-D * lsi_area)
# 結果の表示
print(f"LSIチップの発熱密度: {lsi_heat_density:.2f} W/cm²")
print(f"ホットプレートの発熱密度: {hot_plate_heat_density:.2f} W/cm²")
# プロット
plt.figure(figsize=(12, 6))
# 発熱密度の比較
plt.subplot(1, 2, 1)
plt.bar(['LSI Chip', 'Hot Plate'], [lsi_heat_density, hot_plate_heat_density], color=['blue', 'red'])
plt.xlabel('Device')
plt.ylabel('Heat Density (W/cm²)')
plt.title('Heat Density Comparison')
# 歩留まりのプロット
plt.subplot(1, 2, 2)
plt.plot(D, lsi_yield, color='green')
plt.xlabel('Defect Density (D)')
plt.ylabel('Yield (Y)')
plt.title('Yield vs. Defect Density')
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# パラメータ
L = 1 # チップの長さ (任意単位)
mu = 1 # キャリア移動度 (任意単位)
V_G_Vth = 1 # 元の(VG - Vth) (任意単位)
# スケーリング因子の範囲
k_values = np.linspace(0.1, 10, 100) # スケーリング因子 (0.1から10)
# 元の時定数
tau_orig = L**2 / (mu * V_G_Vth)
# スケーリング後の時定数
tau_scaled = k_values * tau_orig
# プロット
plt.figure(figsize=(8, 6))
plt.plot(k_values, tau_scaled, label='Scaled Time Constant', color='blue')
plt.xlabel('Scaling Factor (k)')
plt.ylabel('Time Constant')
plt.title('Time Constant vs. Scaling Factor')
plt.grid(True)
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 時間の範囲を設定
time = np.linspace(0, 100, 500)
# 初期不良期（指数関数的に減少）
early_failure_rate = np.exp(-0.1 * time)
# 偶発故障期（一定の故障率）
constant_failure_rate = 0.01 * np.ones_like(time)
# 摩耗故障期（指数関数的に増加）
wear_out_failure_rate = np.exp(0.05 * (time - 50))
# バスタブ曲線を作成
bathtub_curve = early_failure_rate + constant_failure_rate + wear_out_failure_rate
# プロット
plt.figure(figsize=(10, 6))
plt.plot(time, early_failure_rate, label="Early Failures")
plt.plot(time, constant_failure_rate, label="Random Failures")
plt.plot(time, wear_out_failure_rate, label="Wear-out Failures")
plt.plot(time, bathtub_curve, label="Bathtub Curve", linewidth=2, color='black')
plt.title("Bathtub Curve for Electronic Component Reliability")
plt.xlabel("Time")
plt.ylabel("Failure Rate")
plt.yscale("log")
plt.grid(True, which="both", ls="--")
plt.legend()
plt.show()
import numpy as np
# サンプルデータ（例えば、ウェハの厚さ測定値）
data = np.array([1.01, 0.99, 1.02, 1.00, 1.03, 0.98, 1.01, 1.00, 0.97, 1.02])
# 仕様限界
USL = 1.05 # 上限
LSL = 0.95 # 下限
# 平均と標準偏差
mean = np.mean(data)
std_dev = np.std(data)
# Cpkの計算
cpk = min((USL - mean) / (3 * std_dev), (mean - LSL) / (3 * std_dev))
print(f"プロセス能力指数 (Cpk): {cpk:.2f}")
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import weibull_min
# ワイブル分布のパラメータ
shape = 2.0 # 形状パラメータ
scale = 1000 # 尺度パラメータ
# 故障時間データの生成
failure_times = weibull_min.rvs(shape, scale=scale, size=1000)
# ワイブル分布のプロット
x = np.linspace(0, 3000, 100)
pdf = weibull_min.pdf(x, shape, scale=scale)
plt.hist(failure_times, bins=30, density=True, alpha=0.6, color='g', label='Failure Data')
plt.plot(x, pdf, 'r-', lw=2, label='Weibull PDF')
plt.xlabel('Time to Failure')
plt.ylabel('Probability Density')
plt.title('Weibull Distribution of Failure Times')
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# サンプルデータ（例えば、ロットごとのウェハ厚さの平均値）
data = np.random.normal(loc=1.00, scale=0.01, size=30)
# 平均と標準偏差
mean = np.mean(data)
std_dev = np.std(data)
# 管理限界の設定
UCL = mean + 3 * std_dev / np.sqrt(len(data))
LCL = mean - 3 * std_dev / np.sqrt(len(data))
# プロット
plt.plot(data, marker='o', linestyle='-', color='b')
plt.axhline(y=mean, color='g', linestyle='-', label='Mean')
plt.axhline(y=UCL, color='r', linestyle='--', label='UCL (Upper Control Limit)')
plt.axhline(y=LCL, color='r', linestyle='--', label='LCL (Lower Control Limit)')
plt.title('X̄ Control Chart')
plt.xlabel('Sample')
plt.ylabel('Mean Thickness')
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# サンプルデータ（例えば、温度と故障率のデータ）
temperatures = np.array([300, 350, 400, 450, 500]) # 温度 (K)
failure_rates = np.array([0.001, 0.005, 0.02, 0.1, 0.4]) # 故障率
# アレニウスプロットのためのデータ変換
inverse_temps = 1 / temperatures
log_failure_rates = np.log(failure_rates)
# 回帰直線のフィット
coeffs = np.polyfit(inverse_temps, log_failure_rates, 1)
fit_line = np.poly1d(coeffs)
# プロット
plt.scatter(inverse_temps, log_failure_rates, color='blue', label='Data')
plt.plot(inverse_temps, fit_line(inverse_temps), color='red', linestyle='--', label='Fit Line')
plt.title('Arrhenius Plot')
plt.xlabel('1/Temperature (1/K)')
plt.ylabel('Log(Failure Rate)')
plt.legend()
plt.show()
print(f"Fit Line: Log(Failure Rate) = {coeffs[0]:.4f} * (1/T) + {coeffs[1]:.4f}")
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report
# サンプルデータ（例えば、製造プロセスのパラメータと故障の有無）
# 特徴量データ
X = np.random.rand(100, 5)
# ラベルデータ（0: 正常, 1: 故障）
y = np.random.randint(0, 2, 100)
# データの分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# ランダムフォレストモデルの訓練
clf = RandomForestClassifier(n_estimators=100, random_state=42)
clf.fit(X_train, y_train)
# 予測
y_pred = clf.predict(X_test)
# 結果の評価
accuracy = accuracy_score(y_test, y_pred)
report = classification_report(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")
print("Classification Report:\n", report)