PyAntiGen 1.0.9__py3-none-any.whl

framework/template/Example/Modules/Optimizer_settings.py

@@ -0,0 +1,258 @@
+from dataclasses import dataclass, field
+from .Loss_config import *
+
+@dataclass
+class Optimization:
+    param_names: list
+    x0: list
+    bounds: list = None
+    method: str = "Nelder-Mead"
+    optimizer_kwargs: dict = field(default_factory=dict)
+    group_normalization: str = "mean_over_groups"  # "mean_over_groups" | "sum_over_groups"
+    groups: dict = field(default_factory=dict)       # nested group/loss configuration
+    passive_simulations: list = field(default_factory=list) # passive simulations to run for plotting
+    # Per-parameter optimizer scale: None/"lin" keeps the parameter linear,
+    # "log10" fits log10(p) instead. Accepts a single string for all parameters,
+    # a {name: scale} dict, or a list aligned with param_names. x0 and bounds
+    # stay in linear units; so does everything reported back.
+    parameter_scale: object = None
+
+
+def _build_example_opt1_ADpos():
+    """
+    "k_A_to_B" and "SF" are jointly identifiable from the ADpos data, so they
+    are fit together in one optimization against the ADpos replicates.
+    """
+    return Optimization(
+        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}},
+        group_normalization="mean_over_groups",
+        groups={
+            "ADpos": {
+                "group_weight": 1.0,
+                "loss_elements": [
+                    {"simulation": "ADpos_Early", "loss_config": Example1_loss_config, "weight": 1.0},
+                    {"simulation": "ADpos_Late",  "loss_config": Example1_loss_config, "weight": 1.0},
+                ]
+            }
+        },
+        passive_simulations=[],
+    )
+
+
+def _build_example_opt1_ADneg():
+    """
+    "V_Comp1" is fit separately, against the ADneg data. It is not folded
+    into the ADpos optimization above because it is not jointly identifiable
+    with "SF" there: both trade off against the same [B] trajectories, so a
+    combined fit lands on a ridge rather than a minimum. Splitting the fit by
+    group (rather than lumping all three parameters into one optimization)
+    keeps each individual fit well-posed.
+    """
+    return Optimization(
+        param_names=["V_Comp1"],
+        x0=[0.5],
+        bounds=[(0.01, 10.0)],
+        method="Nelder-Mead",
+        optimizer_kwargs={"options": {"maxiter": 500}},
+        group_normalization="mean_over_groups",
+        groups={
+            "ADneg": {
+                "group_weight": 1.0,
+                "loss_elements": [
+                    {"simulation": "ADneg_Early", "loss_config": Example1_loss_config, "weight": 1.0},
+                    {"simulation": "ADneg_Late",  "loss_config": Example1_loss_config, "weight": 1.0},
+                ]
+            }
+        },
+        passive_simulations=[],
+    )
+
+OPTIMIZATION_Example1_ADpos = _build_example_opt1_ADpos()
+OPTIMIZATION_Example1_ADneg = _build_example_opt1_ADneg()
+
+
+def _build_example3_joint():
+    """
+    NEGATIVE EXAMPLE: fits "k_A_to_B", "SF", and "V_Comp1" jointly against the
+    ADpos data, instead of splitting "V_Comp1" out as Example1 does. This is
+    the fit Example1 deliberately avoids.
+
+    The confound is exact, not approximate: the reaction rate law is
+    "k_A_to_B * (A_Comp1/V_Comp1) * V_Comp1", so V_Comp1 cancels out of the
+    ODE entirely (see antimony_models/Example/Example_reactions.txt) and
+    B_Comp1(t) never depends on it. The only place V_Comp1 appears is the
+    output map "predicted_B := SF * B_Comp1 / V_Comp1" (Example_manual.txt),
+    so predicted_B depends only on the ratio SF/V_Comp1 -- any (SF, V_Comp1)
+    pair with the same ratio fits identically. "SF" and "V_Comp1" are
+    therefore structurally unidentifiable together; only "k_A_to_B" (which
+    shapes the amount trajectory itself) is well-identified here.
+
+    Run with Example2's diagnostics settings to see the signature of this in
+    practice: profile likelihood gives k_A_to_B a tight, finite 95% CI while
+    SF and V_Comp1 both come back [nan, nan] (their profiles never cross the
+    threshold, because the optimizer can always trade one against the other
+    to hold SF/V_Comp1 constant and recover the identical loss).
+
+    CAVEAT -- Sobol says the opposite, and that is expected, not a bug:
+    run_sobol_analysis samples k_A_to_B, SF, and V_Comp1 *independently* and
+    uniformly across their bounds and measures variance of the raw loss, with
+    no re-optimization. Since the model only depends on the ratio SF/V_Comp1,
+    independently randomizing them over a 1000x range almost always lands far
+    off the SF/V_Comp1 = const ridge that fits the data -- that scale mismatch
+    dominates the loss variance, so SF and V_Comp1 get large ST (in a run of
+    this example, ST(V_Comp1)=4.25, ST(SF)=0.64) while k_A_to_B's genuine but
+    comparatively small effect on trajectory timing gets washed out
+    (ST(k_A_to_B)=0.00000), flipping the "identifiable" (ST > 0.01) label onto
+    exactly the two confounded parameters and off the one real one. Sobol-on-
+    loss measures uncorrelated sensitivity ("does perturbing this parameter
+    alone move the loss"), not identifiability ("can the other parameters
+    compensate for it") -- for a ridge/confound like this, those two
+    questions have opposite answers. Treat Sobol here as a sensitivity
+    screen, and profile likelihood as the identifiability check.
+    """
+    return Optimization(
+        param_names=["k_A_to_B", "SF", "V_Comp1"],
+        x0=[0.5, 2.0, 0.5],
+        bounds=[(0.01, 10.0), (0.01, 10.0), (0.01, 10.0)],
+        method="Nelder-Mead",
+        optimizer_kwargs={"options": {"maxiter": 500}},
+        group_normalization="mean_over_groups",
+        groups={
+            "ADpos": {
+                "group_weight": 1.0,
+                "loss_elements": [
+                    {"simulation": "ADpos_Early", "loss_config": Example1_loss_config, "weight": 1.0},
+                    {"simulation": "ADpos_Late",  "loss_config": Example1_loss_config, "weight": 1.0},
+                ]
+            }
+        },
+        passive_simulations=[],
+    )
+
+OPTIMIZATION_Example3_joint = _build_example3_joint()
+
+
+def _flipflop_groups():
+    return {
+        "Flipflop": {
+            "group_weight": 1.0,
+            "loss_elements": [
+                {"simulation": "Flipflop_Early", "loss_config": Flipflop_loss_config, "weight": 1.0},
+                {"simulation": "Flipflop_Late",  "loss_config": Flipflop_loss_config, "weight": 1.0},
+            ],
+        }
+    }
+
+
+def _build_example4_flipflop():
+    """
+    MULTIMODAL EXAMPLE: tests the *accuracy* of profile likelihood dNLL, not
+    just its ability to flag a flat direction (which Example3 covers).
+
+    The model is the chain A -> B -> C (rates k_A_to_B, k_B_to_C) observed
+    through predicted_B := SF*B_Comp1/V_Comp1 on a log10 scale. Since
+
+        B(t) = dose * k_A_to_B * (exp(-k_A_to_B*t) - exp(-k_B_to_C*t))
+               / (k_B_to_C - k_A_to_B),
+
+    swapping the two rate constants rescales B by a constant factor that the
+    fitted SF absorbs exactly: (k1, k2, SF) and (k2, k1, SF*k1/k2) produce
+    IDENTICAL predicted_B trajectories (pharmacokinetic "flip-flop"). Four
+    deliberately noisy predicted_A points on the Early treatment break the
+    symmetry by a small, known amount: relative to the NLL optimum the
+    swapped mode is a genuine local minimum at dNLL ~ 2.4, just above the
+    95% threshold of 1.9207 (printed by data/make_flipflop_data.py).
+
+    What accurate diagnostics must show here (numbers from
+    Flipflop_reference.py, which replicates the full pipeline):
+      * likelihood slices: a single sharp minimum — slices cannot see the
+        second mode at all, because reaching it requires the OTHER two
+        parameters to move (k_B_to_C and SF swap along with k_A_to_B).
+      * every true profile dips to dNLL ~ -2.12 next to the fit point. That
+        is not an error: the FITTING objective averages each observable's
+        chi-square over its own points, which upweights the 4 noisy logA
+        points ~11x against 45 logB points, so the fit optimum (k_A_to_B ~
+        0.363) sits measurably away from the NLL optimum (~0.324) that
+        diagnostics are anchored to. A profile that does not dip is wrong.
+      * true profile likelihood for each parameter: TWO minima. Because of
+        that anchor offset, the swapped mode (k_A_to_B ~ 0.074, k_B_to_C ~
+        0.32, SF ~ 7.2) reports at dNLL ~ +0.8 — BELOW the threshold — so
+        the correct 95% confidence set is a union of two disjoint intervals
+        even though the fit started in the right basin. A profile walker
+        that stops at the first threshold crossing never discovers the
+        second mode, and a first-crossing CI extractor cannot represent the
+        disjoint set; both failures make the reported CI silently
+        conditional on the wrong assumption of unimodality. And if the dNLL
+        scale is off (the log10-objective sigma pitfalls described in
+        Flipflop_loss_config), everything above shifts across the threshold
+        and the CI changes shape entirely.
+
+    Flipflop_reference.py recomputes the exact profiles from the closed-form
+    solution with scipy (no RoadRunner, no framework loss code) under the same
+    frozen-sigma convention — run it and overlay the two sets of curves. Any
+    disagreement is an error in the profile machinery, not in the model.
+    """
+    return Optimization(
+        param_names=["k_A_to_B", "k_B_to_C", "SF"],
+        x0=[0.3, 0.08, 1.5],  # inside the true-mode basin (k_A_to_B > k_B_to_C)
+        bounds=[(0.005, 5.0), (0.005, 5.0), (0.05, 50.0)],
+        method="Nelder-Mead",
+        optimizer_kwargs={"options": {"maxiter": 2000, "xatol": 1e-8, "fatol": 1e-10}},
+        group_normalization="sum_over_groups",
+        parameter_scale="log10",
+        groups=_flipflop_groups(),
+        passive_simulations=[],
+    )
+
+
+def _build_example5_flipflop_swapped():
+    """
+    Same problem as Example4 but started inside the WRONG basin
+    (k_A_to_B < k_B_to_C), so Nelder-Mead converges to the swapped local
+    minimum. This stresses the diagnostics in the way multimodal problems
+    stress them in practice, where nobody tells you the optimizer found the
+    wrong mode:
+
+      * every sigma is frozen by MLE at the *local* optimum. The logA sigma
+        absorbs the swapped mode's A-misfit (~1.73 dex instead of ~0.92), and
+        that inflation deflates every dNLL built on it — the same
+        log10-objective sigma sensitivity described in Flipflop_loss_config,
+        arising here from mode choice rather than from a heuristic;
+      * an accurate profile must go NEGATIVE — dropping to dNLL ~ -0.98 at
+        the true mode (not the -2.4 the true-mode sigmas would give: the
+        inflated sigma has already flattened the landscape). A negative
+        profile minimum is the unambiguous signature that the fit missed the
+        global optimum, and the analysis must report it rather than clip,
+        re-anchor, or hide it;
+      * with the true mode at -0.98, BOTH modes lie below the 1.9207
+        threshold: the correct 95% confidence set for every parameter is a
+        union of two disjoint intervals (e.g. k_A_to_B in [0.072, 0.076] U
+        [0.284, 0.363]), which a first-threshold-crossing CI extractor
+        cannot represent — it reports the narrow interval around the wrong
+        mode and silently discards the one containing the truth.
+
+    Compare against Flipflop_reference.py --anchor swapped, which computes
+    the reference profiles anchored at the same wrong mode.
+    """
+    return Optimization(
+        param_names=["k_A_to_B", "k_B_to_C", "SF"],
+        x0=[0.06, 0.4, 7.0],  # inside the swapped-mode basin
+        bounds=[(0.005, 5.0), (0.005, 5.0), (0.05, 50.0)],
+        method="Nelder-Mead",
+        optimizer_kwargs={"options": {"maxiter": 2000, "xatol": 1e-8, "fatol": 1e-10}},
+        group_normalization="sum_over_groups",
+        parameter_scale="log10",
+        groups=_flipflop_groups(),
+        passive_simulations=[],
+    )
+
+OPTIMIZATION_Example4_flipflop = _build_example4_flipflop()
+OPTIMIZATION_Example5_flipflop_swapped = _build_example5_flipflop_swapped()
+
+def get_OPTIMIZATION(name):
+    """Returns a single Optimization configuration by name."""
+    return globals().get(name)

framework/template/Example/Modules/Plots.py

@@ -0,0 +1,89 @@
+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], linestyle='--')
+        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}")
+            
+
+            
+    # plot_tag carries the run label + group names (e.g. "Example1_ADpos") so
+    # each example/group writes its own figure instead of overwriting one file.
+    tag = paths.get("plot_tag")
+    ax.set_xlabel("Time")
+    ax.set_ylabel("Concentration")
+    ax.set_title("Simulation Results for " + MODEL_NAME + (f" — {tag}" if tag else ""))
+    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 + (f"_{tag}" if tag else "") + ".png")
+    plt.savefig(plot_name, bbox_inches="tight")
+    print(f"Plot saved to: {plot_name}")
+    plt.show()
+
+
+
+def plot_flipflop(paths, results_dict):
+    """Plot the flip-flop example on a log scale (the scale the loss uses)."""
+    plot_path = paths["plot_path"]
+    MODEL_NAME = paths["MODEL_NAME"]
+    colors = ["tab:blue", "tab:red", "tab:green", "tab:orange"]
+    fig, ax = plt.subplots(figsize=(9, 6))
+    for i, (label, item) in enumerate(results_dict.items()):
+        results = item["results"]
+        data_dict = item["data"]
+        c = colors[i % len(colors)]
+        ax.semilogy(results["time"], np.maximum(results["predicted_B"], 1e-12),
+                    color=c, label=f"predicted_B {label}")
+        ax.semilogy(results["time"], np.maximum(results["predicted_A"], 1e-12),
+                    color=c, linestyle=":", label=f"predicted_A {label}")
+        data_B = data_dict.get(label)
+        if data_B is not None and "logB" in data_B.columns:
+            ax.scatter(data_B["time"], 10.0 ** data_B["logB"], color=c, s=20,
+                       zorder=5, label=f"logB data {label}")
+        data_A = data_dict.get(f"{label}_A")
+        if data_A is not None and "logA" in data_A.columns:
+            ax.scatter(data_A["time"], 10.0 ** data_A["logA"], color=c, s=40,
+                       marker="x", zorder=5, label=f"logA data {label}")
+    tag = paths.get("plot_tag")
+    ax.set_xlabel("Time")
+    ax.set_ylabel("Output (log scale)")
+    ax.set_ylim(1e-3, 30)
+    ax.set_title("Flip-flop example: " + MODEL_NAME + (f" — {tag}" if tag else ""))
+    ax.legend(loc="center left", bbox_to_anchor=(1.02, 0.5), fontsize=8)
+    plt.subplots_adjust(right=0.62)
+    plot_name = os.path.join(plot_path, MODEL_NAME + (f"_{tag}" if tag else "") + "_flipflop.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,16 @@
+def make_solver_settings(blocks, abs_tol=1e-10, rel_tol=1e-10, max_steps=20000):
+    """Factory for solver settings dicts. Reduces boilerplate across all figure settings."""
+    return {
+        'integrator': 'cvode',
+        'absolute_tolerance': abs_tol,
+        'relative_tolerance': rel_tol,
+        'maximum_num_steps': max_steps,
+        '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_opt_parameters.py

@@ -0,0 +1,24 @@
+#  Unlike Update_parameters.py, this function is called at each
+#  iteration of the optimization problem. The purpose is to modify some 
+#  non-optimized parameters that depend upon an optimized parameter.
+#  The parameters are modified in the RoadRunner instance (r).
+#
+#  Use cases: 
+#    1. Some parameters depend on parameters that are being optimized.
+#    2. Event parameters change depending on experimental design.
+#    
+#
+#  Example:
+#
+#      def update_opt_parameters_antibody(r, experiment, parameters):
+#          drug_name = experiment.get("Drug")
+#          if drug_name == "Lecanemab":
+#              if 'k_f_DensePlaque_Antibody_Lecanemab' in parameters:
+#                  r['k_f_DensePlaque_Antibody'] = parameters['k_f_DensePlaque_Antibody_Lecanemab']
+#          elif drug_name == "Aducanumab":
+#              if 'k_f_DensePlaque_Antibody_Aducanumab' in parameters:
+#                  r['k_f_DensePlaque_Antibody'] = parameters['k_f_DensePlaque_Antibody_Aducanumab']
+#          
+
+def update_opt_no_parameters(r, experiment, parameters):
+    return

framework/template/Example/Modules/Update_parameters.py

@@ -0,0 +1,49 @@
+# 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 during
+#  construction of the RoadRunner model, but before the simulation is run.
+#  It is not called during each round of optimization, only at the
+#  setup of the optimization problem. If parameters need to be modified
+#  at each parameter update in an optimization problem, then
+#  contruct a function within Update_opt_parameters.py.
+#  The function does not need to return anything, but modifies the parameters in the
+#  RoadRunner instance (r).
+#  'mode' is optional and is given "Simulator" for a pure simulation
+#  and "Optimizer" for an optimization problem. The purpose is to allow for
+#  different parameter updates for simulations and optimizations.
+#  'replicate' is a dictionary containing the replicate information.
+#  'r' is the RoadRunner instance.
+#
+#  Example:
+#
+#      def update_parameters(r, replicate):
+#          dose = replicate.get("dose", 10)
+#          r.A_Comp1 = dose
+#          
+
+
+
+def update_no_parameters(r, replicate):
+    return
+
+def update_flipflop(r, replicate):
+    # Ground-truth values used to generate data/Flipflop.csv
+    # (see data/make_flipflop_data.py). During optimization these are
+    # overwritten every evaluation by the fitted parameters; for --simulate
+    # they make the model reproduce the data-generating truth.
+    r['k_A_to_B'] = 0.35
+    r['k_B_to_C'] = 0.07
+    r['SF'] = 1.6
+    return
+
+def update_Example(r, replicate):
+    
+    if replicate["amyloid_positive"]:
+        r['k_A_to_B'] = 0.2
+        print("Replicate: ", replicate["Label"], " k_A_to_B: ", r['k_A_to_B'])
+    else:
+        r['k_A_to_B'] = 0.1
+        print("Replicate: ", replicate["Label"], " k_A_to_B: ", r['k_A_to_B'])
+    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

framework/template/data/ADpos.csv

@@ -0,0 +1,27 @@
+Treatment,time,B1,B2,B3
+Early,0,0.19539234562313734,0.10477882730649994,0.2973846164284792
+Early,4,0.2779771221561284,0.001055937,0.15111804708517929
+Early,8,4.782679084451829,4.928558620981794,4.334643272
+Early,12,7.695253302802565,7.486506183447338,7.670888582077174
+Early,16,8.638920256993988,8.764901952880617,8.564767024924421
+Early,20,10.068564764063265,9.200881089445513,9.537327159244036
+Early,24,9.771893527990473,9.680509836078317,10.036671602844494
+Early,28,9.766074610781745,9.724111693188496,9.633603887143744
+Early,32,9.771636547315907,10.058348006501559,9.835037442469508
+Early,36,9.741328028636595,9.841645089251156,10.324624435991593
+Early,40,10.254511279938015,10.221952974860242,10.491660840441746
+Early,44,9.786108617,9.761913566948376,10.119088405111514
+Early,48,10.015206566912964,9.845875563835472,10.189985242581589
+Late,0,0.059418625,0.43622598860070966,0.051827353
+Late,4,0.032439186,0.29560196972284575,0.47402815513002483
+Late,8,0.24482615492977228,0.33293636113115616,0.18588304790121768
+Late,12,1.8331570082144877,1.5068034514622044,1.9884429742073217
+Late,16,3.5858548374647796,3.7843160670685094,3.184916367764073
+Late,20,4.454215165716751,3.9987812269179885,4.507405268303338
+Late,24,5.213944309839263,4.7283469122991875,4.606607241602831
+Late,28,4.607051917370045,4.827165416,4.678734126
+Late,32,5.035079704004494,4.6585003935782145,4.863747375143898
+Late,36,5.088830444826097,4.725803807279649,4.991999062797336
+Late,40,4.657881902164966,4.586923631573959,4.980773876820317
+Late,44,4.676904224019542,4.985150713710271,5.478033425560597
+Late,48,5.070358496196444,5.466873701873418,5.129366196

framework/template/data/Flipflop.csv

@@ -0,0 +1,29 @@
+Treatment,time,logB1,logB2,logB3,logA
+Early,6,0.618307,0.592186,0.645986,0.87279
+Early,9,1.02893,1.06471,1.01339,0.424712
+Early,12,0.994658,0.983051,1.05973,-1.55534
+Early,15,1.05152,0.983416,0.908111,-0.695098
+Early,18,0.846355,0.974269,0.904413,
+Early,21,0.723063,0.805485,0.751509,
+Early,24,0.689824,0.696888,0.685623,
+Early,27,0.658967,0.628144,0.601827,
+Early,30,0.5611,0.582111,0.458467,
+Early,33,0.436805,0.400604,0.440984,
+Early,36,0.294066,0.359572,0.356643,
+Early,39,0.25216,0.214981,0.247568,
+Early,42,0.121627,0.108433,0.187433,
+Early,45,0.029532,0.143514,0.120829,
+Early,48,-0.10609,0.00740748,-0.0612848,
+Late,12,0.558655,0.619544,0.512372,
+Late,15,0.761926,0.670076,0.70846,
+Late,18,0.665886,0.780346,0.73632,
+Late,21,0.766747,0.677256,0.68741,
+Late,24,0.607722,0.535357,0.562186,
+Late,27,0.546973,0.459626,0.488894,
+Late,30,0.389318,0.42084,0.372133,
+Late,33,0.292474,0.312211,0.305243,
+Late,36,0.166036,0.254074,0.144361,
+Late,39,0.0581972,0.0541284,0.166602,
+Late,42,0.00909416,-0.0214272,-0.0296765,
+Late,45,-0.042989,-0.116788,-0.127649,
+Late,48,-0.124534,-0.215069,-0.171356,