Fit a Gaussian bump on an exponential background

{
 "path": "README.md",
 "max_chars": 3000,
 "offset": 0
}

{
 "path": "data/synth_diphoton.csv",
 "max_chars": 3000,
 "offset": 0
}

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')

# Write solution.py
solution_code = '''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Load data
data = pd.read_csv('data/synth_diphoton.csv')
m_gg = data['m_gg'].values

# Histogram m_gg in 80 bins of width 1 GeV on [100, 180]
bin_edges = np.linspace(100, 180, 81)
hist, bin_centers = np.histogram(m_gg, bins=bin_edges, density=False)

# Define the model function
def model(m, N_s, mu, sigma, N_b, lam):
    w = 1.0  # Bin width
    gauss = np.exp(-((m - mu)**2) / (2 * sigma**2)) / (sigma * np.sqrt(2 * np.pi))
    expo = np.exp(-m / lam) / (lam * (np.exp(-100 / lam) - np.exp(-180 / lam)))
    return w * (N_s * gauss + N_b * expo)

# Prepare data for fitting
x = bin_centers
y = hist

# Exclude bins with zero counts
non_zero_mask = y > 0
x_non_zero = x[non_zero_mask]
y_non_zero = y[non_zero_mask]

# Initial guesses
initial_guess = [300, 125, 2, 30000, 25]

# Perform the least-squares fit
params, cov = curve_fit(model, x_non_zero, y_non_zero, p0=initial_guess, absolute_sigma=True)

# Extract parameters and uncertainties
N_s_fit, mu_fit, sigma_fit, N_b_fit, lam_fit = params
N_s_err = np.sqrt(cov[0, 0])
mu_err = np.sqrt(cov[1, 1])
sigma_err = np.sqrt(cov[2, 2])
N_b_err = np.sqrt(cov[3, 3])
lam_err = np.sqrt(cov[4, 4])

# Compute chi2 and ndf
chi2 = np.sum(((y_non_zero - model(x_non_zero, *params)) ** 2) / y_non_zero)
ndf = len(y_non_zero) - len(params)

# Compute naive significance
naive_significance = N_s_fit / N_s_err

# Save results to result.json
result = {
    'mu': mu_fit,
    'mu_err': mu_err,
    'sigma': sigma_fit,
    'sigma_err': sigma_err,
    'n_sig': N_s_fit,
    'n_sig_err': N_s_err,
    'n_bkg': N_b_fit,
    'lam': lam_fit,
    'chi2': chi2,
    'ndf': ndf,
    'naive_significance': naive_significance
}

import json
with open('result.json', 'w') as f:
    json.dump(result, f)

# Plot the results
plt.figure(figsize=(10, 6))
plt.errorbar(x_non_zero, y_non_zero, yerr=np.sqrt(y_non_zero), fmt='o', label='Data')

# Generate fit curve
x_fit = np.linspace(100, 180, 1000)
y_fit = model(x_fit, *params)
plt.plot(x_fit, y_fit, label='Fit')

# Generate background-only curve
y_bkg = model(x_fit, 0, mu_fit, sigma_fit, N_b_fit, lam_fit)
plt.plot(x_fit, y_bkg, label='Background')

plt.xlabel('Invariant Mass (GeV)')
plt.ylabel('Counts')
plt.legend()
plt.savefig('figures/fit.svg')
'''

with open('solution.py', 'w') as f:
    f.write(solution_code)

# Submit the task
submit(
    summary='Fitted Gaussian bump on exponential background with parameters: mu=%.2f +/- %.2f, sigma=%.2f +/- %.2f, n_sig=%.2f +/- %.2f, n_bkg=%.2f, lam=%.2f, chi2=%.2f, ndf=%d, naive_significance=%.2f' % (
        mu_fit, mu_err, sigma_fit, sigma_err, N_s_fit, N_s_err, N_b_fit, lam_fit, chi2, ndf, naive_significance),
    assumptions=['Initial guesses are reasonable', 'No missing values in data', 'Correct binning and normalization']
)