diff --git a/.github/workflows/unit-test-python-versions.yml b/.github/workflows/unit-test-python-versions.yml
index c7b0f930..177386b2 100644
--- a/.github/workflows/unit-test-python-versions.yml
+++ b/.github/workflows/unit-test-python-versions.yml
@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.7, 3.8, 3.9]
+        python-version: ['3.9', '3.10', '3.11']
 
     steps:
       - uses: actions/checkout@v1
@@ -24,7 +24,7 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
           architecture: x64
-          
+
       - name: install sundials
         run: |
           sudo apt-get update
diff --git a/LICENSE.md b/LICENSE.md
index bac41ad3..3da5425a 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2022, David Augustin
+Copyright (c) 2023, David Augustin
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
diff --git a/chi/_error_models.py b/chi/_error_models.py
index 5c3f083e..9208570f 100644
--- a/chi/_error_models.py
+++ b/chi/_error_models.py
@@ -1791,7 +1791,7 @@ def fix_parameters(self, name_value_dict):
             self._fixed_params_values[index] = value
 
         # If all parameters are free, set mask and values to None again
-        if np.alltrue(~self._fixed_params_mask):
+        if np.all(~self._fixed_params_mask):
             self._fixed_params_mask = None
             self._fixed_params_values = None
 
diff --git a/chi/_log_pdfs.py b/chi/_log_pdfs.py
index fc4271d2..5323ce7d 100644
--- a/chi/_log_pdfs.py
+++ b/chi/_log_pdfs.py
@@ -130,8 +130,8 @@ def __call__(self, parameters):
             top_parameters, bottom_parameters, covariates=self._covariates)
 
         # Return if values already lead to a rejection
-        if np.isinf(score):
-            return score
+        if np.isinf(score):  # noqa: no cover
+            return score  # noqa: no cover
 
         # Transform bottom-level parameters
         # Identity, if model does not tranform parameters
diff --git a/chi/_mechanistic_models.py b/chi/_mechanistic_models.py
index f58b885f..e8378b13 100644
--- a/chi/_mechanistic_models.py
+++ b/chi/_mechanistic_models.py
@@ -986,7 +986,7 @@ def fix_parameters(self, name_value_dict):
             self._fixed_params_values[index] = value
 
         # If all parameters are free, set mask and values to None again
-        if np.alltrue(~self._fixed_params_mask):
+        if np.all(~self._fixed_params_mask):
             self._fixed_params_mask = None
             self._fixed_params_values = None
 
diff --git a/chi/_population_models.py b/chi/_population_models.py
index ea717b6b..3648c18f 100644
--- a/chi/_population_models.py
+++ b/chi/_population_models.py
@@ -3274,7 +3274,7 @@ def fix_parameters(self, name_value_dict):
             self._fixed_params_values[index] = value
 
         # If all parameters are free, set mask and values to None again
-        if np.alltrue(~self._fixed_params_mask):
+        if np.all(~self._fixed_params_mask):
             self._fixed_params_mask = None
             self._fixed_params_values = None
 
diff --git a/chi/plots/_time_series.py b/chi/plots/_time_series.py
index 29291909..2cfa25be 100644
--- a/chi/plots/_time_series.py
+++ b/chi/plots/_time_series.py
@@ -149,11 +149,11 @@ def _compute_bulk_probs(self, data, bulk_probs, time_key, sample_key):
                 biom_upper = reduced_data[mask][sample_key].min()
 
                 # Append percentiles to container
-                container = container.append(pd.DataFrame({
+                container = pd.concat([container, pd.DataFrame({
                     'Time': [time],
                     'Lower': [biom_lower],
                     'Upper': [biom_upper],
-                    'Bulk probability': [str(bulk_prob)]}))
+                    'Bulk probability': [str(bulk_prob)]})])
 
         return container
 
@@ -538,11 +538,11 @@ def _compute_bulk_probs(self, data, bulk_probs, time_key, sample_key):
                 biom_upper = reduced_data[mask][sample_key].min()
 
                 # Append percentiles to container
-                container = container.append(pd.DataFrame({
+                container = pd.concat([container, pd.DataFrame({
                     'Time': [time],
                     'Lower': [biom_lower],
                     'Upper': [biom_upper],
-                    'Bulk probability': [str(bulk_prob)]}))
+                    'Bulk probability': [str(bulk_prob)]})])
 
         return container
 
diff --git a/chi/tests/test_error_models.py b/chi/tests/test_error_models.py
index 98e1b675..cc2205b6 100644
--- a/chi/tests/test_error_models.py
+++ b/chi/tests/test_error_models.py
@@ -1487,11 +1487,11 @@ def test_set_get_parameter_names(self):
         self.error_model.fix_parameters(name_value_dict={
             'Sigma base': 1})
         self.error_model.set_parameter_names(
-            ['myokit.tumour_volume Sigma rel.'])
+            ['global.tumour_volume Sigma rel.'])
 
         names = self.error_model.get_parameter_names()
         self.assertEqual(len(names), 1)
-        self.assertEqual(names[0], 'myokit.tumour_volume Sigma rel.')
+        self.assertEqual(names[0], 'global.tumour_volume Sigma rel.')
 
         # Reset to defaults
         self.error_model.set_parameter_names(None)
diff --git a/chi/tests/test_inference.py b/chi/tests/test_inference.py
index a39d3285..5a552607 100644
--- a/chi/tests/test_inference.py
+++ b/chi/tests/test_inference.py
@@ -223,7 +223,7 @@ def test_call(self):
         self.assertEqual(draws.loc[2], 2)
 
         # Map parameters
-        param_map = {'myokit.tumour_volume': 'myokit.tumour_volume'}
+        param_map = {'global.tumour_volume': 'global.tumour_volume'}
         pw_ll = chi.compute_pointwise_loglikelihood(
             self.log_likelihood, self.posterior_samples,
             param_map=param_map)
@@ -396,7 +396,7 @@ def test_call(self):
 
         # # Map parameters
         # param_map = {
-        #     'Pooled myokit.tumour_volume': 'Pooled myokit.tumour_volume'}
+        #     'Pooled global.tumour_volume': 'Pooled global.tumour_volume'}
         # pw_ll = chi.compute_pointwise_loglikelihood(
         #     self.hierarch_log_likelihood,
         #     self.hierarch_posterior_samples,
@@ -510,7 +510,7 @@ def test_call_bad_input(self):
                 param_map=param_map)
 
         # Not all parameters of the log-likelihood can be identified
-        param_map = {'myokit.tumour_volume': 'Something else'}
+        param_map = {'global.tumour_volume': 'Something else'}
         with self.assertRaisesRegex(ValueError, 'The parameter <Something'):
             chi.compute_pointwise_loglikelihood(
                 self.log_likelihood, self.posterior_samples,
@@ -682,7 +682,7 @@ def setUpClass(cls):
         cls.problem = chi.ProblemModellingController(model, error_models)
 
         data = DataLibrary().lung_cancer_control_group()
-        cls.problem.set_data(data, {'myokit.tumour_volume': 'Tumour volume'})
+        cls.problem.set_data(data, {'global.tumour_volume': 'Tumour volume'})
 
         n_parameters = 7
         log_prior = pints.ComposedLogPrior(*[
@@ -739,11 +739,11 @@ def test_run(self):
         n_parameters = 7
         parameters = result['Parameter'].unique()
         self.assertEqual(len(parameters), n_parameters)
-        self.assertEqual(parameters[0], 'myokit.tumour_volume')
-        self.assertEqual(parameters[1], 'myokit.drug_concentration')
-        self.assertEqual(parameters[2], 'myokit.kappa')
-        self.assertEqual(parameters[3], 'myokit.lambda_0')
-        self.assertEqual(parameters[4], 'myokit.lambda_1')
+        self.assertEqual(parameters[0], 'global.tumour_volume')
+        self.assertEqual(parameters[1], 'global.drug_concentration')
+        self.assertEqual(parameters[2], 'global.kappa')
+        self.assertEqual(parameters[3], 'global.lambda_0')
+        self.assertEqual(parameters[4], 'global.lambda_1')
         self.assertEqual(parameters[5], 'Sigma base')
         self.assertEqual(parameters[6], 'Sigma rel.')
 
@@ -788,18 +788,18 @@ def test_run(self):
         parameters = result['Parameter'].unique()
         self.assertEqual(len(parameters), 16)
         self.assertEqual(parameters[0], 'Sigma rel.')
-        self.assertEqual(parameters[1], 'Pooled myokit.tumour_volume')
-        self.assertEqual(parameters[2], 'Pooled myokit.drug_concentration')
-        self.assertEqual(parameters[3], 'ID 1 myokit.kappa')
-        self.assertEqual(parameters[4], 'ID 2 myokit.kappa')
-        self.assertEqual(parameters[5], 'ID 3 myokit.kappa')
-        self.assertEqual(parameters[6], 'ID 4 myokit.kappa')
-        self.assertEqual(parameters[7], 'ID 5 myokit.kappa')
-        self.assertEqual(parameters[8], 'ID 6 myokit.kappa')
-        self.assertEqual(parameters[9], 'ID 7 myokit.kappa')
-        self.assertEqual(parameters[10], 'ID 8 myokit.kappa')
-        self.assertEqual(parameters[11], 'Pooled myokit.lambda_0')
-        self.assertEqual(parameters[12], 'Pooled myokit.lambda_1')
+        self.assertEqual(parameters[1], 'Pooled global.tumour_volume')
+        self.assertEqual(parameters[2], 'Pooled global.drug_concentration')
+        self.assertEqual(parameters[3], 'ID 1 global.kappa')
+        self.assertEqual(parameters[4], 'ID 2 global.kappa')
+        self.assertEqual(parameters[5], 'ID 3 global.kappa')
+        self.assertEqual(parameters[6], 'ID 4 global.kappa')
+        self.assertEqual(parameters[7], 'ID 5 global.kappa')
+        self.assertEqual(parameters[8], 'ID 6 global.kappa')
+        self.assertEqual(parameters[9], 'ID 7 global.kappa')
+        self.assertEqual(parameters[10], 'ID 8 global.kappa')
+        self.assertEqual(parameters[11], 'Pooled global.lambda_0')
+        self.assertEqual(parameters[12], 'Pooled global.lambda_1')
         self.assertEqual(parameters[13], 'Pooled Sigma base')
         self.assertEqual(parameters[14], 'Log mean Sigma rel.')
         self.assertEqual(parameters[15], 'Log std. Sigma rel.')
@@ -817,10 +817,10 @@ def test_run_catch_exception(self):
         # Get test data and model
         problem = copy.deepcopy(self.problem)
         problem.fix_parameters({
-            'myokit.drug_concentration': 1,
-            'myokit.kappa': 1,
-            'myokit.lambda_0': 1,
-            'myokit.lambda_1': 1,
+            'global.drug_concentration': 1,
+            'global.kappa': 1,
+            'global.lambda_0': 1,
+            'global.lambda_1': 1,
             'Sigma base': 1,
             'Sigma rel.': 1})
         problem.set_log_prior(pints.ComposedLogPrior(*[
@@ -842,7 +842,7 @@ def test_run_catch_exception(self):
 
         parameters = result['Parameter'].unique()
         self.assertEqual(len(parameters), 1)
-        self.assertEqual(parameters[0], 'myokit.tumour_volume')
+        self.assertEqual(parameters[0], 'global.tumour_volume')
 
         runs = result['Run'].unique()
         self.assertEqual(len(runs), 3)
@@ -878,7 +878,7 @@ def setUpClass(cls):
         problem = chi.ProblemModellingController(model, error_models)
 
         data = DataLibrary().lung_cancer_control_group()
-        problem.set_data(data, {'myokit.tumour_volume': 'Tumour volume'})
+        problem.set_data(data, {'global.tumour_volume': 'Tumour volume'})
 
         n_parameters = 7
         log_prior = pints.ComposedLogPrior(*[
@@ -929,11 +929,11 @@ def test_run(self):
         self.assertEqual(len(parameters), 7)
         self.assertEqual(parameters[0], 'Sigma base')
         self.assertEqual(parameters[1], 'Sigma rel.')
-        self.assertEqual(parameters[2], 'myokit.drug_concentration')
-        self.assertEqual(parameters[3], 'myokit.kappa')
-        self.assertEqual(parameters[4], 'myokit.lambda_0')
-        self.assertEqual(parameters[5], 'myokit.lambda_1')
-        self.assertEqual(parameters[6], 'myokit.tumour_volume')
+        self.assertEqual(parameters[2], 'global.drug_concentration')
+        self.assertEqual(parameters[3], 'global.kappa')
+        self.assertEqual(parameters[4], 'global.lambda_0')
+        self.assertEqual(parameters[5], 'global.lambda_1')
+        self.assertEqual(parameters[6], 'global.tumour_volume')
 
         chains = result.chain
         self.assertEqual(len(chains), 3)
@@ -978,21 +978,21 @@ def test_run(self):
 
         parameters = sorted(list(result.data_vars.keys()))
         self.assertEqual(len(parameters), 16)
-        self.assertEqual(parameters[0], 'ID 1 myokit.kappa')
-        self.assertEqual(parameters[1], 'ID 2 myokit.kappa')
-        self.assertEqual(parameters[2], 'ID 3 myokit.kappa')
-        self.assertEqual(parameters[3], 'ID 4 myokit.kappa')
-        self.assertEqual(parameters[4], 'ID 5 myokit.kappa')
-        self.assertEqual(parameters[5], 'ID 6 myokit.kappa')
-        self.assertEqual(parameters[6], 'ID 7 myokit.kappa')
-        self.assertEqual(parameters[7], 'ID 8 myokit.kappa')
+        self.assertEqual(parameters[0], 'ID 1 global.kappa')
+        self.assertEqual(parameters[1], 'ID 2 global.kappa')
+        self.assertEqual(parameters[2], 'ID 3 global.kappa')
+        self.assertEqual(parameters[3], 'ID 4 global.kappa')
+        self.assertEqual(parameters[4], 'ID 5 global.kappa')
+        self.assertEqual(parameters[5], 'ID 6 global.kappa')
+        self.assertEqual(parameters[6], 'ID 7 global.kappa')
+        self.assertEqual(parameters[7], 'ID 8 global.kappa')
         self.assertEqual(parameters[8], 'Log mean Sigma rel.')
         self.assertEqual(parameters[9], 'Log std. Sigma rel.')
         self.assertEqual(parameters[10], 'Pooled Sigma base')
-        self.assertEqual(parameters[11], 'Pooled myokit.drug_concentration')
-        self.assertEqual(parameters[12], 'Pooled myokit.lambda_0')
-        self.assertEqual(parameters[13], 'Pooled myokit.lambda_1')
-        self.assertEqual(parameters[14], 'Pooled myokit.tumour_volume')
+        self.assertEqual(parameters[11], 'Pooled global.drug_concentration')
+        self.assertEqual(parameters[12], 'Pooled global.lambda_0')
+        self.assertEqual(parameters[13], 'Pooled global.lambda_1')
+        self.assertEqual(parameters[14], 'Pooled global.tumour_volume')
         self.assertEqual(parameters[15], 'Sigma rel.')
 
         chains = result.chain
diff --git a/chi/tests/test_log_pdfs.py b/chi/tests/test_log_pdfs.py
index 97da6364..869d9fb6 100644
--- a/chi/tests/test_log_pdfs.py
+++ b/chi/tests/test_log_pdfs.py
@@ -1850,7 +1850,7 @@ def test_call_and_compute_pointwise_ll(self):
         self.assertEqual(score, ref_score_2)
         n_obs = 3
         self.assertEqual(pw_score.shape, (n_obs,))
-        self.assertEqual(np.sum(pw_score), score)
+        self.assertAlmostEqual(np.sum(pw_score), score)
 
     def test_evaluateS1(self):
         # Test case I: Compute reference score manually
@@ -1987,7 +1987,7 @@ def test_fix_parameters(self):
         self.assertEqual(len(parameter_names), 7)
         self.assertEqual(parameter_names[0], 'dose.drug_amount')
         self.assertEqual(parameter_names[1], 'central.size')
-        self.assertEqual(parameter_names[2], 'myokit.elimination_rate')
+        self.assertEqual(parameter_names[2], 'global.elimination_rate')
         self.assertEqual(parameter_names[3], 'central.drug_amount Sigma base')
         self.assertEqual(parameter_names[4], 'central.drug_amount Sigma rel.')
         self.assertEqual(parameter_names[5], 'dose.drug_amount Sigma base')
@@ -1997,7 +1997,7 @@ def test_fix_parameters(self):
         self.log_likelihood.fix_parameters(name_value_dict={
             'dose.absorption_rate': None,
             'dose.drug_amount Sigma base': 0.5,
-            'myokit.elimination_rate': 0.3})
+            'global.elimination_rate': 0.3})
 
         n_parameters = self.log_likelihood.n_parameters()
         self.assertEqual(n_parameters, 6)
@@ -2015,7 +2015,7 @@ def test_fix_parameters(self):
         self.log_likelihood.fix_parameters(name_value_dict={
             'central.drug_amount': None,
             'dose.drug_amount Sigma base': None,
-            'myokit.elimination_rate': None})
+            'global.elimination_rate': None})
 
         n_parameters = self.log_likelihood.n_parameters()
         self.assertEqual(n_parameters, 9)
@@ -2026,7 +2026,7 @@ def test_fix_parameters(self):
         self.assertEqual(parameter_names[1], 'dose.drug_amount')
         self.assertEqual(parameter_names[2], 'central.size')
         self.assertEqual(parameter_names[3], 'dose.absorption_rate')
-        self.assertEqual(parameter_names[4], 'myokit.elimination_rate')
+        self.assertEqual(parameter_names[4], 'global.elimination_rate')
         self.assertEqual(parameter_names[5], 'central.drug_amount Sigma base')
         self.assertEqual(parameter_names[6], 'central.drug_amount Sigma rel.')
         self.assertEqual(parameter_names[7], 'dose.drug_amount Sigma base')
@@ -2046,7 +2046,7 @@ def test_get_parameter_names(self):
         self.assertEqual(parameter_names[1], 'dose.drug_amount')
         self.assertEqual(parameter_names[2], 'central.size')
         self.assertEqual(parameter_names[3], 'dose.absorption_rate')
-        self.assertEqual(parameter_names[4], 'myokit.elimination_rate')
+        self.assertEqual(parameter_names[4], 'global.elimination_rate')
         self.assertEqual(parameter_names[5], 'central.drug_amount Sigma base')
         self.assertEqual(parameter_names[6], 'central.drug_amount Sigma rel.')
         self.assertEqual(parameter_names[7], 'dose.drug_amount Sigma base')
@@ -2227,11 +2227,11 @@ def test_get_parameter_names(self):
         parameter_names = self.log_posterior.get_parameter_names()
 
         self.assertEqual(len(parameter_names), 7)
-        self.assertEqual(parameter_names[0], 'myokit.tumour_volume')
-        self.assertEqual(parameter_names[1], 'myokit.drug_concentration')
-        self.assertEqual(parameter_names[2], 'myokit.kappa')
-        self.assertEqual(parameter_names[3], 'myokit.lambda_0')
-        self.assertEqual(parameter_names[4], 'myokit.lambda_1')
+        self.assertEqual(parameter_names[0], 'global.tumour_volume')
+        self.assertEqual(parameter_names[1], 'global.drug_concentration')
+        self.assertEqual(parameter_names[2], 'global.kappa')
+        self.assertEqual(parameter_names[3], 'global.lambda_0')
+        self.assertEqual(parameter_names[4], 'global.lambda_1')
         self.assertEqual(parameter_names[5], 'Sigma base')
         self.assertEqual(parameter_names[6], 'Sigma rel.')
 
diff --git a/chi/tests/test_mechanistic_models.py b/chi/tests/test_mechanistic_models.py
index 33a14f34..4cf09a1e 100644
--- a/chi/tests/test_mechanistic_models.py
+++ b/chi/tests/test_mechanistic_models.py
@@ -124,62 +124,62 @@ def test_copy(self):
         self.assertEqual(self.model.n_outputs(), 1)
         outputs_c = model.outputs()
         outputs = self.model.outputs()
-        self.assertEqual(outputs_c[0], 'myokit.tumour_volume')
-        self.assertEqual(outputs[0], 'myokit.tumour_volume')
+        self.assertEqual(outputs_c[0], 'global.tumour_volume')
+        self.assertEqual(outputs[0], 'global.tumour_volume')
         self.assertEqual(model.n_parameters(), 5)
         self.assertEqual(self.model.n_parameters(), 5)
         params_c = model.parameters()
         params = self.model.parameters()
-        self.assertEqual(params_c[0], 'myokit.tumour_volume')
-        self.assertEqual(params_c[1], 'myokit.drug_concentration')
-        self.assertEqual(params_c[2], 'myokit.kappa')
-        self.assertEqual(params_c[3], 'myokit.lambda_0')
-        self.assertEqual(params_c[4], 'myokit.lambda_1')
-        self.assertEqual(params[0], 'myokit.tumour_volume')
-        self.assertEqual(params[1], 'myokit.drug_concentration')
-        self.assertEqual(params[2], 'myokit.kappa')
-        self.assertEqual(params[3], 'myokit.lambda_0')
-        self.assertEqual(params[4], 'myokit.lambda_1')
+        self.assertEqual(params_c[0], 'global.tumour_volume')
+        self.assertEqual(params_c[1], 'global.drug_concentration')
+        self.assertEqual(params_c[2], 'global.kappa')
+        self.assertEqual(params_c[3], 'global.lambda_0')
+        self.assertEqual(params_c[4], 'global.lambda_1')
+        self.assertEqual(params[0], 'global.tumour_volume')
+        self.assertEqual(params[1], 'global.drug_concentration')
+        self.assertEqual(params[2], 'global.kappa')
+        self.assertEqual(params[3], 'global.lambda_0')
+        self.assertEqual(params[4], 'global.lambda_1')
 
         # Change output name
-        model.set_output_names({'myokit.tumour_volume': 'test'})
+        model.set_output_names({'global.tumour_volume': 'test'})
         self.assertEqual(model.n_outputs(), 1)
         self.assertEqual(self.model.n_outputs(), 1)
         outputs_c = model.outputs()
         outputs = self.model.outputs()
         self.assertEqual(outputs_c[0], 'test')
-        self.assertEqual(outputs[0], 'myokit.tumour_volume')
+        self.assertEqual(outputs[0], 'global.tumour_volume')
 
         # Set new outputs
         model.set_outputs(
-            ['myokit.tumour_volume', 'myokit.tumour_volume'])
+            ['global.tumour_volume', 'global.tumour_volume'])
         self.assertEqual(model.n_outputs(), 2)
         self.assertEqual(self.model.n_outputs(), 1)
         outputs_c = model.outputs()
         outputs = self.model.outputs()
         self.assertEqual(outputs_c[0], 'test')
         self.assertEqual(outputs_c[1], 'test')
-        self.assertEqual(outputs[0], 'myokit.tumour_volume')
-        model.set_outputs(['myokit.tumour_volume'])
+        self.assertEqual(outputs[0], 'global.tumour_volume')
+        model.set_outputs(['global.tumour_volume'])
 
         # Rename some parameters
         model.set_parameter_names({
-            'myokit.kappa': 'new 1',
-            'myokit.lambda_0': 'new 2'})
+            'global.kappa': 'new 1',
+            'global.lambda_0': 'new 2'})
         self.assertEqual(model.n_parameters(), 5)
         self.assertEqual(self.model.n_parameters(), 5)
         params_c = model.parameters()
         params = self.model.parameters()
-        self.assertEqual(params_c[0], 'myokit.tumour_volume')
-        self.assertEqual(params_c[1], 'myokit.drug_concentration')
+        self.assertEqual(params_c[0], 'global.tumour_volume')
+        self.assertEqual(params_c[1], 'global.drug_concentration')
         self.assertEqual(params_c[2], 'new 1')
         self.assertEqual(params_c[3], 'new 2')
-        self.assertEqual(params_c[4], 'myokit.lambda_1')
-        self.assertEqual(params[0], 'myokit.tumour_volume')
-        self.assertEqual(params[1], 'myokit.drug_concentration')
-        self.assertEqual(params[2], 'myokit.kappa')
-        self.assertEqual(params[3], 'myokit.lambda_0')
-        self.assertEqual(params[4], 'myokit.lambda_1')
+        self.assertEqual(params_c[4], 'global.lambda_1')
+        self.assertEqual(params[0], 'global.tumour_volume')
+        self.assertEqual(params[1], 'global.drug_concentration')
+        self.assertEqual(params[2], 'global.kappa')
+        self.assertEqual(params[3], 'global.lambda_0')
+        self.assertEqual(params[4], 'global.lambda_1')
 
     def test_enable_sensitivities(self):
         # Enable sensitivities
@@ -187,7 +187,7 @@ def test_enable_sensitivities(self):
         self.assertTrue(self.model.has_sensitivities())
 
         # Enable sensitivties for a subset of parameters
-        parameters = ['myokit.tumour_volume', 'myokit.kappa']
+        parameters = ['global.tumour_volume', 'global.kappa']
         self.model.enable_sensitivities(True, parameters)
         self.assertTrue(self.model.has_sensitivities())
 
@@ -214,16 +214,16 @@ def test_n_parameters(self):
     def test_outputs(self):
         outputs = self.model.outputs()
 
-        self.assertEqual(outputs, ['myokit.tumour_volume'])
+        self.assertEqual(outputs, ['global.tumour_volume'])
 
     def test_parameters(self):
         parameters = self.model.parameters()
 
-        self.assertEqual(parameters[0], 'myokit.tumour_volume')
-        self.assertEqual(parameters[1], 'myokit.drug_concentration')
-        self.assertEqual(parameters[2], 'myokit.kappa')
-        self.assertEqual(parameters[3], 'myokit.lambda_0')
-        self.assertEqual(parameters[4], 'myokit.lambda_1')
+        self.assertEqual(parameters[0], 'global.tumour_volume')
+        self.assertEqual(parameters[1], 'global.drug_concentration')
+        self.assertEqual(parameters[2], 'global.kappa')
+        self.assertEqual(parameters[3], 'global.lambda_0')
+        self.assertEqual(parameters[4], 'global.lambda_1')
 
         # Test case II: Model where lambda_0 is defined as lambda_1 * kappa
         directory = os.path.dirname(__file__)
@@ -233,14 +233,14 @@ def test_parameters(self):
 
         self.assertEqual(len(parameters), 4)
         self.assertEqual(model.n_parameters(), 4)
-        self.assertEqual(parameters[0], 'myokit.tumour_volume')
-        self.assertEqual(parameters[1], 'myokit.drug_concentration')
-        self.assertEqual(parameters[2], 'myokit.kappa')
-        self.assertEqual(parameters[3], 'myokit.lambda_1')
+        self.assertEqual(parameters[0], 'global.tumour_volume')
+        self.assertEqual(parameters[1], 'global.drug_concentration')
+        self.assertEqual(parameters[2], 'global.kappa')
+        self.assertEqual(parameters[3], 'global.lambda_1')
 
     def test_set_outputs(self):
         # Set twice the same output
-        outputs = ['myokit.tumour_volume', 'myokit.tumour_volume']
+        outputs = ['global.tumour_volume', 'global.tumour_volume']
         self.model.set_outputs(outputs)
         self.assertEqual(self.model.outputs(), outputs)
         self.assertEqual(self.model.n_outputs(), 2)
@@ -248,7 +248,7 @@ def test_set_outputs(self):
         self.assertEqual(output.shape, (2, 2))
 
         # Set to default again
-        outputs = ['myokit.tumour_volume']
+        outputs = ['global.tumour_volume']
         self.model.set_outputs(outputs)
         self.assertEqual(self.model.outputs(), outputs)
         self.assertEqual(self.model.n_outputs(), 1)
@@ -262,11 +262,11 @@ def test_set_ouputs_bad_input(self):
 
         # Set output to constant
         with self.assertRaisesRegex(ValueError, 'Outputs have to be state or'):
-            self.model.set_outputs(['myokit.kappa'])
+            self.model.set_outputs(['global.kappa'])
 
     def test_set_output_names(self):
         # Set output name
-        names = {'myokit.tumour_volume': 'Some name'}
+        names = {'global.tumour_volume': 'Some name'}
         self.model.set_output_names(names)
         outputs = self.model.outputs()
         self.assertEqual(len(outputs), 1)
@@ -280,11 +280,11 @@ def test_set_output_names(self):
         self.assertEqual(outputs[0], 'Some other name')
 
         # Set name back to default
-        names = {'Some other name': 'myokit.tumour_volume'}
+        names = {'Some other name': 'global.tumour_volume'}
         self.model.set_output_names(names)
         outputs = self.model.outputs()
         self.assertEqual(len(outputs), 1)
-        self.assertEqual(outputs[0], 'myokit.tumour_volume')
+        self.assertEqual(outputs[0], 'global.tumour_volume')
 
     def test_set_output_names_bad_input(self):
         # List input is not ok!
@@ -298,36 +298,36 @@ def test_set_output_names_bad_input(self):
             self.model.set_output_names(names)
 
         # New names exist already
-        names = {'param 1': 'myokit.tumour_volume', 'param 2': 'Some name'}
+        names = {'param 1': 'global.tumour_volume', 'param 2': 'Some name'}
         with self.assertRaisesRegex(ValueError, 'The output names cannot'):
             self.model.set_output_names(names)
 
     def test_set_parameter_names(self):
         # Set some parameter names
         names = {
-            'myokit.tumour_volume': 'TV',
-            'myokit.lambda_0': 'Expon. growth rate'}
+            'global.tumour_volume': 'TV',
+            'global.lambda_0': 'Expon. growth rate'}
         self.model.set_parameter_names(names)
         parameters = self.model.parameters()
 
         self.assertEqual(parameters[0], 'TV')
-        self.assertEqual(parameters[1], 'myokit.drug_concentration')
-        self.assertEqual(parameters[2], 'myokit.kappa')
+        self.assertEqual(parameters[1], 'global.drug_concentration')
+        self.assertEqual(parameters[2], 'global.kappa')
         self.assertEqual(parameters[3], 'Expon. growth rate')
-        self.assertEqual(parameters[4], 'myokit.lambda_1')
+        self.assertEqual(parameters[4], 'global.lambda_1')
 
         # Reverse parameter names
         names = {
-            'TV': 'myokit.tumour_volume',
-            'Expon. growth rate': 'myokit.lambda_0'}
+            'TV': 'global.tumour_volume',
+            'Expon. growth rate': 'global.lambda_0'}
         self.model.set_parameter_names(names)
         parameters = self.model.parameters()
 
-        self.assertEqual(parameters[0], 'myokit.tumour_volume')
-        self.assertEqual(parameters[1], 'myokit.drug_concentration')
-        self.assertEqual(parameters[2], 'myokit.kappa')
-        self.assertEqual(parameters[3], 'myokit.lambda_0')
-        self.assertEqual(parameters[4], 'myokit.lambda_1')
+        self.assertEqual(parameters[0], 'global.tumour_volume')
+        self.assertEqual(parameters[1], 'global.drug_concentration')
+        self.assertEqual(parameters[2], 'global.kappa')
+        self.assertEqual(parameters[3], 'global.lambda_0')
+        self.assertEqual(parameters[4], 'global.lambda_1')
 
     def test_set_parameter_names_bad_input(self):
         # List input is not ok!
@@ -341,7 +341,7 @@ def test_set_parameter_names_bad_input(self):
             self.model.set_parameter_names(names)
 
         # New names exist already
-        names = {'param 1': 'myokit.tumour_volume', 'param 2': 'Some name'}
+        names = {'param 1': 'global.tumour_volume', 'param 2': 'Some name'}
         with self.assertRaisesRegex(ValueError, 'The parameter names cannot'):
             self.model.set_parameter_names(names)
 
@@ -453,7 +453,7 @@ def test_parameters(self):
 
         self.assertEqual(parameters[0], 'central.drug_amount')
         self.assertEqual(parameters[1], 'central.size')
-        self.assertEqual(parameters[2], 'myokit.elimination_rate')
+        self.assertEqual(parameters[2], 'global.elimination_rate')
 
     def test_set_administration(self):
         model = ModelLibrary().one_compartment_pk_model()
@@ -466,7 +466,7 @@ def test_set_administration(self):
         self.assertEqual(model.n_parameters(), 3)
         self.assertEqual(parameters[0], 'central.drug_amount')
         self.assertEqual(parameters[1], 'central.size')
-        self.assertEqual(parameters[2], 'myokit.elimination_rate')
+        self.assertEqual(parameters[2], 'global.elimination_rate')
 
         # Administer dose indirectly to central compartment
         model.set_administration(compartment='central', direct=False)
@@ -478,7 +478,7 @@ def test_set_administration(self):
         self.assertEqual(parameters[1], 'dose.drug_amount')
         self.assertEqual(parameters[2], 'central.size')
         self.assertEqual(parameters[3], 'dose.absorption_rate')
-        self.assertEqual(parameters[4], 'myokit.elimination_rate')
+        self.assertEqual(parameters[4], 'global.elimination_rate')
 
     def test_set_administration_bad_input(self):
         # Bad compartment
@@ -655,7 +655,7 @@ def test_set_parameter_names(self):
         # Set some parameter names
         names = {
             'central.drug_amount': 'A',
-            'myokit.elimination_rate': 'k_e'}
+            'global.elimination_rate': 'k_e'}
         self.model.set_parameter_names(names)
         parameters = self.model.parameters()
 
@@ -666,13 +666,13 @@ def test_set_parameter_names(self):
         # Reverse parameter names
         names = {
             'A': 'central.drug_amount',
-            'k_e': 'myokit.elimination_rate'}
+            'k_e': 'global.elimination_rate'}
         self.model.set_parameter_names(names)
         parameters = self.model.parameters()
 
         self.assertEqual(parameters[0], 'central.drug_amount')
         self.assertEqual(parameters[1], 'central.size')
-        self.assertEqual(parameters[2], 'myokit.elimination_rate')
+        self.assertEqual(parameters[2], 'global.elimination_rate')
 
     def test_set_parameter_names_bad_input(self):
         # List input is not ok!
@@ -735,9 +735,9 @@ def test_copy(self):
         params_c = model.parameters()
         params = self.pkpd_model.parameters()
         self.assertEqual(params_c[0], 'central.drug_amount')
-        self.assertEqual(params_c[1], 'myokit.elimination_rate')
+        self.assertEqual(params_c[1], 'global.elimination_rate')
         self.assertEqual(params[0], 'central.drug_amount')
-        self.assertEqual(params[1], 'myokit.elimination_rate')
+        self.assertEqual(params[1], 'global.elimination_rate')
 
         # Rename the output
         model.set_output_names({'central.drug_concentration': 'test'})
@@ -767,9 +767,9 @@ def test_copy(self):
         params_c = model.parameters()
         params = self.pkpd_model.parameters()
         self.assertEqual(params_c[0], 'central.size')
-        self.assertEqual(params_c[1], 'myokit.elimination_rate')
+        self.assertEqual(params_c[1], 'global.elimination_rate')
         self.assertEqual(params[0], 'central.drug_amount')
-        self.assertEqual(params[1], 'myokit.elimination_rate')
+        self.assertEqual(params[1], 'global.elimination_rate')
 
         # Unfix model parameters
         self.pkpd_model.fix_parameters({'central.size': None})
@@ -881,7 +881,7 @@ def test_set_get_parameters(self):
         self.assertEqual(len(parameters), 3)
         self.assertEqual(parameters[0], 'Test')
         self.assertEqual(parameters[1], 'central.size')
-        self.assertEqual(parameters[2], 'myokit.elimination_rate')
+        self.assertEqual(parameters[2], 'global.elimination_rate')
 
         # Test case II: set back to default
         self.pkpd_model.set_parameter_names({
@@ -891,7 +891,7 @@ def test_set_get_parameters(self):
         self.assertEqual(len(parameters), 3)
         self.assertEqual(parameters[0], 'central.drug_amount')
         self.assertEqual(parameters[1], 'central.size')
-        self.assertEqual(parameters[2], 'myokit.elimination_rate')
+        self.assertEqual(parameters[2], 'global.elimination_rate')
 
         # Test case III: Set parameter names for chi.MechanisticModel
         with self.assertRaisesRegex(NotImplementedError, 'The mechanistic'):
diff --git a/chi/tests/test_model_library_api.py b/chi/tests/test_model_library_api.py
index 7f5d6f23..5d7e9d23 100644
--- a/chi/tests/test_model_library_api.py
+++ b/chi/tests/test_model_library_api.py
@@ -57,10 +57,10 @@ def test_constant_variables(self):
         n_const = len(const_names)
         self.assertEqual(n_const, 5)
         self.assertEqual(const_names[0], 'central.size')
-        self.assertEqual(const_names[1], 'myokit.critical_volume')
-        self.assertEqual(const_names[2], 'myokit.elimination_rate')
-        self.assertEqual(const_names[3], 'myokit.kappa')
-        self.assertEqual(const_names[4], 'myokit.lambda')
+        self.assertEqual(const_names[1], 'global.critical_volume')
+        self.assertEqual(const_names[2], 'global.elimination_rate')
+        self.assertEqual(const_names[3], 'global.kappa')
+        self.assertEqual(const_names[4], 'global.lambda')
 
     def test_intermediate_variables(self):
         inter_names = sorted(
@@ -79,7 +79,7 @@ def test_states(self):
         n_states = len(state_names)
         self.assertTrue(n_states, 2)
         self.assertEqual(state_names[0], 'central.drug_amount')
-        self.assertEqual(state_names[1], 'myokit.tumour_volume')
+        self.assertEqual(state_names[1], 'global.tumour_volume')
 
 
 class TestTumourGrowthInhibitionModelKoch(unittest.TestCase):
@@ -100,7 +100,7 @@ def test_states(self):
         n_states = len(state_names)
         self.assertTrue(n_states, 1)
 
-        tumour_volume = 'myokit.tumour_volume'
+        tumour_volume = 'global.tumour_volume'
         self.assertEqual(state_names[0], tumour_volume)
 
     def test_constant_variables(self):
@@ -110,16 +110,16 @@ def test_constant_variables(self):
         n_const = len(const_names)
         self.assertEqual(n_const, 4)
 
-        drug_conc = 'myokit.drug_concentration'
+        drug_conc = 'global.drug_concentration'
         self.assertEqual(const_names[0], drug_conc)
 
-        kappa = 'myokit.kappa'
+        kappa = 'global.kappa'
         self.assertEqual(const_names[1], kappa)
 
-        lambda_0 = 'myokit.lambda_0'
+        lambda_0 = 'global.lambda_0'
         self.assertEqual(const_names[2], lambda_0)
 
-        lambda_1 = 'myokit.lambda_1'
+        lambda_1 = 'global.lambda_1'
         self.assertEqual(const_names[3], lambda_1)
 
 
@@ -143,7 +143,7 @@ def test_states(self):
         n_states = len(state_names)
         self.assertTrue(n_states, 1)
 
-        tumour_volume = 'myokit.tumour_volume'
+        tumour_volume = 'global.tumour_volume'
         self.assertEqual(state_names[0], tumour_volume)
 
     def test_constant_variables(self):
@@ -153,16 +153,16 @@ def test_constant_variables(self):
         n_const = len(const_names)
         self.assertEqual(n_const, 4)
 
-        critical_volume = 'myokit.critical_volume'
+        critical_volume = 'global.critical_volume'
         self.assertEqual(const_names[0], critical_volume)
 
-        drug_conc = 'myokit.drug_concentration'
+        drug_conc = 'global.drug_concentration'
         self.assertEqual(const_names[1], drug_conc)
 
-        kappa = 'myokit.kappa'
+        kappa = 'global.kappa'
         self.assertEqual(const_names[2], kappa)
 
-        growth_rate = 'myokit.lambda'
+        growth_rate = 'global.lambda'
         self.assertEqual(const_names[3], growth_rate)
 
 
@@ -196,7 +196,7 @@ def test_constant_variables(self):
         volume = 'central.size'
         self.assertEqual(const_names[0], volume)
 
-        elimination_rate = 'myokit.elimination_rate'
+        elimination_rate = 'global.elimination_rate'
         self.assertEqual(const_names[1], elimination_rate)
 
     def test_intermediate_variables(self):
diff --git a/chi/tests/test_plots_optimisation.py b/chi/tests/test_plots_optimisation.py
index f54d3e3a..70a73c4d 100644
--- a/chi/tests/test_plots_optimisation.py
+++ b/chi/tests/test_plots_optimisation.py
@@ -44,13 +44,13 @@ def setUpClass(cls):
             'Run': runs})
 
         # Add a 'population' parameter to the dataset
-        cls.data = data.append(pd.DataFrame({
+        cls.data = pd.concat([data, pd.DataFrame({
             'ID': [None] * 8,
             'Parameter': 'Param 3',
             'Sample': np.arange(8),
             'Iteration': [1, 2, 3, 4] * 2,
             'Run': [1] * 4 + [2] * 4
-        }))
+        })])
 
         # Create test figure
         cls.fig = plots.ParameterEstimatePlot()
diff --git a/chi/tests/test_plots_sampling.py b/chi/tests/test_plots_sampling.py
index 29c96be9..0d41695d 100644
--- a/chi/tests/test_plots_sampling.py
+++ b/chi/tests/test_plots_sampling.py
@@ -57,11 +57,11 @@ def setUpClass(cls):
                 'chain': list(range(n_chains)),
                 'draw': list(range(n_draws))})
         cls.pop_post_samples = xr.Dataset({
-            'Pooled myokit.tumour_volume': pop_samples,
-            'myokit.drug_concentration': samples,
-            'Pooled myokit.kappa': pop_samples,
-            'Pooled myokit.lambda_0': pop_samples,
-            'Pooled myokit.lambda_1': pop_samples,
+            'Pooled global.tumour_volume': pop_samples,
+            'global.drug_concentration': samples,
+            'Pooled global.kappa': pop_samples,
+            'Pooled global.lambda_0': pop_samples,
+            'Pooled global.lambda_1': pop_samples,
             'Pooled Sigma base': pop_samples,
             'Sigma rel.': samples,
             'Mean Sigma rel.': pop_samples,
diff --git a/chi/tests/test_predictive_models.py b/chi/tests/test_predictive_models.py
index 029a9c3c..500a98ac 100644
--- a/chi/tests/test_predictive_models.py
+++ b/chi/tests/test_predictive_models.py
@@ -57,7 +57,7 @@ def test_get_n_outputs(self):
     def test_get_output_names(self):
         names = self.model.get_output_names()
         self.assertEqual(len(names), 1)
-        self.assertEqual(names[0], 'myokit.tumour_volume')
+        self.assertEqual(names[0], 'global.tumour_volume')
 
     def test_get_predictive_model(self):
         predictive_model = self.model.get_predictive_model()
@@ -179,7 +179,7 @@ def test_bad_instantiation(self):
         # (Drop dims removes all parameters with the dimension 'individual')
         posterior_samples = posterior_samples.rename(
             {'wrong name': 'chain'})
-        with self.assertRaisesRegex(ValueError, 'The parameter <myokit.'):
+        with self.assertRaisesRegex(ValueError, 'The parameter <global.'):
             chi.PosteriorPredictiveModel(
                 self.pred_model, posterior_samples)
 
@@ -204,7 +204,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -239,7 +239,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -272,7 +272,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -294,11 +294,11 @@ def test_sample(self):
 
         # Define a map between the parameters to recycle posterior samples
         param_map = {
-            'central.size': 'myokit.tumour_volume',
-            'dose.absorption_rate': 'myokit.lambda_0',
-            'myokit.elimination_rate': 'myokit.lambda_1',
-            'central.drug_amount': 'myokit.drug_concentration',
-            'dose.drug_amount': 'myokit.kappa'}
+            'central.size': 'global.tumour_volume',
+            'dose.absorption_rate': 'global.lambda_0',
+            'global.elimination_rate': 'global.lambda_1',
+            'central.drug_amount': 'global.drug_concentration',
+            'dose.drug_amount': 'global.kappa'}
         model = chi.PosteriorPredictiveModel(
             predictive_model, self.posterior_samples, param_map=param_map)
 
@@ -414,7 +414,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -452,7 +452,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -493,7 +493,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -561,24 +561,24 @@ def test_bad_instantiation(self):
     def test_fix_parameters(self):
         # Test case I: fix some parameters
         self.model.fix_parameters(name_value_dict={
-            'myokit.tumour_volume': 1,
-            'myokit.kappa': 1})
+            'global.tumour_volume': 1,
+            'global.kappa': 1})
 
         n_parameters = self.model.n_parameters()
         self.assertEqual(n_parameters, 5)
 
         parameter_names = self.model.get_parameter_names()
         self.assertEqual(len(parameter_names), 5)
-        self.assertEqual(parameter_names[0], 'myokit.drug_concentration')
-        self.assertEqual(parameter_names[1], 'myokit.lambda_0')
-        self.assertEqual(parameter_names[2], 'myokit.lambda_1')
+        self.assertEqual(parameter_names[0], 'global.drug_concentration')
+        self.assertEqual(parameter_names[1], 'global.lambda_0')
+        self.assertEqual(parameter_names[2], 'global.lambda_1')
         self.assertEqual(parameter_names[3], 'Sigma base')
         self.assertEqual(parameter_names[4], 'Sigma rel.')
 
         # Test case II: fix overlapping set of parameters
         self.model.fix_parameters(name_value_dict={
-            'myokit.kappa': None,
-            'myokit.lambda_0': 0.5,
+            'global.kappa': None,
+            'global.lambda_0': 0.5,
             'Sigma rel.': 0.3})
 
         n_parameters = self.model.n_parameters()
@@ -586,15 +586,15 @@ def test_fix_parameters(self):
 
         parameter_names = self.model.get_parameter_names()
         self.assertEqual(len(parameter_names), 4)
-        self.assertEqual(parameter_names[0], 'myokit.drug_concentration')
-        self.assertEqual(parameter_names[1], 'myokit.kappa')
-        self.assertEqual(parameter_names[2], 'myokit.lambda_1')
+        self.assertEqual(parameter_names[0], 'global.drug_concentration')
+        self.assertEqual(parameter_names[1], 'global.kappa')
+        self.assertEqual(parameter_names[2], 'global.lambda_1')
         self.assertEqual(parameter_names[3], 'Sigma base')
 
         # Test case III: unfix all parameters
         self.model.fix_parameters(name_value_dict={
-            'myokit.tumour_volume': None,
-            'myokit.lambda_0': None,
+            'global.tumour_volume': None,
+            'global.lambda_0': None,
             'Sigma rel.': None})
 
         n_parameters = self.model.n_parameters()
@@ -602,11 +602,11 @@ def test_fix_parameters(self):
 
         parameter_names = self.model.get_parameter_names()
         self.assertEqual(len(parameter_names), 7)
-        self.assertEqual(parameter_names[0], 'myokit.tumour_volume')
-        self.assertEqual(parameter_names[1], 'myokit.drug_concentration')
-        self.assertEqual(parameter_names[2], 'myokit.kappa')
-        self.assertEqual(parameter_names[3], 'myokit.lambda_0')
-        self.assertEqual(parameter_names[4], 'myokit.lambda_1')
+        self.assertEqual(parameter_names[0], 'global.tumour_volume')
+        self.assertEqual(parameter_names[1], 'global.drug_concentration')
+        self.assertEqual(parameter_names[2], 'global.kappa')
+        self.assertEqual(parameter_names[3], 'global.lambda_0')
+        self.assertEqual(parameter_names[4], 'global.lambda_1')
         self.assertEqual(parameter_names[5], 'Sigma base')
         self.assertEqual(parameter_names[6], 'Sigma rel.')
 
@@ -621,18 +621,18 @@ def test_get_n_outputs(self):
     def test_get_output_names(self):
         outputs = self.model.get_output_names()
         self.assertEqual(len(outputs), 1)
-        self.assertEqual(outputs[0], 'myokit.tumour_volume')
+        self.assertEqual(outputs[0], 'global.tumour_volume')
 
     def test_get_parameter_names(self):
         # Test case I: Single output problem
         names = self.model.get_parameter_names()
 
         self.assertEqual(len(names), 7)
-        self.assertEqual(names[0], 'myokit.tumour_volume')
-        self.assertEqual(names[1], 'myokit.drug_concentration')
-        self.assertEqual(names[2], 'myokit.kappa')
-        self.assertEqual(names[3], 'myokit.lambda_0')
-        self.assertEqual(names[4], 'myokit.lambda_1')
+        self.assertEqual(names[0], 'global.tumour_volume')
+        self.assertEqual(names[1], 'global.drug_concentration')
+        self.assertEqual(names[2], 'global.kappa')
+        self.assertEqual(names[3], 'global.lambda_0')
+        self.assertEqual(names[4], 'global.lambda_1')
         self.assertEqual(names[5], 'Sigma base')
         self.assertEqual(names[6], 'Sigma rel.')
 
@@ -652,7 +652,7 @@ def test_get_parameter_names(self):
         self.assertEqual(names[1], 'dose.drug_amount')
         self.assertEqual(names[2], 'central.size')
         self.assertEqual(names[3], 'dose.absorption_rate')
-        self.assertEqual(names[4], 'myokit.elimination_rate')
+        self.assertEqual(names[4], 'global.elimination_rate')
         self.assertEqual(names[5], 'central.drug_amount Sigma base')
         self.assertEqual(names[6], 'central.drug_amount Sigma rel.')
         self.assertEqual(names[7], 'dose.drug_amount Sigma base')
@@ -846,7 +846,7 @@ def test_get_submodels(self):
 
         # Test case II: some fixed parameters
         self.model.fix_parameters({
-            'myokit.tumour_volume': 1,
+            'global.tumour_volume': 1,
             'Sigma rel.': 10})
         submodels = self.model.get_submodels()
 
@@ -864,7 +864,7 @@ def test_get_submodels(self):
 
         # Unfix parameter
         self.model.fix_parameters({
-            'myokit.tumour_volume': None,
+            'global.tumour_volume': None,
             'Sigma rel.': None})
 
     def test_n_parameters(self):
@@ -894,7 +894,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -951,7 +951,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -1034,7 +1034,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -1333,7 +1333,7 @@ def test_get_n_outputs(self):
     def test_get_output_names(self):
         outputs = self.model.get_output_names()
         self.assertEqual(len(outputs), 1)
-        self.assertEqual(outputs[0], 'myokit.tumour_volume')
+        self.assertEqual(outputs[0], 'global.tumour_volume')
 
     def test_get_parameter_names(self):
         # Test case I: Single output problem
@@ -1414,7 +1414,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -1461,7 +1461,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -1506,7 +1506,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -1676,7 +1676,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 3)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
         self.assertEqual(biomarkers[1], 'Cov. 1')
         self.assertEqual(biomarkers[2], 'Cov. 2')
 
@@ -1859,7 +1859,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -1895,7 +1895,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -1928,7 +1928,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -2051,7 +2051,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -2086,7 +2086,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -2140,7 +2140,7 @@ def setUpClass(cls):
         mechanistic_model = \
             ModelLibrary().erlotinib_tumour_growth_inhibition_model()
         mechanistic_model.set_administration('central', direct=True)
-        mechanistic_model.set_outputs(['myokit.tumour_volume'])
+        mechanistic_model.set_outputs(['global.tumour_volume'])
         error_models = [chi.GaussianErrorModel()]
         pred_model = chi.PredictiveModel(
             mechanistic_model, error_models)
@@ -2182,7 +2182,7 @@ def test_bad_instantiation(self):
         mechanistic_model = \
             ModelLibrary().erlotinib_tumour_growth_inhibition_model()
         mechanistic_model.set_outputs(
-            ['central.drug_concentration', 'myokit.tumour_volume'])
+            ['central.drug_concentration', 'global.tumour_volume'])
         error_models = [chi.GaussianErrorModel()] * 2
         pred_model = chi.PredictiveModel(
             mechanistic_model, error_models)
@@ -2269,7 +2269,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -2306,7 +2306,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -2338,7 +2338,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -2373,7 +2373,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].unique()
         self.assertEqual(len(times), 5)
@@ -2410,7 +2410,7 @@ def test_sample(self):
 
         biomarkers = samples['Observable'].dropna().unique()
         self.assertEqual(len(biomarkers), 1)
-        self.assertEqual(biomarkers[0], 'myokit.tumour_volume')
+        self.assertEqual(biomarkers[0], 'global.tumour_volume')
 
         times = samples['Time'].dropna().unique()
         self.assertEqual(len(times), 5)
diff --git a/chi/tests/test_problems.py b/chi/tests/test_problems.py
index be7de3e6..e715c3ef 100644
--- a/chi/tests/test_problems.py
+++ b/chi/tests/test_problems.py
@@ -58,7 +58,7 @@ def setUpClass(cls):
         cls.pkpd_model.set_administration('central')
         cls.pkpd_model.set_outputs([
             'central.drug_concentration',
-            'myokit.tumour_volume'])
+            'global.tumour_volume'])
         cls.error_models = [
             chi.ConstantAndMultiplicativeGaussianErrorModel(),
             chi.ConstantAndMultiplicativeGaussianErrorModel()]
@@ -66,7 +66,7 @@ def setUpClass(cls):
             cls.pkpd_model, cls.error_models,
             outputs=[
                 'central.drug_concentration',
-                'myokit.tumour_volume'])
+                'global.tumour_volume'])
 
     def test_bad_input(self):
         # Mechanistic model has wrong type
@@ -103,48 +103,48 @@ def test_fix_parameters(self):
         # Test case I: PD model
         # Fix model parameters
         name_value_dict = dict({
-            'myokit.drug_concentration': 0,
+            'global.drug_concentration': 0,
             'Sigma base': 1})
         self.pd_problem.fix_parameters(name_value_dict)
 
         self.assertEqual(self.pd_problem.get_n_parameters(), 5)
         param_names = self.pd_problem.get_parameter_names()
         self.assertEqual(len(param_names), 5)
-        self.assertEqual(param_names[0], 'myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'myokit.kappa')
-        self.assertEqual(param_names[2], 'myokit.lambda_0')
-        self.assertEqual(param_names[3], 'myokit.lambda_1')
+        self.assertEqual(param_names[0], 'global.tumour_volume')
+        self.assertEqual(param_names[1], 'global.kappa')
+        self.assertEqual(param_names[2], 'global.lambda_0')
+        self.assertEqual(param_names[3], 'global.lambda_1')
         self.assertEqual(param_names[4], 'Sigma rel.')
 
         # Free and fix a parameter
         name_value_dict = dict({
-            'myokit.lambda_1': 2,
+            'global.lambda_1': 2,
             'Sigma base': None})
         self.pd_problem.fix_parameters(name_value_dict)
 
         self.assertEqual(self.pd_problem.get_n_parameters(), 5)
         param_names = self.pd_problem.get_parameter_names()
         self.assertEqual(len(param_names), 5)
-        self.assertEqual(param_names[0], 'myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'myokit.kappa')
-        self.assertEqual(param_names[2], 'myokit.lambda_0')
+        self.assertEqual(param_names[0], 'global.tumour_volume')
+        self.assertEqual(param_names[1], 'global.kappa')
+        self.assertEqual(param_names[2], 'global.lambda_0')
         self.assertEqual(param_names[3], 'Sigma base')
         self.assertEqual(param_names[4], 'Sigma rel.')
 
         # Free all parameters again
         name_value_dict = dict({
-            'myokit.lambda_1': None,
-            'myokit.drug_concentration': None})
+            'global.lambda_1': None,
+            'global.drug_concentration': None})
         self.pd_problem.fix_parameters(name_value_dict)
 
         self.assertEqual(self.pd_problem.get_n_parameters(), 7)
         param_names = self.pd_problem.get_parameter_names()
         self.assertEqual(len(param_names), 7)
-        self.assertEqual(param_names[0], 'myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'myokit.drug_concentration')
-        self.assertEqual(param_names[2], 'myokit.kappa')
-        self.assertEqual(param_names[3], 'myokit.lambda_0')
-        self.assertEqual(param_names[4], 'myokit.lambda_1')
+        self.assertEqual(param_names[0], 'global.tumour_volume')
+        self.assertEqual(param_names[1], 'global.drug_concentration')
+        self.assertEqual(param_names[2], 'global.kappa')
+        self.assertEqual(param_names[3], 'global.lambda_0')
+        self.assertEqual(param_names[4], 'global.lambda_1')
         self.assertEqual(param_names[5], 'Sigma base')
         self.assertEqual(param_names[6], 'Sigma rel.')
 
@@ -152,10 +152,10 @@ def test_fix_parameters(self):
         problem = chi.ProblemModellingController(
             self.pd_model, self.error_model)
         name_value_dict = dict({
-            'myokit.tumour_volume': 1,
-            'myokit.drug_concentration': 0,
-            'myokit.kappa': 1,
-            'myokit.lambda_1': 2})
+            'global.tumour_volume': 1,
+            'global.drug_concentration': 0,
+            'global.kappa': 1,
+            'global.lambda_1': 2})
         problem.fix_parameters(name_value_dict)
         problem.set_population_model(chi.ComposedPopulationModel([
             chi.HeterogeneousModel(),
@@ -163,15 +163,15 @@ def test_fix_parameters(self):
             chi.LogNormalModel()]))
         problem.set_data(
             self.data,
-            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})
+            output_observable_dict={'global.tumour_volume': 'Tumour volume'})
 
         n_ids = 3
         self.assertEqual(problem.get_n_parameters(), n_ids + 1 + 2)
         param_names = problem.get_parameter_names()
         self.assertEqual(len(param_names), 6)
-        self.assertEqual(param_names[0], 'ID 1 myokit.lambda_0')
-        self.assertEqual(param_names[1], 'ID 2 myokit.lambda_0')
-        self.assertEqual(param_names[2], 'ID 3 myokit.lambda_0')
+        self.assertEqual(param_names[0], 'ID 1 global.lambda_0')
+        self.assertEqual(param_names[1], 'ID 2 global.lambda_0')
+        self.assertEqual(param_names[2], 'ID 3 global.lambda_0')
         self.assertEqual(param_names[3], 'Pooled Sigma base')
         self.assertEqual(param_names[4], 'Log mean Sigma rel.')
         self.assertEqual(param_names[5], 'Log std. Sigma rel.')
@@ -179,29 +179,29 @@ def test_fix_parameters(self):
         # Fix parameters after setting a population model
         # (Only population models can be fixed)
         name_value_dict = dict({
-            'ID 1 myokit.lambda_0': 1,
-            'ID 3 myokit.lambda_0': 4,
+            'ID 1 global.lambda_0': 1,
+            'ID 3 global.lambda_0': 4,
             'Pooled Sigma base': 2})
         problem.fix_parameters(name_value_dict)
 
         # self.assertEqual(problem.get_n_parameters(), 8)
         param_names = problem.get_parameter_names()
         self.assertEqual(len(param_names), 3)
-        self.assertEqual(param_names[0], 'ID 2 myokit.lambda_0')
+        self.assertEqual(param_names[0], 'ID 2 global.lambda_0')
         self.assertEqual(param_names[1], 'Log mean Sigma rel.')
         self.assertEqual(param_names[2], 'Log std. Sigma rel.')
 
         # Unfix all paramaters
         name_value_dict = dict({
-            'ID 1 myokit.lambda_0': None,
-            'ID 3 myokit.lambda_0': None,
+            'ID 1 global.lambda_0': None,
+            'ID 3 global.lambda_0': None,
             'Pooled Sigma base': None})
         problem.fix_parameters(name_value_dict)
 
         # Test case II: PKPD model
         # Fix model parameters
         name_value_dict = dict({
-            'myokit.kappa': 0,
+            'global.kappa': 0,
             'central.drug_concentration Sigma base': 1})
         self.pkpd_problem.fix_parameters(name_value_dict)
 
@@ -209,39 +209,39 @@ def test_fix_parameters(self):
         param_names = self.pkpd_problem.get_parameter_names()
         self.assertEqual(len(param_names), 9)
         self.assertEqual(param_names[0], 'central.drug_amount')
-        self.assertEqual(param_names[1], 'myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'global.tumour_volume')
         self.assertEqual(param_names[2], 'central.size')
-        self.assertEqual(param_names[3], 'myokit.critical_volume')
-        self.assertEqual(param_names[4], 'myokit.elimination_rate')
-        self.assertEqual(param_names[5], 'myokit.lambda')
+        self.assertEqual(param_names[3], 'global.critical_volume')
+        self.assertEqual(param_names[4], 'global.elimination_rate')
+        self.assertEqual(param_names[5], 'global.lambda')
         self.assertEqual(
             param_names[6], 'central.drug_concentration Sigma rel.')
-        self.assertEqual(param_names[7], 'myokit.tumour_volume Sigma base')
-        self.assertEqual(param_names[8], 'myokit.tumour_volume Sigma rel.')
+        self.assertEqual(param_names[7], 'global.tumour_volume Sigma base')
+        self.assertEqual(param_names[8], 'global.tumour_volume Sigma rel.')
 
         # Free and fix a parameter
         name_value_dict = dict({
-            'myokit.lambda': 2,
-            'myokit.kappa': None})
+            'global.lambda': 2,
+            'global.kappa': None})
         self.pkpd_problem.fix_parameters(name_value_dict)
 
         self.assertEqual(self.pkpd_problem.get_n_parameters(), 9)
         param_names = self.pkpd_problem.get_parameter_names()
         self.assertEqual(len(param_names), 9)
         self.assertEqual(param_names[0], 'central.drug_amount')
-        self.assertEqual(param_names[1], 'myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'global.tumour_volume')
         self.assertEqual(param_names[2], 'central.size')
-        self.assertEqual(param_names[3], 'myokit.critical_volume')
-        self.assertEqual(param_names[4], 'myokit.elimination_rate')
-        self.assertEqual(param_names[5], 'myokit.kappa')
+        self.assertEqual(param_names[3], 'global.critical_volume')
+        self.assertEqual(param_names[4], 'global.elimination_rate')
+        self.assertEqual(param_names[5], 'global.kappa')
         self.assertEqual(
             param_names[6], 'central.drug_concentration Sigma rel.')
-        self.assertEqual(param_names[7], 'myokit.tumour_volume Sigma base')
-        self.assertEqual(param_names[8], 'myokit.tumour_volume Sigma rel.')
+        self.assertEqual(param_names[7], 'global.tumour_volume Sigma base')
+        self.assertEqual(param_names[8], 'global.tumour_volume Sigma rel.')
 
         # Free all parameters again
         name_value_dict = dict({
-            'myokit.lambda': None,
+            'global.lambda': None,
             'central.drug_concentration Sigma base': None})
         self.pkpd_problem.fix_parameters(name_value_dict)
 
@@ -249,18 +249,18 @@ def test_fix_parameters(self):
         param_names = self.pkpd_problem.get_parameter_names()
         self.assertEqual(len(param_names), 11)
         self.assertEqual(param_names[0], 'central.drug_amount')
-        self.assertEqual(param_names[1], 'myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'global.tumour_volume')
         self.assertEqual(param_names[2], 'central.size')
-        self.assertEqual(param_names[3], 'myokit.critical_volume')
-        self.assertEqual(param_names[4], 'myokit.elimination_rate')
-        self.assertEqual(param_names[5], 'myokit.kappa')
-        self.assertEqual(param_names[6], 'myokit.lambda')
+        self.assertEqual(param_names[3], 'global.critical_volume')
+        self.assertEqual(param_names[4], 'global.elimination_rate')
+        self.assertEqual(param_names[5], 'global.kappa')
+        self.assertEqual(param_names[6], 'global.lambda')
         self.assertEqual(
             param_names[7], 'central.drug_concentration Sigma base')
         self.assertEqual(
             param_names[8], 'central.drug_concentration Sigma rel.')
-        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')
-        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')
+        self.assertEqual(param_names[9], 'global.tumour_volume Sigma base')
+        self.assertEqual(param_names[10], 'global.tumour_volume Sigma rel.')
 
     def test_fix_parameters_bad_input(self):
         # Input is not a dictionary
@@ -328,7 +328,7 @@ def test_get_dosing_regimens(self):
         self.assertIsNone(regimens)
 
         # Set data, but because PD model, no dosing regimen can be set
-        problem.set_data(self.data, {'myokit.tumour_volume': 'Tumour volume'})
+        problem.set_data(self.data, {'global.tumour_volume': 'Tumour volume'})
         regimens = problem.get_dosing_regimens()
         self.assertIsNone(regimens)
 
@@ -344,7 +344,7 @@ def test_get_dosing_regimens(self):
         problem.set_data(
             self.data,
             output_observable_dict={
-                'myokit.tumour_volume': 'Tumour volume',
+                'global.tumour_volume': 'Tumour volume',
                 'central.drug_concentration': 'IL 6'},
             dose_duration_key=None)
         regimens = problem.get_dosing_regimens()
@@ -354,7 +354,7 @@ def test_get_dosing_regimens(self):
         problem.set_data(
             self.data,
             output_observable_dict={
-                'myokit.tumour_volume': 'Tumour volume',
+                'global.tumour_volume': 'Tumour volume',
                 'central.drug_concentration': 'IL 6'})
         regimens = problem.get_dosing_regimens()
         self.assertIsInstance(regimens, dict)
@@ -372,7 +372,7 @@ def test_get_log_posterior(self):
         # Set data which does not provide measurements for all IDs
         problem.set_data(
             self.data,
-            output_observable_dict={'myokit.tumour_volume': 'IL 6'})
+            output_observable_dict={'global.tumour_volume': 'IL 6'})
         problem.set_log_prior(pints.ComposedLogPrior(*[
             pints.HalfCauchyLogPrior(0, 1)]*7))
 
@@ -384,7 +384,7 @@ def test_get_log_posterior(self):
         # Set data that has measurements for all IDs
         problem.set_data(
             self.data,
-            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})
+            output_observable_dict={'global.tumour_volume': 'Tumour volume'})
         problem.set_log_prior(pints.ComposedLogPrior(*[
             pints.HalfCauchyLogPrior(0, 1)]*7))
 
@@ -402,8 +402,8 @@ def test_get_log_posterior(self):
 
         # Test case II: Fix some parameters
         name_value_dict = dict({
-            'myokit.drug_concentration': 0,
-            'myokit.kappa': 1})
+            'global.drug_concentration': 0,
+            'global.kappa': 1})
         problem.fix_parameters(name_value_dict)
         problem.set_log_prior(pints.ComposedLogPrior(*[
             pints.HalfCauchyLogPrior(0, 1)]*5))
@@ -451,15 +451,15 @@ def test_get_log_posterior(self):
         self.assertEqual(ids[1], '1')
         self.assertEqual(names[2], 'Sigma rel.')
         self.assertEqual(ids[2], '2')
-        self.assertEqual(names[3], 'Pooled myokit.tumour_volume')
+        self.assertEqual(names[3], 'Pooled global.tumour_volume')
         self.assertIsNone(ids[3])
-        self.assertEqual(names[4], 'ID 1 myokit.lambda_0')
+        self.assertEqual(names[4], 'ID 1 global.lambda_0')
         self.assertIsNone(ids[4])
-        self.assertEqual(names[5], 'ID 2 myokit.lambda_0')
+        self.assertEqual(names[5], 'ID 2 global.lambda_0')
         self.assertIsNone(ids[5])
-        self.assertEqual(names[6], 'ID 3 myokit.lambda_0')
+        self.assertEqual(names[6], 'ID 3 global.lambda_0')
         self.assertIsNone(ids[6])
-        self.assertEqual(names[7], 'Pooled myokit.lambda_1')
+        self.assertEqual(names[7], 'Pooled global.lambda_1')
         self.assertIsNone(ids[7])
         self.assertEqual(names[8], 'Pooled Sigma base')
         self.assertIsNone(ids[8])
@@ -488,15 +488,15 @@ def test_get_log_posterior(self):
         self.assertEqual(ids[1], '1')
         self.assertEqual(names[2], 'Sigma rel.')
         self.assertEqual(ids[2], '2')
-        self.assertEqual(names[3], 'Pooled myokit.tumour_volume')
+        self.assertEqual(names[3], 'Pooled global.tumour_volume')
         self.assertIsNone(ids[3])
-        self.assertEqual(names[4], 'ID 1 myokit.lambda_0')
+        self.assertEqual(names[4], 'ID 1 global.lambda_0')
         self.assertIsNone(ids[4])
-        self.assertEqual(names[5], 'ID 2 myokit.lambda_0')
+        self.assertEqual(names[5], 'ID 2 global.lambda_0')
         self.assertIsNone(ids[5])
-        self.assertEqual(names[6], 'ID 3 myokit.lambda_0')
+        self.assertEqual(names[6], 'ID 3 global.lambda_0')
         self.assertIsNone(ids[6])
-        self.assertEqual(names[7], 'Pooled myokit.lambda_1')
+        self.assertEqual(names[7], 'Pooled global.lambda_1')
         self.assertIsNone(ids[7])
         self.assertEqual(names[8], 'Pooled Sigma base')
         self.assertIsNone(ids[8])
@@ -516,7 +516,7 @@ def test_get_log_posterior(self):
             self.data,
             output_observable_dict={
                 'central.drug_concentration': 'IL 6',
-                'myokit.tumour_volume': 'Tumour volume'})
+                'global.tumour_volume': 'Tumour volume'})
         problem.set_log_prior(pints.ComposedLogPrior(*[
             pints.HalfCauchyLogPrior(0, 1)]*11))
 
@@ -536,7 +536,7 @@ def test_get_log_posterior_bad_input(self):
         # No log-prior has been set
         problem.set_data(
             self.data,
-            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})
+            output_observable_dict={'global.tumour_volume': 'Tumour volume'})
 
         with self.assertRaisesRegex(ValueError, 'The log-prior has not'):
             problem.get_log_posterior()
@@ -582,7 +582,7 @@ def test_get_n_parameters(self):
         # Test case I.3: Set data
         problem.set_data(
             self.data,
-            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})
+            output_observable_dict={'global.tumour_volume': 'Tumour volume'})
         n_parameters = problem.get_n_parameters()
         self.assertEqual(n_parameters, 11)
 
@@ -627,7 +627,7 @@ def test_get_n_parameters(self):
         problem.set_data(
             self.data,
             output_observable_dict={
-                'myokit.tumour_volume': 'Tumour volume',
+                'global.tumour_volume': 'Tumour volume',
                 'central.drug_concentration': 'IL 6'})
         n_parameters = problem.get_n_parameters()
         self.assertEqual(n_parameters, 15)
@@ -645,22 +645,22 @@ def test_get_parameter_names(self):
         # Test default flag
         param_names = problem.get_parameter_names()
         self.assertEqual(len(param_names), 7)
-        self.assertEqual(param_names[0], 'myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'myokit.drug_concentration')
-        self.assertEqual(param_names[2], 'myokit.kappa')
-        self.assertEqual(param_names[3], 'myokit.lambda_0')
-        self.assertEqual(param_names[4], 'myokit.lambda_1')
+        self.assertEqual(param_names[0], 'global.tumour_volume')
+        self.assertEqual(param_names[1], 'global.drug_concentration')
+        self.assertEqual(param_names[2], 'global.kappa')
+        self.assertEqual(param_names[3], 'global.lambda_0')
+        self.assertEqual(param_names[4], 'global.lambda_1')
         self.assertEqual(param_names[5], 'Sigma base')
         self.assertEqual(param_names[6], 'Sigma rel.')
 
         # Check that also works with exclude pop params flag
         param_names = problem.get_parameter_names(exclude_pop_model=True)
         self.assertEqual(len(param_names), 7)
-        self.assertEqual(param_names[0], 'myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'myokit.drug_concentration')
-        self.assertEqual(param_names[2], 'myokit.kappa')
-        self.assertEqual(param_names[3], 'myokit.lambda_0')
-        self.assertEqual(param_names[4], 'myokit.lambda_1')
+        self.assertEqual(param_names[0], 'global.tumour_volume')
+        self.assertEqual(param_names[1], 'global.drug_concentration')
+        self.assertEqual(param_names[2], 'global.kappa')
+        self.assertEqual(param_names[3], 'global.lambda_0')
+        self.assertEqual(param_names[4], 'global.lambda_1')
         self.assertEqual(param_names[5], 'Sigma base')
         self.assertEqual(param_names[6], 'Sigma rel.')
 
@@ -676,11 +676,11 @@ def test_get_parameter_names(self):
         problem.set_population_model(pop_model)
         param_names = problem.get_parameter_names()
         self.assertEqual(len(param_names), 9)
-        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')
-        self.assertEqual(param_names[2], 'ID 1 myokit.kappa')
-        self.assertEqual(param_names[3], 'Pooled myokit.lambda_0')
-        self.assertEqual(param_names[4], 'Pooled myokit.lambda_1')
+        self.assertEqual(param_names[0], 'Pooled global.tumour_volume')
+        self.assertEqual(param_names[1], 'Pooled global.drug_concentration')
+        self.assertEqual(param_names[2], 'ID 1 global.kappa')
+        self.assertEqual(param_names[3], 'Pooled global.lambda_0')
+        self.assertEqual(param_names[4], 'Pooled global.lambda_1')
         self.assertEqual(param_names[5], 'Log mean Sigma base')
         self.assertEqual(param_names[6], 'Log std. Sigma base')
         self.assertEqual(param_names[7], 'Log mean Sigma rel.')
@@ -689,27 +689,27 @@ def test_get_parameter_names(self):
         # Test exclude population model True
         param_names = problem.get_parameter_names(exclude_pop_model=True)
         self.assertEqual(len(param_names), 7)
-        self.assertEqual(param_names[0], 'myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'myokit.drug_concentration')
-        self.assertEqual(param_names[2], 'myokit.kappa')
-        self.assertEqual(param_names[3], 'myokit.lambda_0')
-        self.assertEqual(param_names[4], 'myokit.lambda_1')
+        self.assertEqual(param_names[0], 'global.tumour_volume')
+        self.assertEqual(param_names[1], 'global.drug_concentration')
+        self.assertEqual(param_names[2], 'global.kappa')
+        self.assertEqual(param_names[3], 'global.lambda_0')
+        self.assertEqual(param_names[4], 'global.lambda_1')
         self.assertEqual(param_names[5], 'Sigma base')
         self.assertEqual(param_names[6], 'Sigma rel.')
 
         # Test case I.3: Set data
         problem.set_data(
             self.data,
-            output_observable_dict={'myokit.tumour_volume': 'Tumour volume'})
+            output_observable_dict={'global.tumour_volume': 'Tumour volume'})
         param_names = problem.get_parameter_names()
         self.assertEqual(len(param_names), 11)
-        self.assertEqual(param_names[0], 'Pooled myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'Pooled myokit.drug_concentration')
-        self.assertEqual(param_names[2], 'ID 1 myokit.kappa')
-        self.assertEqual(param_names[3], 'ID 2 myokit.kappa')
-        self.assertEqual(param_names[4], 'ID 3 myokit.kappa')
-        self.assertEqual(param_names[5], 'Pooled myokit.lambda_0')
-        self.assertEqual(param_names[6], 'Pooled myokit.lambda_1')
+        self.assertEqual(param_names[0], 'Pooled global.tumour_volume')
+        self.assertEqual(param_names[1], 'Pooled global.drug_concentration')
+        self.assertEqual(param_names[2], 'ID 1 global.kappa')
+        self.assertEqual(param_names[3], 'ID 2 global.kappa')
+        self.assertEqual(param_names[4], 'ID 3 global.kappa')
+        self.assertEqual(param_names[5], 'Pooled global.lambda_0')
+        self.assertEqual(param_names[6], 'Pooled global.lambda_1')
         self.assertEqual(param_names[7], 'Log mean Sigma base')
         self.assertEqual(param_names[8], 'Log std. Sigma base')
         self.assertEqual(param_names[9], 'Log mean Sigma rel.')
@@ -718,11 +718,11 @@ def test_get_parameter_names(self):
         # Test exclude population model True
         param_names = problem.get_parameter_names(exclude_pop_model=True)
         self.assertEqual(len(param_names), 7)
-        self.assertEqual(param_names[0], 'myokit.tumour_volume')
-        self.assertEqual(param_names[1], 'myokit.drug_concentration')
-        self.assertEqual(param_names[2], 'myokit.kappa')
-        self.assertEqual(param_names[3], 'myokit.lambda_0')
-        self.assertEqual(param_names[4], 'myokit.lambda_1')
+        self.assertEqual(param_names[0], 'global.tumour_volume')
+        self.assertEqual(param_names[1], 'global.drug_concentration')
+        self.assertEqual(param_names[2], 'global.kappa')
+        self.assertEqual(param_names[3], 'global.lambda_0')
+        self.assertEqual(param_names[4], 'global.lambda_1')
         self.assertEqual(param_names[5], 'Sigma base')
         self.assertEqual(param_names[6], 'Sigma rel.')
 
@@ -735,35 +735,35 @@ def test_get_parameter_names(self):
         param_names = problem.get_parameter_names()
         self.assertEqual(len(param_names), 11)
         self.assertEqual(param_names[0], 'central.drug_amount')
-        self.assertEqual(param_names[1], 'myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'global.tumour_volume')
         self.assertEqual(param_names[2], 'central.size')
-        self.assertEqual(param_names[3], 'myokit.critical_volume')
-        self.assertEqual(param_names[4], 'myokit.elimination_rate')
-        self.assertEqual(param_names[5], 'myokit.kappa')
-        self.assertEqual(param_names[6], 'myokit.lambda')
+        self.assertEqual(param_names[3], 'global.critical_volume')
+        self.assertEqual(param_names[4], 'global.elimination_rate')
+        self.assertEqual(param_names[5], 'global.kappa')
+        self.assertEqual(param_names[6], 'global.lambda')
         self.assertEqual(
             param_names[7], 'central.drug_concentration Sigma base')
         self.assertEqual(
             param_names[8], 'central.drug_concentration Sigma rel.')
-        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')
-        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')
+        self.assertEqual(param_names[9], 'global.tumour_volume Sigma base')
+        self.assertEqual(param_names[10], 'global.tumour_volume Sigma rel.')
 
         # Test exclude population model True
         param_names = problem.get_parameter_names(exclude_pop_model=True)
         self.assertEqual(len(param_names), 11)
         self.assertEqual(param_names[0], 'central.drug_amount')
-        self.assertEqual(param_names[1], 'myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'global.tumour_volume')
         self.assertEqual(param_names[2], 'central.size')
-        self.assertEqual(param_names[3], 'myokit.critical_volume')
-        self.assertEqual(param_names[4], 'myokit.elimination_rate')
-        self.assertEqual(param_names[5], 'myokit.kappa')
-        self.assertEqual(param_names[6], 'myokit.lambda')
+        self.assertEqual(param_names[3], 'global.critical_volume')
+        self.assertEqual(param_names[4], 'global.elimination_rate')
+        self.assertEqual(param_names[5], 'global.kappa')
+        self.assertEqual(param_names[6], 'global.lambda')
         self.assertEqual(
             param_names[7], 'central.drug_concentration Sigma base')
         self.assertEqual(
             param_names[8], 'central.drug_concentration Sigma rel.')
-        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')
-        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')
+        self.assertEqual(param_names[9], 'global.tumour_volume Sigma base')
+        self.assertEqual(param_names[10], 'global.tumour_volume Sigma rel.')
 
         # Test case II.2: Population model
         cov_pop_model = chi.CovariatePopulationModel(
@@ -786,14 +786,14 @@ def test_get_parameter_names(self):
         param_names = problem.get_parameter_names()
         self.assertEqual(len(param_names), 16)
         self.assertEqual(param_names[0], 'Pooled central.drug_amount')
-        self.assertEqual(param_names[1], 'Pooled myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'Pooled global.tumour_volume')
         self.assertEqual(param_names[2], 'ID 1 central.size')
-        self.assertEqual(param_names[3], 'Pooled myokit.critical_volume')
-        self.assertEqual(param_names[4], 'Pooled myokit.elimination_rate')
-        self.assertEqual(param_names[5], 'Log mean myokit.kappa')
-        self.assertEqual(param_names[6], 'Log std. myokit.kappa')
-        self.assertEqual(param_names[7], 'Log mean myokit.lambda')
-        self.assertEqual(param_names[8], 'Log std. myokit.lambda')
+        self.assertEqual(param_names[3], 'Pooled global.critical_volume')
+        self.assertEqual(param_names[4], 'Pooled global.elimination_rate')
+        self.assertEqual(param_names[5], 'Log mean global.kappa')
+        self.assertEqual(param_names[6], 'Log std. global.kappa')
+        self.assertEqual(param_names[7], 'Log mean global.lambda')
+        self.assertEqual(param_names[8], 'Log std. global.lambda')
         self.assertEqual(
             param_names[9], 'Pooled central.drug_concentration Sigma base')
         self.assertEqual(
@@ -808,46 +808,46 @@ def test_get_parameter_names(self):
             param_names[13],
             'Log std. central.drug_concentration Sigma rel. Age')
         self.assertEqual(
-            param_names[14], 'Pooled myokit.tumour_volume Sigma base')
+            param_names[14], 'Pooled global.tumour_volume Sigma base')
         self.assertEqual(
-            param_names[15], 'Pooled myokit.tumour_volume Sigma rel.')
+            param_names[15], 'Pooled global.tumour_volume Sigma rel.')
 
         # Test exclude population model True
         param_names = problem.get_parameter_names(exclude_pop_model=True)
         self.assertEqual(len(param_names), 11)
         self.assertEqual(param_names[0], 'central.drug_amount')
-        self.assertEqual(param_names[1], 'myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'global.tumour_volume')
         self.assertEqual(param_names[2], 'central.size')
-        self.assertEqual(param_names[3], 'myokit.critical_volume')
-        self.assertEqual(param_names[4], 'myokit.elimination_rate')
-        self.assertEqual(param_names[5], 'myokit.kappa')
-        self.assertEqual(param_names[6], 'myokit.lambda')
+        self.assertEqual(param_names[3], 'global.critical_volume')
+        self.assertEqual(param_names[4], 'global.elimination_rate')
+        self.assertEqual(param_names[5], 'global.kappa')
+        self.assertEqual(param_names[6], 'global.lambda')
         self.assertEqual(
             param_names[7], 'central.drug_concentration Sigma base')
         self.assertEqual(
             param_names[8], 'central.drug_concentration Sigma rel.')
-        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')
-        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')
+        self.assertEqual(param_names[9], 'global.tumour_volume Sigma base')
+        self.assertEqual(param_names[10], 'global.tumour_volume Sigma rel.')
 
         # Test case II.3: Set data
         problem.set_data(
             self.data,
             output_observable_dict={
-                'myokit.tumour_volume': 'Tumour volume',
+                'global.tumour_volume': 'Tumour volume',
                 'central.drug_concentration': 'IL 6'})
         param_names = problem.get_parameter_names()
         self.assertEqual(len(param_names), 18)
         self.assertEqual(param_names[0], 'Pooled central.drug_amount')
-        self.assertEqual(param_names[1], 'Pooled myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'Pooled global.tumour_volume')
         self.assertEqual(param_names[2], 'ID 1 central.size')
         self.assertEqual(param_names[3], 'ID 2 central.size')
         self.assertEqual(param_names[4], 'ID 3 central.size')
-        self.assertEqual(param_names[5], 'Pooled myokit.critical_volume')
-        self.assertEqual(param_names[6], 'Pooled myokit.elimination_rate')
-        self.assertEqual(param_names[7], 'Log mean myokit.kappa')
-        self.assertEqual(param_names[8], 'Log std. myokit.kappa')
-        self.assertEqual(param_names[9], 'Log mean myokit.lambda')
-        self.assertEqual(param_names[10], 'Log std. myokit.lambda')
+        self.assertEqual(param_names[5], 'Pooled global.critical_volume')
+        self.assertEqual(param_names[6], 'Pooled global.elimination_rate')
+        self.assertEqual(param_names[7], 'Log mean global.kappa')
+        self.assertEqual(param_names[8], 'Log std. global.kappa')
+        self.assertEqual(param_names[9], 'Log mean global.lambda')
+        self.assertEqual(param_names[10], 'Log std. global.lambda')
         self.assertEqual(
             param_names[11], 'Pooled central.drug_concentration Sigma base')
         self.assertEqual(
@@ -862,26 +862,26 @@ def test_get_parameter_names(self):
             param_names[15],
             'Log std. central.drug_concentration Sigma rel. Age')
         self.assertEqual(
-            param_names[16], 'Pooled myokit.tumour_volume Sigma base')
+            param_names[16], 'Pooled global.tumour_volume Sigma base')
         self.assertEqual(
-            param_names[17], 'Pooled myokit.tumour_volume Sigma rel.')
+            param_names[17], 'Pooled global.tumour_volume Sigma rel.')
 
         # Test exclude population model True
         param_names = problem.get_parameter_names(exclude_pop_model=True)
         self.assertEqual(len(param_names), 11)
         self.assertEqual(param_names[0], 'central.drug_amount')
-        self.assertEqual(param_names[1], 'myokit.tumour_volume')
+        self.assertEqual(param_names[1], 'global.tumour_volume')
         self.assertEqual(param_names[2], 'central.size')
-        self.assertEqual(param_names[3], 'myokit.critical_volume')
-        self.assertEqual(param_names[4], 'myokit.elimination_rate')
-        self.assertEqual(param_names[5], 'myokit.kappa')
-        self.assertEqual(param_names[6], 'myokit.lambda')
+        self.assertEqual(param_names[3], 'global.critical_volume')
+        self.assertEqual(param_names[4], 'global.elimination_rate')
+        self.assertEqual(param_names[5], 'global.kappa')
+        self.assertEqual(param_names[6], 'global.lambda')
         self.assertEqual(
             param_names[7], 'central.drug_concentration Sigma base')
         self.assertEqual(
             param_names[8], 'central.drug_concentration Sigma rel.')
-        self.assertEqual(param_names[9], 'myokit.tumour_volume Sigma base')
-        self.assertEqual(param_names[10], 'myokit.tumour_volume Sigma rel.')
+        self.assertEqual(param_names[9], 'global.tumour_volume Sigma base')
+        self.assertEqual(param_names[10], 'global.tumour_volume Sigma rel.')
 
     def test_get_predictive_model(self):
         # Test case I: PD model
@@ -934,7 +934,7 @@ def test_set_data(self):
         # Set data with explicit output-observable map
         problem = chi.ProblemModellingController(
             self.pd_model, self.error_model)
-        output_observable_dict = {'myokit.tumour_volume': 'Tumour volume'}
+        output_observable_dict = {'global.tumour_volume': 'Tumour volume'}
         problem.set_data(self.data, output_observable_dict)
 
         # Set data with implicit output-observable map
@@ -998,7 +998,7 @@ def test_set_data_bad_input(self):
 
         # The output-observable map references a observable that is not in the
         # dataframe
-        output_observable_dict = {'myokit.tumour_volume': 'some observable'}
+        output_observable_dict = {'global.tumour_volume': 'some observable'}
         with self.assertRaisesRegex(ValueError, 'The observable <some'):
             self.pd_problem.set_data(self.data, output_observable_dict)
 
@@ -1020,7 +1020,7 @@ def test_set_data_bad_input(self):
         pop_model = chi.ComposedPopulationModel(
             [cov_pop_model1] * 4 + [cov_pop_model2] * 3)
         problem.set_population_model(pop_model)
-        output_observable_dict = {'myokit.tumour_volume': 'Tumour volume'}
+        output_observable_dict = {'global.tumour_volume': 'Tumour volume'}
         covariate_dict = {'Age': 'Age', 'Something': 'else'}
         with self.assertRaisesRegex(ValueError, 'The covariate <Sex> could'):
             problem.set_data(
@@ -1062,7 +1062,7 @@ def test_set_log_prior(self):
         # Test case I: PD model
         problem = chi.ProblemModellingController(
             self.pd_model, self.error_model)
-        problem.set_data(self.data, {'myokit.tumour_volume': 'Tumour volume'})
+        problem.set_data(self.data, {'global.tumour_volume': 'Tumour volume'})
         log_prior = pints.ComposedLogPrior(
             *[pints.HalfCauchyLogPrior(0, 1)] * 7)
         problem.set_log_prior(log_prior)
@@ -1076,7 +1076,7 @@ def test_set_log_prior_bad_input(self):
             problem.set_log_prior('some prior')
 
         # Wrong log-prior type
-        problem.set_data(self.data, {'myokit.tumour_volume': 'Tumour volume'})
+        problem.set_data(self.data, {'global.tumour_volume': 'Tumour volume'})
         log_prior = 'Wrong type'
         with self.assertRaisesRegex(ValueError, 'The log-prior has to be an'):
             problem.set_log_prior(log_prior)
@@ -1091,7 +1091,7 @@ def test_set_population_model(self):
         # Test case I: PD model
         problem = chi.ProblemModellingController(
             self.pd_model, self.error_model)
-        problem.set_data(self.data, {'myokit.tumour_volume': 'Tumour volume'})
+        problem.set_data(self.data, {'global.tumour_volume': 'Tumour volume'})
         pop_model = chi.ComposedPopulationModel([
             chi.PooledModel(),
             chi.PooledModel(),
@@ -1123,7 +1123,7 @@ def test_set_population_model(self):
             self.data,
             output_observable_dict={
                 'central.drug_concentration': 'IL 6',
-                'myokit.tumour_volume': 'Tumour volume'})
+                'global.tumour_volume': 'Tumour volume'})
         pop_model = chi.ComposedPopulationModel([
             chi.LogNormalModel(),
             chi.LogNormalModel(),
diff --git a/docs/source/getting_started/code/1_simulation_1.py b/docs/source/getting_started/code/1_simulation_1.py
index 00473797..58d587db 100644
--- a/docs/source/getting_started/code/1_simulation_1.py
+++ b/docs/source/getting_started/code/1_simulation_1.py
@@ -222,7 +222,7 @@
     fig.add_trace(
         go.Histogram(
             name='Posterior samples',
-            x=posterior_samples['myokit.elimination_rate'].values.flatten(),
+            x=posterior_samples['global.elimination_rate'].values.flatten(),
             histnorm='probability',
             showlegend=False
         ),
@@ -497,7 +497,7 @@
 fig.add_trace(
     go.Histogram(
         name='Posterior samples',
-        x=posterior_samples['myokit.elimination_rate'].values.flatten(),
+        x=posterior_samples['global.elimination_rate'].values.flatten(),
         histnorm='probability',
         showlegend=False
     ),
diff --git a/docs/source/getting_started/code/1_simulation_2.py b/docs/source/getting_started/code/1_simulation_2.py
index 1d53762b..cc158ead 100644
--- a/docs/source/getting_started/code/1_simulation_2.py
+++ b/docs/source/getting_started/code/1_simulation_2.py
@@ -395,7 +395,7 @@
     fig.add_trace(
         go.Histogram(
             name='Patient 1 Post. samples',
-            x=posterior_samples['myokit.elimination_rate'].values[
+            x=posterior_samples['global.elimination_rate'].values[
                 0, :, 0].flatten(),
             histnorm='probability',
             showlegend=False,
@@ -407,7 +407,7 @@
     fig.add_trace(
         go.Histogram(
             name='Patient 1 Post. samples',
-            x=posterior_samples['myokit.elimination_rate'].values[
+            x=posterior_samples['global.elimination_rate'].values[
                 0, :, 1].flatten(),
             histnorm='probability',
             showlegend=False,
@@ -419,7 +419,7 @@
     fig.add_trace(
         go.Histogram(
             name='Patient 1 post. samples',
-            x=posterior_samples['myokit.elimination_rate'].values[
+            x=posterior_samples['global.elimination_rate'].values[
                 0, :, 2].flatten(),
             histnorm='probability',
             showlegend=False,
@@ -953,7 +953,7 @@
 fig.add_trace(
     go.Histogram(
         name='Patient 1 Post. samples',
-        x=posterior_samples['myokit.elimination_rate'].values[
+        x=posterior_samples['global.elimination_rate'].values[
             0, :, 0].flatten(),
         histnorm='probability',
         showlegend=False,
@@ -965,7 +965,7 @@
 fig.add_trace(
     go.Histogram(
         name='Patient 1 Post. samples',
-        x=posterior_samples['myokit.elimination_rate'].values[
+        x=posterior_samples['global.elimination_rate'].values[
             0, :, 1].flatten(),
         histnorm='probability',
         showlegend=False,
@@ -977,7 +977,7 @@
 fig.add_trace(
     go.Histogram(
         name='Patient 1 post. samples',
-        x=posterior_samples['myokit.elimination_rate'].values[
+        x=posterior_samples['global.elimination_rate'].values[
             0, :, 2].flatten(),
         histnorm='probability',
         showlegend=False,
diff --git a/setup.py b/setup.py
index 781beeb7..d690cf23 100644
--- a/setup.py
+++ b/setup.py
@@ -9,7 +9,7 @@
 setup(
     # Module name
     name='chi-drm',
-    version='0.2.2',
+    version='0.2.3',
     description='Package to model dose response dynamics',
     long_description=readme,
     long_description_content_type="text/markdown",
@@ -31,7 +31,7 @@
     # List of dependencies
     install_requires=[
         'arviz>=0.11',
-        'myokit>=1.33',
+        'myokit>=1.34',
         'numpy>=1.17',
         'pandas>=0.24',
         'pints>=0.4',