# Introduction

The ultimate goal of the sstModel package is to build an instance of the Swiss Solvency Test (SST) model in order to be able to simulate from it and compute solvency figures. At the core of the sstModel package lies the idea that a binding occurs between risk-factor spaces (market risks, life risks, health risks, non-life risks, scenario risks, participation risks) and a portfolio characterizing the balance sheet.

In this document, we will follow step-by-step the process of defining a specific instance of sstModel and then computing it to get final solvency figures. Please consider that this document is only intended to present the API, meaning that we do not assume that it provides a comprehension on the model assumptions nor that the data values (chosen for the sake of API presentation) are representative of a real-world example.

# 1. Defining risk-factor spaces

As an example, we consider a portfolio subject to all types of risks implemented in the R-package:

- market risks
- life risks
- health risks
- non-life risks
- participation risks
- scenario risks

## Defining a marketRisk

In order to define a marketRisk, we first need to define a vocabulary of base market risk factors. In this special example we will consider that we hold a portfolio reporting in Swiss currency an that the market is composed of two currencies:

- Swiss market (CHF)
- European market (EUR)

For the Swiss market we will consider the following base risk factors:

- `MSCI_CHF` (equity in CHF)
- `Rued_Blass` (commercial real estate in CHF)
- `SNB_IND` (spread in CHF)
- `2Y_CHF`, `10Y_CHF`, `30Y_CHF` the interests rate in CHF for 2, 10 and 30 years.

For the European market we will consider:

- `MSCI_EUR` (equity in EUR)
- `AA_EUR_Spread` (spread in EUR)
- `2Y_EUR`, `10Y_EUR`, `30Y_EUR` the interests rate in EUR for 2, 10 and 30 years.

Additionally, since we have two markets, we should also consider the FX risk factor:

- `EURCHF`.

We define this vocabulary as follows:

    # define the market vocabulary
    name <- c("EURCHF",                           # currency risk
              "MSCI_CHF", "MSCI_EUR",             # equity risks
              "2Y_CHF", "10Y_CHF", "30Y_CHF",     # interest rate risks in CHF
              "2Y_EUR", "10Y_EUR", "30Y_EUR",     # interest rate risks in EUR
              "SNB_IND", "AA_EUR_Spread",         # the spread risks
              "Rued_Blass")                       # real estate

As the distribution of base market risk factor changes is assumed to be multivariate normal according to the SST standard model, we need to provide information on the covariance matrix of these risk factor changes.

    # define the correlation matrix of base market risk factor changes
    corr.mat <- matrix(c(
      1,0.34161024,0.14725368,0.32600072,0.23891105,0.15829093,
      0.33053628,0.2120393,0.22398321,-0.238861,-0.1888347,0.00871576, # EURCHF
      0.34161024,1,0.80390297,0.36492975,0.2296897,0.14789193,
      0.39493016,0.22665597,0.16277712,-0.4181629,-0.4711875,0.14542951, # MSCI_CHF
      0.14725368,0.80390297,1,0.25113843,0.2195543,0.21116258,
      0.50130346,0.30194514,0.23652861,-0.4573374,-0.497173,0.222605, # MSCI_EUR
      0.32600072,0.36492975,0.25113843,1,0.54235597,0.34141452,
      0.63987172,0.42851556,0.26727693,-0.3639534,-0.2760417,-0.0754334, # 2Y_CHF
      0.23891105,0.2296897,0.2195543,0.54235597,1,0.85134549,
      0.53410699,0.79149277,0.69474163,-0.4059395,-0.2140168,-0.0550199, # 10Y_CHF
      0.15829093,0.14789193,0.21116258,0.34141452,0.85134549,1,
      0.40118418,0.74668904,0.72843346,-0.1943058,-0.2089049,-0.1116269, # 30Y_CHF
      0.33053628,0.39493016,0.50130346,0.63987172,0.53410699,0.40118418,
      1,0.63153892,0.45730512,-0.4195621,-0.3505668,0.08683017, # 2Y_EUR
      0.2120393,0.22665597,0.30194514,0.42851556,0.79149277,0.74668904,
      0.63153892,1,0.90211566,-0.2619321,-0.3121842,-0.0739692, # 10Y_EUR
      0.22398321,0.16277712,0.23652861,0.26727693,0.69474163,0.72843346,
      0.45730512,0.90211566,1,-0.1365209,-0.2398577,-0.0437529, # 20Y_EUR_3
      -0.238861,-0.4181629,-0.4573374,-0.3639534,-0.4059395,-0.1943058,
      -0.4195621,-0.2619321,-0.1365209,1,0.31807203,-0.1240017, # SNB_IND
      -0.1888347,-0.4711875,-0.497173,-0.2760417,-0.2140168,-0.2089049,
      -0.3505668,-0.3121842,-0.2398577,0.31807203,1,-0.187089, # AA_EUR_Spread
      0.00871576,0.14542951,0.222605,-0.0754334,-0.0550199,-0.1116269,
      0.08683017,-0.0739692,-0.0437529,-0.1240017,-0.187089,1 # Rued_Blass
    ), byrow = T, ncol = length(name))

    # name the columns and rows of this correlation matrix
    colnames(corr.mat) <- name
    rownames(corr.mat) <- name

    # define the associated volatilities
    volatility <- c(0.002473,                      # fx EURCHF
                    0.1281, 0.1674,                # stocks (CHF, EUR)
                    0.0048876, 0.004994, 0.005203, # rate CHF
                    0.006247, 0.006575, 0.007183,  # rate EUR
                    0.002979, 0.003496,            # spreads
                    0.0739)                        # commercial real estate

    # compute thr covariance matrix
    cov.mat <- diag(volatility, length(volatility), length(volatility)) %*% corr.mat %*% diag(volatility, length(volatility), length(volatility))

    # add the names to the columns and rows
    colnames(cov.mat) <- rownames(cov.mat) <- colnames(corr.mat)

    # we additionally should specify the base currency (equal indeed to the reporting currency) in which the covariance matrix is expressed as an attribute of the covariance matrix.
    attr(cov.mat, "base.currency") <- "CHF"

Now we have a vocabulary of base market risk factors, but we still do not have a clear mapping to these quantitiy toward economical (-financial) meaningful metrics subject to risk (that we call `riskFactor`). The next step thus consists in defining what we call a mappingTable, i.e., a coherent mapping of base market risk factors towards economical (-financial) measures (`riskFactor`).

For that, we have the following constructors:

- `currency`: FX echange rate risk.
- `equity`: asset (with direct market price) risk.
- `spread`: spread risk (for cashflows).
- `rate`: interest rates risk.
- `pcRate`: principal component of interest rate curves (in case of principal component modelling of rates).

Each of this constructor basically contains three type of information:

- `name`: a mapping towards the base market vocabulary.
- `scale`: the scaling that should be applied to the base market risk factor to represent the `riskFactor` change that we want to construct.
- other information specific to the class of `riskFactor`.

`name` and `scale` together imply that a change in the `riskFactor` that we are defining will be represent by \(scale \times name\) (extended to linear combinations in case of principal component modeling of rates). Beware that this representation is strong (probabilistically speaking, there is equality almost surely and not only in distribution).

In our specific case we define:

    # the exchange rates (here only one), always assuming that exchange rates should map into the reporting (base currency) and be coherent with the covariance matrix of base market risk factors.
    list.currency <- list(currency(name = "EURCHF",
                                   from = "EUR",
                                   to   = "CHF"))

    # the asset risks (with direct market price).
    list.equity <- list(equity(name     = "MSCI_CHF",
                               type     = "equity",
                               currency = "CHF"),
                        equity(name     = "MSCI_EUR",
                               type     = "equity",
                               currency = "EUR"))

    # the real estates, here we assume that private real estate is a scaling
    # of commercial real estate (implying a perfect correlation of riskFactor changes in the Monte-Carlo simulations).
    list.real.estate <- list(equity(name      = "Rued_Blass",
                                    type      = "commercial real estate",
                                    currency  = "CHF"),
                             equity(name      = "Rued_Blass",
                                    type      = "private real estate",
                                    currency  = "CHF",
                                    scale     = 0.4694626))

    # the interests rates (specififying the mapping)
    list.rates <- list(rate(name     = "2Y_CHF",
                            currency = "CHF",
                            horizon  = "k"),
                       rate(name     = "10Y_CHF",
                            currency = "CHF",
                            horizon  = "m"),
                       rate(name     = "30Y_CHF",
                            currency = "CHF",
                            horizon  = "l"),
                       rate(name     = "2Y_EUR",
                            currency = "EUR",
                            horizon  = "k"),
                       rate(name     = "10Y_EUR",
                            currency = "EUR",
                            horizon  = "m"),
                       rate(name     = "30Y_EUR",
                            currency = "EUR",
                            horizon  = "l"))

    # the spread risks (attached with a rating)
    list.spread <- list(spread(name     = "SNB_IND",
                               currency = "CHF",
                               rating   = "AAA"),
                        spread(name     = "AA_EUR_Spread",
                               currency = "EUR",
                               rating   = "AA"))

    # we finally bind all these risks in a mapping table of market risks
    mapping.table <- mappingTable(c(list.currency, list.equity,
                                    list.real.estate, list.rates,
                                    list.spread),
                                  list.arg = T)

## Initialize the risk-factors

We need to provide initial values (\(t = 0\)) for rates (`rate`) and FX rates (`currency`) as well as time-to-maturity projections.

    # initial values list
    initial.values <- list()

    # initial fx values
    initial.values$initial.fx <- initialFX(from = c("EUR"),
                                           to   = c("CHF"),
                                           fx   = c(1.07209))

    # initial rates values, please note that initial.rates.values are defined in the document but not shown on the PDF version due to its length.
    initial.values$initial.rate <- initialRate(time     = c(c(1:10, 11:20, 21:50),
                                                            c(1:10, 11:20, 21:50)),
                                               currency = c(rep("CHF", 50),
                                                            rep("EUR", 50)),
                                               rate     = initial.rates.values)

    # define the time-to-maturity projections for rates
    mapping.time <- mappingTime(time    = c(1:10, 11:20, 21:50),
                                mapping = c(rep("k", 10), rep("m", 10), rep("l", 30)))

We are now in shape of constructing a `marketRisk` instance.

    # symmetrize the covariance matrix (to avoid numerical errors)
    cov.mat <- (cov.mat + t(cov.mat)) / 2

    # we build the full market risk
    market.risk <-   marketRisk(cov.mat        = cov.mat,
                                mapping.table  = mapping.table,
                                initial.values = initial.values,
                                base.currency  = "CHF",
                                mapping.time   = mapping.time)

## Defining a lifeRisk

As before, we first need to define a base vocabulary of life insurance risk factors:

    # define the names of life insurance risk-factors.
    life.risk.name <- c("Sterblichkeit", "Langlebigkeit", "Invaliditat",
                        "Reaktivierung","Kosten", "Storno", "Kapitaloption",
                        "KostenBVG", "StornoBVG")

Next we define the correlation matrix of life risk-factors (due to multivariate normal assumption) and probability values (sensitivites beeing understood as quantiles at one minus these probability values of centered Normal random variables):

    # define the life correlation matrix
    life.corr.mat <- matrix(c(1,-0.75,0.25,0,0,0,0,0,0,
                       -0.75,1,0,0,0,0,0.25,0,0,
                       0.25,0,1,-0.75,0.25,0,0,0.25,0,
                       0,0,-0.75,1,0,0,0,0,0,
                       0,0,0.25,0,1,0.5,0,0.5,0.5,
                       0,0,0,0,0.5,1,0,0.5,0.5,
                       0,0.25,0,0,0,0,1,0,-0.5,
                       0,0,0.25,0,0.5,0.5,0,1,0.5,
                       0,0,0,0,0.5,0.5,-0.5,0.5,1), ncol = 9, byrow = T)

    # add names
    colnames(life.corr.mat) <- life.risk.name
    rownames(life.corr.mat) <- life.risk.name

    # choose the life quantiles
    life.quantiles <- rep(0.995, 9)

    # define a lifeRisk
    life.risk <- lifeRisk(corr.mat = life.corr.mat,
                          quantile = life.quantiles)

## Defining a healthRisk

As before, we first need to define a base vocabulary of health insurance risk factors:

    # define the names of health insurance risk-factors.
    health.risk.name <- c("Langzeit Verpflichtungen", "Kollektiv Taggeld")

Next we define the correlation matrix of health risk factors (due to multivariate normal assumption) and quantiles values (sensitivites beeing understood as volatilities of centered Normal random variables):

    # define the life correlation matrix
    health.corr.mat <- diag(1, 2)

    # add names
    colnames(health.corr.mat) <- health.risk.name
    rownames(health.corr.mat) <- health.risk.name

    # define a healthRisk
    health.risk <- healthRisk(corr.mat = health.corr.mat)

## Define a nonLifeRisk

There are three types of inputs for nonLifeRisk supported by the package:

- simulation inputs
- empirical cumulative distribution function (right continuous step function)
- log-normal assumption on the simulations

In this example we will assume log-normal simulation inputs:

    # define a nonLifeRisk
    nonlife.risk <- nonLifeRisk(type     = "log-normal",
                                param    = list(mu = 10, sigma = 2),
                                currency = "CHF")

## Defining a participationRisk

In order to define a participation risk we provide the volatility information:

    # define a participarion risk
    participation.risk <- participationRisk(volatility = 0.25)

## Defining a ScenarioRisk

In order to define scenario risks, we need to provide information on:

- the probability of each scenarios
- the effect on the risk-bearing capital knowing that the scenario has occured.

In our case, we consider two scenarios:

- terrorism: probability \(0.05\) and loss \(-2 \times 10^{6}\).
- financial: probability \(0.01\) and loss \(-10^{6}\).

    # define a scenario risk
    scenario.risk <- scenarioRisk(name        = c("terrorism", "financial distress"),
                                  probability = c(0.05, 0.01),
                                  currency    = c("CHF", "CHF"),
                                  effect      = c(-2*10^6, -10^6))

# 2. Creating a portfolio

Once all risk-factors have been defined, we can proceed to the portfolio definition. We consider, in coherence with the risk factors, four types of items:

- market items
- life item
- health item
- participation item

Please note that there is no non-life item, since all sufficient information for non life risk is contained in nonLifeRisk.

## Market items

Let us incrementally add market items of all existing types:

### Defining cashflow and liabilities

    # cashflows items (please note that spread is the initial spread value for this cashflow)
    list.fixed.income <- list( # cashflow in CHF and EUR
                                 cashflow(time = 1L, currency = "CHF",
                                          rating = "AAA", spread = 0.05, value = 10^6),
                                 cashflow(time = 5L, currency = "CHF",
                                          rating = "AAA", spread = 0.03, value = 10^6),
                                 cashflow(time = 1L, currency = "EUR",
                                          rating = "AA", spread = -0.05, value = 10^6),
                                 cashflow(time = 5L, currency = "EUR",
                                          rating = "AA", spread = -0.03, value = 10^6),

                              # liabilities in CHF
                                liability(time = 2L, currency = "CHF", value = 20*10^6))

### Defining assets (with directed market price)

    # asset items
    list.assets <- list( # stock assets
                         asset(type = "equity",
                               currency = "CHF", value = 30*10^6),
                         asset(type = "equity",
                               currency = "EUR", value = 20*10^6),

                         # real estate assets
                         asset(type = "commercial real estate",
                               currency = "CHF", value = 10*10^6),
                         asset(type = "private real estate",
                               currency = "CHF", value = 5*10^6))

### Defining assetForwards and fxForwards

    # assetForwards and fxForwards
    list.forwards <- list( # asset forward
                         assetForward(type     = "equity",
                                      currency = "CHF",
                                      time     = 2L,
                                      exposure = 2*10^6,
                                      price    = 10^6,
                                      position ="short"),
                         # fx forward
                         fxForward(domestic = "CHF", foreign = "EUR",
                                      time = 1L, nominal = 10^6, rate = 1.06,
                                        position ="short"))

### Defining a delta remainder term

    # delta remainder
    list.delta <- list(delta(name = c("MSCI_CHF", "MSCI_EUR"),
                             currency = c("CHF","CHF"),
                             sensitivity = c(10^5, -10^5)))

## Insurance items

We then add the insurance items:

### Life insurance item

    life.item <- life(name        = c("Sterblichkeit", "Langlebigkeit", "Invaliditat",
                                      "Reaktivierung", "Kosten", "Storno", "Kapitaloption",
                                      "KostenBVG", "StornoBVG"),
                      currency    = rep("CHF",9),
                      sensitivity = rep(-10^5, 9))

### Health insurance item

    health.item <- health(name = c("Langzeit Verpflichtungen", "Kollektiv Taggeld"), currency = rep("CHF",2), sensitivity = rep(10^5, 2))

## Participatio item

We also need to provide the exposure to the participation:

    participation.item <- participation(currency = "CHF", value = 10^6)

## Aggregating all items in a portfolio

Once all market items and insurance items have been defined, we can bind all positions in a portfolio. Note that portfolio-specific values are also added as a parameter named `portfolio.parameters`.

    pf <- portfolio(market.items         = c(list.fixed.income, list.assets,
                                             list.forwards, list.delta),
                    base.currency = "CHF",
                    life.item            = life.item,
                    health.item          = health.item,
                    participation.item   = participation.item,
                    portfolio.parameters = list(mvm = list(mvm.life    = 10^5,
                                                           mvm.health  = 10^5,
                                                           mvm.nonlife = 10^5),
                                                credit.risk     = 10^5,
                                                correction.term = 10^4,
                                                expected.financial.result = 3*10^6,
                                                expected.insurance.result = 2*10^6,
                                                rtkg = 20*10^6,
                                                rtkr = 18*10^6))

## 3. Creating macro-economic scenarios

In addition, you can also create macro-economic scenarios. Meaning you can valuate the portfolio (market items including participation if any) for specific values taken by the change in risk factors (with non-centered valuation formulas).

Here we define two scenarios:

    # define here a macro economic scenario

    # values taken by the change in market risk-factors (last in participation).
    eco <- matrix(rnorm(2*13), nrow = 2)

    # give names to economic scenarios and risk-factors (including participation)
    colnames(eco) <- c(name, "participation")
    rownames(eco) <- c("scenario_1", "scenario_2")

    # create the maro.economic scenarios
    macro.economic.scenarios <- macroEconomicScenarios(macro.economic.scenario.table = eco)

# 4. Building an sstModel instance

Once all type of risks and the portfolio have be defined, we can proceed to the sstModel definition, for that we will need to provide the aggregation copula for the risks:

- market (aggregated with participation if any)
- life
- health
- nonlife

## Defining the reordering scheme for risk aggregation

the R-package supports conditional reordering with stressed Gaussian Copulas (as well as simple reordering with base Gaussian copula):

    # providing a list of correlation matrices (the first one called "base" is used for ranks generation and the following for conditional scenarios).
    list.correlation.matrix <- list(base = matrix(c(1,0.15,0.075,0.15,
                                                      0.15,1,0.25,0.25,
                                                      0.075,0.25,1,0.15,
                                                      0.15,0.25,0.15,1), ncol=4, byrow = T),
                                      scenario1 = matrix(c(1,1,1,0.35,
                                                           1,1,1,0.35,
                                                           1,1,1,0.35,
                                                           0.35,0.35,0.35,1), ncol=4, byrow = T),
                                      scenario2 = matrix(c(1,0.6,0.5,0.25,
                                                           0.6,1,0.8,0.35,
                                                           0.5,0.8,1,0.35,
                                                           0.25,0.35,0.35,1), ncol=4, byrow = T),
                                      scenario3 = matrix(c(1,0.25,0.25,0.5,
                                                           0.25,1,0.25,0.25,
                                                           0.25,0.25,1,0.25,
                                                           0.5,0.25,0.25,1), ncol=4, byrow = T))

    # we provide names for the correlation matrices
      list.correlation.matrix <- lapply(list.correlation.matrix, function(corr) {rownames(corr) <- colnames(corr) <- c("market", "life","health","nonlife"); corr})

      # define the region boundaries (i.e. the thresholds t under which we should reorder)
      region.boundaries <- matrix(c(0.2,0.3,0.3,0.5,
                                    0.5,0.2,0.2,0.8,
                                    0.6,0.8,0.8,0.2), nrow=3, byrow = T)

      # providing names for the regions boundaries and scenarios
      colnames(region.boundaries) <- c("market", "life","health","nonlife")
      rownames(region.boundaries) <- c("scenario1", "scenario2", "scenario3")

      # scenario and region probabilities
      scenario.probability  = c(0.01, 0.01, 0.01)
      region.probability    = c(0.023, 0.034, 0.107)

## Creating the model

Now we are in shape of binding the portfolio with all the types risks by creating a model instance:

    # create a model instance
    sst <- sstModel(portfolio                = pf,
                    market.risk              = market.risk,
                    life.risk                = life.risk,
                    health.risk              = health.risk,
                    participation.risk       = participation.risk,
                    scenario.risk            = scenario.risk,
                    macro.economic.scenarios = macro.economic.scenarios,
                    nhmr                     = 0.06,
                    reordering.parameters = list(list.correlation.matrix  = list.correlation.matrix,
                                                     region.boundaries    = region.boundaries,
                                                     region.probability   = region.probability,
                                                     scenario.probability = scenario.probability))

## Computing the model

Once an instance of the sstModel has been defined, we compute the model via Monte-Carlo simulations. The following R call agglomerates the core computations of the R-package. Please not that we provide a small number of simulations here (recommended \(10^6\)). Note also that the option `nested.market.computation = T` is set to have more granularity details on the market simulations:

    output <- compute(sst,
                      nsim = as.integer(10^4),
                      nested.market.computations = T)

## Accessing solvency figures and summaries

The object `object` output is of class `sstOutput`. The idea is that once the computations have been made we can gather from this structure all type of summaries/sst figures that we are interested in. Here is the internal structure of the output:

    str(output)
    #> List of 15
    #>  $ simulations              :Classes 'data.table' and 'data.frame':  10000 obs. of  15 variables:
    #>   ..$ marketRisk             : num [1:10000] 882874 14300815 -3419543 1873604 -3360203 ...
    #>   ..$ cashflow               : num [1:10000] -2016 56132 9327 58406 2472 ...
    #>   ..$ liability              : num [1:10000] 258878 -108755 -89220 -340098 -23501 ...
    #>   ..$ asset                  : num [1:10000] 773630 14833456 -3705723 2224795 -3326423 ...
    #>   ..$ assetForward           : num [1:10000] -147163 -485679 384918 -75935 -12619 ...
    #>   ..$ fxForward              : num [1:10000] -8624 -539 6042 1444 -9687 ...
    #>   ..$ delta                  : num [1:10000] 8169 6199 -24887 4991 9556 ...
    #>   ..$ lifeRisk               : num [1:10000] 107221 -161291 -109869 253654 196761 ...
    #>   ..$ healthRisk             : num [1:10000] 281392 -72166 -83661 -6925 -207421 ...
    #>   ..$ participation          : num [1:10000] -186478 346633 -318699 -58797 94067 ...
    #>   ..$ marketParticipationRisk: num [1:10000] 9328153 -3930547 -12107616 -10423842 5841706 ...
    #>   ..$ insuranceRisk          : num [1:10000] 388613 -233457 -193530 246730 -10660 ...
    #>   ..$ drbc                   : num [1:10000] 7716766 -6164003 -14301146 -12177112 3831047 ...
    #>   ..$ scenarioRisk           : num [1:10000] 0e+00 0e+00 -2e+06 0e+00 0e+00 0e+00 -2e+06 0e+00 0e+00 0e+00 ...
    #>   ..$ drbc.scenarioRisk      : num [1:10000] 7716766 -6164003 -16301146 -12177112 3831047 ...
    #>   ..- attr(*, ".internal.selfref")=<externalptr>
    #>  $ mvm                      : num 3e+05
    #>  $ mvm.list                 :List of 3
    #>   ..$ mvm.life   : num 1e+05
    #>   ..$ mvm.health : num 1e+05
    #>   ..$ mvm.nonlife: num 1e+05
    #>  $ rtkg                     : num 2e+07
    #>  $ rtkr                     : num 1.8e+07
    #>  $ credit.risk              : num 1e+05
    #>  $ nhmr                     : num 0.06
    #>  $ correction.term          : num 10000
    #>  $ expected.financial.result: num 3e+06
    #>  $ expected.insurance.result: num 2e+06
    #>  $ reference.currency       : chr "CHF"
    #>  $ life.standalones         : Named num [1:9] -103470 -103470 -103470 -103470 -103470 ...
    #>   ..- attr(*, "names")= chr [1:9] "Sterblichkeit" "Langlebigkeit" "Invaliditat" "Reaktivierung" ...
    #>  $ health.standalones       : Named num [1:2] -266521 -266521
    #>   ..- attr(*, "names")= chr [1:2] "Langzeit Verpflichtungen" "Kollektiv Taggeld"
    #>  $ scenario.risk            :Classes 'scenarioRisk', 'risk' and 'data.frame':    2 obs. of  4 variables:
    #>   ..$ name       : chr [1:2] "terrorism" "financial distress"
    #>   ..$ probability: num [1:2] 0.05 0.01
    #>   ..$ currency   : chr [1:2] "CHF" "CHF"
    #>   ..$ effect     : num [1:2] -2e+06 -1e+06
    #>  $ macro.economic.scenarios :Classes 'data.table' and 'data.frame':  1 obs. of  2 variables:
    #>   ..$ scenario_1: num 4.94e+10
    #>   ..$ scenario_2: num -2.33e+08
    #>   ..- attr(*, ".internal.selfref")=<externalptr>
    #>  - attr(*, "class")= chr [1:2] "sstOutput" "list"

Let us first have a look at the the simulation values:

    head(output$simulations)
    #>    marketRisk  cashflow  liability      asset assetForward  fxForward
    #> 1:     882874 -2016.293  258878.10   773629.9   -147162.81 -8623.9707
    #> 2:   14300815 56132.477 -108754.58 14833455.6   -485678.68  -538.7012
    #> 3:   -3419543  9327.034  -89219.51 -3705723.4    384917.86  6042.1542
    #> 4:    1873604 58405.912 -340097.52  2224794.8    -75934.54  1444.2319
    #> 5:   -3360203  2471.569  -23501.37 -3326423.3    -12618.68 -9686.6872
    #> 6:   -4081443 51982.441 -110830.70 -4190220.7    175006.12 -2815.3698
    #>         delta   lifeRisk healthRisk participation marketParticipationRisk
    #> 1:   8168.988  107221.20  281391.95    -186477.66                 9328153
    #> 2:   6199.306 -161290.57  -72166.13     346632.81                -3930547
    #> 3: -24887.406 -109869.20  -83660.92    -318698.95               -12107616
    #> 4:   4990.979  253654.39   -6924.69     -58797.26               -10423842
    #> 5:   9555.730  196760.94 -207420.54      94066.63                 5841706
    #> 6:  -4564.435   50513.47 -126554.54     436829.75                -3040367
    #>    insuranceRisk      drbc scenarioRisk drbc.scenarioRisk
    #> 1:     388613.15   7716766        0e+00           7716766
    #> 2:    -233456.70  -6164003        0e+00          -6164003
    #> 3:    -193530.12 -14301146       -2e+06         -16301146
    #> 4:     246729.70 -12177112        0e+00         -12177112
    #> 5:     -10659.60   3831047        0e+00           3831047
    #> 6:     -76041.07  -5116408        0e+00          -5116408

Then we can consult a bunch of solvency figures:

    # market value margin
    marketValueMargin(output)
    #> [1] 1318066

    # one year risk capital without scenarios
    riskCapital(object = output, with.scenario = F)
    #> [1] 14218415

    # one year risk capital with scenarios
    riskCapital(object = output, with.scenario = T)
    #> [1] 14366917

    # without scenarios
    targetCapital(output, with.scenario = F)
    #> [1] 15536481

    # with scenarios
    targetCapital(output, with.scenario = T)
    #> [1] 15684983

    # sst ratio without scenarios
    sstRatio(object = output, with.scenario = F)
    #> [1] 1.313925

    # sst ratio with scenarios
    sstRatio(object = output, with.scenario = T)
    #> [1] 1.300344

Finally the output can be saved into a formated Excel output using the function `write.sstOutput`.