stochvolmodels 1.0.20__tar.gz → 1.0.22__tar.gz

{stochvolmodels-1.0.20 → stochvolmodels-1.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stochvolmodels
-Version: 1.0.20
+Version: 1.0.22
 Summary: Implementation of stochastic volatility models for option pricing
 Home-page: https://github.com/ArturSepp/StochVolModels
 License: LICENSE.txt
@@ -24,6 +24,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Dist: matplotlib (>=3.5.2)

{stochvolmodels-1.0.20 → stochvolmodels-1.0.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "stochvolmodels"
-version = "1.0.20"
+version = "1.0.22"
 description = "Implementation of stochastic volatility models for option pricing"
 license = "LICENSE.txt"
 authors = ["Artur Sepp <artursepp@gmail.com>"]

{stochvolmodels-1.0.20 → stochvolmodels-1.0.22}/stochvolmodels/__init__.py

@@ -104,10 +104,10 @@ from stochvolmodels.pricers.heston_pricer import (
 from stochvolmodels.pricers.logsv_pricer import (
     LOGSV_BTC_PARAMS,
     LogSVPricer,
-    LogSvParams,
     LogsvModelCalibrationType,
     ConstraintsType
 )
+from stochvolmodels.pricers.logsv.logsv_params import LogSvParams
 
 from stochvolmodels.pricers.gmm_pricer import (
     GmmParams,

{stochvolmodels-1.0.20 → stochvolmodels-1.0.22}/stochvolmodels/data/option_chain.py

@@ -10,9 +10,12 @@ from __future__ import annotations
 import numpy as np
 from dataclasses import dataclass
 from typing import Tuple, Optional
+
+import pandas as pd
 from numba.typed import List
 
 import stochvolmodels.pricers.analytic.bsm as bsm
+from  stochvolmodels.utils.var_swap_pricer import compute_var_swap_strike
 
 
 @dataclass
@@ -227,6 +230,26 @@ class OptionChain:
                                    ask_prices=None if self.ask_prices is None else self.ask_prices[idx])
         return option_slice
 
+    def get_slice_varswap_strikes(self, floor_with_atm_vols: bool = True) -> pd.Series:
+        varswap_strikes = np.zeros_like(self.ttms)
+        vols_ttms = self.get_mid_vols()
+        for idx, ttm in enumerate(self.ttms):
+            mid_prices = bsm.compute_bsm_vanilla_slice_prices(ttm=ttm,
+                                                              forward=self.forwards[idx],
+                                                              strikes=self.strikes_ttms[idx],
+                                                              vols=vols_ttms[idx],
+                                                              optiontypes=self.optiontypes_ttms[idx])
+            strikes = self.strikes_ttms[idx]
+            puts_cond = self.optiontypes_ttms[idx] == 'P'
+            puts = pd.Series(mid_prices[puts_cond], index=strikes[puts_cond])
+            calls = pd.Series(mid_prices[puts_cond == False], index=strikes[puts_cond == False])
+            varswap_strikes[idx] = compute_var_swap_strike(puts=puts, calls=calls, forward=self.forwards[idx], ttm=ttm)
+
+        if floor_with_atm_vols:
+            varswap_strikes = np.maximum(self.get_chain_atm_vols(), varswap_strikes)
+
+        return pd.Series(varswap_strikes, index=self.ttms)
+
     @classmethod
     def get_slices_as_chain(cls, option_chain: OptionChain, ids: List[str]) -> OptionChain:
         """

stochvolmodels-1.0.22/stochvolmodels/examples/quick_run_lognormal_sv_pricer.py

@@ -0,0 +1,34 @@
+"""
+run few unit test to illustrate implementation of log-normal sv model analytics
+"""
+import numpy as np
+import matplotlib.pyplot as plt
+from stochvolmodels import LogSVPricer, LogSvParams, LogsvModelCalibrationType, ConstraintsType, get_btc_test_chain_data
+
+# 1. create instance of pricer
+logsv_pricer = LogSVPricer()
+
+# 2. define model params
+params = LogSvParams(sigma0=1.0, theta=1.0, kappa1=5.0, kappa2=5.0, beta=0.2, volvol=2.0)
+
+# 3. compute model prices for option slices
+model_prices, vols = logsv_pricer.price_slice(params=params,
+                                              ttm=0.25,
+                                              forward=1.0,
+                                              strikes=np.array([0.8, 0.9, 1.0, 1.1]),
+                                              optiontypes=np.array(['P', 'P', 'C', 'C']))
+print([f"{p:0.4f}, implied vol={v: 0.2%}" for p, v in zip(model_prices, vols)])
+
+# 4. calibrate model to test option chain data
+btc_option_chain = get_btc_test_chain_data()
+params0 = LogSvParams(sigma0=1.0, theta=1.0, kappa1=2.21, kappa2=2.18, beta=0.15, volvol=2.0)
+btc_calibrated_params = logsv_pricer.calibrate_model_params_to_chain(option_chain=btc_option_chain,
+                                                                     params0=params0,
+                                                                     model_calibration_type=LogsvModelCalibrationType.PARAMS4,
+                                                                     constraints_type=ConstraintsType.INVERSE_MARTINGALE)
+print(btc_calibrated_params)
+
+# 5. plot model implied vols
+logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=btc_option_chain,
+                                         params=btc_calibrated_params)
+plt.show()

{stochvolmodels-1.0.20 → stochvolmodels-1.0.22}/stochvolmodels/examples/run_lognormal_sv_pricer.py

@@ -90,7 +90,6 @@ def run_unit_test(unit_test: UnitTests):
                                                            nb_path=100000)
 
     elif unit_test == UnitTests.PLOT_FIT_TO_BITCOIN_OPTION_CHAIN:
-
         btc_option_chain = sv.get_btc_test_chain_data()
         btc_calibrated_params = LogSvParams(sigma0=0.8327, theta=1.0139, kappa1=4.8609, kappa2=4.7940, beta=0.1988, volvol=2.3694)
         logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=btc_option_chain,
@@ -102,7 +101,6 @@ def run_unit_test(unit_test: UnitTests):
         btc_calibrated_params = logsv_pricer.calibrate_model_params_to_chain(option_chain=btc_option_chain,
                                                                              params0=params0,
                                                                              model_calibration_type=LogsvModelCalibrationType.PARAMS4,
-
                                                                              constraints_type=sv.ConstraintsType.INVERSE_MARTINGALE)
         print(btc_calibrated_params)
         logsv_pricer.plot_model_ivols_vs_bid_ask(option_chain=btc_option_chain,
@@ -112,7 +110,7 @@ def run_unit_test(unit_test: UnitTests):
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.COMPARE_MODEL_VOLS_TO_MC
+    unit_test = UnitTests.COMPUTE_MODEL_PRICES
 
     is_run_all_tests = False
     if is_run_all_tests:

{stochvolmodels-1.0.20 → stochvolmodels-1.0.22}/stochvolmodels/pricers/heston_pricer.py

@@ -412,7 +412,7 @@ def run_unit_test(unit_test: UnitTests):
 
     elif unit_test == UnitTests.MC_COMPARISION_QVAR:
         from stochvolmodels.pricers.logsv.vol_moments_ode import compute_analytic_qvar
-        from stochvolmodels.pricers.logsv_pricer import LogSvParams
+        from stochvolmodels import LogSvParams
         heston_pricer = HestonPricer()
         ttms = {'1m': 1.0/12.0, '6m': 0.5}
         option_chain = chains.get_qv_options_test_chain_data()

{stochvolmodels-1.0.20 → stochvolmodels-1.0.22}/stochvolmodels/pricers/logsv/affine_expansion.py

@@ -36,7 +36,8 @@ def func_a_ode_quadratic_terms(theta: float,
                                phi: np.complex128,
                                psi: np.complex128,
                                is_spot_measure: bool = True,
-                               expansion_order: ExpansionOrder = ExpansionOrder.FIRST
+                               expansion_order: ExpansionOrder = ExpansionOrder.FIRST,
+                               vol_backbone_eta: float = 1.0
                                ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
     """
     Matrices for the quadratic form A_t = A.T@M@A + L@A + H
@@ -45,14 +46,15 @@ def func_a_ode_quadratic_terms(theta: float,
     vartheta2 = beta * beta + volvol * volvol
     qv = theta * vartheta2
     qv2 = theta2 * vartheta2
+    vol_backbone_eta2 = vol_backbone_eta * vol_backbone_eta
     if is_spot_measure:
         lamda = 0
         kappa2_p = kappa2
         kappa_p = kappa1 + kappa2 * theta
     else:
-        lamda = beta*theta2
-        kappa2_p = kappa2-beta
-        kappa_p = kappa1 + kappa2 * theta - 2*beta*theta
+        lamda = beta*theta2*vol_backbone_eta
+        kappa2_p = kappa2-beta*vol_backbone_eta
+        kappa_p = kappa1 + kappa2 * theta - 2*beta*theta*vol_backbone_eta
 
     # fill Ms: M should be of same type as L and H for numba, eventhough they are real
     # utilize that M is symmetric
@@ -83,15 +85,15 @@ def func_a_ode_quadratic_terms(theta: float,
 
     # fills Ls
     L = np.zeros((n, n), dtype=np.complex128)
-    L[0, 1], L[0, 2] = lamda - theta2 * beta * phi, qv2
-    L[1, 1], L[1, 2] = -kappa_p - 2.0 * theta * beta * phi, 2.0 * (lamda + qv - theta2 * beta * phi)
-    L[2, 1], L[2, 2] = -kappa2_p - beta * phi, vartheta2 - 2.0 * kappa_p - 4.0 * theta * beta * phi
+    L[0, 1], L[0, 2] = lamda - theta2 * beta * vol_backbone_eta * phi, qv2
+    L[1, 1], L[1, 2] = -kappa_p - 2.0 * theta * beta * vol_backbone_eta * phi, 2.0 * (lamda + qv - theta2 * beta * vol_backbone_eta * phi)
+    L[2, 1], L[2, 2] = -kappa2_p - beta * vol_backbone_eta * phi, vartheta2 - 2.0 * kappa_p - 4.0 * theta * beta * vol_backbone_eta * phi
 
     if expansion_order == ExpansionOrder.SECOND:
         L[1, 3] = 3.0*qv2
-        L[2, 3], L[2, 4] = 3.0 * (2.0 * qv - theta2 * beta * phi), 6.0 * qv2
-        L[3, 2], L[3, 3], L[3, 4] = -2.0 * (kappa2_p + beta * phi), 3.0 * (vartheta2 - kappa_p - 2.0 * theta * beta * phi), 4.0 * (3.0 * qv - theta2 * beta * phi)
-        L[4, 3], L[4, 4] = -3.0 * (kappa2_p + beta * phi), 2.0 * (vartheta2 - 2.0 * kappa_p - 4.0 * theta * beta * phi)
+        L[2, 3], L[2, 4] = 3.0 * (2.0 * qv - theta2 * beta * vol_backbone_eta * phi), 6.0 * qv2
+        L[3, 2], L[3, 3], L[3, 4] = -2.0 * (kappa2_p + beta * vol_backbone_eta * phi), 3.0 * (vartheta2 - kappa_p - 2.0 * theta * beta * vol_backbone_eta * phi), 4.0 * (3.0 * qv - theta2 * beta * vol_backbone_eta * phi)
+        L[4, 3], L[4, 4] = -3.0 * (kappa2_p + beta * vol_backbone_eta * phi), 2.0 * (vartheta2 - 2.0 * kappa_p - 4.0 * theta * beta * vol_backbone_eta * phi)
 
     # fill Hs
     H = np.zeros(n, dtype=np.complex128)
@@ -99,7 +101,7 @@ def func_a_ode_quadratic_terms(theta: float,
         rhs = (phi * (phi + 1.0) - 2.0 * psi)
     else:
         rhs = (phi * (phi - 1.0) - 2.0 * psi)
-    H[0], H[1], H[2] = 0.5 * theta2 * rhs, theta * rhs, 0.5 * rhs
+    H[0], H[1], H[2] = 0.5*theta2 * vol_backbone_eta2 * rhs, theta * vol_backbone_eta2 * rhs, 0.5*vol_backbone_eta2 * rhs
 
     return M, L, H
 
@@ -153,7 +155,8 @@ def solve_ode_for_a(ttm: float,
                     a_t0: Optional[np.ndarray] = None,
                     expansion_order: ExpansionOrder = ExpansionOrder.FIRST,
                     is_stiff_solver: bool = False,
-                    dense_output: bool = False
+                    dense_output: bool = False,
+                    vol_backbone_eta: float = 1.0
                     ) -> OdeResult:
     """
     solve ode for given phi
@@ -167,7 +170,8 @@ def solve_ode_for_a(ttm: float,
                                          phi=phi,
                                          psi=psi,
                                          expansion_order=expansion_order,
-                                         is_spot_measure=is_spot_measure)
+                                         is_spot_measure=is_spot_measure,
+                                         vol_backbone_eta=vol_backbone_eta)
 
     if a_t0 is None:
         a_t0 = np.zeros_like(H, dtype=np.complex128)
@@ -361,7 +365,8 @@ def solve_a_ode_grid(phi_grid: np.ndarray,
                      is_spot_measure: bool = True,
                      a_t0: Optional[np.ndarray] = None,
                      is_stiff_solver: bool = False,
-                     expansion_order: ExpansionOrder = ExpansionOrder.FIRST
+                     expansion_order: ExpansionOrder = ExpansionOrder.FIRST,
+                     vol_backbone_eta: float = 1.0
                      ) -> np.ndarray:
     """
     solve ode for range phi
@@ -382,7 +387,8 @@ def solve_a_ode_grid(phi_grid: np.ndarray,
                                               is_stiff_solver=is_stiff_solver,
                                               dense_output=False,
                                               expansion_order=expansion_order,
-                                              is_spot_measure=is_spot_measure)
+                                              is_spot_measure=is_spot_measure,
+                                              vol_backbone_eta=vol_backbone_eta)
 
     a_t1 = np.zeros((phi_grid.shape[0], get_expansion_n(expansion_order)), dtype=np.complex128)
     for idx, (phi, psi) in enumerate(zip(phi_grid, psi_grid)):
@@ -429,6 +435,7 @@ def compute_logsv_a_mgf_grid(ttm: float,
                              is_stiff_solver: bool = False,
                              is_analytic: bool = False,
                              is_spot_measure: bool = True,
+                             vol_backbone_eta: float = 1.0,
                              **kwargs
                              ) -> Tuple[np.ndarray, np.ndarray]:
     """
@@ -471,7 +478,8 @@ def compute_logsv_a_mgf_grid(ttm: float,
                                 a_t0=a_t0,
                                 is_stiff_solver=is_stiff_solver,
                                 expansion_order=expansion_order,
-                                is_spot_measure=is_spot_measure)
+                                is_spot_measure=is_spot_measure,
+                                vol_backbone_eta=vol_backbone_eta)
 
     y = sigma0 - theta
     if expansion_order == ExpansionOrder.FIRST:

stochvolmodels-1.0.22/stochvolmodels/pricers/logsv/logsv_params.py

@@ -0,0 +1,176 @@
+from dataclasses import dataclass, asdict
+from typing import Optional, Dict, Any
+
+import numpy as np
+import pandas as pd
+from numpy import linalg as la
+from qis import find_nearest
+
+from stochvolmodels import VariableType
+from stochvolmodels.pricers.model_pricer import ModelParams
+
+
+@dataclass
+class LogSvParams(ModelParams):
+    """
+    Implementation of model params class
+    """
+    sigma0: float = 0.2
+    theta: float = 0.2
+    kappa1: float = 1.0
+    kappa2: Optional[float] = 2.5  # Optional is mapped to self.kappa1 / self.theta
+    beta: float = -1.0
+    volvol: float = 1.0
+    vol_backbone: pd.Series = None
+
+    def __post_init__(self):
+        if self.kappa2 is None:
+            self.kappa2 = self.kappa1 / self.theta
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+    def to_str(self) -> str:
+        return f"sigma0={self.sigma0:0.2f}, theta={self.theta:0.2f}, kappa1={self.kappa1:0.2f}, kappa2={self.kappa2:0.2f}, " \
+               f"beta={self.beta:0.2f}, volvol={self.volvol:0.2f}"
+
+    def set_vol_backbone(self, vol_backbone: pd.Series) -> None:
+        self.vol_backbone = vol_backbone
+
+    def get_vol_backbone_eta(self, tau: float) -> float:
+        if self.vol_backbone is not None:
+            nearest_tau = find_nearest(a=self.vol_backbone.index.to_numpy(), value=tau, is_equal_or_largest=True)
+            vol_backbone_eta = self.vol_backbone.loc[nearest_tau]
+        else:
+            vol_backbone_eta = 1.0
+        return vol_backbone_eta
+
+    def get_vol_backbone_etas(self, ttms: np.ndarray) -> np.ndarray:
+        if self.vol_backbone is not None:
+            vol_backbone_etas = np.ones_like(ttms)
+            for idx, tau in enumerate(ttms):
+                nearest_tau = find_nearest(a=self.vol_backbone.index.to_numpy(), value=tau, is_equal_or_largest=True)
+                vol_backbone_etas[idx] = self.vol_backbone.loc[nearest_tau]
+        else:
+            vol_backbone_etas = np.ones_like(ttms)
+        return vol_backbone_etas
+
+    @property
+    def kappa(self) -> float:
+        return self.kappa1+self.kappa2*self.theta
+
+    @property
+    def theta2(self) -> float:
+        return self.theta*self.theta
+
+    @property
+    def vartheta2(self) -> float:
+        return self.beta*self.beta + self.volvol*self.volvol
+
+    @property
+    def gamma(self) -> float:
+        """
+        assume kappa2 = kappa1 / theta
+        """
+        return self.kappa1 / self.theta
+
+    @property
+    def eta(self) -> float:
+        """
+        assume kappa2 = kappa1 / theta
+        """
+        return self.kappa1 * self.theta / self.vartheta2 - 1.0
+
+    def get_x_grid(self, ttm: float = 1.0, n_stdevs: float = 3.0, n: int = 200) -> np.ndarray:
+        """
+        spacial grid to compute density of x
+        """
+        sigma_t = np.sqrt(ttm * 0.5 * (np.square(self.sigma0) + np.square(self.theta)))
+        drift = - 0.5*sigma_t*sigma_t
+        stdev = (n_stdevs+1)*sigma_t
+        return np.linspace(-stdev+drift, stdev+drift, n)
+
+    def get_sigma_grid(self, ttm: float = 1.0, n_stdevs: float = 3.0, n: int = 200) -> np.ndarray:
+        """
+        spacial grid to compute density of sigma
+        """
+        sigma_t = np.sqrt(0.5*(np.square(self.sigma0) + np.square(self.theta)))
+        vvol = 0.5*np.sqrt(self.vartheta2*ttm)
+        return np.linspace(0.0, sigma_t+n_stdevs*vvol, n)
+
+    def get_qvar_grid(self, ttm: float = 1.0, n_stdevs: float = 3.0, n: int = 200) -> np.ndarray:
+        """
+        spacial grid to compute density of i
+        """
+        sigma_t = np.sqrt(ttm * (np.square(self.sigma0) + np.square(self.theta)))
+        vvol = np.sqrt(self.vartheta2)*ttm
+        return np.linspace(0.0, sigma_t+n_stdevs*vvol, n)
+
+    def get_variable_space_grid(self, variable_type: VariableType = VariableType.LOG_RETURN,
+                                ttm: float = 1.0,
+                                n_stdevs: float = 3,
+                                n: int = 200
+                                ) -> np.ndarray:
+        if variable_type == VariableType.LOG_RETURN:
+            return self.get_x_grid(ttm=ttm, n_stdevs=n_stdevs, n=n)
+        if variable_type == VariableType.SIGMA:
+            return self.get_sigma_grid(ttm=ttm, n_stdevs=n_stdevs, n=n)
+        elif variable_type == VariableType.Q_VAR:
+            return self.get_qvar_grid(ttm=ttm, n_stdevs=n_stdevs, n=n)
+        else:
+            raise NotImplementedError
+
+    def get_vol_moments_lambda(self,
+                               n_terms: int = 4
+                               ) -> np.ndarray:
+
+        kappa2 = self.kappa2
+        kappa = self.kappa
+        vartheta2 = self.vartheta2
+        theta = self.theta
+        theta2 = self.theta2
+
+        def c(n: int) -> float:
+            return 0.5 * vartheta2 * n * (n - 1.0)
+
+        lambda_m = np.zeros((n_terms, n_terms))
+        lambda_m[0, 0] = -kappa
+        lambda_m[0, 1] = -kappa2
+        lambda_m[1, 0] = 2.0*c(2) * theta
+        lambda_m[1, 1] = c(2) - 2.0*kappa
+        lambda_m[1, 2] = -2.0*kappa2
+
+        for n_ in np.arange(2, n_terms):
+            n = n_ + 1  # n_ is array counter, n is formula counter
+            c_n = c(n)
+            lambda_m[n_, n_ - 2] = c_n * theta2
+            lambda_m[n_, n_ - 1] = 2.0 * c_n * theta
+            lambda_m[n_, n_] = c_n - n*kappa
+            if n_ + 1 < n_terms:
+                lambda_m[n_, n_ + 1] = -n*kappa2
+
+        return lambda_m
+
+    def assert_vol_moments_stability(self, n_terms: int = 4):
+        lambda_m = self.get_vol_moments_lambda(n_terms=n_terms)
+        w, v = la.eig(lambda_m)
+        cond = np.all(np.real(w)<0.0)
+        print(f"vol moments stable = {cond}")
+
+    def print_vol_moments_stability(self, n_terms: int = 4) -> None:
+        def c(n: int) -> float:
+            return 0.5 * self.vartheta2 * n * (n - 1.0)
+
+        cond_m2 = c(2) - 2.0*self.kappa
+        print(f"con2:\n{cond_m2}")
+        cond_m3 = c(3) - 3.0*self.kappa
+        print(f"con3:\n{cond_m3}")
+        cond_m4 = c(4) - 4.0*self.kappa
+        print(f"cond4:\n{cond_m4}")
+
+        lambda_m = self.get_vol_moments_lambda(n_terms=n_terms)
+        print(f"lambda_m:\n{lambda_m}")
+
+        w, v = la.eig(lambda_m)
+        print(f"eigenvalues w:\n{w}")
+        print(f"vol moments stable = {np.all(np.real(w)<0.0)}")

{stochvolmodels-1.0.20 → stochvolmodels-1.0.22}/stochvolmodels/pricers/logsv/vol_moments_ode.py

@@ -1,7 +1,7 @@
 """
 analytics for vol and QV moments computation
 """
-
+# packages
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
@@ -9,9 +9,9 @@ import seaborn as sns
 from numpy import linalg as la
 from scipy import linalg as sla
 from enum import Enum
-
-from ...pricers.logsv_pricer import LogSvParams
-from ...utils.funcs import set_seed
+# project
+from stochvolmodels.pricers.logsv.logsv_params import LogSvParams
+from stochvolmodels.utils.funcs import set_seed
 
 
 VOLVOL = 1.75
@@ -40,7 +40,7 @@ def compute_analytic_vol_moments(params: LogSvParams,
     rhs = np.zeros(n_terms)
     rhs[1] = params.vartheta2*params.theta2
 
-    if is_qvar: # need flat boundary condition
+    if is_qvar:  # need flat boundary condition
         rhs[-1] = -n_terms*params.kappa2*np.power(y, n_terms+1)
     else:
         rhs[-1] = -n_terms*params.kappa2*np.power(y, n_terms+1)
@@ -73,6 +73,9 @@ def compute_analytic_qvar(params: LogSvParams,
                           ttm: float = 1.0,
                           n_terms: int = 4
                           ) -> float:
+    """
+    compute expected value [ (1/T) int^T_0 sigma^2_t dt]
+    """
     if np.isclose(ttm, 0.0):
         qvar = np.square(params.sigma0)
     else:
@@ -113,10 +116,45 @@ def compute_sqrt_qvar_t(params: LogSvParams, t: np.ndarray, n_terms: int = 4) ->
     return ev
 
 
+def fit_model_vol_backbone_to_varswaps(log_sv_params: LogSvParams,
+                                       varswap_strikes: pd.Series,
+                                       n_terms: int = 4,
+                                       verbose: bool = False
+                                       ) -> pd.Series:
+    """
+    fit model eta so that model reproduces quadratic var
+    """
+    ttms = varswap_strikes.index.to_numpy()
+    market_qvar_dt = ttms * np.square(varswap_strikes.to_numpy())
+    # compute model qvars
+    model_forwards = np.array([compute_analytic_qvar(params=log_sv_params, ttm=ttm, n_terms=n_terms) for ttm in ttms])
+    model_qvar_dt = model_forwards*ttms
+    model_eta = np.ones_like(ttms)
+    for idx, ttm in enumerate(ttms):
+        if idx == 0:
+            model_eta[idx] = market_qvar_dt[idx] / model_qvar_dt[idx]
+        else:
+            model_eta[idx] = (market_qvar_dt[idx]-market_qvar_dt[idx-1]) / (model_qvar_dt[idx]-model_qvar_dt[idx-1])
+    # model_eta = np.where(model_eta > 0.0, np.sqrt(model_eta), 1.0)
+    model_eta = np.where(model_eta > 0.0, model_eta, 1.0)
+    # adhoc adjustemnt for now
+    model_eta = np.where(ttms < 0.06, np.sqrt(model_eta), model_eta)
+
+    model_eta = pd.Series(model_eta, index=ttms)
+    if verbose:
+        varswap_strikes = np.sqrt(varswap_strikes.to_frame('vars_swap strikes'))
+        varswap_strikes['market_qvar_dt'] = market_qvar_dt
+        varswap_strikes['model_qvar_dt'] = model_qvar_dt
+        varswap_strikes['model_eta'] = model_eta
+        print(f"vars_swaps\n{varswap_strikes}")
+    return model_eta
+
+
 class UnitTests(Enum):
     VOL_MOMENTS = 1
     EXPECTED_VOL = 2
     EXPECTED_QVAR = 3
+    VOL_BACKBONE = 4
 
 
 def run_unit_test(unit_test: UnitTests):
@@ -185,12 +223,17 @@ def run_unit_test(unit_test: UnitTests):
             sns.lineplot(data=analytic_vol_moments, dashes=False, ax=ax)
             ax.errorbar(x=df.index[::5], y=mc_mean[::5], yerr=mc_std[::5], fmt='o', color='green', capsize=8)
 
+    elif unit_test == UnitTests.VOL_BACKBONE:
+        fit_model_vol_backbone_to_varswaps(log_sv_params=params,
+                                           varswap_strikes=pd.Series([1.0, 1.0], index=[1.0 / 12., 2 / 12.0]),
+                                           verbose=True)
+
     plt.show()
 
 
 if __name__ == '__main__':
 
-    unit_test = UnitTests.VOL_MOMENTS
+    unit_test = UnitTests.VOL_BACKBONE
 
     is_run_all_tests = False
     if is_run_all_tests: