Fix timepoint specific observables

python/amici/petab_import.py

@@ -459,6 +459,20 @@ def import_model_sbml(
     sbml_importer = amici.SbmlImporter(sbml_model)
     sbml_model = sbml_importer.sbml
 
+    allow_n_noise_pars = \
+        petab.lint.observable_table_has_nontrivial_noise_formula(
+            observable_df
+        )
+    if petab.lint.measurement_table_has_timepoint_specific_mappings(
+        measurement_table,
+        allow_scalar_numeric_noise_parameters=allow_n_noise_pars
+    ):
+        raise ValueError(
+            'AMICI does not support importing models with timepoint specific '
+            'mappings for noise or observable parameters. Please flatten '
+            'the problem and try again.'
+        )
+
     if observable_df is not None:
         observables, noise_distrs, sigmas = \
             get_observation_model(observable_df)
@@ -574,10 +588,10 @@ def import_model_sbml(
 import_model = import_model_sbml
 
 
-def get_observation_model(observable_df: pd.DataFrame
-                          ) -> Tuple[Dict[str, Dict[str, str]],
-                                     Dict[str, str],
-                                     Dict[str, Union[str, float]]]:
+def get_observation_model(
+        observable_df: pd.DataFrame,
+) -> Tuple[Dict[str, Dict[str, str]], Dict[str, str],
+           Dict[str, Union[str, float]]]:
     """
     Get observables, sigmas, and noise distributions from PEtab observation
     table in a format suitable for
@@ -596,13 +610,13 @@ def get_observation_model(observable_df: pd.DataFrame
     observables = {}
     sigmas = {}
 
+    nan_pat = r'^[nN]a[nN]$'
     for _, observable in observable_df.iterrows():
-        oid = observable.name
+        oid = str(observable.name)
         # need to sanitize due to https://github.com/PEtab-dev/PEtab/issues/447
-        pat = r'^[nN]a[nN]$'
-        name = re.sub(pat, '', str(observable.get(OBSERVABLE_NAME, '')))
-        formula_obs = re.sub(pat, '', str(observable[OBSERVABLE_FORMULA]))
-        formula_noise = re.sub(pat, '', str(observable[NOISE_FORMULA]))
+        name = re.sub(nan_pat, '', str(observable.get(OBSERVABLE_NAME, '')))
+        formula_obs = re.sub(nan_pat, '', str(observable[OBSERVABLE_FORMULA]))
+        formula_noise = re.sub(nan_pat, '', str(observable[NOISE_FORMULA]))
         observables[oid] = {'name': name, 'formula': formula_obs}
         sigmas[oid] = formula_noise
 
@@ -617,7 +631,8 @@ def get_observation_model(observable_df: pd.DataFrame
     return observables, noise_distrs, sigmas
 
 
-def petab_noise_distributions_to_amici(observable_df: pd.DataFrame) -> Dict:
+def petab_noise_distributions_to_amici(observable_df: pd.DataFrame
+                                       ) -> Dict[str, str]:
     """
     Map from the petab to the amici format of noise distribution
     identifiers.
@@ -689,6 +704,10 @@ def parse_cli_args():
     parser.add_argument('--no-compile', action='store_false',
                         dest='compile',
                         help='Only generate model code, do not compile')
+    parser.add_argument('--flatten', dest='flatten', default=False,
+                        action='store_true',
+                        help='Flatten measurement specific overrides of '
+                             'observable and noise parameters')
 
     # Call with set of files
     parser.add_argument('-s', '--sbml', dest='sbml_file_name',
@@ -740,6 +759,9 @@ def main():
     # First check for valid PEtab
     petab.lint_problem(pp)
 
+    if args.flatten:
+        petab.flatten_timepoint_specific_output_overrides(pp)
+
     import_model(model_name=args.model_name,
                  sbml_model=pp.sbml_model,
                  condition_table=pp.condition_df,

python/amici/petab_import_pysb.py

@@ -47,8 +47,10 @@ def __init__(self, pysb_model: 'pysb.Model' = None, *args, **kwargs):
         :param args: See :meth:`petab.Problem.__init__`
         :param kwargs: See :meth:`petab.Problem.__init__`
         """
-
+        flatten = kwargs.pop('flatten', False)
         super().__init__(*args, **kwargs)
+        if flatten:
+            petab.flatten_timepoint_specific_output_overrides(self)
 
         self.pysb_model: 'pysb.Model' = pysb_model
         self._add_observation_model()
@@ -108,17 +110,33 @@ def from_files(condition_file: str = None,
                    visualization_files: Union[str, Iterable[str]] = None,
                    observable_files: Union[str, Iterable[str]] = None,
                    pysb_model_file: str = None,
-                   ) -> 'PysbPetabProblem':
+                   flatten: bool = False) -> 'PysbPetabProblem':
         """
         Factory method to load model and tables from files.
 
-        Arguments:
-            condition_file: PEtab condition table
-            measurement_file: PEtab measurement table
-            parameter_file: PEtab parameter table
-            visualization_files: PEtab visualization tables
-            observable_files: PEtab observables tables
-            pysb_model_file: PySB model file
+        :param condition_file:
+            PEtab condition table
+
+        :param measurement_file:
+            PEtab measurement table
+
+        :param parameter_file:
+            PEtab parameter table
+
+        :param visualization_files:
+            PEtab visualization tables
+
+        :param observable_files:
+            PEtab observables tables
+
+        :param pysb_model_file:
+            PySB model file
+
+        :param flatten:
+            Flatten the petab problem
+
+        :return:
+            Petab Problem
         """
 
         condition_df = measurement_df = parameter_df = visualization_df = None
@@ -152,18 +170,27 @@ def from_files(condition_file: str = None,
             measurement_df=measurement_df,
             parameter_df=parameter_df,
             observable_df=observable_df,
-            visualization_df=visualization_df)
+            visualization_df=visualization_df,
+            flatten=flatten
+        )
 
     @staticmethod
-    def from_yaml(yaml_config: Union[Dict, str]) -> 'PysbPetabProblem':
+    def from_yaml(yaml_config: Union[Dict, str],
+                  flatten: bool = False) -> 'PysbPetabProblem':
         """
         Factory method to load model and tables as specified by YAML file.
 
         NOTE: The PySB model is currently expected in the YAML file under
         ``sbml_files``.
 
-        Arguments:
-            yaml_config: PEtab configuration as dictionary or YAML file name
+        :param yaml_config:
+            PEtab configuration as dictionary or YAML file name
+
+        :param flatten:
+            Flatten the petab problem
+
+        :return:
+            Petab Problem
         """
         from petab.yaml import (load_yaml, is_composite_problem,
                                 assert_single_condition_and_sbml_file)
@@ -210,7 +237,8 @@ def from_yaml(yaml_config: Union[Dict, str]) -> 'PysbPetabProblem':
                 for f in problem0.get(VISUALIZATION_FILES, [])],
             observable_files=[
                 os.path.join(path_prefix, f)
-                for f in problem0.get(OBSERVABLE_FILES, [])]
+                for f in problem0.get(OBSERVABLE_FILES, [])],
+            flatten=flatten
         )
 
 

python/sdist/setup.cfg

@@ -41,7 +41,7 @@ include_package_data = True
 zip_safe = False
 
 [options.extras_require]
-petab = petab>=0.1.11
+petab = petab>=0.1.17
 pysb = pysb>=1.11.0
 
 [options.package_data]

tests/benchmark-models/benchmark_models.yaml

@@ -18,8 +18,7 @@ Borghans_BiophysChem1997:
   note: benchmark collection reference value matches up to sign when applying log10-correction +sum(log(meas*log(10)) / 2
 
 Brannmark_JBC2010:
-  llh: 283.778227541074
-  note: unchecked
+  llh: -141.889113770537
 
 #Bruno_JExpBio2016:    None
 
@@ -36,8 +35,7 @@ Elowitz_Nature2000:
   note: benchmark collection reference value matches up to sign when applying log10-correction +sum(log(meas*log(10))) / 2
 
 Fiedler_BMC2016:
-  llh: -117.16780323362
-  note: unchecked
+  llh: 58.58390161681
 
 Fujita_SciSignal2010:
   llh: 53.08749124997969

tests/benchmark-models/test_benchmark_collection.sh

@@ -10,8 +10,10 @@ models="
 Beer_MolBioSystems2014
 Boehm_JProteomeRes2014
 Borghans_BiophysChem1997
+Brannmark_JBC2010
 Crauste_CellSystems2017
 Elowitz_Nature2000
+Fiedler_BMC2016
 Fujita_SciSignal2010
 Schwen_PONE2014
 Sneyd_PNAS2002
@@ -36,12 +38,6 @@ Zheng_PNAS2012"
 # Perelson_Science1996
 # Bruno_JExpBio2016
 #
-# Timepoint-specific parameter overrides
-# Fiedler_BMC2016
-# Brannmark_JBC2010
-# Isensee_JCB2018
-# Sobotta_Frontiers2017
-#
 # yaml missing:
 # Casaletto_PNAS2019
 #
@@ -59,6 +55,9 @@ Zheng_PNAS2012"
 #
 # Evaluation is known to be inconsistent:
 # Chen_MSB2009
+#
+# Integration Failure:
+# Isensee_JCB2018
 
 set -e
 
@@ -91,7 +90,7 @@ for model in $models; do
   yaml="${model_dir}"/"${model}"/"${model}".yaml
   amici_model_dir=test_bmc/"${model}"
   mkdir -p "$amici_model_dir"
-  cmd_import="amici_import_petab --verbose -y ${yaml} -o ${amici_model_dir} -n ${model}"
+  cmd_import="amici_import_petab --verbose -y ${yaml} -o ${amici_model_dir} -n ${model} --flatten"
   cmd_run="$script_path/test_petab_model.py --verbose -y ${yaml} -d ${amici_model_dir} -m ${model} -c"
 
   printf '=%.0s' {1..40}

tests/benchmark-models/test_petab_model.py

@@ -75,6 +75,7 @@ def main():
 
     # load PEtab files
     problem = petab.Problem.from_yaml(args.yaml_file_name)
+    petab.flatten_timepoint_specific_output_overrides(problem)
 
     # load model
     if args.model_directory:

tests/petab_test_suite/test_petab_suite.py

@@ -57,11 +57,14 @@ def _test_case(case, model_type):
         case_dir = os.path.join(petabtests.PYSB_DIR, case)
         # import petab problem
         yaml_file = os.path.join(case_dir, petabtests.problem_yaml_name(case))
-        problem = PysbPetabProblem.from_yaml(yaml_file)
+        problem = PysbPetabProblem.from_yaml(yaml_file,
+                                             flatten=case.startswith('0006'))
     else:
         raise ValueError(f"Unsupported model_type: {model_type}")
 
     # compile amici model
+    if case.startswith('0006') and model_type != "pysb":
+        petab.flatten_timepoint_specific_output_overrides(problem)
     model_output_dir = f'amici_models/model_{case}'
     model = import_petab_problem(
         problem, model_output_dir=model_output_dir,
@@ -83,6 +86,10 @@ def _test_case(case, model_type):
     gt_chi2 = solution[petabtests.CHI2]
     gt_llh = solution[petabtests.LLH]
     gt_simulation_dfs = solution[petabtests.SIMULATION_DFS]
+    if case.startswith('0006'):
+        # account for flattening
+        gt_simulation_dfs[0].loc[:, petab.OBSERVABLE_ID] = ('obs_a__10__c0',
+                                                            'obs_a__15__c0')
     tol_chi2 = solution[petabtests.TOL_CHI2]
     tol_llh = solution[petabtests.TOL_LLH]
     tol_simulations = solution[petabtests.TOL_SIMULATIONS]