1
import numpy as np
2
import matplotlib.pyplot as plt
3

4
print("Setup complete.")

1
Setup complete.

1
# Exercise 1 — Hello, Exoplanet Hunter
2
# Replace None with your own name and team number.
3

4
### START CODE HERE ###
5
student_name = 'Luquiescene'
6
team_number = 1
7
### END CODE HERE ###
8

9
print("Hello, Exoplanet Hunter!")
10
print("Student:", student_name)
11
print("Team:", team_number)

1
Hello, Exoplanet Hunter!
2
Student: Luquiescene
3
Team: 1

1
# Test 1
2
assert isinstance(student_name, str), "student_name should be a string, for example: 'Aigerim'"
3
assert student_name.strip() != "", "student_name should not be empty."
4
assert isinstance(team_number, int), "team_number should be an integer, for example: 1"
5
print("Test 1 passed.")

1
Test 1 passed.

1
# Exercise 2 — brightness drop
2
# A star has normal brightness 1.00.
3
# During a possible transit, the brightness becomes 0.985.
4
# Calculate the drop in brightness.
5

6
normal_brightness = 1.00
7
during_transit = 0.985
8

9
### START CODE HERE ###
10
dip = normal_brightness - during_transit
11
dip_percent = dip * 100
12
### END CODE HERE ###
13

14
print("Brightness drop:", dip)
15
print("Brightness drop in percent:", dip_percent)

1
Brightness drop: 0.015000000000000013
2
Brightness drop in percent: 1.5000000000000013

1
# Test 2
2
assert abs(dip - 0.015) < 1e-12, "Check: dip = normal_brightness - during_transit"
3
assert abs(dip_percent - 1.5) < 1e-12, "Check: dip_percent = dip * 100"
4
print("Test 2 passed.")

1
Test 2 passed.

1
# Exercise 3 — lists and simple measurements
2
# This is a very small fake light curve.
3

4
time_small = [1., 2., 3., 4., 5., 6., 7.]
5
brightness_small = [1.00, 1.00, 0.99, 0.96, 0.95, 0.96, 0.99]
6

7
### START CODE HERE ###
8
n_time_points = len(time_small)
9
minimum_brightness = min(brightness_small)
10
maximum_brightness = max(brightness_small)
11
### END CODE HERE ###
12

13
print("Number of points:", n_time_points)
14
print("Minimum brightness:", minimum_brightness)
15
print("Maximum brightness:", maximum_brightness)

1
Number of points: 7
2
Minimum brightness: 0.95
3
Maximum brightness: 1.0

1
# Test 3
2
assert n_time_points == 7, "Use len(time_small)."
3
assert abs(minimum_brightness - 0.95) < 1e-12, "Use min(brightness_small)."
4
assert abs(maximum_brightness - 1.00) < 1e-12, "Use max(brightness_small)."
5
print("Test 3 passed.")

1
Test 3 passed.

1
# Exercise 4 — plot the small light curve
2
# Use plt.plot(..., marker="o").
3

4
plt.figure(figsize=(7, 4))
5

6
### START CODE HERE ###
7
plt.plot(time_small, brightness_small, marker="o")
8
### END CODE HERE ###
9

10
plt.xlabel("Time [days]")
11
plt.ylabel("Brightness")
12
plt.title("Small light curve")
13
plt.grid(True)
14
plt.show()

1
# Exercise 5 — NumPy time grid and noisy brightness
2
# Today you used NumPy to create many points.
3
# np.linspace(start, stop, number_of_points) creates an evenly spaced grid.
4

5
rng = np.random.default_rng(42)
6

7
### START CODE HERE ###
8
time_demo = np.linspace(0, 10, 300)
9
noise = rng.normal(0, 0.01, len(time_demo))
10
brightness_demo = 1 + noise
11
### END CODE HERE ###
12

13
print("First 5 time values:", time_demo[:5])
14
print("First 5 brightness values:", brightness_demo[:5])

1
First 5 time values: [0.         0.03344482 0.06688963 0.10033445 0.13377926]
2
First 5 brightness values: [1.00304717 0.98960016 1.00750451 1.00940565 0.98048965]

1
# Test 5
2
assert isinstance(time_demo, np.ndarray), "time_demo should be a NumPy array."
3
assert isinstance(brightness_demo, np.ndarray), "brightness_demo should be a NumPy array."
4
assert len(time_demo) == 300, "time_demo should contain 300 points."
5
assert len(brightness_demo) == 300, "brightness_demo should contain 300 points."
6
print("Test 5 passed.")

1
Test 5 passed.

1
# Plot your noisy flat light curve.
2

3
plt.figure(figsize=(8, 4))
4
plt.scatter(time_demo, brightness_demo, s=8, alpha=0.7)
5
plt.xlabel("Time [days]")
6
plt.ylabel("Brightness")
7
plt.title("Noisy brightness measurements")
8
plt.grid(True)
9
plt.show()

1
# Exercise 6 — create a simple synthetic transit
2
# We will make brightness lower between day 4 and day 5.
3

4
brightness_transit = brightness_demo.copy()
5

6
### START CODE HERE ###
7
in_transit = (time_demo > 4) & (time_demo < 5)
8
brightness_transit[in_transit] = 0
9
### END CODE HERE ###
10

11
print("Number of points inside the transit:", np.sum(in_transit))

1
Number of points inside the transit: 30

1
# Test 6
2
assert in_transit.dtype == bool, "in_transit should be a Boolean mask."
3
assert np.sum(in_transit) > 0, "Your transit mask should select some points."
4
assert np.nanmin(brightness_transit) < np.nanmin(brightness_demo), "The transit should make the brightness lower."
5
print("Test 6 passed.")

1
Test 6 passed.

1
# Plot the synthetic transit.
2

3
plt.figure(figsize=(8, 4))
4
plt.scatter(time_demo, brightness_transit, s=8, alpha=0.7)
5
plt.xlabel("Time [days]")
6
plt.ylabel("Brightness")
7
plt.title("Synthetic transit")
8
plt.grid(True)
9
plt.show()

1
def make_mystery_light_curve(team, student_id, n_days=45, cadence_minutes=30):
2
    # This function creates one reproducible mystery light curve.
3
    # Same team + same student_id = same target.
4
    seed = 1000 + 100 * int(team) + int(student_id)
5
    rng = np.random.default_rng(seed)
6

7
    time = np.arange(0, n_days, cadence_minutes / (60 * 24))
8

9
    possible_periods = np.array([3.25, 4.10, 5.60, 6.80, 8.40])
10
    period = possible_periods[(int(team) + int(student_id)) % len(possible_periods)]
11
    period = period + rng.normal(0, 0.04)
12

13
    first_transit_time = rng.uniform(1.0, period + 0.5)
14
    duration = rng.uniform(0.14, 0.28)
15
    depth = rng.uniform(0.010, 0.026)
16

17
    slow_trend = 1 + 0.005 * np.sin(2 * np.pi * time / 22 + rng.uniform(0, 2 * np.pi))
18
    flux = slow_trend.copy()
19

20
    # Distance from the nearest transit center.
21
    dt = ((time - first_transit_time + period / 2) % period) - period / 2
22
    transit_mask = np.abs(dt) < duration / 2
23
    flux[transit_mask] -= depth
24

25
    # Add random measurement noise.
26
    flux += rng.normal(0, 0.0025, size=len(time))
27

28
    # Add missing values.
29
    nan_index = rng.choice(len(time), size=8, replace=False)
30
    flux[nan_index] = np.nan
31

32
    # Add a few bright outliers.
33
    finite_index = np.where(np.isfinite(flux))[0]
34
    outlier_index = rng.choice(finite_index, size=10, replace=False)
35
    flux[outlier_index] += rng.uniform(0.035, 0.070, size=len(outlier_index))
36

37
    target_id = f"MYSTERY-{int(team):02d}-{int(student_id):02d}"
38

39
    truth = {
40
        "period_days": period,
41
        "first_transit_time_days": first_transit_time,
42
        "duration_days": duration,
43
        "depth_fraction": depth,
44
        "depth_percent": depth * 100,
45
    }
46

47
    return {
48
        "target_id": target_id,
49
        "time": time,
50
        "flux": flux,
51
        "truth": truth,
52
    }

1
# Exercise 7 — choose your target
2
# Use your real team number and your own student number.
3
# TEAM must be 1, 2, 3, or 4.
4
# STUDENT_ID can be any integer from 1 to 99.
5

6
### START CODE HERE ###
7
TEAM = 1
8
STUDENT_ID = 36
9
### END CODE HERE ###
10

11
MYSTERY_TARGET = make_mystery_light_curve(TEAM, STUDENT_ID)
12

13
time_raw = MYSTERY_TARGET["time"]
14
flux_raw = MYSTERY_TARGET["flux"]
15

16
print("Target ID:", MYSTERY_TARGET["target_id"])
17
print("Number of measurements:", len(time_raw))

1
Target ID: MYSTERY-01-36
2
Number of measurements: 2160

1
# Test 7
2
assert TEAM in [1, 2, 3, 4], "TEAM must be 1, 2, 3, or 4."
3
assert isinstance(STUDENT_ID, int), "STUDENT_ID should be an integer."
4
assert 1 <= STUDENT_ID <= 99, "STUDENT_ID should be between 1 and 99."
5
assert len(time_raw) == len(flux_raw), "time and flux should have the same length."
6
print("Test 7 passed.")

1
Test 7 passed.

1
# Exercise 8 — plot raw mystery light curve
2

3
plt.figure(figsize=(10, 4))
4

5
### START CODE HERE ###
6
plt.scatter(time_raw, flux_raw, s=4, alpha=0.6)
7
### END CODE HERE ###
8

9
plt.xlabel("Time [days]")
10
plt.ylabel("Raw flux")
11
plt.title("Raw mystery light curve")
12
plt.grid(True)
13
plt.show()

1
# Exercise 9 — remove NaNs, remove bright outliers, normalize
2

3
### START CODE HERE ###
4
finite_mask = np.isfinite(flux_raw)
5

6
time_no_nan = time_raw[finite_mask]
7
flux_no_nan = flux_raw[finite_mask]
8

9
median_flux = np.median(flux_no_nan)
10
scatter_flux = 1.4826 * np.median(np.abs(flux_no_nan - median_flux))
11

12
outlier_mask = flux_no_nan > median_flux + 5 * scatter_flux
13

14
time_clean = time_no_nan[~outlier_mask]
15
flux_clean = flux_no_nan[~outlier_mask]
16

17
flux_normalized = flux_clean / median_flux
18
### END CODE HERE ###
19

20
print("Raw points:", len(time_raw))
21
print("After cleaning:", len(time_clean))
22
print("Median normalized flux:", np.nanmedian(flux_normalized))

1
Raw points: 2160
2
After cleaning: 2142
3
Median normalized flux: 0.999955187521236

1
# Test 9
2
assert np.all(np.isfinite(time_clean)), "time_clean should not contain NaNs."
3
assert np.all(np.isfinite(flux_normalized)), "flux_normalized should not contain NaNs."
4
assert len(time_clean) == len(flux_normalized), "time_clean and flux_normalized should have the same length."
5
assert abs(np.nanmedian(flux_normalized) - 1.0) < 0.01, "The median normalized flux should be close to 1."
6
print("Test 9 passed.")

1
Test 9 passed.

1
# Exercise 10 — plot cleaned and normalized light curve
2

3
plt.figure(figsize=(10, 4))
4

5
### START CODE HERE ###
6
plt.scatter(time_clean, flux_normalized, s=4, alpha=0.6)
7
### END CODE HERE ###
8

9
plt.xlabel("Time [days]")
10
plt.ylabel("Normalized flux")
11
plt.title("Cleaned and normalized light curve")
12
plt.grid(True)
13
plt.show()

1
# Exercise 11 — find the deepest point
2
# Hint: np.argmin(array) gives the index of the smallest value.
3

4
### START CODE HERE ###
5
min_index = np.argmin(flux_normalized)
6
transit_time_guess = time_clean[min_index]
7
minimum_flux = flux_normalized[min_index]
8
transit_depth_fraction = 1.0 - minimum_flux
9
transit_depth_percent = transit_depth_fraction * 100
10
### END CODE HERE ###
11

12
print("Deepest point time [days]:", transit_time_guess)
13
print("Minimum normalized flux:", minimum_flux)
14
print("Estimated depth [%]:", transit_depth_percent)

1
Deepest point time [days]: 10.895833333333332
2
Minimum normalized flux: 0.9753378892244227
3
Estimated depth [%]: 2.466211077557734

1
# Test 11
2
assert isinstance(min_index, (int, np.integer)), "min_index should be an integer index."
3
assert np.isfinite(transit_time_guess), "transit_time_guess should be a number."
4
assert np.isfinite(transit_depth_percent), "transit_depth_percent should be a number."
5
assert transit_depth_percent > 0, "The depth should be positive."
6
print("Test 11 passed.")

1
Test 11 passed.

1
# Plot the cleaned light curve and mark the deepest point.
2

3
plt.figure(figsize=(10, 4))
4
plt.scatter(time_clean, flux_normalized, s=4, alpha=0.6)
5
plt.axvline(transit_time_guess, linestyle="--", label="deepest point")
6
plt.xlabel("Time [days]")
7
plt.ylabel("Normalized flux")
8
plt.title("Where is the deepest point?")
9
plt.legend()
10
plt.grid(True)
11
plt.show()

1
# Exercise 12 — zoom near the deepest point
2
# We will look at a window of 1.5 days before and after the deepest point.
3

4
window = 1.5
5

6
### START CODE HERE ###
7
zoom_mask = np.abs(time_clean - transit_time_guess) < window
8
### END CODE HERE ###
9

10
plt.figure(figsize=(8, 4))
11
plt.scatter(time_clean[zoom_mask], flux_normalized[zoom_mask], s=12, alpha=0.8)
12
plt.axvline(transit_time_guess, linestyle="--")
13
plt.xlabel("Time [days]")
14
plt.ylabel("Normalized flux")
15
plt.title("Zoom near the deepest point")
16
plt.grid(True)
17
plt.show()

1
# Test 12
2
assert zoom_mask.dtype == bool, "zoom_mask should be a Boolean mask."
3
assert np.sum(zoom_mask) > 5, "Your zoom window should contain several data points."
4
print("Test 12 passed.")

1
Test 12 passed.

1
# Exercise 13 — estimate a rough duration
2
# We use a simple threshold halfway between normal flux (1.0) and the deepest point.
3
# Points below this threshold near the deepest point are counted as part of the dip.
4

5
### START CODE HERE ###
6
threshold = (1.0 + minimum_flux) / 2
7
near_transit_mask = zoom_mask
8
in_dip_mask = near_transit_mask & (flux_normalized < threshold)
9
estimated_duration_days = np.ptp(time_clean[in_dip_mask])
10
### END CODE HERE ###
11

12
print("Threshold:", threshold)
13
print("Estimated duration [days]:", estimated_duration_days)
14
print("Estimated duration [hours]:", estimated_duration_days * 24)

1
Threshold: 0.9876689446122113
2
Estimated duration [days]: 0.20833333333333393
3
Estimated duration [hours]: 5.000000000000014

1
# Test 13
2
assert np.isfinite(threshold), "threshold should be a number."
3
assert in_dip_mask.dtype == bool, "in_dip_mask should be a Boolean mask."
4
assert np.sum(in_dip_mask) >= 2, "You should have at least two points inside the possible dip."
5
assert estimated_duration_days > 0, "estimated_duration_days should be positive."
6
print("Test 13 passed.")

1
Test 13 passed.

1
# Exercise 14 — highlight low-flux points
2
# Create a mask for points that are below the threshold.
3

4
### START CODE HERE ###
5
low_flux_mask = flux_normalized < threshold
6
number_of_low_points = np.sum(low_flux_mask)
7
### END CODE HERE ###
8

9
print("Number of low-flux points:", number_of_low_points)

1
Number of low-flux points: 66

1
# Test 14
2
assert low_flux_mask.dtype == bool, "low_flux_mask should be a Boolean mask."
3
assert number_of_low_points == np.sum(low_flux_mask), "number_of_low_points should count the True values."
4
assert number_of_low_points > 0, "There should be at least one low-flux point."
5
print("Test 14 passed.")

1
Test 14 passed.

1
# Plot all points and highlight the low-flux points.
2

3
plt.figure(figsize=(10, 4))
4
plt.scatter(time_clean, flux_normalized, s=4, alpha=0.35, label="all points")
5
plt.scatter(time_clean[low_flux_mask], flux_normalized[low_flux_mask],
6
            s=14, alpha=0.9, label="low-flux points")
7
plt.axhline(threshold, linestyle="--", label="threshold")
8
plt.xlabel("Time [days]")
9
plt.ylabel("Normalized flux")
10
plt.title("Low-flux points in the light curve")
11
plt.legend()
12
plt.grid(True)
13
plt.show()

1
# Exercise 15 — observation card
2
# Fill this card using your measurements.
3

4
### START CODE HERE ###
5
observation_card = {
6
    "target_id": MYSTERY_TARGET["target_id"],
7
    "estimated_transit_time_days": transit_time_guess,
8
    "estimated_depth_percent": transit_depth_percent,
9
    "estimated_duration_hours": estimated_duration_days * 24,
10
    "number_of_low_flux_points": number_of_low_points,
11
    "confidence": "medium",
12
    "conclusion": "A possible transit-like signal was detected in the light curve. "
13
    "The dips are short, grouped, and appear at several locations. "
14
    "But further period-folding analysis is needed to verify whether "
15
    "the signal repeats at regular intervals.",
16
}
17
### END CODE HERE ###
18

19
observation_card

1
{'target_id': 'MYSTERY-01-36',
2
 'estimated_transit_time_days': np.float64(10.895833333333332),
3
 'estimated_depth_percent': np.float64(2.466211077557734),
4
 'estimated_duration_hours': np.float64(5.000000000000014),
5
 'number_of_low_flux_points': np.int64(66),
6
 'confidence': 'medium',
7
 'conclusion': 'A possible transit-like signal was detected in the light curve. '
8
 'The dips are short, grouped, and appear at several locations. '
9
 'But further period-folding analysis is needed to verify whether '
10
 'the signal repeats at regular intervals.'}

1
# Test 15
2
required_keys = [
3
    "target_id",
4
    "estimated_transit_time_days",
5
    "estimated_depth_percent",
6
    "estimated_duration_hours",
7
    "number_of_low_flux_points",
8
    "confidence",
9
    "conclusion",
10
]
11

12
for key in required_keys:
13
    assert key in observation_card, f"Missing key: {key}"
14

15
assert observation_card["target_id"] == MYSTERY_TARGET["target_id"], "Use the correct target_id."
16
assert observation_card["confidence"] in ["low", "medium", "high"], "confidence should be low, medium, or high."
17
assert "confirmed" in observation_card["conclusion"].lower() or "possible" in observation_card["conclusion"].lower(), "Use careful scientific language."
18
print("Test 15 passed.")

1
Test 15 passed.