This notebook tutorial explains the basics of spaces, by taking a closer look at spaces defined in the simplelife model as an example.

If you're viewing this page as a static HTML page on https://lifelib.io, the same contents are also available here on binder as Jupyter notebook executable online (it may take a while to load). To run this notebook and get all the outputs below, Go to the **Cell** menu above, and then click **Run All**.

A new simplelife model is created and returned by `build`

function in lifelib project. Import simplelife in your working folder.

```
import simplelife
```

In [ ]:

```
import simplelife
```

In [ ]:

```
model = simplelife.build()
model
```

Nextime you create the same model, you can give `load_saved`

parameter `True`

, to save time to load input data.

In [ ]:

```
model = simplelife.build(True)
```

The previously created model is renamed automatically to avoid name conflict. To get all existing models, `get_models`

modelx API function can be used. `get_models`

returns a dict of all the existing models associated with their names.

In [ ]:

```
import modelx as mx
mx.get_models()
```

In the model, there are child spaces and other objects referenced in the model. `spaces`

property holds pairs of child space names and objects as a dict-like view.

In [ ]:

```
model.spaces
```

To just get all the names of the spaces, use the idiomatic expression below. To get all the space objects, `values`

method can be used instead of `keys`

.

In [ ]:

```
list(model.spaces.keys())
```

To get a specific space, simply type its name as model's attribute, or pass the name as a key to spaces property. For example, to get `Input`

space:

In [ ]:

```
model.Input
```

or

In [ ]:

```
model.spaces['Input']
```

A space can in turn contain other spaces, forming a space tree. To access child spaces of a space, the `spaces`

property and attribute access by name as we used on models can be used.

In [ ]:

```
model.Input.spaces
```

In [ ]:

```
model.Input.PolicyData
```

In [ ]:

```
model.Input.spaces['PolicyData']
```

Below is the list of the names of the spaces in the simplelife model.

In [ ]:

```
list(model.spaces.keys())
```

Below is a brief explanation of each space directly under the model.

`Input`

: Parent space containing spaces and cells hoding data read from the input file.`LifeTable`

: Space containing cells related to commutation functions and actuarial notations.`Policy`

: Parametric space whose dynamic child spaces hold attribute data of each policy read from the input file.`Assumption`

: Parametric space whose dynamic child spaces hold assumptions for each policy.`Economic`

: Parametric space whose dynamic child spaces hold economic assumptions for each scenario.`BaseProj`

: Base space of`Projection`

space, which contains cells to carry out projections.`PV`

: Mixin space to`Projection`

space, which contains cells to calculate present values of cashflows.`Projection`

: Parametric space, whose dynamic child spaces carry out projection for each policy.

`BaseProj`

and `PV`

are base spaces of `Projection`

, and cells defined in those cells are copied into `Projection`

space.

In [ ]:

```
model.Projection.bases
```

Among the spaces listed above, parametric spaces along with their parameters are listed below.

`LifeTable[Sex, IntRate, TableID]`

`Policy[PolicyID]`

`Assumption[PolicyID]`

`Economic[ScenID]`

`Projection[PolicyID, ScenID=1]`

To check parameters of a parametric space, call its `parameters`

property.

In [ ]:

```
model.LifeTable.parameters
```

A space becomes parametric when it has the `formula`

property. By calling the `formula`

property, the source code of the function the formula is created from is printed.

The paramters of a parametric space, and their default values if any, are taken from the signature of its associated function.

In [ ]:

```
model.LifeTable.formula
```

Parameter spaces serve as factories to create their child spaces dynamically.

When a parametric space is called with specific arguments being passed to the parameters, a dynamic child space associated with the arguments is created if it's not yet created, and returned. This can be achieved either by the call operation `()`

or by subscription `[]`

on the parametric space. If a parameter has its default value, and the arguments to the parameter is omitted, the default value is passed.

In [ ]:

```
model.Projection[1]
```

Space formulas have 2 roles relating to dynamic element spaces.

- To define the space's parameters and their default values.
- To specify arguments used for constructing element spaces.

When the user tries to access the element space of a space, such as `model.Projection[1]`

, for the first time, the formula of the space is called in order to pass a dictionary of pairs of parameters and arguments used for constructing and initializing the element space.

The parameters include:

`bases`

: a list of base spaces of the element space. If not specified, the space itself becomes the direct base space of the element space.`refs`

: a dictionary of references to be defined in the element space.

Both of the parameters are optional. As we have seen in the above, space formulas are created from function definitions.

In [ ]:

```
model.Projection.formula
```

The formula code is executed in the namespace associated with the space. Note that the global scope of the function underlying the formula has nothing to do with the formula's scope. So, names such as `Policy`

, `Assumption`

, `Economic`

that appear in the formula above are defined in the namespace of `model.Projection`

.
The names defined in the namespace consists of child cells, child spaces and references in the space,

i.e. the namespace is the union of `cells`

, `spaces`

, `refs`

properties.

`dir`

function on a space lists all the names defined in the namespace associated with the space.

In [ ]:

```
dir(model.Projection)
```