PyAntiGen 1.0__py3-none-any.whl

framework/pyantigen.py

@@ -0,0 +1,51 @@
+import os
+from framework.isotopomer_tools import ensure_isotopes_format
+from framework.model_generation import generate_model
+
+class PyAntiGen:
+    def __init__(self, name, isotopes=None):
+        self.name = name
+        self.isotopes = ensure_isotopes_format(isotopes or [''])
+        self.reactions = []
+        self.rules = []
+        self.counter = 0
+
+    def add_reaction(
+        self,
+        name,
+        reactants,
+        products,
+        rate_type,
+        rate_eqtn,
+        compartment=None,
+        compartment_reverse=None,
+    ):
+        from framework.reaction_creation import reaction_creation
+        self.counter, self.reactions = reaction_creation(
+            self.reactions,
+            self.counter,
+            name,
+            reactants,
+            products,
+            rate_type,
+            rate_eqtn,
+            compartment=compartment,
+            compartment_reverse=compartment_reverse,
+        )
+
+    def add_rule(self, rule):
+        self.rules.append(rule)
+
+    def generate(self, calling_file_path, model_name=None):
+        """
+        Generates the Antimony model. This wraps the existing model_generation logic.
+        """
+        if model_name is None:
+            model_name = self.name
+            
+        def build_reactions_wrapper(Isotopes):
+            # The isotopes passed in here by generate_model are essentially self.isotopes
+            # because we formatted them earlier. So we can just return our state.
+            return self.reactions, self.rules
+            
+        generate_model(build_reactions_wrapper, self.isotopes, calling_file_path, model_name)

framework/rate_laws.py

@@ -0,0 +1,101 @@
+"""
+Rate law semantics and volumetric scaling for PyAntiGen.
+
+Each rate type has defined units and explicit volume scaling behavior so that
+generated Antimony has correct [amount/time] ODE terms.
+
+Units summary:
+- MA / RMA: User supplies [concentration]^n / time; framework multiplies by V_compartment
+  to yield [amount/time]. Single-compartment reactions.
+- UDF / BDF: User supplies [volume/time] (flow rate); framework uses concentration
+  of species (no global V multiplier). Trans-compartment transport.
+- custom_conc_per_time: User equation in [concentration]^n/time; framework multiplies
+  by V_compartment. Set species_names_are_conc_per_time=True (default).
+- custom_amt_per_time: User equation already in [amount/time]; no volume scaling.
+- custom: Raw expression as-is; user must include volume scaling if needed.
+"""
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class RateLaw(ABC):
+    """Base for rate law semantics (units and volume scaling)."""
+
+    @property
+    @abstractmethod
+    def multiplies_by_volume(self) -> bool:
+        """Whether the framework multiplies the rate expression by compartment volume."""
+        pass
+
+    @property
+    @abstractmethod
+    def user_units_description(self) -> str:
+        """Expected units of the user-supplied rate expression."""
+        pass
+
+
+class MassActionLaw(RateLaw):
+    """MA / RMA: [concentration]^n / time; framework multiplies by V_compartment."""
+    rate_type = "MA"
+
+    @property
+    def multiplies_by_volume(self) -> bool:
+        return True
+
+    @property
+    def user_units_description(self) -> str:
+        return "[concentration]^n / time → framework multiplies by V_compartment to yield amount/time"
+
+
+class VolumeTransportLaw(RateLaw):
+    """UDF / BDF: [volume/time]; species appear as concentration; no V multiplier on expression."""
+    rate_type = "UDF"
+
+    @property
+    def multiplies_by_volume(self) -> bool:
+        return False
+
+    @property
+    def user_units_description(self) -> str:
+        return "[volume/time]; species in equation are concentrations; no V_compartment multiplier"
+
+
+class CustomLaw(RateLaw):
+    """
+    custom_conc_per_time / custom_amt_per_time / custom.
+    custom_conc_per_time: equation in conc/time → we multiply by V.
+    custom_amt_per_time: equation already in amount/time → no scaling.
+    custom: as-is; user must include volume scaling if needed.
+    """
+    def __init__(
+        self,
+        rate_type: str = "custom",
+        species_names_are_conc_per_time: Optional[bool] = None,
+    ):
+        self.rate_type = rate_type
+        self._mult_vol = (
+            species_names_are_conc_per_time
+            if species_names_are_conc_per_time is not None
+            else (rate_type == "custom_conc_per_time")
+        )
+
+    @property
+    def multiplies_by_volume(self) -> bool:
+        return self._mult_vol
+
+    @property
+    def user_units_description(self) -> str:
+        if self.multiplies_by_volume:
+            return "[concentration]^n/time → framework multiplies by V_compartment"
+        return "Equation already in [amount/time]; no volume scaling applied"
+
+
+def get_rate_law_info(rate_type: str) -> str:
+    """Return a short docstring for the given rate type (units and scaling)."""
+    if rate_type in ("MA", "RMA"):
+        return MassActionLaw(rate_type).user_units_description
+    if rate_type in ("UDF", "BDF"):
+        return VolumeTransportLaw(rate_type).user_units_description
+    if rate_type in ("custom_conc_per_time", "custom_amt_per_time", "custom"):
+        return CustomLaw(rate_type).user_units_description
+    return "Unknown rate type"

framework/reaction_creation.py

@@ -0,0 +1,43 @@
+from framework.models import (
+    reaction_from_args,
+    VALID_RATE_TYPES,
+    RATE_TYPES_TWO_CONSTANTS,
+)
+
+
+def reaction_creation(
+    all_reactions,
+    counter,
+    Reaction_name,
+    Reactants,
+    Products,
+    Rate_type,
+    Rate_eqtn_prototype,
+    compartment=None,
+    compartment_reverse=None,
+):
+    """
+    Create and append a validated reaction to all_reactions.
+    Accepts reactants/products as either list of strings or bracket string (e.g. "[A, B]").
+    Validates required fields and rate type at call time; raises on invalid input.
+    """
+    try:
+        reaction = reaction_from_args(
+            name=Reaction_name,
+            reactants=Reactants,
+            products=Products,
+            rate_type=Rate_type,
+            rate_eqtn=Rate_eqtn_prototype,
+            compartment=compartment,
+            compartment_reverse=compartment_reverse,
+        )
+    except ValueError as e:
+        raise ValueError(f"add_reaction validation failed: {e}") from e
+
+    if reaction.Rate_type in RATE_TYPES_TWO_CONSTANTS:
+        counter += 2
+    else:
+        counter += 1
+
+    all_reactions.append(reaction.to_dict())
+    return counter, all_reactions

framework/template/Example/AntiGen_paths.py

@@ -0,0 +1,23 @@
+import sys
+from pathlib import Path
+
+# Use location: import Modules from the same folder as this script (model folder)
+_project_dir = Path(__file__).resolve().parent
+if str(_project_dir) not in sys.path:
+    sys.path.insert(0, str(_project_dir))
+
+MODEL_NAME = _project_dir.name
+
+# Add PyAntiGen root to sys.path if running from within the framework template
+if _project_dir.parent.name == "template":
+    _pyantigen_root = _project_dir.parents[2]
+    if str(_pyantigen_root) not in sys.path:
+        sys.path.insert(0, str(_pyantigen_root))
+
+if _project_dir.name == "scripts":
+    REPO_ROOT = str(_project_dir.parent)
+else:
+    REPO_ROOT = str(_project_dir.parents[1])
+
+if REPO_ROOT not in sys.path:
+    sys.path.insert(0, REPO_ROOT)

framework/template/Example/Example_generate.py

@@ -0,0 +1,30 @@
+"""
+Example model builder. Outputs go to antimony_models/Example/ and generated/Example/.
+"""
+import os
+import sys
+
+import AntiGen_paths
+
+
+from framework.pyantigen import PyAntiGen
+from antimony_modules.Basic.ma_reaction import BasicMAReaction
+
+def generate_antimony_model(Isotopes=['']):
+    MODEL_NAME = AntiGen_paths.MODEL_NAME
+    model = PyAntiGen(name=MODEL_NAME, isotopes=Isotopes)
+    BasicMAReaction(model)
+
+    print(f"Reactions generated: {model.counter}")
+    print(f"Rules generated: {len(model.rules)}")
+
+    model.generate(__file__, model_name=MODEL_NAME)
+    
+    print("\nModel generated successfully.")
+    print("Next steps:")
+    print(f"  1. Optionally edit parameters in antimony_models/{MODEL_NAME}/{MODEL_NAME}_parameters.csv")
+    print(f"  2. From scripts/{MODEL_NAME}/, run: python {MODEL_NAME}_run.py")
+
+if __name__ == "__main__":
+    Isotopes = ['']
+    generate_antimony_model(Isotopes)

framework/template/Example/Example_run.py

@@ -0,0 +1,37 @@
+import os
+import sys
+
+from Engine.Model_simulate import setup_simulation
+from Engine.Model_optimize import setup_optimization_from_groups
+from Modules.Plots import *
+from Modules.Experiment import get_experiment
+from Modules.Optimizer_settings import OPTIMIZATION_SETTINGS
+from AntiGen_paths import MODEL_NAME
+
+
+EXPERIMENT_dict = {
+    "Example": {'EXPERIMENT': get_experiment('EXPERIMENT_Example'), 'plot': plot_results, 'opt_settings_key': 'Example'},
+}
+
+run_settings = {
+    "run_steady_state_first" : True,
+    "Verbose" : True,
+}
+
+
+if __name__ == "__main__":
+    print("Run_settings: ", run_settings)
+    
+    run_optimization = True
+    run_name = "Example"
+
+    if run_optimization:
+        opt_key      = EXPERIMENT_dict[run_name].get('opt_settings_key', run_name)
+        experiment_arg = {
+            "EXPERIMENT": EXPERIMENT_dict[run_name]['EXPERIMENT'],
+            "plot":       EXPERIMENT_dict[run_name]['plot'],
+        }
+        setup_optimization_from_groups(run_settings, OPTIMIZATION_SETTINGS[opt_key], experiment_arg)
+    else:
+        setup_simulation(run_settings, EXPERIMENT_dict[run_name])
+

framework/template/Example/Modules/Data.py

@@ -0,0 +1,36 @@
+import pandas as pd
+import os
+
+
+def load_no_data(replicate, data_path):
+    data_dict = {}  
+    return data_dict
+
+
+def load_ad_data(replicate, data_path):
+    def reshape_df(df):
+        return pd.concat([
+            df[['time', 'B1']].rename(columns={'B1': 'B'}),
+            df[['time', 'B2']].rename(columns={'B2': 'B'}),
+            df[['time', 'B3']].rename(columns={'B3': 'B'})
+        ], ignore_index=True)
+
+    treatment_path = os.path.join(data_path, 'ADneg.csv')
+    df_neg = pd.read_csv(treatment_path)
+    df_neg_early = reshape_df(df_neg[df_neg['Treatment'] == 'Early'])
+    df_neg_late = reshape_df(df_neg[df_neg['Treatment'] == 'Late'])
+    treatment_path = os.path.join(data_path, 'ADpos.csv')
+    df_pos = pd.read_csv(treatment_path)
+    df_pos_early = reshape_df(df_pos[df_pos['Treatment'] == 'Early'])
+    df_pos_late = reshape_df(df_pos[df_pos['Treatment'] == 'Late'])
+    
+    data_dict = {
+        "ADneg__Early": df_neg_early,
+        "ADneg__Late": df_neg_late,
+        "ADpos__Early": df_pos_early,
+        "ADpos__Late": df_pos_late,
+    }
+    return data_dict
+
+
+

framework/template/Example/Modules/Events.py

@@ -0,0 +1,14 @@
+from framework.data_interpolation import generate_antimony_piecewise
+
+def generate_no_events(replicate, df_dict):
+    events = '' 
+    return events
+
+def Example_event(replicate, df_dict):
+    dose = replicate["dose"]
+    delay = replicate["delay"]
+    events = f'at (time >= {delay}): A_Comp1 = {dose}'
+    return events
+
+
+

framework/template/Example/Modules/Experiment.py

@@ -0,0 +1,160 @@
+"""Experiment registry: one 'replicate' entry per simulation,
+simulations are optimized together if in the same opt_group. 
+"""
+from .Data import *
+from .Events import *
+from .Loss_config import *
+from .Observed_species import *
+from .Solver_settings import *
+from .Update_parameters import *
+
+from dataclasses import dataclass, field
+
+@dataclass
+class Experiment:
+    replicates: dict = field(default_factory=dict)
+
+    @property
+    def opt_groups(self):
+        """Return {opt_group: [replicate_key, ...]} by scanning replicates."""
+        groups = {}
+        for key, rep in self.replicates.items():
+            og = rep.get("Opt_group")
+            if og is not None:
+                groups.setdefault(og, []).append(key)
+        return groups
+
+
+def make_replicate(config, **meta):
+    """
+    Build a single replicate entry dict from an explicit config dict.
+
+    config keys (all required unless noted):
+      "Label"            : str
+      "Events"           : callable(replicate, df_dict) -> str
+      "Data"             : callable(replicate, data_path) -> Dict of DataFrame or None
+      "Observed_species" : callable(RoadRunner_instance or None) -> list[str]
+      "Solver_settings"  : callable(replicate) -> dict
+      "Update_parameters": callable(RoadRunner_instance, replicate, mode) -> dict
+      "Loss_config"      : callable(replicate) -> dict
+      "Opt_group"        : str
+      
+    'callable' functions are contained in separate files with the same name as the key. 
+    For example, "Events" is contained in the file "Events.py", "Data" is contained in
+    the file "Data.py", etc. 
+    
+    'replicate' is the output of make_replicate. It contains the dictionary above plus
+    any optional keyword arguments. 
+
+    Any arguments required by the 'callable' functions should be passed as keyword arguments.
+    
+    Keyword arguments are stored in 'replicate' as additional keys.  Example arguments:
+      Age = 70, Status = True, Population = "Amyloid_negative", Drug = "Lecanemab", 
+      dose_nmol = 10, Schedule = "default", Type = "default", …  
+
+    Example::
+
+        make_replicate(
+            {
+                "Label":            "Example_1",
+                "Events":           generate_no_events,
+                "Data":             load_data_Example,
+                "Observed_species": observed_Example,
+                "Solver_settings":  solver_settings_Example,
+                "Update_parameters": update_no_parameters,
+                "Loss_config": Example_loss_config,
+                "Opt_group": opt_group
+            },
+        )
+    """
+    entry = dict(config)
+    return {**entry, **meta}
+
+# ***************************************************************************
+# USER DEFINED OPTIMIZATION
+# ***************************************************************************
+
+# Build each replicate so that each element described in the
+# make_replicate function has a value. 
+# It can be helpful (but not required) to define experimental groups
+# and treatments (conditions) as separate dictionaries, and then 
+# build each replicate by combining elements from the experimental groups
+# and treatments. "params" are used to pass arguments to the 'callable' functions.
+# The "opt_group" is a string that defines which replicates are optimized
+# together, each contributing to the total loss function value when their
+# "Opt_group" valuse are the same. For example, if "Opt_group" is "ADneg" for
+# "Early" and "Late", then the loss function will be calculated for both
+# "Early" and "Late" replicates.
+# The "Label" should be unique for each replicate, although not required.
+# The "replicate" designation implies an experimental replicate, but it is rare
+# to optimize at the replicate level. Typically, replicates are handled at
+# the "Data" level, with all replicates' data fit simultaneously.
+
+
+
+def _build_experiment():
+    # Initialize Experiment class object
+    exp = Experiment()
+
+    # Treatments are typically linked to events, but other settings can also be linked.
+    # In the example below, "loss_config" is also linked to the treatment because
+    # the data loaded depends on the treatment.
+    # Treatment types may also comprise the 'opt_group' in some cases.
+    treatments = {
+        "Early": {"params": {"dose": 10, "delay": 5}},
+        "Late": {"params": {"dose": 5, "delay": 10}},
+    }
+    
+    # Experimental groups are not always necessary but are natural for some
+    # experimental designs. For example, when studying the effect of a treatment
+    # in different populations.
+    exp_groups = {
+        "ADneg": {"opt_group": "ADneg", "params": {"amyloid_positive": False}},
+        "ADpos": {"opt_group": "ADpos", "params": {"amyloid_positive": True}}
+    }
+    
+    for exp_group_name, exp_group_data in exp_groups.items():
+        opt_group = exp_group_data.get("opt_group", exp_group_name)
+        exp_params = exp_group_data.get("params", {})
+        for treatment_name, treatment_data in treatments.items():
+            treatment_params = treatment_data.get("params", {})
+
+            key = f"{exp_group_name}__{treatment_name}"
+            
+            replicate = make_replicate(
+                {
+                    "Label":               key,
+                    "Events":              Example_event,
+                    "Data":                load_ad_data,
+                    "Observed_species":    all_species,
+                    "Solver_settings":     solver_settings_Example,
+                    "Update_parameters":   update_Example,
+                    "Loss_config":         Example_loss_config_AD,
+                    "Opt_group":           opt_group,
+                },
+                **exp_params, 
+                **treatment_params
+            )
+            
+            # Store replicate in the flat registry and nested structure
+            exp.replicates[key] = replicate
+
+    return exp
+
+EXPERIMENT_Example = _build_experiment()
+
+# ***************************************************************************
+# END USER DEFINED EXPERIMENTS
+# ***************************************************************************
+
+# ---------------------------------------------------------------------------
+# Registry accessors
+# ---------------------------------------------------------------------------
+
+def get_experiments():
+    """Returns a dict mapping experiment name -> experiment dict."""
+    return {k: v for k, v in globals().items() if k.startswith('EXPERIMENT_')}
+
+def get_experiment(name):
+    """Returns an experiment dict by name."""
+    return globals().get(name)

framework/template/Example/Modules/Loss_config.py

@@ -0,0 +1,12 @@
+def no_optimization(replicate):
+    return {}
+    
+def Example_loss_config_AD(replicate):
+    label = replicate["Label"]
+    return {"observables": [{
+        "observed_variable": "predicted_B",
+        "data_column":       "B",
+        "time_column":       "time",
+        "data_dict_key":     label,
+    }]}
+

framework/template/Example/Modules/Observed_species.py

@@ -0,0 +1,3 @@
+def all_species(r):
+    observed_species = ['time'] + list(r.getFloatingSpeciesIds()) + list(r.getBoundarySpeciesIds()) + list(r.getAssignmentRuleIds()) + list(r.getGlobalParameterIds())
+    return observed_species

framework/template/Example/Modules/Optimizer_settings.py

@@ -0,0 +1,25 @@
+OPTIMIZATION_SETTINGS = {
+
+    "Example": {
+        "ADneg": {
+            "param_names": ["k_A_to_B", "SF"],
+            "x0": [0.5, 2.0],
+            "bounds": [(0.01, 10.0), (0.01, 10.0)],
+            "method": "Nelder-Mead",
+            "optimizer_kwargs": {"options": {"maxiter": 500}},
+            "wald_analysis": False,
+            "slice_analysis": True,
+            "profile_likelihood_analysis": False,
+        },
+        "ADpos": {
+            "param_names": ["k_A_to_B", "SF"],
+            "x0": [0.5, 2.0],
+            "bounds": [(0.01, 10.0), (0.01, 10.0)],
+            "method": "Nelder-Mead",
+            "optimizer_kwargs": {"options": {"maxiter": 500}},
+            "wald_analysis": False,
+            "slice_analysis": False,
+            "profile_likelihood_analysis": False,
+        },
+    }
+}

framework/template/Example/Modules/Plots.py

@@ -0,0 +1,51 @@
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+import os
+import numpy as np
+
+
+def plot_results(paths, results_dict):
+    """
+    Plot simulation results for N experiments.
+
+    Args:
+        plot_path: Directory to save the plot.
+        MODEL_NAME: Model name for title/filename.
+        results: List of dicts from Experiment.run_all: each has "result", "data", "label".
+    """
+    
+    plot_path = paths["plot_path"]
+    MODEL_NAME = paths["MODEL_NAME"]
+    repo_root = paths["repo_root"]
+    n = max(len(results_dict), 1)
+    color_A = ["blue","green","cyan","black"]
+    color_B = ["red","orange","purple","brown"]
+    fig = plt.figure(figsize=(10, 10))
+    gs  = gridspec.GridSpec(1, 1, figure=fig, hspace=0.5, wspace=0.35)
+    ax = fig.add_subplot(gs[0, 0])
+    for i, (label, item) in enumerate(results_dict.items()):
+        
+        results = item["results"]
+        data_dict = item["data"]
+        
+        data = data_dict[f"{label}"]
+        
+        time_points = results["time"]
+        
+        ax.plot(time_points, results["predicted_A"], label=f"[A] {label}", color=color_A[i])
+        ax.plot(time_points, results["predicted_B"], label=f"[B] {label}", color=color_B[i])
+        if "time" in data.columns and "B" in data.columns:
+            ax.scatter(data["time"], data["B"], color=color_B[i], s=30, zorder=5, label=f"Measured [B] {label}")
+            
+
+            
+    ax.set_xlabel("Time")
+    ax.set_ylabel("Concentration")
+    ax.set_title("Simulation Results for " + MODEL_NAME)
+    ax.legend(loc="center left", bbox_to_anchor=(1.02, 0.5))
+    plt.subplots_adjust(right=0.65)
+    plot_name = os.path.join(plot_path, MODEL_NAME + ".png")
+    plt.savefig(plot_name, bbox_inches="tight")
+    print(f"Plot saved to: {plot_name}")
+    plt.show()
+

framework/template/Example/Modules/Solver_settings.py

@@ -0,0 +1,15 @@
+def make_solver_settings(blocks, abs_tol=1e-10, rel_tol=1e-10):
+    """Factory for solver settings dicts. Reduces boilerplate across all figure settings."""
+    return {
+        'integrator': 'cvode',
+        'absolute_tolerance': abs_tol,
+        'relative_tolerance': rel_tol,
+        'stiff': True,
+        'variable_step_size': True,
+        'simulation_blocks': blocks,
+    }
+
+def solver_settings_Example(replicate):
+    return make_solver_settings(
+        {'block1': {'start': 0, 'end': 48, 'n_points': 1000, 'abs_tol':1e-12, 'rel_tol':1e-12}}
+    )

framework/template/Example/Modules/Update_parameters.py

@@ -0,0 +1,26 @@
+# Update_parameters.py is used in these cases:
+# 1. The base parameters change from one treatment to another
+# 2. The base parameters change from one replicate to another
+# 3. The base parameters are modified by events during the treatment
+#  Update_parameters is called after the parameters are set, but before the simulation is run.
+#  The function does not need to return anything, but modifies the parameters in the
+#  RoadRunner instance (r).
+#  Keyword arguments are passed to the function as meta data.
+#
+#  Example:
+#
+#      def update_parameters(r, replicate):
+#          dose = replicate.get("dose", 10)
+#          r.A_Comp1 = dose
+#          
+
+
+
+def update_no_parameters(r, replicate, mode):
+    return {}
+
+def update_Example(r, replicate, mode):
+    if mode == "Simulator":
+        if replicate["amyloid_positive"]:
+            r['k_A_to_B'] = 0.2
+    return {}

framework/template/data/ADneg.csv

@@ -0,0 +1,27 @@
+Treatment,time,B1,B2,B3
+Early,0,0.38342206790138894,0.091549388,0.5900498343353935
+Early,4,0.2703454588887822,0.17383910077895837,0.6020884589334081
+Early,8,2.296824911197708,2.487658225541256,2.293891968985253
+Early,12,5.277374209126811,5.601574235385922,5.1235773990747475
+Early,16,6.294924781277804,6.741032603463997,6.207362167461668
+Early,20,7.627622224028859,7.827731764768038,7.637070537276994
+Early,24,8.095154334660107,8.483255473019799,8.632232828229437
+Early,28,8.824407618146214,9.305510261116316,8.776431868004604
+Early,32,9.577892749513929,9.121325348548881,9.481106334
+Early,36,9.803956887789985,8.999973449725445,9.596915791033005
+Early,40,9.972862529,9.945594885,9.674311540321838
+Early,44,9.367666080270844,10.008398237577786,9.880527147349609
+Early,48,9.655247074718085,10.145675796028533,9.929383743361324
+Late,0,0.1791263071636229,0.10003528830134165,0.12159208964547695
+Late,4,0.19491688193363405,0.12378603847264884,0.2462734469696091
+Late,8,0.092482469,0.29851688388349296,0.19202822519921844
+Late,12,0.7697289334950888,0.6124998769902201,1.318366837872463
+Late,16,2.418552127081854,2.4872151677545156,2.5537485789706498
+Late,20,2.5945616441206996,2.6845832675225005,3.1989915955519637
+Late,24,3.5197094831506863,4.049684883564003,3.848379545818031
+Late,28,4.095113399003736,4.132972884332342,3.9449664938773834
+Late,32,4.557037667813649,4.4178217770342565,4.252760815246755
+Late,36,4.498622402962995,4.424129799453062,4.968822520193124
+Late,40,4.796580380353387,4.575674896370977,4.614222306643472
+Late,44,4.9971092743924075,4.492494963763387,5.129134868989082
+Late,48,5.067487553321051,5.042477656094307,4.6794104140856545