From 64b3c36eca814cd4d0dd82ff62dbde68f362bbd4 Mon Sep 17 00:00:00 2001 From: emile-cochin Date: Thu, 19 Jun 2025 15:15:28 +0100 Subject: [PATCH 1/6] Adds an alternative method to compute eta_function in CustomSD Adds an alt_integrator parameter to PowerLawSD/CustomSD and to eta_function/correlation_2d_integral that dictates whether or not to use an alternative method to numerically integrate eta_function (splitting the integrals into oscillating terms and using cos/sin weighted integrals instead). Also adds corresponding coverage tests and physics tests comparing exact values of these integrals to both versions of the integrator (asking for at least an IntegrationWarning if the results don't match). --- oqupy/bath_correlations.py | 166 +++++++++++++++++++++++- tests/coverage/correlations_test.py | 38 +++--- tests/physics/bath_correlations_test.py | 78 +++++++++++ 3 files changed, 259 insertions(+), 23 deletions(-) create mode 100644 tests/physics/bath_correlations_test.py diff --git a/oqupy/bath_correlations.py b/oqupy/bath_correlations.py index 3bc40b4f..b18a4464 100644 --- a/oqupy/bath_correlations.py +++ b/oqupy/bath_correlations.py @@ -13,7 +13,7 @@ Module for environment correlations. """ -from typing import Callable, Optional, Text +from typing import Callable, Optional, Union, Text from typing import Any as ArrayLike from functools import lru_cache @@ -309,6 +309,30 @@ def _gaussian_cutoff(omega: ArrayLike, omega_c: float) -> ArrayLike: # --- the spectral density classes -------------------------------------------- +def _weighted_integral( + re_integrand: Callable[[float], float], + im_integrand: Callable[[float], float], + w: float, + a: Optional[float] = 0.0, + b: Optional[float] = 1.0, + epsrel: Optional[float] = INTEGRATE_EPSREL, + limit: Optional[int] = SUBDIV_LIMIT) -> complex: + re_int = integrate.quad(re_integrand, + a=a, + b=b, + epsrel=epsrel, + limit=limit, + weight='cos', + wvar=w)[0] + im_int = integrate.quad(im_integrand, + a=a, + b=b, + epsrel=epsrel, + limit=limit, + weight='sin', + wvar=w)[0] + return re_int + 1j * im_int + def _complex_integral( integrand: Callable[[float], complex], a: Optional[float] = 0.0, @@ -362,6 +386,10 @@ class CustomSD(BaseCorrelations): ``'gaussian'``} temperature: float The environment's temperature. + alt_integrator: bool + Whether or not to use a sine/cosine weighted version of the + integrals that could be better suited if you're encountering + numerical difficulties, especially for long memory times. name: str An optional name for the correlations. description: str @@ -374,6 +402,7 @@ def __init__( cutoff: float, cutoff_type: Optional[Text] = 'exponential', temperature: Optional[float] = 0.0, + alt_integrator: Optional[bool] = False, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Create a CustomFunctionSD (spectral density) object. """ @@ -409,6 +438,10 @@ def __init__( tmp_temperature)) self.temperature = tmp_temperature + # input check for alt_integrator + assert isinstance(alt_integrator, bool) + self._alt_integrator = alt_integrator + self._cutoff_function = \ lambda omega: CUTOFF_DICT[self.cutoff_type](omega, self.cutoff) self._spectral_density = \ @@ -515,23 +548,75 @@ def integrand(w): integral = integral.real return integral + @lru_cache(maxsize=2 ** 10, typed=False) + def _truncated_eta(self, + a: float, + epsrel: float, + limit: int) -> complex: + """Computes the parts of `eta_function` that are tau independant when + `alt_integrator` is set to True. + """ + if self.temperature == 0.0: + def re_integrand(w): + return self._spectral_density(w) / w ** 2 + else: + def re_integrand(w): + # this is to stop overflow + if np.exp(-w / self.temperature) > np.finfo(float).eps: + inte = self._spectral_density(w) / w ** 2 \ + * 1/np.tanh(w / (2*self.temperature)) + else: + inte = self._spectral_density(w) / w ** 2 + return inte + + def im_integrand(w): + return self._spectral_density(w)/w + + im_constant = integrate.quad(im_integrand, + a=a, + b=self.cutoff, + epsrel=epsrel, + limit=limit)[0] + + re_constant = integrate.quad(re_integrand, + a=a, + b=self.cutoff, + epsrel=epsrel, + limit=limit)[0] + + if self.cutoff_type != "hard": + im_constant += integrate.quad(im_integrand, + a=self.cutoff, + b=np.inf, + epsrel=epsrel, + limit=limit)[0] + + re_constant += integrate.quad(re_integrand, + a=self.cutoff, + b=np.inf, + epsrel=epsrel, + limit=limit)[0] + return re_constant, im_constant + @lru_cache(maxsize=2 ** 10, typed=False) def eta_function( self, tau: ArrayLike, epsrel: Optional[float] = INTEGRATE_EPSREL, subdiv_limit: Optional[int] = SUBDIV_LIMIT, + alt_integrator: Optional[Union[bool, None]] = None, matsubara: Optional[bool] = False) -> ArrayLike: r""" - Auto-correlation function associated to the spectral density at the + :math:`\eta` function associated to the spectral density at the given temperature :math:`T` .. math:: - C(\tau) = \int_0^{\infty} J(\omega) \ - \left[ \cos(\omega \tau) \ + \eta(\tau) = \int_0^{\infty} \frac{J(\omega)}{\omega^2} \ + \left[ ( \cos(\omega \tau) - 1 ) \ \coth\left( \frac{\omega}{2 T}\right) \ - - i \sin(\omega \tau) \right] \mathrm{d}\omega . + - i ( \sin(\omega \tau) - \omega \tau ) \right] \ + \mathrm{d}\omega . with time difference `tau` :math:`\tau`. @@ -543,12 +628,23 @@ def eta_function( Relative error tolerance. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. - + alt_integrator: Union[bool, None] + Whether or not to use a sine/cosine weighted version of the + integrals that could be better suited if you're encountering + numerical difficulties, especially for long memory times. If the + value is `None`, the value of `alt_integrator` set during + initialization of the `CustomSD` object is used instead. Returns ------- correlation : ndarray - The auto-correlation function :math:`C(\tau)` at time :math:`\tau`. + The function :math:`\eta(\tau)` at time :math:`\tau`. """ + if alt_integrator is None: + alt_integrator = self._alt_integrator + check_true(not (matsubara is True and alt_integrator is True), + "Can't use weighted integrator with matsubara") + check_true(isinstance(alt_integrator, bool), + "alt_integrator has to be either True, False or None") # real and imaginary part of the integrand if matsubara: tau = -1j * tau @@ -574,6 +670,50 @@ def integrand(w): * (np.exp(-1j * w * tau) - 1 + 1j * w * tau) return inte + # Alternative computation with weighted integrators + if alt_integrator and tau*self.cutoff > 1.: + im_integrand = lambda w: - self._spectral_density(w) / w ** 2 + if self.temperature == 0.0: + re_integrand = lambda w: self._spectral_density(w) / w ** 2 + else: + def re_integrand(w): + # this is to stop overflow + if np.exp(-w / self.temperature) > np.finfo(float).eps: + inte = self._spectral_density(w) / w ** 2 \ + * 1/np.tanh(w / (2*self.temperature)) + else: + inte = self._spectral_density(w) / w ** 2 + return inte + + omega_tilde = self.cutoff/int(self.cutoff*tau/10+2) + + integral = _complex_integral(integrand, + a=0.0, + b=omega_tilde, + epsrel=epsrel, + limit=subdiv_limit) + + integral += _weighted_integral(re_integrand, im_integrand, + w=tau, + a=omega_tilde, + b=self.cutoff, + epsrel=epsrel, + limit=subdiv_limit) + + if self.cutoff_type != "hard": + integral += _weighted_integral(re_integrand, im_integrand, + w=tau, + a=self.cutoff, + b=np.inf, + epsrel=epsrel, + limit=subdiv_limit) + + re_constant, im_constant = self._truncated_eta(a=omega_tilde, + epsrel=epsrel, + limit=subdiv_limit) + return - (integral + 1.j*tau*im_constant - re_constant) + + # Default computation of eta_function when alt_integrator is False integral = _complex_integral(integrand, a=0.0, b=self.cutoff, @@ -598,6 +738,7 @@ def correlation_2d_integral( shape: Optional[Text] = 'square', epsrel: Optional[float] = INTEGRATE_EPSREL, subdiv_limit: Optional[int] = SUBDIV_LIMIT, + alt_integrator: Optional[bool] = False, matsubara: Optional[bool] = False) -> complex: r""" 2D integrals of the correlation function @@ -632,6 +773,10 @@ def correlation_2d_integral( Relative error tolerance. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. + alt_integrator: Union[bool, None] + Whether or not to use a sine/cosine weighted version of the + integrals that could be better suited if you're encountering + numerical difficulties, especially for long times. Returns ------- @@ -642,6 +787,7 @@ def correlation_2d_integral( kwargs = { 'epsrel': epsrel, 'subdiv_limit': subdiv_limit, + 'alt_integrator': alt_integrator, 'matsubara': matsubara} if shape == 'upper-triangle': @@ -701,6 +847,10 @@ class PowerLawSD(CustomSD): ``'gaussian'``} temperature: float The environment's temperature. + alt_integrator: bool + Whether or not to use a sine/cosine weighted version of the + integrals that could be better suited if you're encountering + numerical difficulties, especially for long memory times. name: str An optional name for the correlations. description: str @@ -714,6 +864,7 @@ def __init__( cutoff: float, cutoff_type: Text = 'exponential', temperature: Optional[float] = 0.0, + alt_integrator: Optional[bool] = False, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Create a StandardSD (spectral density) object. """ @@ -747,6 +898,7 @@ def __init__( cutoff=cutoff, cutoff_type=cutoff_type, temperature=temperature, + alt_integrator=alt_integrator, name=name, description=description) diff --git a/tests/coverage/correlations_test.py b/tests/coverage/correlations_test.py index 6a67a534..1df1d9c8 100644 --- a/tests/coverage/correlations_test.py +++ b/tests/coverage/correlations_test.py @@ -63,22 +63,25 @@ def test_custom_correlations_bad_input(): def test_custom_s_d(): for cutoff_type in ["hard", "exponential", "gaussian"]: for temperature in [0.0, 2.0]: - sd = CustomSD(square_function, - cutoff=2.0, - temperature=temperature, - cutoff_type=cutoff_type) - str(sd) - w = np.linspace(0, 8.0 * sd.cutoff, 10) - y = sd.spectral_density(w) - t = np.linspace(0, 4.0 / sd.cutoff, 10) - [sd.correlation(tt) for tt in t] - for shape in ["square", "upper-triangle"]: - sd.correlation_2d_integral(time_1=0.25, - delta=0.05, - shape=shape) - sd.correlation_2d_integral(time_1=0.25, - delta=0.05, - shape=shape) + for alt_integrator in [True, False, None]: + sd = CustomSD(square_function, + cutoff=2.0, + temperature=temperature, + cutoff_type=cutoff_type) + str(sd) + w = np.linspace(0, 8.0 * sd.cutoff, 10) + y = sd.spectral_density(w) + t = np.linspace(0, 4.0 / sd.cutoff, 10) + [sd.correlation(tt) for tt in t] + for shape in ["square", "upper-triangle"]: + sd.correlation_2d_integral(time_1=0.25, + delta=0.05, + shape=shape, + alt_integrator=alt_integrator) + sd.correlation_2d_integral(time_1=0.5, + delta=0.05, + shape=shape, + alt_integrator=alt_integrator) def test_matsubara_custom_s_d(): @@ -171,6 +174,9 @@ def test_custom_s_d_bad_input(): with pytest.raises(AssertionError): CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ temperature="bla") + with pytest.raises(AssertionError): + CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ + temperature=0.0, alt_integrator="bla") with pytest.raises(ValueError): CustomSD(square_function, cutoff=2.0, cutoff_type="hard", \ temperature=-2.0) diff --git a/tests/physics/bath_correlations_test.py b/tests/physics/bath_correlations_test.py new file mode 100644 index 00000000..8b81aa0e --- /dev/null +++ b/tests/physics/bath_correlations_test.py @@ -0,0 +1,78 @@ +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" +Tests for the oqupy.bath_correlations module. +""" + +import pytest +import warnings +import numpy as np +from scipy.integrate import IntegrationWarning + +from oqupy.bath_correlations import BaseCorrelations +from oqupy.bath_correlations import CustomCorrelations +from oqupy.bath_correlations import CustomSD +from oqupy.bath_correlations import PowerLawSD + +def exact_2d_correlations(alpha, omega_cutoff, k, dt, shape): + # Exact 2d correlations for an Ohmic spectral density and exponential cutoff at 0 temperature + eta_func = lambda k: np.log(1/omega_cutoff+1.j*k*dt) + if shape == "square": + correl = eta_func(k-1)-2*eta_func(k)+eta_func(k+1) + elif shape == "upper-triangle": + correl = eta_func(k+1)-eta_func(k)-1.j*omega_cutoff*dt + return 2*alpha*correl + +def test(): + kranges = [np.arange(1, 5), np.arange(395, 400)] + + omega_cutoff = 3.0 + temperature = 0.0 + alpha = 5e-2 + dt = 0.4 + + for shape in ["square", "upper-triangle"]: + for krange in kranges: + exact_correls_2d = exact_2d_correlations(alpha, + omega_cutoff, + krange, + dt, + shape) + for alt_integrator in [False, True]: + correls = PowerLawSD(alpha=alpha, + zeta=1.0, + cutoff=omega_cutoff, + cutoff_type="exponential", + temperature=temperature, + alt_integrator=alt_integrator) + with warnings.catch_warnings(): + warnings.simplefilter(action="error", + category=IntegrationWarning) + try: + correls_2d = [correls.correlation_2d_integral(dt, k*dt, shape=shape) + for k in krange] + except IntegrationWarning: + pass + else: + try: + np.testing.assert_allclose(exact_correls_2d, + correls_2d, + rtol=1e-3, atol=1e-6) + except AssertionError: + pytest.fail("correlation_2d_integral should "\ + "either give precise results or at least"\ + "warn the user that there could be some"\ + f"numerical error, failed: shape={shape},"\ + f"ks={krange},"\ + f"alt_integrator={alt_integrator}") + + From 11662824ef9d044353f25e0adc47f9f4aaa9f253 Mon Sep 17 00:00:00 2001 From: emile-cochin Date: Mon, 30 Jun 2025 18:09:05 +0100 Subject: [PATCH 2/6] Added a way to change the first cutoff when using alt_integrator in CustomSD --- oqupy/bath_correlations.py | 58 ++++++++++++++++- tests/coverage/correlations_test.py | 10 ++- tests/physics/bath_correlations_test.py | 86 ++++++++++++++----------- 3 files changed, 113 insertions(+), 41 deletions(-) diff --git a/oqupy/bath_correlations.py b/oqupy/bath_correlations.py index b18a4464..55b3f8a4 100644 --- a/oqupy/bath_correlations.py +++ b/oqupy/bath_correlations.py @@ -390,6 +390,21 @@ class CustomSD(BaseCorrelations): Whether or not to use a sine/cosine weighted version of the integrals that could be better suited if you're encountering numerical difficulties, especially for long memory times. + The integral computed in `eta_function` is cut in two: one + handling the divergent part near 0 using the default integrator + and the other taking care of the fast oscillations at angular + frequency :math:`\tau` using an appropriate integration scheme. + The cutoff point can be modified with `num_oscillations`. + num_oscillations: int, float, callable + When using `alt_integrator`, specifies how many oscillations to keep + for the non-weighted part of the integral of `eta_function`. This should + be either an integer or specified as a function of :math:`\tau`. To help + choose: the higher this number is, the more the default integrator will + struggle to integrate the non-weighted part. The lower it is, the more + the weighted integrators will struggle to integrate the near divergent + part close to 0. A constant value is a good choice for most use cases. + Otherwise, it is possible to input a function to target possible issues + at specific memory times :math:`\tau`. name: str An optional name for the correlations. description: str @@ -403,6 +418,8 @@ def __init__( cutoff_type: Optional[Text] = 'exponential', temperature: Optional[float] = 0.0, alt_integrator: Optional[bool] = False, + num_oscillations: Optional[ + Union[int, float, Callable[[float], float]]] = None, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Create a CustomFunctionSD (spectral density) object. """ @@ -442,6 +459,24 @@ def __init__( assert isinstance(alt_integrator, bool) self._alt_integrator = alt_integrator + # create the first_cutoff function and input check for num_oscillations + if num_oscillations is None: + num_oscillations = 3 + if isinstance(num_oscillations, (int, float)) and num_oscillations > 0: + tmp_n = num_oscillations + # This form is a step version of the first cutoff which prevents + # useless computations of _truncated_eta + self.first_cutoff = lambda t: 2*np.pi*tmp_n/(1+1/tmp_n)**np.floor( + np.log(t)/np.log(1+1/tmp_n)) + else: + try: + float(num_oscillations(1.0)) + except Exception as e: + raise AssertionError("num_oscillations must be a positive" \ + "float, int or a function returning floats or ints.") from e + self.first_cutoff = lambda t: max(min(2*np.pi*num_oscillations(t)/t, + self.cutoff), 0.0) + self._cutoff_function = \ lambda omega: CUTOFF_DICT[self.cutoff_type](omega, self.cutoff) self._spectral_density = \ @@ -608,7 +643,7 @@ def eta_function( matsubara: Optional[bool] = False) -> ArrayLike: r""" :math:`\eta` function associated to the spectral density at the - given temperature :math:`T` + given temperature :math:`T` as given in [Strathearn2017] .. math:: @@ -685,7 +720,7 @@ def re_integrand(w): inte = self._spectral_density(w) / w ** 2 return inte - omega_tilde = self.cutoff/int(self.cutoff*tau/10+2) + omega_tilde = self.first_cutoff(tau) integral = _complex_integral(integrand, a=0.0, @@ -738,7 +773,7 @@ def correlation_2d_integral( shape: Optional[Text] = 'square', epsrel: Optional[float] = INTEGRATE_EPSREL, subdiv_limit: Optional[int] = SUBDIV_LIMIT, - alt_integrator: Optional[bool] = False, + alt_integrator: Optional[Union[bool, None]] = None, matsubara: Optional[bool] = False) -> complex: r""" 2D integrals of the correlation function @@ -851,6 +886,21 @@ class PowerLawSD(CustomSD): Whether or not to use a sine/cosine weighted version of the integrals that could be better suited if you're encountering numerical difficulties, especially for long memory times. + The integral computed in `eta_function` is cut in two: one + handling the divergent part near 0 using the default integrator + and the other taking care of the fast oscillations at angular + frequency :math:`\tau` using an appropriate integration scheme. + The cutoff point can be modified with `num_oscillations`. + num_oscillations: int, float, callable + When using `alt_integrator`, specifies how many oscillations to keep + for the non-weighted part of the integral of `eta_function`. This should + be either an integer or specified as a function of :math:`\tau`. To help + choose: the higher this number is, the more the default integrator will + struggle to integrate the non-weighted part. The lower it is, the more + the weighted integrators will struggle to integrate the near divergent + part close to 0. A constant value is a good choice for most use cases. + Otherwise, it is possible to input a function to target possible issues + at specific memory times :math:`\tau`. name: str An optional name for the correlations. description: str @@ -865,6 +915,8 @@ def __init__( cutoff_type: Text = 'exponential', temperature: Optional[float] = 0.0, alt_integrator: Optional[bool] = False, + num_oscillations: Optional[ + Union[int, float, Callable[[float], float]]] = None, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Create a StandardSD (spectral density) object. """ diff --git a/tests/coverage/correlations_test.py b/tests/coverage/correlations_test.py index 1df1d9c8..01fa1e44 100644 --- a/tests/coverage/correlations_test.py +++ b/tests/coverage/correlations_test.py @@ -158,7 +158,9 @@ def test_matsubara_custom_s_d_bad_input(): delta=0.1, shape=shape, matsubara=True) - + correlations = CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", temperature=1.0, alt_integrator=True) + with pytest.raises(ValueError): + correlations.correlation_2d_integral(time_1=2, delta=0.1, shape='upper-triangle', matsubara=True, alt_integrator=True) @@ -177,6 +179,12 @@ def test_custom_s_d_bad_input(): with pytest.raises(AssertionError): CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ temperature=0.0, alt_integrator="bla") + with pytest.raises(AssertionError): + CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ + temperature=0.0, num_oscillations=-1.0) + with pytest.raises(AssertionError): + CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ + temperature=0.0, num_oscillations=lambda t: "a") with pytest.raises(ValueError): CustomSD(square_function, cutoff=2.0, cutoff_type="hard", \ temperature=-2.0) diff --git a/tests/physics/bath_correlations_test.py b/tests/physics/bath_correlations_test.py index 8b81aa0e..12f07df4 100644 --- a/tests/physics/bath_correlations_test.py +++ b/tests/physics/bath_correlations_test.py @@ -13,23 +13,32 @@ Tests for the oqupy.bath_correlations module. """ +from itertools import product import pytest import warnings import numpy as np from scipy.integrate import IntegrationWarning +from scipy.special import loggamma from oqupy.bath_correlations import BaseCorrelations from oqupy.bath_correlations import CustomCorrelations from oqupy.bath_correlations import CustomSD from oqupy.bath_correlations import PowerLawSD -def exact_2d_correlations(alpha, omega_cutoff, k, dt, shape): - # Exact 2d correlations for an Ohmic spectral density and exponential cutoff at 0 temperature - eta_func = lambda k: np.log(1/omega_cutoff+1.j*k*dt) +def exact_2d_correlations(alpha, omega_cutoff, temperature, k, dt, shape): + # Exact 2d correlations for an Ohmic spectral density and exponential cutoff + if temperature == 0.0: + eta_func = lambda k: np.log(1/omega_cutoff+1.j*k*dt)-1.j*omega_cutoff*dt*k + else: + eta_func = lambda k: -(1/2*np.log(1+(k*dt*omega_cutoff)**2)+ + loggamma(temperature*(1/omega_cutoff+1.j*k*dt))+ + loggamma(temperature*(1/omega_cutoff-1.j*k*dt))- + 2*loggamma(temperature/omega_cutoff)+ + 1j*(omega_cutoff*k*dt-np.arctan(omega_cutoff*k*dt))) if shape == "square": correl = eta_func(k-1)-2*eta_func(k)+eta_func(k+1) elif shape == "upper-triangle": - correl = eta_func(k+1)-eta_func(k)-1.j*omega_cutoff*dt + correl = eta_func(k+1)-eta_func(k) return 2*alpha*correl def test(): @@ -40,39 +49,42 @@ def test(): alpha = 5e-2 dt = 0.4 - for shape in ["square", "upper-triangle"]: - for krange in kranges: - exact_correls_2d = exact_2d_correlations(alpha, - omega_cutoff, - krange, - dt, - shape) - for alt_integrator in [False, True]: - correls = PowerLawSD(alpha=alpha, - zeta=1.0, - cutoff=omega_cutoff, - cutoff_type="exponential", - temperature=temperature, - alt_integrator=alt_integrator) - with warnings.catch_warnings(): - warnings.simplefilter(action="error", - category=IntegrationWarning) + for shape, temperature, krange in product(["square", "upper-triangle"], + [0.0, 2.0], + kranges): + exact_correls_2d = exact_2d_correlations(alpha, + omega_cutoff, + temperature, + krange, + dt, + shape) + for alt_integrator in [False, True]: + correls = PowerLawSD(alpha=alpha, + zeta=1.0, + cutoff=omega_cutoff, + cutoff_type="exponential", + temperature=temperature, + alt_integrator=alt_integrator) + with warnings.catch_warnings(): + warnings.simplefilter(action="error", + category=IntegrationWarning) + try: + correls_2d = [correls.correlation_2d_integral(dt, k*dt, shape=shape) + for k in krange] + except IntegrationWarning: + pass + else: try: - correls_2d = [correls.correlation_2d_integral(dt, k*dt, shape=shape) - for k in krange] - except IntegrationWarning: - pass - else: - try: - np.testing.assert_allclose(exact_correls_2d, - correls_2d, - rtol=1e-3, atol=1e-6) - except AssertionError: - pytest.fail("correlation_2d_integral should "\ - "either give precise results or at least"\ - "warn the user that there could be some"\ - f"numerical error, failed: shape={shape},"\ - f"ks={krange},"\ - f"alt_integrator={alt_integrator}") + np.testing.assert_allclose(exact_correls_2d, + correls_2d, + rtol=1e-3, atol=1e-6) + except AssertionError: + pytest.fail("correlation_2d_integral should "\ + "either give precise results or at least "\ + "warn the user that there could be some "\ + f"numerical error, failed: shape={shape}, "\ + f"temperature={temperature}, ", + f"ks={krange}, "\ + f"alt_integrator={alt_integrator}") From 4fd3e5ada6f4b484027db4d994429ac0829cb3ce Mon Sep 17 00:00:00 2001 From: emile-cochin Date: Mon, 20 Apr 2026 14:16:28 +0200 Subject: [PATCH 3/6] added a parameters dictionary for integration parameters in CustomSD Put previous `epsrel`, `subdiv_limit` parameters together with `alt_integrator` and `num_oscillations` in a single parameter dictionary as input for `CustomSD` (and necessary modifications resulting from this change in tests/) which defaults to `INTEGRATION_PARAMS` in `config.py`. Also adds a small section in the parameters tutorials about the alternative integrator. --- docs/pages/tutorials/parameters.rst | 18 ++ oqupy/bath_correlations.py | 213 +++++++++++++----------- oqupy/config.py | 8 + tests/coverage/correlations_test.py | 14 +- tests/physics/bath_correlations_test.py | 2 +- 5 files changed, 150 insertions(+), 105 deletions(-) diff --git a/docs/pages/tutorials/parameters.rst b/docs/pages/tutorials/parameters.rst index 7730eb0b..23b8b0c9 100644 --- a/docs/pages/tutorials/parameters.rst +++ b/docs/pages/tutorials/parameters.rst @@ -321,6 +321,24 @@ computation time over a timescale ``end_time-start_time``, so make sure to set these to reflect those you actually intend to use in calculations. +Long memory lengths +~~~~~~~~~~~~~~~~~~~ + +When defining the bath parameters with a spectral density (for example with a ``CustomSD`` or ``PowerLawSD``), large values of ``tcut`` can lead to numerical instabilities in the computation of the influence matrix. Indeed, the coefficients of the influence matrix are computed through discrete time differences of the ``eta_function`` given by: + +.. math:: + \eta(\tau) = \int_0^{\infty} \frac{J(\omega)}{\omega^2} \ + \left[ ( \cos(\omega \tau) - 1 ) \ + \coth\left( \frac{\omega}{2 T}\right) \ + - i ( \sin(\omega \tau) - \omega \tau ) \right] \ + \mathrm{d}\omega. + +with memory-time ``tau`` :math:`\tau`. ``tcut`` is the highest value used for ``tau`` in this expression. Thus, high memory lengths lead to highly oscillating terms in this integral due to the :math:`\cos(\tau\omega)` and :math:`\sin(\tau\omega)` terms. The default integrator used for this integral can struggle to give converged results in these cases. However, it is possible to specify whether to use a weighted integrator instead which is better suited for these oscillatory behaviours with ``alt_integrator`` in ``CustomSD`` (or any of its subclasses). + +In more detail, this keyword changes the computation by splitting the integral in two: it uses the default integrator for the divergent part near 0 and the weighted sine or cosine versions of ``scipy.integrate.quad`` after. By default, the point where the integral is split is chosen automatically by setting a maximum number of oscillations for the first integral. It is possible to change the default number of oscillations through the ``num_oscillations`` parameter. It either takes an integer, float or a function of ``tau`` which should return the maxium number of oscillations for each ``tau``. The results are often quite accurate with the default values, but rough guidelines for modifying it are to decrease the number of oscillations if the integrator struggles with the first integral (too oscillatory for the default integrator), and increase it if it struggles with the second integral (too divergent for the cos/sin weighted versions). + + + ---------------------- Choosing dt and epsrel ---------------------- diff --git a/oqupy/bath_correlations.py b/oqupy/bath_correlations.py index 55b3f8a4..13c35748 100644 --- a/oqupy/bath_correlations.py +++ b/oqupy/bath_correlations.py @@ -13,15 +13,16 @@ Module for environment correlations. """ -from typing import Callable, Optional, Union, Text +from typing import Callable, Optional, Union, Text, Dict from typing import Any as ArrayLike from functools import lru_cache +import warnings import numpy as np from scipy import integrate from oqupy.base_api import BaseAPIClass -from oqupy.config import INTEGRATE_EPSREL, SUBDIV_LIMIT +from oqupy.config import INTEGRATE_EPSREL, SUBDIV_LIMIT, INTEGRATION_PARAMS from oqupy.util import check_true #np.seterr(all='warn') @@ -386,29 +387,39 @@ class CustomSD(BaseCorrelations): ``'gaussian'``} temperature: float The environment's temperature. - alt_integrator: bool - Whether or not to use a sine/cosine weighted version of the - integrals that could be better suited if you're encountering - numerical difficulties, especially for long memory times. - The integral computed in `eta_function` is cut in two: one - handling the divergent part near 0 using the default integrator - and the other taking care of the fast oscillations at angular - frequency :math:`\tau` using an appropriate integration scheme. - The cutoff point can be modified with `num_oscillations`. - num_oscillations: int, float, callable - When using `alt_integrator`, specifies how many oscillations to keep - for the non-weighted part of the integral of `eta_function`. This should - be either an integer or specified as a function of :math:`\tau`. To help - choose: the higher this number is, the more the default integrator will - struggle to integrate the non-weighted part. The lower it is, the more - the weighted integrators will struggle to integrate the near divergent - part close to 0. A constant value is a good choice for most use cases. - Otherwise, it is possible to input a function to target possible issues - at specific memory times :math:`\tau`. name: str An optional name for the correlations. description: str An optional description of the correlations. + integration_params: dict + Optional dictionary to pass integration parameters. Possible + parameters include: + + - **epsrel** (*float*) -- Relative error tolerance. + - **subdiv_limit** (*int*) -- Maximal number of interval subdivisions + for numerical integration. + - **alt_integrator** (*bool*) -- Whether to use an alternative + integration scheme leveraging sine/cosine weighted versions of + `scipy.integrate.quad` to handle rapid oscillations. This may improve + numerical accuracy and stability, especially for long memory times. + + The integral computed in :func:`eta_function` is cut in two: one + handling the divergent part near 0 using the default integrator + and the other taking care of the fast oscillations at angular + frequency :math:`\tau` using an appropriate integration scheme. + The cutoff point can be modified with ``num_oscillations``. This + isn't compatible with imaginary time computations. + - **num_oscillations** (*int, float, callable*) -- When + ``alt_integrator`` is ``True``, specifies how many oscillations to + keep for the non-weighted part of the integral of + :func:`eta_function`. This should be either an integer or specified + as a function of :math:`\tau`. To help choose: the higher this number + is, the more the default integrator will struggle to integrate the + non-weighted part. The lower it is, the more the weighted integrators + will struggle to integrate the near divergent part close to 0. A + constant value is a good choice for most use cases. Otherwise, it is + possible to input a function to target possible issues at specific + memory times :math:`\tau`. """ def __init__( @@ -417,11 +428,9 @@ def __init__( cutoff: float, cutoff_type: Optional[Text] = 'exponential', temperature: Optional[float] = 0.0, - alt_integrator: Optional[bool] = False, - num_oscillations: Optional[ - Union[int, float, Callable[[float], float]]] = None, name: Optional[Text] = None, - description: Optional[Text] = None) -> None: + description: Optional[Text] = None, + integration_params: Optional[Dict] = None) -> None: """Create a CustomFunctionSD (spectral density) object. """ # check input: j_function @@ -454,20 +463,29 @@ def __init__( raise ValueError("Temperature must be >= 0.0 (but is {})".format( tmp_temperature)) self.temperature = tmp_temperature + if integration_params is None: + integration_params = INTEGRATION_PARAMS + elif isinstance(integration_params, dict): + integration_params = INTEGRATION_PARAMS | integration_params + else: + raise AssertionError("integration_params should be "\ + "a dictionary") # input check for alt_integrator + alt_integrator = integration_params["alt_integrator"] + num_oscillations = integration_params["num_oscillations"] assert isinstance(alt_integrator, bool) + if alt_integrator is False and num_oscillations is not None: + warnings.warn("num_oscillations will be discarded since "\ + "alt_integrator is False", UserWarning) self._alt_integrator = alt_integrator - # create the first_cutoff function and input check for num_oscillations - if num_oscillations is None: - num_oscillations = 3 if isinstance(num_oscillations, (int, float)) and num_oscillations > 0: - tmp_n = num_oscillations # This form is a step version of the first cutoff which prevents # useless computations of _truncated_eta - self.first_cutoff = lambda t: 2*np.pi*tmp_n/(1+1/tmp_n)**np.floor( - np.log(t)/np.log(1+1/tmp_n)) + self.first_cutoff = lambda t: 2*np.pi*num_oscillations/(1 + +1/num_oscillations)**np.floor(np.log(t)/ + np.log(1+1/num_oscillations)) else: try: float(num_oscillations(1.0)) @@ -583,6 +601,56 @@ def integrand(w): integral = integral.real return integral + def _eta_function_alt(self, + tau: float, + integrand: Callable, + epsrel: float, + subdiv_limit: int) -> complex: + """Computes `eta_function` when `alt_integrator` is set to True.""" + im_integrand = lambda w: - self._spectral_density(w) / w ** 2 + if self.temperature == 0.0: + re_integrand = lambda w: self._spectral_density(w) / w ** 2 + else: + def re_integrand(w): + # this is to stop overflow + if np.exp(-w / self.temperature) > np.finfo(float).eps: + inte = self._spectral_density(w) / w ** 2 \ + * 1/np.tanh(w / (2*self.temperature)) + else: + inte = self._spectral_density(w) / w ** 2 + return inte + + omega_tilde = self.first_cutoff(tau) + + # compute tau independant parts of the full eta integral + re_constant, im_constant = self._truncated_eta(a=omega_tilde, + epsrel=epsrel, + limit=subdiv_limit) + # first cut of integral on [0, omega_tilde] (non-weighted integral) + integral = _complex_integral(integrand, + a=0.0, + b=omega_tilde, + epsrel=epsrel, + limit=subdiv_limit) + + # second cut of integral on [omega_tilde, omega_c] (weighted integral) + integral += _weighted_integral(re_integrand, im_integrand, + w=tau, + a=omega_tilde, + b=self.cutoff, + epsrel=epsrel, + limit=subdiv_limit) + + if self.cutoff_type != "hard": + # last cut of integral on [omega_c, infinity] (weighted integral) + integral += _weighted_integral(re_integrand, im_integrand, + w=tau, + a=self.cutoff, + b=np.inf, + epsrel=epsrel, + limit=subdiv_limit) + return - (integral + 1.j*tau*im_constant - re_constant) + @lru_cache(maxsize=2 ** 10, typed=False) def _truncated_eta(self, a: float, @@ -664,11 +732,12 @@ def eta_function( subdiv_limit: int Maximal number of interval subdivisions for numerical integration. alt_integrator: Union[bool, None] - Whether or not to use a sine/cosine weighted version of the - integrals that could be better suited if you're encountering - numerical difficulties, especially for long memory times. If the - value is `None`, the value of `alt_integrator` set during - initialization of the `CustomSD` object is used instead. + Whether to use an alternative integration scheme leveraging + sine/cosine weighted versions of scipy.integrate.quad to handle + rapid oscillations. See ``alt_integrator`` in :class:`CustomSD`. + If the value is ``None``, the value of ``alt_integrator`` set + during initialization of the :class:`CustomSD` object is used + instead. Returns ------- correlation : ndarray @@ -707,46 +776,10 @@ def integrand(w): # Alternative computation with weighted integrators if alt_integrator and tau*self.cutoff > 1.: - im_integrand = lambda w: - self._spectral_density(w) / w ** 2 - if self.temperature == 0.0: - re_integrand = lambda w: self._spectral_density(w) / w ** 2 - else: - def re_integrand(w): - # this is to stop overflow - if np.exp(-w / self.temperature) > np.finfo(float).eps: - inte = self._spectral_density(w) / w ** 2 \ - * 1/np.tanh(w / (2*self.temperature)) - else: - inte = self._spectral_density(w) / w ** 2 - return inte - - omega_tilde = self.first_cutoff(tau) - - integral = _complex_integral(integrand, - a=0.0, - b=omega_tilde, - epsrel=epsrel, - limit=subdiv_limit) - - integral += _weighted_integral(re_integrand, im_integrand, - w=tau, - a=omega_tilde, - b=self.cutoff, - epsrel=epsrel, - limit=subdiv_limit) - - if self.cutoff_type != "hard": - integral += _weighted_integral(re_integrand, im_integrand, - w=tau, - a=self.cutoff, - b=np.inf, - epsrel=epsrel, - limit=subdiv_limit) - - re_constant, im_constant = self._truncated_eta(a=omega_tilde, - epsrel=epsrel, - limit=subdiv_limit) - return - (integral + 1.j*tau*im_constant - re_constant) + return self._eta_function_alt(tau=tau, + integrand=integrand, + epsrel=epsrel, + subdiv_limit=subdiv_limit) # Default computation of eta_function when alt_integrator is False integral = _complex_integral(integrand, @@ -882,25 +915,9 @@ class PowerLawSD(CustomSD): ``'gaussian'``} temperature: float The environment's temperature. - alt_integrator: bool - Whether or not to use a sine/cosine weighted version of the - integrals that could be better suited if you're encountering - numerical difficulties, especially for long memory times. - The integral computed in `eta_function` is cut in two: one - handling the divergent part near 0 using the default integrator - and the other taking care of the fast oscillations at angular - frequency :math:`\tau` using an appropriate integration scheme. - The cutoff point can be modified with `num_oscillations`. - num_oscillations: int, float, callable - When using `alt_integrator`, specifies how many oscillations to keep - for the non-weighted part of the integral of `eta_function`. This should - be either an integer or specified as a function of :math:`\tau`. To help - choose: the higher this number is, the more the default integrator will - struggle to integrate the non-weighted part. The lower it is, the more - the weighted integrators will struggle to integrate the near divergent - part close to 0. A constant value is a good choice for most use cases. - Otherwise, it is possible to input a function to target possible issues - at specific memory times :math:`\tau`. + integration_params: dict + Optional dictionary to pass integration parameters. See + ``integration_params`` in :class:`CustomSD`. name: str An optional name for the correlations. description: str @@ -914,9 +931,7 @@ def __init__( cutoff: float, cutoff_type: Text = 'exponential', temperature: Optional[float] = 0.0, - alt_integrator: Optional[bool] = False, - num_oscillations: Optional[ - Union[int, float, Callable[[float], float]]] = None, + integration_params: Optional[Dict] = None, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Create a StandardSD (spectral density) object. """ @@ -950,7 +965,7 @@ def __init__( cutoff=cutoff, cutoff_type=cutoff_type, temperature=temperature, - alt_integrator=alt_integrator, + integration_params=integration_params, name=name, description=description) diff --git a/oqupy/config.py b/oqupy/config.py index 592dfa7b..7e38544b 100644 --- a/oqupy/config.py +++ b/oqupy/config.py @@ -73,3 +73,11 @@ # default tolerance for degeneracy checking (how many decimals to round to) DEFAULT_TOLERANCE_DEGENERACY = 12 + + +# -- BATH_CORRELATIONS ------------------------------------------------------- + +INTEGRATION_PARAMS = {"epsrel": INTEGRATE_EPSREL, + "subdiv_limit": SUBDIV_LIMIT, + "alt_integrator": False, + "num_oscillations": 3} diff --git a/tests/coverage/correlations_test.py b/tests/coverage/correlations_test.py index 01fa1e44..24bea368 100644 --- a/tests/coverage/correlations_test.py +++ b/tests/coverage/correlations_test.py @@ -158,7 +158,7 @@ def test_matsubara_custom_s_d_bad_input(): delta=0.1, shape=shape, matsubara=True) - correlations = CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", temperature=1.0, alt_integrator=True) + correlations = CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", temperature=1.0, integration_params={"alt_integrator": True}) with pytest.raises(ValueError): correlations.correlation_2d_integral(time_1=2, delta=0.1, shape='upper-triangle', matsubara=True, alt_integrator=True) @@ -178,13 +178,17 @@ def test_custom_s_d_bad_input(): temperature="bla") with pytest.raises(AssertionError): CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ - temperature=0.0, alt_integrator="bla") + temperature=0.0, integration_params={"alt_integrator": "bla"}) with pytest.raises(AssertionError): CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ - temperature=0.0, num_oscillations=-1.0) + temperature=0.0, integration_params={"num_oscillations": -1.0}) with pytest.raises(AssertionError): CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ - temperature=0.0, num_oscillations=lambda t: "a") + temperature=0.0, integration_params={"num_oscillations": + lambda t: "a"}) + with pytest.raises(AssertionError): + CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ + temperature=0.0, integration_params=5) with pytest.raises(ValueError): CustomSD(square_function, cutoff=2.0, cutoff_type="hard", \ temperature=-2.0) @@ -202,7 +206,7 @@ def test_power_law_s_d(): y = sd.spectral_density(w) t = np.linspace(0, 4.0 / sd.cutoff, 10) [sd.correlation(tt) for tt in t] - [sd.correlation(tt) for tt in t] + [sd.eta_function(tt) for tt in t] for shape in ["square", "upper-triangle"]: sd.correlation_2d_integral(time_1=0.25, delta=0.05, diff --git a/tests/physics/bath_correlations_test.py b/tests/physics/bath_correlations_test.py index 12f07df4..fca2535d 100644 --- a/tests/physics/bath_correlations_test.py +++ b/tests/physics/bath_correlations_test.py @@ -64,7 +64,7 @@ def test(): cutoff=omega_cutoff, cutoff_type="exponential", temperature=temperature, - alt_integrator=alt_integrator) + integration_params={"alt_integrator": alt_integrator}) with warnings.catch_warnings(): warnings.simplefilter(action="error", category=IntegrationWarning) From 9651b5e4b0c2f9a14e1b7becc739648a34147198 Mon Sep 17 00:00:00 2001 From: "Gerald E. Fux" Date: Mon, 15 Jun 2026 01:26:21 +0200 Subject: [PATCH 4/6] Simplify eta_function integral computation using weighted quadrature * untangle matsubara computation from default eta_function computation * simplify the weighted quadrature parameter to just a single float * rearrange the eta_function integrals for readability and maintainability --- docs/pages/tutorials/parameters.rst | 17 - docs/pages/tutorials/parameters.rst~ | 853 ------------------------ oqupy/bath_correlations.py | 406 +++++------ oqupy/config.py | 8 +- tests/coverage/correlations_test.py | 21 +- tests/physics/bath_correlations_test.py | 63 +- tests/physics/tempo_spin_boson_test.py | 4 + 7 files changed, 215 insertions(+), 1157 deletions(-) delete mode 100644 docs/pages/tutorials/parameters.rst~ diff --git a/docs/pages/tutorials/parameters.rst b/docs/pages/tutorials/parameters.rst index 23b8b0c9..723bea8b 100644 --- a/docs/pages/tutorials/parameters.rst +++ b/docs/pages/tutorials/parameters.rst @@ -321,23 +321,6 @@ computation time over a timescale ``end_time-start_time``, so make sure to set these to reflect those you actually intend to use in calculations. -Long memory lengths -~~~~~~~~~~~~~~~~~~~ - -When defining the bath parameters with a spectral density (for example with a ``CustomSD`` or ``PowerLawSD``), large values of ``tcut`` can lead to numerical instabilities in the computation of the influence matrix. Indeed, the coefficients of the influence matrix are computed through discrete time differences of the ``eta_function`` given by: - -.. math:: - \eta(\tau) = \int_0^{\infty} \frac{J(\omega)}{\omega^2} \ - \left[ ( \cos(\omega \tau) - 1 ) \ - \coth\left( \frac{\omega}{2 T}\right) \ - - i ( \sin(\omega \tau) - \omega \tau ) \right] \ - \mathrm{d}\omega. - -with memory-time ``tau`` :math:`\tau`. ``tcut`` is the highest value used for ``tau`` in this expression. Thus, high memory lengths lead to highly oscillating terms in this integral due to the :math:`\cos(\tau\omega)` and :math:`\sin(\tau\omega)` terms. The default integrator used for this integral can struggle to give converged results in these cases. However, it is possible to specify whether to use a weighted integrator instead which is better suited for these oscillatory behaviours with ``alt_integrator`` in ``CustomSD`` (or any of its subclasses). - -In more detail, this keyword changes the computation by splitting the integral in two: it uses the default integrator for the divergent part near 0 and the weighted sine or cosine versions of ``scipy.integrate.quad`` after. By default, the point where the integral is split is chosen automatically by setting a maximum number of oscillations for the first integral. It is possible to change the default number of oscillations through the ``num_oscillations`` parameter. It either takes an integer, float or a function of ``tau`` which should return the maxium number of oscillations for each ``tau``. The results are often quite accurate with the default values, but rough guidelines for modifying it are to decrease the number of oscillations if the integrator struggles with the first integral (too oscillatory for the default integrator), and increase it if it struggles with the second integral (too divergent for the cos/sin weighted versions). - - ---------------------- Choosing dt and epsrel diff --git a/docs/pages/tutorials/parameters.rst~ b/docs/pages/tutorials/parameters.rst~ deleted file mode 100644 index 3d0be0f1..00000000 --- a/docs/pages/tutorials/parameters.rst~ +++ /dev/null @@ -1,853 +0,0 @@ -Computational parameters and convergence -======================================== - -Discussion of the computational parameters in a TEMPO or PT-TEMPO -computation and establishing convergence of results - -- `launch - binder `__ - (runs in browser), -- `download the jupyter - file `__, - or -- read through the text below and code along. - --------- -Contents --------- - -- `Introduction - numerical exactness and computational parameters`_ -- `Choosing tcut`_ - - * `Example - memory effects in a spin boson model`_ - * `Discussion - environment correlations`_ -- `Choosing dt and epsrel`_ - - * `Example - convergence for a spin boson model`_ - * `Resolving fast system dynamics`_ -- `Further considerations`_ - - * `Additional TempoParameters arguments`_ - * `Bath coupling degeneracies`_ - * `Mean-field systems`_ -- `PT-TEMPO`_ - - * `The dkmax anomaly`_ - -The following packages will be required - -.. code:: ipython3 - - import sys - sys.path.insert(0,'..') - - import oqupy - import numpy as np - import matplotlib.pyplot as plt - plt.rcParams.update({'font.size': 14.0, 'lines.linewidth':2.50, 'figure.figsize':(8,6)}) - -The OQuPy version should be ``>=0.5.0`` - -.. code:: ipython3 - - oqupy.__version__ - - - - -.. parsed-literal:: - - '0.5.0' - - ---------------------------------------------------------------- -Introduction - numerical exactness and computational parameters ---------------------------------------------------------------- - -The TEMPO and PT-TEMPO methods are numerically exact meaning no -approximations are required in their derivation. Instead error only -arises in their numerical implementation, and is controlled by a set of -computational parameters. The error can, in principle (at least up to -machine precision), be made as small as desired by tuning those -numerical parameters. In this tutorial we discuss how this is done to -derive accurate results with manageable computational costs. - -As introduced in the -`Quickstart `__ -tutorial a TEMPO or PT-TEMPO calculation has three main computational -parameters: - -1. A memory cut-off ``tcut``, which must be long enough to capture - non-Markovian effects of the environment -2. A timestep length ``dt``, which must be short enough to avoid Trotter - error and provide a sufficient resolution of the system dynamics -3. A precision ``epsrel``, which must be small enough such that the - numerical compression (singular value truncation) does not incur - physical error - -In order to verify the accuracy of a calculation, convergence should be -established under all three parameters, under increases of ``tcut`` and -decreases ``dt`` and ``epsrel``. The challenge is that these parameters -cannot necessarily be considered in isolation, and a balance must be -struck between accuracy and computational cost. The strategy we take is -to firstly determine a suitable ``tcut`` (set physically by properties -of the environment) with rough values of ``dt`` and ``epsrel``, then -determine convergence under ``dt->0,epsrel->0``. - -We illustrate convergence using the TEMPO method, but the ideas -discussed will also generally apply to a PT-TEMPO computation where one -first calculates a process tensor - fixing ``tcut``, ``dt``, ``epsrel`` -- before calculating the system dynamics (see `PT-TEMPO <#PT-TEMPO>`__). -Note some of the calculations in this tutorial may not be suitable to -run in a Binder instance. If you want to run them on your own device, -you can either copy the code as you go along or `download the .ipynb -file `__ -to run in a local jupyter notebook session. Example results for all -calculations are embedded in the notebook already, so this is not -strictly required. - -------------- -Choosing tcut -------------- - -Example - memory effects in a spin boson model ----------------------------------------------- - -We firstly define a spin-boson model similar to that in the Quickstart -tutorial, but with a finite temperature environment and a small -additional incoherent dissipation of the spin. - -.. code:: ipython3 - - sigma_x = oqupy.operators.sigma('x') - sigma_y = oqupy.operators.sigma('y') - sigma_z = oqupy.operators.sigma('z') - sigma_m = oqupy.operators.sigma('-') - - omega_cutoff = 2.5 - alpha = 0.8 - T = 0.2 - correlations = oqupy.PowerLawSD(alpha=alpha, - zeta=1, - cutoff=omega_cutoff, - cutoff_type='exponential', - temperature=T) - bath = oqupy.Bath(0.5 * sigma_z, correlations) - Omega = 2.0 - Gamma = 0.02 - system = oqupy.System(0.5 * Omega * sigma_x, - gammas=[Gamma], - lindblad_operators=[sigma_m], # incoherent dissipation - ) - - t_start = 0.0 - t_end = 5.0 - -To determine a suitable set of computational parameters for -``t_start<=t<=t_end``, a good place to start is with a call to the -``guess_tempo_parameters`` function: - -.. code:: ipython3 - - guessed_paramsA = oqupy.guess_tempo_parameters(bath=bath, - start_time=t_start, - end_time=t_end, - tolerance=0.01) - print(guessed_paramsA) - - -.. parsed-literal:: - - ../oqupy/tempo.py:865: UserWarning: Estimating TEMPO parameters. No guarantee subsequent dynamics calculations are converged. Please refer to the TEMPO documentation and check convergence by varying the parameters manually. - warnings.warn(GUESS_WARNING_MSG, UserWarning) - - -.. parsed-literal:: - - ---------------------------------------------- - TempoParameters object: Roughly estimated parameters - Estimated with 'guess_tempo_parameters()' based on bath correlations. - dt = 0.125 - tcut [dkmax] = 2.5 [20] - epsrel = 6.903e-05 - add_correlation_time = None - - - -As indicated in the description of this object, the parameters were -estimated by analysing the correlations of ``bath``, which are discussed -further below. - -From the suggested parameters, we focus on ``tcut`` first, assuming the -values of ``dt`` and ``epsrel`` are reasonable to work with. To do so we -compare results at the recommend ``tcut`` to those calculated at a -smaller (``1.25``) and larger (``5.0``) values of this parameter, -starting from the spin-up state: - -.. code:: ipython3 - - initial_state = oqupy.operators.spin_dm('z+') - - for tcut in [1.25,2.5,5.0]: - # Create TempoParameters object matching those guessed above, except possibly for tcut - params = oqupy.TempoParameters(dt=0.125, epsrel=6.9e-06, tcut=tcut) - dynamics = oqupy.tempo_compute(system=system, - bath=bath, - initial_state=initial_state, - start_time=t_start, - end_time=t_end, - parameters=params) - t, s_z = dynamics.expectations(sigma_z, real=True) - plt.plot(t, s_z, label=r'${}$'.format(tcut)) - plt.xlabel(r'$t$') - plt.ylabel(r'$\langle\sigma_z\rangle$') - plt.legend(title=r'$t_{cut}$') - - -.. parsed-literal:: - - --> TEMPO computation: - 100.0% 40 of 40 [########################################] 00:00:00 - Elapsed time: 0.8s - --> TEMPO computation: - 100.0% 40 of 40 [########################################] 00:00:01 - Elapsed time: 1.6s - --> TEMPO computation: - 100.0% 40 of 40 [########################################] 00:00:01 - Elapsed time: 1.9s - - - - -.. parsed-literal:: - - - - - - -.. image:: parameters_files/parameters_12_2.png - - -We see that ``tcut=2.5`` (orange) does very well, matching ``tcut=5.0`` -(green) until essentially the end of the simulation (the precision -``epsrel`` could well be causing the small discrepancy). We know -``tcut=5.0`` should capture the actual result, because -``tcut=5.0=t_end`` means no memory cutoff was made! In general it is not -always necessary to make a finite memory approximation. For example, -perhaps one is interested in short-time dynamics only. The memory cutoff -can be disable by setting ``tcut=None``; be aware computation to long -times (i.e. many hundreds of timesteps) may then be infeasible. - -The ``tcut=1.25`` result matches the other two exactly until ``t=1.25`` -(no memory approximation is made before this time), but deviates shorlty -after. On the other hand, the cost of using the larger ``tcut=2.5`` was -a longer computation: 1.6s vs 0.8s above. This was a trivial example, -but in many real calculations the runtimes will be far longer -e.g. minutes or hours. It may be that an intermediary value -``1.25<=tcut<=2.5`` provides a satisfactory approximation - depending on -the desired precision - with a more favourable cost: a TEMPO (or -PT-TEMPO) computation scales **linearly** with the number of steps -included in the memory cutoff. - -A word of warning -~~~~~~~~~~~~~~~~~ - -``guess_tempo_parameters`` provides a reasonable starting point for many -cases, but it is only a guess. You should always verify results using a -larger ``tcut``, whilst also not discounting smaller ``tcut`` to reduce -the computational requirements. Similar will apply to checking -convergence under ``dt`` and ``epsrel``. - -Also, note we only inspected the expectations -:math:`\langle \sigma_z \rangle`. To be most thorough all unique -components of the state matrix should be checked, or at least the -expectations of observables you are intending to study. So, if you were -interested in the coherences as well as the populations, you would want -to add calls to calculate :math:`\langle \sigma_x \rangle`, -:math:`\langle \sigma_y \rangle` above (you can check ``tcut=2.5`` is -still good for the above example). - -Discussion - environment correlations -------------------------------------- - -So what influences the required ``tcut``? The physically relevant -timescale is that for the decay of correlations in the environment. -These can be inspected using -``oqupy.helpers.plot_correlations_with_parameters``: - -.. code:: ipython3 - - fig, ax = plt.subplots() - params = oqupy.TempoParameters(dt=0.125, epsrel=1, tcut=2.5) # N.B. epsrel not used by helper, and tcut only to set plot t-limits - oqupy.helpers.plot_correlations_with_parameters(bath.correlations, params, ax=ax) - - - - -.. parsed-literal:: - - - - - - -.. image:: parameters_files/parameters_15_1.png - - -This shows the real and imaginary parts of the bath autocorrelation -function, with markers indicating samples of spacing ``dt``. We see that -correlations have not fully decayed by ``t=1.25``, but have - at least -by eye - by ``t=2.5``. It seems like ``tcut`` around this value would -indeed be a good choice. - -The autocorrelation function depends on the properties of the bath: the -form the spectral density, the cutoff, and the temperature. These are -accounted for by the ``guess_tempo_parameters`` function, which is -really analysing the error in performing integrals of this function. The -``tolerance`` parameter specifies the maximum absolute error permitted, -with an inbuilt default value of ``3.9e-3`` - passing ``tolerance=0.01`` -made for slightly ‘easier’ parameters. - -Note, however, what is observed in the *system dynamics* also depends -the bath coupling operator and strength (``alpha``), and that these are -*not* taken into account by the guessing function. More generally, the -nature of the intrinsic system dynamics (see below) and initial state -preparation also has to be considered. - -Finally, the guessing function uses specified ``start_time`` and -``end_time`` to come up with parameters providing a manageable -computation time over a timescale ``end_time-start_time``, so make sure -to set these to reflect those you actually intend to use in -calculations. - ----------------------- -Choosing dt and epsrel ----------------------- - -Example - convergence for a spin boson model --------------------------------------------- - -Continuing with the previous example, we now investigate changing ``dt`` -at our chosen ``tcut=2.5``. - -.. code:: ipython3 - - plt.figure(figsize=(10,8)) - for dt in [0.0625, 0.125, 0.25]: - params = oqupy.TempoParameters(dt=dt, epsrel=6.9e-05, tcut=2.5) - dynamics = oqupy.tempo_compute(system=system, - bath=bath, - initial_state=initial_state, - start_time=t_start, - end_time=t_end, - parameters=params) - t, s_z = dynamics.expectations(sigma_z, real=True) - plt.plot(t, s_z, label=r'${}$'.format(dt)) - plt.xlabel(r'$t$') - plt.ylabel(r'$\langle\sigma_z\rangle$') - plt.legend(title=r'$dt$') - - -.. parsed-literal:: - - --> TEMPO computation: - 100.0% 80 of 80 [########################################] 00:00:03 - Elapsed time: 3.0s - --> TEMPO computation: - 100.0% 40 of 40 [########################################] 00:00:00 - Elapsed time: 0.9s - --> TEMPO computation: - 100.0% 20 of 20 [########################################] 00:00:00 - Elapsed time: 0.3s - - - - -.. parsed-literal:: - - - - - - -.. image:: parameters_files/parameters_18_2.png - - -That doesn’t look good! If we had just checked ``dt=0.25`` and -``dt=0.125`` we may have been happy with the convergence, but a halving -of the timestep gave very different results (you can check ``dt=0.0625`` -is even worse). - -The catch here is that we used the same precision ``epsrel=6.9e-05`` for -all runs, but ``dt=0.125`` requires a smaller ``epsrel``: halving the -timestep *doubles* the number of steps ``dkmax`` for which singular -value truncations are made in the bath’s memory ``tcut=dt*dkmax``. - -Let’s repeat the calculation with a smaller ``epsrel`` at ``dt=0.125``: - -.. code:: ipython3 - - for dt, epsrel in zip([0.0625,0.125, 0.25],[6.9e-06,6.9e-05,6.9e-05]): - params = oqupy.TempoParameters(dt=dt, epsrel=epsrel, tcut=2.5) - dynamics = oqupy.tempo_compute(system=system, - bath=bath, - initial_state=initial_state, - start_time=t_start, - end_time=t_end, - parameters=params) - t, s_z = dynamics.expectations(sigma_z, real=True) - plt.plot(t, s_z, label=r'${}$, ${:.2g}$'.format(dt,epsrel)) - plt.xlabel(r'$t$') - plt.ylabel(r'$\langle\sigma_z\rangle$') - plt.legend(title=r'$dt, \epsilon_{rel}$') - - -.. parsed-literal:: - - --> TEMPO computation: - 100.0% 80 of 80 [########################################] 00:00:04 - Elapsed time: 5.0s - --> TEMPO computation: - 100.0% 40 of 40 [########################################] 00:00:00 - Elapsed time: 0.9s - --> TEMPO computation: - 100.0% 20 of 20 [########################################] 00:00:00 - Elapsed time: 0.2s - - - - -.. parsed-literal:: - - - - - - -.. image:: parameters_files/parameters_20_2.png - - -That looks far better. The lesson here is that one cannot expect to be -able to decrease ``dt`` at fixed ``tcut`` without also decreasing -``epsrel``. A heuristic used by ``guess_tempo_parameters``, which you -may find useful, is - -.. math:: \epsilon_{\text{r}} = \text{tol} \cdot 10^{-p},\ p=\log_4 (\text{dkmax}), - -where tol is a target tolerance (e.g. ``tolerance=0.01`` above) and -``dkmax`` the number of steps such that ``tcut=dt*dkmax``. - -Note ``TempoParameters`` allows the memory cutoff to be specified as the -integer ``dkmax`` rather than float ``tcut``, meaning this estimation of -``epsrel`` doesn’t change with ``dt``. However, the author prefers -working at a constant ``tcut`` which is set physically by the decay of -correlations in the environment; then one only has to worry about the -simultaneous convergence of ``dt`` and ``epsrel``. - -Comparing the simulation times at ``dt=0.0625`` between the previous two -sets of results, we see the cost of a smaller ``epsrel`` is a longer -computation (5 vs. 3 seconds). The time complexity of the singular value -decompositions in the TEMPO tensor network scales with the **third -power** of the internal bond dimension, which is directly controlled by -the precision, so be aware that decreasing ``epsrel`` may lead to rapid -increase in computation times. - -The last results suggest that we may well already have convergence w.r.t -``epsrel`` at ``dt=0.125``. This should be checked: - -.. code:: ipython3 - - for epsrel in [6.9e-06,6.9e-05,6.9e-04]: - params = oqupy.TempoParameters(dt=dt, epsrel=epsrel, tcut=2.5) - dynamics = oqupy.tempo_compute(system=system, - bath=bath, - initial_state=initial_state, - start_time=t_start, - end_time=t_end, - parameters=params) - t, s_z = dynamics.expectations(sigma_z, real=True) - plt.plot(t, s_z, label=r'${:.2g}$'.format(epsrel)) - plt.xlabel(r'$t$') - plt.ylabel(r'$\langle\sigma_z\rangle$') - plt.legend(title=r'$\epsilon_{rel}$') - - -.. parsed-literal:: - - --> TEMPO computation: - 100.0% 20 of 20 [########################################] 00:00:00 - Elapsed time: 0.3s - --> TEMPO computation: - 100.0% 20 of 20 [########################################] 00:00:00 - Elapsed time: 0.2s - --> TEMPO computation: - 100.0% 20 of 20 [########################################] 00:00:00 - Elapsed time: 0.2s - - - - -.. parsed-literal:: - - - - - - -.. image:: parameters_files/parameters_22_2.png - - -In summary, we may well be happy with the parameters ``dt=0.125``, -``epsrel=6.9e-05``, ``tcut=2.5`` for this model (we could probably use a -larger ``epsrel``, but the computation is so inexpensive in this example -it is hardly necessary). - -So far we have discussed mainly how the environment - namely the memory -length - dictates the parameters. We now look at what influence the -system can have. - -Resolving fast system dynamics ------------------------------- - -In the above you may have noticed that the results at ``dt=0.125``, -while converged, were slightly undersampled. This becomes more -noticeable if the scale of the system energies is increased (here by a -factor of 4): - -.. code:: ipython3 - - Omega = 8.0 # From 2.0 - Gamma = 0.08 # From 0.02 - system = oqupy.System(0.5 * Omega * sigma_x, - gammas=[Gamma], - lindblad_operators=[sigma_m]) - params = oqupy.guess_tempo_parameters(bath=bath, - start_time=t_start, - end_time=t_end, - tolerance=0.01) - print(params) - dynamics = oqupy.tempo_compute(system=system, - bath=bath, - initial_state=initial_state, - start_time=t_start, - end_time=t_end, - parameters=params) - t, s_z = dynamics.expectations(sigma_z, real=True) - plt.plot(t, s_z) - plt.xlabel(r'$t$') - plt.ylabel(r'$\langle\sigma_z\rangle$') - plt.show() - - -.. parsed-literal:: - - ../oqupy/tempo.py:865: UserWarning: Estimating TEMPO parameters. No guarantee subsequent dynamics calculations are converged. Please refer to the TEMPO documentation and check convergence by varying the parameters manually. - warnings.warn(GUESS_WARNING_MSG, UserWarning) - - -.. parsed-literal:: - - ---------------------------------------------- - TempoParameters object: Roughly estimated parameters - Estimated with 'guess_tempo_parameters()' based on bath correlations. - dt = 0.125 - tcut [dkmax] = 2.5 [20] - epsrel = 6.903e-05 - add_correlation_time = None - - --> TEMPO computation: - 100.0% 40 of 40 [########################################] 00:00:03 - Elapsed time: 3.5s - - - -.. image:: parameters_files/parameters_26_2.png - - -The call to ``guess_tempo_parameters`` returned the same set -``dt=0.125``, ``epsrel=6.9e-05``, ``tcut=2.5`` as before, because it did -not use any information of the system. We can change this, and hopefully -resolve the system dynamics on a more appropriate grid, by providing the -system as an optional argument: - -[Warning: long computation] - -.. code:: ipython3 - - Omega = 8.0 # From 2.0 - Gamma = 0.08 # From 0.02 - system = oqupy.System(0.5 * Omega * sigma_x, - gammas=[Gamma], - lindblad_operators=[sigma_m]) - params = oqupy.guess_tempo_parameters(system=system, # new system argument (optional) - bath=bath, - start_time=t_start, - end_time=t_end, - tolerance=0.01) - print(params) - dynamics = oqupy.tempo_compute(system=system, - bath=bath, - initial_state=initial_state, - start_time=t_start, - end_time=t_end, - parameters=params) - t, s_z = dynamics.expectations(sigma_z, real=True) - plt.plot(t, s_z) - plt.xlabel(r'$t$') - plt.ylabel(r'$\langle\sigma_z\rangle$') - - -.. parsed-literal:: - - ../oqupy/tempo.py:865: UserWarning: Estimating TEMPO parameters. No guarantee subsequent dynamics calculations are converged. Please refer to the TEMPO documentation and check convergence by varying the parameters manually. - warnings.warn(GUESS_WARNING_MSG, UserWarning) - - -.. parsed-literal:: - - ---------------------------------------------- - TempoParameters object: Roughly estimated parameters - Estimated with 'guess_tempo_parameters()' based on bath correlations and system frequencies (limiting). - dt = 0.03125 - tcut [dkmax] = 2.5 [80] - epsrel = 6.903e-06 - add_correlation_time = None - - --> TEMPO computation: - 100.0% 160 of 160 [########################################] 00:01:09 - Elapsed time: 69.5s - - - - -.. parsed-literal:: - - Text(0, 0.5, '$\\langle\\sigma_z\\rangle$') - - - - -.. image:: parameters_files/parameters_28_3.png - - -As both ``dkmax`` increased and ``epsrel`` decreased to accommodate the -smaller ``dt=0.03125``, the computation took far longer - over a minute -compared to a few seconds at ``dt=0.125`` (it may now be worth -investigating whether a larger ``epsrel`` can be used). - -With a ``system`` argument, ``guess_tempo_parameters`` uses the matrix -norm of the system Hamiltonian and any Lindblad operators/rates to -estimate a suitable timestep on which to resolve the system dynamics. -This is compared to the ``dt`` required to meet the tolerance on error -for the bath correlations, and the smaller of the two is returned. The -description of the ``TempoParameters`` object indicates which part was -‘limiting’ i.e. required the smaller ``dt``. - -Often it is not necessary to calculate the system dynamics on such a -fine grid. For example, if one only needs to calculate the steady-state -polarisation. Moreover, the undersampling is easy to spot and adjust by -eye. Hence you may choose to not pass a ``system`` object to -``guess_tempo_parameters``. However, note there are cases where not -accounting for system frequencies can lead to more physical features -being missed, namely when the Hamiltonian or Lindblad operators/rates -are (rapidly) *time-dependent.* - -What sets dt, really? -~~~~~~~~~~~~~~~~~~~~~ - -The main error associated with ``dt`` is that from the Trotter splitting -of the system propagators. In a simple (non-symmetrised) splitting, a -basic requirement is - -.. math:: [H_S(t) , H_E] dt \ll \left(H_S(t)+H_E\right) dt^2. - -In words: error arises from non-commutation between the system and bath -coupling operator. This simply reflects the fact that in the -discretisation of the path integral the splitting is made between the -system and environment Hamiltonians. In cases where :math:`H_S` commutes -with :math:`H_E`, such as the independent boson model, :math:`dt` can be -arbitrarily large without physical error. - -Note ``guess_tempo_parameters`` does *not* attempt to estimate the -Trotter error, even when both ``system`` and ``bath`` objects are -specified - another reason to be cautious when using the estimate -produced by this function. - ----------------------- -Further considerations ----------------------- - -Additional TempoParameters arguments ------------------------------------- - -For completeness, there are a few other parameters that can be passed to -the ``TempoParameters`` constructor: - ``subdiv_limit`` and -``liouvillian_epsrel``. These control the maximum number of subdivisions -and relative error tolerance when integrating a time-dependent system -Liouvillian to construct the system propagators. It is unlikely you will -need to change them from their default values (``265``, ``2**(-26)``) - -``add_correlation_time``. This allows one to include correlations -*beyond* ``tcut`` in the final bath tensor at ``dkmax`` (i.e., have your -finite memory cutoff cake and eat it). Doing so may provide better -approximations in cases where ``tcut`` is limited due to computational -difficultly. See -`[Strathearn2017] `__ for -details. - -Bath coupling degeneracies --------------------------- - -The bath tensors in the TEMPO network are nominally -:math:`d^2\times d^2` matrices, where :math:`d` is the system Hilbert -space dimension. If there are degeneracies in the sums or differences of -the eigenvalues of the system operator coupling to the environment, it -is possible for the dimension of these tensors to be reduced. - -Specifying ``unique=True`` as an argument to ``oqupy.tempo_compute``, -degeneracy checking is enabled: if a dimensional reduction of the bath -tensors is possible, the lower dimensional tensors will be used. We -expect this to provide in many cases a significant speed-up without any -significant loss of accuracy, although this has not been extensively -tested (new in ``v0.5.0``). - -Mean-field systems ------------------- - -For calculating mean-field dynamics, there is an additional requirement -on ``dt`` being small enough so not as to introduce error when -integrating the field equation of motion between timesteps (2nd order -Runge-Kutta). Common experience is that this is generally satisfied if -``dt`` is sufficiently small to avoid Trotter error. Still, you will -want to at least inspect the field dynamics in addition to the system -observables when checking convergence. - -Note that, for the purposes of estimating the characteristic frequency -of a ``SystemWithField`` object, ``guess_tempo_parameters`` uses an -arbitrary complex value :math:`\exp(i \pi/4)` for the field variable -when evaluating the system Hamiltonian. This may give a poor estimation -for situations where the field variable is not of order :math:`1` in the -dynamics. - --------- -PT-TEMPO --------- - -The above considerations for ``tcut``, ``dt`` and ``epsrel`` all apply -to a PT-TEMPO computation, with the following caveats: - -1. Convergence for a TEMPO computation does not necessarily imply - convergence for a PT-TEMPO computation. This is important as it is - often convenient to perform several one-off TEMPO computations to - determine a good set of computational parameters to save having to - construct many large process tensors. You can still take this - approach, but must be sure to check for convergence in the PT-TEMPO - computation when you have derived a reasonable set. -2. Similar to 1., the best possible accuracy of a TEMPO and PT-TEMPO - computation may be different. In particular, there may be a trade-off - of accuracy for overall reduced computation time when using the PT - approach. We note that the error in PT-TEMPO has also been observed - (`[FowlerWright2022] `__) - to become unstable at very high precisions (small ``epsrel``), i.e., - there may be a higher floor for how small you can make ``epsrel``. -3. The computational difficultly of constructing the PT may not be - monotonic with memory cutoff ``dkmax`` (or ``tcut``). In particular, - the computational time may diverge *below* a certain ``dkmax``, - a.k.a, the ‘dkmax anomaly’. We highlight this counter-intuitive - behaviour, which seems to occur at relatively high precisions (small - ``epsrel``) with short timesteps, because it may lead one to falsely - believe the computation of a process tensor is not feasible. See - below for a demonstration and the Supplementary Material of - `[FowlerWright2022] `__ - for further discussion. - -The dkmax anomaly ------------------ - -We consider constructing a process tensor of 250 timesteps for the -harmonic environment discussed in the `Mean-Field -Dynamics `__ -tutorial, but with a smaller timestep ``dt=1e-3`` ps and ``epsrel=1e-8`` -than considered there. Note that the following computations are very -demanding. - -.. code:: ipython3 - - alpha = 0.25 # Doesn't affect PT computation - nu_c = 227.9 - T = 39.3 - start_time = 0.0 - - dt = 1e-3 - epsrel = 1e-8 - end_time = 250 * dt # 251 steps starting from t=0.0 - - correlations = oqupy.PowerLawSD(alpha=alpha, - zeta=1, - cutoff=nu_c, - cutoff_type='gaussian') - bath = oqupy.Bath(oqupy.operators.sigma("z")/2.0, correlations) - -We firstly set ``dkmax=250`` (or ``None``), i.e., make no memory -approximation: - -.. code:: ipython3 - - params = oqupy.TempoParameters(dt=dt, - epsrel=epsrel, - dkmax=250) - - process_tensor = oqupy.pt_tempo_compute(bath=bath, - start_time=start_time, - end_time=end_time, - parameters=params) - - -.. parsed-literal:: - - --> PT-TEMPO computation: - 100.0% 250 of 250 [########################################] 00:01:37 - Elapsed time: 97.3s - - -Including the full memory didn’t take too long, just over one and a half -minutes on a modern desktop (AMD 6-Core processor @4.7GHz, python3.6). - -What about if we now make a memory approximation, say only after -``dkmax=225`` timesteps: - -.. code:: ipython3 - - params = oqupy.TempoParameters(dt=dt, - epsrel=epsrel, - dkmax=225) - - process_tensor = oqupy.pt_tempo_compute(bath=bath, - start_time=start_time, - end_time=end_time, - parameters=params) - - -.. parsed-literal:: - - --> PT-TEMPO computation: - 100.0% 250 of 250 [########################################] 00:08:04 - Elapsed time: 484.6s - - -That was far slower (8 mins)! You can try ``dkmax=200`` - on my hardware -the computation took half an hour; it may not be possible to complete -the calculation ``dkmax`` much below this. - -In general, there may exist some ``dkmax`` value (here close to 250) -below which the computational time grows quickly. On the other hand, for -longer computations, e.g. a 500 step process tensor, increases of -``dkmax`` will eventually lead to increasing compute times again, -although the dynamics will surely be converged with respect to this -parameter well before then. - -The take-home message is to not discount that a stalling PT computation -may in fact be possible with an increase in the memory length. In these -situations one approach is to start with ``dkmax=None`` and work -backwards to find the ``dkmax`` offering the minimum compute time -(before the rapid increase). diff --git a/oqupy/bath_correlations.py b/oqupy/bath_correlations.py index 13c35748..8985717a 100644 --- a/oqupy/bath_correlations.py +++ b/oqupy/bath_correlations.py @@ -13,19 +13,19 @@ Module for environment correlations. """ -from typing import Callable, Optional, Union, Text, Dict +from typing import Callable, Optional, Text, Dict from typing import Any as ArrayLike from functools import lru_cache -import warnings import numpy as np from scipy import integrate from oqupy.base_api import BaseAPIClass -from oqupy.config import INTEGRATE_EPSREL, SUBDIV_LIMIT, INTEGRATION_PARAMS +from oqupy.config import INTEGRATE_EPSREL, SUBDIV_LIMIT +from oqupy.config import INTEGRATION_PARAMS from oqupy.util import check_true -#np.seterr(all='warn') + # --- spectral density classes ------------------------------------------------ class BaseCorrelations(BaseAPIClass): @@ -310,30 +310,6 @@ def _gaussian_cutoff(omega: ArrayLike, omega_c: float) -> ArrayLike: # --- the spectral density classes -------------------------------------------- -def _weighted_integral( - re_integrand: Callable[[float], float], - im_integrand: Callable[[float], float], - w: float, - a: Optional[float] = 0.0, - b: Optional[float] = 1.0, - epsrel: Optional[float] = INTEGRATE_EPSREL, - limit: Optional[int] = SUBDIV_LIMIT) -> complex: - re_int = integrate.quad(re_integrand, - a=a, - b=b, - epsrel=epsrel, - limit=limit, - weight='cos', - wvar=w)[0] - im_int = integrate.quad(im_integrand, - a=a, - b=b, - epsrel=epsrel, - limit=limit, - weight='sin', - wvar=w)[0] - return re_int + 1j * im_int - def _complex_integral( integrand: Callable[[float], complex], a: Optional[float] = 0.0, @@ -387,39 +363,18 @@ class CustomSD(BaseCorrelations): ``'gaussian'``} temperature: float The environment's temperature. - name: str - An optional name for the correlations. - description: str - An optional description of the correlations. integration_params: dict Optional dictionary to pass integration parameters. Possible parameters include: - - **epsrel** (*float*) -- Relative error tolerance. - **subdiv_limit** (*int*) -- Maximal number of interval subdivisions for numerical integration. - - **alt_integrator** (*bool*) -- Whether to use an alternative - integration scheme leveraging sine/cosine weighted versions of - `scipy.integrate.quad` to handle rapid oscillations. This may improve - numerical accuracy and stability, especially for long memory times. - - The integral computed in :func:`eta_function` is cut in two: one - handling the divergent part near 0 using the default integrator - and the other taking care of the fast oscillations at angular - frequency :math:`\tau` using an appropriate integration scheme. - The cutoff point can be modified with ``num_oscillations``. This - isn't compatible with imaginary time computations. - - **num_oscillations** (*int, float, callable*) -- When - ``alt_integrator`` is ``True``, specifies how many oscillations to - keep for the non-weighted part of the integral of - :func:`eta_function`. This should be either an integer or specified - as a function of :math:`\tau`. To help choose: the higher this number - is, the more the default integrator will struggle to integrate the - non-weighted part. The lower it is, the more the weighted integrators - will struggle to integrate the near divergent part close to 0. A - constant value is a good choice for most use cases. Otherwise, it is - possible to input a function to target possible issues at specific - memory times :math:`\tau`. + - **omega_tau_theshold** (*float*) -- Threshold for using a weighted + quadrature when computing the :math:`\eta(\tau)` integral. + name: str + An optional name for the correlations. + description: str + An optional description of the correlations. """ def __init__( @@ -428,9 +383,9 @@ def __init__( cutoff: float, cutoff_type: Optional[Text] = 'exponential', temperature: Optional[float] = 0.0, + integration_params: Optional[Dict] = None, name: Optional[Text] = None, - description: Optional[Text] = None, - integration_params: Optional[Dict] = None) -> None: + description: Optional[Text] = None) -> None: """Create a CustomFunctionSD (spectral density) object. """ # check input: j_function @@ -463,37 +418,15 @@ def __init__( raise ValueError("Temperature must be >= 0.0 (but is {})".format( tmp_temperature)) self.temperature = tmp_temperature + + # input check for integration params. if integration_params is None: integration_params = INTEGRATION_PARAMS elif isinstance(integration_params, dict): integration_params = INTEGRATION_PARAMS | integration_params else: - raise AssertionError("integration_params should be "\ - "a dictionary") - - # input check for alt_integrator - alt_integrator = integration_params["alt_integrator"] - num_oscillations = integration_params["num_oscillations"] - assert isinstance(alt_integrator, bool) - if alt_integrator is False and num_oscillations is not None: - warnings.warn("num_oscillations will be discarded since "\ - "alt_integrator is False", UserWarning) - self._alt_integrator = alt_integrator - # create the first_cutoff function and input check for num_oscillations - if isinstance(num_oscillations, (int, float)) and num_oscillations > 0: - # This form is a step version of the first cutoff which prevents - # useless computations of _truncated_eta - self.first_cutoff = lambda t: 2*np.pi*num_oscillations/(1 - +1/num_oscillations)**np.floor(np.log(t)/ - np.log(1+1/num_oscillations)) - else: - try: - float(num_oscillations(1.0)) - except Exception as e: - raise AssertionError("num_oscillations must be a positive" \ - "float, int or a function returning floats or ints.") from e - self.first_cutoff = lambda t: max(min(2*np.pi*num_oscillations(t)/t, - self.cutoff), 0.0) + raise AssertionError("integration_params should be a dictionary") + self.integration_params = integration_params self._cutoff_function = \ lambda omega: CUTOFF_DICT[self.cutoff_type](omega, self.cutoff) @@ -532,8 +465,8 @@ def spectral_density(self, omega: ArrayLike) -> ArrayLike: def correlation( self, tau: ArrayLike, - epsrel: Optional[float] = INTEGRATE_EPSREL, - subdiv_limit: Optional[int] = SUBDIV_LIMIT, + epsrel: Optional[float] = None, + subdiv_limit: Optional[int] = None, matsubara: Optional[bool] = False) -> ArrayLike: r""" Auto-correlation function associated to the spectral density at the @@ -562,6 +495,11 @@ def correlation( correlation : ndarray The auto-correlation function :math:`C(\tau)` at time :math:`\tau`. """ + if epsrel is None: + epsrel = self.integration_params["epsrel"] + if subdiv_limit is None: + subdiv_limit = self.integration_params["subdiv_limit"] + # real and imaginary part of the integrand if matsubara: tau = -1j * tau @@ -601,113 +539,14 @@ def integrand(w): integral = integral.real return integral - def _eta_function_alt(self, - tau: float, - integrand: Callable, - epsrel: float, - subdiv_limit: int) -> complex: - """Computes `eta_function` when `alt_integrator` is set to True.""" - im_integrand = lambda w: - self._spectral_density(w) / w ** 2 - if self.temperature == 0.0: - re_integrand = lambda w: self._spectral_density(w) / w ** 2 - else: - def re_integrand(w): - # this is to stop overflow - if np.exp(-w / self.temperature) > np.finfo(float).eps: - inte = self._spectral_density(w) / w ** 2 \ - * 1/np.tanh(w / (2*self.temperature)) - else: - inte = self._spectral_density(w) / w ** 2 - return inte - - omega_tilde = self.first_cutoff(tau) - - # compute tau independant parts of the full eta integral - re_constant, im_constant = self._truncated_eta(a=omega_tilde, - epsrel=epsrel, - limit=subdiv_limit) - # first cut of integral on [0, omega_tilde] (non-weighted integral) - integral = _complex_integral(integrand, - a=0.0, - b=omega_tilde, - epsrel=epsrel, - limit=subdiv_limit) - - # second cut of integral on [omega_tilde, omega_c] (weighted integral) - integral += _weighted_integral(re_integrand, im_integrand, - w=tau, - a=omega_tilde, - b=self.cutoff, - epsrel=epsrel, - limit=subdiv_limit) - - if self.cutoff_type != "hard": - # last cut of integral on [omega_c, infinity] (weighted integral) - integral += _weighted_integral(re_integrand, im_integrand, - w=tau, - a=self.cutoff, - b=np.inf, - epsrel=epsrel, - limit=subdiv_limit) - return - (integral + 1.j*tau*im_constant - re_constant) - - @lru_cache(maxsize=2 ** 10, typed=False) - def _truncated_eta(self, - a: float, - epsrel: float, - limit: int) -> complex: - """Computes the parts of `eta_function` that are tau independant when - `alt_integrator` is set to True. - """ - if self.temperature == 0.0: - def re_integrand(w): - return self._spectral_density(w) / w ** 2 - else: - def re_integrand(w): - # this is to stop overflow - if np.exp(-w / self.temperature) > np.finfo(float).eps: - inte = self._spectral_density(w) / w ** 2 \ - * 1/np.tanh(w / (2*self.temperature)) - else: - inte = self._spectral_density(w) / w ** 2 - return inte - - def im_integrand(w): - return self._spectral_density(w)/w - - im_constant = integrate.quad(im_integrand, - a=a, - b=self.cutoff, - epsrel=epsrel, - limit=limit)[0] - - re_constant = integrate.quad(re_integrand, - a=a, - b=self.cutoff, - epsrel=epsrel, - limit=limit)[0] - - if self.cutoff_type != "hard": - im_constant += integrate.quad(im_integrand, - a=self.cutoff, - b=np.inf, - epsrel=epsrel, - limit=limit)[0] - - re_constant += integrate.quad(re_integrand, - a=self.cutoff, - b=np.inf, - epsrel=epsrel, - limit=limit)[0] - return re_constant, im_constant @lru_cache(maxsize=2 ** 10, typed=False) def eta_function( self, tau: ArrayLike, - epsrel: Optional[float] = INTEGRATE_EPSREL, - subdiv_limit: Optional[int] = SUBDIV_LIMIT, - alt_integrator: Optional[Union[bool, None]] = None, + epsrel: Optional[float] = None, + subdiv_limit: Optional[int] = None, + omega_tau_threshold: Optional[float] = None, matsubara: Optional[bool] = False) -> ArrayLike: r""" :math:`\eta` function associated to the spectral density at the @@ -715,7 +554,7 @@ def eta_function( .. math:: - \eta(\tau) = \int_0^{\infty} \frac{J(\omega)}{\omega^2} \ + \eta(\tau) = - \int_0^{\infty} \frac{J(\omega)}{\omega^2} \ \left[ ( \cos(\omega \tau) - 1 ) \ \coth\left( \frac{\omega}{2 T}\right) \ - i ( \sin(\omega \tau) - \omega \tau ) \right] \ @@ -731,32 +570,43 @@ def eta_function( Relative error tolerance. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. - alt_integrator: Union[bool, None] - Whether to use an alternative integration scheme leveraging - sine/cosine weighted versions of scipy.integrate.quad to handle - rapid oscillations. See ``alt_integrator`` in :class:`CustomSD`. - If the value is ``None``, the value of ``alt_integrator`` set - during initialization of the :class:`CustomSD` object is used - instead. + omega_tau_threshold: float + Threshold for using a weighted quadrature when computing the + :math:`\eta(\tau)` integral. + matsubara: bool + Compute :math:`\eta(-i \tau)` instead. + Returns ------- correlation : ndarray The function :math:`\eta(\tau)` at time :math:`\tau`. """ - if alt_integrator is None: - alt_integrator = self._alt_integrator - check_true(not (matsubara is True and alt_integrator is True), - "Can't use weighted integrator with matsubara") - check_true(isinstance(alt_integrator, bool), - "alt_integrator has to be either True, False or None") - # real and imaginary part of the integrand + if epsrel is None: + epsrel = self.integration_params["epsrel"] + if subdiv_limit is None: + subdiv_limit = self.integration_params["subdiv_limit"] + if omega_tau_threshold is None: + omega_tau_threshold = self.integration_params["omega_tau_threshold"] + if matsubara: - tau = -1j * tau - # convention is tau.imag < 0 + return self._eta_function_matsubara(tau, epsrel, subdiv_limit) + return self._eta_function( + tau, epsrel, subdiv_limit, omega_tau_threshold) + + + def _eta_function( + self, + tau: ArrayLike, + epsrel: float, + subdiv_limit: int, + omega_tau_threshold: float) -> ArrayLike: + + omega_cutoff = self.cutoff + kwargs = {'epsrel': epsrel, 'limit': subdiv_limit} + + # integrand = J(w)/w**2 [ (cos(wt)-1) coth(w/(2T)) - i (sin(wt)-wt) ] + if self.temperature == 0.0: - check_true( - matsubara is False, - 'Matsubara correlations only defined for temperature > 0') def integrand(w): return self._spectral_density(w) / w ** 2 * ( (np.exp(-1j * w * tau) - 1) + 1j * w * tau) @@ -774,28 +624,110 @@ def integrand(w): * (np.exp(-1j * w * tau) - 1 + 1j * w * tau) return inte - # Alternative computation with weighted integrators - if alt_integrator and tau*self.cutoff > 1.: - return self._eta_function_alt(tau=tau, - integrand=integrand, - epsrel=epsrel, - subdiv_limit=subdiv_limit) + # If tau is small, ... + if tau * omega_cutoff < 1.0: + integral = _complex_integral( + integrand, a=0, b=omega_cutoff, **kwargs) + if self.cutoff_type!="hard": + integral += _complex_integral( + integrand, a=omega_cutoff, b=np.inf, **kwargs) + return -integral + + # ... else, let's rewrite the integrand as ... + # + # integrand = A(w) cos(wt) - A(w) - i B(w) sin(wt) + i C(w) t + # + # A = + J(w)/w**2 coth(w/(2T)) + # B = + J(w)/w**2 + # C = + J(w)/w - # Default computation of eta_function when alt_integrator is False - integral = _complex_integral(integrand, - a=0.0, - b=self.cutoff, - epsrel=epsrel, - limit=subdiv_limit) + if self.temperature == 0.0: + def intA(w): + return self._spectral_density(w) / w ** 2 + else: + def intA(w): + # this is to stop overflow + if np.exp(-w / self.temperature) > np.finfo(float).eps: + inte = self._spectral_density(w) / w ** 2 \ + * 1/np.tanh(w / (2*self.temperature)) + else: + inte = self._spectral_density(w) / w ** 2 + return inte + + def intB(w): + return self._spectral_density(w) / w ** 2 + + def intC(w): + return self._spectral_density(w) / w + + + # == compute the integral in two steps == + # 1. omega from 0 to omega_tilde + # 2. omega from omega_tilde to omega_bound + omega_tilde = min( + [omega_tau_threshold / (tau + np.finfo(float).eps), self.cutoff]) + omega_bound = self.cutoff if self.cutoff_type=="hard" else np.inf + + # -- step 1 -- + + integral = _complex_integral( + integrand, a=0.0, b=omega_tilde, **kwargs) + + # -- step 2 -- + + # + A(w) cos(wt) + integral += integrate.quad( + intA, a=omega_tilde, b=omega_bound, weight='cos', wvar=tau, + **kwargs)[0] + # - A(w) + integral -= integrate.quad( + intA, a=omega_tilde, b=omega_bound, **kwargs)[0] + # - i B(w) sin(wt) + integral -= 1.0j * integrate.quad( + intB, a=omega_tilde, b=omega_bound, weight='sin', wvar=tau, + **kwargs)[0] + # + i C(w) t + integral += 1.0j * tau * integrate.quad( + intC, a=omega_tilde, b=omega_bound, **kwargs)[0] + + return -integral + + def _eta_function_matsubara( + self, + tau: ArrayLike, + epsrel: float, + subdiv_limit: int) -> ArrayLike: + check_true(self.temperature > 0.0, + 'Matsubara correlations only defined for temperature > 0') + + def integrand(w): + # this is to stop overflow + if np.exp(-w / self.temperature) > np.finfo(float).eps: + inte = self._spectral_density(w) / w ** 2 \ + * (((np.exp(-w * tau) \ + + np.exp(-(w / self.temperature - w * tau ))) \ + - np.exp(- w / self.temperature) - 1) \ + / (1 - np.exp(-w / self.temperature)) + w * tau) + else: + inte = self._spectral_density(w) / w ** 2 \ + * (np.exp(- w * tau) - 1 + w * tau) + return inte + + integral = integrate.quad( + integrand, + a=0.0, + b=self.cutoff, + epsrel=epsrel, + limit=subdiv_limit)[0] if self.cutoff_type != "hard": - integral += _complex_integral(integrand, - a=self.cutoff, - b=np.inf, - epsrel=epsrel, - limit=subdiv_limit) - if matsubara: - integral = integral.real + integral += integrate.quad( + integrand, + a=self.cutoff, + b=np.inf, + epsrel=epsrel, + limit=subdiv_limit)[0] + return -integral def correlation_2d_integral( @@ -804,9 +736,9 @@ def correlation_2d_integral( time_1: float, time_2: Optional[float] = None, shape: Optional[Text] = 'square', - epsrel: Optional[float] = INTEGRATE_EPSREL, - subdiv_limit: Optional[int] = SUBDIV_LIMIT, - alt_integrator: Optional[Union[bool, None]] = None, + epsrel: Optional[float] = None, + subdiv_limit: Optional[int] = None, + omega_tau_threshold: Optional[float] = None, matsubara: Optional[bool] = False) -> complex: r""" 2D integrals of the correlation function @@ -841,10 +773,9 @@ def correlation_2d_integral( Relative error tolerance. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. - alt_integrator: Union[bool, None] - Whether or not to use a sine/cosine weighted version of the - integrals that could be better suited if you're encountering - numerical difficulties, especially for long times. + omega_tau_threshold: float + Threshold for using a weighted quadrature when computing the + :math:`\eta(\tau)` integral. Returns ------- @@ -852,10 +783,17 @@ def correlation_2d_integral( The numerical value for the two dimensional integral :math:`\eta_\mathrm{shape}`. """ + if epsrel is None: + epsrel = self.integration_params["epsrel"] + if subdiv_limit is None: + subdiv_limit = self.integration_params["subdiv_limit"] + if omega_tau_threshold is None: + omega_tau_threshold = self.integration_params["omega_tau_threshold"] + kwargs = { 'epsrel': epsrel, 'subdiv_limit': subdiv_limit, - 'alt_integrator': alt_integrator, + 'omega_tau_threshold': omega_tau_threshold, 'matsubara': matsubara} if shape == 'upper-triangle': diff --git a/oqupy/config.py b/oqupy/config.py index 7e38544b..c9c9a1bb 100644 --- a/oqupy/config.py +++ b/oqupy/config.py @@ -13,7 +13,7 @@ Module to define global configuration for the time_evovling_mpo package. """ -from numpy import float64, complex128 +from numpy import float64, complex128, pi # Numpy datatype NpDtype = complex128 @@ -28,6 +28,9 @@ # maximal number of subdivision for adaptive np.integrate.quad() SUBDIV_LIMIT = 256 +# threshold for using an weighted quadratuer for the eta(tau) integral. +OMEGA_TAU_THRESHOLD = 2 * pi * 3.0 + # 'silent', 'simple' or 'bar' as a default to show the progress of computations PROGRESS_TYPE = 'bar' @@ -79,5 +82,4 @@ INTEGRATION_PARAMS = {"epsrel": INTEGRATE_EPSREL, "subdiv_limit": SUBDIV_LIMIT, - "alt_integrator": False, - "num_oscillations": 3} + "omega_tau_threshold": OMEGA_TAU_THRESHOLD} diff --git a/tests/coverage/correlations_test.py b/tests/coverage/correlations_test.py index 24bea368..9f83be01 100644 --- a/tests/coverage/correlations_test.py +++ b/tests/coverage/correlations_test.py @@ -63,7 +63,6 @@ def test_custom_correlations_bad_input(): def test_custom_s_d(): for cutoff_type in ["hard", "exponential", "gaussian"]: for temperature in [0.0, 2.0]: - for alt_integrator in [True, False, None]: sd = CustomSD(square_function, cutoff=2.0, temperature=temperature, @@ -76,12 +75,10 @@ def test_custom_s_d(): for shape in ["square", "upper-triangle"]: sd.correlation_2d_integral(time_1=0.25, delta=0.05, - shape=shape, - alt_integrator=alt_integrator) + shape=shape) sd.correlation_2d_integral(time_1=0.5, delta=0.05, - shape=shape, - alt_integrator=alt_integrator) + shape=shape) def test_matsubara_custom_s_d(): @@ -158,10 +155,6 @@ def test_matsubara_custom_s_d_bad_input(): delta=0.1, shape=shape, matsubara=True) - correlations = CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", temperature=1.0, integration_params={"alt_integrator": True}) - with pytest.raises(ValueError): - correlations.correlation_2d_integral(time_1=2, delta=0.1, shape='upper-triangle', matsubara=True, alt_integrator=True) - def test_custom_s_d_bad_input(): @@ -176,16 +169,6 @@ def test_custom_s_d_bad_input(): with pytest.raises(AssertionError): CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ temperature="bla") - with pytest.raises(AssertionError): - CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ - temperature=0.0, integration_params={"alt_integrator": "bla"}) - with pytest.raises(AssertionError): - CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ - temperature=0.0, integration_params={"num_oscillations": -1.0}) - with pytest.raises(AssertionError): - CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ - temperature=0.0, integration_params={"num_oscillations": - lambda t: "a"}) with pytest.raises(AssertionError): CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ temperature=0.0, integration_params=5) diff --git a/tests/physics/bath_correlations_test.py b/tests/physics/bath_correlations_test.py index fca2535d..d24da456 100644 --- a/tests/physics/bath_correlations_test.py +++ b/tests/physics/bath_correlations_test.py @@ -41,13 +41,16 @@ def exact_2d_correlations(alpha, omega_cutoff, temperature, k, dt, shape): correl = eta_func(k+1)-eta_func(k) return 2*alpha*correl -def test(): - kranges = [np.arange(1, 5), np.arange(395, 400)] +def test_exact_2d_correlations(): + kranges = [ + np.arange(1, 5), + np.arange(35, 40), + np.arange(395, 400), + np.arange(3995, 4000)] omega_cutoff = 3.0 - temperature = 0.0 alpha = 5e-2 - dt = 0.4 + dt = 0.04 for shape, temperature, krange in product(["square", "upper-triangle"], [0.0, 2.0], @@ -58,33 +61,31 @@ def test(): krange, dt, shape) - for alt_integrator in [False, True]: - correls = PowerLawSD(alpha=alpha, - zeta=1.0, - cutoff=omega_cutoff, - cutoff_type="exponential", - temperature=temperature, - integration_params={"alt_integrator": alt_integrator}) - with warnings.catch_warnings(): - warnings.simplefilter(action="error", - category=IntegrationWarning) + correls = PowerLawSD(alpha=alpha, + zeta=1.0, + cutoff=omega_cutoff, + cutoff_type="exponential", + temperature=temperature) + with warnings.catch_warnings(): + warnings.simplefilter(action="error", + category=IntegrationWarning) + try: + correls_2d = [ + correls.correlation_2d_integral(dt, k*dt, shape=shape) + for k in krange] + except IntegrationWarning: + pass + else: try: - correls_2d = [correls.correlation_2d_integral(dt, k*dt, shape=shape) - for k in krange] - except IntegrationWarning: - pass - else: - try: - np.testing.assert_allclose(exact_correls_2d, - correls_2d, - rtol=1e-3, atol=1e-6) - except AssertionError: - pytest.fail("correlation_2d_integral should "\ - "either give precise results or at least "\ - "warn the user that there could be some "\ - f"numerical error, failed: shape={shape}, "\ - f"temperature={temperature}, ", - f"ks={krange}, "\ - f"alt_integrator={alt_integrator}") + np.testing.assert_allclose(exact_correls_2d, + correls_2d, + rtol=1e-3, atol=1e-6) + except AssertionError: + pytest.fail("correlation_2d_integral should "\ + "either give precise results or at least "\ + "warn the user that there could be some "\ + f"numerical error, failed: shape={shape}, "\ + f"temperature={temperature}, "\ + f"ks={krange}.") diff --git a/tests/physics/tempo_spin_boson_test.py b/tests/physics/tempo_spin_boson_test.py index 362d2322..e2ab8415 100644 --- a/tests/physics/tempo_spin_boson_test.py +++ b/tests/physics/tempo_spin_boson_test.py @@ -51,6 +51,10 @@ cutoff_type="exponential", temperature=temperature_A, name="ohmic") + +correlations_A.eta_function(0) +correlations_A.eta_function(200) + bath_A = oqupy.Bath(coupling_operator_A, correlations_A, name="phonon bath") From b8168e27f80998f7330808cb44d4202abd9674a3 Mon Sep 17 00:00:00 2001 From: "Gerald E. Fux" Date: Tue, 16 Jun 2026 01:55:50 +0200 Subject: [PATCH 5/6] Reorganize integration parameters --- docs/pages/tutorials/parameters.rst | 138 +++++++++++----- oqupy/bath_correlations.py | 210 ++++++++++++++---------- oqupy/config.py | 22 ++- oqupy/tempo.py | 64 ++++---- tests/coverage/correlations_test.py | 3 - tests/coverage/tempo_parameters_test.py | 35 ++-- tests/coverage/tempo_test.py | 10 +- tutorials/parameters.ipynb | 103 ++++++++---- 8 files changed, 352 insertions(+), 233 deletions(-) diff --git a/docs/pages/tutorials/parameters.rst b/docs/pages/tutorials/parameters.rst index 723bea8b..0672e63a 100644 --- a/docs/pages/tutorials/parameters.rst +++ b/docs/pages/tutorials/parameters.rst @@ -12,27 +12,34 @@ computation and establishing convergence of results or - read through the text below and code along. --------- Contents -------- -- `Introduction - numerical exactness and computational parameters`_ -- `Choosing tcut`_ +- `Introduction <#Introduction>`__ +- `Choosing tcut <#Choosing-tcut>`__ + + - `Example - memory effects in a spin boson + model <#Example---memory-effects-in-a-spin-boson-model>`__ + - `Discussion - environment + correlations <#Discussion---environment-correlations>`__ + +- `Choosing dt and epsrel <#Choosing-dt-and-epsrel>`__ - * `Example - memory effects in a spin boson model`_ - * `Discussion - environment correlations`_ -- `Choosing dt and epsrel`_ + - `Example - convergence for a spin boson + model <#Example---convergence-for-a-spin-boson-model>`__ + - `Resolving fast system + dynamics <#Resolving-fast-system-dynamics>`__ - * `Example - convergence for a spin boson model`_ - * `Resolving fast system dynamics`_ -- `Further considerations`_ +- `Further considerations <#Further-considerations>`__ - * `Additional TempoParameters arguments`_ - * `Bath coupling degeneracies`_ - * `Mean-field systems`_ -- `PT-TEMPO`_ + - `Additional TempoParameters + arguments <#Additional-TempoParameters-arguments>`__ + - `Additional spectral density + arguments <#Additional-spectral-density-arguments>`__ + - `Bath coupling degeneracies <#Bath-coupling-degeneracies>`__ + - `Mean-field systems <#Mean-field-systems>`__ - * `The dkmax anomaly`_ +- `PT-TEMPO <#PT-TEMPO>`__ The following packages will be required @@ -60,9 +67,11 @@ The OQuPy version should be ``>=0.5.0`` '0.5.0' ---------------------------------------------------------------- -Introduction - numerical exactness and computational parameters ---------------------------------------------------------------- + +Introduction +------------ + +**numerical exactness and computational parameters** The TEMPO and PT-TEMPO methods are numerically exact meaning no approximations are required in their derivation. Instead error only @@ -106,12 +115,11 @@ to run in a local jupyter notebook session. Example results for all calculations are embedded in the notebook already, so this is not strictly required. -------------- Choosing tcut ------------- Example - memory effects in a spin boson model ----------------------------------------------- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We firstly define a spin-boson model similar to that in the Quickstart tutorial, but with a finite temperature environment and a small @@ -251,7 +259,7 @@ PT-TEMPO) computation scales **linearly** with the number of steps included in the memory cutoff. A word of warning -~~~~~~~~~~~~~~~~~ +^^^^^^^^^^^^^^^^^ ``guess_tempo_parameters`` provides a reasonable starting point for many cases, but it is only a guess. You should always verify results using a @@ -269,7 +277,7 @@ to add calls to calculate :math:`\langle \sigma_x \rangle`, still good for the above example). Discussion - environment correlations -------------------------------------- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ So what influences the required ``tcut``? The physically relevant timescale is that for the decay of correlations in the environment. @@ -321,13 +329,11 @@ computation time over a timescale ``end_time-start_time``, so make sure to set these to reflect those you actually intend to use in calculations. - ----------------------- Choosing dt and epsrel ---------------------- Example - convergence for a spin boson model --------------------------------------------- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Continuing with the previous example, we now investigate changing ``dt`` at our chosen ``tcut=2.5``. @@ -509,7 +515,7 @@ length - dictates the parameters. We now look at what influence the system can have. Resolving fast system dynamics ------------------------------- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In the above you may have noticed that the results at ``dt=0.125``, while converged, were slightly undersampled. This becomes more @@ -655,7 +661,7 @@ being missed, namely when the Hamiltonian or Lindblad operators/rates are (rapidly) *time-dependent.* What sets dt, really? -~~~~~~~~~~~~~~~~~~~~~ +^^^^^^^^^^^^^^^^^^^^^ The main error associated with ``dt`` is that from the Trotter splitting of the system propagators. In a simple (non-symmetrised) splitting, a @@ -675,29 +681,74 @@ Trotter error, even when both ``system`` and ``bath`` objects are specified - another reason to be cautious when using the estimate produced by this function. ----------------------- Further considerations ---------------------- Additional TempoParameters arguments ------------------------------------- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ For completeness, there are a few other parameters that can be passed to -the ``TempoParameters`` constructor: - ``subdiv_limit`` and -``liouvillian_epsrel``. These control the maximum number of subdivisions -and relative error tolerance when integrating a time-dependent system -Liouvillian to construct the system propagators. It is unlikely you will -need to change them from their default values (``265``, ``2**(-26)``) - -``add_correlation_time``. This allows one to include correlations -*beyond* ``tcut`` in the final bath tensor at ``dkmax`` (i.e., have your -finite memory cutoff cake and eat it). Doing so may provide better -approximations in cases where ``tcut`` is limited due to computational -difficultly. See -`[Strathearn2017] `__ for -details. +the ``TempoParameters`` constructor: + +- ``add_correlation_time``. This allows one to include correlations + *beyond* ``tcut`` in the final bath tensor at ``dkmax`` (i.e., have + your finite memory cutoff cake and eat it). Doing so may provide + better approximations in cases where ``tcut`` is limited due to + computational difficultly. See + `[Strathearn2017] `__ for + details. +- ``liouvillian_epsrel`` and ``liouvillian_subdiv_limit``. These + control relative error tolerance and the maximum number of + subdivisions when integrating a time-dependent system Liouvillian to + construct the system propagators\*. It is unlikely you will need to + change them from their default values (``2**(-26)``, ``265``) + +Additional spectral density arguments +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +When defining the bath parameters with a spectral density (for example +with a ``CustomSD`` or ``PowerLawSD``), large values of ``tcut`` can +lead to numerical instabilities in the computation of the influence +matrix. Indeed, the coefficients of the influence matrix are computed +through discrete time differences of the ``eta_function()`` given by: + +.. math:: + + \eta(\tau) = - \int_0^{\infty} \frac{J(\omega)}{\omega^2} \ + \left[ ( \cos(\omega \tau) - 1 ) \coth\left( \frac{\omega}{2 T}\right) \ + - i ( \sin(\omega \tau) - \omega \tau ) \right] \mathrm{d}\omega. + +with memory-time ``tau`` :math:`\tau`. ``tcut`` is the highest value +used for ``tau`` in this expression. Thus, high memory lengths lead to +highly oscillating terms in this integral due to the +:math:`\cos(\tau\omega)` and :math:`\sin(\tau\omega)` terms. The +``CustomSD`` class (and any of its subclasses, like ``PowerLawSD``) +deals with this by splitting the integral in two: it uses the default +integrator for the divergent part near 0 and the weighted sine and +cosine versions of ``scipy.integrate.quad`` after. + +In the ``CustomSD`` and ``PowerLawSD`` constructor we can specify three +optional parameters to tweek this process: + +- ``epsrel`` and ``subdiv_limit`` control the relative error tolerance + and the maximum number of subdivisions for the numerical integration, + and +- ``omega_tau_threshold`` sets the boundary :math:`\tilde{\omega}` + between the default quadrature and the weighted sine and cosine + quadratures to + :math:`\tilde{\omega}`\ =\ ``min(omega_tau_threshold/tau, cutoff)``. + +Unless your spectral density behaves very diferently from what we’d +expect, you will not need to change these from their default values +(``2**(-26)``, ``256``, ``2*pi*3.0``). If you *do* need to adjust +``omega_tau_threshold`` you should decrease it if the integrator +struggles with the first part of the integral (too oscillatory for the +default integrator), and increase it if the integrator struggles with +the second part of the integral (too divergent for the cos/sin weighted +versions). Bath coupling degeneracies --------------------------- +~~~~~~~~~~~~~~~~~~~~~~~~~~ The bath tensors in the TEMPO network are nominally :math:`d^2\times d^2` matrices, where :math:`d` is the system Hilbert @@ -713,7 +764,7 @@ significant loss of accuracy, although this has not been extensively tested (new in ``v0.5.0``). Mean-field systems ------------------- +~~~~~~~~~~~~~~~~~~ For calculating mean-field dynamics, there is an additional requirement on ``dt`` being small enough so not as to introduce error when @@ -730,7 +781,6 @@ when evaluating the system Hamiltonian. This may give a poor estimation for situations where the field variable is not of order :math:`1` in the dynamics. --------- PT-TEMPO -------- @@ -763,7 +813,7 @@ to a PT-TEMPO computation, with the following caveats: for further discussion. The dkmax anomaly ------------------ +~~~~~~~~~~~~~~~~~ We consider constructing a process tensor of 250 timesteps for the harmonic environment discussed in the `Mean-Field diff --git a/oqupy/bath_correlations.py b/oqupy/bath_correlations.py index 8985717a..110c75c9 100644 --- a/oqupy/bath_correlations.py +++ b/oqupy/bath_correlations.py @@ -13,7 +13,7 @@ Module for environment correlations. """ -from typing import Callable, Optional, Text, Dict +from typing import Callable, Optional, Text from typing import Any as ArrayLike from functools import lru_cache @@ -22,7 +22,7 @@ from oqupy.base_api import BaseAPIClass from oqupy.config import INTEGRATE_EPSREL, SUBDIV_LIMIT -from oqupy.config import INTEGRATION_PARAMS +from oqupy.config import BATH_EPSREL, BATH_SUBDIV_LIMIT, OMEGA_TAU_THRESHOLD from oqupy.util import check_true @@ -34,8 +34,8 @@ class BaseCorrelations(BaseAPIClass): def correlation( self, tau: ArrayLike, - epsrel: Optional[float] = INTEGRATE_EPSREL, - subdiv_limit: Optional[int] = SUBDIV_LIMIT) -> ArrayLike: + epsrel: Optional[float] = BATH_EPSREL, + subdiv_limit: Optional[int] = BATH_SUBDIV_LIMIT) -> ArrayLike: r""" Auto-correlation function. @@ -50,16 +50,16 @@ def correlation( Parameters ---------- - tau : ndarray + tau: ndarray Time difference :math:`\tau` - epsrel : float - Relative error tolerance. + epsrel: float + Relative error tolerance for numerical integration. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. Returns ------- - correlation : ndarray + correlation: ndarray The auto-correlation function :math:`C(\tau)` at time :math:`\tau`. """ raise NotImplementedError( @@ -71,8 +71,8 @@ def correlation_2d_integral( time_1: float, time_2: Optional[float] = None, shape: Optional[Text] = 'square', - epsrel: Optional[float] = INTEGRATE_EPSREL, - subdiv_limit: Optional[int] = SUBDIV_LIMIT) -> complex: + epsrel: Optional[float] = BATH_EPSREL, + subdiv_limit: Optional[int] = BATH_SUBDIV_LIMIT) -> complex: r""" 2D integrals of the correlation function @@ -92,24 +92,24 @@ def correlation_2d_integral( Parameters ---------- - delta : float + delta: float Length of integration intervals. - time_1 : float + time_1: float Lower bound of integration interval of :math:`dt'`. - time_2 : float + time_2: float Upper bound of integration interval of :math:`dt'` for `shape` = ``'rectangle'``. - shape : str (default = ``'square'``) + shape: str (default = ``'square'``) The shape of the 2D integral. Shapes are: {``'square'``, ``'upper-triangle'``, ``'rectangle'``} - epsrel : float - Relative error tolerance. + epsrel: float + Relative error tolerance for numerical integration. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. Returns ------- - integral : float + integral: float The numerical value for the two dimensional integral :math:`\eta_\mathrm{shape}`. """ @@ -133,7 +133,7 @@ class CustomCorrelations(BaseCorrelations): Parameters ---------- - correlation_function : callable + correlation_function: callable The correlation function :math:`C`. name: str An optional name for the correlations. @@ -144,6 +144,8 @@ class CustomCorrelations(BaseCorrelations): def __init__( self, correlation_function: Callable[[float], float], + epsrel: Optional[float] = BATH_EPSREL, + subdiv_limit: Optional[int] = BATH_SUBDIV_LIMIT, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Creates a CustomCorrelations object. """ @@ -157,6 +159,9 @@ def __init__( + "and must return float.") from e self.correlation_function = tmp_correlation_function + self.epsrel = epsrel + self.subdiv_limit = subdiv_limit + super().__init__(name, description) def __str__(self) -> Text: @@ -183,17 +188,18 @@ def correlation( Parameters ---------- - tau : ndarray + tau: ndarray Time difference :math:`\tau` - epsrel : float - Relative error tolerance (has no effect here). - subdiv_limit : int + epsrel: float + Relative error tolerance for numerical integration + (has no effect here). + subdiv_limit: int Maximal number of interval subdivisions for numerical integration (has no effect here). Returns ------- - correlation : ndarray + correlation: ndarray The auto-correlation function :math:`C(\tau)` at time :math:`\tau`. """ return self.correlation_function(tau) @@ -205,8 +211,8 @@ def correlation_2d_integral( time_1: float, time_2: Optional[float] = None, shape: Optional[Text] = 'square', - epsrel: Optional[float] = INTEGRATE_EPSREL, - subdiv_limit: Optional[int] = SUBDIV_LIMIT) -> complex: + epsrel: Optional[float] = None, + subdiv_limit: Optional[int] = None) -> complex: r""" 2D integrals of the correlation function @@ -226,27 +232,32 @@ def correlation_2d_integral( Parameters ---------- - delta : float + delta: float Length of integration intervals. - time_1 : float + time_1: float Lower bound of integration interval of :math:`dt'`. - time_2 : float + time_2: float Upper bound of integration interval of :math:`dt'` for `shape` = ``'rectangle'``. - shape : str (default = ``'square'``) + shape: str (default = ``'square'``) The shape of the 2D integral. Shapes are: {``'square'``, ``'upper-triangle'``, ``'rectangle'``} - epsrel : float - Relative error tolerance. + epsrel: float + Relative error tolerance for numerical integration. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. Returns ------- - integral : float + integral: float The numerical value for the two dimensional integral :math:`\eta_\mathrm{shape}`. """ + if epsrel is None: + epsrel = self.epsrel + if subdiv_limit is None: + subdiv_limit = self.subdiv_limit + c_real = lambda y, x: np.real(self.correlation(x - y)) c_imag = lambda y, x: np.imag(self.correlation(x - y)) @@ -354,23 +365,22 @@ class CustomSD(BaseCorrelations): Parameters ---------- - j_function : callable + j_function: callable The spectral density :math:`j` without the cutoff. - cutoff : float + cutoff: float The cutoff frequency :math:`\omega_c`. - cutoff_type : str (default = ``'exponential'``) + cutoff_type: str (default = ``'exponential'``) The cutoff type. Types are: {``'hard'``, ``'exponential'``, ``'gaussian'``} temperature: float The environment's temperature. - integration_params: dict - Optional dictionary to pass integration parameters. Possible - parameters include: - - **epsrel** (*float*) -- Relative error tolerance. - - **subdiv_limit** (*int*) -- Maximal number of interval subdivisions - for numerical integration. - - **omega_tau_theshold** (*float*) -- Threshold for using a weighted - quadrature when computing the :math:`\eta(\tau)` integral. + epsrel: float + Relative error tolerance for numerical integration. + subdiv_limit: int + Maximal number of interval subdivisions for numerical integration. + omega_tau_threshold: float + Threshold for using a weighted quadrature when computing the + :math:`\eta(\tau)` integral. name: str An optional name for the correlations. description: str @@ -383,7 +393,9 @@ def __init__( cutoff: float, cutoff_type: Optional[Text] = 'exponential', temperature: Optional[float] = 0.0, - integration_params: Optional[Dict] = None, + epsrel: Optional[float] = BATH_EPSREL, + subdiv_limit: Optional[int] = BATH_SUBDIV_LIMIT, + omega_tau_threshold: Optional[float] = OMEGA_TAU_THRESHOLD, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Create a CustomFunctionSD (spectral density) object. """ @@ -419,14 +431,10 @@ def __init__( tmp_temperature)) self.temperature = tmp_temperature - # input check for integration params. - if integration_params is None: - integration_params = INTEGRATION_PARAMS - elif isinstance(integration_params, dict): - integration_params = INTEGRATION_PARAMS | integration_params - else: - raise AssertionError("integration_params should be a dictionary") - self.integration_params = integration_params + # integration parameters + self.epsrel = epsrel + self.subdiv_limit = subdiv_limit + self.omega_tau_threshold = omega_tau_threshold self._cutoff_function = \ lambda omega: CUTOFF_DICT[self.cutoff_type](omega, self.cutoff) @@ -450,13 +458,13 @@ def spectral_density(self, omega: ArrayLike) -> ArrayLike: Parameters ---------- - omega : ndarray + omega: ndarray The frequency :math:`\omega` for which we want to know the spectral density. Returns ------- - spectral_density : ndarray + spectral_density: ndarray The resulting spectral density :math:`J(\omega)` at the frequency :math:`\omega`. """ @@ -483,22 +491,22 @@ def correlation( Parameters ---------- - tau : ndarray + tau: ndarray Time difference :math:`\tau` - epsrel : float - Relative error tolerance. + epsrel: float + Relative error tolerance for numerical integration. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. Returns ------- - correlation : ndarray + correlation: ndarray The auto-correlation function :math:`C(\tau)` at time :math:`\tau`. """ if epsrel is None: - epsrel = self.integration_params["epsrel"] + epsrel = self.epsrel if subdiv_limit is None: - subdiv_limit = self.integration_params["subdiv_limit"] + subdiv_limit = self.subdiv_limit # real and imaginary part of the integrand if matsubara: @@ -564,10 +572,10 @@ def eta_function( Parameters ---------- - tau : ndarray + tau: ndarray Time difference :math:`\tau` - epsrel : float - Relative error tolerance. + epsrel: float + Relative error tolerance for numerical integration. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. omega_tau_threshold: float @@ -578,15 +586,15 @@ def eta_function( Returns ------- - correlation : ndarray + correlation: ndarray The function :math:`\eta(\tau)` at time :math:`\tau`. """ if epsrel is None: - epsrel = self.integration_params["epsrel"] + epsrel = self.epsrel if subdiv_limit is None: - subdiv_limit = self.integration_params["subdiv_limit"] + subdiv_limit = self.subdiv_limit if omega_tau_threshold is None: - omega_tau_threshold = self.integration_params["omega_tau_threshold"] + omega_tau_threshold = self.omega_tau_threshold if matsubara: return self._eta_function_matsubara(tau, epsrel, subdiv_limit) @@ -604,7 +612,11 @@ def _eta_function( omega_cutoff = self.cutoff kwargs = {'epsrel': epsrel, 'limit': subdiv_limit} - # integrand = J(w)/w**2 [ (cos(wt)-1) coth(w/(2T)) - i (sin(wt)-wt) ] + # + # The integrand is: + # + # integrand = J(w)/w**2 [ (cos(wt)-1) coth(w/(2T)) - i (sin(wt)-wt) ] + # if self.temperature == 0.0: def integrand(w): @@ -624,7 +636,10 @@ def integrand(w): * (np.exp(-1j * w * tau) - 1 + 1j * w * tau) return inte - # If tau is small, ... + # + # If tau is small, we use the default quadrature. + # + if tau * omega_cutoff < 1.0: integral = _complex_integral( integrand, a=0, b=omega_cutoff, **kwargs) @@ -633,13 +648,15 @@ def integrand(w): integrand, a=omega_cutoff, b=np.inf, **kwargs) return -integral - # ... else, let's rewrite the integrand as ... + # + # If tau is not small, we rewrite the integrand as ... # # integrand = A(w) cos(wt) - A(w) - i B(w) sin(wt) + i C(w) t # # A = + J(w)/w**2 coth(w/(2T)) # B = + J(w)/w**2 # C = + J(w)/w + # if self.temperature == 0.0: def intA(w): @@ -660,10 +677,13 @@ def intB(w): def intC(w): return self._spectral_density(w) / w - - # == compute the integral in two steps == + # + # ... then, we compute the integral in two steps ... + # # 1. omega from 0 to omega_tilde # 2. omega from omega_tilde to omega_bound + # + omega_tilde = min( [omega_tau_threshold / (tau + np.finfo(float).eps), self.cutoff]) omega_bound = self.cutoff if self.cutoff_type=="hard" else np.inf @@ -759,18 +779,18 @@ def correlation_2d_integral( Parameters ---------- - delta : float + delta: float Length of integration intervals. - time_1 : float + time_1: float Lower bound of integration interval of :math:`dt'`. - time_2 : float + time_2: float Upper bound of integration interval of :math:`dt'` for `shape` = ``'rectangle'``. - shape : str (default = ``'square'``) + shape: str (default = ``'square'``) The shape of the 2D integral. Shapes are: {``'square'``, ``'upper-triangle'``, ``'rectangle'``} - epsrel : float - Relative error tolerance. + epsrel: float + Relative error tolerance for numerical integration. subdiv_limit: int Maximal number of interval subdivisions for numerical integration. omega_tau_threshold: float @@ -779,16 +799,16 @@ def correlation_2d_integral( Returns ------- - integral : float + integral: float The numerical value for the two dimensional integral :math:`\eta_\mathrm{shape}`. """ if epsrel is None: - epsrel = self.integration_params["epsrel"] + epsrel = self.epsrel if subdiv_limit is None: - subdiv_limit = self.integration_params["subdiv_limit"] + subdiv_limit = self.subdiv_limit if omega_tau_threshold is None: - omega_tau_threshold = self.integration_params["omega_tau_threshold"] + omega_tau_threshold = self.omega_tau_threshold kwargs = { 'epsrel': epsrel, @@ -840,22 +860,26 @@ class PowerLawSD(CustomSD): Parameters ---------- - alpha : float + alpha: float The coupling strength :math:`\alpha`. - zeta : float + zeta: float The exponent :math:`\zeta` (corresponds to the dimensionality of the environment). The environment is called *ohmic* if :math:`\zeta=1`, *superohmic* if :math:`\zeta>1` and *subohmic* if :math:`\zeta<1` - cutoff : float + cutoff: float The cutoff frequency :math:`\omega_c`. - cutoff_type : str (default = ``'exponential'``) + cutoff_type: str (default = ``'exponential'``) The cutoff type. Types are: {``'hard'``, ``'exponential'``, ``'gaussian'``} temperature: float The environment's temperature. - integration_params: dict - Optional dictionary to pass integration parameters. See - ``integration_params`` in :class:`CustomSD`. + epsrel: float + Relative error tolerance for numerical integration. + subdiv_limit: int + Maximal number of interval subdivisions for numerical integration. + omega_tau_threshold: float + Threshold for using a weighted quadrature when computing the + :math:`\eta(\tau)` integral. name: str An optional name for the correlations. description: str @@ -869,7 +893,9 @@ def __init__( cutoff: float, cutoff_type: Text = 'exponential', temperature: Optional[float] = 0.0, - integration_params: Optional[Dict] = None, + epsrel: Optional[float] = BATH_EPSREL, + subdiv_limit: Optional[int] = BATH_SUBDIV_LIMIT, + omega_tau_threshold: Optional[float] = OMEGA_TAU_THRESHOLD, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Create a StandardSD (spectral density) object. """ @@ -903,7 +929,9 @@ def __init__( cutoff=cutoff, cutoff_type=cutoff_type, temperature=temperature, - integration_params=integration_params, + epsrel=epsrel, + subdiv_limit=subdiv_limit, + omega_tau_threshold=omega_tau_threshold, name=name, description=description) diff --git a/oqupy/config.py b/oqupy/config.py index c9c9a1bb..3fbcbc2b 100644 --- a/oqupy/config.py +++ b/oqupy/config.py @@ -10,7 +10,7 @@ # See the License for the specific language governing permissions and # limitations under the License. """ -Module to define global configuration for the time_evovling_mpo package. +Module to define global configuration for the oqupy package. """ from numpy import float64, complex128, pi @@ -28,9 +28,6 @@ # maximal number of subdivision for adaptive np.integrate.quad() SUBDIV_LIMIT = 256 -# threshold for using an weighted quadratuer for the eta(tau) integral. -OMEGA_TAU_THRESHOLD = 2 * pi * 3.0 - # 'silent', 'simple' or 'bar' as a default to show the progress of computations PROGRESS_TYPE = 'bar' @@ -50,6 +47,12 @@ # default tolerances for tempo parameter guessing function DEFAULT_TOLERANCE = 3.9e-3 +# default subdiv_limit for integrating a time-dependent Liouvillian +LIOUVILLIAN_SUBDIV_LIMIT = SUBDIV_LIMIT + +# default epsrel for integrating a time-dependent Liouvillian +LIOUVILLIAN_EPSREL = INTEGRATE_EPSREL + # -- PT_TEMPO ----------------------------------------------------------------- # default PT-TEMPO backend configuration @@ -80,6 +83,11 @@ # -- BATH_CORRELATIONS ------------------------------------------------------- -INTEGRATION_PARAMS = {"epsrel": INTEGRATE_EPSREL, - "subdiv_limit": SUBDIV_LIMIT, - "omega_tau_threshold": OMEGA_TAU_THRESHOLD} +# default subdiv_limit for integrating bath correlations +BATH_SUBDIV_LIMIT = SUBDIV_LIMIT + +# default epsrel for integrating bath correlations +BATH_EPSREL = INTEGRATE_EPSREL + +# threshold for using an weighted quadratuer for the eta(tau) integral +OMEGA_TAU_THRESHOLD = 2 * pi * 3.0 diff --git a/oqupy/tempo.py b/oqupy/tempo.py index 896679bc..c066eff2 100644 --- a/oqupy/tempo.py +++ b/oqupy/tempo.py @@ -35,7 +35,7 @@ from oqupy.bath import Bath from oqupy.base_api import BaseAPIClass from oqupy.config import MAX_DKMAX, DEFAULT_TOLERANCE, MAX_SYS_SAMPLES -from oqupy.config import INTEGRATE_EPSREL, SUBDIV_LIMIT +from oqupy.config import LIOUVILLIAN_EPSREL, LIOUVILLIAN_SUBDIV_LIMIT from oqupy.config import TEMPO_BACKEND_CONFIG from oqupy.bath_correlations import BaseCorrelations, CustomSD from oqupy.dynamics import Dynamics, MeanFieldDynamics @@ -77,14 +77,14 @@ class TempoParameters(BaseAPIClass): add_correlation_time: float Additional correlation time to include in the last influence functional as explained in [Strathearn2017]. - subdiv_limit: int (default = config.SUBDIV_LIMIT) + liouvillian_epsrel: float (default = config.LIOUVILLIAN_INTEGRATE_EPSREL) + The relative error tolerance for the adaptive algorithm + when integrating a time-dependent Liouvillian. + liouvillian_subdiv_limit: int (default = config.LIOUVILLIAN_SUBDIV_LIMIT) The maximum number of subdivisions used during the adaptive algorithm when integrating a time-dependent Liouvillian. If None then the Liouvillian is not integrated but sampled twice to construct the system propagators at a timestep. - liouvillian_epsrel: float (default = config.INTEGRATE_EPSREL) - The relative error tolerance for the adaptive algorithm - when integrating a time-dependent Liouvillian. name: str (default = None) An optional name for the tempo parameters object. description: str (default = None) @@ -97,8 +97,8 @@ def __init__( tcut: Optional[float] = None, dkmax: Optional[int] = None, add_correlation_time: Optional[float] = None, - subdiv_limit: Optional[int] = SUBDIV_LIMIT, - liouvillian_epsrel: Optional[float] = INTEGRATE_EPSREL, + liouvillian_epsrel: Optional[float] = LIOUVILLIAN_EPSREL, + liouvillian_subdiv_limit: Optional[int] = LIOUVILLIAN_SUBDIV_LIMIT, name: Optional[Text] = None, description: Optional[Text] = None) -> None: """Create a TempoParameters object.""" @@ -135,19 +135,6 @@ def __init__( "Argument 'add_correlation_time' must be non-negative.") self._add_correlation_time = tmp_tau - try: - if subdiv_limit is None: - tmp_subdiv_limit = None - else: - tmp_subdiv_limit = int(subdiv_limit) - except Exception as e: - raise TypeError("Argument 'subdiv_limit' must be int or "\ - "None.") from e - if tmp_subdiv_limit is not None and tmp_subdiv_limit < 0: - raise ValueError( - "Argument 'subdiv_limit' must be non-negative or None.") - self._subdiv_limit = tmp_subdiv_limit - try: tmp_liouvillian_epsrel = float(liouvillian_epsrel) except Exception as e: @@ -160,6 +147,20 @@ def __init__( super().__init__(name, description) + try: + if liouvillian_subdiv_limit is None: + tmp_lsl = None + else: + tmp_lsl = int(liouvillian_subdiv_limit) + except Exception as e: + raise TypeError("Argument 'liouvillian_subdiv_limit' must be int "\ + "or None.") from e + if tmp_lsl is not None and tmp_lsl < 0: + raise ValueError( + "Argument 'liouvillian_subdiv_limit' must be non-negative or None.") + self._liouvillian_subdiv_limit = tmp_lsl + + def __str__(self) -> Text: ret = [] ret.append(super().__str__()) @@ -181,8 +182,6 @@ def epsrel(self) -> float: """The maximal relative error in the singular value truncation.""" return self._epsrel - # epsrel is error tolerance for both correlation omega integration and svds - @property def tcut(self) -> float: """Length of non-Markovian memory""" @@ -201,20 +200,18 @@ def add_correlation_time(self) -> float: """ return self._add_correlation_time - @property - def subdiv_limit(self) -> int: - """The maximum number of subdivisions used during the adaptive - algorithm when integrating a time-dependent Liouvillian.""" - return self._subdiv_limit - @property def liouvillian_epsrel(self) -> float: """The relative error tolerance for integrating a time-dependent system Liouvillian. """ return self._liouvillian_epsrel - # lio epsrel for dynamics time integrals only -# + @property + def liouvillian_subdiv_limit(self) -> int: + """The maximum number of subdivisions used during the adaptive + algorithm when integrating a time-dependent Liouvillian.""" + return self._liouvillian_subdiv_limit + class GibbsParameters(BaseAPIClass): r""" Parameters for the GibbsTEMPO computation. @@ -406,7 +403,7 @@ def _prepare_backend(self): propagators = self._system.get_propagators( self._parameters.dt, self._start_time, - self._parameters.subdiv_limit, + self._parameters.liouvillian_subdiv_limit, self._parameters.liouvillian_epsrel) if self._unique: sum_north = np.ones(np.max(self._bath.north_degeneracy_map)+1, @@ -790,7 +787,7 @@ def _prepare_backend(self): propagators_list = [system.get_propagators( self._parameters.dt, self._start_time, - self._parameters.subdiv_limit, + self._parameters.liouvillian_subdiv_limit, self._parameters.liouvillian_epsrel) for system in self._parsed_parameters_dict["system"]] compute_field = self._compute_field @@ -999,8 +996,7 @@ def influence_matrix( delta=dt, time_1=time_1, time_2=time_2, - shape=shape, - epsrel=parameters.epsrel) + shape=shape) op_p = coupling_acomm op_m = coupling_comm diff --git a/tests/coverage/correlations_test.py b/tests/coverage/correlations_test.py index 9f83be01..376817a4 100644 --- a/tests/coverage/correlations_test.py +++ b/tests/coverage/correlations_test.py @@ -169,9 +169,6 @@ def test_custom_s_d_bad_input(): with pytest.raises(AssertionError): CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ temperature="bla") - with pytest.raises(AssertionError): - CustomSD(square_function, cutoff=2.0, cutoff_type="gaussian", \ - temperature=0.0, integration_params=5) with pytest.raises(ValueError): CustomSD(square_function, cutoff=2.0, cutoff_type="hard", \ temperature=-2.0) diff --git a/tests/coverage/tempo_parameters_test.py b/tests/coverage/tempo_parameters_test.py index 7e910379..2a8ce4f1 100644 --- a/tests/coverage/tempo_parameters_test.py +++ b/tests/coverage/tempo_parameters_test.py @@ -20,14 +20,15 @@ def test_tempo_parameters(): tempo_param = tempo.TempoParameters( - 0.1, 1.0e-5, None, None, None, None, 2.0e-5, "rough", "bla") + 0.1, 1.0e-5, None, None, None, 2.0e-5, None, "rough", "bla") str(tempo_param) assert tempo_param.dt == 0.1 assert tempo_param.epsrel == 1.0e-5 assert tempo_param.tcut == None assert tempo_param.dkmax == None - assert tempo_param.subdiv_limit == None + assert tempo_param.add_correlation_time == None assert tempo_param.liouvillian_epsrel == 2.0e-5 + assert tempo_param.liouvillian_subdiv_limit == None with pytest.raises(AttributeError): tempo_param.dt = 0.05 with pytest.raises(AttributeError): @@ -41,9 +42,9 @@ def test_tempo_parameters(): with pytest.raises(AttributeError): del tempo_param.epsrel with pytest.raises(AttributeError): - tempo_param.subdiv_limit = 256 + tempo_param.liouvillian_subdiv_limit = 256 with pytest.raises(AttributeError): - del tempo_param.subdiv_limit + del tempo_param.liouvillian_subdiv_limit with pytest.raises(AttributeError): tempo_param.liouvillian_epsrel = 2.0e-6 with pytest.raises(AttributeError): @@ -51,33 +52,33 @@ def test_tempo_parameters(): def test_tempo_parameters_bad_input(): with pytest.raises(TypeError): - tempo.TempoParameters("x", 1.0e-5, 4.2, None, None, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters("x", 1.0e-5, 4.2, None, None, 2.0e-6, None, "rough", "bla") with pytest.raises(ValueError): - tempo.TempoParameters(-0.1, 1.0e-05, None, None, None, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(-0.1, 1.0e-05, None, None, None, 2.0e-6, None, "rough", "bla") with pytest.raises(TypeError): - tempo.TempoParameters(0.1, "x", 4.2, None, None, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, "x", 4.2, None, None, 2.0e-6, None, "rough", "bla") with pytest.raises(ValueError): - tempo.TempoParameters(0.1, -1.0e-10, 4.2, None, None, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, -1.0e-10, 4.2, None, None, 2.0e-6, None, "rough", "bla") with pytest.raises(TypeError): - tempo.TempoParameters(0.1, 1.0e-05, "x", None, None, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, "x", None, None, 2.0e-6, None, "rough", "bla") with pytest.raises(ValueError): - tempo.TempoParameters(0.1, 1.0e-05, -.5, None, None, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, -.5, None, None, 2.0e-6, None, "rough", "bla") with pytest.raises(TypeError): - tempo.TempoParameters(0.1, 1.0e-05, None, "x", None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, None, "x", 2.0e-6, None, "rough", "bla") with pytest.raises(ValueError): - tempo.TempoParameters(0.1, 1.0e-05, None, -5, None, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, None, -5, None, 2.0e-6, None, "rough", "bla") with pytest.raises(AssertionError): - tempo.TempoParameters(0.1, 1.0e-05, 1.0, 1, None, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, 1.0, 1, None, 2.0e-6, None, "rough", "bla") with pytest.raises(TypeError): - tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, "x", None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, "x", 2.0e-6, None, "rough", "bla") with pytest.raises(ValueError): - tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, -99, None, 2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, -99, 2.0e-6, None, "rough", "bla") with pytest.raises(TypeError): tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, None, "x", 2.0e-6, "rough", "bla") with pytest.raises(ValueError): tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, None, -1000, 2.0e-6, "rough", "bla") with pytest.raises(TypeError): - tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, None, None, "x", "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, None, "x", None, "rough", "bla") with pytest.raises(ValueError): - tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, None, None, -2.0e-6, "rough", "bla") + tempo.TempoParameters(0.1, 1.0e-05, 4.2, None, None, -2.0e-6, None, "rough", "bla") diff --git a/tests/coverage/tempo_test.py b/tests/coverage/tempo_test.py index 95cec34f..639956e1 100644 --- a/tests/coverage/tempo_test.py +++ b/tests/coverage/tempo_test.py @@ -162,16 +162,16 @@ def test_tempo_parameters(): dkmax=10, epsrel=2.0e-05, add_correlation_time=-1.0) - with pytest.raises(TypeError): # invalid subdiv_limit + with pytest.raises(TypeError): # invalid liouvillian_subdiv_limit param = oqupy.TempoParameters(dt=0.1, dkmax=10, epsrel=2.0e-05, - subdiv_limit='a') - with pytest.raises(ValueError): # invalid subdiv_limit + liouvillian_subdiv_limit='a') + with pytest.raises(ValueError): # invalid liouvillian_subdiv_limit param = oqupy.TempoParameters(dt=0.1, dkmax=10, epsrel=2.0e-05, - subdiv_limit=-1.0) + liouvillian_subdiv_limit=-1.0) with pytest.raises(TypeError): # invalid liouvillian_epsrel param = oqupy.TempoParameters(dt=0.1, dkmax=10, @@ -186,7 +186,7 @@ def test_tempo_parameters(): param = oqupy.TempoParameters(dt=0.1, dkmax=10, epsrel=2.0e-05, - subdiv_limit=None) + liouvillian_subdiv_limit=None) print(param) # Must be true on creation assert np.isclose(param.tcut, param.dkmax * param.dt) diff --git a/tutorials/parameters.ipynb b/tutorials/parameters.ipynb index b9243b67..32459db0 100644 --- a/tutorials/parameters.ipynb +++ b/tutorials/parameters.ipynb @@ -17,18 +17,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Contents\n", + "## Contents\n", "\n", - "* [Introduction - numerical exactness and computational parameters](#Introduction---numerical-exactness-and-computational-parameters)\n", - "* [Choosing `tcut`](#Choosing-tcut)\n", + "* [Introduction](#Introduction)\n", + "* [Choosing tcut](#Choosing-tcut)\n", " - [Example - memory effects in a spin boson model](#Example---memory-effects-in-a-spin-boson-model)\n", " - [Discussion - environment correlations](#Discussion---environment-correlations)\n", - "* [Choosing `dt` and `epsrel`](#Choosing-dt-and-epsrel)\n", + "* [Choosing dt and epsrel](#Choosing-dt-and-epsrel)\n", " - [Example - convergence for a spin boson model](#Example---convergence-for-a-spin-boson-model)\n", " - [Resolving fast system dynamics](#Resolving-fast-system-dynamics)\n", "* [Further considerations](#Further-considerations)\n", " - [Additional TempoParameters arguments](#Additional-TempoParameters-arguments)\n", + " - [Additional spectral density arguments](#Additional-spectral-density-arguments)\n", " - [Bath coupling degeneracies](#Bath-coupling-degeneracies)\n", + " - [Mean-field systems](#Mean-field-systems)\n", "* [PT-TEMPO](#PT-TEMPO)" ] }, @@ -85,7 +87,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Introduction - numerical exactness and computational parameters\n", + "## Introduction\n", + "\n", + "**numerical exactness and computational parameters**\n", + "\n", "The TEMPO and PT-TEMPO methods are numerically exact meaning no approximations are required in their derivation. Instead error only arises in their numerical implementation, and is controlled by a set of computational parameters. The error can, in principle (at least up to machine precision), be made as small as desired by tuning those numerical parameters. In this tutorial we discuss how this is done to derive accurate results with manageable computational costs.\n", "\n", "As introduced in the [Quickstart](https://oqupy.readthedocs.io/en/latest/pages/tutorials/quickstart.html) tutorial a TEMPO or PT-TEMPO calculation has three main computational parameters:\n", @@ -104,8 +109,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Choosing tcut\n", - "## Example - memory effects in a spin boson model\n", + "## Choosing tcut\n", + "### Example - memory effects in a spin boson model\n", "We firstly define a spin-boson model similar to that in the Quickstart tutorial, but with a finite temperature environment and a small additional incoherent dissipation of the spin." ] }, @@ -224,7 +229,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAF7CAYAAADc0IJwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABE70lEQVR4nO3dd3hc9Z32//dnmnqzJNuSbdkWxlU2NrZxARITsFmTkIQWShIgu0l+YJL1hiW/3eRJIRsSNk+ybNiAYUl2QwuBhCS7kJiA6cXYRgb3gnuVi9zUNaOZ7/PHyEJykS1bmqOR7td1zTVnzpyjuSXK/T1lzjHnHCIiItJ7+LwOICIiIoml8hcREellVP4iIiK9jMpfRESkl1H5i4iI9DIqfxERkV4m4HWARCkoKHBDhgzxOoaIiEhCLF26tNI5V3ii93pN+Q8ZMoTy8nKvY4iIiCSEmW072Xva7S8iItLLqPxFRER6GZW/iIhIL6PyFxER6WVU/iIiIr1MrznbX0REupdIJMLOnTtpaGjwOkrS8fv95ObmUlBQgM/X8e14lb+IiHhi586dZGVlMWTIEMzM6zhJwzlHJBJh79697Ny5k5KSkg7/DO32FxERTzQ0NJCfn6/i7yAzIxQKMWDAAGpra8/oZ6j8RUTEMyr+M3cmu/tb1u3EHB1iZh8zs+fMbJeZOTO79TTWGWtmb5hZffN63zP9myMiItIhXm75ZwKrgLlA/akWNrNsYAGwF5jcvN43gTu7MOMJHTqynz2VOxL9sSIiIp3CsxP+nHPzgfkAZvboaazyeSAduMU5Vw+sMrORwJ1mdp9zznVZ2FYOHN7DnN/NJkqMB6+ZT7/8AYn4WBERkU6TTMf8pwFvNRf/US8CxcCQE61gZl81s3IzK9+/f3+nhPjZn25jTUoT61NifO0Pn2T/od2d8nNFRCSxvvnNb3L55Zd7HcMTyVT+/Ynv8m9tb6v3juOce8Q5N8k5N6mw8IR3Neyw71z/BOMbUgBYlxLljt9fwYHDezrlZ4uISOIsWbKECy64wOsYnkim8u8WMtKzmPeFlzmveQCwNiXKnN/N5tCRztmzICIiXSscDhMKhXjzzTe55557MDNGjx7tdayESqby3wP0O2Zev1bvJUxWRi4Pfv4lxjWEAFiT0sTtz8zSAEBEJAkEAgHeffddABYvXkxFRQXvvPOOx6kSK5nK/13gYjNLbTVvJrAb2JroMDmZfZj3+QWMbQgCsDqliTnPXM7h6spERxERkQ7w+XxUVFSQlZXF5MmT6d+/P3l5eR3+OZs3b+a5557rgoRdz8vv+Wea2XgzG9+co6T5dUnz+/ea2SutVnkKqAMeNbMyM7sa+GcgYWf6Hysnsw/zbnqJssb4lyZWpUSY89tZHKk56EUcERE5TR988AHnnXfeWV1k6IUXXmDNmjWdmCpxvNzynwR80PxIA37QPP0vze8XAeccXdg5d4T4ln4xUA48CPwbcF/iIh8vN6uAede/xJjmAcDKlAhzfjNTAwARkW5s2bJlTJgwoc28bdu2ceWVVzJhwgTKysrYvn07559/PocOHQJg4cKFXH/99QC88cYbfPe73+W//uu/mDBhwhlfZtcrnpW/c+5155yd4HFr8/u3OueGHLPOSufcx5xzqc65IufcD7za6m8tL6eQBz/3AqMa/QCsSA1zx29mUV172NtgIiJyQsuXL2fcuHEtr8PhMFdccQX/+I//yAcffMBbb71FUVERR44caTkksHLlSsaOHQvAxz/+ccaNG8eCBQv44IMPyMjI8OT3OFPJdMy/W8vP7c+D181nZPMAYHlqI3f8Zia1ddUeJxMRkWM1NTWxbt06du/ezeHDh/nTn/7E1KlTmTFjBgB5eXls2LCBc889t2WdVatWUVZW1vJ6+/btDBkyJMHJO4fKvxMV5hUz77r5jGiM/1k/SGlgzhOfoK4huXYHiYj0dD/60Y94+umnGThwIN/61rdYuXLlcd/5P7bsy8vLW7b8d+7cSXFxcUIzdyaVfycrzCvmwWvmM7x5APB+agO/+ONcj1OJiEhrn//859m5cyexWIyHHnqIfv36sWrVKgCi0SgHDx7k4MGD5ObmAvDOO++wevVqSktLgfj5AUVFRV7FP2sq/y7QL38AD179ZwqbYgAsrF3scSIREWnPrbfeyqZNmygrK2PSpEl8+OGHzJ49m2effZabb76Zv/71r4waNarl2wFlZWVs3ryZsWPHJuUZ/57d2Ken618wiKm+4TzPRjaH4KV3f8usaTd6HUtERE4gKyuL+fPnHzd/2bJlLdM//OEPW6ZzcnJYunRpIqJ1CW35d6EbLvwm1vxlhD+v+qXHaUREROJU/l1o3PDpjG2M3wPgPf9eXf1PRES6BZV/F/tY31kA1Ph9PPHXH3mcRkREROXf5b5w+bfJicZP/Hv70OvehhEREUHl3+Uy0rO4IDYQiN/9b8nKlz1OJCIivZ3KPwGuOv+Olulnl/y7h0lERERU/glx8fmfbrnozxK20tBY53EiERHpzVT+CTI9ezoABwI+frvg3zxOIyIivZnKP0Fuvvy7pMfiJ/69vus5j9OIiEhvpvJPkMK8YiZG8gFYnlLPh9uWeRtIRER6LZV/Av3NyFsAiJrxm9fv9TiNiIiciTfffJNPf/rTDBgwADPj0UcfbXf5e++9l8mTJ5OdnU1hYSFXXnlly02Ejrr77rsxszaP/v37d9nvoPJPoE9deCuDwvHL/S6KrCYWjXqcSEREOqqmpoaysjLuv/9+0tLSTrn866+/zpw5c1i4cCGvvvoqgUCAyy67jIMHD7ZZbsSIEVRUVLQ8Vq5c2VW/gm7sk0g+v5+pqeexI7aC3UHjj68/zLWX3nHqFUVEpNu44ooruOKKK4D43QBP5cUXX2zz+oknniAnJ4d33nmHK6+8smV+IBDo0q391rTln2BfmPFtAs03+1mw6bcepxERkUSrrq4mFouRl5fXZv7mzZspLi5m6NCh3HDDDWzevLnLMmjLP8FKB41hQjiD91LqWBo8zO792yguHOx1LBERz/3g+dWs2V2V8M8dXZzN968ck7DPmzt3LuPHj2fatGkt86ZMmcKjjz7KyJEj2bdvH/fccw/Tp09n9erV5Ofnd3oGlb8HPjHoat7b9ySNPuOJBT/kn276ldeRREQ8t2Z3FYu3HDz1gknszjvv5O233+btt9/G7/e3zJ89e3ab5aZOnUppaSmPPfYYd955Z6fnUPl74HOX/gP//cTj7A/4eLd2iddxRES6hdHF2T36c7/xjW/w9NNP89prr1FaWtruspmZmYwZM4YNGzZ0SRaVvwdCoRSm+M7lz2xiU8jx8uLfc9mU67yOJSLiqUTuek+0uXPn8swzz/Daa68xcuTIUy7f0NDAunXruOSSS7okj07488j10+/Cmk/8e37Ff3qcRkRETldNTQ3Lli1j2bJlxGIxtm/fzrJly9i+fTsADzzwQJuCv+OOO/j1r3/NU089RV5eHnv27GHPnj3U1NS0LHPXXXfxxhtvsGXLFhYvXsy1115LbW0tt9xyS5f8Dip/j4wfcRFl4RAA7/krOFLTs49ziYj0FOXl5UyYMIEJEyZQX1/P97//fSZMmMD3vvc9ACorK1m/fn3L8vPmzaO6uppLL72UoqKilsfPfvazlmV27tzJjTfeyIgRI7j66qtJSUlh0aJFDB7cNSeEm2ve+uzpJk2a5MrLy72O0cZDf/wn5lXPB+D/y7ycr13zs1OsISLSc6xdu5ZRo0Z5HSOptfc3NLOlzrlJJ3pPW/4e+sLl3yInGr/Zz9sHXvE4jYiI9BYqfw9lZeQyOTYAgNUpTZSvft3bQCIi0iuo/D32mfG3t0z/YcnPvQsiIiK9hsrfYzMmXcWQcHx6faTrLuUoIiJylMq/Gxhu8V3/m0IxduzRAEBERLqWyr8bOH/gJwCImfHC4v/yOI2IiPR0Kv9u4JMX/i2hWPwrlyv2LfQ4jYiI9HQq/24gN6uA4ZEgAB/afo/TiIhIT6fy7yaGpwwHoCJovL/mDY/TiIhIT6by7yamD/9My/TLy3/jYRIREenpVP7dxKWTr2u52t+66uUepxERkZO59957mTx5MtnZ2RQWFnLllVeyatWqdte5++67MbM2j/79+yco8fFU/t1EIBBkRFP8ntLrAjWEw40eJxIRkRN5/fXXmTNnDgsXLuTVV18lEAhw2WWXcfBg+zdoGzFiBBUVFS2PlStXJijx8QKefbIcZ3T2eJY0vk2138fLS57hiotu9jqSiIgc48UXX2zz+oknniAnJ4d33nmHK6+88qTrBQIBT7f2W9OWfzcy8/wvtky/u/F5D5OIiMjpqq6uJhaLkZeX1+5ymzdvpri4mKFDh3LDDTewebN3F3XTln83Mm74dAa86dgVND4Mb/Q6johIYr3wz7DHg13h/cfC7H8949Xnzp3L+PHjmTZt2kmXmTJlCo8++igjR45k37593HPPPUyfPp3Vq1eTn59/xp99plT+3cxw15dd7OfDUIQDh/eQn9s9dhGJiHS5PSth29tep+iQO++8k7fffpu3334bv99/0uVmz57d5vXUqVMpLS3lscce48477+zqmMdR+Xcz4/pdzGuH/kiTGX9Z+N/cfMW3vY4kIpIY/ccm1ed+4xvf4Omnn+a1116jtLS0Q+tmZmYyZswYNmzYcEaffbZU/t3MFdP+lgf+8geiZnyw+3VuRuUvIr3EWex6T7S5c+fyzDPP8NprrzFy5MgOr9/Q0MC6deu45JJLuiDdqemEv26muHAww8LxXUcbXIXHaURE5Fh33HEHv/71r3nqqafIy8tjz5497Nmzh5qaGgAeeOCB4wYEd911F2+88QZbtmxh8eLFXHvttdTW1nLLLbd48Suo/Lujc4NDAdgWgvVbPvA4jYiItDZv3jyqq6u59NJLKSoqann87Gc/A6CyspL169e3WWfnzp3ceOONjBgxgquvvpqUlBQWLVrE4MGDvfgVtNu/O5oyZDZ/3v4AAH8tf5QRQyd4nEhERI5yzrX7/t13383dd9/dZt7TTz/dhYk6ztMtfzObY2ZbzKzBzJaa2cWnWP4mM1tmZnVmtsfMnjSzHnc6/KxpXyA9Fr/U7+pD5R6nERGRnsaz8jez64H7gR8DE4CFwAtmVnKS5S8EngAeA8YAnwVGAz3uLjjpqRmMCKcD8KH/MLFo1ONEIiLSk3i55X8n8Khz7pfOubXOua8DFcDtJ1l+GrDTOffvzrktzrlFwC+AKQnKm1CjMscAcCDg480PnvM4jYiI9CSelL+ZhYCJwEvHvPUSMP0kq70DFJnZlRZXANwAzO+6pN75eNn1LdNvrf2Dh0lERKSn8WrLvwDwA3uPmb8XOOExfOfcu8TL/jdAGNgPGHDS70mY2VfNrNzMyvfv398ZuRNmatksCpvix/3X1631OI2IiPQkSfNVPzMbTXw3/w+J7zX4G+IDhf882TrOuUecc5Occ5MKCwsTE7ST+Px+RkT7ALA+1Eh17WFvA4mISI/hVflXAlGg3zHz+wF7TrLOt4AlzrmfOudWOOdeBOYAXzSzgV0X1TtlBVMBaPAZLyx83OM0IiLSU3hS/s65MLAUmHnMWzOJn/V/IunEBwytHX2dNHswOmL25Ftbpst3HHt6hIiIyJnxsjTvA241sy+b2Sgzux8oBh4GMLPHzaz15u7zwGfM7HYzK23+6t9/AO8757YnPH0ClA4aQ2k4Pr2hqUf+iiIi4gHPrvDnnHvGzPKB7wBFwCrgCufctuZFSo5Z/lEzywK+BvwbcAR4FfinxKVOvHN9A9nMTjaFYuyo2MCgonO9jiQiIknO093lzrl5zrkhzrkU59xE59ybrd6b4Zybcczyv3DOjXHOpTvnipxzn3fO7Ux48AQ6f+BlADgz5i/6b4/TiIjI3XffjZm1efTvf+qLzc6bN4+hQ4eSmprKxIkTeeuttxKQ9sR65LHynuSTF36JlFj8OtIr9r/rcRoREQEYMWIEFRUVLY+VK1e2u/wzzzzD3Llz+fa3v80HH3zA9OnTmT17Ntu3e3NIV+XfzeVk9mF4OATAh75Kj9OIiAhAIBCgf//+LY9TfZ38vvvu49Zbb+UrX/kKo0aN4he/+AVFRUU89NBDCUrclso/CYxIGw7AnqDx3upXPE4jIiKbN2+muLiYoUOHcsMNN7B58+aTLhsOh1m6dCmzZs1qM3/WrFksXHiyL7h1Ld3SNwlMH34Vz65fDcCry3/L5DGXepxIRKTz/WTJT1h3cF3CP3dkn5H80wWnf+74lClTePTRRxk5ciT79u3jnnvuYfr06axevZr8/Pzjlq+srCQajdKvX9tL2/Tr14+XX375rPOfCZV/Erhk0tXkrvkXDvt9rKtu/7iSiEiyWndwHeV7u/9tzGfPnt3m9dSpUyktLeWxxx7jzjvv9ChVx6j8k0AgEGREJJvF/hrWB2sIhxsJhVK8jiUi0qlG9hmZlJ+bmZnJmDFj2LBhwwnfLygowO/3s3dv29vZ7N2797S+JdAVVP5JYnTu+SxueJNqv48XF/2GKz/2t15HEhHpVB3Z9d6dNDQ0sG7dOi655JITvh8KhZg4cSILFizguuuua5m/YMECrrnmmkTFbEMn/CWJWRNvbplevOkvHiYREend7rrrLt544w22bNnC4sWLufbaa6mtreWWW+I3mX3ggQcYObLt3oQ777yTRx99lF/96lesXbuWuXPnsnv3bm677TYvfgVt+SeLsmFTGPi6Y2fQ2Bg5+VmlIiLStXbu3MmNN95IZWUlhYWFTJ06lUWLFjF48GAgfoLf+vXr26xz/fXXc+DAAe655x4qKiooKytj/vz5LeskmjnnPPngRJs0aZIrL+/+J5K0545HZvBmygFSY443blxMemqG15FERM7Y2rVrGTVqlNcxklp7f0MzW+qcm3Si97TbP4kMzzsPiN/i942lf/Q4jYiIJCuVfxK5cPRVLdNLN+sWvyIicmZU/knk/JEXk98UA2Bz/YcepxERkWSl8k8iPr+f0mgmAJv8NcSiUY8TiYhIMlL5J5nStBEAHAz4eH+dd7eDFBHpDL3lpPOucDZ/O5V/kplYOrNl+u3VOulPRJKX3+8nEol4HSNp1dfXEwwGz2hdlX+SuWTSNaTF4sf9Nxxe4XEaEZEzl5uby969e4k1/z9NTo9zjrq6Onbt2kXfvn3P6GfoIj9JJjUlndJIiNUpTWyxSq/jiIicsYKCAnbu3HncBXHk1ILBIP369SM7O/uM1lf5J6GhwRJWs5kdIWNHxQYGFZ3rdSQRkQ7z+XyUlJR4HaNX0m7/JFRWdGHL9MtLn/YwiYiIJCOVfxK6dNKN+JrP8lyzd5HHaUREJNmo/JNQ/4JBDI4YAFujuzxOIyIiyUbln6SGEj/Dc3Owieraw96GERGRpKLyT1LD888HIOwzXn3vdx6nERGRZKLyT1IfH3dty/Sy7a96mERERJKNyj9JlQ2bQt/mm/xsqt/kcRoREUkmKv8kNrQpfnGHzcE63eRHREROm8o/iQ3LHAXAEb+PhStf9DiNiIgkC5V/Eps0bHbL9OJ1z3uYREREkonKP4l9bMKnyTh6k5+qVR6nERGRZKHyT2KhUArnhFMB2OI75HEaERFJFir/JDc0NASA3UHjw226xa+IiJyayj/JjR14ccv068t+72ESERFJFir/JHfZ5BsINN/kZ93+JR6nERGRZKDyT3L5uf0ZEo7/Y9waq/A4jYiIJAOVfw8wxNcfgC2hGIeO7Pc4jYiIdHcq/x5gZMEkAJrMePm9ZzxOIyIi3Z3Kvwe4ZMLnWqaX73zNwyQiIpIMVP49wPDB4ymKxE/629q41dswIiLS7an8e4jSWC4Am4INNDVFvA0jIiLdmsq/hzgnawwANX4fb33wnMdpRESkO1P59xDTRl7ZMr14w3wPk4iISHen8u8hpo69nOxo/CY/m2rWepxGRES6M5V/DxEIBDmnKR2ALb4jHqcREZHuTOXfgwxNKQVgb9DHqo2LPU4jIiLdlcq/B5lQ8omW6TdX/MHDJCIi0p2p/HuQSyZfR7D5Jj/rD7zvcRoREemuVP49SE5mH0rDfgC2stfjNCIi0l15Wv5mNsfMtphZg5ktNbOLT7F8yMz+pXmdRjPbbmZ/n6i8yWCIvxiArUHH3gO7PE4jIiLdkWflb2bXA/cDPwYmAAuBF8yspJ3Vngb+BvgqMAK4DljRxVGTyui+0wCImfFK+VMepxERke7Iyy3/O4FHnXO/dM6tdc59HagAbj/RwmY2C7gUuMI5t8A5t9U5t9g593riInd/l068oWV65e53PEwiIiLdlSflb2YhYCLw0jFvvQRMP8lqnwXeA+40s51mtsHM/sPMMrsuafIZXDycQeHmm/xEtnmcRkREuiOvtvwLAD8cd1baXqD/SdYpBS4CzgOuAb5G/BDAoyf7EDP7qpmVm1n5/v37zzZz0hji8gHYFAzT0FjncRoREelukulsfx/ggJuad/e/SHwAcI2Z9TvRCs65R5xzk5xzkwoLCxOZ1VPDcsYCUO/z8eb7/+txGhER6W68Kv9KIAocW9r9gD0nWacC2OWca33t2qMXsW/vJMFeZ9qoT7VML938oodJRESkO/Kk/J1zYWApMPOYt2YSP+v/RN4Bio85xj+8+VkHt1uZMmYmOS03+VnvcRoREeluvNztfx9wq5l92cxGmdn9QDHwMICZPW5mj7da/ingAPBrMxtjZhcS/6rgs865fYkO3535/H5KI803+QlUeZxGRES6G8/K3zn3DPAPwHeAZcRP5rvCOXd0K76EVrvznXM1wGVADvGz/n8HvAH8bcJCJ5HS1HMA2BfQTX5ERKStgJcf7pybB8w7yXszTjBvPTCri2P1CONLLuEP21cD8NaKP1I2bIrHiUREpLtIprP9pQPa3OTnoG7yIyIiH1H591A5mX0YevQmP043+RERkY+o/HuwIb749ZK2BmMcOHyyb1CKiEhvo/LvwUYUXgBA1IxX3vudx2lERKS7UPn3YDPGX9cyvWLXGx4mERGR7kTl34MNHzyOokjzTX4adR0kERGJU/n3cENjuQBsDtbT1BTxNoyIiHQLKv8e7pzMUQBU+328u+IFj9OIiEh3oPLv4S4YfkXL9KL1f/EwiYiIdBcq/x7uovGfIvPoTX6q13icRkREugOVfw8XCAQpjaQCsMV3yOM0IiLSHaj8e4GhoSEA7A4aG7ev8jaMiIh4TuXfC5QNuKhl+vVlv/cwiYiIdAdnXP5mNtDMQp0ZRrrGpZOvx998k591+5Z4nEZERLzWofI3swlm9gMzWw5sAyrN7Pdm9gUzy+2ShHLWCvOKGRwxALbGdnucRkREvHbK8jezUWb2H2a2DXgFOBf4MZAHXAQsB+YCe83sFTP7elcGljMzhH4AbAlGqa497G0YERHx1Ols+V8AGPB3QF/n3E3OuWecc1XOuRXOuXucc5OBUuAPwCe7MK+coeH5EwAI+4xXy5/1OI2IiHjplOXvnHvMOfd159zLzrmm1u+Z2fmtltvlnJvnnPubrggqZ+fisde0TC/b9oqHSURExGtne7b/EjO7r/UMM7viZAuLd8adO5XCpvjFfrbUb/I4jYiIeOlsy38lUGVmv241756z/JnSRYZGswHYHKwlFo16nEZERLxytuXvnHN3A8vN7FkzCxI/P0C6odL0EQAc8vsoX/Oax2lERMQrZ1v+VQDOuZ8DzwPPAWln+TOli0wsndkyvXDtcx4mERERL3X0e/6lrV8752a0mn4MeATo2ynJpNPNmHgVqbH4xX42HF7hcRoREfFKR7f8N5jZDSd70zn3J+dcn7PMJF0kNSWdcyJBALbZAY/TiIiIVzpa/gbMNbP1ZrbOzJ4ws5mnXEu6jSGBQQBsDzp27tvqbRgREfHEmRzzLyF+MZ8ngEzgf83sV2ammwQlgTH9pwPgzHit/GmP04iIiBfOpLBvcs592zn3I+fcVcA44pf5/afOjSZd4ZJJN2DNN/lZvWehx2lERMQLHS3/SmBf6xnOuY3Er+3/5c4KJV1nYN8hlBy9yU/TDo/TiIiIFzpa/suAr55g/jZgwFmnkYQY7PIB2BwM09BY53EaERFJtI6W/3eAr5rZ78xshpn1MbMBwHeBzZ0fT7rCubnjAKj3+Xh96Z88TiMiIonWofJ3zi0BpgD5wAJgP7Ad+AxwZ6enky5x4ZjPtEwv3bzAwyQiIuKFQEdXcM6tAi41s3xgIuAHFjvnDnZ2OOkaE0fOIG9xjEN+H5vr1nsdR0REEuyUW/5mVmJm2cfOd84dcM695Jx7oXXxm9m4zg4pncvn91MayQBgi7/K4zQiIpJop7Pb/5PAfjN7yczuMLNBrd80M5+ZXWJmPzezLcAbXZJUOtXQtHMA2B/wsWLDIo/TiIhIIp2y/J1zDwHnEr9pz2eBjWa21Mx+aGZPEP/63+NACLgNXds/KYwffGnL9Nsr/+hhEhERSbTTOuHPObfdOfeAc24m8XL/d6CU+Ml+lzvnBjnn5jjnXnTORbowr3SST0y6llDzTX7WH3jf4zQiIpJIZ3LC3xHgyeaHJKmsjFyGRvysT4mxlb1exxERkQTS9fh7sSH+YgC2BR17D+zyOI2IiCSKyr8XK2u+yU/UjJcWP+FxGhERSRSVfy8264Kb8TXf5GdFxZsepxERkURR+fdixYWDGRqJ/yuwKbrT4zQiIpIoKv9e7hyLH/ffHIrpuL+ISC+h8u/lxhZdCOi4v4hIb6Ly7+V03F9EpPdR+fdyOu4vItL7qPxFx/1FRHoZlb/ouL+ISC+j8hcd9xcR6WU8LX8zm2NmW8ysoflOgRef5noXmVmTma3q6oy9gY77i4j0Lp6Vv5ldD9wP/BiYACwEXjCzklOsl0f8FsKvdHnIXuQcKwJ03F9EpDfwcsv/TuBR59wvnXNrnXNfByqA20+x3n8BjwHvdnXA3qSs/0VA/Lj/giW6YaOISE/mSfmbWQiYCLx0zFsvAdPbWW8O0A+4p+vS9U4zL/hiy3H/5bt13F9EpCfzasu/APDDcTeS3wv0P9EKZjYW+D7wBedc9HQ+xMy+amblZla+f//+s8nb4w3sO4Sh4fi/Dpt13F9EpEdLirP9zSwFeAa4yzm35XTXc8494pyb5JybVFhY2HUBe4hzfPHj/ptCUfYf2u1xGhER6SpelX8lECW+C7+1fsCeEyxfBIwCft18ln8T8D1gTPPrWV2atpdofdz/xUX6vr+ISE/lSfk758LAUmDmMW/NJH7W/7F2AWOB8a0eDwMbm6dPtI50kI77i4j0DgEPP/s+4AkzWwK8A9wGFBMvdczscQDn3M3OuQjQ5jv9ZrYPaHTO6bv+neTocf9NKU7H/UVEejDPyt8594yZ5QPfIb5bfxVwhXNuW/Mi7X7fX7rGOb4iNrG75bh/YV6x15FERKSTeXrCn3NunnNuiHMuxTk30Tn3Zqv3ZjjnZrSz7t3OubKEBO1FdNxfRKTnS4qz/SVxdNxfRKTnU/lLG/q+v4hIz6fyl+OU6vv+IiI9mspfjlPW70JAx/1FRHoqlb8cZ9aUm7Hm4/4rdNxfRKTHUfnLcQb2HcLQiAGwScf9RUR6HJW/nNA5Fv9+/2Yd9xcR6XFU/nJCR4/7N5nx0uInPU4jIiKdSeUvJ9T6uP/yXW94nEZERDqTyl9OSMf9RUR6LpW/nJSO+4uI9EwqfzkpHfcXEemZVP5yUjruLyLSM6n85aR03F9EpGdS+Uu7Si1+nX8d9xcR6TlU/tKusTruLyLS46j8pV0zJ3/xo+P+us6/iEiPoPKXdg3qX9py3H9z0w6P04iISGdQ+cspHT3uv0nH/UVEegSVv5zSuP4XA/Hj/s+//UuP04iIyNlS+cspffbi20iJxY/7l1e86nEaERE5Wyp/OaW8nEJGhlMBWOOvpKkp4nEiERE5Gyp/OS1js8YDcCDg4+Ulv/M2jIiInBWVv5yW2ZO/3DL9xvrfe5hERETOlspfTsu4c6cyJByfXhvZ7G0YERE5Kyp/OW1j/EMB2JTiWLt5qcdpRETkTKn85bRdOOyzLdN/XvyId0FEROSsqPzltM2e/kXyojEAVla973EaERE5Uyp/OW2BQJDRTX0AWBOq53B1pceJRETkTKj8pUPO7/cxABp9xv+++Z8epxERkTOh8pcO+cxFcwg23+WvfPfLHqcREZEzofKXDumXP4CR4RAAq337iEWjHicSEZGOUvlLh41JHwfA/oCPV8v/6HEaERHpKJW/dNjs87/UMv36mqc9TCIiImdC5S8ddv7oj1PSfLW/NZEN3oYREZEOU/nLGRntGwTAxlCMD7et8DiNiIh0hMpfzsj00k8D4Mz48yJ95U9EJJmo/OWMfPLCL5F99Gp/h8s9TiMiIh2h8pczEgqlMKYpF4A1oRqqaw97mkdERE6fyl/O2PiCCwGo8/l47i3d6EdEJFmo/OWMffqiOQSar/a3ZMdLHqcREZHTpfKXMzaw7xBGhIMArLYKXe1PRCRJqPzlrIxJGwPA3qCPt5b92eM0IiJyOlT+clZmjr+5ZfrVVU95mERERE6Xyl/OytSxsxgQiR/3X924zuM0IiJyOlT+ctbGMACADaEoW3ZpACAi0t2p/OWsTRn8SQBiZjy/8GGP04iIyKmo/OWsferivyOz+Wp/yw8u8jiNiIiciqflb2ZzzGyLmTWY2VIzu7idZa82s5fMbL+ZVZvZYjP7dCLzyomlp2YwpikbgNWhauoaaj1OJCIi7fGs/M3seuB+4MfABGAh8IKZlZxklY8DrwKfbF5+PvCn9gYMkjjn5U0FoNbn47k3dbU/EZHuzMst/zuBR51zv3TOrXXOfR2oAG4/0cLOubnOuX91zi1xzm10zv0AWAp8NnGR5WQ+feHt+Jqv9rd4+wsepxERkfZ4Uv5mFgImAsdeE/YlYHoHflQWcKizcsmZG1w8nOHhAABr2O1xGhERaY9XW/4FgB/Ye8z8vUD/0/kBZnYHMBB4op1lvmpm5WZWvn///jPNKqdpTMpIAHYHjbeXzfc4jYiInExSnu1vZtcAPwVucs5tO9lyzrlHnHOTnHOTCgsLExewl7rsvI+u9vfc+/M8TCIiIu3xqvwrgSjQ75j5/YA97a1oZtcS39q/2Tn3fNfEkzNx0fgrGN4Y/1dqidtCQ2Odx4lEROREPCl/51yY+Ml6M495aybxs/5PyMw+R7z4b3XOPdt1CeVMXZhzIQAHAj6eeumnHqcREZET8XK3/33ArWb2ZTMbZWb3A8XAwwBm9riZPX50YTO7AfgN8M/Am2bWv/nRx4vwcmJfnPUd0mPxC/68XqG7/ImIdEeelb9z7hngH4DvAMuAi4ArWh3DL2l+HHUbEAB+TvwrgUcff0xIYDkthXnFTGoqAGB5qJ7Vm8o9TiQiIsfy9IQ/59w859wQ51yKc26ic+7NVu/NcM7NOOa1neAx40Q/W7xzxagvAfFr/T/91k88TiMiIsdKyrP9pXubPe2LDA7Hpxc3raWpKeJtIBERaUPlL53O5/czLe18ACqCxrOvPuBxIhERaU3lL13i5ku/QygWv9zvy1t+53EaERFpTeUvXWJQ0bmcH4nf6e/9lGq27f7Q40QiInKUyl+6zGVDPwdAxIwnX/2Rx2lEROQolb90mWsuuYOiSHzX/7v17xOLRj1OJCIioPKXLhQIBJkaHAXAthC88O5J78EkIiIJpPKXLnXjxf+M38W3/uev/bXHaUREBFT+0sVGlU5kXGMaAOWBSvYf2u1xIhERUflLl5tRfCUAdT4fj7/4Q4/TiIiIyl+63E2z7iK/KX6zn4VVJ71po4iIJIjKX7pcako6U6wUgA9TYrxe/iePE4mI9G4qf0mI66b8Y8v0/y57yMMkIiKi8peEmDRmBmWNAQCW+HZRXXvY20AiIr2Yyl8S5qKCywCo8vt44sUfe5xGRKT3UvlLwnxh1rfIjsZP/Hur8mWP04iI9F4qf0mYnMw+TI4VA7AqJcL7a97wOJGISO+k8peE+sx5t7VM/27Rv3mYRESk91L5S0JdMvkazm00ABa7TTQ01nmcSESk91H5S8JdmH0hAJUBH4//9V6P04iI9D4qf0m4my//LpnNJ/79af+fqGuo9TiRiEjvovKXhCvMK2Z2cDwAO4PGfb+/rf0VRESkUwW8DiC90z9e8zDvPDWN3UFjfuR9Pr9rHUMHjPQ6lpxCpLGWHbsXs3PfcmoaDhNuaiAcbSQcbSDcFCYcCxOOhonEIoSbHyFfkOxgFjmpOeSk5pOdlk9ORj+yM/uTnTWAnKxBBFMyvP7VRHoVlb94IiM9i+v7fY5/P/h7qv0+7pt/O7/4ymtexxKgKdJAxZ6lbKt4n20H1rCtajvbGyrZGq2jwueImXX8h9YDVSd/Oy3myHdGiT+dQan5lGQNoqTPCAb1G8/A4smkpGSd8e8jIscz55zXGRJi0qRJrry83OsY0kosGuULv5rMytQIPue4v+yHzJh0ldexep3qql0sWfUk725/nffqdrHdF6PpTAq+mTlHyEEICAIRoNp3dj+vnzNKfKkMSslncHYJw/tPYsTQmRTkDT3jnyvS05nZUufcpBO+p/IXL72x9H+Zu/L/EDWjrDHIb/7uPXx+v9exerRoU5jV6//Ewo3P8+6htSynkWg7ZZ8WcwzGT0kwm8Hp/Rmcew4lBWXkZBUTCqYTCmYSCmUQCmYQTMkk4E/FfG1PJ2qKNFBTU8GRqp1U1ezhSO0equorOVJ/gKrGwxwOV7Gv8RA7IlVsJ0rtaQ4W8mMwIpDFiKzBDO87nhGDL2FI0QSCvuBZ/Y1EegKVPyr/7uzvf/kJXgvtB+Abfa7lb6/8vseJep6K3UtZuPopFu5dwqLIIapOUK4h55hgaYzOHMTg7KGUFI5hSPEUCgpGHVfmXcnFYhw6uIHtu99jR+Uqth/ewo66PeyIHGG7i3DY336WoHMMszRGZBQxpu/5jCmdyYiiyYT8oQT9BiLdg8oflX93tm33h9z416uo9vsojjievfFtsjJyvY6V9OrrDvLSov/Ls9tfYplFTrjMsKgxLWso0wdfxsSyz5OW3ifBKTvIOQ7sW8X6ra/w4Z73WV+1mXXhw2z10+6hioCD4YFMxmSfQ9mAaYwZcinn5A0j4NNpT9JzqfxR+Xd3P3ryFp6Ovg/AtVbG92/+rceJkteHG1/gD+8/yPO1W4871p4bc0wL5jOtaArTy75Av37jPErZucJVu9m0eQHrdy9m/aH1rG/YzzqLUt3OXoJUjJEp+YzpM5qykhmUFU2mJLsEn+kb0NIzqPxR+Xd3dQ21XPPkFHYGjYxYjCcvfYZhJWVex0oa9XUHefHdn/Ds9gUs97Xdys+POj6bM5KZo29k1PDP4PP3jq1dV3eQHRtfZNX211h1YA2rGw+wNuijvp1DGFkWYExmCWVFkykbMI2y/DL6ZfRLYGqRzqPyR+WfDB6f/2N+uj++xf+xxnwe/Orr3gZKAus3/IVn33+Qv9RtP24rfzppXHfOVXx8ylyCwXSPEnYjsSjRfWvYsvGvrNq9iFVHNrImVs+6lBCRdg4ZFAYyKOszirLiqYwpKGNkn5Hkp+UnMLjImVH5o/JPFl/4z4ksTw3jc45/G/V9LptyndeRuqX3PvgvHlr+EO9ZY5v5BVHHVbmjuPqCf2TgwKkepUsidQeJbFvIh1sWsGrvUlbVVbAqFGBTMIhrZ0DQLyWPUQVjGV1Qxqj8UYzqM4q+6X2xs/iKpEhnU/mj8k8Wby+bz9eX/f80mTG6McBv/65cX/1r5mIxliz7FQ+teISlrUrfnGO6ZXDdsKv42AV/r638sxFpgIpl1G19kzXb32TVofWs8kVZlZLCrmD7h0v6pOQxqmA0o/uMZnif4QzPHU5JdolOKhTPqPxR+SeTf/jVTF4J7gHg67mf5quf+ZHHibzlYjEWffAID6/8Je9buGV+asxxXeY53DTtW6e1ld8UjXG4PsLhujCH6iIcqg23eX24LkxVfRN+n5EW9JMa9JEa8pMa8JMW8pMa8MWfg/FHQWYKA/PSKMxMwXcWF/Hp1mIxqFwP29/l0Na3WLunnLWRQ6wJhVibEmJHsP3rCYR8IUpzSzk391zOzYs/huUOo196P+0lkC6n8kfln0x2VGzghhc+S5XfR/+I49kb3iQns5t/Ba0LuFiMd99/mIdW/arNV/XSYo7rs87llhn3UlBw/P0QmqIxNu2vZdWuI6zcdYTVu4/w4d4ajtSf+Ot+Zyvk9zEgL40BuWkMPPrcJ40BuekMzEujX3Yq/p40OKiqgB2LYPsiqrYvZP3hDawJBlibEmJtKMSWYKDdQwYA2aFshuUOY1juMIbkDGFw9mCGZg+lKLNIewqk06j8Ufknm3t/8yWeaor/87qKUfzLLb/zOFHiuFiMhUvn8dCq/25z5n5azHFD1rncMuMn5BcMByASjbFhbw2rdh1h1e542a+tqKIhEuvQZwZ8Rm56kOy0ILGYoyESoz4SpSESpbGpYz/rWGlBP8P7ZzGqfxYj+2cxqiibkf2zyUnvIVfha6yBXeWwfTFsf5e6Xe+xyYXZGAryYSjIhlCIDaEgB0/j8FXAF6Akq4TB2YMZkjOEIdnxR0l2Cfmp+dpbIB2i8kfln2waGuu45vEpbA9BeizG4zOeZMTQCV7H6nIfrHiS+96/77gt/RuzR3DLJT+hT59h7DnSwII1e3hpzV4WbzlIuJ1yDgV8jCrKZnRRNv2yU8hLD5GbHiQ3PUReerDldWZK4KTFEos5Gps+GgzUR6LUh6PsrWpg1+F6dh6qZ9ehenYeqmPnoXoO1IZP+HOOVZyTysiibEYVZTGyfzaji7MZmp+R/IcQYlHYvz4+INhZDruWwr41HDDYEAqysXkwsCEYZEsoSM1pXj0x1Z9KUWYRAzIHMCBzAMWZxRRnFjMgIz7dJ7WPBgfShsoflX8yeurFn3LvnscBGN7o48Gr/0z/gkEep+oamzYt4OfvfJ/XXXXLvPSY46bskXzxkp9wINKXl9bs5aXVe1i+88gJf0Zq0MfoomzKBuRQNiCHsQNyGNY3k+ApLofb2erCTew+XM+OQ/GBwca91azdU83aiiqqG5raXTcrJcC4QTmMG5jLeQNzOW9QDv2zU5O/1MK1sHtZ2wFB1S4ccMDvY2swyNZggG2B+PPWYJCdwUCHbrB0dHDQN70vfdP6UpheGJ9O70thWmHLc9DfQ/a4yCmp/FH5J6uvPDKdRSnxQhzR6OPBa+bTL3+Ax6k6z969K3jo1bv4U+PullvlpsQcN2UNZ/LI7/H2jhQWrN7L5sra49btn53KpaP6cn5JHmMH5lBakEEgwUXfEc45dh9pYF1FFev2VLOmoop1FVVsqawl1s7/hvpmpTBuYC7jWw0KesQhg+o9ULEcKlbAnuWwZyUc2trydgTYHQiwNRhgZzDArkD8sTslnV0BH9Wc2eGYvJQ8CtMLyUvNo09qH/qk9iEvJY+81DzyU/PJS81reS8rlKUrHiYxlT8q/2RVW1fN7U98gg9SG4CeMwCortrFfy+Yy5NV62ho3s3tc46/8fclI/Q1ntuQTWVN43Hrnds3k1lj+jFrdH/GDshJ/l3kQEMkyod7q1m56wgrdhxh+c7DfLi3ut0BwdCCDMYPym15jCrKJhToASVVfxj2rmoeEKyEPStg/zqIHb/HpMpnVBwdEAQC7ErPoSItk/3+APssSmW0niZ3dudr+M1PTkoO2aHsNs85KTnkhHLITslumZcVyiIzmBl/hDLJCGZo4OAxlT8q/2RWW1fN7U9+gg9Skn8AEG6s5plX7uKRve9wuFVxT2lKI1p7I6/tHt5meTM4vySPWaP7MXN0P0oLMxMd2RN14SZW7api+Y7DLN8Zf+w4WH/S5UMBH2OKszlvYC4TSuIDgpI+6cl/uADi1x44sDE+CKj8MP68fz0c2ASxk3+DIwYc8vnYH/CzLy2X/dmF7EvLZl8olUqfcZAoh6INHAxXUdtU1yXRM4IZbQYEmaFMMgIZpAfTyQhmkB5IbzPdel56MJ20QBppgTTSA+mkBlI1mOgglT8q/2RXXXuYOU9exrLU+NbwyEY/866bT2FescfJTk+0Kcz8t/6FB7f8L7tanfQ9Iuwjuv9yPqj6eMs8M7hoWAFXjC3i0lF96ZuV6kHi7udATSMrdh5hWfOAYNmOwxyuO3n55aUHGTswl7EDshk7IJexA3MozukB5w8cFY3AwS3x6xAcHRBUbogfOmg43KEf1ZiSzaGc/hzKKOBgei4HUzM5FEzhUCDAEWJUEeVItIEj4WqqwlUcaTxCTaSmS36t9hwdDLQeFBydTg2kHvd+WiCNtGAaqf7Uj5Ztft16vfRAOgHfyU96TVYqf1T+PUEyDgCiTWFefOdHPLzpT2zxf/Tf2oCII3PfVMqrPgPEt2b6Z6fyuUkDuW7SIAb10VX6TsU5x7YDdSzbcbjlsWZ3FeHoyXd198kIMbb5ZMiyATmMG5hDUU8aEBxVfyg+CDi4Jf58aEvz9Dao2glnejggJQcyCyGjkKb0fKrT8ziSmsWRlDRqAilU+wPU+owagxocNbEINU211IRrqI5UUxOuoa6pjtpILfWRemqbaomd5aGJzuI3/6kHEu08jl0nPZDeZqDh9yX+SqUqf1T+PUV17WFuf/IyljcPAEY1+nmwGw4AYtEmXnrnRzy08Q9sblX6eU0xBh0YxeKDN9FECn6f8YmRfbnxgkF8fHjfnnUxHA80NkVZW1HNsu2HWLEzft2DjftraO9/c/kZIUY2f91wRPO1CM7tm0VaqIdeVropDEd2QHUFVO2Gql3Nz62ma/YBndAN5oPUHEjNhbQ8SMuNv07JgpRsXCiTxlA6tcEU6gIh6vwB6nzxAUSdQb056l2MuliY+qZ66iP11DXVxaeb6qmLxKcbog0t79c31VMfrafpBOdJeCnkC5EWPPGgofUejK9P+Do5KTmd8pkqf1T+PcmRmoPc8ZuZLE+Nf598VKOfhz73V/Jz+3ucLF76Cxbey8Mbfs/GVqWfG40x5GAp5Qduot5lU9InnesnD+K6iQPpm63d+l2ptrGJNRVVrGweDKzcdYRNpxgQmMGQ/AxG9MtqGRCM6J9FSZ/0bv2Nik4TjcS/jVC1G2r3H/+oaTVdf7Dr8/iCEEqHUCaEMiDYajqUHn8dTGt+xKcjgRTq/QHqfQEa/H7qzZofUA/UE6OBGPUuSn2siYajA4xTPBqa4gONqIt2ya/62udeoyCtoFN+lsoflX9Pc6TmIHN+M5MV3WQAEIs28fLCf+Whjb9no++j3Zg50RhDDw6l/MDnafLlcPmY/tx4QQnTSvN7xJn6yaqmsYk1u6vilz/edYR1e6rZuK+m3UMGAEG/MahPOqUFGQzJz2BoYQZDC+KPHnE9gjMRjUDdgfihhvpD8W8s1B+Kn3dw7Lz6Q9BY/dEjcvxXWD3jC340gAiktppOO26+C6QSCaZQ7wtSH4jvrWjw+6n3+ag3X3yAYY564nsu6lsNMupPMcj46zV/JSOY0Sm/ksoflX9PdOwAYHRjgP+45s8J/RZAuLGa15b8nEc2PMuH/mNLfwhLD3yevn2KuPGCEq6dOJD8zJSEZZOOiURjbK2sZd2eatbvqY4/761q91sGraUF/QzOT6e0MINBeekU56Y1P1IZkJtGTlqwdw4O2hNtgnB12wFBYzU0HIlfGClSB+Ga+HS4FsKtXrd+L9IQfx2ph6bT++flGfO12lPRvNeiZe9FOnx2HmRoy7/TqPx7piM1B7n9qctYmRI/6zsjFmNyU18+PfY2Zk69vks+M9oUpnzFo/x53e95pXE31a0uz5odjVF6cAjLDn2Bj40ewU1TtJWf7Goam/hwbzUf7qlmS2Utmytr2VpZy7YDdafcU9BaWtBPcW4qxbnxmx8V5aTRPyeFgsz4Iz8zREFmCqnBHnquQaLEYtDUEB8IHB0QROpaDQ6Ovtdquuno4KH5+UTLHB1YRFo9osdfi+OsfXNT7yh/M5sDfBMoAlYD/+Cce6ud5T8O3AeMAXYD/9c59/CpPkfl33Mdrq7kjqcub9kDcNSwRmN61jRunvW9s94b4GIxVq39A/+z4jFerd9Kpb9tmWdFY5xzaDB7ol/h6gvGce3EgRRmaSu/J4vGHLsP17OlspatB2rZvD/+vKWylorDDR0aGLSWlRKgICuFgubBQH5miD4ZKeSkBclNC5KTFiQnvfm5+aEBg0di0WMGGg1tBxxNDfG9FS3zaj8aOIRr2847utyXXojvCegE3bb8zex64ElgDvB28/OXgNHOue0nWH4osAr4b2AecFHz8w3OuT+091kq/54tHG7k8b/+iNcr5rMipaHNLVXTYzEmNRXwqdFf5vKpN+E7jburHbV+4wL+sORh3qxfz65A28IPOMeIuhR8NeMo6P9Frps2lgvPKdBWvhCLOSprG9l9uIHdh+vZfbieXc3PFUfi8yprTu8GSKcjFPCRkxYkOzVAZkqAjOZHfNoffx06Oi/+Oi3oJy3oJzXkb5lOC/lJbZ4O+k2HKZJcdy7/xcAK59xXWs3bADzrnPvWCZb/CXC1c+7cVvN+BYxxzk1r77NU/r3HsvVv88zCn7IotpHKYy75OjQM09InUZA5gLrGI9Q3VVPfVENDtI6GaD0NrpEGIjQQocqa2Bls+z8/c47h9QFyG8YwcNCtzBh7HlNL87XlJR3WEImyv7qRyppGKmvC8efqRg7UhtnfPH30vSP1J7+YUVfx+4zUgI/UoJ+UgI+UY58DPlICflKD8edQyzxfy3Qo4CPkj68Tf46/DrVexu9vef3R8s3L+X0aTJ+Fbln+ZhYC6oAbnXO/bzX/QaDMOffxE6zzJrDSOXdHq3nXAU8B6c65k/4XovLvfRoa6/jtgn/jtd3PsTxU33LjnDNR2gAlTSMZMfRvmXn+RQzvl6mtIkmYpmiM6oYmjtRHTv6oi1DdGKGmMUptYxO1jU3UND/XNkbP+DCE14J+azOAaD1ICLUZbPhPOPhoPTBpvdxx85oHHKnB+IAkJdj2/WS8Bkd75R9IdJhWCgA/sPeY+XuBy06yTn/g5RMsH2j+eRWt3zCzrwJfBSgpKTnLuJJsUlPS+dKnvsuX+C6rNi7mt2/9hEWx9ew7wQ1gUmKO9JgjLWakOiPF+QnFAhT6BjDp3FuYPeVT9MkIefBbiEDA7yMvI0TeWfw7GG6KURc+OiCI0hCJUt/8aAh/NF0fbvVeOEZjU5TGplj8EYnS0PzcMq8pSmPko+lwU4xwNNbudRQ6IhJ1RKJRasNd87360+X32TGDi2MHFT5CxwwsUlotd+xgJXTMe0eXnzgkj5RA1+9J9LL8u5xz7hHgEYhv+XscRzxUNmwKPxr2R8LhRt54/38AIyuzL3lZ/cjL6U92RjYpAZ+25qXHihdOiNz0rh/EOueIRB3haHygEI7GCDcPFlo/fzS/edDQZt5HrxsjMcLRtsvE5x37M6PHrdfYFG33DpGnKxpz1IWj1HXxIGTJty+lb3bPLv9KIAr0O2Z+P2DPSdbZc5Llm5p/nki7QqGULvsKoIjEmRmhgBEK+MhM8X4bsynadlBxdDDREGk7SDh2gNJ63tE9HG2Wbz0IicRobDXY+Wj+R4Of0xmEJGKrHzwsf+dc2MyWAjOB37d6ayZwsjP33wWuOmbeTKC8veP9IiLSewX8PgJ+HwnY6dGupuiJ9nq03fORkdLDy7/ZfcATZrYEeAe4DSgGHgYws8cBnHM3Ny//MPA1M/s58J/AhcCtwI0JTS0iItJBRwchGd3gEiCelr9z7hkzywe+Q/wiP6uAK5xz25oXKTlm+S1mdgXw78DtxC/y8/en+o6/iIiIfMTrLX+cc/OIX6jnRO/NOMG8N4DzuziWiIhIj9UL7k0pIiIiran8RUREehmVv4iISC+j8hcREellVP4iIiK9jMpfRESkl1H5i4iI9DIqfxERkV5G5S8iItLLqPxFRER6GXOud9zm3sz2A9tOueDpK0C3ET5b+huePf0NO4f+jmdPf8Oz19l/w8HOucITvdFryr+zmVm5c26S1zmSmf6GZ09/w86hv+PZ09/w7CXyb6jd/iIiIr2Myl9ERKSXUfmfuUe8DtAD6G949vQ37Bz6O549/Q3PXsL+hjrmLyIi0stoy19ERKSXUfmLiIj0Mir/M2Bmc8xsi5k1mNlSM7vY60zJwsw+ZmbPmdkuM3NmdqvXmZKNmX3LzN4zsyoz229mz5tZmde5komZ3WFmK5r/hlVm9q6ZfdLrXMms+d9LZ2YPeJ0lWZjZ3c1/s9aPPYn4bJV/B5nZ9cD9wI+BCcBC4AUzK/E0WPLIBFYBc4F6j7MkqxnAPGA68AmgCXjZzPp4GSrJ7AT+CTgfmAS8CvyPmY3zNFWSMrOpwFeBFV5nSULrgaJWj7GJ+FCd8NdBZrYYWOGc+0qreRuAZ51z3/IuWfIxsxrga865R73OkszMLBM4AnzWOfe813mSlZkdBL7lnPtPr7MkEzPLAd4Hvgx8H1jlnPuat6mSg5ndDVzrnEv4njtt+XeAmYWAicBLx7z1EvGtMBEvZBH/b/mQ10GSkZn5zewG4nulFnqdJwk9Qnzj5zWvgySpUjPb3Xwo+WkzK03EhwYS8SE9SAHgB/YeM38vcFni44gA8cNQy4B3Pc6RVMxsLPG/WSpQA1zlnFvpbarkYmZfAYYBX/A6S5JaDNwKrAP6At8BFprZGOfcga78YJW/SBIzs/uAi4CLnHNRr/MkmfXAeCAHuBZ4zMxmOOdWeZoqSZjZCOLnPl3knIt4nScZOedeaP3azBYBm4FbgPu68rNV/h1TCUSBfsfM7wck5AxNkaPM7N+BG4BLnHObvc6TbJxzYWBj88ulZjYZ+Abwd96lSirTiO8NXW1mR+f5gY+Z2W1AhnOu0atwycg5V2Nmq4Fzu/qzdMy/A5r/Z7EUmHnMWzPRsUJJIDO7H7gR+IRzbp3XeXoIH5DidYgk8j/Ez0wf3+pRDjzdPB32JFUSM7NUYCRQ0dWfpS3/jrsPeMLMlgDvALcBxcDDnqZKEs1npg9rfukDSsxsPHDQObfds2BJxMweBL4IfBY4ZGb9m9+qcc7VeBYsiZjZvwJ/AXYQP2HyJuJfodR3/U+Tc+4wcLj1PDOrJf7fsg6dnAYz+xnwPLCd+DH/7wIZwGNd/dkq/w5yzj1jZvnET8woIv6d9Succ9u8TZY0JgGtzwr+QfPjMeInvsipzWl+fuWY+T8A7k5slKTVH3iy+fkI8e+nz3bOvehpKultBgK/JX74ZD+wCJiaiD7R9/xFRER6GR3zFxER6WVU/iIiIr2Myl9ERKSXUfmLiIj0Mip/ERGRXkblLyIi0suo/EVERHoZlb+IdBkz+6mZ6cI5It2Myl9EutIFwBKvQ4hIW7rCn4h0OjMLATVAsNXstc650R5FEpFWtOUvIl2hifgtXwGmEL8PxoXexRGR1nRjHxHpdM65mJkVAdXAe067GEW6FW35i0hXmQAsV/GLdD8qfxHpKuOBD7wOISLHU/mLSFc5D1jhdQgROZ7KX0S6SgAYaWbFZpbrdRgR+YjKX0S6yv8BbgB2Avd6nEVEWtH3/EVERHoZbfmLiIj0Mip/ERGRXkblLyIi0suo/EVERHoZlb+IiEgvo/IXERHpZVT+IiIivYzKX0REpJdR+YuIiPQy/w+jwZRhZofMmwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -262,7 +267,7 @@ "\n", "The `tcut=1.25` result matches the other two exactly until `t=1.25` (no memory approximation is made before this time), but deviates shorlty after. On the other hand, the cost of using the larger `tcut=2.5` was a longer computation: 1.6s vs 0.8s above. This was a trivial example, but in many real calculations the runtimes will be far longer e.g. minutes or hours. It may be that an intermediary value `1.25<=tcut<=2.5` provides a satisfactory approximation - depending on the desired precision - with a more favourable cost: a TEMPO (or PT-TEMPO) computation scales **linearly** with the number of steps included in the memory cutoff.\n", "\n", - "### A word of warning\n", + "#### A word of warning\n", "\n", "`guess_tempo_parameters` provides a reasonable starting point for many cases, but it is only a guess. You should always verify results using a larger `tcut`, whilst also not discounting smaller `tcut` to reduce the computational requirements. Similar will apply to checking convergence under `dt` and `epsrel`.\n", "\n", @@ -273,7 +278,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Discussion - environment correlations\n", + "### Discussion - environment correlations\n", "So what influences the required `tcut`? The physically relevant timescale is that for the decay of correlations in the environment. These can be inspected using `oqupy.helpers.plot_correlations_with_parameters`:" ] }, @@ -294,7 +299,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -328,8 +333,8 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Choosing dt and epsrel\n", - "## Example - convergence for a spin boson model\n", + "## Choosing dt and epsrel\n", + "### Example - convergence for a spin boson model\n", "Continuing with the previous example, we now investigate changing `dt` at our chosen `tcut=2.5`." ] }, @@ -365,7 +370,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -436,7 +441,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAF7CAYAAADc0IJwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABWSklEQVR4nO3deXxV9Z3/8df3btkDgQSSsAeQJWFLAgioFau41WWwDmr1p21tx6IWpe1UW/3Rzri0nba/QYVxajvgMq1UW607oAKC7EsgrIJsAiHsELLfe7+/P268JpCEBJKc3OT9fDzuI8nZ7ueeBN7nfL/fc46x1iIiIiLth8vpAkRERKRlKfxFRETaGYW/iIhIO6PwFxERaWcU/iIiIu2Mwl9ERKSd8ThdQEtJTk62vXv3droMERGRFrFmzZoj1tqU2ua1m/Dv3bs3q1evdroMERGRFmGM2VPXPDX7i4iItDMKfxERkXZG4S8iItLOKPxFRETaGYW/iIhIO9NuRvuLiNQlGAxy5MgRTpw4QSAQcLockXNyu9107NiR5ORkXK7Gn8cr/EWk3du3bx/GGHr37o3X68UY43RJInWy1lJZWUlhYSH79u2jZ8+ejd6Gmv1FpN0rLi6mW7du+Hw+Bb+0esYYfD4f3bp1o7i4+Ly2ofAXEYHzajoVcdKF/M069tdujLnMGPOWMWa/McYaY+5pwDpDjDGLjDGlVev9X6PDdBERkUZx8lA3HtgITAFKz7WwMSYRmA8UAiOr1vsJMLUZa6zViZMnOHlyX0u/rYiISJNwLPytte9Za39mrX0dCDZglW8BscDd1tqNVev9Gpjakmf/Ow9tZcqfx3PL69exY98XLfW2IiIiTSaSOrnGAIuttdVbCeYC6UDv2lYwxnzfGLPaGLP68OHDTVLE6+9NY22sn0KP5aW/3sgz76+jtEKXBolI2/f888/Tv39/p8uQJhBJ4Z9KqMm/usJq885irf2DtTbXWpubklLrUw0b7e6bnqen3wvA+0kV9Fv5L3zjd3P5YGMB1tomeQ8RkdYoLy+P4cOHA/CTn/yEq6++2tmC5LxFUvi3Cl2TkvjFNc8BUOZysSD5CP9e8u889Moy7pm1itPlfocrFBFpHnl5eYwYMQKAlStXMmrUKIcrkvMVSeF/EOh6xrSu1ea1mJHdxnJNz6sA+CA+Dm/c57zg/R3LP9vPv729qSVLERFpFnl5eYwfP56YmBiGDBnCypUryc/PJysrC5/PxyeffMITTzyBMYbBgwc3aJuzZ89mxIgRxMbGkpiYyMUXX4zfrxMmJ0RS+C8DLjXGRFebdhVwANjd0sX8aNS/Eu2OAuBXnZIY497IC97f8Y/VO/lw85m9EyIikWP79u187WtfY/To0eTn5/OrX/2Kf/7nf6akpITc3FyWLVsGwIoVKygoKODTTz895zbffvttpkyZwr/+67+yZcsWli9fzqOPPorHoxvNOsHJ6/zjjTHDjTHDq+roWfVzz6r5TxtjPqq2yp+BEmC2MSbLGDMReAT4vXWgsz01LpV7h3wPgM+ifLyeEM9l7nye9/4/Hv/bWo4VV7R0SSIiTeKBBx7g+uuv51e/+hX9+vXj+uuv56qrrqJLly6kp6dTUFBAQkICI0eOJDU1laSkpHNuc+vWrfTo0YOrr76aXr16MXjwYG666aZG1/aPf/yDKVOmnM/HkmqcPPPPBdZVvWKAX1Z9/29V89OAvl8ubK09SehMPx1YDcwAfgf8vuVKrumerHvoFt8NgGc7J3PC5WK8ez3/XvFrfvnGWqfKEhE5b1988QXz5s3j4YcfrjHd6/WGB/utW7eOYcOGNepWyN/97neJjo6mc+fOxMfHs3HjxjqXre/hShs2bGDo0KENfl+pnZPX+S+01ppaXvdUzb/HWtv7jHXyrbWXWWujrbVp1tpfOnHW/6UodxQ/GfkTAE6ZIM/2GADAle51XL/tZ7y9brdTpYmInJd169bhdrsZNmxYjelr164Nh3/1gX8N4ff7uf3228nJyWHVqlXk5eUxaNCgGsvceOONTJ48mZEjRzJr1iy2b9/O9ddfT05ODpdddhmHDh0CFP5NJZL6/FulK3pcwZi0MQC87i5lY7fhAExwryH2H9+j8HiRg9WJiDSOMYZAIEB5eXl42uLFi1mxYkU48NevX9+oAH7jjTfYtGkT//3f/01ubi79+vXD7XbXWCY/P58BAwawatUq7rrrLiZPnsx///d/s2bNGu644w7+8Ic/ALBp0yaysrKa4JO2bwr/C2SM4ZFRj+AxHoI2yH9068GxTqF/FF9nJXtfuB0bqHS4ShGRhsnNzSUqKoof//jHfP7557z77rvceeedAOEzf7/fz9atWzlw4AAnTpw45zbLy8s5dOgQL774Irt372bTpk386U9/Cj+RrqioiEAgEO7Lf/PNN9m0aRPf+MY3GD58ONOnT8fr9VJaGrrHW0xMTNN/8HZG4d8EMjpmcPug2wFYe3g9K655iD3RAwEYWbKY/HdmOlmeiEiDpaWlMWvWLD744AOysrJ48sknueeee4iNjeWiiy4C4Mknn+TVV1+le/fuPProo+F1Z8+ejTGG3bt319jmbbfdxg9/+EMef/xxBgwYwBVXXME777xDXFwcEDqbHzt2bHj5/Px8fve735GXl0deXh5btmzhpz/9KRs3biQzM7P5d0I7oPBvIj8Y9gM6RXcC4LfrZxL1ndc5SGcAYvJf1t3/RCRi3H777ezZs4fS0lKWLl3KL3/5S4qLi8OPkP3Wt77Fvn37CAaD/Nd//Vd4vV27djF48GC6d+9eY3sej4ff/va37N27l/LycgoLC3njjTfC8/Pz8xkyZEj459TUVObOnRv+ecOGDeGv6u9vGgr/JpLgS+Ch7IcAOFRyiL/ue4Nd3f8JgP7+7WzJW+pgdSIize+9995jxowZjb52/8zw//a3v82JEycYOHAgw4YN45VXXgEU/k3JtJcz0tzcXLt69epmfY+gDXLHu3ew6egmvC4vs0b9J0P+fCMuY1nQcSLjH5rVrO8vIudny5YtZ40+F4kE9f3tGmPWWGtza5unM/8m5DIuHh0d6v+qDFbyp/2vsz0+G4Dhx+fxxaFjTpYnIiICKPyb3LCUYdzY90YAFnyxgC1DLgcgyZxm1QcvO1iZiIhIiMK/GTyc8zBx3tAo1j+VruS4iQcg7fPX9NQ/ERFxnMK/GSTHJPODYT8AYPepPbyYMRKAMSaf9z5Z7mRpIiIiCv/mcsfAO+id2BuAV80BjrhDu7p4xYsEgu1jkKWIiLROCv9m4nV7+emonwJQHCjl1116AzCh8iPmbzrgYGUiItLeKfyb0SXdLuHyHpcD8EG0nw1RPrqZo6z5+O/OFiYiIu2awr+Z/Wvuv+J1eQF4qnNngsDwI2+Rv++ks4WJiEi7pfBvZj0Se3BP5j0AbIry8o/4OK5yreGd5RucLUxERNothX8LuHfIvXSJ7QLAf3bqSLkrSNTm1zXwT0REHKHwbwGx3lh+lPMjAI653Tyf1IHr/R+yYucRhysTEZH2SOHfQq7tcy3ZXUK3+v1zYgLeqINsWP6hw1WJSFswc+ZM+vTpQ3R0NDk5OSxevLhJ1ikoKODuu+8mJSWF6OhoBg8ezKJFi8Lzn376aUaOHEliYiIpKSnccMMNbNy4scY2fvGLX2CMqfFKTU1t9Gc8Vy21KSoq4qGHHqJXr17ExMQwduxYVq1a1ej3bgpNsb+bksK/hRhjeHT0o7hw4TeGX3dKosvnf8UfCDpdmohEsDlz5jBlyhR+9rOfsW7dOsaOHcu1117L3r17L2idEydOMG7cOKy1vPvuu2zZsoVnn32WLl26hJdZuHAhkydPZunSpXz88cd4PB6uvPJKjh2r+RyTAQMGUFBQEH7l5+c36jM2pJba3HvvvcydO5cXX3yR/Px8JkyYwJVXXsn+/fsb9f4Xqqn2d5Oy1raLV05Ojm0N/m3pv9ms2Vk2a3aWffdX3e2nm3Y7XZJIu7d582anSzhvo0aNsvfee2+Naf369bOPPPLIBa3z6KOP2rFjxzaqlqKiIutyuexbb70VnjZt2jSbmZnZqO2c6XxqKSkpsW6327755ps1pmdnZ9uf//znNabt27fP3nXXXbZTp062Q4cOduLEifbgwYMXVHN1zbW/ra3/bxdYbevIRJ35t7AHRjxAojsGgGc6x7N3qR72IyLnp6KigjVr1jBhwoQa0ydMmMDSpUsvaJ0333yT0aNHM2nSJLp06cLw4cN57rnnsPU8Br6oqIhgMEhSUlKN6Tt37iQ9PZ0+ffpw2223sXPnzkZ9zvOpxe/3EwgEiI6OrjE9JiaGJUuWhH/etWsX2dnZdOvWjSVLlrBw4UKOHDnCfffd16ga69Kc+/tCeJplq1KnpOgkHsiewlOrfsV+r4dtx/5GZeBneN06DhNpLX759iY2HzjV4u87OD2RaTdkNnj5I0eOEAgE6Nq1a43pXbt25cMPax9T1NB1du7cycyZM3n44Yd55JFHyMvL48EHHwTggQceqHXbU6ZMYfjw4YwZMyY8bfTo0cyePZuBAwdy6NAhnnjiCcaOHcumTZvo3Llzgz7n+dSSkJDAmDFjeOKJJ8jKyiI1NZW//OUvLFu2jH79+oWXu++++/jud7/LU089FZ72+OOPM3HixAbVdi7Nub8vhMLfAbcOnMQrq55jL6d5t2MFF694n6vHXu90WSJSZfOBU6zYdezcC7ZhwWCQ3Nxcnn76aQBGjBjB9u3bmTFjRq1hNHXqVJYsWcKSJUtwu93h6ddee22N5S6++GIyMjJ48cUXmTp1arPU8qWXX36Z73znO3Tv3h232012dja33347a9asAWDPnj3MmzePxYsX88wzz4TXCwQCxMbGnrW9xx57jCeffLLeWhcsWMDll1/eoM/VFJ/xfCn8HeBxefhpzo+4f80vKXW5+Mvm3yr8RVqRwemJEfG+ycnJuN1uCgsLa0wvLCysc0R9Q9dJS0tj8ODBNZYZNGgQ06dPP2ubDz/8MK+++ioLFiwgIyOj3prj4+PJzMxk+/bt9S5XXWNqqa5v374sWrSI4uJiTp06RVpaGpMmTQrXuH79ehITE8MHA9X5fL6zpj300EPceeed9b5nz549a/zcHPu7KSj8HXJZ1jcZu+QplsZUssZ7hOVfLOPiHmPOvaKINLvGNL07yefzkZOTw/z587n11lvD0+fPn88tt9xyQeuMGzeObdu21Vj3s88+o1evXjWmTZkyhTlz5rBgwQIGDhx4zprLysrYunUr48ePb9BnbEwtdYmLiyMuLo7jx48zd+5cfvOb3wDg9XopLi4mNTWV+Pj4c24nOTmZ5OTkBtcNTb+/m0xdIwHb2qu1jPavbt4bv7K5/zPYZs3Oste9Mt5WBiqdLkmkXYrk0f6vvvqq9Xq99oUXXrCbN2+2P/zhD21cXJzdvTt0JdGzzz5rBwwY0Kh1rLV25cqV1uPx2CeeeMJu377d/vWvf7WJiYn2ueeeCy8zefJkm5CQYD/66CNbUFAQfhUVFYWX+dGPfmQXLlxod+7caZcvX26vv/56m5CQUOO9zqUhtdT2OT/44AP73nvv2Z07d9p58+bZYcOG2dGjR9uKigprrbXHjh2zycnJ9uabb7Zr1661O3bssPPmzbOTJ0+2gUCgwfWdS1Pt79qc72h/x0O5pV6tMfyLik7a6b/vE77072+f/c3pkkTapUgOf2utnTFjhu3Vq5f1+Xw2OzvbLlq0KDxv2rRpNnSe1/B1vvTOO+/YoUOH2qioKNu/f387ffp0GwwGw/OBWl/Tpk0LLzNp0iSblpZmvV6vTU9PtxMnTrSbNm0Kz581a5YF7K5du+r9jOeqpbbPOWfOHJuRkWF9Pp9NTU21999/vz1x4kSNZVatWmXHjx9vO3ToYOPj4+3QoUPtU089VW8t56Mp9ndtzjf8TWh+25ebm2tXr17tdBln+ej3d/Bkh3Uc9ni4pMtI/uva/3G6JJF2Z8uWLQwaNMjpMtqladOm8frrr7N+/Xo8HvVEN1Z9f7vGmDXW2tza5un6Mof5su9mbGkZAKsPraMyWOlwRSIiLee9995jxowZCv4Wpr3tsJwxV7BtVQwkQBl+Nh/dzLCUYU6XJSLSIpy61357pzN/h8VGeeng+SrsV+5bUs/SIiIiF07h3wokZ1xNr8pQc/8nO+Y5XI2IiLR1Cv9WoN+o68gprQBgU/FuKgIVDlckIiJtmcK/FeiR1oX08k4AVJogGw5vcLgiERFpyxT+rURqwujw90s+n+9gJSIi0tYp/FuJ7pk30K8i1Nz/6e4FDlcjIiJtmcK/lRicO57hpX4AtlcWUOovdbgiERFpqxT+rURMdBRpwR4ABAysO7jW4YpERKStUvi3In26jMdU3W75w81vOVyNiIi0VQr/VuSi3JsZWBG63n91wXKHqxERkbZK4d+K9Ow3hKwyA8Bue4yiiiKHKxKRSDBz5kz69OlDdHQ0OTk5LF68uN7lP/nkE2688Ua6deuGMYbZs2eftczTTz/NyJEjSUxMJCUlhRtuuIGNGzfWWOYXv/gFxpgar9TU1EbXX1BQwN13301KSgrR0dEMHjyYRYsW1btOUVERDz30EL169SImJoaxY8c6eqvg+n4HTbWfmpLCvxUxLhfdPP0AsAaW7V3qcEUi0trNmTOHKVOm8LOf/Yx169YxduxYrr32Wvbu3VvnOqdPnyYrK4vp06cTExNT6zILFy5k8uTJLF26lI8//hiPx8OVV17JsWPHaiw3YMAACgoKwq/8/PxG1X/ixAnGjRuHtZZ3332XLVu28Oyzz9KlS5d617v33nuZO3cuL774Ivn5+UyYMIErr7yS/fv3N+r9m0JDfgcXup+aXF3P+m1rr5ycnHqfidxaLH9nph02K9Nmzc6yP/77vzhdjki7UN8z0Vu7UaNG2XvvvbfGtH79+tlHHnmkQevHxcXZWbNmnXO5oqIi63K57FtvvRWeNm3aNJuZmdmoes/06KOP2rFjxzZqnZKSEut2u+2bb75ZY3p2drb9+c9/XmPavn377F133WU7depkO3ToYCdOnGgPHjx4QTWf6Vy/g6bYT3Wp728XWG3ryESd+bcymWP/iczy0PX+G0+sd7gaEWnNKioqWLNmDRMmTKgxfcKECSxd2rQth0VFRQSDQZKSkmpM37lzJ+np6fTp04fbbruNnTt3Nmq7b775JqNHj2bSpEl06dKF4cOH89xzz2GrBj/Xxu/3EwgEiI6OrjE9JiaGJUu+ejjarl27yM7Oplu3bixZsoSFCxdy5MgR7rvvvkbVWJ+G/g4udD81NT3St5WJT0plQEUMG6KD7HOd5kTZCTpGd3S6LJH25f1H4KADzbKpQ+DaXzV48SNHjhAIBOjatWuN6V27duXDDz9s0tKmTJnC8OHDGTNmTHja6NGjmT17NgMHDuTQoUM88cQTjB07lk2bNtG5c+cGbXfnzp3MnDmThx9+mEceeYS8vDwefPBBAB544IFa10lISGDMmDE88cQTZGVlkZqayl/+8heWLVtGv379wsvdd999fPe73+Wpp54KT3v88ceZOHHi+eyCWjXkd9AU+6mpKfxbob5xQ4DQWf/7m+dye/YkZwsSaW8O5sMePV77S1OnTmXJkiUsWbIEt9sdnn7ttdfWWO7iiy8mIyODF198kalTpzZo28FgkNzcXJ5++mkARowYwfbt25kxY0ad4Q/w8ssv853vfIfu3bvjdrvJzs7m9ttvZ82aNQDs2bOHefPmsXjxYp555pnweoFAgNjY2LO299hjj/Hkk0/WW+uCBQu4/PLLG/S5qmuK/dTUFP6t0KjMW/BuyaPSGBZvfUvhL9LSUodExPsmJyfjdrspLCysMb2wsLDJRpM//PDDvPrqqyxYsICMjIx6l42PjyczM5Pt27c3ePtpaWkMHjy4xrRBgwYxffr0etfr27cvixYtori4mFOnTpGWlsakSZPCNa5fv57ExMTwwUB1Pp/vrGkPPfQQd955Z73v2bNnz7Omnc/v4Hz2U1NT+LdC/UZczZB1P2VtTBTbS7c5XY5I+9OIpncn+Xw+cnJymD9/Prfeemt4+vz587nlllsuePtTpkxhzpw5LFiwgIEDB55z+bKyMrZu3cr48eMb/B7jxo1j27aa/8999tln9OrVq0Hrx8XFERcXx/Hjx5k7dy6/+c1vAPB6vRQXF5Oamkp8fPw5t5OcnExycnKD6/7S+fwOzmc/NTVHB/wZYyYbY3YZY8qMMWuMMZeeY/k7jDF5xpgSY8xBY8wrxhhnL5ZsBsYXS/9AaFDNQU85hcWHHa5IRFqrqVOnMnv2bP74xz+yZcsWpkyZwoEDB8KD2p577rmzgvv06dPk5eWRl5dHMBhk79695OXl1bg07f7772fWrFn8+c9/JikpiYMHD3Lw4EFOnz4dXubHP/4xixYtYteuXaxYsYJvfvObFBcXc/fddze4/ocffpjly5fz5JNPsmPHDl577TWeeeYZ7r///vAytX2GuXPn8v7777Nr1y7mz5/P+PHjGThwIN/+9reBUNN6UlISd911F+vWrePzzz9n/vz53H///QSDwYbv4AY41++gKfZTk6vrMoDmfgGTgErge8Ag4FngNNCzjuXHAQHgYaAPcDGwFvioIe8XKZf6fenV/73fZs3Oslmzs+wfF/+X0+WItGmRfKmftdbOmDHD9urVy/p8PpudnW0XLVoUnjdt2jQb+q/+KwsWLLDAWa+77747vExt8wE7bdq08DKTJk2yaWlp1uv12vT0dDtx4kS7adOmGu81a9YsC9hdu3bVWf8777xjhw4daqOiomz//v3t9OnTbTAYrPczzJkzx2ZkZFifz2dTU1Pt/fffb0+cOFFjmVWrVtnx48fbDh062Pj4eDt06FD71FNPnWt3npf6fgcN2U/n63wv9TO2nsspmpMxZgWwwVr7vWrTtgOvW2sfrWX5HwMPWmt7VZv2beBZa+0523Ryc3Pt6tWrm6b4FrB386fcsuL7lLlcjHP14/m73nC6JJE2a8uWLQwaNMjpMtqkadOm8frrr7N+/Xo8HvU0N7X6/naNMWustbm1zXOk2d8Y4wNygHlnzJoHjK1jtU+BNGPMDSYkGbgNeK/5KnVOj4EXM6QsAMD2it3OFiMicp7ee+89ZsyYoeBvZZzq808G3EDhGdMLgVr78K21ywiF/f8CFcBhwAB1dpoYY75vjFltjFl9+HBk9Zsbl5veNrQrDnn87D2xx+GKREQab9WqVed1eZw0r4i5w58xZjChcQH/TqjV4BpCBwr/Xdc61to/WGtzrbW5KSkpLVNoExqQMi78/ftrXnWwEhERaUucCv8jhAbvdT1jelfgYB3rPAqstNb+h7V2g7V2LjAZuMsY0735SnXO2Nw7ia8albp230JnixERkTbDkfC31lYAa4Crzph1FVDXDaljCR0wVPflzxHTgtEYPfoMYnBZ6Pttgf313utaRESkoZwMzd8D9xhj7jXGDDLGTAfSgecBjDEvGWNeqrb828BNxpgfGGMyjDHjgGeAtdbaup9dGeF6mtAdpY66LbsOb3W4GhERaQscC39r7RzgIeAxIA+4BLjOWvvlyLaeVa8vl58NTAUeADYCrwOfATe1VM1OGJj29fD3H6x5xcFKRESkrXD02gtr7UxgZh3zLq9l2rOEBv21G+NGf4uO7/0PJ9xu1h5c5nQ5IiLSBrTJvvK2pHtqGheVeQHYZg+r319ERC6Ywj8C9HCHnk99wg3b9i13uBoREYl0Cv8IMLjnNeHv56/7i4OViIhIW6DwjwCXjPpnOvtDVzXmHT772dQiIiKNofCPAOmdO5BRHgfAFnOSQMDvcEUi0prMnDmTPn36EB0dTU5ODosXL65z2aeffpqRI0eSmJhISkoKN9xwAxs3bqyxzC9+8QuMMTVeqann9/T0goIC7r77blJSUoiOjmbw4MEsWrSozuWLiop46KGH6NWrFzExMYwdO5ZVq1ad13s3hXPt26bcVy1J4R8huvlCT20qchs27vjA4WpEpLWYM2cOU6ZM4Wc/+xnr1q1j7NixXHvttezdW/vtTxYuXMjkyZNZunQpH3/8MR6PhyuvvJJjx47VWG7AgAEUFBSEX/n5+Y2u7cSJE4wbNw5rLe+++y5btmzh2WefpUuXLnWuc++99zJ37lxefPFF8vPzmTBhAldeeSX79+9v9PtfqIbu26bYVy2urmf9trVXTk5Onc88jgSvfvQ3mzU7y2bNzrL/+do9Tpcj0qbU90z01m7UqFH23nvvrTGtX79+9pFHHmnQ+kVFRdblctm33norPG3atGk2MzPzgmt79NFH7dixYxu8fElJiXW73fbNN9+sMT07O9v+/Oc/rzFt37599q677rKdOnWyHTp0sBMnTrQHDx684Jqra8i+bap9db7q+9sFVts6MlFn/hHia9nX0LUydJ//vBObHK5GRFqDiooK1qxZw4QJE2pMnzBhAkuX1nWn9JqKiooIBoMkJSXVmL5z507S09Pp06cPt912Gzt37mx0fW+++SajR49m0qRJdOnSheHDh/Pcc8/Vecmy3+8nEAgQHR1dY3pMTAxLliwJ/7xr1y6ys7Pp1q0bS5YsYeHChRw5coT77ruv0TXWpTH7tin2VUvTA5YjRGrHWHpWJFLoPc1mdwmV/nK8niinyxJpk3698tdsPdbyt9Me2GkgPx310wYvf+TIEQKBAF271nxGWteuXfnwww8btI0pU6YwfPhwxowZE542evRoZs+ezcCBAzl06BBPPPEEY8eOZdOmTXTu3LnB9e3cuZOZM2fy8MMP88gjj5CXl8eDDz4IwAMPPHDW8gkJCYwZM4YnnniCrKwsUlNT+ctf/sKyZcvo169feLn77ruP7373uzz11FPhaY8//jgTJ05scG3n0tB921T7qqUp/CNID+8gVrGKEpchf8cHZA9s03c2FnHM1mNbWV242ukymt3UqVNZsmQJS5Yswe12h6dfe+21NZa7+OKLycjI4MUXX2Tq1KkN3n4wGCQ3N5enn34agBEjRrB9+3ZmzJhRa/gDvPzyy3znO9+he/fuuN1usrOzuf3221mzJnSl0549e5g3bx6LFy/mmWeeCa8XCASIjY09a3uPPfYYTz75ZL11LliwgMsvv7zBn6u6ptpXLU3hH0EG97qevxeERr0u2PK2wl+kmQzsNDAi3jc5ORm3201hYWGN6YWFhecccf7www/z6quvsmDBAjIyMupdNj4+nszMTLZv396o+tLS0hg8eHCNaYMGDWL69Ol1rtO3b18WLVpEcXExp06dIi0tjUmTJoVrXL9+PYmJieGDgep8Pt9Z0x566CHuvPPOeuvs2bPnWdPOd9+e775qaQr/CHJx9gR6vPE4X/jcrFW/v0izaUzTu5N8Ph85OTnMnz+fW2+9NTx9/vz53HLLLXWuN2XKFObMmcOCBQsYOPDcBxxlZWVs3bqV8ePHN6q+cePGsW3bthrTPvvsM3r16nXOdePi4oiLi+P48ePMnTuX3/zmNwB4vV6Ki4tJTU0lPj7+nNtJTk4mOTm5UXXD+e/b891XLa6ukYBt7RXpo/2ttTYYDNrJz+bYrNlZNntWpi33lztdkkibEMmj/V999VXr9XrtCy+8YDdv3mx/+MMf2ri4OLt7925rrbXPPvusHTBgQHj5yZMn24SEBPvRRx/ZgoKC8KuoqCi8zI9+9CO7cOFCu3PnTrt8+XJ7/fXX24SEhPA2G2rlypXW4/HYJ554wm7fvt3+9a9/tYmJifa5554LL3NmfR988IF977337M6dO+28efPssGHD7OjRo21FRYW11tpjx47Z5ORke/PNN9u1a9faHTt22Hnz5tnJkyfbQCBwXvuwLufat9Y23b46X+c72t/xUG6pV1sIf2utfWLmbeFL/lZ+PtfpckTahEgOf2utnTFjhu3Vq5f1+Xw2OzvbLlq0KDxv2rRpNnSeFwLU+po2bVp4mUmTJtm0tDTr9Xptenq6nThxot20aVON95w1a5YF7K5du+qt7Z133rFDhw61UVFRtn///nb69Ok2GAzWWd+cOXNsRkaG9fl8NjU11d5///32xIkTNba5atUqO378eNuhQwcbHx9vhw4dap966qnG7LIGq2/fWtuwfdWczjf8TWh+25ebm2tXr478ATx/fXMW/37y9wD8n+TL+Mn1MxyuSCTybdmyhUGDBjldRkSZNm0ar7/+OuvXr8fjUQ+yU+r72zXGrLHW5tY2T9f5R5jBw6+lX0UlAKuOrHe4GhFpr9577z1mzJih4I9Q+q1FmIE9upBRGsUOX5Dt9iQllSXEes++vEVEpDk5eb99uXA6848wHreLVPoA4DeQd2C5wxWJiEikUfhHoN4pl2Oqxmos3va2w9WIiEikUfhHoF5ZVzOwqt9/ReHZN7oQERGpj8I/AmVe1J9BpaFf3eeB4xRVFDlckUjkay9XPknbcSF/swr/CBQX5SElELodZdDA2oORfwmjiJO8Xi+lpaVOlyHSKKWlpXi93vNaV+EfodI6jsVdddS39PP3Ha5GJLJ16dKF/fv3U1JSohYAafWstZSUlLB//366dOlyXtvQpX4RqsuAK8ja+L+sj45i2YGVTpcjEtESExMBOHDgAJWVlQ5XI3JuXq+Xrl27hv92G0vhH6EGDsll2KoA66Nhl/8oJ8pO0DG6o9NliUSsxMTE8/6PVCTSqNk/QqUkxtC5Ij3886pC3XBDREQaRuEfwTrHj8Rb1T+5fM8Ch6sREZFIofCPYAl9L2N4WTkAy/YtdbgaERGJFAr/CNZn6DiySysA+KLyKIdLDjtckYiIRAKFfwTrnZpMl7Lk8M8rD2rUv4iInJvCP4IZY4iLHk5MMAjAqv1q+hcRkXNT+Ec4T88xjAj3+3/qcDUiIhIJFP4RLjXzMkaVlQFwoOIoB04fcLgiERFp7RT+EW5A3750L00I/6x+fxEROReFf4SL9roxrsHEV/X7ryxY4XBFIiLS2in824CK1JHkloaa/lfs/1QPJhERkXop/NuADgMuZVTVoL9D5cfZW7TX4YpERKQ1U/i3AQMGZ3NRqTv88wo1/YuISD0U/m1Alw4xlAX70TEQAGDVQT3kR0RE6qbwbyNOdMplZFXT/4oDy9TvLyIidVL4txFRfcYwqmrQ3/GKk+w4scPhikREpLVS+LcRPYeMZUSpP/yzrvcXEZG6KPzbiIvSkymq7EWKP3QAsLJA4S8iIrVT+LcRHreLA4nDwv3+qw6uIhAMOFyViIi0Rgr/NiTYbTSjq/r9iyqL2HZ8m8MViYhIa6Twb0OSB18afsgPqOlfRERqp/BvQ4b0z6C0IpX0ylC//4qDutmPiIicTeHfhnSI8bI9KpORVWf/6w6tU7+/iIicxdHwN8ZMNsbsMsaUGWPWGGMuPcfyPmPMv1WtU26M2WuM+WFL1RsJirvmklM16K+4slj9/iIichbHwt8YMwmYDjwFjACWAu8bY3rWs9qrwDXA94EBwK3AhmYuNaLE9b+E7KrwB1hbuNbBakREpDVy8sx/KjDbWvuCtXaLtfZBoAD4QW0LG2MmAF8HrrPWzrfW7rbWrrDWLmy5klu/gYOGElMZS2d/qLl/7SGFv4iI1ORI+BtjfEAOMO+MWfOAsXWsdjOwCphqjNlnjNlujHnGGBPffJVGnj4p8eSbgeRU9fuvKVyj+/yLiEgNTp35JwNuoPCM6YVAah3rZACXAMOAW4AHCHUBzK7rTYwx3zfGrDbGrD58+PCF1hwRjDEc7TSC7PJQ0/+xsmPsObXH4apERKQ1iaTR/i7AAndUNffPJXQAcIsxpmttK1hr/2CtzbXW5qakpLRkrY5y9xoTHvQHavoXEZGanAr/I0AAODO0uwIH61inANhvrT1ZbdqWqq/1DRJsd7oPHk3PcogPBoFQ07+IiMiXHAl/a20FsAa46oxZVxEa9V+bT4H0M/r4L6r6qnbtaob26somm8HwqrN/jfgXEZHqnGz2/z1wjzHmXmPMIGPMdCAdeB7AGPOSMealasv/GTgKzDLGZBpjxhG6VPB1a+2hli6+NYvxudkblxVu+t93eh+HSrSLREQkxLHwt9bOAR4CHgPyCA3mu85a++VZfE+qNedba08DVwIdCI36/yuwCPhOixUdQSrSRup6fxERqZXHyTe31s4EZtYx7/Japm0DJjRzWW1C0sBLydpZji9oqXAZ1hSu4Zo+1zhdloiItAKRNNpfGmHIRX3ZF0wlq6Kq318j/kVEpIrCv41K7xDNZs+gcL//9uPbOVVxyuGqRESkNVD4t1HGGE4mZ4f7/S2WvEN5zhYlIiKtgsK/DYvqM4bhZeW4qm7vq+v9RUQEFP5tWt/B2QSCMQyoqAQ04l9EREIU/m1YZrck1tkB4ab/jUc3UuYvc7gqERFxmsK/DfN5XBQkDiG76gl//qCf/CP5DlclIiJOU/i3ccHuo3WzHxERqUHh38Z1HTSWjgHoVVnV76/r/UVE2j2Ffxs3LKMbm22v8Nl/3qE8/EG/w1WJiIiTFP5tXEpCFJ/5MsPhX+IvYdvxbQ5XJSIiTlL4twPFXXPCd/oD9fuLiLR35x3+xpjuxhhfUxYjzSO+/zi6+/2k+EPN/Qp/EZH2rVHhb4wZYYz5pTFmPbAHOGKMec0Yc6cxpmOzVCgXbNBFgzhgO4eb/tceWoutuuufiIi0P+cMf2PMIGPMM8aYPcBHQH/gKSAJuARYD0wBCo0xHxljHmzOgqXxBqQmsJ6vbvZzrOwYu0/tdrYoERFxTEPO/EcBBvgu0MVae4e1do619pS1doO19glr7UggA/gbcH0z1ivnwe0yHE4aTk65+v1FRKQB4W+tfdFa+6C19kNrbY1rxIwx2dWW22+tnWmtvaY5CpUL4+55Mf0qKkkIBAFd7y8i0p5d6Gj/lcaY31efYIy57gK3Kc2gx+BRlNsohled/esJfyIi7deFhn8+cMoYM6vatCcucJvSDEb0TibP9g33++8/vZ/C4kKHqxIRESdcaPhba+0vgPXGmNeNMV5C4wOklUmM9rI7Zgg5ZV891U9N/yIi7dOFhv8pAGvtfwJvA28BMRe4TWkmld1yySyvwBcMXeanpn8Rkfapsdf5Z1T/2Vp7ebXvXwT+AHRpksqkySUPvBQfMKT8q+v9RUSk/Wnsmf92Y8xtdc201r5hre10gTVJMxnarxfbgt3Jrgr/Hcd3cLL8pMNViYhIS2ts+BtgijFmmzFmqzHmZWPMVc1RmDS97kkxbPYMCt/n32LJO5TnbFEiItLizqfPvyehm/m8DMQD/zDG/NEYo4cEtXLGGIpSshlWVo6r6va+aw6p319EpL3xnMc6d1hrF335gzGmH/AO8FPg6aYqTJpHTN9xxBdaBlRUsiXKpzv9iYi0Q409Wz8CHKo+wVq7g9C9/e9tqqKk+QwYNJQjNjF8yd+mo5so85edYy0REWlLGhv+ecD3a5m+B+h2wdVIsxuU3oG8ag/58Qf95B/Jd7gqERFpSY0N/8eA7xtj/mqMudwY08kY0w14HNjZ9OVJU/O6XRR2GMaIsq8e8qPr/UVE2pdGhb+1diUwGugMzAcOA3uBm4CpTV6dNAtXz9EkB4P0rqgE9IQ/EZH2ptED/qy1G4GvG2M6AzmAG1hhrT3W1MVJ8+g2eAzl+R6yy8vZ7fOy/vB6/EE/Htf5jP8UEZFIc84zf2NMT2NM4pnTrbVHrbXzrLXvVw9+Y8zQpi5SmtbwjFQ22j7hfv8Sfwnbjm1zuCoREWkpDWn2vx44bIyZZ4y53xjTo/pMY4zLGDPeGPOfxphdwKLaNyOtRWK0l10xWWRXe8iP+v1FRNqPc4a/tfa/gP6EHtpzM7DDGLPGGPPvxpiXCV3+9xLgA+5D9/aPCOVpuXT3B+ji9wO6z7+ISHvSoE5ea+1e4DngOWNMB+AG4FpgN3C1tXZVs1UozSJpwCWY3ZBdVs4H8R7WHVqHtRZj9ERmEZG2rtG35LXWnrTWvmKt/Za19ucK/sg0ZMBF7A52Dff7Hys7xq5TuxyuSkREWoLux99OdU+KYZNnUDj8QZf8iYi0Fwr/dsoYw4nkHPpXVpIQCAIKfxGR9kLh345F97sMFzCiPHT2r0F/IiLtg8K/HRsweDiFtmP4kr/9p/dzsPigw1WJiEhzU/i3Y4PSO7CGTHLU7y8i0q4o/Nsxt8twqPNIMssriApW9fur6V9EpM1T+Ldzvn5fwwsMKa8AdKc/EZH2QOHfzn3V7x9q+t9xYgcny086XJWIiDQnhX87N6R7R1bbweSUf9Xvv+7QOgcrEhGR5qbwb+d8HhcFSbkMKyvHZS2gQX8iIm2dwl/wZFxKnLUMrKjq9z+kfn8RkbZM4S9cNHgEh6r1+28+splSf6nDVYmISHNxNPyNMZONMbuMMWVVjwm+tIHrXWKM8RtjNjZ3je3BiF6dWBEcFL7e32/95B/Od7gqERFpLo6FvzFmEjAdeAoYASwF3jfG9DzHeknAS8BHzV5kOxHjc7O/YzYjqt3sR03/IiJtl5Nn/lOB2dbaF6y1W6y1DwIFwA/Osd6fgBeBZc1dYHti+lxK52CQ3hWVgAb9iYi0ZY6EvzHGB+QA886YNQ8YW896k4GuwBPNV1371H/QCA7bDuFL/tYfXo8/6He4KhERaQ5OnfknA26g8IzphUBqbSsYY4YA04A7rbWBhryJMeb7xpjVxpjVhw8fvpB627yc3p1ZHhwUHvRX6i9l67GtDlclIiLNISJG+xtjooA5wI+ttbsaup619g/W2lxrbW5KSkrzFdgGdIjxsichO/yEP9CtfkVE2iqnwv8IECDUhF9dV6C2Z8qmAYOAWVWj/P3A/wUyq36e0KzVthe9LqGbP0AXf6i5X/3+IiJtkyPhb62tANYAV50x6ypCo/7PtB8YAgyv9noe2FH1fW3rSCP1HTSCIzYxfMnfukPrsFV3/RMRkbbDyWb/3wP3GGPuNcYMMsZMB9IJhTrGmJeMMS8BWGsrrbUbq7+AQ0B51c+nHfsUbUhun86sCA4O9/sfLz/OrpMN7mUREZEI4XHqja21c4wxnYHHCDXrbwSus9buqVqk3uv9pemlJESxI3Y415V91de/5tAaMjpmOFiViIg0NUcH/FlrZ1pre1tro6y1OdbaT6rNu9xae3k96/7CWpvVIoW2I8Fe4+hXWUliIHRBhfr9RUTanogY7S8tJ2NgNkdtIiPKQw/5UfiLiLQ9Cn+pYUy/ZFYEB4Uv+TtQfICDxbVdgCEiIpFK4S81dE2M5vPY4eFBf6Dr/UVE2hqFv5zF1edSMssriA4GATX9i4i0NQp/OUv/zBxO2kSGfNnvf0jhLyLSlij85SwX901mZXBguOl/x4kdnCg74WxRIiLSZBT+cpaOsT72JGbX6Pdfd2idgxWJiEhTUvhLrdx9LmN4eTnuqtv7qulfRKTtUPhLrfpn5VIajGdgha73FxFpaxT+UqtRfTqz0n51n//NRzdTUlnicFUiItIUFP5Sq7goD/s7ZIef8Oe3fvKP5DtclYiINAWFv9TJm3EZI6oN+lPTv4hI26DwlzoNGDoSG4ijT0UlEHrCn4iIRD6Fv9RpRK9OrLKDwv3+Gw6vpzJY6XBVIiJyoRT+Uqcoj5vCTiPJqXrIT6m/TE3/IiJtgMJf6hXV71IuKy3DU3W9//w98x2uSERELpTCX+o1cOhoAoFYRpWGzv4/2vsRgWDA4apERORCKPylXlndOrLGDOaqktA1/kdKj5B3OM/ZokRE5IIo/KVeHreLw51GcUVxKa6qpv8P93zocFUiInIhFP5yTr4BV9EpGCS3atT//D3zCdqgw1WJiMj5UvjLOQ0fkcPOYCpXFYea/gtLCnW3PxGRCKbwl3PqmxLPSu9Ivl5Sgvly1P9ujfoXEYlUCn85J2MMp3tdSUogyIjyUNP/h3s/xFYdCIiISGRR+EuD9BpxBadsDFcVlwKw//R+Nh/b7HBVIiJyPhT+0iBjLkpniR3KlcVfPdZXTf8iIpFJ4S8NEh/lYXenS0kNBBhabdS/mv5FRCKPwl8aLC7zWoLWhEf97y3ay2fHP3O4KhERaSyFvzTY6CEXsdb258qSak3/ute/iEjEUfhLgw3omsBK70i6+wMMLv+q6V9ERCKLwl8azBhDecZVAOFR/ztP7uTzE587WZaIiDSSwl8aZeCQ0eyzyeF+f9DZv4hIpFH4S6OMuyiFBcER9PL7uaiiElD4i4hEGoW/NEpitJcvki8D4KriYgA+O/4Zu0/udrAqERFpDIW/NFqnrK9TYqOYUK3p/8O9esyviEikUPhLo106qDufBrPIqPTTpzIAqOlfRCSSKPyl0QanJbLSNxKACadPA7D56Gb2Fe1zsiwREWkghb80mjGGQN8JADVG/X+4R03/IiKRQOEv52VE5iA2BPtwUWUlPQIGgPl71fQvIhIJFP5yXr42IIWFNhsDTCg6AcCGwxs4WHzQ0bpEROTcFP5yXhKjvRxNHw+o6V9EJNIo/OW8DRhxKYdsRwZXVJJmPYBG/YuIRAKFv5y3qzLTWBAcjgGuPHUSgHWH1nG45LCzhYmISL0U/nLeUhKi2N3pUgCuLi4CwGL5aO9HTpYlIiLnoPCXC9J1+DWUWw9DyitIwQeo6V9EpLVT+MsF+fqwDJYFM3EB40+HBv6tLlzNsbJjzhYmIiJ1UvjLBenRKZZN8WMAuP7UUQCCNsjHez92siwREamHwl8uWEzmtQAMLy+nkysaUNO/iEhrpvCXCzY2N5utwR64gEtKQg/6WVGwghNlJxytS0REaudo+BtjJhtjdhljyowxa4wxl9az7ERjzDxjzGFjTJExZoUx5saWrFdqN6BrAqujRgFw0/HQw30CNsCCLxY4WZaIiNTBsfA3xkwCpgNPASOApcD7xpiedazyNeBj4Pqq5d8D3qjvgEFahjGGYL/Qg36yy8rp6I4B4MO9utufiEhr5OSZ/1RgtrX2BWvtFmvtg0AB8IPaFrbWTrHW/spau9Jau8Na+0tgDXBzy5Usdckc9XWO23g8wOhyLwBLDyylqKLI2cJEROQsjoS/McYH5ADzzpg1DxjbiE0lAMebqi45fyN6JbPMlQ3A9Uf2AuAP+ln4xULnihIRkVo5deafDLiBwjOmFwKpDdmAMeZ+oDvwcj3LfN8Ys9oYs/rwYd1ytjm5XIaTPb8OwCWlp0isavrXqH8RkdYnIkf7G2NuAf4DuMNau6eu5ay1f7DW5lprc1NSUlquwHaq56ibKLFReIGLq5r+P93/KcWVxc4WJiIiNTgV/keAAND1jOldgXofCG+M+Sahs/3/Y619u3nKk/MxamAvPnSFem2+cWQnABXBChbvW+xkWSIicgZHwt9aW0FosN5VZ8y6itCo/1oZY/6ZUPDfY619vfkqlPPhdbs4fNFtAIwrLSHOhM7+5+05c2iHiIg4yclm/98D9xhj7jXGDDLGTAfSgecBjDEvGWNe+nJhY8xtwP8CjwCfGGNSq16dnCheajfqkmvYHuyGDxhXUgnAkv1LKPWXOluYiIiEORb+1to5wEPAY0AecAlwXbU+/J5Vry/dB3iA/yR0SeCXr7+3SMHSIFndO/BRTOia/+tPhQZZlvpL+XT/p06WJSIi1Tg64M9aO9Na29taG2WtzbHWflJt3uXW2svP+NnU8rq8tm2LM4wx+LLvoMK6GVtaRkzVn5ia/kVEWo+IHO0vrdvVo4cwP5hDtLVcWhx6zO+iLxZRHih3uDIREQGFvzSDbh1jWJ8SeuzC1adDd/gr8Zew7MAyJ8sSEZEqCn9pFv0vvoH9tjOXlJYRZUPTdMMfEZHWQeEvzeKaod34u72cWGu5rCTU9L9g7wIqA5UOVyYiIgp/aRYJ0V4O97uVoDVcWdXvX1RZxPKC5Q5XJiIiCn9pNuNH5bA4OITLSkrx2VDbvx7zKyLiPIW/NJtL+yfznvcq4q1lbEnoJj8f7f2IyqCa/kVEnKTwl2bjcbuIH3YjR20CE6r6/U+Wn2T1wdUOVyYi0r4p/KVZ3ZzTh78HLuVrJaV4qpr+NepfRMRZCn9pVlndEslLvoHEoOXi0jIg1PQfCAYcrkxEpP1S+EuzMsZwxaWXsTp4EROqRv0fKzvG2kNrHa5MRKT9UvhLs/vGsDTe83yd8SWluNX0LyLiOIW/NLsoj5ukkZPwBHyMLAs1/X+450OCNuhwZSIi7ZPCX1rEP48bxDvBsVxVHLrk73DpYTYc3uBwVSIi7ZPCX1pE18Ro9vW5lSuKS3BVNf3rMb8iIs5Q+EuLGX/FNRzxdyOnLPRo3w/3fIitOhAQEZGWo/CXFpPdK4lP4q8N3+u/oLiA/CP5DlclItL+KPylxRhjSLv0bi4rrgg3/f929W91zb+ISAtT+EuLmjByEJvsSG4/dRqAdYfW8b9b/tfhqkRE2heFv7SoKI+bU4Nu54fHT9CjMvSAn2fWPcPuk7udLUxEpB1R+EuLu+zqW/gi0J1/O3IMgPJAOY9/+ria/0VEWojCX1pc1w6xfNpvKrll5XzrZBEAeYfzeGXLKw5XJiLSPnicLkDap+tuuoOPf/cKPzy+lk9io/nC6+XZdc9yWffL6NOhj9PltXuVgSBfHCth5+Fidh8t5lBROSdOncJzYg+xp3fRoXQfvkAJbvy4bejlsX58JkC0O0i0K0CUCRLlChD0xFAZ1YlAbAomvguexC7EJqWRktqDLmnd8cXEO/1xRdodhb84IrVDNH8b+lMuyb+dfz98jG+ndQ03/794zYu4XW6nS2w3Sir8rP/iJGv3Hid/71FOH9pJ1Imd9KSAPuYgF5mDXOMqIJ2juMzZ92UocRkOetwc8Hgo8LjZ6fFQ4PFwwOPmoDv0X0xSMECSP0inowGSDgdJCgToFAiSFAgSE3TjJQGvtwum4wCi0obQOWM4Sb2HYGKSWnp3iLQLpr3cZCU3N9euXr3a6TKkmqOny3n7P77NPeZdft2pI690SATgx7k/5u7Mux2uru0qqfDz6Y6jLN5+mDW7j1FZuI1LzTq+5trAaNdWokxleFkLHHO5KKgK9gMeT7WgD0074W66AzVf0JIU/PLAIEBs0Eu0uwOJsal07dSHHt0ySUsdTr+ULKI90U32viJtkTFmjbU2t9Z5Cn9x0nPvreb2FTcT6zrNLd2784XHEOWO4rUbXlPzfxP64lgJC7Yd4qMth9iwcx+5wXwud63na+71dDdHANjp9fBxbCxfeEOhXuD2UOD1UG5Mo97LZVx0ie1Celw6qXGpuIyL42XHOVZ6hGOlRzlefpIKW3nuDdX3Hha6m1gGJGQwotclZHYfw4BOA4jzxl3QdkXaEoU/Cv/W6mRpJdN//Sj/lxdYGxXFPeldscCwlGFq/r9Ah06V8faGAv6xbh9lBzZxuSuPy13ryXVtw2dCV1Ycd7l4Py6WtxLi2BQV1aDtxnhiSItLC73i08Ihnx6fTlpcGl1iu+Bx1d2jaK2l1F/KsbJjHC87zvHy4xwrO8ax0mPsLzrM/iO7OV60n6LyY5TYYopdfsoaMDTZWEhzdyCz8yCG9RzLoM6ZDOw8kERfYoM+l0hbo/BH4d+azfx4K+MXfpNBri/4Vedk/jcxFoAf5fyIe7Lucba4CFNc7uf9jQf5R95+8nZ8wY2uT7nT/SGDXHvDy1QAi2Nj+EdCAotjo/GfsY1O0Z1Ii0sjPb4q1OPSSYsPhX16XDodojpgGtkacCEqA0E27itg27aVHNy/hqKTGylmN0ejitka5T1nt0OqL5mhqSMYlDyYwZ0GM6jzIJKiNZZA2j6FPwr/1qykws/UXz3D88FfUmoM38zoz95gGT6Xj9dufI2MDhlOl9jqbS8s4pXle/jb2v10q9jJne4Pudn9KQkm9AhlC+RH+XircyofRHs5eUaze7f4btzQ9wZuyLiBnok9HfgEjVPhD/LZvsPs37KUI3sWcLI4j2L3AXZHwWafjyOe+g8Iusamktk5dCAwuPNghiQP0QGBtDkKfxT+rd3/LNlFt7n3crV7NeuifNydnobFMjRlKC9d85Ka/2tRGQgyd9NBXl62h3W7CrnGtZI7PR8yyrUtvEyB283byWm83aEjuytP1Vg/zhvH1b2v5oaMG8jumo3LRPZtP06WVLBtcx7Ht35C2cGlVPi3cDT6NJt9PrZE+Tjoqf/ipt6JvRnRZQQjuoxgeJfh9E7s3aItHCJNTeGPwr+1K6sM8H/+41VeKX8QnwnwdI+B/NkTevrf1JypfDvr2w5X2HqUVgR4ddVeXvhkJ65Te/mW+yNudS8i2YTCvdgY5sfF8nZKD1ZSUmNdl3ExJn0MN/W9ict7XE6MJ8aJj9AiAkHL5zs+41D+fHx7PqFD8RqO+kIHA5ujfGzxednn9da5flJUEsO6DAsfEGR2zsTn9rXgJxC5MAp/FP6RYOG2Q2x9+WHu87xDqTHcOmAYe8qPhZr/b3iNjI7tu/n/ZEklLy3bzaylu+lSsoMpnr9xtWs1LmMJACuio3m7Yyc+io2i1Na8VXL/pP7c1PcmrutzHSmxKc58AKdZy5G9W9m/bi6u3Z/Q4+RqjDnFZp+PvOgo1kVHsSEqimJX7S0gXpeXzM6Z4ZaB4V2G0ym6Uwt/CJGGU/ij8I8UP/vLEqZuvZ1kc4plien8S2dvqPk/eSgvXds+m/+PF1fwh8U7eXnZHtIqdjPF8ze+4V4BwOdeD/+Ij+fdDh05ZII11usU3YnrM67nxr43MiBpgJqwz2QtJ/ds4EDeB7h2Lab7qTVE2xK2+7ysiwodDORFR1FQT3dB78TeDO8yPHxA0Cexj/aztBoKfxT+keJESQXP/fZxHgs+D8BTWRP4S/FWAB7OeZjvZH3HyfJa1KmySv60eBd/WrKLrhV7mOL5O99wLcdlLOujfExPSmJVTM3L83wuH+N7jufGvjcyNn1svZfcyRkCfk7vWs3B9XNx7/mE9FMbiKKCg253qGWg6oDgM5+XQB0B3zGqI8NThjM0ZShZyVlkJmfqUkNxjMIfhX8k+SB/Hz1fu47Brj2cdEVzZ2Y2u0/vazfN/8XlfmYv3c0fPtlJp7K9/NDzd25yLcVlLDu8Xp7p1JEFsTX76kd0GcGNfW9kQu8JCpumUllG+a7lHNowF8+exXQp2oSbICXGsCEq1FWQFxVqHairqwCgV2IvspKzyOqcRVZyFgM7DdTdCaVFKPxR+Eea//fCn3h4/1QA5vf8Oj9y78BiGZI8hJeufalNntFW+IO8umovz3y0nbjivfzQ8wY3u5bgNpYDHjczOnbk7YQ4vvwX63V5mTRgEncMvIMeiT0crb1dKDtFYPdSTm7+CHYvpuOprbgIjbfY4fWGxw2sjYqmwFt395TbeOif1I/MzpkMSR5CVnIWfTv2bZN/0+IshT8K/0hzuKic9b+7gSsJ9W0/Nfbb/KXgIwAeyn6I7w75rpPlNalg0PJOfgG/nbuNsmP7edjzOre6F+ExQY66XPyxYyJzOnSgsir2XcbFjX1v5AfDfkB6fLrD1bdjJcdgz6eUb1+I//OFxJ3cEZ51zOViY5SPTVE+8qOiWB8VzSl33WMBotxRDO48uMYBQY+EHho/IBdE4Y/CPxLNXbKMy+d/gyjj54g7gW8PHMzukgK8Li+v3fAafTv2dbrEC7Z4+2F+9f5Wdh8o5F88b/M993vEmApOG8OLHRJ5KSmJEr4ayPf1nl/nwREPtonP3uYUFcLuxdhdi6ncvRzvsW2YqgM2CxzwuNno87EpKop1UTFsifJSXs+tFeI8CWQlZzE0JYvBnQeT0SGDHok98LrqvjxRpDqFPwr/SGSt5c8zpvGtI9MBWB7TiX9JTSCIJatzFi9f93LENpVuPnCKp9/fwrLtB7nNvYCHPH8j2Zyi3MCrCQn8sXMyJ/jqcr1RqaOYkj2FoSlDHaxaGqX0BOxfDV+sxO5dgd23CldlcXh2ANjt9ZAfFcXGKB/rfLF8HuUmUM/Jvgs3XWK6kdGxD4M69yOjYwYZHTLondibeF98s38kiSwKfxT+kaq43M8r0x/hX0peAODXyam8khC60cqU7CncO+ReJ8trtP0nSvndvG28sW4fV5nV/NTzKn1dBfiBt+PjmJmcwsFql+wN7jyYKdlTGJM2Rk3AkS4YgEOb4YsVoQOCL1Zgju+usUgF8JnPx8YoH/lRPvKiYvnC68I24Fcf7+lMemwv+iVlkJnSjwGd+tGnQx9SYlL0t9NOKfxR+EeywlNlzJn+U34YmE2ZMXyzWzf2eF14XV7++o2/0i+pn9MlntPJkkpmLtrBrE93kxnYxqPePzPKtQ0LfBgbw7PJKeyqNkasd2JvHhzxIFf1ukr/cbdlJcegIA8O5H319cSeGosUG8MOn5ddXi87vaGvn3mjKGjgQYGbGDp4utE1uie9EnozoHNfhnTtz6CUHiRGqbWgLVP4o/CPdFsPnuLd/3qUH5lXWB/l4/+kdSVoDJmdM3nluldabfN/WWWAWZ/u5r8W7qBj+X7+1fNq+AY9y6OjmN45mY2+r1K/a2xXJg+fzI19b2y1n0maWQMOCCDUSrDX62WX18NOX+jAYLs3ij1eDxUNfUxDMBqP7UiMqxMJns50ik4mJaYr6fFd6ZmYRkanNPp0SqVzbDQed2Q/+6E9Uvij8G8LPvnsMCte+jk/8czh90kdmdUxdD17a2z+9weCvL5mH//54XY8RV/wgPsNbnEvxmsCbPT5mN4pieXVbtDTIaoD3xvyPSYNmKRrwOVs5afh6HY4/Bkc2QZHPgt9f+xzCNZ8KHMQKHS72RluLfCEvvq8HDvH449rY60L64/HFeyIj47EuJKI9yTT0ZdMp+hkUmO7kp7Qlc4xiXSI9ZIY7SUxxktCtIeEaC9xPrdarxyi8Efh31a8unIv+/7xbzzoe41b09PY5fPidXmY842/0j+pv9PlEQha3tlwgOkfbaf88G7u97zJre5P8JoAn3s9zEjqyPy42PDyMZ4Y7hp8F/dk3kOCL8HByiUiBSrh2K7QwcCRbXB0J5z8ouq1DwIVNRY/6XKxy+thj9fLYbebQo+bQ243h6q+HnG7CZ5vUFsXNhATegVjwt8TjMZr4vC54ohxJxDjjiPOm0CCL4FEbyKJUYkkRScSH+0jPspDrM9DnM9NjM9NrM9DbNX3cT4PMT43MV43Po9aIRpC4Y/Cvy155qPtBD5+mq/Hv81dVc3/gzv05ZUbX3PsMih/IMjbGw7w7Mc7KDu8h/s9/+BW90KCriDzY2P4W0I8a2K+OqP3uDz880X/zPeGfo/kmGRHapY2LhiE4sOhA4ETe786IDjxBZzaB6cPQ/EhsF8NMPUDx9yhA4EzDwxCXz0c8rg5Xc8dDc+XO+DBFYzCBKIgGI0NRhEMRBG0UQSCUfiD0VgbhQ16cdkofO5ofCaaKE8UUe4Yoj0xxLijifHGEueJIcYbTaw3mhivh2ivi2ivm2ivixivmyivO/Szx0WML/R9TNX86C/nVc2P5O4OhT8K/7bmH3n72ff3xyjv/HG4+f8H/b/F5LGPtGgdFf4gb68/wIwFOyg5spf7Pf9gknsBu30u/pYQz9vxcRRV+8/DYLih7w38YNgP6J7QvUVrFTlLMBAaY1B8CE4XwulDVa+q74sPhS5ZLDtR9fUkYCkxhkKPO9R64HZz2OPmpMvFKZeLIpeLU+6qr66vvtb1PITmZCx4gwavdeEOunBbN27rwhV0Y+yXLw8m6AHrwQa9WFv1CnoJBn1YfLhcMbhMNC53DB53LB5PHG53HFHeOGK8McR6o4n1xhDvjSHG5yHGG2qtiKo6qIjxusMtGLHVWzS+XM7japauEYU/Cv+2aOO+E6yY9RBvpS5np8+Lx1r+td993Dj628R545r1vQtPlfG/K/by5xV7cZ8uYLLnH9zoWcjH8T7+lhBPfnTNB+4kRSVxY98bueWiW+jToU+z1ibSbIJBKD9V7WCg2tfy01BR9So/DRXF4Z9teRGlFcWc8hdzyl9KUaCMU8ZWO0AwnKr6/lTVwUOpcVFqDCUuQ5kxlLpcVEbA2AGPtVUHHOC1Bk/4wMOFy7pwBT0Y64agB1PtQMOYaFwmit/e9iR9U5vmxEDhj8K/rTpSVMarf/w2LyTlh/sq3RYGxqQzrt+1jE4fy7Auw4hyR51jS+cWDFpW7znOS8t2s2zjDq4wq/iGaykdY7bzRkIc78fHUnJGc+iYtDHcctEtXNHjCrxu3ZlNJMxfAZXFUFEClSVVBwoloYOGymKoLAN/GfjLw1/9lSWUVZZQ6i+htLKU0kAppf5SSgMVlAbLKQtWUhqopNRWUhb0U2IDlNoAZQQotZZygpQbqDChA4ryaq8ylwlP9zt4kPHG+Jfp13N4k2yrVYe/MWYy8BMgDdgEPGStXVzP8l8Dfg9kAgeA31hrnz/X+yj8265Kf4CnZt3Km97Pav1H63N5GdElm1FpoxiVOorM5MwGjw3wB4Ks3H2MDzYeZMnGzxlevJRvuJczzLORufHR/D0hnm1RvhrrdInpws39b+af+v2TmvZFWptgEIKVoYOKQEXo5S8PDZ4MlIO/goC/lPKK05RXloS++kspqyyh3F9Cub+Mcn8p5f5yygKllPvLKAuUUx4opyxYQXmgkrJgBWUBP2XWT1nQTxkBym0wdPCBDb1cVQcdVQcfX568LLzxXTon9WySj9pqw98YMwl4BZgMLKn6+m1gsLV2by3L9wE2Av8DzAQuqfp6m7X2b/W9l8K/7duwZTUfffwfFPnXkh/jYusZofylWE8sOV1zGJ02mlGpoxjQaQAuEzpjP1ZcwdaDp9h2sIj8/SdZsWUPOeUruMG9nEtd69kU7eZvCfHMi4uhvNpZvgvDZd2/xi0X3cIl3S7RNfoiUjdrQwcdlSVQWYatKMZfWUxZ+Unie4zFuJvm/4/WHP4rgA3W2u9Vm7YdeN1a+2gty/8amGit7V9t2h+BTGvtmPreS+Hffmzbf5ilb82id+Ff8cfuY0VMNCuio9ntq/1sPzropVdlB7qdjqV7kZf0SkusqSSJ01zs2kyJO8Bb8XH8LSH+rG10i0tn4kW3cFPfm+ga17UlPp6ISIO0yvA3xviAEuB2a+1r1abPALKstV+rZZ1PgHxr7f3Vpt0K/BmItdZW1vV+Cv/2Z+vBUyxc9BG9d/6Fy8oWUuTxszI6ipUx0ayIiabAU/vRdYrfz6iycoaVlbM6OoqP42JrdCd4XB6u6HEFt1x0CxenXRxuNRARaU3qC38n2yaTATdQeMb0QuDKOtZJBT6sZXlP1fYKqs8wxnwf+D5Az55N04cikWNgaiIDJ/0T8E+cPnmU05/8D+M2vcQNR/ZigX0eNyujQwcCK6OjOeoJ3f3ssMfDu/Ee3o2vecVA78TefPOib3JD3xvoFN2p5T+QiEgTadMdk9baPwB/gNCZv8PliIPiO3Qm/oafwDd+DIe3YWyQHt4YenhjucUbg/VEs/P0F6woWMHKgytZeXAlRRVFRLmjuLr31UzsP5HsLtm6TamItAlOhv8RQo+0PrOjtCtwsI51DtaxvL9qeyL1Mwa6DDx7MtC3Y1/6duzLHYPuIBAM8EXRFyTHJOs56SLS5jjWWWmtrQDWAFedMesqYGkdqy2rY/nV9fX3izSW2+Wmd4feCn4RaZOcHqn0e+AeY8y9xphBxpjpQDrwPIAx5iVjzEvVln8e6GaM+c+q5e8F7gF+29KFi4iIRCpH+/yttXOMMZ2Bxwjd5GcjcJ219suHV/c8Y/ldxpjrgP8H/IDQTX5+eK5r/EVEROQrjg/4s9bOJHSjntrmXV7LtEVAdjOXJSIi0mY53ewvIiIiLUzhLyIi0s4o/EVERNoZhb+IiEg7o/AXERFpZxT+IiIi7YzCX0REpJ1R+IuIiLQzCn8REZF2xljbPp50a4w5DOw554INl4yeJHihtA8vnPZh09B+vHDahxeuqfdhL2ttSm0z2k34NzVjzGprba7TdUQy7cMLp33YNLQfL5z24YVryX2oZn8REZF2RuEvIiLSzij8z98fnC6gDdA+vHDah01D+/HCaR9euBbbh+rzFxERaWd05i8iItLOKPxFRETaGYX/eTDGTDbG7DLGlBlj1hhjLnW6pkhhjLnMGPOWMWa/McYaY+5xuqZIY4x51Bizyhhzyhhz2BjztjEmy+m6Iokx5n5jzIaqfXjKGLPMGHO903VFsqq/S2uMec7pWiKFMeYXVfus+utgS7y3wr+RjDGTgOnAU8AIYCnwvjGmp6OFRY54YCMwBSh1uJZIdTkwExgLXAH4gQ+NMZ2cLCrC7AN+CmQDucDHwJvGmKGOVhWhjDEXA98HNjhdSwTaBqRVew1piTfVgL9GMsasADZYa79Xbdp24HVr7aPOVRZ5jDGngQestbOdriWSGWPigZPAzdbat52uJ1IZY44Bj1pr/9vpWiKJMaYDsBa4F5gGbLTWPuBsVZHBGPML4JvW2hZvudOZfyMYY3xADjDvjFnzCJ2FiTghgdC/5eNOFxKJjDFuY8xthFqlljpdTwT6A6GTnwVOFxKhMowxB6q6kl81xmS0xJt6WuJN2pBkwA0UnjG9ELiy5csRAULdUHnAMofriCjGmCGE9lk0cBr4J2ttvrNVRRZjzPeAfsCdTtcSoVYA9wBbgS7AY8BSY0ymtfZoc76xwl8kghljfg9cAlxirQ04XU+E2QYMBzoA3wReNMZcbq3d6GhVEcIYM4DQ2KdLrLWVTtcTiay171f/2RizHNgJ3A38vjnfW+HfOEeAAND1jOldgRYZoSnyJWPM/wNuA8Zba3c6XU+ksdZWADuqflxjjBkJPAx817mqIsoYQq2hm4wxX05zA5cZY+4D4qy15U4VF4mstaeNMZuA/s39Xurzb4Sq/yzWAFedMesq1FcoLcgYMx24HbjCWrvV6XraCBcQ5XQREeRNQiPTh1d7rQZerfq+wpGqIpgxJhoYCBQ093vpzL/xfg+8bIxZCXwK3AekA887WlWEqBqZ3q/qRxfQ0xgzHDhmrd3rWGERxBgzA7gLuBk4boxJrZp12lp72rHCIogx5lfAu8AXhAZM3kHoEkpd699A1toTwInq04wxxYT+LavrpAGMMb8F3gb2EurzfxyIA15s7vdW+DeStXaOMaYzoYEZaYSuWb/OWrvH2coiRi5QfVTwL6teLxIa+CLnNrnq60dnTP8l8IuWLSVipQKvVH09Sej69GuttXMdrUram+7AXwh1nxwGlgMXt0Se6Dp/ERGRdkZ9/iIiIu2Mwl9ERKSdUfiLiIi0Mwp/ERGRdkbhLyIi0s4o/EVERNoZhb+IiEg7o/AXkWZjjPkPY4xunCPSyij8RaQ5jQJWOl2EiNSkO/yJSJMzxviA04C32uQt1trBDpUkItXozF9EmoOf0CNfAUYTeg7GOOfKEZHq9GAfEWly1tqgMSYNKAJWWTUxirQqOvMXkeYyAliv4BdpfRT+ItJchgPrnC5CRM6m8BeR5jIM2OB0ESJyNoW/iDQXDzDQGJNujOnodDEi8hWFv4g0l58DtwH7gKcdrkVEqtF1/iIiIu2MzvxFRETaGYW/iIhIO6PwFxERaWcU/iIiIu2Mwl9ERKSdUfiLiIi0Mwp/ERGRdkbhLyIi0s4o/EVERNqZ/w8AqGysOMFHkgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -510,7 +515,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -550,7 +555,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Resolving fast system dynamics" + "### Resolving fast system dynamics" ] }, { @@ -592,7 +597,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -678,7 +683,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -728,7 +733,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### What sets dt, really?" + "#### What sets dt, really?" ] }, { @@ -747,19 +752,53 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Further considerations\n", - "## Additional TempoParameters arguments\n", + "## Further considerations\n", + "\n", + "### Additional TempoParameters arguments\n", "For completeness, there are a few other parameters that can be passed to the `TempoParameters` constructor:\n", - "- `subdiv_limit` and `liouvillian_epsrel`. These control the maximum number of subdivisions and relative error tolerance when integrating a time-dependent system Liouvillian to construct the system propagators. It is unlikely you will need to change them from their default values (`265`, `2**(-26)`)\n", + "\n", "- `add_correlation_time`. This allows one to include correlations _beyond_ `tcut` in the final bath tensor at `dkmax` (i.e., have your finite memory cutoff cake and eat it). Doing so may provide better approximations in cases where `tcut` is limited due to computational difficultly. See [[Strathearn2017]](http://dx.doi.org/10.1088/1367-2630/aa8744) for details.\n", + "- `liouvillian_epsrel` and `liouvillian_subdiv_limit`. These control relative error tolerance and the maximum number of subdivisions when integrating a time-dependent system Liouvillian to construct the system propagators*. It is unlikely you will need to change them from their default values (`2**(-26)`, `265`)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Additional spectral density arguments\n", + "When defining the bath parameters with a spectral density (for example with a `CustomSD` or `PowerLawSD`), large values of `tcut` can lead to numerical instabilities in the computation of the influence matrix. Indeed, the coefficients of the influence matrix are computed through discrete time differences of the `eta_function()` given by:\n", + "\n", + "$$ \\eta(\\tau) = - \\int_0^{\\infty} \\frac{J(\\omega)}{\\omega^2} \\\n", + " \\left[ ( \\cos(\\omega \\tau) - 1 ) \\coth\\left( \\frac{\\omega}{2 T}\\right) \\\n", + " - i ( \\sin(\\omega \\tau) - \\omega \\tau ) \\right] \\mathrm{d}\\omega. $$\n", + "\n", + "with memory-time `tau` $\\tau$. `tcut` is the highest value used for `tau` in this expression. Thus, high memory lengths lead to highly oscillating terms in this integral due to the $\\cos(\\tau\\omega)$ and $\\sin(\\tau\\omega)$ terms. The `CustomSD` class (and any of its subclasses, like `PowerLawSD`) deals with this by splitting the integral in two: it uses the default integrator for the divergent part near 0 and the weighted sine and cosine versions of `scipy.integrate.quad` after.\n", + "\n", + "In the `CustomSD` and `PowerLawSD` constructor we can specify three optional parameters to tweek this process:\n", + "\n", + "- `epsrel` and `subdiv_limit` control the relative error tolerance and the maximum number of subdivisions for the numerical integration, and\n", + "- `omega_tau_threshold` sets the boundary $\\tilde{\\omega}$ between the default quadrature and the weighted sine and cosine quadratures to $\\tilde{\\omega}$=`min(omega_tau_threshold/tau, cutoff)`.\n", "\n", - "## Bath coupling degeneracies\n", + "Unless your spectral density behaves very diferently from what we'd expect, you will not need to change these from their default values (`2**(-26)`, `256`, `2*pi*3.0`).\n", + "If you *do* need to adjust `omega_tau_threshold` you should decrease it if the integrator struggles with the first part of the integral (too oscillatory for the default integrator), and increase it if the integrator struggles with the second part of the integral (too divergent for the cos/sin weighted versions)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Bath coupling degeneracies\n", "The bath tensors in the TEMPO network are nominally $d^2\\times d^2$ matrices, where $d$ is the system Hilbert space dimension. \n", "If there are degeneracies in the sums or differences of the eigenvalues of the system operator coupling to the environment, it is possible for the dimension of these tensors to be reduced.\n", "\n", - "Specifying `unique=True` as an argument to `oqupy.tempo_compute`, degeneracy checking is enabled: if a dimensional reduction of the bath tensors is possible, the lower dimensional tensors will be used. We expect this to provide in many cases a significant speed-up without any significant loss of accuracy, although this has not been extensively tested (new in `v0.5.0`).\n", - "\n", - "## Mean-field systems\n", + "Specifying `unique=True` as an argument to `oqupy.tempo_compute`, degeneracy checking is enabled: if a dimensional reduction of the bath tensors is possible, the lower dimensional tensors will be used. We expect this to provide in many cases a significant speed-up without any significant loss of accuracy, although this has not been extensively tested (new in `v0.5.0`)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Mean-field systems\n", "For calculating mean-field dynamics, there is an additional requirement on `dt` being small enough so not as to introduce error when integrating the field equation of motion between timesteps (2nd order Runge-Kutta). Common experience is that this is generally satisfied if `dt` is sufficiently small to avoid Trotter error. Still, you will want to at least inspect the field dynamics in addition to the system observables when checking convergence.\n", "\n", "Note that, for the purposes of estimating the characteristic frequency of a `SystemWithField` object, `guess_tempo_parameters` uses an arbitrary complex value $\\exp(i \\pi/4)$ for the field variable when evaluating the system Hamiltonian. This may give a poor estimation for situations where the field variable is not of order $1$ in the dynamics." @@ -769,7 +808,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# PT-TEMPO\n", + "## PT-TEMPO\n", "The above considerations for `tcut`, `dt` and `epsrel` all apply to a PT-TEMPO computation, with the following caveats:\n", "\n", "1. Convergence for a TEMPO computation does not necessarily imply convergence for a PT-TEMPO computation. This is important as it is often convenient to perform several one-off TEMPO computations to determine a good set of computational parameters to save having to construct many large process tensors. You can still take this approach, but must be sure to check for convergence in the PT-TEMPO computation when you have derived a reasonable set. \n", @@ -781,7 +820,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## The dkmax anomaly \n", + "### The dkmax anomaly \n", "We consider constructing a process tensor of 250 timesteps for the harmonic environment discussed in the [Mean-Field Dynamics](https://oqupy.readthedocs.io/en/latest/pages/tutorials/mf_tempo.ipynb) tutorial, but with a smaller timestep `dt=1e-3` ps and `epsrel=1e-8` than considered there. Note that the following computations are very demanding." ] }, @@ -893,9 +932,9 @@ "hash": "3306e98808c0871e8a1685f50cc307ae5b4a4a013844b10634a4efe89132c3fe" }, "kernelspec": { - "display_name": "oqupyDev", + "display_name": "oqupy", "language": "python", - "name": "oqupydev" + "name": "oqupy" }, "language_info": { "codemirror_mode": { @@ -907,7 +946,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.15" + "version": "3.10.19" }, "widgets": { "application/vnd.jupyter.widget-state+json": { From 3230e982aba45a00e0df3384ab326221708781e4 Mon Sep 17 00:00:00 2001 From: Piper Fowler-Wright Date: Sat, 27 Jun 2026 16:32:10 +0100 Subject: [PATCH 6/6] Parameter names for contraction functions --- oqupy/system_dynamics.py | 28 +++++++++++++++------------- tests/coverage/contractions_test.py | 4 ++-- 2 files changed, 17 insertions(+), 15 deletions(-) diff --git a/oqupy/system_dynamics.py b/oqupy/system_dynamics.py index 1ddc9659..3256f5d8 100644 --- a/oqupy/system_dynamics.py +++ b/oqupy/system_dynamics.py @@ -22,7 +22,7 @@ import tensornetwork as tn from oqupy.system import TimeDependentSystemWithField -from oqupy.config import NpDtype, INTEGRATE_EPSREL, SUBDIV_LIMIT +from oqupy.config import NpDtype, LIOUVILLIAN_EPSREL, LIOUVILLIAN_SUBDIV_LIMIT from oqupy.control import Control from oqupy.dynamics import Dynamics, MeanFieldDynamics from oqupy.process_tensor import BaseProcessTensor @@ -48,8 +48,8 @@ def compute_dynamics( BaseProcessTensor]] = None, control: Optional[Control] = None, record_all: Optional[bool] = True, - subdiv_limit: Optional[int] = SUBDIV_LIMIT, - liouvillian_epsrel: Optional[float] = INTEGRATE_EPSREL, + liouvillian_subdiv_limit: Optional[int] = LIOUVILLIAN_SUBDIV_LIMIT, + liouvillian_epsrel: Optional[float] = LIOUVILLIAN_EPSREL, progress_type: Optional[Text] = None) -> Dynamics: """ Compute the system dynamics for a given system Hamiltonian, accounting @@ -74,12 +74,12 @@ def compute_dynamics( Optional control operations. record_all: bool If `false` function only computes the final state. - subdiv_limit: int (default = config.SUBDIV_LIMIT) + liouvillian_subdiv_limit: int (default = config.LIOUVILLIAN_SUBDIV_LIMIT) The maximum number of subdivisions used during the adaptive algorithm when integrating the system Liouvillian. If None then the Liouvillian is not integrated but sampled twice to to construct the system propagators at each timestep. - liouvillian_epsrel: float (default = config.INTEGRATE_EPSREL) + liouvillian_epsrel: float (default = config.LIOUVILLIAN_EPSREL) The relative error tolerance for the adaptive algorithm when integrating the system Liouvillian. progress_type: str (default = None) @@ -103,8 +103,9 @@ def compute_dynamics( num_envs = len(process_tensors) # -- prepare propagators -- - propagators = system.get_propagators(dt, start_time, subdiv_limit, - liouvillian_epsrel) + propagators = system.get_propagators(dt, start_time, + liouvillian_subdiv_limit, + liouvillian_epsrel) # -- prepare controls -- def controls(step: int): @@ -192,8 +193,8 @@ def compute_dynamics_with_field( start_time: Optional[float] = 0.0, control_list: Optional[List[Control]] = None, record_all: Optional[bool] = True, - subdiv_limit: Optional[int] = SUBDIV_LIMIT, - liouvillian_epsrel: Optional[float] = INTEGRATE_EPSREL, + liouvillian_subdiv_limit: Optional[int] = LIOUVILLIAN_SUBDIV_LIMIT, + liouvillian_epsrel: Optional[float] = LIOUVILLIAN_EPSREL, progress_type: Optional[Text] = None) -> MeanFieldDynamics: """ Compute each system and field dynamics for a MeanFieldSystem @@ -223,12 +224,12 @@ def compute_dynamics_with_field( Optional list of control operations. record_all: bool If `false` function only computes the final state. - subdiv_limit: int (default = config.SUBDIV_LIMIT) + liouvillian_subdiv_limit: int (default = config.LIOUVILLIAN_SUBDIV_LIMIT) The maximum number of subdivisions used during the adaptive algorithm when integrating the system Liouvillian. If None then the Liouvillian is not integrated but sampled twice to to construct the system propagators at each timestep. - liouvillian_epsrel: float (default = config.INTEGRATE_EPSREL) + liouvillian_epsrel: float (default = config.LIOUVILLIAN_EPSREL) The relative error tolerance for the adaptive algorithm when integrating the system Liouvillian. progress_type: str (default = None) @@ -311,8 +312,9 @@ def compute_dynamics_with_field( num_envs_list = [len(process_tensors) for process_tensors in parsed_parameters_dict["process_tensors"]] - propagators_list = [system.get_propagators(dt, start_time, subdiv_limit, - liouvillian_epsrel) + propagators_list = [system.get_propagators(dt, start_time, + liouvillian_subdiv_limit, + liouvillian_epsrel) for system in parsed_parameters_dict["system"]] # -- prepare compute field -- diff --git a/tests/coverage/contractions_test.py b/tests/coverage/contractions_test.py index 14452563..90eab973 100644 --- a/tests/coverage/contractions_test.py +++ b/tests/coverage/contractions_test.py @@ -69,7 +69,7 @@ def test_compute_dynamics_with_field(): # check initial field recorded correctly assert np.isclose(mean_field_dynamics.fields[0], initial_field) - # Test subdiv_limit == None + # Test liouvillian_subdiv_limit == None mean_field_dynamics2 = oqupy.compute_dynamics_with_field( mean_field_system, initial_field, @@ -77,7 +77,7 @@ def test_compute_dynamics_with_field(): dt = 0.2, num_steps = num_steps, start_time = start_time, - subdiv_limit = None + liouvillian_subdiv_limit = None ) # input checks