def get_from_stepwise_convergence(J,
domain,
nof_coefficients,
disc_type='sp_quad',
interval_type='log',
mapping_type='sp_hes',
permute=None,
residual=True,
low_memory=True,
stable=False,
min_ncap=10,
max_ncap=2000,
step_ncap=1,
stop_rel=1e-10,
stop_abs=1e-10,
get_trafo=False,
**kwargs):
"""
Parameters are the same as for get_from_convergence. Uses a slightly different convergence condition
(see BaseMapping.compute_from_stepwise_convergence for an explanation), which is often
faster than the other one.
Defaults to logarithmic intervals for the direct discretization
"""
if disc_type == 'bsdo':
# mapping back and forth would be superfluous, just use orthpol directly
# There is no bsdo stepwise convergence implemented currently so just take the normal one
c0, omega, t, info = get_bsdo_from_convergence(J,
domain,
nof_coefficients,
min_ncap=min_ncap,
step_ncap=step_ncap,
max_ncap=max_ncap,
stop_abs=stop_abs,
stop_rel=stop_rel)
info['trafo'] = None
info['res'] = None
else:
disc_bath = get_discretized_bath(J,
domain,
max_nof_coefficients=max(
max_ncap, nof_coefficients),
disc_type=disc_type,
interval_type=interval_type,
**kwargs)
mapping = get_mapping(disc_bath,
mapping_type=mapping_type,
max_nof_coefficients=nof_coefficients,
low_memory=low_memory,
stable=stable)
info = mapping.compute_from_stepwise_convergence(nof_coefficients,
min_ncap=min_ncap,
max_ncap=max_ncap,
step_ncap=step_ncap,
stop_rel=stop_rel,
stop_abs=stop_abs,
permute=permute,
residual=residual,
get_trafo=get_trafo)
c0, omega, t = mapping.get_coefficients()
return c0, omega, t, info
def from_bath_from_stepwise_convergence(discretized_bath,
nof_coefficients,
mapping_type='sp_hes',
permute=None,
residual=True,
low_memory=True,
stable=False,
min_ncap=10,
max_ncap=2000,
step_ncap=1,
stop_rel=1e-10,
stop_abs=1e-10,
get_trafo=False):
"""
Uses the same convergence condition for the discretized coefficients as get_from_stepwise_discretization.
Parameters are a mix between the ones from get_from_stepwise_discretization and from_bath
"""
mapping = get_mapping(discretized_bath,
mapping_type=mapping_type,
max_nof_coefficients=nof_coefficients,
low_memory=low_memory,
stable=stable)
info = mapping.compute_from_stepwise_convergence(nof_coefficients,
min_ncap=min_ncap,
max_ncap=max(
max_ncap,
nof_coefficients),
step_ncap=step_ncap,
stop_rel=stop_rel,
stop_abs=stop_abs,
permute=permute,
residual=residual,
get_trafo=get_trafo)
c0, omega, t = mapping.get_coefficients()
return c0, omega, t, info
def from_bath(discretized_bath,
nof_coefficients,
mapping_type='lan_bath',
permute=None,
residual=True,
low_memory=True,
stable=False,
ncap=None,
get_trafo=False):
"""
Interface for the generation of chain coefficients from pre-constructed discretized_bath objects.
:param discretized_bath: Discretized bath object
:param nof_coefficients: Desired number of chain coefficients (=number of bath sites)
:param mapping_type: Type of the mapping to be used (see chain.get_mapping for an in-depth explanation)
:param permute: If the star coefficients should be permuted before each tridiagonalization (essentially
sorting them, see utils.sorting.sort_star_coefficients for an explanation of the
possible parameters). This may help increase numerical stability for Lanczos tridiagonalization
specifically
:param residual: If set True computes the residual for the tridiagonalization.
This may use extra memory, specifically if low_memory was set True.
:param low_memory: Uses a more memory efficient version of the lanczos algorithms, which may be slightly slower
:param stable: Uses a stable summation algorithm, which is much slower but may help counteract some
some stability problems encountered with Lanczos tridiagonalization
:param ncap: Accuracy parameter (number of discretized coefficients). Default is None. If None,
we set ncap=nof_coefficients (unitary map)
:param get_trafo: Returns the corresponding transformation matrix
:return: c0 (System-Bath coupling), omega (Bath energies), t (bath-bath couplings),
info dict with keys: 'ncap': Number of star discretization points/orthpol_ncap,
'res': Computed residual of the tridiagonaliation
'trafo': Transformation matix between star and chain
"""
if ncap is None:
ncap = nof_coefficients
mapping = get_mapping(discretized_bath,
mapping_type=mapping_type,
max_nof_coefficients=nof_coefficients,
low_memory=low_memory,
stable=stable)
info = mapping.compute(ncap,
permute=permute,
residual=residual,
get_trafo=get_trafo)
c0, omega, t = mapping.get_coefficients()
return c0, omega, t, info
def get(J,
domain,
nof_coefficients,
ncap=None,
disc_type='sp_quad',
interval_type='lin',
mapping_type='lan_bath',
permute=None,
residual=True,
low_memory=True,
stable=False,
get_trafo=False,
**kwargs):
"""
Main interface for the generation of chain coefficients.
:param J: Spectral density of the bath as vectorized python function of one argument
:param domain: Domain (support) of the spectral density as list/tuple/numpy array like [a, b]
:param nof_coefficients: Desired number of chain coefficients (=number of bath sites)
:param ncap: Accuracy parameter for the calculation of the coefficients (=orthpol_ncap for bsdo,
otherwise represents the number of coefficients in the discretized star to be used for the mapping)
Default is None, which sets ncap=nof_coefficients for non bsdo (unitary map) and ncap=60000 for bsdo.
If set < nof_coefficient, it is automatically set equal to nof_coefficients.
:param disc_type: Type of the discretization (see star.get_discretized_bath for an in-depth explanation)
:param interval_type: Type of intervals for the discretization (see star.get_discretized_bath
for an in-depth explanation)
:param mapping_type: Type of the mapping to be used (see chain.get_mapping for an in-depth explanation)
:param permute: If the star coefficients should be permuted before each tridiagonalization (essentially
sorting them, see utils.sorting.sort_star_coefficients for an explanation of the
possible parameters). This may help increase numerical stability for Lanczos tridiagonalization
specifically
:param residual: If set True computes the residual for the tridiagonalization.
This may use extra memory, specifically if low_memory was set True.
:param low_memory: Uses a more memory efficient version of the lanczos algorithms, which may be slightly slower
:param stable: Uses a stable summation algorithm, which is much slower but may help counteract some
some stability problems encountered with Lanczos tridiagonalization
:param get_trafo: Returns the corresponding transformation matrix
:param kwargs: Additional parameters for the discretization
:return: c0 (System-Bath coupling), omega (Bath energies), t (bath-bath couplings),
info dict with keys: 'ncap': Number of star discretization points/orthpol_ncap,
'res': Computed residual of the tridiagonaliation
'trafo': Transformation matix between star and chain
"""
if disc_type == 'bsdo':
# mapping back and forth would be superfluous, just use orthpol directly
c0, omega, t = get_bsdo(J,
domain,
nof_coefficients=nof_coefficients,
orthpol_ncap=ncap)
info = dict()
info['ncap'] = ncap
info['res'] = None
info['trafo'] = None
else:
if ncap is None:
ncap = nof_coefficients
disc_bath = get_discretized_bath(J,
domain,
max_nof_coefficients=max(
ncap, nof_coefficients),
disc_type=disc_type,
interval_type=interval_type,
**kwargs)
disc_bath.compute_all()
mapping = get_mapping(disc_bath,
mapping_type=mapping_type,
max_nof_coefficients=nof_coefficients,
low_memory=low_memory,
stable=stable)
info = mapping.compute(nof_coefficients,
ncap=ncap,
permute=permute,
residual=residual,
get_trafo=get_trafo)
c0, omega, t = mapping.get_coefficients()
return c0, omega, t, info
def get_from_convergence(J,
domain,
nof_coefficients,
disc_type='sp_quad',
interval_type='log',
mapping_type='sp_hes',
permute=None,
residual=True,
low_memory=True,
stable=False,
min_ncap=10,
max_ncap=2000,
step_ncap=1,
stop_rel=1e-10,
stop_abs=1e-10,
get_trafo=False,
**kwargs):
"""
Interface for the generation of chain coefficients, which uses a convergence condition.
See BaseMapping.compute_from_convergence for details.
Defaults to logarithmic intervals for the direct discretization
:param J: Spectral density of the bath as vectorized python function of one argument
:param domain: Domain (support) of the spectral density as list/tuple/numpy array like [a, b]
:param nof_coefficients: Desired number of chain coefficients (=number of bath sites)
:param min_ncap: Minimum accuracy to use for the computaton (start of the convergence check)
Must be >= nof_coefficients. If not so, is set automatically to nof_coefficients
:param max_ncap: Maximum accuracy parameter. Forces exit if ncap reaches that value without convergence
Must be <= discretized_bath.max_nof_coefficients. If not so is set automatically to
:param step_ncap: Number of star coefficients to be added in each step of the convergence
:param stop_rel: Target relative deviation between successive steps. May be None if stop_abs is not None
:param stop_abs: Target aboslute deviation between successive steps. May be None if stop_rel is not None
:param disc_type: Type of the discretization (see star.get_discretized_bath for an in-depth explanation)
:param interval_type: Type of intervals for the discretization (see star.get_discretized_bath
for an in-depth explanation)
:param mapping_type: Type of the mapping to be used (see chain.get_mapping for an in-depth explanation)
:param permute: If the star coefficients should be permuted before each tridiagonalization (essentially
sorting them, see utils.sorting.sort_star_coefficients for an explanation of the
possible parameters). This may help increase numerical stability for Lanczos tridiagonalization
specifically
:param residual: If set True computes the residual for the tridiagonalization.
This may use extra memory, specifically if low_memory was set True.
:param low_memory: Uses a more memory efficient version of the lanczos algorithms, which may be slightly slower
:param stable: Uses a stable summation algorithm, which is much slower but may help counteract some
some stability problems encountered with Lanczos tridiagonalization
:param get_trafo: Returns the corresponding transformation matrix
:param kwargs: Additional parameters for the discretization
:return: c0 (System-Bath coupling), omega (Bath energies), t (bath-bath couplings),
info dict with keys: 'ncap': Number of star discretization points/orthpol_ncap,
'res': Computed residual of the tridiagonaliation
'trafo': Transformation matix between star and chain
"""
if disc_type == 'bsdo':
# mapping back and forth would be superfluous, just use orthpol directly
c0, omega, t, info = get_bsdo_from_convergence(J,
domain,
nof_coefficients,
min_ncap=min_ncap,
step_ncap=step_ncap,
max_ncap=max_ncap,
stop_abs=stop_abs,
stop_rel=stop_rel)
info['trafo'] = None
info['res'] = None
else:
disc_bath = get_discretized_bath(J,
domain,
max_nof_coefficients=max(
max_ncap, nof_coefficients),
disc_type=disc_type,
interval_type=interval_type,
**kwargs)
mapping = get_mapping(disc_bath,
mapping_type=mapping_type,
max_nof_coefficients=nof_coefficients,
low_memory=low_memory,
stable=stable)
info = mapping.compute_from_convergence(nof_coefficients,
min_ncap=min_ncap,
max_ncap=max_ncap,
step_ncap=step_ncap,
stop_rel=stop_rel,
stop_abs=stop_abs,
permute=permute,
residual=residual,
get_trafo=get_trafo)
c0, omega, t = mapping.get_coefficients()
return c0, omega, t, info