Per-event HT and leading-jet energy with a MeV column

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

{}

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

import pandas as pd
import numpy as np

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    lead_jet_e_gev=('jet_e_gev', lambda x: x.loc[x.index.get_level_values('jet_index') == 0].values[0] if not x.empty else np.nan),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    lead_jet_e_gev=('jet_e_gev', lambda x: x.loc[x.index.get_level_values('jet_index') == 0].values[0] if not x.empty else np.nan),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np
import json

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np
import json

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np
import json

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np
import json

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np
import json

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np
import json

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np
import json

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

# Submit the task
submit(summary="Computed per-event HT and leading-jet energy with MeV column", assumptions=["Duplicates removed by keeping first occurrence", "Jets with missing jet_pt excluded from sums"])

import pandas as pd
import numpy as np
import json

# Read the data
jets_df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
jets_df = jets_df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
jets_df = jets_df[jets_df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
jets_df['jet_e_gev'] = jets_df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = jets_df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in jets_df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

# Write solution.py
solution_code = '''
import pandas as pd
import numpy as np
import json

# Read the data
df = pd.read_csv('data/synth_jets.csv')

# Remove duplicates, keeping the first occurrence
df = df.drop_duplicates(subset=['event_id', 'jet_index'], keep='first')

# Filter out jets with missing jet_pt
df = df[df['jet_pt'].notna()]

# Convert jet_e_mev to GeV
df['jet_e_gev'] = df['jet_e_mev'] / 1000

# Group by event_id to compute per-event quantities
events_df = df.groupby('event_id').agg(
    ht_gev=('jet_pt', 'sum'),
    n_jets_valid=('jet_pt', 'count')
).reset_index()

# Extract lead_jet_e_gev for each event
lead_jet_e_gev = []
for _, group in df.groupby('event_id'):
    # Find the jet with jet_index == 0
    lead_jet = group[group['jet_index'] == 0]
    if not lead_jet.empty:
        lead_jet_e_gev.append(lead_jet['jet_e_gev'].values[0])
    else:
        lead_jet_e_gev.append(np.nan)

# Add lead_jet_e_gev to events_df
events_df['lead_jet_e_gev'] = lead_jet_e_gev

# Sort events by event_id
events_df = events_df.sort_values('event_id').reset_index(drop=True)

# Save events.csv
events_df.to_csv('events.csv', index=False)

# Compute summary statistics
n_events = len(events_df)
mean_ht_gev = events_df['ht_gev'].mean()
mean_lead_jet_e_gev = events_df['lead_jet_e_gev'].mean()
max_lead_jet_e_gev = events_df['lead_jet_e_gev'].max()
frac_events_ht_gt_200 = (events_df['ht_gev'] > 200).mean()

# Save result.json
result = {
    'n_events': int(n_events),
    'mean_ht_gev': float(mean_ht_gev),
    'mean_lead_jet_e_gev': float(mean_lead_jet_e_gev),
    'max_lead_jet_e_gev': float(max_lead_jet_e_gev),
    'frac_events_ht_gt_200': float(frac_events_ht_gt_200)
}

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

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

# Print summary
print(f"n_events: {n_events}")
print(f"mean_ht_gev: {mean_ht_gev}")
print(f"mean_lead_jet_e_gev: {mean_lead_jet_e_gev}")
print(f"max_lead_jet_e_gev: {max_lead_jet_e_gev}")
print(f"frac_events_ht_gt_200: {frac_events_ht_gt_200}")

{
 "summary": "Computed per-event HT and leading-jet energy with MeV column",
 "assumptions": [
  "Duplicates removed by keeping first occurrence",
  "Jets with missing jet_pt excluded from sums"
 ]
}