def test_squeeze(sc):
from numpy import ones as npones
x = npones((1, 2, 1, 4))
b = ones((1, 2, 1, 4), sc, axis=0)
assert allclose(b.squeeze().toarray(), x.squeeze())
assert allclose(b.squeeze((0, 2)).toarray(), x.squeeze((0, 2)))
assert allclose(b.squeeze(0).toarray(), x.squeeze(0))
assert allclose(b.squeeze(2).toarray(), x.squeeze(2))
assert b.squeeze().split == 0
assert b.squeeze((0, 2)).split == 0
assert b.squeeze(2).split == 1
x = npones((1, 2, 1, 4))
b = ones((1, 2, 1, 4), sc, axis=(0, 1))
assert allclose(b.squeeze().toarray(), x.squeeze())
assert allclose(b.squeeze((0, 2)).toarray(), x.squeeze((0, 2)))
assert allclose(b.squeeze(0).toarray(), x.squeeze(0))
assert allclose(b.squeeze(2).toarray(), x.squeeze(2))
assert b.squeeze().split == 1
assert b.squeeze((0, 2)).split == 1
assert b.squeeze(2).split == 2
x = npones((1, 1, 1, 1))
b = ones((1, 1, 1, 1), sc, axis=(0, 1))
assert allclose(b.squeeze().toarray(), x.squeeze())
def test_squeeze(sc):
from numpy import ones as npones
x = npones((1, 2, 1, 4))
b = ones((1, 2, 1, 4), sc, axis=0)
assert allclose(b.squeeze().toarray(), x.squeeze())
assert allclose(b.squeeze((0, 2)).toarray(), x.squeeze((0, 2)))
assert allclose(b.squeeze(0).toarray(), x.squeeze(0))
assert allclose(b.squeeze(2).toarray(), x.squeeze(2))
assert b.squeeze().split == 0
assert b.squeeze((0, 2)).split == 0
assert b.squeeze(2).split == 1
x = npones((1, 2, 1, 4))
b = ones((1, 2, 1, 4), sc, axis=(0, 1))
assert allclose(b.squeeze().toarray(), x.squeeze())
assert allclose(b.squeeze((0, 2)).toarray(), x.squeeze((0, 2)))
assert allclose(b.squeeze(0).toarray(), x.squeeze(0))
assert allclose(b.squeeze(2).toarray(), x.squeeze(2))
assert b.squeeze().split == 1
assert b.squeeze((0, 2)).split == 1
assert b.squeeze(2).split == 2
x = npones((1, 1, 1, 1))
b = ones((1, 1, 1, 1), sc, axis=(0, 1))
assert allclose(b.squeeze().toarray(), x.squeeze())
def FillNC(root_grp_ptr, scene_location):
retGps = NT("returnGroups", "calGrp, productsGrp, navGrp, slaGrp, periodGrp")
root_grp_ptr.createDimension('samples', 512)
root_grp_ptr.createDimension('scan_lines', 2000)
root_grp_ptr.createDimension('bands', 128)
root_grp_ptr.instrument = 'HICO'
root_grp_ptr.institution = 'NASA Goddard Space Flight Center'
root_grp_ptr.resolution = '100m'
root_grp_ptr.location_description = scene_location
root_grp_ptr.license = 'http://science.nasa.gov/earth-science/earth-science-data/data-information-policy/'
root_grp_ptr.naming_authority = 'gov.nasa.gsfc.sci.oceandata'
root_grp_ptr.date_created = DT.strftime(DT.utcnow(), '%Y-%m-%dT%H:%M:%SZ')
root_grp_ptr.creator_name = 'NASA/GSFC'
root_grp_ptr.creator_email = '*****@*****.**'
root_grp_ptr.publisher_name = 'NASA/GSFC'
root_grp_ptr.publisher_url = 'http_oceancolor.gsfc.nasa.gov'
root_grp_ptr.publisher_email = '*****@*****.**'
root_grp_ptr.processing_level = 'L1B'
nav_grp = root_grp_ptr.createGroup('navigation')
nav_vars = list()
nav_vars.append(nav_grp.createVariable('sensor_zenith', 'f4', ('scan_lines', 'samples',)))
nav_vars.append(nav_grp.createVariable('solar_zenith', 'f4', ('scan_lines', 'samples',)))
nav_vars.append(nav_grp.createVariable('sensor_azimuth', 'f4', ('scan_lines', 'samples',)))
nav_vars.append(nav_grp.createVariable('solar_azimuth', 'f4', ('scan_lines', 'samples',)))
nav_vars.append(nav_grp.createVariable('longitudes', 'f4', ('scan_lines', 'samples',)))
nav_vars.append(nav_grp.createVariable('latitudes', 'f4', ('scan_lines', 'samples',)))
for var in nav_vars:
var.units = 'degrees'
var.valid_min = -180
var.valid_max = 180
var.long_name = var.name.replace('_', ' ').rstrip('s')
retGps.navGrp = nav_grp
retGps.productsGrp = root_grp_ptr.createGroup('products')
lt = retGps.productsGrp.createVariable('Lt', 'u2', ('scan_lines',
'samples', 'bands'))
lt.scale_factor = float32([0.02])
lt.add_offset = float32(0)
lt.units = "W/m^2/micrometer/sr"
# lt.valid_range = nparray([0, 16384], dtype='u2')
lt.long_name = "HICO Top of Atmosphere"
lt.wavelength_units = "nanometers"
# lt.createVariable('fwhm', 'f4', ('bands',))
lt.fwhm = npones((128,), dtype='f4') * -1
# wv = lt.createVariable('wavelengths', 'f4', ('bands',))
lt.wavelengths = npones((128,), dtype='f4')
lt.wavelength_units = "nanometers"
retGps.slaGrp = root_grp_ptr.createGroup('scan_line_attributes')
retGps.slaGrp.createVariable('scan_quality_flags', 'u1', ('scan_lines',
'samples'))
# Create metadata group and sub-groups
meta_grp = root_grp_ptr.createGroup('metadata')
pl_info_grp = meta_grp.createGroup("FGDC/Identification_Information/Platform_and_Instrument_Identification")
pl_info_grp.Instrument_Short_Name = "hico"
prc_lvl_grp = meta_grp.createGroup("FGDC/Identification_Information/Processing_Level")
prc_lvl_grp.Processing_Level_Identifier = "Level-1B"
retGps.periodGrp = meta_grp.createGroup("FGDC/Identification_Information/Time_Period_of_Content")
# fill HICO group
retGps.calGrp = meta_grp.createGroup("HICO/Calibration")
return retGps
def test_ones(sc):
from numpy import ones as npones
x = npones((2, 3, 4))
b = ones((2, 3, 4), sc)
assert allclose(x, b.toarray())
x = npones(5)
b = ones(5, sc)
assert allclose(x, b.toarray())
def test_astype(sc):
from numpy import ones as npones
a = npones(2**8, dtype=int64)
b = array(a, sc, dtype=int64)
c = b.astype(bool)
assert c.dtype == dtype(bool)
dtypes = c._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(bool)
b = ones((100, 100), sc, dtype=int64)
c = b.astype(bool)
assert c.dtype == dtype(bool)
dtypes = c._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(bool)
b = ones((100, 100), sc)
c = b.astype(bool)
assert c.dtype == dtype(bool)
dtypes = c._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(bool)
def __init__(self, leaf_num: int, ancestor_num: int, gene_num: int,
leaves: List[List[int]], all_paths: List[PGMPathForAGenome],
medians: List[MedianData], nodes_int: ndarray,
nodes_str: List[str]):
"""
Parameters
----------
leaf_num : int
Number of leaves in the tree
ancestor_num : int
Number of ancestors (medians) in the tree
gene_num : int
Total number of genes in the tree
leaves : List[ndarray]
List of each leaf for each genome in the tree (in relation to the median)
all_paths : List[PGMPathForAGenome]
List of all paths for each genome in the tree
medians : List[MedianData]
List of all medians in the tree
nodes_int : ndarray
List of the integer representations of each node
nodes_str : List[str]
List of the string representations of each node
"""
self.leaf_num: int = leaf_num
self.changed: ndarray = npones(ancestor_num)
self.gene_num: int = gene_num
self.leaves: List[List[int]] = leaves
self.all_paths: List[PGMPathForAGenome] = all_paths
self.medians: List[MedianData] = medians
self.nodes_int: ndarray = nodes_int
self.nodes_str: List[str] = nodes_str
def val2vecParams(N, hamParams):
# Extract values
if not isinstance(hamParams[0], (collections.Sequence, npndarray)):
a = float(hamParams[0])
aVec = npzeros(N, dtype=float_)
aVec[0] = a
else:
aVec = a
if not isinstance(hamParams[1], (collections.Sequence, npndarray)):
g = float(hamParams[1])
gVec = npzeros(N, dtype=float_)
gVec[0] = g
else:
gVec = g
if not isinstance(hamParams[2], (collections.Sequence, npndarray)):
p = float(hamParams[2])
pVec = p * npones(N, dtype=float_)
else:
pVec = p
if not isinstance(hamParams[3], (collections.Sequence, npndarray)):
q = float(hamParams[3])
qVec = q * npones(N, dtype=float_)
else:
qVec = q
if not isinstance(hamParams[4], (collections.Sequence, npndarray)):
b = float(hamParams[4])
bVec = npzeros(N, dtype=float_)
bVec[-1] = b
else:
bVec = b
if not isinstance(hamParams[5], (collections.Sequence, npndarray)):
d = float(hamParams[5])
dVec = npzeros(N, dtype=float_)
dVec[-1] = d
else:
dVec = d
if not isinstance(hamParams[6], (collections.Sequence, npndarray)):
s = float(hamParams[6])
sVec = s * npones(N, dtype=float_)
else:
sVec = s
# Convert to vectors
returnParams = (aVec, gVec, pVec, qVec, bVec, dVec, sVec)
return returnParams
def test_stacked_shape_inference(sc):
from numpy import ones as npones
a = ones((100, 2), sc)
a._rdd = a._rdd.partitionBy(2)
s = a.stack(5)
n = s.tordd().count()
# operations that preserve keys
assert s.map(lambda x: x * 2).unstack().shape == (100, 2)
assert s.map(lambda x: x.sum(axis=1)).unstack().shape == (100, )
assert s.map(lambda x: tile(x, (1, 2))).unstack().shape == (100, 4)
# operations that create new keys
assert s.map(lambda x: npones((2, 2))).unstack().shape == (n, 2, 2)
assert s.map(lambda x: x.sum(axis=0)).unstack().shape == (n, 2)
assert s.map(lambda x: asarray([2])).unstack().toarray().shape == (n, 1)
assert s.map(lambda x: asarray(2)).unstack().toarray().shape == (n, )
# composing functions works
assert s.map(lambda x: x * 2).map(lambda x: x * 2).unstack().shape == (100,
2)
assert s.map(lambda x: x * 2).map(lambda x: npones(
(2, 2))).unstack().shape == (n, 2, 2)
assert s.map(lambda x: npones((2, 2))).map(
lambda x: x * 2).unstack().shape == (n, 2, 2)
# check the result
assert allclose(
s.map(lambda x: x.sum(axis=1)).unstack().toarray(),
npones(100) * 2)
assert allclose(
s.map(lambda x: tile(x, (1, 2))).unstack().toarray(), npones((100, 4)))
with pytest.raises(ValueError):
s.map(lambda x: 2)
with pytest.raises(ValueError):
s.map(lambda x: None)
with pytest.raises(RuntimeError):
s.map(lambda x: 1 / 0)
def test_stacked_shape_inference(sc):
from numpy import ones as npones
a = ones((100, 2), sc)
a._rdd = a._rdd.partitionBy(2)
s = a.stack(5)
n = s.tordd().count()
# operations that preserve keys
assert s.map(lambda x: x * 2).unstack().shape == (100, 2)
assert s.map(lambda x: x.sum(axis=1)).unstack().shape == (100,)
assert s.map(lambda x: tile(x, (1, 2))).unstack().shape == (100, 4)
# operations that create new keys
assert s.map(lambda x: npones((2, 2))).unstack().shape == (n, 2, 2)
assert s.map(lambda x: x.sum(axis=0)).unstack().shape == (n, 2)
assert s.map(lambda x: asarray([2])).unstack().toarray().shape == (n, 1)
assert s.map(lambda x: asarray(2)).unstack().toarray().shape == (n,)
# composing functions works
assert s.map(lambda x: x * 2).map(lambda x: x * 2).unstack().shape == (100, 2)
assert s.map(lambda x: x * 2).map(lambda x: npones((2, 2))).unstack().shape == (n, 2, 2)
assert s.map(lambda x: npones((2, 2))).map(lambda x: x * 2).unstack().shape == (n, 2, 2)
# check the result
assert allclose(s.map(lambda x: x.sum(axis=1)).unstack().toarray(), npones(100) * 2)
assert allclose(s.map(lambda x: tile(x, (1, 2))).unstack().toarray(), npones((100, 4)))
with pytest.raises(ValueError):
s.map(lambda x: 2)
with pytest.raises(ValueError):
s.map(lambda x: None)
with pytest.raises(RuntimeError):
s.map(lambda x: 1/0)
def ma(self, tap=3):
data = self.get_amp()
data[0] = 0
from numpy import convolve
from numpy import ones as npones
# ma = [1. / tap] * tap
m = npones(tap) / tap
res = convolve(data, m, "same")
Spec = SpectrumData(res, self.get_xdata())
Spec._fs = self._fs
return Spec
def ma(self, tap=3):
data = self.get_amp()
data[0] = 0
from numpy import convolve
from numpy import ones as npones
# ma = [1. / tap] * tap
m = npones(tap) / tap
res = convolve(data, m, "same")
Spec = SpectrumData(res, self.get_xdata())
Spec._fs = self._fs
return Spec
def test_dtype(sc):
a = arange(2 ** 8, dtype=int64)
b = array(a, sc, dtype=int64)
assert a.dtype == b.dtype
assert b.dtype == dtype(int64)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(int64)
a = arange(2.0 ** 8)
b = array(a, sc)
assert a.dtype == b.dtype
assert b.dtype == dtype(float64)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(float64)
a = arange(2 ** 8)
b = array(a, sc)
assert a.dtype == b.dtype
assert b.dtype == dtype(int64)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(int64)
from numpy import ones as npones
a = npones(2 ** 8, dtype=bool)
b = array(a, sc)
assert a.dtype == b.dtype
assert b.dtype == dtype(bool)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(bool)
b = ones(2 ** 8, sc)
assert b.dtype == dtype(float64)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(float64)
b = ones(2 ** 8, sc, dtype=bool)
assert b.dtype == dtype(bool)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(bool)
def test_dtype(sc):
a = arange(2**8, dtype=int64)
b = array(a, sc, dtype=int64)
assert a.dtype == b.dtype
assert b.dtype == dtype(int64)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(int64)
a = arange(2.0**8)
b = array(a, sc)
assert a.dtype == b.dtype
assert b.dtype == dtype(float64)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(float64)
a = arange(2**8)
b = array(a, sc)
assert a.dtype == b.dtype
assert b.dtype == dtype(int64)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(int64)
from numpy import ones as npones
a = npones(2**8, dtype=bool)
b = array(a, sc)
assert a.dtype == b.dtype
assert b.dtype == dtype(bool)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(bool)
b = ones(2**8, sc)
assert b.dtype == dtype(float64)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(float64)
b = ones(2**8, sc, dtype=bool)
assert b.dtype == dtype(bool)
dtypes = b._rdd.map(lambda x: x[1].dtype).collect()
for dt in dtypes:
assert dt == dtype(bool)
def dmrg(mpo,
mps=None,
mpsl=None,
env=None,
envl=None,
mbd=10,
tol=1.e-5,
max_iter=10,
min_iter=0,
noise=0.,
mps_subdir='mps',
env_subdir='env',
mpsl_subdir='mpsl',
envl_subdir='envl',
nStates=2,
dtype=complex_,
fixed_bd=False,
alg='davidson',
return_state=False,
return_env=False,
return_entanglement=False,
return_wgt=False,
orthonormalize=False,
state_avg=True,
left=False,
start_gauge=0,
end_gauge=0):
"""
Run the one-site DMRG algorithm
Args:
mpo : 1D Array
An array that contains a list of mpos, each of which
is a list with an array for each site in the lattice
representing the mpo at that site.
Kwargs:
mps : 1D Array of Matrix Product States
The initial guess for the mps (stored as an mpsList
as specified in cyclomps.tools.mps_tools)
Default : None (mps0 will be random)
mpsl : 1D Array of Matrix Product States
The initial guess for the left mps (stored as an mpsList
as specified in cyclomps.tools.mps_tools)
Default : None (mps0 will be random)
env : 1D Array of an environment
The initial environment for mps (stored as an envList
as specified in cyclomps.tools.env_tools)
Default : None (env will be built in computation)
envl : 1D Array of an environment
The initial environment for the left mps (stored as an envList
as specified in cyclomps.tools.env_tools)
Default : None (env will be built in computation)
mbd : int or 1D Array of ints
The maximum bond dimension for the mps.
If this is a single int, then the bond dimension
will be held constant for all sweeps. Otherwise, the
bond dimension will be incremented after max_iter sweeps
or until the tolerance is reached.
sweeps. (Note that if max_iter and/or tol is a list, we
require len(max_iter) == len(mbd) == len(tol), and the
maximum number of iterations or convergence tolerance
changes with the retained maximum bond dimension.)
Default : 10
tol : int or 1D Array of ints
The relative convergence tolerance. This may be a list,
meaning that as the mbd is increased, different tolerances
are specified.
Default : 1.e-5
max_iter : int or 1D Array of ints
The maximum number of iterations for each mbd
Default : 10
min_iter : int or 1D Array of ints
The minimum number of iterations for each mbd
Default : 0
noise : float or 1D Array of floats
The magnitude of the noise added to the mbd to prevent
getting stuck in a local minimum
!! NOT IMPLEMENTED !!
Default : 0.
mps_subdir : string
The subdirectory under CALC_DIR (specified in cyclomps.tools.params)
where the mps will be saved.
Default : 'mps'
mpsl_subdir : string
The subdirectory under CALC_DIR (specified in cyclomps.tools.params)
where the left mps will be saved.
Default : 'mpsl'
env_subdir : string
The subdirectory under CALC_DIR (specified in cyclomps.tools.params)
where the environment will be saved.
Default : 'env'
envl_subdir : string
The subdirectory under CALC_DIR (specified in cyclomps.tools.params)
where the environment for the left mps will be saved.
Default : 'envl'
nStates : int
The number of retained states
Default : 2
dtype : dtype
The data type for the mps and env
Default : np.complex_
fixed_bd : bool
This ensures that all bond dimensions are constant
throughout the MPS, i.e. mps[0].dim = (1 x d[0] x mbd)
instead of mps[0].dim = (1 x d[0] x d[0]), and so forth.
Default : False
alg : string
The algorithm that will be used. Available options are
'arnoldi', 'exact', and 'davidson', current default is
'davidson'.
Default : 'davidson'
return_state : bool
Return the resulting mps list
Default : False
return_env : bool
Return the resulting env list
Default : False
return_entanglement : bool
Return the entanglement entropy and entanglement spectrum
Default : False
return_wgt : bool
Return the discarded weights
Default : False
orthonormalize : bool
Specify whether to orthonormalize eigenvectors after solution
of eigenproblem. This will cause problems for all systems
unless the eigenstates being orthonormalized are degenerate.
Default : False
state_avg : bool
Specify whether to use the state averaging procedure to target
multiple states when doing the renormalization step.
Default : True
!! ONLY STATE AVG IS IMPLEMENTED !!
left : bool
If True, then we calculate the left and right eigenstate
otherwise, only the right.
Default : False
start_gauge : int
The site at which the gauge should (or is) located in the
initial mps.
Default : 0
end_gauge : int
The site at which the gauge should be located when the
mps is returned.
Default : 0
Returns:
E : 1D Array
The energies for the number of states targeted
EE : 1D Array
The entanglement entropy for the states targeted
Returned only if return_entanglement == True
EEs : 1D Array of 1D Arrays
The entanglement entropy spectrum for the states targeted
Returned only if return_entanglement == True
mps : 1D Array of Matrix Product States
The resulting matrix product state list
Returned only if return_state == True
env : 1D Array of an environment
The resulting environment list
"""
t0 = time.time()
mpiprint(0, '\n\nStarting DMRG one-site calculation')
mpiprint(0, '#' * 50)
# Check inputs for problems
if not hasattr(mbd, '__len__'): mbd = nparray([mbd])
if not hasattr(tol, '__len__'):
tol = tol * npones(len(mbd))
else:
assert (len(mbd) == len(tol)), 'Lengths of mbd and tol do not agree'
if not hasattr(max_iter, '__len__'):
max_iter = max_iter * npones(len(mbd))
else:
assert (len(max_iter) == len(mbd)
), 'Lengths of mbd and max_iter do not agree'
if not hasattr(min_iter, '__len__'):
min_iter = min_iter * npones(len(mbd))
else:
assert (len(min_iter) == len(mbd)
), 'Lengths of mbd and min_iter do not agree'
# --------------------------------------------------------------------------------
# Solve for Right Eigenvector
# --------------------------------------------------------------------------------
# Determine local bond dimensions from mpo
d = mpo_local_dim(mpo)
# Create structures to save results
return_E = npzeros((len(mbd), nStates))
return_EE = npzeros((len(mbd), nStates))
return_EEs = npzeros((len(mbd), nStates, max(mbd)))
mps_res = []
env_res = []
# Loop through all maximum bond dimensions
for mbd_ind, mbdi in enumerate(mbd):
mpiprint(1, '\n' + '/' * 50)
mpiprint(1, 'Starting Calculation for mbd = {}'.format(mbdi))
# Set up initial mps
if mbd_ind == 0:
if mps is None:
# There is no previous guess to build on
mps = create_mps_list(d,
mbdi,
nStates,
dtype=dtype,
fixed_bd=fixed_bd,
subdir=mps_subdir + '_mbd' + str(mbdi) +
'_')
# Make sure it is in correct canonical form
mps = make_mps_list_right(mps)
mps = move_gauge(mps, 0, start_gauge)
else:
# Increase the maximum bond dim of the previous system
mps = increase_bond_dim(mps, mbdi, fixed_bd=fixed_bd)
# Set up initial env
if mbd_ind == 0:
if env is None:
env = calc_env(mps,
mpo,
dtype=dtype,
subdir='env_mbd' + str(mbdi) + '_')
else:
env = calc_env(mps,
mpo,
dtype=dtype,
gSite=end_gauge,
subdir='env_mbd' + str(mbdi) + '_')
# Run the DMRG Sweeps
outputr = sweeps(mps,
mpo,
env,
max_iter=max_iter[mbd_ind],
min_iter=min_iter[mbd_ind],
tol=tol[mbd_ind],
alg=alg,
noise=noise,
orthonormalize=orthonormalize,
state_avg=state_avg,
start_gauge=start_gauge,
end_gauge=end_gauge)
# Collect results
E = outputr[0]
EE = outputr[1]
EEs = outputr[2]
wgt = outputr[3]
# --------------------------------------------------------------------------------
# Solve for Left Eigenvector
# --------------------------------------------------------------------------------
if left:
mpiprint(0, '#' * 50)
mpiprint(0, 'Left State')
mpiprint(0, '#' * 50)
# Create left mpo
mpol = mpo_conj_trans(mpo)
# Run this same function, but now with this new left mpo
outputl = dmrg(mpo,
mps=mpsl,
env=envl,
mbd=mbd,
tol=tol,
max_iter=max_iter,
min_iter=min_iter,
noise=noise,
mps_subdir=mpsl_subdir,
env_subdir=envl_subdir,
nStates=nStates,
dtype=dtype,
fixed_bd=fixed_bd,
alg=alg,
return_state=True,
return_env=True,
return_entanglement=True,
return_wgt=True,
orthonormalize=orthonormalize,
state_avg=state_avg,
left=False,
start_gauge=start_gauge,
end_gauge=end_gauge)
# Collect results
El = outputl[0]
EEl = outputl[1]
EEls = outputl[2]
wgtl = outputl[3]
mpsl = outputl[4]
envl = outputl[5]
# ---------------------------------------------------------------------------------
# Wrap Up Calculation
# ---------------------------------------------------------------------------------
# Prin://arxiv.org/abs/1706.09537t time for dmrg procedure
timeprint(1, 'Total time: {} s'.format(time.time() - t0))
# Return results
ret_list = [E]
if left: ret_list += [El]
if return_entanglement:
ret_list += [EE, EEs]
if left: ret_list += [EEl, EEls]
if return_wgt:
ret_list += [wgt]
if left: ret_list += [wgtl]
if return_state:
ret_list += [mps]
if left: ret_list += [mpsl]
if return_env:
ret_list += [env]
if left: ret_list += [envl]
return ret_list
def rep2(serie=[], option={}):
n_serie = 10
if type(serie) != int:
# it's a list
if len(serie) == 0:
serie = range(0, n_serie)
if len(serie) > n_serie:
raise ExperimentalInfoError('Serie list is too long.')
if max(serie) > n_serie:
raise ExperimentalInfoError('Serie index out of range.')
else:
# it's a int
if serie > n_serie:
raise ExperimentalInfoError('Serie index out of range.')
t_givrage = nparray([
14,
20,
44,
40,
38,
34,
34,
35,
35,
37,
])
t_total = nparray([
158,
86,
46,
50,
51,
50,
54,
56,
45,
52,
])
air_temperature = nparray([
22.0,
22.8,
22.6,
22.8,
22.8,
22.8,
22.8,
22.8,
22.7,
22.7,
])
ca_left = nparray([0])
ca_right = nparray([0])
Tw = -7. * npones(n_serie)
try:
if option['wall temperature']:
return Tw
except Exception as e:
pass
ca = (ca_right + ca_left) / 2
ca = nparray([
60.,
64.,
79.,
79.,
79.,
71.,
76.,
75.,
72.,
80.,
])
return (t_givrage[serie], t_total[serie], air_temperature[serie],
ca[serie])
def rep1(serie=[], option={}):
n_serie = 10
if type(serie) != int:
# it's a list
if len(serie) == 0:
serie = range(0, n_serie)
if len(serie) > n_serie:
raise ExperimentalInfoError('Serie list is too long.')
if max(serie) > n_serie:
raise ExperimentalInfoError('Serie index out of range.')
else:
# it's a int
if serie > n_serie:
raise ExperimentalInfoError('Serie index out of range.')
# === user entrance information === #
t_givrage = nparray([
40,
43,
51,
46,
46,
38,
80,
76,
70,
npnan,
])
t_total = nparray([120, 266, 177, 193, 329, 324, 80, 90, 70, 166])
air_temperature = nparray(
[20.6, 20.6, 21., 21.2, 21.2, 21.6, 21.6, 21.8, 21.5, 21.5])
ca_left = nparray([0])
ca_right = nparray([0])
ca = (ca_left + ca_right) / 2
ca = nparray([
51.,
78.,
74.,
76.,
56.,
62.,
63.,
75.,
64.,
81,
])
Tw = -7. * npones(n_serie)
# /!\ l'angle 9, 7 on été mesuré après début du givrage #
try:
if option['wall temperature']:
return Tw
except Exception as e:
pass
return (t_givrage[serie], t_total[serie], air_temperature[serie],
ca[serie])
def ones(shape, dtype=float, order='C'):
return tensor(npones(shape, dtype=dtype, order=order))
