Oriole solar and storage, Mozambique

model "Oriole Solar and Storage, Mozambique" {
  currency   USD
  display    thousands
  day_count  act/360                  // every tranche accrues on 360 days
  data       "oriole_inputs.xlsx"
}

list stages = inputs.stages.rows      // phase_1, phase_2, phase_3

timeline {
  start   2019-01-01
  step    month until operations[phase_1].start, then half
  for s in stages {
    construction[s]  from inputs.stages[s].financial_close for inputs.stages[s].build
    operations[s]    inputs.stages[s].life
  }
}

/// One row per phase
table stages {
  rows     stage "Phase"
  columns  financial_close: date "Financial close",
           build: month "Construction period",
           life: y "Operating life",
           capacity: MWp "Nominal capacity",
           battery: MW "Battery capacity",
           battery_hours: h "Battery storage",
           tariff: USD/MWh "Base price",
           escalation_month: text "Escalation month",
           alpha "S-curve alpha", beta "S-curve beta",
           fixed_debt: USD "Fixed senior debt"
}

table development: USD sheet "Development cost" { rows item;  columns by stages }
table epc:         USD sheet "EPC"              { rows item;  columns by stages }

table tranches {
  rows     tranche
  columns  share: % "Share of senior debt", maturity: y "Maturity",
           grace: month "Grace period", rate: %/y "All-in interest",
           commitment: %/y "Commitment fee", front_end: % "Front-end fee",
           repayment: text "Repayment", pri: %/y "PRI premium", pri_cover: % "PRI cover"
}

table tracking {                        // Scenarios sheet
  rows     option
  columns  cost: USD/kW "Cost", base_yield: kWh/kWp/y "Base yield", pr: % "Performance ratio"
}

inputs "Plant" {
  transmission_loss = 2 %
  degradation       = 0.4 %/y
  yield             = { p50: 1_902.5, p90: 1_744.1, p99: 1_636.1 } kWh/kWp/y
  yield_case        = option p50 | p90 | p99
  battery_loss      = 10 %              // round trip
  cycles            = 1 /d
  land_per_mw       = 2.22 ha/MW
}

inputs "Operating costs" {
  om            = 12.18 USD/kW/y
  admin         = 5.00 USD/kW/y
  land_lease    = 850 USD/ha/y
  insurance     = 0.48 %/y             // of EPC
  escalation    = 1.5 %/y
  success_fee   = 2 %
}

inputs "Tax" {
  tax_rate           = 32 %
  depreciation_life  = 20y
  loss_expiry        = 10y
  dividend_wht       = 10 %
}

inputs "Financing" {
  upfront_equity  = 40 %                // of each phase's equity, before any debt
  senior_gearing  = 75 %
  mezzanine       = 0 %
  dsra_cover      = 6m
  sizing          = option gearing | dscr | fixed
  target_dscr     = 1.30 x
}

table partners {
  rows     partner
  columns  share: %, carried: text "Carried"
}                                       // Main Investor 95%, EDM 5% (carried)

/// One sheet per phase, like Phase 1, 2 and 3 Model
module phase[s] "Phase {s}" for s in stages {
  st = inputs.stages[s]

  // Operations
  capacity: MWp = st.capacity * (1 - inputs.transmission_loss)
                * decline(inputs.degradation)                 | during operations[s]
  solar:    MWh = capacity * inputs.yield[inputs.yield_case] * operations[s].share
  battery:  MWh = st.battery * st.battery_hours * inputs.cycles
                * (1 - inputs.battery_loss)                   | during operations[s]

  // Revenue: the tariff steps up in the phase's own anniversary month
  price:   USD/MWh = st.tariff | grow inputs.escalation yearly in st.escalation_month
                               from operations[s].start
  revenue: USD     = (solar + battery) * price

  // Capital expenditure on a beta S-curve
  epc:         USD = spread(inputs.epc[*, s], over: construction[s],
                            profile: beta(st.alpha, st.beta))
  development: USD = sum(inputs.development[*, s]) | at construction[s].start
  success_fee: USD = gross_up(sum(epc) + sum(development), inputs.success_fee)
                     | at construction[s].start

  // Operating costs
  opex: USD = st.capacity * (inputs.om + inputs.admin
                + inputs.land_lease * inputs.land_per_mw)
              | grow inputs.escalation from operations[s].start | during operations[s]
            + sum(epc) * inputs.insurance                     | during operations[s]
  ebitda: USD = revenue - opex
}

function gross_up(base, rate) = base * rate / (1 - rate)

module finance[s] "Financing, phase {s}" for s in stages {
  /// Replaces the Parallel Model's VBA function: one visible loop break per phase
  solve uses: USD = phase[s].epc + phase[s].development + phase[s].success_fee
                  + sum(loan[*].idc) + sum(loan[*].fees) + dsra.initial

  equity_commitment: USD = (1 - inputs.senior_gearing - inputs.mezzanine) * sum(uses)

  funding uses {
    first  equity  up to inputs.upfront_equity * equity_commitment
    then   pro_rata {
      senior     share inputs.senior_gearing
      mezzanine  share inputs.mezzanine
      equity     rest
    }
  }

  cfads: USD = phase[s].ebitda - tax.paid[s]
  senior_size: USD = match inputs.sizing {
    gearing => inputs.senior_gearing * sum(uses)
    dscr    => npv(cfads / inputs.target_dscr | during operations[s],
                   rate: inputs.tranches[senior_1].rate)
    fixed   => inputs.stages[s].fixed_debt
  }

  // Senior 1, 2, 3 and mezzanine, each with its own terms
  for t in inputs.tranches {
    loan[t] = term_loan(
      amount:  inputs.tranches[t].share * senior_size,
      draws:   funding.senior * inputs.tranches[t].share,
      rate:    inputs.tranches[t].rate,
      window:  operations[s].start + inputs.tranches[t].grace
               for inputs.tranches[t].maturity,
      profile: inputs.tranches[t].repayment,            // "Flat DS" in the base case
      fees:    { commitment: inputs.tranches[t].commitment,
                 front_end:  inputs.tranches[t].front_end }
    )
    pri[t]: USD = loan[t].balance.opening * inputs.tranches[t].pri
                * inputs.tranches[t].pri_cover
  }

  debt_service: USD = sum(loan[*].debt_service) + sum(pri[*])
  dscr: x = cfads / debt_service | during operations[s]
  dsra = reserve(target: debt_service | next inputs.dsra_cover)

  to_equity: USD = cfads - debt_service - dsra.net
}

module tax "Tax" {
  for s in stages {
    depreciation[s]: USD = sum(finance[s].uses) / inputs.depreciation_life | during operations[s]
    profit[s]:       USD = phase[s].ebitda - depreciation[s] - sum(finance[s].loan[*].interest)
    losses[s] = tax_losses(profit: profit[s], expiry: inputs.loss_expiry)
    paid[s]:         USD = losses[s].taxable * inputs.tax_rate
  }
}

module owners "Partners" {
  equity_draws: USD = sum(finance[*].funding.equity)
  to_equity:    USD = sum(finance[*].to_equity) * (1 - inputs.dividend_wht)

  /// EDM holds 5% without contributing capital
  split to_equity {
    main_investor  inputs.partners[main_investor].share
    edm            inputs.partners[edm].share   carried
    funded by      equity_draws
  }

  overall_irr = xirr(to_equity - equity_draws)
  main_irr    = xirr(to_equity.main_investor)       // below overall: it funds EDM's 5%
}

dashboard "Summary" {
  columns  for s in stages
  row "Capacity (MWp)"        inputs.stages[s].capacity
  row "EPC cost per kW"       sum(phase[s].epc) / inputs.stages[s].capacity
  row "Pre-tax project IRR"   xirr(phase[s].ebitda - phase[s].epc - phase[s].development)
  row "Min DSCR"              min(finance[s].dscr)
}

scenario base "Base case: tracking, P50" {}

scenario fixed_tilt "Fixed tilt" {
  inputs.yield = { p50: 1_450.5 } kWh/kWp/y       // Scenarios sheet, base yield
}

scenario lenders "Lenders' P90" extends base {
  inputs.yield_case = p90
}

scenario dscr_sized "Sized on DSCR" {
  inputs.sizing = dscr
}