morphgen-rates 0.4.0__py3-none-any.whl

morphgen_rates/__init__.py

@@ -0,0 +1,4 @@
+from .rates import compute_rates
+from .data import get_data
+from .init_count import compute_init_number_probs
+__all__ = ["compute_rates", "get_data", "compute_init_number_probs"]

morphgen_rates/data.py

@@ -0,0 +1,147 @@
+import pandas as pd
+from pathlib import Path
+
+
+def _local_data_path(filename='morph_data', ext="csv"):
+  """
+  Build a path like: <this_file_dir>/data/<filename>.<ext>
+
+  Parameters
+  ----------
+  filename : str
+      Base filename (without extension)
+  ext : str, default "csv"
+      File extension (without the dot)
+
+  Returns
+  -------
+  pathlib.Path
+      Full path to the data file
+  """
+  work_dir = Path(__file__).resolve().parent
+  return work_dir / f"{filename}.{ext}"
+
+
+def get_data(key):
+  """
+  Retrieve a dataset entry using a key-path of the form
+  "<brain region>/<neuron class>/<subcellular section>".
+
+  The argument `data_path` is interpreted as a slash-separated path of keys used
+  to traverse a nested dataset dictionary. The selected dataset is expected to
+  contain both Sholl-plot statistics and bifurcation statistics; when both are
+  available, this function returns a standardized dictionary compatible with
+  `compute_rates`.
+
+  Parameters
+  ----------
+  key : str
+      Dataset identifier expressed as a key path:
+
+      "<brain region>/<neuron class>/<subcellular section>"
+
+      Examples:
+      - "CTX/pyr/apical"
+      - "HPC/pyr/basal"
+
+      Each component is used as a successive key lookup into the nested dataset
+      container.
+
+  Returns
+  -------
+  dict
+      If both Sholl and bifurcation information are present for the selected dataset,
+      returns:
+
+      data = {
+        "sholl": {
+          "bin_size": float,
+          "mean": numpy.ndarray,   # shape (K,)
+          "var":  numpy.ndarray,   # shape (K,)
+        },
+        "bifurcations": {
+          "mean": float,
+          "var":  float,
+        },
+      }
+
+      Where:
+      - `data["sholl"]["bin_size"]` is the spatial bin size used to define Sholl shells
+      - `data["sholl"]["mean"]` is the mean Sholl intersection count per radial bin
+      - `data["sholl"]["var"]` is the variance of the Sholl intersection count per bin
+      - `data["bifurcations"]["mean"]` is the mean bifurcation count
+      - `data["bifurcations"]["var"]` is the variance of the bifurcation count
+
+  Raises
+  ------
+  KeyError
+      If any key along `data_path` is missing (brain region, neuron class, or section)
+  ValueError
+      If the selected dataset does not contain both Sholl and bifurcation data, or
+      if the provided arrays have incompatible shapes
+
+  Notes
+  -----
+  - `data_path` is a *key path*, not a filesystem path
+  - The function assumes the dataset entry referenced by `data_path` includes:
+      - Sholl bin size, mean array, variance array
+      - Bifurcation mean and variance
+
+  Examples
+  --------
+  >>> data = get("CTX/pyr/apical")
+  >>> data["sholl"]["bin_size"]
+  50.0
+  >>> data["bifurcations"]["mean"]
+  12.3
+  """
+  data = {}
+
+  # split the key
+  parts = tuple(p.strip() for p in key.split("/") if p.strip())
+  if len(parts) != 2:
+      raise ValueError(f"Expected key like 'area/neuron_type', got: {key!r}")
+  area, neuron_type = parts
+    
+  # load data
+  df = pd.read_csv(_local_data_path(), index_col=0)
+
+  # select specific area and neuron type
+  df = df[(df['area'] == area) & (df['neuron_type'] == neuron_type)]
+  
+  # neuron name unnecessary
+  df.drop(['area', 'neuron_type', 'neuron_name'], axis=1, inplace=True)
+
+  # statistics
+  df = df.groupby('section_type').describe()
+
+  # select only a subset of columns
+  df = df.loc[:, df.columns.get_level_values(1).isin(['mean', 'std', 'min', 'max'])]
+
+  # get subsections
+  for section_type, row in df.iterrows():
+    data[section_type] = {}
+
+    print()
+
+    # get statistics
+    for data_type in ['bifurcation_count', 'total_length']:
+      tmp = row.loc[row.index.get_level_values(0) == data_type, :]
+      tmp.index = tmp.index.droplevel(0)
+      data[section_type][data_type] = tmp.to_dict()
+
+    # count neurites at the soma
+    tmp = row.loc[row.index.get_level_values(0) == 'Count0', :]
+    tmp.index = tmp.index.droplevel(0)
+    data[section_type]['primary_count'] = tmp.to_dict()
+    
+    # sholl plots
+    tmp = row.loc[row.index.get_level_values(0).str.startswith('Count'), :]
+    data[section_type]['sholl_plot'] = {
+      'bin_size':row[('bin_size', 'mean')].tolist(),
+      'mean':tmp.loc[tmp.index.get_level_values(1) == 'mean', :].tolist(),
+      'std':tmp.loc[tmp.index.get_level_values(1) == 'std', :].tolist()
+      }
+
+  return data
+

morphgen_rates/init_count.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+from typing import Dict, Optional, Sequence, Union
+
+import numpy as np
+import pyomo.environ as pyo
+
+
+def compute_init_number_probs(
+    mean_primary_dendrites: float,
+    sd_primary_dendrites: float,
+    min_primary_dendrites: int,
+    max_primary_dendrites: int,
+    *,
+    support_values: Optional[Sequence[float]] = None,
+    epsilon: float = 1e-12,
+    slack_penalty: float = 1e-1,
+    use_variance_form: bool = True,
+    use_abs_slack: bool = False,
+    solver: str = "ipopt",
+    solver_options: Optional[Dict[str, Union[str, int, float]]] = None,
+) -> np.ndarray:
+    """
+    Maximum-entropy PMF for the (discrete) number of primary dendrites.
+
+    This returns a numpy array p of length n = max_primary_dendrites + 1, where:
+      - p[i] is the probability of observing i primary dendrites
+      - p[i] = 0 for i < min_primary_dendrites or i > max_primary_dendrites
+
+    The distribution is obtained by maximizing Shannon entropy:
+        H(p) = -sum_i p[i] * log(p[i])
+
+    Subject to:
+      - Normalization: sum_{i in [min,max]} p[i] = 1
+      - Soft mean constraint (with slack):
+            sum i*p[i] - mean_primary_dendrites = slack_mean
+      - Soft dispersion constraint (with slack):
+        If use_variance_form=True (recommended):
+            sum (i-mean)^2 * p[i] - (sd_primary_dendrites^2) = slack_disp
+        If use_variance_form=False:
+            sqrt( sum (i-mean)^2 * p[i] + tiny ) - sd_primary_dendrites = slack_disp
+
+    The objective is penalized to keep slacks small:
+        maximize  H(p) - slack_penalty * (slack terms)
+
+    Parameters
+    ----------
+    mean_primary_dendrites : float
+        Target mean number of primary dendrites
+    sd_primary_dendrites : float
+        Target standard deviation (>= 0)
+    min_primary_dendrites : int
+        Minimum allowed dendrite count (inclusive)
+    max_primary_dendrites : int
+        Maximum allowed dendrite count (inclusive). Also sets array length n=max+1
+
+    Keyword-only parameters
+    ----------------------
+    support_values : Sequence[float] | None
+        Optional support for indices 0..max. If None, uses support=i (integers).
+        Keep this None if you truly mean "i is the dendrite count".
+    epsilon : float
+        Lower bound on active probabilities to avoid log(0)
+    slack_penalty : float
+        Larger values enforce closer moment matching
+    use_variance_form : bool
+        Recommended True: match variance to sd^2 (smoother than sqrt constraint)
+    use_abs_slack : bool
+        If True, use L1-like slack penalty via +/- variables; otherwise squared (smooth)
+    solver : str
+        Nonlinear solver name (typically "ipopt")
+    solver_options : dict | None
+        Passed to the solver (e.g., {"max_iter": 5000})
+
+    Returns
+    -------
+    np.ndarray
+        Probability vector p with length max_primary_dendrites + 1
+
+    Raises
+    ------
+    ValueError
+        For invalid inputs
+    RuntimeError
+        If the requested solver is not available
+    """
+    if max_primary_dendrites < 0:
+        raise ValueError("max_primary_dendrites must be >= 0")
+    if sd_primary_dendrites < 0:
+        raise ValueError("sd_primary_dendrites must be nonnegative")
+    if not (0 <= min_primary_dendrites <= max_primary_dendrites):
+        raise ValueError("Require 0 <= min_primary_dendrites <= max_primary_dendrites")
+    if slack_penalty <= 0:
+        raise ValueError("slack_penalty must be positive")
+    if epsilon <= 0:
+        raise ValueError("epsilon must be positive")
+
+    n = max_primary_dendrites + 1
+    active = list(range(min_primary_dendrites, max_primary_dendrites + 1))
+
+    # Support values for each index i (default: i itself)
+    if support_values is None:
+        support_values = list(range(n))
+    if len(support_values) != n:
+        raise ValueError("support_values must have length n = max_primary_dendrites + 1")
+
+    support = {i: float(support_values[i]) for i in range(n)}
+    mu = float(mean_primary_dendrites)
+    sd = float(sd_primary_dendrites)
+    target_var = sd * sd
+
+    # -----------------------------
+    # Pyomo model
+    # -----------------------------
+    m = pyo.ConcreteModel()
+    m.A = pyo.Set(initialize=active, ordered=True)
+
+    # Decision variables for active probabilities only
+    m.p = pyo.Var(m.A, domain=pyo.NonNegativeReals, bounds=(epsilon, 1.0))
+
+    # Normalization over active set
+    m.norm = pyo.Constraint(expr=sum(m.p[i] for i in m.A) == 1.0)
+
+    # Moment expressions
+    mean_expr = sum(support[i] * m.p[i] for i in m.A)
+    var_expr = sum((support[i] - mu) ** 2 * m.p[i] for i in m.A)
+
+    # Soft constraints with slack
+    if use_abs_slack:
+        # L1 slack via +/- decomposition
+        m.s_mean_pos = pyo.Var(domain=pyo.NonNegativeReals)
+        m.s_mean_neg = pyo.Var(domain=pyo.NonNegativeReals)
+        m.s_disp_pos = pyo.Var(domain=pyo.NonNegativeReals)
+        m.s_disp_neg = pyo.Var(domain=pyo.NonNegativeReals)
+
+        m.mean_soft = pyo.Constraint(expr=mean_expr - mu == m.s_mean_pos - m.s_mean_neg)
+
+        if use_variance_form:
+            m.disp_soft = pyo.Constraint(expr=var_expr - target_var == m.s_disp_pos - m.s_disp_neg)
+        else:
+            tiny = 1e-18
+            m.disp_soft = pyo.Constraint(
+                expr=pyo.sqrt(var_expr + tiny) - sd == m.s_disp_pos - m.s_disp_neg
+            )
+
+        slack_term = (m.s_mean_pos + m.s_mean_neg) + (m.s_disp_pos + m.s_disp_neg)
+
+    else:
+        # Smooth squared slacks
+        m.s_mean = pyo.Var(domain=pyo.Reals)
+        m.s_disp = pyo.Var(domain=pyo.Reals)
+
+        m.mean_soft = pyo.Constraint(expr=mean_expr - mu == m.s_mean)
+
+        if use_variance_form:
+            m.disp_soft = pyo.Constraint(expr=var_expr - target_var == m.s_disp)
+        else:
+            tiny = 1e-18
+            m.disp_soft = pyo.Constraint(expr=pyo.sqrt(var_expr + tiny) - sd == m.s_disp)
+
+        slack_term = m.s_mean**2 + m.s_disp**2
+
+    # Entropy objective (active probs only; inactive probs are exactly 0)
+    entropy = -sum(m.p[i] * pyo.log(m.p[i]) for i in m.A)
+    m.obj = pyo.Objective(expr=entropy - float(slack_penalty) * slack_term, sense=pyo.maximize)
+
+    # Solve
+    opt = pyo.SolverFactory(solver)
+    if opt is None or not opt.available():
+        raise RuntimeError(
+            f"Solver '{solver}' is not available. Install/configure it (e.g., ipopt) "
+            "or pass a different solver name."
+        )
+    if solver_options:
+        for k, v in solver_options.items():
+            opt.options[k] = v
+
+    res = opt.solve(m, tee=False)
+
+    # -----------------------------
+    # Extract solution into numpy array
+    # -----------------------------
+    p = np.zeros(n, dtype=float)
+    for i in active:
+        p[i] = float(pyo.value(m.p[i]))
+
+    # Optional: renormalize tiny numerical drift (keeps zeros outside band)
+    s = p.sum()
+    if s > 0:
+        p[active] /= s
+
+    return p
+
+
+if __name__ == "__main__":
+    p = maxent_primary_dendrite_pmf(
+        mean_primary_dendrites=2.33,
+        sd_primary_dendrites=1.53,
+        min_primary_dendrites=1,
+        max_primary_dendrites=4,
+        slack_penalty=0.1,
+        use_variance_form=True,
+        use_abs_slack=False,
+        solver="ipopt",
+    )
+    print("p shape:", p.shape)
+    print("sum:", p.sum())
+    print(p)

morphgen_rates/rates.py

@@ -0,0 +1,172 @@
+from pyomo.environ import *
+import numpy as np
+
+_Mean_Penalty=0
+_Var_Penalty=1.0
+
+def mk_objective(model, kappa, Z, V):
+    
+    def getA_term(model, kappa, Z, V, m, i):
+        return model.b[m] * 2 * Z[i] ** 2 * (Z[m + 1] - Z[m]) / (Z[m + 1] * Z[m]) / kappa[m]
+
+    def getB_term(kappa, Z, V, m):
+        return (Z[m + 1] - Z[m]) / (Z[m + 1] * Z[m])
+    
+
+    terms = []
+    for i in range(1, kappa.size + 1):
+        B = (V[0] - sum(getB_term(kappa, Z, V, m) for m in range(0, i))) * (Z[i] ** 2)
+        terms += [2 * getA_term(model, kappa, Z, V, m, i) * (B - V[i]) for m in range(0, i) ]              
+        terms += [getA_term(model, kappa, Z, V, m, i) * getA_term(model, kappa, Z, V, n, i) for m in range(0, i) for n in range(0, i)]
+    return sum(terms)
+
+def compute_rates(data, max_step_size):
+    """
+    Compute bifurcation and annihilation rates from summary statistics.
+
+    The estimator expects Sholl-plot summary statistics (mean and variance per
+    radial bin) and summary statistics of bifurcation counts (mean and variance).
+    These quantities are used to infer the event rates of a branching-and-
+    annihilating process.
+
+    Parameters
+    ----------
+    data : dict
+      Input container with the following structure:
+
+      data = {
+        "sholl_plot": {
+          "bin_size": float,
+          "mean": numpy.ndarray,   # shape (K,)
+          "var":  numpy.ndarray,   # shape (K,)
+        },
+        "bifurcation_count": {
+          "mean": float,
+          "var":  float,
+        },
+      }
+
+      Where:
+      - `data["sholl_plot"]["bin_size"]` is the spatial bin size used to build the Sholl plot
+      - `data["sholl_plot"]["mean"][i]` is the mean Sholl intersection count in bin i
+      - `data["sholl_plot"]["var"][i]` is the variance of the Sholl intersection count in bin i
+      - `data["bifurcation_count"]["mean"]` is the mean number of bifurcations
+      - `data["bifurcation_count"]["var"]` is the variance of the number of bifurcations
+
+    max_step_size : float
+      Maximum advancement (in distance from the soma) allowed for a single
+      elongation step in the model. This value bounds the radial increment used
+      by the estimator and should be expressed in the same spatial units as the
+      Sholl binning.
+
+    Returns
+    -------
+    dict
+      Dictionary containing the estimated rates and any additional derived values
+      produced by the implementation. At minimum, the returned dictionary is
+      expected to include:
+
+      - "bifurcation_rate"
+      - "annihilation_rate"
+
+    Notes
+    -----
+    - `data["sholl_plot"]["mean"]` and `data["sholl_plot"]["var"]` must be 1D arrays of equal length
+    - Variances must be non-negative
+    - Ensure `bin_size` and `max_step_size` use consistent spatial units
+    """    
+
+##    Solves a QP problem using Pyomo with vector-style variable indexing.
+##
+##    Minimize: 0.5*x[0]^2 + x[1]^2 + x[0]*x[1] + 3*x[0]
+##    Subject to: x[0] + x[1] >= 1, x[i] >= 0
+##
+##    Returns:
+##        np.ndarray: [x[0], x[1], objective_value]
+
+
+    global _Mean_Penalty, _Var_Penalty
+    dx = data['sholl_plot']['bin_size']
+
+    min_zero_bin = min(data['sholl_plot']['mean'].index(0), data['sholl_plot']['std'].index(0))
+    
+    Z =  np.array(data['sholl_plot']['mean'][:min_zero_bin])
+    V = np.power(data['sholl_plot']['std'][:min_zero_bin], 2)
+
+    if 'bifurcations' in data:
+        n_bif = [data['bifurcation_count']['mean'], data['bifurcation_count']['std'] ** 2]
+    else:
+        n_bif = None
+
+    # get the kappa
+    kappa = np.log(Z[1:] / Z[:-1]) / dx
+
+    if np.any(kappa == 0):
+        kappa += 1e-5
+        
+    model = ConcreteModel()
+
+    # Define index set and variables
+    model.b = Var(range(kappa.size), domain=NonNegativeReals)
+
+    # define 1 slack variables for eventual constraints of variance of bifurcations
+    model.s = Var(range(2), domain=Reals)
+            
+    # Constraint: 
+    model.constraints = ConstraintList()
+    for i in range(kappa.size):
+        model.constraints.add(model.b[i] >= kappa[i])
+        model.constraints.add((2 * model.b[i] - kappa[i]) * max_step_size <= 1)
+
+    # if we have number of bifurcations as contraings
+    if n_bif:        
+        # constraint the average number of bifurcations
+        if n_bif[0]:
+            f = (Z[1:] - Z[:-1]) / kappa
+            model.constraints.add(sum(f[i] * model.b[i] for i in range(kappa.size)) == n_bif[0])
+        
+        # constrain the variance for the number of bifurcations
+        if n_bif[1]:            
+            f1 = (Z[1:] - Z[:-1]) / kappa
+            f2 = - Z[:-1] * (np.power(Z[1:] / Z[:-1], 2) - 2 * kappa * dx * Z[1:] / Z[:-1] - 1) / kappa ** 2 + V[:-1] * np.power((Z[1:] - Z[:-1]) / Z[:-1] / kappa, 2)
+            f3 = 2 * Z[:-1] * (np.power(Z[1:] / Z[:-1], 2) - 2 * kappa * dx * Z[1:] / Z[:-1] - 1) / kappa ** 3
+            
+            var_terms = [ ]
+            for i in range(kappa.size):
+                var_terms.append(f1[i] * model.b[i] + f2[i] * model.b[i] ** 2 + f3[i] * model.b[i] ** 3)
+
+            for i in range(1, kappa.size):
+                for j in range(i + 1, kappa.size + 1):
+                    term1 = model.b[i - 1] * (Z[i] - Z[i - 1])/  Z[i - 1] / kappa[i - 1] 
+                    term2 = model.b[j - 1] * (Z[j] - Z[j - 1]) / Z[j - 1] / kappa[j - 1]
+                    for k in range(1, i + 1):
+                        if k == 1:
+                            Vprev = V[0]
+                        term3 = (2 * model.b[k - 1] - kappa[k - 1]) / kappa[k - 1] * Z[k] * (Z[k] - Z[k - 1]) / Z[k - 1] + Vprev * np.power(Z[k] / Z[k - 1], 2)
+                        var_terms.append(2 * term1 * term2 * Z[j - 1] / Z[i - 1] * term3)
+                        Vprev = term3
+                
+            model.constraints.add(sum(var_terms) + model.s[1] == n_bif[1]) 
+
+    # Objective
+    model.obj = Objective(
+        expr=mk_objective(model, kappa, Z, V) + _Mean_Penalty * model.s[0] ** 2 + _Var_Penalty * model.s[1] ** 2,
+        sense=minimize
+    )
+
+    
+    # Solve
+    solver = SolverFactory('ipopt')
+    #solver.options['max_iter'] = max_iter
+    solver.solve(model, tee=False)
+    #print("Objective value:", value(model.obj))
+    #print(value(model.s))
+    
+    # Extract bifurcation rates as array
+    b = np.array([value(model.b[i]) for i in model.b])
+    b[b < 0] = 0.
+
+    # calculate annihilation rates
+    a = - kappa + b
+    a[a < 0] = 0.
+    return { 'bifurcation_rate':b, 'annihilation_rate':a }

morphgen_rates-0.4.0.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: morphgen-rates
+Version: 0.4.0
+Summary: Compute bifurcation and annihilation rates from morphology data
+Author-email: Francesco Cavarretta <fcavarretta@ualr.edu>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: pyomo>=6.6
+Dynamic: license-file
+
+# morphgen-rates
+
+Python package to compute **bifurcation** and **annihilation** rates from morphology-derived data.
+
+## Provenance
+
+This package is based on code originally provided in the repository:
+
+- https://github.com/FrancescoCavarretta/NeuronSynthesis
+
+The original repository was developed for the following publication:
+
+- Cavarretta F (2025) *A mathematical model for data-driven synthesis of neuron morphologies based on random walks.* Front. Appl. Math. Stat. 11:1632271. doi: 10.3389/fams.2025.1632271
+
+
+## Quick start
+
+```python
+from morphgen_rates import compute_rates
+
+# Replace `data` with your input object (events, traces, or morphology structures)
+rates = compute_rates(data)
+
+print(rates["bifurcation_rate"])
+print(rates["annihilation_rate"])
+```
+
+
+## License
+
+GPL-3.0-or-later
+

morphgen_rates-0.4.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+morphgen_rates/__init__.py,sha256=UE8YWsulDIfeYhGb5GHdkakUIFx4j9H3ZkoKoaDCd_0,179
+morphgen_rates/data.py,sha256=yj_GT3ks6ukwtALfC4Bklcwu3MeTOr-2BGGo5W0ZxM0,4330
+morphgen_rates/init_count.py,sha256=PhYlp0-CzRdf8opTKb-om3cFIKSv5M8eTcyKy1_IFMI,7283
+morphgen_rates/rates.py,sha256=2Gn3Ew2uVJ7c_LdYJogxS-jAM9q-039y0maWi4CNpTM,6442
+morphgen_rates-0.4.0.dist-info/licenses/LICENSE,sha256=VONsnKVXQRcWwCaHWHuwMtemIj9jNJSmpunazxlyvOk,670
+morphgen_rates-0.4.0.dist-info/METADATA,sha256=Xb088-i11lgv8rY4jVvQ3ghYDpyliSw83yjC-kfYANw,1178
+morphgen_rates-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+morphgen_rates-0.4.0.dist-info/top_level.txt,sha256=UYPGC2dGp9xD_4iVxVVTkKaizBA4XeDNM7OBC_DCWRk,15
+morphgen_rates-0.4.0.dist-info/RECORD,,

morphgen_rates-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

morphgen_rates-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,16 @@
+morphgen-rates
+
+Copyright (C) 2025 Francesco Cavarretta
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.

morphgen_rates-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+morphgen_rates