def __init__(self, model_params):
model_params = asConfig(model_params, "AKLTModel")
L = model_params.get('L', 2)
site = SpinSite(S=1., conserve='Sz')
# lattice
bc_MPS = model_params.get('bc_MPS', 'finite')
bc = 'open' if bc_MPS == 'finite' else 'periodic'
lat = Chain(L, site, bc=bc, bc_MPS=bc_MPS)
Sp, Sm, Sz = site.Sp, site.Sm, site.Sz
S_dot_S = 0.5 * (kron(Sp, Sm) + kron(Sm, Sp)) + kron(Sz, Sz)
S_dot_S_square = npc.tensordot(S_dot_S, S_dot_S, [['(p0*.p1*)'], ['(p0.p1)']])
H_bond = S_dot_S + S_dot_S_square / 3.
# P_2 = H_bond * 0.5 + 1/3 * npc.eye_like(S_dot_S)
J = model_params.get('J', 1.)
H_bond = J * H_bond.split_legs().transpose(['p0', 'p1', 'p0*', 'p1*'])
H_bond = [H_bond] * L
# H_bond[i] acts on sites (i-1, i)
if bc_MPS == "finite":
H_bond[0] = None
# 7) initialize H_bond (the order of 7/8 doesn't matter)
NearestNeighborModel.__init__(self, lat, H_bond)
# 9) initialize H_MPO
MPOModel.__init__(self, lat, self.calc_H_MPO_from_bond())
def test_parameters():
pars = Config(dict(), "Test empty")
example_function(pars)
pars = dict(
a=None,
b=2.5,
d="dict-style access",
e="non-used",
sub=dict(x=10, y=20),
verbose=1,
)
pars_copy = copy.deepcopy(pars)
config = asConfig(pars, "Test parameters")
example_function(config)
assert config['d'] == "dict-style access" # reads out d
pars_copy['c'] = 2
assert config.as_dict() == pars_copy
sub = config.subconfig("sub")
sub.setdefault('z', 30)
pars_copy['sub']['z'] = 30
pars_copy['sub']['verbose'] = pars['verbose'] / 10.
assert config.as_dict() == pars_copy
example_function(sub)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
assert len(config.unused) == 1
del config # catch the warning for 'e'
del pars
assert len(w) == 1
sub.deprecated_alias('y', 'y_new')
assert len(w) == 2
assert len(sub.unused) == 2
del sub # catch warnings for 'x', y'
assert len(w) == 3
def test_parameters():
pars = Config(dict(), "Test empty")
example_function(pars)
pars = dict(
a=None,
b=2.5,
d="dict-style access",
e="non-used",
sub=dict(x=10, y=20),
)
pars_copy = copy.deepcopy(pars)
config = asConfig(pars, "Test parameters")
example_function(config)
assert config['d'] == "dict-style access" # reads out d
pars_copy['c'] = 2
assert config.as_dict() == pars_copy
sub = config.subconfig("sub")
sub.setdefault('z', 30)
pars_copy['sub']['z'] = 30
assert config.as_dict() == pars_copy
example_function(sub)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
assert len(config.unused) == 1
del config # catch the warning for 'e'
del pars
# assert len(w) == 1
sub.deprecated_alias('y', 'y_new')
# assert len(w) == 2
assert len(sub.unused) == 2
sub.__del__()
assert len(w) == 3
sub.touch(
'x', 'y_new'
) # avoid warnings when deconstructed outside of the catch_warning
def __init__(self, psi, model, options, environment=None):
if model.H_MPO.explicit_plus_hc:
raise NotImplementedError("TDVP does not respect 'MPO.explicit_plus_hc' flag")
self.options = options = asConfig(options, "TDVP")
self.verbose = options.get('verbose', 1)
self.lanczos_options = options.subconfig('lanczos_options')
if environment is None:
environment = MPOEnvironment(psi, model.H_MPO, psi)
self.evolved_time = options.get('start_time', 0.)
self.H_MPO = model.H_MPO
self.environment = environment
if not psi.finite:
raise ValueError("TDVP is only implemented for finite boundary conditions")
self.psi = psi
self.L = self.psi.L
self.dt = options.get('dt', 2)
self.trunc_params = options.get('trunc_params', {})
self.N_steps = options.get('N_steps', 10)
def test_parameters():
pars = Config(dict(), "Test empty")
example_function(pars)
pars = dict(a=None, b=2.5, d="dict-style", e="non-used", sub=dict(x=10, y=20), verbose=1)
config = asConfig(pars, "Test parameters")
example_function(config)
assert config['d'] == "dict-style"
sub = config.subconfig("sub")
sub.setdefault('z', 30)
example_function(sub)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
assert len(config.unused) == 1
del config # catch the warning for 'e'
assert len(w) == 1
sub.deprecated_alias('y', 'y_new')
assert len(w) == 2
assert len(sub.unused) == 2
del sub # catch warnings for 'x', y'
assert len(w) == 3
def __init__(self, model_params):
# model parameters
model_params = asConfig(model_params,
"ExponentiallyDecayingHeisenberg")
L = model_params.get('L', 2)
xi = model_params.get('xi', 0.5)
Jxx = model_params.get('Jxx', 1.)
Jz = model_params.get('Jz', 1.5)
hz = model_params.get('hz', 0.)
conserve = model_params.get('conserve', 'Sz')
if xi == 0.:
g = 0.
elif xi == np.inf:
g = 1.
else:
g = np.exp(-1 / (xi))
# Define the sites and the lattice, which in this case is a simple uniform chain
# of spin 1/2 sites
site = SpinHalfSite(conserve=conserve)
lat = Chain(L, site, bc_MPS='infinite', bc='periodic')
# The operators that appear in the Hamiltonian. Standard spin operators are
# already defined for the spin 1/2 site, but it is also possible to add new
# operators using the add_op method
Sz, Sp, Sm, Id = site.Sz, site.Sp, site.Sm, site.Id
# yapf:disable
# The grid (list of lists) that defines the MPO. It is possible to define the
# operators in the grid in the following ways:
# 1) NPC arrays, defined above:
grid = [[Id, Sp, Sm, Sz, -hz*Sz ],
[None, g*Id, None, None, 0.5*Jxx*Sm],
[None, None, g*Id, None, 0.5*Jxx*Sp],
[None, None, None, g*Id, Jz*Sz ],
[None, None, None, None, Id ]]
# 2) In the form [("OpName", strength)], where "OpName" is the name of the
# operator (e.g. "Sm" for Sm) and "strength" is a number that multiplies it.
grid = [[[("Id", 1)], [("Sp",1)], [("Sm",1)], [("Sz",1)], [("Sz", -hz)] ],
[None , [("Id",g)], None , None , [("Sm", 0.5*Jxx)]],
[None , None , [("Id",g)], None , [("Sp", 0.5*Jxx)]],
[None , None , None , [("Id",g)], [("Sz",Jz)] ],
[None , None , None , None , [("Id",1)] ]]
# 3) It is also possible to write a single "OpName", equivalent to
# [("OpName", 1)].
grid = [["Id" , "Sp" , "Sm" , "Sz" , [("Sz", -hz)] ],
[None , [("Id",g)], None , None , [("Sm", 0.5*Jxx)]],
[None , None , [("Id",g)], None , [("Sp", 0.5*Jxx)]],
[None , None , None , [("Id",g)], [("Sz",Jz)] ],
[None , None , None , None , "Id" ]]
# yapf:enable
grids = [grid] * L
# Generate the MPO from the grid. Note that it is not necessary to specify
# the physical legs and their charges, since the from_grids method can extract
# this information from the position of the operators inside the grid.
H = MPO.from_grids(lat.mps_sites(),
grids,
bc='infinite',
IdL=0,
IdR=-1)
MPOModel.__init__(self, lat, H)
def __init__(self, model_params):
model_params = asConfig(model_params, self.__class__.__name__)
model_params.setdefault('lattice', "Chain")
CouplingMPOModel.__init__(self, model_params)
