Repository: twallema/pySODM (language: python)

Issue:
The suffix '_names' in the model declaration seems redundant
# Current implementation

They're all `_names` technically.

```python
class ODE_influenza_model(ODEModel):
    """
    Simple SEIR model for influenza with undetected carriers
    """
    
    state_names = ['S','E','Ip','Iud','Id','R','Im_inc']
    parameter_names = ['alpha', 'beta', 'gamma', 'delta','N']
    parameter_stratified_names = ['f_ud']
    dimension_names = ['age_group']

    @staticmethod
    def integrate(t, S, E, Ip, Iud, Id, R, Im_inc, alpha, beta, gamma, delta, N, f_ud):
        
        # Calculate total population
        T = S+E+Ip+Iud+Id+R
        # Calculate differentials
        dS = -beta*N@((Ip+Iud+0.22*Id)*S/T)
        dE = beta*N@((Ip+Iud+0.22*Id)*S/T) - 1/alpha*E
        dIp = 1/alpha*E - 1/gamma*Ip
        dIud = f_ud/gamma*Ip - 1/delta*Iud
        dId = (1-f_ud)/gamma*Ip - 1/delta*Id
        dR = 1/delta*(Iud+Id)
        # Calculate incidence mild disease
        dIm_inc_new = (1-f_ud)/gamma*Ip - Im_inc

        return dS, dE, dIp, dIud, dId, dR, dIm_inc_new
```

# Proposed implementation

Additionally, drop the stratified parameters?

```python
class ODE_influenza_model(ODEModel):
    """
    Simple SEIR model for influenza with undetected carriers
    """
    
    states = ['S','E','Ip','Iud','Id','R','Im_inc']
    parameters = ['alpha', 'beta', 'gamma', 'delta','N']
    stratified_parameters = ['f_ud']
    dimensions = ['age_group']

    @staticmethod
    def integrate(t, S, E, Ip, Iud, Id, R, Im_inc, alpha, beta, gamma, delta, N, f_ud):
        
        # Calculate total population
        T = S+E+Ip+Iud+Id+R
        # Calculate differentials
        dS = -beta*N@((Ip+Iud+0.22*Id)*S/T)
        dE = beta*N@((Ip+Iud+0.22*Id)*S/T) - 1/alpha*E
        dIp = 1/alpha*E - 1/gamma*Ip
        dIud = f_ud/gamma*Ip - 1/delta*Iud
        dId = (1-f_ud)/gamma*Ip - 1/delta*Id
        dR = 1/delta*(Iud+Id)
        # Calculate incidence mild disease
        dIm_inc_new = (1-f_ud)/gamma*Ip - Im_inc

        return dS, dE, dIp, dIud, dId, dR, dIm_inc_new
```



Discussion / hints:

Fix patch:
diff --git a/docs/enzyme_kinetics.md b/docs/enzyme_kinetics.md
index 20daf3d..d8c4d61 100644
--- a/docs/enzyme_kinetics.md
+++ b/docs/enzyme_kinetics.md
@@ -62,8 +62,8 @@ class PPBB_model(ODEModel):
     S + A <--> Es + W
     """
     
-    state_names = ['S','A','Es','W']
-    parameter_names = ['c_enzyme', 'Vf_Ks', 'R_AS', 'R_AW', 'R_Es', 'K_eq']
+    states = ['S','A','Es','W']
+    parameters = ['c_enzyme', 'Vf_Ks', 'R_AS', 'R_AW', 'R_Es', 'K_eq']
 
     @staticmethod
     def integrate(t, S, A, Es, W, c_enzyme, Vf_Ks, R_AS, R_AW, R_Es, K_eq):
@@ -354,7 +354,7 @@ We'll start by coding the 1D packed PFR model in our `models.py`. Our model has
 - {math}`C_{F}^{i,j}` : The concentration of species {math}`i` at axial location {math}`j` in the freestreaming liquid.
 - {math}`C_{S}^{i,j}` : The concentration of species {math}`i` at axial location {math}`j` at the catalyst surface.
 
-We'll use the concept of *dimensions* to implement these two-dimensional numpy arrays. We'll do this by defining `dimension_names = ['species', 'x']`. At this point, we only need to provide a good name for our dimension, the coordinates are provided later when we initialize the model model. Additionally, we have a mass transfer coefficient {math}`k_La^{i}` and an axial dispersion coefficient {math}`D_{ax}^i` for every species. We can optionally assign these parameters as *stratified parameters* of the species axis in our model declaration by defining `parameter_stratified_names = [['kL_a', 'D_ax'],]`. This is not necessary, but the length of *stratified parameters* are contrasted to the dimension's coordinates when the model is initialized, providing a fail safe.
+We'll use the concept of *dimensions* to implement these two-dimensional numpy arrays. We'll do this by defining `dimensions = ['species', 'x']`. At this point, we only need to provide a good name for our dimension, the coordinates are provided later when we initialize the model model. Additionally, we have a mass transfer coefficient {math}`k_La^{i}` and an axial dispersion coefficient {math}`D_{ax}^i` for every species. We can optionally assign these parameters as *stratified parameters* of the species axis in our model declaration by defining `stratified_parameters = [['kL_a', 'D_ax'],]`. This is not necessary, but the length of *stratified parameters* are contrasted to the dimension's coordinates when the model is initialized, providing a fail safe.
 
 The derivatives are pre-initialized as zeros and their computation is done by looping over every reacting species and then looping over all spatial nodes except the inlet node ({math}`j=0`). An exception is coded at the outlet, whwere the no-flux boundary approximation is substituted in the system of equations. Stepping through these loops slows the code down and thus we decorate the `integrate()` function with the [numba](https://numba.pydata.org/) `@njit` decorator. Doing so speeds the code up by a factor 16.
 
@@ -368,10 +368,10 @@ class packed_PFR(ODEModel):
     S + A <--> Es + W
     """
 
-    state_names = ['C_F', 'C_S']
-    parameter_names = ['delta_x', 'epsilon', 'u', 'rho_B','Vf_Ks', 'R_AS', 'R_AW', 'K_eq', 'R_Es']
-    dimension_names = ['species', 'x']
-    parameter_stratified_names = [['kL_a', 'D_ax'],]
+    states = ['C_F', 'C_S']
+    parameters = ['delta_x', 'epsilon', 'u', 'rho_B','Vf_Ks', 'R_AS', 'R_AW', 'K_eq', 'R_Es']
+    dimensions = ['species', 'x']
+    stratified_parameters = [['kL_a', 'D_ax'],]
 
     @staticmethod
     @njit
@@ -410,7 +410,7 @@ class packed_PFR(ODEModel):
         return dC_F, dC_S
 ```
 
-Because the model is stratified, a dictionary containing the coordinates of every dimension must be provided when initializing the model. The keys of the dictionary must match the names provided previously in `dimension_names`. We define the names of our four species as coordinates of the species dimension. To define a reactor of 1 m, discretized in 100 parts, we define `np.linspace(start=0, stop=1, num=100)` as the coordinates of the spatial axis. In the model, the states are `np.ndarrays` of size `(4,100)`.
+Because the model is stratified, a dictionary containing the coordinates of every dimension must be provided when initializing the model. The keys of the dictionary must match the names provided previously in `dimensions`. We define the names of our four species as coordinates of the species dimension. To define a reactor of 1 m, discretized in 100 parts, we define `np.linspace(start=0, stop=1, num=100)` as the coordinates of the spatial axis. In the model, the states are `np.ndarrays` of size `(4,100)`.
 
 ```python
 # Define coordinates
diff --git a/docs/influenza_1718.md b/docs/influenza_1718.md
index 4ba4b63..4144ced 100644
--- a/docs/influenza_1718.md
+++ b/docs/influenza_1718.md
@@ -100,7 +100,7 @@ and the population basic reproduction number is computed as the weighted average
 
 ### The model
 
-Opposed to ODE models, where the user had to define an `integrate()` function to compute the values of the derivatives at time {math}`t`, the user will have to define [two functions](models.md) to setup an SDE model: 1) A function to compute the rates at time {math}`t` named `compute_rates()`, and 2) A function to compute the values of the model states at time {math}`t+\tau` named `apply_transitionings()`. As we did in the [packed-bed continuous flow reactor](enzyme_kinetics.md) tutorial, we'll stratifiy the model into age groups by specifying a variable `dimension_names` in our model declaration and we'll implement the parameter {math}`f_a` as a stratified parameter by specifying a variable `parameter_stratified_names`. **As dimension name, we use the same name as the age dimension in the dataset: `'age_group'`. The coordinates of the dimension will be defined later when the model is initialized, we'll have to use the same coordinates as the dataset.** As in the [enzyme kinetics tutorial](enzyme_kinetics.md), we'll group our model in a file called `models.py` to reduce the complexity of our calibration script. We introduce one additional state in the model, the incidence of new detected cases, `I_m_inc`, which we'll use this state to match our data to.
+Opposed to ODE models, where the user had to define an `integrate()` function to compute the values of the derivatives at time {math}`t`, the user will have to define [two functions](models.md) to setup an SDE model: 1) A function to compute the rates at time {math}`t` named `compute_rates()`, and 2) A function to compute the values of the model states at time {math}`t+\tau` named `apply_transitionings()`. As we did in the [packed-bed continuous flow reactor](enzyme_kinetics.md) tutorial, we'll stratifiy the model into age groups by specifying a variable `dimensions` in our model declaration and we'll implement the parameter {math}`f_a` as a stratified parameter by specifying a variable `stratified_parameters`. **As dimension name, we use the same name as the age dimension in the dataset: `'age_group'`. The coordinates of the dimension will be defined later when the model is initialized, we'll have to use the same coordinates as the dataset.** As in the [enzyme kinetics tutorial](enzyme_kinetics.md), we'll group our model in a file called `models.py` to reduce the complexity of our calibration script. We introduce one additional state in the model, the incidence of new detected cases, `I_m_inc`, which we'll use this state to match our data to.
 
 ```python
 from pySODM.models.base import SDEModel
@@ -110,10 +110,10 @@ class SDE_influenza_model(SDEModel):
     Simple stochastic SEIR model for influenza with undetected carriers
     """
     
-    state_names = ['S','E','Ip','Iud','Id','R','Im_inc']
-    parameter_names = ['alpha', 'beta', 'gamma', 'delta','N']
-    parameter_stratified_names = ['f_ud']
-    dimension_names = ['age_group']
+    states = ['S','E','Ip','Iud','Id','R','Im_inc']
+    parameters = ['alpha', 'beta', 'gamma', 'delta','N']
+    stratified_parameters = ['f_ud']
+    dimensions = ['age_group']
 
     @staticmethod
     def compute_rates(t, S, E, Ip, Iud, Id, R, Im_inc, alpha, beta, gamma, delta, N, f_ud):
diff --git a/docs/models.md b/docs/models.md
index ea0c192..2061603 100644
--- a/docs/models.md
+++ b/docs/models.md
@@ -8,24 +8,24 @@ Standard usage of pySODM involves building an ODE or SDE model. For practical ex
 
 The ODEModel class inherits several attributes from the model class defined by the user.
 
-**Inherits:**
+**Inherits from model declaration:**
 
-* **state_names** (list) - Names of the model's states.
-* **parameter_names** (list) - Names of the model's parameters. Parameters are not subject to input checks and can thus be of any datatype/size.
-* **integrate** (function) - Function computing the differentials of every model state. The integrate function must have the timestep `t` as its first input, followed by the `state_names`, `parameter_names` and `parameter_stratified_names` (their order is not important). The integrate function must return a differential for every model state of the correct size and **in the same order as `state_names`**. The integrate function must be a static method (include `@staticmethod`).
-* **dimension_names** (list) - optional - Names of the possible model dimensions. The coordinates of the dimensions are specified during initialization of the model.
-* **parameter_stratified_names** (list) - optional - Names of the *stratified* parameters. Stratified parameters must be of type list/1D np.array and their length, which must be equal to the number of coordinates of the dimension axis it corresponds to, is verified during model initialization. Their use is optional and mainly serves as a way for the user to structure his code.
+* **states** (list) - Names of the model's states. Internally converted to variable `states_names` upon model initialisation.
+* **parameters** (list) - Names of the model's parameters. Parameters are not subject to input checks and can thus be of any datatype/size. Internally converted to variable `parameters_names` upon model initialisation.
+* **integrate** (function) - Function computing the differentials of every model state. The integrate function must have the timestep `t` as its first input, followed by the names `states`, `parameters` and `stratified_parameters` (their order is not important). The integrate function must return a differential for every model state of the correct size and **in the same order as the names `states`**. The integrate function must be a static method (include `@staticmethod`).
+* **dimensions** (list) - optional - Names of the possible model dimensions. The coordinates of the dimensions are specified during initialization of the model. Internally converted to variable `dimensions_names` upon model initialisation.
+* **stratified_parameters** (list) - optional - Names of the *stratified* parameters. Stratified parameters must be of type list/1D np.array and their length, which must be equal to the number of coordinates of the dimension axis it corresponds to, is verified during model initialization. Internally converted to variable `stratified_parameters_names` upon model initialisation. Their use is optional and mainly serves as a way for the user to structure his code.
     * If the model has one dimension: list contains strings - `['stratpar_1', 'stratpar_2']`
-    * If the model has multiple dimensions: list contains *n* sublists, where *n* is the number of model dimensions (length of `dimension_names`). Each sublist contains names of stratified parameters associated with the dimension in the corresponding position in `dimension_names` - example: `[['stratpar_1', 'stratpar_2'],[],['stratpar_3']]`
-* **state_dimensions** (list) - optional - Specify, for each model state in `state_names`, its dimensions. Allows users to define models with states of different sizes. If `state_dimensions` is not provided, all model states will have the same size, depending on the model's dimensions specified in `dimension_names`. If specified, `state_dimensions` must contain *n* sublists, where *n* is the number of model states (length of `state_names`). If some model states have no dimensions (i.e. it is a float), specify an empty list.
+    * If the model has multiple dimensions: list contains *n* sublists, where *n* is the number of model dimensions (length of `dimensions`). Each sublist contains names of stratified parameters associated with the dimension in the corresponding position in `dimensions` - example: `[['stratpar_1', 'stratpar_2'],[],['stratpar_3']]`
+* **state_dimensions** (list) - optional - Specify, for each model state in `states`, its dimensions. Allows users to define models with states of different sizes. If `state_dimensions` is not provided, all model states will have the same size, depending on the model's dimensions specified in `dimensions`. If specified, `state_dimensions` must contain *n* sublists, where *n* is the number of model states (length of `states`). If some model states have no dimensions (i.e. it is a float), specify an empty list.
 
 Upon intialization of the model class, the following arguments must be provided.
 
 **Parameters:**
 
-* **states** (dict) - Keys: names of states. Values: values of states. The dictionary does not have to contain a key,value pair for all states listed in `state_names`. States that lack a key,value pair are filled with zeros upon initialization.
-* **parameters** (dict) - Keys: names of parameters. Values: values of parameters. A key,value pair must be provided for all parameters listed in `parameter_names` and `parameter_stratified_names`. If time dependent parameter functions with additional parameters (aside from the obligatory `t`, `states`, `params`) are used, these parameters must be included as well. 
-* **coordinates** (dict) - optional - Keys: names of dimensions (`dimension_names`). Values: desired coordinates for the dimension axis. Values provided here become the dimension's coordinates in the `xarray` Dataset.
+* **states** (dict) - Keys: names of states. Values: values of states. The dictionary does not have to contain a key,value pair for all state names listed in `states` of the model declaration. States that lack a key,value pair are filled with zeros upon initialization.
+* **parameters** (dict) - Keys: names of parameters. Values: values of parameters. A key,value pair must be provided for all parameter names listed in `parameters` and `stratified_parameters` of the model declaration. If time dependent parameter functions with additional parameters (aside from the obligatory `t`, `states`, `params`) are used, these parameters must be included as well. 
+* **coordinates** (dict) - optional - Keys: names of dimensions (`dimensions`). Values: desired coordinates for the dimension axis. Values provided here become the dimension's coordinates in the `xarray` Dataset.
 * **time_dependent_parameters** (dict) - optional - Keys: name of the model parameter the time-dependent parameter function should be applied to. Must be a valid model parameter. Values: time-dependent parameter function. Time-dependent parameter functions must have `t` (simulation timestep), `states` (model states at timestep `t`) and `params` (model parameters dictionary) as the first three arguments.
 
 **Methods:**
@@ -55,25 +55,25 @@ Upon intialization of the model class, the following arguments must be provided.
 
 The SDEModel class inherits several attributes from the model class defined by the user.
 
-**Inherits:**
+**Inherits from model declaration:**
 
-* **state_names** (list) - Names of the model's states.
-* **parameter_names** (list) - Names of the model's parameters. Parameters are not subject to input checks and can thus be of any datatype/size.
-* **compute_rates** (function) - Function returning the rates of transitioning between the model states. `compute_rates()` must have the timestep `t` as its first input, followed by the `state_names`, `parameter_names` and the `parameter_stratified_names` (their order is not important). `compute_rates()` must be a static method (include `@staticmethod`). The output of `compute_rates()` must be a dictionary. Its keys must be valid model states, a rate is only needed for the states undergoing a transitioning. The corresponding values must be a list containing the rates of the possible transitionings of the state. In this way, a model state can have multiple transitionings.
+* **states** (list) - Names of the model's states. Internally converted to variable `states_names` upon model initialisation.
+* **parameters** (list) - Names of the model's parameters. Parameters are not subject to input checks and can thus be of any datatype/size. Internally converted to variable `parameters_names` upon model initialisation.
+* **compute_rates** (function) - Function returning the rates of transitioning between the model states. `compute_rates()` must have the timestep `t` as its first input, followed by the names `states`, `parameters` and `stratified_parameters` (their order is not important). `compute_rates()` must be a static method (include `@staticmethod`). The output of `compute_rates()` must be a dictionary. Its keys must be valid model states, a rate is only needed for the states undergoing a transitioning. The corresponding values must be a list containing the rates of the possible transitionings of the state. In this way, a model state can have multiple transitionings.
 * **apply_transitionings** (function) - Function to update the states with the number of drawn transitionings. `apply_transitionings()` must have the timestep `t` as its first input, followed by the solver timestep `tau`, follwed by the dictionary containing the transitionings `transitionings`, then followed by the model states and parameters similarily to `compute_rates()`.
-* **dimension_names** (list) - optional - Names of the possible model dimensions. The coordinates of the dimensions are specified during initialization of the model.
-* **parameter_stratified_names** (list) - optional - Names of the *stratified* parameters. Stratified parameters must be of type list/1D np.array and their length, which must be equal to the number of coordinates of the dimension axis it corresponds to, is verified during model initialization. Their use is optional and mainly serves as a way for the user to structure his code.
+* **dimensions** (list) - optional - Names of the possible model dimensions. The coordinates of the dimensions are specified during initialization of the model. Internally converted to variable `dimensions_names` upon model initialisation.
+* **stratified_parameters** (list) - optional - Names of the *stratified* parameters. Stratified parameters must be of type list/1D np.array and their length, which must be equal to the number of coordinates of the dimension axis it corresponds to, is verified during model initialization. Internally converted to variable `stratified_parameters_names` upon model initialisation. Their use is optional and mainly serves as a way for the user to structure his code.
     * If the model has one dimension: list contains strings - `['stratpar_1', 'stratpar_2']`
-    * If the model has multiple dimensions: list contains *n* sublists, where *n* is the number of model dimensions (length of `dimension_names`). Each sublist contains names of stratified parameters associated with the dimension in the corresponding position in `dimension_names` - example: `[['stratpar_1', 'stratpar_2'],[],['stratpar_3']]`
-* **state_dimensions** (list) - optional - Specify, for each model state in `state_names`, its dimensions. Allows users to define models with states of different sizes. If `state_dimensions` is not provided, all model states will have the same size, depending on the model's dimensions specified in `dimension_names`. If specified, `state_dimensions` must contain *n* sublists, where *n* is the number of model states (length of `state_names`). If some model states have no dimensions (i.e. it is a float), specify an empty list.
+    * If the model has multiple dimensions: list contains *n* sublists, where *n* is the number of model dimensions (length of `dimensions`). Each sublist contains names of stratified parameters associated with the dimension in the corresponding position in `dimensions` - example: `[['stratpar_1', 'stratpar_2'],[],['stratpar_3']]`
+* **state_dimensions** (list) - optional - Specify, for each model state name in `states`, its dimensions. Allows users to define models with states of different sizes. If `state_dimensions` is not provided, all model states will have the same size, depending on the model's dimensions specified in `dimensions`. If specified, `state_dimensions` must contain *n* sublists, where *n* is the number of model states (length of `states`). If some model states have no dimensions (i.e. it is a float), specify an empty list.
 
 Upon intialization of the model class, the following arguments must be provided.
 
 **Parameters:**
 
-* **states** (dict) - Keys: names of states. Values: values of states. The dictionary does not have to contain a key,value pair for all states listed in `state_names`. States that lack a key,value pair are filled with zeros upon initialization.
-* **parameters** (dict) - Keys: names of parameters. Values: values of parameters. A key,value pair must be provided for all parameters listed in `parameter_names` and `parameter_stratified_names`. If time dependent parameter functions with additional parameters (aside from the obligatory `t`, `states`, `params`) are used, these parameters must be included as well. 
-* **coordinates** (dict) - optional - Keys: names of dimensions (`dimension_names`). Values: desired coordinates for the dimension axis. Values provided here become the dimension's coordinates in the `xarray` Dataset.
+* **states** (dict) - Keys: names of states. Values: values of states. The dictionary does not have to contain a key,value pair for all model state names listed in `states` of the model declaration. States that lack a key,value pair are filled with zeros upon initialization.
+* **parameters** (dict) - Keys: names of parameters. Values: values of parameters. A key,value pair must be provided for all parameter names listed in `parameters` and `stratified_parameters` of the model declaration. If time dependent parameter functions with additional parameters (aside from the obligatory `t`, `states`, `params`) are used, these parameters must be included as well. 
+* **coordinates** (dict) - optional - Keys: names of dimensions (`dimensions`). Values: desired coordinates for the dimension axis. Values provided here become the dimension's coordinates in the `xarray` Dataset.
 * **time_dependent_parameters** (dict) - optional - Keys: name of the model parameter the time-dependent parameter function should be applied to. Must be a valid model parameter. Values: time-dependent parameter function. Time-dependent parameter functions must have `t` (simulation timestep), `states` (model states at timestep `t`) and `params` (model parameters dictionary) as the first three arguments.
 
 **Methods:**
diff --git a/docs/quickstart.md b/docs/quickstart.md
index 31a0b8e..c0310d6 100644
--- a/docs/quickstart.md
+++ b/docs/quickstart.md
@@ -23,8 +23,8 @@ from pySODM.models.base import ODEModel
 # Define the model equations
 class SIR(ODEModel):
 
-    state_names = ['S','I','R']
-    parameter_names = ['beta','gamma']
+    states = ['S','I','R']
+    parameters = ['beta','gamma']
 
     @staticmethod
     def integrate(t, S, I, R, beta, gamma):
@@ -85,7 +85,7 @@ The simulation above results in the following trajectories for the number of sus
 
 ## Set up an ODE model with a labeled dimension
 
-To transform all our SIR model's states in 1D vectors, referred to as a *dimension* throughout the documentation, add the `dimension_names` keyword to the model declaration. Here, we add a dimension representing the age groups individuals belong to.
+To transform all our SIR model's states in 1D vectors, referred to as a *dimension* throughout the documentation, add the `dimensions` keyword to the model declaration. Here, we add a dimension representing the age groups individuals belong to.
 
 ```python
 # Import the ODEModel class
@@ -94,9 +94,9 @@ from pySODM.models.base import ODEModel
 # Define the model equations
 class stratified_SIR(ODEModel):
     
-    state_names = ['S','I','R']
-    parameter_names = ['beta', 'gamma]
-    dimension_names = ['age_groups']
+    states = ['S','I','R']
+    parameters = ['beta', 'gamma]
+    dimensions = ['age_groups']
 
     @staticmethod
     def integrate(t, S, I, R, beta, gamma):
@@ -145,10 +145,10 @@ class ODE_SIR_SI(ODEModel):
     An age-stratified SIR model for humans, an unstratified SI model for a disease vector (f.i. mosquito)
     """
 
-    state_names = ['S', 'I', 'R', 'S_v', 'I_v']
-    parameter_names = ['beta', 'gamma']
-    parameter_stratified_names = ['alpha']
-    dimension_names = ['age_group']
+    states = ['S', 'I', 'R', 'S_v', 'I_v']
+    parameters = ['beta', 'gamma']
+    stratified_parameters = ['alpha']
+    dimensions = ['age_group']
     state_dimensions = [['age_group'],['age_group'],['age_group'],[],[]]
 
     @staticmethod
@@ -209,8 +209,8 @@ from pySODM.models.base import SDEModel
 # Define the model equations
 class SIR(SDEModel):
 
-    state_names = ['S','I','R']
-    parameter_names = ['beta','gamma']
+    states = ['S','I','R']
+    parameters = ['beta','gamma']
 
     @staticmethod
     def compute_rates(t, S, I, R, beta, gamma):
diff --git a/docs/workflow.md b/docs/workflow.md
index bbb4ff9..3f6f588 100644
--- a/docs/workflow.md
+++ b/docs/workflow.md
@@ -85,14 +85,14 @@ N &=& S + I + R, \\
 ```
 
 The model has three states: 1) The number of individuals susceptible to the disease (S), 2) the number of infectious individuals (I), and 3) the number of removed individuals (R). The model has two parameters: 1) `beta`, the rate of transmission and, 2) `gamma`, the duration of infectiousness. Building a model is based on the class inheritance, the user must first load the `ODEModel` class from `~/src/models/base.by`. Then, the user must define his/her own class which must contain (minimally),
-- A list containing the state names `state_names`,
+- A list containing the state names `states`,
 - A list containing the parameter names `parameter_names`,
 - An `integrate()` function where the differentials of the model are computed,
 
 and take the `ODEModel` class as its input. Checkout the documentation of the ODEModel class [here](models.md). There are some important formatting requirements to the integrate function, which are verified when the model is initialized,
 1. The integrate function must have the timestep `t` as its first input
 2. The model states and parameters must also be given as input, their order does not make a difference
-3. The integrate function must return a differential for every model state, arranged in the same order as the state names defined in `state_names`
+3. The integrate function must return a differential for every model state, arranged in the same order as the state names defined in `states`
 4. The integrate function must be a static method (include `@staticmethod`)
 
 ```
@@ -105,7 +105,7 @@ class ODE_SIR(ODEModel):
     Simple SIR model without dimensions
     """
     
-    state_names = ['S','I','R']
+    states = ['S','I','R']
     parameter_names = ['beta','gamma']
 
     @staticmethod
@@ -124,7 +124,7 @@ class ODE_SIR(ODEModel):
 After defining our model, we'll initialize it by supplying a dictionary of initial states and a dictionary of model parameters. In our example, we'll assume the disease spreads in a relatively small population of 1000 individuals. At the start of the simulation we'll assume there is one "patient zero". We don't have to define the number of recovered individuals as undefined states are automatically set to zero by pySODM.
 
 ```
-model = ODE_SIR(states=init_states={'S': 1000, 'I': 1}, parameters={'beta': 0.35, 'gamma': 5})
+model = ODE_SIR(states={'S': 1000, 'I': 1}, parameters={'beta': 0.35, 'gamma': 5})
 ```
 
 ### Calibrating the model
diff --git a/src/pySODM/models/base.py b/src/pySODM/models/base.py
index 250d2a5..8f33e21 100644
--- a/src/pySODM/models/base.py
+++ b/src/pySODM/models/base.py
@@ -43,63 +43,72 @@ class SDEModel:
         Example: {'spatial_units': ['city_1','city_2','city_3']}
     """
 
-    state_names = None
-    parameter_names = None
-    dimension_names = None
-    parameter_stratified_names = None
+    states = None
+    parameters = None
+    stratified_parameters = None
+    dimensions = None
     state_dimensions = None
 
     def __init__(self, states, parameters, coordinates=None, time_dependent_parameters=None):
 
+        # Add a suffix _names to all user-defined name declarations 
+        self.states_names = self.states
+        self.parameters_names = self.parameters
+        self.parameters_stratified_names = self.stratified_parameters
+        self.dimensions_names = self.dimensions
+        
+        self.states = states
+        parameters = parameters
+
         # Do not undergo manipulation during model initialization
         self.coordinates = coordinates
         self.time_dependent_parameters = time_dependent_parameters
 
         # Merge parameter_names and parameter_stratified_names
-        self.parameter_names_merged = merge_parameter_names_parameter_stratified_names(self.parameter_names, self.parameter_stratified_names)
+        self.parameters_names_merged = merge_parameter_names_parameter_stratified_names(self.parameters_names, self.parameters_stratified_names)
 
         # Duplicates in lists containing names of states/parameters/stratified parameters/dimensions?
-        check_duplicates(self.state_names, 'state_names')
-        check_duplicates(self.parameter_names, 'parameter_names')
-        check_duplicates(self.parameter_names_merged, 'parameter_names + parameter_stratified_names')
-        if self.dimension_names:
-            check_duplicates(self.dimension_names, 'dimension_names')
+        check_duplicates(self.states_names, 'state_names')
+        check_duplicates(self.parameters_names, 'parameter_names')
+        check_duplicates(self.parameters_names_merged, 'parameter_names + parameter_stratified_names')
+        if self.dimensions_names:
+            check_duplicates(self.dimensions_names, 'dimension_names')
 
         # Validate and compute the dimension sizes
-        self.dimension_size = validate_dimensions(self.dimension_names, self.coordinates)
+        self.dimension_size = validate_dimensions(self.dimensions_names, self.coordinates)
 
         # Validate state_dimensions
         if self.state_dimensions:
-            validate_state_dimensions(self.state_dimensions, self.coordinates, self.state_names)
+            validate_state_dimensions(self.state_dimensions, self.coordinates, self.states_names)
         
         # Build a dictionary containing the size of every state; build a dictionary containing the dimensions of very state; build a dictionary containing the coordinates of every state
-        self.state_shapes, self.state_dimensions, self.state_coordinates = build_state_sizes_dimensions(self.coordinates, self.state_names, self.state_dimensions)
+        self.state_shapes, self.state_dimensions, self.state_coordinates = build_state_sizes_dimensions(self.coordinates, self.states_names, self.state_dimensions)
 
         # Validate the shapes of the initial states, fill non-defined states with zeros
-        self.initial_states = validate_initial_states(self.state_shapes, states)
+        self.initial_states = validate_initial_states(self.state_shapes, self.states)
 
         # Validate the time-dependent parameter functions (TDPFs) and extract the names of their input arguments
         if time_dependent_parameters:
-            self._function_parameters = validate_time_dependent_parameters(self.parameter_names, self.parameter_stratified_names, self.time_dependent_parameters)
+            self._function_parameters = validate_time_dependent_parameters(self.parameters_names, self.parameters_stratified_names, self.time_dependent_parameters)
         else:
             self._function_parameters = []
 
         # Verify the signature of the compute_rates function; extract the additional parameters of the TDPFs
-        all_params, self._extra_params = validate_integrate_or_compute_rates_signature(self.compute_rates, self.parameter_names_merged, self.state_names, self._function_parameters)
+        all_params, self._extra_params = validate_integrate_or_compute_rates_signature(self.compute_rates, self.parameters_names_merged, self.states_names, self._function_parameters)
 
         # Verify the signature of the apply_transitionings function
-        validate_apply_transitionings_signature(self.apply_transitionings, self.parameter_names_merged, self.state_names)
+        validate_apply_transitionings_signature(self.apply_transitionings, self.parameters_names_merged, self.states_names)
 
         # Verify all parameters were provided
         self.parameters = validate_provided_parameters(all_params, parameters)
 
         # Validate the size of the stratified parameters (Perhaps move this way up front?)
-        if self.parameter_stratified_names:
-            self.parameters = validate_parameter_stratified_sizes(self.parameter_stratified_names, self.dimension_names, coordinates, self.parameters)
+        if self.parameters_stratified_names:
+            self.parameters = validate_parameter_stratified_sizes(self.parameters_stratified_names, self.dimensions_names, coordinates, self.parameters)
 
         # Call the compute_rates function, check if it works and check the sizes of the differentials in the output
-        rates = validate_compute_rates(self.compute_rates, self.initial_states, self.state_shapes, self.parameter_names_merged, self.parameters)
-        validate_apply_transitionings(self.apply_transitionings, rates, self.initial_states, self.state_shapes, self.parameter_names_merged, self.parameters)
+        rates = validate_compute_rates(self.compute_rates, self.initial_states, self.state_shapes, self.parameters_names_merged, self.parameters)
+        validate_apply_transitionings(self.apply_transitionings, rates, self.initial_states, self.state_shapes, self.parameters_names_merged, self.parameters)
 
     # Overwrite integrate class
     @staticmethod
@@ -287,7 +296,7 @@ def func(t, y, pars={}):
                 #  throw parameters of TDPFs out of model parameters dictionary
                 # -------------------------------------------------------------
 
-                params = {k:v for k,v in params.items() if ((k not in self._extra_params) or (k in self.parameter_names_merged))}
+                params = {k:v for k,v in params.items() if ((k not in self._extra_params) or (k in self.parameters_names_merged))}
 
                 # -------------
                 # compute rates
@@ -498,59 +507,67 @@ class ODEModel:
         Example: {'spatial_units': ['city_1','city_2','city_3']}
     """
 
-    state_names = None
-    parameter_names = None
-    dimension_names = None
-    parameter_stratified_names = None
+    states = None
+    parameters = None
+    stratified_parameters = None
+    dimensions = None
     state_dimensions = None
 
     def __init__(self, states, parameters, coordinates=None, time_dependent_parameters=None):
 
+        # Add a suffix _names to all user-defined name declarations 
+        self.states_names = self.states
+        self.parameters_names = self.parameters
+        self.parameters_stratified_names = self.stratified_parameters
+        self.dimensions_names = self.dimensions
+        self.states = states
+        parameters = parameters
+
         # Do not undergo manipulation during model initialization
         self.coordinates = coordinates
         self.time_dependent_parameters = time_dependent_parameters
 
         # Merge parameter_names and parameter_stratified_names
-        self.parameter_names_merged = merge_parameter_names_parameter_stratified_names(self.parameter_names, self.parameter_stratified_names)
+        self.parameters_names_merged = merge_parameter_names_parameter_stratified_names(self.parameters_names, self.parameters_stratified_names)
 
         # Duplicates in lists containing names of states/parameters/stratified parameters/dimensions?
-        check_duplicates(self.state_names, 'state_names')
-        check_duplicates(self.parameter_names, 'parameter_names')
-        check_duplicates(self.parameter_names_merged, 'parameter_names + parameter_stratified_names')
-        if self.dimension_names:
-            check_duplicates(self.dimension_names, 'dimension_names')
+        check_duplicates(self.states_names, 'state_names')
+        check_duplicates(self.parameters_names, 'parameter_names')
+        check_duplicates(self.parameters_names_merged, 'parameter_names + parameter_stratified_names')
+        if self.dimensions_names:
+            check_duplicates(self.dimensions_names, 'dimension_names')
 
         # Validate and compute the dimension sizes
-        self.dimension_size = validate_dimensions(self.dimension_names, self.coordinates)
+        self.dimension_size = validate_dimensions(self.dimensions_names, self.coordinates)
 
         # Validate state_dimensions
         if self.state_dimensions:
-            validate_state_dimensions(self.state_dimensions, self.coordinates, self.state_names)
+            validate_state_dimensions(self.state_dimensions, self.coordinates, self.states_names)
         
         # Build a dictionary containing the size of every state; build a dictionary containing the dimensions of very state; build a dictionary containing the coordinates of every state
-        self.state_shapes, self.state_dimensions, self.state_coordinates = build_state_sizes_dimensions(self.coordinates, self.state_names, self.state_dimensions)
+        self.state_shapes, self.state_dimensions, self.state_coordinates = build_state_sizes_dimensions(self.coordinates, self.states_names, self.state_dimensions)
 
         # Validate the shapes of the initial states, fill non-defined states with zeros
-        self.initial_states = validate_initial_states(self.state_shapes, states)
+        self.initial_states = validate_initial_states(self.state_shapes, self.states)
 
         # Validate the time-dependent parameter functions (TDPFs) and extract the names of their input arguments
         if time_dependent_parameters:
-            self._function_parameters = validate_time_dependent_parameters(self.parameter_names, self.parameter_stratified_names, self.time_dependent_parameters)
+            self._function_parameters = validate_time_dependent_parameters(self.parameters_names, self.parameters_stratified_names, self.time_dependent_parameters)
         else:
             self._function_parameters = []
 
         # Verify the signature of the integrate function; extract the additional parameters of the TDPFs
-        all_params, self._extra_params = validate_integrate_or_compute_rates_signature(self.integrate, self.parameter_names_merged, self.state_names, self._function_parameters)
+        all_params, self._extra_params = validate_integrate_or_compute_rates_signature(self.integrate, self.parameters_names_merged, self.states_names, self._function_parameters)
 
         # Verify all parameters were provided
         self.parameters = validate_provided_parameters(all_params, parameters)
 
         # Validate the size of the stratified parameters (Perhaps move this way up front?)
-        if self.parameter_stratified_names:
-            self.parameters = validate_parameter_stratified_sizes(self.parameter_stratified_names, self.dimension_names, coordinates, self.parameters)
+        if self.parameters_stratified_names:
+            self.parameters = validate_parameter_stratified_sizes(self.parameters_stratified_names, self.dimensions_names, coordinates, self.parameters)
 
         # Call the integrate function, check if it works and check the sizes of the differentials in the output
-        validate_integrate(self.initial_states, dict(zip(self.parameter_names_merged,[self.parameters[k] for k in self.parameter_names_merged])), self.integrate, self.state_shapes)
+        validate_integrate(self.initial_states, dict(zip(self.parameters_names_merged,[self.parameters[k] for k in self.parameters_names_merged])), self.integrate, self.state_shapes)
 
     # Overwrite integrate class
     @staticmethod
@@ -590,7 +607,7 @@ def func(t, y, pars={}):
             #  throw parameters of TDPFs out of model parameters dictionary
             # -------------------------------------------------------------
 
-            params = {k:v for k,v in params.items() if ((k not in self._extra_params) or (k in self.parameter_names_merged))}
+            params = {k:v for k,v in params.items() if ((k not in self._extra_params) or (k in self.parameters_names_merged))}
 
             # -------------------
             # perform integration
diff --git a/src/pySODM/optimization/objective_functions.py b/src/pySODM/optimization/objective_functions.py
index c5dd9fe..63ef65f 100644
--- a/src/pySODM/optimization/objective_functions.py
+++ b/src/pySODM/optimization/objective_functions.py
@@ -315,7 +315,7 @@ def __init__(self, model, parameter_names, bounds, data, states, log_likelihood_
         ################################################
 
         # Expand parameter names 
-        self.parameter_names_postprocessing = expand_parameter_names(self.parameter_shapes)
+        self.parameters_names_postprocessing = expand_parameter_names(self.parameter_shapes)
         # Expand bounds
         if len(bounds) == len(parameter_names):
             check_bounds(bounds)
@@ -325,7 +325,7 @@ def __init__(self, model, parameter_names, bounds, data, states, log_likelihood_
             self.expanded_bounds = bounds
         else:
             raise Exception(
-                f"The number of provided bounds ({len(bounds)}) must either:\n\t1) equal the number of calibrated parameters '{parameter_names}' ({len(parameter_names)}) or,\n\t2) equal the element-expanded number of calibrated parameters '{self.parameter_names_postprocessing}'  ({len(self.parameter_names_postprocessing)})"
+                f"The number of provided bounds ({len(bounds)}) must either:\n\t1) equal the number of calibrated parameters '{parameter_names}' ({len(parameter_names)}) or,\n\t2) equal the element-expanded number of calibrated parameters '{self.parameters_names_postprocessing}'  ({len(self.parameters_names_postprocessing)})"
             )
         # Expand labels
         if labels:
@@ -335,10 +335,10 @@ def __init__(self, model, parameter_names, bounds, data, states, log_likelihood_
                 self.expanded_labels = labels
             else:
                 raise Exception(
-                    f"The number of provided labels ({len(labels)}) must either:\n\t1) equal the number of calibrated parameters '{parameter_names}' ({len(parameter_names)}) or,\n\t2) equal the element-expanded number of calibrated parameters '{self.parameter_names_postprocessing}'  ({len(self.parameter_names_postprocessing)})"
+                    f"The number of provided labels ({len(labels)}) must either:\n\t1) equal the number of calibrated parameters '{parameter_names}' ({len(parameter_names)}) or,\n\t2) equal the element-expanded number of calibrated parameters '{self.parameters_names_postprocessing}'  ({len(self.parameters_names_postprocessing)})"
                 )
         else:
-            self.expanded_labels = self.parameter_names_postprocessing
+            self.expanded_labels = self.parameters_names_postprocessing
 
         ####################################################################
         ## Input check on number of prior functions + potential expansion ##
@@ -373,7 +373,7 @@ def __init__(self, model, parameter_names, bounds, data, states, log_likelihood_
         self.model = model
         self.data = data
         self.states = states
-        self.parameter_names = parameter_names
+        self.parameters_names = parameter_names
         self.log_likelihood_fnc = log_likelihood_fnc
         self.weights = weights
 
diff --git a/tutorials/SIR/workflow_tutorial.py b/tutorials/SIR/workflow_tutorial.py
index 089e561..ec7e7aa 100644
--- a/tutorials/SIR/workflow_tutorial.py
+++ b/tutorials/SIR/workflow_tutorial.py
@@ -55,8 +55,8 @@ class ODE_SIR(ODEModel):
     Simple SIR model without dimensions
     """
     
-    state_names = ['S','I','R']
-    parameter_names = ['beta','gamma']
+    states = ['S','I','R']
+    parameters = ['beta','gamma']
 
     @staticmethod
     def integrate(t, S, I, R, beta, gamma):
@@ -70,13 +70,8 @@ def integrate(t, S, I, R, beta, gamma):
 
         return dS, dI, dR
 
-# Define parameters and initial condition
-params={'beta':0.35, 'gamma':5}
-init_states = {'S': 1000, 'I': 1}
-
 # Initialize model
-model = ODE_SIR(states=init_states, parameters=params)
-
+model = ODE_SIR(states={'S': 1000, 'I': 1}, parameters={'beta':0.35, 'gamma':5})
 
 # Simulate from t=0 until t=121
 out = model.sim([0, 121])
diff --git a/tutorials/SIR_SI/calibration.py b/tutorials/SIR_SI/calibration.py
index 2d56be0..007bcaf 100644
--- a/tutorials/SIR_SI/calibration.py
+++ b/tutorials/SIR_SI/calibration.py
@@ -38,7 +38,7 @@
 age_groups = pd.IntervalIndex.from_tuples([(0,5),(5,15),(15,65),(65,120)])
 coordinates={'age_group': age_groups}
 # Initialize model
-model = SIR_SI(states=init_states, parameters=params, coordinates=coordinates)
+model = SIR_SI(init_states, params, coordinates=coordinates)
 
 ################################
 ## Generate synthetic dataset ##
@@ -50,7 +50,7 @@
 # Overdisperse data from humans
 alpha=0.03
 y = np.random.negative_binomial(1/alpha, (1/alpha)/(out['I'] + (1/alpha)))
-out['I'] = (['age_group','time'], y)
+out['I'] = (['time', 'age_group'], y)
 data_humans = out['I'].to_series()
 
 # Overdisperse data from mosquitos
@@ -102,7 +102,7 @@
     labels=['0-5','5-15','15-65','65-120']
     for i,age_group in enumerate(age_groups):
         ax[1].plot(out['time'], out['I'].sel(age_group=age_group)/init_states['S'][i]*100000, color=colors[i], label=labels[i])
-        ax[1].plot(data_humans.index.get_level_values('time').unique(), data_humans.loc[age_group, slice(None)]/init_states['S'][i]*100000, color='black', label='data', alpha=0.6)
+        ax[1].plot(data_humans.index.get_level_values('time').unique(), data_humans.loc[slice(None), age_group]/init_states['S'][i]*100000, color='black', label='data', alpha=0.6)
     ax[1].set_ylabel('Infectious humans per 100K')
     ax[1].legend()
     ax[1].set_xlabel('time (days)')
@@ -168,7 +168,7 @@ def draw_fcn(param_dict, samples_dict):
     colors=['black', 'red', 'green', 'blue']
     labels=['0-5','5-15','15-65','65-120']
     for i,age_group in enumerate(age_groups):
-        ax[1].plot(data_humans.index.get_level_values('time').unique(), data_humans.loc[age_group,slice(None)]/init_states['S'][i]*100000, color=colors[i], label=labels[i])
+        ax[1].plot(data_humans.index.get_level_values('time').unique(), data_humans.loc[slice(None), age_group]/init_states['S'][i]*100000, color=colors[i], label=labels[i])
         for j in range(N):
             ax[1].plot(out['time'], out['I'].sel(age_group=age_group).isel(draws=j)/init_states['S'][i]*100000, color=colors[i], linewidth=2, alpha=0.03)
     ax[1].set_ylabel('Infectious humans per 100K')
diff --git a/tutorials/SIR_SI/models.py b/tutorials/SIR_SI/models.py
index fb0d12b..247479a 100644
--- a/tutorials/SIR_SI/models.py
+++ b/tutorials/SIR_SI/models.py
@@ -6,10 +6,10 @@ class SDE_SIR_SI(SDEModel):
     A stochastic, age-stratified SIR model for humans, an unstratified SI model for a disease vector (f.i. mosquito)
     """
 
-    state_names = ['S', 'I', 'R', 'S_v', 'I_v']
-    parameter_names = ['beta', 'gamma']
-    parameter_stratified_names = ['alpha']
-    dimension_names = ['age_group']
+    states = ['S', 'I', 'R', 'S_v', 'I_v']
+    parameters = ['beta', 'gamma']
+    stratified_parameters = ['alpha']
+    dimensions = ['age_group']
     state_dimensions = [['age_group'],['age_group'],['age_group'],[],[]]
 
     @staticmethod
@@ -44,10 +44,10 @@ class ODE_SIR_SI(ODEModel):
     An age-stratified SIR model for humans, an unstratified SI model for a disease vector (f.i. mosquito)
     """
 
-    state_names = ['S', 'I', 'R', 'S_v', 'I_v']
-    parameter_names = ['beta', 'gamma']
-    parameter_stratified_names = ['alpha']
-    dimension_names = ['age_group']
+    states = ['S', 'I', 'R', 'S_v', 'I_v']
+    parameters = ['beta', 'gamma']
+    stratified_parameters = ['alpha']
+    dimensions = ['age_group']
     state_dimensions = [['age_group'],['age_group'],['age_group'],[],[]]
 
     @staticmethod
diff --git a/tutorials/enzyme_kinetics/models.py b/tutorials/enzyme_kinetics/models.py
index 21612de..fb4c0d1 100644
--- a/tutorials/enzyme_kinetics/models.py
+++ b/tutorials/enzyme_kinetics/models.py
@@ -9,10 +9,10 @@ class packed_PFR(ODEModel):
     S + A <--> Es + W
     """
 
-    state_names = ['C_F', 'C_S']
-    parameter_names = ['delta_x', 'epsilon', 'u', 'rho_B','Vf_Ks', 'R_AS', 'R_AW', 'K_eq', 'R_Es']
-    parameter_stratified_names = [['kL_a', 'D_ax'],[]]
-    dimension_names = ['species', 'x']
+    states = ['C_F', 'C_S']
+    parameters = ['delta_x', 'epsilon', 'u', 'rho_B','Vf_Ks', 'R_AS', 'R_AW', 'K_eq', 'R_Es']
+    stratified_parameters = [['kL_a', 'D_ax'],[]]
+    dimensions = ['species', 'x']
 
     @staticmethod
     @njit
@@ -56,8 +56,8 @@ class PPBB_model(ODEModel):
     S + A <--> Es + W
     """
     
-    state_names = ['S','A','Es','W']
-    parameter_names = ['c_enzyme', 'Vf_Ks', 'R_AS', 'R_AW', 'R_Es', 'K_eq']
+    states = ['S','A','Es','W']
+    parameters = ['c_enzyme', 'Vf_Ks', 'R_AS', 'R_AW', 'R_Es', 'K_eq']
 
     @staticmethod
     @njit
diff --git a/tutorials/influenza_1718/calibration.py b/tutorials/influenza_1718/calibration.py
index 2f1d7f0..160cb4c 100644
--- a/tutorials/influenza_1718/calibration.py
+++ b/tutorials/influenza_1718/calibration.py
@@ -36,7 +36,7 @@
 alpha = 0.03            # Overdispersion factor (based on COVID-19)
 end_calibration = pd.Timestamp('2018-03-01')
 identifier = 'twallema_2018-03-01'
-n_pso = 30              # Number of PSO iterations
+n_pso = 3              # Number of PSO iterations
 multiplier_pso = 36     # PSO swarm size
 n_mcmc = 200            # Number of MCMC iterations
 multiplier_mcmc = 36    # Total number of Markov chains = number of parameters * multiplier_mcmc
@@ -121,7 +121,7 @@
 # Define model coordinates
 coordinates={'age_group': age_groups}
 # Initialize model
-model = influenza_model(init_states,params,coordinates,time_dependent_parameters={'N': contact_function})
+model = influenza_model(states=init_states,parameters=params,coordinates=coordinates,time_dependent_parameters={'N': contact_function})
 
 #####################
 ## Calibrate model ##
diff --git a/tutorials/influenza_1718/models.py b/tutorials/influenza_1718/models.py
index ff416d8..7bdf6e5 100644
--- a/tutorials/influenza_1718/models.py
+++ b/tutorials/influenza_1718/models.py
@@ -7,10 +7,10 @@ class ODE_influenza_model(ODEModel):
     Simple SEIR model for influenza with undetected carriers
     """
     
-    state_names = ['S','E','Ip','Iud','Id','R','Im_inc']
-    parameter_names = ['alpha', 'beta', 'gamma', 'delta','N']
-    parameter_stratified_names = ['f_ud']
-    dimension_names = ['age_group']
+    states = ['S','E','Ip','Iud','Id','R','Im_inc']
+    parametes = ['alpha', 'beta', 'gamma', 'delta','N']
+    stratified_parameters = ['f_ud']
+    dimensions = ['age_group']
 
     @staticmethod
     def integrate(t, S, E, Ip, Iud, Id, R, Im_inc, alpha, beta, gamma, delta, N, f_ud):
@@ -34,10 +34,10 @@ class SDE_influenza_model(SDEModel):
     Simple stochastic SEIR model for influenza with undetected carriers
     """
     
-    state_names = ['S','E','Ip','Iud','Id','R','Im_inc']
-    parameter_names = ['alpha', 'beta', 'gamma', 'delta','N']
-    parameter_stratified_names = ['f_ud']
-    dimension_names = ['age_group']
+    states = ['S','E','Ip','Iud','Id','R','Im_inc']
+    parameters = ['alpha', 'beta', 'gamma', 'delta','N']
+    stratified_parameters = ['f_ud']
+    dimensions = ['age_group']
 
     @staticmethod
     def compute_rates(t, S, E, Ip, Iud, Id, R, Im_inc, alpha, beta, gamma, delta, N, f_ud):


Test patch:
diff --git a/src/tests/test_ODEModel.py b/src/tests/test_ODEModel.py
index 8f82e3e..c6b927f 100644
--- a/src/tests/test_ODEModel.py
+++ b/src/tests/test_ODEModel.py
@@ -11,8 +11,8 @@ class SIR(ODEModel):
     """A Simple SIR model without dimension
     """
 
-    state_names = ['S', 'I', 'R']
-    parameter_names = ['beta', 'gamma']
+    states = ['S', 'I', 'R']
+    parameters = ['beta', 'gamma']
 
     @staticmethod
     def integrate(t, S, I, R, beta, gamma):
@@ -155,8 +155,8 @@ def test_model_init_validation():
     assert model.initial_states == initial_states
     assert model.parameters == parameters
     # model state/parameter names didn't change
-    assert model.state_names == ['S', 'I', 'R']
-    assert model.parameter_names == ['beta', 'gamma']
+    assert model.states_names == ['S', 'I', 'R']
+    assert model.parameters_names == ['beta', 'gamma']
 
     # valid initialization: initial states as int
     initial_states = {"S": 1_000_000 - 10, "I": 10, "R": 0}
@@ -164,8 +164,8 @@ def test_model_init_validation():
     assert model.initial_states == initial_states
     assert model.parameters == parameters
     # model state/parameter names didn't change
-    assert model.state_names == ['S', 'I', 'R']
-    assert model.parameter_names == ['beta', 'gamma']
+    assert model.states_names == ['S', 'I', 'R']
+    assert model.parameters_names == ['beta', 'gamma']
 
     # valid initialization: initial states as np.array
     initial_states = {"S": np.array([1_000_000 - 10]), "I": np.array([10]), "R": np.array([0])}
@@ -173,8 +173,8 @@ def test_model_init_validation():
     assert model.initial_states == initial_states
     assert model.parameters == parameters
     # model state/parameter names didn't change
-    assert model.state_names == ['S', 'I', 'R']
-    assert model.parameter_names == ['beta', 'gamma']
+    assert model.states_names == ['S', 'I', 'R']
+    assert model.parameters_names == ['beta', 'gamma']
 
     # wrong length initial states
     initial_states2 = {"S": np.array([1_000_000 - 10,1]), "I": np.array([10,1]), "R": np.array([0,1])}
@@ -192,22 +192,22 @@ def test_model_init_validation():
         SIR(initial_states, parameters2)
 
     # validate model class itself
-    SIR.state_names = ["S", "R"]
+    SIR.states = ["S", "R"]
     with pytest.raises(ValueError):
         SIR(initial_states, parameters)
 
-    SIR.state_names = ["S", "II", "R"]
+    SIR.states = ["S", "II", "R"]
     with pytest.raises(ValueError):
         SIR(initial_states, parameters)
 
-    SIR.state_names = ["S", "I", "R"]
-    SIR.parameter_names = ['beta', 'alpha']
+    SIR.states = ["S", "I", "R"]
+    SIR.parameters = ['beta', 'alpha']
     with pytest.raises(ValueError):
         SIR(initial_states, parameters)
 
     # ensure to set back to correct ones
-    SIR.state_names = ["S", "I", "R"]
-    SIR.parameter_names = ['beta', 'gamma']
+    SIR.states = ["S", "I", "R"]
+    SIR.parameters = ['beta', 'gamma']
 
 ###################################
 ## Model with one dimension ##
@@ -216,10 +216,10 @@ def test_model_init_validation():
 class SIRstratified(ODEModel):
     """An SIR Model with one dimension and the same state size
     """
-    state_names = ['S', 'I', 'R']
-    parameter_names = ['gamma']
-    parameter_stratified_names = ['beta']
-    dimension_names = ['age_groups']
+    states = ['S', 'I', 'R']
+    parameters = ['gamma']
+    stratified_parameters = ['beta']
+    dimensions = ['age_groups']
 
     @staticmethod
     def integrate(t, S, I, R, gamma, beta):
@@ -269,9 +269,9 @@ def test_stratified_SIR_init_validation():
 
     assert model.initial_states == initial_states
     assert model.parameters == parameters
-    assert model.parameter_stratified_names == ['beta']
-    assert model.state_names == ['S', 'I', 'R']
-    assert model.parameter_names == ['gamma']
+    assert model.parameters_stratified_names == ['beta']
+    assert model.states_names == ['S', 'I', 'R']
+    assert model.parameters_names == ['gamma']
 
     # forget coordinates
     with pytest.raises(ValueError, match="dimension name provided in integrate"):
@@ -311,19 +311,19 @@ def test_stratified_SIR_init_validation():
 
     # validate model class itself
     msg = "The provided state names and parameters don't match the parameters and states of the integrate/compute_rates function"
-    SIRstratified.parameter_names = ["gamma", "alpha"]
+    SIRstratified.parameters = ["gamma", "alpha"]
     with pytest.raises(ValueError, match=msg):
         SIRstratified(initial_states, parameters, coordinates=coordinates)
 
-    SIRstratified.parameter_names = ["gamma"]
-    SIRstratified.parameter_stratified_names = [["beta", "alpha"]]
+    SIRstratified.parameters = ["gamma"]
+    SIRstratified.stratified_parameters = [["beta", "alpha"]]
     with pytest.raises(ValueError, match=msg):
         SIRstratified(initial_states, parameters, coordinates=coordinates)
 
     # ensure to set back to correct ones
-    SIRstratified.state_names = ["S", "I", "R"]
-    SIRstratified.parameter_names = ["gamma"]
-    SIRstratified.parameter_stratified_names = [["beta"]]
+    SIRstratified.states = ["S", "I", "R"]
+    SIRstratified.parameters = ["gamma"]
+    SIRstratified.stratified_parameters = [["beta"]]
 
 ############################################################
 ## A model with different dimensions for different states ##
@@ -335,10 +335,10 @@ class SIR_SI(ODEModel):
     The S states is higher-dimensional to test the possiblities
     """
 
-    state_names = ['S', 'I', 'R', 'S_v', 'I_v']
-    parameter_names = ['beta', 'gamma']
-    parameter_stratified_names = ['alpha']
-    dimension_names = ['age_group']
+    states = ['S', 'I', 'R', 'S_v', 'I_v']
+    parameters = ['beta', 'gamma']
+    stratified_parameters = ['alpha']
+    dimensions = ['age_group']
     state_dimensions = [['age_group','age_group'],['age_group'],['age_group'],[],[]]
 
     @staticmethod
@@ -372,7 +372,7 @@ def test_SIR_SI_state_shapes():
     age_groups = pd.IntervalIndex.from_tuples([(0,5),(5,15),(15,65),(65,120)])
     coordinates={'age_group': age_groups}
     # Initialize model
-    model = SIR_SI(states=init_states, parameters=params, coordinates=coordinates)
+    model = SIR_SI(init_states, params, coordinates=coordinates)
     # Simulate
     output = model.sim([0, 50])
     # Assert state size
@@ -393,7 +393,7 @@ def test_SIR_SI_automatic_filling_initial_states():
     age_groups = pd.IntervalIndex.from_tuples([(0,5),(5,15),(15,65),(65,120)])
     coordinates={'age_group': age_groups}
     # Initialize model
-    model = SIR_SI(states=init_states, parameters=params, coordinates=coordinates)
+    model = SIR_SI(init_states, params, coordinates=coordinates)
     assert model.initial_states["I"].tolist() == [0, 0, 0, 0]
     assert model.initial_states["R"].tolist() == [0, 0, 0, 0]
 
diff --git a/src/tests/test_SDEModel.py b/src/tests/test_SDEModel.py
index 5b911de..325ad34 100644
--- a/src/tests/test_SDEModel.py
+++ b/src/tests/test_SDEModel.py
@@ -10,8 +10,8 @@
 class SIR(SDEModel):
 
     # state variables and parameters
-    state_names = ['S', 'I', 'R']
-    parameter_names = ['beta', 'gamma']
+    states = ['S', 'I', 'R']
+    parameters = ['beta', 'gamma']
 
     @staticmethod
     def compute_rates(t, S, I, R, beta, gamma):
@@ -158,8 +158,8 @@ def test_model_init_validation():
     assert model.initial_states == initial_states
     assert model.parameters == parameters
     # model state/parameter names didn't change
-    assert model.state_names == ['S', 'I', 'R']
-    assert model.parameter_names == ['beta', 'gamma']
+    assert model.states_names == ['S', 'I', 'R']
+    assert model.parameters_names == ['beta', 'gamma']
 
     # valid initialization: initial states as int
     initial_states = {"S": 1_000_000 - 10, "I": 10, "R": 0}
@@ -167,8 +167,8 @@ def test_model_init_validation():
     assert model.initial_states == initial_states
     assert model.parameters == parameters
     # model state/parameter names didn't change
-    assert model.state_names == ['S', 'I', 'R']
-    assert model.parameter_names == ['beta', 'gamma']
+    assert model.states_names == ['S', 'I', 'R']
+    assert model.parameters_names == ['beta', 'gamma']
 
     # valid initialization: initial states as np.array
     initial_states = {"S": np.array([1_000_000 - 10]), "I": np.array([10]), "R": np.array([0])}
@@ -176,8 +176,8 @@ def test_model_init_validation():
     assert model.initial_states == initial_states
     assert model.parameters == parameters
     # model state/parameter names didn't change
-    assert model.state_names == ['S', 'I', 'R']
-    assert model.parameter_names == ['beta', 'gamma']
+    assert model.states_names == ['S', 'I', 'R']
+    assert model.parameters_names == ['beta', 'gamma']
 
     # wrong length initial states
     initial_states2 = {"S": np.array([1_000_000 - 10,1]), "I": np.array([10,1]), "R": np.array([0,1])}
@@ -197,24 +197,24 @@ def test_model_init_validation():
 
     # validate model class itself
     initial_states = {"S": np.array([1_000_000 - 10]), "I": np.array([10]), "R": np.array([0])}
-    SIR.state_names = ["S", "R"]
+    SIR.states = ["S", "R"]
     with pytest.raises(ValueError, match="The specified initial states don't exactly match the predefined states."):
         SIR(initial_states, parameters)
 
     initial_states = {"S": np.array([1_000_000 - 10]), "I": np.array([10]), "R": np.array([0])}
-    SIR.state_names = ["S", "II", "R"]
+    SIR.states = ["S", "II", "R"]
     with pytest.raises(ValueError, match="The specified initial states don't exactly match the predefined states."):
         SIR(initial_states, parameters)
 
     initial_states = {"S": np.array([1_000_000 - 10]), "I": np.array([10]), "R": np.array([0])}
-    SIR.state_names = ["S", "I", "R"]
-    SIR.parameter_names = ['beta', 'alpha']
+    SIR.states = ["S", "I", "R"]
+    SIR.parameters = ['beta', 'alpha']
     with pytest.raises(ValueError, match="The provided state names and parameters don't match the parameters and states of the integrate/compute_rates function."):
         SIR(initial_states, parameters)
 
     # ensure to set back to correct ones
-    SIR.state_names = ["S", "I", "R"]
-    SIR.parameter_names = ['beta', 'gamma']
+    SIR.states = ["S", "I", "R"]
+    SIR.parameters = ['beta', 'gamma']
 
 ##############################
 ## Model with one dimension ##
@@ -223,10 +223,10 @@ def test_model_init_validation():
 class SIRstratified(SDEModel):
 
     # state variables and parameters
-    state_names = ['S', 'I', 'R']
-    parameter_names = ['gamma']
-    parameter_stratified_names = ['beta']
-    dimension_names = ['age_groups']
+    states = ['S', 'I', 'R']
+    parameters = ['gamma']
+    stratified_parameters = ['beta']
+    dimensions = ['age_groups']
 
     @staticmethod
     def compute_rates(t, S, I, R, gamma, beta):
@@ -279,8 +279,8 @@ def test_model_stratified_init_validation():
     #assert model.initial_states == initial_states --> some weird ass shit happens here
     assert model.parameters == parameters
     # assert model state/parameter names didn't change
-    assert model.state_names == ['S', 'I', 'R']
-    assert model.parameter_names == ['gamma']
+    assert model.states_names == ['S', 'I', 'R']
+    assert model.parameters_names == ['gamma']
     #assert model.parameter_stratified_names == [['beta']] --> some weird ass shit happens here
 
     # forget coordinates
@@ -321,19 +321,19 @@ def test_model_stratified_init_validation():
 
     # validate model class itself
     msg = "The provided state names and parameters don't match the parameters and states of the"
-    SIRstratified.parameter_names = ["gamma", "alpha"]
+    SIRstratified.parameters = ["gamma", "alpha"]
     with pytest.raises(ValueError, match=msg):
         SIRstratified(initial_states, parameters, coordinates=coordinates)
 
-    SIRstratified.parameter_names = ["gamma"]
-    SIRstratified.parameter_stratified_names = [["beta", "alpha"]]
+    SIRstratified.parameters = ["gamma"]
+    SIRstratified.stratified_parameters = [["beta", "alpha"]]
     with pytest.raises(ValueError, match=msg):
         SIRstratified(initial_states, parameters, coordinates=coordinates)
 
     # ensure to set back to correct ones
-    SIRstratified.state_names = ["S", "I", "R"]
-    SIRstratified.parameter_names = ["gamma"]
-    SIRstratified.parameter_stratified_names = [["beta"]]
+    SIRstratified.states = ["S", "I", "R"]
+    SIRstratified.parameters = ["gamma"]
+    SIRstratified.stratified_parameters = [["beta"]]
 
 ############################################################
 ## A model with different dimensions for different states ##
@@ -344,10 +344,10 @@ class SIR_SI(SDEModel):
     A stochastic, age-stratified SIR model for humans, an unstratified SI model for a disease vector (f.i. mosquito)
     """
 
-    state_names = ['S', 'I', 'R', 'S_v', 'I_v']
-    parameter_names = ['beta', 'gamma']
-    parameter_stratified_names = ['alpha']
-    dimension_names = ['age_group']
+    states = ['S', 'I', 'R', 'S_v', 'I_v']
+    parameters = ['beta', 'gamma']
+    stratified_parameters = ['alpha']
+    dimensions = ['age_group']
     state_dimensions = [['age_group'],['age_group'],['age_group'],[],[]]
 
     @staticmethod
@@ -388,7 +388,7 @@ def test_SIR_SI_state_shapes():
     age_groups = pd.IntervalIndex.from_tuples([(0,5),(5,15),(15,65),(65,120)])
     coordinates={'age_group': age_groups}
     # Initialize model
-    model = SIR_SI(states=init_states, parameters=params, coordinates=coordinates)
+    model = SIR_SI(init_states, params, coordinates=coordinates)
     # Simulate
     output = model.sim([0, 50])
     # Assert state size
@@ -409,7 +409,7 @@ def test_SIR_SI_automatic_filling_initial_states():
     age_groups = pd.IntervalIndex.from_tuples([(0,5),(5,15),(15,65),(65,120)])
     coordinates={'age_group': age_groups}
     # Initialize model
-    model = SIR_SI(states=init_states, parameters=params, coordinates=coordinates)
+    model = SIR_SI(init_states, params, coordinates=coordinates)
     assert model.initial_states["I"].tolist() == [0, 0, 0, 0]
     assert model.initial_states["R"].tolist() == [0, 0, 0, 0]
 
@@ -490,7 +490,7 @@ def compliance_func(t, states, param):
 
     # simulate model
     model = SIRstratified(initial_states, parameters, coordinates=coordinates,
-                          time_dependent_parameters={'beta': compliance_func})
+                            time_dependent_parameters={'beta': compliance_func})
     output = model.sim(time)
 
     # without the rise in time to recovery, the infected pool will be larger over the first 10 timesteps
diff --git a/src/tests/test_calibration.py b/src/tests/test_calibration.py
index abe12d8..f229951 100644
--- a/src/tests/test_calibration.py
+++ b/src/tests/test_calibration.py
@@ -46,8 +46,8 @@
 class SIR(ODEModel):
 
     # state variables and parameters
-    state_names = ['S', 'I', 'R']
-    parameter_names = ['beta', 'gamma']
+    states = ['S', 'I', 'R']
+    parameters = ['beta', 'gamma']
 
     @staticmethod
     def integrate(t, S, I, R, beta, gamma):
@@ -311,8 +311,8 @@ def test_xarray_datasets():
 class SIR_nd_beta(ODEModel):
 
     # state variables and parameters
-    state_names = ['S', 'I', 'R']
-    parameter_names = ['beta', 'gamma']
+    states = ['S', 'I', 'R']
+    parameters = ['beta', 'gamma']
 
     @staticmethod
     def integrate(t, S, I, R, beta, gamma):
@@ -359,10 +359,10 @@ def test_calibration_nd_parameter():
 class SIRstratified(ODEModel):
 
     # state variables and parameters
-    state_names = ['S', 'I', 'R']
-    parameter_names = ['gamma']
-    parameter_stratified_names = ['beta']
-    dimension_names = ['age_groups']
+    states = ['S', 'I', 'R']
+    parameters = ['gamma']
+    stratified_parameters = ['beta']
+    dimensions = ['age_groups']
 
     @staticmethod
     def integrate(t, S, I, R, gamma, beta):
@@ -503,10 +503,10 @@ def break_log_likelihood_functions_with_one_dimension():
 class SIRdoublestratified(ODEModel):
 
     # state variables and parameters
-    state_names = ['S', 'I', 'R']
-    parameter_names = ['gamma']
-    parameter_stratified_names = [['beta'],[]]
-    dimension_names = ['age_groups', 'spatial_units']
+    states = ['S', 'I', 'R']
+    parameters = ['gamma']
+    stratified_parameters = [['beta'],[]]
+    dimensions = ['age_groups', 'spatial_units']
 
     @staticmethod
     def integrate(t, S, I, R, gamma, beta):
@@ -540,7 +540,7 @@ def test_correct_approach_with_two_dimensions():
     objective_function = log_posterior_probability(model,pars,bounds,data,states,
                                                     log_likelihood_fnc,log_likelihood_fnc_args,weights,labels=labels)
     # Extract formatted parameter_names, bounds and labels
-    pars_postprocessing = objective_function.parameter_names_postprocessing
+    pars_postprocessing = objective_function.parameters_names_postprocessing
     labels = objective_function.expanded_labels 
     bounds = objective_function.expanded_bounds
     # PSO
@@ -680,10 +680,10 @@ class ODE_SIR_SI(ODEModel):
     An age-stratified SIR model for humans, an unstratified SI model for a disease vector (f.i. mosquito)
     """
 
-    state_names = ['S', 'I', 'R', 'S_v', 'I_v']
-    parameter_names = ['beta', 'gamma']
-    parameter_stratified_names = ['alpha']
-    dimension_names = ['age_groups']
+    states = ['S', 'I', 'R', 'S_v', 'I_v']
+    parameters = ['beta', 'gamma']
+    stratified_parameters = ['alpha']
+    dimensions = ['age_groups']
     state_dimensions = [['age_groups'],['age_groups'],['age_groups'],[],[]]
 
     @staticmethod
@@ -715,7 +715,7 @@ def test_SIR_SI():
     age_groups = ['0-20','20-120']
     coordinates={'age_groups': age_groups}
     # Initialize model
-    model = ODE_SIR_SI(states=init_states, parameters=params, coordinates=coordinates)
+    model = ODE_SIR_SI(init_states, params, coordinates=coordinates)
 
     # Variables that don't really change
     states = ["I","I_v"]