Rename py

Author: dweindl

doc/examples/getting_started_extended/GettingStartedExtended.ipynb

@@ -415,7 +415,7 @@
     "print(\n",
     "    \"Simulation was run using model default parameters as specified in the SBML model:\"\n",
     ")\n",
-    "print(dict(zip(model.get_free_parameter_ids(), model.get_parameters())))"
+    "print(dict(zip(model.get_free_parameter_ids(), model.get_free_parameters())))"
    ]
   },
   {
@@ -1111,11 +1111,11 @@
    "source": [
     "# Set model options\n",
     "model = model_module.get_model()\n",
-    "p_orig = np.array(model.get_parameters())\n",
+    "p_orig = np.array(model.get_free_parameters())\n",
     "p_orig[\n",
     "    list(model.get_free_parameter_ids()).index(\"observable_x1withsigma_sigma\")\n",
     "] = 0.1  # Change default parameter\n",
-    "model.set_parameters(p_orig)\n",
+    "model.set_free_parameters(p_orig)\n",
     "model.set_parameter_scale(amici.ParameterScaling.none)\n",
     "model.set_timepoints(np.linspace(0, 10, 21))\n",
     "\n",
@@ -1172,12 +1172,12 @@
     "        p[plist] = x0\n",
     "    verbose and print(f\"f: p={p}\")\n",
     "\n",
-    "    old_parameters = model.get_parameters()\n",
+    "    old_parameters = model.get_free_parameters()\n",
     "    solver.set_sensitivity_order(amici.SensitivityOrder.none)\n",
-    "    model.set_parameters(p)\n",
+    "    model.set_free_parameters(p)\n",
     "    rdata = amici.run_simulation(model, solver, edata)\n",
     "\n",
-    "    model.set_parameters(old_parameters)\n",
+    "    model.set_free_parameters(old_parameters)\n",
     "\n",
     "    res = np.sum(rdata[symbol])\n",
     "    verbose and print(res)\n",
@@ -1194,13 +1194,13 @@
     "        model.require_sensitivities_for_all_parameters()\n",
     "    verbose and print(f\"g: p={p}\")\n",
     "\n",
-    "    old_parameters = model.get_parameters()\n",
+    "    old_parameters = model.get_free_parameters()\n",
     "    solver.set_sensitivity_method(amici.SensitivityMethod.forward)\n",
     "    solver.set_sensitivity_order(amici.SensitivityOrder.first)\n",
-    "    model.set_parameters(p)\n",
+    "    model.set_free_parameters(p)\n",
     "    rdata = amici.run_simulation(model, solver, edata)\n",
     "\n",
-    "    model.set_parameters(old_parameters)\n",
+    "    model.set_free_parameters(old_parameters)\n",
     "\n",
     "    res = rdata[f\"s{symbol}\"]\n",
     "    if not isinstance(res, float):\n",
@@ -1255,7 +1255,7 @@
    "outputs": [],
    "source": [
     "eps = 1e-4\n",
-    "op = model.get_parameters()\n",
+    "op = model.get_free_parameters()\n",
     "\n",
     "\n",
     "solver.set_sensitivity_method(\n",
@@ -1271,23 +1271,23 @@
     "\n",
     "def fd(x0, ip, eps, symbol=\"llh\"):\n",
     "    p = list(x0[:])\n",
-    "    old_parameters = model.get_parameters()\n",
+    "    old_parameters = model.get_free_parameters()\n",
     "    solver.set_sensitivity_order(amici.SensitivityOrder.none)\n",
     "    p[ip] += eps\n",
-    "    model.set_parameters(p)\n",
+    "    model.set_free_parameters(p)\n",
     "    rdata_f = amici.run_simulation(model, solver, edata)\n",
     "    p[ip] -= 2 * eps\n",
-    "    model.set_parameters(p)\n",
+    "    model.set_free_parameters(p)\n",
     "    rdata_b = amici.run_simulation(model, solver, edata)\n",
     "\n",
-    "    model.set_parameters(old_parameters)\n",
+    "    model.set_free_parameters(old_parameters)\n",
     "    return (rdata_f[symbol] - rdata_b[symbol]) / (2 * eps)\n",
     "\n",
     "\n",
     "def plot_sensitivities(symbol, eps):\n",
     "    fig, axes = plt.subplots(4, 2, figsize=(15, 10))\n",
     "    for ip in range(4):\n",
-    "        fd_approx = fd(model.get_parameters(), ip, eps, symbol=symbol)\n",
+    "        fd_approx = fd(model.get_free_parameters(), ip, eps, symbol=symbol)\n",
     "\n",
     "        axes[ip, 0].plot(\n",
     "            edata.get_timepoints(), rdata[f\"s{symbol}\"][:, ip, :], \"r-\"\n",

python/sdist/amici/debugging/__init__.py

@@ -36,7 +36,7 @@ def get_model_for_preeq(model: amici.Model, edata: amici.ExpData):
     if edata.pscale:
         model.set_parameter_scale(edata.pscale)
     if edata.free_parameters:
-        model.set_parameters(edata.free_parameters)
+        model.set_free_parameters(edata.free_parameters)
     if edata.plist:
         model.set_parameter_list(edata.plist)
     model.set_initial_state(edata.x0)

python/sdist/amici/gradient_check.py

@@ -71,7 +71,7 @@ def check_finite_difference(
 
     # store original settings and apply new ones
     og_sensitivity_order = solver.get_sensitivity_order()
-    og_parameters = model.get_parameters()
+    og_parameters = model.get_free_parameters()
     og_plist = model.get_parameter_list()
     if edata:
         og_eplist = edata.plist
@@ -88,7 +88,7 @@ def check_finite_difference(
         model.set_parameter_list(plist)
 
     model.set_parameter_scale(pscale)
-    model.set_parameters(p)
+    model.set_free_parameters(p)
 
     # simulation with gradient
     if int(og_sensitivity_order) < int(SensitivityOrder.first):
@@ -110,13 +110,13 @@ def check_finite_difference(
         pb[ip] /= 1 + epsilon / 2
 
     # forward:
-    model.set_parameters(pf)
+    model.set_free_parameters(pf)
     rdataf = run_simulation(model, solver, edata)
     if rdataf["status"] != AMICI_SUCCESS:
         raise AssertionError(f"Simulation failed (status {rdataf['status']}")
 
     # backward:
-    model.set_parameters(pb)
+    model.set_free_parameters(pb)
     rdatab = run_simulation(model, solver, edata)
     if rdatab["status"] != AMICI_SUCCESS:
         raise AssertionError(f"Simulation failed (status {rdatab['status']}")
@@ -146,7 +146,7 @@ def check_finite_difference(
         )
 
     solver.set_sensitivity_order(og_sensitivity_order)
-    model.set_parameters(og_parameters)
+    model.set_free_parameters(og_parameters)
     model.set_parameter_list(og_plist)
     if edata:
         edata.plist = og_eplist
@@ -182,7 +182,7 @@ def check_derivatives(
     if edata and edata.free_parameters:
         p = np.array(edata.free_parameters)
     else:
-        p = np.array(model.get_parameters())
+        p = np.array(model.get_free_parameters())
 
     og_sens_order = solver.get_sensitivity_order()
 

python/sdist/amici/pandas.py

@@ -421,7 +421,7 @@ def _fill_conditions_dict(
         if len(edata.free_parameters):
             datadict[par] = edata.free_parameters[i_par]
         else:
-            datadict[par] = model.get_parameters()[i_par]
+            datadict[par] = model.get_free_parameters()[i_par]
 
         if len(edata.pscale):
             datadict[par + "_scale"] = edata.pscale[i_par]

python/sdist/amici/petab/petab_importer.py

@@ -681,7 +681,7 @@ def __init__(
         # create a new model instance from the model module from which
         #  we can get the default parameters
         model0 = model.module.get_model()
-        self._original_p = np.array(model0.get_parameters())
+        self._original_p = np.array(model0.get_free_parameters())
         self._original_k = np.array(model0.get_fixed_parameters())
 
     def create_edatas(self) -> list[amici.ExpData]:

python/sdist/amici/swig_wrappers.py

@@ -266,7 +266,7 @@ def _ids_and_names_to_rdata(
         "state",
         "observable",
         "expression",
-        "parameter",
+        "free_parameter",
         "fixed_parameter",
     ):
         for name_or_id in ("ids", "names"):

python/tests/test_edata.py

@@ -28,7 +28,7 @@ def test_edata_sensi_unscaling(model_units_module):  # noqa: F811
     model = model_units_module.get_model()
     model.set_timepoints(np.linspace(0, 1, 3))
     model.set_parameter_scale(parameter_scales_log10)
-    model.set_parameters(parameters0)
+    model.set_free_parameters(parameters0)
 
     solver = model.create_solver()
     solver.set_sensitivity_order(amici.SensitivityOrder.first)

python/tests/test_jax.py

@@ -129,10 +129,10 @@ def _test_model(amici_module, jax_module, ts, p, k):
 
     jax_model = jax_module.Model()
 
-    amici_model.set_parameters(np.asarray(p, dtype=np.float64))
+    amici_model.set_free_parameters(np.asarray(p, dtype=np.float64))
     amici_model.set_fixed_parameters(np.asarray(k, dtype=np.float64))
     edata = amici.ExpData(sol_amici_ref, 1.0, 1.0)
-    edata.free_parameters = amici_model.get_parameters()
+    edata.free_parameters = amici_model.get_free_parameters()
     edata.fixed_parameters = amici_model.get_fixed_parameters()
     edata.pscale = amici_model.get_parameter_scale()
     amici_solver = amici_model.create_solver()

python/tests/test_preequilibration.py

@@ -279,9 +279,11 @@ def test_parameter_in_expdata(preeq_fixture):
     model.set_parameter_list([i for i in reversed(model.get_parameter_list())])
 
     # set ExpData parameters
-    edata.free_parameters = model.get_parameters()
+    edata.free_parameters = model.get_free_parameters()
     # perturb model parameters
-    model.set_parameters(tuple(p * 2 for p in model.get_parameters()))
+    model.set_free_parameters(
+        tuple(p * 2 for p in model.get_free_parameters())
+    )
 
     # set ExpData pscale
     edata.pscale = model.get_parameter_scale()

python/tests/test_pysb.py

@@ -239,7 +239,7 @@ def test_compare_to_pysb_simulation(example):
                                 ParameterScaling.log10
                                 if p > 0
                                 else ParameterScaling.none
-                                for p in model_pysb.get_parameters()
+                                for p in model_pysb.get_free_parameters()
                             ]
                         )
                     )