How does LUSID calculate PV?

LUSID’s calculation of PV depends on the pricing model and, where applicable, model options you set.

To report the PV of a holding, include Valuation/* metrics when you generate a valuation report, for example (not a definitive list):

Valuation/PV
Valuation/CleanPV (this is always PV minus accrued interest for applicable instrument types)
Valuation/PvInPortfolioCcy and Valuation/TotalPortfolioPvInPortfolioCcy
Valuation/TotalGroupPvInPortfolioCcy (providing all portfolios share a base currency)
Valuation/PvInReportCcy and Valuation/TotalPortfolioPvInReportCcy (if you set report currency ≠ portfolio currency in the valuation request)
Valuation/TotalGroupPvInReportCcy (providing all portfolios share a base currency)
Valuation/Leg1/PV and Valuation/Leg2/PV (for instruments with legs)

Note the following:

You can call APIs in advance to understand which metrics might be useful or valid to include in a valuation report.
The recommended pricing model for an instrument type is seldom the default, so in most cases you should change it.
Many pricing models have model options that change the calculation. The tables below mention those that do.

How LUSID calculates `Valuation/PV`

Every pricing model values one unit of the instrument. LUSID then multiplies by the holding's units to give Valuation/PV in the instrument's currency, with three exceptions:

For a FlexibleLoan, FlexibleDeposit or LoanFacility, LUSID calculates PV for the holding as a whole, from its balance. More information.
For a PIK bond, LUSID scales by the holding's current face instead of its units. It does the same for other bonds, except asset-backed ones, if your recipe sets the fixedIncomeValuationsUsingCurrentFace recipe option.
If a holding has unsettled units, or purchased interest, LUSID values the traded units at the clean price and adds the accrued interest on the settled units, plus purchased interest.

Wherever an equation below uses a price, the following rules apply:

Price is the quote's value divided by the quote's own scaleFactor. If the quote has no scale factor and your recipe sets the useInstrumentScaleFactorAsDefault recipe option, LUSID divides by the instrument's tradingConventions.priceScaleFactor instead.
Accrual is the holding's accrued interest. LUSID adds it only if the quote's quoteType is Price. If it is DirtyPrice, the price already includes it. Where applicable, the assumeAccruedIsZero model option sets accrual to zero.

Note: For a bond priced from a quote, include the Valuation/Diagnostics/BondLookupPricer/Methodology metric in your valuation request to retrieve the equation applied, for example PV = Notional * (Price + AccruedInterest). For a cap, floor or swaption priced with DiscountedForward, include Valuation/Diagnostics/DiscountedForward/Methodology to retrieve the equation.

Equity

Instrument type (flavour)	Pricing model	`Valuation/PV` calculation
Equity (incl. ETF)	`SimpleStatic` only	`(price / scale factor) * contract size * units`, where contract size is 1.
ContractForDifference	`ConstantTimeValueOfMoney`, `Discounting`	`(forward price - reference price) * contract size * discount factor * units`, where contract size is set in the instrument definition (default 1). The discount factor is 1 except for a Futures-type CFD under `Discounting`. The forward price is spot unless you set the `equityForwardProjectionType` model option.
ContractForDifference	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is set in the instrument definition (default 1).
EquitySwap	`ConstantTimeValueOfMoney`, `Discounting`	Sum of the equity leg's return and dividend flows and the funding leg's flows, discounted for `Discounting` only.
EquitySwap	`SimpleStatic`	`((price / scale factor) * contract size * units) + accrual`, where contract size is the funding leg's notional.
Future	`ConstantTimeValueOfMoney`	`((price / scale factor) - reference price) * contract size * units`, where contract size is set in the instrument definition. PV is the gain since the reference price. The reference price is the instrument's `refSpotPrice` or, if that is zero, derived from the holding's cost and variation margin.
Future (ASX bond and bank bill futures, IMM, B3 DI1)	`ConstantTimeValueOfMoney`	As above, but LUSID first converts each price (a yield or rate) into a contract value using the exchange's formula. A B3 DI1 future is always valued at its full contract value.
ExchangeTradedOption	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is set in the instrument definition.
ExchangeTradedOption	`ConstantTimeValueOfMoney`	`((price / scale factor) - reference price) * contract size * units`, where contract size is set in the instrument definition. The reference price defaults to the holding's cost per contract.
EquityOption (European, incl. cash-settled, rights issue, warrant, index option)	`BlackScholes`, `Bachelier`	`(option value * number of shares - unpaid premium) * units`. The option value comes from the forward, strike, volatility surface (log-normal or normal) and discount curve. Number of shares is set in the instrument definition (default 1).
EquityOption (American)	`BjerksundStensland1993`	As `BlackScholes`, but with an approximation that allows for early exercise.
EquityOption	`Discounting`	Intrinsic value against the forward price, discounted: `(max(±(forward - strike), 0) * number of shares * discount factor - unpaid premium) * units`, where number of shares is set in the instrument definition (default 1).
EquityOption	`ConstantTimeValueOfMoney`	Intrinsic value against spot, undiscounted.
EquityOption	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is `numberOfShares` (default 1).

For ContractForDifference, EquitySwap or EquityOption, the equityForwardProjectionType model option chooses where the forward price comes from.

Debt

Instrument type (flavour)	Pricing model	`Valuation/PV` calculation
Bond (fixed, zero coupon)	`BondLookupPricer`	`((price / scale factor) * principal * units) + accrual`
ComplexBond (floating, sinkable, fixed-to-float, PIK, callable, puttable, convertible)	`BondLookupPricer`	`((price / scale factor) * principal * units) + accrual`, where principal is the amount outstanding on the valuation date
ComplexBond (asset-backed: MBS, ABS, CMBS, CLO tranche)	`BondLookupPricer`	`((price / scale factor) * principal * pool factor * units) + accrual`
Bond, ComplexBond	`BondLookupPricer` with `spreadAnchoredRisk` model option	Sum of future cashflows, discounted on the funding curve plus a spread from a `ZSpread` quote or credit spread curve (or, with `spreadAnchorSource` set to `SolvedFromPrice`, the spread that reproduces the price).
Bond, ComplexBond (not asset-backed)	`Discounting`	Sum of future cashflows, each discounted on the funding curve for the bond's currency. Unfixed floating coupons are projected off the index curve. Ignores calls and puts.
Bond, ComplexBond (fixed, floating, step, callable, puttable; not PIK, convertible or asset-backed)	`HullWhite1F`	Value from a Hull-White interest rate tree that exercises calls and puts when it is optimal to, discounting on the funding curve. With the `priceAtQuoteImpliedOas` model option, PV reproduces the quoted price; with `ignoreOptionality`, calls and puts are ignored.
InflationLinkedBond (`calculationType` `Standard`, `Quarterly`)	`BondLookupPricer`	`((price / scale factor) * principal * index ratio * units) + accrual`, with accrual indexed by the same ratio.
InflationLinkedBond (`Ratio`)	`BondLookupPricer`	As `Standard`, with the index ratio from the bond's own ratio fixings.
InflationLinkedBond (`StandardAccruedOnly`, `RatioAccruedOnly`)	`BondLookupPricer`	`((price / scale factor) * principal * units) + accrual`, with accrual indexed. The price already includes inflation but not accrued interest.
InflationLinkedBond (`Brazil`)	`BondLookupPricer`	`(price / scale factor) * principal * units`. The quote must be a `DirtyPrice`.
InflationLinkedBond	`InflationForward`	Sum of future cashflows, indexed by published fixings and then the inflation curve, each discounted on the funding curve.
`BondForward`	`SimpleStatic`, or `Discounting` with `bondForwardProjectionType` model option set to `QuotedContractPrice`	`(price / scale factor) * contract size * units` from the forward's own quote, where contract size is set in the instrument definition.
`BondForward`	`Discounting` with `bondForwardProjectionType` model option set to `ForwardProjectedFromFundingCurve` or `DeliverableSpreadAnchoredToQuote`	The bond's dirty value today, less coupons paid before delivery and the discounted settlement amount.
`ToBeAnnounced`, `ToBeAnnouncedOption`	`SimpleStatic` only	`(price / scale factor) * contract size * units`, where contract size is 1.
`BondOption`	`SimpleStatic` only	`(price / scale factor) * contract size * units`, where contract size is set in the instrument definition.

Note the following:

No pricing model values the conversion option of a convertible bond.
Discounting ignores calls and puts. Under BondLookupPricer, the workout model option doesn't change PV unless spreadAnchoredRisk is also on.
Under Discounting, an asset-backed bond fails; use BondLookupPricer.

Rates

Instrument type (flavour)	Pricing model	`Valuation/PV` calculation
`FlexibleDeposit` (STIF, rolling deposit facility)	`FlexibleLoanPricer` only	`settled balance + accrual`, for the holding as a whole. With the `setCleanPVToZero` model option set, PV is accrual only.
`ForwardRateAgreement`	`Discounting`	The difference between the fixed rate and the forward rate, applied to the notional and accrual period, and discounted.
`ForwardRateAgreement`	`ConstantTimeValueOfMoney`	As `Discounting`, with the last fixing in place of the forward rate, undiscounted.
`ForwardRateAgreement`	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is the notional.
InterestRateSwap (vanilla, basis, OIS)	`Discounting`	Sum of each leg's future cashflows, discounted on the funding curve for its currency. Unfixed floating coupons are projected off the index curve.
InterestRateSwap	`ConstantTimeValueOfMoney`	Sum of each leg's future cashflows, undiscounted. Unfixed floating coupons use the last fixing.
InterestRateSwap (cross-currency)	`Discounting`, `ConstantTimeValueOfMoney`	As above, with the second leg converted at the spot rate. For a resetting (MtM) swap, future notionals use projected FX forward rates.
InterestRateSwap (non-deliverable, cancellable)	any	Valued as a deliverable, non-cancellable swap.
InterestRateSwap	`SimpleStatic`	`((price / scale factor) * contract size * units) + accrual`, where contract size is the first leg's notional.
InterestRateSwap	`SimpleStatic` with `priceIsParOffset` model option	`(notional * ((price / scale factor) - 1) * units) + accrual`. The quote is an offset from par, and must be a `Price` or `DirtyPrice`. Notional is the first leg's notional. If the quote has no scale factor, LUSID uses 100.
InflationSwap (zero coupon, year on year, LPI)	`InflationForward`	Sum of each leg's future cashflows, indexed by published fixings and then the inflation curve, and discounted.
InflationSwap	`ConstantTimeValueOfMoney`	Sum of each leg's future cashflows, undiscounted, indexed by holding the latest published index flat.
InflationSwap	`SimpleStatic`	`((price / scale factor) * contract size * units) + accrual`, where contract size is the inflation leg's notional.
`TermDeposit`	`Discounting`, `ConstantTimeValueOfMoney`	Principal and interest still to be paid, discounted for `Discounting` only.
`TermDeposit`	`SimpleStatic`	`((price / scale factor) * contract size * units) + accrual`, where contract size is set in the instrument definition.
`InterestRateSwaption` (European)	`BlackScholes`, `Bachelier`	`(annuity * option value * notional - unpaid premium) * units`. The option value comes from the forward swap rate, strike and volatility (log-normal or normal). Notional is the underlying swap's first-leg notional.
`InterestRateSwaption`	`Discounting`	Intrinsic value against the forward swap rate, discounted, less unpaid premium.
`InterestRateSwaption`	`ConstantTimeValueOfMoney`	Intrinsic value against the swap rate implied by the last fixings, undiscounted.
`InterestRateSwaption`	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is 1.
`InterestRateSwaption` (European), `CapFloor`	`DiscountedForward`	`contract size * discount factor * forward price * units`, from a forward premium quote. Contract size is the underlying floating leg's notional for `CapFloor`, and 1 for `InterestRateSwaption`.
`CapFloor`	`ConstantTimeValueOfMoney`	Sum of caplet and floorlet payoffs at the last fixing, undiscounted.
`CapFloor`	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is the underlying floating leg's notional.

Credit

Instrument type (flavour)	Pricing model	`Valuation/PV` calculation
`CreditDefaultSwap`, CdsIndex	`CdsLookupPricer` (`Rate` quote)	`(current notional * rate * units) + accrual`
`CreditDefaultSwap`, CdsIndex	`CdsLookupPricer` (`Price` quote)	`(current notional * (100 - price) / 100 * units) + accrual`
`CreditDefaultSwap`	`Discounting`	Protection leg less premium leg, weighted by survival probabilities from the credit spread curve and discounted. Without a credit curve, only the premium leg is valued.
CdsIndex	`Discounting`	Premium leg cashflows still to be paid, discounted; no allowance for default.
`CreditDefaultSwap`, CdsIndex	`ConstantTimeValueOfMoney`	Premium leg cashflows still to be paid, undiscounted; no allowance for default.
`CreditDefaultSwap`, CdsIndex	`SimpleStatic`	`((price / scale factor) * contract size * units) + accrual`, where contract size is the notional (default 1) for `CreditDefaultSwap`, and the current notional for `CdsIndex`.
`CdsOption`	`SimpleStatic` only	`(price / scale factor) * contract size * units`, where contract size is the notional.

FX

Instrument type (flavour)	Pricing model	`Valuation/PV` calculation
FxForward (deliverable, NDF)	`ConstantTimeValueOfMoney`	`(domestic amount + foreign amount / spot rate) * units`
FxForward	`Discounting`	`(domestic amount * domestic discount factor + foreign amount * foreign discount factor / spot rate) * units`
FxForward	`ForwardWithPoints`, `ForwardSpecifiedRate`, `ForwardFromCurve`	`(domestic amount + foreign amount / forward rate) * domestic discount factor * units`. The forward rate is spot plus forward points, a quoted forward rate, or read off an FX forward curve. The `…Undiscounted` pricing model variants don't discount.
FxForward	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is the domestic amount (unsigned).
FxSwap	`ConstantTimeValueOfMoney`, `Discounting`	Sum of the near and far legs still to settle, each valued as an `FxForward`.
FxSwap	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is the near leg's domestic amount (signed).
FxOption (European)	`BlackScholes`, `Bachelier`	`(option value * contract size - unpaid premium) * units`. The option value comes from the FX forward, strike and volatility surface (log-normal or normal). Contract size is the foreign amount (or the domestic amount, if no foreign amount is set).
FxOption (American)	`BjerksundStensland1993`	As `BlackScholes`, but with an approximation that allows for early exercise. Contract size is the foreign amount (or the domestic amount, if no foreign amount is set).
FxOption (digital)	`BlackScholesDigital`	The cash-or-nothing value from spot, strike and volatility, times contract size and units. Contract size is the foreign amount (or the domestic amount, if no foreign amount is set).
FxOption (European)	`Discounting`	Intrinsic value against the FX forward, discounted, less unpaid premium.
FxOption (European)	`ConstantTimeValueOfMoney`	Intrinsic value against spot, undiscounted, less unpaid premium.
FxOption (any, incl. barrier and touch)	`SimpleStatic`	`(price / scale factor) * contract size * units`, where contract size is the foreign amount (or the domestic amount, if no foreign amount is set).

Commodities

CommodityForward and CommodityCalendarSwap support SimpleStatic only: (price / scale factor) * contract size * units, where contract size is 1.

Securitised finance

Instrument type (flavour)	Pricing model	`Valuation/PV` calculation
FlexibleRepo	`FlexibleRepoSimplePricer`	`(remaining purchase price * units) + accrual`, negative for the seller. Doesn't use a price.
`SimpleInstrument` (portfolio securitisation)	`SimpleStatic` only	`(price / scale factor) * contract size * units`, where contract size is set in the instrument definition (default 1).
`TotalReturnSwap` (bond, inflation-linked bond or loan underlying)	`BondLookupPricer`; `FlexibleLoanPricer` (loan underlying only)	The underlying's dirty value from its own quote, plus the funding leg, undiscounted.
`TotalReturnSwap` (with a reset schedule)	`Discounting`, `ConstantTimeValueOfMoney`, `BondLookupPricer`, `FlexibleLoanPricer`	Sum of the price-return flows between resets, plus the funding leg, discounted (`Discounting` only).
`TotalReturnSwap` (no reset schedule; not a loan underlying)	`Discounting`, `ConstantTimeValueOfMoney`	Sum of asset and funding leg cashflows. Discounted for `Discounting` only.
`TotalReturnSwap` (not a loan underlying)	`SimpleStatic`	`((price / scale factor) * contract size * units) + accrual`, where contract size is the bond's principal for a bond underlying; otherwise the funding leg's notional.
`PreferredShare`	`SimpleStatic` only	`((price / scale factor) * contract size * units) + accrual`, where contract size is fixed at 1.
FlexibleLoan (loan, PIK loan)	`FlexibleLoanPricer` only	`settled balance + accrual`, for the holding as a whole, undiscounted. With the `setCleanPVToZero` model option set, PV is accrual only.
`LoanFacility` (incl. PIK-able, multi-currency, non pro-rata)	`LoanFacilityPricer`	`funded balance * (price / scale factor) - unfunded commitment * (1 - price / scale factor) + accrual + delayed compensation`, for the holding as a whole, per currency converted at spot.
`LoanFacility`	`SimpleStatic`	As `LoanFacilityPricer`: LUSID always values a loan facility holding this way, whichever pricing model you choose.

Volatility

VolatilitySwap supports SimpleStatic only: (price / scale factor) * contract size * units, where contract size is the notional divided by the price denominator.

Real estate

SimpleInstrument supports SimpleStatic only: (price / scale factor) * contract size * units, where contract size is the instrument's contractSize (default 1).